@jsnw/srv-utils 1.0.3 → 1.0.5

package/dist/config/config-loader.js

@@ -5,57 +5,135 @@ const node_path_1 = require("node:path");
 const node_fs_1 = require("node:fs");
 const zod_1 = require("zod");
 const yaml_1 = require("yaml");
+const file_exists_1 = require("../file-exists");
 const getRootPackageDirname_1 = require("../getRootPackageDirname");
 const PKG_ROOT_REGEX = /^%pkgroot[\/\\]/i;
 class ConfigLoader {
+    static _instance;
+    /**
+     * @returns {ConfigLoader}
+     */
+    static instance() {
+        if (!ConfigLoader._instance)
+            ConfigLoader._instance = new ConfigLoader();
+        return ConfigLoader._instance;
+    }
     /**
      * @template {z.ZodObject} S
      * @template {object} P
      * @param {string} path You can use %pkgroot prefix for automatic project root resolution by AppConfigLoader.
      * Example: %pkgroot/config.yml
      * @param {S} schema
-     * @param {P} addProps
-     * @returns {ResolvedConfig<S>}
+     * @param {P} [addProps]
+     * @returns {ResolvedConfig<S, P>}
      */
-    static loadAndValidate(path, schema, addProps) {
-        if (PKG_ROOT_REGEX.test(path))
-            path = path.replace(PKG_ROOT_REGEX, (0, getRootPackageDirname_1.getRootPackageDirnameSync)() + node_path_1.sep);
-        let data = undefined;
-        let parsedYaml = undefined;
+    static loadConfig(path, schema, addProps) {
+        const loader = ConfigLoader.instance();
+        const [yaml, loadError] = loader.loadYamlFile(path);
+        if (loadError) {
+            console.error(loadError.message);
+            process.exit(1);
+        }
+        const [processedYaml, includeErrors] = loader.processIncludes(yaml);
+        if (includeErrors && includeErrors.length > 0) {
+            for (const err of includeErrors)
+                console.error(`$include error: ${err.message}`);
+            process.exit(1);
+        }
+        const [validatedYaml, validateError] = loader.validateYaml(processedYaml, schema);
+        if (validateError) {
+            console.error(validateError.message);
+            process.exit(1);
+        }
+        //@ts-expect-error
+        validatedYaml['isDev'] = (process?.env?.APP_CONTEXT
+            ?? process?.env?.APPLICATION_CONTEXT
+            ?? process?.env?.NODE_ENV
+            ?? '').toLowerCase() !== 'production';
+        return {
+            ...validatedYaml,
+            ...(addProps ?? {})
+        };
+    }
+    constructor() { }
+    /**
+     * @param {string} path
+     * @returns {ErrorResult<any, Error>}
+     * @protected
+     */
+    loadYamlFile(path) {
+        path = this.resolvePkgRootPath(path);
+        if (!(0, file_exists_1.fileExistsSync)(path))
+            return [null, new Error(`YAML file does not exists at path: ${path}`)];
+        let data = undefined, parsedYml = undefined;
         try {
             data = (0, node_fs_1.readFileSync)(path, 'utf-8');
         }
         catch (e) {
-            console.error(`Failed to read config file at path: ${path}\nError: ${e?.message ?? '-'}; syscall: ${e?.syscall ?? '-'}`);
-            process.exit(1);
+            return [null, new Error(`Failed to read config file at path: ${path}`)];
         }
         try {
-            parsedYaml = (0, yaml_1.parse)(data, { prettyErrors: true });
+            parsedYml = (0, yaml_1.parse)(data, { prettyErrors: true });
         }
         catch (e) {
-            console.error(`Failed to parse YAML file at path: ${path}\nError: ${e?.message ?? '-'}`);
-            process.exit(1);
+            return [null, new Error(`Failed to parse YAML file at path: ${path}`)];
         }
-        const extendedSchema = schema.transform(v => ({
-            isDev: (process?.env?.APP_CONTEXT
-                ?? process?.env?.APPLICATION_CONTEXT
-                ?? process?.env?.NODE_ENV
-                ?? '').toLowerCase() !== 'production',
-            ...v
-        }));
-        const { data: config, error, success } = extendedSchema.safeParse(parsedYaml);
+        return [parsedYml, null];
+    }
+    /**
+     * @template {z.ZodTypeAny} T
+     * @param data
+     * @param {T} schema
+     * @returns {ErrorResult<output<T>, Error>}
+     * @protected
+     */
+    validateYaml(data, schema) {
+        const { data: parsed, error, success } = schema.safeParse(data);
         if (!success) {
-            if (error && error instanceof zod_1.ZodError) {
-                console.error(`Failed to validate config file at path ${path}. Error: ${zod_1.z.prettifyError(error)}`);
-                process.exit(1);
+            if (error && error instanceof zod_1.ZodError)
+                return [null, new Error(`Failed to validate yaml (#1)`)];
+            return [null, new Error(`Failed to validate yaml (#2)`)];
+        }
+        return [parsed, null];
+    }
+    /**
+     * @param yaml
+     * @returns {ErrorResult<any, Error[]>}
+     * @protected
+     */
+    processIncludes(yaml) {
+        if (typeof yaml !== 'object')
+            return yaml;
+        const nodesToVisit = [yaml], errors = [];
+        for (let i = 0; i < nodesToVisit.length; i++) {
+            const node = nodesToVisit[i];
+            if (typeof node !== 'object' || Array.isArray(node))
+                continue;
+            if (node['$include'] && typeof node['$include'] === 'string') {
+                const [loadedYaml, loadError] = this.loadYamlFile(node['$include']);
+                delete node['$include'];
+                if (loadError) {
+                    errors.push(loadError);
+                }
+                else {
+                    for (const [k, v] of Object.entries(loadedYaml))
+                        node[k] = v;
+                }
+            }
+            for (const k of Object.keys(node)) {
+                if (Object.hasOwn(node, k)
+                    && typeof node[k] === 'object'
+                    && !Array.isArray(node[k]))
+                    nodesToVisit.push(node[k]);
             }
-            console.error(`Failed to parse config file at path ${path}`);
-            process.exit(1);
         }
-        return {
-            ...config,
-            ...(addProps ? {} : addProps)
-        };
+        return [yaml, errors];
+    }
+    //region Utils
+    resolvePkgRootPath(path) {
+        if (PKG_ROOT_REGEX.test(path))
+            path = path.replace(PKG_ROOT_REGEX, (0, getRootPackageDirname_1.getRootPackageDirnameSync)() + node_path_1.sep);
+        return path;
     }
 }
 exports.ConfigLoader = ConfigLoader;

package/dist/file-exists.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileExists = fileExists;
+exports.fileExistsSync = fileExistsSync;
+const promises_1 = require("node:fs/promises");
+const node_fs_1 = require("node:fs");
+/**
+ * @param {string} path
+ * @param {number} [mode]
+ * @returns {boolean}
+ */
+async function fileExists(path, mode = node_fs_1.constants.F_OK | node_fs_1.constants.R_OK) {
+    try {
+        await (0, promises_1.access)(path, mode);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+/**
+ * @param {string} path
+ * @param {number} [mode]
+ * @returns {boolean}
+ */
+function fileExistsSync(path, mode = node_fs_1.constants.F_OK | node_fs_1.constants.R_OK) {
+    try {
+        (0, node_fs_1.accessSync)(path, mode);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}

package/dist/getRootPackageDirname.js

@@ -11,6 +11,11 @@ function getRootPackageDirnameSync() {
     if (cachedRootPackageDirname !== null)
         return cachedRootPackageDirname;
     let path = (0, node_path_1.resolve)(__dirname, '..'), lastValidPath = path;
+    if (/[\\\/]node_modules[\\\/]/i.test(path)) {
+        const pieces = path.split(/[\\\/]node_modules[\\\/]/i);
+        if (pieces.length > 0)
+            path = pieces[0];
+    }
     while (true) {
         const packageJsonPath = (0, node_path_1.resolve)(path, 'package.json');
         try {

package/dist/index.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.withNest = exports.configSchemas = exports.ConfigLoader = exports.getRootPackageDirnameSync = exports.useTsconfigPaths = void 0;
+exports.withNest = exports.configSchemas = exports.ConfigLoader = exports.getRootPackageDirnameSync = exports.useTsconfigPaths = exports.fileExistsSync = exports.fileExists = void 0;
+var file_exists_1 = require("./file-exists");
+Object.defineProperty(exports, "fileExists", { enumerable: true, get: function () { return file_exists_1.fileExists; } });
+Object.defineProperty(exports, "fileExistsSync", { enumerable: true, get: function () { return file_exists_1.fileExistsSync; } });
 var useTsconfigPaths_1 = require("./useTsconfigPaths");
 Object.defineProperty(exports, "useTsconfigPaths", { enumerable: true, get: function () { return useTsconfigPaths_1.useTsconfigPaths; } });
 var getRootPackageDirname_1 = require("./getRootPackageDirname");

package/dist/types/config/config-loader.d.ts

@@ -1,14 +1,42 @@
 import { z } from 'zod';
+import { type ErrorResult } from '@jsnw/common-utils';
 import { ResolvedConfig } from './config-loader.types';
-export declare abstract class ConfigLoader {
+export declare class ConfigLoader {
+    private static _instance;
+    /**
+     * @returns {ConfigLoader}
+     */
+    static instance(): ConfigLoader;
     /**
      * @template {z.ZodObject} S
      * @template {object} P
      * @param {string} path You can use %pkgroot prefix for automatic project root resolution by AppConfigLoader.
      * Example: %pkgroot/config.yml
      * @param {S} schema
-     * @param {P} addProps
-     * @returns {ResolvedConfig<S>}
+     * @param {P} [addProps]
+     * @returns {ResolvedConfig<S, P>}
+     */
+    static loadConfig<S extends z.ZodObject, P extends object | undefined = undefined>(path: string, schema: S, addProps?: P): ResolvedConfig<S, P>;
+    private constructor();
+    /**
+     * @param {string} path
+     * @returns {ErrorResult<any, Error>}
+     * @protected
+     */
+    protected loadYamlFile(path: string): ErrorResult<any, Error>;
+    /**
+     * @template {z.ZodTypeAny} T
+     * @param data
+     * @param {T} schema
+     * @returns {ErrorResult<output<T>, Error>}
+     * @protected
+     */
+    protected validateYaml<T extends z.ZodTypeAny>(data: any, schema: T): ErrorResult<z.infer<T>, Error>;
+    /**
+     * @param yaml
+     * @returns {ErrorResult<any, Error[]>}
+     * @protected
      */
-    static loadAndValidate<S extends z.ZodObject, P extends object | undefined = undefined>(path: string, schema: S, addProps?: P): ResolvedConfig<S, P>;
+    protected processIncludes(yaml: any): ErrorResult<any, Error[]>;
+    private resolvePkgRootPath;
 }

package/dist/types/file-exists.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @param {string} path
+ * @param {number} [mode]
+ * @returns {boolean}
+ */
+export declare function fileExists(path: string, mode?: number): Promise<boolean>;
+/**
+ * @param {string} path
+ * @param {number} [mode]
+ * @returns {boolean}
+ */
+export declare function fileExistsSync(path: string, mode?: number): boolean;

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
+export { fileExists, fileExistsSync } from './file-exists';
 export { useTsconfigPaths } from './useTsconfigPaths';
 export { getRootPackageDirnameSync } from './getRootPackageDirname';
 export { ConfigLoader, configSchemas, type ResolvedConfig } from './config';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsnw/srv-utils",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Server-side utilities for Node.js/TypeScript: tsconfig paths, Nest helpers, and config loading.",
   "main": "./dist/index.js",
   "types": "./dist/types/index.d.ts",
@@ -40,6 +40,7 @@
   },
   "homepage": "https://github.com/pvbaliuk/jsn-srv-utils#readme",
   "dependencies": {
+    "@jsnw/common-utils": "^1.0.0",
     "ms": "^2.1.3",
     "yaml": "^2.8.2",
     "zod": "^4.3.6"