@anchrd/intel-api 0.2.0

package/dist/adapters/db/db-flows.js

@@ -0,0 +1,466 @@
+import { Flow, FlowGraph, FlowRun, FlowVersion, } from "@anchrd/intel-contract";
+const flowColumns = `id, title, description, owner_id, current_version_id,
+  published_version_id, created_at, updated_at, archived_at`;
+const runColumnNames = [
+    "id",
+    "flow_id",
+    "version_id",
+    "status",
+    "current_node_id",
+    "input_json",
+    "output_json",
+    "error",
+    "initiated_by",
+    "created_at",
+    "updated_at",
+    "completed_at",
+];
+const runColumns = runColumnNames.join(", ");
+// Joined queries need the columns qualified. Deriving them from the array keeps both forms in step;
+// splitting the rendered string would break the moment it is reformatted.
+const qualifiedRunColumns = (alias) => runColumnNames.map((column) => `${alias}.${column}`).join(", ");
+function accessPredicate(roles = []) {
+    const role = roles.length ? `AND grant_row.role IN (${roles.map(() => "?").join(", ")})` : "";
+    return `(flow.owner_id = ? OR EXISTS (
+    SELECT 1 FROM resource_grants grant_row
+    WHERE grant_row.resource_type = 'flow' AND grant_row.resource_id = flow.id
+      AND (
+        (grant_row.principal_type = 'user' AND grant_row.principal_id = ?)
+        OR (grant_row.principal_type = 'email' AND lower(grant_row.principal_id) = lower(?))
+        OR (grant_row.principal_type = 'organization' AND grant_row.principal_id = '*')
+      )
+      ${role}
+      AND (grant_row.expires_at IS NULL OR grant_row.expires_at > ?)
+  ))`;
+}
+function accessBindings(actor, now, roles = []) {
+    return [actor.id, actor.id, actor.email, ...roles, now];
+}
+function mapFlow(row) {
+    return Flow.parse({
+        id: row.id,
+        title: row.title,
+        description: row.description,
+        ownerId: row.owner_id,
+        currentVersionId: row.current_version_id,
+        publishedVersionId: row.published_version_id,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        archivedAt: row.archived_at,
+    });
+}
+function mapVersion(row) {
+    return FlowVersion.parse({
+        id: row.id,
+        flowId: row.flow_id,
+        sequence: row.sequence,
+        graph: FlowGraph.parse(JSON.parse(row.graph_json)),
+        createdBy: row.created_by,
+        createdAt: row.created_at,
+    });
+}
+function mapRun(row) {
+    return FlowRun.parse({
+        id: row.id,
+        flowId: row.flow_id,
+        versionId: row.version_id,
+        status: row.status,
+        currentNodeId: row.current_node_id,
+        input: JSON.parse(row.input_json),
+        output: row.output_json === null ? null : JSON.parse(row.output_json),
+        error: row.error,
+        initiatedBy: row.initiated_by,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        completedAt: row.completed_at,
+    });
+}
+function mapGrant(row) {
+    let principal;
+    switch (row.principal_type) {
+        case "user":
+            principal = { type: "user", id: row.principal_id };
+            break;
+        case "email":
+            principal = { type: "email", email: row.principal_id };
+            break;
+        case "organization":
+            principal = { type: "organization" };
+            break;
+        default:
+            throw new Error("Unsupported flow grant principal type");
+    }
+    return {
+        id: row.id,
+        resourceId: row.resource_id,
+        principal,
+        role: row.role,
+        expiresAt: row.expires_at,
+        createdBy: row.created_by,
+        createdAt: row.created_at,
+    };
+}
+export function createFlowRepository(deps) {
+    const visible = accessPredicate();
+    return {
+        async listVisible(actor) {
+            const result = await deps.db
+                .prepare(`SELECT ${flowColumns} FROM flows flow
+          WHERE ${visible} AND flow.archived_at IS NULL
+          ORDER BY lower(flow.title), flow.id`)
+                .bind(...accessBindings(actor, deps.now().toISOString()))
+                .all();
+            return (result.results ?? []).map(mapFlow);
+        },
+        async getVisible(actor, flowId) {
+            const row = await deps.db
+                .prepare(`SELECT ${flowColumns} FROM flows flow WHERE flow.id = ? AND ${visible}`)
+                .bind(flowId, ...accessBindings(actor, deps.now().toISOString()))
+                .first();
+            return row ? mapFlow(row) : null;
+        },
+        async canEdit(actor, flowId) {
+            const row = await deps.db
+                .prepare(`SELECT 1 AS allowed FROM flows flow
+          WHERE flow.id = ? AND ${accessPredicate(["editor", "manager"])}`)
+                .bind(flowId, ...accessBindings(actor, deps.now().toISOString(), ["editor", "manager"]))
+                .first();
+            return row?.allowed === 1;
+        },
+        async canManage(actor, flowId) {
+            const row = await deps.db
+                .prepare(`SELECT 1 AS allowed FROM flows flow
+          WHERE flow.id = ? AND ${accessPredicate(["manager"])}`)
+                .bind(flowId, ...accessBindings(actor, deps.now().toISOString(), ["manager"]))
+                .first();
+            return row?.allowed === 1;
+        },
+        async findIdempotent(actorId, operation, key) {
+            const row = await deps.db
+                .prepare(`SELECT resource_id FROM idempotency_keys
+          WHERE actor_id = ? AND operation = ? AND idempotency_key = ?`)
+                .bind(actorId, operation, key)
+                .first();
+            return row?.resource_id ?? null;
+        },
+        async findIdempotentRevocation(actorId, key) {
+            const row = await deps.db
+                .prepare(`SELECT resource_id FROM idempotency_keys
+          WHERE actor_id = ? AND operation = 'flows.revoke' AND idempotency_key = ?`)
+                .bind(actorId, key)
+                .first();
+            if (!row)
+                return null;
+            return row.resource_id.startsWith("1:");
+        },
+        async insertFlow(input) {
+            const flow = input.flow;
+            try {
+                await deps.db.batch([
+                    deps.db
+                        .prepare(`INSERT INTO flows (
+              id, title, description, owner_id, current_version_id, published_version_id,
+              created_at, updated_at, archived_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                        .bind(flow.id, flow.title, flow.description, flow.ownerId, flow.currentVersionId, flow.publishedVersionId, flow.createdAt, flow.updatedAt, flow.archivedAt),
+                    deps.db
+                        .prepare(`INSERT INTO idempotency_keys (
+              actor_id, operation, idempotency_key, resource_id, created_at
+            ) VALUES (?, 'flows.create', ?, ?, ?)`)
+                        .bind(input.actorId, input.idempotencyKey, flow.id, flow.createdAt),
+                    deps.db
+                        .prepare(`INSERT INTO audit_events (
+              id, actor_id, action, resource_type, resource_id, metadata_json, occurred_at
+            ) VALUES (?, ?, 'flows.create', 'flow', ?, '{}', ?)`)
+                        .bind(input.auditId, input.actorId, flow.id, flow.createdAt),
+                ]);
+                return flow;
+            }
+            catch (error) {
+                const replayedId = await this.findIdempotent(input.actorId, "flows.create", input.idempotencyKey);
+                const replayed = replayedId
+                    ? await deps.db
+                        .prepare(`SELECT ${flowColumns} FROM flows WHERE id = ?`)
+                        .bind(replayedId)
+                        .first()
+                    : null;
+                if (replayed)
+                    return mapFlow(replayed);
+                throw error;
+            }
+        },
+        async getVersion(versionId) {
+            const row = await deps.db
+                .prepare(`SELECT id, flow_id, sequence, graph_json, created_by, created_at
+          FROM flow_versions WHERE id = ?`)
+                .bind(versionId)
+                .first();
+            return row ? mapVersion(row) : null;
+        },
+        async insertVersion(input) {
+            const version = input.version;
+            try {
+                await deps.db.batch([
+                    deps.db
+                        .prepare(`INSERT INTO flow_versions (
+              id, flow_id, sequence, graph_json, created_by, created_at
+            ) SELECT ?, ?, ?, ?, ?, ?
+            WHERE EXISTS (
+              SELECT 1 FROM flows WHERE id = ? AND current_version_id IS ?
+            )`)
+                        .bind(version.id, version.flowId, version.sequence, JSON.stringify(version.graph), version.createdBy, version.createdAt, version.flowId, input.baseVersionId),
+                    deps.db
+                        .prepare(`UPDATE flows SET current_version_id = ?, updated_at = ?
+              WHERE id = ? AND current_version_id IS ?
+                AND EXISTS (SELECT 1 FROM flow_versions WHERE id = ?)`)
+                        .bind(version.id, version.createdAt, version.flowId, input.baseVersionId, version.id),
+                    deps.db
+                        .prepare(`INSERT INTO idempotency_keys (
+              actor_id, operation, idempotency_key, resource_id, created_at
+            ) SELECT ?, 'flows.save', ?, ?, ?
+            WHERE EXISTS (SELECT 1 FROM flow_versions WHERE id = ?)`)
+                        .bind(input.actorId, input.idempotencyKey, version.id, version.createdAt, version.id),
+                    deps.db
+                        .prepare(`INSERT INTO audit_events (
+              id, actor_id, action, resource_type, resource_id, metadata_json, occurred_at
+            ) SELECT ?, ?, 'flows.save', 'flow', ?, ?, ?
+            WHERE EXISTS (SELECT 1 FROM flow_versions WHERE id = ?)`)
+                        .bind(input.auditId, input.actorId, version.flowId, JSON.stringify({ versionId: version.id, sequence: version.sequence }), version.createdAt, version.id),
+                ]);
+            }
+            catch (error) {
+                const replayed = await this.findIdempotent(input.actorId, "flows.save", input.idempotencyKey);
+                if (!replayed)
+                    throw error;
+            }
+            const stored = await deps.db
+                .prepare("SELECT 1 AS saved FROM flow_versions WHERE id = ?")
+                .bind(version.id)
+                .first();
+            return stored ? "saved" : "conflict";
+        },
+        async publish(input) {
+            try {
+                await deps.db.batch([
+                    deps.db
+                        .prepare(`UPDATE flows SET published_version_id = ?, updated_at = ?
+              WHERE id = ? AND EXISTS (
+                SELECT 1 FROM flow_versions WHERE id = ? AND flow_id = ?
+              )`)
+                        .bind(input.versionId, input.occurredAt, input.flowId, input.versionId, input.flowId),
+                    deps.db
+                        .prepare(`INSERT INTO idempotency_keys (
+              actor_id, operation, idempotency_key, resource_id, created_at
+            ) SELECT ?, 'flows.publish', ?, ?, ?
+            WHERE EXISTS (
+              SELECT 1 FROM flows WHERE id = ? AND published_version_id = ?
+            )`)
+                        .bind(input.actorId, input.idempotencyKey, input.versionId, input.occurredAt, input.flowId, input.versionId),
+                    deps.db
+                        .prepare(`INSERT INTO audit_events (
+              id, actor_id, action, resource_type, resource_id, metadata_json, occurred_at
+            ) SELECT ?, ?, 'flows.publish', 'flow', ?, ?, ?
+            WHERE EXISTS (
+              SELECT 1 FROM idempotency_keys
+              WHERE actor_id = ? AND operation = 'flows.publish' AND idempotency_key = ?
+            )`)
+                        .bind(input.auditId, input.actorId, input.flowId, JSON.stringify({ versionId: input.versionId }), input.occurredAt, input.actorId, input.idempotencyKey),
+                ]);
+            }
+            catch (error) {
+                const replayed = await this.findIdempotent(input.actorId, "flows.publish", input.idempotencyKey);
+                if (!replayed)
+                    throw error;
+            }
+            return ((await this.findIdempotent(input.actorId, "flows.publish", input.idempotencyKey)) !== null);
+        },
+        async listGrants(flowId) {
+            const result = await deps.db
+                .prepare(`SELECT id, resource_id, principal_type, principal_id, role, expires_at,
+          created_by, created_at FROM resource_grants
+          WHERE resource_type = 'flow' AND resource_id = ?
+          ORDER BY created_at, id`)
+                .bind(flowId)
+                .all();
+            return (result.results ?? []).map(mapGrant);
+        },
+        async setGrant(input) {
+            const grant = input.grant;
+            const principalType = grant.principal.type;
+            const principalId = grant.principal.type === "user"
+                ? grant.principal.id
+                : grant.principal.type === "email"
+                    ? grant.principal.email.toLowerCase()
+                    : "*";
+            try {
+                await deps.db.batch([
+                    deps.db
+                        .prepare(`INSERT INTO resource_grants (
+              id, resource_type, resource_id, principal_type, principal_id, role,
+              expires_at, created_by, created_at
+            ) VALUES (?, 'flow', ?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT (resource_type, resource_id, principal_type, principal_id)
+            DO UPDATE SET role = excluded.role, expires_at = excluded.expires_at`)
+                        .bind(grant.id, grant.resourceId, principalType, principalId, grant.role, grant.expiresAt, grant.createdBy, grant.createdAt),
+                    deps.db
+                        .prepare(`INSERT INTO idempotency_keys (
+              actor_id, operation, idempotency_key, resource_id, created_at
+            ) SELECT ?, 'flows.share', ?, id, ? FROM resource_grants
+              WHERE resource_type = 'flow' AND resource_id = ?
+                AND principal_type = ? AND principal_id = ?`)
+                        .bind(input.actorId, input.idempotencyKey, grant.createdAt, grant.resourceId, principalType, principalId),
+                    deps.db
+                        .prepare(`INSERT INTO audit_events (
+              id, actor_id, action, resource_type, resource_id, metadata_json, occurred_at
+            ) VALUES (?, ?, 'flows.share', 'flow', ?, ?, ?)`)
+                        .bind(input.auditId, input.actorId, grant.resourceId, JSON.stringify({ principalType, role: grant.role }), grant.createdAt),
+                ]);
+                const stored = await deps.db
+                    .prepare(`SELECT id, resource_id, principal_type, principal_id, role, expires_at,
+            created_by, created_at FROM resource_grants
+            WHERE resource_type = 'flow' AND resource_id = ?
+              AND principal_type = ? AND principal_id = ?`)
+                    .bind(grant.resourceId, principalType, principalId)
+                    .first();
+                if (!stored)
+                    throw new Error("Flow grant disappeared after upsert");
+                return mapGrant(stored);
+            }
+            catch (error) {
+                const replayed = await this.findIdempotent(input.actorId, "flows.share", input.idempotencyKey);
+                const row = replayed
+                    ? await deps.db
+                        .prepare(`SELECT id, resource_id, principal_type, principal_id, role, expires_at,
+                created_by, created_at FROM resource_grants WHERE id = ?`)
+                        .bind(replayed)
+                        .first()
+                    : null;
+                if (row)
+                    return mapGrant(row);
+                throw error;
+            }
+        },
+        async revokeGrant(input) {
+            try {
+                await deps.db.batch([
+                    deps.db
+                        .prepare(`INSERT INTO idempotency_keys (
+              actor_id, operation, idempotency_key, resource_id, created_at
+            ) SELECT ?, 'flows.revoke', ?,
+              (CASE WHEN EXISTS (
+                SELECT 1 FROM resource_grants
+                WHERE id = ? AND resource_type = 'flow' AND resource_id = ?
+              ) THEN '1:' ELSE '0:' END) || ?, ?`)
+                        .bind(input.actorId, input.idempotencyKey, input.grantId, input.flowId, input.grantId, input.occurredAt),
+                    deps.db
+                        .prepare(`DELETE FROM resource_grants
+              WHERE id = ? AND resource_type = 'flow' AND resource_id = ?`)
+                        .bind(input.grantId, input.flowId),
+                    deps.db
+                        .prepare(`INSERT INTO audit_events (
+              id, actor_id, action, resource_type, resource_id, metadata_json, occurred_at
+            ) SELECT ?, ?, 'flows.revoke', 'flow', ?,
+              json_object(
+                'grantId', ?,
+                'revoked', json(CASE WHEN substr(resource_id, 1, 2) = '1:' THEN 'true' ELSE 'false' END)
+              ), ?
+              FROM idempotency_keys
+              WHERE actor_id = ? AND operation = 'flows.revoke' AND idempotency_key = ?`)
+                        .bind(input.auditId, input.actorId, input.flowId, input.grantId, input.occurredAt, input.actorId, input.idempotencyKey),
+                ]);
+            }
+            catch (error) {
+                const replayed = await this.findIdempotentRevocation(input.actorId, input.idempotencyKey);
+                if (replayed === null)
+                    throw error;
+                return replayed;
+            }
+            return (await this.findIdempotentRevocation(input.actorId, input.idempotencyKey)) ?? false;
+        },
+        async insertRun(input) {
+            const run = input.run;
+            try {
+                await deps.db.batch([
+                    deps.db
+                        .prepare(`INSERT INTO flow_runs (
+              id, flow_id, version_id, status, current_node_id, input_json, output_json,
+              error, initiated_by, created_at, updated_at, completed_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                        .bind(run.id, run.flowId, run.versionId, run.status, run.currentNodeId, JSON.stringify(run.input), null, run.error, run.initiatedBy, run.createdAt, run.updatedAt, run.completedAt),
+                    deps.db
+                        .prepare(`INSERT INTO idempotency_keys (
+              actor_id, operation, idempotency_key, resource_id, created_at
+            ) VALUES (?, 'flows.run', ?, ?, ?)`)
+                        .bind(input.actorId, input.idempotencyKey, run.id, run.createdAt),
+                    deps.db
+                        .prepare(`INSERT INTO audit_events (
+              id, actor_id, action, resource_type, resource_id, metadata_json, occurred_at
+            ) VALUES (?, ?, 'flows.run', 'flow-run', ?, ?, ?)`)
+                        .bind(input.auditId, input.actorId, run.id, JSON.stringify({ flowId: run.flowId, versionId: run.versionId }), run.createdAt),
+                ]);
+                return run;
+            }
+            catch (error) {
+                const replayedId = await this.findIdempotent(input.actorId, "flows.run", input.idempotencyKey);
+                const replayed = replayedId
+                    ? await deps.db
+                        .prepare(`SELECT ${runColumns} FROM flow_runs WHERE id = ?`)
+                        .bind(replayedId)
+                        .first()
+                    : null;
+                if (replayed)
+                    return mapRun(replayed);
+                throw error;
+            }
+        },
+        async getRunVisible(actor, runId) {
+            const row = await deps.db
+                .prepare(`SELECT ${qualifiedRunColumns("run")} FROM flow_runs run
+          JOIN flows flow ON flow.id = run.flow_id
+          WHERE run.id = ? AND ${visible}`)
+                .bind(runId, ...accessBindings(actor, deps.now().toISOString()))
+                .first();
+            return row ? mapRun(row) : null;
+        },
+        async advanceRun(input) {
+            const run = input.run;
+            try {
+                await deps.db.batch([
+                    deps.db
+                        .prepare(`UPDATE flow_runs SET
+              status = ?, current_node_id = ?, output_json = ?, error = ?,
+              updated_at = ?, completed_at = ?, transition_id = ?
+              WHERE id = ? AND current_node_id = ? AND status IN ('running', 'waiting')`)
+                        .bind(run.status, run.currentNodeId, run.output === null ? null : JSON.stringify(run.output), run.error, run.updatedAt, run.completedAt, input.stepId, run.id, input.expectedNodeId),
+                    deps.db
+                        .prepare(`INSERT INTO flow_run_steps (
+              id, run_id, node_id, outcome, branch, output_json, error, completed_by, completed_at
+            ) SELECT ?, ?, ?, ?, ?, ?, ?, ?, ?
+            WHERE EXISTS (
+              SELECT 1 FROM flow_runs WHERE id = ? AND transition_id = ?
+            )`)
+                        .bind(input.stepId, run.id, input.expectedNodeId, input.outcome, input.branch, JSON.stringify(input.output), input.error, input.actorId, run.updatedAt, run.id, input.stepId),
+                    deps.db
+                        .prepare(`INSERT INTO idempotency_keys (
+              actor_id, operation, idempotency_key, resource_id, created_at
+            ) SELECT ?, 'flows.complete', ?, ?, ?
+            WHERE EXISTS (SELECT 1 FROM flow_run_steps WHERE id = ?)`)
+                        .bind(input.actorId, input.idempotencyKey, run.id, run.updatedAt, input.stepId),
+                    deps.db
+                        .prepare(`INSERT INTO audit_events (
+              id, actor_id, action, resource_type, resource_id, metadata_json, occurred_at
+            ) SELECT ?, ?, 'flows.complete', 'flow-run', ?, ?, ?
+            WHERE EXISTS (SELECT 1 FROM flow_run_steps WHERE id = ?)`)
+                        .bind(input.auditId, input.actorId, run.id, JSON.stringify({ nodeId: input.expectedNodeId, outcome: input.outcome }), run.updatedAt, input.stepId),
+                ]);
+            }
+            catch (error) {
+                const replayed = await this.findIdempotent(input.actorId, "flows.complete", input.idempotencyKey);
+                if (!replayed)
+                    throw error;
+            }
+            const replayed = await this.findIdempotent(input.actorId, "flows.complete", input.idempotencyKey);
+            return replayed === run.id ? "advanced" : "conflict";
+        },
+    };
+}

package/dist/adapters/db/db-indexing.d.ts

@@ -0,0 +1,3 @@
+import type { KnowledgeIndexRepository } from "../../knowledge/knowledge.types.js";
+import type { D1Database } from "./db.types.js";
+export declare function createKnowledgeIndexRepository(db: D1Database): KnowledgeIndexRepository;

package/dist/adapters/db/db-indexing.js

@@ -0,0 +1,70 @@
+function mapTarget(row) {
+    return {
+        nodeId: row.node_id,
+        versionId: row.version_id,
+        title: row.title,
+        contentKey: row.content_key,
+        mediaType: row.media_type,
+        kind: row.kind,
+        updatedAt: row.updated_at,
+    };
+}
+export function createKnowledgeIndexRepository(db) {
+    return {
+        async getTarget(versionId) {
+            const row = await db
+                .prepare(`SELECT n.id AS node_id, v.id AS version_id, n.title, v.content_key,
+          v.media_type, n.kind, n.updated_at
+          FROM knowledge_versions v
+          JOIN knowledge_nodes n ON n.id = v.node_id
+          WHERE v.id = ? AND n.current_version_id = v.id AND n.archived_at IS NULL`)
+                .bind(versionId)
+                .first();
+            return row ? mapTarget(row) : null;
+        },
+        async replace(target, content) {
+            await db.batch([
+                db
+                    .prepare(`DELETE FROM knowledge_fts WHERE node_id = ? AND EXISTS (
+            SELECT 1 FROM knowledge_nodes
+            WHERE id = ? AND current_version_id = ? AND archived_at IS NULL
+          )`)
+                    .bind(target.nodeId, target.nodeId, target.versionId),
+                db
+                    .prepare(`INSERT INTO knowledge_fts (version_id, node_id, title, content)
+            SELECT ?, ?, ?, ? WHERE EXISTS (
+              SELECT 1 FROM knowledge_nodes
+              WHERE id = ? AND current_version_id = ? AND archived_at IS NULL
+            )`)
+                    .bind(target.versionId, target.nodeId, target.title, content, target.nodeId, target.versionId),
+            ]);
+        },
+        async markIndexed(versionId, occurredAt) {
+            await db
+                .prepare(`UPDATE knowledge_index_state
+          SET status = 'indexed', attempt_count = attempt_count + 1,
+            last_error = NULL, updated_at = ?
+          WHERE version_id = ? AND EXISTS (
+            SELECT 1 FROM knowledge_versions version
+            JOIN knowledge_nodes node ON node.id = version.node_id
+            WHERE version.id = ? AND node.current_version_id = version.id
+              AND node.archived_at IS NULL
+          )`)
+                .bind(occurredAt, versionId, versionId)
+                .run();
+        },
+        async markError(versionId, message, occurredAt) {
+            await db
+                .prepare(`UPDATE knowledge_index_state
+          SET status = 'error', attempt_count = attempt_count + 1,
+            last_error = ?, updated_at = ? WHERE version_id = ? AND EXISTS (
+              SELECT 1 FROM knowledge_versions version
+              JOIN knowledge_nodes node ON node.id = version.node_id
+              WHERE version.id = ? AND node.current_version_id = version.id
+                AND node.archived_at IS NULL
+            )`)
+                .bind(message.slice(0, 500), occurredAt, versionId, versionId)
+                .run();
+        },
+    };
+}

package/dist/adapters/db/db-oauth.d.ts

@@ -0,0 +1,3 @@
+import type { OAuthClientStore } from "../../auth/auth.types.js";
+import type { D1Database } from "./db.types.js";
+export declare function createOAuthClientStore(db: D1Database): OAuthClientStore;

package/dist/adapters/db/db-oauth.js

@@ -0,0 +1,26 @@
+export function createOAuthClientStore(db) {
+    return {
+        async get(issuer, redirectUri) {
+            const row = await db
+                .prepare("SELECT client_id FROM oauth_clients WHERE issuer = ? AND redirect_uri = ?")
+                .bind(issuer, redirectUri)
+                .first();
+            return row?.client_id ?? null;
+        },
+        async put(input) {
+            await db
+                .prepare(`INSERT OR IGNORE INTO oauth_clients (
+          issuer, redirect_uri, client_id, created_at
+        ) VALUES (?, ?, ?, ?)`)
+                .bind(input.issuer, input.redirectUri, input.clientId, input.createdAt)
+                .run();
+            const stored = await db
+                .prepare("SELECT client_id FROM oauth_clients WHERE issuer = ? AND redirect_uri = ?")
+                .bind(input.issuer, input.redirectUri)
+                .first();
+            if (!stored)
+                throw new Error("OAuth client registration was not stored");
+            return stored.client_id;
+        },
+    };
+}

package/dist/adapters/db/db-tools.d.ts

@@ -0,0 +1,6 @@
+import type { ToolRepository } from "../../tools/tools.types.js";
+import type { D1Database } from "./db.types.js";
+export declare function createToolRepository(deps: {
+    db: D1Database;
+    now(): Date;
+}): ToolRepository;