@invect/core 0.0.1

package/dist/services/flow-versions/schemas-fresh.d.ts

@@ -0,0 +1,201 @@
+import { z } from "zod/v4";
+
+//#region src/services/flow-versions/schemas-fresh.d.ts
+/**
+// =============================================================================
+// MAPPER CONFIGURATION SCHEMA
+// Per-node data mapper — sandboxed JS expression that reshapes upstream data.
+// If the mapper returns an array, the node auto-iterates over each item.
+// Replaces _loop (will be removed in a future phase).
+// =============================================================================
+
+/**
+ * Mapper configuration schema for nodes.
+ * When enabled, the JS expression runs against incoming upstream data.
+ * Use `return` for multi-statement code; single expressions auto-return.
+ */
+declare const mapperConfigSchema: z.ZodObject<{
+  enabled: z.ZodDefault<z.ZodBoolean>;
+  expression: z.ZodString;
+  mode: z.ZodDefault<z.ZodEnum<{
+    auto: "auto";
+    iterate: "iterate";
+    reshape: "reshape";
+  }>>;
+  outputMode: z.ZodDefault<z.ZodEnum<{
+    object: "object";
+    array: "array";
+    concat: "concat";
+    first: "first";
+    last: "last";
+  }>>;
+  keyField: z.ZodOptional<z.ZodString>;
+  concurrency: z.ZodDefault<z.ZodNumber>;
+  onEmpty: z.ZodDefault<z.ZodEnum<{
+    error: "error";
+    skip: "skip";
+  }>>;
+}, z.core.$strip>;
+type MapperConfig = z.infer<typeof mapperConfigSchema>;
+/**
+ * Flow node schema.
+ *
+ * All nodes share the same base shape with a flexible params record.
+ * The `type` field is an arbitrary string – it can be a legacy
+ * GraphNodeType enum value (e.g. "AGENT") or an action ID
+ * (e.g. "core.model", "gmail.send_message").
+ *
+ * Runtime validation of params is handled by each node executor /
+ * action definition via its `paramFields`.
+ */
+declare const flowNodeDefinitionsSchema: z.ZodObject<{
+  id: z.ZodString;
+  position: z.ZodOptional<z.ZodObject<{
+    x: z.ZodNumber;
+    y: z.ZodNumber;
+  }, z.core.$strip>>;
+  label: z.ZodOptional<z.ZodString>;
+  referenceId: z.ZodOptional<z.ZodString>;
+  _loop: z.ZodOptional<z.ZodUnknown>;
+  mapper: z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    expression: z.ZodString;
+    mode: z.ZodDefault<z.ZodEnum<{
+      auto: "auto";
+      iterate: "iterate";
+      reshape: "reshape";
+    }>>;
+    outputMode: z.ZodDefault<z.ZodEnum<{
+      object: "object";
+      array: "array";
+      concat: "concat";
+      first: "first";
+      last: "last";
+    }>>;
+    keyField: z.ZodOptional<z.ZodString>;
+    concurrency: z.ZodDefault<z.ZodNumber>;
+    onEmpty: z.ZodDefault<z.ZodEnum<{
+      error: "error";
+      skip: "skip";
+    }>>;
+  }, z.core.$strip>>;
+  type: z.ZodString;
+  params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type FlowNodeDefinitions = z.infer<typeof flowNodeDefinitionsSchema>;
+/**
+ * Extract a flow-node sub-type.
+ *
+ * With the move to action-based node types the schema is no longer a
+ * discriminated union, so this resolves to the base FlowNodeDefinitions
+ * for every `TNodeType`. Kept for API compatibility with the legacy
+ * executor (`AgentNodeExecutor`).
+ */
+type FlowNodeForType<_TNodeType extends string> = FlowNodeDefinitions;
+declare const flowEdgeSchema: z.ZodObject<{
+  id: z.ZodString;
+  source: z.ZodString;
+  target: z.ZodString;
+  sourceHandle: z.ZodOptional<z.ZodString>;
+  targetHandle: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type FlowEdge = z.infer<typeof flowEdgeSchema>;
+declare const invectDefinitionSchema: z.ZodObject<{
+  nodes: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    position: z.ZodOptional<z.ZodObject<{
+      x: z.ZodNumber;
+      y: z.ZodNumber;
+    }, z.core.$strip>>;
+    label: z.ZodOptional<z.ZodString>;
+    referenceId: z.ZodOptional<z.ZodString>;
+    _loop: z.ZodOptional<z.ZodUnknown>;
+    mapper: z.ZodOptional<z.ZodObject<{
+      enabled: z.ZodDefault<z.ZodBoolean>;
+      expression: z.ZodString;
+      mode: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        iterate: "iterate";
+        reshape: "reshape";
+      }>>;
+      outputMode: z.ZodDefault<z.ZodEnum<{
+        object: "object";
+        array: "array";
+        concat: "concat";
+        first: "first";
+        last: "last";
+      }>>;
+      keyField: z.ZodOptional<z.ZodString>;
+      concurrency: z.ZodDefault<z.ZodNumber>;
+      onEmpty: z.ZodDefault<z.ZodEnum<{
+        error: "error";
+        skip: "skip";
+      }>>;
+    }, z.core.$strip>>;
+    type: z.ZodString;
+    params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  }, z.core.$strip>>;
+  edges: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    source: z.ZodString;
+    target: z.ZodString;
+    sourceHandle: z.ZodOptional<z.ZodString>;
+    targetHandle: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  }, z.core.$strip>>;
+  metadata: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+type InvectDefinition = z.infer<typeof invectDefinitionSchema>;
+type InvectDefinitionRuntime = InvectDefinition;
+declare const createFlowVersionRequestSchema: z.ZodObject<{
+  invectDefinition: z.ZodObject<{
+    nodes: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      position: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+      }, z.core.$strip>>;
+      label: z.ZodOptional<z.ZodString>;
+      referenceId: z.ZodOptional<z.ZodString>;
+      _loop: z.ZodOptional<z.ZodUnknown>;
+      mapper: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        expression: z.ZodString;
+        mode: z.ZodDefault<z.ZodEnum<{
+          auto: "auto";
+          iterate: "iterate";
+          reshape: "reshape";
+        }>>;
+        outputMode: z.ZodDefault<z.ZodEnum<{
+          object: "object";
+          array: "array";
+          concat: "concat";
+          first: "first";
+          last: "last";
+        }>>;
+        keyField: z.ZodOptional<z.ZodString>;
+        concurrency: z.ZodDefault<z.ZodNumber>;
+        onEmpty: z.ZodDefault<z.ZodEnum<{
+          error: "error";
+          skip: "skip";
+        }>>;
+      }, z.core.$strip>>;
+      type: z.ZodString;
+      params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    edges: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      source: z.ZodString;
+      target: z.ZodString;
+      sourceHandle: z.ZodOptional<z.ZodString>;
+      targetHandle: z.ZodOptional<z.ZodString>;
+      metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    metadata: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+  }, z.core.$strip>;
+}, z.core.$strip>;
+type CreateFlowVersionRequest = z.infer<typeof createFlowVersionRequestSchema>;
+//#endregion
+export { CreateFlowVersionRequest, FlowEdge, FlowNodeDefinitions, FlowNodeForType, InvectDefinition, InvectDefinitionRuntime, MapperConfig, createFlowVersionRequestSchema, flowEdgeSchema, flowNodeDefinitionsSchema, invectDefinitionSchema, mapperConfigSchema };
+//# sourceMappingURL=schemas-fresh.d.ts.map

