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

package/query/ArrayCriteriaNode.d.ts

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

package/query/ArrayCriteriaNode.js

@@ -0,0 +1,24 @@
+import { CriteriaNode } from './CriteriaNode.js';
+/**
+ * @internal
+ */
+export class ArrayCriteriaNode extends CriteriaNode {
+    process(qb, options) {
+        return this.payload.map((node) => {
+            return node.process(qb, options);
+        });
+    }
+    unwrap() {
+        return this.payload.map((node) => {
+            return node.unwrap();
+        });
+    }
+    willAutoJoin(qb, alias, options) {
+        return this.payload.some((node) => {
+            return node.willAutoJoin(qb, alias, options);
+        });
+    }
+    isStrict() {
+        return this.strict || this.payload.some((node) => node.isStrict());
+    }
+}

package/query/CriteriaNode.d.ts

@@ -0,0 +1,29 @@
+import { type EntityKey, type EntityProperty, type MetadataStorage } from '@mikro-orm/core';
+import type { ICriteriaNode, ICriteriaNodeProcessOptions, IQueryBuilder } from '../typings.js';
+/**
+ * Helper for working with deeply nested where/orderBy/having criteria. Uses composite pattern to build tree from the payload.
+ * Auto-joins relations and converts payload from { books: { publisher: { name: '...' } } } to { 'publisher_alias.name': '...' }
+ * @internal
+ */
+export declare class CriteriaNode<T extends object> implements ICriteriaNode<T> {
+    protected readonly metadata: MetadataStorage;
+    readonly entityName: string;
+    readonly parent?: ICriteriaNode<T> | undefined;
+    readonly key?: EntityKey<T> | undefined;
+    readonly strict: boolean;
+    payload: any;
+    prop?: EntityProperty<T>;
+    index?: number;
+    constructor(metadata: MetadataStorage, entityName: string, parent?: ICriteriaNode<T> | undefined, key?: EntityKey<T> | undefined, validate?: boolean, strict?: boolean);
+    process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any;
+    unwrap(): any;
+    shouldInline(payload: any): boolean;
+    willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): boolean;
+    shouldRename(payload: any): boolean;
+    renameFieldToPK<T>(qb: IQueryBuilder<T>, ownerAlias?: string): string;
+    getPath(addIndex?: boolean): string;
+    private isPivotJoin;
+    getPivotPath(path: string): string;
+    aliased(field: string, alias?: string): string;
+    isStrict(): boolean;
+}

package/query/CriteriaNode.js

