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

package/types/BigIntType.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BigIntType = void 0;
+const Type_1 = require("./Type");
+/**
+ * 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`.
+ */
+class BigIntType extends Type_1.Type {
+    mode;
+    constructor(mode) {
+        super();
+        this.mode = mode;
+    }
+    convertToDatabaseValue(value) {
+        if (value == null) {
+            return value;
+        }
+        return '' + value;
+    }
+    convertToJSValue(value) {
+        if (value == null) {
+            return value;
+        }
+        switch (this.mode) {
+            case 'number':
+                return Number(value);
+            case 'string':
+                return String(value);
+            case 'bigint':
+            default:
+                return BigInt(value);
+        }
+    }
+    toJSON(value) {
+        return this.convertToDatabaseValue(value);
+    }
+    getColumnType(prop, platform) {
+        return platform.getBigIntTypeDeclarationSQL(prop);
+    }
+    compareAsType() {
+        return this.mode ?? 'bigint';
+    }
+}
+exports.BigIntType = BigIntType;

package/types/BlobType.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { Uint8ArrayType } from './Uint8ArrayType';
+import type { Platform } from '../platforms';
+import type { EntityProperty } from '../typings';
+export declare class BlobType extends Uint8ArrayType {
+    convertToJSValue(value: Buffer): Buffer | null;
+    compareAsType(): string;
+    ensureComparable(): boolean;
+    getColumnType(prop: EntityProperty, platform: Platform): string;
+}

package/types/BlobType.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlobType = void 0;
+const Uint8ArrayType_1 = require("./Uint8ArrayType");
+class BlobType extends Uint8ArrayType_1.Uint8ArrayType {
+    convertToJSValue(value) {
+        if (value instanceof Buffer || !value) {
+            return value;
+        }
+        /* istanbul ignore else */
+        if (value.buffer instanceof Buffer) {
+            return value.buffer;
+        }
+        /* istanbul ignore next */
+        return Buffer.from(value);
+    }
+    compareAsType() {
+        return 'Buffer';
+    }
+    ensureComparable() {
+        return false;
+    }
+    getColumnType(prop, platform) {
+        return platform.getBlobDeclarationSQL();
+    }
+}
+exports.BlobType = BlobType;

package/types/BooleanType.d.ts

@@ -0,0 +1,8 @@
+import { Type } from './Type';
+import type { Platform } from '../platforms';
+import type { EntityProperty } from '../typings';
+export declare class BooleanType extends Type<number | null | undefined, number | null | undefined> {
+    getColumnType(prop: EntityProperty, platform: Platform): string;
+    compareAsType(): string;
+    ensureComparable(): boolean;
+}

package/types/BooleanType.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BooleanType = void 0;
+const Type_1 = require("./Type");
+class BooleanType extends Type_1.Type {
+    getColumnType(prop, platform) {
+        return platform.getBooleanTypeDeclarationSQL();
+    }
+    compareAsType() {
+        return 'boolean';
+    }
+    ensureComparable() {
+        return false;
+    }
+}
+exports.BooleanType = BooleanType;

package/types/DateTimeType.d.ts

@@ -0,0 +1,8 @@
+import { Type } from './Type';
+import type { Platform } from '../platforms';
+import type { EntityProperty } from '../typings';
+export declare class DateTimeType extends Type<Date, string> {
+    getColumnType(prop: EntityProperty, platform: Platform): string;
+    compareAsType(): string;
+    ensureComparable(): boolean;
+}

package/types/DateTimeType.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateTimeType = void 0;
+const Type_1 = require("./Type");
+class DateTimeType extends Type_1.Type {
+    getColumnType(prop, platform) {
+        return platform.getDateTimeTypeDeclarationSQL({ length: prop.length });
+    }
+    compareAsType() {
+        return 'Date';
+    }
+    ensureComparable() {
+        return false;
+    }
+}
+exports.DateTimeType = DateTimeType;

