rebackend-drizzle 0.1.0 → 0.1.1

package/README.md

@@ -19,3 +19,4 @@ pnpm add rebackend rebackend-drizzle drizzle-orm farrow-schema
 ## Related Package
 
 - `rebackend`: core runtime, DDD/CQRS primitives, outbox, dispatcher, UoW
+- `rebackend-farrow-http`: official Farrow HTTP adapter for request handling and context bridge

package/dist/drizzle/index.d.ts

@@ -0,0 +1,4 @@
+export * from './transaction';
+export * from './repository';
+export * from './outbox';
+export * from './presets';

package/dist/drizzle/outbox.d.ts

@@ -0,0 +1,90 @@
+import type { InferInsertModel, InferSelectModel, Table } from 'drizzle-orm';
+import type { EventOutbox, OutboxEntryInput, OutboxRecord, OutboxRecordStatus, OutboxSourceType } from 'rebackend';
+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 declare const createJsonDrizzleOutboxCodec: () => DrizzleOutboxCodec<DrizzleOutboxStoredRow, DrizzleOutboxInsertRow>;
+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 declare const createDrizzleOutbox: <TDb, TTransaction, TStoredRow, TInsertRow>(options: DrizzleOutboxOptions<TDb, TTransaction, TStoredRow, TInsertRow>) => EventOutbox;
+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 declare 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;

package/dist/drizzle/presets.d.ts

@@ -0,0 +1,36 @@
+import { type InferSelectModel, type Table } from 'drizzle-orm';
+import type { AggregateState, AnyAggregateDefinition } from 'rebackend';
+import { type DrizzleSelectKey, type DrizzleTableAggregateRepositoryOptions } from './repository';
+import { type DrizzleOutboxColumnMap } 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 declare 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>) => import("rebackend").AggregateRepository<TAggregate>;
+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 declare 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>) => import("rebackend").EventOutbox;
+export {};

package/dist/drizzle/repository.d.ts

@@ -0,0 +1,69 @@
+import type { InferInsertModel, InferSelectModel, Table } from 'drizzle-orm';
+import type { AggregateIdentity, AggregateRepository, AggregateState, AnyAggregateDefinition } from 'rebackend';
+export type DrizzleSelectRow<TTable extends Table> = InferSelectModel<TTable>;
+export type DrizzleInsertRow<TTable extends Table> = InferInsertModel<TTable>;
+type KeysMatching<TRow, TValue> = Extract<{
+    [K in keyof TRow]-?: Exclude<TRow[K], null | undefined> extends TValue ? K : never;
+}[keyof TRow], string>;
+export type DrizzleSelectKeyMatching<TTable extends Table, TValue> = KeysMatching<DrizzleSelectRow<TTable>, TValue>;
+export type DrizzleInsertKeyMatching<TTable extends Table, TValue> = KeysMatching<DrizzleInsertRow<TTable>, TValue>;
+export type DrizzleSelectKey<TTable extends Table> = Extract<keyof DrizzleSelectRow<TTable>, string>;
+export type DrizzleAggregateRepositoryOptions<TAggregate extends AnyAggregateDefinition, TDb, TTransaction, TRow> = {
+    db: TDb;
+    load: (executor: TDb | TTransaction, id: AggregateIdentity<TAggregate>) => Promise<TRow | null | undefined>;
+    insert: (executor: TDb | TTransaction, next: AggregateState<TAggregate>) => Promise<void>;
+    update: (input: {
+        executor: TDb | TTransaction;
+        next: AggregateState<TAggregate>;
+        current: AggregateState<TAggregate>;
+        optimisticLock: boolean;
+    }) => Promise<boolean>;
+    deserialize: (row: TRow) => AggregateState<TAggregate>;
+};
+export declare const createDrizzleAggregateRepository: <TAggregate extends AnyAggregateDefinition, TDb, TTransaction, TRow>(options: DrizzleAggregateRepositoryOptions<TAggregate, TDb, TTransaction, TRow>) => AggregateRepository<TAggregate>;
+export type DrizzleTableAggregateRepositoryOptions<TAggregate extends AnyAggregateDefinition, TDb, TTransaction, 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> = {
+    db: TDb;
+    table: TTable;
+    identity: {
+        stateKey: TIdentityStateKey;
+        rowKey: TIdentityRowKey;
+    };
+    version?: {
+        stateKey: TVersionStateKey;
+        rowKey: TVersionRowKey;
+    };
+    serialize: {
+        insert(state: AggregateState<TAggregate>): DrizzleInsertRow<TTable>;
+        update(state: AggregateState<TAggregate>): Partial<DrizzleInsertRow<TTable>>;
+    };
+    deserialize(row: DrizzleSelectRow<TTable>): AggregateState<TAggregate>;
+    operations: {
+        findById(input: {
+            executor: TDb | TTransaction;
+            table: TTable;
+            rowKey: TIdentityRowKey;
+            id: AggregateIdentity<TAggregate>;
+        }): Promise<DrizzleSelectRow<TTable> | null | undefined>;
+        insertOne(input: {
+            executor: TDb | TTransaction;
+            table: TTable;
+            row: DrizzleInsertRow<TTable>;
+        }): Promise<void>;
+        updateById(input: {
+            executor: TDb | TTransaction;
+            table: TTable;
+            rowKey: TIdentityRowKey;
+            id: AggregateIdentity<TAggregate>;
+            row: Partial<DrizzleInsertRow<TTable>>;
+            optimisticLock: boolean;
+            expectedVersion?: number;
+            versionRowKey?: TVersionRowKey;
+        }): Promise<boolean>;
+    };
+};
+export declare const createDrizzleTableAggregateRepository: <TAggregate extends AnyAggregateDefinition, TDb, TTransaction, 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: DrizzleTableAggregateRepositoryOptions<TAggregate, TDb, TTransaction, TTable, TIdentityRowKey, TIdentityStateKey, TVersionRowKey, TVersionStateKey>) => AggregateRepository<TAggregate>;
+export type DrizzleVersionedAggregateRow = {
+    version?: number;
+};
+export declare const hasSameVersion: <TRow extends DrizzleVersionedAggregateRow, TState extends DrizzleVersionedAggregateRow>(row: TRow | null | undefined, state: TState) => boolean;
+export {};

