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

package/serialization/EntitySerializer.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serialize = exports.EntitySerializer = void 0;
+const wrap_1 = require("../entity/wrap");
+const Utils_1 = require("../utils/Utils");
+const enums_1 = require("../enums");
+const Reference_1 = require("../entity/Reference");
+const SerializationContext_1 = require("./SerializationContext");
+function isVisible(meta, propName, options) {
+    if (Array.isArray(options.populate) && options.populate?.find(item => item === propName || item.startsWith(propName + '.') || item === '*')) {
+        return true;
+    }
+    if (options.exclude?.find(item => item === propName)) {
+        return false;
+    }
+    const prop = meta.properties[propName];
+    const visible = prop && !prop.hidden;
+    const prefixed = prop && !prop.primary && propName.startsWith('_'); // ignore prefixed properties, if it's not a PK
+    return visible && !prefixed;
+}
+function isPopulated(propName, options) {
+    if (typeof options.populate !== 'boolean' && options.populate?.find(item => item === propName || item.startsWith(propName + '.') || item === '*')) {
+        return true;
+    }
+    if (typeof options.populate === 'boolean') {
+        return options.populate;
+    }
+    return false;
+}
+class EntitySerializer {
+    static serialize(entity, options = {}) {
+        const wrapped = (0, wrap_1.helper)(entity);
+        const meta = wrapped.__meta;
+        let contextCreated = false;
+        if (!wrapped.__serializationContext.root) {
+            const root = new SerializationContext_1.SerializationContext(wrapped.__config);
+            SerializationContext_1.SerializationContext.propagate(root, entity, (meta, prop) => meta.properties[prop]?.kind !== enums_1.ReferenceKind.SCALAR);
+            options.populate = (options.populate ? Utils_1.Utils.asArray(options.populate) : options.populate);
+            contextCreated = true;
+        }
+        const root = wrapped.__serializationContext.root;
+        const ret = {};
+        const keys = new Set(meta.primaryKeys);
+        Utils_1.Utils.keys(entity).forEach(prop => keys.add(prop));
+        const visited = root.visited.has(entity);
+        if (!visited) {
+            root.visited.add(entity);
+        }
+        [...keys]
+            .filter(prop => isVisible(meta, prop, options))
+            .map(prop => {
+            const cycle = root.visit(meta.className, prop);
+            if (cycle && visited) {
+                return [prop, undefined];
+            }
+            const val = this.processProperty(prop, entity, options);
+            if (!cycle) {
+                root.leave(meta.className, prop);
+            }
+            if (options.skipNull && Utils_1.Utils.isPlainObject(val)) {
+                Utils_1.Utils.dropUndefinedProperties(val, null);
+            }
+            return [prop, val];
+        })
+            .filter(([, value]) => typeof value !== 'undefined' && !(value === null && options.skipNull))
+            .forEach(([prop, value]) => ret[this.propertyName(meta, prop, wrapped.__platform)] = value);
+        if (contextCreated) {
+            root.close();
+        }
+        if (!wrapped.isInitialized()) {
+            return ret;
+        }
+        // decorated getters
+        meta.props
+            .filter(prop => prop.getter && prop.getterName === undefined && typeof entity[prop.name] !== 'undefined' && isVisible(meta, prop.name, options))
+            // @ts-ignore
+            .forEach(prop => ret[this.propertyName(meta, prop.name, wrapped.__platform)] = this.processProperty(prop.name, entity, options));
+        // decorated get methods
+        meta.props
+            .filter(prop => prop.getterName && entity[prop.getterName] instanceof Function && isVisible(meta, prop.name, options))
+            // @ts-ignore
+            .forEach(prop => ret[this.propertyName(meta, prop.name, wrapped.__platform)] = this.processProperty(prop.getterName, entity, options));
+        return ret;
+    }
+    static propertyName(meta, prop, platform) {
+        /* istanbul ignore next */
+        if (meta.properties[prop]?.serializedName) {
+            return meta.properties[prop].serializedName;
+        }
+        if (meta.properties[prop]?.primary && platform) {
+            return platform.getSerializedPrimaryKeyField(prop);
+        }
+        return prop;
+    }
+    static processProperty(prop, entity, options) {
+        const parts = prop.split('.');
+        prop = parts[0];
+        const wrapped = (0, wrap_1.helper)(entity);
+        const property = wrapped.__meta.properties[prop];
+        const serializer = property?.serializer;
+        const value = entity[prop];
+        // getter method
+        if (entity[prop] instanceof Function) {
+            const returnValue = entity[prop]();
+            if (!options.ignoreSerializers && serializer) {
+                return serializer(returnValue);
+            }
+            return returnValue;
+        }
+        /* istanbul ignore next */
+        if (!options.ignoreSerializers && serializer) {
+            return serializer(value);
+        }
+        if (Utils_1.Utils.isCollection(value)) {
+            return this.processCollection(prop, entity, options);
+        }
+        if (Utils_1.Utils.isEntity(value, true)) {
+            return this.processEntity(prop, entity, wrapped.__platform, options);
+        }
+        if (Utils_1.Utils.isScalarReference(value)) {
+            return value.unwrap();
+        }
+        /* istanbul ignore next */
+        if (property?.kind === enums_1.ReferenceKind.EMBEDDED) {
+            if (Array.isArray(value)) {
+                return value.map(item => (0, wrap_1.helper)(item).toJSON());
+            }
+            if (Utils_1.Utils.isObject(value)) {
+                return (0, wrap_1.helper)(value).toJSON();
+            }
+        }
+        const customType = property?.customType;
+        if (customType) {
+            return customType.toJSON(value, wrapped.__platform);
+        }
+        return wrapped.__platform.normalizePrimaryKey(value);
+    }
+    static extractChildOptions(options, prop) {
+        return {
+            ...options,
+            populate: Array.isArray(options.populate) ? Utils_1.Utils.extractChildElements(options.populate, prop, '*') : options.populate,
+            exclude: Array.isArray(options.exclude) ? Utils_1.Utils.extractChildElements(options.exclude, prop) : options.exclude,
+        };
+    }
+    static processEntity(prop, entity, platform, options) {
+        const child = Reference_1.Reference.unwrapReference(entity[prop]);
+        const wrapped = (0, wrap_1.helper)(child);
+        const populated = isPopulated(prop, options) && wrapped.isInitialized();
+        const expand = populated || !wrapped.__managed;
+        const meta = wrapped.__meta;
+        const childOptions = this.extractChildOptions(options, prop);
+        const visible = meta.primaryKeys.filter(prop => isVisible(meta, prop, childOptions));
+        if (expand) {
+            return this.serialize(child, childOptions);
+        }
+        const pk = wrapped.getPrimaryKey(true);
+        if (options.forceObject || wrapped.__config.get('serialization').forceObject) {
+            return Utils_1.Utils.primaryKeyToObject(meta, pk, visible);
+        }
+        if (Utils_1.Utils.isPlainObject(pk)) {
+            const pruned = Utils_1.Utils.primaryKeyToObject(meta, pk, visible);
+            if (visible.length === 1) {
+                return platform.normalizePrimaryKey(pruned[visible[0]]);
+            }
+            return pruned;
+        }
+        return platform.normalizePrimaryKey(pk);
+    }
+    static processCollection(prop, entity, options) {
+        const col = entity[prop];
+        if (!col.isInitialized()) {
+            return undefined;
+        }
+        return col.getItems(false).map(item => {
+            const populated = isPopulated(prop, options);
+            const wrapped = (0, wrap_1.helper)(item);
+            if (populated || !wrapped.__managed) {
+                return this.serialize(item, this.extractChildOptions(options, prop));
+            }
+            if (options.forceObject || wrapped.__config.get('serialization').forceObject) {
+                return Utils_1.Utils.primaryKeyToObject(wrapped.__meta, wrapped.getPrimaryKey(true));
+            }
+            return (0, wrap_1.helper)(item).getPrimaryKey();
+        });
+    }
+}
+exports.EntitySerializer = EntitySerializer;
+/**
+ * Converts entity instance to POJO, converting the `Collection`s to arrays and unwrapping the `Reference` wrapper, while respecting the serialization options.
+ * This method accepts either a single entity or an array of entities, and returns the corresponding POJO or an array of POJO.
+ * To serialize a single entity, you can also use `wrap(entity).serialize()` which handles a single entity only.
+ *
+ * ```ts
+ * const dtos = serialize([user1, user, ...], { exclude: ['id', 'email'], forceObject: true });
+ * const [dto2, dto3] = serialize([user2, user3], { exclude: ['id', 'email'], forceObject: true });
+ * const dto1 = serialize(user, { exclude: ['id', 'email'], forceObject: true });
+ * const dto2 = wrap(user).serialize({ exclude: ['id', 'email'], forceObject: true });
+ * ```
+ */
+function serialize(entities, options) {
+    if (Array.isArray(entities)) {
+        return entities.map(e => EntitySerializer.serialize(e, options));
+    }
+    return EntitySerializer.serialize(entities, options);
+}
+exports.serialize = serialize;