package/dist/services/flow-versions/schemas-fresh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas-fresh.d.ts","names":[],"sources":["../../../src/services/flow-versions/schemas-fresh.ts"],"mappings":";;;;;AAqBA;;;;;;;;;;;cAAa,kBAAA,EAAkB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;KAwDnB,YAAA,GAAe,CAAA,CAAE,KAAA,QAAa,kBAAA;;;;;;;;;;;;cAqD7B,yBAAA,EAAyB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAK1B,mBAAA,GAAsB,CAAA,CAAE,KAAA,QAAa,yBAAA;;;;;;;;;KAUrC,eAAA,8BAA6C,mBAAA;AAAA,cAE5C,cAAA,EAAc,CAAA,CAAA,SAAA;;;;;;;;KASf,QAAA,GAAW,CAAA,CAAE,KAAA,QAAa,cAAA;AAAA,cAEzB,sBAAA,EAAsB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAMvB,gBAAA,GAAmB,CAAA,CAAE,KAAA,QAAa,sBAAA;AAAA,KAGlC,uBAAA,GAA0B,gBAAA;AAAA,cAEzB,8BAAA,EAA8B,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAI/B,wBAAA,GAA2B,CAAA,CAAE,KAAA,QAAa,8BAAA"}

package/dist/services/flow-versions/schemas-fresh.js

