feat: rewrite to typescript

Author: oldskytree

.eslintignore

@@ -0,0 +1 @@
+build

.gitignore

@@ -1 +1,2 @@
 node_modules
+build

.travis.yml

@@ -3,4 +3,5 @@ node_js:
 - '6'
 - '8'
 script:
+- npm build
 - npm test

README.md

@@ -8,6 +8,7 @@ Config is described with a combination of a functions:
 var parser = root(section({
     system: section({
         parallelLimit: option({
+            defaultValue: 0,
             parseEnv: Number,
             parseCli: Number,
             validate: function() {...}

lib/core.js lib/core.tslib/core.js renamed to lib/core.ts

@@ -1,23 +1,35 @@
-const _ = require('lodash');
-const {buildLazyObject, forceParsing} = require('./lazy');
-const {MissingOptionError, UnknownKeysError} = require('./errors');
-const initLocator = require('./locator');
+import _ from 'lodash';
+
+import { MissingOptionError, UnknownKeysError } from './errors';
+import { buildLazyObject, forceParsing } from './lazy';
+import initLocator from './locator';
+
+import type { LazyObject } from '../types/lazy';
+import type { RootParsedConfig } from '../types/common';
+import type { MapParser } from '../types/map';
+import type { OptionParser, OptionParserConfig } from '../types/option';
+import type { RootParser, RootPrefixes, ConfigParser } from '../types/root';
+import type { SectionParser, SectionProperties } from '../types/section';
+
+type Parser<T, R = any> = OptionParser<T, R> | SectionParser<T, R> | MapParser<T, R>;
 
 /**
  * Single option
  */
-function option({
+export function option<T, S = T, R = any>({
     defaultValue,
     parseCli = _.identity,
     parseEnv = _.identity,
     validate = _.noop,
     map: mapFunc = _.identity
-}) {
+}: OptionParserConfig<T, S, R>): OptionParser<S, R> {
+    const validateFunc: typeof validate = validate;
+
     return (locator, parsed) => {
         const config = parsed.root;
-        const currNode = locator.parent ? _.get(config, locator.parent) : config;
+        const currNode = locator.parent ? _.get(parsed, locator.parent) : config;
 
-        let value;
+        let value: unknown;
         if (locator.cliOption !== undefined) {
             value = parseCli(locator.cliOption);
         } else if (locator.envVar !== undefined) {
@@ -31,7 +43,8 @@ function option({
         } else {
             throw new MissingOptionError(locator.name);
         }
-        validate(value, config, currNode);
+
+        validateFunc(value, config, currNode);
 
         return mapFunc(value, config, currNode);
     };
@@ -41,13 +54,15 @@ function option({
  * Object with fixed properties.
  * Any unknown property will be reported as error.
  */
-function section(properties) {
-    const expectedKeys = _.keys(properties);
+export function section<T, R = any>(properties: SectionProperties<T, R>): SectionParser<T, R> {
+    const expectedKeys = _.keys(properties) as Array<keyof T>;
+
     return (locator, config) => {
         const unknownKeys = _.difference(
             _.keys(locator.option),
-            expectedKeys
+            expectedKeys as Array<string>
         );
+
         if (unknownKeys.length > 0) {
             throw new UnknownKeysError(
                 unknownKeys.map((key) => `${locator.name}.${key}`)
@@ -56,6 +71,7 @@ function section(properties) {
 
         const lazyResult = buildLazyObject(expectedKeys, (key) => {
             const parser = properties[key];
+
             return () => parser(locator.nested(key), config);
         });
 
@@ -69,17 +85,20 @@ function section(properties) {
  * Object with user-specified keys and values,
  * parsed by valueParser.
  */
-function map(valueParser, defaultValue) {
+export function map<T extends Record<string, any>, V extends T[string] = T[string], R = any>(
+    valueParser: Parser<V, R>,
+    defaultValue: Record<string, V>
+): MapParser<Record<string, V>, R> {
     return (locator, config) => {
         if (locator.option === undefined) {
             if (!defaultValue) {
-                return {};
+                return {} as LazyObject<T>;
             }
             locator = locator.resetOption(defaultValue);
         }
 
-        const optionsToParse = Object.keys(locator.option);
-        const lazyResult = buildLazyObject(optionsToParse, (key) => {
+        const optionsToParse = Object.keys(locator.option as Record<string, V>);
+        const lazyResult = buildLazyObject<Record<string, V>>(optionsToParse, (key) => {
             return () => valueParser(locator.nested(key), config);
         });
         _.set(config, locator.name, lazyResult);
@@ -88,13 +107,11 @@ function map(valueParser, defaultValue) {
     };
 }
 
-function root(rootParser, {envPrefix, cliPrefix}) {
+export function root<T>(rootParser: RootParser<T>, {envPrefix, cliPrefix}: RootPrefixes): ConfigParser<T> {
     return ({options, env, argv}) => {
         const rootLocator = initLocator({options, env, argv, envPrefix, cliPrefix});
-        const parsed = {};
-        rootParser(rootLocator, parsed);
-        return forceParsing(parsed.root);
+        const parsed = rootParser(rootLocator, {} as RootParsedConfig<T>);
+
+        return forceParsing(parsed);
     };
 }
-
-module.exports = {option, section, map, root};

lib/errors.js lib/errors.tslib/errors.js renamed to lib/errors.ts

@@ -1,5 +1,7 @@
-class MissingOptionError extends Error {
-    constructor(optionName) {
+export class MissingOptionError extends Error {
+    public optionName: string;
+
+    constructor(optionName: string) {
         const message = `${optionName} is required`;
         super(message);
         this.name = 'MissingOptionError';
@@ -10,8 +12,10 @@ class MissingOptionError extends Error {
     }
 }
 
-class UnknownKeysError extends Error {
-    constructor(keys) {
+export class UnknownKeysError extends Error {
+    public keys: Array<string>;
+
+    constructor(keys: Array<string>) {
         const message = `Unknown options: ${keys.join(', ')}`;
         super(message);
         this.name = 'UnknownKeysError';
@@ -21,5 +25,3 @@ class UnknownKeysError extends Error {
         Error.captureStackTrace(this, UnknownKeysError);
     }
 }
-
-module.exports = {MissingOptionError, UnknownKeysError};

lib/index.js

@@ -0,0 +1,2 @@
+export { root, section, map, option } from './core';
+export { MissingOptionError, UnknownKeysError } from './errors';

lib/index.ts

@@ -0,0 +1,52 @@
+import _ from 'lodash';
+
+import type { LazyObject } from '../types/lazy';
+
+export const isLazy = Symbol('isLazy');
+
+export function buildLazyObject<T>(keys: Array<keyof T>, getKeyGetter: (key: keyof T) => () => (T[keyof T] | LazyObject<T[keyof T]>)): LazyObject<T> {
+    const target = {
+        [isLazy]: true
+    } as LazyObject<T>;
+
+    for (const key of keys) {
+        defineLazy(target, key, getKeyGetter(key));
+    }
+
+    return target;
+}
+
+export function forceParsing<T>(lazyObject: LazyObject<T>): T {
+    return _.cloneDeep(lazyObject);
+}
+
+function defineLazy<T>(object: LazyObject<T>, key: keyof T, getter: () => T[keyof T] | LazyObject<T[keyof T]>): void {
+    let defined = false;
+    let value: T[keyof T];
+
+    Object.defineProperty(object, key, {
+        get(): T[keyof T] {
+            if (!defined) {
+                defined = true;
+                const val = getter();
+
+                if (isLazyObject(val)) {
+                    value = forceParsing(val);
+                } else {
+                    value = val;
+                }
+            }
+
+            return value;
+        },
+        enumerable: true
+    });
+}
+
+function isLazyObject<T>(value: T): value is LazyObject<T> {
+    return _.isObject(value) && hasOwnProperty(value, isLazy) && value[isLazy] === true;
+}
+
+function hasOwnProperty<T extends {}>(obj: T, prop: PropertyKey): obj is T & Record<typeof prop, unknown> {
+    return obj.hasOwnProperty(prop);
+}