@achs/env 3.1.0 → 3.1.1

package/src/utils/interpolate.util.ts

@@ -1,65 +0,0 @@
-import subslate from 'subslate';
-
-/**
- * Validates value must be a record.
- *
- * @export
- * @param {unknown} obj
- * @returns {*}  {obj is Record<string, unknown>}
- */
-export function isRecord(obj: unknown): obj is Record<string, unknown> {
-    if (!obj || typeof obj !== 'object') return false;
-
-    return Object.keys(obj).length > 0;
-}
-
-/**
- * Replaces string arguments with regex interpolation.
- *
- * @export
- * @template T
- * @param {T} value
- * @param {Record<string, unknown>} args
- * @param {[string, string]} [delimiters=['[[', ']]']]
- *
- * @returns {T} mutated value
- */
-export function interpolate<T extends string | unknown>(
-    value: T,
-    args: Record<string, unknown>,
-    delimiters: [string, string] = ['[[', ']]']
-): T {
-    if (typeof value === 'string') {
-        return subslate(value, args, {
-            startStopPairs: delimiters
-        }) as T;
-    }
-
-    if (Array.isArray(value))
-        return value.map((a) => interpolate(a, args, delimiters)) as T;
-
-    if (isRecord(value)) return interpolateJson(value, args, delimiters) as T;
-
-    return value;
-}
-
-/**
- * Replaces JSON string arguments with regex interpolation.
- *
- * @export
- * @param {Record<string, unknown>} args
- * @param {Record<string, unknown>} values
- * @param {[string, string]} [delimiters=['[[', ']]']]
- *
- * @returns {Record<string, unknown>} mutated args
- */
-export function interpolateJson(
-    values: Record<string, unknown>,
-    args: Record<string, unknown>,
-    delimiters: [string, string] = ['[[', ']]']
-): Record<string, unknown> {
-    for (const key in values)
-        values[key] = interpolate(values[key], args, delimiters);
-
-    return values;
-}

package/src/utils/json.util.ts

@@ -1,116 +0,0 @@
-import os from 'os';
-import path from 'path';
-import { existsSync } from 'fs';
-import { readFile, writeFile } from 'fs/promises';
-
-/**
- * Replaces undefined by null in JSON.stringify()
- *
- * @param {string} _ property key
- * @param {any} value property value
- *
- * @returns {any} value
- */
-const replacer = (_: string, value: any): typeof value | null =>
-    value === undefined ? null : value;
-
-/**
- * Resolve a relative path for os.
- *
- * @export
- * @param {string} filePath relative path from project root
- *
- * @returns {string} path
- */
-export function resolvePath(filePath: string): string {
-    const home = os.homedir();
-
-    if (home !== undefined)
-        filePath = filePath.replace(/^~($|\/|\\)/, `${home}$1`);
-
-    return path.resolve(process.cwd(), filePath);
-}
-
-/**
- * Reads and parses a JSON file.
- *
- * @export
- * @template T
- * @param {string} path
- *
- * @returns {Promise<[Record<string, any>, boolean]>}
- */
-export async function readJson<T = Record<string, any>>(
-    path: string
-): Promise<[T | Record<string, any>, boolean] | never> {
-    if (!existsSync(path)) return [{}, false];
-
-    return [JSON.parse(await readFile(path, 'utf8')), true];
-}
-
-/**
- * Saves a JSON into a file.
- *
- * @export
- * @param {string} path
- * @param {unknown} content
- * @param {false} overwrite
- * @param {false} undefinedAsNull replaces undefined by null
- *
- * @returns {Promise<boolean>}
- */
-export async function writeJson(
-    path: string,
-    content: Record<string, unknown>,
-    overwrite = false,
-    undefinedAsNull = false
-): Promise<boolean | never> {
-    const exists = existsSync(path);
-
-    if (exists && !overwrite) return false;
-
-    await writeFile(
-        path,
-        `${JSON.stringify(
-            content,
-            undefinedAsNull ? replacer : undefined,
-            4
-        )}\n`,
-        'utf8'
-    );
-
-    return true;
-}
-
-/**
- * Saves a JSON into a file as dotenv.
- *
- * @export
- * @param {string} path
- * @param {unknown} content
- * @param {false} overwrite
- *
- * @returns {Promise<boolean>}
- */
-export async function writeEnvFromJson(
-    path: string,
-    content: Record<string, unknown>,
-    overwrite = false
-): Promise<boolean | never> {
-    const exists = existsSync(path);
-
-    if (exists && !overwrite) return false;
-
-    let data = '';
-
-    for (const key in content) {
-        let value = content[key];
-        if (typeof value === 'string') value = `"${value}"`;
-
-        data += `${key}=${value}\n`;
-    }
-
-    await writeFile(path, data, 'utf8');
-
-    return true;
-}

