@invect/core 0.0.1

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

@@ -0,0 +1,181 @@
+require("../../_virtual/_rolldown/runtime.cjs");
+const require_chat_types = require("../../services/chat/chat-types.cjs");
+let zod_v4 = require("zod/v4");
+//#region src/types/schemas-fresh/invect-config.ts
+const databaseConfigSchema = zod_v4.z.object({
+	connectionString: zod_v4.z.string().min(1, "Database URL is required"),
+	type: zod_v4.z.enum([
+		"postgresql",
+		"sqlite",
+		"mysql"
+	]),
+	id: zod_v4.z.string(),
+	name: zod_v4.z.string().optional()
+});
+/**
+* Database configuration schema
+*/
+const queryDatabasesConfigSchema = zod_v4.z.array(databaseConfigSchema).optional().default(() => []);
+/**
+* Execution configuration schema
+*/
+const ExecutionConfigSchema = zod_v4.z.object({
+	defaultTimeout: zod_v4.z.number().positive().default(6e4),
+	maxConcurrentExecutions: zod_v4.z.number().positive().default(10),
+	enableTracing: zod_v4.z.boolean().default(true),
+	flowTimeoutMs: zod_v4.z.number().positive().default(6e5),
+	heartbeatIntervalMs: zod_v4.z.number().positive().default(3e4),
+	staleRunCheckIntervalMs: zod_v4.z.number().positive().default(6e4)
+});
+/**
+* Log level enum values
+*/
+const LogLevelSchema = zod_v4.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 = zod_v4.z.object({
+	level: LogLevelSchema.default("silent"),
+	scopes: zod_v4.z.record(zod_v4.z.string(), LogLevelSchema).optional()
+});
+zod_v4.z.enum([
+	"admin",
+	"editor",
+	"operator",
+	"viewer"
+]);
+/**
+* Invect permissions
+*/
+const InvectPermissionSchema = zod_v4.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 = zod_v4.z.object({
+	enabled: zod_v4.z.boolean().default(false),
+	resolveUser: zod_v4.z.any().optional(),
+	roleMapper: zod_v4.z.record(zod_v4.z.string(), zod_v4.z.string()).optional(),
+	customRoles: zod_v4.z.record(zod_v4.z.string(), zod_v4.z.array(InvectPermissionSchema)).optional(),
+	customAuthorize: zod_v4.z.any().optional(),
+	publicRoutes: zod_v4.z.array(zod_v4.z.string()).optional(),
+	defaultRole: zod_v4.z.string().default("viewer"),
+	onAuthFailure: zod_v4.z.enum([
+		"throw",
+		"log",
+		"deny"
+	]).default("throw"),
+	useFlowAccessTable: zod_v4.z.boolean().default(false)
+});
+/**
+* Core Invect configuration schema
+*/
+const InvectConfigSchema = zod_v4.z.object({
+	queryDatabases: queryDatabasesConfigSchema.optional(),
+	baseDatabaseConfig: databaseConfigSchema,
+	logging: LoggingConfigSchema.default(() => ({ level: "info" })).optional(),
+	logger: zod_v4.z.any().optional(),
+	basePath: zod_v4.z.string().optional(),
+	execution: ExecutionConfigSchema.optional(),
+	auth: InvectAuthConfigSchema.optional(),
+	triggers: zod_v4.z.object({
+		webhookBaseUrl: zod_v4.z.string().optional(),
+		cronEnabled: zod_v4.z.boolean().default(true)
+	}).optional(),
+	chat: require_chat_types.ChatConfigSchema.optional(),
+	plugins: zod_v4.z.array(zod_v4.z.any()).optional(),
+	schemaVerification: zod_v4.z.union([zod_v4.z.boolean(), zod_v4.z.object({ strict: zod_v4.z.boolean().default(false) })]).optional(),
+	defaultCredentials: zod_v4.z.array(zod_v4.z.object({
+		name: zod_v4.z.string(),
+		type: zod_v4.z.string(),
+		authType: zod_v4.z.string(),
+		config: zod_v4.z.record(zod_v4.z.string(), zod_v4.z.unknown()),
+		description: zod_v4.z.string().optional(),
+		isShared: zod_v4.z.boolean().optional(),
+		metadata: zod_v4.z.record(zod_v4.z.string(), zod_v4.z.unknown()).optional()
+	})).optional()
+});
+//#endregion
+exports.ExecutionConfigSchema = ExecutionConfigSchema;
+exports.InvectAuthConfigSchema = InvectAuthConfigSchema;
+exports.InvectConfigSchema = InvectConfigSchema;
+exports.InvectPermissionSchema = InvectPermissionSchema;
+exports.LogLevelSchema = LogLevelSchema;
+exports.LoggingConfigSchema = LoggingConfigSchema;
+exports.queryDatabasesConfigSchema = queryDatabasesConfigSchema;
+
+//# sourceMappingURL=invect-config.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"invect-config.cjs","names":["z","ChatConfigSchema"],"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/schemas-fresh/invect-config.d.cts

