rebackend-drizzle 0.1.0

package/src/drizzle/outbox.ts

@@ -0,0 +1,387 @@
+import type { InferInsertModel, InferSelectModel, Table } from 'drizzle-orm'
+
+import type {
+  AnyDomainEventAction,
+  EventOutbox,
+  OutboxEntryInput,
+  OutboxRecord,
+  OutboxRecordStatus,
+  OutboxSourceType,
+} from 'rebackend'
+
+import { resolveDrizzleExecutor } from './transaction'
+
+export type DrizzleOutboxSelectRow<TTable extends Table> = InferSelectModel<TTable>
+export type DrizzleOutboxInsertRowShape<TTable extends Table> = InferInsertModel<TTable>
+export type DrizzleOutboxSelectKey<TTable extends Table> = Extract<
+  keyof DrizzleOutboxSelectRow<TTable>,
+  string
+>
+
+export type DrizzleOutboxColumnMap<
+  TTable extends Table,
+  TIdKey extends DrizzleOutboxSelectKey<TTable>,
+  TEventNameKey extends DrizzleOutboxSelectKey<TTable>,
+  TPayloadKey extends DrizzleOutboxSelectKey<TTable>,
+  TSourceTypeKey extends DrizzleOutboxSelectKey<TTable>,
+  TSourceNameKey extends DrizzleOutboxSelectKey<TTable>,
+  TStatusKey extends DrizzleOutboxSelectKey<TTable>,
+  TAttemptsKey extends DrizzleOutboxSelectKey<TTable>,
+  TCreatedAtKey extends DrizzleOutboxSelectKey<TTable>,
+  TDispatchedAtKey extends DrizzleOutboxSelectKey<TTable> | undefined = undefined,
+  TLastErrorKey extends DrizzleOutboxSelectKey<TTable> | undefined = undefined,
+> = {
+  id: TIdKey
+  eventName: TEventNameKey
+  payload: TPayloadKey
+  sourceType: TSourceTypeKey
+  sourceName: TSourceNameKey
+  status: TStatusKey
+  attempts: TAttemptsKey
+  createdAt: TCreatedAtKey
+  dispatchedAt?: TDispatchedAtKey
+  lastError?: TLastErrorKey
+}
+
+export type DrizzleOutboxInsertRow = {
+  eventName: string
+  payload: string
+  sourceType: OutboxSourceType
+  sourceName: string
+  status: OutboxRecordStatus
+  attempts: number
+  createdAt: Date
+  dispatchedAt: Date | null
+  lastError: string | null
+}
+
+export type DrizzleOutboxStoredRow = DrizzleOutboxInsertRow & {
+  id: number
+}
+
+export type DrizzleOutboxCodec<TRow, TInsertRow> = {
+  toInsertRow(entry: OutboxEntryInput, now: Date): TInsertRow
+  fromStoredRow(row: TRow): OutboxRecord
+}
+
+export const createJsonDrizzleOutboxCodec = (): DrizzleOutboxCodec<
+  DrizzleOutboxStoredRow,
+  DrizzleOutboxInsertRow
+> => {
+  return {
+    toInsertRow(entry, now) {
+      return {
+        eventName: entry.event.name,
+        payload: JSON.stringify({
+          key: entry.event.key,
+          version: entry.event.version,
+          payload: entry.event.payload,
+        }),
+        sourceType: entry.sourceType,
+        sourceName: entry.sourceName,
+        status: 'pending',
+        attempts: 0,
+        createdAt: now,
+        dispatchedAt: null,
+        lastError: null,
+      }
+    },
+    fromStoredRow(row) {
+      const envelope = JSON.parse(row.payload) as {
+        key: string
+        version: number
+        payload: AnyDomainEventAction['payload']
+      }
+
+      return {
+        id: row.id,
+        event: {
+          kind: 'DomainEventAction',
+          key: envelope.key,
+          name: row.eventName,
+          version: envelope.version,
+          payload: envelope.payload,
+        },
+        sourceType: row.sourceType,
+        sourceName: row.sourceName,
+        status: row.status,
+        attempts: row.attempts,
+        createdAt: row.createdAt,
+        dispatchedAt: row.dispatchedAt ?? undefined,
+        lastError: row.lastError ?? undefined,
+      }
+    },
+  }
+}
+
+export type DrizzleOutboxOptions<TDb, TTransaction, TStoredRow, TInsertRow> = {
+  db: TDb
+  codec: DrizzleOutboxCodec<TStoredRow, TInsertRow>
+  insertRows: (executor: TDb | TTransaction, rows: readonly TInsertRow[]) => Promise<void>
+  listRows: (executor: TDb | TTransaction) => Promise<readonly TStoredRow[]>
+  listPendingRows: (executor: TDb | TTransaction, limit?: number) => Promise<readonly TStoredRow[]>
+  markRowsDispatched: (
+    executor: TDb | TTransaction,
+    ids: readonly number[],
+    dispatchedAt: Date,
+  ) => Promise<void>
+  markRowsFailed: (
+    executor: TDb | TTransaction,
+    ids: readonly number[],
+    error: string,
+  ) => Promise<void>
+}
+
+export const createDrizzleOutbox = <TDb, TTransaction, TStoredRow, TInsertRow>(
+  options: DrizzleOutboxOptions<TDb, TTransaction, TStoredRow, TInsertRow>,
+): EventOutbox => {
+  return {
+    async append(entries, context) {
+      if (entries.length === 0) {
+        return
+      }
+
+      const executor = resolveDrizzleExecutor<TDb, TTransaction>(options.db, context)
+      const now = new Date()
+      const rows = entries.map((entry) => options.codec.toInsertRow(entry, now))
+
+      await options.insertRows(executor, rows)
+    },
+    async list() {
+      const executor = resolveDrizzleExecutor<TDb, TTransaction>(options.db)
+      const rows = await options.listRows(executor)
+
+      return rows.map((row) => options.codec.fromStoredRow(row))
+    },
+    async listPending(limit) {
+      const executor = resolveDrizzleExecutor<TDb, TTransaction>(options.db)
+      const rows = await options.listPendingRows(executor, limit)
+
+      return rows.map((row) => options.codec.fromStoredRow(row))
+    },
+    async markDispatched(ids) {
+      if (ids.length === 0) {
+        return
+      }
+
+      const executor = resolveDrizzleExecutor<TDb, TTransaction>(options.db)
+      await options.markRowsDispatched(executor, ids, new Date())
+    },
+    async markFailed(ids, error) {
+      if (ids.length === 0) {
+        return
+      }
+
+      const executor = resolveDrizzleExecutor<TDb, TTransaction>(options.db)
+      await options.markRowsFailed(executor, ids, error)
+    },
+  }
+}
+
+export type DrizzleTableOutboxOptions<
+  TDb,
+  TTransaction,
+  TTable extends Table,
+  TIdKey extends DrizzleOutboxSelectKey<TTable>,
+  TEventNameKey extends DrizzleOutboxSelectKey<TTable>,
+  TPayloadKey extends DrizzleOutboxSelectKey<TTable>,
+  TSourceTypeKey extends DrizzleOutboxSelectKey<TTable>,
+  TSourceNameKey extends DrizzleOutboxSelectKey<TTable>,
+  TStatusKey extends DrizzleOutboxSelectKey<TTable>,
+  TAttemptsKey extends DrizzleOutboxSelectKey<TTable>,
+  TCreatedAtKey extends DrizzleOutboxSelectKey<TTable>,
+  TDispatchedAtKey extends DrizzleOutboxSelectKey<TTable> | undefined = undefined,
+  TLastErrorKey extends DrizzleOutboxSelectKey<TTable> | undefined = undefined,
+> = {
+  db: TDb
+  table: TTable
+  columns: DrizzleOutboxColumnMap<
+    TTable,
+    TIdKey,
+    TEventNameKey,
+    TPayloadKey,
+    TSourceTypeKey,
+    TSourceNameKey,
+    TStatusKey,
+    TAttemptsKey,
+    TCreatedAtKey,
+    TDispatchedAtKey,
+    TLastErrorKey
+  >
+  operations: {
+    insertRows(input: {
+      executor: TDb | TTransaction
+      table: TTable
+      rows: readonly DrizzleOutboxInsertRowShape<TTable>[]
+    }): Promise<void>
+    listRows(input: {
+      executor: TDb | TTransaction
+      table: TTable
+    }): Promise<readonly DrizzleOutboxSelectRow<TTable>[]>
+    listPendingRows(input: {
+      executor: TDb | TTransaction
+      table: TTable
+      statusKey: TStatusKey
+      pendingStatus: OutboxRecordStatus
+      limit?: number
+    }): Promise<readonly DrizzleOutboxSelectRow<TTable>[]>
+    markRowsDispatched(input: {
+      executor: TDb | TTransaction
+      table: TTable
+      ids: readonly number[]
+      idKey: TIdKey
+      statusKey: TStatusKey
+      attemptsKey: TAttemptsKey
+      dispatchedAtKey?: TDispatchedAtKey
+      dispatchedAt: Date
+    }): Promise<void>
+    markRowsFailed(input: {
+      executor: TDb | TTransaction
+      table: TTable
+      ids: readonly number[]
+      idKey: TIdKey
+      statusKey: TStatusKey
+      attemptsKey: TAttemptsKey
+      lastErrorKey?: TLastErrorKey
+      error: string
+    }): Promise<void>
+  }
+}
+
+export const createDrizzleTableOutbox = <
+  TDb,
+  TTransaction,
+  TTable extends Table,
+  TIdKey extends DrizzleOutboxSelectKey<TTable>,
+  TEventNameKey extends DrizzleOutboxSelectKey<TTable>,
+  TPayloadKey extends DrizzleOutboxSelectKey<TTable>,
+  TSourceTypeKey extends DrizzleOutboxSelectKey<TTable>,
+  TSourceNameKey extends DrizzleOutboxSelectKey<TTable>,
+  TStatusKey extends DrizzleOutboxSelectKey<TTable>,
+  TAttemptsKey extends DrizzleOutboxSelectKey<TTable>,
+  TCreatedAtKey extends DrizzleOutboxSelectKey<TTable>,
+  TDispatchedAtKey extends DrizzleOutboxSelectKey<TTable> | undefined = undefined,
+  TLastErrorKey extends DrizzleOutboxSelectKey<TTable> | undefined = undefined,
+>(
+  options: DrizzleTableOutboxOptions<
+    TDb,
+    TTransaction,
+    TTable,
+    TIdKey,
+    TEventNameKey,
+    TPayloadKey,
+    TSourceTypeKey,
+    TSourceNameKey,
+    TStatusKey,
+    TAttemptsKey,
+    TCreatedAtKey,
+    TDispatchedAtKey,
+    TLastErrorKey
+  >,
+): EventOutbox => {
+  const codec: DrizzleOutboxCodec<
+    DrizzleOutboxSelectRow<TTable>,
+    DrizzleOutboxInsertRowShape<TTable>
+  > = {
+    toInsertRow(entry, now) {
+      const row = {
+        [options.columns.eventName]: entry.event.name,
+        [options.columns.payload]: JSON.stringify({
+          key: entry.event.key,
+          version: entry.event.version,
+          payload: entry.event.payload,
+        }),
+        [options.columns.sourceType]: entry.sourceType,
+        [options.columns.sourceName]: entry.sourceName,
+        [options.columns.status]: 'pending',
+        [options.columns.attempts]: 0,
+        [options.columns.createdAt]: now,
+      }
+
+      return row as DrizzleOutboxInsertRowShape<TTable>
+    },
+    fromStoredRow(row) {
+      const dispatchedAtKey = options.columns.dispatchedAt
+      const lastErrorKey = options.columns.lastError
+      const rowRecord = row as Record<string, unknown>
+      const envelope = JSON.parse(row[options.columns.payload] as string) as {
+        key: string
+        version: number
+        payload: AnyDomainEventAction['payload']
+      }
+
+      return {
+        id: row[options.columns.id] as number,
+        event: {
+          kind: 'DomainEventAction',
+          key: envelope.key,
+          name: row[options.columns.eventName] as string,
+          version: envelope.version,
+          payload: envelope.payload,
+        },
+        sourceType: row[options.columns.sourceType] as OutboxSourceType,
+        sourceName: row[options.columns.sourceName] as string,
+        status: row[options.columns.status] as OutboxRecordStatus,
+        attempts: row[options.columns.attempts] as number,
+        createdAt: row[options.columns.createdAt] as OutboxRecord['createdAt'],
+        dispatchedAt: dispatchedAtKey
+          ? (rowRecord[dispatchedAtKey] as OutboxRecord['dispatchedAt'])
+          : undefined,
+        lastError: lastErrorKey
+          ? (rowRecord[lastErrorKey] as OutboxRecord['lastError'])
+          : undefined,
+      }
+    },
+  }
+
+  return createDrizzleOutbox<
+    TDb,
+    TTransaction,
+    DrizzleOutboxSelectRow<TTable>,
+    DrizzleOutboxInsertRowShape<TTable>
+  >({
+    db: options.db,
+    codec,
+    insertRows: (executor, rows) =>
+      options.operations.insertRows({
+        executor,
+        table: options.table,
+        rows,
+      }),
+    listRows: (executor) =>
+      options.operations.listRows({
+        executor,
+        table: options.table,
+      }),
+    listPendingRows: (executor, limit) =>
+      options.operations.listPendingRows({
+        executor,
+        table: options.table,
+        statusKey: options.columns.status,
+        pendingStatus: 'pending',
+        limit,
+      }),
+    markRowsDispatched: (executor, ids, dispatchedAt) =>
+      options.operations.markRowsDispatched({
+        executor,
+        table: options.table,
+        ids,
+        idKey: options.columns.id,
+        statusKey: options.columns.status,
+        attemptsKey: options.columns.attempts,
+        dispatchedAtKey: options.columns.dispatchedAt,
+        dispatchedAt,
+      }),
+    markRowsFailed: (executor, ids, error) =>
+      options.operations.markRowsFailed({
+        executor,
+        table: options.table,
+        ids,
+        idKey: options.columns.id,
+        statusKey: options.columns.status,
+        attemptsKey: options.columns.attempts,
+        lastErrorKey: options.columns.lastError,
+        error,
+      }),
+  })
+}

