@b4moss/crudian 0.10.0 → 0.11.0

package/README.md

@@ -20,6 +20,7 @@ Install only the peer deps for the adapter you use:
 | `@b4moss/crudian/drizzle` | Node.js 24+ | sync | `drizzle-orm`, `better-sqlite3` |
 | `@b4moss/crudian/prisma` | Node.js 24+ | async | `@prisma/client` |
 | `@b4moss/crudian/libsql` | Node.js 24+ / Bun | async | `@libsql/client` |
+| `@b4moss/crudian/typeorm` | Node.js 24+ / Bun | async | `typeorm` |
 
 Node must not import `@b4moss/crudian/bun-sqlite` (resolves to an explicit error stub).
 
@@ -96,6 +97,7 @@ the client you inject:
 | Adapter | How to set pool |
 |---------|-----------------|
 | **Prisma** | Prisma datasource / connection URL params / engine pool settings (caller-owned). See Prisma docs for your provider. |
+| **TypeORM** | `DataSource` options (caller-owned). |
 | **bun-sqlite / drizzle (sqlite) / libsql** | No pool settings needed (no-op). |
 
 Optional type for docs / future drivers: `PoolOptions` from `@b4moss/crudian`
@@ -119,11 +121,39 @@ await crud.create("items", { name: "alpha", score: 1 })
 
 URL / auth token belong on the caller-created client (typically from `.env`).
 
+### TypeORM (`DataSource`) — async
+
+```ts
+import "reflect-metadata"
+import { DataSource } from "typeorm"
+import { createCrud } from "@b4moss/crudian/typeorm"
+import { where } from "@b4moss/crudian"
+
+const dataSource = new DataSource({
+  type: "better-sqlite3",
+  database: ":memory:",
+  // entities / migrations / pool: caller-owned
+})
+await dataSource.initialize()
+
+const crud = createCrud(dataSource)
+await crud.create("items", { name: "alpha", score: 1 })
+await crud.search("items", { where: where().eq("name", "alpha") })
+
+// JOIN / QueryBuilder / relation graphs → use crud.db (raw DataSource)
+```
+
+Dialect is inferred from `dataSource.options.type` (`sqlite` / `better-sqlite3` → sqlite, `postgres` → postgres, `mysql` / `mariadb` → mysql). Override with `createCrud(dataSource, { dialect: "postgres" })`.
+
+**Boundaries:** callers run migrations; crudian does single-table CRUD by table name. Relations may exist on the schema, but cross-relation CRUD is out of scope (`crud.db`). Subscribers fire only if the write path goes through TypeORM persistence hooks your app configured — treat side effects as caller-owned.
+
+Pool / lifetime: configure on the `DataSource` options (same ownership model as Prisma).
+
 ---
 
 ## API reference (all methods)
 
-Examples below use the **sync** Bun adapter. For `prisma` / `libsql`, `await` every call (same shapes).
+Examples below use the **sync** Bun adapter. For `prisma` / `libsql` / `typeorm`, `await` every call (same shapes).
 
 Assume a table:
 
@@ -407,9 +437,9 @@ Nestable `and` / `or`. Empty `in([])` is rejected.
 | Topic | Behavior |
 |-------|----------|
 | Entry | `createCrud(db, options?)` — inject a caller-owned client; exposed as `crud.db` |
-| Dialects | Shared Dialect layer: SQLite (all adapters), Postgres / MySQL via **Prisma** (`options.dialect`) |
+| Dialects | Shared Dialect layer: SQLite (all adapters), Postgres / MySQL via **Prisma** / **TypeORM** (`options.dialect` or DataSource type) |
 | Drizzle | **SQLite (better-sqlite3) only** in this line; PG/MySQL subpaths are out of scope |
-| Sync vs async | `bun-sqlite` / `drizzle` sync; `prisma` / `libsql` return `Promise`s |
+| Sync vs async | `bun-sqlite` / `drizzle` sync; `prisma` / `libsql` / `typeorm` return `Promise`s |
 | `read` / `update` / `duplicate` miss | `null` |
 | `delete` / bulk miss | `0` |
 | Upsert conflict | application-level on PK (default `id`; no SQL `ON CONFLICT`) |