package/serialization/EntityTransformer.d.ts

@@ -0,0 +1,8 @@
+import type { EntityDTO, EntityKey } from '../typings';
+export declare class EntityTransformer {
+    static toObject<Entity extends object, Ignored extends EntityKey<Entity> = never>(entity: Entity, ignoreFields?: Ignored[], raw?: boolean): Omit<EntityDTO<Entity>, Ignored>;
+    private static propertyName;
+    private static processProperty;
+    private static processEntity;
+    private static processCollection;
+}

package/serialization/EntityTransformer.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityTransformer = void 0;
+const wrap_1 = require("../entity/wrap");
+const Utils_1 = require("../utils/Utils");
+const enums_1 = require("../enums");
+const SerializationContext_1 = require("./SerializationContext");
+function isVisible(meta, propName, ignoreFields = []) {
+    const prop = meta.properties[propName];
+    const visible = prop && !prop.hidden;
+    const prefixed = prop && !prop.primary && propName.startsWith('_'); // ignore prefixed properties, if it's not a PK
+    return visible && !prefixed && !ignoreFields.includes(propName);
+}
+class EntityTransformer {
+    static toObject(entity, ignoreFields = [], raw = false) {
+        if (!Array.isArray(ignoreFields)) {
+            ignoreFields = [];
+        }
+        const wrapped = (0, wrap_1.helper)(entity);
+        let contextCreated = false;
+        if (!wrapped.__serializationContext.root) {
+            const root = new SerializationContext_1.SerializationContext(wrapped.__config, wrapped.__serializationContext.populate, wrapped.__serializationContext.fields, wrapped.__serializationContext.exclude);
+            SerializationContext_1.SerializationContext.propagate(root, entity, isVisible);
+            contextCreated = true;
+        }
+        const root = wrapped.__serializationContext.root;
+        const meta = wrapped.__meta;
+        const ret = {};
+        const keys = new Set();
+        if (meta.serializedPrimaryKey && !meta.compositePK) {
+            keys.add(meta.serializedPrimaryKey);
+        }
+        else {
+            meta.primaryKeys.forEach(pk => keys.add(pk));
+        }
+        if (wrapped.isInitialized() || !wrapped.hasPrimaryKey()) {
+            Utils_1.Utils.keys(entity).forEach(prop => keys.add(prop));
+        }
+        const visited = root.visited.has(entity);
+        if (!visited) {
+            root.visited.add(entity);
+        }
+        [...keys]
+            .filter(prop => raw ? meta.properties[prop] : isVisible(meta, prop, ignoreFields))
+            .map(prop => {
+            const populated = root.isMarkedAsPopulated(meta.className, prop);
+            const partiallyLoaded = root.isPartiallyLoaded(meta.className, prop);
+            const isPrimary = wrapped.__config.get('serialization').includePrimaryKeys && meta.properties[prop].primary;
+            if (!partiallyLoaded && !populated && !isPrimary) {
+                return [prop, undefined];
+            }
+            const cycle = root.visit(meta.className, prop);
+            if (cycle && visited) {
+                return [prop, undefined];
+            }
+            const val = EntityTransformer.processProperty(prop, entity, raw, populated);
+            if (!cycle) {
+                root.leave(meta.className, prop);
+            }
+            return [prop, val];
+        })
+            .filter(([, value]) => typeof value !== 'undefined')
+            .forEach(([prop, value]) => ret[this.propertyName(meta, prop, wrapped.__platform)] = value);
+        if (!visited) {
+            root.visited.delete(entity);
+        }
+        if (!wrapped.isInitialized() && wrapped.hasPrimaryKey()) {
+            return ret;
+        }
+        // decorated getters
+        meta.props
+            .filter(prop => prop.getter && prop.getterName === undefined && !prop.hidden && typeof entity[prop.name] !== 'undefined')
+            // @ts-ignore
+            .forEach(prop => ret[this.propertyName(meta, prop.name, wrapped.__platform)] = this.processProperty(prop.name, entity, raw));
+        // decorated get methods
+        meta.props
+            .filter(prop => prop.getterName && !prop.hidden && entity[prop.getterName] instanceof Function)
+            // @ts-ignore
+            .forEach(prop => ret[this.propertyName(meta, prop.name, wrapped.__platform)] = this.processProperty(prop.getterName, entity, raw));
+        if (contextCreated) {
+            root.close();
+        }
+        return ret;
+    }
+    static propertyName(meta, prop, platform) {
+        if (meta.properties[prop].serializedName) {
+            return meta.properties[prop].serializedName;
+        }
+        if (meta.properties[prop].primary && platform) {
+            return platform.getSerializedPrimaryKeyField(prop);
+        }
+        return prop;
+    }
+    static processProperty(prop, entity, raw, populated) {
+        const wrapped = (0, wrap_1.helper)(entity);
+        const property = wrapped.__meta.properties[prop];
+        const serializer = property?.serializer;
+        const value = entity[prop];
+        // getter method
+        if (entity[prop] instanceof Function) {
+            const returnValue = entity[prop]();
+            if (serializer) {
+                return serializer(returnValue);
+            }
+            return returnValue;
+        }
+        if (serializer) {
+            return serializer(value);
+        }
+        if (Utils_1.Utils.isCollection(value)) {
+            return EntityTransformer.processCollection(prop, entity, raw, populated);
+        }
+        if (Utils_1.Utils.isEntity(value, true)) {
+            return EntityTransformer.processEntity(prop, entity, wrapped.__platform, raw, populated);
+        }
+        if (Utils_1.Utils.isScalarReference(value)) {
+            return value.unwrap();
+        }
+        if (property.kind === enums_1.ReferenceKind.EMBEDDED) {
+            if (Array.isArray(value)) {
+                return value.map(item => {
+                    const wrapped = item && (0, wrap_1.helper)(item);
+                    return wrapped ? wrapped.toJSON() : item;
+                });
+            }
+            const wrapped = value && (0, wrap_1.helper)(value);
+            return wrapped ? wrapped.toJSON() : value;
+        }
+        const customType = property?.customType;
+        if (customType) {
+            return customType.toJSON(value, wrapped.__platform);
+        }
+        if (property?.primary) {
+            return wrapped.__platform.normalizePrimaryKey(value);
+        }
+        return value;
+    }
+    static processEntity(prop, entity, platform, raw, populated) {
+        const child = entity[prop];
+        const wrapped = (0, wrap_1.helper)(child);
+        const meta = wrapped.__meta;
+        const visible = meta.primaryKeys.filter(prop => isVisible(meta, prop));
+        if (raw && wrapped.isInitialized() && child !== entity) {
+            return wrapped.toPOJO();
+        }
+        function isPopulated() {
+            if (wrapped.__populated != null) {
+                return wrapped.__populated;
+            }
+            if (populated) {
+                return true;
+            }
+            return !wrapped.__managed;
+        }
+        if (wrapped.isInitialized() && isPopulated() && child !== entity) {
+            return (0, wrap_1.wrap)(child).toJSON();
+        }
+        const pk = wrapped.getPrimaryKey(true);
+        if (wrapped.__config.get('serialization').forceObject) {
+            return Utils_1.Utils.primaryKeyToObject(meta, pk, visible);
+        }
+        if (Utils_1.Utils.isPlainObject(pk)) {
+            const pruned = Utils_1.Utils.primaryKeyToObject(meta, pk, visible);
+            if (visible.length === 1) {
+                return platform.normalizePrimaryKey(pruned[visible[0]]);
+            }
+            return pruned;
+        }
+        return platform.normalizePrimaryKey(pk);
+    }
+    static processCollection(prop, entity, raw, populated) {
+        const col = entity[prop];
+        if (raw && col.isInitialized(true)) {
+            return col.map(item => (0, wrap_1.helper)(item).toPOJO());
+        }
+        if (col.shouldPopulate(populated)) {
+            return col.toArray();
+        }
+        if (col.isInitialized()) {
+            const wrapped = (0, wrap_1.helper)(entity);
+            if (wrapped.__config.get('serialization').forceObject) {
+                return col.map(item => {
+                    const wrapped = (0, wrap_1.helper)(item);
+                    return Utils_1.Utils.primaryKeyToObject(wrapped.__meta, wrapped.getPrimaryKey(true));
+                });
+            }
+            return col.map(i => (0, wrap_1.helper)(i).getPrimaryKey(true));
+        }
+        return undefined;
+    }
+}
+exports.EntityTransformer = EntityTransformer;