package/types/DateType.d.ts

@@ -0,0 +1,8 @@
+import { Type } from './Type';
+import type { Platform } from '../platforms';
+import type { EntityProperty } from '../typings';
+export declare class DateType extends Type<string | null | undefined, string | null | undefined> {
+    compareAsType(): string;
+    ensureComparable(): boolean;
+    getColumnType(prop: EntityProperty, platform: Platform): string;
+}

package/types/DateType.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateType = void 0;
+const Type_1 = require("./Type");
+class DateType extends Type_1.Type {
+    compareAsType() {
+        return 'string';
+    }
+    ensureComparable() {
+        return false;
+    }
+    getColumnType(prop, platform) {
+        return platform.getDateTypeDeclarationSQL(prop.length);
+    }
+}
+exports.DateType = DateType;

package/types/DecimalType.d.ts

@@ -0,0 +1,11 @@
+import { Type } from './Type';
+import type { Platform } from '../platforms';
+import type { EntityProperty } from '../typings';
+/**
+ * Type that maps an SQL DECIMAL to a JS string or number.
+ */
+export declare class DecimalType extends Type<string | number, string> {
+    convertToJSValue(value: string): number | string;
+    getColumnType(prop: EntityProperty, platform: Platform): string;
+    compareAsType(): string;
+}

package/types/DecimalType.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DecimalType = void 0;
+const Type_1 = require("./Type");
+/**
+ * Type that maps an SQL DECIMAL to a JS string or number.
+ */
+class DecimalType extends Type_1.Type {
+    convertToJSValue(value) {
+        if (this.prop?.runtimeType === 'number') {
+            return +value;
+        }
+        return value;
+    }
+    getColumnType(prop, platform) {
+        return platform.getDecimalTypeDeclarationSQL(prop);
+    }
+    compareAsType() {
+        return this.prop?.runtimeType ?? 'string';
+    }
+}
+exports.DecimalType = DecimalType;

package/types/DoubleType.d.ts

@@ -0,0 +1,11 @@
+import { Type } from './Type';
+import type { Platform } from '../platforms';
+import type { EntityProperty } from '../typings';
+/**
+ * Type that maps an SQL DOUBLE to a JS string or number.
+ */
+export declare class DoubleType extends Type<number | string, string> {
+    convertToJSValue(value: string): number | string;
+    getColumnType(prop: EntityProperty, platform: Platform): string;
+    compareAsType(): string;
+}

package/types/DoubleType.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DoubleType = void 0;
+const Type_1 = require("./Type");
+/**
+ * Type that maps an SQL DOUBLE to a JS string or number.
+ */
+class DoubleType extends Type_1.Type {
+    convertToJSValue(value) {
+        if (this.prop?.runtimeType === 'number') {
+            return +value;
+        }
+        return value;
+    }
+    getColumnType(prop, platform) {
+        return platform.getDoubleDeclarationSQL();
+    }
+    compareAsType() {
+        return this.prop?.runtimeType ?? 'number';
+    }
+}
+exports.DoubleType = DoubleType;

package/types/EnumArrayType.d.ts

@@ -0,0 +1,9 @@
+import { ArrayType } from './ArrayType';
+import type { Platform } from '../platforms';
+import type { TransformContext } from './Type';
+export declare class EnumArrayType<T extends string | number = string> extends ArrayType<T> {
+    private readonly owner;
+    private readonly items?;
+    constructor(owner: string, items?: T[] | undefined, hydrate?: (i: string) => T);
+    convertToDatabaseValue(value: T[] | null, platform: Platform, context?: TransformContext): string | null;
+}

