uql-orm 0.57.0 → 0.58.0

package/dist/entity/metadata/definition.js

@@ -38,18 +38,41 @@ export function defineField(entity, key, opts = {}) {
 export function defineId(entity, key, opts) {
     return defineField(entity, key, { ...opts, isId: true });
 }
-// `RelationOptions` is parameterized by the *target* entity, which is independent of the owner `E`, so it
-// is left at its default here rather than tied to the class being registered.
+/** `T` is the relation's target, independent of the owner `E`. */
 export function defineRelation(entity, key, opts) {
-    if (!opts.entity) {
+    return addRelation(entity, key, relationRegistration(opts));
+}
+/**
+ * `opts` as the registry takes them: `mappedBy` and `references` read off their key maps down to the
+ * names they give. The callbacks only read properties, so they run here, before any entity has to
+ * exist, and the registry holds data alone.
+ */
+export function relationRegistration({ mappedBy, references, ...opts }) {
+    return {
+        ...opts,
+        ...(mappedBy ? { mappedBy: mappedBy(keyMap()) } : {}),
+        ...(references ? { references: [...references(keyMap(), keyMap())] } : {}),
+    };
+}
+/** Every entity's key map: a callback only reads one property off it, and that property is its own key. */
+function keyMap() {
+    return KEY_MAP;
+}
+const KEY_MAP = new Proxy({}, { get: (_, key) => key });
+function addRelation(entity, key, registration) {
+    if (!registration.entity) {
         throw new TypeError(`'${entity.name}.${key}' needs an 'entity' getter, e.g. '@ManyToOne({ entity: () => Company })'.`);
     }
+    if (registration.through && registration.references) {
+        throw new TypeError(`'${entity.name}.${key}' joins through a junction, whose columns follow the convention; 'references' ` +
+            "pairs the declaring entity's columns with the target's instead.");
+    }
     const meta = ensureWritableMeta(entity);
-    // Registration writes the authored shape into a map declared as resolved: `getMeta` runs
-    // `fillRelations`, which settles `entity`, `references` and `mappedBy` or throws. Bridging the two
-    // shapes here is what lets every consumer read `RelationMeta` without asserting.
+    // Registration writes into a map declared as resolved: `getMeta` runs `fillRelations`, which settles
+    // `references` or throws. Bridging the two shapes here is what lets every consumer read `RelationMeta`
+    // without asserting.
     const relations = meta.relations;
-    relations[key] = { ...relations[key], ...opts };
+    relations[key] = { ...relations[key], ...registration };
     return meta;
 }
 export function defineHook(entity, methodName, event) {
@@ -62,18 +85,18 @@ export function defineHook(entity, methodName, event) {
     return meta;
 }
 /**
- * Declares a composite index. `unique` and the authored column sugar are normalized here, which is what
- * lets the dialects render one shape instead of re-parsing it.
+ * Declares a composite index, its columns read off the key map. `unique` and the authored column sugar
+ * are normalized here, which is what lets the dialects render one shape instead of re-parsing it.
  */
 export function defineIndex(entity, index) {
     const meta = ensureWritableMeta(entity);
-    if (!meta.indexes)
-        meta.indexes = [];
-    meta.indexes.push({
+    const keys = keyMap();
+    (meta.indexes ??= []).push({
         ...index,
         unique: index.unique ?? false,
         where: ddlText(index.where, 'a partial-index predicate'),
-        columns: index.columns.map(normalizeIndexColumn),
+        columns: index.columns(keys).map(normalizeIndexColumn),
+        include: index.include?.(keys),
     });
     return meta;
 }
@@ -104,7 +127,7 @@ export function applyMembers(entity, specs) {
         }
     }
     for (const [key, spec] of definedEntries(specs?.relations ?? {})) {
-        defineRelation(entity, key, spec);
+        addRelation(entity, key, spec);
     }
     for (const [event, methodNames] of definedEntries(specs?.hooks ?? {})) {
         for (const methodName of methodNames) {
@@ -113,10 +136,8 @@ export function applyMembers(entity, specs) {
     }
 }
 /**
- * Registers an entity described by data alone, minting the class the registry keys it by. The row
- * type follows from the spec - see {@link SpecRow} - so a definition written out is checked column by
- * column, and one assembled at runtime is the column bag it is. Pass `Row` to name a shape the spec
- * cannot describe, such as the interface `uql-migrate types` generated for it.
+ * Registers a class as an entity from `opts` alone, the decorator-free counterpart of `@Entity()` with
+ * `@Field`/`@ManyToOne`/...
  */
 export function defineEntity(entity, opts = {}) {
     // Ahead of any registration, so a rejected definition leaves nothing half-written in the registry.
@@ -132,7 +153,12 @@ export function defineEntity(entity, opts = {}) {
     // drains `context.metadata` itself, because TypeScript only attaches `Symbol.metadata` to the class
     // after class decorators return; draining empties the bag, so whichever runs second is a no-op.
     applyMembers(entity, ownRegistrations(entity));
-    applyMembers(entity, opts);
+    const keys = keyMap();
+    applyMembers(entity, {
+        fields: opts.fields,
+        relations: Object.fromEntries(definedEntries(opts.relations ?? {}).map(([key, spec]) => [key, relationRegistration(spec)])),
+        hooks: Object.fromEntries(definedEntries(opts.hooks ?? {}).map(([event, methods]) => [event, methods(keys)])),
+    });
     // Unnamed checks are named by the generator, as unnamed indexes are.
     for (const check of opts.checks ?? []) {
         (meta.checks ??= []).push({ name: check.name, expression: ddlText(check.expression, 'a check constraint') });
@@ -267,12 +293,7 @@ export function removeEntity(entity) {
     return metas.delete(entity);
 }
 export function getEntities() {
-    return metas.entries().reduce((acc, [key, val]) => {
-        if (val.ids.length) {
-            acc.push(key);
-        }
-        return acc;
-    }, []);
+    return [...metas.values()].filter((meta) => meta.ids.length).map((meta) => meta.entity);
 }
 /**
  * The metadata of `entity`, marked as changed. Every `define*` goes through this, and nothing outside
@@ -308,11 +329,11 @@ export function getMeta(entity) {
 }
 function fillRelations(meta) {
     for (const [relKey, relation] of definedEntries(meta.relations)) {
-        // The authored view: `mappedBy` may still be the callback and `references` unset until this settles them.
+        // The registered view: `references` may be unset until this settles it.
         const relOpts = relation;
         const at = `'${meta.entity.name}.${relKey}'`;
         if (relOpts.mappedBy) {
-            fillInverseSide(at, meta, relOpts);
+            fillInverseSide(at, meta, relOpts, relOpts.mappedBy);
         }
         else if (!relOpts.references) {
             fillOwningSide(at, meta, relKey, relOpts);
@@ -326,8 +347,8 @@ function fillRelations(meta) {
             for (const { local } of relOpts.references) {
                 if (junction.fields[local])
                     continue;
-                throw new TypeError(`${at} joins through '${junction.entity.name}', which has no '${local}' field. Declare it, or name ` +
-                    "the join columns with 'references'.");
+                throw new TypeError(`${at} joins through '${junction.entity.name}', which has no '${local}' field: a junction's ` +
+                    'columns are named after the entities it joins. Declare it.');
             }
         }
     }
@@ -372,11 +393,9 @@ function fillOwningSide(at, meta, relKey, relOpts) {
         };
     }
 }
-function fillInverseSide(at, meta, relOpts) {
+function fillInverseSide(at, meta, relOpts, mappedBy) {
     const relEntity = relOpts.entity();
     const relMeta = getMeta(relEntity);
-    const mappedBy = getMappedByKey(relOpts);
-    relOpts.mappedBy = mappedBy;
     if (relOpts.references)
         return;
     if (relMeta.fields[mappedBy]) {
@@ -448,13 +467,6 @@ function fillForeignKeyRelations(meta) {
 function junctionColumn(meta, idKey) {
     return lowerFirst(entityName(meta)) + upperFirst(fieldOf(meta, idKey).name ?? idKey);
 }
-/** A callback only reads one property off the key map, and that property is the key, so one serves every entity. */
-const RELATION_KEY_MAP = new Proxy({}, { get: (_, key) => key });
-function getMappedByKey(relOpts) {
-    return typeof relOpts.mappedBy === 'function'
-        ? relOpts.mappedBy(RELATION_KEY_MAP)
-        : relOpts.mappedBy;
-}
 /** Every key the entity marks, in declaration order. More than one is a composite primary key. */
 function getIdKeys(meta) {
     return getKeys(meta.fields).filter((key) => meta.fields[key]?.isId);

package/dist/http/handler.d.ts

@@ -49,8 +49,8 @@ export type HookContext<E extends object, Ctx = unknown> = {
 export type Hook<Ctx = unknown> = <E extends object>(ctx: HookContext<E, Ctx>) => void | Promise<void>;
 export type ResponseHook<Ctx = unknown> = <E extends object>(ctx: HookContext<E, Ctx>, envelope: RequestSuccessResponse<unknown>) => void | Promise<void>;
 export type RequestHandlerOptions<Ctx = unknown> = {
-    include?: Type<any>[];
-    exclude?: Type<any>[];
+    include?: Type<object>[];
+    exclude?: Type<object>[];
     /**
      * The URL segment an entity is addressed by, defaulting to its kebab-cased class name.
      *

package/dist/http/handler.js

@@ -27,7 +27,6 @@ export function createRequestHandler(opts) {
             "A route is the kebab-cased class name unless 'entityPath' says otherwise. Name them apart, " +
             "pass an 'entityPath', or pass only one of them in 'include'.");
     }
-    // oxlint-disable-next-line typescript/no-explicit-any -- heterogeneous entity map
     const entityByPath = new Map([...byPath].map(([path, [entity]]) => [path, entity]));
     return (req) => {
         const entity = entityByPath.get(req.entityPath);

package/dist/migrate/codegen/entityCodeGenerator.js

@@ -11,7 +11,7 @@
  */
 import { canonicalToTypeScript } from '../../schema/canonicalType.js';
 import { DEFAULT_FOREIGN_KEY_ACTION, } from '../../schema/types.js';
-import { camelCase, pascalCase, singularize } from '../../util/string.util.js';
+import { camelCase, lowerFirst, pascalCase, singularize } from '../../util/string.util.js';
 import { buildFieldOptionsSource, fieldNeedsRaw } from './fieldOptionsSource.js';
 import { buildIndexDecoratorSource, indexNeedsRaw, isPlainFieldIndex } from './indexDecoratorSource.js';
 /**
@@ -116,8 +116,9 @@ export class EntityCodeGenerator {
     buildEntityDecorators(table) {
         const lines = [];
         if (this.options.includeIndexes) {
+            const param = lowerFirst(this.options.classNameTransformer(table.name));
             for (const index of this.declaredIndexes(table)) {
-                lines.push(buildIndexDecoratorSource(index, this.options.propertyNameTransformer));
+                lines.push(buildIndexDecoratorSource(index, this.options.propertyNameTransformer, param));
             }
         }
         // Entity decorator
@@ -260,9 +261,10 @@ export class EntityCodeGenerator {
             lines.push(`   * Inverse relation from ${rel.from.table.name}`);
             lines.push('   */');
         }
-        // Decorator - includes references to property name
+        // The inverse side, mapped by the related class's property that points back at this one.
         const inverseProp = this.options.propertyNameTransformer(this.options.singularize(table.name));
-        lines.push(`  @${decoratorName}({ entity: () => ${relatedClassName}, references: '${inverseProp}' })`);
+        const param = lowerFirst(relatedClassName);
+        lines.push(`  @${decoratorName}({ entity: () => ${relatedClassName}, mappedBy: (${param}) => ${param}.${inverseProp} })`);
         // Property
         if (inverseType === 'OneToMany' || inverseType === 'ManyToMany') {
             lines.push(`  ${propertyName}?: ${relatedClassName}[];`);

package/dist/migrate/codegen/entityTypes.d.ts

@@ -4,4 +4,4 @@ import type { Type } from '../../type/index.js';
  * compiler too. Interfaces, not the entity classes `generate:from-db` writes: those are the source of
  * a schema, these describe one already defined elsewhere.
  */
-export declare function entityTypesSource(entities: readonly Type<unknown>[]): string;
+export declare function entityTypesSource(entities: readonly Type<object>[]): string;

package/dist/migrate/codegen/entityTypes.js

@@ -2,6 +2,7 @@ import { getMeta } from '../../entity/index.js';
 import { canonicalToTypeScript } from '../../schema/canonicalType.js';
 import { resolveColumnCanonicalType } from '../../schema/schemaASTBuilder.js';
 import { isToManyRelation, upperFirst } from '../../util/index.js';
+import { isIdentifierName } from './sourceLiteral.js';
 /**
  * A `.d.ts` for the entities as registered, so a shape that only exists at runtime reaches the
  * compiler too. Interfaces, not the entity classes `generate:from-db` writes: those are the source of
@@ -41,12 +42,12 @@ function interfaceNames(metas) {
 }
 /** `text` as an identifier: what cannot be in one is dropped, and what cannot start one is prefixed. */
 function identifier(text) {
-    const stripped = text.replace(/[^A-Za-z0-9_$]/g, '');
-    return /^[A-Za-z_$]/.test(stripped) ? stripped : `Entity${stripped}`;
+    const stripped = text.replace(/[^\p{ID_Continue}$\u200C\u200D]/gu, '');
+    return isIdentifierName(stripped) ? stripped : `Entity${stripped}`;
 }
 /** A column name a property cannot hold - `hero-image` - is quoted rather than dropped. */
 function member(key, type) {
-    const name = key === identifier(key) ? key : JSON.stringify(key);
+    const name = isIdentifierName(key) ? key : JSON.stringify(key);
     return `  ${name}?: ${type};`;
 }
 /**

package/dist/migrate/codegen/indexDecoratorSource.d.ts

@@ -2,13 +2,14 @@ import type { IndexNode } from '../../schema/types.js';
 /**
  * Whether `@Field({ index })` can carry the whole index. It says only "this column is indexed under
  * this name", so anything else the index declares - an expression, a predicate, uniqueness, an access
- * method, stored columns, a stored order - has to be written out as `@Index([...])` instead.
+ * method, stored columns, a stored order - has to be written out as an `@Index` instead.
  */
 export declare function isPlainFieldIndex(index: IndexNode): boolean;
 /**
- * One `@Index([...])` as source, for an index no `@Field` can express. Emits `raw(...)` for an
- * expression entry, so callers import `raw` when {@link indexNeedsRaw} holds.
+ * One `@Index((user) => [...])` as source, for an index no `@Field` can express, its columns read off the
+ * key map `param` names. Emits `raw(...)` for an expression entry, so callers import `raw` when
+ * {@link indexNeedsRaw} holds.
  */
-export declare function buildIndexDecoratorSource(index: IndexNode, propertyName: (column: string) => string): string;
+export declare function buildIndexDecoratorSource(index: IndexNode, propertyName: (column: string) => string, param: string): string;
 /** Whether emitting this index needs `raw` imported alongside `Index`. */
 export declare function indexNeedsRaw(index: IndexNode): boolean;

package/dist/migrate/codegen/indexDecoratorSource.js

@@ -1,4 +1,4 @@
-import { rawTag } from './sourceLiteral.js';
+import { isIdentifierName, quoted, rawTag } from './sourceLiteral.js';
 /**
  * A vector index carries its metric in the operator class pgvector names after it
  * (`vector_cosine_ops`), which is the only place introspection can recover it from. `@Index` requires
@@ -37,7 +37,7 @@ function significantModifiers(entry) {
 /**
  * Whether `@Field({ index })` can carry the whole index. It says only "this column is indexed under
  * this name", so anything else the index declares - an expression, a predicate, uniqueness, an access
- * method, stored columns, a stored order - has to be written out as `@Index([...])` instead.
+ * method, stored columns, a stored order - has to be written out as an `@Index` instead.
  */
 export function isPlainFieldIndex(index) {
     const entries = index.entries;
@@ -53,11 +53,12 @@ export function isPlainFieldIndex(index) {
         significantModifiers(entry).length === 0);
 }
 /**
- * One `@Index([...])` as source, for an index no `@Field` can express. Emits `raw(...)` for an
- * expression entry, so callers import `raw` when {@link indexNeedsRaw} holds.
+ * One `@Index((user) => [...])` as source, for an index no `@Field` can express, its columns read off the
+ * key map `param` names. Emits `raw(...)` for an expression entry, so callers import `raw` when
+ * {@link indexNeedsRaw} holds.
  */
-export function buildIndexDecoratorSource(index, propertyName) {
-    const entries = index.entries.map((entry) => indexEntrySource(entry, propertyName)).join(', ');
+export function buildIndexDecoratorSource(index, propertyName, param) {
+    const entries = index.entries.map((entry) => indexEntrySource(entry, propertyName, param)).join(', ');
     const isVector = index.type === 'hnsw' || index.type === 'ivfflat';
     const distance = isVector ? vectorDistance(index) : undefined;
     const options = [];
@@ -77,21 +78,24 @@ export function buildIndexDecoratorSource(index, propertyName) {
     if (index.where)
         options.push(`where: ${rawTag(index.where)}`);
     if (index.include?.length) {
-        options.push(`include: [${index.include.map((column) => `'${propertyName(column)}'`).join(', ')}]`);
+        const included = index.include.map((column) => memberSource(param, propertyName(column)));
+        options.push(`include: (${param}) => [${included.join(', ')}]`);
     }
-    return `@Index([${entries}]${options.length > 0 ? `, { ${options.join(', ')} }` : ''})`;
+    return `@Index((${param}) => [${entries}]${options.length > 0 ? `, { ${options.join(', ')} }` : ''})`;
 }
 /** Whether emitting this index needs `raw` imported alongside `Index`. */
 export function indexNeedsRaw(index) {
     return Boolean(index.where) || index.entries.some((entry) => entry.expression);
 }
-function indexEntrySource(entry, propertyName) {
+function indexEntrySource(entry, propertyName, param) {
     if (entry.expression) {
         return rawTag(entry.column);
     }
+    const column = memberSource(param, propertyName(entry.column));
     const modifiers = significantModifiers(entry);
-    if (modifiers.length === 0) {
-        return `'${propertyName(entry.column)}'`;
-    }
-    return `{ column: '${propertyName(entry.column)}', ${modifiers.join(', ')} }`;
+    return modifiers.length === 0 ? column : `{ column: ${column}, ${modifiers.join(', ')} }`;
+}
+/** `user.email`, or `user['first-name']` for a property name that is no identifier. */
+function memberSource(param, property) {
+    return isIdentifierName(property) ? `${param}.${property}` : `${param}[${quoted(property)}]`;
 }

package/dist/migrate/codegen/sourceLiteral.d.ts

@@ -1,3 +1,5 @@
+/** Whether `text` can name a property unquoted, in any script: `dueño` can, `first-name` cannot. */
+export declare function isIdentifierName(text: string): boolean;
 /**
  * A string as single-quoted source. Introspected text is arbitrary - a comment or a default
  * expression can hold a quote or a backslash - and only escaping both keeps the generated file

package/dist/migrate/codegen/sourceLiteral.js

@@ -1,3 +1,7 @@
+/** Whether `text` can name a property unquoted, in any script: `dueño` can, `first-name` cannot. */
+export function isIdentifierName(text) {
+    return /^[\p{ID_Start}$_][\p{ID_Continue}$\u200C\u200D]*$/u.test(text);
+}
 /**
  * A string as single-quoted source. Introspected text is arbitrary - a comment or a default
  * expression can hold a quote or a backslash - and only escaping both keeps the generated file

package/dist/migrate/generator/mongoSchemaGenerator.d.ts

@@ -13,8 +13,8 @@ export declare class MongoSchemaGenerator extends AbstractDialect implements Sch
      * defer and no order to respect: this is each collection and nothing more. `foreignKeys` is accepted
      * and ignored for the same reason.
      */
-    generateCreateSchema(entities: readonly Type<unknown>[], options?: CreateSchemaOptions): string[];
-    generateDropSchema(entities: readonly Type<unknown>[]): string[];
+    generateCreateSchema(entities: readonly Type<object>[], options?: CreateSchemaOptions): string[];
+    generateDropSchema(entities: readonly Type<object>[]): string[];
     private selected;
     /**
      * The indexes `@Field({ index })` declares, as the collection would hold them.
@@ -48,5 +48,5 @@ export declare class MongoSchemaGenerator extends AbstractDialect implements Sch
         ifNotExists?: boolean;
     }): string[];
     generateRenameTableSql(oldName: string, newName: string): string;
-    diffSchema<E>(entity: Type<E>, currentTable: TableNode | undefined): SchemaDiff | undefined;
+    diffSchema(entity: Type<object>, currentTable: TableNode | undefined): SchemaDiff | undefined;
 }

package/dist/migrate/migrator.d.ts

@@ -12,7 +12,7 @@ export declare class Migrator {
     get logger(): LoggerWrapper;
     set logger(value: LoggingOptions);
     private readonly _entities?;
-    get entities(): Type<unknown>[];
+    get entities(): Type<object>[];
     readonly dialectName: DialectName;
     schemaGenerator?: SchemaGenerator;
     schemaIntrospector?: SchemaIntrospector;
@@ -89,7 +89,7 @@ export declare class Migrator {
      * {@link schemaIntrospector} so a caller that replaced it still wins.
      */
     private introspectClaimedSchemas;
-    findEntityForTable(tableName: string): Promise<Type<unknown> | undefined>;
+    findEntityForTable(tableName: string): Promise<Type<object> | undefined>;
     /**
      * Applies the entity schema to the database: every registered entity, or the one `entity` names.
      *

package/dist/migrate/schemaGenerator.d.ts

@@ -46,7 +46,7 @@ export declare class SqlSchemaGenerator implements SqlDdlGenerator {
     protected columnSqlType(col: ColumnNode): string;
     protected canonicalTypeToSql(type: CanonicalType): string;
     /** The entity side as an AST, carrying this generator's default referential action. */
-    buildAST(entities: readonly Type<unknown>[]): SchemaAST;
+    buildAST(entities: readonly Type<object>[]): SchemaAST;
     /**
      * Every `CREATE TABLE` for `entities`, then their foreign keys.
      *
@@ -56,14 +56,14 @@ export declare class SqlSchemaGenerator implements SqlDdlGenerator {
      * then `createForeignKeys()`). SQLite is the exception and keeps them inline: it cannot `ALTER` a
      * foreign key in, but it resolves targets lazily, so a forward reference is fine there.
      */
-    generateCreateSchema(entities: readonly Type<unknown>[], options?: CreateSchemaOptions): string[];
+    generateCreateSchema(entities: readonly Type<object>[], options?: CreateSchemaOptions): string[];
     /**
      * One statement per distinct schema the tables being created live in, in first-seen order. Only
      * the tables actually being created, so a narrowed `only` does not declare namespaces it is not
      * about to fill. Empty on an engine without schemas, whose tables are never qualified.
      */
     private generateCreateSchemas;
-    generateDropSchema(entities: readonly Type<unknown>[], options?: DropSchemaOptions): string[];
+    generateDropSchema(entities: readonly Type<object>[], options?: DropSchemaOptions): string[];
     /**
      * The tables of `entities` in dependency order, optionally narrowed to `only`. The AST always spans
      * every entity even when narrowed, so a relation pointing at a table outside the subset still
@@ -132,7 +132,7 @@ export declare class SqlSchemaGenerator implements SqlDdlGenerator {
      * longer disagree about what has changed. Only two things are this side's own: the entity becomes a
      * table node first, and types are compared as the *engine* would store them - see `normalizeType`.
      */
-    diffSchema<E>(entity: Type<E>, currentTable: TableNode | undefined, desiredAst?: SchemaAST): SchemaDiff | undefined;
+    diffSchema(entity: Type<object>, currentTable: TableNode | undefined, desiredAst?: SchemaAST): SchemaDiff | undefined;
     /**
      * Indexes the entity declares that the table does not already have, in any shape.
      *
@@ -217,7 +217,7 @@ export declare class SqlSchemaGenerator implements SqlDdlGenerator {
  * other way and the table is created under one name and compared under another, which reports every
  * table of a project using a naming strategy as both missing and unexpected.
  */
-export declare function buildEntityAST(generator: Pick<SchemaGenerator, 'resolveTableAlias' | 'resolveSchema' | 'resolveColumnName'>, entities: readonly Type<unknown>[], defaultForeignKeyAction?: ForeignKeyAction): SchemaAST;
+export declare function buildEntityAST(generator: Pick<SchemaGenerator, 'resolveTableAlias' | 'resolveSchema' | 'resolveColumnName'>, entities: readonly Type<object>[], defaultForeignKeyAction?: ForeignKeyAction): SchemaAST;
 /**
  * Synchronous factory for SQL schema generators only.
  * For MongoDB, use `createSchemaGeneratorAsync` from `./schemaGeneratorAsync.js` so the optional `mongodb` peer is not loaded at import time.

package/dist/mongo/mongoDialect.d.ts

@@ -152,7 +152,7 @@ export declare class MongoDialect extends AbstractDialect {
     /** Whether a `$sort` reads a relation, which is what forces the lookups to run before it. */
     sortsRelations<E extends Document>(entity: Type<E>, sort: QuerySortMap<E> | undefined): boolean;
     /**
-     * Aggregate results are keyed by `$group`/`$agg` alias rather than by column, so an aggregate
+     * Aggregate results are keyed by `$group`/`$select` alias rather than by column, so an aggregate
      * `$sort` addresses those aliases as-is - the same reason the SQL dialects sort by alias there.
      */
     private aliasSort;

package/dist/mongo/mongoDialect.js

@@ -551,7 +551,7 @@ export class MongoDialect extends AbstractDialect {
         return someKey(sort, (key) => Boolean(meta.relations[key]));
     }
     /**
-     * Aggregate results are keyed by `$group`/`$agg` alias rather than by column, so an aggregate
+     * Aggregate results are keyed by `$group`/`$select` alias rather than by column, so an aggregate
      * `$sort` addresses those aliases as-is - the same reason the SQL dialects sort by alias there.
      */
     aliasSort(sort) {
@@ -958,7 +958,7 @@ export class MongoDialect extends AbstractDialect {
             }
         }
         // $group stage
-        const { groupId, groupAccumulators, distinctReducers } = this.buildGroupSpec(getMeta(entity), parseGroupMap(q.$group, q.$agg));
+        const { groupId, groupAccumulators, distinctReducers } = this.buildGroupSpec(getMeta(entity), parseGroupMap(q.$group, q.$select));
         pipeline.push({ $group: { _id: hasKeys(groupId) ? groupId : null, ...groupAccumulators } });
         // Project stage - rename _id fields back to their original names, and reduce collected distinct
         // sets. Needed whenever there are group keys OR any distinct alias.
@@ -1008,7 +1008,7 @@ export class MongoDialect extends AbstractDialect {
      */
     buildGroupSpec(meta, groupEntries) {
         if (!groupEntries.length) {
-            throw new TypeError('aggregate requires at least one $group column or $agg function');
+            throw new TypeError('aggregate requires at least one $group column or $select function');
         }
         const groupId = {};
         const groupAccumulators = {};

package/dist/mongo/mongodbQuerier.js

@@ -126,7 +126,6 @@ export class MongodbQuerier extends AbstractQuerier {
     async internalAggregate(entity, q, opts) {
         return this.timed('internalAggregate', undefined, async () => {
             const pipeline = this.dialect.buildAggregateStages(entity, q, opts);
-            // oxlint-disable-next-line typescript/no-explicit-any -- aggregate result type matches QueryAggregateResult at runtime but TS can't verify
             return this.execute((session) => this.collection(entity).aggregate(pipeline, { session }).toArray());
         });
     }

package/dist/querier/abstractSqlQuerier.js

@@ -329,17 +329,17 @@ export class AbstractSqlQuerier extends AbstractQuerier {
     async internalAggregate(entity, q, opts) {
         const ctx = this.dialect.createContext();
         this.dialect.aggregate(ctx, entity, q, opts);
-        // oxlint-disable-next-line typescript/no-explicit-any -- raw DB rows satisfy QueryAggregateResult at runtime but TS can't verify
-        const res = await this.all(ctx.sql, ctx.values);
+        const rows = await this.all(ctx.sql, ctx.values);
         const hydratable = this.dialect.hydratableAggregates(entity, q);
-        for (const row of res) {
+        for (const row of rows) {
+            const cells = row;
             for (const [alias, kind] of hydratable) {
-                if (row[alias] != null) {
-                    row[alias] = decodeColumn(row[alias], kind);
+                if (cells[alias] != null) {
+                    cells[alias] = decodeColumn(cells[alias], kind);
                 }
             }
         }
-        return res;
+        return rows;
     }
     async internalInsertMany(entity, rows) {
         const meta = getMeta(entity);

package/dist/schema/schemaASTBuilder.d.ts

@@ -15,9 +15,9 @@ import { type CanonicalType, type ForeignKeyAction } from './types.js';
  */
 export interface BuildSchemaASTOptions {
     /** Custom resolver for a table's own name, unqualified. */
-    resolveTableName?: (meta: EntityMeta<unknown>) => string;
+    resolveTableName?: (meta: EntityMeta<object>) => string;
     /** Custom resolver for the schema a table lives in; `undefined` leaves it unqualified. */
-    resolveSchema?: (meta: EntityMeta<unknown>) => string | undefined;
+    resolveSchema?: (meta: EntityMeta<object>) => string | undefined;
     /** Custom column name resolver */
     resolveColumnName?: (key: string, field: FieldOptions) => string;
     /** Naming strategy to use */
@@ -31,7 +31,7 @@ export interface BuildSchemaASTOptions {
  * Three passes, because each needs the one before it to have finished for *every* entity: a relation
  * resolves against a table another entity declares, and an index against the columns of its own.
  */
-export declare function buildSchemaAST(entities: readonly Type<unknown>[], options?: BuildSchemaASTOptions): SchemaAST;
+export declare function buildSchemaAST(entities: readonly Type<object>[], options?: BuildSchemaASTOptions): SchemaAST;
 /**
  * Resolve the canonical type for a field, inheriting from the referenced
  * entity's primary key when the field is a foreign-key reference

package/dist/schema/schemaASTBuilder.js

@@ -168,7 +168,7 @@ function addRelationshipsFromEntity(ctx, meta) {
     }
 }
 /**
- * Add indexes from field options (`@Field({ index })`), from `@Index([...])`, and for every foreign
+ * Add indexes from field options (`@Field({ index })`), from `@Index`, and for every foreign
  * key none of those already serves.
  */
 function addIndexesFromEntity(ctx, meta) {
@@ -230,7 +230,7 @@ function resolveIncludeColumn(ctx, meta, column) {
     return field ? ctx.resolveColumnName(column, field) : column;
 }
 /**
- * One `@Index([...])`. Its entries keep the authored form (expression, prefix length, order) with
+ * One `@Index`. Its entries keep the authored form (expression, prefix length, order) with
  * names resolved, so the generator renders exactly what was declared; `columns` is the resolvable
  * subset, which is what diffing and introspection compare.
  */

package/dist/type/config.d.ts

@@ -17,7 +17,7 @@ export interface Config {
      * List of entity classes to be managed by the ORM.
      * If omitted, classes that completed `defineEntity` (including via `@Entity()`) are discovered via `getEntities()`.
      */
-    entities?: Type<unknown>[];
+    entities?: Type<object>[];
     /**
      * The directory where migration files are stored.
      * @default './migrations'