package/src/utils/normalize.util.ts

@@ -1,142 +0,0 @@
-/**
- * Flatten a object keeping depth path
- * in key using __ as level separator.
- *
- * @param {Record<string, any>} obj
- * @param {string} nestingDelimiter char for delimit nesting levels
- * @param {boolean} arrayDescomposition serialize or break down arrays
- * @param {boolean} clearNull if null should removed from object
- * @param {string} pkey first level key
- *
- * @returns {Record<string, string>} flattended object
- */
-export function flatten(
-    obj: Record<string, any>,
-    nestingDelimiter = '__',
-    pkey = ''
-): Record<string, string> {
-    const flattened: Record<string, string> = {};
-
-    for (let key in obj) {
-        const value = obj[key];
-        const type = typeof value;
-
-        if (value === undefined || type === 'function') continue;
-
-        // skipped property
-        if (key[0] === '#') continue;
-        key = pkey + key;
-
-        if (value === null || type !== 'object' || Array.isArray(value)) {
-            flattened[key] = value;
-
-            continue;
-        }
-
-        Object.assign(
-            flattened,
-            flatten(value, nestingDelimiter, `${key}${nestingDelimiter}`)
-        );
-    }
-
-    return flattened;
-}
-
-/**
- * Normalizes env object, converts arrays in list strings,
- * only primitives types array,
- * and removes $ global character from keys.
- *
- * @param {Record<string, any>} obj
- * @param {string} nestingDelimiter char for delimit nesting levels
- * @param {boolean} arrayDescomposition serialize or break down arrays
- * @param {string} pkey first level key
- *
- * @returns {Record<string, string>} normalized object
- */
-export function normalize(
-    obj: Record<string, any>,
-    nestingDelimiter = '__',
-    arrayDescomposition = false,
-    pkey = ''
-): Record<string, string> {
-    const flattened: Record<string, string> = {};
-
-    for (let key in obj) {
-        const value = obj[key];
-        const type = typeof value;
-
-        if (value === null || value === undefined || type === 'function')
-            continue;
-
-        // global property, but prefix removed for injection
-        key = pkey + key.replace('$', '');
-
-        if (type !== 'object') {
-            flattened[key] = value;
-
-            continue;
-        }
-
-        if (Array.isArray(value)) {
-            normalizeArray(
-                flattened,
-                key,
-                value,
-                nestingDelimiter,
-                arrayDescomposition
-            );
-        } else {
-            Object.assign(
-                flattened,
-                normalize(
-                    value,
-                    nestingDelimiter,
-                    arrayDescomposition,
-                    `${key}${nestingDelimiter}`
-                )
-            );
-        }
-    }
-
-    return flattened;
-}
-
-/**
- * Flatten and normalizes an array.
- *
- * @param {Record<string, string>} flattened
- * @param {string} key
- * @param {any[]} value
- * @param {string} [nestingDelimiter='__']
- * @param {boolean} [arrayDescomposition=false]
- */
-function normalizeArray(
-    flattened: Record<string, string>,
-    key: string,
-    value: any[],
-    nestingDelimiter = '__',
-    arrayDescomposition = false
-): void {
-    if (arrayDescomposition) {
-        key = `${key}${nestingDelimiter}`;
-
-        for (let i = 0; i < value.length; i++) {
-            if (typeof value[i] === 'object') {
-                Object.assign(
-                    flattened,
-                    normalize(
-                        value[i],
-                        nestingDelimiter,
-                        arrayDescomposition,
-                        `${key}${i}${nestingDelimiter}`
-                    )
-                );
-            } else {
-                flattened[`${key}${i}`] = value[i];
-            }
-        }
-    } else {
-        flattened[key] = value.filter((v) => typeof v !== 'object').join(',');
-    }
-}

