@invect/core 0.0.1

package/dist/types/schemas-fresh/invect-config.js

@@ -0,0 +1,174 @@
+import { ChatConfigSchema } from "../../services/chat/chat-types.js";
+import { z } from "zod/v4";
+//#region src/types/schemas-fresh/invect-config.ts
+const databaseConfigSchema = z.object({
+	connectionString: z.string().min(1, "Database URL is required"),
+	type: z.enum([
+		"postgresql",
+		"sqlite",
+		"mysql"
+	]),
+	id: z.string(),
+	name: z.string().optional()
+});
+/**
+* Database configuration schema
+*/
+const queryDatabasesConfigSchema = z.array(databaseConfigSchema).optional().default(() => []);
+/**
+* Execution configuration schema
+*/
+const ExecutionConfigSchema = z.object({
+	defaultTimeout: z.number().positive().default(6e4),
+	maxConcurrentExecutions: z.number().positive().default(10),
+	enableTracing: z.boolean().default(true),
+	flowTimeoutMs: z.number().positive().default(6e5),
+	heartbeatIntervalMs: z.number().positive().default(3e4),
+	staleRunCheckIntervalMs: z.number().positive().default(6e4)
+});
+/**
+* Log level enum values
+*/
+const LogLevelSchema = z.enum([
+	"debug",
+	"info",
+	"warn",
+	"error",
+	"silent"
+]);
+/**
+* Logging configuration schema with support for scope-level overrides.
+*
+* Scopes allow independent log level control for different feature areas:
+* - execution: Flow execution orchestration
+* - validation: Flow validation
+* - batch: Batch processing (AI providers)
+* - database: Database operations
+* - node: Node execution
+* - graph: Graph operations (topological sort, etc.)
+* - credentials: Credential management
+* - ai: AI/LLM operations
+* - template: Template rendering
+* - renderer: React Flow rendering
+* - flows: Flow management (CRUD)
+* - versions: Flow version management
+* - http: HTTP/API layer
+*
+* @example
+* ```typescript
+* const config = {
+*   logging: {
+*     level: 'info',  // Default level for all scopes
+*     scopes: {
+*       execution: 'debug',  // Verbose execution logging
+*       validation: 'warn',  // Only validation warnings
+*       batch: 'silent',     // Disable batch logging
+*     }
+*   }
+* };
+* ```
+*/
+const LoggingConfigSchema = z.object({
+	level: LogLevelSchema.default("silent"),
+	scopes: z.record(z.string(), LogLevelSchema).optional()
+});
+z.enum([
+	"admin",
+	"editor",
+	"operator",
+	"viewer"
+]);
+/**
+* Invect permissions
+*/
+const InvectPermissionSchema = z.enum([
+	"flow:create",
+	"flow:read",
+	"flow:update",
+	"flow:delete",
+	"flow:publish",
+	"flow-version:create",
+	"flow-version:read",
+	"flow-run:create",
+	"flow-run:read",
+	"flow-run:cancel",
+	"credential:create",
+	"credential:read",
+	"credential:update",
+	"credential:delete",
+	"agent-tool:read",
+	"agent-tool:configure",
+	"node:test",
+	"admin:*"
+]);
+/**
+* Authentication/Authorization configuration schema.
+*
+* Invect uses a "BYO Auth" (Bring Your Own Authentication) pattern.
+* The host app handles authentication and provides user identity to Invect.
+* Invect handles authorization based on roles and permissions.
+*
+* @example
+* ```typescript
+* const config = {
+*   auth: {
+*     enabled: true,
+*     resolveUser: async (req) => ({
+*       id: req.user.id,
+*       role: req.user.invectRole,
+*     }),
+*     roleMapper: {
+*       'super_admin': 'admin',
+*       'content_manager': 'editor',
+*     },
+*   }
+* };
+* ```
+*/
+const InvectAuthConfigSchema = z.object({
+	enabled: z.boolean().default(false),
+	resolveUser: z.any().optional(),
+	roleMapper: z.record(z.string(), z.string()).optional(),
+	customRoles: z.record(z.string(), z.array(InvectPermissionSchema)).optional(),
+	customAuthorize: z.any().optional(),
+	publicRoutes: z.array(z.string()).optional(),
+	defaultRole: z.string().default("viewer"),
+	onAuthFailure: z.enum([
+		"throw",
+		"log",
+		"deny"
+	]).default("throw"),
+	useFlowAccessTable: z.boolean().default(false)
+});
+/**
+* Core Invect configuration schema
+*/
+const InvectConfigSchema = z.object({
+	queryDatabases: queryDatabasesConfigSchema.optional(),
+	baseDatabaseConfig: databaseConfigSchema,
+	logging: LoggingConfigSchema.default(() => ({ level: "info" })).optional(),
+	logger: z.any().optional(),
+	basePath: z.string().optional(),
+	execution: ExecutionConfigSchema.optional(),
+	auth: InvectAuthConfigSchema.optional(),
+	triggers: z.object({
+		webhookBaseUrl: z.string().optional(),
+		cronEnabled: z.boolean().default(true)
+	}).optional(),
+	chat: ChatConfigSchema.optional(),
+	plugins: z.array(z.any()).optional(),
+	schemaVerification: z.union([z.boolean(), z.object({ strict: z.boolean().default(false) })]).optional(),
+	defaultCredentials: z.array(z.object({
+		name: z.string(),
+		type: z.string(),
+		authType: z.string(),
+		config: z.record(z.string(), z.unknown()),
+		description: z.string().optional(),
+		isShared: z.boolean().optional(),
+		metadata: z.record(z.string(), z.unknown()).optional()
+	})).optional()
+});
+//#endregion
+export { ExecutionConfigSchema, InvectAuthConfigSchema, InvectConfigSchema, InvectPermissionSchema, LogLevelSchema, LoggingConfigSchema, queryDatabasesConfigSchema };
+
+//# sourceMappingURL=invect-config.js.map

