@jsnw/srv-utils 1.3.2 → 2.0.0

package/dist/config/config-loader.js

@@ -1,179 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigLoader = void 0;
-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;
-const ENV_VAR_REGEX = /^%env:(?<var_name>[A-Za-z0-9_]+)(?:[\/\\]|$)/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.
-     * Also, you can use %env:ENV_VARIABLE to resolve config path based on environment variable
-     * Example 1: %pkgroot/config.yml
-     * Example 2: %env:CONFIG_PATH/config.yml
-     * @param {S} schema
-     * @param {P} [addProps]
-     * @returns {ResolvedConfig<S, P>}
-     */
-    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, directiveErrors] = loader.processDirectives((0, node_path_1.dirname)(loader.resolveFilePath(path)), yaml);
-        if (directiveErrors && directiveErrors.length > 0) {
-            for (const err of directiveErrors)
-                console.error(`directive 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.resolveFilePath(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) {
-            return [null, new Error(`Failed to read config file at path: ${path}`)];
-        }
-        try {
-            parsedYml = (0, yaml_1.parse)(data, { prettyErrors: true });
-        }
-        catch (e) {
-            return [null, new Error(`Failed to parse YAML file at path: ${path}`)];
-        }
-        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)
-                return [null, new Error(`Failed to validate yaml (#1). Error message: ${zod_1.z.prettifyError(error)}`)];
-            return [null, new Error(`Failed to validate yaml (#2)`)];
-        }
-        return [parsed, null];
-    }
-    /**
-     * @param {string} mainYamlDirname
-     * @param yaml
-     * @returns {ErrorResult<any, Error[]>}
-     * @protected
-     */
-    processDirectives(mainYamlDirname, 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;
-            const nodeFields = Object.keys(node);
-            for (const field of nodeFields) {
-                if (field === '$include') {
-                    const $includePaths = [];
-                    if (typeof node['$include'] === 'string') {
-                        $includePaths.push(node['$include']);
-                    }
-                    else if (Array.isArray(node['$include'])) {
-                        $includePaths.push(...(node['$include']
-                            .filter(v => v && typeof v === 'string' && v.trim() !== '')));
-                    }
-                    delete node['$include'];
-                    for (const path of $includePaths) {
-                        const [loadedYaml, loadError] = this.loadYamlFile(this.resolveIncludePath(mainYamlDirname, path));
-                        if (loadError) {
-                            errors.push(loadError);
-                        }
-                        else {
-                            for (const [k, v] of Object.entries(loadedYaml))
-                                node[k] = v;
-                        }
-                    }
-                }
-                else {
-                    if (typeof node[field] === 'string' && /^\s*\$[A-Z0-9_]+$/.test(node[field]))
-                        node[field] = process.env?.[node[field].trim().slice(1)] ?? '';
-                }
-            }
-            for (const k of Object.keys(node)) {
-                if (Object.hasOwn(node, k) && typeof node[k] === 'object' && !Array.isArray(node[k]))
-                    nodesToVisit.push(node[k]);
-            }
-        }
-        return [yaml, errors];
-    }
-    //region Utils
-    resolveFilePath(path) {
-        const initialPath = path;
-        while (ENV_VAR_REGEX.test(path)) {
-            const m = path.match(ENV_VAR_REGEX);
-            if (m.groups?.['var_name']) {
-                if (process.env?.[m.groups['var_name']]) {
-                    path = path.replace(ENV_VAR_REGEX, process.env[m.groups['var_name']].replace(/[\/\\]+$/, '') + node_path_1.sep);
-                }
-                else {
-                    throw new Error(`Failed to resolve path: "${initialPath}"`);
-                }
-            }
-        }
-        if (PKG_ROOT_REGEX.test(path))
-            path = path.replace(PKG_ROOT_REGEX, (0, getRootPackageDirname_1.getRootPackageDirnameSync)() + node_path_1.sep);
-        return (0, node_path_1.resolve)(path);
-    }
-    /**
-     * @param {string} fromDirname
-     * @param {string} toPath
-     * @returns {string}
-     * @private
-     */
-    resolveIncludePath(fromDirname, toPath) {
-        return (0, node_path_1.resolve)(this.resolveFilePath(fromDirname), toPath);
-    }
-}
-exports.ConfigLoader = ConfigLoader;