@@ -0,0 +1,85 @@
+import { metadataSchema } from "../../types-fresh.js";
+import { z } from "zod/v4";
+//#region src/services/flow-versions/schemas-fresh.ts
+/**
+// =============================================================================
+// MAPPER CONFIGURATION SCHEMA
+// Per-node data mapper — sandboxed JS expression that reshapes upstream data.
+// If the mapper returns an array, the node auto-iterates over each item.
+// Replaces _loop (will be removed in a future phase).
+// =============================================================================
+
+/**
+* Mapper configuration schema for nodes.
+* When enabled, the JS expression runs against incoming upstream data.
+* Use `return` for multi-statement code; single expressions auto-return.
+*/
+const mapperConfigSchema = z.object({
+	enabled: z.boolean().default(false),
+	expression: z.string().min(1),
+	mode: z.enum([
+		"auto",
+		"iterate",
+		"reshape"
+	]).default("auto"),
+	outputMode: z.enum([
+		"array",
+		"object",
+		"first",
+		"last",
+		"concat"
+	]).default("array"),
+	keyField: z.string().optional(),
+	concurrency: z.number().int().min(1).max(50).default(1),
+	onEmpty: z.enum(["error", "skip"]).default("skip")
+});
+const baseNodeSchema = z.object({
+	id: z.string().min(1, "Node ID is required"),
+	position: z.object({
+		x: z.number(),
+		y: z.number()
+	}).optional(),
+	label: z.string().optional(),
+	referenceId: z.string().optional(),
+	_loop: z.unknown().optional(),
+	mapper: mapperConfigSchema.optional()
+});
+/**
+* Flexible params schema that accepts any key-value pairs.
+* Each node executor validates its own params at runtime using its paramFields definition.
+* This allows the schema to be extensible without code changes when adding new nodes.
+*/
+const flexibleParamsSchema = z.record(z.string(), z.unknown()).default({});
+/**
+* Flow node schema.
+*
+* All nodes share the same base shape with a flexible params record.
+* The `type` field is an arbitrary string – it can be a legacy
+* GraphNodeType enum value (e.g. "AGENT") or an action ID
+* (e.g. "core.model", "gmail.send_message").
+*
+* Runtime validation of params is handled by each node executor /
+* action definition via its `paramFields`.
+*/
+const flowNodeDefinitionsSchema = baseNodeSchema.extend({
+	type: z.string().min(1, "Node type is required"),
+	params: flexibleParamsSchema
+});
+const flowEdgeSchema = z.object({
+	id: z.string().min(1, "Edge ID is required"),
+	source: z.string().min(1, "Edge source is required"),
+	target: z.string().min(1, "Edge target is required"),
+	sourceHandle: z.string().optional(),
+	targetHandle: z.string().optional(),
+	metadata: z.record(z.string(), z.unknown()).optional()
+});
+const invectDefinitionSchema = z.object({
+	nodes: z.array(flowNodeDefinitionsSchema),
+	edges: z.array(flowEdgeSchema),
+	metadata: metadataSchema.optional()
+});
+const createFlowVersionRequestSchema = z.object({ invectDefinition: invectDefinitionSchema });
+//#endregion
+export { createFlowVersionRequestSchema, flowEdgeSchema, flowNodeDefinitionsSchema, invectDefinitionSchema, mapperConfigSchema };
+
+//# sourceMappingURL=schemas-fresh.js.map