package/dist/types/schemas-fresh/invect-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"invect-config.js","names":[],"sources":["../../../src/types/schemas-fresh/invect-config.ts"],"sourcesContent":["import { z } from 'zod/v4';\nimport { ChatConfigSchema } from 'src/services/chat/chat-types';\n\nconst databaseConfigSchema = z.object({\n  connectionString: z.string().min(1, 'Database URL is required'),\n  type: z.enum(['postgresql', 'sqlite', 'mysql']),\n  id: z.string(), // Optional ID for the database, useful for multi-database setups\n  name: z.string().optional(), // Human readable name for the database\n});\n\nexport type InvectDatabaseConfig = z.infer<typeof databaseConfigSchema>;\n\n/**\n * Database configuration schema\n */\nexport const queryDatabasesConfigSchema = z\n  .array(databaseConfigSchema)\n  .optional()\n  .default(() => []);\n\n/**\n * Execution configuration schema\n */\nexport const ExecutionConfigSchema = z.object({\n  defaultTimeout: z.number().positive().default(60000),\n  maxConcurrentExecutions: z.number().positive().default(10),\n  enableTracing: z.boolean().default(true),\n  /**\n   * Maximum time (in ms) a flow run is allowed to stay in RUNNING state\n   * before being considered stale and marked as FAILED.\n   * @default 600_000 (10 minutes)\n   */\n  flowTimeoutMs: z.number().positive().default(600_000),\n  /**\n   * Interval (in ms) at which the heartbeat is updated during flow execution.\n   * @default 30_000 (30 seconds)\n   */\n  heartbeatIntervalMs: z.number().positive().default(30_000),\n  /**\n   * Interval (in ms) at which the stale run detector polls for stuck runs.\n   * @default 60_000 (60 seconds)\n   */\n  staleRunCheckIntervalMs: z.number().positive().default(60_000),\n});\n\n/**\n * Log level enum values\n */\nexport const LogLevelSchema = z.enum(['debug', 'info', 'warn', 'error', 'silent']);\n\n/**\n * Logging configuration schema with support for scope-level overrides.\n *\n * Scopes allow independent log level control for different feature areas:\n * - execution: Flow execution orchestration\n * - validation: Flow validation\n * - batch: Batch processing (AI providers)\n * - database: Database operations\n * - node: Node execution\n * - graph: Graph operations (topological sort, etc.)\n * - credentials: Credential management\n * - ai: AI/LLM operations\n * - template: Template rendering\n * - renderer: React Flow rendering\n * - flows: Flow management (CRUD)\n * - versions: Flow version management\n * - http: HTTP/API layer\n *\n * @example\n * ```typescript\n * const config = {\n *   logging: {\n *     level: 'info',  // Default level for all scopes\n *     scopes: {\n *       execution: 'debug',  // Verbose execution logging\n *       validation: 'warn',  // Only validation warnings\n *       batch: 'silent',     // Disable batch logging\n *     }\n *   }\n * };\n * ```\n */\nexport const LoggingConfigSchema = z.object({\n  /** Default log level for all scopes */\n  level: LogLevelSchema.default('silent'),\n  /** Per-scope log level overrides */\n  scopes: z.record(z.string(), LogLevelSchema).optional(),\n});\n\n/**\n * Built-in Invect roles\n */\nexport const InvectRoleSchema = z.enum(['admin', 'editor', 'operator', 'viewer']);\n\n/**\n * Invect permissions\n */\nexport const InvectPermissionSchema = z.enum([\n  // Flow permissions\n  'flow:create',\n  'flow:read',\n  'flow:update',\n  'flow:delete',\n  'flow:publish',\n  // Flow version permissions\n  'flow-version:create',\n  'flow-version:read',\n  // Execution permissions\n  'flow-run:create',\n  'flow-run:read',\n  'flow-run:cancel',\n  // Credential permissions\n  'credential:create',\n  'credential:read',\n  'credential:update',\n  'credential:delete',\n  // Agent/tool permissions\n  'agent-tool:read',\n  'agent-tool:configure',\n  // Node testing\n  'node:test',\n  // Admin wildcard\n  'admin:*',\n]);\n\n/**\n * Authentication/Authorization configuration schema.\n *\n * Invect uses a \"BYO Auth\" (Bring Your Own Authentication) pattern.\n * The host app handles authentication and provides user identity to Invect.\n * Invect handles authorization based on roles and permissions.\n *\n * @example\n * ```typescript\n * const config = {\n *   auth: {\n *     enabled: true,\n *     resolveUser: async (req) => ({\n *       id: req.user.id,\n *       role: req.user.invectRole,\n *     }),\n *     roleMapper: {\n *       'super_admin': 'admin',\n *       'content_manager': 'editor',\n *     },\n *   }\n * };\n * ```\n */\nexport const InvectAuthConfigSchema = z.object({\n  /**\n   * Enable RBAC (Role-Based Access Control).\n   * When false, all requests are allowed without authentication checks.\n   * @default false\n   */\n  enabled: z.boolean().default(false),\n\n  /**\n   * Function to resolve user identity from incoming request.\n   * This is provided at runtime, not validated by Zod.\n   */\n  resolveUser: z.any().optional(),\n\n  /**\n   * Map host app roles to Invect roles.\n   */\n  roleMapper: z.record(z.string(), z.string()).optional(),\n\n  /**\n   * Define custom roles with specific permissions.\n   */\n  customRoles: z.record(z.string(), z.array(InvectPermissionSchema)).optional(),\n\n  /**\n   * Custom authorization callback (provided at runtime).\n   */\n  customAuthorize: z.any().optional(),\n\n  /**\n   * Routes that don't require authentication.\n   */\n  publicRoutes: z.array(z.string()).optional(),\n\n  /**\n   * Default role for authenticated users without explicit role.\n   */\n  defaultRole: z.string().default('viewer'),\n\n  /**\n   * Behavior when auth fails.\n   */\n  onAuthFailure: z.enum(['throw', 'log', 'deny']).default('throw'),\n\n  /**\n   * Use the flow_access database table to manage flow-level permissions.\n   * When enabled, Invect stores flow access records in its own database.\n   * @default false\n   */\n  useFlowAccessTable: z.boolean().default(false),\n});\n\n/**\n * Core Invect configuration schema\n */\nexport const InvectConfigSchema = z.object({\n  queryDatabases: queryDatabasesConfigSchema.optional(),\n  baseDatabaseConfig: databaseConfigSchema,\n  logging: LoggingConfigSchema.default(() => ({\n    level: 'info' as const,\n  })).optional(),\n  logger: z.any().optional(),\n  basePath: z.string().optional(),\n  /**\n   * Execution settings: flow timeout, heartbeat interval, stale run detection.\n   */\n  execution: ExecutionConfigSchema.optional(),\n  /**\n   * Authentication and authorization configuration.\n   * When not provided, auth is disabled (all requests allowed).\n   */\n  auth: InvectAuthConfigSchema.optional(),\n  /**\n   * Trigger system configuration.\n   * Controls webhook and cron scheduler behavior.\n   */\n  triggers: z\n    .object({\n      /**\n       * The public-facing base URL where Invect routes are mounted.\n       * Used to display the full webhook URL in the flow editor.\n       * Example: \"https://api.myapp.com/invect\"\n       */\n      webhookBaseUrl: z.string().optional(),\n      /**\n       * Enable/disable the cron scheduler. When disabled, cron trigger nodes\n       * can still be placed on flows but won't fire automatically.\n       * @default true\n       */\n      cronEnabled: z.boolean().default(true),\n    })\n    .optional(),\n  /**\n   * Chat assistant configuration.\n   * Controls the AI chat sidebar for flow building assistance.\n   */\n  chat: ChatConfigSchema.optional(),\n  /**\n   * Plugins extend Invect with additional capabilities:\n   * actions, hooks, endpoints, database schema, and middleware.\n   *\n   * Plugins are plain objects satisfying the `InvectPlugin` interface.\n   * They are initialized in array order during `Invect.initialize()`.\n   *\n   * Database schema changes from plugins require running `npx invect generate`\n   * to regenerate the Drizzle schema files, then `npx invect migrate` to apply.\n   *\n   * @example\n   * ```typescript\n   * import { rbac } from '@invect/plugin-rbac';\n   * import { auditLog } from '@invect/plugin-audit-log';\n   *\n   * const config = {\n   *   plugins: [\n   *     rbac({ resolveUser: (req) => req.user }),\n   *     auditLog({ destination: 'database' }),\n   *   ],\n   * };\n   * ```\n   */\n  plugins: z.array(z.any()).optional(),\n  /**\n   * Schema verification configuration.\n   *\n   * When enabled, Invect checks on startup that the database has all\n   * required tables and columns. This does NOT run migrations — the\n   * developer is responsible for applying schema changes via the CLI:\n   *\n   *   npx invect generate    # regenerate schema files\n   *   npx drizzle-kit push    # apply via Drizzle\n   *   npx prisma db push      # apply via Prisma\n   *\n   * @example\n   * ```typescript\n   * const config = {\n   *   schemaVerification: true,           // warn on missing tables/columns\n   *   // or\n   *   schemaVerification: { strict: true }, // throw on missing tables/columns\n   * };\n   * ```\n   */\n  schemaVerification: z\n    .union([\n      z.boolean(),\n      z.object({\n        /** If true, throw an error when schema is invalid. If false, only log warnings. */\n        strict: z.boolean().default(false),\n      }),\n    ])\n    .optional(),\n  /**\n   * Default credentials to ensure on startup.\n   *\n   * Each entry is created if no credential with the same `name` already exists.\n   * Useful for development environments where you want API keys and OAuth\n   * tokens available immediately without running a separate seed script.\n   *\n   * @example\n   * ```typescript\n   * const config = {\n   *   defaultCredentials: [\n   *     {\n   *       name: 'Anthropic API Key',\n   *       type: 'http-api',\n   *       authType: 'bearer',\n   *       config: { token: process.env.SEED_ANTHROPIC_API_KEY! },\n   *       description: 'Seeded Anthropic credential',\n   *     },\n   *   ],\n   * };\n   * ```\n   */\n  defaultCredentials: z\n    .array(\n      z.object({\n        name: z.string(),\n        type: z.string(),\n        authType: z.string(),\n        config: z.record(z.string(), z.unknown()),\n        description: z.string().optional(),\n        isShared: z.boolean().optional(),\n        metadata: z.record(z.string(), z.unknown()).optional(),\n      }),\n    )\n    .optional(),\n});\n\n/**\n * Type inference from schemas\n */\nexport type QueryDatabasesConfig = z.infer<typeof queryDatabasesConfigSchema>;\nexport type ExecutionConfig = z.infer<typeof ExecutionConfigSchema>;\nexport type LoggingConfig = z.infer<typeof LoggingConfigSchema>;\nexport type InvectAuthConfigZod = z.infer<typeof InvectAuthConfigSchema>;\nexport type InvectConfig = z.infer<typeof InvectConfigSchema>;\n\nexport interface Logger {\n  debug(message: string, ...args: unknown[]): void;\n  info(message: string, ...args: unknown[]): void;\n  warn(message: string, ...args: unknown[]): void;\n  error(message: string, ...args: unknown[]): void;\n}\n"],"mappings":"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"}

