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

package/AbstractSqlPlatform.d.ts

@@ -0,0 +1,25 @@
+import { Platform, type Constructor, type EntityManager, type EntityRepository, type IDatabaseDriver, type MikroORM } from "@yandjin-mikro-orm/core";
+import { SqlSchemaGenerator, type SchemaHelper } from "./schema";
+import type { IndexDef } from "./typings";
+export declare abstract class AbstractSqlPlatform extends Platform {
+    protected readonly schemaHelper?: SchemaHelper;
+    usesPivotTable(): boolean;
+    indexForeignKeys(): boolean;
+    getRepositoryClass<T extends object>(): Constructor<EntityRepository<T>>;
+    getSchemaHelper(): SchemaHelper | undefined;
+    /** @inheritDoc */
+    lookupExtensions(orm: MikroORM): void;
+    getSchemaGenerator(driver: IDatabaseDriver, em?: EntityManager): SqlSchemaGenerator;
+    quoteValue(value: any): string;
+    getSearchJsonPropertySQL(path: string, type: string, aliased: boolean): string;
+    getSearchJsonPropertyKey(path: string[], type: string, aliased: boolean, value?: unknown): string;
+    getJsonIndexDefinition(index: IndexDef): string[];
+    isRaw(value: any): boolean;
+    supportsSchemas(): boolean;
+    /** @inheritDoc */
+    generateCustomOrder(escapedColumn: string, values: unknown[]): string;
+    /**
+     * @internal
+     */
+    getOrderByExpression(column: string, direction: string): string[];
+}

package/AbstractSqlPlatform.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractSqlPlatform = void 0;
+const sqlstring_1 = require("sqlstring");
+const core_1 = require("@yandjin-mikro-orm/core");
+const SqlEntityRepository_1 = require("./SqlEntityRepository");
+const schema_1 = require("./schema");
+class AbstractSqlPlatform extends core_1.Platform {
+    schemaHelper;
+    usesPivotTable() {
+        return true;
+    }
+    indexForeignKeys() {
+        return true;
+    }
+    getRepositoryClass() {
+        return SqlEntityRepository_1.SqlEntityRepository;
+    }
+    getSchemaHelper() {
+        return this.schemaHelper;
+    }
+    /** @inheritDoc */
+    lookupExtensions(orm) {
+        schema_1.SqlSchemaGenerator.register(orm);
+    }
+    /* istanbul ignore next: kept for type inference only */
+    getSchemaGenerator(driver, em) {
+        return new schema_1.SqlSchemaGenerator(em ?? driver);
+    }
+    quoteValue(value) {
+        if (core_1.Utils.isRawSql(value)) {
+            return this.formatQuery(value.sql, value.params ?? []);
+        }
+        if (this.isRaw(value)) {
+            return value;
+        }
+        /* istanbul ignore if */
+        if (core_1.Utils.isPlainObject(value) || value?.[core_1.JsonProperty]) {
+            return (0, sqlstring_1.escape)(JSON.stringify(value));
+        }
+        // @ts-ignore
+        return (0, sqlstring_1.escape)(value, true, this.timezone);
+    }
+    getSearchJsonPropertySQL(path, type, aliased) {
+        return this.getSearchJsonPropertyKey(path.split("->"), type, aliased);
+    }
+    getSearchJsonPropertyKey(path, type, aliased, value) {
+        const [a, ...b] = path;
+        const quoteKey = (key) => key.match(/^[a-z]\w*$/i) ? key : `"${key}"`;
+        if (aliased) {
+            return (0, core_1.raw)((alias) => `json_extract(${this.quoteIdentifier(`${alias}.${a}`)}, '$.${b.map(quoteKey).join(".")}')`);
+        }
+        return (0, core_1.raw)(`json_extract(${this.quoteIdentifier(a)}, '$.${b.map(quoteKey).join(".")}')`);
+    }
+    getJsonIndexDefinition(index) {
+        return index.columnNames.map((column) => {
+            const [root, ...path] = column.split(".");
+            return `json_extract(${root}, '$.${path.join(".")}')`;
+        });
+    }
+    isRaw(value) {
+        return (super.isRaw(value) ||
+            (typeof value === "object" &&
+                value !== null &&
+                value.client &&
+                ["Ref", "Raw"].includes(value.constructor.name)));
+    }
+    supportsSchemas() {
+        return false;
+    }
+    /** @inheritDoc */
+    generateCustomOrder(escapedColumn, values) {
+        let ret = "(case ";
+        values.forEach((v, i) => {
+            ret += `when ${escapedColumn} = ${this.quoteValue(v)} then ${i} `;
+        });
+        return ret + "else null end)";
+    }
+    /**
+     * @internal
+     */
+    getOrderByExpression(column, direction) {
+        return [`${column} ${direction.toLowerCase()}`];
+    }
+}
+exports.AbstractSqlPlatform = AbstractSqlPlatform;

