@vendoai/store 0.1.0 → 0.4.0

package/dist/connections-store.d.ts

@@ -1,25 +0,0 @@
-import type { Principal } from "@vendoai/core";
-import type { VendoDb } from "./db.js";
-/** Structural stand-in for `vendo/server`'s `IntegrationCatalogEntry`. */
-export interface IntegrationCatalogEntry {
-    id: string;
-    name: string;
-}
-export interface DurableConnectionsStore {
-    list(): Promise<Array<IntegrationCatalogEntry & {
-        connected: boolean;
-    }>>;
-    connect(id: string): Promise<void>;
-    disconnect(id: string): Promise<void>;
-    connectedToolkits(): Promise<string[]>;
-    /** Record the Composio connected-account id once the OAuth flow lands. */
-    setConnectedAccount(toolkit: string, connectedAccountId: string): Promise<void>;
-    /** Webhook routing: which principal owns this connected account? */
-    findByConnectedAccount(connectedAccountId: string): Promise<{
-        toolkit: string;
-        principal: Principal;
-    } | undefined>;
-}
-export declare function createDrizzleConnectionsStore(handle: VendoDb, scope: Principal, catalog: IntegrationCatalogEntry[], opts?: {
-    now?: () => string;
-}): DurableConnectionsStore;

package/dist/connections-store.js

@@ -1,102 +0,0 @@
-/**
- * DrizzleConnectionsStore — durable implementation of the STRUCTURAL shape of
- * `vendo/server`'s `ConnectionsStore` (packages/vendo-server/src/connections.ts):
- * which toolkits are connected, i.e. what the agent ingests. Duck-typed
- * locally (not imported) to avoid a server -> store -> server dependency cycle.
- * Both the upstream interface and this durable port are fully async — every
- * operation here is a DB round-trip, and the upstream in-memory store matches
- * that shape (even though it never actually awaits) so the two are drop-in
- * compatible: `vendo/server`'s handler wires this in whenever durable
- * storage is configured, the in-memory one otherwise.
- *
- * Two additions beyond the upstream shape (webhook + integrations flow):
- *  - `setConnectedAccount` records the Composio connected-account id once the
- *    OAuth flow lands.
- *  - `findByConnectedAccount` is a CROSS-PRINCIPAL lookup (unlike every other
- *    method here, which is scoped to the store's own Principal) — webhook
- *    routing needs to answer "which principal owns this connected account?"
- *    before it has a scope to work with.
- */
-import { and, eq } from "drizzle-orm";
-import { connections } from "./schema.js";
-const CONNECTED = "connected";
-const DISCONNECTED = "disconnected";
-export function createDrizzleConnectionsStore(handle, scope, catalog, opts = {}) {
-    const db = handle.db;
-    const now = opts.now ?? (() => new Date().toISOString());
-    const validIds = new Set(catalog.map((c) => c.id));
-    async function connectedSet() {
-        const rows = await db
-            .select({ toolkit: connections.toolkit })
-            .from(connections)
-            .where(and(eq(connections.tenantId, scope.tenantId), eq(connections.subject, scope.subject), eq(connections.status, CONNECTED)));
-        return new Set(rows.map((r) => r.toolkit));
-    }
-    return {
-        async list() {
-            const connected = await connectedSet();
-            return catalog.map((c) => ({ ...c, connected: connected.has(c.id) }));
-        },
-        async connect(id) {
-            if (!validIds.has(id))
-                return;
-            await db
-                .insert(connections)
-                .values({
-                toolkit: id,
-                tenantId: scope.tenantId,
-                subject: scope.subject,
-                connectedAccountId: null,
-                status: CONNECTED,
-                createdAt: now(),
-            })
-                .onConflictDoUpdate({
-                target: [connections.tenantId, connections.subject, connections.toolkit],
-                set: { status: CONNECTED },
-            });
-        },
-        async disconnect(id) {
-            await db
-                .update(connections)
-                .set({ status: DISCONNECTED })
-                .where(and(eq(connections.tenantId, scope.tenantId), eq(connections.subject, scope.subject), eq(connections.toolkit, id)));
-        },
-        async connectedToolkits() {
-            const connected = await connectedSet();
-            return catalog.filter((c) => connected.has(c.id)).map((c) => c.id);
-        },
-        async setConnectedAccount(toolkit, connectedAccountId) {
-            if (!validIds.has(toolkit))
-                return;
-            await db
-                .insert(connections)
-                .values({
-                toolkit,
-                tenantId: scope.tenantId,
-                subject: scope.subject,
-                connectedAccountId,
-                status: CONNECTED,
-                createdAt: now(),
-            })
-                .onConflictDoUpdate({
-                target: [connections.tenantId, connections.subject, connections.toolkit],
-                set: { connectedAccountId, status: CONNECTED },
-            });
-        },
-        async findByConnectedAccount(connectedAccountId) {
-            // Status-filtered: disconnect() flips the row to DISCONNECTED without
-            // clearing connectedAccountId (so reconnecting can leave routing
-            // history intact) — a redelivered/live webhook for a disconnected
-            // account must NOT resolve a principal, or a revoked toolkit would
-            // keep firing automations after the user disconnected it.
-            const rows = await db
-                .select()
-                .from(connections)
-                .where(and(eq(connections.connectedAccountId, connectedAccountId), eq(connections.status, CONNECTED)));
-            const row = rows[0];
-            if (!row)
-                return undefined;
-            return { toolkit: row.toolkit, principal: { tenantId: row.tenantId, subject: row.subject } };
-        },
-    };
-}