package/dist/config/config-loader.types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/config/index.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.configSchemas = exports.ConfigLoader = void 0;
-var config_loader_1 = require("./config-loader");
-Object.defineProperty(exports, "ConfigLoader", { enumerable: true, get: function () { return config_loader_1.ConfigLoader; } });
-var predefined_schemas_1 = require("./predefined-schemas");
-Object.defineProperty(exports, "configSchemas", { enumerable: true, get: function () { return predefined_schemas_1.configSchemas; } });

package/dist/config/predefined-schemas/connection.schema.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.connectionSchema = void 0;
-const zod_1 = require("zod");
-exports.connectionSchema = zod_1.z.object({
-    host: zod_1.z.string().nonempty(),
-    port: zod_1.z.coerce.number().min(1).max(65535),
-    user: zod_1.z.string(),
-    pass: zod_1.z.string()
-});

package/dist/config/predefined-schemas/index.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.configSchemas = void 0;
-const timestring_schema_1 = require("./timestring.schema");
-const connection_schema_1 = require("./connection.schema");
-const mongodb_connection_schema_1 = require("./mongodb-connection.schema");
-const mysql_connection_schema_1 = require("./mysql-connection.schema");
-const redis_connection_schema_1 = require("./redis-connection.schema");
-const rabbit_connection_schema_1 = require("./rabbit-connection.schema");
-exports.configSchemas = {
-    timeString: timestring_schema_1.timeStringSchema,
-    connection: connection_schema_1.connectionSchema,
-    mongodbConnection: mongodb_connection_schema_1.mongodbConnectionSchema,
-    mysqlConnection: mysql_connection_schema_1.mysqlConnectionSchema,
-    redisConnection: redis_connection_schema_1.redisConnectionSchema,
-    rabbitConnection: rabbit_connection_schema_1.rabbitConnectionSchema
-};

package/dist/config/predefined-schemas/mongodb-connection.schema.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mongodbConnectionSchema = void 0;
-const zod_1 = require("zod");
-const connection_schema_1 = require("./connection.schema");
-const timestring_schema_1 = require("./timestring.schema");
-exports.mongodbConnectionSchema = connection_schema_1.connectionSchema.extend({
-    db: zod_1.z.string().nonempty(),
-    authDb: zod_1.z.string().optional(),
-    connectTimeout: timestring_schema_1.timeStringSchema.default(5_000)
-}).transform(v => ({
-    ...v,
-    authDb: v.authDb || v.db,
-    dsn: `mongodb://${v.host}:${v.port}/${v.db}`
-}));

package/dist/config/predefined-schemas/mysql-connection.schema.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mysqlConnectionSchema = void 0;
-const zod_1 = require("zod");
-const connection_schema_1 = require("./connection.schema");
-exports.mysqlConnectionSchema = connection_schema_1.connectionSchema.extend({
-    dbname: zod_1.z.string().nonempty()
-});

package/dist/config/predefined-schemas/rabbit-connection.schema.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rabbitConnectionSchema = void 0;
-const zod_1 = require("zod");
-const connection_schema_1 = require("./connection.schema");
-exports.rabbitConnectionSchema = connection_schema_1.connectionSchema.extend({
-    vhost: zod_1.z.string().default('/')
-});

package/dist/config/predefined-schemas/redis-connection.schema.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.redisConnectionSchema = void 0;
-const zod_1 = require("zod");
-const connection_schema_1 = require("./connection.schema");
-exports.redisConnectionSchema = connection_schema_1.connectionSchema.extend({
-    db: zod_1.z.number().min(0).default(0),
-    keyPrefix: zod_1.z.string().default('')
-});

package/dist/config/predefined-schemas/timestring.schema.js