package/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/MonkeyPatchable.d.ts

@@ -0,0 +1,11 @@
+export declare const MonkeyPatchable: {
+    Client: any;
+    QueryExecutioner: any;
+    MySqlDialect: any;
+    MySqlColumnCompiler: any;
+    MySqlQueryCompiler: any;
+    PostgresDialectTableCompiler: any;
+    Sqlite3Dialect: any;
+    Sqlite3DialectTableCompiler: any;
+    TableCompiler: any;
+};

package/MonkeyPatchable.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MonkeyPatchable = void 0;
+// @ts-ignore
+const client_1 = __importDefault(require("knex/lib/client"));
+// @ts-ignore
+const query_executioner_1 = __importDefault(require("knex/lib/execution/internal/query-executioner"));
+// @ts-ignore
+const mysql_1 = __importDefault(require("knex/lib/dialects/mysql"));
+// @ts-ignore
+const mysql_columncompiler_1 = __importDefault(require("knex/lib/dialects/mysql/schema/mysql-columncompiler"));
+// @ts-ignore
+const mysql_querycompiler_1 = __importDefault(require("knex/lib/dialects/mysql/query/mysql-querycompiler"));
+// @ts-ignore
+const pg_tablecompiler_1 = __importDefault(require("knex/lib/dialects/postgres/schema/pg-tablecompiler"));
+// @ts-ignore
+const sqlite3_1 = __importDefault(require("knex/lib/dialects/sqlite3"));
+// @ts-ignore
+const sqlite_tablecompiler_1 = __importDefault(require("knex/lib/dialects/sqlite3/schema/sqlite-tablecompiler"));
+// @ts-ignore
+const tablecompiler_1 = __importDefault(require("knex/lib/schema/tablecompiler"));
+// These specific portions of knex are overridden by the different
+// database packages. We need to be sure the knex files they get to
+// monkey patch are the same version as our overall knex instance
+// which is why we need to import them in this package.
+exports.MonkeyPatchable = {
+    Client: client_1.default,
+    QueryExecutioner: query_executioner_1.default,
+    MySqlDialect: mysql_1.default,
+    MySqlColumnCompiler: mysql_columncompiler_1.default,
+    MySqlQueryCompiler: mysql_querycompiler_1.default,
+    PostgresDialectTableCompiler: pg_tablecompiler_1.default,
+    Sqlite3Dialect: sqlite3_1.default,
+    Sqlite3DialectTableCompiler: sqlite_tablecompiler_1.default,
+    TableCompiler: tablecompiler_1.default,
+};

package/PivotCollectionPersister.d.ts

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