package/serialization/SerializationContext.d.ts

@@ -0,0 +1,30 @@
+import type { AnyEntity, EntityMetadata, PopulateOptions } from '../typings';
+import type { Configuration } from '../utils/Configuration';
+/**
+ * Helper that allows to keep track of where we are currently at when serializing complex entity graph with cycles.
+ * Before we process a property, we call `visit` that checks if it is not a cycle path (but allows to pass cycles that
+ * are defined in populate hint). If not, we proceed and call `leave` afterwards.
+ */
+export declare class SerializationContext<T> {
+    private readonly config;
+    private readonly populate;
+    private readonly fields?;
+    private readonly exclude?;
+    readonly path: [string, string][];
+    readonly visited: Set<Partial<any>>;
+    private entities;
+    constructor(config: Configuration, populate?: PopulateOptions<T>[], fields?: Set<string> | undefined, exclude?: string[] | undefined);
+    /**
+     * Returns true when there is a cycle detected.
+     */
+    visit(entityName: string, prop: string): boolean;
+    leave<U>(entityName: string, prop: string): void;
+    close(): void;
+    /**
+     * When initializing new context, we need to propagate it to the whole entity graph recursively.
+     */
+    static propagate(root: SerializationContext<AnyEntity>, entity: AnyEntity, isVisible: (meta: EntityMetadata, prop: string) => boolean): void;
+    isMarkedAsPopulated(entityName: string, prop: string): boolean;
+    isPartiallyLoaded(entityName: string, prop: string): boolean;
+    private register;
+}

