@decaf-ts/integrations 0.3.6 → 0.3.7

package/lib/esm/nest/graph/GraphExecutionController.js

@@ -0,0 +1,144 @@
+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); }
+};
+/**
+ * @module integrations/nest/graph/GraphExecutionController
+ * @summary NestJS controller bridging the graph execution engine to REST + SSE.
+ * @description Exposes three endpoints:
+ * - `POST /graph/execute` — triggers {@link GraphExecutionEngine.execute}, persists the result via a Decaf repository, and returns `{ runId, status, outputs }`.
+ * - `GET /graph/events` — SSE endpoint streaming {@link GraphExecutionEvent}s as `[modelName, operation, id, payload]` tuples (compatible with for-http's `ServerEventConnector`).
+ * - `GET /graph/results/:runId` — retrieves a persisted {@link GraphExecutionResultModel} from the repository.
+ *
+ * This is the production pattern: for-nest hosts the engine, for-angular consumes events over the network via SSE and fetches persisted results via REST.
+ */
+import { Controller, Post, Get, Body, Param, Sse, Inject, NotFoundException, } from "@nestjs/common";
+import { Subject, Observable } from "rxjs";
+import { map } from "rxjs/operators";
+import { GraphExecutionEngine, } from "./../../graph/index.js";
+import { fromResultModel, toResultModel, } from "./GraphExecutionResultRepository.js";
+/**
+ * NestJS injection token for the graph execution result repository.
+ */
+export const GRAPH_RESULT_REPOSITORY = "GRAPH_RESULT_REPOSITORY";
+/**
+ * NestJS controller that hosts the graph execution engine server-side,
+ * streams events via SSE, and persists results for later retrieval.
+ */
+let GraphExecutionController = class GraphExecutionController {
+    constructor(engine, resultRepository) {
+        this.engine = engine;
+        this.resultRepository = resultRepository;
+        this.eventSubject = new Subject();
+        this.engine.observe({
+            refresh: async (event) => {
+                this.eventSubject.next(event);
+            },
+        });
+    }
+    /**
+     * Triggers graph execution server-side, persists the result, and returns
+     * a summary containing the `runId`, `status`, and `outputs`.
+     */
+    async execute(body) {
+        const result = await this.engine.execute(body.workflow, body.inputs ?? {});
+        try {
+            await this.resultRepository.create(toResultModel(result));
+        }
+        catch {
+            // persistence failures must not mask a successful execution result
+        }
+        return {
+            runId: result.runId,
+            status: result.status,
+            outputs: result.outputs,
+        };
+    }
+    /**
+     * SSE endpoint that streams graph execution events.
+     *
+     * Events are serialized as `[modelName, operation, id, payload]` to match
+     * the format expected by for-http's `ServerEventConnector`.
+     */
+    events() {
+        return this.eventSubject.asObservable().pipe(map((event) => ({
+            type: "message",
+            data: JSON.stringify([
+                "graph",
+                event.type,
+                event.runId,
+                {
+                    id: event.id,
+                    sequence: event.sequence,
+                    type: event.type,
+                    runId: event.runId,
+                    parentRunId: event.parentRunId,
+                    workflowId: event.workflowId,
+                    nodeId: event.nodeId,
+                    edgeId: event.edgeId,
+                    port: event.port,
+                    iteration: event.iteration,
+                    path: event.path,
+                    status: event.status,
+                    payload: event.payload,
+                    error: event.error,
+                    timestamp: event.timestamp.toISOString(),
+                },
+            ]),
+        })));
+    }
+    /**
+     * Retrieves a persisted graph execution result by its `runId`.
+     *
+     * @throws {NotFoundException} when no result is stored for the given `runId`.
+     */
+    async getResult(runId) {
+        let model;
+        try {
+            model = (await this.resultRepository.read(runId));
+        }
+        catch {
+            model = null;
+        }
+        const result = fromResultModel(model);
+        if (!result) {
+            throw new NotFoundException(`No graph execution result found for runId '${runId}'`);
+        }
+        return result;
+    }
+};
+__decorate([
+    Post("execute"),
+    __param(0, Body()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], GraphExecutionController.prototype, "execute", null);
+__decorate([
+    Sse("events"),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Observable)
+], GraphExecutionController.prototype, "events", null);
+__decorate([
+    Get("results/:runId"),
+    __param(0, Param("runId")),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], GraphExecutionController.prototype, "getResult", null);
+GraphExecutionController = __decorate([
+    Controller("graph"),
+    __param(1, Inject(GRAPH_RESULT_REPOSITORY)),
+    __metadata("design:paramtypes", [GraphExecutionEngine, Object])
+], GraphExecutionController);
+export { GraphExecutionController };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"GraphExecutionController.js","sourceRoot":"","sources":["../../../../src/nest/graph/GraphExecutionController.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA;;;;;;;;;GASG;AACH,OAAO,EACL,UAAU,EACV,IAAI,EACJ,GAAG,EACH,IAAI,EACJ,KAAK,EACL,GAAG,EAEH,MAAM,EACN,iBAAiB,GAClB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAC3C,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAErC,OAAO,EACL,oBAAoB,GAGrB,+BAAoB;AAGrB,OAAO,EACL,eAAe,EACf,aAAa,GAEd,4CAAyC;AAG1C;;GAEG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,yBAAyB,CAAC;AAmBjE;;;GAGG;AAEI,IAAM,wBAAwB,GAA9B,MAAM,wBAAwB;IAGnC,YACmB,MAA4B,EAE7C,gBAAyE;QAFxD,WAAM,GAAN,MAAM,CAAsB;QAE5B,qBAAgB,GAAhB,gBAAgB,CAAwC;QAL1D,iBAAY,GAAG,IAAI,OAAO,EAAuB,CAAC;QAOjE,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC;YAClB,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE;gBACvB,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAChC,CAAC;SACF,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IAEG,AAAN,KAAK,CAAC,OAAO,CACH,IAAyB;QAEjC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC;QAE3E,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC;QAC5D,CAAC;QAAC,MAAM,CAAC;YACP,mEAAmE;QACrE,CAAC;QAED,OAAO;YACL,KAAK,EAAE,MAAM,CAAC,KAAK;YACnB,MAAM,EAAE,MAAM,CAAC,MAAM;YACrB,OAAO,EAAE,MAAM,CAAC,OAAO;SACxB,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IAEH,MAAM;QACJ,OAAO,IAAI,CAAC,YAAY,CAAC,YAAY,EAAE,CAAC,IAAI,CAC1C,GAAG,CACD,CAAC,KAA0B,EAAgB,EAAE,CAAC,CAAC;YAC7C,IAAI,EAAE,SAAS;YACf,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC;gBACnB,OAAO;gBACP,KAAK,CAAC,IAAI;gBACV,KAAK,CAAC,KAAK;gBACX;oBACE,EAAE,EAAE,KAAK,CAAC,EAAE;oBACZ,QAAQ,EAAE,KAAK,CAAC,QAAQ;oBACxB,IAAI,EAAE,KAAK,CAAC,IAAI;oBAChB,KAAK,EAAE,KAAK,CAAC,KAAK;oBAClB,WAAW,EAAE,KAAK,CAAC,WAAW;oBAC9B,UAAU,EAAE,KAAK,CAAC,UAAU;oBAC5B,MAAM,EAAE,KAAK,CAAC,MAAM;oBACpB,MAAM,EAAE,KAAK,CAAC,MAAM;oBACpB,IAAI,EAAE,KAAK,CAAC,IAAI;oBAChB,SAAS,EAAE,KAAK,CAAC,SAAS;oBAC1B,IAAI,EAAE,KAAK,CAAC,IAAI;oBAChB,MAAM,EAAE,KAAK,CAAC,MAAM;oBACpB,OAAO,EAAE,KAAK,CAAC,OAAO;oBACtB,KAAK,EAAE,KAAK,CAAC,KAAK;oBAClB,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC,WAAW,EAAE;iBACzC;aACF,CAAC;SACH,CAAC,CACH,CACF,CAAC;IACJ,CAAC;IAED;;;;OAIG;IAEG,AAAN,KAAK,CAAC,SAAS,CAAiB,KAAa;QAC3C,IAAI,KAAuC,CAAC;QAC5C,IAAI,CAAC;YACH,KAAK,GAAG,CAAC,MAAM,IAAI,CAAC,gBAAgB,CAAC,IAAI,CACvC,KAAK,CACN,CAAqC,CAAC;QACzC,CAAC;QAAC,MAAM,CAAC;YACP,KAAK,GAAG,IAAI,CAAC;QACf,CAAC;QACD,MAAM,MAAM,GAAG,eAAe,CAAC,KAAK,CAAC,CAAC;QACtC,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,IAAI,iBAAiB,CACzB,8CAA8C,KAAK,GAAG,CACvD,CAAC;QACJ,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;CACF,CAAA;AAhFO;IADL,IAAI,CAAC,SAAS,CAAC;IAEb,WAAA,IAAI,EAAE,CAAA;;;;uDAeR;AASD;IADC,GAAG,CAAC,QAAQ,CAAC;;;oCACJ,UAAU;sDA8BnB;AAQK;IADL,GAAG,CAAC,gBAAgB,CAAC;IACL,WAAA,KAAK,CAAC,OAAO,CAAC,CAAA;;;;yDAgB9B;AAnGU,wBAAwB;IADpC,UAAU,CAAC,OAAO,CAAC;IAMf,WAAA,MAAM,CAAC,uBAAuB,CAAC,CAAA;qCADP,oBAAoB;GAJpC,wBAAwB,CAoGpC","sourcesContent":["/**\n * @module integrations/nest/graph/GraphExecutionController\n * @summary NestJS controller bridging the graph execution engine to REST + SSE.\n * @description Exposes three endpoints:\n * - `POST /graph/execute` — triggers {@link GraphExecutionEngine.execute}, persists the result via a Decaf repository, and returns `{ runId, status, outputs }`.\n * - `GET /graph/events` — SSE endpoint streaming {@link GraphExecutionEvent}s as `[modelName, operation, id, payload]` tuples (compatible with for-http's `ServerEventConnector`).\n * - `GET /graph/results/:runId` — retrieves a persisted {@link GraphExecutionResultModel} from the repository.\n *\n * This is the production pattern: for-nest hosts the engine, for-angular consumes events over the network via SSE and fetches persisted results via REST.\n */\nimport {\n  Controller,\n  Post,\n  Get,\n  Body,\n  Param,\n  Sse,\n  MessageEvent,\n  Inject,\n  NotFoundException,\n} from \"@nestjs/common\";\nimport { Subject, Observable } from \"rxjs\";\nimport { map } from \"rxjs/operators\";\n\nimport {\n  GraphExecutionEngine,\n  type GraphExecutionEvent,\n  type GraphExecutionValues,\n} from \"../../graph\";\nimport type { GraphWorkflowDefinition } from \"@decaf-ts/ui-decorators/graph\";\n\nimport {\n  fromResultModel,\n  toResultModel,\n  type GraphExecutionResultRepositoryInstance,\n} from \"./GraphExecutionResultRepository\";\nimport type { GraphExecutionResultModel } from \"./GraphExecutionResultModel\";\n\n/**\n * NestJS injection token for the graph execution result repository.\n */\nexport const GRAPH_RESULT_REPOSITORY = \"GRAPH_RESULT_REPOSITORY\";\n\n/**\n * Payload for the `POST /graph/execute` endpoint.\n */\nexport interface GraphExecutePayload {\n  workflow: GraphWorkflowDefinition;\n  inputs: GraphExecutionValues;\n}\n\n/**\n * Response shape for the `POST /graph/execute` endpoint.\n */\nexport interface GraphExecuteResponse {\n  runId: string;\n  status: string;\n  outputs: Record<string, unknown>;\n}\n\n/**\n * NestJS controller that hosts the graph execution engine server-side,\n * streams events via SSE, and persists results for later retrieval.\n */\n@Controller(\"graph\")\nexport class GraphExecutionController {\n  private readonly eventSubject = new Subject<GraphExecutionEvent>();\n\n  constructor(\n    private readonly engine: GraphExecutionEngine,\n    @Inject(GRAPH_RESULT_REPOSITORY)\n    private readonly resultRepository: GraphExecutionResultRepositoryInstance\n  ) {\n    this.engine.observe({\n      refresh: async (event) => {\n        this.eventSubject.next(event);\n      },\n    });\n  }\n\n  /**\n   * Triggers graph execution server-side, persists the result, and returns\n   * a summary containing the `runId`, `status`, and `outputs`.\n   */\n  @Post(\"execute\")\n  async execute(\n    @Body() body: GraphExecutePayload\n  ): Promise<GraphExecuteResponse> {\n    const result = await this.engine.execute(body.workflow, body.inputs ?? {});\n\n    try {\n      await this.resultRepository.create(toResultModel(result));\n    } catch {\n      // persistence failures must not mask a successful execution result\n    }\n\n    return {\n      runId: result.runId,\n      status: result.status,\n      outputs: result.outputs,\n    };\n  }\n\n  /**\n   * SSE endpoint that streams graph execution events.\n   *\n   * Events are serialized as `[modelName, operation, id, payload]` to match\n   * the format expected by for-http's `ServerEventConnector`.\n   */\n  @Sse(\"events\")\n  events(): Observable<MessageEvent> {\n    return this.eventSubject.asObservable().pipe(\n      map(\n        (event: GraphExecutionEvent): MessageEvent => ({\n          type: \"message\",\n          data: JSON.stringify([\n            \"graph\",\n            event.type,\n            event.runId,\n            {\n              id: event.id,\n              sequence: event.sequence,\n              type: event.type,\n              runId: event.runId,\n              parentRunId: event.parentRunId,\n              workflowId: event.workflowId,\n              nodeId: event.nodeId,\n              edgeId: event.edgeId,\n              port: event.port,\n              iteration: event.iteration,\n              path: event.path,\n              status: event.status,\n              payload: event.payload,\n              error: event.error,\n              timestamp: event.timestamp.toISOString(),\n            },\n          ]),\n        })\n      )\n    );\n  }\n\n  /**\n   * Retrieves a persisted graph execution result by its `runId`.\n   *\n   * @throws {NotFoundException} when no result is stored for the given `runId`.\n   */\n  @Get(\"results/:runId\")\n  async getResult(@Param(\"runId\") runId: string): Promise<unknown> {\n    let model: GraphExecutionResultModel | null;\n    try {\n      model = (await this.resultRepository.read(\n        runId\n      )) as GraphExecutionResultModel | null;\n    } catch {\n      model = null;\n    }\n    const result = fromResultModel(model);\n    if (!result) {\n      throw new NotFoundException(\n        `No graph execution result found for runId '${runId}'`\n      );\n    }\n    return result;\n  }\n}\n"]}