package/dist/types/validation/common.schemas.cjs

@@ -0,0 +1,41 @@
+require("../../_virtual/_rolldown/runtime.cjs");
+let zod_v4 = require("zod/v4");
+zod_v4.z.string().uuid("Invalid UUID format");
+zod_v4.z.number().int("Version must be an integer").positive("Version must be a positive integer");
+const tagsSchema = zod_v4.z.array(zod_v4.z.string().trim().min(1, "Tag cannot be empty")).optional().default([]);
+zod_v4.z.enum([
+	"low",
+	"normal",
+	"high"
+]).default("normal");
+zod_v4.z.number().min(1e3, "Timeout must be at least 1 second (1000ms)").max(36e5, "Timeout cannot exceed 1 hour (3600000ms)").optional();
+zod_v4.z.number().min(0, "Retry count cannot be negative").max(10, "Retry count cannot exceed 10").default(0);
+zod_v4.z.string().max(255, "Search query cannot exceed 255 characters").optional();
+zod_v4.z.enum(["active", "inactive"]).optional();
+zod_v4.z.union([zod_v4.z.string().trim(), zod_v4.z.array(zod_v4.z.string().trim())]).optional();
+zod_v4.z.object({ id: zod_v4.z.string().min(1, "Flow ID is required") });
+zod_v4.z.object({ executionId: zod_v4.z.string().min(1, "Execution ID is required") });
+zod_v4.z.object({ versionId: zod_v4.z.string().min(1, "Version ID is required") });
+const successResponseSchema = (dataSchema) => zod_v4.z.object({
+	success: zod_v4.z.literal(true),
+	data: dataSchema,
+	timestamp: zod_v4.z.string().datetime()
+});
+zod_v4.z.object({
+	success: zod_v4.z.literal(false),
+	error: zod_v4.z.object({
+		code: zod_v4.z.string(),
+		message: zod_v4.z.string(),
+		details: zod_v4.z.array(zod_v4.z.object({
+			field: zod_v4.z.string().optional(),
+			message: zod_v4.z.string(),
+			value: zod_v4.z.unknown().optional()
+		})).optional()
+	}),
+	timestamp: zod_v4.z.string().datetime()
+});
+//#endregion
+exports.successResponseSchema = successResponseSchema;
+exports.tagsSchema = tagsSchema;
+
+//# sourceMappingURL=common.schemas.cjs.map

package/dist/types/validation/common.schemas.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.schemas.cjs","names":["z"],"sources":["../../../src/types/validation/common.schemas.ts"],"sourcesContent":["// Common Zod validation schemas for Invect API\n// Shared across all framework adapters (Express, NestJS, etc.)\n\nimport { z } from 'zod/v4';\n\n/**\n * Common validation schemas\n */\n\n// UUID validation\nexport const uuidSchema = z.string().uuid('Invalid UUID format');\n\n// Version number validation (positive integer)\nexport const versionSchema = z\n  .number()\n  .int('Version must be an integer')\n  .positive('Version must be a positive integer');\n\n// Tags array validation\nexport const tagsSchema = z\n  .array(z.string().trim().min(1, 'Tag cannot be empty'))\n  .optional()\n  .default([]);\n\n// Priority validation\nexport const prioritySchema = z.enum(['low', 'normal', 'high']).default('normal');\n\n// Timeout validation (1 second to 1 hour)\nexport const timeoutSchema = z\n  .number()\n  .min(1000, 'Timeout must be at least 1 second (1000ms)')\n  .max(3600000, 'Timeout cannot exceed 1 hour (3600000ms)')\n  .optional();\n\n// Retry count validation\nexport const retryCountSchema = z\n  .number()\n  .min(0, 'Retry count cannot be negative')\n  .max(10, 'Retry count cannot exceed 10')\n  .default(0);\n\n// Search and filter schemas\nexport const searchSchema = z\n  .string()\n  .max(255, 'Search query cannot exceed 255 characters')\n  .optional();\n\nexport const statusFilterSchema = z.enum(['active', 'inactive']).optional();\n\nexport const tagsFilterSchema = z.union([z.string().trim(), z.array(z.string().trim())]).optional();\n\n// // Query parameters schema\n// export const queryParamsSchema = paginatedResponseSchema.extend({\n//   search: searchSchema,\n//   status: statusFilterSchema,\n//   tags: tagsFilterSchema\n// });\n\n// ID parameter validation\nexport const flowIdParamSchema = z.object({\n  id: z.string().min(1, 'Flow ID is required'),\n});\n\nexport const executionIdParamSchema = z.object({\n  executionId: z.string().min(1, 'Execution ID is required'),\n});\n\nexport const versionIdParamSchema = z.object({\n  versionId: z.string().min(1, 'Version ID is required'),\n});\n\n// Response wrapper schemas\nexport const successResponseSchema = <T extends z.ZodType>(dataSchema: T) =>\n  z.object({\n    success: z.literal(true),\n    data: dataSchema,\n    timestamp: z.string().datetime(),\n  });\n\nexport const errorResponseSchema = z.object({\n  success: z.literal(false),\n  error: z.object({\n    code: z.string(),\n    message: z.string(),\n    details: z\n      .array(\n        z.object({\n          field: z.string().optional(),\n          message: z.string(),\n          value: z.unknown().optional(),\n        }),\n      )\n      .optional(),\n  }),\n  timestamp: z.string().datetime(),\n});\n"],"mappings":";;AAU0BA,OAAAA,EAAE,QAAQ,CAAC,KAAK,sBAAsB;AAGnCA,OAAAA,EAC1B,QAAQ,CACR,IAAI,6BAA6B,CACjC,SAAS,qCAAqC;AAGjD,MAAa,aAAaA,OAAAA,EACvB,MAAMA,OAAAA,EAAE,QAAQ,CAAC,MAAM,CAAC,IAAI,GAAG,sBAAsB,CAAC,CACtD,UAAU,CACV,QAAQ,EAAE,CAAC;AAGgBA,OAAAA,EAAE,KAAK;CAAC;CAAO;CAAU;CAAO,CAAC,CAAC,QAAQ,SAAS;AAGpDA,OAAAA,EAC1B,QAAQ,CACR,IAAI,KAAM,6CAA6C,CACvD,IAAI,MAAS,2CAA2C,CACxD,UAAU;AAGmBA,OAAAA,EAC7B,QAAQ,CACR,IAAI,GAAG,iCAAiC,CACxC,IAAI,IAAI,+BAA+B,CACvC,QAAQ,EAAE;AAGeA,OAAAA,EACzB,QAAQ,CACR,IAAI,KAAK,4CAA4C,CACrD,UAAU;AAEqBA,OAAAA,EAAE,KAAK,CAAC,UAAU,WAAW,CAAC,CAAC,UAAU;AAE3CA,OAAAA,EAAE,MAAM,CAACA,OAAAA,EAAE,QAAQ,CAAC,MAAM,EAAEA,OAAAA,EAAE,MAAMA,OAAAA,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,UAAU;AAUlEA,OAAAA,EAAE,OAAO,EACxC,IAAIA,OAAAA,EAAE,QAAQ,CAAC,IAAI,GAAG,sBAAsB,EAC7C,CAAC;AAEoCA,OAAAA,EAAE,OAAO,EAC7C,aAAaA,OAAAA,EAAE,QAAQ,CAAC,IAAI,GAAG,2BAA2B,EAC3D,CAAC;AAEkCA,OAAAA,EAAE,OAAO,EAC3C,WAAWA,OAAAA,EAAE,QAAQ,CAAC,IAAI,GAAG,yBAAyB,EACvD,CAAC;AAGF,MAAa,yBAA8C,eACzDA,OAAAA,EAAE,OAAO;CACP,SAASA,OAAAA,EAAE,QAAQ,KAAK;CACxB,MAAM;CACN,WAAWA,OAAAA,EAAE,QAAQ,CAAC,UAAU;CACjC,CAAC;AAE+BA,OAAAA,EAAE,OAAO;CAC1C,SAASA,OAAAA,EAAE,QAAQ,MAAM;CACzB,OAAOA,OAAAA,EAAE,OAAO;EACd,MAAMA,OAAAA,EAAE,QAAQ;EAChB,SAASA,OAAAA,EAAE,QAAQ;EACnB,SAASA,OAAAA,EACN,MACCA,OAAAA,EAAE,OAAO;GACP,OAAOA,OAAAA,EAAE,QAAQ,CAAC,UAAU;GAC5B,SAASA,OAAAA,EAAE,QAAQ;GACnB,OAAOA,OAAAA,EAAE,SAAS,CAAC,UAAU;GAC9B,CAAC,CACH,CACA,UAAU;EACd,CAAC;CACF,WAAWA,OAAAA,EAAE,QAAQ,CAAC,UAAU;CACjC,CAAC"}

