@smounters/imperium 1.0.0

package/dist/decorators/guards.decorators.js

@@ -0,0 +1,8 @@
+import "reflect-metadata";
+import { appendArrayMetadata } from "./metadata.decorators";
+export const GUARDS_KEY = Symbol("guards");
+export function UseGuards(...guards) {
+    return (target, propertyKey) => {
+        appendArrayMetadata(GUARDS_KEY, guards, target, propertyKey);
+    };
+}

package/dist/decorators/http.decorators.d.ts

@@ -0,0 +1,16 @@
+import "reflect-metadata";
+export declare const HTTP_ROUTES_KEY: unique symbol;
+export declare const HTTP_CONTROLLER_KEY: unique symbol;
+export declare const PARAMS_KEY: unique symbol;
+export declare function HttpController(prefix?: string): ClassDecorator;
+export declare const Get: (path: string) => MethodDecorator;
+export declare const Post: (path: string) => MethodDecorator;
+export declare const Put: (path: string) => MethodDecorator;
+export declare const Patch: (path: string) => MethodDecorator;
+export declare const Delete: (path: string) => MethodDecorator;
+export declare const Body: (key?: string) => ParameterDecorator;
+export declare const Query: (key?: string) => ParameterDecorator;
+export declare const Param: (key?: string) => ParameterDecorator;
+export declare const Header: (key: string) => ParameterDecorator;
+export declare const Req: () => ParameterDecorator;
+export declare const Res: () => ParameterDecorator;

package/dist/decorators/http.decorators.js

@@ -0,0 +1,60 @@
+import "reflect-metadata";
+import { Injectable } from "./di.decorators";
+export const HTTP_ROUTES_KEY = Symbol("http:routes");
+export const HTTP_CONTROLLER_KEY = Symbol("http:controller");
+export const PARAMS_KEY = Symbol("http:params");
+export function HttpController(prefix = "") {
+    return (target) => {
+        Injectable()(target);
+        Reflect.defineMetadata(HTTP_CONTROLLER_KEY, { prefix }, target);
+    };
+}
+function methodDecorator(method) {
+    return (path) => {
+        return (target, propertyKey) => {
+            const existing = Reflect.getMetadata(HTTP_ROUTES_KEY, target.constructor) ?? [];
+            existing.push({
+                method,
+                path,
+                handlerName: propertyKey,
+            });
+            Reflect.defineMetadata(HTTP_ROUTES_KEY, existing, target.constructor);
+        };
+    };
+}
+export const Get = methodDecorator("GET");
+export const Post = methodDecorator("POST");
+export const Put = methodDecorator("PUT");
+export const Patch = methodDecorator("PATCH");
+export const Delete = methodDecorator("DELETE");
+function getMetaTarget(target, propertyKey) {
+    if (propertyKey === undefined) {
+        return target;
+    }
+    const value = target[propertyKey];
+    if (typeof value !== "object" && typeof value !== "function") {
+        throw new Error("Decorator target is not an object");
+    }
+    return value;
+}
+function setParamMeta(target, propertyKey, meta) {
+    const metaTarget = getMetaTarget(target, propertyKey);
+    const existing = Reflect.getMetadata(PARAMS_KEY, metaTarget);
+    const next = existing ? [...existing, meta] : [meta];
+    Reflect.defineMetadata(PARAMS_KEY, next, metaTarget);
+}
+function paramDecorator(source, key) {
+    return (target, propertyKey, index) => {
+        setParamMeta(target, propertyKey ?? undefined, {
+            index,
+            source,
+            key,
+        });
+    };
+}
+export const Body = (key) => paramDecorator("body", key);
+export const Query = (key) => paramDecorator("query", key);
+export const Param = (key) => paramDecorator("param", key);
+export const Header = (key) => paramDecorator("header", key);
+export const Req = () => paramDecorator("req");
+export const Res = () => paramDecorator("res");

package/dist/decorators/index.d.ts

@@ -0,0 +1,8 @@
+export { Inject, InjectAll, Injectable, Module, Optional, Scope } from "./di.decorators";
+export { Catch, UseFilters } from "./filters.decorators";
+export { UseGuards } from "./guards.decorators";
+export { Body, Delete, Get, Header, HttpController, Param, Patch, Post, Put, Query, Req, Res } from "./http.decorators";
+export { UseInterceptors } from "./interceptors.decorators";
+export { SetMetadata } from "./metadata.decorators";
+export { UsePipes } from "./pipes.decorators";
+export { RpcContext, RpcData, RpcHeader, RpcHeaders, RpcMethod, RpcService } from "./rpc.decorators";