@@ -1,14 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.timeStringSchema = void 0;
-const zod_1 = require("zod");
-const ms_1 = __importDefault(require("ms"));
-const TIMESTRING_UNIT = ['Years', 'Year', 'Yrs', 'Yr', 'Y', 'Weeks', 'Week', 'W', 'Days', 'Day', 'D', 'Hours', 'Hour', 'Hrs', 'Hr', 'H', 'Minutes', 'Minute', 'Mins', 'Min', 'M', 'Seconds', 'Second', 'Secs', 'Sec', 's', 'Milliseconds', 'Millisecond', 'Msecs', 'Msec', 'Ms'];
-const TIMESTRING_REGEX = new RegExp(`\\d+\\s*(?:${TIMESTRING_UNIT.map(unit => unit.toLowerCase()).join('|')})`, 'i');
-exports.timeStringSchema = zod_1.z.string()
-    .nonempty()
-    .regex(TIMESTRING_REGEX)
-    .transform(v => (0, ms_1.default)(v));

package/dist/create-random-string.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRandomString = createRandomString;
-const node_crypto_1 = require("node:crypto");
-/**
- * @param {number} length The length of the string
- * @return {Promise<string>}
- */
-function createRandomString(length) {
-    if (length <= 0)
-        return Promise.resolve('');
-    return new Promise((resolve, reject) => {
-        const bytesLength = Math.ceil(length / 2);
-        (0, node_crypto_1.randomBytes)(bytesLength, (err, buff) => {
-            if (err)
-                return reject(err);
-            const hexString = buff.toString('hex').slice(0, length);
-            return resolve(hexString);
-        });
-    });
-}

package/dist/file-exists.js

@@ -1,34 +0,0 @@
-"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

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRootPackageDirnameSync = getRootPackageDirnameSync;
-const node_path_1 = require("node:path");
-const node_fs_1 = require("node:fs");
-let cachedRootPackageDirname = null;
-/**
- * @returns {string}
- */
-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 {
-            (0, node_fs_1.accessSync)(packageJsonPath, node_fs_1.constants.F_OK | node_fs_1.constants.R_OK);
-        }
-        catch (e) {
-            break;
-        }
-        lastValidPath = path;
-        path = (0, node_path_1.resolve)(path, '..');
-    }
-    cachedRootPackageDirname = lastValidPath;
-    return lastValidPath;
-}

package/dist/index.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRandomString = 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");
-Object.defineProperty(exports, "getRootPackageDirnameSync", { enumerable: true, get: function () { return getRootPackageDirname_1.getRootPackageDirnameSync; } });
-var config_1 = require("./config");
-Object.defineProperty(exports, "ConfigLoader", { enumerable: true, get: function () { return config_1.ConfigLoader; } });
-Object.defineProperty(exports, "configSchemas", { enumerable: true, get: function () { return config_1.configSchemas; } });
-var withNest_1 = require("./withNest");
-Object.defineProperty(exports, "withNest", { enumerable: true, get: function () { return withNest_1.withNest; } });
-var create_random_string_1 = require("./create-random-string");
-Object.defineProperty(exports, "createRandomString", { enumerable: true, get: function () { return create_random_string_1.createRandomString; } });

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

@@ -1,52 +0,0 @@
-import { z } from 'zod';
-import { type ErrorResult } from '@jsnw/common-utils';
-import { ResolvedConfig } from './config-loader.types';
-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.
-     * Also, you can use %env:ENV_VARIABLE to resolve config path based on environment variable
-     * Example 1: %pkgroot/config.yml
-     * Example 2: %env:CONFIG_PATH/config.yml
-     * @param {S} schema
-     * @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 {string} mainYamlDirname
-     * @param yaml
-     * @returns {ErrorResult<any, Error[]>}
-     * @protected
-     */
-    protected processDirectives(mainYamlDirname: string, yaml: any): ErrorResult<any, Error[]>;
-    private resolveFilePath;
-    /**
-     * @param {string} fromDirname
-     * @param {string} toPath
-     * @returns {string}
-     * @private
-     */
-    private resolveIncludePath;
-}

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

@@ -1,4 +0,0 @@
-import { z } from 'zod';
-export type ResolvedConfig<T extends z.ZodObject, P extends object | undefined = undefined> = z.output<T> & {
-    isDev: boolean;
-} & (P extends undefined ? {} : P);