package/dist/services/flow-versions/schemas-fresh.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas-fresh.js","names":[],"sources":["../../../src/services/flow-versions/schemas-fresh.ts"],"sourcesContent":["import { z } from 'zod/v4';\nimport { metadataSchema } from 'src/types-fresh';\n\n// =============================================================================\n// LOOP CONFIGURATION SCHEMA\n// Generic loop-over capability for any node that accepts input\n// =============================================================================\n\n/**\n// =============================================================================\n// MAPPER CONFIGURATION SCHEMA\n// Per-node data mapper — sandboxed JS expression that reshapes upstream data.\n// If the mapper returns an array, the node auto-iterates over each item.\n// Replaces _loop (will be removed in a future phase).\n// =============================================================================\n\n/**\n * Mapper configuration schema for nodes.\n * When enabled, the JS expression runs against incoming upstream data.\n * Use `return` for multi-statement code; single expressions auto-return.\n */\nexport const mapperConfigSchema = z.object({\n  /** Whether the mapper is enabled for this node. */\n  enabled: z.boolean().default(false),\n\n  /**\n   * JS expression that receives all upstream outputs as local variables.\n   * Executed in a QuickJS sandbox. Use `return` to produce a value.\n   * Single expressions (no `return` keyword) auto-return.\n   *\n   * @example\n   * // Pass array → node iterates per item:\n   * \"users\"\n   *\n   * // Filter then iterate:\n   * \"users.filter(u => u.active)\"\n   *\n   * // Multi-statement with explicit return:\n   * \"const active = users.filter(u => u.active);\\nreturn active.map(u => ({ ...u, rank: 1 }));\"\n   *\n   * // Reshape into object → single run:\n   * \"return { total: orders.reduce((s, o) => s + o.amount, 0), count: orders.length }\"\n   */\n  expression: z.string().min(1),\n\n  /**\n   * Explicit intent declaration — prevents accidental iteration.\n   * - \"auto\"    (default): infer from return type (array → iterate, object → single)\n   * - \"iterate\": assert the result is an array, fail if not\n   * - \"reshape\": assert the result is NOT an array (wrap in object if it is), single run\n   */\n  mode: z.enum(['auto', 'iterate', 'reshape']).default('auto'),\n\n  /**\n   * How to combine iteration results when mapper returns an array.\n   * - \"array\"  (default): collect all outputs into [result1, result2, ...]\n   * - \"object\": build { keyField: result } using a field as key\n   * - \"first\":  return only the first iteration's output\n   * - \"last\":   return only the last iteration's output\n   * - \"concat\": join all string outputs\n   */\n  outputMode: z.enum(['array', 'object', 'first', 'last', 'concat']).default('array'),\n\n  /** For outputMode \"object\": the field path in each result to use as key. */\n  keyField: z.string().optional(),\n\n  /** Max parallel iterations (1 = sequential). Only applies when mapper returns array. */\n  concurrency: z.number().int().min(1).max(50).default(1),\n\n  /**\n   * Behavior when mapper returns an empty array.\n   * - \"skip\":   produce empty output, don't fail (default)\n   * - \"error\":  fail the node\n   */\n  onEmpty: z.enum(['error', 'skip']).default('skip'),\n});\n\nexport type MapperConfig = z.infer<typeof mapperConfigSchema>;\n\nconst baseNodeSchema = z.object({\n  id: z.string().min(1, 'Node ID is required'),\n  position: z\n    .object({\n      x: z.number(),\n      y: z.number(),\n    })\n    .optional(),\n  label: z.string().optional(),\n  referenceId: z.string().optional(), // snake_case unique identifier for input mapping\n  /**\n   * @deprecated Ignored at runtime. Use `mapper` instead. Kept for backward\n   *             compatibility so existing stored flow definitions still parse.\n   */\n  _loop: z.unknown().optional(),\n  /**\n   * Data mapper — sandboxed JS expression that reshapes upstream data\n   * before the node executes. If the expression returns an array, the node\n   * auto-iterates over each element.\n   */\n  mapper: mapperConfigSchema.optional(),\n});\n\n// =============================================================================\n// NODE PARAMS SCHEMA\n// All nodes use a flexible params schema - validation happens at runtime\n// based on each node's paramFields in getDefinition()\n// =============================================================================\n\n/**\n * Flexible params schema that accepts any key-value pairs.\n * Each node executor validates its own params at runtime using its paramFields definition.\n * This allows the schema to be extensible without code changes when adding new nodes.\n */\nconst flexibleParamsSchema = z.record(z.string(), z.unknown()).default({});\n\n// =============================================================================\n// FLOW NODE DEFINITIONS\n// =============================================================================\n\n/**\n * Flow node schema.\n *\n * All nodes share the same base shape with a flexible params record.\n * The `type` field is an arbitrary string – it can be a legacy\n * GraphNodeType enum value (e.g. \"AGENT\") or an action ID\n * (e.g. \"core.model\", \"gmail.send_message\").\n *\n * Runtime validation of params is handled by each node executor /\n * action definition via its `paramFields`.\n */\nexport const flowNodeDefinitionsSchema = baseNodeSchema.extend({\n  type: z.string().min(1, 'Node type is required'),\n  params: flexibleParamsSchema,\n});\n\nexport type FlowNodeDefinitions = z.infer<typeof flowNodeDefinitionsSchema>;\n\n/**\n * Extract a flow-node sub-type.\n *\n * With the move to action-based node types the schema is no longer a\n * discriminated union, so this resolves to the base FlowNodeDefinitions\n * for every `TNodeType`. Kept for API compatibility with the legacy\n * executor (`AgentNodeExecutor`).\n */\nexport type FlowNodeForType<_TNodeType extends string> = FlowNodeDefinitions;\n\nexport const flowEdgeSchema = z.object({\n  id: z.string().min(1, 'Edge ID is required'),\n  source: z.string().min(1, 'Edge source is required'),\n  target: z.string().min(1, 'Edge target is required'),\n  sourceHandle: z.string().optional(),\n  targetHandle: z.string().optional(),\n  metadata: z.record(z.string(), z.unknown()).optional(),\n});\n\nexport type FlowEdge = z.infer<typeof flowEdgeSchema>;\n\nexport const invectDefinitionSchema = z.object({\n  nodes: z.array(flowNodeDefinitionsSchema),\n  edges: z.array(flowEdgeSchema),\n  metadata: metadataSchema.optional(),\n});\n\nexport type InvectDefinition = z.infer<typeof invectDefinitionSchema>;\n\n// Runtime type alias for flow definitions stored in database\nexport type InvectDefinitionRuntime = InvectDefinition;\n\nexport const createFlowVersionRequestSchema = z.object({\n  invectDefinition: invectDefinitionSchema,\n});\n\nexport type CreateFlowVersionRequest = z.infer<typeof createFlowVersionRequestSchema>;\n"],"mappings":";;;;;;;;;;;;;;;;AAqBA,MAAa,qBAAqB,EAAE,OAAO;CAEzC,SAAS,EAAE,SAAS,CAAC,QAAQ,MAAM;CAoBnC,YAAY,EAAE,QAAQ,CAAC,IAAI,EAAE;CAQ7B,MAAM,EAAE,KAAK;EAAC;EAAQ;EAAW;EAAU,CAAC,CAAC,QAAQ,OAAO;CAU5D,YAAY,EAAE,KAAK;EAAC;EAAS;EAAU;EAAS;EAAQ;EAAS,CAAC,CAAC,QAAQ,QAAQ;CAGnF,UAAU,EAAE,QAAQ,CAAC,UAAU;CAG/B,aAAa,EAAE,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,IAAI,GAAG,CAAC,QAAQ,EAAE;CAOvD,SAAS,EAAE,KAAK,CAAC,SAAS,OAAO,CAAC,CAAC,QAAQ,OAAO;CACnD,CAAC;AAIF,MAAM,iBAAiB,EAAE,OAAO;CAC9B,IAAI,EAAE,QAAQ,CAAC,IAAI,GAAG,sBAAsB;CAC5C,UAAU,EACP,OAAO;EACN,GAAG,EAAE,QAAQ;EACb,GAAG,EAAE,QAAQ;EACd,CAAC,CACD,UAAU;CACb,OAAO,EAAE,QAAQ,CAAC,UAAU;CAC5B,aAAa,EAAE,QAAQ,CAAC,UAAU;CAKlC,OAAO,EAAE,SAAS,CAAC,UAAU;CAM7B,QAAQ,mBAAmB,UAAU;CACtC,CAAC;;;;;;AAaF,MAAM,uBAAuB,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,SAAS,CAAC,CAAC,QAAQ,EAAE,CAAC;;;;;;;;;;;;AAiB1E,MAAa,4BAA4B,eAAe,OAAO;CAC7D,MAAM,EAAE,QAAQ,CAAC,IAAI,GAAG,wBAAwB;CAChD,QAAQ;CACT,CAAC;AAcF,MAAa,iBAAiB,EAAE,OAAO;CACrC,IAAI,EAAE,QAAQ,CAAC,IAAI,GAAG,sBAAsB;CAC5C,QAAQ,EAAE,QAAQ,CAAC,IAAI,GAAG,0BAA0B;CACpD,QAAQ,EAAE,QAAQ,CAAC,IAAI,GAAG,0BAA0B;CACpD,cAAc,EAAE,QAAQ,CAAC,UAAU;CACnC,cAAc,EAAE,QAAQ,CAAC,UAAU;CACnC,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,SAAS,CAAC,CAAC,UAAU;CACvD,CAAC;AAIF,MAAa,yBAAyB,EAAE,OAAO;CAC7C,OAAO,EAAE,MAAM,0BAA0B;CACzC,OAAO,EAAE,MAAM,eAAe;CAC9B,UAAU,eAAe,UAAU;CACpC,CAAC;AAOF,MAAa,iCAAiC,EAAE,OAAO,EACrD,kBAAkB,wBACnB,CAAC"}