package/dist/decorators/index.js

@@ -0,0 +1,8 @@
+export { Inject, InjectAll, Injectable, Module, Optional, Scope } from "./di.decorators";
+export { Catch, UseFilters } from "./filters.decorators";
+export { UseGuards } from "./guards.decorators";
+export { Body, Delete, Get, Header, HttpController, Param, Patch, Post, Put, Query, Req, Res } from "./http.decorators";
+export { UseInterceptors } from "./interceptors.decorators";
+export { SetMetadata } from "./metadata.decorators";
+export { UsePipes } from "./pipes.decorators";
+export { RpcContext, RpcData, RpcHeader, RpcHeaders, RpcMethod, RpcService } from "./rpc.decorators";

package/dist/decorators/interceptors.decorators.d.ts

@@ -0,0 +1,4 @@
+import "reflect-metadata";
+import type { InterceptorLike } from "../types";
+export declare const INTERCEPTORS_KEY: unique symbol;
+export declare function UseInterceptors(...inters: InterceptorLike[]): ClassDecorator & MethodDecorator;

package/dist/decorators/interceptors.decorators.js

@@ -0,0 +1,8 @@
+import "reflect-metadata";
+import { appendArrayMetadata } from "./metadata.decorators";
+export const INTERCEPTORS_KEY = Symbol("interceptors");
+export function UseInterceptors(...inters) {
+    return (target, propertyKey) => {
+        appendArrayMetadata(INTERCEPTORS_KEY, inters, target, propertyKey);
+    };
+}

package/dist/decorators/metadata.decorators.d.ts

@@ -0,0 +1,4 @@
+import "reflect-metadata";
+import type { MetadataKey } from "../types";
+export declare function SetMetadata<T = unknown>(metadataKey: MetadataKey, metadataValue: T): ClassDecorator & MethodDecorator;
+export declare function appendArrayMetadata<T>(metadataKey: MetadataKey, values: readonly T[], target: object, propertyKey?: string | symbol): void;

package/dist/decorators/metadata.decorators.js

@@ -0,0 +1,22 @@
+import "reflect-metadata";
+function getMetaTarget(target, propertyKey) {
+    if (propertyKey === undefined) {
+        return target;
+    }
+    const value = target[propertyKey];
+    if (typeof value !== "object" && typeof value !== "function") {
+        throw new Error("Decorator target is not an object");
+    }
+    return value;
+}
+export function SetMetadata(metadataKey, metadataValue) {
+    return (target, propertyKey) => {
+        const metaTarget = getMetaTarget(target, propertyKey);
+        Reflect.defineMetadata(metadataKey, metadataValue, metaTarget);
+    };
+}
+export function appendArrayMetadata(metadataKey, values, target, propertyKey) {
+    const metaTarget = getMetaTarget(target, propertyKey);
+    const prev = Reflect.getMetadata(metadataKey, metaTarget) ?? [];
+    Reflect.defineMetadata(metadataKey, [...prev, ...values], metaTarget);
+}

package/dist/decorators/pipes.decorators.d.ts

@@ -0,0 +1,4 @@
+import "reflect-metadata";
+import type { PipeLike } from "../types";
+export declare const PIPES_KEY: unique symbol;
+export declare function UsePipes(...pipes: PipeLike[]): ClassDecorator & MethodDecorator;

package/dist/decorators/pipes.decorators.js

@@ -0,0 +1,8 @@
+import "reflect-metadata";
+import { appendArrayMetadata } from "./metadata.decorators";
+export const PIPES_KEY = Symbol("pipes");
+export function UsePipes(...pipes) {
+    return (target, propertyKey) => {
+        appendArrayMetadata(PIPES_KEY, pipes, target, propertyKey);
+    };
+}

package/dist/decorators/rpc.decorators.d.ts