package/dist/drizzle/transaction.d.ts

@@ -0,0 +1,6 @@
+import type { PersistenceContext, TransactionRunner, MaybePromise } from 'rebackend';
+export type DrizzleTransactionCapable<TTransaction> = {
+    transaction<T>(transaction: (tx: TTransaction) => MaybePromise<T>): MaybePromise<T>;
+};
+export declare const createDrizzleTransactionRunner: <TDb extends DrizzleTransactionCapable<TTransaction>, TTransaction>(db: TDb) => TransactionRunner<TTransaction>;
+export declare const resolveDrizzleExecutor: <TDb, TTransaction>(db: TDb, context?: PersistenceContext) => TDb | TTransaction;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './drizzle';

package/package.json

@@ -1,29 +1,27 @@
 {
   "name": "rebackend-drizzle",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Drizzle adapters for Rebackend.",
   "private": false,
   "main": "dist/index.js",
-  "types": "src/index.ts",
+  "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./src/index.ts",
+      "types": "./dist/index.d.ts",
       "require": "./dist/index.js",
       "default": "./dist/index.js"
     }
   },
   "files": [
-    "dist",
-    "src/index.ts",
-    "src/drizzle"
+    "dist"
   ],
   "keywords": [
     "rebackend",
     "drizzle",
     "adapter"
   ],
-  "author": "",
-  "license": "ISC",
+  "author": "AisonSu <aisonsu@outlook.com>",
+  "license": "UNLICENSED",
   "publishConfig": {
     "access": "public"
   },
@@ -39,19 +37,22 @@
   "dependencies": {
     "drizzle-orm": "^0.45.2",
     "farrow-schema": "^2.3.3",
-    "rebackend": "0.1.0"
+    "rebackend": "^0.1.1"
   },
   "devDependencies": {
     "@types/node": "^25.5.0",
     "@types/sql.js": "^1.4.11",
+    "rimraf": "^6.0.1",
     "sql.js": "^1.14.1",
     "tsx": "^4.21.0",
     "typescript": "^6.0.2"
   },
   "scripts": {
-    "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
+    "clean": "rimraf dist",
+    "prebuild": "pnpm --filter rebackend build",
     "build": "pnpm run clean && tsc -p tsconfig.build.json",
     "pretest": "pnpm --filter rebackend build",
+    "pretypecheck": "pnpm --filter rebackend build",
     "predemo:drizzle-adapter": "pnpm --filter rebackend build",
     "predemo:drizzle-table-adapter": "pnpm --filter rebackend build",
     "predemo:drizzle-sqljs": "pnpm --filter rebackend build",

package/src/drizzle/index.ts

@@ -1,4 +0,0 @@
-export * from './transaction'
-export * from './repository'
-export * from './outbox'
-export * from './presets'

package/src/drizzle/outbox.ts

@@ -1,387 +0,0 @@
-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

@@ -1,274 +0,0 @@
-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)
-}