package/dist/types/validation/common.schemas.js

@@ -0,0 +1,39 @@
+import { z } from "zod/v4";
+z.string().uuid("Invalid UUID format");
+z.number().int("Version must be an integer").positive("Version must be a positive integer");
+const tagsSchema = z.array(z.string().trim().min(1, "Tag cannot be empty")).optional().default([]);
+z.enum([
+	"low",
+	"normal",
+	"high"
+]).default("normal");
+z.number().min(1e3, "Timeout must be at least 1 second (1000ms)").max(36e5, "Timeout cannot exceed 1 hour (3600000ms)").optional();
+z.number().min(0, "Retry count cannot be negative").max(10, "Retry count cannot exceed 10").default(0);
+z.string().max(255, "Search query cannot exceed 255 characters").optional();
+z.enum(["active", "inactive"]).optional();
+z.union([z.string().trim(), z.array(z.string().trim())]).optional();
+z.object({ id: z.string().min(1, "Flow ID is required") });
+z.object({ executionId: z.string().min(1, "Execution ID is required") });
+z.object({ versionId: z.string().min(1, "Version ID is required") });
+const successResponseSchema = (dataSchema) => z.object({
+	success: z.literal(true),
+	data: dataSchema,
+	timestamp: z.string().datetime()
+});
+z.object({
+	success: z.literal(false),
+	error: z.object({
+		code: z.string(),
+		message: z.string(),
+		details: z.array(z.object({
+			field: z.string().optional(),
+			message: z.string(),
+			value: z.unknown().optional()
+		})).optional()
+	}),
+	timestamp: z.string().datetime()
+});
+//#endregion
+export { successResponseSchema, tagsSchema };
+
+//# sourceMappingURL=common.schemas.js.map

package/dist/types/validation/common.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.schemas.js","names":[],"sources":["../../../src/types/validation/common.schemas.ts"],"sourcesContent":["// Common Zod validation schemas for Invect API\n// Shared across all framework adapters (Express, NestJS, etc.)\n\nimport { z } from 'zod/v4';\n\n/**\n * Common validation schemas\n */\n\n// UUID validation\nexport const uuidSchema = z.string().uuid('Invalid UUID format');\n\n// Version number validation (positive integer)\nexport const versionSchema = z\n  .number()\n  .int('Version must be an integer')\n  .positive('Version must be a positive integer');\n\n// Tags array validation\nexport const tagsSchema = z\n  .array(z.string().trim().min(1, 'Tag cannot be empty'))\n  .optional()\n  .default([]);\n\n// Priority validation\nexport const prioritySchema = z.enum(['low', 'normal', 'high']).default('normal');\n\n// Timeout validation (1 second to 1 hour)\nexport const timeoutSchema = z\n  .number()\n  .min(1000, 'Timeout must be at least 1 second (1000ms)')\n  .max(3600000, 'Timeout cannot exceed 1 hour (3600000ms)')\n  .optional();\n\n// Retry count validation\nexport const retryCountSchema = z\n  .number()\n  .min(0, 'Retry count cannot be negative')\n  .max(10, 'Retry count cannot exceed 10')\n  .default(0);\n\n// Search and filter schemas\nexport const searchSchema = z\n  .string()\n  .max(255, 'Search query cannot exceed 255 characters')\n  .optional();\n\nexport const statusFilterSchema = z.enum(['active', 'inactive']).optional();\n\nexport const tagsFilterSchema = z.union([z.string().trim(), z.array(z.string().trim())]).optional();\n\n// // Query parameters schema\n// export const queryParamsSchema = paginatedResponseSchema.extend({\n//   search: searchSchema,\n//   status: statusFilterSchema,\n//   tags: tagsFilterSchema\n// });\n\n// ID parameter validation\nexport const flowIdParamSchema = z.object({\n  id: z.string().min(1, 'Flow ID is required'),\n});\n\nexport const executionIdParamSchema = z.object({\n  executionId: z.string().min(1, 'Execution ID is required'),\n});\n\nexport const versionIdParamSchema = z.object({\n  versionId: z.string().min(1, 'Version ID is required'),\n});\n\n// Response wrapper schemas\nexport const successResponseSchema = <T extends z.ZodType>(dataSchema: T) =>\n  z.object({\n    success: z.literal(true),\n    data: dataSchema,\n    timestamp: z.string().datetime(),\n  });\n\nexport const errorResponseSchema = z.object({\n  success: z.literal(false),\n  error: z.object({\n    code: z.string(),\n    message: z.string(),\n    details: z\n      .array(\n        z.object({\n          field: z.string().optional(),\n          message: z.string(),\n          value: z.unknown().optional(),\n        }),\n      )\n      .optional(),\n  }),\n  timestamp: z.string().datetime(),\n});\n"],"mappings":";AAU0B,EAAE,QAAQ,CAAC,KAAK,sBAAsB;AAGnC,EAC1B,QAAQ,CACR,IAAI,6BAA6B,CACjC,SAAS,qCAAqC;AAGjD,MAAa,aAAa,EACvB,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,IAAI,GAAG,sBAAsB,CAAC,CACtD,UAAU,CACV,QAAQ,EAAE,CAAC;AAGgB,EAAE,KAAK;CAAC;CAAO;CAAU;CAAO,CAAC,CAAC,QAAQ,SAAS;AAGpD,EAC1B,QAAQ,CACR,IAAI,KAAM,6CAA6C,CACvD,IAAI,MAAS,2CAA2C,CACxD,UAAU;AAGmB,EAC7B,QAAQ,CACR,IAAI,GAAG,iCAAiC,CACxC,IAAI,IAAI,+BAA+B,CACvC,QAAQ,EAAE;AAGe,EACzB,QAAQ,CACR,IAAI,KAAK,4CAA4C,CACrD,UAAU;AAEqB,EAAE,KAAK,CAAC,UAAU,WAAW,CAAC,CAAC,UAAU;AAE3C,EAAE,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,UAAU;AAUlE,EAAE,OAAO,EACxC,IAAI,EAAE,QAAQ,CAAC,IAAI,GAAG,sBAAsB,EAC7C,CAAC;AAEoC,EAAE,OAAO,EAC7C,aAAa,EAAE,QAAQ,CAAC,IAAI,GAAG,2BAA2B,EAC3D,CAAC;AAEkC,EAAE,OAAO,EAC3C,WAAW,EAAE,QAAQ,CAAC,IAAI,GAAG,yBAAyB,EACvD,CAAC;AAGF,MAAa,yBAA8C,eACzD,EAAE,OAAO;CACP,SAAS,EAAE,QAAQ,KAAK;CACxB,MAAM;CACN,WAAW,EAAE,QAAQ,CAAC,UAAU;CACjC,CAAC;AAE+B,EAAE,OAAO;CAC1C,SAAS,EAAE,QAAQ,MAAM;CACzB,OAAO,EAAE,OAAO;EACd,MAAM,EAAE,QAAQ;EAChB,SAAS,EAAE,QAAQ;EACnB,SAAS,EACN,MACC,EAAE,OAAO;GACP,OAAO,EAAE,QAAQ,CAAC,UAAU;GAC5B,SAAS,EAAE,QAAQ;GACnB,OAAO,EAAE,SAAS,CAAC,UAAU;GAC9B,CAAC,CACH,CACA,UAAU;EACd,CAAC;CACF,WAAW,EAAE,QAAQ,CAAC,UAAU;CACjC,CAAC"}