package/dist/decision-store.d.ts

@@ -1,8 +0,0 @@
-import type { Principal } from "@vendoai/core";
-import type { DecisionStore } from "@vendoai/runtime";
-import type { VendoDb } from "./db.js";
-/** `createDrizzleDecisionStore(handle, scope)` — one store per Principal,
- *  mirroring how `rememberDecisions` is wired per-request. */
-export declare function createDrizzleDecisionStore(handle: VendoDb, scope: Principal, opts?: {
-    now?: () => string;
-}): DecisionStore;

package/dist/decision-store.js

@@ -1,39 +0,0 @@
-/**
- * DrizzleDecisionStore — durable port of the runtime `DecisionStore` seam
- * (packages/vendo-runtime/src/policy/remember.ts): memoised ask-once
- * approval decisions, keyed by an opaque canonical key and scoped per
- * Principal. Not a junk drawer — see the `decisions` table doc in schema.ts.
- */
-import { and, eq } from "drizzle-orm";
-import { decisions } from "./schema.js";
-/** `createDrizzleDecisionStore(handle, scope)` — one store per Principal,
- *  mirroring how `rememberDecisions` is wired per-request. */
-export function createDrizzleDecisionStore(handle, scope, opts = {}) {
-    const db = handle.db;
-    const now = opts.now ?? (() => new Date().toISOString());
-    return {
-        async get(canonicalKey) {
-            const rows = await db
-                .select()
-                .from(decisions)
-                .where(and(eq(decisions.tenantId, scope.tenantId), eq(decisions.subject, scope.subject), eq(decisions.canonicalKey, canonicalKey)));
-            const row = rows[0];
-            return row ? row.decision : undefined;
-        },
-        async set(canonicalKey, decision) {
-            await db
-                .insert(decisions)
-                .values({
-                tenantId: scope.tenantId,
-                subject: scope.subject,
-                canonicalKey,
-                decision,
-                createdAt: now(),
-            })
-                .onConflictDoUpdate({
-                target: [decisions.tenantId, decisions.subject, decisions.canonicalKey],
-                set: { decision },
-            });
-        },
-    };
-}

package/dist/meta.d.ts

@@ -1,5 +0,0 @@
-import type { VendoDb } from "./db.js";
-/** Read one meta value; `undefined` on a miss. */
-export declare function getMeta(handle: VendoDb, key: string): Promise<unknown>;
-/** Upsert one meta value (last write wins). */
-export declare function setMeta(handle: VendoDb, key: string, value: unknown): Promise<void>;

