@smounters/imperium 1.0.0

package/dist/rpc/adapter.js

@@ -0,0 +1,186 @@
+import "reflect-metadata";
+import { ForbiddenException, toConnectError } from "../core/errors";
+import { CATCH_EXCEPTIONS_KEY } from "../decorators/filters.decorators";
+import { RPC_PARAMS_KEY } from "../decorators/rpc.decorators";
+import { LoggerService } from "../services";
+import { collectFiltersForRpc, collectGuardsForRpc, collectInterceptorsForRpc, collectPipesForRpc } from "./utils";
+function logRpcError(app, scope, details, error) {
+    try {
+        scope.resolve(LoggerService).error(details, error);
+        return;
+    }
+    catch {
+        // fallback below
+    }
+    try {
+        app.getLogger().error(details, error);
+        return;
+    }
+    catch {
+        // final fallback
+    }
+    console.error("[imperium] rpc_error", details, error);
+}
+function getPayloadValue(payload, key) {
+    if (!key) {
+        return payload;
+    }
+    if (!payload || typeof payload !== "object") {
+        return undefined;
+    }
+    return payload[key];
+}
+function buildRpcArgs(payload, context, handler) {
+    const metas = Reflect.getMetadata(RPC_PARAMS_KEY, handler) ?? [];
+    if (!metas.length) {
+        return [payload];
+    }
+    const args = [];
+    for (const meta of metas) {
+        switch (meta.source) {
+            case "data":
+                args[meta.index] = getPayloadValue(payload, meta.key);
+                break;
+            case "context":
+                args[meta.index] = context;
+                break;
+            case "headers":
+                args[meta.index] = context.requestHeader;
+                break;
+            case "header":
+                args[meta.index] = meta.key ? context.requestHeader.get(meta.key) : undefined;
+                break;
+        }
+    }
+    return args;
+}
+function resolveEnhancer(scope, enhancer) {
+    if (typeof enhancer === "function") {
+        return scope.resolve(enhancer);
+    }
+    return enhancer;
+}
+function getRequestScope(app, controller) {
+    return app.createRequestScope(controller);
+}
+function canHandleException(error, filter) {
+    const exceptions = Reflect.getMetadata(CATCH_EXCEPTIONS_KEY, filter.constructor);
+    if (!exceptions || exceptions.length === 0) {
+        return true;
+    }
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return exceptions.some((ExceptionType) => error instanceof ExceptionType);
+}
+async function runRpcFilters(error, filters, ctx) {
+    let currentError = error;
+    for (const filter of filters) {
+        if (!canHandleException(currentError, filter)) {
+            continue;
+        }
+        try {
+            const result = await filter.catch(currentError, ctx);
+            if (result !== undefined) {
+                return {
+                    handled: true,
+                    error: currentError,
+                    result: result,
+                };
+            }
+        }
+        catch (nextError) {
+            currentError = nextError;
+        }
+    }
+    return {
+        handled: false,
+        error: currentError,
+    };
+}
+export function createRpcHandler(app, controller, methodName) {
+    return async (req, context) => {
+        const scope = getRequestScope(app, controller);
+        const handler = controller.prototype[methodName];
+        return app.runInRequestScope(scope, async () => {
+            const ctx = {
+                type: "rpc",
+                method: methodName,
+                headers: context.requestHeader,
+                rpc: {
+                    data: req,
+                    context,
+                },
+                controller,
+                handler,
+                getType: () => "rpc",
+                getClass: () => controller,
+                getHandler: () => handler,
+                switchToHttp: () => ({
+                    getRequest: () => undefined,
+                    getResponse: () => undefined,
+                }),
+                switchToRpc: () => ({
+                    getData: () => req,
+                    getContext: () => context,
+                }),
+            };
+            try {
+                const instance = scope.resolve(controller);
+                const guards = collectGuardsForRpc(controller, methodName, app.getGlobalGuards()).map((guardLike) => resolveEnhancer(scope, guardLike));
+                for (const guard of guards) {
+                    const ok = await guard.canActivate(ctx);
+                    if (!ok) {
+                        throw new ForbiddenException();
+                    }
+                }
+                let payload = req;
+                const pipes = collectPipesForRpc(controller, methodName, app.getGlobalPipes()).map((pipeLike) => resolveEnhancer(scope, pipeLike));
+                for (const pipe of pipes) {
+                    payload = await pipe.transform(payload, ctx);
+                }
+                const interceptors = collectInterceptorsForRpc(controller, methodName, app.getGlobalInterceptors()).map((interceptorLike) => resolveEnhancer(scope, interceptorLike));
+                const args = buildRpcArgs(payload, context, handler);
+                const controllerHandler = instance[methodName];
+                let idx = -1;
+                const next = async () => {
+                    idx++;
+                    if (idx < interceptors.length) {
+                        return (await interceptors[idx].intercept(ctx, next));
+                    }
+                    return controllerHandler(...args);
+                };
+                return next();
+            }
+            catch (error) {
+                logRpcError(app, scope, {
+                    type: "rpc_error",
+                    controller: controller.name,
+                    handler: methodName,
+                    procedure: context.method.name,
+                }, error);
+                const filters = collectFiltersForRpc(controller, methodName, app.getGlobalFilters()).map((filterLike) => resolveEnhancer(scope, filterLike));
+                const filtered = await runRpcFilters(error, filters, ctx);
+                if (filtered.handled) {
+                    return filtered.result;
+                }
+                throw toConnectError(filtered.error, {
+                    exposeInternalErrors: app.shouldExposeInternalErrors(),
+                });
+            }
+            finally {
+                try {
+                    await app.disposeRequestScope(scope);
+                }
+                catch (disposeError) {
+                    logRpcError(app, scope, {
+                        type: "rpc_scope_dispose_error",
+                        controller: controller.name,
+                        handler: methodName,
+                        procedure: context.method.name,
+                    }, disposeError);
+                }
+            }
+        });
+    };
+}

