@decaf-ts/integrations 0.3.5 → 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":"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","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=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbmVzdC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQkFBd0I7QUFDeEIsMkJBQXdCO0FBQ3hCLGlDQUE4QjtBQUM5Qix5Q0FBc0M7QUFDdEMsb0NBQWlDO0FBRWpDLHNCQUFtQjtBQUVuQjs7Ozs7O0dBTUciLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi90eXBlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vdXRpbHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2F1dGhTZXJ2aWNlXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9rZXljbG9ha0F1dGhIYW5kbGVyXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9rZXljbG9ha01vZHVsZVwiO1xuXG5pbXBvcnQgXCIuL2xvZ2dpbmdcIjtcblxuLyoqXG4gKiBAc3VtbWFyeSBOZXN0LXN0eWxlIGF1dGggaW50ZWdyYXRpb25zLlxuICogQGRlc2NyaXB0aW9uIEZyYW1ld29yay1hZ25vc3RpYyBhdXRoIGhlbHBlcnMgY29tcGF0aWJsZSB3aXRoIERlY2FmIHJlcXVlc3QgY29udGV4dCBoYW5kbGluZy5cbiAqIEltcG9ydHMgdGhlIGB1c2VyYC9gb3JnYW5pemF0aW9uYCBsb2cgcGFyYW1ldGVyIHJlZ2lzdHJhdGlvbnMgYXMgYSBzaWRlIGVmZmVjdC5cbiAqIEBuYW1lc3BhY2UgbmVzdFxuICogQG1lbWJlck9mIG1vZHVsZTppbnRlZ3JhdGlvbnNcbiAqL1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbmVzdC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQkFBd0I7QUFDeEIsMkJBQXdCO0FBQ3hCLGlDQUE4QjtBQUM5Qix5Q0FBc0M7QUFDdEMsb0NBQWlDO0FBQ2pDLGlDQUF3QjtBQUV4QixzQkFBbUI7QUFFbkI7Ozs7OztHQU1HIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vdHlwZXNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3V0aWxzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9hdXRoU2VydmljZVwiO1xuZXhwb3J0ICogZnJvbSBcIi4va2V5Y2xvYWtBdXRoSGFuZGxlclwiO1xuZXhwb3J0ICogZnJvbSBcIi4va2V5Y2xvYWtNb2R1bGVcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2dyYXBoXCI7XG5cbmltcG9ydCBcIi4vbG9nZ2luZ1wiO1xuXG4vKipcbiAqIEBzdW1tYXJ5IE5lc3Qtc3R5bGUgYXV0aCBpbnRlZ3JhdGlvbnMuXG4gKiBAZGVzY3JpcHRpb24gRnJhbWV3b3JrLWFnbm9zdGljIGF1dGggaGVscGVycyBjb21wYXRpYmxlIHdpdGggRGVjYWYgcmVxdWVzdCBjb250ZXh0IGhhbmRsaW5nLlxuICogSW1wb3J0cyB0aGUgYHVzZXJgL2Bvcmdhbml6YXRpb25gIGxvZyBwYXJhbWV0ZXIgcmVnaXN0cmF0aW9ucyBhcyBhIHNpZGUgZWZmZWN0LlxuICogQG5hbWVzcGFjZSBuZXN0XG4gKiBAbWVtYmVyT2YgbW9kdWxlOmludGVncmF0aW9uc1xuICovXG4iXX0=

package/lib/types/graph/nodes/base.d.cts

@@ -0,0 +1,28 @@
+/**
+ * @module integrations/graph/nodes/base
+ * @summary Base class for graph node declarations.
+ * @description `GraphNode` extends {@link Model} with an overridable
+ * `applyMetadata` static method. Concrete node kinds that support dynamic
+ * metadata changes (e.g. `SwitchFlowNode` adding case output ports) override
+ * this method to compute their own ports, size, and data patches — the node
+ * is exclusively responsible for itself in every way.
+ */
+import { Model } from "@decaf-ts/decorator-validation";
+import type { NodeMetadataChange } from "../types.d.cts";
+export declare class GraphNode extends Model {
+    /**
+     * Applies a metadata patch to this node class, returning the resulting
+     * ports, size, and data patches.
+     *
+     * The default implementation returns `null` (no changes). Concrete node
+     * kinds that support dynamic metadata override this to compute their own
+     * ports and size from the metadata — the caller (renderer) simply relays
+     * the result to the diagram model.
+     *
+     * @param _meta - The metadata patch (node-kind-specific, e.g.
+     *   `SwitchNodeMetadata`).
+     * @returns The computed change, or `null` when the node kind does not
+     *   support dynamic metadata.
+     */
+    static applyMetadata(_meta: unknown): NodeMetadataChange | null;
+}

package/lib/types/graph/nodes/base.d.mts

