@kavo/mikroorm 0.6.0

package/dist/metadata.js

@@ -0,0 +1,202 @@
+import { ConfigurationException } from "@kavo/core";
+/**
+ * Translate a MikroORM property's declared type into the ORM-independent
+ * `FieldKind` core coerces against.
+ *
+ * `runtimeType` is preferred over `type`: MikroORM normalizes the former to
+ * the JavaScript type the property actually holds (`"string"`, `"Date"`),
+ * which is what core must coerce toward — a `decimal` column surfaces as
+ * `"string"` there, and `string` is genuinely the right target for it. The
+ * declared `type` is still consulted as a fallback, because `runtimeType` is
+ * `"any"` for the custom types that carry no JavaScript equivalent
+ * (`JsonType`). An unrecognized type degrades to `string` — comparison still
+ * works, coercion just doesn't narrow.
+ *
+ * A `bigint` column is a caveat, not a case this function special-cases: as
+ * of MikroORM v7, `BigIntType`'s default mode hands JavaScript a native
+ * `bigint`, and `runtimeType` reports that as `"bigint"`, matched below
+ * alongside `"number"`. An app that needs the old, precision-safe string
+ * representation back must construct the type explicitly —
+ * `new BigIntType("string")` — see doc 17 §1.
+ */
+function fieldKindOf(property) {
+    if (property.enum === true)
+        return "enum";
+    const type = String(property.runtimeType ?? property.type).toLowerCase();
+    if (type === "date")
+        return "date";
+    if (type === "boolean" || type === "bool")
+        return "boolean";
+    if (type === "number" || type === "bigint")
+        return "number";
+    if (type === "string")
+        return "string";
+    if (type === "object" || type === "json" || type === "jsonb")
+        return "json";
+    // Fall back to the declared column type for anything `runtimeType` did not
+    // already answer (a custom `type: "int8"`, a driver-native column type).
+    const declared = String(property.type).toLowerCase();
+    if (/^(int|integer|tinyint|smallint|mediumint|bigint|float|double|real|decimal|numeric|number)/.test(declared)) {
+        return "number";
+    }
+    if (/^(bool|boolean)/.test(declared))
+        return "boolean";
+    if (/^(date|datetime|timestamp|time)/.test(declared))
+        return "date";
+    if (/^(json|jsonb)/.test(declared))
+        return "json";
+    return "string";
+}
+/**
+ * Whether a property is written by the database or the ORM rather than by
+ * the caller — excluded from the derived `create`/`update`/`patch` defaults
+ * and stripped from write payloads by the default deserializer.
+ *
+ * MikroORM has no single flag for this, so the four independent ways a
+ * property becomes non-caller-writable are each checked: an auto-increment
+ * or database-generated column, an `onCreate`/`onUpdate` hook (the
+ * equivalent of TypeORM's `@CreateDateColumn`/`@UpdateDateColumn`), an
+ * optimistic-lock `@Property({ version: true })`, and `persist: false`,
+ * which is not stored at all.
+ */
+function isGenerated(property) {
+    return (property.autoincrement === true ||
+        property.generated !== undefined ||
+        property.onCreate !== undefined ||
+        property.onUpdate !== undefined ||
+        property.version === true ||
+        property.persist === false);
+}
+/** MikroORM's relation `kind` discriminators that carry many rows. */
+const TO_MANY = new Set(["1:m", "m:n"]);
+/**
+ * The lazy target-class thunk for one relation.
+ *
+ * A relation target can be declared two ways, and they do *not* arrive the
+ * same: `@ManyToOne(() => Owner)` leaves `property.entity` a thunk resolving
+ * to the class, while `@ManyToOne((): any => "Owner")` — the spelling that
+ * keeps a bidirectional relation's import cycle off the runtime graph, and
+ * therefore the one a `dependency-cruiser`-checked codebase reaches for —
+ * leaves it a thunk resolving to a plain **string** (MikroORM v7's decorator
+ * types no longer accept a bare string; `any` is what makes the thunk
+ * type-check). Calling it would return a string, not a class, for half the
+ * codebases that use this adapter.
+ *
+ * `targetMeta` is what both spellings have in common: MikroORM resolves it
+ * during metadata discovery either way. The metadata-storage lookup behind
+ * it covers a target discovered after this thunk was built, and the declared
+ * thunk is the last resort. The resolution is deferred until the thunk is
+ * called, because a bidirectional relation's target may not be registered at
+ * the time this entity's metadata is derived.
+ */
+function targetOf(orm, property, owner) {
+    return () => {
+        const resolved = property.targetMeta?.class ?? orm.getMetadata().getByClassName(String(property.type), false)?.class;
+        if (resolved !== undefined)
+            return resolved;
+        if (typeof property.entity === "function") {
+            return property.entity();
+        }
+        throw new ConfigurationException(owner, `relations.${property.name}`, `cannot resolve the target entity of relation '${property.name}'; ` +
+            `MikroORM reports its type as '${String(property.type)}', which is not a registered entity`);
+    };
+}
+/**
+ * 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 function buildEntityMetadata(orm, entity) {
+    const metadata = orm.getMetadata().getByClassName(entity.name, false);
+    if (metadata === undefined) {
+        throw new ConfigurationException(entity.name, "entity", `MikroORM has no registered entity named '${entity.name}'; ` +
+            `add it to the 'entities' array the ORM was initialized with`);
+    }
+    if (metadata.primaryKeys.length !== 1) {
+        throw new ConfigurationException(metadata.className, "primaryKeys", `Kavo v6 requires exactly one primary key; found ${metadata.primaryKeys.length}`);
+    }
+    const properties = Object.values(metadata.properties);
+    const discriminatorColumn = metadata.root?.discriminatorColumn ?? metadata.discriminatorColumn;
+    const fields = properties
+        // An embeddable contributes *two* kinds of property: the object-valued
+        // parent (`kind: "embedded"`, what a caller addresses) and one child per
+        // inner column, carrying an `embedded: [parent, child]` back-reference
+        // and a name that is an implementation detail (`addr~city`,
+        // `inline_city`). Only the parent belongs on the wire, so the children
+        // are dropped rather than leaked into DTOs and allowlists.
+        .filter((property) => property.embedded === undefined)
+        // `hidden: true` is MikroORM's "never expose this" — `toObject` drops it,
+        // so it can never reach a response. Excluding it from the metadata seam
+        // as well, rather than relying on that, is what stops it from landing on
+        // the *default allowlists*: a filterable-but-invisible column is a blind
+        // extraction oracle, where `filter[passwordHash][like]=a%` is answered by
+        // the row count even though the value is projected out of the body.
+        // `lazy: true` is excluded for the same reason — it is not loaded with
+        // the entity, so a DTO naming it would emit `undefined` while a filter on
+        // it still ran in the database. `@kavo/mongoose` excludes its
+        // `select: false` paths on identical reasoning (doc 15 §1). The trade is
+        // the same one it documents: Kavo does not manage such a property at all,
+        // so write it through a custom operation or the ORM directly.
+        .filter((property) => property.hidden !== true && property.lazy !== true)
+        .filter((property) => property.kind === "scalar" || property.kind === "embedded")
+        .map((property) => ({
+        name: property.name,
+        kind: property.kind === "embedded" ? "json" : fieldKindOf(property),
+        nullable: property.nullable === true,
+        // The single-table-inheritance discriminator: write-only bookkeeping
+        // MikroORM manages itself from the subtype being persisted. It never
+        // hydrates onto an entity and never survives `toObject`, so it cannot
+        // reach a response either way — what this flag stops is the *inbound*
+        // direction. Left un-generated it would join the writable projection,
+        // and a client sending `species: "cat"` on a Dog would produce a row
+        // that entity's own repository can no longer load.
+        //
+        // Read from `root`, because MikroORM records `discriminatorColumn` only
+        // on the inheritance root while the property itself is inherited by
+        // every subtype — and a subtype is what a caller passes to `createCrud`.
+        generated: isGenerated(property) || property.name === discriminatorColumn,
+        ...(property.items !== undefined && {
+            enumValues: property.items.map((value) => String(value)),
+        }),
+    }));
+    const relations = properties
+        .filter((property) => property.kind !== "scalar" && property.kind !== "embedded")
+        .map((property) => ({
+        name: property.name,
+        // Resolved lazily and from `targetMeta` rather than by calling
+        // `property.entity` — see `targetOf`, which exists because a
+        // string-declared target (the spelling that keeps a bidirectional
+        // relation's cycle off the runtime graph) leaves `entity` a string.
+        target: targetOf(orm, property, metadata.className),
+        cardinality: TO_MANY.has(property.kind) ? "many" : "one",
+        // Inclusion is an opt-in allowlist; ORM metadata only supplies shape,
+        // never permission.
+        includable: false,
+        strategy: "auto",
+    }));
+    return {
+        entity,
+        name: metadata.className,
+        idField: metadata.primaryKeys[0],
+        fields,
+        relations,
+        // MikroORM declares no delete-date marker of its own — its soft-delete
+        // pattern is a user-defined `@Filter`, which is a query concern rather
+        // than a column declaration, so there is nothing here to detect.
+        //
+        // This is *not* the same as "soft delete is off until configured".
+        // `softDelete` defaults to `{ field: "deletedAt", strategy: "auto" }`, and
+        // core matches that name against the entity's own columns — so a plain
+        // `deletedAt` property enables soft delete with no config at all. What
+        // reporting `null` here really costs is the ability to mark the marker
+        // generated, which is why it stays client-writable. See doc 17 §5 and §7.
+        softDeleteField: null,
+    };
+}
+//# sourceMappingURL=metadata.js.map

package/dist/metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.js","sourceRoot":"","sources":["../src/metadata.ts"],"names":[],"mappings":"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"}

package/dist/mikro-orm-repository-adapter.d.ts

@@ -0,0 +1,110 @@
+import type { EntityId, EntityMetadata, KavoContext, NormalizedQueryContext, RepositoryAdapter } from "@kavo/core";
+import { type MikroORM } from "@mikro-orm/core";
+/**
+ * `RepositoryAdapter` over a MikroORM `EntityManager`: CRUD with hard *or*
+ * soft delete, restore, purge, filtering, sorting, pagination, optional
+ * counting, and nested relation includes.
+ *
+ * Two things are specific to MikroORM and load-bearing:
+ *
+ * **Every method forks the EntityManager.** MikroORM is a Unit-of-Work ORM:
+ * an `EntityManager` owns an identity map that caches every entity it has
+ * loaded, and reusing one across requests would serve stale rows and leak
+ * one caller's entities into another's. `orm.em` is the *root* manager and
+ * is not meant to be queried directly; `orm.em.fork()` gives each operation
+ * a clean, isolated one, which is the same scope a request-scoped
+ * `RequestContext` would give a hand-written MikroORM application.
+ *
+ * **`IncludeNode.strategy` is deliberately ignored**, exactly as in
+ * `@kavo/prisma` and unlike `@kavo/typeorm`. The TypeORM adapter translates
+ * the join/batch split because it drives a raw SQL query builder, where a
+ * to-many `JOIN` multiplies root rows and separate batched queries are how
+ * that is avoided. MikroORM resolves `populate` with its own queries and
+ * applies `limit`/`offset` to the root regardless of the load strategy, so a
+ * to-many include never disturbs pagination here. There is nothing left for
+ * the distinction to control, and MikroORM's `strategy` option is per-query
+ * rather than per-relation anyway — it could not express a mixed tree.
+ */
+export declare class MikroOrmRepositoryAdapter<Entity extends object> implements RepositoryAdapter<Entity> {
+    private readonly orm;
+    private readonly entity;
+    private readonly idField;
+    private readonly filterOptions;
+    /**
+     * Relation property name → the target entity's primary-key property.
+     * Resolved lazily: a bidirectional relation's target may not be registered
+     * with MikroORM's metadata storage at the time this adapter is built.
+     */
+    private readonly relationIdFields;
+    constructor(orm: MikroORM, metadata: EntityMetadata<Entity>, options?: {
+        caseInsensitiveFilters?: boolean;
+    });
+    /** A clean, isolated `EntityManager` for one operation — see the class doc. */
+    private fork;
+    findOneById(id: EntityId, query: NormalizedQueryContext<Entity> | null, context: KavoContext<Entity>): Promise<Entity | null>;
+    findOne(query: NormalizedQueryContext<Entity>, context: KavoContext<Entity>): Promise<Entity | null>;
+    findMany(query: NormalizedQueryContext<Entity>, context: KavoContext<Entity>): Promise<readonly Entity[]>;
+    count(query: NormalizedQueryContext<Entity>, context: KavoContext<Entity>): Promise<number>;
+    /** The translated filter, narrowed to the request's soft-delete scope. */
+    private buildWhere;
+    private buildFindOptions;
+    /**
+     * Translate a validated `IncludeTree` into MikroORM's `populate` paths.
+     *
+     * Soft-delete scoping of included rows is deliberately **not** done here —
+     * see {@link pruneIncluded}. MikroORM's `populateWhere` cannot express it:
+     * a nested condition (`{ articles: { deletedAt: null, notes: { deletedAt:
+     * null } } }`) is read as a relation-path predicate on the *parent*, so an
+     * article with no live notes is dropped from the parent's collection
+     * altogether rather than coming back with an empty one. The dotted spelling
+     * MikroORM rejects outright, and the parent-only spelling silently leaves
+     * every deeper level unscoped.
+     */
+    private populateOptions;
+    /**
+     * Three-way soft-delete scope: exclude deleted rows by default, include
+     * both live and deleted with `withDeleted`, or restrict to only deleted
+     * with `onlyDeleted` (mutually exclusive — validated upstream).
+     *
+     * There is one shape to handle rather than TypeORM's two: MikroORM
+     * declares no delete-date column of its own, so the marker is always an
+     * ordinary property and always needs its predicate spelled out.
+     */
+    private scopeToLive;
+    /** The resolved strategy, refused when an operation requires soft. */
+    private requireSoftDelete;
+    private isDeleted;
+    /** One row by id, as a plain object, under the given soft-delete scope. */
+    private byId;
+    create(data: Partial<Entity>, context: KavoContext<Entity>): Promise<Entity>;
+    update(id: EntityId, data: Partial<Entity>, context: KavoContext<Entity>): Promise<Entity>;
+    patch(id: EntityId, data: Partial<Entity>, context: KavoContext<Entity>): Promise<Entity>;
+    /**
+     * update and patch share one load-merge-flush primitive: the *shape* of
+     * `data` differs (full body vs. sparse) because the DTO layer differs, not
+     * the persistence mechanics.
+     *
+     * This goes through the Unit of Work rather than `nativeUpdate` — one
+     * managed entity, assigned and flushed — so lifecycle hooks,
+     * `onUpdate` properties, and relation diffing all behave as they would in
+     * a hand-written MikroORM application. The row is loaded first anyway, to
+     * turn a missing id into `NotFoundException`, so this costs no extra
+     * query.
+     */
+    private mergeAndFlush;
+    delete(id: EntityId, context: KavoContext<Entity>): Promise<void>;
+    restore(id: EntityId, context: KavoContext<Entity>): Promise<Entity>;
+    purge(id: EntityId, context: KavoContext<Entity>): Promise<void>;
+    /**
+     * Normalize the engine's write payload for MikroORM.
+     *
+     * Core's default deserializer narrows a relation value to `{ id }` (or an
+     * array of them) — association by id, ADR-0014. MikroORM associates by
+     * *primary key value*, and would read a nested `{ id }` object as a
+     * request to create a new entity, so each relation value is unwrapped to
+     * the bare key before it reaches `create`/`assign`.
+     */
+    private toWriteData;
+    private notFound;
+}
+//# sourceMappingURL=mikro-orm-repository-adapter.d.ts.map