package/serialization/SerializationContext.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializationContext = void 0;
+const Utils_1 = require("../utils/Utils");
+const wrap_1 = require("../entity/wrap");
+/**
+ * Helper that allows to keep track of where we are currently at when serializing complex entity graph with cycles.
+ * Before we process a property, we call `visit` that checks if it is not a cycle path (but allows to pass cycles that
+ * are defined in populate hint). If not, we proceed and call `leave` afterwards.
+ */
+class SerializationContext {
+    config;
+    populate;
+    fields;
+    exclude;
+    path = [];
+    visited = new Set();
+    entities = new Set();
+    constructor(config, populate = [], fields, exclude) {
+        this.config = config;
+        this.populate = populate;
+        this.fields = fields;
+        this.exclude = exclude;
+    }
+    /**
+     * Returns true when there is a cycle detected.
+     */
+    visit(entityName, prop) {
+        if (!this.path.find(([cls, item]) => entityName === cls && prop === item)) {
+            this.path.push([entityName, prop]);
+            return false;
+        }
+        // check if the path is explicitly populated
+        if (!this.isMarkedAsPopulated(entityName, prop)) {
+            return true;
+        }
+        this.path.push([entityName, prop]);
+        return false;
+    }
+    leave(entityName, prop) {
+        const last = this.path.pop();
+        /* istanbul ignore next */
+        if (!last || last[0] !== entityName || last[1] !== prop) {
+            throw new Error(`Trying to leave wrong property: ${entityName}.${prop} instead of ${last?.join('.')}`);
+        }
+    }
+    close() {
+        this.entities.forEach(entity => {
+            delete (0, wrap_1.helper)(entity).__serializationContext.root;
+        });
+    }
+    /**
+     * When initializing new context, we need to propagate it to the whole entity graph recursively.
+     */
+    static propagate(root, entity, isVisible) {
+        root.register(entity);
+        const meta = (0, wrap_1.helper)(entity).__meta;
+        const items = [];
+        Object.keys(entity)
+            .filter(key => isVisible(meta, key))
+            .forEach(key => {
+            if (Utils_1.Utils.isEntity(entity[key], true)) {
+                items.push(entity[key]);
+            }
+            else if (Utils_1.Utils.isCollection(entity[key])) {
+                items.push(...entity[key].getItems(false));
+            }
+        });
+        items
+            .filter(item => !item.__helper.__serializationContext.root)
+            .forEach(item => this.propagate(root, item, isVisible));
+    }
+    isMarkedAsPopulated(entityName, prop) {
+        let populate = this.populate;
+        for (const segment of this.path) {
+            if (!populate) {
+                return false;
+            }
+            const exists = populate.find(p => p.field === segment[1]);
+            if (exists) {
+                // we need to check for cycles here too, as we could fall into endless loops for bidirectional relations
+                if (exists.all) {
+                    return !this.path.find(([cls, item]) => entityName === cls && prop === item);
+                }
+                populate = exists.children;
+            }
+        }
+        return !!populate?.some(p => p.field === prop);
+    }
+    isPartiallyLoaded(entityName, prop) {
+        if (!this.fields) {
+            return true;
+        }
+        let fields = [...this.fields];
+        for (const segment of this.path) {
+            /* istanbul ignore next */
+            if (fields.length === 0) {
+                return true;
+            }
+            fields = fields
+                .filter(field => field.startsWith(`${segment[1]}.`) || field === '*')
+                .map(field => field === '*' ? field : field.substring(segment[1].length + 1));
+        }
+        return fields.some(p => p === prop || p === '*');
+    }
+    register(entity) {
+        (0, wrap_1.helper)(entity).__serializationContext.root = this;
+        this.entities.add(entity);
+    }
+}
+exports.SerializationContext = SerializationContext;