package/dist/types/validation/flow.schemas.cjs

@@ -0,0 +1,49 @@
+require("../../_virtual/_rolldown/runtime.cjs");
+const require_pagination_sort_filter = require("../schemas/pagination-sort-filter.cjs");
+const require_common_schemas = require("./common.schemas.cjs");
+const require_schemas_fresh = require("../../services/flow-versions/schemas-fresh.cjs");
+let zod_v4 = require("zod/v4");
+//#region src/types/validation/flow.schemas.ts
+/**
+* Flow creation schema
+*/
+const createFlowSchema = zod_v4.z.object({
+	name: zod_v4.z.string().min(1, "Flow name is required").max(255, "Flow name cannot exceed 255 characters").trim(),
+	isActive: zod_v4.z.boolean().optional()
+});
+zod_v4.z.object({
+	name: zod_v4.z.string().min(1, "Flow name cannot be empty").max(255, "Flow name cannot exceed 255 characters").trim().optional(),
+	description: zod_v4.z.string().max(1e3, "Description cannot exceed 1000 characters").trim().optional(),
+	tags: require_common_schemas.tagsSchema.optional(),
+	isActive: zod_v4.z.boolean().optional()
+});
+/**
+* Flow response schemas
+*/
+const flowSchema = zod_v4.z.object({
+	id: zod_v4.z.string(),
+	name: zod_v4.z.string(),
+	description: zod_v4.z.string().nullable(),
+	tags: zod_v4.z.array(zod_v4.z.string()),
+	isActive: zod_v4.z.boolean(),
+	createdAt: zod_v4.z.string().datetime(),
+	updatedAt: zod_v4.z.string().datetime()
+});
+const flowVersionSchema = zod_v4.z.object({
+	id: zod_v4.z.string(),
+	flowId: zod_v4.z.string(),
+	invectDefinition: require_schemas_fresh.invectDefinitionSchema,
+	isDraft: zod_v4.z.boolean().default(true),
+	createdBy: zod_v4.z.string().nullable(),
+	createdAt: zod_v4.z.string().datetime()
+});
+require_common_schemas.successResponseSchema(flowSchema);
+require_pagination_sort_filter.PaginatedResponseSchema(flowSchema);
+require_common_schemas.successResponseSchema(flowVersionSchema);
+require_pagination_sort_filter.PaginatedResponseSchema(flowVersionSchema);
+//#endregion
+exports.createFlowSchema = createFlowSchema;
+exports.flowSchema = flowSchema;
+exports.flowVersionSchema = flowVersionSchema;
+
+//# sourceMappingURL=flow.schemas.cjs.map

package/dist/types/validation/flow.schemas.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow.schemas.cjs","names":["z","tagsSchema","invectDefinitionSchema","successResponseSchema","PaginatedResponseSchema"],"sources":["../../../src/types/validation/flow.schemas.ts"],"sourcesContent":["// Flow-related Zod validation schemas for Invect API\n// Shared across all framework adapters (Express, NestJS, etc.)\n\nimport { z } from 'zod/v4';\nimport { successResponseSchema, tagsSchema } from './common.schemas';\nimport { invectDefinitionSchema } from 'src/services/flow-versions/schemas-fresh';\nimport { PaginatedResponseSchema } from '../schemas/pagination-sort-filter';\n\n/**\n * Flow creation schema\n */\nexport const createFlowSchema = z.object({\n  name: z\n    .string()\n    .min(1, 'Flow name is required')\n    .max(255, 'Flow name cannot exceed 255 characters')\n    .trim(),\n  isActive: z.boolean().optional(),\n});\n\n/**\n * Flow update schema (all fields optional except constraints)\n */\nexport const updateFlowSchema = z.object({\n  name: z\n    .string()\n    .min(1, 'Flow name cannot be empty')\n    .max(255, 'Flow name cannot exceed 255 characters')\n    .trim()\n    .optional(),\n\n  description: z.string().max(1000, 'Description cannot exceed 1000 characters').trim().optional(),\n\n  tags: tagsSchema.optional(),\n\n  isActive: z.boolean().optional(),\n});\n\n/**\n * Flow response schemas\n */\nexport const flowSchema = z.object({\n  id: z.string(),\n  name: z.string(),\n  description: z.string().nullable(),\n  tags: z.array(z.string()),\n  isActive: z.boolean(),\n  createdAt: z.string().datetime(),\n  updatedAt: z.string().datetime(),\n});\n\nexport const flowVersionSchema = z.object({\n  id: z.string(),\n  flowId: z.string(),\n  invectDefinition: invectDefinitionSchema,\n  isDraft: z.boolean().default(true),\n  createdBy: z.string().nullable(),\n  createdAt: z.string().datetime(),\n});\n\n/**\n * API response schemas\n */\nexport const flowResponseSchema = successResponseSchema(flowSchema);\nexport const flowsResponseSchema = PaginatedResponseSchema(flowSchema);\nexport const flowVersionResponseSchema = successResponseSchema(flowVersionSchema);\nexport const flowVersionsResponseSchema = PaginatedResponseSchema(flowVersionSchema);\n\n/**\n * Type inference helpers\n */\nexport type InvectDefinitionSchema = z.infer<typeof invectDefinitionSchema>;\nexport type CreateFlowSchema = z.infer<typeof createFlowSchema>;\nexport type UpdateFlowSchema = z.infer<typeof updateFlowSchema>;\nexport type FlowSchema = z.infer<typeof flowSchema>;\nexport type FlowVersionSchema = z.infer<typeof flowVersionSchema>;\nexport type FlowResponseSchema = z.infer<typeof flowResponseSchema>;\nexport type FlowsResponseSchema = z.infer<typeof flowsResponseSchema>;\nexport type FlowVersionResponseSchema = z.infer<typeof flowVersionResponseSchema>;\nexport type FlowVersionsResponseSchema = z.infer<typeof flowVersionsResponseSchema>;\n\n// Schema-derived node and edge types (recommended for new code)\nexport type SchemaFlowNode = z.infer<typeof invectDefinitionSchema>['nodes'][0];\nexport type SchemaFlowEdge = z.infer<typeof invectDefinitionSchema>['edges'][0];\nexport type SchemaInvectDefinition = z.infer<typeof invectDefinitionSchema>;\n"],"mappings":";;;;;;;;;AAWA,MAAa,mBAAmBA,OAAAA,EAAE,OAAO;CACvC,MAAMA,OAAAA,EACH,QAAQ,CACR,IAAI,GAAG,wBAAwB,CAC/B,IAAI,KAAK,yCAAyC,CAClD,MAAM;CACT,UAAUA,OAAAA,EAAE,SAAS,CAAC,UAAU;CACjC,CAAC;AAK8BA,OAAAA,EAAE,OAAO;CACvC,MAAMA,OAAAA,EACH,QAAQ,CACR,IAAI,GAAG,4BAA4B,CACnC,IAAI,KAAK,yCAAyC,CAClD,MAAM,CACN,UAAU;CAEb,aAAaA,OAAAA,EAAE,QAAQ,CAAC,IAAI,KAAM,4CAA4C,CAAC,MAAM,CAAC,UAAU;CAEhG,MAAMC,uBAAAA,WAAW,UAAU;CAE3B,UAAUD,OAAAA,EAAE,SAAS,CAAC,UAAU;CACjC,CAAC;;;;AAKF,MAAa,aAAaA,OAAAA,EAAE,OAAO;CACjC,IAAIA,OAAAA,EAAE,QAAQ;CACd,MAAMA,OAAAA,EAAE,QAAQ;CAChB,aAAaA,OAAAA,EAAE,QAAQ,CAAC,UAAU;CAClC,MAAMA,OAAAA,EAAE,MAAMA,OAAAA,EAAE,QAAQ,CAAC;CACzB,UAAUA,OAAAA,EAAE,SAAS;CACrB,WAAWA,OAAAA,EAAE,QAAQ,CAAC,UAAU;CAChC,WAAWA,OAAAA,EAAE,QAAQ,CAAC,UAAU;CACjC,CAAC;AAEF,MAAa,oBAAoBA,OAAAA,EAAE,OAAO;CACxC,IAAIA,OAAAA,EAAE,QAAQ;CACd,QAAQA,OAAAA,EAAE,QAAQ;CAClB,kBAAkBE,sBAAAA;CAClB,SAASF,OAAAA,EAAE,SAAS,CAAC,QAAQ,KAAK;CAClC,WAAWA,OAAAA,EAAE,QAAQ,CAAC,UAAU;CAChC,WAAWA,OAAAA,EAAE,QAAQ,CAAC,UAAU;CACjC,CAAC;AAKgCG,uBAAAA,sBAAsB,WAAW;AAChCC,+BAAAA,wBAAwB,WAAW;AAC7BD,uBAAAA,sBAAsB,kBAAkB;AACvCC,+BAAAA,wBAAwB,kBAAkB"}