package/dist/rpc/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./adapter";
+export * from "./router-builder";
+export * from "./utils";

package/dist/rpc/index.js

@@ -0,0 +1,3 @@
+export * from "./adapter";
+export * from "./router-builder";
+export * from "./utils";

package/dist/rpc/router-builder.d.ts

@@ -0,0 +1,4 @@
+import type { ConnectRouter } from "@connectrpc/connect";
+import "reflect-metadata";
+import type { AppContainer } from "../core/container";
+export declare function buildConnectRoutes(di: AppContainer): (router: ConnectRouter) => void;

package/dist/rpc/router-builder.js

@@ -0,0 +1,28 @@
+import "reflect-metadata";
+import { RPC_METHODS_KEY, RPC_SERVICE_KEY } from "../decorators/rpc.decorators";
+import { createRpcHandler } from "./adapter";
+function assertUnaryRpcMethod(controller, handlerName, method) {
+    if (method.methodKind === "unary") {
+        return;
+    }
+    const serviceName = method.parent.name;
+    const rpcName = method.name;
+    throw new Error(`Streaming RPC methods are not supported: ${serviceName}.${rpcName} (${method.methodKind}) ` +
+        `at ${controller.name}.${handlerName}. Only unary methods are supported.`);
+}
+export function buildConnectRoutes(di) {
+    return (router) => {
+        for (const ctrl of di.getControllers()) {
+            const controller = ctrl;
+            const service = Reflect.getMetadata(RPC_SERVICE_KEY, controller);
+            if (!service) {
+                continue;
+            }
+            const methods = Reflect.getMetadata(RPC_METHODS_KEY, controller) ?? [];
+            for (const { method, handlerName } of methods) {
+                assertUnaryRpcMethod(controller, handlerName, method);
+                router.rpc(method, createRpcHandler(di, controller, handlerName));
+            }
+        }
+    };
+}

package/dist/rpc/utils.d.ts

@@ -0,0 +1,6 @@
+import "reflect-metadata";
+import type { Constructor, ExceptionFilterLike, GuardLike, InterceptorLike, PipeLike } from "../types";
+export declare function collectGuardsForRpc(controller: Constructor, method: string, global: GuardLike[]): GuardLike[];
+export declare function collectInterceptorsForRpc(controller: Constructor, method: string, global: InterceptorLike[]): InterceptorLike[];
+export declare function collectPipesForRpc(controller: Constructor, method: string, global: PipeLike[]): PipeLike[];
+export declare function collectFiltersForRpc(controller: Constructor, method: string, global: ExceptionFilterLike[]): ExceptionFilterLike[];

