@mikro-orm/sql 7.0.0-dev.97 → 7.0.0-dev.99

package/AbstractSqlPlatform.d.ts

@@ -0,0 +1,38 @@
+import { type Constructor, type EntityManager, type EntityRepository, type IDatabaseDriver, type IsolationLevel, type MikroORM, Platform } from '@mikro-orm/core';
+import { SqlSchemaGenerator } from './schema/SqlSchemaGenerator.js';
+import { type SchemaHelper } from './schema/SchemaHelper.js';
+import type { IndexDef } from './typings.js';
+import { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
+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;
+    /** @internal */
+    createNativeQueryBuilder(): NativeQueryBuilder;
+    getBeginTransactionSQL(options?: {
+        isolationLevel?: IsolationLevel;
+        readOnly?: boolean;
+    }): string[];
+    getCommitTransactionSQL(): string;
+    getRollbackTransactionSQL(): string;
+    getSavepointSQL(savepointName: string): string;
+    getRollbackToSavepointSQL(savepointName: string): string;
+    getReleaseSavepointSQL(savepointName: string): string;
+    quoteValue(value: any): string;
+    escape(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[];
+    supportsSchemas(): boolean;
+    /** @inheritDoc */
+    generateCustomOrder(escapedColumn: string, values: unknown[]): string;
+    /**
+     * @internal
+     */
+    getOrderByExpression(column: string, direction: string): string[];
+}

package/AbstractSqlPlatform.js

@@ -0,0 +1,104 @@
+import SqlString from 'sqlstring';
+import { isRaw, JsonProperty, Platform, raw, Utils, } from '@mikro-orm/core';
+import { SqlEntityRepository } from './SqlEntityRepository.js';
+import { SqlSchemaGenerator } from './schema/SqlSchemaGenerator.js';
+import { NativeQueryBuilder } from './query/NativeQueryBuilder.js';
+export class AbstractSqlPlatform extends Platform {
+    schemaHelper;
+    usesPivotTable() {
+        return true;
+    }
+    indexForeignKeys() {
+        return true;
+    }
+    getRepositoryClass() {
+        return SqlEntityRepository;
+    }
+    getSchemaHelper() {
+        return this.schemaHelper;
+    }
+    /** @inheritDoc */
+    lookupExtensions(orm) {
+        SqlSchemaGenerator.register(orm);
+    }
+    /* v8 ignore next: kept for type inference only */
+    getSchemaGenerator(driver, em) {
+        return new SqlSchemaGenerator(em ?? driver);
+    }
+    /** @internal */
+    /* v8 ignore next */
+    createNativeQueryBuilder() {
+        return new NativeQueryBuilder(this);
+    }
+    getBeginTransactionSQL(options) {
+        if (options?.isolationLevel) {
+            return [`set transaction isolation level ${options.isolationLevel}`, 'begin'];
+        }
+        return ['begin'];
+    }
+    getCommitTransactionSQL() {
+        return 'commit';
+    }
+    getRollbackTransactionSQL() {
+        return 'rollback';
+    }
+    getSavepointSQL(savepointName) {
+        return `savepoint ${this.quoteIdentifier(savepointName)}`;
+    }
+    getRollbackToSavepointSQL(savepointName) {
+        return `rollback to savepoint ${this.quoteIdentifier(savepointName)}`;
+    }
+    getReleaseSavepointSQL(savepointName) {
+        return `release savepoint ${this.quoteIdentifier(savepointName)}`;
+    }
+    quoteValue(value) {
+        if (isRaw(value)) {
+            return this.formatQuery(value.sql, value.params);
+        }
+        if (Utils.isPlainObject(value) || value?.[JsonProperty]) {
+            return this.escape(JSON.stringify(value));
+        }
+        return this.escape(value);
+    }
+    escape(value) {
+        return SqlString.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 raw(alias => `json_extract(${this.quoteIdentifier(`${alias}.${a}`)}, '$.${b.map(quoteKey).join('.')}')`);
+        }
+        return raw(`json_extract(${this.quoteIdentifier(a)}, '$.${b.map(quoteKey).join('.')}')`);
+    }
+    getJsonIndexDefinition(index) {
+        return index.columnNames
+            .map(column => {
+            if (!column.includes('.')) {
+                return column;
+            }
+            const [root, ...path] = column.split('.');
+            return `(json_extract(${root}, '$.${path.join('.')}'))`;
+        });
+    }
+    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()}`];
+    }
+}

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

@@ -0,0 +1,22 @@
+import { type Dictionary, type EntityMetadata, type EntityProperty, type Primary, type Transaction } from '@mikro-orm/core';
+import { type AbstractSqlDriver } from './AbstractSqlDriver.js';
+export declare class PivotCollectionPersister<Entity extends object> {
+    private readonly meta;
+    private readonly driver;
+    private readonly ctx?;
+    private readonly schema?;
+    private readonly loggerContext?;
+    private readonly inserts;
+    private readonly upserts;
+    private readonly deletes;
+    private readonly batchSize;
+    private order;
+    constructor(meta: EntityMetadata<Entity>, driver: AbstractSqlDriver, ctx?: Transaction | undefined, schema?: string | undefined, loggerContext?: Dictionary | undefined);
+    enqueueUpdate(prop: EntityProperty<Entity>, insertDiff: Primary<Entity>[][], deleteDiff: Primary<Entity>[][] | boolean, pks: Primary<Entity>[], isInitialized?: boolean): void;
+    private enqueueInsert;
+    private enqueueUpsert;
+    private createInsertStatement;
+    private enqueueDelete;
+    private collectStatements;
+    execute(): Promise<void>;
+}

package/PivotCollectionPersister.js

@@ -0,0 +1,159 @@
+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;
+    }
+}
+export class PivotCollectionPersister {
+    meta;
+    driver;
+    ctx;
+    schema;
+    loggerContext;
+    inserts = new Map();
+    upserts = new Map();
+    deletes = new Map();
+    batchSize;
+    order = 0;
+    constructor(meta, driver, ctx, schema, loggerContext) {
+        this.meta = meta;
+        this.driver = driver;
+        this.ctx = ctx;
+        this.schema = schema;
+        this.loggerContext = loggerContext;
+        this.batchSize = this.driver.config.get('batchSize');
+    }
+    enqueueUpdate(prop, insertDiff, deleteDiff, pks, isInitialized = true) {
+        if (insertDiff.length) {
+            if (isInitialized) {
+                this.enqueueInsert(prop, insertDiff, pks);
+            }
+            else {
+                this.enqueueUpsert(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 statement = this.createInsertStatement(prop, fks, pks);
+            const hash = statement.getHash();
+            if (prop.owner || !this.inserts.has(hash)) {
+                this.inserts.set(hash, statement);
+            }
+        }
+    }
+    enqueueUpsert(prop, insertDiff, pks) {
+        for (const fks of insertDiff) {
+            const statement = this.createInsertStatement(prop, fks, pks);
+            const hash = statement.getHash();
+            if (prop.owner || !this.upserts.has(hash)) {
+                this.upserts.set(hash, statement);
+            }
+        }
+    }
+    createInsertStatement(prop, fks, pks) {
+        const data = prop.owner ? [...fks, ...pks] : [...pks, ...fks];
+        const keys = prop.owner
+            ? [...prop.inverseJoinColumns, ...prop.joinColumns]
+            : [...prop.joinColumns, ...prop.inverseJoinColumns];
+        return new InsertStatement(keys, data, this.order++);
+    }
+    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);
+        }
+    }
+    collectStatements(statements) {
+        const items = [];
+        for (const statement of statements.values()) {
+            items[statement.order] = statement.getData();
+        }
+        return items.filter(Boolean);
+    }
+    async execute() {
+        if (this.deletes.size > 0) {
+            const deletes = [...this.deletes.values()];
+            for (let i = 0; i < deletes.length; i += this.batchSize) {
+                const chunk = deletes.slice(i, i + this.batchSize);
+                const cond = { $or: [] };
+                for (const item of chunk) {
+                    cond.$or.push(item.getCondition());
+                }
+                await this.driver.nativeDelete(this.meta.className, cond, {
+                    ctx: this.ctx,
+                    schema: this.schema,
+                    loggerContext: this.loggerContext,
+                });
+            }
+        }
+        if (this.inserts.size > 0) {
+            const filtered = this.collectStatements(this.inserts);
+            for (let i = 0; i < filtered.length; i += this.batchSize) {
+                const chunk = filtered.slice(i, i + this.batchSize);
+                await this.driver.nativeInsertMany(this.meta.className, chunk, {
+                    ctx: this.ctx,
+                    schema: this.schema,
+                    convertCustomTypes: false,
+                    processCollections: false,
+                    loggerContext: this.loggerContext,
+                });
+            }
+        }
+        if (this.upserts.size > 0) {
+            const filtered = this.collectStatements(this.upserts);
+            for (let i = 0; i < filtered.length; i += this.batchSize) {
+                const chunk = filtered.slice(i, i + this.batchSize);
+                await this.driver.nativeUpdateMany(this.meta.className, [], chunk, {
+                    ctx: this.ctx,
+                    schema: this.schema,
+                    convertCustomTypes: false,
+                    processCollections: false,
+                    upsert: true,
+                    onConflictAction: 'ignore',
+                    loggerContext: this.loggerContext,
+                });
+            }
+        }
+    }
+}