package/src/utils/schema.util.ts

@@ -1,191 +0,0 @@
-import Ajv, { Format, JSONSchemaType, ValidateFunction } from 'ajv';
-import addFormats from 'ajv-formats';
-import toJsonSchema, { Options } from 'to-json-schema';
-
-const FORMAT_REGEXPS: Record<string, Format> = {
-    'ip-address':
-        /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d{1,2})\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d{1,2})$/,
-
-    color: /^(#?([\dA-Fa-f]{3}){1,2}\b|aqua|black|blue|fuchsia|gray|green|lime|maroon|navy|olive|orange|purple|red|silver|teal|white|yellow|(rgb\(\s*\b(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\b\s*,\s*\b(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\b\s*,\s*\b(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\b\s*\))|(rgb\(\s*(\d?\d%|100%)+\s*,\s*(\d?\d%|100%)+\s*,\s*(\d?\d%|100%)+\s*\)))$/,
-
-    hostname:
-        /^(?=.{1,255}$)[\dA-Za-z](?:(?:[\dA-Za-z]|-){0,61}[\dA-Za-z])?(?:\.[\dA-Za-z](?:(?:[\dA-Za-z]|-){0,61}[\dA-Za-z])?)*\.?$/,
-
-    alphanumeric: /^[\dA-Za-z]+$/,
-
-    'utc-millisec': (input: string) => !Number.isNaN(+input),
-
-    alpha: /^[A-Za-z]+$/,
-
-    style: /\s*(.+?):\s*([^;]+);?/g,
-
-    phone: /^\+(?:\d ?){6,14}\d$/
-};
-
-/**
- * Generates JSON schema from JSON template/object.
- *
- * @export
- * @param {Record<string, unknown>} json json object
- * @param {Options} [options]
- *
- * @returns {*}  {Record<string, unknown>}
- */
-export function schemaFrom(
-    json: Record<string, unknown>,
-    options?: Options & { nullable?: boolean }
-): Record<string, unknown> {
-    return toJsonSchema(json, {
-        required: false,
-        ...options,
-        postProcessFnc: (type, schema, value, defaultFunc) => {
-            if (value !== json) {
-                schema.type = [type];
-                schema.nullable = options?.nullable ?? false;
-            }
-
-            return defaultFunc(type, schema, value);
-        }
-    });
-}
-
-/**
- * Validates if a object is a JSON schema.
- *
- * @export
- * @param {Record<string, unknown>} schema
- *
- * @returns {boolean} if is a JSON schema
- */
-export function isJsonSchemaObject(
-    schema: Record<string, unknown>
-): schema is JSONSchemaType<object> {
-    if (schema.type === 'object') return true;
-
-    return Array.isArray(schema.type) && schema.type.includes('object');
-}
-
-/**
- * Converts a JSON schema to JSON template.
- *
- * @export
- * @param {Record<string, unknown>} schema JSON schema
- * @param {Record<string, any>} [container] template container
- *
- * @returns {unknown} object or default value
- */
-export function schemaToJson(
-    schema: Record<string, unknown>,
-    container: Record<string, any> = {}
-): unknown {
-    if (isJsonSchemaObject(schema)) {
-        for (const key in schema.properties)
-            container[key] = schemaToJson(schema.properties[key]);
-
-        return container;
-    } else {
-        return schema.default ?? (schema.nullable ? null : undefined);
-    }
-}
-
-/**
- * Flatten a JSON schema.
- *
- * @export
- * @param {Record<string, unknown>} schema JSON schema
- * @param {string} [parentKey] previous level key
- * @param {string} [nestingDelimiter] char for delimit nesting levels
- * @param {Record<string, any>} [container] result container
- *
- * @returns {Record<string, unknown>} flattened schema
- */
-export function flatSchema(
-    schema: Record<string, unknown>,
-    parentKey = '',
-    nestingDelimiter = '__',
-    container: Record<string, any> = {}
-): Record<string, unknown> {
-    if (isJsonSchemaObject(schema)) {
-        for (const key in schema.properties) {
-            if (key[0] === '#') continue;
-
-            // global property, but prefix removed for injection
-            const subKey =
-                parentKey + (parentKey ? nestingDelimiter : '') + key;
-
-            container = {
-                ...container,
-                ...flatSchema(schema.properties[key], subKey, nestingDelimiter)
-            };
-        }
-
-        return container;
-    } else {
-        return { [parentKey]: schema };
-    }
-}
-
-/**
- * Creates a JSON schema validator using AJV.
- *
- * @see https://ajv.js.org/
- *
- * @export
- * @param {Record<string, object>} schema json schema by provider
- * @param {boolean} enableFormats whether formats are enabled
- *
- * @returns {ValidateFunction} validators
- */
-export function createValidator(
-    schema: Record<string, unknown>,
-    enableFormats = true
-): ValidateFunction {
-    const ajv = new Ajv({
-        allErrors: true,
-        allowUnionTypes: true
-    });
-
-    if (enableFormats) {
-        addFormats(ajv, { mode: 'fast' });
-
-        for (const key in FORMAT_REGEXPS)
-            ajv.addFormat(key, FORMAT_REGEXPS[key]);
-    }
-
-    return ajv.compile(schema);
-}
-
-/**
- * Creates a JSON schema validator lookup using AJV.
- *
- * @see https://ajv.js.org/
- *
- * @export
- * @param {Record<string, object>} schemaLookup json schema by provider
- * @param {boolean} enableFormats whether formats are enabled
- *
- * @returns {Record<string, ValidateFunction>} validators lookup
- */
-export function createValidators(
-    schemaLookup: Record<string, object>,
-    enableFormats = true
-): Record<string, ValidateFunction> {
-    const ajv = new Ajv({
-        allErrors: true,
-        allowUnionTypes: true
-    });
-
-    if (enableFormats) {
-        addFormats(ajv, { mode: 'fast' });
-
-        for (const key in FORMAT_REGEXPS)
-            ajv.addFormat(key, FORMAT_REGEXPS[key]);
-    }
-
-    const validators: Record<string, ValidateFunction> = {};
-
-    for (const key in schemaLookup)
-        validators[key] = ajv.compile(schemaLookup[key]);
-
-    return validators;
-}