@@ -0,0 +1,28 @@
+/**
+ * @module integrations/graph/nodes/base
+ * @summary Base class for graph node declarations.
+ * @description `GraphNode` extends {@link Model} with an overridable
+ * `applyMetadata` static method. Concrete node kinds that support dynamic
+ * metadata changes (e.g. `SwitchFlowNode` adding case output ports) override
+ * this method to compute their own ports, size, and data patches — the node
+ * is exclusively responsible for itself in every way.
+ */
+import { Model } from "@decaf-ts/decorator-validation";
+import type { NodeMetadataChange } from "../types.d.mts";
+export declare class GraphNode extends Model {
+    /**
+     * Applies a metadata patch to this node class, returning the resulting
+     * ports, size, and data patches.
+     *
+     * The default implementation returns `null` (no changes). Concrete node
+     * kinds that support dynamic metadata override this to compute their own
+     * ports and size from the metadata — the caller (renderer) simply relays
+     * the result to the diagram model.
+     *
+     * @param _meta - The metadata patch (node-kind-specific, e.g.
+     *   `SwitchNodeMetadata`).
+     * @returns The computed change, or `null` when the node kind does not
+     *   support dynamic metadata.
+     */
+    static applyMetadata(_meta: unknown): NodeMetadataChange | null;
+}

package/lib/types/graph/nodes/flow-control.d.cts

@@ -11,6 +11,8 @@
  * executors (§5.9) and are NOT redeclared here.
  */
 import { Model } from "@decaf-ts/decorator-validation";
+import type { NodeMetadataChange, SwitchNodeMetadata } from "../types.d.cts";
+import { GraphNode } from "./base.d.cts";
 /**
  * If — conditional branch. Evaluates a `ConditionExpression` (§22.3) and
  * routes the input to the `then` or `else` output.
@@ -30,9 +32,15 @@ export declare class IfFlowNode extends Model {
  * The node grows in height as cases are added. Each case gets its own
  * output port on the right side, labeled with the case label.
  */
-export declare class SwitchFlowNode extends Model {
+export declare class SwitchFlowNode extends GraphNode {
     value: unknown;
     default: unknown;
+    /**
+     * Computes the node's ports, size, and data patch from the given switch
+     * metadata. Each case gets its own output port on the right side; the
+     * node grows in height as cases are added.
+     */
+    static applyMetadata(meta: SwitchNodeMetadata): NodeMetadataChange;
 }
 /**
  * Parallel — splits execution into concurrent branches.

package/lib/types/graph/nodes/flow-control.d.mts

@@ -11,6 +11,8 @@
  * executors (§5.9) and are NOT redeclared here.
  */
 import { Model } from "@decaf-ts/decorator-validation";
+import type { NodeMetadataChange, SwitchNodeMetadata } from "../types.d.mts";
+import { GraphNode } from "./base.d.mts";
 /**
  * If — conditional branch. Evaluates a `ConditionExpression` (§22.3) and
  * routes the input to the `then` or `else` output.
@@ -30,9 +32,15 @@ export declare class IfFlowNode extends Model {
  * The node grows in height as cases are added. Each case gets its own
  * output port on the right side, labeled with the case label.
  */
-export declare class SwitchFlowNode extends Model {
+export declare class SwitchFlowNode extends GraphNode {
     value: unknown;
     default: unknown;
+    /**
+     * Computes the node's ports, size, and data patch from the given switch
+     * metadata. Each case gets its own output port on the right side; the
+     * node grows in height as cases are added.
+     */
+    static applyMetadata(meta: SwitchNodeMetadata): NodeMetadataChange;
 }
 /**
  * Parallel — splits execution into concurrent branches.

package/lib/types/graph/nodes/index.d.cts

@@ -10,6 +10,7 @@
  * Consumers (for-angular, ALFRED, etc.) import these declarations to populate
  * node palettes, registries, and reference snapshots.
  */
+export * from "./base.d.cts";
 export * from "./category-styles.d.cts";
 export * from "./triggers.d.cts";
 export * from "./flow-control.d.cts";

package/lib/types/graph/nodes/index.d.mts

@@ -10,6 +10,7 @@
  * Consumers (for-angular, ALFRED, etc.) import these declarations to populate
  * node palettes, registries, and reference snapshots.
  */
+export * from "./base.d.mts";
 export * from "./category-styles.d.mts";
 export * from "./triggers.d.mts";
 export * from "./flow-control.d.mts";

package/lib/types/graph/types.d.cts

@@ -3,7 +3,7 @@
  * @summary Graph execution engine core types.
  * @description Type aliases and interfaces shared across the graph execution engine.
  */
-import type { GraphNodeDefinition, GraphWorkflowDefinition } from "@decaf-ts/ui-decorators/graph";
+import type { GraphNodeDefinition, GraphPortDefinition, GraphWorkflowDefinition } from "@decaf-ts/ui-decorators/graph";
 import type { GraphExecutionEventType, GraphExecutionStatus } from "./constants.d.cts";
 /**
  * Unique identifier for a single graph execution run.
@@ -244,6 +244,20 @@ export interface SwitchNodeMetadata {
     cases: SwitchCase[];
     defaultPort?: string;
 }
+/**
+ * The result of applying a metadata change to a node. Each concrete node
+ * class that overrides `GraphNode.applyMetadata()` returns this so the
+ * renderer can update the diagram model — the node owns its ports, its
+ * size, and any data patches.
+ */
+export interface NodeMetadataChange {
+    ports: GraphPortDefinition[];
+    size: {
+        width: number;
+        height: number;
+    };
+    dataPatch: Record<string, unknown>;
+}
 /**
  * Pinning metadata attached to a node via `@pinnable()`.
  */