package/dist/types/validation/flow.schemas.js

@@ -0,0 +1,46 @@
+import { PaginatedResponseSchema } from "../schemas/pagination-sort-filter.js";
+import { successResponseSchema, tagsSchema } from "./common.schemas.js";
+import { invectDefinitionSchema } from "../../services/flow-versions/schemas-fresh.js";
+import { z } from "zod/v4";
+//#region src/types/validation/flow.schemas.ts
+/**
+* Flow creation schema
+*/
+const createFlowSchema = z.object({
+	name: z.string().min(1, "Flow name is required").max(255, "Flow name cannot exceed 255 characters").trim(),
+	isActive: z.boolean().optional()
+});
+z.object({
+	name: z.string().min(1, "Flow name cannot be empty").max(255, "Flow name cannot exceed 255 characters").trim().optional(),
+	description: z.string().max(1e3, "Description cannot exceed 1000 characters").trim().optional(),
+	tags: tagsSchema.optional(),
+	isActive: z.boolean().optional()
+});
+/**
+* Flow response schemas
+*/
+const flowSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	description: z.string().nullable(),
+	tags: z.array(z.string()),
+	isActive: z.boolean(),
+	createdAt: z.string().datetime(),
+	updatedAt: z.string().datetime()
+});
+const flowVersionSchema = z.object({
+	id: z.string(),
+	flowId: z.string(),
+	invectDefinition: invectDefinitionSchema,
+	isDraft: z.boolean().default(true),
+	createdBy: z.string().nullable(),
+	createdAt: z.string().datetime()
+});
+successResponseSchema(flowSchema);
+PaginatedResponseSchema(flowSchema);
+successResponseSchema(flowVersionSchema);
+PaginatedResponseSchema(flowVersionSchema);
+//#endregion
+export { createFlowSchema, flowSchema, flowVersionSchema };
+
+//# sourceMappingURL=flow.schemas.js.map

package/dist/types/validation/flow.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow.schemas.js","names":[],"sources":["../../../src/types/validation/flow.schemas.ts"],"sourcesContent":["// Flow-related Zod validation schemas for Invect API\n// Shared across all framework adapters (Express, NestJS, etc.)\n\nimport { z } from 'zod/v4';\nimport { successResponseSchema, tagsSchema } from './common.schemas';\nimport { invectDefinitionSchema } from 'src/services/flow-versions/schemas-fresh';\nimport { PaginatedResponseSchema } from '../schemas/pagination-sort-filter';\n\n/**\n * Flow creation schema\n */\nexport const createFlowSchema = z.object({\n  name: z\n    .string()\n    .min(1, 'Flow name is required')\n    .max(255, 'Flow name cannot exceed 255 characters')\n    .trim(),\n  isActive: z.boolean().optional(),\n});\n\n/**\n * Flow update schema (all fields optional except constraints)\n */\nexport const updateFlowSchema = z.object({\n  name: z\n    .string()\n    .min(1, 'Flow name cannot be empty')\n    .max(255, 'Flow name cannot exceed 255 characters')\n    .trim()\n    .optional(),\n\n  description: z.string().max(1000, 'Description cannot exceed 1000 characters').trim().optional(),\n\n  tags: tagsSchema.optional(),\n\n  isActive: z.boolean().optional(),\n});\n\n/**\n * Flow response schemas\n */\nexport const flowSchema = z.object({\n  id: z.string(),\n  name: z.string(),\n  description: z.string().nullable(),\n  tags: z.array(z.string()),\n  isActive: z.boolean(),\n  createdAt: z.string().datetime(),\n  updatedAt: z.string().datetime(),\n});\n\nexport const flowVersionSchema = z.object({\n  id: z.string(),\n  flowId: z.string(),\n  invectDefinition: invectDefinitionSchema,\n  isDraft: z.boolean().default(true),\n  createdBy: z.string().nullable(),\n  createdAt: z.string().datetime(),\n});\n\n/**\n * API response schemas\n */\nexport const flowResponseSchema = successResponseSchema(flowSchema);\nexport const flowsResponseSchema = PaginatedResponseSchema(flowSchema);\nexport const flowVersionResponseSchema = successResponseSchema(flowVersionSchema);\nexport const flowVersionsResponseSchema = PaginatedResponseSchema(flowVersionSchema);\n\n/**\n * Type inference helpers\n */\nexport type InvectDefinitionSchema = z.infer<typeof invectDefinitionSchema>;\nexport type CreateFlowSchema = z.infer<typeof createFlowSchema>;\nexport type UpdateFlowSchema = z.infer<typeof updateFlowSchema>;\nexport type FlowSchema = z.infer<typeof flowSchema>;\nexport type FlowVersionSchema = z.infer<typeof flowVersionSchema>;\nexport type FlowResponseSchema = z.infer<typeof flowResponseSchema>;\nexport type FlowsResponseSchema = z.infer<typeof flowsResponseSchema>;\nexport type FlowVersionResponseSchema = z.infer<typeof flowVersionResponseSchema>;\nexport type FlowVersionsResponseSchema = z.infer<typeof flowVersionsResponseSchema>;\n\n// Schema-derived node and edge types (recommended for new code)\nexport type SchemaFlowNode = z.infer<typeof invectDefinitionSchema>['nodes'][0];\nexport type SchemaFlowEdge = z.infer<typeof invectDefinitionSchema>['edges'][0];\nexport type SchemaInvectDefinition = z.infer<typeof invectDefinitionSchema>;\n"],"mappings":";;;;;;;;AAWA,MAAa,mBAAmB,EAAE,OAAO;CACvC,MAAM,EACH,QAAQ,CACR,IAAI,GAAG,wBAAwB,CAC/B,IAAI,KAAK,yCAAyC,CAClD,MAAM;CACT,UAAU,EAAE,SAAS,CAAC,UAAU;CACjC,CAAC;AAK8B,EAAE,OAAO;CACvC,MAAM,EACH,QAAQ,CACR,IAAI,GAAG,4BAA4B,CACnC,IAAI,KAAK,yCAAyC,CAClD,MAAM,CACN,UAAU;CAEb,aAAa,EAAE,QAAQ,CAAC,IAAI,KAAM,4CAA4C,CAAC,MAAM,CAAC,UAAU;CAEhG,MAAM,WAAW,UAAU;CAE3B,UAAU,EAAE,SAAS,CAAC,UAAU;CACjC,CAAC;;;;AAKF,MAAa,aAAa,EAAE,OAAO;CACjC,IAAI,EAAE,QAAQ;CACd,MAAM,EAAE,QAAQ;CAChB,aAAa,EAAE,QAAQ,CAAC,UAAU;CAClC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC;CACzB,UAAU,EAAE,SAAS;CACrB,WAAW,EAAE,QAAQ,CAAC,UAAU;CAChC,WAAW,EAAE,QAAQ,CAAC,UAAU;CACjC,CAAC;AAEF,MAAa,oBAAoB,EAAE,OAAO;CACxC,IAAI,EAAE,QAAQ;CACd,QAAQ,EAAE,QAAQ;CAClB,kBAAkB;CAClB,SAAS,EAAE,SAAS,CAAC,QAAQ,KAAK;CAClC,WAAW,EAAE,QAAQ,CAAC,UAAU;CAChC,WAAW,EAAE,QAAQ,CAAC,UAAU;CACjC,CAAC;AAKgC,sBAAsB,WAAW;AAChC,wBAAwB,WAAW;AAC7B,sBAAsB,kBAAkB;AACvC,wBAAwB,kBAAkB"}