package/dist/rpc/utils.js

@@ -0,0 +1,46 @@
+import "reflect-metadata";
+import { Reflector } from "../core/reflector";
+import { FILTERS_KEY } from "../decorators/filters.decorators";
+import { GUARDS_KEY } from "../decorators/guards.decorators";
+import { INTERCEPTORS_KEY } from "../decorators/interceptors.decorators";
+import { PIPES_KEY } from "../decorators/pipes.decorators";
+const reflector = new Reflector();
+function enhancerKey(value) {
+    if (typeof value === "function") {
+        return value;
+    }
+    if (value && typeof value === "object") {
+        const ctor = value.constructor;
+        if (ctor && ctor !== Object) {
+            return ctor;
+        }
+    }
+    return value;
+}
+function uniqueByEnhancer(values) {
+    return values.filter((value, index, arr) => {
+        const key = enhancerKey(value);
+        return arr.findIndex((other) => enhancerKey(other) === key) === index;
+    });
+}
+function readClassAndMethodMeta(metadataKey, controller, method) {
+    const classValues = (reflector.get(metadataKey, controller) ?? []);
+    const methodValues = (reflector.get(metadataKey, controller.prototype[method]) ?? []);
+    return [...classValues, ...methodValues];
+}
+export function collectGuardsForRpc(controller, method, global) {
+    const local = readClassAndMethodMeta(GUARDS_KEY, controller, method);
+    return [...global, ...local];
+}
+export function collectInterceptorsForRpc(controller, method, global) {
+    const local = readClassAndMethodMeta(INTERCEPTORS_KEY, controller, method);
+    return uniqueByEnhancer([...global, ...local]);
+}
+export function collectPipesForRpc(controller, method, global) {
+    const local = readClassAndMethodMeta(PIPES_KEY, controller, method);
+    return [...global, ...local];
+}
+export function collectFiltersForRpc(controller, method, global) {
+    const local = readClassAndMethodMeta(FILTERS_KEY, controller, method);
+    return uniqueByEnhancer([...global, ...local]);
+}

package/dist/services/config.service.d.ts

@@ -0,0 +1,10 @@
+type ConfigMap = Record<string, unknown>;
+export declare class ConfigService<TConfig extends ConfigMap = ConfigMap> {
+    private readonly config;
+    constructor(config: TConfig);
+    getAll(): Readonly<TConfig>;
+    get<K extends keyof TConfig>(key: K): TConfig[K];
+    has(key: PropertyKey): boolean;
+    getOrThrow<K extends keyof TConfig>(key: K, message?: string): NonNullable<TConfig[K]>;
+}
+export {};

package/dist/services/config.service.js

@@ -0,0 +1,41 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { CONFIG_TOKEN } from "../core/config";
+import { Inject, Injectable } from "../decorators";
+let ConfigService = class ConfigService {
+    constructor(config) {
+        this.config = config;
+    }
+    getAll() {
+        return this.config;
+    }
+    get(key) {
+        return this.config[key];
+    }
+    has(key) {
+        return key in this.config;
+    }
+    getOrThrow(key, message) {
+        const value = this.config[key];
+        if (value === undefined || value === null) {
+            throw new Error(message ?? `Missing config key: ${String(key)}`);
+        }
+        return value;
+    }
+};
+ConfigService = __decorate([
+    Injectable(),
+    __param(0, Inject(CONFIG_TOKEN)),
+    __metadata("design:paramtypes", [Object])
+], ConfigService);
+export { ConfigService };

package/dist/services/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./config.service";
+export * from "./logger.service";

package/dist/services/index.js

@@ -0,0 +1,2 @@
+export * from "./config.service";
+export * from "./logger.service";

package/dist/services/logger.service.d.ts