package/src/drizzle/repository.ts

@@ -1,221 +0,0 @@
-import type { InferInsertModel, InferSelectModel, Table } from 'drizzle-orm'
-
-import type {
-  AggregateIdentity,
-  AggregateRepository,
-  AggregateState,
-  AnyAggregateDefinition,
-} from 'rebackend'
-
-import { resolveDrizzleExecutor } from './transaction'
-
-export type DrizzleSelectRow<TTable extends Table> = InferSelectModel<TTable>
-export type DrizzleInsertRow<TTable extends Table> = InferInsertModel<TTable>
-
-type KeysMatching<TRow, TValue> = Extract<
-  {
-    [K in keyof TRow]-?: Exclude<TRow[K], null | undefined> extends TValue ? K : never
-  }[keyof TRow],
-  string
->
-
-export type DrizzleSelectKeyMatching<TTable extends Table, TValue> = KeysMatching<
-  DrizzleSelectRow<TTable>,
-  TValue
->
-export type DrizzleInsertKeyMatching<TTable extends Table, TValue> = KeysMatching<
-  DrizzleInsertRow<TTable>,
-  TValue
->
-export type DrizzleSelectKey<TTable extends Table> = Extract<keyof DrizzleSelectRow<TTable>, string>
-
-export type DrizzleAggregateRepositoryOptions<
-  TAggregate extends AnyAggregateDefinition,
-  TDb,
-  TTransaction,
-  TRow,
-> = {
-  db: TDb
-  load: (
-    executor: TDb | TTransaction,
-    id: AggregateIdentity<TAggregate>,
-  ) => Promise<TRow | null | undefined>
-  insert: (executor: TDb | TTransaction, next: AggregateState<TAggregate>) => Promise<void>
-  update: (input: {
-    executor: TDb | TTransaction
-    next: AggregateState<TAggregate>
-    current: AggregateState<TAggregate>
-    optimisticLock: boolean
-  }) => Promise<boolean>
-  deserialize: (row: TRow) => AggregateState<TAggregate>
-}
-
-export const createDrizzleAggregateRepository = <
-  TAggregate extends AnyAggregateDefinition,
-  TDb,
-  TTransaction,
-  TRow,
->(
-  options: DrizzleAggregateRepositoryOptions<TAggregate, TDb, TTransaction, TRow>,
-): AggregateRepository<TAggregate> => {
-  return {
-    async findById(id, context) {
-      const executor = resolveDrizzleExecutor<TDb, TTransaction>(options.db, context)
-      const row = await options.load(executor, id)
-
-      if (row === null || row === undefined) {
-        return null
-      }
-
-      return options.deserialize(row)
-    },
-    async save(input, context) {
-      const executor = resolveDrizzleExecutor<TDb, TTransaction>(options.db, context)
-
-      if (input.mode === 'create') {
-        await options.insert(executor, input.next)
-        return
-      }
-
-      if (input.current === null) {
-        throw new Error('Drizzle aggregate update requires current aggregate state.')
-      }
-
-      return options.update({
-        executor,
-        next: input.next,
-        current: input.current,
-        optimisticLock: input.optimisticLock,
-      })
-    },
-  }
-}
-
-export type DrizzleTableAggregateRepositoryOptions<
-  TAggregate extends AnyAggregateDefinition,
-  TDb,
-  TTransaction,
-  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,
-> = {
-  db: TDb
-  table: TTable
-  identity: {
-    stateKey: TIdentityStateKey
-    rowKey: TIdentityRowKey
-  }
-  version?: {
-    stateKey: TVersionStateKey
-    rowKey: TVersionRowKey
-  }
-  serialize: {
-    insert(state: AggregateState<TAggregate>): DrizzleInsertRow<TTable>
-    update(state: AggregateState<TAggregate>): Partial<DrizzleInsertRow<TTable>>
-  }
-  deserialize(row: DrizzleSelectRow<TTable>): AggregateState<TAggregate>
-  operations: {
-    findById(input: {
-      executor: TDb | TTransaction
-      table: TTable
-      rowKey: TIdentityRowKey
-      id: AggregateIdentity<TAggregate>
-    }): Promise<DrizzleSelectRow<TTable> | null | undefined>
-    insertOne(input: {
-      executor: TDb | TTransaction
-      table: TTable
-      row: DrizzleInsertRow<TTable>
-    }): Promise<void>
-    updateById(input: {
-      executor: TDb | TTransaction
-      table: TTable
-      rowKey: TIdentityRowKey
-      id: AggregateIdentity<TAggregate>
-      row: Partial<DrizzleInsertRow<TTable>>
-      optimisticLock: boolean
-      expectedVersion?: number
-      versionRowKey?: TVersionRowKey
-    }): Promise<boolean>
-  }
-}
-
-export const createDrizzleTableAggregateRepository = <
-  TAggregate extends AnyAggregateDefinition,
-  TDb,
-  TTransaction,
-  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: DrizzleTableAggregateRepositoryOptions<
-    TAggregate,
-    TDb,
-    TTransaction,
-    TTable,
-    TIdentityRowKey,
-    TIdentityStateKey,
-    TVersionRowKey,
-    TVersionStateKey
-  >,
-): AggregateRepository<TAggregate> => {
-  return createDrizzleAggregateRepository<TAggregate, TDb, TTransaction, DrizzleSelectRow<TTable>>({
-    db: options.db,
-    load: async (executor, id) => {
-      return options.operations.findById({
-        executor,
-        table: options.table,
-        rowKey: options.identity.rowKey,
-        id,
-      })
-    },
-    insert: async (executor, next) => {
-      await options.operations.insertOne({
-        executor,
-        table: options.table,
-        row: options.serialize.insert(next),
-      })
-    },
-    update: async ({ executor, next, current, optimisticLock }) => {
-      const versionRowKey = options.version?.rowKey
-      const currentVersion = options.version
-        ? (current[options.version.stateKey as keyof AggregateState<TAggregate>] as
-            | number
-            | undefined)
-        : undefined
-
-      return options.operations.updateById({
-        executor,
-        table: options.table,
-        rowKey: options.identity.rowKey,
-        id: next[
-          options.identity.stateKey as keyof AggregateState<TAggregate>
-        ] as AggregateIdentity<TAggregate>,
-        row: options.serialize.update(next),
-        optimisticLock,
-        expectedVersion: currentVersion,
-        versionRowKey,
-      })
-    },
-    deserialize: options.deserialize,
-  })
-}
-
-export type DrizzleVersionedAggregateRow = {
-  version?: number
-}
-
-export const hasSameVersion = <
-  TRow extends DrizzleVersionedAggregateRow,
-  TState extends DrizzleVersionedAggregateRow,
->(
-  row: TRow | null | undefined,
-  state: TState,
-): boolean => {
-  return row?.version === state.version
-}

package/src/drizzle/transaction.ts

@@ -1,31 +0,0 @@
-import type { PersistenceContext, TransactionRunner, MaybePromise } from 'rebackend'
-
-export type DrizzleTransactionCapable<TTransaction> = {
-  transaction<T>(transaction: (tx: TTransaction) => MaybePromise<T>): MaybePromise<T>
-}
-
-export const createDrizzleTransactionRunner = <
-  TDb extends DrizzleTransactionCapable<TTransaction>,
-  TTransaction,
->(
-  db: TDb,
-): TransactionRunner<TTransaction> => {
-  return {
-    async run<T>(work: (transaction: TTransaction) => MaybePromise<T>): Promise<T> {
-      return Promise.resolve(db.transaction((transaction) => work(transaction)))
-    },
-  }
-}
-
-export const resolveDrizzleExecutor = <TDb, TTransaction>(
-  db: TDb,
-  context?: PersistenceContext,
-): TDb | TTransaction => {
-  const transaction = context?.transaction
-
-  if (transaction === null || transaction === undefined) {
-    return db
-  }
-
-  return transaction as TTransaction
-}

package/src/index.ts

@@ -1 +0,0 @@
-export * from './drizzle'