package/dist/types/config/index.d.ts

@@ -1,3 +0,0 @@
-export { ConfigLoader } from './config-loader';
-export type { ResolvedConfig } from './config-loader.types';
-export { configSchemas } from './predefined-schemas';

package/dist/types/config/predefined-schemas/connection.schema.d.ts

@@ -1,7 +0,0 @@
-import { z } from 'zod';
-export declare const connectionSchema: z.ZodObject<{
-    host: z.ZodString;
-    port: z.ZodCoercedNumber<unknown>;
-    user: z.ZodString;
-    pass: z.ZodString;
-}, z.core.$strip>;

package/dist/types/config/predefined-schemas/index.d.ts

@@ -1,57 +0,0 @@
-export declare const configSchemas: {
-    timeString: import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<number, string>>;
-    connection: import("zod").ZodObject<{
-        host: import("zod").ZodString;
-        port: import("zod").ZodCoercedNumber<unknown>;
-        user: import("zod").ZodString;
-        pass: import("zod").ZodString;
-    }, import("zod/v4/core").$strip>;
-    mongodbConnection: import("zod").ZodPipe<import("zod").ZodObject<{
-        host: import("zod").ZodString;
-        port: import("zod").ZodCoercedNumber<unknown>;
-        user: import("zod").ZodString;
-        pass: import("zod").ZodString;
-        db: import("zod").ZodString;
-        authDb: import("zod").ZodOptional<import("zod").ZodString>;
-        connectTimeout: import("zod").ZodDefault<import("zod").ZodPipe<import("zod").ZodString, import("zod").ZodTransform<number, string>>>;
-    }, import("zod/v4/core").$strip>, import("zod").ZodTransform<{
-        authDb: string;
-        dsn: string;
-        host: string;
-        port: number;
-        user: string;
-        pass: string;
-        db: string;
-        connectTimeout: number;
-    }, {
-        host: string;
-        port: number;
-        user: string;
-        pass: string;
-        db: string;
-        connectTimeout: number;
-        authDb?: string;
-    }>>;
-    mysqlConnection: import("zod").ZodObject<{
-        host: import("zod").ZodString;
-        port: import("zod").ZodCoercedNumber<unknown>;
-        user: import("zod").ZodString;
-        pass: import("zod").ZodString;
-        dbname: import("zod").ZodString;
-    }, import("zod/v4/core").$strip>;
-    redisConnection: import("zod").ZodObject<{
-        host: import("zod").ZodString;
-        port: import("zod").ZodCoercedNumber<unknown>;
-        user: import("zod").ZodString;
-        pass: import("zod").ZodString;
-        db: import("zod").ZodDefault<import("zod").ZodNumber>;
-        keyPrefix: import("zod").ZodDefault<import("zod").ZodString>;
-    }, import("zod/v4/core").$strip>;
-    rabbitConnection: import("zod").ZodObject<{
-        host: import("zod").ZodString;
-        port: import("zod").ZodCoercedNumber<unknown>;
-        user: import("zod").ZodString;
-        pass: import("zod").ZodString;
-        vhost: import("zod").ZodDefault<import("zod").ZodString>;
-    }, import("zod/v4/core").$strip>;
-};

package/dist/types/config/predefined-schemas/mongodb-connection.schema.d.ts

@@ -1,27 +0,0 @@
-import { z } from 'zod';
-export declare const mongodbConnectionSchema: z.ZodPipe<z.ZodObject<{
-    host: z.ZodString;
-    port: z.ZodCoercedNumber<unknown>;
-    user: z.ZodString;
-    pass: z.ZodString;
-    db: z.ZodString;
-    authDb: z.ZodOptional<z.ZodString>;
-    connectTimeout: z.ZodDefault<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>;
-}, z.core.$strip>, z.ZodTransform<{
-    authDb: string;
-    dsn: string;
-    host: string;
-    port: number;
-    user: string;
-    pass: string;
-    db: string;
-    connectTimeout: number;
-}, {
-    host: string;
-    port: number;
-    user: string;
-    pass: string;
-    db: string;
-    connectTimeout: number;
-    authDb?: string;
-}>>;

