@decaf-ts/for-nest 0.7.0 → 0.9.0

package/lib/types/request/DecafHandlerExecutor.d.ts

@@ -1,52 +0,0 @@
-import { DecafRequestContext } from "./DecafRequestContext";
-import { type DecafRequestHandler } from "../types";
-/**
- * @description
- * Executes all registered {@link DecafRequestHandler} instances for the current request,
- * providing them with a shared {@link DecafRequestContext}.
- *
- * @summary
- * The {@link DecafHandlerExecutor} class is responsible for orchestrating and executing
- * a sequence of request handlers. Each handler receives the same request-scoped context,
- * allowing coordinated processing such as authentication, metadata extraction, auditing,
- * and custom pipeline behavior. Handlers are injected via the {@link DECAF_HANDLERS} token,
- * ensuring extensibility and loose coupling.
- *
- * @class DecafHandlerExecutor
- *
- * @example
- * ```ts
- * // Example handler:
- * class AuthHandler implements DecafRequestHandler {
- *   async handle(context: DecafRequestContext, req: Request) {
- *     const token = req.headers["authorization"];
- *     const result = MyService.doSomething(token);
- *     context.set("my-key", result);
- *   }
- * }
- *
- * // Executor usage in a request:
- * await executor.exec(request);
- * // All handlers will run in sequence
- * ```
- *
- * @mermaid
- * sequenceDiagram
- *     participant Client
- *     participant Executor
- *     participant HandlerA
- *     participant HandlerB
- *
- *     Client->>Executor: exec(req)
- *     Executor->>HandlerA: handle(context, req)
- *     HandlerA-->>Executor: completed
- *     Executor->>HandlerB: handle(context, req)
- *     HandlerB-->>Executor: completed
- *     Executor-->>Client: processing finished
- */
-export declare class DecafHandlerExecutor {
-    private readonly handlers;
-    private readonly context;
-    constructor(handlers: DecafRequestHandler[], context: DecafRequestContext);
-    exec(req: Request, res: Response): Promise<void>;
-}

package/lib/types/request/DecafRequestContext.d.ts

@@ -1,11 +0,0 @@
-import { DecafServerCtx } from "../constants";
-export declare class DecafRequestContext<C extends DecafServerCtx = DecafServerCtx> {
-    private readonly req;
-    private _ctx?;
-    uuid: string | Promise<string>;
-    constructor(req: Request);
-    get request(): Record<string | symbol, any>;
-    put(record: Record<any, any>): void;
-    applyCtx(ctx: C): void;
-    get ctx(): C;
-}

package/lib/types/request/DecafResponseInterceptor.d.ts

@@ -1,8 +0,0 @@
-import { NestInterceptor, ExecutionContext, CallHandler } from "@nestjs/common";
-import { Observable } from "rxjs";
-import { DecafRequestContext } from "./DecafRequestContext";
-export declare class DecafResponseInterceptor implements NestInterceptor {
-    protected ctx: DecafRequestContext;
-    constructor(ctx: DecafRequestContext);
-    intercept(context: ExecutionContext, next: CallHandler): Observable<any>;
-}

package/lib/types/request/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./DecafAuthHandler";
-export * from "./DecafRequestContext";
-export * from "./DecafHandlerExecutor";
-export * from "./DecafResponseInterceptor";

package/lib/types/types.d.ts

@@ -1,88 +0,0 @@
-import { Adapter, ConfigOf, ContextOf } from "@decaf-ts/core";
-import { Constructor } from "@decaf-ts/decoration";
-import { ExecutionContext, Type } from "@nestjs/common";
-import { RequestToContextTransformer } from "./interceptors/context";
-import { DecafRequestContext } from "./request/index";
-export interface DecafRequestHandler<C extends DecafRequestContext = DecafRequestContext> {
-    handle(context: C, req: Request, res: Response): Promise<void>;
-}
-export interface ObserverEventsOptions {
-    /**
-     * Enables or disables SSE stream events globally
-     */
-    enableObserverEvents?: boolean;
-    /**
-     * List of adapter flavours that will emit stream events
-     * If omitted, all registered flavours may be used
-     */
-    observerFlavours?: any[];
-    /**
-     * SSE endpoint path
-     * @default "/events"
-     */
-    observerApiPath?: string;
-}
-/**
- * @publicApi
- */
-export type DecafModuleOptions<CONF = any, A extends Adapter<CONF, any, any, any> = Adapter<CONF, any, any, any>> = {
-    conf: [
-        Constructor<A>,
-        ConfigOf<A>,
-        ...args: any[] | [
-            ...any[],
-            (RequestToContextTransformer<ContextOf<A>> | Constructor<RequestToContextTransformer<ContextOf<A>>>)
-        ]
-    ][];
-    alias?: string;
-    autoControllers: boolean;
-    autoServices?: boolean;
-    observerOptions?: ObserverEventsOptions;
-    aggregations?: boolean;
-    handlers?: Type<DecafRequestHandler>[];
-    initialization?: () => Promise<void>;
-};
-/**
- * Abstraction used by the {@link AuthInterceptor} to authorize decaf models.
- *
- * // costumauthHandler.ts
- *
- * @example
- * export class CustomAuthHandler implements AuthHandler {
- *   async authorize(ctx: ExecutionContext, resource: string) {
- *     const req = ctx.switchToHttp().getRequest();
- *     const userRole = req.headers.authorization?.split(" ")[1] as string;
- *     if (!userRole) throw new AuthorizationError("Unauthenticated");
- *     const roles = Metadata.get(Model.get(resource)!, AuthRole);
- *     if (!roles.includes(userRole)) {
- *       throw new AuthorizationError("Unauthorized");
- *     }
- *   }
- * }
- *
- * // auth.module.ts
- *
- * @Global()
- * @Module({
- *  providers: [
- *    AuthInterceptor,
- *    CustomAuthHandler,
- *    {
- *      provide: AUTH_HANDLER,
- *      useClass: CustomAuthHandler, //swap this to use another provider
- *    },
- *  ],
- *  exports: [AUTH_HANDLER, AuthInterceptor],
- * })
- * export class AuthModule {}
- */
-export interface AuthHandler {
-    /**
-     * Inspect the request context and ensure the caller can access the model.
-     * Implementations should throw an {@link AuthorizationError} on denial.
-     *
-     * @param ctx - Nest execution context that exposes the request/response.
-     * @param model - Model name or constructor being accessed.
-     */
-    authorize(ctx: ExecutionContext, model: string | Constructor): Promise<void> | void;
-}

package/lib/types/utils.d.ts

@@ -1,2 +0,0 @@
-import { Model } from "@decaf-ts/decorator-validation";
-export declare function repoForModel(model: string): import("@decaf-ts/core").Repo<Model<false>>;