package/src/drizzle/presets.ts

@@ -0,0 +1,274 @@
+import {
+  and,
+  eq,
+  getTableColumns,
+  inArray,
+  sql,
+  type InferSelectModel,
+  type Table,
+} from 'drizzle-orm'
+
+import type { AggregateState, AnyAggregateDefinition } from 'rebackend'
+
+import {
+  createDrizzleTableAggregateRepository,
+  type DrizzleSelectKey,
+  type DrizzleTableAggregateRepositoryOptions,
+} from './repository'
+import {
+  createDrizzleTableOutbox,
+  type DrizzleOutboxColumnMap,
+  type DrizzleTableOutboxOptions,
+} from './outbox'
+
+type QueryRows<TRow> = PromiseLike<readonly TRow[]>
+
+type SelectWhereQuery<TRow> = QueryRows<TRow> & {
+  limit(limit: number): QueryRows<TRow>
+}
+
+type SelectFromQuery<TTable extends Table> = QueryRows<InferSelectModel<TTable>> & {
+  where(condition: unknown): SelectWhereQuery<InferSelectModel<TTable>>
+}
+
+export type BasicDrizzleTableExecutor<TTable extends Table> = {
+  select(): {
+    from(table: TTable): SelectFromQuery<TTable>
+  }
+  insert(table: TTable): {
+    values(values: unknown): unknown
+  }
+  update(table: TTable): {
+    set(values: Record<string, unknown>): {
+      where(condition: unknown): unknown
+    }
+  }
+}
+
+export type DrizzleMutationSuccessJudge = (result: unknown) => boolean
+
+export type BasicDrizzleTableAggregateRepositoryOptions<
+  TAggregate extends AnyAggregateDefinition,
+  TDb extends BasicDrizzleTableExecutor<TTable>,
+  TTransaction extends BasicDrizzleTableExecutor<TTable>,
+  TTable extends Table,
+  TIdentityRowKey extends DrizzleSelectKey<TTable>,
+  TIdentityStateKey extends Extract<keyof AggregateState<TAggregate>, string>,
+  TVersionRowKey extends DrizzleSelectKey<TTable> | undefined = undefined,
+  TVersionStateKey extends Extract<keyof AggregateState<TAggregate>, string> | undefined =
+    undefined,
+> = Omit<
+  DrizzleTableAggregateRepositoryOptions<
+    TAggregate,
+    TDb,
+    TTransaction,
+    TTable,
+    TIdentityRowKey,
+    TIdentityStateKey,
+    TVersionRowKey,
+    TVersionStateKey
+  >,
+  'operations'
+> & {
+  didUpdateSucceed: DrizzleMutationSuccessJudge
+}
+
+export const createBasicDrizzleTableAggregateRepository = <
+  TAggregate extends AnyAggregateDefinition,
+  TDb extends BasicDrizzleTableExecutor<TTable>,
+  TTransaction extends BasicDrizzleTableExecutor<TTable>,
+  TTable extends Table,
+  TIdentityRowKey extends DrizzleSelectKey<TTable>,
+  TIdentityStateKey extends Extract<keyof AggregateState<TAggregate>, string>,
+  TVersionRowKey extends DrizzleSelectKey<TTable> | undefined = undefined,
+  TVersionStateKey extends Extract<keyof AggregateState<TAggregate>, string> | undefined =
+    undefined,
+>(
+  options: BasicDrizzleTableAggregateRepositoryOptions<
+    TAggregate,
+    TDb,
+    TTransaction,
+    TTable,
+    TIdentityRowKey,
+    TIdentityStateKey,
+    TVersionRowKey,
+    TVersionStateKey
+  >,
+) => {
+  const columns = getTableColumns(options.table)
+  const identityColumn = columns[options.identity.rowKey]
+  const versionRowKey = options.version?.rowKey
+  const versionColumn = versionRowKey ? columns[versionRowKey] : undefined
+
+  const repositoryOptions: DrizzleTableAggregateRepositoryOptions<
+    TAggregate,
+    TDb,
+    TTransaction,
+    TTable,
+    TIdentityRowKey,
+    TIdentityStateKey,
+    TVersionRowKey,
+    TVersionStateKey
+  > = {
+    ...options,
+    operations: {
+      async findById({ executor, table, id }) {
+        const rows = await executor.select().from(table).where(eq(identityColumn, id)).limit(1)
+        return rows[0] ?? null
+      },
+      async insertOne({ executor, table, row }) {
+        await executor.insert(table).values(row)
+      },
+      async updateById({ executor, table, id, row, optimisticLock, expectedVersion }) {
+        const whereCondition =
+          optimisticLock && versionColumn && expectedVersion !== undefined
+            ? and(eq(identityColumn, id), eq(versionColumn, expectedVersion))
+            : eq(identityColumn, id)
+
+        const result = await executor.update(table).set(row).where(whereCondition)
+        return options.didUpdateSucceed(result)
+      },
+    },
+  }
+
+  return createDrizzleTableAggregateRepository(repositoryOptions)
+}
+
+export type BasicDrizzleTableOutboxOptions<
+  TDb extends BasicDrizzleTableExecutor<TTable>,
+  _TTransaction extends BasicDrizzleTableExecutor<TTable>,
+  TTable extends Table,
+  TIdKey extends Extract<keyof InferSelectModel<TTable>, string>,
+  TEventNameKey extends Extract<keyof InferSelectModel<TTable>, string>,
+  TPayloadKey extends Extract<keyof InferSelectModel<TTable>, string>,
+  TSourceTypeKey extends Extract<keyof InferSelectModel<TTable>, string>,
+  TSourceNameKey extends Extract<keyof InferSelectModel<TTable>, string>,
+  TStatusKey extends Extract<keyof InferSelectModel<TTable>, string>,
+  TAttemptsKey extends Extract<keyof InferSelectModel<TTable>, string>,
+  TCreatedAtKey extends Extract<keyof InferSelectModel<TTable>, string>,
+  TDispatchedAtKey extends Extract<keyof InferSelectModel<TTable>, string> | undefined = undefined,
+  TLastErrorKey extends Extract<keyof InferSelectModel<TTable>, string> | undefined = undefined,
+> = {
+  db: TDb
+  table: TTable
+  columns: DrizzleOutboxColumnMap<
+    TTable,
+    TIdKey,
+    TEventNameKey,
+    TPayloadKey,
+    TSourceTypeKey,
+    TSourceNameKey,
+    TStatusKey,
+    TAttemptsKey,
+    TCreatedAtKey,
+    TDispatchedAtKey,
+    TLastErrorKey
+  >
+}
+
+export const createBasicDrizzleTableOutbox = <
+  TDb extends BasicDrizzleTableExecutor<TTable>,
+  _TTransaction extends BasicDrizzleTableExecutor<TTable>,
+  TTable extends Table,
+  TIdKey extends Extract<keyof InferSelectModel<TTable>, string>,
+  TEventNameKey extends Extract<keyof InferSelectModel<TTable>, string>,
+  TPayloadKey extends Extract<keyof InferSelectModel<TTable>, string>,
+  TSourceTypeKey extends Extract<keyof InferSelectModel<TTable>, string>,
+  TSourceNameKey extends Extract<keyof InferSelectModel<TTable>, string>,
+  TStatusKey extends Extract<keyof InferSelectModel<TTable>, string>,
+  TAttemptsKey extends Extract<keyof InferSelectModel<TTable>, string>,
+  TCreatedAtKey extends Extract<keyof InferSelectModel<TTable>, string>,
+  TDispatchedAtKey extends Extract<keyof InferSelectModel<TTable>, string> | undefined = undefined,
+  TLastErrorKey extends Extract<keyof InferSelectModel<TTable>, string> | undefined = undefined,
+>(
+  options: BasicDrizzleTableOutboxOptions<
+    TDb,
+    _TTransaction,
+    TTable,
+    TIdKey,
+    TEventNameKey,
+    TPayloadKey,
+    TSourceTypeKey,
+    TSourceNameKey,
+    TStatusKey,
+    TAttemptsKey,
+    TCreatedAtKey,
+    TDispatchedAtKey,
+    TLastErrorKey
+  >,
+) => {
+  const columns = getTableColumns(options.table)
+  const idColumn = columns[options.columns.id]
+  const attemptsColumn = columns[options.columns.attempts]
+  const statusColumn = columns[options.columns.status]
+
+  const outboxOptions: DrizzleTableOutboxOptions<
+    TDb,
+    _TTransaction,
+    TTable,
+    TIdKey,
+    TEventNameKey,
+    TPayloadKey,
+    TSourceTypeKey,
+    TSourceNameKey,
+    TStatusKey,
+    TAttemptsKey,
+    TCreatedAtKey,
+    TDispatchedAtKey,
+    TLastErrorKey
+  > = {
+    ...options,
+    operations: {
+      async insertRows({ executor, table, rows }) {
+        await executor.insert(table).values(rows)
+      },
+      async listRows({ executor, table }) {
+        return executor.select().from(table)
+      },
+      async listPendingRows({ executor, table, pendingStatus, limit }) {
+        const query = executor.select().from(table).where(eq(statusColumn, pendingStatus))
+        return limit === undefined ? query : query.limit(limit)
+      },
+      async markRowsDispatched({
+        executor,
+        table,
+        ids,
+        statusKey,
+        attemptsKey,
+        dispatchedAtKey,
+        dispatchedAt,
+      }) {
+        const updateRow: Record<string, unknown> = {
+          [statusKey]: 'dispatched',
+          [attemptsKey]: sql`${attemptsColumn} + 1`,
+        }
+
+        if (dispatchedAtKey) {
+          updateRow[dispatchedAtKey] = dispatchedAt
+        }
+
+        await executor
+          .update(table)
+          .set(updateRow)
+          .where(inArray(idColumn, [...ids]))
+      },
+      async markRowsFailed({ executor, table, ids, statusKey, attemptsKey, lastErrorKey, error }) {
+        const updateRow: Record<string, unknown> = {
+          [statusKey]: 'failed',
+          [attemptsKey]: sql`${attemptsColumn} + 1`,
+        }
+
+        if (lastErrorKey) {
+          updateRow[lastErrorKey] = error
+        }
+
+        await executor
+          .update(table)
+          .set(updateRow)
+          .where(inArray(idColumn, [...ids]))
+      },
+    },
+  }
+
+  return createDrizzleTableOutbox(outboxOptions)
+}