@@ -417,10 +447,10 @@ Nestable `and` / `or`. Empty `in([])` is rejected.
 | `columns` | optional on `read` / `search` / `list`; omit → `*` |
 | `search.total` / `count` | full where count; not page length |
 | `exists` | boolean presence; same input as `count` |
-| Pool | caller-owned; Prisma via datasource settings; SQLite adapters no-op |
+| Pool | caller-owned; Prisma via datasource settings; TypeORM via DataSource options; SQLite adapters no-op |
 | Errors | minimal `CrudianError`; other errors propagate from the driver |
 | Identifiers | string required; no format validation |
-| Out of scope | relations, migrations, full-text search, ORM models, TypeORM (#43) |
+| Out of scope | relations graph CRUD, migrations ownership, full-text search, Entity-as-first-arg API |
 
 ## License
 

package/dist/index.d.ts

@@ -5,6 +5,7 @@
  * - @b4moss/crudian/drizzle
  * - @b4moss/crudian/prisma
  * - @b4moss/crudian/libsql
+ * - @b4moss/crudian/typeorm
  */
 export { CrudianError, assertString } from "./errors.js";
 export { WhereBuilder, where, isWhereBuilder, type Op, type CondNode, type GroupNode, type WhereNode, } from "./where.js";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AACxD,OAAO,EACL,YAAY,EACZ,KAAK,EACL,cAAc,EACd,KAAK,EAAE,EACP,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,KAAK,SAAS,GACf,MAAM,YAAY,CAAA;AACnB,YAAY,EACV,GAAG,EACH,kBAAkB,EAClB,kBAAkB,EAClB,YAAY,EACZ,UAAU,EACV,SAAS,EACT,WAAW,EACX,UAAU,EACV,WAAW,EACX,WAAW,EACX,cAAc,EACd,iBAAiB,EACjB,iBAAiB,GAClB,MAAM,YAAY,CAAA;AACnB,YAAY,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AACxD,OAAO,EACL,YAAY,EACZ,KAAK,EACL,cAAc,EACd,KAAK,EAAE,EACP,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,KAAK,SAAS,GACf,MAAM,YAAY,CAAA;AACnB,YAAY,EACV,GAAG,EACH,kBAAkB,EAClB,kBAAkB,EAClB,YAAY,EACZ,UAAU,EACV,SAAS,EACT,WAAW,EACX,UAAU,EACV,WAAW,EACX,WAAW,EACX,cAAc,EACd,iBAAiB,EACjB,iBAAiB,GAClB,MAAM,YAAY,CAAA;AACnB,YAAY,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA"}

package/dist/index.js

@@ -5,6 +5,7 @@
  * - @b4moss/crudian/drizzle
  * - @b4moss/crudian/prisma
  * - @b4moss/crudian/libsql
+ * - @b4moss/crudian/typeorm
  */
 export { CrudianError, assertString } from "./errors.js";
 export { WhereBuilder, where, isWhereBuilder, } from "./where.js";

package/dist/typeorm/crud.d.ts

@@ -0,0 +1,24 @@
+import { type CreateCrudOptions } from "../index.js";
+import { type AsyncSqliteCrud } from "../sqlite/async-crud.js";
+/** Minimal EntityManager / QueryRunner query surface used by the adapter. */
+export type TypeormLikeQuerier = {
+    query(query: string, parameters?: unknown[]): Promise<unknown>;
+};
+/**
+ * Minimal DataSource surface used by the adapter.
+ * Callers own `initialize` / entities / pool configuration.
+ */
+export type TypeormLikeDataSource = TypeormLikeQuerier & {
+    options: {
+        type?: string;
+    };
+    transaction<T>(runInTransaction: (entityManager: TypeormLikeQuerier) => Promise<T>): Promise<T>;
+};
+export type TypeormCrud = AsyncSqliteCrud<TypeormLikeDataSource>;
+/**
+ * Create a Crud bound to a TypeORM DataSource.
+ * Methods are async. The injected DataSource is exposed as `crud.db`.
+ * Dialect defaults from `dataSource.options.type`; override with `options.dialect`.
+ */
+export declare function createCrud(dataSource: TypeormLikeDataSource, options?: CreateCrudOptions): TypeormCrud;
+//# sourceMappingURL=crud.d.ts.map

package/dist/typeorm/crud.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crud.d.ts","sourceRoot":"","sources":["../../src/typeorm/crud.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,aAAa,CAAA;AAEpB,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,yBAAyB,CAAA;AAGhC,6EAA6E;AAC7E,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;CAC/D,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,qBAAqB,GAAG,kBAAkB,GAAG;IACvD,OAAO,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;IAC1B,WAAW,CAAC,CAAC,EACX,gBAAgB,EAAE,CAAC,aAAa,EAAE,kBAAkB,KAAK,OAAO,CAAC,CAAC,CAAC,GAClE,OAAO,CAAC,CAAC,CAAC,CAAA;CACd,CAAA;AAED,MAAM,MAAM,WAAW,GAAG,eAAe,CAAC,qBAAqB,CAAC,CAAA;AA8ChE;;;;GAIG;AACH,wBAAgB,UAAU,CACxB,UAAU,EAAE,qBAAqB,EACjC,OAAO,CAAC,EAAE,iBAAiB,GAC1B,WAAW,CA0Db"}

package/dist/typeorm/crud.js

@@ -0,0 +1,142 @@
+import { CrudianError, } from "../index.js";
+import { resolveDialect } from "../dialect/index.js";
+import { createAsyncCrud, } from "../sqlite/async-crud.js";
+function normalizeRow(row) {
+    const out = { ...row };
+    for (const [k, v] of Object.entries(out)) {
+        if (typeof v === "bigint")
+            out[k] = Number(v);
+    }
+    return out;
+}
+function normalizeQueryResult(result) {
+    if (result == null)
+        return [];
+    if (Array.isArray(result)) {
+        return result.filter(isPlainRow);
+    }
+    if (isPlainRow(result))
+        return [result];
+    return [];
+}
+function isPlainRow(value) {
+    return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function mapDataSourceType(type) {
+    switch (type) {
+        case "postgres":
+        case "aurora-postgres":
+            return "postgres";
+        case "mysql":
+        case "mariadb":
+        case "aurora-mysql":
+            return "mysql";
+        case "sqlite":
+        case "better-sqlite3":
+        case "capacitor":
+        case "cordova":
+        case "react-native":
+        case "expo":
+        case "sqljs":
+        case undefined:
+            return "sqlite";
+        default:
+            throw new CrudianError(`unsupported DataSource type: ${String(type)}`);
+    }
+}
+/**
+ * Create a Crud bound to a TypeORM DataSource.
+ * Methods are async. The injected DataSource is exposed as `crud.db`.
+ * Dialect defaults from `dataSource.options.type`; override with `options.dialect`.
+ */
+export function createCrud(dataSource, options) {
+    if (dataSource == null) {
+        throw new CrudianError("db is required");
+    }
+    if (typeof dataSource !== "object" ||
+        typeof dataSource.query !== "function" ||
+        typeof dataSource.transaction !== "function" ||
+        dataSource.options == null ||
+        typeof dataSource.options !== "object") {
+        throw new CrudianError("db must be a TypeORM DataSource");
+    }
+    let active = dataSource;
+    const dialectName = options?.dialect ?? mapDataSourceType(dataSource.options.type);
+    const dialect = resolveDialect(dialectName);
+    return createAsyncCrud(dataSource, {
+        async run(sql, args = []) {
+            if (dialect.name === "postgres") {
+                const trimmed = sql.trim();
+                if (/^(UPDATE|DELETE)\b/i.test(trimmed)) {
+                    const wrapped = `WITH _crudian_write AS (${trimmed} RETURNING 1) ` +
+                        `SELECT COUNT(*)::int AS changes FROM _crudian_write`;
+                    const rows = normalizeQueryResult(await active.query(wrapped, args));
+                    return { changes: Number(rows[0]?.changes ?? 0) };
+                }
+            }
+            const result = await active.query(sql, args);
+            return { changes: await resolveChanges(active, dialect.name, result) };
+        },
+        async get(sql, args = []) {
+            const rows = normalizeQueryResult(await active.query(sql, args));
+            const row = rows[0];
+            return row == null ? undefined : normalizeRow(row);
+        },
+        async all(sql, args = []) {
+            return normalizeQueryResult(await active.query(sql, args)).map(normalizeRow);
+        },
+        async transaction(fn) {
+            return dataSource.transaction(async (manager) => {
+                const prev = active;
+                active = manager;
+                try {
+                    return await fn();
+                }
+                finally {
+                    active = prev;
+                }
+            });
+        },
+    }, dialect, options);
+}
+async function resolveChanges(querier, dialectName, result) {
+    if (dialectName === "sqlite") {
+        // better-sqlite3 via TypeORM returns lastInsertRowid for writes, not changes.
+        const rows = normalizeQueryResult(await querier.query("SELECT changes() AS changes"));
+        return Number(rows[0]?.changes ?? 0);
+    }
+    if (dialectName === "mysql") {
+        const header = mysqlResultHeader(result);
+        if (header != null)
+            return Number(header.affectedRows ?? 0);
+    }
+    if (result != null && typeof result === "object" && !Array.isArray(result)) {
+        const obj = result;
+        if ("affected" in obj)
+            return Number(obj.affected ?? 0);
+        if ("affectedRows" in obj)
+            return Number(obj.affectedRows ?? 0);
+        if ("rowCount" in obj)
+            return Number(obj.rowCount ?? 0);
+    }
+    // Postgres (and similar): TypeORM often returns [] and drops rowCount.
+    if (dialectName === "postgres" && typeof result === "number") {
+        return result;
+    }
+    return 0;
+}
+function mysqlResultHeader(result) {
+    if (result == null)
+        return null;
+    if (Array.isArray(result)) {
+        const first = result[0];
+        if (first != null && typeof first === "object" && "affectedRows" in first) {
+            return first;
+        }
+        return null;
+    }
+    if (typeof result === "object" && "affectedRows" in result) {
+        return result;
+    }
+    return null;
+}

package/dist/typeorm/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * TypeORM adapter for @b4moss/crudian.
+ * Import via: `import { createCrud } from "@b4moss/crudian/typeorm"`
+ */
+export { createCrud, type TypeormCrud, type TypeormLikeDataSource, type TypeormLikeQuerier, } from "./crud.js";
+export type { Row, SearchResult, WhereInput, ReadQuery, SearchQuery, CountQuery, DeleteQuery, UpdateQuery, DuplicateQuery, } from "../types.js";
+export { CrudianError, where, WhereBuilder, type Op, type CondNode, type GroupNode, type WhereNode, } from "../index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/typeorm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/typeorm/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EACL,UAAU,EACV,KAAK,WAAW,EAChB,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,GACxB,MAAM,WAAW,CAAA;AAClB,YAAY,EACV,GAAG,EACH,YAAY,EACZ,UAAU,EACV,SAAS,EACT,WAAW,EACX,UAAU,EACV,WAAW,EACX,WAAW,EACX,cAAc,GACf,MAAM,aAAa,CAAA;AACpB,OAAO,EACL,YAAY,EACZ,KAAK,EACL,YAAY,EACZ,KAAK,EAAE,EACP,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,KAAK,SAAS,GACf,MAAM,aAAa,CAAA"}

package/dist/typeorm/index.js

@@ -0,0 +1,6 @@
+/**
+ * TypeORM adapter for @b4moss/crudian.
+ * Import via: `import { createCrud } from "@b4moss/crudian/typeorm"`
+ */
+export { createCrud, } from "./crud.js";
+export { CrudianError, where, WhereBuilder, } from "../index.js";

package/dist/typeorm/server-dialect-harness.d.ts

@@ -0,0 +1,13 @@
+import type { DataSource } from "typeorm";
+export type DialectName = "postgres" | "mysql";
+export type TypeormServerDbHarness = {
+    dialect: DialectName;
+    envKey: "DATABASE_URL_POSTGRES" | "DATABASE_URL_MYSQL";
+    createDataSource: (url: string) => DataSource;
+    createItemsDDL: string;
+    dropItemsDDL: string;
+    createAltPkDDL: string;
+    dropAltPkDDL: string;
+};
+export declare function registerTypeormServerDialectTests(h: TypeormServerDbHarness): void;
+//# sourceMappingURL=server-dialect-harness.d.ts.map

package/dist/typeorm/server-dialect-harness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-dialect-harness.d.ts","sourceRoot":"","sources":["../../src/typeorm/server-dialect-harness.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAIzC,MAAM,MAAM,WAAW,GAAG,UAAU,GAAG,OAAO,CAAA;AAE9C,MAAM,MAAM,sBAAsB,GAAG;IACnC,OAAO,EAAE,WAAW,CAAA;IACpB,MAAM,EAAE,uBAAuB,GAAG,oBAAoB,CAAA;IACtD,gBAAgB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,UAAU,CAAA;IAC7C,cAAc,EAAE,MAAM,CAAA;IACtB,YAAY,EAAE,MAAM,CAAA;IACpB,cAAc,EAAE,MAAM,CAAA;IACtB,YAAY,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,wBAAgB,iCAAiC,CAAC,CAAC,EAAE,sBAAsB,QA0I1E"}

package/dist/typeorm/server-dialect-harness.js

@@ -0,0 +1,120 @@
+/**
+ * Shared contract suite for TypeORM against Postgres / MySQL.
+ * Skipped automatically when the DATABASE_URL_* env var is unset.
+ */
+import assert from "node:assert/strict";
+import { after, before, describe, test } from "node:test";
+import { CrudianError, where } from "../index.js";
+import { createCrud } from "./index.js";
+export function registerTypeormServerDialectTests(h) {
+    const url = process.env[h.envKey];
+    const suite = describe;
+    suite(`typeorm.${h.dialect}`, { skip: !url }, () => {
+        let dataSource;
+        let crud;
+        before(async () => {
+            if (!url)
+                return;
+            dataSource = h.createDataSource(url);
+            await dataSource.initialize();
+            await dataSource.query(h.dropItemsDDL);
+            await dataSource.query(h.createItemsDDL);
+            crud = createCrud(dataSource, { dialect: h.dialect });
+        });
+        after(async () => {
+            if (!url || !dataSource?.isInitialized)
+                return;
+            try {
+                await dataSource.query(h.dropItemsDDL);
+                await dataSource.query(h.dropAltPkDDL);
+            }
+            catch {
+                /* ignore */
+            }
+            await dataSource.destroy();
+        });
+        async function reset() {
+            await dataSource.query(h.dropItemsDDL);
+            await dataSource.query(h.createItemsDDL);
+        }
+        test("正常系: create / read / update / delete", async () => {
+            await reset();
+            const created = await crud.create("items", { name: "alice", score: 10 });
+            assert.equal(created.name, "alice");
+            assert.ok(created.id != null);
+            const got = await crud.read("items", {
+                where: where().eq("id", created.id),
+            });
+            assert.equal(got?.name, "alice");
+            const updated = await crud.update("items", { score: 20 }, { where: where().eq("id", created.id) });
+            assert.equal(updated?.score, 20);
+            const n = await crud.delete("items", {
+                where: where().eq("id", created.id),
+            });
+            assert.equal(n, 1);
+            assert.equal(await crud.read("items", { where: where().eq("id", created.id) }), null);
+        });
+        test("正常系: count / exists / search offset / cursor", async () => {
+            await reset();
+            await crud.bulkCreate("items", [
+                { name: "a", score: 1 },
+                { name: "b", score: 2 },
+                { name: "c", score: 3 },
+            ]);
+            assert.equal(await crud.count("items"), 3);
+            assert.equal(await crud.exists("items", { where: where().eq("name", "b") }), true);
+            assert.equal(await crud.exists("items", { where: where().eq("name", "z") }), false);
+            const page = await crud.search("items", { limit: 2, offset: 0 });
+            assert.equal(page.items.length, 2);
+            assert.equal("total" in page && page.total, 3);
+            assert.equal("hasMore" in page && page.hasMore, true);
+            const cursorPage = await crud.search("items", {
+                paging: "cursor",
+                limit: 2,
+            });
+            assert.equal(cursorPage.items.length, 2);
+            assert.ok("nextCursor" in cursorPage);
+        });
+        test("正常系: upsert / duplicate / transaction", async () => {
+            await reset();
+            const a = await crud.create("items", { name: "x", score: 1 });
+            const up = await crud.upsert("items", {
+                id: a.id,
+                name: "x",
+                score: 9,
+            });
+            assert.equal(up.score, 9);
+            const dup = await crud.duplicate("items", {
+                where: where().eq("id", a.id),
+                overrides: { name: "y" },
+            });
+            assert.ok(dup);
+            assert.notEqual(dup.id, a.id);
+            assert.equal(dup.name, "y");
+            await crud.transaction(async () => {
+                await crud.create("items", { name: "tx", score: 1 });
+            });
+            assert.equal(await crud.exists("items", { where: where().eq("name", "tx") }), true);
+        });
+        test("正常系: 可変 PK", async () => {
+            await reset();
+            await dataSource.query(h.dropAltPkDDL);
+            await dataSource.query(h.createAltPkDDL);
+            const alt = createCrud(dataSource, { dialect: h.dialect, pk: "item_id" });
+            const row = await alt.create("alt_items", { name: "pk" });
+            assert.ok(row.item_id != null);
+            const got = await alt.read("alt_items", {
+                where: where().eq("item_id", row.item_id),
+            });
+            assert.equal(got?.name, "pk");
+            await dataSource.query(h.dropAltPkDDL);
+        });
+        test("異常系: 空 in / 不正 dialect は拒否", async () => {
+            await reset();
+            await assert.rejects(() => crud.search("items", {
+                where: where().in("id", []),
+            }), CrudianError);
+            assert.throws(() => createCrud(dataSource, { dialect: "nope" }), CrudianError);
+        });
+    });
+}

package/dist/types.d.ts

@@ -52,7 +52,7 @@ export type CreateCrudOptions = {
     pk?: string;
     /**
      * SQL dialect. Default: `"sqlite"`.
-     * Used by Prisma (and future multi-DB adapters). SQLite-only adapters ignore this.
+     * Used by Prisma / TypeORM (and other multi-DB adapters). SQLite-only adapters ignore this.
      */
     dialect?: CreateCrudDialect;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b4moss/crudian",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "CRUD abstraction for DDD repositories",
   "type": "module",
   "license": "MIT",
@@ -30,6 +30,11 @@
       "types": "./dist/libsql/index.d.ts",
       "import": "./dist/libsql/index.js",
       "default": "./dist/libsql/index.js"
+    },
+    "./typeorm": {
+      "types": "./dist/typeorm/index.d.ts",
+      "import": "./dist/typeorm/index.js",
+      "default": "./dist/typeorm/index.js"
     }
   },
   "files": [
@@ -43,15 +48,21 @@
     "prisma:generate": "prisma generate --schema prisma/schema.prisma",
     "prisma:generate:postgres": "prisma generate --schema prisma/schema.postgres.prisma",
     "prisma:generate:mysql": "prisma generate --schema prisma/schema.mysql.prisma",
-    "test": "bun run test:bun-sqlite && bun run test:drizzle && bun run test:prisma && bun run test:libsql",
+    "test": "bun run test:bun-sqlite && bun run test:drizzle && bun run test:prisma && bun run test:libsql && bun run test:typeorm && bun run test:dialect",
     "test:bun-sqlite": "bun test src/bun-sqlite",
     "test:drizzle": "tsx --test src/drizzle/crud.test.ts src/drizzle/pk.test.ts",
     "test:prisma": "bun run prisma:generate && tsx --test src/prisma/crud.test.ts src/prisma/pk.test.ts",
     "test:prisma:postgres": "bun run prisma:generate:postgres && DATABASE_URL_POSTGRES=\"${DATABASE_URL_POSTGRES:-postgresql://crudian:crudian@127.0.0.1:5432/crudian?sslmode=disable}\" tsx --test src/prisma/postgres.test.ts",
     "test:prisma:mysql": "bun run prisma:generate:mysql && DATABASE_URL_MYSQL=\"${DATABASE_URL_MYSQL:-mysql://crudian:crudian@127.0.0.1:3306/crudian}\" tsx --test src/prisma/mysql.test.ts",
-    "test:libsql": "tsx --test src/libsql/crud.test.ts src/libsql/pk.test.ts"
-  },
-  "engines": {
+    "test:libsql": "tsx --test src/libsql/crud.test.ts src/libsql/pk.test.ts",
+    "test:dialect": "tsx --test src/dialect/dialect.test.ts",
+    "test:node-adapters:coverage": "bun run prisma:generate && c8 --reporter=lcov --reporter=text-summary --report-dir=coverage/node-adapters --exclude='**/*.test.ts' --exclude='prisma/**' --exclude='dist/**' tsx --test src/drizzle/crud.test.ts src/drizzle/pk.test.ts src/prisma/crud.test.ts src/prisma/pk.test.ts src/libsql/crud.test.ts src/libsql/pk.test.ts src/dialect/dialect.test.ts",
+    "test:typeorm": "tsx --test src/typeorm/crud.test.ts src/typeorm/pk.test.ts",
+    "test:typeorm:bun": "bun test src/typeorm/crud.test.ts src/typeorm/pk.test.ts",
+    "test:typeorm:coverage": "c8 --reporter=lcov --reporter=text-summary --report-dir=coverage/typeorm --exclude='**/*.test.ts' --exclude='dist/**' tsx --test src/typeorm/crud.test.ts src/typeorm/pk.test.ts",
+    "test:typeorm:postgres": "DATABASE_URL_POSTGRES=\"${DATABASE_URL_POSTGRES:-postgresql://crudian:crudian@127.0.0.1:5432/crudian?sslmode=disable}\" tsx --test src/typeorm/postgres.test.ts",
+    "test:typeorm:mysql": "DATABASE_URL_MYSQL=\"${DATABASE_URL_MYSQL:-mysql://crudian:crudian@127.0.0.1:3306/crudian}\" tsx --test src/typeorm/mysql.test.ts"
+  },  "engines": {
     "node": ">=24",
     "bun": ">=1.0.0"
   },