package/tests/env/appsettings.json

@@ -1,32 +0,0 @@
-{
-    "|DEFAULT|": {
-        "VAR1": "v1_default"
-    },
-    "|MODE|": {
-        "build": {
-            "NODE_ENV": "production"
-        },
-        "debug": {
-            "NODE_ENV": "development"
-        },
-        "test": {
-            "NODE_ENV": "test"
-        }
-    },
-    "|ENV|": {
-        "dev": {
-            "C1": "V1",
-            "C2": "V2",
-            "C3": 3,
-            "GROUP1": {
-                "VAR1": null,
-                "VAR2": "G1V2",
-                "VAR3": true,
-                "GROUP2": {
-                    "VAR1": "G1G2V1"
-                }
-            },
-            "C4": "23"
-        }
-    }
-}

package/tests/env/dev.env.json

@@ -1,12 +0,0 @@
-{
-    "VAR1": true,
-    "VAR2": false,
-    "VAR3": 12,
-    "VAR4": "any",
-    "ARR1": [1, "val", true],
-    "GROUP2": {
-        "VAR1": "g1v1",
-        "VAR2": "g1v2"
-    },
-    "$SECRET": "ANY SECRET"
-}

package/tests/env/dev.local.env.json

@@ -1,9 +0,0 @@
-{
-    "VAR4": "any_local",
-    "GROUP1": {
-        "VAR1": null
-    },
-    "GROUP2": {
-        "VAR2": "g1v2_local"
-    }
-}