@woltz/rich-domain-drizzle 0.1.0

package/dist/types/repository.d.ts

@@ -0,0 +1,46 @@
+import { Aggregate, Repository, Mapper, Criteria, PaginatedResult } from "@woltz/rich-domain";
+import { DrizzleClient, DrizzleUnitOfWork } from "./unit-of-work";
+import { DrizzleToPersistence } from "./mappers/to-persistence";
+import { SearchableField } from "./query-builder";
+export interface DrizzleRepositoryConfig<TDomain, TPersistence> {
+    db: DrizzleClient;
+    table: any;
+    toDomainMapper: Mapper<TPersistence, TDomain>;
+    toPersistenceMapper: DrizzleToPersistence<TDomain>;
+    uow: DrizzleUnitOfWork;
+}
+export declare abstract class DrizzleRepository<TDomain extends Aggregate<any>, TPersistence> extends Repository<TDomain> {
+    protected readonly db: DrizzleClient;
+    protected readonly table: any;
+    protected readonly toDomainMapper: Mapper<TPersistence, TDomain>;
+    protected readonly toPersistenceMapper: DrizzleToPersistence<TDomain>;
+    protected readonly uow: DrizzleUnitOfWork;
+    constructor(config: DrizzleRepositoryConfig<TDomain, TPersistence>);
+    /**
+     * Returns tx from UOWStorage if inside a transaction, otherwise the raw db.
+     */
+    protected get context(): DrizzleClient;
+    /**
+     * The table name string used by EntitySchemaRegistry and db.query accessor.
+     */
+    protected abstract get model(): string;
+    /**
+     * Search conditions for full-text search via Criteria.search().
+     */
+    protected abstract getSearchableFields(): SearchableField<TPersistence>[];
+    /**
+     * Relations to include when fetching (for Drizzle relational query API).
+     */
+    protected getDefaultRelations(): Record<string, any>;
+    find(criteria: Criteria<TDomain>): Promise<PaginatedResult<TDomain>>;
+    findById(id: string): Promise<TDomain | null>;
+    findManyByIds(ids: string[]): Promise<TDomain[]>;
+    count(criteria?: Criteria<TDomain>): Promise<number>;
+    exists(id: string): Promise<boolean>;
+    save(entity: TDomain): Promise<void>;
+    delete(entity: TDomain): Promise<void>;
+    deleteById(id: string): Promise<void>;
+    transaction<T>(work: () => Promise<T>): Promise<T>;
+    private markArrayOfAggregateWithClean;
+}
+//# sourceMappingURL=repository.d.ts.map

package/dist/types/repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../../src/repository.ts"],"names":[],"mappings":"AACA,OAAO,EACL,SAAS,EACT,UAAU,EACV,MAAM,EACN,QAAQ,EACR,eAAe,EAChB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAc,MAAM,gBAAgB,CAAC;AAE9E,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAuB,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvE,MAAM,WAAW,uBAAuB,CAAC,OAAO,EAAE,YAAY;IAC5D,EAAE,EAAE,aAAa,CAAC;IAClB,KAAK,EAAE,GAAG,CAAC;IACX,cAAc,EAAE,MAAM,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC;IAC9C,mBAAmB,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;IACnD,GAAG,EAAE,iBAAiB,CAAC;CACxB;AAED,8BAAsB,iBAAiB,CACrC,OAAO,SAAS,SAAS,CAAC,GAAG,CAAC,EAC9B,YAAY,CACZ,SAAQ,UAAU,CAAC,OAAO,CAAC;IAC3B,SAAS,CAAC,QAAQ,CAAC,EAAE,EAAE,aAAa,CAAC;IACrC,SAAS,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC;IAC9B,SAAS,CAAC,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC;IACjE,SAAS,CAAC,QAAQ,CAAC,mBAAmB,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;IACtE,SAAS,CAAC,QAAQ,CAAC,GAAG,EAAE,iBAAiB,CAAC;gBAE9B,MAAM,EAAE,uBAAuB,CAAC,OAAO,EAAE,YAAY,CAAC;IASlE;;OAEG;IACH,SAAS,KAAK,OAAO,IAAI,aAAa,CAGrC;IAED;;OAEG;IACH,SAAS,CAAC,QAAQ,KAAK,KAAK,IAAI,MAAM,CAAC;IAEvC;;OAEG;IACH,SAAS,CAAC,QAAQ,CAAC,mBAAmB,IAAI,eAAe,CAAC,YAAY,CAAC,EAAE;IAEzE;;OAEG;IACH,SAAS,CAAC,mBAAmB,IAAI,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAI9C,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;IAqDpE,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;IA8B7C,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;IA4BhD,KAAK,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAkBpD,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAQpC,IAAI,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAKpC,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBtC,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBrC,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAIxD,OAAO,CAAC,6BAA6B;CAOtC"}