package/dist/mikro-orm-repository-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mikro-orm-repository-adapter.d.ts","sourceRoot":"","sources":["../src/mikro-orm-repository-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,QAAQ,EACR,cAAc,EAEd,WAAW,EACX,sBAAsB,EACtB,iBAAiB,EAElB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAA4B,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAsB1E;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,yBAAyB,CAAC,MAAM,SAAS,MAAM,CAAE,YAAW,iBAAiB,CAAC,MAAM,CAAC;IAY9F,OAAO,CAAC,QAAQ,CAAC,GAAG;IAXtB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAmB;IAC1C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA0B;IACxD;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAoC;gBAGlD,GAAG,EAAE,QAAQ,EAC9B,QAAQ,EAAE,cAAc,CAAC,MAAM,CAAC,EAChC,OAAO,GAAE;QAAE,sBAAsB,CAAC,EAAE,OAAO,CAAA;KAAO;IAkBpD,+EAA+E;IAC/E,OAAO,CAAC,IAAI;IAMN,WAAW,CACf,EAAE,EAAE,QAAQ,EACZ,KAAK,EAAE,sBAAsB,CAAC,MAAM,CAAC,GAAG,IAAI,EAC5C,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAC3B,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAgBnB,OAAO,CAAC,KAAK,EAAE,sBAAsB,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAwBpG,QAAQ,CAAC,KAAK,EAAE,sBAAsB,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC;IAiBzG,KAAK,CAAC,KAAK,EAAE,sBAAsB,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAYjG,0EAA0E;IAC1E,OAAO,CAAC,UAAU;IASlB,OAAO,CAAC,gBAAgB;IAUxB;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,eAAe;IAOvB;;;;;;;;OAQG;IACH,OAAO,CAAC,WAAW;IAanB,sEAAsE;IACtE,OAAO,CAAC,iBAAiB;IAazB,OAAO,CAAC,SAAS;IAIjB,2EAA2E;YAC7D,IAAI;IAYZ,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAW5E,MAAM,CAAC,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAI1F,KAAK,CAAC,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAI/F;;;;;;;;;;;OAWG;YACW,aAAa;IAgBrB,MAAM,CAAC,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAuBjE,OAAO,CAAC,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAsBpE,KAAK,CAAC,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAsBtE;;;;;;;;OAQG;IACH,OAAO,CAAC,WAAW;IASnB,OAAO,CAAC,QAAQ;CAMjB"}