package/types/EnumArrayType.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnumArrayType = void 0;
+const util_1 = require("util");
+const ArrayType_1 = require("./ArrayType");
+const errors_1 = require("../errors");
+function mapHydrator(items, hydrate) {
+    if (items && items.length > 0 && typeof items[0] === 'number') {
+        return (i) => +i;
+    }
+    return hydrate;
+}
+class EnumArrayType extends ArrayType_1.ArrayType {
+    owner;
+    items;
+    constructor(owner, items, hydrate = i => i) {
+        super(mapHydrator(items, hydrate));
+        this.owner = owner;
+        this.items = items;
+    }
+    convertToDatabaseValue(value, platform, context) {
+        /* istanbul ignore else */
+        if (Array.isArray(value) && Array.isArray(this.items)) {
+            const invalid = value.filter(v => !this.items.includes(v));
+            if (invalid.length > 0) {
+                throw new errors_1.ValidationError(`Invalid enum array items provided in ${this.owner}: ${(0, util_1.inspect)(invalid)}`);
+            }
+        }
+        return super.convertToDatabaseValue(value, platform, context);
+    }
+}
+exports.EnumArrayType = EnumArrayType;

package/types/EnumType.d.ts

@@ -0,0 +1,8 @@
+import { Type } from './Type';
+import type { Platform } from '../platforms';
+import type { EntityProperty } from '../typings';
+export declare class EnumType extends Type<string | null | undefined> {
+    getColumnType(prop: EntityProperty, platform: Platform): string;
+    compareAsType(): string;
+    ensureComparable(): boolean;
+}

package/types/EnumType.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnumType = void 0;
+const Type_1 = require("./Type");
+class EnumType extends Type_1.Type {
+    getColumnType(prop, platform) {
+        return prop.columnTypes?.[0] ?? platform.getEnumTypeDeclarationSQL(prop);
+    }
+    compareAsType() {
+        return 'string';
+    }
+    ensureComparable() {
+        return false;
+    }
+}
+exports.EnumType = EnumType;

package/types/FloatType.d.ts

@@ -0,0 +1,8 @@
+import { Type } from './Type';
+import type { Platform } from '../platforms';
+import type { EntityProperty } from '../typings';
+export declare class FloatType extends Type<number | null | undefined, number | null | undefined> {
+    getColumnType(prop: EntityProperty, platform: Platform): string;
+    compareAsType(): string;
+    ensureComparable(): boolean;
+}

package/types/FloatType.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FloatType = void 0;
+const Type_1 = require("./Type");
+class FloatType extends Type_1.Type {
+    getColumnType(prop, platform) {
+        return platform.getFloatDeclarationSQL();
+    }
+    compareAsType() {
+        return 'number';
+    }
+    ensureComparable() {
+        return false;
+    }
+}
+exports.FloatType = FloatType;

package/types/IntegerType.d.ts

@@ -0,0 +1,8 @@
+import { Type } from './Type';
+import type { Platform } from '../platforms';
+import type { EntityProperty } from '../typings';
+export declare class IntegerType extends Type<number | null | undefined, number | null | undefined> {
+    getColumnType(prop: EntityProperty, platform: Platform): string;
+    compareAsType(): string;
+    ensureComparable(): boolean;
+}

package/types/IntegerType.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegerType = void 0;
+const Type_1 = require("./Type");
+class IntegerType extends Type_1.Type {
+    getColumnType(prop, platform) {
+        return platform.getIntegerTypeDeclarationSQL(prop);
+    }
+    compareAsType() {
+        return 'number';
+    }
+    ensureComparable() {
+        return false;
+    }
+}
+exports.IntegerType = IntegerType;

package/types/IntervalType.d.ts

@@ -0,0 +1,8 @@
+import { Type } from './Type';
+import type { Platform } from '../platforms';
+import type { EntityProperty } from '../typings';
+export declare class IntervalType extends Type<string | null | undefined, string | null | undefined> {
+    getColumnType(prop: EntityProperty, platform: Platform): string;
+    convertToJSValue(value: string | null | undefined, platform: Platform): string | null | undefined;
+    convertToDatabaseValue(value: string | null | undefined, platform: Platform): string | null | undefined;
+}