package/PivotCollectionPersister.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PivotCollectionPersister = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+class InsertStatement {
+    keys;
+    data;
+    order;
+    constructor(keys, data, order) {
+        this.keys = keys;
+        this.data = data;
+        this.order = order;
+    }
+    getHash() {
+        return JSON.stringify(this.data);
+    }
+    getData() {
+        const data = {};
+        this.keys.forEach((key, idx) => (data[key] = this.data[idx]));
+        return data;
+    }
+}
+class DeleteStatement {
+    keys;
+    cond;
+    constructor(keys, cond) {
+        this.keys = keys;
+        this.cond = cond;
+    }
+    getHash() {
+        return JSON.stringify(this.cond);
+    }
+    getCondition() {
+        const cond = {};
+        this.keys.forEach((key, idx) => (cond[key] = this.cond[idx]));
+        return cond;
+    }
+}
+class PivotCollectionPersister {
+    meta;
+    driver;
+    ctx;
+    schema;
+    platform;
+    inserts = new Map();
+    deletes = new Map();
+    order = 0;
+    constructor(meta, driver, ctx, schema) {
+        this.meta = meta;
+        this.driver = driver;
+        this.ctx = ctx;
+        this.schema = schema;
+        this.platform = this.driver.getPlatform();
+    }
+    enqueueUpdate(prop, insertDiff, deleteDiff, pks) {
+        if (insertDiff.length) {
+            this.enqueueInsert(prop, insertDiff, pks);
+        }
+        if (deleteDiff === true ||
+            (Array.isArray(deleteDiff) && deleteDiff.length)) {
+            this.enqueueDelete(prop, deleteDiff, pks);
+        }
+    }
+    enqueueInsert(prop, insertDiff, pks) {
+        for (const fks of insertDiff) {
+            const data = prop.owner ? [...fks, ...pks] : [...pks, ...fks];
+            const keys = prop.owner
+                ? [...prop.inverseJoinColumns, ...prop.joinColumns]
+                : [...prop.joinColumns, ...prop.inverseJoinColumns];
+            const statement = new InsertStatement(keys, data, this.order++);
+            const hash = statement.getHash();
+            if (prop.owner || !this.inserts.has(hash)) {
+                this.inserts.set(hash, statement);
+            }
+        }
+    }
+    enqueueDelete(prop, deleteDiff, pks) {
+        if (deleteDiff === true) {
+            const statement = new DeleteStatement(prop.joinColumns, pks);
+            this.deletes.set(statement.getHash(), statement);
+            return;
+        }
+        for (const fks of deleteDiff) {
+            const data = prop.owner ? [...fks, ...pks] : [...pks, ...fks];
+            const keys = prop.owner
+                ? [...prop.inverseJoinColumns, ...prop.joinColumns]
+                : [...prop.joinColumns, ...prop.inverseJoinColumns];
+            const statement = new DeleteStatement(keys, data);
+            this.deletes.set(statement.getHash(), statement);
+        }
+    }
+    async execute() {
+        if (this.deletes.size > 0) {
+            const knex = this.driver
+                .createQueryBuilder(this.meta.className, this.ctx, "write")
+                .withSchema(this.schema)
+                .getKnex();
+            for (const item of this.deletes.values()) {
+                knex.orWhere(item.getCondition());
+            }
+            await this.driver.execute(knex.delete());
+        }
+        if (this.inserts.size === 0) {
+            return;
+        }
+        let items = [];
+        for (const insert of this.inserts.values()) {
+            items[insert.order] = insert.getData();
+        }
+        items = items.filter((i) => i);
+        /* istanbul ignore else */
+        if (this.platform.allowsMultiInsert()) {
+            await this.driver.nativeInsertMany(this.meta.className, items, {
+                ctx: this.ctx,
+                schema: this.schema,
+                convertCustomTypes: false,
+                processCollections: false,
+            });
+        }
+        else {
+            await core_1.Utils.runSerial(items, (item) => {
+                return this.driver
+                    .createQueryBuilder(this.meta.className, this.ctx, "write")
+                    .withSchema(this.schema)
+                    .insert(item)
+                    .execute("run", false);
+            });
+        }
+    }
+}
+exports.PivotCollectionPersister = PivotCollectionPersister;