@mikro-orm/knex 6.2.10-dev.1 → 6.2.10-dev.100

package/AbstractSqlDriver.d.ts

@@ -20,7 +20,7 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     countVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: CountOptions<T, any>): Promise<number>;
     protected findFromVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: FindOptions<T, any> | CountOptions<T, any>, type: QueryType): Promise<EntityData<T>[] | number>;
     protected wrapVirtualExpressionInSubquery<T extends object>(meta: EntityMetadata<T>, expression: string, where: FilterQuery<T>, options: FindOptions<T, any>, type: QueryType): Promise<T[] | number>;
-    mapResult<T extends object>(result: EntityData<T>, meta: EntityMetadata<T>, populate?: PopulateOptions<T>[], qb?: QueryBuilder<T>, map?: Dictionary): EntityData<T> | null;
+    mapResult<T extends object>(result: EntityData<T>, meta: EntityMetadata<T>, populate?: PopulateOptions<T>[], qb?: QueryBuilder<T, any, any, any>, map?: Dictionary): EntityData<T> | null;
     private mapJoinedProps;
     count<T extends object>(entityName: string, where: any, options?: CountOptions<T>): Promise<number>;
     nativeInsert<T extends object>(entityName: string, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
@@ -52,16 +52,16 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
      * @internal
      */
     mergeJoinedResult<T extends object>(rawResults: EntityData<T>[], meta: EntityMetadata<T>, joinedProps: PopulateOptions<T>[]): EntityData<T>[];
-    protected getFieldsForJoinedLoad<T extends object>(qb: QueryBuilder<T>, meta: EntityMetadata<T>, explicitFields?: Field<T>[], exclude?: Field<T>[], populate?: PopulateOptions<T>[], options?: {
+    protected getFieldsForJoinedLoad<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, explicitFields?: Field<T>[], exclude?: Field<T>[], populate?: PopulateOptions<T>[], options?: {
         strategy?: Options['loadStrategy'];
         populateWhere?: FindOptions<any>['populateWhere'];
     }, parentTableAlias?: string, parentJoinPath?: string): Field<T>[];
     /**
      * @internal
      */
-    mapPropToFieldNames<T extends object>(qb: QueryBuilder<T>, prop: EntityProperty<T>, tableAlias?: string): Field<T>[];
+    mapPropToFieldNames<T extends object>(qb: QueryBuilder<T, any, any, any>, prop: EntityProperty<T>, tableAlias?: string): Field<T>[];
     /** @internal */
-    createQueryBuilder<T extends object>(entityName: EntityName<T> | QueryBuilder<T>, ctx?: Transaction<Knex.Transaction>, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean, loggerContext?: LoggingOptions, alias?: string, em?: SqlEntityManager): QueryBuilder<T>;
+    createQueryBuilder<T extends object>(entityName: EntityName<T> | QueryBuilder<T, any, any, any>, ctx?: Transaction<Knex.Transaction>, preferredConnectionType?: ConnectionType, convertCustomTypes?: boolean, loggerContext?: LoggingOptions, alias?: string, em?: SqlEntityManager): QueryBuilder<T, any, any, any>;
     protected resolveConnectionType(args: {
         ctx?: Transaction<Knex.Transaction>;
         connectionType?: ConnectionType;
@@ -70,10 +70,10 @@ export declare abstract class AbstractSqlDriver<Connection extends AbstractSqlCo
     protected processManyToMany<T extends object>(meta: EntityMetadata<T> | undefined, pks: Primary<T>[], collections: EntityData<T>, clear: boolean, options?: DriverMethodOptions): Promise<void>;
     lockPessimistic<T extends object>(entity: T, options: LockOptions): Promise<void>;
     protected buildPopulateWhere<T extends object>(meta: EntityMetadata<T>, joinedProps: PopulateOptions<T>[], options: Pick<FindOptions<any>, 'populateWhere'>): ObjectQuery<T>;
-    protected buildOrderBy<T extends object>(qb: QueryBuilder<T>, meta: EntityMetadata<T>, populate: PopulateOptions<T>[], options: Pick<FindOptions<any>, 'strategy' | 'orderBy' | 'populateOrderBy'>): QueryOrderMap<T>[];
-    protected buildPopulateOrderBy<T extends object>(qb: QueryBuilder<T>, meta: EntityMetadata<T>, populateOrderBy: QueryOrderMap<T>[], parentPath: string, explicit: boolean, parentAlias?: string): QueryOrderMap<T>[];
-    protected buildJoinedPropsOrderBy<T extends object>(qb: QueryBuilder<T>, meta: EntityMetadata<T>, populate: PopulateOptions<T>[], options?: Pick<FindOptions<any>, 'strategy' | 'orderBy' | 'populateOrderBy'>, parentPath?: string): QueryOrderMap<T>[];
+    protected buildOrderBy<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, populate: PopulateOptions<T>[], options: Pick<FindOptions<any>, 'strategy' | 'orderBy' | 'populateOrderBy'>): QueryOrderMap<T>[];
+    protected buildPopulateOrderBy<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, populateOrderBy: QueryOrderMap<T>[], parentPath: string, explicit: boolean, parentAlias?: string): QueryOrderMap<T>[];
+    protected buildJoinedPropsOrderBy<T extends object>(qb: QueryBuilder<T, any, any, any>, meta: EntityMetadata<T>, populate: PopulateOptions<T>[], options?: Pick<FindOptions<any>, 'strategy' | 'orderBy' | 'populateOrderBy'>, parentPath?: string): QueryOrderMap<T>[];
     protected normalizeFields<T extends object>(fields: Field<T>[], prefix?: string): string[];
-    protected processField<T extends object>(meta: EntityMetadata<T>, prop: EntityProperty<T> | undefined, field: string, ret: Field<T>[], populate: PopulateOptions<T>[], joinedProps: PopulateOptions<T>[], qb: QueryBuilder<T>): void;
-    protected buildFields<T extends object>(meta: EntityMetadata<T>, populate: PopulateOptions<T>[], joinedProps: PopulateOptions<T>[], qb: QueryBuilder<T>, alias: string, options: Pick<FindOptions<T, any, any, any>, 'strategy' | 'fields' | 'exclude'>): Field<T>[];
+    protected processField<T extends object>(meta: EntityMetadata<T>, prop: EntityProperty<T> | undefined, field: string, ret: Field<T>[], populate: PopulateOptions<T>[], joinedProps: PopulateOptions<T>[], qb: QueryBuilder<T, any, any, any>): void;
+    protected buildFields<T extends object>(meta: EntityMetadata<T>, populate: PopulateOptions<T>[], joinedProps: PopulateOptions<T>[], qb: QueryBuilder<T, any, any, any>, alias: string, options: Pick<FindOptions<T, any, any, any>, 'strategy' | 'fields' | 'exclude'>): Field<T>[];
 }

package/AbstractSqlDriver.js

@@ -538,7 +538,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         let sql = `update ${this.getTableName(meta, options)} set `;
         const addParams = (prop, value) => {
             if (prop.kind === core_1.ReferenceKind.EMBEDDED && prop.object) {
-                if (prop.array) {
+                if (prop.array && value) {
                     for (let i = 0; i < value.length; i++) {
                         const item = value[i];
                         value[i] = this.mapDataToFieldNames(item, false, prop.embeddedProps, options.convertCustomTypes);
@@ -1099,9 +1099,12 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
                 if (!prop) {
                     throw new Error(`Trying to order by not existing property ${meta.className}.${propName}`);
                 }
+                let path = parentPath;
                 const meta2 = this.metadata.find(prop.type);
                 const childOrder = orderHint[prop.name];
-                let path = `${parentPath}.${propName}`;
+                if (![core_1.ReferenceKind.MANY_TO_ONE, core_1.ReferenceKind.ONE_TO_ONE].includes(prop.kind) || !prop.owner || core_1.Utils.isPlainObject(childOrder)) {
+                    path += `.${propName}`;
+                }
                 if (prop.kind === core_1.ReferenceKind.MANY_TO_MANY && typeof childOrder !== 'object') {
                     path += '[pivot]';
                 }

package/PivotCollectionPersister.d.ts

@@ -1,4 +1,4 @@
-import { type EntityMetadata, type EntityProperty, type Primary } from '@mikro-orm/core';
+import { type EntityMetadata, type EntityProperty, type Primary, type Transaction } from '@mikro-orm/core';
 import { type AbstractSqlDriver } from './AbstractSqlDriver';
 export declare class PivotCollectionPersister<Entity extends object> {
     private readonly meta;
@@ -10,7 +10,7 @@ export declare class PivotCollectionPersister<Entity extends object> {
     private readonly deletes;
     private readonly batchSize;
     private order;
-    constructor(meta: EntityMetadata<Entity>, driver: AbstractSqlDriver, ctx?: any, schema?: string | undefined);
+    constructor(meta: EntityMetadata<Entity>, driver: AbstractSqlDriver, ctx?: Transaction | undefined, schema?: string | undefined);
     enqueueUpdate(prop: EntityProperty<Entity>, insertDiff: Primary<Entity>[][], deleteDiff: Primary<Entity>[][] | boolean, pks: Primary<Entity>[]): void;
     private enqueueInsert;
     private enqueueDelete;

package/SqlEntityManager.d.ts

@@ -10,11 +10,11 @@ export declare class SqlEntityManager<Driver extends AbstractSqlDriver = Abstrac
     /**
      * Creates a QueryBuilder instance
      */
-    createQueryBuilder<T extends object>(entityName: EntityName<T> | QueryBuilder<T>, alias?: string, type?: ConnectionType, loggerContext?: LoggingOptions): QueryBuilder<T>;
+    createQueryBuilder<Entity extends object, RootAlias extends string = never>(entityName: EntityName<Entity> | QueryBuilder<Entity>, alias?: RootAlias, type?: ConnectionType, loggerContext?: LoggingOptions): QueryBuilder<Entity, RootAlias>;
     /**
      * Shortcut for `createQueryBuilder()`
      */
-    qb<T extends object>(entityName: EntityName<T>, alias?: string, type?: ConnectionType, loggerContext?: LoggingOptions): QueryBuilder<T>;
+    qb<Entity extends object, RootAlias extends string = never>(entityName: EntityName<Entity>, alias?: RootAlias, type?: ConnectionType, loggerContext?: LoggingOptions): QueryBuilder<Entity, RootAlias, never, never>;
     /**
      * Returns configured knex instance.
      */

package/SqlEntityRepository.d.ts

@@ -2,17 +2,17 @@ import type { Knex } from 'knex';
 import { EntityRepository, type ConnectionType, type EntityName } from '@mikro-orm/core';
 import type { SqlEntityManager } from './SqlEntityManager';
 import type { QueryBuilder } from './query';
-export declare class SqlEntityRepository<T extends object> extends EntityRepository<T> {
+export declare class SqlEntityRepository<Entity extends object> extends EntityRepository<Entity> {
     protected readonly em: SqlEntityManager;
-    constructor(em: SqlEntityManager, entityName: EntityName<T>);
+    constructor(em: SqlEntityManager, entityName: EntityName<Entity>);
     /**
      * Creates a QueryBuilder instance
      */
-    createQueryBuilder(alias?: string): QueryBuilder<T>;
+    createQueryBuilder<RootAlias extends string = never>(alias?: RootAlias): QueryBuilder<Entity, RootAlias>;
     /**
      * Shortcut for `createQueryBuilder()`
      */
-    qb(alias?: string): QueryBuilder<T>;
+    qb<RootAlias extends string = never>(alias?: RootAlias): QueryBuilder<Entity, RootAlias>;
     /**
      * Returns configured knex instance.
      */

package/dialects/mysql/MySqlSchemaHelper.js

@@ -46,7 +46,7 @@ class MySqlSchemaHelper extends SchemaHelper_1.SchemaHelper {
         }
     }
     async getAllIndexes(connection, tables) {
-        const sql = `select table_name as table_name, nullif(table_schema, schema()) as schema_name, index_name as index_name, non_unique as non_unique, column_name as column_name, expression as expression
+        const sql = `select table_name as table_name, nullif(table_schema, schema()) as schema_name, index_name as index_name, non_unique as non_unique, column_name as column_name /*!80013 , expression as expression */
         from information_schema.statistics where table_schema = database()
         and table_name in (${tables.map(t => this.platform.quoteValue(t.table_name)).join(', ')})
         order by schema_name, table_name, index_name, seq_in_index`;
@@ -78,7 +78,7 @@ class MySqlSchemaHelper extends SchemaHelper_1.SchemaHelper {
       nullif(table_schema, schema()) as schema_name,
       column_name as column_name,
       column_default as column_default,
-      column_comment as column_comment,
+      nullif(column_comment, '') as column_comment,
       is_nullable as is_nullable,
       data_type as data_type,
       column_type as column_type,

package/dialects/sqlite/BaseSqlitePlatform.d.ts

@@ -30,6 +30,9 @@ export declare abstract class BaseSqlitePlatform extends AbstractSqlPlatform {
     }): string;
     getFloatDeclarationSQL(): string;
     getBooleanTypeDeclarationSQL(): string;
+    getCharTypeDeclarationSQL(column: {
+        length?: number;
+    }): string;
     getVarcharTypeDeclarationSQL(column: {
         length?: number;
     }): string;

package/dialects/sqlite/BaseSqlitePlatform.js

@@ -38,6 +38,9 @@ class BaseSqlitePlatform extends AbstractSqlPlatform_1.AbstractSqlPlatform {
     getBooleanTypeDeclarationSQL() {
         return 'integer';
     }
+    getCharTypeDeclarationSQL(column) {
+        return 'text';
+    }
     getVarcharTypeDeclarationSQL(column) {
         return 'text';
     }

package/dialects/sqlite/BaseSqliteSchemaHelper.d.ts

@@ -1,7 +1,7 @@
 import type { Connection, Dictionary } from '@mikro-orm/core';
 import type { AbstractSqlConnection } from '../../AbstractSqlConnection';
 import { SchemaHelper } from '../../schema/SchemaHelper';
-import type { CheckDef, Column, IndexDef } from '../../typings';
+import type { CheckDef, Column, IndexDef, TableDifference } from '../../typings';
 export declare abstract class BaseSqliteSchemaHelper extends SchemaHelper {
     disableForeignKeysSQL(): string;
     enableForeignKeysSQL(): string;
@@ -24,4 +24,5 @@ export declare abstract class BaseSqliteSchemaHelper extends SchemaHelper {
      * Implicit indexes will be ignored when diffing
      */
     isImplicitIndex(name: string): boolean;
+    getAlterTable(changedTable: TableDifference, wrap?: boolean): Promise<string>;
 }

package/dialects/sqlite/BaseSqliteSchemaHelper.js

@@ -168,5 +168,22 @@ class BaseSqliteSchemaHelper extends SchemaHelper_1.SchemaHelper {
         // Ignore indexes with reserved names, e.g. autoindexes
         return name.startsWith('sqlite_');
     }
+    async getAlterTable(changedTable, wrap) {
+        wrap ??= this.options.disableForeignKeys;
+        const tempName = `${(changedTable.toTable.name)}__temp_alter`;
+        const quotedName = this.platform.quoteIdentifier(changedTable.toTable.name);
+        const quotedTempName = this.platform.quoteIdentifier(tempName);
+        const createSql = await this.dump(this.createTable(changedTable.toTable), '');
+        const [first, ...rest] = createSql.split('\n');
+        return [
+            'pragma foreign_keys = off;',
+            first.replace(`create table ${quotedName}`, `create table ${quotedTempName}`),
+            `insert into ${quotedTempName} select * from ${quotedName};`,
+            `drop table ${quotedName};`,
+            `alter table ${quotedTempName} rename to ${quotedName};`,
+            ...rest,
+            'pragma foreign_keys = on;',
+        ].join('\n');
+    }
 }
 exports.BaseSqliteSchemaHelper = BaseSqliteSchemaHelper;

package/dialects/sqlite/LibSqlKnexDialect.d.ts

@@ -2,5 +2,10 @@ import { MonkeyPatchable } from '../../MonkeyPatchable';
 export declare class LibSqlKnexDialect extends MonkeyPatchable.BetterSqlite3Dialect {
     get driverName(): string;
     _driver(): any;
+    _query(this: any, connection: any, obj: any): Promise<any>;
+    acquireRawConnection(this: any): Promise<any>;
     tableCompiler(): any;
+    validateConnection(connection: any): boolean;
+    private getCallMethod;
+    private isRunQuery;
 }

package/dialects/sqlite/LibSqlKnexDialect.js

@@ -10,9 +10,76 @@ class LibSqlKnexDialect extends MonkeyPatchable_1.MonkeyPatchable.BetterSqlite3D
     _driver() {
         return require('libsql');
     }
+    async _query(connection, obj) {
+        /* istanbul ignore next */
+        if (!obj.sql) {
+            throw new Error('The query is empty');
+        }
+        /* istanbul ignore next */
+        if (!connection) {
+            throw new Error('No connection provided');
+        }
+        const callMethod = this.getCallMethod(obj);
+        const statement = connection.prepare(obj.sql);
+        const bindings = this._formatBindings(obj.bindings);
+        const response = await statement[callMethod](bindings);
+        obj.response = response;
+        obj.context = {
+            lastID: response.lastInsertRowid,
+            changes: response.changes,
+        };
+        return obj;
+    }
+    async acquireRawConnection() {
+        const connection = new this.driver(this.connectionSettings.filename, {
+            ...this.connectionSettings,
+        });
+        connection.__created = Date.now();
+        return connection;
+    }
     tableCompiler() {
         // eslint-disable-next-line prefer-rest-params
         return new SqliteTableCompiler_1.SqliteTableCompiler(this, ...arguments);
     }
+    validateConnection(connection) {
+        if (connection.memory) {
+            return true;
+        }
+        /* istanbul ignore next */
+        return connection.__created > Date.now() - 10_000;
+    }
+    getCallMethod(obj) {
+        if (obj.method === 'raw') {
+            const query = obj.sql.trim().toLowerCase();
+            if ((query.startsWith('insert into') || query.startsWith('update ')) && query.includes(' returning ')) {
+                return 'all';
+            }
+            if (this.isRunQuery(query)) {
+                return 'run';
+            }
+        }
+        /* istanbul ignore next */
+        switch (obj.method) {
+            case 'insert':
+            case 'update':
+                return obj.returning ? 'all' : 'run';
+            case 'counter':
+            case 'del':
+                return 'run';
+            default:
+                return 'all';
+        }
+    }
+    isRunQuery(query) {
+        query = query.trim().toLowerCase();
+        /* istanbul ignore next */
+        if ((query.startsWith('insert into') || query.startsWith('update ')) && query.includes(' returning ')) {
+            return false;
+        }
+        return query.startsWith('insert into') ||
+            query.startsWith('update') ||
+            query.startsWith('delete') ||
+            query.startsWith('truncate');
+    }
 }
 exports.LibSqlKnexDialect = LibSqlKnexDialect;

package/index.mjs

@@ -33,6 +33,7 @@ export const ChangeSet = mod.ChangeSet;
 export const ChangeSetComputer = mod.ChangeSetComputer;
 export const ChangeSetPersister = mod.ChangeSetPersister;
 export const ChangeSetType = mod.ChangeSetType;
+export const CharacterType = mod.CharacterType;
 export const Check = mod.Check;
 export const CheckConstraintViolationException = mod.CheckConstraintViolationException;
 export const Collection = mod.Collection;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "6.2.10-dev.1",
+  "version": "6.2.10-dev.100",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "main": "index.js",
   "module": "index.mjs",
@@ -66,7 +66,7 @@
     "@mikro-orm/core": "^6.2.9"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "6.2.10-dev.1",
+    "@mikro-orm/core": "6.2.10-dev.100",
     "better-sqlite3": "*",
     "libsql": "*",
     "mariadb": "*"

package/query/CriteriaNode.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { inspect } from 'util';
 import { type EntityKey, type EntityProperty, type MetadataStorage } from '@mikro-orm/core';
 import type { ICriteriaNode, ICriteriaNodeProcessOptions, IQueryBuilder } from '../typings';

package/query/ObjectCriteriaNode.js

@@ -70,7 +70,8 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
             const primaryKey = this.key && this.metadata.find(this.entityName).primaryKeys.includes(field);
             if (childNode.shouldInline(payload)) {
                 const childAlias = qb.getAliasForJoinPath(childNode.getPath(), options);
-                this.inlineChildPayload(o, payload, field, alias, childAlias);
+                const a = qb.helper.isTableNameAliasRequired(qb.type) ? alias : undefined;
+                this.inlineChildPayload(o, payload, field, a, childAlias);
             }
             else if (childNode.shouldRename(payload)) {
                 o[childNode.renameFieldToPK(qb)] = payload;
@@ -149,7 +150,6 @@ class ObjectCriteriaNode extends CriteriaNode_1.CriteriaNode {
                 o[k] = payload[k];
             }
             else {
-                o[`${childAlias}.${k}`] = payload[k];
                 o[this.aliased(k, childAlias)] = payload[k];
             }
         }