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

package/types/Type.d.ts

@@ -0,0 +1,64 @@
+/// <reference types="node" />
+import { inspect } from 'util';
+import type { Platform } from '../platforms';
+import type { Constructor, EntityMetadata, EntityProperty } from '../typings';
+export interface TransformContext {
+    fromQuery?: boolean;
+    key?: string;
+    mode?: 'hydration' | 'query' | 'query-data' | 'discovery' | 'serialization';
+}
+export declare abstract class Type<JSType = string, DBType = JSType> {
+    private static readonly types;
+    platform?: Platform;
+    meta?: EntityMetadata;
+    prop?: EntityProperty;
+    /**
+     * Converts a value from its JS representation to its database representation of this type.
+     */
+    convertToDatabaseValue(value: JSType, platform: Platform, context?: TransformContext): DBType;
+    /**
+     * Converts a value from its database representation to its JS representation of this type.
+     */
+    convertToJSValue(value: DBType, platform: Platform): JSType;
+    /**
+     * Converts a value from its JS representation to its database representation of this type.
+     */
+    convertToDatabaseValueSQL?(key: string, platform: Platform): string;
+    /**
+     * Modifies the SQL expression (identifier, parameter) to convert to a JS value.
+     */
+    convertToJSValueSQL?(key: string, platform: Platform): string;
+    /**
+     * How should the raw database values be compared? Used in `EntityComparator`.
+     * Possible values: string | number | boolean | date | any | buffer | array
+     */
+    compareAsType(): string;
+    /**
+     * Allows to override the internal comparison logic.
+     */
+    compareValues?(a: DBType, b: DBType): boolean;
+    get runtimeType(): string;
+    get name(): string;
+    /**
+     * When a value is hydrated, we convert it back to the database value to ensure comparability,
+     * as often the raw database response is not the same as the `convertToDatabaseValue` result.
+     * This allows to disable the additional conversion in case you know it is not needed.
+     */
+    ensureComparable<T extends object>(meta: EntityMetadata<T>, prop: EntityProperty<T>): boolean;
+    /**
+     * Converts a value from its JS representation to its serialized JSON form of this type.
+     * By default uses the runtime value.
+     */
+    toJSON(value: JSType, platform: Platform): JSType | DBType;
+    /**
+     * Gets the SQL declaration snippet for a field of this type.
+     */
+    getColumnType(prop: EntityProperty, platform: Platform): string;
+    static getType<JSType, DBType = JSType>(cls: Constructor<Type<JSType, DBType>>): Type<JSType, DBType>;
+    /**
+     * Checks whether the argument is instance of `Type`.
+     */
+    static isMappedType(data: any): data is Type<any>;
+    /** @ignore */
+    [inspect.custom](depth: number): string;
+}

package/types/Type.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Type = void 0;
+const util_1 = require("util");
+class Type {
+    static types = new Map();
+    platform;
+    meta;
+    prop;
+    /**
+     * Converts a value from its JS representation to its database representation of this type.
+     */
+    convertToDatabaseValue(value, platform, context) {
+        return value;
+    }
+    /**
+     * Converts a value from its database representation to its JS representation of this type.
+     */
+    convertToJSValue(value, platform) {
+        return value;
+    }
+    /**
+     * How should the raw database values be compared? Used in `EntityComparator`.
+     * Possible values: string | number | boolean | date | any | buffer | array
+     */
+    compareAsType() {
+        return 'any';
+    }
+    get runtimeType() {
+        const compareType = this.compareAsType();
+        return compareType === 'any' ? 'string' : compareType;
+    }
+    get name() {
+        return this.constructor.name;
+    }
+    /**
+     * When a value is hydrated, we convert it back to the database value to ensure comparability,
+     * as often the raw database response is not the same as the `convertToDatabaseValue` result.
+     * This allows to disable the additional conversion in case you know it is not needed.
+     */
+    ensureComparable(meta, prop) {
+        return true;
+    }
+    /**
+     * Converts a value from its JS representation to its serialized JSON form of this type.
+     * By default uses the runtime value.
+     */
+    toJSON(value, platform) {
+        return value;
+    }
+    /**
+     * Gets the SQL declaration snippet for a field of this type.
+     */
+    getColumnType(prop, platform) {
+        return prop.columnTypes?.[0] ?? platform.getTextTypeDeclarationSQL(prop);
+    }
+    static getType(cls) {
+        const key = cls.name;
+        if (!Type.types.has(key)) {
+            Type.types.set(key, new cls());
+        }
+        return Type.types.get(key);
+    }
+    /**
+     * Checks whether the argument is instance of `Type`.
+     */
+    static isMappedType(data) {
+        return !!data?.__mappedType;
+    }
+    /** @ignore */
+    [util_1.inspect.custom](depth) {
+        const object = { ...this };
+        const hidden = ['prop', 'platform', 'meta'];
+        hidden.forEach(k => delete object[k]);
+        const ret = (0, util_1.inspect)(object, { depth });
+        const name = this.constructor.name;
+        /* istanbul ignore next */
+        return ret === '[Object]' ? `[${name}]` : name + ' ' + ret;
+    }
+}
+exports.Type = Type;
+Object.defineProperties(Type.prototype, {
+    __mappedType: { value: true, enumerable: false, writable: false },
+});