package/dist/services/flows/flows.model.cjs

@@ -0,0 +1,273 @@
+const require_errors_types = require("../../types/common/errors.types.cjs");
+const require_id_generator = require("../../utils/id-generator.cjs");
+//#region src/services/flows/flows.model.ts
+const TABLE = "flows";
+/**
+* Flows CRUD operations class — uses InvectAdapter for all database operations,
+* eliminating 3-way dialect branching.
+*/
+var FlowsModel = class {
+	constructor(adapter, logger) {
+		this.adapter = adapter;
+		this.logger = logger;
+	}
+	/**
+	* Create a new flow
+	*/
+	async create(input) {
+		const flowId = require_id_generator.IdGenerator.generateFlowId(input.name);
+		const now = /* @__PURE__ */ new Date();
+		try {
+			const result = await this.adapter.create({
+				model: TABLE,
+				data: {
+					id: flowId,
+					name: input.name,
+					description: input.description ?? null,
+					tags: input.tags || [],
+					is_active: input.isActive ?? true,
+					live_version_number: input.liveVersionNumber ?? null,
+					created_at: now,
+					updated_at: now
+				}
+			});
+			return this.normalize(result);
+		} catch (error) {
+			this.logger.error("Failed to create flow", {
+				name: input.name,
+				error
+			});
+			throw new require_errors_types.DatabaseError("Failed to create flow", { error });
+		}
+	}
+	/**
+	* Calculate pagination metadata
+	*/
+	calculatePaginationMetadata(totalCount, pagination) {
+		const totalPages = Math.ceil(totalCount / pagination.limit);
+		return {
+			page: pagination.page,
+			limit: pagination.limit,
+			totalPages
+		};
+	}
+	/**
+	* Process query results into paginated response
+	*/
+	processPaginatedResults(result, totalCount, pagination) {
+		return {
+			data: result.map((flow) => this.normalize(flow)),
+			pagination: this.calculatePaginationMetadata(totalCount, pagination)
+		};
+	}
+	/**
+	* Get all flows with optional filtering
+	*/
+	async listFlows(options) {
+		const pagination = options?.pagination || {
+			limit: 100,
+			page: 1
+		};
+		const sort = options?.sort;
+		const filter = options?.filter || {};
+		const offset = (pagination.page - 1) * pagination.limit;
+		const where = this.buildFilterWhere(filter);
+		try {
+			const [data, totalCount] = await Promise.all([this.adapter.findMany({
+				model: TABLE,
+				where,
+				limit: pagination.limit,
+				offset,
+				sortBy: sort ? {
+					field: this.mapSortField(sort.sortBy),
+					direction: sort.sortOrder
+				} : {
+					field: "created_at",
+					direction: "desc"
+				}
+			}), this.adapter.count({
+				model: TABLE,
+				where
+			})]);
+			return this.processPaginatedResults(data, totalCount, pagination);
+		} catch (error) {
+			this.logger.error("Failed to retrieve flows", {
+				options,
+				error
+			});
+			throw new require_errors_types.DatabaseError("Failed to retrieve flows", { error });
+		}
+	}
+	/**
+	* Get flow by ID
+	*/
+	async findById(id) {
+		try {
+			const result = await this.adapter.findOne({
+				model: TABLE,
+				where: [{
+					field: "id",
+					value: id
+				}]
+			});
+			return result ? this.normalize(result) : null;
+		} catch (error) {
+			this.logger.error("Failed to get flow by ID", {
+				flowId: id,
+				error
+			});
+			throw new require_errors_types.DatabaseError("Failed to get flow by ID", { error });
+		}
+	}
+	/**
+	* Get flow with its live version details.
+	* Uses two adapter queries (flow + version) instead of Drizzle's relational API.
+	*/
+	async findByIdWithLiveVersion(id) {
+		try {
+			const flow = await this.findById(id);
+			if (!flow) return null;
+			if (flow.liveVersionNumber === null || flow.liveVersionNumber === void 0) return flow;
+			const version = await this.adapter.findOne({
+				model: "flow_versions",
+				where: [{
+					field: "flow_id",
+					value: id
+				}, {
+					field: "version",
+					value: flow.liveVersionNumber
+				}]
+			});
+			return {
+				...flow,
+				liveVersion: version ? {
+					version: Number(version.version),
+					flowId: String(version.flow_id),
+					invectDefinition: version.invect_definition,
+					createdAt: String(version.created_at),
+					createdBy: version.created_by ? String(version.created_by) : null
+				} : void 0
+			};
+		} catch (error) {
+			this.logger.error("Failed to get flow with live version", {
+				flowId: id,
+				error
+			});
+			throw new require_errors_types.DatabaseError("Failed to get flow with live version", { error });
+		}
+	}
+	/**
+	* Update flow
+	*/
+	async update(id, input) {
+		try {
+			const updateData = { updated_at: /* @__PURE__ */ new Date() };
+			if (input.name !== void 0) updateData.name = input.name;
+			if (input.description !== void 0) updateData.description = input.description;
+			if (input.tags !== void 0) updateData.tags = input.tags;
+			if (input.isActive !== void 0) updateData.is_active = input.isActive;
+			if (input.liveVersionNumber !== void 0) updateData.live_version_number = input.liveVersionNumber;
+			const result = await this.adapter.update({
+				model: TABLE,
+				where: [{
+					field: "id",
+					value: id
+				}],
+				update: updateData
+			});
+			if (!result) throw new require_errors_types.DatabaseError("Flow not found");
+			return this.normalize(result);
+		} catch (error) {
+			this.logger.error("Failed to update flow", {
+				flowId: id,
+				error
+			});
+			throw new require_errors_types.DatabaseError("Failed to update flow", { error });
+		}
+	}
+	/**
+	* Delete flow
+	*/
+	async delete(id) {
+		try {
+			await this.adapter.delete({
+				model: TABLE,
+				where: [{
+					field: "id",
+					value: id
+				}]
+			});
+		} catch (error) {
+			this.logger.error("Failed to delete flow", {
+				flowId: id,
+				error
+			});
+			throw new require_errors_types.DatabaseError("Failed to delete flow", { error });
+		}
+	}
+	/**
+	* Set the live version for a flow
+	*/
+	async setLiveVersion(flowId, versionNumber) {
+		return this.update(flowId, { liveVersionNumber: versionNumber });
+	}
+	/**
+	* Clear the live version for a flow
+	*/
+	async clearLiveVersion(flowId) {
+		return this.update(flowId, { liveVersionNumber: void 0 });
+	}
+	/**
+	* Normalize database results to standard Flow type
+	*/
+	normalize(raw) {
+		return {
+			id: String(raw.id),
+			name: String(raw.name),
+			description: raw.description ? String(raw.description) : void 0,
+			tags: Array.isArray(raw.tags) ? raw.tags : [],
+			isActive: Boolean(raw.is_active ?? raw.isActive),
+			liveVersionNumber: raw.live_version_number !== null && raw.live_version_number !== void 0 ? Number(raw.live_version_number) : raw.liveVersionNumber !== null && raw.liveVersionNumber !== void 0 ? Number(raw.liveVersionNumber) : void 0,
+			createdAt: raw.created_at ?? raw.createdAt ?? /* @__PURE__ */ new Date(),
+			updatedAt: raw.updated_at ?? raw.updatedAt ?? /* @__PURE__ */ new Date()
+		};
+	}
+	/**
+	* Build WhereClause[] from a FilterQuery.
+	*/
+	buildFilterWhere(filter) {
+		const clauses = [];
+		for (const [key, values] of Object.entries(filter)) {
+			if (!values || !Array.isArray(values) || values.length === 0) continue;
+			const dbField = this.mapFilterField(key);
+			if (values.length === 1) clauses.push({
+				field: dbField,
+				operator: "eq",
+				value: values[0]
+			});
+			else clauses.push({
+				field: dbField,
+				operator: "in",
+				value: values
+			});
+		}
+		return clauses;
+	}
+	/** Map camelCase entity field to snake_case DB column. */
+	mapFilterField(field) {
+		return {
+			isActive: "is_active",
+			liveVersionNumber: "live_version_number",
+			createdAt: "created_at",
+			updatedAt: "updated_at"
+		}[field] ?? field;
+	}
+	/** Map camelCase sort field to snake_case DB column. */
+	mapSortField(field) {
+		return this.mapFilterField(field);
+	}
+};
+//#endregion
+exports.FlowsModel = FlowsModel;
+
+//# sourceMappingURL=flows.model.cjs.map

