@invect/core 0.0.1

package/dist/types/plugin.types.d.cts

@@ -0,0 +1,654 @@
+import { ActionDefinition } from "../actions/types.cjs";
+import { AuthorizationContext, AuthorizationResult, InvectIdentity, InvectPermission } from "./auth.types.cjs";
+
+//#region src/types/plugin.types.d.ts
+/**
+ * Abstract field types that map to concrete column types per dialect.
+ *
+ * | Abstract    | SQLite        | PostgreSQL       | MySQL              |
+ * |-------------|---------------|------------------|--------------------|
+ * | "string"    | text          | text             | varchar(255)       |
+ * | "text"      | text          | text             | text               |
+ * | "number"    | integer       | integer          | int                |
+ * | "boolean"   | integer(bool) | boolean          | boolean            |
+ * | "date"      | text          | timestamp        | timestamp          |
+ * | "json"      | text(json)    | json             | json               |
+ * | "uuid"      | text          | uuid             | varchar(36)        |
+ * | "bigint"    | integer       | bigint           | bigint             |
+ * | string[]    | N/A (enum)    | pgEnum values    | mysqlEnum values   |
+ */
+type PluginFieldType = 'string' | 'text' | 'number' | 'boolean' | 'date' | 'json' | 'uuid' | 'bigint' | string[];
+/**
+ * Abstract field definition for plugin database schemas.
+ *
+ * Plugins declare fields using this format. The CLI schema generator
+ * converts these to dialect-specific Drizzle column definitions.
+ */
+interface PluginFieldAttribute {
+  /** Abstract column type */
+  type: PluginFieldType;
+  /**
+   * Whether the field is required (NOT NULL).
+   * @default true
+   */
+  required?: boolean;
+  /** Whether to add a UNIQUE constraint */
+  unique?: boolean;
+  /** Whether this field is the primary key (or part of a composite PK) */
+  primaryKey?: boolean;
+  /**
+   * Foreign key reference.
+   * `table` is the Drizzle table name (e.g., "flows", "credentials").
+   */
+  references?: {
+    table: string;
+    field: string;
+    onDelete?: 'cascade' | 'set null' | 'restrict' | 'no action';
+  };
+  /** Whether to create an index on this column */
+  index?: boolean;
+  /**
+   * Default value for the column.
+   * - Primitives are used as literal defaults
+   * - "uuid()" generates a UUID default
+   * - "now()" generates a current timestamp default
+   * - "true" / "false" for booleans
+   */
+  defaultValue?: string | number | boolean | 'uuid()' | 'now()';
+  /**
+   * For string fields, the max length (MySQL varchar).
+   * Ignored for SQLite/PostgreSQL text columns.
+   * @default 255
+   */
+  maxLength?: number;
+  /**
+   * TypeScript type annotation for the column (Drizzle's $type<>()).
+   * Used for JSON columns or text columns storing typed data.
+   *
+   * @example "Record<string, unknown>"
+   * @example "string[]"
+   */
+  typeAnnotation?: string;
+  /**
+   * JSON mode for text/json columns.
+   * When true on SQLite, uses text({ mode: 'json' }).
+   */
+  jsonMode?: boolean;
+}
+/**
+ * Abstract table definition for plugin schemas.
+ */
+interface PluginTableDefinition {
+  /**
+   * Column definitions keyed by field name.
+   * Field names are camelCase; the generator converts to snake_case for DB columns.
+   */
+  fields: Record<string, PluginFieldAttribute>;
+  /**
+   * Composite primary key columns (if not using a single-column PK).
+   * Array of field names that together form the primary key.
+   */
+  compositePrimaryKey?: string[];
+  /**
+   * Whether to skip this table in migration generation.
+   * Useful for tables that are conditionally created.
+   * @default false
+   */
+  disableMigration?: boolean;
+  /**
+   * Custom DB table name. If not provided, the key in the schema object
+   * is used, converted to snake_case.
+   */
+  tableName?: string;
+  /**
+   * Table creation order hint. Lower numbers are created first.
+   * Use this when tables have foreign key dependencies.
+   * @default 100
+   */
+  order?: number;
+}
+/**
+ * Plugin schema declaration.
+ *
+ * Keys are logical table names (camelCase). Use an existing core table name
+ * (e.g., "flows", "credentials") to add fields to that table (additive only).
+ *
+ * @example
+ * ```typescript
+ * const schema: InvectPluginSchema = {
+ *   // New table
+ *   auditLogs: {
+ *     fields: {
+ *       id: { type: 'uuid', primaryKey: true, defaultValue: 'uuid()' },
+ *       action: { type: 'string', required: true },
+ *       userId: { type: 'string', references: { table: 'flows', field: 'id' } },
+ *       metadata: { type: 'json' },
+ *       createdAt: { type: 'date', defaultValue: 'now()' },
+ *     },
+ *   },
+ *   // Extend existing core table
+ *   flows: {
+ *     fields: {
+ *       ownerId: { type: 'string' },
+ *       tenantId: { type: 'string', index: true },
+ *     },
+ *   },
+ * };
+ * ```
+ */
+type InvectPluginSchema = Record<string, PluginTableDefinition>;
+/**
+ * An API endpoint defined by a plugin.
+ *
+ * Framework adapters (Express, Next.js, NestJS) mount these automatically.
+ * The handler receives a framework-agnostic request/response interface.
+ */
+interface InvectPluginEndpoint {
+  /** HTTP method */
+  method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+  /**
+   * Path relative to the Invect base path.
+   * Supports Express-style params: `/my-plugin/items/:id`
+   */
+  path: string;
+  /**
+   * The handler function.
+   * Receives parsed body/params/query and the Invect core instance.
+   * Must return a serializable response.
+   */
+  handler: (context: PluginEndpointContext) => Promise<PluginEndpointResponse>;
+  /**
+   * Required permission to access this endpoint.
+   * If set, the framework adapter enforces authorization before calling the handler.
+   */
+  permission?: InvectPermission;
+  /**
+   * If true, this endpoint does not require authentication.
+   * @default false
+   */
+  isPublic?: boolean;
+}
+/**
+ * Narrow API surface exposed to plugin endpoint handlers.
+ *
+ * This gives plugins access to core functionality (auth, flow access, etc.)
+ * without coupling them to the full Invect class. Framework adapters
+ * populate this from their core instance.
+ */
+interface PluginEndpointCoreApi {
+  /** Get all permissions for an identity (based on role) */
+  getPermissions(identity: InvectIdentity | null): InvectPermission[];
+  /** Get available roles and their permission definitions */
+  getAvailableRoles(): Array<{
+    role: string;
+    permissions: InvectPermission[];
+  }>;
+  /** Get the resolved role string for an identity */
+  getResolvedRole(identity: InvectIdentity): string | null;
+  /** Whether the flow access table feature is enabled */
+  isFlowAccessTableEnabled(): boolean;
+  /** List flow access records for a flow */
+  listFlowAccess(flowId: string): Promise<unknown[]>;
+  /** Grant access to a flow */
+  grantFlowAccess(input: {
+    flowId: string;
+    userId?: string;
+    teamId?: string;
+    permission: 'owner' | 'editor' | 'operator' | 'viewer';
+    grantedBy?: string;
+    expiresAt?: Date | string;
+  }): Promise<unknown>;
+  /** Revoke a specific flow access record */
+  revokeFlowAccess(accessId: string): Promise<void>;
+  /** Get all flow IDs accessible to a user/teams */
+  getAccessibleFlowIds(userId: string, teamIds?: string[]): Promise<string[]>;
+  /** Get the highest permission level a user/teams has for a flow */
+  getFlowPermission(flowId: string, userId: string, teamIds?: string[]): Promise<'owner' | 'editor' | 'operator' | 'viewer' | null>;
+  /** Authorize an action for an identity */
+  authorize(context: AuthorizationContext): Promise<AuthorizationResult>;
+}
+/**
+ * Narrow database API exposed to plugin endpoint handlers.
+ *
+ * Plugins should use this instead of reaching into framework-specific
+ * database clients directly. It keeps plugin code portable across the
+ * supported host database types while still allowing schema-owning plugins
+ * to persist their own records.
+ */
+interface PluginDatabaseApi {
+  /** Host database dialect */
+  type: 'postgresql' | 'sqlite' | 'mysql';
+  /** Execute a query and return result rows */
+  query<T = Record<string, unknown>>(sql: string, params?: unknown[]): Promise<T[]>;
+  /** Execute a statement where no result rows are needed */
+  execute(sql: string, params?: unknown[]): Promise<void>;
+}
+/**
+ * Context passed to plugin endpoint handlers.
+ */
+interface PluginEndpointContext {
+  /** Parsed request body (for POST/PUT/PATCH) */
+  body: Record<string, unknown>;
+  /** URL path parameters (e.g., { id: '123' }) */
+  params: Record<string, string>;
+  /** URL query parameters */
+  query: Record<string, string | undefined>;
+  /** Request headers */
+  headers: Record<string, string | undefined>;
+  /** Resolved identity (null if unauthenticated or public route) */
+  identity: InvectIdentity | null;
+  /** Database API for plugin-owned tables */
+  database: PluginDatabaseApi;
+  /** The raw Request object (Web API Request) */
+  request: Request;
+  /**
+   * Core API — provides access to auth, flow access, and authorization
+   * services. Populated by the framework adapter.
+   */
+  core: PluginEndpointCoreApi;
+}
+/**
+ * Response from a plugin endpoint handler.
+ */
+type PluginEndpointResponse = {
+  status?: number;
+  body: unknown;
+} | {
+  status?: number;
+  stream: ReadableStream;
+} | Response;
+/**
+ * Context for flow run lifecycle hooks.
+ */
+interface FlowRunHookContext {
+  /** The flow ID being executed */
+  flowId: string;
+  /** The flow run ID */
+  flowRunId: string;
+  /** The flow version number */
+  flowVersion: number;
+  /** Input data for the flow run */
+  inputs: Record<string, unknown>;
+  /** Identity of the user who triggered the run (if available) */
+  identity?: InvectIdentity | null;
+}
+/**
+ * Context for node execution lifecycle hooks.
+ */
+interface NodeExecutionHookContext {
+  /** The flow run context */
+  flowRun: FlowRunHookContext;
+  /** The node ID being executed */
+  nodeId: string;
+  /** The node type (action ID or "AGENT") */
+  nodeType: string;
+  /** The node's label */
+  nodeLabel?: string;
+  /** Input data for this node */
+  inputs: Record<string, unknown>;
+  /** Resolved config params for this node */
+  params: Record<string, unknown>;
+}
+/**
+ * Result from an afterNodeExecute hook.
+ */
+interface NodeExecutionHookResult {
+  /** Optionally override the node output */
+  output?: unknown;
+}
+/**
+ * Plugin hooks for intercepting Invect lifecycle events.
+ *
+ * Hooks run in plugin array order. A hook returning `{ cancel: true }`
+ * short-circuits the operation (remaining plugins are skipped).
+ */
+interface InvectPluginHooks {
+  /**
+   * Runs before a flow execution starts.
+   * Return `{ cancel: true, reason: '...' }` to prevent the run.
+   * Return `{ inputs: {...} }` to modify the inputs.
+   */
+  beforeFlowRun?: (context: FlowRunHookContext) => Promise<void | {
+    cancel?: boolean;
+    reason?: string;
+    inputs?: Record<string, unknown>;
+  }>;
+  /**
+   * Runs after a flow execution completes (success or failure).
+   */
+  afterFlowRun?: (context: FlowRunHookContext & {
+    status: 'SUCCESS' | 'FAILED' | 'CANCELLED';
+    outputs?: Record<string, unknown>;
+    error?: string;
+    duration?: number;
+  }) => Promise<void>;
+  /**
+   * Runs before each node executes.
+   * Return `{ skip: true }` to skip this node.
+   * Return `{ params: {...} }` to override resolved params.
+   */
+  beforeNodeExecute?: (context: NodeExecutionHookContext) => Promise<void | {
+    skip?: boolean;
+    params?: Record<string, unknown>;
+  }>;
+  /**
+   * Runs after each node executes.
+   * Return `{ output: ... }` to override the node's output.
+   */
+  afterNodeExecute?: (context: NodeExecutionHookContext & {
+    status: 'SUCCESS' | 'FAILED' | 'SKIPPED';
+    output?: unknown;
+    error?: string;
+    duration?: number;
+  }) => Promise<void | NodeExecutionHookResult>;
+  /**
+   * Runs before every API request (in framework adapters).
+   * Return a Response to short-circuit (like better-auth's onRequest).
+   * Return `{ request }` to modify the request.
+   */
+  onRequest?: (request: Request, context: {
+    path: string;
+    method: string;
+    identity: InvectIdentity | null;
+  }) => Promise<void | {
+    response: Response;
+  } | {
+    request: Request;
+  }>;
+  /**
+   * Runs after every API response (in framework adapters).
+   * Return a Response to replace the original response.
+   */
+  onResponse?: (response: Response, context: {
+    path: string;
+    method: string;
+    identity: InvectIdentity | null;
+  }) => Promise<void | {
+    response: Response;
+  }>;
+  /**
+   * Runs during authorization checks.
+   * Return `{ allowed: true/false }` to override the default RBAC result.
+   * Return void to use the default authorization logic.
+   */
+  onAuthorize?: (context: {
+    identity: InvectIdentity | null;
+    action: InvectPermission;
+    resource?: {
+      type: string;
+      id?: string;
+    };
+    database?: PluginDatabaseApi;
+  }) => Promise<void | AuthorizationResult>;
+}
+/**
+ * Context provided to a plugin's `init()` function.
+ *
+ * Gives plugins access to Invect's internals for deep integration.
+ */
+interface InvectPluginContext {
+  /**
+   * The full Invect configuration (read-only).
+   * Plugins can read config but not modify it after init.
+   */
+  config: Record<string, unknown>;
+  /** Logger instance for the plugin */
+  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;
+  };
+  /**
+   * Check if another plugin is registered.
+   *
+   * @example
+   * ```typescript
+   * if (ctx.hasPlugin('rbac')) {
+   *   // RBAC plugin is active, can rely on identity being resolved
+   * }
+   * ```
+   */
+  hasPlugin: (pluginId: string) => boolean;
+  /**
+   * Get another registered plugin by ID.
+   * Returns null if the plugin is not registered.
+   */
+  getPlugin: (pluginId: string) => InvectPlugin | null;
+  /**
+   * Register additional actions at init time.
+   * Equivalent to calling `invect.registerAction()` for each action.
+   */
+  registerAction: (action: ActionDefinition) => void;
+  /**
+   * Store plugin-specific data accessible to other plugins and hooks.
+   * This is a simple key-value store scoped to the plugin.
+   */
+  store: Map<string, unknown>;
+}
+/**
+ * Optional return value from `init()`.
+ * Allows plugins to modify Invect's configuration or provide additional context.
+ */
+interface InvectPluginInitResult {
+  /**
+   * Additional options to merge into the Invect config.
+   * Shallow-merged with the existing config. Cannot override core fields.
+   */
+  options?: Record<string, unknown>;
+  /**
+   * Additional context to merge into the plugin context.
+   * Available to other plugins via `ctx.store`.
+   */
+  context?: Record<string, unknown>;
+}
+/**
+ * The Invect Plugin interface.
+ *
+ * Only `id` is required. All other properties are optional and enable
+ * specific extension capabilities.
+ *
+ * @example
+ * ```typescript
+ * import type { InvectPlugin } from '@invect/core';
+ *
+ * export function myPlugin(options?: MyPluginOptions): InvectPlugin {
+ *   return {
+ *     id: 'my-plugin',
+ *
+ *     schema: {
+ *       auditLogs: {
+ *         fields: {
+ *           id: { type: 'uuid', primaryKey: true, defaultValue: 'uuid()' },
+ *           action: { type: 'string', required: true },
+ *           createdAt: { type: 'date', defaultValue: 'now()' },
+ *         },
+ *       },
+ *     },
+ *
+ *     actions: [myCustomAction],
+ *
+ *     endpoints: [{
+ *       method: 'GET',
+ *       path: '/my-plugin/stats',
+ *       handler: async (ctx) => ({ body: { count: 42 } }),
+ *     }],
+ *
+ *     hooks: {
+ *       afterFlowRun: async (context) => {
+ *         console.log(`Flow ${context.flowId} completed with ${context.status}`);
+ *       },
+ *     },
+ *
+ *     async init(ctx) {
+ *       ctx.logger.info('My plugin initialized');
+ *     },
+ *
+ *     async shutdown() {
+ *       // cleanup
+ *     },
+ *   };
+ * }
+ * ```
+ */
+interface InvectPlugin {
+  /**
+   * Unique plugin identifier.
+   * Used for `hasPlugin()` / `getPlugin()` lookups and logging.
+   */
+  id: string;
+  /**
+   * Human-readable plugin name (for logging and diagnostics).
+   */
+  name?: string;
+  /**
+   * Called during `Invect.initialize()`, after the action registry is created
+   * but before the service factory is built.
+   *
+   * Use this to:
+   * - Register actions dynamically
+   * - Set up plugin-internal state
+   * - Read configuration from other plugins
+   * - Validate plugin prerequisites
+   */
+  init?: (context: InvectPluginContext) => Promise<InvectPluginInitResult | void> | InvectPluginInitResult | void;
+  /**
+   * Database schema required by this plugin.
+   *
+   * Declared using the abstract `InvectPluginSchema` format.
+   * The Invect CLI generates the concrete Drizzle schema files
+   * from core + plugin schemas combined.
+   *
+   * Run `npx invect generate` after adding/changing plugin schemas.
+   */
+  schema?: InvectPluginSchema;
+  /**
+   * Table names that this plugin requires to exist in the database.
+   *
+   * Used during startup to verify that all required tables are present.
+   * If any are missing, Invect logs a clear, developer-friendly error
+   * explaining which plugin needs which tables and how to fix it.
+   *
+   * This is separate from `schema` — use `requiredTables` when your plugin
+   * relies on tables that are managed externally (e.g., better-auth creates
+   * its own tables) or when you want a lightweight existence check without
+   * needing to declare a full abstract schema.
+   *
+   * If `schema` is declared and `requiredTables` is not, the table names
+   * from `schema` are used automatically.
+   *
+   * @example
+   * ```typescript
+   * // Plugin that relies on better-auth's tables
+   * requiredTables: ['user', 'session', 'account', 'verification']
+   *
+   * // Plugin that declares its own schema (requiredTables inferred)
+   * schema: { auditLogs: { tableName: 'audit_logs', fields: { ... } } }
+   * ```
+   */
+  requiredTables?: string[];
+  /**
+   * Actions (nodes + agent tools) provided by this plugin.
+   *
+   * These are registered into the ActionRegistry during initialization,
+   * making them available as flow nodes and agent tools.
+   */
+  actions?: ActionDefinition[];
+  /**
+   * API endpoints provided by this plugin.
+   *
+   * Framework adapters (Express, Next.js, NestJS) automatically mount
+   * these alongside the core Invect routes.
+   */
+  endpoints?: InvectPluginEndpoint[];
+  /**
+   * Lifecycle hooks for intercepting flow execution, API requests,
+   * and authorization.
+   */
+  hooks?: InvectPluginHooks;
+  /**
+   * Human-readable setup instructions shown when required tables are missing.
+   * Overrides the default generic Drizzle instructions.
+   *
+   * @example
+   * ```typescript
+   * setupInstructions: 'Run `pnpm db:push` to create the better-auth tables.'
+   * ```
+   */
+  setupInstructions?: string;
+  /**
+   * Error codes returned by this plugin.
+   * Merged into the global error code registry.
+   */
+  $ERROR_CODES?: Record<string, {
+    message: string;
+    status?: number;
+  }>;
+  /**
+   * Called during `Invect.shutdown()`.
+   * Clean up connections, timers, or other resources.
+   */
+  shutdown?: () => Promise<void> | void;
+}
+/**
+ * Collects and executes hooks from all registered plugins.
+ * Used internally by `Invect` and framework adapters.
+ */
+interface PluginHookRunner {
+  /** Run all beforeFlowRun hooks in order */
+  runBeforeFlowRun: (context: FlowRunHookContext) => Promise<{
+    cancelled: boolean;
+    reason?: string;
+    inputs?: Record<string, unknown>;
+  }>;
+  /** Run all afterFlowRun hooks in order */
+  runAfterFlowRun: (context: FlowRunHookContext & {
+    status: 'SUCCESS' | 'FAILED' | 'CANCELLED';
+    outputs?: Record<string, unknown>;
+    error?: string;
+    duration?: number;
+  }) => Promise<void>;
+  /** Run all beforeNodeExecute hooks in order */
+  runBeforeNodeExecute: (context: NodeExecutionHookContext) => Promise<{
+    skipped: boolean;
+    params?: Record<string, unknown>;
+  }>;
+  /** Run all afterNodeExecute hooks in order */
+  runAfterNodeExecute: (context: NodeExecutionHookContext & {
+    status: 'SUCCESS' | 'FAILED' | 'SKIPPED';
+    output?: unknown;
+    error?: string;
+    duration?: number;
+  }) => Promise<{
+    output?: unknown;
+  }>;
+  /** Run all onRequest hooks in order */
+  runOnRequest: (request: Request, context: {
+    path: string;
+    method: string;
+    identity: InvectIdentity | null;
+  }) => Promise<{
+    intercepted: boolean;
+    response?: Response;
+    request?: Request;
+  }>;
+  /** Run all onResponse hooks in order */
+  runOnResponse: (response: Response, context: {
+    path: string;
+    method: string;
+    identity: InvectIdentity | null;
+  }) => Promise<Response>;
+  /** Run all onAuthorize hooks in order */
+  runOnAuthorize: (context: {
+    identity: InvectIdentity | null;
+    action: InvectPermission;
+    resource?: {
+      type: string;
+      id?: string;
+    };
+    database?: PluginDatabaseApi;
+  }) => Promise<AuthorizationResult | null>;
+}
+//#endregion
+export { FlowRunHookContext, InvectPlugin, InvectPluginContext, InvectPluginEndpoint, InvectPluginHooks, InvectPluginInitResult, InvectPluginSchema, NodeExecutionHookContext, NodeExecutionHookResult, PluginDatabaseApi, PluginEndpointContext, PluginEndpointCoreApi, PluginEndpointResponse, PluginFieldAttribute, PluginFieldType, PluginHookRunner, PluginTableDefinition };
+//# sourceMappingURL=plugin.types.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.types.d.cts","names":[],"sources":["../../src/types/plugin.types.ts"],"mappings":"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"}