@sixb/sqlite 0.0.1

package/src/auth-storage/users.ts

@@ -0,0 +1,226 @@
+import type { Database } from "bun:sqlite"
+import type {
+  AuthUserStore,
+  CreateAuthUserInput,
+  ListAuthUsersInput,
+  ListAuthUsersResult,
+  UpdateAuthUserProfileInput,
+  UpdateAuthUserStatusInput,
+  UserRecord,
+} from "@sixb/core/storage"
+import { AuthStorageError } from "@sixb/core/storage"
+import type { SqliteAuthUserRow } from "./rows"
+import { rowToUserRecord } from "./rows"
+import {
+  appendPagination,
+  assertNonEmpty,
+  dateOrNow,
+  getUserRowByEmail,
+  getUserRowById,
+  hasEmptyFilter,
+  mapUniqueConstraintError,
+  normalizeEmail,
+  type SqliteValue,
+  toIso,
+} from "./shared"
+
+export class SqliteAuthUserStore implements AuthUserStore {
+  constructor(private readonly db: Database) {}
+
+  async create(input: CreateAuthUserInput): Promise<UserRecord> {
+    const id = assertNonEmpty(input.id, "User id")
+    const projectId = assertNonEmpty(input.projectId, "Project id")
+    const email = normalizeEmail(input.email)
+
+    if (getUserRowById(this.db, { projectId, id })) {
+      throw new AuthStorageError(
+        "duplicate_user",
+        `[Sixb] User '${id}' already exists for project '${projectId}'.`
+      )
+    }
+
+    if (getUserRowByEmail(this.db, { projectId, email })) {
+      throw new AuthStorageError(
+        "duplicate_user",
+        `[Sixb] User email '${email}' already exists for project '${projectId}'.`
+      )
+    }
+
+    const createdAt = dateOrNow(input.createdAt)
+    const updatedAt = input.updatedAt ? new Date(input.updatedAt) : createdAt
+
+    try {
+      this.db
+        .query(
+          `
+          INSERT INTO auth_users (
+            project_id,
+            id,
+            email,
+            display_name,
+            avatar_url,
+            status,
+            created_at,
+            updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        `
+        )
+        .run(
+          projectId,
+          id,
+          email,
+          input.displayName ?? null,
+          input.avatarUrl ?? null,
+          input.status ?? "active",
+          toIso(createdAt),
+          toIso(updatedAt)
+        )
+    } catch (error) {
+      mapUniqueConstraintError(
+        error,
+        "duplicate_user",
+        `[Sixb] User '${id}' already exists for project '${projectId}'.`
+      )
+    }
+
+    return {
+      id,
+      projectId,
+      email,
+      displayName: input.displayName,
+      avatarUrl: input.avatarUrl,
+      status: input.status ?? "active",
+      createdAt,
+      updatedAt,
+    }
+  }
+
+  async getById(params: {
+    readonly projectId: string
+    readonly id: string
+  }): Promise<UserRecord | null> {
+    const row = getUserRowById(this.db, params)
+    return row ? rowToUserRecord(row) : null
+  }
+
+  async getByEmail(params: {
+    readonly projectId: string
+    readonly email: string
+  }): Promise<UserRecord | null> {
+    const row = getUserRowByEmail(this.db, params)
+    return row ? rowToUserRecord(row) : null
+  }
+
+  async updateProfile(input: UpdateAuthUserProfileInput): Promise<UserRecord> {
+    const existing = getUserRowById(this.db, {
+      projectId: input.projectId,
+      id: input.id,
+    })
+
+    if (!existing) {
+      throw new AuthStorageError(
+        "missing_user",
+        `[Sixb] User '${input.id}' not found for project '${input.projectId}'.`
+      )
+    }
+
+    const updatedAt = dateOrNow(input.updatedAt)
+    this.db
+      .query(
+        `
+        UPDATE auth_users
+        SET display_name = ?,
+            avatar_url = ?,
+            updated_at = ?
+        WHERE project_id = ?
+          AND id = ?
+      `
+      )
+      .run(
+        input.displayName ?? null,
+        input.avatarUrl ?? null,
+        toIso(updatedAt),
+        input.projectId,
+        input.id
+      )
+
+    return rowToUserRecord({
+      ...existing,
+      display_name: input.displayName ?? null,
+      avatar_url: input.avatarUrl ?? null,
+      updated_at: toIso(updatedAt),
+    })
+  }
+
+  async updateStatus(input: UpdateAuthUserStatusInput): Promise<UserRecord> {
+    const existing = getUserRowById(this.db, {
+      projectId: input.projectId,
+      id: input.id,
+    })
+
+    if (!existing) {
+      throw new AuthStorageError(
+        "missing_user",
+        `[Sixb] User '${input.id}' not found for project '${input.projectId}'.`
+      )
+    }
+
+    const updatedAt = dateOrNow(input.updatedAt)
+    this.db
+      .query(
+        `
+        UPDATE auth_users
+        SET status = ?,
+            updated_at = ?
+        WHERE project_id = ?
+          AND id = ?
+      `
+      )
+      .run(input.status, toIso(updatedAt), input.projectId, input.id)
+
+    return rowToUserRecord({
+      ...existing,
+      status: input.status,
+      updated_at: toIso(updatedAt),
+    })
+  }
+
+  async list(input: ListAuthUsersInput): Promise<ListAuthUsersResult> {
+    if (hasEmptyFilter(input.statuses)) {
+      return { users: [], hasMore: false, total: 0 }
+    }
+
+    const whereClauses = ["project_id = ?"]
+    const args: SqliteValue[] = [input.projectId]
+
+    if (input.statuses) {
+      whereClauses.push(`status IN (${input.statuses.map(() => "?").join(", ")})`)
+      args.push(...input.statuses)
+    }
+
+    const where = `WHERE ${whereClauses.join(" AND ")}`
+    const order = input.order === "asc" ? "ASC" : "DESC"
+    const totalRow = this.db
+      .query(`SELECT COUNT(*) AS count FROM auth_users ${where}`)
+      .get(...args) as { readonly count: number }
+
+    const queryArgs = [...args]
+    const query = appendPagination(
+      `
+      SELECT *
+      FROM auth_users
+      ${where}
+      ORDER BY created_at ${order}, id ${order}
+    `,
+      queryArgs,
+      input
+    )
+    const rows = this.db.query(query).all(...queryArgs) as SqliteAuthUserRow[]
+
+    return {
+      users: rows.map(rowToUserRecord),
+      hasMore: (input.offset ?? 0) + rows.length < totalRow.count,
+      total: totalRow.count,
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,292 @@
+// Keep SQL module declarations visible to downstream workspaces that typecheck this package from
+// source.
+/// <reference path="./sql.d.ts" />
+
+import { AsyncLocalStorage } from "node:async_hooks"
+import type {
+  MigrationCapableStorage,
+  Storage,
+  StorageMigrator,
+  StorageTransactionOptions,
+} from "@sixb/core"
+import { ProviderMaterializationTransactionLifecycle } from "@sixb/core/internal/ontology-storage-provider"
+import {
+  createAgentOperationScope,
+  createAuthOperationScope,
+  createOntologyOperationScope,
+  createOperationScopedFacade,
+  createStorageOperationScope,
+  createWorkflowRunOperationScope,
+} from "@sixb/core/internal/storage-operation-scope"
+import {
+  createTransactionStorageProxy,
+  StorageTransactionError,
+  throwNestedStorageTransaction,
+} from "@sixb/core/storage"
+import { SqliteActionRunStorage } from "./action-run-storage"
+import { SqliteAgentStorage } from "./agents"
+import { SqliteAuthStorage } from "./auth-storage"
+import {
+  createSqliteStorageMigrators,
+  installFreshSqliteSchema,
+  sqliteStoragePath,
+} from "./migrations"
+import { SqliteObjectStorage } from "./object-storage"
+import { SqliteOntologyStorage, type SqliteOntologyTransactionContext } from "./ontology-storage"
+import { SqlitePipelineRunStorage } from "./pipeline-run-storage"
+import { SqliteProjectionRunStorage } from "./projection-run-storage"
+import { SqliteRulesStorage } from "./rules-storage"
+import { SqliteSyncRunStorage } from "./sync-run-storage"
+import { SqliteTimeseriesStorage } from "./timeseries-storage"
+import {
+  closeSqliteStoreConnection,
+  openSqliteStoreConnection,
+  runImmediateTransactionAsync,
+  type SqliteStoreConnection,
+} from "./transactions"
+import { SqliteWebhookDeliveryStorage } from "./webhook-delivery-storage"
+import { SqliteWebhookRunStorage } from "./webhook-run-storage"
+import { SqliteWorkflowInterventionStorage } from "./workflow-intervention-storage"
+import { SqliteWorkflowRunStorage } from "./workflow-run-storage"
+
+export interface SqliteStorageOptions {
+  /** Directory path for the SQLite storage database. */
+  path?: string
+}
+
+/**
+ * SQLite storage provider for Sixb.
+ *
+ * Bundles object, timeseries, auth, sync run, pipeline run, projection run, workflow run, webhook
+ * run, and webhook delivery storage backed by SQLite.
+ *
+ * Usage:
+ * ```ts
+ * const storage = new SqliteStorage({ path: ".sixb" })
+ *
+ * export const sixb = createSixb({
+ *   broker: new InMemoryBroker(),
+ *   storage,
+ * })
+ * ```
+ */
+export class SqliteStorage implements MigrationCapableStorage {
+  readonly objects: Storage["objects"]
+  readonly ontology: SqliteOntologyStorage
+  readonly auth: SqliteAuthStorage
+  readonly agents: SqliteAgentStorage
+  readonly actionRuns: SqliteActionRunStorage
+  readonly pipelineRuns: SqlitePipelineRunStorage
+  readonly syncRuns: SqliteSyncRunStorage
+  readonly projectionRuns: SqliteProjectionRunStorage
+  readonly workflowRuns: SqliteWorkflowRunStorage
+  readonly workflowInterventions: SqliteWorkflowInterventionStorage
+  readonly timeseries: Storage["timeseries"]
+  readonly webhookDeliveries: SqliteWebhookDeliveryStorage
+  readonly webhookRuns: SqliteWebhookRunStorage
+  readonly rules: SqliteRulesStorage
+  readonly migrators: readonly StorageMigrator[]
+
+  private readonly connection: SqliteStoreConnection
+  private readonly transactionScope = new AsyncLocalStorage<{ active: boolean }>()
+  private transactionTail: Promise<void> = Promise.resolve()
+
+  constructor(options: SqliteStorageOptions = {}) {
+    const path = options.path ? sqliteStoragePath(options.path) : undefined
+    this.connection = openSqliteStoreConnection({ path })
+
+    if (this.connection.installFreshSchema) {
+      installFreshSqliteSchema(this.connection.db)
+    }
+
+    const stores = createSqliteStores(this.connection, {
+      runOntologyOperation: async (run) => run(),
+      transactionContext: null,
+    })
+    const assertRootOperationAvailable = () => this.assertRootOperationAvailable()
+    const scope = createStorageOperationScope(
+      (run) => this.runRootStorageOperation(run),
+      assertRootOperationAvailable
+    )
+    const ontologyScope = createStorageOperationScope(
+      (run) => this.runRootOntologyOperation(run),
+      assertRootOperationAvailable
+    )
+    this.objects = createOperationScopedFacade(stores.objects, scope)
+    this.ontology = createOntologyOperationScope(stores.ontology, ontologyScope)
+    this.auth = createAuthOperationScope(stores.auth, scope)
+    this.agents = createAgentOperationScope(stores.agents, scope)
+    this.actionRuns = createOperationScopedFacade(stores.actionRuns, scope)
+    this.pipelineRuns = createOperationScopedFacade(stores.pipelineRuns, scope)
+    this.timeseries = createOperationScopedFacade(stores.timeseries, scope)
+    this.syncRuns = createOperationScopedFacade(stores.syncRuns, scope)
+    this.projectionRuns = createOperationScopedFacade(stores.projectionRuns, scope)
+    this.workflowRuns = createWorkflowRunOperationScope(stores.workflowRuns, scope)
+    this.workflowInterventions = createOperationScopedFacade(stores.workflowInterventions, scope)
+    this.webhookDeliveries = createOperationScopedFacade(stores.webhookDeliveries, scope)
+    this.webhookRuns = createOperationScopedFacade(stores.webhookRuns, scope)
+    this.rules = createOperationScopedFacade(stores.rules, scope)
+    this.migrators = options.path ? createSqliteStorageMigrators(options.path) : []
+  }
+
+  async ping(): Promise<void> {
+    await this.runRootStorageOperation(() => {
+      this.connection.db.query("SELECT 1").get()
+    })
+  }
+
+  /**
+   * The `isolation` option is intentionally ignored. SQLite runs every transaction through one
+   * shared connection serialized by {@link withTransactionLock} and a `BEGIN IMMEDIATE`, so there is
+   * no concurrent transaction to isolate against — the lock already provides serializable semantics
+   * for transaction-vs-transaction races. Postgres, which has true concurrent connections, is where
+   * `isolation: "serializable"` translates to a real isolation level.
+   */
+  async transaction<T>(
+    run: (tx: Storage) => Promise<T> | T,
+    _options: StorageTransactionOptions = {}
+  ): Promise<T> {
+    if (this.transactionScope.getStore()) {
+      throwNestedStorageTransaction()
+    }
+
+    return this.withTransactionLock(async () => {
+      let active = true
+      const scope = { active: true }
+      const transactionContext: SqliteOntologyTransactionContext = {
+        id: {},
+        materializations: new ProviderMaterializationTransactionLifecycle(),
+        active: true,
+      }
+      const txStorage = this.createTransactionStorage(transactionContext)
+      const tx = createTransactionStorageProxy(txStorage, () => active)
+
+      try {
+        return await runImmediateTransactionAsync(this.connection.db, () =>
+          this.transactionScope.run(scope, async () => {
+            try {
+              const result = await run(tx)
+              transactionContext.materializations.assertCommittable()
+              return result
+            } finally {
+              scope.active = false
+              transactionContext.active = false
+              txStorage.ontology.deactivateSessions()
+              transactionContext.materializations.deactivate()
+            }
+          })
+        )
+      } finally {
+        active = false
+      }
+    })
+  }
+
+  close(): void {
+    closeSqliteStoreConnection(this.connection)
+  }
+
+  private createTransactionStorage(
+    transactionContext: SqliteOntologyTransactionContext
+  ): Storage & { readonly ontology: SqliteOntologyStorage } {
+    return {
+      ...createSqliteStores(
+        {
+          db: this.connection.db,
+          ownsConnection: false,
+          installFreshSchema: false,
+        },
+        {
+          runOntologyOperation: async (run) => run(),
+          transactionContext,
+        }
+      ),
+      ping: async () => {
+        this.connection.db.query("SELECT 1").get()
+      },
+      transaction: async <T>(): Promise<T> => {
+        throwNestedStorageTransaction()
+      },
+    }
+  }
+
+  private runRootStorageOperation<T>(run: () => Promise<T> | T): Promise<T> {
+    this.assertRootOperationAvailable()
+    return this.withTransactionLock(async () => run())
+  }
+
+  private runRootOntologyOperation<T>(run: () => Promise<T> | T): Promise<T> {
+    this.assertRootOperationAvailable()
+    return this.withTransactionLock(() => runImmediateTransactionAsync(this.connection.db, run))
+  }
+
+  private assertRootOperationAvailable(): void {
+    if (!this.transactionScope.getStore()?.active) return
+    throw new StorageTransactionError(
+      "[SixbSqlite] Root storage cannot be used inside a transaction callback; use the provided tx storage."
+    )
+  }
+
+  private async withTransactionLock<T>(run: () => Promise<T>): Promise<T> {
+    const previous = this.transactionTail
+    let release!: () => void
+    this.transactionTail = new Promise<void>((resolve) => {
+      release = resolve
+    })
+
+    await previous
+    try {
+      return await run()
+    } finally {
+      release()
+    }
+  }
+}
+
+function createSqliteStores(
+  connection: SqliteStoreConnection,
+  options: {
+    readonly runOntologyOperation: <T>(run: () => Promise<T> | T) => Promise<T>
+    readonly transactionContext: SqliteOntologyTransactionContext | null
+  }
+): SqliteStoreSet {
+  return {
+    objects: new SqliteObjectStorage({ connection }),
+    ontology: new SqliteOntologyStorage({
+      db: connection.db,
+      runRootOperation: options.runOntologyOperation,
+      transactionContext: options.transactionContext,
+    }),
+    auth: new SqliteAuthStorage({ connection }),
+    agents: new SqliteAgentStorage({ connection }),
+    actionRuns: new SqliteActionRunStorage({ connection }),
+    pipelineRuns: new SqlitePipelineRunStorage({ connection }),
+    timeseries: new SqliteTimeseriesStorage({ connection }),
+    syncRuns: new SqliteSyncRunStorage({ connection }),
+    projectionRuns: new SqliteProjectionRunStorage({ connection }),
+    workflowRuns: new SqliteWorkflowRunStorage({ connection }),
+    workflowInterventions: new SqliteWorkflowInterventionStorage({ connection }),
+    webhookDeliveries: new SqliteWebhookDeliveryStorage({ connection }),
+    webhookRuns: new SqliteWebhookRunStorage({ connection }),
+    rules: new SqliteRulesStorage({ connection }),
+  }
+}
+
+interface SqliteStoreSet {
+  readonly objects: SqliteObjectStorage
+  readonly ontology: SqliteOntologyStorage
+  readonly auth: SqliteAuthStorage
+  readonly agents: SqliteAgentStorage
+  readonly actionRuns: SqliteActionRunStorage
+  readonly pipelineRuns: SqlitePipelineRunStorage
+  readonly syncRuns: SqliteSyncRunStorage
+  readonly projectionRuns: SqliteProjectionRunStorage
+  readonly workflowRuns: SqliteWorkflowRunStorage
+  readonly workflowInterventions: SqliteWorkflowInterventionStorage
+  readonly timeseries: SqliteTimeseriesStorage
+  readonly webhookDeliveries: SqliteWebhookDeliveryStorage
+  readonly webhookRuns: SqliteWebhookRunStorage
+  readonly rules: SqliteRulesStorage
+}
+
+export { migrateSqliteStorage } from "./migrations"

package/src/latest-run-query.ts

@@ -0,0 +1,49 @@
+import type { Database } from "bun:sqlite"
+import type { SqliteValue } from "./run-list-query"
+
+type SqliteLatestRunTarget =
+  | { readonly tableName: "pipeline_runs"; readonly ownerColumn: "pipeline_id" }
+  | { readonly tableName: "projection_runs"; readonly ownerColumn: "projection_id" }
+  | { readonly tableName: "sync_runs"; readonly ownerColumn: "sync_id" }
+  | { readonly tableName: "workflow_runs"; readonly ownerColumn: "workflow_id" }
+
+export function queryLatestRunsByOwnerId<TRow>(
+  input: {
+    readonly db: Database
+    readonly ownerIds: readonly string[]
+    readonly projectId: string
+    readonly ownerIdFor: (row: TRow) => string
+  } & SqliteLatestRunTarget
+): readonly TRow[] {
+  const ownerIds = [...new Set(input.ownerIds)]
+  if (ownerIds.length === 0) {
+    return []
+  }
+
+  const placeholders = ownerIds.map(() => "?").join(", ")
+  const rows = input.db
+    .query(
+      `
+        SELECT *
+        FROM (
+          SELECT
+            *,
+            ROW_NUMBER() OVER (
+              PARTITION BY ${input.ownerColumn}
+              ORDER BY started_at DESC, id DESC
+            ) AS sixb_latest_rank
+          FROM ${input.tableName}
+          WHERE project_id = ? AND ${input.ownerColumn} IN (${placeholders})
+        )
+        WHERE sixb_latest_rank = 1
+      `
+    )
+    .all(input.projectId, ...ownerIds) as (TRow & { sixb_latest_rank: SqliteValue })[]
+
+  const latestByOwnerId = new Map(rows.map((row) => [input.ownerIdFor(row), row]))
+
+  return ownerIds.flatMap((ownerId) => {
+    const row = latestByOwnerId.get(ownerId)
+    return row ? [row] : []
+  })
+}