package/types/IntervalType.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntervalType = void 0;
+const Type_1 = require("./Type");
+class IntervalType extends Type_1.Type {
+    getColumnType(prop, platform) {
+        return platform.getIntervalTypeDeclarationSQL(prop);
+    }
+    convertToJSValue(value, platform) {
+        return platform.convertIntervalToJSValue(value);
+    }
+    convertToDatabaseValue(value, platform) {
+        return platform.convertIntervalToDatabaseValue(value);
+    }
+}
+exports.IntervalType = IntervalType;

package/types/JsonType.d.ts

@@ -0,0 +1,13 @@
+import { Type, type TransformContext } from './Type';
+import type { Platform } from '../platforms';
+import type { EntityMetadata, EntityProperty } from '../typings';
+export declare class JsonType extends Type<unknown, string | null> {
+    convertToDatabaseValue(value: unknown, platform: Platform, context?: TransformContext): string | null;
+    convertToJSValueSQL(key: string, platform: Platform): string;
+    convertToDatabaseValueSQL(key: string, platform: Platform): string;
+    convertToJSValue(value: string | unknown, platform: Platform): unknown;
+    getColumnType(prop: EntityProperty, platform: Platform): string;
+    ensureComparable<T extends object>(meta: EntityMetadata<T>, prop: EntityProperty<T>): boolean;
+    compareAsType(): string;
+    get runtimeType(): string;
+}

package/types/JsonType.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonType = void 0;
+const Type_1 = require("./Type");
+class JsonType extends Type_1.Type {
+    convertToDatabaseValue(value, platform, context) {
+        if (value == null) {
+            return value;
+        }
+        return platform.convertJsonToDatabaseValue(value, context);
+    }
+    convertToJSValueSQL(key, platform) {
+        return key + platform.castJsonValue(this.prop);
+    }
+    convertToDatabaseValueSQL(key, platform) {
+        return key + platform.castColumn(this.prop);
+    }
+    convertToJSValue(value, platform) {
+        return platform.convertJsonToJSValue(value);
+    }
+    getColumnType(prop, platform) {
+        return platform.getJsonDeclarationSQL();
+    }
+    ensureComparable(meta, prop) {
+        return !prop.embedded || !meta.properties[prop.embedded[0]].object;
+    }
+    compareAsType() {
+        return 'any';
+    }
+    get runtimeType() {
+        return 'object';
+    }
+}
+exports.JsonType = JsonType;

package/types/MediumIntType.d.ts

@@ -0,0 +1,6 @@
+import type { Platform } from '../platforms';
+import type { EntityProperty } from '../typings';
+import { IntegerType } from './IntegerType';
+export declare class MediumIntType extends IntegerType {
+    getColumnType(prop: EntityProperty, platform: Platform): string;
+}

package/types/MediumIntType.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MediumIntType = void 0;
+const IntegerType_1 = require("./IntegerType");
+class MediumIntType extends IntegerType_1.IntegerType {
+    getColumnType(prop, platform) {
+        return platform.getMediumIntTypeDeclarationSQL(prop);
+    }
+}
+exports.MediumIntType = MediumIntType;

package/types/SmallIntType.d.ts

@@ -0,0 +1,8 @@
+import { Type } from './Type';
+import type { Platform } from '../platforms';
+import type { EntityProperty } from '../typings';
+export declare class SmallIntType extends Type<number | null | undefined, number | null | undefined> {
+    getColumnType(prop: EntityProperty, platform: Platform): string;
+    compareAsType(): string;
+    ensureComparable(): boolean;
+}

package/types/SmallIntType.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmallIntType = void 0;
+const Type_1 = require("./Type");
+class SmallIntType extends Type_1.Type {
+    getColumnType(prop, platform) {
+        return platform.getSmallIntTypeDeclarationSQL(prop);
+    }
+    compareAsType() {
+        return 'number';
+    }
+    ensureComparable() {
+        return false;
+    }
+}
+exports.SmallIntType = SmallIntType;