@@ -0,0 +1,121 @@
+import { RawQueryFragment, ReferenceKind, Utils, inspect, } from '@mikro-orm/core';
+/**
+ * Helper for working with deeply nested where/orderBy/having criteria. Uses composite pattern to build tree from the payload.
+ * Auto-joins relations and converts payload from { books: { publisher: { name: '...' } } } to { 'publisher_alias.name': '...' }
+ * @internal
+ */
+export class CriteriaNode {
+    metadata;
+    entityName;
+    parent;
+    key;
+    strict;
+    payload;
+    prop;
+    index;
+    constructor(metadata, entityName, parent, key, validate = true, strict = false) {
+        this.metadata = metadata;
+        this.entityName = entityName;
+        this.parent = parent;
+        this.key = key;
+        this.strict = strict;
+        const meta = parent && metadata.find(parent.entityName);
+        if (meta && key) {
+            const pks = Utils.splitPrimaryKeys(key);
+            if (pks.length > 1) {
+                return;
+            }
+            for (const k of pks) {
+                this.prop = meta.props.find(prop => prop.name === k || (prop.fieldNames?.length === 1 && prop.fieldNames[0] === k && prop.persist !== false));
+                const isProp = this.prop || meta.props.find(prop => (prop.fieldNames || []).includes(k));
+                // do not validate if the key is prefixed or type casted (e.g. `k::text`)
+                if (validate && !isProp && !k.includes('.') && !k.includes('::') && !Utils.isOperator(k) && !RawQueryFragment.isKnownFragment(k)) {
+                    throw new Error(`Trying to query by not existing property ${entityName}.${k}`);
+                }
+            }
+        }
+    }
+    process(qb, options) {
+        return this.payload;
+    }
+    unwrap() {
+        return this.payload;
+    }
+    shouldInline(payload) {
+        return false;
+    }
+    willAutoJoin(qb, alias, options) {
+        return false;
+    }
+    shouldRename(payload) {
+        const type = this.prop ? this.prop.kind : null;
+        const composite = this.prop?.joinColumns ? this.prop.joinColumns.length > 1 : false;
+        const customExpression = RawQueryFragment.isKnownFragment(this.key);
+        const scalar = payload === null || Utils.isPrimaryKey(payload) || payload instanceof RegExp || payload instanceof Date || customExpression;
+        const plainObject = Utils.isPlainObject(payload);
+        const keys = plainObject ? Object.keys(payload) : [];
+        const operator = plainObject && keys.every(k => Utils.isOperator(k, false));
+        if (composite) {
+            return true;
+        }
+        switch (type) {
+            case ReferenceKind.MANY_TO_ONE: return false;
+            case ReferenceKind.ONE_TO_ONE: return !this.prop.owner;
+            case ReferenceKind.ONE_TO_MANY: return scalar || operator;
+            case ReferenceKind.MANY_TO_MANY: return scalar || operator;
+            default: return false;
+        }
+    }
+    renameFieldToPK(qb, ownerAlias) {
+        const joinAlias = qb.getAliasForJoinPath(this.getPath(), { matchPopulateJoins: true });
+        if (!joinAlias && this.parent && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(this.prop.kind) && this.prop.owner) {
+            const alias = qb.getAliasForJoinPath(this.parent.getPath()) ?? ownerAlias ?? qb.alias;
+            return Utils.getPrimaryKeyHash(this.prop.joinColumns.map(col => `${alias}.${col}`));
+        }
+        const alias = joinAlias ?? ownerAlias ?? qb.alias;
+        if (this.prop.kind === ReferenceKind.MANY_TO_MANY) {
+            return Utils.getPrimaryKeyHash(this.prop.inverseJoinColumns.map(col => `${alias}.${col}`));
+        }
+        return Utils.getPrimaryKeyHash(this.prop.referencedColumnNames.map(col => `${alias}.${col}`));
+    }
+    getPath(addIndex = false) {
+        // use index on parent only if we are processing to-many relation
+        const addParentIndex = this.prop && [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(this.prop.kind);
+        const parentPath = this.parent?.getPath(addParentIndex) ?? this.entityName;
+        const index = addIndex && this.index != null ? `[${this.index}]` : '';
+        // ignore group operators to allow easier mapping (e.g. for orderBy)
+        const key = this.key && !['$and', '$or', '$not'].includes(this.key) ? '.' + this.key : '';
+        const ret = parentPath + index + key;
+        if (this.isPivotJoin()) {
+            // distinguish pivot table join from target entity join
+            return this.getPivotPath(ret);
+        }
+        return ret;
+    }
+    isPivotJoin() {
+        if (!this.key || !this.prop) {
+            return false;
+        }
+        const customExpression = RawQueryFragment.isKnownFragment(this.key);
+        const scalar = this.payload === null || Utils.isPrimaryKey(this.payload) || this.payload instanceof RegExp || this.payload instanceof Date || customExpression;
+        const operator = Utils.isObject(this.payload) && Object.keys(this.payload).every(k => Utils.isOperator(k, false));
+        return this.prop.kind === ReferenceKind.MANY_TO_MANY && (scalar || operator);
+    }
+    getPivotPath(path) {
+        return `${path}[pivot]`;
+    }
+    aliased(field, alias) {
+        return alias ? `${alias}.${field}` : field;
+    }
+    isStrict() {
+        return this.strict;
+    }
+    /** @ignore */
+    [Symbol.for('nodejs.util.inspect.custom')]() {
+        const o = {};
+        ['entityName', 'key', 'index', 'payload']
+            .filter(k => this[k] !== undefined)
+            .forEach(k => o[k] = this[k]);
+        return `${this.constructor.name} ${inspect(o)}`;
+    }
+}

package/query/CriteriaNodeFactory.d.ts

@@ -0,0 +1,12 @@
+import { type Dictionary, type EntityKey, type EntityMetadata, type MetadataStorage } from '@mikro-orm/core';
+import type { ICriteriaNode } from '../typings.js';
+/**
+ * @internal
+ */
+export declare class CriteriaNodeFactory {
+    static createNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: any, parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
+    static createScalarNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: any, parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
+    static createArrayNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: any[], parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
+    static createObjectNode<T extends object>(metadata: MetadataStorage, entityName: string, payload: Dictionary, parent?: ICriteriaNode<T>, key?: EntityKey<T>): ICriteriaNode<T>;
+    static createObjectItemNode<T extends object>(metadata: MetadataStorage, entityName: string, node: ICriteriaNode<T>, payload: Dictionary, key: EntityKey<T>, meta?: EntityMetadata<T>): ICriteriaNode<T>;
+}

package/query/CriteriaNodeFactory.js

@@ -0,0 +1,90 @@
+import { GroupOperator, isRaw, JsonType, RawQueryFragment, ReferenceKind, Utils, ValidationError, } from '@mikro-orm/core';
+import { ObjectCriteriaNode } from './ObjectCriteriaNode.js';
+import { ArrayCriteriaNode } from './ArrayCriteriaNode.js';
+import { ScalarCriteriaNode } from './ScalarCriteriaNode.js';
+/**
+ * @internal
+ */
+export class CriteriaNodeFactory {
+    static createNode(metadata, entityName, payload, parent, key) {
+        const customExpression = RawQueryFragment.isKnownFragment(key || '');
+        const scalar = Utils.isPrimaryKey(payload) || isRaw(payload) || payload instanceof RegExp || payload instanceof Date || customExpression;
+        if (Array.isArray(payload) && !scalar) {
+            return this.createArrayNode(metadata, entityName, payload, parent, key);
+        }
+        if (Utils.isPlainObject(payload) && !scalar) {
+            return this.createObjectNode(metadata, entityName, payload, parent, key);
+        }
+        return this.createScalarNode(metadata, entityName, payload, parent, key);
+    }
+    static createScalarNode(metadata, entityName, payload, parent, key) {
+        const node = new ScalarCriteriaNode(metadata, entityName, parent, key);
+        node.payload = payload;
+        return node;
+    }
+    static createArrayNode(metadata, entityName, payload, parent, key) {
+        const node = new ArrayCriteriaNode(metadata, entityName, parent, key);
+        node.payload = payload.map((item, index) => {
+            const n = this.createNode(metadata, entityName, item, node);
+            // we care about branching only for $and
+            if (key === '$and' && payload.length > 1) {
+                n.index = index;
+            }
+            return n;
+        });
+        return node;
+    }
+    static createObjectNode(metadata, entityName, payload, parent, key) {
+        const meta = metadata.find(entityName);
+        const node = new ObjectCriteriaNode(metadata, entityName, parent, key, true, payload.__strict);
+        node.payload = {};
+        for (const key of Object.keys(payload)) {
+            node.payload[key] = this.createObjectItemNode(metadata, entityName, node, payload, key, meta);
+        }
+        return node;
+    }
+    static createObjectItemNode(metadata, entityName, node, payload, key, meta) {
+        const prop = meta?.properties[key];
+        const childEntity = prop && prop.kind !== ReferenceKind.SCALAR ? prop.type : entityName;
+        const isNotEmbedded = prop?.kind !== ReferenceKind.EMBEDDED;
+        if (isNotEmbedded && prop?.customType instanceof JsonType) {
+            return this.createScalarNode(metadata, childEntity, payload[key], node, key);
+        }
+        if (prop?.kind === ReferenceKind.SCALAR && payload[key] != null && Object.keys(payload[key]).some(f => f in GroupOperator)) {
+            throw ValidationError.cannotUseGroupOperatorsInsideScalars(entityName, prop.name, payload);
+        }
+        if (isNotEmbedded) {
+            return this.createNode(metadata, childEntity, payload[key], node, key);
+        }
+        if (payload[key] == null) {
+            const map = Object.keys(prop.embeddedProps).reduce((oo, k) => {
+                oo[prop.embeddedProps[k].name] = null;
+                return oo;
+            }, {});
+            return this.createNode(metadata, entityName, map, node, key);
+        }
+        // array operators can be used on embedded properties
+        const allowedOperators = ['$contains', '$contained', '$overlap'];
+        const operator = Object.keys(payload[key]).some(f => Utils.isOperator(f) && !allowedOperators.includes(f));
+        if (operator) {
+            throw ValidationError.cannotUseOperatorsInsideEmbeddables(entityName, prop.name, payload);
+        }
+        const map = Object.keys(payload[key]).reduce((oo, k) => {
+            const embeddedProp = prop.embeddedProps[k] ?? Object.values(prop.embeddedProps).find(p => p.name === k);
+            if (!embeddedProp && !allowedOperators.includes(k)) {
+                throw ValidationError.invalidEmbeddableQuery(entityName, k, prop.type);
+            }
+            if (embeddedProp) {
+                oo[embeddedProp.name] = payload[key][k];
+            }
+            else if (typeof payload[key][k] === 'object') {
+                oo[k] = JSON.stringify(payload[key][k]);
+            }
+            else {
+                oo[k] = payload[key][k];
+            }
+            return oo;
+        }, {});
+        return this.createNode(metadata, entityName, map, node, key);
+    }
+}

package/query/NativeQueryBuilder.d.ts

@@ -0,0 +1,108 @@
+import { type Dictionary, LockMode, type QueryFlag, RawQueryFragment } from '@mikro-orm/core';
+import { QueryType } from './enums.js';
+import type { AbstractSqlPlatform } from '../AbstractSqlPlatform.js';
+interface Options {
+    tableName?: string | RawQueryFragment;
+    indexHint?: string;
+    select?: (string | RawQueryFragment)[];
+    distinct?: boolean;
+    distinctOn?: string[];
+    joins?: {
+        sql: string;
+        params: unknown[];
+    }[];
+    groupBy?: (string | RawQueryFragment)[];
+    where?: {
+        sql: string;
+        params: unknown[];
+    };
+    having?: {
+        sql: string;
+        params: unknown[];
+    };
+    orderBy?: string;
+    limit?: number;
+    offset?: number;
+    data?: Dictionary;
+    onConflict?: OnConflictClause;
+    lockMode?: LockMode;
+    lockTables?: string[];
+    returning?: (string | RawQueryFragment)[];
+    comment?: string[];
+    hintComment?: string[];
+    flags?: Set<QueryFlag>;
+    wrap?: [prefix: string, suffix: string];
+}
+interface TableOptions {
+    schema?: string;
+    indexHint?: string;
+    alias?: string;
+}
+interface OnConflictClause {
+    fields: string[] | RawQueryFragment;
+    ignore?: boolean;
+    merge?: Dictionary | (string | RawQueryFragment)[];
+    where?: {
+        sql: string;
+        params: unknown[];
+    };
+}
+/** @internal */
+export declare class NativeQueryBuilder {
+    protected readonly platform: AbstractSqlPlatform;
+    protected type?: QueryType;
+    protected parts: string[];
+    protected params: unknown[];
+    protected options: Options;
+    constructor(platform: AbstractSqlPlatform);
+    select(fields: string | RawQueryFragment | (string | RawQueryFragment)[]): this;
+    count(fields?: string | RawQueryFragment | (string | RawQueryFragment)[], distinct?: boolean): this;
+    into(tableName: string | RawQueryFragment | NativeQueryBuilder, options?: TableOptions): this;
+    from(tableName: string | RawQueryFragment | NativeQueryBuilder, options?: TableOptions): this;
+    where(sql: string, params: unknown[]): this;
+    having(sql: string, params: unknown[]): this;
+    groupBy(groupBy: (string | RawQueryFragment)[]): this;
+    join(sql: string, params: unknown[]): this;
+    orderBy(orderBy: string): this;
+    toString(): string;
+    compile(): {
+        sql: string;
+        params: unknown[];
+    };
+    protected addLockClause(): void;
+    protected addOnConflictClause(): void;
+    protected combineParts(): {
+        sql: string;
+        params: unknown[];
+    };
+    limit(limit: number): this;
+    offset(offset: number): this;
+    insert(data: Dictionary): this;
+    update(data: Dictionary): this;
+    delete(): this;
+    truncate(): this;
+    distinct(): this;
+    distinctOn(fields: string[]): this;
+    onConflict(options: OnConflictClause): OnConflictClause;
+    returning(fields: (string | RawQueryFragment)[]): this;
+    lockMode(lockMode: LockMode, lockTables?: string[]): this;
+    comment(comment: string | string[]): this;
+    hintComment(comment: string | string[]): this;
+    setFlags(flags: Set<QueryFlag>): this;
+    clear(clause: keyof Options): this;
+    wrap(prefix: string, suffix: string): this;
+    as(alias: string): this;
+    toRaw(): RawQueryFragment;
+    protected compileSelect(): void;
+    protected getFields(): string;
+    protected compileInsert(): void;
+    protected addOutputClause(type: 'inserted' | 'deleted'): void;
+    protected processInsertData(): string[];
+    protected compileUpdate(): void;
+    protected compileDelete(): void;
+    protected compileTruncate(): void;
+    protected addHintComment(): void;
+    protected getTableName(): string;
+    protected quote(id: string | RawQueryFragment | NativeQueryBuilder): string;
+}
+export {};