package/dist/types/validation.cjs

@@ -0,0 +1,49 @@
+//#region src/types/validation.ts
+const FLOW_VALIDATION_ERROR_TYPES = {
+	ERROR: {
+		INVALID_EDGE_REFERENCE: "INVALID_EDGE_REFERENCE",
+		SELF_REFERENCING_EDGE: "SELF_REFERENCING_EDGE",
+		CIRCULAR_DEPENDENCY: "CIRCULAR_DEPENDENCY",
+		MULTIPLE_MANUAL_TRIGGERS: "MULTIPLE_MANUAL_TRIGGERS",
+		VALIDATION_SYSTEM_ERROR: "VALIDATION_SYSTEM_ERROR"
+	},
+	WARNING: {
+		EMPTY_FLOW: "EMPTY_FLOW",
+		ENTRY_NODE_HAS_INCOMING_EDGES: "ENTRY_NODE_HAS_INCOMING_EDGES",
+		DISCONNECTED_NODE: "DISCONNECTED_NODE",
+		DUPLICATE_EDGE: "DUPLICATE_EDGE"
+	}
+};
+var ValidationContext = class {
+	definition;
+	analysis;
+	issues = [];
+	constructor(definition, analysis) {
+		this.definition = definition;
+		this.analysis = analysis;
+	}
+	addError(type, message, context) {
+		this.issues.push({
+			severity: "error",
+			type,
+			message,
+			...context
+		});
+	}
+	addWarning(type, message, context) {
+		this.issues.push({
+			severity: "warning",
+			type,
+			message,
+			...context
+		});
+	}
+	hasErrors() {
+		return this.issues.some((issue) => issue.severity === "error");
+	}
+};
+//#endregion
+exports.FLOW_VALIDATION_ERROR_TYPES = FLOW_VALIDATION_ERROR_TYPES;
+exports.ValidationContext = ValidationContext;
+
+//# sourceMappingURL=validation.cjs.map

package/dist/types/validation.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.cjs","names":[],"sources":["../../src/types/validation.ts"],"sourcesContent":["// Flow validation types shared between frontend and backend\nimport type {\n  FlowNodeDefinitions,\n  InvectDefinition,\n  FlowEdge,\n} from '../services/flow-versions/schemas-fresh';\n\ninterface ValidationOutput {\n  message: string;\n\n  // Optional fields for frontend highlighting\n  nodeId?: string;\n  edgeId?: string;\n  sourceNodeId?: string;\n  targetNodeId?: string;\n  sourceNodeType?: string;\n  targetNodeType?: string;\n  additionalContext?: Record<string, unknown>;\n}\n\n// Internal validation types for the validation engine\nexport interface ValidationIssue extends ValidationOutput {\n  severity: 'error' | 'warning';\n  type: string;\n}\n\nexport interface GraphAnalysis {\n  nodeMap: Map<string, FlowNodeDefinitions>;\n  edgeMap: Map<string, FlowEdge>;\n  incomingEdges: Map<string, FlowEdge[]>;\n  outgoingEdges: Map<string, FlowEdge[]>;\n}\n\nexport interface FlowValidationError extends ValidationOutput {\n  severity: 'error';\n  type: keyof (typeof FLOW_VALIDATION_ERROR_TYPES)['ERROR'];\n}\n\nexport interface FlowValidationWarning extends ValidationOutput {\n  severity: 'warning';\n  type: keyof (typeof FLOW_VALIDATION_ERROR_TYPES)['WARNING'];\n}\n\nexport type FlowValidationResult =\n  | {\n      isValid: false;\n      errors: FlowValidationError[];\n      warnings: FlowValidationWarning[];\n    }\n  | {\n      isValid: true;\n      warnings?: FlowValidationWarning[];\n    };\n\nexport interface FlowValidationErrorResponse {\n  message: string;\n  validation: FlowValidationResult;\n}\n\n// ─── Error / Warning type constants ──────────────────────────────────────────\n//\n// Errors  = will cause execution to crash or throw (the flow cannot run).\n// Warnings = probably unintended but the flow will still execute.\n\nexport const FLOW_VALIDATION_ERROR_TYPES = {\n  ERROR: {\n    INVALID_EDGE_REFERENCE: 'INVALID_EDGE_REFERENCE',\n    SELF_REFERENCING_EDGE: 'SELF_REFERENCING_EDGE',\n    CIRCULAR_DEPENDENCY: 'CIRCULAR_DEPENDENCY',\n    MULTIPLE_MANUAL_TRIGGERS: 'MULTIPLE_MANUAL_TRIGGERS',\n    VALIDATION_SYSTEM_ERROR: 'VALIDATION_SYSTEM_ERROR',\n  },\n  WARNING: {\n    EMPTY_FLOW: 'EMPTY_FLOW',\n    ENTRY_NODE_HAS_INCOMING_EDGES: 'ENTRY_NODE_HAS_INCOMING_EDGES',\n    DISCONNECTED_NODE: 'DISCONNECTED_NODE',\n    DUPLICATE_EDGE: 'DUPLICATE_EDGE',\n  },\n} as const;\n\n// ─── Validation context ──────────────────────────────────────────────────────\n\nexport class ValidationContext {\n  public readonly definition: InvectDefinition;\n  public readonly analysis: GraphAnalysis;\n  public readonly issues: ValidationIssue[] = [];\n\n  constructor(definition: InvectDefinition, analysis: GraphAnalysis) {\n    this.definition = definition;\n    this.analysis = analysis;\n  }\n\n  addError(type: string, message: string, context?: Partial<ValidationIssue>): void {\n    this.issues.push({ severity: 'error', type, message, ...context });\n  }\n\n  addWarning(type: string, message: string, context?: Partial<ValidationIssue>): void {\n    this.issues.push({ severity: 'warning', type, message, ...context });\n  }\n\n  hasErrors(): boolean {\n    return this.issues.some((issue) => issue.severity === 'error');\n  }\n}\n"],"mappings":";AAgEA,MAAa,8BAA8B;CACzC,OAAO;EACL,wBAAwB;EACxB,uBAAuB;EACvB,qBAAqB;EACrB,0BAA0B;EAC1B,yBAAyB;EAC1B;CACD,SAAS;EACP,YAAY;EACZ,+BAA+B;EAC/B,mBAAmB;EACnB,gBAAgB;EACjB;CACF;AAID,IAAa,oBAAb,MAA+B;CAC7B;CACA;CACA,SAA4C,EAAE;CAE9C,YAAY,YAA8B,UAAyB;AACjE,OAAK,aAAa;AAClB,OAAK,WAAW;;CAGlB,SAAS,MAAc,SAAiB,SAA0C;AAChF,OAAK,OAAO,KAAK;GAAE,UAAU;GAAS;GAAM;GAAS,GAAG;GAAS,CAAC;;CAGpE,WAAW,MAAc,SAAiB,SAA0C;AAClF,OAAK,OAAO,KAAK;GAAE,UAAU;GAAW;GAAM;GAAS,GAAG;GAAS,CAAC;;CAGtE,YAAqB;AACnB,SAAO,KAAK,OAAO,MAAM,UAAU,MAAM,aAAa,QAAQ"}

package/dist/types/validation.d.cts