package/dist/services/flows/flows.model.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"flows.model.cjs","names":["IdGenerator","DatabaseError"],"sources":["../../../src/services/flows/flows.model.ts"],"sourcesContent":["// Flows Model for Invect core — adapter-based implementation\nimport type { InvectAdapter, WhereClause } from '../../database/adapter';\nimport { IdGenerator } from '../../utils/id-generator';\nimport type { FlowVersion } from '../../database';\nimport { Logger, PaginatedResponse, QueryOptions, FilterQuery } from 'src/types/schemas';\nimport { DatabaseError } from 'src/types/common/errors.types';\n\n/**\n * Flow entity\n */\nexport interface Flow {\n  id: string;\n  name: string;\n  description?: string;\n  tags?: string[];\n  isActive: boolean;\n  liveVersionNumber?: number;\n  createdAt: Date | string;\n  updatedAt: Date | string;\n}\n\n/**\n * Input for creating a new flow\n */\nexport interface CreateFlowInput {\n  name: string;\n  description?: string;\n  tags?: string[];\n  isActive?: boolean;\n  liveVersionNumber?: number;\n}\n\n/**\n * Input for updating a flow\n */\nexport interface UpdateFlowInput {\n  name?: string;\n  description?: string;\n  tags?: string[];\n  isActive?: boolean;\n  liveVersionNumber?: number;\n}\n\n/**\n * Flow query parameters\n */\nexport interface FlowQuery {\n  name?: string;\n  tags?: string[];\n  isActive?: boolean;\n  limit?: number;\n  offset?: number;\n}\n\nconst TABLE = 'flows';\n\n/**\n * Flows CRUD operations class — uses InvectAdapter for all database operations,\n * eliminating 3-way dialect branching.\n */\nexport class FlowsModel {\n  constructor(\n    private readonly adapter: InvectAdapter,\n    private readonly logger: Logger,\n  ) {}\n\n  /**\n   * Create a new flow\n   */\n  async create(input: CreateFlowInput): Promise<Flow> {\n    const flowId = IdGenerator.generateFlowId(input.name);\n    const now = new Date();\n\n    try {\n      const result = await this.adapter.create({\n        model: TABLE,\n        data: {\n          id: flowId,\n          name: input.name,\n          description: input.description ?? null,\n          tags: input.tags || [],\n          is_active: input.isActive ?? true,\n          live_version_number: input.liveVersionNumber ?? null,\n          created_at: now,\n          updated_at: now,\n        },\n      });\n      return this.normalize(result);\n    } catch (error) {\n      this.logger.error('Failed to create flow', { name: input.name, error });\n      throw new DatabaseError('Failed to create flow', { error });\n    }\n  }\n\n  /**\n   * Calculate pagination metadata\n   */\n  private calculatePaginationMetadata(\n    totalCount: number,\n    pagination: { page: number; limit: number },\n  ) {\n    const totalPages = Math.ceil(totalCount / pagination.limit);\n    return {\n      page: pagination.page,\n      limit: pagination.limit,\n      totalPages,\n    };\n  }\n\n  /**\n   * Process query results into paginated response\n   */\n  private processPaginatedResults(\n    result: Record<string, unknown>[],\n    totalCount: number,\n    pagination: { page: number; limit: number },\n  ): PaginatedResponse<Flow> {\n    const data = result.map((flow) => this.normalize(flow));\n    return {\n      data,\n      pagination: this.calculatePaginationMetadata(totalCount, pagination),\n    };\n  }\n\n  /**\n   * Get all flows with optional filtering\n   */\n  async listFlows(options?: QueryOptions<Flow>): Promise<PaginatedResponse<Flow>> {\n    const pagination = options?.pagination || { limit: 100, page: 1 };\n    const sort = options?.sort;\n    const filter = options?.filter || {};\n\n    const offset = (pagination.page - 1) * pagination.limit;\n    const where = this.buildFilterWhere(filter);\n\n    try {\n      const [data, totalCount] = await Promise.all([\n        this.adapter.findMany<Record<string, unknown>>({\n          model: TABLE,\n          where,\n          limit: pagination.limit,\n          offset,\n          sortBy: sort\n            ? { field: this.mapSortField(sort.sortBy as string), direction: sort.sortOrder }\n            : { field: 'created_at', direction: 'desc' },\n        }),\n        this.adapter.count({ model: TABLE, where }),\n      ]);\n\n      return this.processPaginatedResults(data, totalCount, pagination);\n    } catch (error) {\n      this.logger.error('Failed to retrieve flows', { options, error });\n      throw new DatabaseError('Failed to retrieve flows', { error });\n    }\n  }\n\n  /**\n   * Get flow by ID\n   */\n  async findById(id: string): Promise<Flow | null> {\n    try {\n      const result = await this.adapter.findOne<Record<string, unknown>>({\n        model: TABLE,\n        where: [{ field: 'id', value: id }],\n      });\n      return result ? this.normalize(result) : null;\n    } catch (error) {\n      this.logger.error('Failed to get flow by ID', { flowId: id, error });\n      throw new DatabaseError('Failed to get flow by ID', { error });\n    }\n  }\n\n  /**\n   * Get flow with its live version details.\n   * Uses two adapter queries (flow + version) instead of Drizzle's relational API.\n   */\n  async findByIdWithLiveVersion(\n    id: string,\n  ): Promise<(Flow & { liveVersion?: FlowVersion }) | null> {\n    try {\n      const flow = await this.findById(id);\n      if (!flow) {\n        return null;\n      }\n\n      if (flow.liveVersionNumber === null || flow.liveVersionNumber === undefined) {\n        return flow;\n      }\n\n      const version = await this.adapter.findOne<Record<string, unknown>>({\n        model: 'flow_versions',\n        where: [\n          { field: 'flow_id', value: id },\n          { field: 'version', value: flow.liveVersionNumber },\n        ],\n      });\n\n      return {\n        ...flow,\n        liveVersion: version\n          ? {\n              version: Number(version.version),\n              flowId: String(version.flow_id),\n              invectDefinition: version.invect_definition as FlowVersion['invectDefinition'],\n              createdAt: String(version.created_at),\n              createdBy: version.created_by ? String(version.created_by) : null,\n            }\n          : undefined,\n      };\n    } catch (error) {\n      this.logger.error('Failed to get flow with live version', { flowId: id, error });\n      throw new DatabaseError('Failed to get flow with live version', { error });\n    }\n  }\n\n  /**\n   * Update flow\n   */\n  async update(id: string, input: UpdateFlowInput): Promise<Flow> {\n    try {\n      const updateData: Record<string, unknown> = {\n        updated_at: new Date(),\n      };\n\n      if (input.name !== undefined) {\n        updateData.name = input.name;\n      }\n      if (input.description !== undefined) {\n        updateData.description = input.description;\n      }\n      if (input.tags !== undefined) {\n        updateData.tags = input.tags;\n      }\n      if (input.isActive !== undefined) {\n        updateData.is_active = input.isActive;\n      }\n      if (input.liveVersionNumber !== undefined) {\n        updateData.live_version_number = input.liveVersionNumber;\n      }\n\n      const result = await this.adapter.update<Record<string, unknown>>({\n        model: TABLE,\n        where: [{ field: 'id', value: id }],\n        update: updateData,\n      });\n\n      if (!result) {\n        throw new DatabaseError('Flow not found');\n      }\n      return this.normalize(result);\n    } catch (error) {\n      this.logger.error('Failed to update flow', { flowId: id, error });\n      throw new DatabaseError('Failed to update flow', { error });\n    }\n  }\n\n  /**\n   * Delete flow\n   */\n  async delete(id: string): Promise<void> {\n    try {\n      await this.adapter.delete({\n        model: TABLE,\n        where: [{ field: 'id', value: id }],\n      });\n    } catch (error) {\n      this.logger.error('Failed to delete flow', { flowId: id, error });\n      throw new DatabaseError('Failed to delete flow', { error });\n    }\n  }\n\n  /**\n   * Set the live version for a flow\n   */\n  async setLiveVersion(flowId: string, versionNumber: number): Promise<Flow> {\n    return this.update(flowId, { liveVersionNumber: versionNumber });\n  }\n\n  /**\n   * Clear the live version for a flow\n   */\n  async clearLiveVersion(flowId: string): Promise<Flow> {\n    return this.update(flowId, { liveVersionNumber: undefined });\n  }\n\n  /**\n   * Normalize database results to standard Flow type\n   */\n  private normalize(raw: Record<string, unknown>): Flow {\n    return {\n      id: String(raw.id),\n      name: String(raw.name),\n      description: raw.description ? String(raw.description) : undefined,\n      tags: Array.isArray(raw.tags) ? raw.tags : [],\n      isActive: Boolean(raw.is_active ?? raw.isActive),\n      liveVersionNumber:\n        raw.live_version_number !== null && raw.live_version_number !== undefined\n          ? Number(raw.live_version_number)\n          : raw.liveVersionNumber !== null && raw.liveVersionNumber !== undefined\n            ? Number(raw.liveVersionNumber)\n            : undefined,\n      createdAt: (raw.created_at ?? raw.createdAt ?? new Date()) as Date | string,\n      updatedAt: (raw.updated_at ?? raw.updatedAt ?? new Date()) as Date | string,\n    };\n  }\n\n  /**\n   * Build WhereClause[] from a FilterQuery.\n   */\n  private buildFilterWhere(filter: FilterQuery<Flow>): WhereClause[] {\n    const clauses: WhereClause[] = [];\n    for (const [key, values] of Object.entries(filter)) {\n      if (!values || !Array.isArray(values) || values.length === 0) {\n        continue;\n      }\n      const dbField = this.mapFilterField(key);\n      if (values.length === 1) {\n        clauses.push({ field: dbField, operator: 'eq', value: values[0] });\n      } else {\n        clauses.push({ field: dbField, operator: 'in', value: values });\n      }\n    }\n    return clauses;\n  }\n\n  /** Map camelCase entity field to snake_case DB column. */\n  private mapFilterField(field: string): string {\n    const map: Record<string, string> = {\n      isActive: 'is_active',\n      liveVersionNumber: 'live_version_number',\n      createdAt: 'created_at',\n      updatedAt: 'updated_at',\n    };\n    return map[field] ?? field;\n  }\n\n  /** Map camelCase sort field to snake_case DB column. */\n  private mapSortField(field: string): string {\n    return this.mapFilterField(field);\n  }\n}\n"],"mappings":"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"}