@@ -59,7 +70,8 @@
     "@libsql/client": "^0.14.0 || ^0.15.0 || ^0.17.0",
     "@prisma/client": "^6.0.0",
     "better-sqlite3": "^11.0.0",
-    "drizzle-orm": "^0.39.0 || ^0.40.0 || ^0.41.0 || ^0.44.0"
+    "drizzle-orm": "^0.39.0 || ^0.40.0 || ^0.41.0 || ^0.44.0",
+    "typeorm": "^0.3.0"
   },
   "peerDependenciesMeta": {
     "@libsql/client": {
@@ -73,6 +85,9 @@
     },
     "drizzle-orm": {
       "optional": true
+    },
+    "typeorm": {
+      "optional": true
     }
   },
   "devDependencies": {
@@ -81,9 +96,14 @@
     "@types/better-sqlite3": "^7.6.13",
     "better-sqlite3": "^13",
     "bun-types": "^1.2.0",
+    "c8": "10",
     "drizzle-orm": "^0.45.2",
+    "mysql2": "^3.14.0",
+    "pg": "^8.14.0",
     "prisma": "^6.14.0",
+    "reflect-metadata": "^0.2.2",
     "tsx": "^4.23.12",
+    "typeorm": "^0.3.22",
     "typescript": "^5.8.0"
   },
   "keywords": [
@@ -94,6 +114,7 @@
     "drizzle",
     "prisma",
     "libsql",
+    "typeorm",
     "ddd"
   ],
   "repository": {