package/serialization/index.d.ts

@@ -0,0 +1,3 @@
+export * from './EntityTransformer';
+export * from './EntitySerializer';
+export * from './SerializationContext';

package/serialization/index.js

@@ -0,0 +1,19 @@
+"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("./EntityTransformer"), exports);
+__exportStar(require("./EntitySerializer"), exports);
+__exportStar(require("./SerializationContext"), exports);

package/types/ArrayType.d.ts

@@ -0,0 +1,13 @@
+import { Type, type TransformContext } from './Type';
+import type { EntityProperty } from '../typings';
+import type { Platform } from '../platforms';
+export declare class ArrayType<T = string> extends Type<T[] | null, string | null> {
+    private readonly toJsValue;
+    private readonly toDbValue;
+    constructor(toJsValue?: (i: string) => T, toDbValue?: (i: T) => string);
+    convertToDatabaseValue(value: T[] | null, platform: Platform, context?: TransformContext): string | null;
+    convertToJSValue(value: T[] | string | null, platform: Platform): T[] | null;
+    compareAsType(): string;
+    toJSON(value: T[]): T[];
+    getColumnType(prop: EntityProperty, platform: Platform): string;
+}

package/types/ArrayType.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayType = void 0;
+const Type_1 = require("./Type");
+const utils_1 = require("../utils");
+const errors_1 = require("../errors");
+class ArrayType extends Type_1.Type {
+    toJsValue;
+    toDbValue;
+    constructor(toJsValue = i => i, toDbValue = i => i) {
+        super();
+        this.toJsValue = toJsValue;
+        this.toDbValue = toDbValue;
+    }
+    convertToDatabaseValue(value, platform, context) {
+        if (!value) {
+            return value;
+        }
+        if (Array.isArray(value)) {
+            return platform.marshallArray(value.map(i => this.toDbValue(i)));
+        }
+        /* istanbul ignore next */
+        if (context?.fromQuery) {
+            return value;
+        }
+        throw errors_1.ValidationError.invalidType(ArrayType, value, 'JS');
+    }
+    convertToJSValue(value, platform) {
+        if (value == null) {
+            return value;
+        }
+        if (utils_1.Utils.isString(value)) {
+            value = platform.unmarshallArray(value);
+        }
+        return value.map(i => this.toJsValue(i));
+    }
+    compareAsType() {
+        return 'string[]';
+    }
+    toJSON(value) {
+        return value;
+    }
+    getColumnType(prop, platform) {
+        return platform.getArrayDeclarationSQL();
+    }
+}
+exports.ArrayType = ArrayType;

package/types/BigIntType.d.ts

@@ -0,0 +1,16 @@
+import { Type } from './Type';
+import type { Platform } from '../platforms';
+import type { EntityProperty } from '../typings';
+/**
+ * This type will automatically convert string values returned from the database to native JS bigints (default)
+ * or numbers (safe only for values up to `Number.MAX_SAFE_INTEGER`), or strings, depending on the `mode`.
+ */
+export declare class BigIntType extends Type<string | bigint | number | null | undefined, string | null | undefined> {
+    mode?: "string" | "number" | "bigint" | undefined;
+    constructor(mode?: "string" | "number" | "bigint" | undefined);
+    convertToDatabaseValue(value: string | bigint | null | undefined): string | null | undefined;
+    convertToJSValue(value: string | bigint | null | undefined): bigint | number | string | null | undefined;
+    toJSON(value: string | bigint | null | undefined): string | bigint | null | undefined;
+    getColumnType(prop: EntityProperty, platform: Platform): string;
+    compareAsType(): string;
+}