package/types/StringType.d.ts

@@ -0,0 +1,8 @@
+import { Type } from './Type';
+import type { Platform } from '../platforms';
+import type { EntityProperty } from '../typings';
+export declare class StringType extends Type<string | null | undefined, string | null | undefined> {
+    getColumnType(prop: EntityProperty, platform: Platform): string;
+    compareAsType(): string;
+    ensureComparable(): boolean;
+}

package/types/StringType.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringType = void 0;
+const Type_1 = require("./Type");
+class StringType extends Type_1.Type {
+    getColumnType(prop, platform) {
+        return platform.getVarcharTypeDeclarationSQL(prop);
+    }
+    compareAsType() {
+        return 'string';
+    }
+    ensureComparable() {
+        return false;
+    }
+}
+exports.StringType = StringType;

package/types/TextType.d.ts

@@ -0,0 +1,8 @@
+import { Type } from './Type';
+import type { Platform } from '../platforms';
+import type { EntityProperty } from '../typings';
+export declare class TextType extends Type<string | null | undefined, string | null | undefined> {
+    getColumnType(prop: EntityProperty, platform: Platform): string;
+    compareAsType(): string;
+    ensureComparable(): boolean;
+}

package/types/TextType.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextType = void 0;
+const Type_1 = require("./Type");
+class TextType extends Type_1.Type {
+    getColumnType(prop, platform) {
+        return platform.getTextTypeDeclarationSQL(prop);
+    }
+    compareAsType() {
+        return 'string';
+    }
+    ensureComparable() {
+        return false;
+    }
+}
+exports.TextType = TextType;

package/types/TimeType.d.ts

@@ -0,0 +1,9 @@
+import { Type } from './Type';
+import type { Platform } from '../platforms';
+import type { EntityProperty } from '../typings';
+export declare class TimeType extends Type {
+    convertToDatabaseValue(value: any, platform: Platform): string;
+    compareAsType(): string;
+    ensureComparable(): boolean;
+    getColumnType(prop: EntityProperty, platform: Platform): string;
+}

package/types/TimeType.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeType = void 0;
+const Type_1 = require("./Type");
+const errors_1 = require("../errors");
+class TimeType extends Type_1.Type {
+    convertToDatabaseValue(value, platform) {
+        if (value && !value.toString().match(/^\d{2,}:(?:[0-5]\d):(?:[0-5]\d)$/)) {
+            throw errors_1.ValidationError.invalidType(TimeType, value, 'JS');
+        }
+        return super.convertToDatabaseValue(value, platform);
+    }
+    compareAsType() {
+        return 'string';
+    }
+    ensureComparable() {
+        return false;
+    }
+    getColumnType(prop, platform) {
+        return platform.getTimeTypeDeclarationSQL(prop.length);
+    }
+}
+exports.TimeType = TimeType;

package/types/TinyIntType.d.ts

@@ -0,0 +1,8 @@
+import { Type } from './Type';
+import type { Platform } from '../platforms';
+import type { EntityProperty } from '../typings';
+export declare class TinyIntType extends Type<number | null | undefined, number | null | undefined> {
+    getColumnType(prop: EntityProperty, platform: Platform): string;
+    compareAsType(): string;
+    ensureComparable(): boolean;
+}

package/types/TinyIntType.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TinyIntType = void 0;
+const Type_1 = require("./Type");
+class TinyIntType extends Type_1.Type {
+    getColumnType(prop, platform) {
+        return platform.getTinyIntTypeDeclarationSQL(prop);
+    }
+    compareAsType() {
+        return 'number';
+    }
+    ensureComparable() {
+        return false;
+    }
+}
+exports.TinyIntType = TinyIntType;