@mikro-orm/knex 5.0.0-rc.1 → 6.0.0-dev.0

package/{AbstractSqlDriver.d.ts → dist/AbstractSqlDriver.d.ts}

@@ -23,7 +23,6 @@ export declare abstract class AbstractSqlDriver<C extends AbstractSqlConnection
     nativeInsert<T extends AnyEntity<T>>(entityName: string, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
     nativeInsertMany<T extends AnyEntity<T>>(entityName: string, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
     nativeUpdate<T extends AnyEntity<T>>(entityName: string, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
-    private getSchemaName;
     nativeUpdateMany<T extends AnyEntity<T>>(entityName: string, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
     nativeDelete<T extends AnyEntity<T>>(entityName: string, where: FilterQuery<T> | string | any, options?: DeleteOptions<T>): Promise<QueryResult<T>>;
     syncCollection<T extends AnyEntity<T>, O extends AnyEntity<O>>(coll: Collection<T, O>, options?: DriverMethodOptions): Promise<void>;
@@ -47,7 +46,9 @@ export declare abstract class AbstractSqlDriver<C extends AbstractSqlConnection
     protected createQueryBuilder<T extends AnyEntity<T>>(entityName: string, ctx?: Transaction<Knex.Transaction>, write?: boolean, convertCustomTypes?: boolean): QueryBuilder<T>;
     protected extractManyToMany<T extends AnyEntity<T>>(entityName: string, data: EntityDictionary<T>): EntityData<T>;
     protected processManyToMany<T extends AnyEntity<T>>(meta: EntityMetadata<T> | undefined, pks: Primary<T>[], collections: EntityData<T>, clear: boolean, options?: DriverMethodOptions): Promise<void>;
-    protected updateCollectionDiff<T extends AnyEntity<T>, O extends AnyEntity<O>>(meta: EntityMetadata<O>, prop: EntityProperty<T>, pks: Primary<O>[], deleteDiff: Primary<T>[][] | boolean, insertDiff: Primary<T>[][], options?: DriverMethodOptions): Promise<void>;
+    protected updateCollectionDiff<T extends AnyEntity<T>, O extends AnyEntity<O>>(meta: EntityMetadata<O>, prop: EntityProperty<T>, pks: Primary<O>[], deleteDiff: Primary<T>[][] | boolean, insertDiff: Primary<T>[][], options?: DriverMethodOptions & {
+        ownerSchema?: string;
+    }): Promise<void>;
     lockPessimistic<T extends AnyEntity<T>>(entity: T, options: LockOptions): Promise<void>;
     protected buildJoinedPropsOrderBy<T extends AnyEntity<T>>(entityName: string, qb: QueryBuilder<T>, meta: EntityMetadata<T>, populate: PopulateOptions<T>[], parentPath?: string): QueryOrderMap<T>[];
     protected buildFields<T extends AnyEntity<T>>(meta: EntityMetadata<T>, populate: PopulateOptions<T>[], joinedProps: PopulateOptions<T>[], qb: QueryBuilder<T>, fields?: Field<T>[]): Field<T>[];

package/{AbstractSqlDriver.js → dist/AbstractSqlDriver.js}

@@ -183,7 +183,7 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             res = await this.rethrow(qb.insert(data).execute('run', false));
         }
         else {
-            let sql = `insert into ${(this.getTableName(meta, options))} `;
+            let sql = `insert into ${this.getTableName(meta, options)} `;
             /* istanbul ignore next */
             sql += fields.length > 0 ? '(' + fields.map(k => this.platform.quoteIdentifier(k)).join(', ') + ')' : 'default';
             sql += ` values `;
@@ -252,10 +252,6 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         await this.processManyToMany(meta, pk, collections, true, options);
         return res;
     }
-    getSchemaName(meta, options) {
-        /* istanbul ignore next */
-        return options?.schema === '*' ? this.config.get('schema') : options?.schema ?? (meta?.schema === '*' ? this.config.get('schema') : meta?.schema);
-    }
     async nativeUpdateMany(entityName, where, data, options = {}) {
         options.processCollections ?? (options.processCollections = true);
         options.convertCustomTypes ?? (options.convertCustomTypes = true);
@@ -350,11 +346,20 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
         if (coll.property.reference === core_1.ReferenceType.ONE_TO_MANY) {
             const cols = coll.property.referencedColumnNames;
             const qb = this.createQueryBuilder(coll.property.type, ctx, true)
+                .withSchema(this.getSchemaName(meta, options))
                 .update({ [coll.property.mappedBy]: pks })
                 .getKnexQuery()
                 .whereIn(cols, insertDiff);
             return this.rethrow(this.execute(qb));
         }
+        /* istanbul ignore next */
+        const ownerSchema = wrapped.getSchema() === '*' ? this.config.get('schema') : wrapped.getSchema();
+        const pivotMeta = this.metadata.find(coll.property.pivotTable);
+        if (pivotMeta.schema === '*') {
+            /* istanbul ignore next */
+            options ?? (options = {});
+            options.schema = ownerSchema;
+        }
         return this.rethrow(this.updateCollectionDiff(meta, coll.property, pks, deleteDiff, insertDiff, options));
     }
     async loadFromPivotTable(prop, owners, where = {}, orderBy, ctx, options) {
@@ -369,7 +374,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             where = { ...where, ...cond };
         }
         orderBy = this.getPivotOrderBy(prop, orderBy);
-        const qb = this.createQueryBuilder(prop.type, ctx, !!ctx).unsetFlag(core_1.QueryFlag.CONVERT_CUSTOM_TYPES).withSchema(options?.schema);
+        const qb = this.createQueryBuilder(prop.type, ctx, !!ctx)
+            .unsetFlag(core_1.QueryFlag.CONVERT_CUSTOM_TYPES)
+            .withSchema(this.getSchemaName(prop.targetMeta, options));
         const populate = this.autoJoinOneToOneOwner(prop.targetMeta, [{ field: prop.pivotTable }]);
         const fields = this.buildFields(prop.targetMeta, (options?.populate ?? []), [], qb, options?.fields);
         qb.select(fields).populate(populate).where(where).orderBy(orderBy).setLockMode(options?.lockMode, options?.lockTableAliases);
@@ -534,7 +541,9 @@ class AbstractSqlDriver extends core_1.DatabaseDriver {
             deleteDiff = [];
         }
         if (deleteDiff === true || deleteDiff.length > 0) {
-            const qb1 = this.createQueryBuilder(prop.pivotTable, options?.ctx, true).withSchema(this.getSchemaName(meta, options)).unsetFlag(core_1.QueryFlag.CONVERT_CUSTOM_TYPES);
+            const qb1 = this.createQueryBuilder(prop.pivotTable, options?.ctx, true)
+                .withSchema(this.getSchemaName(meta, options))
+                .unsetFlag(core_1.QueryFlag.CONVERT_CUSTOM_TYPES);
             const knex = qb1.getKnex();
             if (Array.isArray(deleteDiff)) {
                 knex.whereIn(prop.inverseJoinColumns, deleteDiff);

package/dist/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Martin Adámek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/package.json

@@ -0,0 +1,99 @@
+{
+  "name": "@mikro-orm/knex",
+  "version": "5.0.0",
+  "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",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": "./index.mjs",
+      "require": "./index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
+  },
+  "keywords": [
+    "orm",
+    "mongo",
+    "mongodb",
+    "mysql",
+    "mariadb",
+    "postgresql",
+    "sqlite",
+    "sqlite3",
+    "ts",
+    "typescript",
+    "js",
+    "javascript",
+    "entity",
+    "ddd",
+    "mikro-orm",
+    "unit-of-work",
+    "data-mapper",
+    "identity-map"
+  ],
+  "author": "Martin Adámek",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/mikro-orm/mikro-orm/issues"
+  },
+  "homepage": "https://mikro-orm.io",
+  "engines": {
+    "node": ">= 14.0.0"
+  },
+  "scripts": {
+    "build": "yarn clean && yarn compile && yarn copy",
+    "postbuild": "yarn gen-esm-wrapper index.js index.mjs",
+    "clean": "rimraf ./dist",
+    "compile": "tsc -p tsconfig.build.json",
+    "copy": "ts-node -T ../../scripts/copy.ts"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "fs-extra": "10.0.0",
+    "knex": "1.0.1",
+    "sqlstring": "2.3.2"
+  },
+  "devDependencies": {
+    "@mikro-orm/core": "^5.0.0"
+  },
+  "peerDependencies": {
+    "@mikro-orm/core": "^5.0.0",
+    "@mikro-orm/entity-generator": "^5.0.0",
+    "@mikro-orm/migrations": "^5.0.0",
+    "@vscode/sqlite3": "^5.0.0",
+    "mssql": "^7.0.0",
+    "mysql": "^2.18.1",
+    "mysql2": "^2.1.0",
+    "pg": "^8.0.3"
+  },
+  "peerDependenciesMeta": {
+    "@mikro-orm/entity-generator": {
+      "optional": true
+    },
+    "@mikro-orm/migrations": {
+      "optional": true
+    },
+    "@vscode/sqlite3": {
+      "optional": true
+    },
+    "mssql": {
+      "optional": true
+    },
+    "mysql": {
+      "optional": true
+    },
+    "mysql2": {
+      "optional": true
+    },
+    "pg": {
+      "optional": true
+    }
+  }
+}

package/{query → dist/query}/CriteriaNode.js

@@ -16,7 +16,11 @@ class CriteriaNode {
         this.key = key;
         const meta = parent && metadata.find(parent.entityName);
         if (meta && key) {
-            core_1.Utils.splitPrimaryKeys(key).forEach(k => {
+            const pks = core_1.Utils.splitPrimaryKeys(key);
+            if (pks.length > 1) {
+                return;
+            }
+            pks.forEach(k => {
                 this.prop = meta.props.find(prop => prop.name === k || (prop.fieldNames || []).includes(k));
                 // do not validate if the key is prefixed or type casted (e.g. `k::text`)
                 if (validate && !this.prop && !k.includes('.') && !k.includes('::') && !core_1.Utils.isOperator(k) && !CriteriaNode.isCustomExpression(k)) {
@@ -52,12 +56,12 @@ class CriteriaNode {
         }
     }
     renameFieldToPK(qb) {
-        const alias = qb.getAliasForJoinPath(this.getPath());
+        const alias = qb.getAliasForJoinPath(this.getPath()) ?? qb.alias;
         if (this.prop.reference === core_1.ReferenceType.MANY_TO_MANY) {
             return core_1.Utils.getPrimaryKeyHash(this.prop.inverseJoinColumns.map(col => `${alias}.${col}`));
         }
         if (this.prop.joinColumns.length > 1) {
-            return core_1.Utils.getPrimaryKeyHash(this.prop.joinColumns);
+            return core_1.Utils.getPrimaryKeyHash(this.prop.joinColumns.map(col => `${alias}.${col}`));
         }
         return core_1.Utils.getPrimaryKeyHash(this.prop.referencedColumnNames.map(col => `${alias}.${col}`));
     }

package/{query → dist/query}/QueryBuilder.js

@@ -279,7 +279,7 @@ class QueryBuilder {
                 return qb.orderByRaw(queryOrder);
             }
         }, this._orderBy);
-        core_1.Utils.runIfNotEmpty(() => qb.limit(this._limit), this._limit);
+        core_1.Utils.runIfNotEmpty(() => qb.limit(this._limit), this._limit != null);
         core_1.Utils.runIfNotEmpty(() => qb.offset(this._offset), this._offset);
         core_1.Utils.runIfNotEmpty(() => this.helper.appendOnConflictClause(this.type, this._onConflict, qb), this._onConflict);
         if (this.type === enums_1.QueryType.TRUNCATE && this.platform.usesCascadeStatement()) {

package/{query → dist/query}/QueryBuilderHelper.d.ts

@@ -1,5 +1,5 @@
 import type { Knex } from 'knex';
-import type { Dictionary, EntityMetadata, EntityProperty, FlatQueryOrderMap, MetadataStorage, Platform, EntityData, QBFilterQuery } from '@mikro-orm/core';
+import type { Dictionary, EntityData, EntityMetadata, EntityProperty, FlatQueryOrderMap, MetadataStorage, Platform, QBFilterQuery } from '@mikro-orm/core';
 import { LockMode } from '@mikro-orm/core';
 import { QueryType } from './enums';
 import type { Field, JoinOptions } from '../typings';

package/{query → dist/query}/QueryBuilderHelper.js

@@ -21,7 +21,18 @@ class QueryBuilderHelper {
         const isTableNameAliasRequired = this.isTableNameAliasRequired(type);
         const fields = core_1.Utils.splitPrimaryKeys(field);
         if (fields.length > 1) {
-            return this.knex.raw('(' + fields.map(f => this.knex.ref(this.mapper(f, type, value, alias))).join(', ') + ')');
+            const parts = [];
+            for (const p of fields) {
+                const [a, f] = this.splitField(p);
+                const prop = this.getProperty(f, a);
+                if (prop) {
+                    parts.push(...prop.fieldNames.map(f => this.mapper(f, type, value, alias)));
+                }
+                else {
+                    parts.push(this.mapper(`${a}.${f}`, type, value, alias));
+                }
+            }
+            return this.knex.raw('(' + parts.map(part => this.knex.ref(part)).join(', ') + ')');
         }
         let ret = field;
         const customExpression = QueryBuilderHelper.isCustomExpression(field, !!alias);
@@ -31,13 +42,19 @@ class QueryBuilderHelper {
         if (prop?.fieldNameRaw) {
             return this.knex.raw(this.prefix(field, isTableNameAliasRequired));
         }
+        if (prop?.formula) {
+            const alias2 = this.knex.ref(a).toString();
+            const aliased = this.knex.ref(prop.fieldNames[0]).toString();
+            const as = alias === null ? '' : ` as ${aliased}`;
+            return this.knex.raw(`${prop.formula(alias2)}${as}`);
+        }
         if (prop?.customType?.convertToJSValueSQL) {
             const prefixed = this.prefix(field, isTableNameAliasRequired, true);
             const valueSQL = prop.customType.convertToJSValueSQL(prefixed, this.platform);
             if (alias === null) {
                 return this.knex.raw(valueSQL);
             }
-            return this.knex.raw(valueSQL + ' as ' + this.platform.quoteIdentifier(alias ?? prop.fieldNames[0]));
+            return this.knex.raw(`${valueSQL} as ${this.platform.quoteIdentifier(alias ?? prop.fieldNames[0])}`);
         }
         // do not wrap custom expressions
         if (!customExpression) {
@@ -147,7 +164,7 @@ class QueryBuilderHelper {
         Object.values(joins).forEach(join => {
             let table = `${join.table} as ${join.alias}`;
             const method = join.type === 'pivotJoin' ? 'leftJoin' : join.type;
-            schema = join.schema ?? schema;
+            schema = join.schema && join.schema !== '*' ? join.schema : schema;
             if (schema) {
                 table = `${schema}.${table}`;
             }

package/{schema → dist/schema}/DatabaseSchema.js

@@ -67,7 +67,15 @@ class DatabaseSchema {
             meta.indexes.forEach(index => table.addIndex(meta, index, 'index'));
             meta.uniques.forEach(index => table.addIndex(meta, index, 'unique'));
             table.addIndex(meta, { properties: meta.props.filter(prop => prop.primary).map(prop => prop.name) }, 'primary');
-            meta.checks.forEach(check => table.addCheck(check));
+            meta.checks.forEach(check => {
+                const columnName = check.property ? meta.properties[check.property].fieldNames[0] : undefined;
+                table.addCheck({
+                    name: check.name,
+                    expression: check.expression,
+                    definition: `check ((${check.expression}))`,
+                    columnName,
+                });
+            });
         }
         return schema;
     }

package/{schema → dist/schema}/DatabaseTable.d.ts

@@ -32,7 +32,7 @@ export declare class DatabaseTable {
     hasColumn(columnName: string): boolean;
     getIndex(indexName: string): Index | undefined;
     hasIndex(indexName: string): boolean;
-    getCheck(checkName: string): Check | undefined;
+    getCheck(checkName: string): Check<unknown> | undefined;
     hasCheck(checkName: string): boolean;
     getPrimaryKey(): Index | undefined;
     hasPrimaryKey(): boolean;
@@ -48,9 +48,6 @@ export declare class DatabaseTable {
         expression?: string;
         options?: Dictionary;
     }, type: 'index' | 'unique' | 'primary'): void;
-    addCheck(check: {
-        name: string;
-        expression: string;
-    }): void;
+    addCheck(check: Check): void;
     toJSON(): Dictionary;
 }

package/{schema → dist/schema}/DatabaseTable.js

@@ -288,7 +288,7 @@ class DatabaseTable {
     }
     addIndex(meta, index, type) {
         const properties = core_1.Utils.flatten(core_1.Utils.asArray(index.properties).map(prop => meta.properties[prop].fieldNames));
-        if (properties.length === 0) {
+        if (properties.length === 0 && !index.expression) {
             return;
         }
         const name = this.getIndexName(index.name, properties, type);

package/{schema → dist/schema}/SchemaComparator.js

@@ -347,6 +347,10 @@ class SchemaComparator {
      * Compares index1 with index2 and returns index2 if there are any differences or false in case there are no differences.
      */
     diffIndex(index1, index2) {
+        // if one of them is a custom expression, compare only by name
+        if (index1.expression || index2.expression) {
+            return index1.keyName !== index2.keyName;
+        }
         return !this.isIndexFulfilledBy(index1, index2) || !this.isIndexFulfilledBy(index2, index1);
     }
     /**

package/{schema → dist/schema}/SchemaHelper.js

@@ -7,7 +7,7 @@ class SchemaHelper {
         this.platform = platform;
     }
     getSchemaBeginning(charset) {
-        return `${this.disableForeignKeysSQL()}`;
+        return `${this.disableForeignKeysSQL()}\n\n`;
     }
     disableForeignKeysSQL() {
         return '';
@@ -16,7 +16,7 @@ class SchemaHelper {
         return '';
     }
     getSchemaEnd() {
-        return `${this.enableForeignKeysSQL()}`;
+        return `${this.enableForeignKeysSQL()}\n`;
     }
     finalizeTable(table, charset, collate) {
         //

package/{typings.d.ts → dist/typings.d.ts}

@@ -1,5 +1,5 @@
 import type { Knex } from 'knex';
-import type { Dictionary, EntityProperty, GroupOperator, QBFilterQuery, QueryOrderMap, Type } from '@mikro-orm/core';
+import type { CheckCallback, Dictionary, EntityProperty, GroupOperator, QBFilterQuery, QueryOrderMap, Type } from '@mikro-orm/core';
 import type { QueryType } from './query/enums';
 import type { DatabaseSchema, DatabaseTable } from './schema';
 export interface Table {
@@ -65,9 +65,9 @@ export interface Index {
         predicate?: Knex.QueryBuilder;
     }>;
 }
-export interface Check {
+export interface Check<T = unknown> {
     name: string;
-    expression: string;
+    expression: string | CheckCallback<T>;
     definition?: string;
     columnName?: string;
 }

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "@mikro-orm/knex",
-  "version": "5.0.0-rc.1",
+  "version": "6.0.0-dev.0+4ab7bdd0ca",
   "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",
-  "typings": "index.d.ts",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "typings": "dist/index.d.ts",
   "exports": {
+    "./package.json": "./package.json",
     ".": {
-      "import": "./index.mjs",
-      "require": "./index.js"
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
     }
   },
   "repository": {
@@ -46,7 +47,7 @@
   },
   "scripts": {
     "build": "yarn clean && yarn compile && yarn copy",
-    "postbuild": "yarn gen-esm-wrapper index.js index.mjs",
+    "postbuild": "yarn gen-esm-wrapper dist/index.js dist/index.mjs",
     "clean": "rimraf ./dist",
     "compile": "tsc -p tsconfig.build.json",
     "copy": "ts-node -T ../../scripts/copy.ts"
@@ -60,17 +61,17 @@
     "sqlstring": "2.3.2"
   },
   "devDependencies": {
-    "@mikro-orm/core": "^5.0.0-rc.1"
+    "@mikro-orm/core": "^6.0.0-dev.0+4ab7bdd0ca"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "^5.0.0-rc.1",
-    "@mikro-orm/entity-generator": "^5.0.0-rc.1",
-    "@mikro-orm/migrations": "^5.0.0-rc.1",
+    "@mikro-orm/core": "^5.0.0",
+    "@mikro-orm/entity-generator": "^5.0.0",
+    "@mikro-orm/migrations": "^5.0.0",
+    "@vscode/sqlite3": "^5.0.0",
     "mssql": "^7.0.0",
     "mysql": "^2.18.1",
     "mysql2": "^2.1.0",
-    "pg": "^8.0.3",
-    "@vscode/sqlite3": "^5.0.0"
+    "pg": "^8.0.3"
   },
   "peerDependenciesMeta": {
     "@mikro-orm/entity-generator": {
@@ -94,5 +95,6 @@
     "pg": {
       "optional": true
     }
-  }
+  },
+  "gitHead": "4ab7bdd0caf4f80b6a646dcd66c5ac6b67308764"
 }