@@ -0,0 +1,11 @@
+import "reflect-metadata";
+import type { RpcMethodDescriptor, RpcServiceDescriptor } from "../core/types";
+export declare const RPC_SERVICE_KEY: unique symbol;
+export declare const RPC_METHODS_KEY: unique symbol;
+export declare const RPC_PARAMS_KEY: unique symbol;
+export declare function RpcService(service: RpcServiceDescriptor): ClassDecorator;
+export declare function RpcMethod(method: RpcMethodDescriptor): MethodDecorator;
+export declare const RpcData: (key?: string) => ParameterDecorator;
+export declare const RpcContext: () => ParameterDecorator;
+export declare const RpcHeaders: () => ParameterDecorator;
+export declare const RpcHeader: (key: string) => ParameterDecorator;

package/dist/decorators/rpc.decorators.js

@@ -0,0 +1,50 @@
+import "reflect-metadata";
+import { Injectable } from "./di.decorators";
+export const RPC_SERVICE_KEY = Symbol("rpc:service");
+export const RPC_METHODS_KEY = Symbol("rpc:methods");
+export const RPC_PARAMS_KEY = Symbol("rpc:params");
+export function RpcService(service) {
+    return (target) => {
+        Injectable()(target);
+        Reflect.defineMetadata(RPC_SERVICE_KEY, service, target);
+    };
+}
+export function RpcMethod(method) {
+    return (target, propertyKey) => {
+        const existing = Reflect.getMetadata(RPC_METHODS_KEY, target.constructor) ?? [];
+        existing.push({
+            method,
+            handlerName: propertyKey,
+        });
+        Reflect.defineMetadata(RPC_METHODS_KEY, existing, target.constructor);
+    };
+}
+function getMetaTarget(target, propertyKey) {
+    if (propertyKey === undefined) {
+        return target;
+    }
+    const value = target[propertyKey];
+    if (typeof value !== "object" && typeof value !== "function") {
+        throw new Error("Decorator target is not an object");
+    }
+    return value;
+}
+function setParamMeta(target, propertyKey, meta) {
+    const metaTarget = getMetaTarget(target, propertyKey);
+    const existing = Reflect.getMetadata(RPC_PARAMS_KEY, metaTarget);
+    const next = existing ? [...existing, meta] : [meta];
+    Reflect.defineMetadata(RPC_PARAMS_KEY, next, metaTarget);
+}
+function rpcParamDecorator(source, key) {
+    return (target, propertyKey, index) => {
+        setParamMeta(target, propertyKey ?? undefined, {
+            index,
+            source,
+            key,
+        });
+    };
+}
+export const RpcData = (key) => rpcParamDecorator("data", key);
+export const RpcContext = () => rpcParamDecorator("context");
+export const RpcHeaders = () => rpcParamDecorator("headers");
+export const RpcHeader = (key) => rpcParamDecorator("header", key);

package/dist/http/adapter.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyReply, FastifyRequest } from "fastify";
+import type { AppContainer } from "../core/container";
+import type { Constructor } from "../types";
+export declare function createHttpHandler<TController extends Record<string, unknown>>(app: AppContainer, controller: Constructor<TController>, methodName: keyof TController & string): (req: FastifyRequest, reply: FastifyReply) => Promise<void>;

package/dist/http/adapter.js

