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

package/naming-strategy/NamingStrategy.d.ts

@@ -0,0 +1,52 @@
+export interface NamingStrategy {
+    /**
+     * Return a name of the class based on its file name
+     */
+    getClassName(file: string, separator?: string): string;
+    /**
+     * Return a table name for an entity class
+     */
+    classToTableName(entityName: string): string;
+    /**
+     * Return a migration name. This name should allow ordering.
+     */
+    classToMigrationName(timestamp: string, customMigrationName?: string): string;
+    /**
+     * Return a column name for a property
+     */
+    propertyToColumnName(propertyName: string, object?: boolean): string;
+    /**
+     * Return a name of the entity class based on database table name (used in `EntityGenerator`).
+     * Default implementation ignores the schema name.
+     */
+    getEntityName(tableName: string, schemaName?: string): string;
+    /**
+     * Return a property for a column name (used in `EntityGenerator`).
+     */
+    columnNameToProperty(columnName: string): string;
+    /**
+     * Return the default reference column name
+     */
+    referenceColumnName(): string;
+    /**
+     * Return a join column name for a property
+     */
+    joinColumnName(propertyName: string): string;
+    /**
+     * Return a join table name
+     */
+    joinTableName(sourceEntity: string, targetEntity: string, propertyName: string): string;
+    /**
+     * Return the foreign key column name for the given parameters
+     */
+    joinKeyColumnName(entityName: string, referencedColumnName?: string, composite?: boolean): string;
+    /**
+     * Returns key/constraint name for given type. Some drivers might not support all the types (e.g. mysql and sqlite enforce the PK name).
+     */
+    indexName(tableName: string, columns: string[], type: 'primary' | 'foreign' | 'unique' | 'index' | 'sequence' | 'check'): string;
+    /**
+     * Returns alias name for given entity. The alias needs to be unique across the query, which is by default
+     * ensured via appended index parameter. It is optional to use it as long as you ensure it will be unique.
+     */
+    aliasName(entityName: string, index: number): string;
+}

package/naming-strategy/NamingStrategy.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/naming-strategy/UnderscoreNamingStrategy.d.ts

@@ -0,0 +1,10 @@
+import { AbstractNamingStrategy } from './AbstractNamingStrategy';
+export declare class UnderscoreNamingStrategy extends AbstractNamingStrategy {
+    classToTableName(entityName: string): string;
+    joinColumnName(propertyName: string): string;
+    joinKeyColumnName(entityName: string, referencedColumnName?: string): string;
+    joinTableName(sourceEntity: string, targetEntity: string, propertyName: string): string;
+    propertyToColumnName(propertyName: string, object?: boolean): string;
+    referenceColumnName(): string;
+    private underscore;
+}

package/naming-strategy/UnderscoreNamingStrategy.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnderscoreNamingStrategy = void 0;
+const AbstractNamingStrategy_1 = require("./AbstractNamingStrategy");
+class UnderscoreNamingStrategy extends AbstractNamingStrategy_1.AbstractNamingStrategy {
+    classToTableName(entityName) {
+        return this.underscore(entityName);
+    }
+    joinColumnName(propertyName) {
+        return this.underscore(propertyName) + '_' + this.referenceColumnName();
+    }
+    joinKeyColumnName(entityName, referencedColumnName) {
+        return this.classToTableName(entityName) + '_' + (referencedColumnName || this.referenceColumnName());
+    }
+    joinTableName(sourceEntity, targetEntity, propertyName) {
+        return this.classToTableName(sourceEntity) + '_' + this.classToTableName(propertyName);
+    }
+    propertyToColumnName(propertyName, object) {
+        return this.underscore(propertyName);
+    }
+    referenceColumnName() {
+        return 'id';
+    }
+    underscore(name) {
+        return name.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
+    }
+}
+exports.UnderscoreNamingStrategy = UnderscoreNamingStrategy;

package/naming-strategy/index.d.ts

@@ -0,0 +1,5 @@
+export * from './NamingStrategy';
+export * from './AbstractNamingStrategy';
+export * from './MongoNamingStrategy';
+export * from './UnderscoreNamingStrategy';
+export * from './EntityCaseNamingStrategy';

package/naming-strategy/index.js