package/types/Uint8ArrayType.d.ts

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

package/types/Uint8ArrayType.js

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

package/types/UnknownType.d.ts

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

package/types/UnknownType.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownType = void 0;
+const StringType_1 = require("./StringType");
+class UnknownType extends StringType_1.StringType {
+    getColumnType(prop, platform) {
+        return prop.columnTypes?.[0] ?? platform.getVarcharTypeDeclarationSQL(prop);
+    }
+    compareAsType() {
+        return 'unknown';
+    }
+}
+exports.UnknownType = UnknownType;

package/types/UuidType.d.ts

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

package/types/UuidType.js

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

package/types/index.d.ts

@@ -0,0 +1,75 @@
+import { Type, TransformContext } from './Type';
+import { DateType } from './DateType';
+import { TimeType } from './TimeType';
+import { DateTimeType } from './DateTimeType';
+import { BigIntType } from './BigIntType';
+import { BlobType } from './BlobType';
+import { Uint8ArrayType } from './Uint8ArrayType';
+import { ArrayType } from './ArrayType';
+import { EnumArrayType } from './EnumArrayType';
+import { EnumType } from './EnumType';
+import { JsonType } from './JsonType';
+import { IntegerType } from './IntegerType';
+import { SmallIntType } from './SmallIntType';
+import { TinyIntType } from './TinyIntType';
+import { MediumIntType } from './MediumIntType';
+import { FloatType } from './FloatType';
+import { DoubleType } from './DoubleType';
+import { BooleanType } from './BooleanType';
+import { DecimalType } from './DecimalType';
+import { StringType } from './StringType';
+import { UuidType } from './UuidType';
+import { TextType } from './TextType';
+import { IntervalType } from './IntervalType';
+import { UnknownType } from './UnknownType';
+export { Type, DateType, TimeType, DateTimeType, BigIntType, BlobType, Uint8ArrayType, ArrayType, EnumArrayType, EnumType, JsonType, IntegerType, SmallIntType, TinyIntType, MediumIntType, FloatType, DoubleType, BooleanType, DecimalType, StringType, UuidType, TextType, UnknownType, TransformContext, IntervalType, };
+export declare const types: {
+    date: typeof DateType;
+    time: typeof TimeType;
+    datetime: typeof DateTimeType;
+    bigint: typeof BigIntType;
+    blob: typeof BlobType;
+    uint8array: typeof Uint8ArrayType;
+    array: typeof ArrayType;
+    enumArray: typeof EnumArrayType;
+    enum: typeof EnumType;
+    json: typeof JsonType;
+    integer: typeof IntegerType;
+    smallint: typeof SmallIntType;
+    tinyint: typeof TinyIntType;
+    mediumint: typeof MediumIntType;
+    float: typeof FloatType;
+    double: typeof DoubleType;
+    boolean: typeof BooleanType;
+    decimal: typeof DecimalType;
+    string: typeof StringType;
+    uuid: typeof UuidType;
+    text: typeof TextType;
+    interval: typeof IntervalType;
+    unknown: typeof UnknownType;
+};
+export declare const t: {
+    date: typeof DateType;
+    time: typeof TimeType;
+    datetime: typeof DateTimeType;
+    bigint: typeof BigIntType;
+    blob: typeof BlobType;
+    uint8array: typeof Uint8ArrayType;
+    array: typeof ArrayType;
+    enumArray: typeof EnumArrayType;
+    enum: typeof EnumType;
+    json: typeof JsonType;
+    integer: typeof IntegerType;
+    smallint: typeof SmallIntType;
+    tinyint: typeof TinyIntType;
+    mediumint: typeof MediumIntType;
+    float: typeof FloatType;
+    double: typeof DoubleType;
+    boolean: typeof BooleanType;
+    decimal: typeof DecimalType;
+    string: typeof StringType;
+    uuid: typeof UuidType;
+    text: typeof TextType;
+    interval: typeof IntervalType;
+    unknown: typeof UnknownType;
+};