@@ -0,0 +1,30 @@
+import { type AppLogger } from "../core/logger";
+export declare class LoggerService {
+    private readonly logger;
+    constructor(logger: AppLogger);
+    getRawLogger(): AppLogger;
+    log(logLevelId: number, logLevelName: string, ...args: unknown[]): ({
+        [x: string]: unknown;
+    } & import("tslog").ILogObjMeta & import("tslog").ILogObj) | undefined;
+    silly(...args: unknown[]): ({
+        [x: string]: unknown;
+    } & import("tslog").ILogObjMeta) | undefined;
+    trace(...args: unknown[]): ({
+        [x: string]: unknown;
+    } & import("tslog").ILogObjMeta) | undefined;
+    debug(...args: unknown[]): ({
+        [x: string]: unknown;
+    } & import("tslog").ILogObjMeta) | undefined;
+    info(...args: unknown[]): ({
+        [x: string]: unknown;
+    } & import("tslog").ILogObjMeta) | undefined;
+    warn(...args: unknown[]): ({
+        [x: string]: unknown;
+    } & import("tslog").ILogObjMeta) | undefined;
+    error(...args: unknown[]): ({
+        [x: string]: unknown;
+    } & import("tslog").ILogObjMeta) | undefined;
+    fatal(...args: unknown[]): ({
+        [x: string]: unknown;
+    } & import("tslog").ILogObjMeta) | undefined;
+}

package/dist/services/logger.service.js

@@ -0,0 +1,52 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { LOGGER_TOKEN } from "../core/logger";
+import { Inject, Injectable } from "../decorators";
+let LoggerService = class LoggerService {
+    constructor(logger) {
+        this.logger = logger;
+    }
+    getRawLogger() {
+        return this.logger;
+    }
+    log(logLevelId, logLevelName, ...args) {
+        return this.logger.log(logLevelId, logLevelName, ...args);
+    }
+    silly(...args) {
+        return this.logger.silly(...args);
+    }
+    trace(...args) {
+        return this.logger.trace(...args);
+    }
+    debug(...args) {
+        return this.logger.debug(...args);
+    }
+    info(...args) {
+        return this.logger.info(...args);
+    }
+    warn(...args) {
+        return this.logger.warn(...args);
+    }
+    error(...args) {
+        return this.logger.error(...args);
+    }
+    fatal(...args) {
+        return this.logger.fatal(...args);
+    }
+};
+LoggerService = __decorate([
+    Injectable(),
+    __param(0, Inject(LOGGER_TOKEN)),
+    __metadata("design:paramtypes", [Object])
+], LoggerService);
+export { LoggerService };

package/dist/types.d.ts