package/dist/meta.js

@@ -1,20 +0,0 @@
-/**
- * `meta` helpers — the tiny operational KV over the `vendo.meta` table
- * (scheduler heartbeat, future flags). NOT for domain data; see the table
- * doc in schema.ts.
- */
-import { eq } from "drizzle-orm";
-import { meta } from "./schema.js";
-/** Read one meta value; `undefined` on a miss. */
-export async function getMeta(handle, key) {
-    const rows = await handle.db.select().from(meta).where(eq(meta.key, key));
-    return rows[0]?.value;
-}
-/** Upsert one meta value (last write wins). */
-export async function setMeta(handle, key, value) {
-    const updatedAt = new Date().toISOString();
-    await handle.db
-        .insert(meta)
-        .values({ key, value, updatedAt })
-        .onConflictDoUpdate({ target: meta.key, set: { value, updatedAt } });
-}

package/dist/thread-store.d.ts

@@ -1,5 +0,0 @@
-import type { ThreadStore } from "@vendoai/core";
-import type { VendoDb } from "./db.js";
-export declare function createDrizzleThreadStore(handle: VendoDb, opts?: {
-    now?: () => string;
-}): ThreadStore;

package/dist/thread-store.js

@@ -1,209 +0,0 @@
-/**
- * DrizzleThreadStore — durable port of the core `ThreadStore` seam
- * (packages/vendo-core/src/seams/store.ts). Behavioral spec:
- * InMemoryThreadStore (packages/vendo-runtime/src/embedded/in-memory-store.ts).
- *
- * Seq allocation is race-safe: `threads.nextSeq` is reserved with an atomic
- * `UPDATE ... SET next_seq = next_seq + n RETURNING next_seq` inside a
- * transaction, never `MAX(seq)+1` (which double-allocates under concurrency —
- * see the Task 9 plan note). `upsertMessages` reserves seqs ONLY for messages
- * that are genuinely new; pre-existing message ids are updated in place
- * (message column only — their seq, and therefore position, never moves).
- * Existing-vs-new is resolved inside the same transaction as the reservation,
- * so two concurrent upserts of disjoint message ids always get disjoint seq
- * ranges without ever touching the `thread_messages_seq_uq` index twice for
- * the same value (a single INSERT ... ON CONFLICT covering both new and
- * pre-existing rows would risk exactly that: passing an existing row's own
- * seq back through the VALUES list can collide with the seq-uniqueness index,
- * which isn't the ON CONFLICT arbiter and so isn't suppressed — Postgres still
- * raises 23505 for a violation on a non-arbiter unique index. Splitting the
- * write into "plain UPDATE for existing ids" + "plain INSERT of freshly
- * reserved seqs for new ids" avoids that path entirely.)
- *
- * Remaining race: two CONCURRENT txns can both run their existing-ids SELECT
- * before either commits and both classify the SAME message id as "new" —
- * each reserves its own seq block and both attempt to INSERT that message
- * id. The new-row INSERT below carries an `ON CONFLICT (tenant_id, subject,
- * thread_id, message_id) DO UPDATE` naming that exact unique index as its
- * arbiter, so the loser's insert becomes an UPDATE of the winner's row
- * (message content only) instead of a 23505 unique-violation. The loser's
- * reserved seq is simply never used — a benign gap in the sequence, not a
- * correctness issue (seq only needs to be strictly ordered, not contiguous).
- */
-import { randomUUID } from "node:crypto";
-import { and, eq, inArray, sql } from "drizzle-orm";
-import { threadMessages, threads } from "./schema.js";
-import { toIso } from "./automation-store.js";
-function rowToThread(row) {
-    const record = {
-        id: row.id,
-        tenantId: row.tenantId,
-        subject: row.subject,
-        createdAt: toIso(row.createdAt),
-        updatedAt: toIso(row.updatedAt),
-    };
-    if (row.title != null)
-        record.title = row.title;
-    return record;
-}
-export function createDrizzleThreadStore(handle, opts = {}) {
-    const db = handle.db;
-    const now = opts.now ?? (() => new Date().toISOString());
-    function withTransaction(fn) {
-        return handle.db.transaction((tx) => fn(tx));
-    }
-    async function selectThreadRow(tx, scope, threadId) {
-        const rows = await tx
-            .select()
-            .from(threads)
-            .where(and(eq(threads.tenantId, scope.tenantId), eq(threads.subject, scope.subject), eq(threads.id, threadId)));
-        return rows[0];
-    }
-    /** Atomically reserves `n` seqs on the thread row and returns the first one
-     *  in the reserved block. Raw SQL (like `claimPendingApproval` in
-     *  automation-store.ts) because drizzle's `.returning()` doesn't type-check
-     *  cleanly against the pglite/node-postgres union `Db` bridge type. */
-    async function reserveSeqs(tx, scope, threadId, n, at) {
-        const result = await tx.execute(sql `
-      UPDATE vendo.threads
-      SET next_seq = next_seq + ${n}, updated_at = ${at}
-      WHERE tenant_id = ${scope.tenantId} AND subject = ${scope.subject} AND id = ${threadId}
-      RETURNING next_seq
-    `);
-        const rows = result.rows;
-        const reserved = rows[0]?.next_seq ?? n;
-        return reserved - n;
-    }
-    return {
-        async create(scope, init = {}) {
-            const id = randomUUID();
-            const createdAt = now();
-            await db.insert(threads).values({
-                id,
-                tenantId: scope.tenantId,
-                subject: scope.subject,
-                title: init.title ?? null,
-                nextSeq: 0,
-                createdAt,
-                updatedAt: createdAt,
-            });
-            const record = {
-                id,
-                tenantId: scope.tenantId,
-                subject: scope.subject,
-                createdAt,
-                updatedAt: createdAt,
-            };
-            if (init.title !== undefined)
-                record.title = init.title;
-            return record;
-        },
-        async get(scope, threadId) {
-            const row = await selectThreadRow(db, scope, threadId);
-            return row ? rowToThread(row) : undefined;
-        },
-        async list(scope) {
-            const rows = await db
-                .select()
-                .from(threads)
-                .where(and(eq(threads.tenantId, scope.tenantId), eq(threads.subject, scope.subject)));
-            return rows.map(rowToThread);
-        },
-        async appendMessages(scope, threadId, messages) {
-            const owned = await selectThreadRow(db, scope, threadId);
-            if (!owned) {
-                throw new Error(`unknown thread "${threadId}" for scope ${scope.tenantId}/${scope.subject}`);
-            }
-            if (messages.length === 0)
-                return;
-            await withTransaction(async (tx) => {
-                const at = now();
-                const startSeq = await reserveSeqs(tx, scope, threadId, messages.length, at);
-                await tx.insert(threadMessages).values(messages.map((m, i) => ({
-                    tenantId: scope.tenantId,
-                    subject: scope.subject,
-                    threadId,
-                    messageId: m.id,
-                    seq: startSeq + i,
-                    message: m,
-                })));
-            });
-        },
-        async getMessages(scope, threadId) {
-            const rows = await db
-                .select()
-                .from(threadMessages)
-                .where(and(eq(threadMessages.tenantId, scope.tenantId), eq(threadMessages.subject, scope.subject), eq(threadMessages.threadId, threadId)))
-                .orderBy(threadMessages.seq);
-            return rows.map((row) => row.message);
-        },
-        async upsertMessages(scope, threadId, messages) {
-            if (messages.length === 0)
-                return;
-            await withTransaction(async (tx) => {
-                const at = now();
-                const existingThread = await selectThreadRow(tx, scope, threadId);
-                if (!existingThread) {
-                    // The client owns thread ids for upsert (ai-SDK resume writes before
-                    // any explicit create() call) — an unrecognized threadId is a
-                    // first-write, not an error. `onConflictDoNothing` guards the (rare)
-                    // race of two concurrent first-writes to the same unknown id.
-                    await tx
-                        .insert(threads)
-                        .values({
-                        id: threadId,
-                        tenantId: scope.tenantId,
-                        subject: scope.subject,
-                        nextSeq: 0,
-                        createdAt: at,
-                        updatedAt: at,
-                    })
-                        .onConflictDoNothing();
-                }
-                const ids = messages.map((m) => m.id);
-                const existingRows = await tx
-                    .select({ messageId: threadMessages.messageId })
-                    .from(threadMessages)
-                    .where(and(eq(threadMessages.tenantId, scope.tenantId), eq(threadMessages.subject, scope.subject), eq(threadMessages.threadId, threadId), inArray(threadMessages.messageId, ids)));
-                const existingIds = new Set(existingRows.map((r) => r.messageId));
-                const existingMessages = messages.filter((m) => existingIds.has(m.id));
-                const newMessages = messages.filter((m) => !existingIds.has(m.id));
-                // Update pre-existing rows in place: message column only, seq (and
-                // therefore position) is never touched.
-                for (const m of existingMessages) {
-                    await tx
-                        .update(threadMessages)
-                        .set({ message: m })
-                        .where(and(eq(threadMessages.tenantId, scope.tenantId), eq(threadMessages.subject, scope.subject), eq(threadMessages.threadId, threadId), eq(threadMessages.messageId, m.id)));
-                }
-                if (newMessages.length > 0) {
-                    const startSeq = await reserveSeqs(tx, scope, threadId, newMessages.length, at);
-                    await tx
-                        .insert(threadMessages)
-                        .values(newMessages.map((m, i) => ({
-                        tenantId: scope.tenantId,
-                        subject: scope.subject,
-                        threadId,
-                        messageId: m.id,
-                        seq: startSeq + i,
-                        message: m,
-                    })))
-                        // Concurrent-same-new-message race: see the module doc. The
-                        // arbiter is the message-id unique index, not the seq one, so
-                        // this can never suppress a genuine seq collision.
-                        .onConflictDoUpdate({
-                        target: [threadMessages.tenantId, threadMessages.subject, threadMessages.threadId, threadMessages.messageId],
-                        set: { message: sql `excluded.message` },
-                    });
-                }
-                else {
-                    // Still bump updatedAt even when nothing new was reserved.
-                    await tx
-                        .update(threads)
-                        .set({ updatedAt: at })
-                        .where(and(eq(threads.tenantId, scope.tenantId), eq(threads.subject, scope.subject), eq(threads.id, threadId)));
-                }
-            });
-        },
-    };
-}

