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

package/utils/clone.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Inspired by https://github.com/pvorb/clone but simplified and never tries to
+ * clone `EventEmitter`s to get around https://github.com/mikro-orm/mikro-orm/issues/2748
+ * @internal
+ */
+export declare function clone<T>(parent: T, respectCustomCloneMethod?: boolean): T;

package/utils/clone.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * Inspired by https://github.com/pvorb/clone but simplified and never tries to
+ * clone `EventEmitter`s to get around https://github.com/mikro-orm/mikro-orm/issues/2748
+ * @internal
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clone = void 0;
+const events_1 = require("events");
+const RawQueryFragment_1 = require("./RawQueryFragment");
+function clone(parent, respectCustomCloneMethod = true) {
+    const allParents = [];
+    const allChildren = [];
+    function _clone(parent) {
+        // cloning null always returns null
+        if (parent === null) {
+            return null;
+        }
+        const raw = RawQueryFragment_1.RawQueryFragment.getKnownFragment(parent, false);
+        if (raw) {
+            return raw.clone();
+        }
+        if (typeof parent !== 'object' || parent instanceof events_1.EventEmitter) {
+            return parent;
+        }
+        if (respectCustomCloneMethod && 'clone' in parent && typeof parent.clone === 'function') {
+            return parent.clone();
+        }
+        let child;
+        let proto;
+        if (parent instanceof Map) {
+            child = new Map();
+        }
+        else if (parent instanceof Set) {
+            child = new Set();
+        }
+        else if (parent instanceof Promise) {
+            child = new Promise((resolve, reject) => {
+                parent.then(resolve.bind(null, _clone), reject.bind(null, _clone));
+            });
+        }
+        else if (Array.isArray(parent)) {
+            child = [];
+        }
+        else if (parent instanceof RegExp) {
+            let flags = '';
+            if (parent.global) {
+                flags += 'g';
+            }
+            if (parent.ignoreCase) {
+                flags += 'i';
+            }
+            if (parent.multiline) {
+                flags += 'm';
+            }
+            child = new RegExp(parent.source, flags);
+            if (parent.lastIndex) {
+                child.lastIndex = parent.lastIndex;
+            }
+        }
+        else if (parent instanceof Date) {
+            child = new Date(parent.getTime());
+        }
+        else if (Buffer.isBuffer(parent)) {
+            child = Buffer.allocUnsafe(parent.length);
+            parent.copy(child);
+            return child;
+        }
+        else if (parent instanceof Error) {
+            child = Object.create(parent);
+        }
+        else {
+            proto = Object.getPrototypeOf(parent);
+            child = Object.create(proto);
+        }
+        const index = allParents.indexOf(parent);
+        if (index !== -1) {
+            return allChildren[index];
+        }
+        allParents.push(parent);
+        allChildren.push(child);
+        if (parent instanceof Map) {
+            parent.forEach((value, key) => {
+                const keyChild = _clone(key);
+                const valueChild = _clone(value);
+                child.set(keyChild, valueChild);
+            });
+        }
+        if (parent instanceof Set) {
+            parent.forEach((value) => {
+                const entryChild = _clone(value);
+                child.add(entryChild);
+            });
+        }
+        for (const i in parent) {
+            let attrs;
+            if (proto) {
+                attrs = Object.getOwnPropertyDescriptor(proto, i);
+            }
+            if (attrs && attrs.set == null) {
+                continue;
+            }
+            const raw = RawQueryFragment_1.RawQueryFragment.getKnownFragment(i, false);
+            if (raw) {
+                const i2 = raw.clone().toString();
+                child[i2] = _clone(parent[i]);
+                continue;
+            }
+            child[i] = _clone(parent[i]);
+        }
+        if (Object.getOwnPropertySymbols) {
+            const symbols = Object.getOwnPropertySymbols(parent);
+            for (let i = 0; i < symbols.length; i++) {
+                const symbol = symbols[i];
+                const descriptor = Object.getOwnPropertyDescriptor(parent, symbol);
+                /* istanbul ignore next */
+                if (descriptor && !descriptor.enumerable) {
+                    continue;
+                }
+                child[symbol] = _clone(parent[symbol]);
+            }
+        }
+        return child;
+    }
+    return _clone(parent);
+}
+exports.clone = clone;

package/utils/index.d.ts

@@ -0,0 +1,13 @@
+export * from './Configuration';
+export * from './ConfigurationLoader';
+export * from './Cursor';
+export * from './DataloaderUtils';
+export * from './Utils';
+export * from './RequestContext';
+export * from './TransactionContext';
+export * from './QueryHelper';
+export * from './NullHighlighter';
+export * from './EntityComparator';
+export * from './AbstractSchemaGenerator';
+export * from './RawQueryFragment';
+export * from './upsert-utils';

package/utils/index.js

@@ -0,0 +1,29 @@
+"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("./Configuration"), exports);
+__exportStar(require("./ConfigurationLoader"), exports);
+__exportStar(require("./Cursor"), exports);
+__exportStar(require("./DataloaderUtils"), exports);
+__exportStar(require("./Utils"), exports);
+__exportStar(require("./RequestContext"), exports);
+__exportStar(require("./TransactionContext"), exports);
+__exportStar(require("./QueryHelper"), exports);
+__exportStar(require("./NullHighlighter"), exports);
+__exportStar(require("./EntityComparator"), exports);
+__exportStar(require("./AbstractSchemaGenerator"), exports);
+__exportStar(require("./RawQueryFragment"), exports);
+__exportStar(require("./upsert-utils"), exports);

package/utils/upsert-utils.d.ts

@@ -0,0 +1,6 @@
+import type { EntityData, EntityMetadata } from '../typings';
+import type { UpsertOptions } from '../drivers/IDatabaseDriver';
+/** @internal */
+export declare function getOnConflictFields<T>(data: EntityData<T>, uniqueFields: (keyof T)[], options: UpsertOptions<T>): (keyof T)[];
+/** @internal */
+export declare function getOnConflictReturningFields<T>(meta: EntityMetadata<T> | undefined, data: EntityData<T>, uniqueFields: (keyof T)[], options: UpsertOptions<T>): (keyof T)[] | '*';

package/utils/upsert-utils.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOnConflictReturningFields = exports.getOnConflictFields = void 0;
+/** @internal */
+function getOnConflictFields(data, uniqueFields, options) {
+    if (options.onConflictMergeFields) {
+        return options.onConflictMergeFields;
+    }
+    const keys = Object.keys(data).filter(f => !uniqueFields.includes(f));
+    if (options.onConflictExcludeFields) {
+        return keys.filter(f => !options.onConflictExcludeFields.includes(f));
+    }
+    return keys;
+}
+exports.getOnConflictFields = getOnConflictFields;
+/** @internal */
+function getOnConflictReturningFields(meta, data, uniqueFields, options) {
+    if (!meta) {
+        return '*';
+    }
+    const keys = meta.comparableProps.filter(p => !p.lazy && !p.embeddable && !uniqueFields.includes(p.name)).map(p => p.name);
+    if (options.onConflictAction === 'ignore') {
+        return keys;
+    }
+    if (options.onConflictMergeFields) {
+        return keys.filter(key => !options.onConflictMergeFields.includes(key));
+    }
+    if (options.onConflictExcludeFields) {
+        return [...new Set(keys.concat(...options.onConflictExcludeFields))];
+    }
+    return keys.filter(key => !(key in data));
+}
+exports.getOnConflictReturningFields = getOnConflictReturningFields;