package/dist/types/config/predefined-schemas/mysql-connection.schema.d.ts

@@ -1,8 +0,0 @@
-import { z } from 'zod';
-export declare const mysqlConnectionSchema: z.ZodObject<{
-    host: z.ZodString;
-    port: z.ZodCoercedNumber<unknown>;
-    user: z.ZodString;
-    pass: z.ZodString;
-    dbname: z.ZodString;
-}, z.core.$strip>;

package/dist/types/config/predefined-schemas/rabbit-connection.schema.d.ts

@@ -1,8 +0,0 @@
-import { z } from 'zod';
-export declare const rabbitConnectionSchema: z.ZodObject<{
-    host: z.ZodString;
-    port: z.ZodCoercedNumber<unknown>;
-    user: z.ZodString;
-    pass: z.ZodString;
-    vhost: z.ZodDefault<z.ZodString>;
-}, z.core.$strip>;

package/dist/types/config/predefined-schemas/redis-connection.schema.d.ts

@@ -1,9 +0,0 @@
-import { z } from 'zod';
-export declare const redisConnectionSchema: z.ZodObject<{
-    host: z.ZodString;
-    port: z.ZodCoercedNumber<unknown>;
-    user: z.ZodString;
-    pass: z.ZodString;
-    db: z.ZodDefault<z.ZodNumber>;
-    keyPrefix: z.ZodDefault<z.ZodString>;
-}, z.core.$strip>;

package/dist/types/config/predefined-schemas/timestring.schema.d.ts

@@ -1,2 +0,0 @@
-import { z } from 'zod';
-export declare const timeStringSchema: z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>;

package/dist/types/create-random-string.d.ts

@@ -1,5 +0,0 @@
-/**
- * @param {number} length The length of the string
- * @return {Promise<string>}
- */
-export declare function createRandomString(length: number): Promise<string>;

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

@@ -1,12 +0,0 @@
-/**
- * @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/getRootPackageDirname.d.ts

@@ -1,4 +0,0 @@
-/**
- * @returns {string}
- */
-export declare function getRootPackageDirnameSync(): string;

package/dist/types/index.d.ts

@@ -1,6 +0,0 @@
-export { fileExists, fileExistsSync } from './file-exists';
-export { useTsconfigPaths } from './useTsconfigPaths';
-export { getRootPackageDirnameSync } from './getRootPackageDirname';
-export { ConfigLoader, configSchemas, type ResolvedConfig } from './config';
-export { withNest } from './withNest';
-export { createRandomString } from './create-random-string';

package/dist/types/useTsconfigPaths.d.ts

@@ -1,9 +0,0 @@
-type UseTsconfigPathsOptions = {
-    basePath?: string;
-    tsconfigPath: string;
-};
-/**
- * @param {UseTsconfigPathsOptions} options
- */
-export declare function useTsconfigPaths({ basePath, tsconfigPath }: UseTsconfigPathsOptions): void;
-export {};

package/dist/types/withNest.d.ts

@@ -1,20 +0,0 @@
-import type { INestApplicationContext } from '@nestjs/common';
-type WithNestFn = (app: INestApplicationContext, preventClosing: () => void) => Promise<void>;
-/**
- * Executes a given function within the context of a NestJS application.
- *
- * This asynchronous function initializes a NestJS application context using the specified
- * module class and then executes the provided function `fn` with the application instance.
- * The application context is automatically closed upon completion of the function execution,
- * unless the function execution requests otherwise by invoking a callback.
- *
- * @param {any} moduleCls - The module class to be used for creating the NestJS application context.
- * @param {WithNestFn} fn - The function to be executed with the NestJS application context.
- *                             It receives the application instance and a callback to prevent
- *                             automatic application context closure.
- * @returns {Promise<void>} A promise that resolves when the function execution is complete.
- * @throws - Will throw an error if the `@nestjs/core` and/or `@nestjs/common` library is not found.
- * @throws - Will propagate any error thrown by the executed function `fn`.
- */
-export declare function withNest(moduleCls: any, fn: WithNestFn): Promise<void>;
-export {};