@intx/db 0.1.2 → 0.3.0

package/dist/schema/workflow-definitions.d.ts

@@ -0,0 +1,371 @@
+export declare const workflowDefinition: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "workflow_definition";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "workflow_definition";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        tenantId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "tenant_id";
+            tableName: "workflow_definition";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        creatorPrincipalId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "creator_principal_id";
+            tableName: "workflow_definition";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        assetId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "asset_id";
+            tableName: "workflow_definition";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        wireHash: import("drizzle-orm/pg-core").PgColumn<{
+            name: "wire_hash";
+            tableName: "workflow_definition";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "workflow_definition";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        description: import("drizzle-orm/pg-core").PgColumn<{
+            name: "description";
+            tableName: "workflow_definition";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        grantRequirements: import("drizzle-orm/pg-core").PgColumn<{
+            name: "grant_requirements";
+            tableName: "workflow_definition";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        modelRequirements: import("drizzle-orm/pg-core").PgColumn<{
+            name: "model_requirements";
+            tableName: "workflow_definition";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        credentialBindings: import("drizzle-orm/pg-core").PgColumn<{
+            name: "credential_bindings";
+            tableName: "workflow_definition";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        currentVersion: import("drizzle-orm/pg-core").PgColumn<{
+            name: "current_version";
+            tableName: "workflow_definition";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "workflow_definition";
+            dataType: "string";
+            columnType: "PgText";
+            data: "deployed" | "stopped";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["deployed", "stopped"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "workflow_definition";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "workflow_definition";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const workflowDefinitionVersion: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "workflow_definition_version";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "workflow_definition_version";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        definitionId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "definition_id";
+            tableName: "workflow_definition_version";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        version: import("drizzle-orm/pg-core").PgColumn<{
+            name: "version";
+            tableName: "workflow_definition_version";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        status: import("drizzle-orm/pg-core").PgColumn<{
+            name: "status";
+            tableName: "workflow_definition_version";
+            dataType: "string";
+            columnType: "PgText";
+            data: "active" | "inactive" | "failed";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["active", "inactive", "failed"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        approvedWireHash: import("drizzle-orm/pg-core").PgColumn<{
+            name: "approved_wire_hash";
+            tableName: "workflow_definition_version";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        grantSnapshot: import("drizzle-orm/pg-core").PgColumn<{
+            name: "grant_snapshot";
+            tableName: "workflow_definition_version";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "workflow_definition_version";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;

package/dist/schema/workflow-definitions.js

@@ -0,0 +1,97 @@
+import { index, jsonb, pgTable, text, timestamp, unique, uniqueIndex, } from "drizzle-orm/pg-core";
+import { asset } from "./assets.js";
+import { principal } from "./principals.js";
+import { tenant } from "./tenants.js";
+// workflow_definition is the first-class definition entity for the workflow
+// model: one row per deployable definition, with a version table alongside it.
+//
+// The definition body (system prompt, context/model config, tool packages) is
+// not stored on this row -- it lives in the `workflow`-kind asset the row
+// points at, and the run reads it back from there. `asset_id` is nullable at
+// the schema level, but a runnable definition points at a materialized asset.
+//
+// Identity is selector-keyed on the wire-projection hash, not one definition
+// per asset: a single asset (e.g. a monorepo package) backs many definitions
+// distinguished by the content hash of their wire projection. `wire_hash` is
+// that content handle; the unique index over `(asset_id, wire_hash)` keys
+// identity so definitions sharing an asset but carrying different wire hashes
+// resolve independently. `wire_hash` is nullable so definitions predating this
+// key carry none; Postgres treats those NULLs as distinct.
+export const workflowDefinition = pgTable("workflow_definition", {
+    id: text("id").primaryKey(),
+    tenantId: text("tenant_id")
+        .notNull()
+        .references(() => tenant.id, { onDelete: "cascade" }),
+    // Nullable to match the weaker of the two definition sources: `asset`'s
+    // creator principal is `onDelete: "set null"`, so a workflow asset whose
+    // creator principal was removed carries no creator onto the definition.
+    creatorPrincipalId: text("creator_principal_id").references(() => principal.id),
+    // The asset holding this definition's body. `restrict`: the definition is
+    // the first-class entity, so deleting the asset must not cascade into
+    // deleting it.
+    assetId: text("asset_id").references(() => asset.id, {
+        onDelete: "restrict",
+    }),
+    // Content hash of this definition's wire projection: the selector that
+    // keys identity within an asset. Nullable so definitions predating the
+    // selector-keyed key carry none.
+    wireHash: text("wire_hash"),
+    name: text("name").notNull(),
+    description: text("description"),
+    // Grant requirements manifest, resolved at launch into materialized grants.
+    // Validated as GrantRequirement[] at parse time.
+    grantRequirements: jsonb("grant_requirements"),
+    // Model requirements manifest: the canonical model names + provider
+    // preferences a definition launched as a single interactive run resolves
+    // against the live tenant catalog into credential-bearing inference
+    // sources, fresh each launch. Non-null marks such a definition and gates
+    // the interactive-launch path; null for a definition deployed as a workflow,
+    // which supplies its sources at deploy time. Validated as ModelRequirements
+    // at parse time.
+    modelRequirements: jsonb("model_requirements"),
+    // Credential bindings manifest: maps a tool package's declared credential
+    // handle (package, handle) to a concrete credential resolved fresh at
+    // launch (by locator + provider + name against the tenant walk-up).
+    // Validated as CredentialBinding[] at parse time. A binding is a request
+    // the launch-time grant gate authorizes; it consents to nothing on its own.
+    credentialBindings: jsonb("credential_bindings"),
+    currentVersion: text("current_version").notNull().default("1"),
+    status: text("status", {
+        enum: ["deployed", "stopped"],
+    })
+        .notNull()
+        .default("deployed"),
+    createdAt: timestamp("created_at").notNull().defaultNow(),
+    updatedAt: timestamp("updated_at").notNull().defaultNow(),
+}, (t) => [
+    index("workflow_definition_tenant_idx").on(t.tenantId, t.createdAt),
+    uniqueIndex("workflow_definition_asset_wire_hash_idx").on(t.assetId, t.wireHash),
+]);
+export const workflowDefinitionVersion = pgTable("workflow_definition_version", {
+    id: text("id").primaryKey(),
+    definitionId: text("definition_id")
+        .notNull()
+        .references(() => workflowDefinition.id, { onDelete: "cascade" }),
+    version: text("version").notNull(),
+    status: text("status", {
+        enum: ["active", "inactive", "failed"],
+    })
+        .notNull()
+        .default("active"),
+    // Hash of the wire bytes approved for this version, recorded at approval
+    // and read back during re-verify to detect drift. Null before approval is
+    // a legitimate state, so the column takes no NOT NULL constraint.
+    approvedWireHash: text("approved_wire_hash"),
+    // Serializable projection of the deploy-time capability walk, recorded
+    // at approval so a run materializes grants from it instead of re-reading
+    // and re-walking a workflow.json blob. Validated as GrantWalkSnapshot at
+    // parse time. Null before approval is a legitimate state, so the column
+    // takes no NOT NULL constraint.
+    grantSnapshot: jsonb("grant_snapshot"),
+    createdAt: timestamp("created_at").notNull().defaultNow(),
+}, (t) => [
+    // Unique per definition so rollback-by-version resolves to one row. The
+    // mirror source `agent_version` omits this; the fresh table constrains it.
+    unique("workflow_definition_version_definition_version").on(t.definitionId, t.version),
+    index("workflow_definition_version_definition_idx").on(t.definitionId),
+]);