package/types/index.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.t = exports.types = exports.IntervalType = exports.UnknownType = exports.TextType = exports.UuidType = exports.StringType = exports.DecimalType = exports.BooleanType = exports.DoubleType = exports.FloatType = exports.MediumIntType = exports.TinyIntType = exports.SmallIntType = exports.IntegerType = exports.JsonType = exports.EnumType = exports.EnumArrayType = exports.ArrayType = exports.Uint8ArrayType = exports.BlobType = exports.BigIntType = exports.DateTimeType = exports.TimeType = exports.DateType = exports.Type = void 0;
+const Type_1 = require("./Type");
+Object.defineProperty(exports, "Type", { enumerable: true, get: function () { return Type_1.Type; } });
+const DateType_1 = require("./DateType");
+Object.defineProperty(exports, "DateType", { enumerable: true, get: function () { return DateType_1.DateType; } });
+const TimeType_1 = require("./TimeType");
+Object.defineProperty(exports, "TimeType", { enumerable: true, get: function () { return TimeType_1.TimeType; } });
+const DateTimeType_1 = require("./DateTimeType");
+Object.defineProperty(exports, "DateTimeType", { enumerable: true, get: function () { return DateTimeType_1.DateTimeType; } });
+const BigIntType_1 = require("./BigIntType");
+Object.defineProperty(exports, "BigIntType", { enumerable: true, get: function () { return BigIntType_1.BigIntType; } });
+const BlobType_1 = require("./BlobType");
+Object.defineProperty(exports, "BlobType", { enumerable: true, get: function () { return BlobType_1.BlobType; } });
+const Uint8ArrayType_1 = require("./Uint8ArrayType");
+Object.defineProperty(exports, "Uint8ArrayType", { enumerable: true, get: function () { return Uint8ArrayType_1.Uint8ArrayType; } });
+const ArrayType_1 = require("./ArrayType");
+Object.defineProperty(exports, "ArrayType", { enumerable: true, get: function () { return ArrayType_1.ArrayType; } });
+const EnumArrayType_1 = require("./EnumArrayType");
+Object.defineProperty(exports, "EnumArrayType", { enumerable: true, get: function () { return EnumArrayType_1.EnumArrayType; } });
+const EnumType_1 = require("./EnumType");
+Object.defineProperty(exports, "EnumType", { enumerable: true, get: function () { return EnumType_1.EnumType; } });
+const JsonType_1 = require("./JsonType");
+Object.defineProperty(exports, "JsonType", { enumerable: true, get: function () { return JsonType_1.JsonType; } });
+const IntegerType_1 = require("./IntegerType");
+Object.defineProperty(exports, "IntegerType", { enumerable: true, get: function () { return IntegerType_1.IntegerType; } });
+const SmallIntType_1 = require("./SmallIntType");
+Object.defineProperty(exports, "SmallIntType", { enumerable: true, get: function () { return SmallIntType_1.SmallIntType; } });
+const TinyIntType_1 = require("./TinyIntType");
+Object.defineProperty(exports, "TinyIntType", { enumerable: true, get: function () { return TinyIntType_1.TinyIntType; } });
+const MediumIntType_1 = require("./MediumIntType");
+Object.defineProperty(exports, "MediumIntType", { enumerable: true, get: function () { return MediumIntType_1.MediumIntType; } });
+const FloatType_1 = require("./FloatType");
+Object.defineProperty(exports, "FloatType", { enumerable: true, get: function () { return FloatType_1.FloatType; } });
+const DoubleType_1 = require("./DoubleType");
+Object.defineProperty(exports, "DoubleType", { enumerable: true, get: function () { return DoubleType_1.DoubleType; } });
+const BooleanType_1 = require("./BooleanType");
+Object.defineProperty(exports, "BooleanType", { enumerable: true, get: function () { return BooleanType_1.BooleanType; } });
+const DecimalType_1 = require("./DecimalType");
+Object.defineProperty(exports, "DecimalType", { enumerable: true, get: function () { return DecimalType_1.DecimalType; } });
+const StringType_1 = require("./StringType");
+Object.defineProperty(exports, "StringType", { enumerable: true, get: function () { return StringType_1.StringType; } });
+const UuidType_1 = require("./UuidType");
+Object.defineProperty(exports, "UuidType", { enumerable: true, get: function () { return UuidType_1.UuidType; } });
+const TextType_1 = require("./TextType");
+Object.defineProperty(exports, "TextType", { enumerable: true, get: function () { return TextType_1.TextType; } });
+const IntervalType_1 = require("./IntervalType");
+Object.defineProperty(exports, "IntervalType", { enumerable: true, get: function () { return IntervalType_1.IntervalType; } });
+const UnknownType_1 = require("./UnknownType");
+Object.defineProperty(exports, "UnknownType", { enumerable: true, get: function () { return UnknownType_1.UnknownType; } });
+exports.types = {
+    date: DateType_1.DateType,
+    time: TimeType_1.TimeType,
+    datetime: DateTimeType_1.DateTimeType,
+    bigint: BigIntType_1.BigIntType,
+    blob: BlobType_1.BlobType,
+    uint8array: Uint8ArrayType_1.Uint8ArrayType,
+    array: ArrayType_1.ArrayType,
+    enumArray: EnumArrayType_1.EnumArrayType,
+    enum: EnumType_1.EnumType,
+    json: JsonType_1.JsonType,
+    integer: IntegerType_1.IntegerType,
+    smallint: SmallIntType_1.SmallIntType,
+    tinyint: TinyIntType_1.TinyIntType,
+    mediumint: MediumIntType_1.MediumIntType,
+    float: FloatType_1.FloatType,
+    double: DoubleType_1.DoubleType,
+    boolean: BooleanType_1.BooleanType,
+    decimal: DecimalType_1.DecimalType,
+    string: StringType_1.StringType,
+    uuid: UuidType_1.UuidType,
+    text: TextType_1.TextType,
+    interval: IntervalType_1.IntervalType,
+    unknown: UnknownType_1.UnknownType,
+};
+exports.t = exports.types;