package/dist/vendo-registry.d.ts

@@ -1,5 +0,0 @@
-import type { SavedVendoStore } from "@vendoai/core";
-import type { VendoDb } from "./db.js";
-export declare function createDrizzleSavedVendoStore(handle: VendoDb, opts?: {
-    now?: () => string;
-}): SavedVendoStore;

package/dist/vendo-registry.js

@@ -1,52 +0,0 @@
-/**
- * DrizzleSavedVendoStore — durable port of the core `SavedVendoStore`
- * seam (packages/vendo-core/src/seams/store.ts). Behavioral spec:
- * InMemorySavedVendoStore (packages/vendo-runtime/src/embedded/in-memory-store.ts).
- *
- * The whole `SavedVendo` record (uiTree, query, originatingPrompt, etc.)
- * lives verbatim in the `record` jsonb column; `updatedAt` is denormalized
- * onto its own column purely so `list()` can order by it without unpacking
- * jsonb per row.
- */
-import { randomUUID } from "node:crypto";
-import { and, desc, eq } from "drizzle-orm";
-import { savedVendos } from "./schema.js";
-export function createDrizzleSavedVendoStore(handle, opts = {}) {
-    const db = handle.db;
-    const now = opts.now ?? (() => new Date().toISOString());
-    return {
-        async save(scope, vendo) {
-            const id = randomUUID();
-            const createdAt = now();
-            const record = { ...vendo, id, createdAt, updatedAt: createdAt };
-            await db.insert(savedVendos).values({
-                id,
-                tenantId: scope.tenantId,
-                subject: scope.subject,
-                record,
-                updatedAt: createdAt,
-            });
-            return record;
-        },
-        async get(scope, id) {
-            const rows = await db
-                .select()
-                .from(savedVendos)
-                .where(and(eq(savedVendos.tenantId, scope.tenantId), eq(savedVendos.subject, scope.subject), eq(savedVendos.id, id)));
-            return rows[0] ? rows[0].record : undefined;
-        },
-        async list(scope) {
-            const rows = await db
-                .select()
-                .from(savedVendos)
-                .where(and(eq(savedVendos.tenantId, scope.tenantId), eq(savedVendos.subject, scope.subject)))
-                .orderBy(desc(savedVendos.updatedAt));
-            return rows.map((row) => row.record);
-        },
-        async delete(scope, id) {
-            await db
-                .delete(savedVendos)
-                .where(and(eq(savedVendos.tenantId, scope.tenantId), eq(savedVendos.subject, scope.subject), eq(savedVendos.id, id)));
-        },
-    };
-}