package/dist/types/unit-of-work.d.ts

@@ -0,0 +1,49 @@
+import { AsyncLocalStorage } from "async_hooks";
+/**
+ * Drizzle database instance type.
+ * Generic to support pg, mysql, sqlite, and other drivers.
+ */
+export type DrizzleClient = {
+    transaction: <T>(fn: (tx: any) => Promise<T>) => Promise<T>;
+    query: Record<string, any>;
+    select: (...args: any[]) => any;
+    insert: (table: any) => any;
+    update: (table: any) => any;
+    delete: (table: any) => any;
+    [key: string]: any;
+};
+export type DrizzleTransactionClient = DrizzleClient;
+export declare class DrizzleTransactionContext {
+    readonly client: DrizzleTransactionClient;
+    constructor(client: DrizzleTransactionClient);
+}
+export declare const UOWStorage: AsyncLocalStorage<{
+    ctx: DrizzleTransactionContext | null;
+}>;
+export declare class DrizzleUnitOfWork {
+    private readonly db;
+    constructor(db: DrizzleClient);
+    /**
+     * Get current transaction context (if any).
+     */
+    getCurrentContext(): DrizzleTransactionContext | null;
+    /**
+     * Check if currently inside a transaction.
+     */
+    isInTransaction(): boolean;
+    /**
+     * Execute work inside a transaction.
+     * If already in a transaction, reuses the existing context (idempotent nesting).
+     */
+    transaction<T>(work: () => Promise<T>): Promise<T>;
+}
+/**
+ * Decorator that wraps a method in a transaction.
+ * If already inside a transaction, reuses the existing one.
+ */
+export declare function Transactional(inputUow?: DrizzleUnitOfWork): MethodDecorator;
+/**
+ * Helper to get current transaction client from anywhere.
+ */
+export declare function getCurrentDrizzleContext(): DrizzleTransactionClient | null;
+//# sourceMappingURL=unit-of-work.d.ts.map

package/dist/types/unit-of-work.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unit-of-work.d.ts","sourceRoot":"","sources":["../../src/unit-of-work.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEhD;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,GAAG,KAAK,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;IAC5D,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC3B,MAAM,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;IAChC,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC;IAC5B,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC;IAC5B,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC;IAC5B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG,aAAa,CAAC;AAErD,qBAAa,yBAAyB;aACR,MAAM,EAAE,wBAAwB;gBAAhC,MAAM,EAAE,wBAAwB;CAC7D;AAED,eAAO,MAAM,UAAU;SAChB,yBAAyB,GAAG,IAAI;EACnC,CAAC;AAEL,qBAAa,iBAAiB;IAChB,OAAO,CAAC,QAAQ,CAAC,EAAE;gBAAF,EAAE,EAAE,aAAa;IAE9C;;OAEG;IACH,iBAAiB,IAAI,yBAAyB,GAAG,IAAI;IAIrD;;OAEG;IACH,eAAe,IAAI,OAAO;IAI1B;;;OAGG;IACG,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;CAazD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,QAAQ,CAAC,EAAE,iBAAiB,GAAG,eAAe,CA2B3E;AAwBD;;GAEG;AACH,wBAAgB,wBAAwB,IAAI,wBAAwB,GAAG,IAAI,CAE1E"}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@woltz/rich-domain-drizzle",
+  "version": "0.1.0",
+  "description": "Drizzle integration for Rich Domain Library",
+  "homepage": "https://woltz.mintlify.app",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "require": "./dist/cjs/index.js",
+      "import": "./dist/esm/index.js"
+    }
+  },
+  "author": "Tarcisio Andrade",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bugs": {
+    "url": "https://github.com/tarcisioandrade/rich-domain/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tarcisioandrade/rich-domain.git",
+    "directory": "packages/rich-domain-drizzle"
+  },
+  "files": [
+    "dist",
+    "src",
+    "**/package.json"
+  ],
+  "scripts": {
+    "build": "npm run build:cjs && npm run build:esm && npm run build:types && npm run postbuild",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build:types": "tsc -p tsconfig.types.json",
+    "postbuild": "node postbuild.js",
+    "test": "echo 'No tests yet'",
+    "test:watch": "echo 'No tests yet'",
+    "check": "tsc -b --noEmit",
+    "coverage": "echo 'No coverage yet'",
+    "lint": "echo 'No linting yet'",
+    "clean": "rm -rf dist coverage node_modules *.tsbuildinfo",
+    "prepublishOnly": "npm run build",
+    "release": "standard-version",
+    "release:minor": "standard-version --release-as minor",
+    "release:major": "standard-version --release-as major",
+    "release:patch": "standard-version --release-as patch"
+  },
+  "keywords": [
+    "ddd",
+    "domain-driven-design",
+    "drizzle",
+    "orm",
+    "repository",
+    "unit-of-work",
+    "typescript"
+  ],
+  "peerDependencies": {
+    "@woltz/rich-domain": "^1.8.6",
+    "drizzle-orm": ">=0.45.2",
+    "typescript": ">=4.7.0"
+  },
+  "engines": {
+    "node": ">=22.12.0"
+  }
+}