@@ -0,0 +1,21 @@
+"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("./NamingStrategy"), exports);
+__exportStar(require("./AbstractNamingStrategy"), exports);
+__exportStar(require("./MongoNamingStrategy"), exports);
+__exportStar(require("./UnderscoreNamingStrategy"), exports);
+__exportStar(require("./EntityCaseNamingStrategy"), exports);

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@yandjin-mikro-orm/core",
+  "version": "6.1.4-rc-sti-changes-1",
+  "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
+  "main": "index.js",
+  "module": "index.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": {
+        "types": "./index.d.ts",
+        "default": "./index.mjs"
+      },
+      "require": "./index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/mikro-orm/mikro-orm.git"
+  },
+  "funding": "https://github.com/sponsors/b4nan",
+  "keywords": [
+    "orm",
+    "mongo",
+    "mongodb",
+    "mysql",
+    "mariadb",
+    "postgresql",
+    "sqlite",
+    "sqlite3",
+    "ts",
+    "typescript",
+    "js",
+    "javascript",
+    "entity",
+    "ddd",
+    "mikro-orm",
+    "unit-of-work",
+    "data-mapper",
+    "identity-map"
+  ],
+  "author": "Martin Adámek",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/mikro-orm/mikro-orm/issues"
+  },
+  "homepage": "https://mikro-orm.io",
+  "engines": {
+    "node": ">= 18.12.0"
+  },
+  "scripts": {
+    "build": "yarn clean && yarn compile && yarn copy && yarn run -T gen-esm-wrapper index.js index.mjs",
+    "clean": "yarn run -T rimraf ./dist",
+    "compile": "yarn run -T tsc -p tsconfig.build.json",
+    "copy": "node ../../scripts/copy.mjs"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "dataloader": "2.2.2",
+    "dotenv": "16.4.4",
+    "esprima": "4.0.1",
+    "fs-extra": "11.2.0",
+    "globby": "11.1.0",
+    "reflect-metadata": "0.2.2",
+    "yandjin-mikro-orm": "6.1.4-rc-sti-changes-1"
+  }
+}

package/platforms/ExceptionConverter.d.ts

@@ -0,0 +1,5 @@
+import type { Dictionary } from '../typings';
+import { DriverException } from '../exceptions';
+export declare class ExceptionConverter {
+    convertException(exception: Error & Dictionary): DriverException;
+}

package/platforms/ExceptionConverter.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExceptionConverter = void 0;
+const exceptions_1 = require("../exceptions");
+class ExceptionConverter {
+    /* istanbul ignore next */
+    convertException(exception) {
+        return new exceptions_1.DriverException(exception);
+    }
+}
+exports.ExceptionConverter = ExceptionConverter;

package/platforms/Platform.d.ts