@@ -0,0 +1,207 @@
+import { z } from "zod/v4";
+
+//#region src/types/schemas-fresh/invect-config.d.ts
+declare const databaseConfigSchema: z.ZodObject<{
+  connectionString: z.ZodString;
+  type: z.ZodEnum<{
+    mysql: "mysql";
+    sqlite: "sqlite";
+    postgresql: "postgresql";
+  }>;
+  id: z.ZodString;
+  name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type InvectDatabaseConfig = z.infer<typeof databaseConfigSchema>;
+/**
+ * Database configuration schema
+ */
+declare const queryDatabasesConfigSchema: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+  connectionString: z.ZodString;
+  type: z.ZodEnum<{
+    mysql: "mysql";
+    sqlite: "sqlite";
+    postgresql: "postgresql";
+  }>;
+  id: z.ZodString;
+  name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>>>;
+/**
+ * Execution configuration schema
+ */
+declare const ExecutionConfigSchema: z.ZodObject<{
+  defaultTimeout: z.ZodDefault<z.ZodNumber>;
+  maxConcurrentExecutions: z.ZodDefault<z.ZodNumber>;
+  enableTracing: z.ZodDefault<z.ZodBoolean>;
+  flowTimeoutMs: z.ZodDefault<z.ZodNumber>;
+  heartbeatIntervalMs: z.ZodDefault<z.ZodNumber>;
+  staleRunCheckIntervalMs: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * 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
+ *     }
+ *   }
+ * };
+ * ```
+ */
+declare const LoggingConfigSchema: z.ZodObject<{
+  level: z.ZodDefault<z.ZodEnum<{
+    error: "error";
+    debug: "debug";
+    info: "info";
+    warn: "warn";
+    silent: "silent";
+  }>>;
+  scopes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+    error: "error";
+    debug: "debug";
+    info: "info";
+    warn: "warn";
+    silent: "silent";
+  }>>>;
+}, z.core.$strip>;
+/**
+ * Core Invect configuration schema
+ */
+declare const InvectConfigSchema: z.ZodObject<{
+  queryDatabases: z.ZodOptional<z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+    connectionString: z.ZodString;
+    type: z.ZodEnum<{
+      mysql: "mysql";
+      sqlite: "sqlite";
+      postgresql: "postgresql";
+    }>;
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>>>>;
+  baseDatabaseConfig: z.ZodObject<{
+    connectionString: z.ZodString;
+    type: z.ZodEnum<{
+      mysql: "mysql";
+      sqlite: "sqlite";
+      postgresql: "postgresql";
+    }>;
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  logging: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+    level: z.ZodDefault<z.ZodEnum<{
+      error: "error";
+      debug: "debug";
+      info: "info";
+      warn: "warn";
+      silent: "silent";
+    }>>;
+    scopes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+      error: "error";
+      debug: "debug";
+      info: "info";
+      warn: "warn";
+      silent: "silent";
+    }>>>;
+  }, z.core.$strip>>>;
+  logger: z.ZodOptional<z.ZodAny>;
+  basePath: z.ZodOptional<z.ZodString>;
+  execution: z.ZodOptional<z.ZodObject<{
+    defaultTimeout: z.ZodDefault<z.ZodNumber>;
+    maxConcurrentExecutions: z.ZodDefault<z.ZodNumber>;
+    enableTracing: z.ZodDefault<z.ZodBoolean>;
+    flowTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    heartbeatIntervalMs: z.ZodDefault<z.ZodNumber>;
+    staleRunCheckIntervalMs: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>>;
+  auth: z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    resolveUser: z.ZodOptional<z.ZodAny>;
+    roleMapper: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    customRoles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodEnum<{
+      "flow:create": "flow:create";
+      "flow:read": "flow:read";
+      "flow:update": "flow:update";
+      "flow:delete": "flow:delete";
+      "flow:publish": "flow:publish";
+      "flow-version:create": "flow-version:create";
+      "flow-version:read": "flow-version:read";
+      "flow-run:create": "flow-run:create";
+      "flow-run:read": "flow-run:read";
+      "flow-run:cancel": "flow-run:cancel";
+      "credential:create": "credential:create";
+      "credential:read": "credential:read";
+      "credential:update": "credential:update";
+      "credential:delete": "credential:delete";
+      "agent-tool:read": "agent-tool:read";
+      "agent-tool:configure": "agent-tool:configure";
+      "node:test": "node:test";
+      "admin:*": "admin:*";
+    }>>>>;
+    customAuthorize: z.ZodOptional<z.ZodAny>;
+    publicRoutes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    defaultRole: z.ZodDefault<z.ZodString>;
+    onAuthFailure: z.ZodDefault<z.ZodEnum<{
+      throw: "throw";
+      log: "log";
+      deny: "deny";
+    }>>;
+    useFlowAccessTable: z.ZodDefault<z.ZodBoolean>;
+  }, z.core.$strip>>;
+  triggers: z.ZodOptional<z.ZodObject<{
+    webhookBaseUrl: z.ZodOptional<z.ZodString>;
+    cronEnabled: z.ZodDefault<z.ZodBoolean>;
+  }, z.core.$strip>>;
+  chat: z.ZodOptional<z.ZodObject<{
+    credentialId: z.ZodOptional<z.ZodString>;
+    defaultModel: z.ZodOptional<z.ZodString>;
+    maxSteps: z.ZodDefault<z.ZodNumber>;
+    maxHistoryMessages: z.ZodDefault<z.ZodNumber>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+  }, z.core.$strip>>;
+  plugins: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+  schemaVerification: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+    strict: z.ZodDefault<z.ZodBoolean>;
+  }, z.core.$strip>]>>;
+  defaultCredentials: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodString;
+    authType: z.ZodString;
+    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    description: z.ZodOptional<z.ZodString>;
+    isShared: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+type ExecutionConfig = z.infer<typeof ExecutionConfigSchema>;
+type LoggingConfig = z.infer<typeof LoggingConfigSchema>;
+type InvectConfig = z.infer<typeof InvectConfigSchema>;
+interface Logger {
+  debug(message: string, ...args: unknown[]): void;
+  info(message: string, ...args: unknown[]): void;
+  warn(message: string, ...args: unknown[]): void;
+  error(message: string, ...args: unknown[]): void;
+}
+//#endregion
+export { ExecutionConfig, InvectConfig, InvectDatabaseConfig, Logger, LoggingConfig, queryDatabasesConfigSchema };
+//# sourceMappingURL=invect-config.d.cts.map

package/dist/types/schemas-fresh/invect-config.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invect-config.d.cts","names":[],"sources":["../../../src/types/schemas-fresh/invect-config.ts"],"mappings":";;;cAGM,oBAAA,EAAoB,CAAA,CAAA,SAAA;;;;;;;;;;KAOd,oBAAA,GAAuB,CAAA,CAAE,KAAA,QAAa,oBAAA;;;;cAKrC,0BAAA,EAA0B,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,WAAA,CAAA,CAAA,CAAA,QAAA,CAAA,CAAA,CAAA,SAAA;;;;;;;;;;;;;cAQ1B,qBAAA,EAAqB,CAAA,CAAA,SAAA;;;;;;;;;;AARlC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmEa,mBAAA,EAAmB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;cA0HnB,kBAAA,EAAkB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAwInB,eAAA,GAAkB,CAAA,CAAE,KAAA,QAAa,qBAAA;AAAA,KACjC,aAAA,GAAgB,CAAA,CAAE,KAAA,QAAa,mBAAA;AAAA,KAE/B,YAAA,GAAe,CAAA,CAAE,KAAA,QAAa,kBAAA;AAAA,UAEzB,MAAA;EACf,KAAA,CAAM,OAAA,aAAoB,IAAA;EAC1B,IAAA,CAAK,OAAA,aAAoB,IAAA;EACzB,IAAA,CAAK,OAAA,aAAoB,IAAA;EACzB,KAAA,CAAM,OAAA,aAAoB,IAAA;AAAA"}

package/dist/types/schemas-fresh/invect-config.d.ts

@@ -0,0 +1,207 @@
+import { z } from "zod/v4";
+
+//#region src/types/schemas-fresh/invect-config.d.ts
+declare const databaseConfigSchema: z.ZodObject<{
+  connectionString: z.ZodString;
+  type: z.ZodEnum<{
+    mysql: "mysql";
+    sqlite: "sqlite";
+    postgresql: "postgresql";
+  }>;
+  id: z.ZodString;
+  name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type InvectDatabaseConfig = z.infer<typeof databaseConfigSchema>;
+/**
+ * Database configuration schema
+ */
+declare const queryDatabasesConfigSchema: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+  connectionString: z.ZodString;
+  type: z.ZodEnum<{
+    mysql: "mysql";
+    sqlite: "sqlite";
+    postgresql: "postgresql";
+  }>;
+  id: z.ZodString;
+  name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>>>;
+/**
+ * Execution configuration schema
+ */
+declare const ExecutionConfigSchema: z.ZodObject<{
+  defaultTimeout: z.ZodDefault<z.ZodNumber>;
+  maxConcurrentExecutions: z.ZodDefault<z.ZodNumber>;
+  enableTracing: z.ZodDefault<z.ZodBoolean>;
+  flowTimeoutMs: z.ZodDefault<z.ZodNumber>;
+  heartbeatIntervalMs: z.ZodDefault<z.ZodNumber>;
+  staleRunCheckIntervalMs: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * 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
+ *     }
+ *   }
+ * };
+ * ```
+ */
+declare const LoggingConfigSchema: z.ZodObject<{
+  level: z.ZodDefault<z.ZodEnum<{
+    error: "error";
+    debug: "debug";
+    info: "info";
+    warn: "warn";
+    silent: "silent";
+  }>>;
+  scopes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+    error: "error";
+    debug: "debug";
+    info: "info";
+    warn: "warn";
+    silent: "silent";
+  }>>>;
+}, z.core.$strip>;
+/**
+ * Core Invect configuration schema
+ */
+declare const InvectConfigSchema: z.ZodObject<{
+  queryDatabases: z.ZodOptional<z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+    connectionString: z.ZodString;
+    type: z.ZodEnum<{
+      mysql: "mysql";
+      sqlite: "sqlite";
+      postgresql: "postgresql";
+    }>;
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>>>>;
+  baseDatabaseConfig: z.ZodObject<{
+    connectionString: z.ZodString;
+    type: z.ZodEnum<{
+      mysql: "mysql";
+      sqlite: "sqlite";
+      postgresql: "postgresql";
+    }>;
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  logging: z.ZodOptional<z.ZodDefault<z.ZodObject<{
+    level: z.ZodDefault<z.ZodEnum<{
+      error: "error";
+      debug: "debug";
+      info: "info";
+      warn: "warn";
+      silent: "silent";
+    }>>;
+    scopes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+      error: "error";
+      debug: "debug";
+      info: "info";
+      warn: "warn";
+      silent: "silent";
+    }>>>;
+  }, z.core.$strip>>>;
+  logger: z.ZodOptional<z.ZodAny>;
+  basePath: z.ZodOptional<z.ZodString>;
+  execution: z.ZodOptional<z.ZodObject<{
+    defaultTimeout: z.ZodDefault<z.ZodNumber>;
+    maxConcurrentExecutions: z.ZodDefault<z.ZodNumber>;
+    enableTracing: z.ZodDefault<z.ZodBoolean>;
+    flowTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    heartbeatIntervalMs: z.ZodDefault<z.ZodNumber>;
+    staleRunCheckIntervalMs: z.ZodDefault<z.ZodNumber>;
+  }, z.core.$strip>>;
+  auth: z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    resolveUser: z.ZodOptional<z.ZodAny>;
+    roleMapper: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    customRoles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodEnum<{
+      "flow:create": "flow:create";
+      "flow:read": "flow:read";
+      "flow:update": "flow:update";
+      "flow:delete": "flow:delete";
+      "flow:publish": "flow:publish";
+      "flow-version:create": "flow-version:create";
+      "flow-version:read": "flow-version:read";
+      "flow-run:create": "flow-run:create";
+      "flow-run:read": "flow-run:read";
+      "flow-run:cancel": "flow-run:cancel";
+      "credential:create": "credential:create";
+      "credential:read": "credential:read";
+      "credential:update": "credential:update";
+      "credential:delete": "credential:delete";
+      "agent-tool:read": "agent-tool:read";
+      "agent-tool:configure": "agent-tool:configure";
+      "node:test": "node:test";
+      "admin:*": "admin:*";
+    }>>>>;
+    customAuthorize: z.ZodOptional<z.ZodAny>;
+    publicRoutes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    defaultRole: z.ZodDefault<z.ZodString>;
+    onAuthFailure: z.ZodDefault<z.ZodEnum<{
+      throw: "throw";
+      log: "log";
+      deny: "deny";
+    }>>;
+    useFlowAccessTable: z.ZodDefault<z.ZodBoolean>;
+  }, z.core.$strip>>;
+  triggers: z.ZodOptional<z.ZodObject<{
+    webhookBaseUrl: z.ZodOptional<z.ZodString>;
+    cronEnabled: z.ZodDefault<z.ZodBoolean>;
+  }, z.core.$strip>>;
+  chat: z.ZodOptional<z.ZodObject<{
+    credentialId: z.ZodOptional<z.ZodString>;
+    defaultModel: z.ZodOptional<z.ZodString>;
+    maxSteps: z.ZodDefault<z.ZodNumber>;
+    maxHistoryMessages: z.ZodDefault<z.ZodNumber>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+  }, z.core.$strip>>;
+  plugins: z.ZodOptional<z.ZodArray<z.ZodAny>>;
+  schemaVerification: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+    strict: z.ZodDefault<z.ZodBoolean>;
+  }, z.core.$strip>]>>;
+  defaultCredentials: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodString;
+    authType: z.ZodString;
+    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    description: z.ZodOptional<z.ZodString>;
+    isShared: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+type ExecutionConfig = z.infer<typeof ExecutionConfigSchema>;
+type LoggingConfig = z.infer<typeof LoggingConfigSchema>;
+type InvectConfig = z.infer<typeof InvectConfigSchema>;
+interface Logger {
+  debug(message: string, ...args: unknown[]): void;
+  info(message: string, ...args: unknown[]): void;
+  warn(message: string, ...args: unknown[]): void;
+  error(message: string, ...args: unknown[]): void;
+}
+//#endregion
+export { ExecutionConfig, ExecutionConfigSchema, InvectConfig, InvectConfigSchema, InvectDatabaseConfig, Logger, LoggingConfig, LoggingConfigSchema, queryDatabasesConfigSchema };
+//# sourceMappingURL=invect-config.d.ts.map