package/src/batch-executor.ts

@@ -0,0 +1,317 @@
+import { eq, inArray, and } from "drizzle-orm";
+import {
+  AggregateChanges,
+  EntitySchemaRegistry,
+  BatchDeleteOperation,
+  BatchCreateOperation,
+  BatchUpdateOperation,
+  BatchCreateItem,
+} from "@woltz/rich-domain";
+import { DrizzleClient } from "./unit-of-work";
+import {
+  TableNotFoundError,
+  BatchOperationError,
+  MissingJunctionConfigError,
+} from "./errors";
+
+export interface DrizzleBatchExecutorConfig {
+  registry: EntitySchemaRegistry;
+  db: DrizzleClient;
+  tableMap: Map<string, any>;
+}
+
+export class DrizzleBatchExecutor {
+  constructor(private readonly config: DrizzleBatchExecutorConfig) {}
+
+  /**
+   * Execute all batch operations in order:
+   * 1. Deletes (leaf → root, sorted by depth DESC)
+   * 2. Creates (root → leaf, sorted by depth ASC)
+   * 3. Updates (any order)
+   */
+  async execute(changes: AggregateChanges): Promise<void> {
+    if (changes.isEmpty()) return;
+
+    const batch = changes.toBatchOperations();
+
+    await this.executeDeletes(batch.deletes);
+    await this.executeCreates(batch.creates);
+    await this.executeUpdates(batch.updates);
+  }
+
+  private async executeDeletes(
+    deletes: Array<BatchDeleteOperation>
+  ): Promise<void> {
+    const sorted = [...deletes].sort((a, b) => b.depth - a.depth);
+
+    for (const del of sorted) {
+      const { entity, ids, relationField, parentEntity, parentId } = del;
+
+      if (relationField && parentEntity) {
+        this.config.registry.validateRelationField(parentEntity, relationField);
+
+        if (
+          this.config.registry.isReferenceCollection(
+            parentEntity,
+            relationField
+          )
+        ) {
+          await this.executeJunctionDelete(
+            parentEntity,
+            relationField,
+            parentId,
+            ids
+          );
+        } else {
+          await this.executeDeleteOwned(entity, ids);
+        }
+      } else {
+        await this.executeDeleteOwned(entity, ids);
+      }
+    }
+  }
+
+  private async executeDeleteOwned(
+    entity: string,
+    ids: string[]
+  ): Promise<void> {
+    if (ids.length === 0) return;
+
+    const table = this.getTable(entity);
+
+    try {
+      await this.config.db.delete(table).where(inArray(table.id, ids));
+    } catch (error: any) {
+      throw new BatchOperationError(
+        "delete",
+        entity,
+        error.message || "Unknown error during deletion",
+        error
+      );
+    }
+  }
+
+  private async executeJunctionDelete(
+    parentEntity: string,
+    relationField: string,
+    parentId: string | undefined,
+    ids: string[]
+  ): Promise<void> {
+    if (ids.length === 0 || !parentId) return;
+
+    const junction = this.config.registry.getJunctionConfig(
+      parentEntity,
+      relationField
+    );
+
+    if (!junction) {
+      throw new MissingJunctionConfigError(parentEntity, relationField);
+    }
+
+    const junctionTable = this.getJunctionTable(junction.table);
+
+    try {
+      await this.config.db
+        .delete(junctionTable)
+        .where(
+          and(
+            eq(junctionTable[junction.sourceKey], parentId),
+            inArray(junctionTable[junction.targetKey], ids)
+          )
+        );
+    } catch (error: any) {
+      throw new BatchOperationError(
+        "disconnect",
+        junction.table,
+        error.message || "Failed to delete from junction table",
+        error
+      );
+    }
+  }
+
+  private async executeCreates(
+    creates: Array<BatchCreateOperation>
+  ): Promise<void> {
+    const sorted = [...creates].sort((a, b) => a.depth - b.depth);
+
+    for (const create of sorted) {
+      const { entity, items, relationField, parentEntity } = create;
+
+      if (relationField && parentEntity) {
+        this.config.registry.validateRelationField(parentEntity, relationField);
+
+        if (
+          this.config.registry.isReferenceCollection(
+            parentEntity,
+            relationField
+          )
+        ) {
+          await this.executeJunctionCreate(parentEntity, relationField, items);
+        } else {
+          await this.executeCreateOwned(entity, items);
+        }
+      } else {
+        await this.executeCreateOwned(entity, items);
+      }
+    }
+  }
+
+  private async executeCreateOwned(
+    entity: string,
+    items: Array<BatchCreateItem>
+  ): Promise<void> {
+    if (items.length === 0) return;
+
+    const table = this.getTable(entity);
+
+    const records = items.map((item) => {
+      const entityData = this.config.registry.mapEntity(entity, item.data);
+      const fk = item.parentId
+        ? this.config.registry.getParentFk(entity, item.parentId)
+        : null;
+
+      return { ...entityData, ...fk };
+    });
+
+    try {
+      await this.config.db.insert(table).values(records);
+    } catch (error: any) {
+      throw new BatchOperationError(
+        "create",
+        entity,
+        error.message || "Unknown error during creation",
+        error
+      );
+    }
+  }
+
+  private async executeJunctionCreate(
+    parentEntity: string,
+    relationField: string,
+    items: Array<BatchCreateItem>
+  ): Promise<void> {
+    if (items.length === 0) return;
+
+    const junction = this.config.registry.getJunctionConfig(
+      parentEntity,
+      relationField
+    );
+
+    if (!junction) {
+      throw new MissingJunctionConfigError(parentEntity, relationField);
+    }
+
+    const junctionTable = this.getJunctionTable(junction.table);
+
+    const grouped = new Map<string, string[]>();
+    for (const item of items) {
+      const parentId = item.parentId;
+      if (!parentId) continue;
+      const entityId = this.extractId(item.data);
+      if (!entityId) continue;
+
+      if (!grouped.has(parentId)) {
+        grouped.set(parentId, []);
+      }
+      grouped.get(parentId)!.push(entityId);
+    }
+
+    const records: Record<string, string>[] = [];
+    for (const [parentId, targetIds] of grouped) {
+      for (const targetId of targetIds) {
+        records.push({
+          [junction.sourceKey]: parentId,
+          [junction.targetKey]: targetId,
+        });
+      }
+    }
+
+    if (records.length === 0) return;
+
+    try {
+      await this.config.db
+        .insert(junctionTable)
+        .values(records)
+        .onConflictDoNothing();
+    } catch (error: any) {
+      throw new BatchOperationError(
+        "connect",
+        junction.table,
+        error.message || "Failed to insert into junction table",
+        error
+      );
+    }
+  }
+
+  private async executeUpdates(
+    updates: Array<BatchUpdateOperation>
+  ): Promise<void> {
+    for (const upd of updates) {
+      const table = this.getTable(upd.entity);
+
+      for (const item of upd.items) {
+        const mappedFields = this.config.registry.mapFields(
+          upd.entity,
+          item.changedFields
+        );
+
+        if (Object.keys(mappedFields).length > 0) {
+          try {
+            await this.config.db
+              .update(table)
+              .set(mappedFields)
+              .where(eq(table.id, item.id));
+          } catch (error: any) {
+            throw new BatchOperationError(
+              "update",
+              upd.entity,
+              error.message || "Failed to update entity",
+              error
+            );
+          }
+        }
+      }
+    }
+  }
+
+  private getTable(entityName: string): any {
+    const table = this.config.tableMap.get(entityName);
+    if (!table) {
+      throw new TableNotFoundError(
+        entityName,
+        Array.from(this.config.tableMap.keys())
+      );
+    }
+    return table;
+  }
+
+  private getJunctionTable(tableName: string): any {
+    const table = this.config.tableMap.get(tableName);
+    if (!table) {
+      throw new TableNotFoundError(
+        tableName,
+        Array.from(this.config.tableMap.keys())
+      );
+    }
+    return table;
+  }
+
+  private extractId(data: any): string | undefined {
+    if (!data) return undefined;
+    if (data.id?.value !== undefined && data.id?.value !== null) {
+      return String(data.id.value);
+    }
+    if (typeof data.id === "string") return data.id;
+    if (typeof data.id === "number") return String(data.id);
+    return undefined;
+  }
+}
+
+export async function executeBatch(
+  db: DrizzleClient,
+  changes: AggregateChanges,
+  config: Omit<DrizzleBatchExecutorConfig, "db">
+): Promise<void> {
+  const executor = new DrizzleBatchExecutor({ ...config, db });
+  await executor.execute(changes);
+}

