@yandjin-mikro-orm/knex 6.1.4-rc-sti-changes-1

package/query/ScalarCriteriaNode.d.ts

@@ -0,0 +1,10 @@
+import { CriteriaNode } from "./CriteriaNode";
+import type { IQueryBuilder, ICriteriaNodeProcessOptions } from "../typings";
+/**
+ * @internal
+ */
+export declare class ScalarCriteriaNode<T extends object> extends CriteriaNode<T> {
+    process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any;
+    willAutoJoin<T>(qb: IQueryBuilder<T>, alias?: string): boolean;
+    shouldJoin(): boolean;
+}

package/query/ScalarCriteriaNode.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScalarCriteriaNode = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+const CriteriaNode_1 = require("./CriteriaNode");
+const enums_1 = require("./enums");
+/**
+ * @internal
+ */
+class ScalarCriteriaNode extends CriteriaNode_1.CriteriaNode {
+    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 = this.aliased(this.prop.name, options?.alias);
+            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.kind === core_1.ReferenceKind.ONE_TO_ONE &&
+                !parentPath.includes(".") &&
+                !qb._fields?.includes(field)) {
+                qb.addSelect(field);
+            }
+        }
+        if (this.payload && typeof this.payload === "object") {
+            const keys = Object.keys(this.payload).filter((key) => core_1.Utils.isArrayOperator(key) && Array.isArray(this.payload[key]));
+            for (const key of keys) {
+                this.payload[key] = JSON.stringify(this.payload[key]);
+            }
+        }
+        return this.payload;
+    }
+    willAutoJoin(qb, alias) {
+        return this.shouldJoin();
+    }
+    shouldJoin() {
+        if (!this.parent || !this.prop) {
+            return false;
+        }
+        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
+        }
+    }
+}
+exports.ScalarCriteriaNode = ScalarCriteriaNode;

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/query/index.d.ts

@@ -0,0 +1,8 @@
+export * from './enums';
+export * from './QueryBuilderHelper';
+export * from './QueryBuilder';
+export * from './CriteriaNode';
+export * from './ArrayCriteriaNode';
+export * from './ObjectCriteriaNode';
+export * from './ScalarCriteriaNode';
+export * from './CriteriaNodeFactory';

package/query/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = 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];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./enums"), exports);
+__exportStar(require("./QueryBuilderHelper"), exports);
+__exportStar(require("./QueryBuilder"), exports);
+__exportStar(require("./CriteriaNode"), exports);
+__exportStar(require("./ArrayCriteriaNode"), exports);
+__exportStar(require("./ObjectCriteriaNode"), exports);
+__exportStar(require("./ScalarCriteriaNode"), exports);
+__exportStar(require("./CriteriaNodeFactory"), exports);

package/schema/DatabaseSchema.d.ts

@@ -0,0 +1,29 @@
+import { type Configuration, type Dictionary, type EntityMetadata } from "@yandjin-mikro-orm/core";
+import { DatabaseTable } from "./DatabaseTable";
+import type { AbstractSqlConnection } from "../AbstractSqlConnection";
+import type { AbstractSqlPlatform } from "../AbstractSqlPlatform";
+/**
+ * @internal
+ */
+export declare class DatabaseSchema {
+    private readonly platform;
+    readonly name: string;
+    private tables;
+    private namespaces;
+    private nativeEnums;
+    constructor(platform: AbstractSqlPlatform, name: string);
+    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, schemas?: string[]): Promise<DatabaseSchema>;
+    static fromMetadata(metadata: EntityMetadata[], platform: AbstractSqlPlatform, config: Configuration, schemaName?: string): DatabaseSchema;
+    private static getSchemaName;
+    private static shouldHaveColumn;
+    toJSON(): Dictionary;
+    prune(schema: string | undefined, wildcardSchemaTables: string[]): void;
+}

package/schema/DatabaseSchema.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseSchema = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+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;
+    }
+    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);
+        }
+        return table;
+    }
+    getTables() {
+        return this.tables;
+    }
+    getTable(name) {
+        return this.tables.find((t) => t.name === name || `${t.schema}.${t.name}` === name);
+    }
+    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, 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);
+        const rootMetadata = core_1.Utils.uniqueBy(metadata.map((e) => e.getStiRoot()), "name");
+        for (const meta of rootMetadata) {
+            // const table = schema.getTable(meta.collection) ?? schema.addTable(meta.collection, this.getSchemaName(meta, config, schemaName));
+            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, 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");
+            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;
+    }
+    static getSchemaName(meta, config, schema) {
+        return (meta.schema === "*" ? schema : meta.schema) ?? config.get("schema");
+    }
+    static shouldHaveColumn(meta, prop) {
+        if (prop.persist === false || (prop.columnTypes?.length ?? 0) === 0) {
+            return false;
+        }
+        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.kind === core_1.ReferenceKind.EMBEDDED) {
+            return prop === rootProp || !rootProp.object;
+        }
+        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;
+        return { namespaces: [...namespaces], ...rest };
+    }
+    prune(schema, wildcardSchemaTables) {
+        const hasWildcardSchema = wildcardSchemaTables.length > 0;
+        this.tables = this.tables.filter((table) => {
+            return ((!schema && !hasWildcardSchema) || // no schema specified and we don't have any multi-schema entity
+                table.schema === schema || // specified schema matches the table's one
+                (!schema && !wildcardSchemaTables.includes(table.name))); // no schema specified and the table has fixed one provided
+        });
+        // remove namespaces of ignored tables
+        this.namespaces.forEach((ns) => !this.tables.find((t) => t.schema === ns) && this.namespaces.delete(ns));
+    }
+}
+exports.DatabaseSchema = DatabaseSchema;

package/schema/DatabaseTable.d.ts

@@ -0,0 +1,61 @@
+import { type Configuration, type Dictionary, type EntityMetadata, type EntityProperty, type NamingStrategy } from "@yandjin-mikro-orm/core";
+import type { SchemaHelper } from "./SchemaHelper";
+import type { CheckDef, Column, ForeignKey, IndexDef } from "../typings";
+import type { AbstractSqlPlatform } from "../AbstractSqlPlatform";
+/**
+ * @internal
+ */
+export declare class DatabaseTable {
+    private readonly platform;
+    readonly name: string;
+    readonly schema?: string | undefined;
+    private columns;
+    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;
+    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, config: Configuration): void;
+    private getIndexName;
+    getEntityDeclaration(namingStrategy: NamingStrategy, schemaHelper: SchemaHelper, scalarPropertiesForRelations: "always" | "never" | "smart"): 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): IndexDef | undefined;
+    hasIndex(indexName: string): boolean;
+    getCheck(checkName: string): CheckDef<unknown> | undefined;
+    hasCheck(checkName: string): boolean;
+    getPrimaryKey(): IndexDef | undefined;
+    hasPrimaryKey(): boolean;
+    private getForeignKeyDeclaration;
+    private getPropertyDeclaration;
+    private getReferenceKind;
+    private getPropertyName;
+    private getPropertyTypeForForeignKey;
+    private getPropertyTypeForColumn;
+    private getPropertyDefaultValue;
+    addIndex(meta: EntityMetadata, index: {
+        properties: string | string[];
+        name?: string;
+        type?: string;
+        expression?: string;
+        options?: Dictionary;
+    }, type: "index" | "unique" | "primary"): void;
+    addCheck(check: CheckDef): void;
+    toJSON(): Dictionary;
+}