@@ -0,0 +1,199 @@
+import { LoggerService } from "../services";
+import { ForbiddenException, toHttpError } from "../core/errors";
+import { CATCH_EXCEPTIONS_KEY } from "../decorators/filters.decorators";
+import { PARAMS_KEY } from "../decorators/http.decorators";
+import { collectFiltersForHttp, collectGuardsForHttp, collectInterceptorsForHttp, collectPipesForHttp } from "./utils";
+function logHttpError(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] http_error", details, error);
+}
+function resolveEnhancer(scope, enhancer) {
+    if (typeof enhancer === "function") {
+        return scope.resolve(enhancer);
+    }
+    return enhancer;
+}
+function getRequestScope(req, app, controller) {
+    const request = req;
+    if (request.diScope?.isRegistered(controller, true)) {
+        return request.diScope;
+    }
+    const scope = app.createRequestScope(controller);
+    request.diScope = scope;
+    return scope;
+}
+function getPayloadValue(payload, key) {
+    if (!key) {
+        return payload;
+    }
+    if (!payload || typeof payload !== "object") {
+        return undefined;
+    }
+    return payload[key];
+}
+function buildArgs(req, reply, handler) {
+    const metas = Reflect.getMetadata(PARAMS_KEY, handler) ?? [];
+    if (!metas.length) {
+        return {
+            args: [req, reply],
+            metasByIndex: new Map(),
+        };
+    }
+    const args = [];
+    const metasByIndex = new Map();
+    for (const meta of metas) {
+        let value;
+        switch (meta.source) {
+            case "body":
+                value = getPayloadValue(req.body, meta.key);
+                break;
+            case "query":
+                value = getPayloadValue(req.query, meta.key);
+                break;
+            case "param":
+                value = getPayloadValue(req.params, meta.key);
+                break;
+            case "header":
+                value = meta.key ? req.headers[meta.key.toLowerCase()] : undefined;
+                break;
+            case "req":
+                value = req;
+                break;
+            case "res":
+                value = reply;
+                break;
+        }
+        args[meta.index] = value;
+        metasByIndex.set(meta.index, meta);
+    }
+    return { args, metasByIndex };
+}
+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 runHttpFilters(error, filters, ctx, reply) {
+    let currentError = error;
+    for (const filter of filters) {
+        if (!canHandleException(currentError, filter)) {
+            continue;
+        }
+        try {
+            const result = await filter.catch(currentError, ctx);
+            if (reply.sent) {
+                return { handled: true, error: currentError };
+            }
+            if (result !== undefined) {
+                reply.send(result);
+                return { handled: true, error: currentError };
+            }
+        }
+        catch (nextError) {
+            currentError = nextError;
+        }
+    }
+    return { handled: false, error: currentError };
+}
+export function createHttpHandler(app, controller, methodName) {
+    return async (req, reply) => {
+        const requestScope = getRequestScope(req, app, controller);
+        const handler = controller.prototype[methodName];
+        return app.runInRequestScope(requestScope, async () => {
+            const ctx = {
+                type: "http",
+                method: methodName,
+                fastify: { req, reply },
+                controller,
+                handler,
+                getType: () => "http",
+                getClass: () => controller,
+                getHandler: () => handler,
+                switchToHttp: () => ({
+                    getRequest: () => req,
+                    getResponse: () => reply,
+                }),
+                switchToRpc: () => ({
+                    getData: () => undefined,
+                    getContext: () => undefined,
+                }),
+            };
+            try {
+                const instance = requestScope.resolve(controller);
+                const guards = collectGuardsForHttp(controller, methodName, app.getGlobalGuards()).map((guardLike) => resolveEnhancer(requestScope, guardLike));
+                for (const guard of guards) {
+                    const ok = await guard.canActivate(ctx);
+                    if (!ok) {
+                        throw new ForbiddenException();
+                    }
+                }
+                const { args, metasByIndex } = buildArgs(req, reply, handler);
+                const pipes = collectPipesForHttp(controller, methodName, app.getGlobalPipes()).map((pipeLike) => resolveEnhancer(requestScope, pipeLike));
+                const transformedArgs = [...args];
+                for (const [index, meta] of metasByIndex) {
+                    if (meta.source === "req" || meta.source === "res") {
+                        continue;
+                    }
+                    let value = args[index];
+                    for (const pipe of pipes) {
+                        value = await pipe.transform(value, ctx);
+                    }
+                    transformedArgs[index] = value;
+                }
+                const interceptors = collectInterceptorsForHttp(controller, methodName, app.getGlobalInterceptors()).map((interceptorLike) => resolveEnhancer(requestScope, interceptorLike));
+                const controllerHandler = instance[methodName];
+                let idx = -1;
+                const next = async () => {
+                    idx++;
+                    if (idx < interceptors.length) {
+                        return interceptors[idx].intercept(ctx, next);
+                    }
+                    return controllerHandler(...transformedArgs);
+                };
+                const result = await next();
+                if (!reply.sent && result !== undefined) {
+                    reply.send(result);
+                }
+            }
+            catch (error) {
+                logHttpError(app, requestScope, {
+                    type: "http_error",
+                    method: req.method,
+                    url: req.url,
+                    controller: controller.name,
+                    handler: methodName,
+                }, error);
+                if (reply.sent) {
+                    return;
+                }
+                const filters = collectFiltersForHttp(controller, methodName, app.getGlobalFilters()).map((filterLike) => resolveEnhancer(requestScope, filterLike));
+                const filtered = await runHttpFilters(error, filters, ctx, reply);
+                if (filtered.handled || reply.sent) {
+                    return;
+                }
+                const mapped = toHttpError(filtered.error, {
+                    exposeInternalErrors: app.shouldExposeInternalErrors(),
+                });
+                reply.status(mapped.status).send(mapped.body);
+            }
+        });
+    };
+}