package/src/errors.ts

@@ -0,0 +1,78 @@
+export class DrizzleAdapterError extends Error {
+  constructor(message: string) {
+    super(`[DrizzleAdapter] ${message}`);
+    this.name = "DrizzleAdapterError";
+  }
+}
+
+export class TableNotFoundError extends DrizzleAdapterError {
+  constructor(
+    public readonly entityName: string,
+    public readonly availableTables: string[]
+  ) {
+    super(
+      `Table for entity "${entityName}" not found in tableMap. ` +
+        `Available: ${availableTables.join(", ")}`
+    );
+    this.name = "TableNotFoundError";
+  }
+}
+
+export class NoRecordsAffectedError extends DrizzleAdapterError {
+  constructor(
+    public readonly operation: string,
+    public readonly entity: string,
+    public readonly id: string,
+    public readonly cause?: Error
+  ) {
+    super(`${operation} on ${entity} (id: ${id}) affected 0 records`);
+    this.name = "NoRecordsAffectedError";
+  }
+}
+
+export class BatchOperationError extends DrizzleAdapterError {
+  constructor(
+    public readonly operation: string,
+    public readonly entity: string,
+    message: string,
+    public readonly cause?: Error
+  ) {
+    super(`Batch ${operation} on ${entity} failed: ${message}`);
+    this.name = "BatchOperationError";
+  }
+}
+
+export class DrizzleRepositoryError extends DrizzleAdapterError {
+  constructor(
+    message: string,
+    public readonly cause?: Error
+  ) {
+    super(message);
+    this.name = "DrizzleRepositoryError";
+  }
+}
+
+export class MissingJunctionConfigError extends DrizzleAdapterError {
+  constructor(
+    public readonly parentEntity: string,
+    public readonly collectionField: string
+  ) {
+    super(
+      `Collection "${collectionField}" on entity "${parentEntity}" is of type "reference" but has no junction configured. ` +
+        `Drizzle does not manage junction tables automatically — you must provide the junction config. ` +
+        `Example:\n` +
+        `  collections: {\n` +
+        `    ${collectionField}: {\n` +
+        `      type: "reference",\n` +
+        `      entity: "TargetEntity",\n` +
+        `      junction: {\n` +
+        `        table: "${parentEntity.toLowerCase()}_${collectionField}",\n` +
+        `        sourceKey: "${parentEntity.toLowerCase()}Id",\n` +
+        `        targetKey: "targetEntityId",\n` +
+        `      },\n` +
+        `    },\n` +
+        `  }`
+    );
+    this.name = "MissingJunctionConfigError";
+  }
+}