package/lib/esm/nest/graph/GraphExecutionModule.js

@@ -0,0 +1,76 @@
+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 GraphExecutionModule_1;
+/**
+ * @module integrations/nest/graph/GraphExecutionModule
+ * @summary NestJS DynamicModule hosting the graph execution engine.
+ * @description Wires the {@link GraphExecutionEngine}, a demo executor registry, a RamAdapter-backed result repository, and the {@link GraphExecutionController} into a single NestJS module. Use `GraphExecutionModule.forRoot()` to register it in the application.
+ */
+import { Module } from "@nestjs/common";
+import { Adapter, Repository } from "@decaf-ts/core";
+import { RamAdapter, RamFlavour } from "@decaf-ts/core/ram";
+import { GraphExecutionEngine } from "./../../graph/index.js";
+import { createGraphExecutorRegistry } from "./GraphExecutorRegistryFactory.js";
+import { GraphExecutionResultModel } from "./GraphExecutionResultModel.js";
+import { GRAPH_RESULT_REPOSITORY, GraphExecutionController, } from "./GraphExecutionController.js";
+/**
+ * NestJS module that hosts the graph execution engine server-side.
+ *
+ * Provides:
+ * - {@link GraphExecutionEngine} — singleton engine with a demo executor registry.
+ * - `GRAPH_RESULT_REPOSITORY` — Decaf repository for {@link GraphExecutionResultModel} backed by RamAdapter.
+ * - {@link GraphExecutionController} — REST + SSE controller.
+ */
+let GraphExecutionModule = GraphExecutionModule_1 = class GraphExecutionModule {
+    /**
+     * Creates a configured {@link DynamicModule} for the graph execution backend.
+     *
+     * @param options - Module configuration options.
+     * @returns A NestJS `DynamicModule` ready for import.
+     */
+    static forRoot(options = {}) {
+        const user = options.adapterUser ?? "graph-engine";
+        const initAdapter = options.initAdapter ?? true;
+        const providers = [
+            {
+                provide: GraphExecutionEngine,
+                useFactory: () => {
+                    if (initAdapter) {
+                        RamAdapter.decoration();
+                        Adapter.setCurrent(RamFlavour);
+                    }
+                    const registry = createGraphExecutorRegistry();
+                    return new GraphExecutionEngine({ registry });
+                },
+            },
+            {
+                provide: GRAPH_RESULT_REPOSITORY,
+                useFactory: () => {
+                    if (initAdapter) {
+                        RamAdapter.decoration();
+                        Adapter.setCurrent(RamFlavour);
+                    }
+                    // Creating the adapter ensures a Ram-flavoured instance is available
+                    // for Repository.forModel. The adapter user is used by audit handlers.
+                    new RamAdapter({ user });
+                    return Repository.forModel(GraphExecutionResultModel);
+                },
+            },
+        ];
+        return {
+            module: GraphExecutionModule_1,
+            controllers: [GraphExecutionController],
+            providers,
+            exports: [GraphExecutionEngine, GRAPH_RESULT_REPOSITORY],
+        };
+    }
+};
+GraphExecutionModule = GraphExecutionModule_1 = __decorate([
+    Module({})
+], GraphExecutionModule);
+export { GraphExecutionModule };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/nest/graph/GraphExecutionResultModel.js