@@ -0,0 +1,167 @@
+import type { FastifyReply, FastifyRequest, FastifyServerOptions } from "fastify";
+import type { ISettingsParam } from "tslog";
+import type { DependencyContainer, RegistrationOptions, InjectionToken as TsyringeInjectionToken } from "tsyringe";
+import type { ZodType } from "zod";
+export type Constructor<T = unknown> = new (...args: any[]) => T;
+export type ContextType = "http" | "rpc";
+export type LoggerOptions = ISettingsParam<Record<string, unknown>>;
+export type InjectionToken<T = unknown> = TsyringeInjectionToken<T>;
+export type MetadataKey = string | symbol;
+export type ShutdownSignal = "SIGINT" | "SIGTERM";
+export interface ClassProvider<T = unknown> {
+    provide: InjectionToken<T>;
+    useClass: Constructor<T>;
+    multi?: boolean;
+    options?: RegistrationOptions;
+}
+export interface ValueProvider<T = unknown> {
+    provide: InjectionToken<T>;
+    useValue: T;
+    multi?: boolean;
+}
+export interface FactoryProvider<T = unknown> {
+    provide: InjectionToken<T>;
+    useFactory: (container: DependencyContainer) => T;
+    multi?: boolean;
+}
+export interface ExistingProvider<T = unknown> {
+    provide: InjectionToken<T>;
+    useExisting: InjectionToken<T>;
+    multi?: boolean;
+    options?: RegistrationOptions;
+}
+export type Provider<T = unknown> = Constructor<T> | ClassProvider<T> | ValueProvider<T> | FactoryProvider<T> | ExistingProvider<T>;
+interface BaseModuleMeta {
+    providers?: Provider[];
+    controllers?: Constructor[];
+    httpControllers?: Constructor[];
+    imports?: ModuleImport[];
+    exports?: InjectionToken[];
+    global?: boolean;
+}
+export interface ModuleMeta extends BaseModuleMeta {
+}
+export interface DynamicModule extends BaseModuleMeta {
+    module: Constructor;
+    id?: string;
+}
+export type ModuleImport = Constructor | DynamicModule;
+export interface OnModuleInit {
+    onModuleInit(): void | Promise<void>;
+}
+export interface OnApplicationBootstrap {
+    onApplicationBootstrap(): void | Promise<void>;
+}
+export interface OnModuleDestroy {
+    onModuleDestroy(): void | Promise<void>;
+}
+export interface BeforeApplicationShutdown {
+    beforeApplicationShutdown(signal?: string): void | Promise<void>;
+}
+export interface OnApplicationShutdown {
+    onApplicationShutdown(signal?: string): void | Promise<void>;
+}
+export interface HttpArgumentsHost {
+    getRequest(): FastifyRequest | undefined;
+    getResponse(): FastifyReply | undefined;
+}
+export interface RpcArgumentsHost {
+    getData<T = unknown>(): T | undefined;
+    getContext<T = unknown>(): T | undefined;
+}
+export interface BaseContext {
+    type: ContextType;
+    method: string;
+    request?: Request;
+    headers?: Headers;
+    fastify?: {
+        req: FastifyRequest;
+        reply: FastifyReply;
+    };
+    rpc?: {
+        data: unknown;
+        context: unknown;
+    };
+    controller: Constructor;
+    handler: Function;
+    getType(): ContextType;
+    getClass(): Constructor;
+    getHandler(): Function;
+    switchToHttp(): HttpArgumentsHost;
+    switchToRpc(): RpcArgumentsHost;
+}
+export interface Guard {
+    canActivate(ctx: BaseContext): Promise<boolean> | boolean;
+}
+export type GuardLike = Constructor<Guard> | Guard;
+export type NextFn = () => Promise<unknown>;
+export interface Interceptor {
+    intercept(ctx: BaseContext, next: NextFn): Promise<unknown>;
+}
+export type InterceptorLike = Constructor<Interceptor> | Interceptor;
+export interface PipeTransform<TIn = unknown, TOut = unknown> {
+    transform(value: TIn, ctx: BaseContext): Promise<TOut> | TOut;
+}
+export type PipeLike = Constructor<PipeTransform> | PipeTransform;
+export interface ExceptionFilter<T = unknown> {
+    catch(exception: T, ctx: BaseContext): Promise<unknown> | unknown;
+}
+export type ExceptionFilterLike = Constructor<ExceptionFilter> | ExceptionFilter;
+export interface ConfigServiceOptions<TSchema extends ZodType = ZodType> {
+    schema: TSchema;
+    source?: unknown;
+}
+export interface CorsOptions {
+    enabled?: boolean;
+    origin?: string | boolean | RegExp | Array<string | boolean | RegExp>;
+    credentials?: boolean;
+    exposedHeaders?: string | string[];
+    allowedHeaders?: string | string[];
+    methods?: string | string[];
+    maxAge?: number;
+    preflightContinue?: boolean;
+    optionsSuccessStatus?: number;
+    strictPreflight?: boolean;
+}
+export type HealthCheckResult = boolean | {
+    ok: boolean;
+    details?: unknown;
+};
+export type HealthCheck = () => HealthCheckResult | Promise<HealthCheckResult>;
+export interface HealthOptions {
+    enabled?: boolean;
+    path?: string;
+    check?: HealthCheck;
+}
+export interface GracefulShutdownOptions {
+    enabled?: boolean;
+    signals?: ShutdownSignal[];
+    timeoutMs?: number;
+    forceExitOnFailure?: boolean;
+}
+export interface ServerOptions {
+    port?: number;
+    host?: string;
+    prefix?: string;
+    httpPrefix?: string;
+    rpcPrefix?: string;
+    trustProxy?: FastifyServerOptions["trustProxy"];
+    requestTimeout?: FastifyServerOptions["requestTimeout"];
+    connectionTimeout?: FastifyServerOptions["connectionTimeout"];
+    keepAliveTimeout?: FastifyServerOptions["keepAliveTimeout"];
+    bodyLimit?: FastifyServerOptions["bodyLimit"];
+    routerOptions?: FastifyServerOptions["routerOptions"];
+    /**
+     * @deprecated Use `routerOptions.maxParamLength` instead.
+     */
+    maxParamLength?: FastifyServerOptions["maxParamLength"];
+    pluginTimeout?: FastifyServerOptions["pluginTimeout"];
+    accessLogs?: boolean;
+    exposeInternalErrors?: boolean;
+    cors?: boolean | CorsOptions;
+    health?: boolean | HealthOptions;
+    gracefulShutdown?: boolean | GracefulShutdownOptions;
+    loggerOptions?: LoggerOptions;
+    config?: ConfigServiceOptions;
+}
+export {};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/validation/app-config.d.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+export declare const appConfigSchema: z.ZodObject<{
+    APP_HOST: z.ZodDefault<z.ZodString>;
+    APP_PORT: z.ZodDefault<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
+    APP_GLOBAL_PREFIX: z.ZodDefault<z.ZodString>;
+    APP_HTTP_PREFIX: z.ZodDefault<z.ZodString>;
+    APP_RPC_PREFIX: z.ZodDefault<z.ZodString>;
+    APP_ACCESS_LOGS: z.ZodDefault<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>;
+    APP_EXPOSE_INTERNAL_ERRORS: z.ZodDefault<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>;
+    MIDDLEWARE_CORS: z.ZodDefault<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>>;
+    CORS_ALLOWED_ORIGINS: z.ZodDefault<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+    CORS_ALLOWED_METHODS: z.ZodDefault<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+    CORS_ALLOWED_HEADERS: z.ZodDefault<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+    CORS_EXPOSE_HEADERS: z.ZodDefault<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodString>>>;
+    LOG_NAME: z.ZodDefault<z.ZodString>;
+    LOG_LEVEL: z.ZodDefault<z.ZodEnum<{
+        error: "error";
+        trace: "trace";
+        fatal: "fatal";
+        warn: "warn";
+        info: "info";
+        debug: "debug";
+        silly: "silly";
+    }>>;
+    LOG_TYPE: z.ZodDefault<z.ZodEnum<{
+        pretty: "pretty";
+        json: "json";
+    }>>;
+}, z.core.$strip>;
+export type AppConfig = z.infer<typeof appConfigSchema>;