package/dist/types/schemas-fresh/invect-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invect-config.d.ts","names":[],"sources":["../../../src/types/schemas-fresh/invect-config.ts"],"mappings":";;;cAGM,oBAAA,EAAoB,CAAA,CAAA,SAAA;;;;;;;;;;KAOd,oBAAA,GAAuB,CAAA,CAAE,KAAA,QAAa,oBAAA;;;;cAKrC,0BAAA,EAA0B,CAAA,CAAA,UAAA,CAAA,CAAA,CAAA,WAAA,CAAA,CAAA,CAAA,QAAA,CAAA,CAAA,CAAA,SAAA;;;;;;;;;;;;;cAQ1B,qBAAA,EAAqB,CAAA,CAAA,SAAA;;;;;;;;;;AARlC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmEa,mBAAA,EAAmB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;cA0HnB,kBAAA,EAAkB,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAwInB,eAAA,GAAkB,CAAA,CAAE,KAAA,QAAa,qBAAA;AAAA,KACjC,aAAA,GAAgB,CAAA,CAAE,KAAA,QAAa,mBAAA;AAAA,KAE/B,YAAA,GAAe,CAAA,CAAE,KAAA,QAAa,kBAAA;AAAA,UAEzB,MAAA;EACf,KAAA,CAAM,OAAA,aAAoB,IAAA;EAC1B,IAAA,CAAK,OAAA,aAAoB,IAAA;EACzB,IAAA,CAAK,OAAA,aAAoB,IAAA;EACzB,KAAA,CAAM,OAAA,aAAoB,IAAA;AAAA"}