@@ -0,0 +1,201 @@
+import { EntityRepository } from '../entity';
+import { type NamingStrategy } from '../naming-strategy';
+import type { Constructor, EntityProperty, IPrimaryKey, ISchemaGenerator, PopulateOptions, Primary, EntityMetadata, SimpleColumnMeta } from '../typings';
+import { ExceptionConverter } from './ExceptionConverter';
+import type { EntityManager } from '../EntityManager';
+import type { Configuration } from '../utils/Configuration';
+import type { IDatabaseDriver } from '../drivers/IDatabaseDriver';
+import { Type } from '../types';
+import type { MikroORM } from '../MikroORM';
+import type { TransformContext } from '../types/Type';
+export declare const JsonProperty: unique symbol;
+export declare abstract class Platform {
+    protected readonly exceptionConverter: ExceptionConverter;
+    protected config: Configuration;
+    protected namingStrategy: NamingStrategy;
+    protected timezone?: string;
+    usesPivotTable(): boolean;
+    supportsTransactions(): boolean;
+    usesImplicitTransactions(): boolean;
+    getNamingStrategy(): {
+        new (): NamingStrategy;
+    };
+    usesReturningStatement(): boolean;
+    usesCascadeStatement(): boolean;
+    /** for postgres native enums */
+    supportsNativeEnums(): boolean;
+    getSchemaHelper(): unknown;
+    indexForeignKeys(): boolean;
+    allowsMultiInsert(): boolean;
+    /**
+     * Whether or not the driver supports retuning list of created PKs back when multi-inserting
+     */
+    usesBatchInserts(): boolean;
+    /**
+     * Whether or not the driver supports updating many records at once
+     */
+    usesBatchUpdates(): boolean;
+    usesDefaultKeyword(): boolean;
+    /**
+     * Normalizes primary key wrapper to scalar value (e.g. mongodb's ObjectId to string)
+     */
+    normalizePrimaryKey<T extends number | string = number | string>(data: Primary<T> | IPrimaryKey): T;
+    /**
+     * Converts scalar primary key representation to native driver wrapper (e.g. string to mongodb's ObjectId)
+     */
+    denormalizePrimaryKey(data: IPrimaryKey): IPrimaryKey;
+    /**
+     * Used when serializing via toObject and toJSON methods, allows to use different PK field name (like `id` instead of `_id`)
+     */
+    getSerializedPrimaryKeyField(field: string): string;
+    usesDifferentSerializedPrimaryKey(): boolean;
+    /**
+     * Returns the SQL specific for the platform to get the current timestamp
+     */
+    getCurrentTimestampSQL(length?: number): string;
+    getDateTimeTypeDeclarationSQL(column?: {
+        length?: number;
+    }): string;
+    getDefaultDateTimeLength(): number;
+    getDateTypeDeclarationSQL(length?: number): string;
+    getTimeTypeDeclarationSQL(length?: number): string;
+    getRegExpOperator(val?: unknown, flags?: string): string;
+    getRegExpValue(val: RegExp): {
+        $re: string;
+        $flags?: string;
+    };
+    isAllowedTopLevelOperator(operator: string): boolean;
+    quoteVersionValue(value: Date | number, prop: EntityProperty): Date | string | number;
+    getDefaultVersionLength(): number;
+    allowsComparingTuples(): boolean;
+    allowsUniqueBatchUpdates(): boolean;
+    isBigIntProperty(prop: EntityProperty): boolean;
+    isRaw(value: any): boolean;
+    getDefaultSchemaName(): string | undefined;
+    getBooleanTypeDeclarationSQL(): string;
+    getIntegerTypeDeclarationSQL(column: {
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getSmallIntTypeDeclarationSQL(column: {
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getMediumIntTypeDeclarationSQL(column: {
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getTinyIntTypeDeclarationSQL(column: {
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getBigIntTypeDeclarationSQL(column: {
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getVarcharTypeDeclarationSQL(column: {
+        length?: number;
+    }): string;
+    getIntervalTypeDeclarationSQL(column: {
+        length?: number;
+    }): string;
+    getTextTypeDeclarationSQL(_column: {
+        length?: number;
+    }): string;
+    getEnumTypeDeclarationSQL(column: {
+        items?: unknown[];
+        fieldNames: string[];
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getFloatDeclarationSQL(): string;
+    getDoubleDeclarationSQL(): string;
+    getDecimalTypeDeclarationSQL(column: {
+        precision?: number;
+        scale?: number;
+    }): string;
+    getUuidTypeDeclarationSQL(column: {
+        length?: number;
+    }): string;
+    extractSimpleType(type: string): string;
+    getMappedType(type: string): Type<unknown>;
+    getDefaultMappedType(type: string): Type<unknown>;
+    supportsMultipleStatements(): boolean;
+    getArrayDeclarationSQL(): string;
+    marshallArray(values: string[]): string;
+    unmarshallArray(value: string): string[];
+    getBlobDeclarationSQL(): string;
+    getJsonDeclarationSQL(): string;
+    getSearchJsonPropertySQL(path: string, type: string, aliased: boolean): string;
+    getSearchJsonPropertyKey(path: string[], type: string, aliased: boolean, value?: unknown): string;
+    getJsonIndexDefinition(index: {
+        columnNames: string[];
+    }): string[];
+    getFullTextWhereClause(prop: EntityProperty): string;
+    supportsCreatingFullTextIndex(): boolean;
+    getFullTextIndexExpression(indexName: string, schemaName: string | undefined, tableName: string, columns: SimpleColumnMeta[]): string;
+    convertsJsonAutomatically(): boolean;
+    convertJsonToDatabaseValue(value: unknown, context?: TransformContext): unknown;
+    convertJsonToJSValue(value: unknown): unknown;
+    convertIntervalToJSValue(value: string): unknown;
+    convertIntervalToDatabaseValue(value: unknown): unknown;
+    parseDate(value: string | number): Date;
+    getRepositoryClass<T extends object>(): Constructor<EntityRepository<T>>;
+    getDefaultCharset(): string;
+    getExceptionConverter(): ExceptionConverter;
+    /**
+     * Allows to register extensions of the driver automatically (e.g. `SchemaGenerator` extension in SQL drivers).
+     */
+    lookupExtensions(orm: MikroORM): void;
+    getSchemaGenerator(driver: IDatabaseDriver, em?: EntityManager): ISchemaGenerator;
+    processDateProperty(value: unknown): string | number | Date;
+    quoteIdentifier(id: string, quote?: string): string;
+    quoteValue(value: any): string;
+    formatQuery(sql: string, params: readonly any[]): string;
+    cloneEmbeddable<T>(data: T): T;
+    setConfig(config: Configuration): void;
+    getConfig(): Configuration;
+    getTimezone(): string | undefined;
+    isNumericColumn(mappedType: Type<unknown>): boolean;
+    supportsUnsigned(): boolean;
+    /**
+     * Returns the default name of index for the given columns
+     */
+    getIndexName(tableName: string, columns: string[], type: 'index' | 'unique' | 'foreign' | 'primary' | 'sequence'): string;
+    getDefaultPrimaryName(tableName: string, columns: string[]): string;
+    supportsCustomPrimaryKeyNames(): boolean;
+    isPopulated<T>(key: string, populate: PopulateOptions<T>[] | boolean): boolean;
+    shouldHaveColumn<T>(prop: EntityProperty<T>, populate: PopulateOptions<T>[] | boolean, exclude?: string[], includeFormulas?: boolean): boolean;
+    /**
+     * Currently not supported due to how knex does complex sqlite diffing (always based on current schema)
+     */
+    supportsDownMigrations(): boolean;
+    validateMetadata(meta: EntityMetadata): void;
+    /**
+     * Generates a custom order by statement given a set of in order values, eg.
+     * ORDER BY (CASE WHEN priority = 'low' THEN 1 WHEN priority = 'medium' THEN 2 ELSE NULL END)
+     */
+    generateCustomOrder(escapedColumn: string, values: unknown[]): void;
+    /**
+     * @internal
+     */
+    castColumn(prop?: {
+        columnTypes?: string[];
+    }): string;
+    /**
+     * @internal
+     */
+    castJsonValue(prop?: {
+        columnTypes?: string[];
+    }): string;
+    /**
+     * @internal
+     */
+    clone(): this;
+}