@mikro-orm/knex 6.0.0-dev.2 → 6.0.0-dev.200

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

@@ -3,33 +3,37 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ScalarCriteriaNode = void 0;
 const core_1 = require("@mikro-orm/core");
 const CriteriaNode_1 = require("./CriteriaNode");
+const enums_1 = require("./enums");
 /**
  * @internal
  */
 class ScalarCriteriaNode extends CriteriaNode_1.CriteriaNode {
-    process(qb, alias) {
+    process(qb, options) {
         if (this.shouldJoin()) {
             const path = this.getPath();
             const parentPath = this.parent.getPath(); // the parent is always there, otherwise `shouldJoin` would return `false`
             const nestedAlias = qb.getAliasForJoinPath(path) || qb.getNextAlias(this.prop?.pivotTable ?? this.entityName);
-            const field = `${alias}.${this.prop.name}`;
-            const type = this.prop.reference === core_1.ReferenceType.MANY_TO_MANY ? 'pivotJoin' : 'leftJoin';
+            const field = `${options?.alias}.${this.prop.name}`;
+            const type = this.prop.kind === core_1.ReferenceKind.MANY_TO_MANY ? enums_1.JoinType.pivotJoin : enums_1.JoinType.leftJoin;
             qb.join(field, nestedAlias, undefined, type, path);
             // select the owner as virtual property when joining from 1:1 inverse side, but only if the parent is root entity
-            if (this.prop.reference === core_1.ReferenceType.ONE_TO_ONE && !parentPath.includes('.')) {
+            if (this.prop.kind === core_1.ReferenceKind.ONE_TO_ONE && !parentPath.includes('.') && !qb._fields?.includes(field)) {
                 qb.addSelect(field);
             }
         }
         return this.payload;
     }
+    willAutoJoin(qb, alias) {
+        return this.shouldJoin();
+    }
     shouldJoin() {
         if (!this.parent || !this.prop) {
             return false;
         }
-        switch (this.prop.reference) {
-            case core_1.ReferenceType.ONE_TO_MANY: return true;
-            case core_1.ReferenceType.MANY_TO_MANY: return true;
-            case core_1.ReferenceType.ONE_TO_ONE: return !this.prop.owner;
+        switch (this.prop.kind) {
+            case core_1.ReferenceKind.ONE_TO_MANY: return true;
+            case core_1.ReferenceKind.MANY_TO_MANY: return true;
+            case core_1.ReferenceKind.ONE_TO_ONE: return !this.prop.owner;
             default: return false; // SCALAR, MANY_TO_ONE
         }
     }

package/query/enums.d.ts

@@ -0,0 +1,15 @@
+export declare enum QueryType {
+    TRUNCATE = "TRUNCATE",
+    SELECT = "SELECT",
+    COUNT = "COUNT",
+    INSERT = "INSERT",
+    UPDATE = "UPDATE",
+    DELETE = "DELETE"
+}
+export declare enum JoinType {
+    leftJoin = "left join",
+    innerJoin = "inner join",
+    pivotJoin = "pivot join",
+    innerJoinLateral = "inner join lateral",
+    leftJoinLateral = "left join lateral"
+}

package/query/enums.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JoinType = exports.QueryType = void 0;
+var QueryType;
+(function (QueryType) {
+    QueryType["TRUNCATE"] = "TRUNCATE";
+    QueryType["SELECT"] = "SELECT";
+    QueryType["COUNT"] = "COUNT";
+    QueryType["INSERT"] = "INSERT";
+    QueryType["UPDATE"] = "UPDATE";
+    QueryType["DELETE"] = "DELETE";
+})(QueryType || (exports.QueryType = QueryType = {}));
+var JoinType;
+(function (JoinType) {
+    JoinType["leftJoin"] = "left join";
+    JoinType["innerJoin"] = "inner join";
+    JoinType["pivotJoin"] = "pivot join";
+    JoinType["innerJoinLateral"] = "inner join lateral";
+    JoinType["leftJoinLateral"] = "left join lateral";
+})(JoinType || (exports.JoinType = JoinType = {}));

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

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];

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

@@ -1,4 +1,4 @@
-import type { Configuration, Dictionary, EntityMetadata } from '@mikro-orm/core';
+import { type Configuration, type Dictionary, type EntityMetadata } from '@mikro-orm/core';
 import { DatabaseTable } from './DatabaseTable';
 import type { AbstractSqlConnection } from '../AbstractSqlConnection';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
@@ -10,14 +10,17 @@ export declare class DatabaseSchema {
     readonly name: string;
     private tables;
     private namespaces;
+    private nativeEnums;
     constructor(platform: AbstractSqlPlatform, name: string);
-    addTable(name: string, schema: string | undefined | null): DatabaseTable;
+    addTable(name: string, schema: string | undefined | null, comment?: string): DatabaseTable;
     getTables(): DatabaseTable[];
     getTable(name: string): DatabaseTable | undefined;
     hasTable(name: string): boolean;
+    setNativeEnums(nativeEnums: Dictionary<unknown[]>): void;
+    getNativeEnums(): Dictionary<unknown[]>;
     hasNamespace(namespace: string): boolean;
     getNamespaces(): string[];
-    static create(connection: AbstractSqlConnection, platform: AbstractSqlPlatform, config: Configuration, schemaName?: string): Promise<DatabaseSchema>;
+    static create(connection: AbstractSqlConnection, platform: AbstractSqlPlatform, config: Configuration, schemaName?: string, schemas?: string[]): Promise<DatabaseSchema>;
     static fromMetadata(metadata: EntityMetadata[], platform: AbstractSqlPlatform, config: Configuration, schemaName?: string): DatabaseSchema;
     private static getSchemaName;
     private static shouldHaveColumn;

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

@@ -7,15 +7,20 @@ const DatabaseTable_1 = require("./DatabaseTable");
  * @internal
  */
 class DatabaseSchema {
+    platform;
+    name;
+    tables = [];
+    namespaces = new Set();
+    nativeEnums = {}; // for postgres
     constructor(platform, name) {
         this.platform = platform;
         this.name = name;
-        this.tables = [];
-        this.namespaces = new Set();
     }
-    addTable(name, schema) {
+    addTable(name, schema, comment) {
         const namespaceName = schema ?? this.name;
         const table = new DatabaseTable_1.DatabaseTable(this.platform, name, namespaceName);
+        table.nativeEnums = this.nativeEnums;
+        table.comment = comment;
         this.tables.push(table);
         if (namespaceName != null) {
             this.namespaces.add(namespaceName);
@@ -31,39 +36,44 @@ class DatabaseSchema {
     hasTable(name) {
         return !!this.getTable(name);
     }
+    setNativeEnums(nativeEnums) {
+        this.nativeEnums = nativeEnums;
+        this.tables.forEach(t => t.nativeEnums = nativeEnums);
+    }
+    getNativeEnums() {
+        return this.nativeEnums;
+    }
     hasNamespace(namespace) {
         return this.namespaces.has(namespace);
     }
     getNamespaces() {
         return [...this.namespaces];
     }
-    static async create(connection, platform, config, schemaName) {
-        const schema = new DatabaseSchema(platform, schemaName ?? config.get('schema'));
-        const tables = await connection.execute(platform.getSchemaHelper().getListTablesSQL());
-        for (const t of tables) {
-            if (t.table_name === config.get('migrations').tableName) {
-                continue;
-            }
-            const table = schema.addTable(t.table_name, t.schema_name);
-            table.comment = t.table_comment;
-            const cols = await platform.getSchemaHelper().getColumns(connection, table.name, table.schema);
-            const indexes = await platform.getSchemaHelper().getIndexes(connection, table.name, table.schema);
-            const checks = await platform.getSchemaHelper().getChecks(connection, table.name, table.schema);
-            const pks = await platform.getSchemaHelper().getPrimaryKeys(connection, indexes, table.name, table.schema);
-            const fks = await platform.getSchemaHelper().getForeignKeys(connection, table.name, table.schema);
-            const enums = await platform.getSchemaHelper().getEnumDefinitions(connection, checks, table.name, table.schema);
-            table.init(cols, indexes, checks, pks, fks, enums);
-        }
+    static async create(connection, platform, config, schemaName, schemas) {
+        const schema = new DatabaseSchema(platform, schemaName ?? config.get('schema') ?? platform.getDefaultSchemaName());
+        const allTables = await connection.execute(platform.getSchemaHelper().getListTablesSQL());
+        const parts = config.get('migrations').tableName.split('.');
+        const migrationsTableName = parts[1] ?? parts[0];
+        const migrationsSchemaName = parts.length > 1 ? parts[0] : config.get('schema', platform.getDefaultSchemaName());
+        const tables = allTables.filter(t => t.table_name !== migrationsTableName || (t.schema_name && t.schema_name !== migrationsSchemaName));
+        await platform.getSchemaHelper().loadInformationSchema(schema, connection, tables, schemas && schemas.length > 0 ? schemas : undefined);
         return schema;
     }
     static fromMetadata(metadata, platform, config, schemaName) {
         const schema = new DatabaseSchema(platform, schemaName ?? config.get('schema'));
+        const nativeEnums = {};
+        for (const meta of metadata) {
+            meta.props
+                .filter(prop => prop.nativeEnumName)
+                .forEach(prop => nativeEnums[prop.nativeEnumName] = prop.items?.map(val => '' + val) ?? []);
+        }
+        schema.setNativeEnums(nativeEnums);
         for (const meta of metadata) {
             const table = schema.addTable(meta.collection, this.getSchemaName(meta, config, schemaName));
             table.comment = meta.comment;
             meta.props
                 .filter(prop => this.shouldHaveColumn(meta, prop))
-                .forEach(prop => table.addColumnFromProperty(prop, meta));
+                .forEach(prop => table.addColumnFromProperty(prop, meta, config));
             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');
@@ -83,18 +93,18 @@ class DatabaseSchema {
         return (meta.schema === '*' ? schema : meta.schema) ?? config.get('schema');
     }
     static shouldHaveColumn(meta, prop) {
-        if (prop.persist === false || !prop.fieldNames) {
+        if (prop.persist === false || (prop.columnTypes?.length ?? 0) === 0) {
             return false;
         }
-        if (meta.pivotTable || (core_1.ReferenceType.EMBEDDED && prop.object)) {
+        if (meta.pivotTable || (prop.kind === core_1.ReferenceKind.EMBEDDED && prop.object)) {
             return true;
         }
         const getRootProperty = (prop) => prop.embedded ? getRootProperty(meta.properties[prop.embedded[0]]) : prop;
         const rootProp = getRootProperty(prop);
-        if (rootProp.reference === core_1.ReferenceType.EMBEDDED) {
+        if (rootProp.kind === core_1.ReferenceKind.EMBEDDED) {
             return prop === rootProp || !rootProp.object;
         }
-        return [core_1.ReferenceType.SCALAR, core_1.ReferenceType.MANY_TO_ONE].includes(prop.reference) || (prop.reference === core_1.ReferenceType.ONE_TO_ONE && prop.owner);
+        return [core_1.ReferenceKind.SCALAR, core_1.ReferenceKind.MANY_TO_ONE].includes(prop.kind) || (prop.kind === core_1.ReferenceKind.ONE_TO_ONE && prop.owner);
     }
     toJSON() {
         const { platform, namespaces, ...rest } = this;

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

@@ -1,6 +1,6 @@
-import type { Dictionary, EntityMetadata, EntityProperty, NamingStrategy } from '@mikro-orm/core';
+import { type Configuration, type Dictionary, type EntityMetadata, type EntityProperty, type MikroORMOptions, type NamingStrategy } from '@mikro-orm/core';
 import type { SchemaHelper } from './SchemaHelper';
-import type { Check, Column, ForeignKey, Index } from '../typings';
+import type { CheckDef, Column, ForeignKey, IndexDef } from '../typings';
 import type { AbstractSqlPlatform } from '../AbstractSqlPlatform';
 /**
  * @internal
@@ -13,33 +13,41 @@ export declare class DatabaseTable {
     private indexes;
     private checks;
     private foreignKeys;
+    nativeEnums: Dictionary<unknown[]>;
     comment?: string;
     constructor(platform: AbstractSqlPlatform, name: string, schema?: string | undefined);
     getColumns(): Column[];
     getColumn(name: string): Column | undefined;
-    getIndexes(): Index[];
-    getChecks(): Check[];
-    init(cols: Column[], indexes: Index[], checks: Check[], pks: string[], fks: Dictionary<ForeignKey>, enums: Dictionary<string[]>): void;
+    removeColumn(name: string): void;
+    getIndexes(): IndexDef[];
+    getChecks(): CheckDef[];
+    init(cols: Column[], indexes: IndexDef[] | undefined, checks: CheckDef<unknown>[] | undefined, pks: string[], fks?: Dictionary<ForeignKey>, enums?: Dictionary<string[]>): void;
     addColumn(column: Column): void;
-    addColumnFromProperty(prop: EntityProperty, meta: EntityMetadata): void;
+    addColumnFromProperty(prop: EntityProperty, meta: EntityMetadata, config: Configuration): void;
     private getIndexName;
-    getEntityDeclaration(namingStrategy: NamingStrategy, schemaHelper: SchemaHelper): EntityMetadata;
+    getEntityDeclaration(namingStrategy: NamingStrategy, schemaHelper: SchemaHelper, scalarPropertiesForRelations: NonNullable<MikroORMOptions['entityGenerator']['scalarPropertiesForRelations']>): EntityMetadata;
+    private foreignKeysToProps;
+    private findFkIndex;
+    private getIndexProperties;
+    private getSafeBaseNameForFkProp;
     /**
      * The shortest name is stripped of the default namespace. All other namespaced elements are returned as full-qualified names.
      */
     getShortestName(): string;
     getForeignKeys(): Dictionary<ForeignKey>;
     hasColumn(columnName: string): boolean;
-    getIndex(indexName: string): Index | undefined;
+    getIndex(indexName: string): IndexDef | undefined;
     hasIndex(indexName: string): boolean;
-    getCheck(checkName: string): Check<unknown> | undefined;
+    getCheck(checkName: string): CheckDef<unknown> | undefined;
     hasCheck(checkName: string): boolean;
-    getPrimaryKey(): Index | undefined;
+    getPrimaryKey(): IndexDef | undefined;
     hasPrimaryKey(): boolean;
+    private getForeignKeyDeclaration;
     private getPropertyDeclaration;
-    private getReferenceType;
+    private getReferenceKind;
     private getPropertyName;
-    private getPropertyType;
+    private getPropertyTypeForForeignKey;
+    private getPropertyTypeForColumn;
     private getPropertyDefaultValue;
     addIndex(meta: EntityMetadata, index: {
         properties: string | string[];
@@ -48,6 +56,6 @@ export declare class DatabaseTable {
         expression?: string;
         options?: Dictionary;
     }, type: 'index' | 'unique' | 'primary'): void;
-    addCheck(check: Check): void;
+    addCheck(check: CheckDef): void;
     toJSON(): Dictionary;
 }