@kavo/mikroorm 0.6.0

package/README.md

@@ -0,0 +1,132 @@
+# @kavo/mikroorm
+
+MikroORM adapter for Kavo: implements `RepositoryAdapter`
+(`EntityReader` + `EntityWriter`) from `@kavo/core` over a MikroORM
+`EntityManager`. `TransactionManager` is not implemented — see the
+`@remarks` on that interface in `@kavo/core`.
+
+**May depend on:** `@kavo/core`, `@mikro-orm/core` (peer). **Never on:**
+`@kavo/nest` or any framework.
+
+Fully implemented: CRUD, filtering/sorting/pagination (including across
+relation paths), soft delete/restore/purge, and nested relation includes
+(via `populate`). MikroORM declares no delete-marker column the way
+TypeORM's `@DeleteDateColumn` does, so the seam reports none — but read the
+soft-delete note under "Known limitations" before assuming that means soft
+delete is off until you configure it.
+
+## Usage
+
+Like `@kavo/typeorm` and unlike `@kavo/prisma`, there is nothing to declare
+twice: a MikroORM entity is a real runtime class carrying its own metadata,
+so the class you pass to `createCrud` _is_ the identity core needs — no
+marker classes, no `entities` list beyond the one MikroORM already has.
+
+```ts
+import { Collection, Entity, ManyToOne, OneToMany, PrimaryKey, Property, MikroORM } from "@mikro-orm/core";
+import { defineConfig } from "@mikro-orm/postgresql";
+import { createMikroOrmKavo } from "@kavo/mikroorm";
+
+@Entity()
+class Author {
+  @PrimaryKey({ type: "number" })
+  id!: number;
+
+  @Property({ type: "string" })
+  name!: string;
+
+  @OneToMany(() => Book, (book) => book.author)
+  books = new Collection<Book>(this);
+}
+
+const orm = await MikroORM.init(defineConfig({ dbName: "app", entities: [Author, Book] }));
+const kavo = createMikroOrmKavo(orm, { caseInsensitiveFilters: true });
+
+const authors = kavo.createCrud(Author);
+```
+
+`createInfrastructure`/`createMikroOrmKavo` take the `MikroORM` instance
+itself rather than an `EntityManager`: every adapter operation calls
+`orm.em.fork()` to get its own manager, which is what keeps one request's
+identity map out of the next one's.
+
+## `caseInsensitiveFilters`
+
+`ILIKE` maps to MikroORM's `$ilike`, which **only PostgreSQL supports** —
+SQLite, MySQL, and MongoDB pass the token through to the driver and fail
+with a syntax error. MikroORM's `Platform` exposes nothing to detect this
+from, so it is a declared setting, defaulting to `false` (the value that
+works everywhere). Turn it on for PostgreSQL.
+
+With it off, `ILIKE` translates exactly like `LIKE`. On SQLite that is not
+even a loss — SQLite's own `LIKE` is already ASCII case-insensitive.
+
+## Known limitations
+
+- **`LIKE` escapes are driver-dependent.** MikroORM has no way to attach an
+  `ESCAPE` clause to a `LIKE`, so the query grammar's `\` escape for a
+  literal `%`/`_` is honored only by drivers that default to backslash
+  (PostgreSQL, MySQL). On SQLite, which has no default escape character,
+  `filter[name][like]=100\%` matches the literal text `100\` followed by
+  anything, rather than the string `100%`.
+- **Soft-deleted related rows are pruned in memory.** MikroORM's
+  `populateWhere` cannot express per-level scoping: nesting a child condition
+  makes it a predicate on the _parent_, so a parent with no surviving
+  children disappears instead of coming back empty. The adapter populates
+  everything and prunes the loaded tree, which is correct at any depth but
+  does fetch soft-deleted related rows before discarding them. Soft-deleted
+  _roots_ are still excluded in SQL.
+- **`IncludeNode.strategy` is ignored.** MikroORM resolves `populate` with
+  its own queries and applies `limit`/`offset` to the root either way, so
+  the join/batch distinction has nothing to control here — and MikroORM's
+  `strategy` option is per-query rather than per-relation, so it could not
+  express a mixed include tree anyway. Same posture as `@kavo/prisma`.
+- **MikroORM's own property options win at the boundary.** Rows are
+  converted with `wrap(entity).toObject()`, so a custom `serializer` runs
+  before core ever sees the row.
+- **The soft-delete marker is writable, and it is on by default.** Nothing
+  in a MikroORM entity declares a delete column, so the adapter cannot mark
+  it generated — but `softDelete` defaults to
+  `{ field: "deletedAt", strategy: "auto" }` and core matches that _name_
+  against your columns, so any entity with a `deletedAt` property is
+  soft-deletable with no config at all. The marker then sits in the derived
+  writable projection: a plain `PATCH` of it soft-deletes a row, bypassing
+  `deleteOne`'s already-deleted check and even
+  `operations: { deleteOne: false }`. It cannot _revive_ one — writes are
+  scoped to the live set, so a soft-deleted row 404s on `PUT`/`PATCH`. This
+  is the same hole `@kavo/prisma` and `@kavo/mongoose` have (only
+  `@kavo/typeorm` escapes it, because `@DeleteDateColumn` is detectable and
+  therefore markable), and the fix belongs in core. Until then, register an
+  explicit `update`/`patch` DTO that omits the marker.
+- **A non-auto-increment primary key is client-writable.**
+  `@PrimaryKey() id: string = v4()` carries none of MikroORM's generated
+  flags, so a `PATCH` can rewrite a row's identity. A numeric `@PrimaryKey()`
+  is auto-increment and safe. Name the write DTOs explicitly for any entity
+  with a caller-assigned key.
+- **`hidden` and `lazy` properties are dropped from Kavo entirely.** Not
+  merely hidden from responses — excluding them from the metadata seam is
+  what keeps them off the default filter/sort allowlists, where an invisible
+  but filterable column is a blind extraction oracle. The trade is the one
+  `@kavo/mongoose` makes for `select: false`: Kavo does not manage such a
+  property at all, so write it through a custom operation or the ORM.
+- **A MikroORM `@Filter` is applied on top of Kavo's scoping.** Kavo owns
+  soft-delete scoping through `softDelete.field`; a default-on MikroORM
+  soft-delete filter would AND a second predicate onto every query and
+  quietly defeat `withDeleted`. Use one or the other, not both.
+- **No transactions.** The `TransactionManager` seam is unbuilt across every
+  Kavo adapter today.
+- **Composite primary keys are refused.** `buildEntityMetadata` raises
+  `KAVO_CONFIG_INVALID` for an entity with more than one `@PrimaryKey`.
+
+## Soft delete and unique indexes
+
+A soft-deleted row still occupies its unique indexes, so re-creating "the
+same" row after a soft delete raises a 409 conflict — the honest answer,
+since the value _is_ taken. The fix is a partial unique index scoped to
+live rows:
+
+```sql
+CREATE UNIQUE INDEX author_email_live ON author (email) WHERE deleted_at IS NULL;
+```
+
+Full design notes: [`docs/internals/architecture/17-mikroorm-adapter.md`](../../../docs/internals/architecture/17-mikroorm-adapter.md).

package/dist/error-mapping.d.ts

@@ -0,0 +1,32 @@
+import type { ErrorContext } from "@kavo/core";
+import { KavoException } from "@kavo/core";
+/**
+ * The error-mapping table: driver error → Kavo exception.
+ *
+ * | MikroORM condition                          | Exception                          |
+ * | ------------------------------------------- | ---------------------------------- |
+ * | `UniqueConstraintViolationException`        | ConflictException                  |
+ * | `ForeignKeyConstraintViolationException`    | ConflictException                  |
+ * | `DeadlockException` / `LockWaitTimeoutException` | TransactionException (retryable) |
+ * | anything else                               | PersistenceException with `cause`  |
+ *
+ * The same four rows `@kavo/typeorm`'s table has, reached differently:
+ * MikroORM normalizes each driver's native error into its own exception
+ * hierarchy before it surfaces, so this matches on those classes rather than
+ * on Postgres SQLSTATEs, MySQL errnos, and SQLite extended codes the way the
+ * TypeORM adapter must. Every driver MikroORM supports is covered by that
+ * normalization, and anything it does not recognize falls through to
+ * `PersistenceException` — the original error always travels as `cause`,
+ * never swallowed.
+ *
+ * **Soft delete and unique indexes.** A soft-deleted row still occupies its
+ * unique indexes, so re-creating "the same" row after a soft delete raises a
+ * unique violation — mapped here to a 409 like any other conflict, which is
+ * the honest answer: the value *is* taken. Kavo never rewrites indexes; the
+ * standard fix is a partial/filtered unique index on the live rows only,
+ * e.g. in Postgres
+ * `CREATE UNIQUE INDEX … ON author (email) WHERE deleted_at IS NULL`
+ * (SQLite supports the same form; MySQL needs a generated column).
+ */
+export declare function mapDriverError(error: unknown, context: ErrorContext): KavoException;
+//# sourceMappingURL=error-mapping.d.ts.map

package/dist/error-mapping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-mapping.d.ts","sourceRoot":"","sources":["../src/error-mapping.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAqB,aAAa,EAA8C,MAAM,YAAY,CAAC;AAQ1G;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,YAAY,GAAG,aAAa,CAsBnF"}

package/dist/error-mapping.js

@@ -0,0 +1,51 @@
+import { ConflictException, KavoException, PersistenceException, TransactionException } from "@kavo/core";
+import { DeadlockException, ForeignKeyConstraintViolationException, LockWaitTimeoutException, UniqueConstraintViolationException, } from "@mikro-orm/core";
+/**
+ * The error-mapping table: driver error → Kavo exception.
+ *
+ * | MikroORM condition                          | Exception                          |
+ * | ------------------------------------------- | ---------------------------------- |
+ * | `UniqueConstraintViolationException`        | ConflictException                  |
+ * | `ForeignKeyConstraintViolationException`    | ConflictException                  |
+ * | `DeadlockException` / `LockWaitTimeoutException` | TransactionException (retryable) |
+ * | anything else                               | PersistenceException with `cause`  |
+ *
+ * The same four rows `@kavo/typeorm`'s table has, reached differently:
+ * MikroORM normalizes each driver's native error into its own exception
+ * hierarchy before it surfaces, so this matches on those classes rather than
+ * on Postgres SQLSTATEs, MySQL errnos, and SQLite extended codes the way the
+ * TypeORM adapter must. Every driver MikroORM supports is covered by that
+ * normalization, and anything it does not recognize falls through to
+ * `PersistenceException` — the original error always travels as `cause`,
+ * never swallowed.
+ *
+ * **Soft delete and unique indexes.** A soft-deleted row still occupies its
+ * unique indexes, so re-creating "the same" row after a soft delete raises a
+ * unique violation — mapped here to a 409 like any other conflict, which is
+ * the honest answer: the value *is* taken. Kavo never rewrites indexes; the
+ * standard fix is a partial/filtered unique index on the live rows only,
+ * e.g. in Postgres
+ * `CREATE UNIQUE INDEX … ON author (email) WHERE deleted_at IS NULL`
+ * (SQLite supports the same form; MySQL needs a generated column).
+ */
+export function mapDriverError(error, context) {
+    if (error instanceof KavoException)
+        return error;
+    const entity = context.entityName ?? "entity";
+    if (error instanceof UniqueConstraintViolationException || error instanceof ForeignKeyConstraintViolationException) {
+        return new ConflictException({
+            messageParams: { entity },
+            context,
+            cause: error,
+        });
+    }
+    if (error instanceof DeadlockException || error instanceof LockWaitTimeoutException) {
+        return new TransactionException({ retryable: true, context, cause: error });
+    }
+    return new PersistenceException({
+        messageParams: { operation: context.operation ?? "unknown" },
+        context,
+        cause: error,
+    });
+}
+//# sourceMappingURL=error-mapping.js.map

package/dist/error-mapping.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-mapping.js","sourceRoot":"","sources":["../src/error-mapping.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAC1G,OAAO,EACL,iBAAiB,EACjB,sCAAsC,EACtC,wBAAwB,EACxB,kCAAkC,GACnC,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,UAAU,cAAc,CAAC,KAAc,EAAE,OAAqB;IAClE,IAAI,KAAK,YAAY,aAAa;QAAE,OAAO,KAAK,CAAC;IAEjD,MAAM,MAAM,GAAG,OAAO,CAAC,UAAU,IAAI,QAAQ,CAAC;IAE9C,IAAI,KAAK,YAAY,kCAAkC,IAAI,KAAK,YAAY,sCAAsC,EAAE,CAAC;QACnH,OAAO,IAAI,iBAAiB,CAAC;YAC3B,aAAa,EAAE,EAAE,MAAM,EAAE;YACzB,OAAO;YACP,KAAK,EAAE,KAAK;SACb,CAAC,CAAC;IACL,CAAC;IAED,IAAI,KAAK,YAAY,iBAAiB,IAAI,KAAK,YAAY,wBAAwB,EAAE,CAAC;QACpF,OAAO,IAAI,oBAAoB,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC;IAC9E,CAAC;IAED,OAAO,IAAI,oBAAoB,CAAC;QAC9B,aAAa,EAAE,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,IAAI,SAAS,EAAE;QAC5D,OAAO;QACP,KAAK,EAAE,KAAK;KACb,CAAC,CAAC;AACL,CAAC"}

package/dist/filter-translator.d.ts

@@ -0,0 +1,49 @@
+import type { Filter } from "@kavo/core";
+/**
+ * A MikroORM `FilterQuery`, built structurally as a plain object. MikroORM's
+ * own `FilterQuery<T>` is entity-generic and deliberately not used here: the
+ * translator works from core's AST, which is not tied to a MikroORM entity
+ * type, and a plain object is what lets this be unit-tested without a
+ * database.
+ */
+export type MikroWhere = Record<string, unknown>;
+export interface FilterTranslatorOptions {
+    /**
+     * The entity's primary-key property. Used only to spell a contradiction
+     * for the degenerate empty-group cases — see {@link matchesNothing}.
+     */
+    readonly idField: string;
+    /**
+     * Whether the target driver supports MikroORM's `$ilike` operator.
+     * PostgreSQL does; SQLite, MySQL, and MongoDB do not — MikroORM passes
+     * `ilike` straight through to SQL, so on those drivers it is a syntax
+     * error rather than a degraded match. A MikroORM `Platform` exposes
+     * nothing to detect this from, so it is a caller-declared setting (see
+     * `MikroOrmInfrastructureOptions.caseInsensitiveFilters`), the same
+     * posture `@kavo/prisma` takes for `mode: "insensitive"`.
+     *
+     * Unlike `@kavo/prisma` this defaults to **`false`**, because the two
+     * failure modes are not symmetric: declaring it off on PostgreSQL costs
+     * case-insensitivity, while leaving it on anywhere else makes every
+     * `ILIKE` query throw. On SQLite the default is not even a loss —
+     * SQLite's own `LIKE` is already ASCII case-insensitive.
+     */
+    readonly caseInsensitiveFilters: boolean;
+}
+/**
+ * Filter AST → MikroORM `FilterQuery`.
+ *
+ * Like `@kavo/prisma`'s translator and unlike `@kavo/typeorm`'s, this needs
+ * no query-builder state — no join aliases, no parameter numbering. MikroORM
+ * nests relation paths natively (`{ author: { name: { $eq: "Ada" } } }`) and
+ * adds the join itself, so a relation-path field nests the same translation
+ * one level deeper instead of registering a join.
+ *
+ * Every comparison is wrapped in an explicit operator (`{ $eq: v }`, never
+ * the bare `{ field: v }` shorthand). Core coerces filter values to scalars
+ * upstream, so this is defence in depth rather than the only guard — but an
+ * object arriving through the shorthand would be spliced in as *operators*,
+ * and the boundary's job is to be safe on its own terms.
+ */
+export declare function translateFilter<Entity>(filter: Filter<Entity>, options: FilterTranslatorOptions): MikroWhere | undefined;
+//# sourceMappingURL=filter-translator.d.ts.map

package/dist/filter-translator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-translator.d.ts","sourceRoot":"","sources":["../src/filter-translator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAmD,MAAM,YAAY,CAAC;AAG1F;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAEjD,MAAM,WAAW,uBAAuB;IACtC;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,sBAAsB,EAAE,OAAO,CAAC;CAC1C;AAgBD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,MAAM,EACpC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,EACtB,OAAO,EAAE,uBAAuB,GAC/B,UAAU,GAAG,SAAS,CAIxB"}

package/dist/filter-translator.js

@@ -0,0 +1,109 @@
+import { assertNever } from "@kavo/core";
+/**
+ * A predicate that matches no row.
+ *
+ * MikroORM rejects an empty `$and`/`$or` outright, and `$not: {}` negates
+ * *no condition at all*, which it renders as a match-everything rather than
+ * a match-nothing — the opposite of what these cases need. An empty `$in`
+ * is the one spelling MikroORM turns into a genuine contradiction on every
+ * driver, which is why this is expressed against the primary key rather
+ * than with a bare connective.
+ */
+function matchesNothing(idField) {
+    return { [idField]: { $in: [] } };
+}
+/**
+ * Filter AST → MikroORM `FilterQuery`.
+ *
+ * Like `@kavo/prisma`'s translator and unlike `@kavo/typeorm`'s, this needs
+ * no query-builder state — no join aliases, no parameter numbering. MikroORM
+ * nests relation paths natively (`{ author: { name: { $eq: "Ada" } } }`) and
+ * adds the join itself, so a relation-path field nests the same translation
+ * one level deeper instead of registering a join.
+ *
+ * Every comparison is wrapped in an explicit operator (`{ $eq: v }`, never
+ * the bare `{ field: v }` shorthand). Core coerces filter values to scalars
+ * upstream, so this is defence in depth rather than the only guard — but an
+ * object arriving through the shorthand would be spliced in as *operators*,
+ * and the boundary's job is to be safe on its own terms.
+ */
+export function translateFilter(filter, options) {
+    const root = filter.root;
+    if (root === null)
+        return undefined;
+    return translateExpression(root, options);
+}
+function translateExpression(expression, options) {
+    if (expression.kind === "condition") {
+        return translateCondition(expression, options);
+    }
+    const children = expression.children.map((child) => translateExpression(child, options));
+    if (expression.operator === "NOT") {
+        // Core's parser gives a NOT group exactly one child. With no child there
+        // is nothing to negate, and "not (anything)" matches nothing.
+        return children.length === 0 ? matchesNothing(options.idField) : { $not: children[0] };
+    }
+    // The parser enforces arity, so the empty cases only guard hand-built ASTs
+    // passed programmatically — but MikroORM rejects an empty `$and`/`$or`, so
+    // the identity for each connective is spelled explicitly.
+    if (children.length === 0) {
+        return expression.operator === "OR" ? matchesNothing(options.idField) : {};
+    }
+    return expression.operator === "OR" ? { $or: children } : { $and: children };
+}
+/** Nest `condition.field` (`"author.name"`) into MikroORM's native relation-path shape. */
+function nest(field, leaf) {
+    return field.split(".").reduceRight((inner, segment) => ({ [segment]: inner }), leaf);
+}
+function translateCondition(condition, options) {
+    const field = condition.field;
+    const value = condition.value;
+    switch (condition.operator) {
+        case "EQ":
+            return nest(field, { $eq: value });
+        case "NE":
+            // `$ne: null` is MikroORM's `IS NOT NULL`, so a null value needs no
+            // separate branch the way the SQL-string translator's does.
+            return nest(field, { $ne: value });
+        case "GT":
+            return nest(field, { $gt: value });
+        case "GTE":
+            return nest(field, { $gte: value });
+        case "LT":
+            return nest(field, { $lt: value });
+        case "LTE":
+            return nest(field, { $lte: value });
+        case "IN":
+            // MikroORM renders an empty `$in` as a contradiction rather than
+            // emitting invalid `IN ()`, and an empty `$nin` as a tautology — the
+            // same answers `@kavo/typeorm` has to spell out by hand because it
+            // writes the SQL itself.
+            return nest(field, { $in: value });
+        case "NOT_IN":
+            return nest(field, { $nin: value });
+        case "LIKE":
+            // The pattern reaches SQL `LIKE` verbatim. MikroORM has no way to
+            // attach an `ESCAPE` clause, so the grammar's `\` escape for a literal
+            // `%`/`_` is honored only by drivers that default to backslash
+            // (PostgreSQL, MySQL) — not by SQLite, which has no default escape
+            // character. See doc 17, "Adapter-specific caveats".
+            return nest(field, { $like: value });
+        case "ILIKE":
+            return nest(field, options.caseInsensitiveFilters ? { $ilike: value } : { $like: value });
+        case "BETWEEN": {
+            const [low, high] = value;
+            return nest(field, { $gte: low, $lte: high });
+        }
+        case "IS_NULL":
+            return nest(field, { $eq: null });
+        case "IS_NOT_NULL":
+            return nest(field, { $ne: null });
+        default:
+            // Every AST operator must translate to a predicate. Falling through
+            // silently would drop the condition and widen the result set, so the
+            // union is proven total here at build time — the same guarantee the
+            // other adapters' translators give.
+            return assertNever(condition.operator, "filter operator");
+    }
+}
+//# sourceMappingURL=filter-translator.js.map

package/dist/filter-translator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-translator.js","sourceRoot":"","sources":["../src/filter-translator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAmCzC;;;;;;;;;GASG;AACH,SAAS,cAAc,CAAC,OAAe;IACrC,OAAO,EAAE,CAAC,OAAO,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,CAAC;AACpC,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,eAAe,CAC7B,MAAsB,EACtB,OAAgC;IAEhC,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;IACzB,IAAI,IAAI,KAAK,IAAI;QAAE,OAAO,SAAS,CAAC;IACpC,OAAO,mBAAmB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AAC5C,CAAC;AAED,SAAS,mBAAmB,CAAC,UAA4B,EAAE,OAAgC;IACzF,IAAI,UAAU,CAAC,IAAI,KAAK,WAAW,EAAE,CAAC;QACpC,OAAO,kBAAkB,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IACjD,CAAC;IAED,MAAM,QAAQ,GAAG,UAAU,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,mBAAmB,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC;IAEzF,IAAI,UAAU,CAAC,QAAQ,KAAK,KAAK,EAAE,CAAC;QAClC,yEAAyE;QACzE,8DAA8D;QAC9D,OAAO,QAAQ,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAE,EAAE,CAAC;IAC1F,CAAC;IAED,2EAA2E;IAC3E,2EAA2E;IAC3E,0DAA0D;IAC1D,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,UAAU,CAAC,QAAQ,KAAK,IAAI,CAAC,CAAC,CAAC,cAAc,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;IAC7E,CAAC;IACD,OAAO,UAAU,CAAC,QAAQ,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;AAC/E,CAAC;AAED,2FAA2F;AAC3F,SAAS,IAAI,CAAC,KAAa,EAAE,IAA6B;IACxD,OAAO,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,WAAW,CAA0B,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC;AACjH,CAAC;AAED,SAAS,kBAAkB,CAAC,SAA0B,EAAE,OAAgC;IACtF,MAAM,KAAK,GAAG,SAAS,CAAC,KAAe,CAAC;IACxC,MAAM,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC;IAE9B,QAAQ,SAAS,CAAC,QAAQ,EAAE,CAAC;QAC3B,KAAK,IAAI;YACP,OAAO,IAAI,CAAC,KAAK,EAAE,EAAE,GAAG,EAAE,KAAqB,EAAE,CAAC,CAAC;QACrD,KAAK,IAAI;YACP,oEAAoE;YACpE,4DAA4D;YAC5D,OAAO,IAAI,CAAC,KAAK,EAAE,EAAE,GAAG,EAAE,KAAqB,EAAE,CAAC,CAAC;QACrD,KAAK,IAAI;YACP,OAAO,IAAI,CAAC,KAAK,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,CAAC;QACrC,KAAK,KAAK;YACR,OAAO,IAAI,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QACtC,KAAK,IAAI;YACP,OAAO,IAAI,CAAC,KAAK,EAAE,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,CAAC;QACrC,KAAK,KAAK;YACR,OAAO,IAAI,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QACtC,KAAK,IAAI;YACP,iEAAiE;YACjE,qEAAqE;YACrE,mEAAmE;YACnE,yBAAyB;YACzB,OAAO,IAAI,CAAC,KAAK,EAAE,EAAE,GAAG,EAAE,KAAgC,EAAE,CAAC,CAAC;QAChE,KAAK,QAAQ;YACX,OAAO,IAAI,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,KAAgC,EAAE,CAAC,CAAC;QACjE,KAAK,MAAM;YACT,kEAAkE;YAClE,uEAAuE;YACvE,+DAA+D;YAC/D,mEAAmE;YACnE,qDAAqD;YACrD,OAAO,IAAI,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,KAAe,EAAE,CAAC,CAAC;QACjD,KAAK,OAAO;YACV,OAAO,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC,sBAAsB,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,KAAe,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,KAAe,EAAE,CAAC,CAAC;QAChH,KAAK,SAAS,CAAC,CAAC,CAAC;YACf,MAAM,CAAC,GAAG,EAAE,IAAI,CAAC,GAAG,KAAgC,CAAC;YACrD,OAAO,IAAI,CAAC,KAAK,EAAE,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;QAChD,CAAC;QACD,KAAK,SAAS;YACZ,OAAO,IAAI,CAAC,KAAK,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC;QACpC,KAAK,aAAa;YAChB,OAAO,IAAI,CAAC,KAAK,EAAE,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC;QACpC;YACE,oEAAoE;YACpE,qEAAqE;YACrE,oEAAoE;YACpE,oCAAoC;YACpC,OAAO,WAAW,CAAC,SAAS,CAAC,QAAQ,EAAE,iBAAiB,CAAC,CAAC;IAC9D,CAAC;AACH,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @kavo/mikroorm — MikroORM adapter for Kavo.
+ *
+ * Implements `@kavo/core`'s `RepositoryAdapter` over a MikroORM
+ * `EntityManager` and feeds core's entity-metadata seam from MikroORM's own
+ * `MetadataStorage`. `@mikro-orm/core` is a peerDependency; `@kavo/core`
+ * never imports it.
+ */
+export { MikroOrmRepositoryAdapter } from "./mikro-orm-repository-adapter.js";
+export { translateFilter, type FilterTranslatorOptions, type MikroWhere } from "./filter-translator.js";
+export { buildEntityMetadata } from "./metadata.js";
+export { mapDriverError } from "./error-mapping.js";
+export { toPlain, toPlainAll } from "./plain-entity.js";
+export { createInfrastructure, createMikroOrmKavo, type MikroOrmInfrastructureOptions } from "./infrastructure.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AAC9E,OAAO,EAAE,eAAe,EAAE,KAAK,uBAAuB,EAAE,KAAK,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACxG,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,KAAK,6BAA6B,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -0,0 +1,15 @@
+/**
+ * @kavo/mikroorm — MikroORM adapter for Kavo.
+ *
+ * Implements `@kavo/core`'s `RepositoryAdapter` over a MikroORM
+ * `EntityManager` and feeds core's entity-metadata seam from MikroORM's own
+ * `MetadataStorage`. `@mikro-orm/core` is a peerDependency; `@kavo/core`
+ * never imports it.
+ */
+export { MikroOrmRepositoryAdapter } from "./mikro-orm-repository-adapter.js";
+export { translateFilter } from "./filter-translator.js";
+export { buildEntityMetadata } from "./metadata.js";
+export { mapDriverError } from "./error-mapping.js";
+export { toPlain, toPlainAll } from "./plain-entity.js";
+export { createInfrastructure, createMikroOrmKavo } from "./infrastructure.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AAC9E,OAAO,EAAE,eAAe,EAAiD,MAAM,wBAAwB,CAAC;AACxG,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,oBAAoB,EAAE,kBAAkB,EAAsC,MAAM,qBAAqB,CAAC"}

package/dist/infrastructure.d.ts

@@ -0,0 +1,35 @@
+import type { KavoInfrastructure, KavoInstance, KavoOptions } from "@kavo/core";
+import type { MikroORM } from "@mikro-orm/core";
+/**
+ * What MikroORM needs beyond the ORM instance. Nothing is required — a
+ * MikroORM entity is a real runtime class carrying its own metadata, so the
+ * ORM instance alone supplies both halves of core's infrastructure seam,
+ * exactly as a TypeORM `DataSource` does and unlike `@kavo/prisma`, which
+ * needs caller-declared marker classes (ADR-0017).
+ */
+export interface MikroOrmInfrastructureOptions {
+    /**
+     * Whether the driver supports MikroORM's `$ilike` operator — PostgreSQL
+     * does; SQLite, MySQL, and MongoDB reject it as a syntax error. Defaults
+     * to `false`, the setting that works on every driver; turn it on for
+     * PostgreSQL to make `ILIKE` genuinely case-insensitive. See
+     * `FilterTranslatorOptions`.
+     */
+    readonly caseInsensitiveFilters?: boolean;
+}
+/**
+ * The MikroORM implementation of core's infrastructure seam: metadata and
+ * adapters derived from one `MikroORM` instance, cached per entity (metadata
+ * derivation and adapter construction are bootstrap work, not per-request
+ * work) — same shape as `@kavo/typeorm`'s `createInfrastructure`.
+ *
+ * The instance is held rather than an `EntityManager`, because every adapter
+ * operation forks its own manager from it; see `MikroOrmRepositoryAdapter`.
+ */
+export declare function createInfrastructure(orm: MikroORM, options?: MikroOrmInfrastructureOptions): KavoInfrastructure;
+/**
+ * Sugar for the common case: a Kavo root instance wired to one MikroORM
+ * instance, so `kavo.createCrud(Author)` is genuinely zero-config.
+ */
+export declare function createMikroOrmKavo(orm: MikroORM, options?: MikroOrmInfrastructureOptions & Omit<KavoOptions, "infrastructure">): KavoInstance;
+//# sourceMappingURL=infrastructure.d.ts.map

package/dist/infrastructure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"infrastructure.d.ts","sourceRoot":"","sources":["../src/infrastructure.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,kBAAkB,EAClB,YAAY,EACZ,WAAW,EAEZ,MAAM,YAAY,CAAC;AAEpB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAIhD;;;;;;GAMG;AACH,MAAM,WAAW,6BAA6B;IAC5C;;;;;;OAMG;IACH,QAAQ,CAAC,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAC3C;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,GAAE,6BAAkC,GAAG,kBAAkB,CA0BnH;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,QAAQ,EACb,OAAO,GAAE,6BAA6B,GAAG,IAAI,CAAC,WAAW,EAAE,gBAAgB,CAAM,GAChF,YAAY,CAMd"}

package/dist/infrastructure.js

@@ -0,0 +1,49 @@
+import { createKavo } from "@kavo/core";
+import { buildEntityMetadata } from "./metadata.js";
+import { MikroOrmRepositoryAdapter } from "./mikro-orm-repository-adapter.js";
+/**
+ * The MikroORM implementation of core's infrastructure seam: metadata and
+ * adapters derived from one `MikroORM` instance, cached per entity (metadata
+ * derivation and adapter construction are bootstrap work, not per-request
+ * work) — same shape as `@kavo/typeorm`'s `createInfrastructure`.
+ *
+ * The instance is held rather than an `EntityManager`, because every adapter
+ * operation forks its own manager from it; see `MikroOrmRepositoryAdapter`.
+ */
+export function createInfrastructure(orm, options = {}) {
+    const metadataCache = new Map();
+    const adapterCache = new Map();
+    function metadataFor(entity) {
+        let metadata = metadataCache.get(entity);
+        if (metadata === undefined) {
+            metadata = buildEntityMetadata(orm, entity);
+            metadataCache.set(entity, metadata);
+        }
+        return metadata;
+    }
+    return {
+        metadataFor,
+        adapterFor(entity) {
+            let adapter = adapterCache.get(entity);
+            if (adapter === undefined) {
+                adapter = new MikroOrmRepositoryAdapter(orm, metadataFor(entity), {
+                    caseInsensitiveFilters: options.caseInsensitiveFilters ?? false,
+                });
+                adapterCache.set(entity, adapter);
+            }
+            return adapter;
+        },
+    };
+}
+/**
+ * Sugar for the common case: a Kavo root instance wired to one MikroORM
+ * instance, so `kavo.createCrud(Author)` is genuinely zero-config.
+ */
+export function createMikroOrmKavo(orm, options = {}) {
+    const { caseInsensitiveFilters, ...kavoOptions } = options;
+    return createKavo({
+        ...kavoOptions,
+        infrastructure: createInfrastructure(orm, { caseInsensitiveFilters }),
+    });
+}
+//# sourceMappingURL=infrastructure.js.map

package/dist/infrastructure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"infrastructure.js","sourceRoot":"","sources":["../src/infrastructure.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAC;AAoB9E;;;;;;;;GAQG;AACH,MAAM,UAAU,oBAAoB,CAAC,GAAa,EAAE,UAAyC,EAAE;IAC7F,MAAM,aAAa,GAAG,IAAI,GAAG,EAA4B,CAAC;IAC1D,MAAM,YAAY,GAAG,IAAI,GAAG,EAA+B,CAAC;IAE5D,SAAS,WAAW,CAAwB,MAAwB;QAClE,IAAI,QAAQ,GAAG,aAAa,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACzC,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC3B,QAAQ,GAAG,mBAAmB,CAAC,GAAG,EAAE,MAAM,CAAmB,CAAC;YAC9D,aAAa,CAAC,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QACtC,CAAC;QACD,OAAO,QAAkC,CAAC;IAC5C,CAAC;IAED,OAAO;QACL,WAAW;QACX,UAAU,CAAwB,MAAwB;YACxD,IAAI,OAAO,GAAG,YAAY,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YACvC,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;gBAC1B,OAAO,GAAG,IAAI,yBAAyB,CAAC,GAAG,EAAE,WAAW,CAAC,MAAM,CAAC,EAAE;oBAChE,sBAAsB,EAAE,OAAO,CAAC,sBAAsB,IAAI,KAAK;iBAChE,CAAsB,CAAC;gBACxB,YAAY,CAAC,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;YACpC,CAAC;YACD,OAAO,OAAoC,CAAC;QAC9C,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,kBAAkB,CAChC,GAAa,EACb,UAA+E,EAAE;IAEjF,MAAM,EAAE,sBAAsB,EAAE,GAAG,WAAW,EAAE,GAAG,OAAO,CAAC;IAC3D,OAAO,UAAU,CAAC;QAChB,GAAG,WAAW;QACd,cAAc,EAAE,oBAAoB,CAAC,GAAG,EAAE,EAAE,sBAAsB,EAAE,CAAC;KACtE,CAAC,CAAC;AACL,CAAC"}

package/dist/metadata.d.ts

@@ -0,0 +1,15 @@
+import type { ClassRef, EntityMetadata } from "@kavo/core";
+import type { MikroORM } from "@mikro-orm/core";
+/**
+ * Build the core `EntityMetadata` for one entity from MikroORM's own
+ * `MetadataStorage`: the adapter feeds core's metadata seam; core never sees
+ * MikroORM types.
+ *
+ * Unlike `@kavo/prisma`, no marker class is needed (ADR-0017 exists because
+ * Prisma erases its models at compile time) — a MikroORM entity is a real
+ * runtime class that already carries its own metadata, so the class the
+ * caller passes to `createCrud` *is* the identity, exactly as in
+ * `@kavo/typeorm`.
+ */
+export declare function buildEntityMetadata<Entity extends object>(orm: MikroORM, entity: ClassRef<Entity>): EntityMetadata<Entity>;
+//# sourceMappingURL=metadata.d.ts.map

package/dist/metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../src/metadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAgD,MAAM,YAAY,CAAC;AAEzG,OAAO,KAAK,EAAkB,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAyGhE;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,SAAS,MAAM,EACvD,GAAG,EAAE,QAAQ,EACb,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,GACvB,cAAc,CAAC,MAAM,CAAC,CAmGxB"}