uql-orm 0.24.0 → 0.24.1

package/README.md

@@ -50,7 +50,7 @@ from the browser to the server. The same object runs on every supported database
 
 ## Why UQL?
 
-- **The fastest.** Wins [all 8 categories](https://uql-orm.dev/benchmark) of our [open benchmark](https://github.com/rogerpadilla/ts-orm-benchmark), beating even query builders like Knex and Kysely: ~2.3× faster than the runner-up on average, close to 4M ops/s on simple SELECTs.
+- **The fastest.** Wins [all 8 categories](https://uql-orm.dev/benchmark) of our [open benchmark](https://github.com/rogerpadilla/ts-orm-benchmark), beating even query builders like Knex and Kysely: ~2.4× faster than the runner-up on average, over 4.6M ops/s on simple SELECTs.
 - **Light.** Zero dependencies, under 1 MB installed, every dialect included.
 - **Queries are data, not method chains.** Plain JSON in, typed rows out. There's no DSL to learn and nothing to compile.
 - **Type-safe to the leaf.** Operators are gated per field type, and JSON/JSONB dot-paths resolve each path's value type, so `{ age: { $like: 'x' } }` or a typo'd path is a compile error instead of a runtime surprise.

package/dist/entity/metadata/definition.js

@@ -227,7 +227,14 @@ function fillRelations(meta) {
             }
         }
         if (relOpts.through) {
-            fillThroughRelations(relOpts.through());
+            const throughEntity = relOpts.through();
+            const throughMeta = fillThroughRelations(throughEntity);
+            for (const { local } of relOpts.references) {
+                if (throughMeta.fields[local])
+                    continue;
+                throw new TypeError(`'${meta.entity.name}.${relKey}' joins through '${throughEntity.name}', which has no '${local}' ` +
+                    "field. Declare it, or name the join columns yourself with 'references'.");
+            }
         }
     }
     return meta;
@@ -254,8 +261,11 @@ function fillInverseSideRelations(relOpts) {
         foreign: local,
     }));
 }
+// `getMeta` rather than `ensureMeta`: a pivot that declares its sides as relations rather than as
+// `@Field({ references })` columns gets those foreign-key columns auto-created there, and the caller
+// checks its own derived join columns against them.
 function fillThroughRelations(entity) {
-    const meta = ensureMeta(entity);
+    const meta = getMeta(entity);
     meta.relations = getKeys(meta.fields).reduce((relations, key) => {
         const field = meta.fields[key];
         if (!field)
@@ -274,6 +284,7 @@ function fillThroughRelations(entity) {
         }
         return relations;
     }, {});
+    return meta;
 }
 function getMappedByRelationKey(relOpts) {
     if (typeof relOpts.mappedBy === 'function') {
@@ -286,10 +297,7 @@ function getMappedByRelationKey(relOpts) {
 }
 function getRelationKeyMap(meta) {
     const keys = [...getKeys(meta.fields), ...getKeys(meta.relations)];
-    return keys.reduce((acc, key) => {
-        acc[key] = key;
-        return acc;
-    }, {});
+    return Object.fromEntries(keys.map((key) => [key, key]));
 }
 function getIdKey(meta) {
     const id = getKeys(meta.fields).find((key) => meta.fields[key]?.isId);

package/dist/type/entity.d.ts

@@ -350,16 +350,28 @@ export type RelationOptions<E = any> = {
     cardinality: RelationCardinality;
     readonly cascade?: boolean | CascadeType;
     mappedBy?: RelationMappedBy<E>;
-    through?: EntityGetter<RelationValue<E>>;
+    /**
+     * The pivot entity of a many-to-many. Unconstrained by `E`: a pivot holds foreign keys to both
+     * sides and is not a relation value of the target, so nothing about it is derivable from `E`.
+     */
+    through?: EntityGetter;
     references?: RelationReferences;
 };
 type RelationOptionsOwner<E> = Pick<RelationOptions<E>, 'entity' | 'references' | 'cascade'>;
 type RelationOptionsInverseSide<E> = Required<Pick<RelationOptions<E>, 'entity' | 'mappedBy'>> & Pick<RelationOptions<E>, 'cascade'>;
 type RelationOptionsThroughOwner<E> = Required<Pick<RelationOptions<E>, 'entity'>> & Pick<RelationOptions<E>, 'through' | 'references' | 'cascade'>;
+/**
+ * The key names of `E` as values, so `mappedBy` can be written as `(user) => user.company` instead of
+ * a string literal and survive a rename.
+ *
+ * Mapping over `Key<E>` rather than `keyof E` is what makes the callback usable: a homomorphic
+ * `[K in keyof E]` inherits the entity's optional modifiers, so `user.company` is
+ * `'company' | undefined` and {@link RelationKeyMapper} rejects it - every callback needed a `!`. The
+ * map is built from the target's metadata (see `getRelationKeyMap`), where every key is present and
+ * every key is a string.
+ */
 export type RelationKeyMap<E> = {
-    readonly [K in keyof E]: K;
-} & {
-    readonly [key: string]: string;
+    readonly [K in Key<E>]: K;
 };
 export type RelationKeyMapper<E> = (keyMap: RelationKeyMap<E>) => Key<E>;
 export type RelationReferences = {

package/package.json

@@ -3,7 +3,7 @@
   "homepage": "https://uql-orm.dev",
   "description": "Extremely fast, type-safe TypeScript ORM - one API for every database",
   "license": "MIT",
-  "version": "0.24.0",
+  "version": "0.24.1",
   "type": "module",
   "engines": {
     "node": ">=24"
@@ -198,5 +198,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "d9499a4b8c5ee866950b397fb87f55643d86fc39"
+  "gitHead": "7f11b72301d647853c7a2778daaa09af8f4d5695"
 }