package/dist/validation/app-config.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import { booleanSchema, numberSchema, stringArraySchema } from "./common";
+const LOG_LEVELS = ["silly", "trace", "debug", "info", "warn", "error", "fatal"];
+const LOG_TYPES = ["pretty", "json"];
+export const appConfigSchema = z.object({
+    APP_HOST: z.string().default("0.0.0.0"),
+    APP_PORT: numberSchema()
+        .refine((value) => Number.isInteger(value) && value >= 1 && value <= 65535, {
+        message: "APP_PORT must be an integer in range 1..65535",
+    })
+        .default(8000),
+    APP_GLOBAL_PREFIX: z.string().default(""),
+    APP_HTTP_PREFIX: z.string().default(""),
+    APP_RPC_PREFIX: z.string().default(""),
+    APP_ACCESS_LOGS: booleanSchema().default(false),
+    APP_EXPOSE_INTERNAL_ERRORS: booleanSchema().default(false),
+    MIDDLEWARE_CORS: booleanSchema().default(false),
+    CORS_ALLOWED_ORIGINS: stringArraySchema(z.string()).default(["*"]),
+    CORS_ALLOWED_METHODS: stringArraySchema(z.string()).default(["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"]),
+    CORS_ALLOWED_HEADERS: stringArraySchema(z.string()).default(["*"]),
+    CORS_EXPOSE_HEADERS: stringArraySchema(z.string()).default([]),
+    LOG_NAME: z.string().default("app"),
+    LOG_LEVEL: z.enum(LOG_LEVELS).default("info"),
+    LOG_TYPE: z.enum(LOG_TYPES).default("pretty"),
+});

package/dist/validation/common.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+type NativeEnumLike = Record<string, string | number>;
+export declare const booleanSchema: () => z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodBoolean>;
+export declare const numberSchema: () => z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>;
+export declare const nativeEnumSchema: <T extends NativeEnumLike>(enumType: T, normalize?: (value: string) => string) => z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodEnum<T>>;
+export declare const stringArraySchema: <T extends z.ZodType>(itemSchema: T) => z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<T>>;
+export declare const enumArraySchema: <T extends NativeEnumLike>(enumType: T, normalize?: (value: string) => string) => z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodArray<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodEnum<T>>>>;
+export {};