package/src/index.ts

@@ -0,0 +1,37 @@
+// Unit of Work
+export {
+  DrizzleUnitOfWork,
+  DrizzleTransactionContext,
+  UOWStorage,
+  Transactional,
+  getCurrentDrizzleContext,
+  type DrizzleClient,
+  type DrizzleTransactionClient,
+} from "./unit-of-work";
+
+// Repository
+export { DrizzleRepository, type DrizzleRepositoryConfig } from "./repository";
+
+// Mappers
+export { DrizzleToPersistence } from "./mappers/to-persistence";
+export { DrizzleToDomain } from "./mappers/to-domain";
+
+// Batch Executor
+export {
+  DrizzleBatchExecutor,
+  executeBatch,
+  type DrizzleBatchExecutorConfig,
+} from "./batch-executor";
+
+// Query Builder
+export { DrizzleQueryBuilder, type SearchableField } from "./query-builder";
+
+// Errors
+export {
+  DrizzleAdapterError,
+  TableNotFoundError,
+  NoRecordsAffectedError,
+  BatchOperationError,
+  DrizzleRepositoryError,
+  MissingJunctionConfigError,
+} from "./errors";

package/src/mappers/to-domain.ts

@@ -0,0 +1,13 @@
+import { Mapper } from "@woltz/rich-domain";
+
+/**
+ * Base class for mapping Drizzle query results to domain entities.
+ * Subclass and implement build() to transform DB records to domain aggregates.
+ *
+ * This is identical to a plain Mapper<TPersistence, TDomain>.
+ * Provided for naming consistency with the adapter pattern.
+ */
+export abstract class DrizzleToDomain<TPersistence, TDomain> extends Mapper<
+  TPersistence,
+  TDomain
+> {}