package/dist/http/index.d.ts

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

package/dist/http/index.js

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

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

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from "fastify";
+import "reflect-metadata";
+import type { AppContainer } from "../core/container";
+export declare function registerHttpRoutes(server: FastifyInstance, di: AppContainer, globalPrefix?: string): void;

package/dist/http/router-builder.js

@@ -0,0 +1,30 @@
+import "reflect-metadata";
+import { HTTP_CONTROLLER_KEY, HTTP_ROUTES_KEY } from "../decorators/http.decorators";
+import { createHttpHandler } from "./adapter";
+function joinUrlPath(...segments) {
+    const parts = segments
+        .map((segment) => segment.trim())
+        .filter((segment) => segment.length > 0 && segment !== "/")
+        .map((segment) => segment.replace(/^\/+|\/+$/g, ""));
+    if (parts.length === 0) {
+        return "/";
+    }
+    return `/${parts.join("/")}`;
+}
+export function registerHttpRoutes(server, di, globalPrefix = "") {
+    for (const ctrl of di.getHttpControllers()) {
+        // сузим тип конструктора контроллера
+        const controller = ctrl;
+        const meta = Reflect.getMetadata(HTTP_CONTROLLER_KEY, controller) ?? {
+            prefix: "",
+        };
+        const routes = Reflect.getMetadata(HTTP_ROUTES_KEY, controller) ?? [];
+        for (const r of routes) {
+            server.route({
+                method: r.method,
+                url: joinUrlPath(globalPrefix, meta.prefix, r.path),
+                handler: createHttpHandler(di, controller, r.handlerName),
+            });
+        }
+    }
+}

package/dist/http/utils.d.ts

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

package/dist/http/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 collectGuardsForHttp(controller, method, global) {
+    const local = readClassAndMethodMeta(GUARDS_KEY, controller, method);
+    return [...global, ...local];
+}
+export function collectInterceptorsForHttp(controller, method, global) {
+    const local = readClassAndMethodMeta(INTERCEPTORS_KEY, controller, method);
+    return uniqueByEnhancer([...global, ...local]);
+}
+export function collectPipesForHttp(controller, method, global) {
+    const local = readClassAndMethodMeta(PIPES_KEY, controller, method);
+    return [...global, ...local];
+}
+export function collectFiltersForHttp(controller, method, global) {
+    const local = readClassAndMethodMeta(FILTERS_KEY, controller, method);
+    return uniqueByEnhancer([...global, ...local]);
+}

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/pipes/index.d.ts

@@ -0,0 +1 @@
+export * from "./zod.pipe";

package/dist/pipes/index.js

@@ -0,0 +1 @@
+export * from "./zod.pipe";

package/dist/pipes/zod.pipe.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+import type { PipeTransform } from "../types";
+export declare class ZodPipe<TSchema extends z.ZodType> implements PipeTransform<unknown, z.infer<TSchema>> {
+    private schema;
+    constructor(schema: TSchema);
+    transform(value: unknown): z.infer<TSchema>;
+}

package/dist/pipes/zod.pipe.js

@@ -0,0 +1,8 @@
+export class ZodPipe {
+    constructor(schema) {
+        this.schema = schema;
+    }
+    transform(value) {
+        return this.schema.parse(value);
+    }
+}

package/dist/rpc/adapter.d.ts

@@ -0,0 +1,7 @@
+import type { HandlerContext } from "@connectrpc/connect";
+import "reflect-metadata";
+import type { AppContainer } from "../core/container";
+import type { Constructor } from "../types";
+type RpcResponse = Record<string, unknown>;
+export declare function createRpcHandler<TController extends Record<string, unknown>>(app: AppContainer, controller: Constructor<TController>, methodName: keyof TController & string): (req: unknown, context: HandlerContext) => Promise<RpcResponse>;
+export {};