@node-in-layers/core/libs.d.ts

The core library for the Node In Layers rapid web development framework.

import { ModelInstanceFetcher } from 'functional-models';
import { Config, LayerDescription, LogLevel, LogLevelNames, ErrorObject } from './types.js';
declare const featurePassThrough: <T extends any[], U>(fn: (...args: T) => U) => (...args: T) => U;
declare const validateConfig: (config: Partial<Config>) => void;
declare const getLogLevelName: (logLevel: LogLevel) => "TRACE" | "DEBUG" | "INFO" | "WARN" | "ERROR" | "SILENT";
declare const getLogLevelNumber: (logLevel: LogLevelNames) => LogLevel;
declare const getLayersUnavailable: (allLayers: readonly LayerDescription[]) => (layer: string) => string[];
declare const isConfig: <TConfig extends Readonly<{
    systemName: string;
    environment: string;
    "@node-in-layers/core": Readonly<{
        logging: {
            logLevel: LogLevelNames;
            logFormat: import("./types.js").LogFormat | readonly import("./types.js").LogFormat[];
            maxLogSizeInCharacters?: number | undefined;
            tcpLoggingOptions?: Readonly<{
                url: string;
                headers?: Record<string, string | object> | undefined;
            }> | undefined;
            customLogger?: Readonly<{
                getLogger: (context: Readonly<{
                    config: Readonly<any>;
                    rootLogger: Readonly<any>;
                    constants: {
                        environment: string;
                        workingDirectory: string;
                        runtimeId: string;
                    };
                }>, props?: {
                    ids?: readonly Readonly<Record<string, string>>[] | undefined;
                    data?: Record<string, any> | undefined;
                } | undefined) => import("./types.js").HighLevelLogger;
            }> | undefined;
            getFunctionWrapLogLevel?: ((layerName: string, functionName?: string | undefined) => LogLevelNames) | undefined;
            ignoreLayerFunctions?: Record<string, boolean | Record<string, boolean | Record<string, boolean>>> | undefined;
        };
        layerOrder: readonly LayerDescription[];
        apps: readonly Readonly<{
            name: string;
            services?: Readonly<{
                create: (context: any) => import("./types.js").MaybePromise<object>;
            }> | undefined;
            features?: Readonly<{
                create: (context: any) => import("./types.js").MaybePromise<object>;
            }> | undefined;
            globals?: Readonly<{
                create: (context: Readonly<{
                    config: Readonly<any>;
                    rootLogger: Readonly<{
                        getLogger: (context: Readonly<{
                            config: Readonly<any>;
                            rootLogger: Readonly<any>;
                            constants: {
                                environment: string;
                                workingDirectory: string;
                                runtimeId: string;
                            };
                        }>, props?: {
                            ids?: readonly Readonly<Record<string, string>>[] | undefined;
                            data?: Record<string, any> | undefined;
                        } | undefined) => import("./types.js").HighLevelLogger;
                    }>;
                    constants: {
                        environment: string;
                        workingDirectory: string;
                        runtimeId: string;
                    };
                }>) => Promise<any>;
            }> | undefined;
            models?: Record<string, Readonly<{
                create: <T extends Readonly<{
                    [s: string]: any;
                }>, TModelExtensions extends object = object, TModelInstanceExtensions extends object = object>(modelProps: Readonly<{
                    Model: import("functional-models/types.js").ModelFactory<object, object>;
                    fetcher: ModelInstanceFetcher<object, object>;
                    getModel: <T_1 extends Readonly<{
                        [s: string]: any;
                    }>>(namespace: string, modelName: string) => () => import("functional-models/types.js").ModelType<T_1, object, object>;
                }>) => import("functional-models/types.js").ModelType<T, TModelExtensions, TModelInstanceExtensions>;
            }>> | undefined;
        }>[];
        modelFactory?: string | undefined;
        modelCruds?: boolean | undefined;
        customModelFactory?: {
            [x: string]: {
                [x: string]: string | [string, string] | [string, string, any[]];
            };
        } | undefined;
    }>;
}>>(obj: any) => obj is TConfig;
declare const getNamespace: (packageName: string, app?: string) => string;
declare const DoNothingFetcher: ModelInstanceFetcher;
/**
 * Creates a standardized error object for consistent error handling across the application.
 * This function handles all the logic for converting different error types to the standard format.
 *
 * @param code - A unique string code for the error
 * @param message - A user-friendly error message
 * @param error - Optional error object or details (can be any type - will be properly handled)
 * @returns A standardized error object conforming to the ErrorObject type
 */
declare const createErrorObject: (code: string, message: string, error?: unknown) => ErrorObject;
declare const isErrorObject: (value: unknown) => value is Readonly<{
    error: Readonly<{
        code: string;
        message: string;
        details?: string | undefined;
        data?: Record<string, import("functional-models/types.js").JsonAble> | undefined;
        trace?: string | undefined;
        cause?: Readonly<any> | undefined;
    }>;
}>;
export { createErrorObject, featurePassThrough, getLogLevelName, validateConfig, getLayersUnavailable, isConfig, getNamespace, DoNothingFetcher, getLogLevelNumber, isErrorObject, };