package/migrations/0000_living_kate_bishop.sql

@@ -1,110 +0,0 @@
-CREATE SCHEMA IF NOT EXISTS "vendo";
---> statement-breakpoint
-CREATE TABLE IF NOT EXISTS "vendo"."automation_runs" (
-	"id" text PRIMARY KEY NOT NULL,
-	"automation_id" text NOT NULL,
-	"tenant_id" text NOT NULL,
-	"subject" text NOT NULL,
-	"version" integer NOT NULL,
-	"manifest_hash" text,
-	"status" text NOT NULL,
-	"outcome" text,
-	"trigger" jsonb NOT NULL,
-	"steps" jsonb NOT NULL,
-	"pending_approval" jsonb,
-	"error" text,
-	"is_test" boolean NOT NULL,
-	"started_at" timestamp with time zone NOT NULL,
-	"finished_at" timestamp with time zone
-);
---> statement-breakpoint
-CREATE TABLE IF NOT EXISTS "vendo"."automation_versions" (
-	"automation_id" text NOT NULL,
-	"version" integer NOT NULL,
-	"spec" jsonb NOT NULL,
-	"dsl_version" integer NOT NULL,
-	"manifest_hash" text,
-	"grants" jsonb NOT NULL,
-	"created_by" text NOT NULL,
-	"created_at" timestamp with time zone NOT NULL,
-	CONSTRAINT "automation_versions_automation_id_version_pk" PRIMARY KEY("automation_id","version")
-);
---> statement-breakpoint
-CREATE TABLE IF NOT EXISTS "vendo"."automations" (
-	"id" text PRIMARY KEY NOT NULL,
-	"tenant_id" text NOT NULL,
-	"subject" text NOT NULL,
-	"name" text NOT NULL,
-	"status" text NOT NULL,
-	"disabled_reason" text,
-	"spec" jsonb NOT NULL,
-	"current_version" integer NOT NULL,
-	"trigger_kind" text NOT NULL,
-	"trigger_key" text,
-	"counters" jsonb NOT NULL,
-	"created_from_thread_id" text,
-	"created_at" timestamp with time zone NOT NULL,
-	"updated_at" timestamp with time zone NOT NULL
-);
---> statement-breakpoint
-CREATE TABLE IF NOT EXISTS "vendo"."connections" (
-	"toolkit" text NOT NULL,
-	"tenant_id" text NOT NULL,
-	"subject" text NOT NULL,
-	"connected_account_id" text,
-	"status" text NOT NULL,
-	"created_at" timestamp with time zone NOT NULL,
-	CONSTRAINT "connections_tenant_id_subject_toolkit_pk" PRIMARY KEY("tenant_id","subject","toolkit")
-);
---> statement-breakpoint
-CREATE TABLE IF NOT EXISTS "vendo"."decisions" (
-	"tenant_id" text NOT NULL,
-	"subject" text NOT NULL,
-	"canonical_key" text NOT NULL,
-	"decision" jsonb NOT NULL,
-	"created_at" timestamp with time zone NOT NULL,
-	CONSTRAINT "decisions_tenant_id_subject_canonical_key_pk" PRIMARY KEY("tenant_id","subject","canonical_key")
-);
---> statement-breakpoint
-CREATE TABLE IF NOT EXISTS "vendo"."meta" (
-	"key" text PRIMARY KEY NOT NULL,
-	"value" jsonb NOT NULL,
-	"updated_at" timestamp with time zone NOT NULL
-);
---> statement-breakpoint
-CREATE TABLE IF NOT EXISTS "vendo"."saved_vendos" (
-	"id" text NOT NULL,
-	"tenant_id" text NOT NULL,
-	"subject" text NOT NULL,
-	"record" jsonb NOT NULL,
-	"updated_at" timestamp with time zone NOT NULL,
-	CONSTRAINT "saved_vendos_tenant_id_subject_id_pk" PRIMARY KEY("tenant_id","subject","id")
-);
---> statement-breakpoint
-CREATE TABLE IF NOT EXISTS "vendo"."thread_messages" (
-	"row_id" bigserial PRIMARY KEY NOT NULL,
-	"tenant_id" text NOT NULL,
-	"subject" text NOT NULL,
-	"thread_id" text NOT NULL,
-	"message_id" text NOT NULL,
-	"seq" integer NOT NULL,
-	"message" jsonb NOT NULL
-);
---> statement-breakpoint
-CREATE TABLE IF NOT EXISTS "vendo"."threads" (
-	"id" text NOT NULL,
-	"tenant_id" text NOT NULL,
-	"subject" text NOT NULL,
-	"title" text,
-	"next_seq" integer DEFAULT 0 NOT NULL,
-	"created_at" timestamp with time zone NOT NULL,
-	"updated_at" timestamp with time zone NOT NULL,
-	CONSTRAINT "threads_tenant_id_subject_id_pk" PRIMARY KEY("tenant_id","subject","id")
-);
---> statement-breakpoint
-CREATE INDEX IF NOT EXISTS "runs_automation_idx" ON "vendo"."automation_runs" USING btree ("automation_id","tenant_id","subject");--> statement-breakpoint
-CREATE INDEX IF NOT EXISTS "automations_scope_idx" ON "vendo"."automations" USING btree ("tenant_id","subject");--> statement-breakpoint
-CREATE INDEX IF NOT EXISTS "automations_trigger_idx" ON "vendo"."automations" USING btree ("trigger_kind","trigger_key");--> statement-breakpoint
-CREATE INDEX IF NOT EXISTS "connections_account_idx" ON "vendo"."connections" USING btree ("connected_account_id");--> statement-breakpoint
-CREATE UNIQUE INDEX IF NOT EXISTS "thread_messages_id_uq" ON "vendo"."thread_messages" USING btree ("tenant_id","subject","thread_id","message_id");--> statement-breakpoint
-CREATE UNIQUE INDEX IF NOT EXISTS "thread_messages_seq_uq" ON "vendo"."thread_messages" USING btree ("tenant_id","subject","thread_id","seq");

package/migrations/0001_brainy_tinkerer.sql

@@ -1,13 +0,0 @@
-CREATE TABLE IF NOT EXISTS "vendo"."parked_actions" (
-	"id" text PRIMARY KEY NOT NULL,
-	"tenant_id" text NOT NULL,
-	"subject" text NOT NULL,
-	"automation_id" text NOT NULL,
-	"run_id" text NOT NULL,
-	"resolution" text,
-	"requested_at" timestamp with time zone NOT NULL,
-	"record" jsonb NOT NULL
-);
---> statement-breakpoint
-ALTER TABLE "vendo"."automation_runs" ADD COLUMN "parked_count" integer DEFAULT 0 NOT NULL;--> statement-breakpoint
-CREATE INDEX IF NOT EXISTS "parked_actions_scope_idx" ON "vendo"."parked_actions" USING btree ("tenant_id","subject","automation_id","run_id");