@@ -0,0 +1,73 @@
+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);
+};
+/**
+ * @module integrations/nest/graph/GraphExecutionResultModel
+ * @summary Decaf model for persisting graph execution results.
+ * @description Serializes a {@link GraphExecutionResult} for storage in a Decaf persistence adapter (e.g. RamAdapter). Stores the run id, workflow id, status, inputs, outputs, per-node results, and timing information so clients can retrieve a completed run's full state via `GET /graph/results/:runId`.
+ */
+import { Model, model } from "@decaf-ts/decorator-validation";
+import { column, pk, table } from "@decaf-ts/core";
+import { uses } from "@decaf-ts/decoration";
+/**
+ * Ram flavour identifier. Duplicated here to avoid the side-effect import of
+ * `@decaf-ts/core/ram` (which calls `RamAdapter.decoration()` at module load
+ * time and can interfere with other modules' metadata initialisation).
+ */
+const RAM_FLAVOUR = "ram";
+/**
+ * Persisted representation of a completed graph execution run.
+ *
+ * Stored in the `graph_execution_result` table and keyed by `runId`.
+ */
+let GraphExecutionResultModel = class GraphExecutionResultModel extends Model {
+    constructor(arg) {
+        super(arg);
+    }
+};
+__decorate([
+    pk({ type: String, generated: false }),
+    __metadata("design:type", String)
+], GraphExecutionResultModel.prototype, "runId", void 0);
+__decorate([
+    column(),
+    __metadata("design:type", String)
+], GraphExecutionResultModel.prototype, "workflowId", void 0);
+__decorate([
+    column(),
+    __metadata("design:type", String)
+], GraphExecutionResultModel.prototype, "status", void 0);
+__decorate([
+    column(),
+    __metadata("design:type", Object)
+], GraphExecutionResultModel.prototype, "inputs", void 0);
+__decorate([
+    column(),
+    __metadata("design:type", Object)
+], GraphExecutionResultModel.prototype, "outputs", void 0);
+__decorate([
+    column(),
+    __metadata("design:type", Object)
+], GraphExecutionResultModel.prototype, "nodeResults", void 0);
+__decorate([
+    column(),
+    __metadata("design:type", Date)
+], GraphExecutionResultModel.prototype, "startedAt", void 0);
+__decorate([
+    column(),
+    __metadata("design:type", Date)
+], GraphExecutionResultModel.prototype, "finishedAt", void 0);
+GraphExecutionResultModel = __decorate([
+    uses(RAM_FLAVOUR),
+    table("graph_execution_result"),
+    model(),
+    __metadata("design:paramtypes", [Object])
+], GraphExecutionResultModel);
+export { GraphExecutionResultModel };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/nest/graph/GraphExecutionResultRepository.js