@@ -0,0 +1,49 @@
+//#region src/types/validation.d.ts
+interface ValidationOutput {
+  message: string;
+  nodeId?: string;
+  edgeId?: string;
+  sourceNodeId?: string;
+  targetNodeId?: string;
+  sourceNodeType?: string;
+  targetNodeType?: string;
+  additionalContext?: Record<string, unknown>;
+}
+interface ValidationIssue extends ValidationOutput {
+  severity: 'error' | 'warning';
+  type: string;
+}
+interface FlowValidationError extends ValidationOutput {
+  severity: 'error';
+  type: keyof (typeof FLOW_VALIDATION_ERROR_TYPES)['ERROR'];
+}
+interface FlowValidationWarning extends ValidationOutput {
+  severity: 'warning';
+  type: keyof (typeof FLOW_VALIDATION_ERROR_TYPES)['WARNING'];
+}
+type FlowValidationResult = {
+  isValid: false;
+  errors: FlowValidationError[];
+  warnings: FlowValidationWarning[];
+} | {
+  isValid: true;
+  warnings?: FlowValidationWarning[];
+};
+declare const FLOW_VALIDATION_ERROR_TYPES: {
+  readonly ERROR: {
+    readonly INVALID_EDGE_REFERENCE: "INVALID_EDGE_REFERENCE";
+    readonly SELF_REFERENCING_EDGE: "SELF_REFERENCING_EDGE";
+    readonly CIRCULAR_DEPENDENCY: "CIRCULAR_DEPENDENCY";
+    readonly MULTIPLE_MANUAL_TRIGGERS: "MULTIPLE_MANUAL_TRIGGERS";
+    readonly VALIDATION_SYSTEM_ERROR: "VALIDATION_SYSTEM_ERROR";
+  };
+  readonly WARNING: {
+    readonly EMPTY_FLOW: "EMPTY_FLOW";
+    readonly ENTRY_NODE_HAS_INCOMING_EDGES: "ENTRY_NODE_HAS_INCOMING_EDGES";
+    readonly DISCONNECTED_NODE: "DISCONNECTED_NODE";
+    readonly DUPLICATE_EDGE: "DUPLICATE_EDGE";
+  };
+};
+//#endregion
+export { FLOW_VALIDATION_ERROR_TYPES, FlowValidationError, FlowValidationResult, FlowValidationWarning, ValidationIssue };
+//# sourceMappingURL=validation.d.cts.map

package/dist/types/validation.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.cts","names":[],"sources":["../../src/types/validation.ts"],"mappings":";UAOU,gBAAA;EACR,OAAA;EAGA,MAAA;EACA,MAAA;EACA,YAAA;EACA,YAAA;EACA,cAAA;EACA,cAAA;EACA,iBAAA,GAAoB,MAAA;AAAA;AAAA,UAIL,eAAA,SAAwB,gBAAA;EACvC,QAAA;EACA,IAAA;AAAA;AAAA,UAUe,mBAAA,SAA4B,gBAAA;EAC3C,QAAA;EACA,IAAA,gBAAoB,2BAAA;AAAA;AAAA,UAGL,qBAAA,SAA8B,gBAAA;EAC7C,QAAA;EACA,IAAA,gBAAoB,2BAAA;AAAA;AAAA,KAGV,oBAAA;EAEN,OAAA;EACA,MAAA,EAAQ,mBAAA;EACR,QAAA,EAAU,qBAAA;AAAA;EAGV,OAAA;EACA,QAAA,GAAW,qBAAA;AAAA;AAAA,cAaJ,2BAAA;EAAA"}

package/dist/types/validation.d.ts

@@ -0,0 +1,49 @@
+//#region src/types/validation.d.ts
+interface ValidationOutput {
+  message: string;
+  nodeId?: string;
+  edgeId?: string;
+  sourceNodeId?: string;
+  targetNodeId?: string;
+  sourceNodeType?: string;
+  targetNodeType?: string;
+  additionalContext?: Record<string, unknown>;
+}
+interface ValidationIssue extends ValidationOutput {
+  severity: 'error' | 'warning';
+  type: string;
+}
+interface FlowValidationError extends ValidationOutput {
+  severity: 'error';
+  type: keyof (typeof FLOW_VALIDATION_ERROR_TYPES)['ERROR'];
+}
+interface FlowValidationWarning extends ValidationOutput {
+  severity: 'warning';
+  type: keyof (typeof FLOW_VALIDATION_ERROR_TYPES)['WARNING'];
+}
+type FlowValidationResult = {
+  isValid: false;
+  errors: FlowValidationError[];
+  warnings: FlowValidationWarning[];
+} | {
+  isValid: true;
+  warnings?: FlowValidationWarning[];
+};
+declare const FLOW_VALIDATION_ERROR_TYPES: {
+  readonly ERROR: {
+    readonly INVALID_EDGE_REFERENCE: "INVALID_EDGE_REFERENCE";
+    readonly SELF_REFERENCING_EDGE: "SELF_REFERENCING_EDGE";
+    readonly CIRCULAR_DEPENDENCY: "CIRCULAR_DEPENDENCY";
+    readonly MULTIPLE_MANUAL_TRIGGERS: "MULTIPLE_MANUAL_TRIGGERS";
+    readonly VALIDATION_SYSTEM_ERROR: "VALIDATION_SYSTEM_ERROR";
+  };
+  readonly WARNING: {
+    readonly EMPTY_FLOW: "EMPTY_FLOW";
+    readonly ENTRY_NODE_HAS_INCOMING_EDGES: "ENTRY_NODE_HAS_INCOMING_EDGES";
+    readonly DISCONNECTED_NODE: "DISCONNECTED_NODE";
+    readonly DUPLICATE_EDGE: "DUPLICATE_EDGE";
+  };
+};
+//#endregion
+export { FLOW_VALIDATION_ERROR_TYPES, FlowValidationError, FlowValidationResult, FlowValidationWarning, ValidationIssue };
+//# sourceMappingURL=validation.d.ts.map

package/dist/types/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","names":[],"sources":["../../src/types/validation.ts"],"mappings":";UAOU,gBAAA;EACR,OAAA;EAGA,MAAA;EACA,MAAA;EACA,YAAA;EACA,YAAA;EACA,cAAA;EACA,cAAA;EACA,iBAAA,GAAoB,MAAA;AAAA;AAAA,UAIL,eAAA,SAAwB,gBAAA;EACvC,QAAA;EACA,IAAA;AAAA;AAAA,UAUe,mBAAA,SAA4B,gBAAA;EAC3C,QAAA;EACA,IAAA,gBAAoB,2BAAA;AAAA;AAAA,UAGL,qBAAA,SAA8B,gBAAA;EAC7C,QAAA;EACA,IAAA,gBAAoB,2BAAA;AAAA;AAAA,KAGV,oBAAA;EAEN,OAAA;EACA,MAAA,EAAQ,mBAAA;EACR,QAAA,EAAU,qBAAA;AAAA;EAGV,OAAA;EACA,QAAA,GAAW,qBAAA;AAAA;AAAA,cAaJ,2BAAA;EAAA"}

package/dist/types/validation.js

@@ -0,0 +1,48 @@
+//#region src/types/validation.ts
+const FLOW_VALIDATION_ERROR_TYPES = {
+	ERROR: {
+		INVALID_EDGE_REFERENCE: "INVALID_EDGE_REFERENCE",
+		SELF_REFERENCING_EDGE: "SELF_REFERENCING_EDGE",
+		CIRCULAR_DEPENDENCY: "CIRCULAR_DEPENDENCY",
+		MULTIPLE_MANUAL_TRIGGERS: "MULTIPLE_MANUAL_TRIGGERS",
+		VALIDATION_SYSTEM_ERROR: "VALIDATION_SYSTEM_ERROR"
+	},
+	WARNING: {
+		EMPTY_FLOW: "EMPTY_FLOW",
+		ENTRY_NODE_HAS_INCOMING_EDGES: "ENTRY_NODE_HAS_INCOMING_EDGES",
+		DISCONNECTED_NODE: "DISCONNECTED_NODE",
+		DUPLICATE_EDGE: "DUPLICATE_EDGE"
+	}
+};
+var ValidationContext = class {
+	definition;
+	analysis;
+	issues = [];
+	constructor(definition, analysis) {
+		this.definition = definition;
+		this.analysis = analysis;
+	}
+	addError(type, message, context) {
+		this.issues.push({
+			severity: "error",
+			type,
+			message,
+			...context
+		});
+	}
+	addWarning(type, message, context) {
+		this.issues.push({
+			severity: "warning",
+			type,
+			message,
+			...context
+		});
+	}
+	hasErrors() {
+		return this.issues.some((issue) => issue.severity === "error");
+	}
+};
+//#endregion
+export { FLOW_VALIDATION_ERROR_TYPES, ValidationContext };
+
+//# sourceMappingURL=validation.js.map