@@ -0,0 +1,60 @@
+/**
+ * @module integrations/nest/graph/GraphExecutionResultRepository
+ * @summary Repository for persisting and retrieving graph execution results.
+ * @description Provides a typed handle to a Decaf {@link Repository} backed by RamAdapter, with convenience methods for saving and loading {@link GraphExecutionResultModel} records. The repository is created via `Repository.forModel()` so it inherits all standard Decaf CRUD operations.
+ */
+import { Repository } from "@decaf-ts/core";
+import { GraphExecutionResultModel } from "./GraphExecutionResultModel.js";
+/**
+ * Creates a Decaf repository for {@link GraphExecutionResultModel}.
+ *
+ * The caller must ensure the RamAdapter has been initialised and set as the
+ * current adapter (via `RamAdapter.decoration()` and `Adapter.setCurrent()`)
+ * before invoking this factory.
+ *
+ * @returns A Decaf repository instance for {@link GraphExecutionResultModel}.
+ */
+export function createGraphExecutionResultRepository() {
+    return Repository.forModel(GraphExecutionResultModel);
+}
+/**
+ * Converts a {@link GraphExecutionResult} into a persistable
+ * {@link GraphExecutionResultModel}.
+ *
+ * @param result - The execution result to convert.
+ * @returns A model instance ready for persistence.
+ */
+export function toResultModel(result) {
+    return new GraphExecutionResultModel({
+        runId: result.runId,
+        workflowId: result.workflowId,
+        status: result.status,
+        inputs: result.inputs,
+        outputs: result.outputs,
+        nodeResults: result.nodeResults,
+        startedAt: result.startedAt,
+        finishedAt: result.finishedAt,
+    });
+}
+/**
+ * Converts a persisted {@link GraphExecutionResultModel} back into a plain
+ * result-like object suitable for API responses.
+ *
+ * @param model - The persisted model (or `null` if not found).
+ * @returns A plain object with the result fields, or `null`.
+ */
+export function fromResultModel(model) {
+    if (!model)
+        return null;
+    return {
+        runId: model.runId,
+        workflowId: model.workflowId,
+        status: model.status,
+        inputs: model.inputs,
+        outputs: model.outputs,
+        nodeResults: model.nodeResults,
+        startedAt: model.startedAt,
+        finishedAt: model.finishedAt,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/nest/graph/GraphExecutorRegistryFactory.js

@@ -0,0 +1,31 @@
+/**
+ * @module integrations/nest/graph/GraphExecutorRegistryFactory
+ * @summary Factory that builds a populated {@link GraphNodeExecutorRegistry}.
+ * @description Creates a registry pre-loaded with the demo executors (`math.add`, `math.multiply`) used by the graph execution backend's sample workflows. Additional executors can be registered on the returned registry before it is handed to the {@link GraphExecutionEngine}.
+ */
+import { GraphNodeExecutorRegistry } from "./../../graph/index.js";
+/**
+ * Builds a {@link GraphNodeExecutorRegistry} populated with the demo executors.
+ *
+ * Registered kinds:
+ * - `math.add` — sums `a` and `b` into `sum`.
+ * - `math.multiply` — multiplies `x` by 2 into `product`.
+ *
+ * @returns A populated registry ready for use with {@link GraphExecutionEngine}.
+ */
+export function createGraphExecutorRegistry(extra) {
+    const registry = new GraphNodeExecutorRegistry();
+    registry.register("math.add", {
+        execute: (input) => ({ sum: Number(input.a) + Number(input.b) }),
+    });
+    registry.register("math.multiply", {
+        execute: (input) => ({ product: Number(input.x) * 2 }),
+    });
+    if (extra) {
+        for (const [kind, executor] of Object.entries(extra)) {
+            registry.register(kind, executor);
+        }
+    }
+    return registry;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/nest/graph/index.js

@@ -0,0 +1,11 @@
+/**
+ * @module integrations/nest/graph
+ * @summary NestJS graph execution backend module.
+ * @description Server-side hosting for the Decaf graph execution engine. Exposes REST endpoints for triggering execution and retrieving persisted results, plus an SSE endpoint for streaming execution events. Designed to be consumed by for-angular via for-http's `ServerEventConnector`.
+ */
+export * from "./GraphExecutionResultModel.js";
+export * from "./GraphExecutionResultRepository.js";
+export * from "./GraphExecutorRegistryFactory.js";
+export * from "./GraphExecutionController.js";
+export * from "./GraphExecutionModule.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbmVzdC9ncmFwaC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBRUgsK0NBQTRDO0FBQzVDLG9EQUFpRDtBQUNqRCxrREFBK0M7QUFDL0MsOENBQTJDO0FBQzNDLDBDQUF1QyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQG1vZHVsZSBpbnRlZ3JhdGlvbnMvbmVzdC9ncmFwaFxuICogQHN1bW1hcnkgTmVzdEpTIGdyYXBoIGV4ZWN1dGlvbiBiYWNrZW5kIG1vZHVsZS5cbiAqIEBkZXNjcmlwdGlvbiBTZXJ2ZXItc2lkZSBob3N0aW5nIGZvciB0aGUgRGVjYWYgZ3JhcGggZXhlY3V0aW9uIGVuZ2luZS4gRXhwb3NlcyBSRVNUIGVuZHBvaW50cyBmb3IgdHJpZ2dlcmluZyBleGVjdXRpb24gYW5kIHJldHJpZXZpbmcgcGVyc2lzdGVkIHJlc3VsdHMsIHBsdXMgYW4gU1NFIGVuZHBvaW50IGZvciBzdHJlYW1pbmcgZXhlY3V0aW9uIGV2ZW50cy4gRGVzaWduZWQgdG8gYmUgY29uc3VtZWQgYnkgZm9yLWFuZ3VsYXIgdmlhIGZvci1odHRwJ3MgYFNlcnZlckV2ZW50Q29ubmVjdG9yYC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tIFwiLi9HcmFwaEV4ZWN1dGlvblJlc3VsdE1vZGVsXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9HcmFwaEV4ZWN1dGlvblJlc3VsdFJlcG9zaXRvcnlcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0dyYXBoRXhlY3V0b3JSZWdpc3RyeUZhY3RvcnlcIjtcbmV4cG9ydCAqIGZyb20gXCIuL0dyYXBoRXhlY3V0aW9uQ29udHJvbGxlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vR3JhcGhFeGVjdXRpb25Nb2R1bGVcIjtcbiJdfQ==

package/lib/esm/nest/index.js

@@ -3,6 +3,7 @@ export * from "./utils.js";
 export * from "./authService.js";
 export * from "./keycloakAuthHandler.js";
 export * from "./keycloakModule.js";
+export * from "./graph/index.js";
 import "./logging.js";
 /**
  * @summary Nest-style auth integrations.
@@ -11,4 +12,4 @@ import "./logging.js";
  * @namespace nest
  * @memberOf module:integrations
  */
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbmVzdC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQkFBd0I7QUFDeEIsMkJBQXdCO0FBQ3hCLGlDQUE4QjtBQUM5Qix5Q0FBc0M7QUFDdEMsb0NBQWlDO0FBQ2pDLGlDQUF3QjtBQUV4QixzQkFBbUI7QUFFbkI7Ozs7OztHQU1HIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vdHlwZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3V0aWxzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9hdXRoU2VydmljZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4va2V5Y2xvYWtBdXRoSGFuZGxlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4va2V5Y2xvYWtNb2R1bGVcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2dyYXBoXCI7XG5cbmltcG9ydCBcIi4vbG9nZ2luZ1wiO1xuXG4vKipcbiAqIEBzdW1tYXJ5IE5lc3Qtc3R5bGUgYXV0aCBpbnRlZ3JhdGlvbnMuXG4gKiBAZGVzY3JpcHRpb24gRnJhbWV3b3JrLWFnbm9zdGljIGF1dGggaGVscGVycyBjb21wYXRpYmxlIHdpdGggRGVjYWYgcmVxdWVzdCBjb250ZXh0IGhhbmRsaW5nLlxuICogSW1wb3J0cyB0aGUgYHVzZXJgL2Bvcmdhbml6YXRpb25gIGxvZyBwYXJhbWV0ZXIgcmVnaXN0cmF0aW9ucyBhcyBhIHNpZGUgZWZmZWN0LlxuICogQG5hbWVzcGFjZSBuZXN0XG4gKiBAbWVtYmVyT2YgbW9kdWxlOmludGVncmF0aW9uc1xuICovXG4iXX0=

package/lib/esm/nest/keycloakAuthHandler.js

@@ -62,4 +62,4 @@ function resolveOrganization(payload, token) {
     return getRealmFromIssuer(token);
 }
 export { getClientRoles };
-//# sourceMappingURL=keycloakAuthHandler.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keycloakAuthHandler.js","sourceRoot":"","sources":["../../../src/nest/keycloakAuthHandler.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,kBAAkB,EAA2B,MAAM,gBAAgB,CAAC;AAC7E,OAAO,EAAE,WAAW,EAAY,MAAM,2BAA2B,CAAC;AAElE,OAAO,EAAE,WAAW,EAA2B,yBAAsB;AAErE,OAAO,EACL,kBAAkB,EAClB,eAAe,EACf,oBAAoB,EACpB,cAAc,GACf,mBAAgB;AAejB,MAAM,OAAO,mBAAoB,SAAQ,WAIxC;IACC;;;;;;OAMG;IACH,YACE,WAAyB,EACzB,kBAAuC;QAEvC,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,WAAW;YACd,WAAW,IAAI,IAAI,WAAW,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC;IAC7D,CAAC;IAIS,eAAe,CAAC,GAA6B;QACrD,MAAM,OAAO,GAAG,GAAG,CAAC,YAAY,EAAE,CAAC,UAAU,EAAmB,CAAC;QAEjE,IAAI,aAAa,CAAC,OAAO,CAAC,EAAE,CAAC;YAC3B,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;QAClD,CAAC;QAED,MAAM,KAAK,GAAG,QAAQ,CAAC,OAAO,CAAC,CAAC;QAChC,IAAI,CAAC,KAAK;YAAE,MAAM,IAAI,kBAAkB,CAAC,iBAAiB,CAAC,CAAC;QAE5D,iDAAiD;QACjD,MAAM,OAAO,GAAG,eAAe,CAAC,KAAK,CAAC,CAAC;QACvC,MAAM,KAAK,GAAG,oBAAoB,CAAC,OAAO,CAAC,CAAC;QAC5C,MAAM,YAAY,GAAG,mBAAmB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QACzD,MAAM,IAAI,GAAG,OAAO,EAAE,KAAK,IAAI,OAAO,EAAE,kBAAkB,CAAC;QAE3D,OAAO,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;IAC/D,CAAC;IAED;;;;OAIG;IACgB,KAAK,CAAC,QAAQ,CAC/B,IAAsB,EACtB,UAAgC,EAChC,KAA2B,EAC3B,GAAG,IAA6B;QAEhC,IAAI,IAAI,CAAC,QAAQ;YAAE,OAAO;QAC1B,MAAM,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACpD,MAAM,KAAK,CAAC,QAAQ,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,GAAG,IAAI,CAAC,CAAC;IACzD,CAAC;CACF;AAED,SAAS,aAAa,CAAC,GAAoB;IACzC,IAAI,GAAG,CAAC,IAAI,EAAE,UAAU,CAAC,SAAS,CAAC;QAAE,OAAO,IAAI,CAAC;IACjD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,QAAQ,CAAC,GAAoB;IACpC,MAAM,KAAK,GAAG,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,6BAA6B,CAAC;QACzD,GAAG,CAAC,OAAO,EAAE,CAAC,eAAe,CAAC,CAAuB,CAAC;IACxD,IAAI,CAAC,KAAK;QAAE,OAAO,SAAS,CAAC;IAC7B,OAAO,KAAK,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;AAC7E,CAAC;AAED,SAAS,mBAAmB,CAC1B,OAA8C,EAC9C,KAAa;IAEb,IAAI,OAAO,EAAE,GAAG;QAAE,OAAO,OAAO,CAAC,GAAG,CAAC;IACrC,IAAI,OAAO,EAAE,GAAG;QAAE,OAAO,OAAO,CAAC,GAAG,CAAC;IACrC,OAAO,kBAAkB,CAAC,KAAK,CAAC,CAAC;AACnC,CAAC;AAED,OAAO,EAAE,cAAc,EAAE,CAAC","sourcesContent":["/**\n * @module integrations/nest/keycloakAuthHandler\n * @summary Keycloak request auth handler.\n * @description Translates Keycloak JWT payloads into Decaf-friendly auth data.\n * Extends the framework-agnostic {@link AuthHandler} from `@decaf-ts/for-http/server`.\n *\n * Only overrides the two extension points:\n * - {@link KeycloakAuthHandler.extractFromAuth} — decodes the JWT and returns auth data (no validation).\n *   Returns empty data for public routes without requiring a token.\n * - {@link KeycloakAuthHandler.validate} — validates the JWT via {@link AuthService.assertValidToken},\n *   then delegates to the base class for route-level and model-level role checks.\n *   Skips entirely for public routes.\n *\n * Does NOT override `bindToContext` — the base class default `ctx.accumulate(data)`\n * is sufficient. Does NOT override `authorize`.\n */\nimport type { Constructor } from \"@decaf-ts/decoration\";\nimport { AuthorizationError, Context, ContextualArgs } from \"@decaf-ts/core\";\nimport { AuthHandler, AuthData } from \"@decaf-ts/for-http/server\";\n\nimport { AuthService, type AuthServiceOptions } from \"./authService\";\nimport type { AuthExecutionContextLike, AuthRequestLike } from \"./types\";\nimport {\n  getRealmFromIssuer,\n  getTokenPayload,\n  extractKeycloakRoles,\n  getClientRoles,\n} from \"./utils\";\n\n/**\n * Auth data returned by {@link KeycloakAuthHandler.extractFromAuth}.\n *\n * Carries the raw JWT `token` so that {@link KeycloakAuthHandler.validate} can\n * validate it against the Keycloak instance (signature, expiry, revocation, etc.).\n */\nexport interface KeycloakAuthData extends AuthData {\n  /** The raw JWT extracted from the request. Empty for public routes. */\n  token: string;\n  /** Whether the request targets a public route (skips validation). */\n  isPublic: boolean;\n}\n\nexport class KeycloakAuthHandler extends AuthHandler<\n  AuthExecutionContextLike,\n  Context,\n  KeycloakAuthData\n> {\n  /**\n   * @param authService  An {@link AuthService} configured with JWKS verification\n   *                     options.  When omitted a default decode-only service is\n   *                     used.\n   * @param authServiceOptions  Convenience: if `authService` is omitted, these\n   *                     options are used to construct one.\n   */\n  constructor(\n    authService?: AuthService,\n    authServiceOptions?: AuthServiceOptions\n  ) {\n    super();\n    this.authService =\n      authService ?? new AuthService(authServiceOptions ?? {});\n  }\n\n  protected readonly authService: AuthService;\n\n  protected extractFromAuth(ctx: AuthExecutionContextLike): KeycloakAuthData {\n    const request = ctx.switchToHttp().getRequest<AuthRequestLike>();\n\n    if (isPublicRoute(request)) {\n      return { roles: [], token: \"\", isPublic: true };\n    }\n\n    const token = getToken(request);\n    if (!token) throw new AuthorizationError(\"Token not found\");\n\n    // Decode only — validation happens in `validate`\n    const payload = getTokenPayload(token);\n    const roles = extractKeycloakRoles(payload);\n    const organization = resolveOrganization(payload, token);\n    const user = payload?.email ?? payload?.preferred_username;\n\n    return { user, organization, roles, token, isPublic: false };\n  }\n\n  /**\n   * Validates the JWT against the Keycloak instance (signature, expiry, etc.)\n   * via {@link AuthService.assertValidToken}, then delegates to the base class\n   * for route-level and model-level role checks. Skips entirely for public routes.\n   */\n  protected override async validate(\n    data: KeycloakAuthData,\n    routeRoles: string[] | undefined,\n    model: string | Constructor,\n    ...args: ContextualArgs<Context>\n  ): Promise<void> {\n    if (data.isPublic) return;\n    await this.authService.assertValidToken(data.token);\n    await super.validate(data, routeRoles, model, ...args);\n  }\n}\n\nfunction isPublicRoute(req: AuthRequestLike): boolean {\n  if (req.path?.startsWith(\"/public\")) return true;\n  return false;\n}\n\nfunction getToken(req: AuthRequestLike): string | undefined {\n  const token = (req.headers?.[\"x-auth-request-access-token\"] ??\n    req.headers?.[\"authorization\"]) as string | undefined;\n  if (!token) return undefined;\n  return token.startsWith(\"Bearer \") ? token.slice(\"Bearer \".length) : token;\n}\n\nfunction resolveOrganization(\n  payload: { aud?: string; azp?: string } | null,\n  token: string\n): string {\n  if (payload?.aud) return payload.aud;\n  if (payload?.azp) return payload.azp;\n  return getRealmFromIssuer(token);\n}\n\nexport { getClientRoles };\n"]}

package/lib/esm/nest/keycloakModule.js

@@ -18,4 +18,4 @@ export class KeycloakModule {
 }
 export class AuthModule extends KeycloakModule {
 }
-//# sourceMappingURL=keycloakModule.js.map
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2V5Y2xvYWtNb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbmVzdC9rZXljbG9ha01vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7OztHQUlHO0FBQ0gsT0FBTyxFQUFFLFdBQVcsRUFBMkIseUJBQXNCO0FBQ3JFLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxpQ0FBOEI7QUFFNUQsTUFBTSxPQUFPLGNBQWM7SUFDekIsWUFDa0IsV0FBd0IsRUFDeEIsV0FBZ0M7UUFEaEMsZ0JBQVcsR0FBWCxXQUFXLENBQWE7UUFDeEIsZ0JBQVcsR0FBWCxXQUFXLENBQXFCO0lBQy9DLENBQUM7SUFFSixNQUFNLENBQUMsTUFBTSxDQUFDLE9BQTRCO1FBQ3hDLE1BQU0sV0FBVyxHQUFHLElBQUksV0FBVyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQzdDLE1BQU0sV0FBVyxHQUFHLElBQUksbUJBQW1CLENBQUMsV0FBVyxDQUFDLENBQUM7UUFDekQsT0FBTyxJQUFJLGNBQWMsQ0FBQyxXQUFXLEVBQUUsV0FBVyxDQUFDLENBQUM7SUFDdEQsQ0FBQztDQUNGO0FBRUQsTUFBTSxPQUFPLFVBQVcsU0FBUSxjQUFjO0NBQUciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBtb2R1bGUgaW50ZWdyYXRpb25zL25lc3Qva2V5Y2xvYWtNb2R1bGVcbiAqIEBzdW1tYXJ5IE5lc3QgbW9kdWxlIHdpcmluZyBmb3IgS2V5Y2xvYWsgYXV0aC5cbiAqIEBkZXNjcmlwdGlvbiBFeHBvc2VzIHRoZSBOZXN0IG1vZHVsZSBzZXR1cCBmb3IgdGhlIGludGVncmF0aW9uIGF1dGggc2VydmljZSBhbmQgS2V5Y2xvYWsgaGFuZGxlci5cbiAqL1xuaW1wb3J0IHsgQXV0aFNlcnZpY2UsIHR5cGUgQXV0aFNlcnZpY2VPcHRpb25zIH0gZnJvbSBcIi4vYXV0aFNlcnZpY2VcIjtcbmltcG9ydCB7IEtleWNsb2FrQXV0aEhhbmRsZXIgfSBmcm9tIFwiLi9rZXljbG9ha0F1dGhIYW5kbGVyXCI7XG5cbmV4cG9ydCBjbGFzcyBLZXljbG9ha01vZHVsZSB7XG4gIGNvbnN0cnVjdG9yKFxuICAgIHB1YmxpYyByZWFkb25seSBhdXRoU2VydmljZTogQXV0aFNlcnZpY2UsXG4gICAgcHVibGljIHJlYWRvbmx5IGF1dGhIYW5kbGVyOiBLZXljbG9ha0F1dGhIYW5kbGVyXG4gICkge31cblxuICBzdGF0aWMgY3JlYXRlKG9wdGlvbnM/OiBBdXRoU2VydmljZU9wdGlvbnMpOiBLZXljbG9ha01vZHVsZSB7XG4gICAgY29uc3QgYXV0aFNlcnZpY2UgPSBuZXcgQXV0aFNlcnZpY2Uob3B0aW9ucyk7XG4gICAgY29uc3QgYXV0aEhhbmRsZXIgPSBuZXcgS2V5Y2xvYWtBdXRoSGFuZGxlcihhdXRoU2VydmljZSk7XG4gICAgcmV0dXJuIG5ldyBLZXljbG9ha01vZHVsZShhdXRoU2VydmljZSwgYXV0aEhhbmRsZXIpO1xuICB9XG59XG5cbmV4cG9ydCBjbGFzcyBBdXRoTW9kdWxlIGV4dGVuZHMgS2V5Y2xvYWtNb2R1bGUge31cbiJdfQ==

package/lib/esm/nest/logging.js

@@ -35,4 +35,4 @@ logParameterRegistry
         return payload.applyTheme(rendered, "app");
     },
 });
-//# sourceMappingURL=logging.js.map
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/nest/types.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=types.js.map
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/nest/utils.js

@@ -80,4 +80,4 @@ export function getRealmFromIssuer(jwt) {
     }
     return parts[realmsIndex + 1];
 }
-//# sourceMappingURL=utils.js.map
+//# sourceMappingURL=data:application/json;base64,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