@mikro-orm/postgresql 7.0.0-dev.11 → 7.0.0-dev.111

package/PostgreSqlConnection.d.ts

@@ -1,6 +1,6 @@
 import { type PoolConfig } from 'pg';
 import { PostgresDialect } from 'kysely';
-import { AbstractSqlConnection } from '@mikro-orm/knex';
+import { AbstractSqlConnection } from '@mikro-orm/sql';
 export declare class PostgreSqlConnection extends AbstractSqlConnection {
     createKyselyDialect(overrides: PoolConfig): PostgresDialect;
     mapOptions(overrides: PoolConfig): PoolConfig;

package/PostgreSqlConnection.js

@@ -1,13 +1,14 @@
-import TypeOverrides from 'pg/lib/type-overrides.js';
-import { Pool } from 'pg';
+import { Pool, TypeOverrides } from 'pg';
+import Cursor from 'pg-cursor';
 import { PostgresDialect } from 'kysely';
 import array from 'postgres-array';
-import { AbstractSqlConnection, Utils } from '@mikro-orm/knex';
+import { AbstractSqlConnection, Utils } from '@mikro-orm/sql';
 export class PostgreSqlConnection extends AbstractSqlConnection {
     createKyselyDialect(overrides) {
         const options = this.mapOptions(overrides);
         return new PostgresDialect({
             pool: new Pool(options),
+            cursor: Cursor,
             onCreateConnection: this.options.onCreateConnection ?? this.config.get('onCreateConnection'),
         });
     }

package/PostgreSqlDriver.d.ts

@@ -1,6 +1,9 @@
-import type { Configuration } from '@mikro-orm/core';
-import { AbstractSqlDriver } from '@mikro-orm/knex';
+import type { Configuration, Constructor } from '@mikro-orm/core';
+import { AbstractSqlDriver } from '@mikro-orm/sql';
 import { PostgreSqlConnection } from './PostgreSqlConnection.js';
+import { PostgreSqlMikroORM } from './PostgreSqlMikroORM.js';
 export declare class PostgreSqlDriver extends AbstractSqlDriver<PostgreSqlConnection> {
     constructor(config: Configuration);
+    /** @inheritDoc */
+    getORMClass(): Constructor<PostgreSqlMikroORM>;
 }

package/PostgreSqlDriver.js

@@ -1,8 +1,13 @@
-import { AbstractSqlDriver } from '@mikro-orm/knex';
+import { AbstractSqlDriver } from '@mikro-orm/sql';
 import { PostgreSqlConnection } from './PostgreSqlConnection.js';
 import { PostgreSqlPlatform } from './PostgreSqlPlatform.js';
+import { PostgreSqlMikroORM } from './PostgreSqlMikroORM.js';
 export class PostgreSqlDriver extends AbstractSqlDriver {
     constructor(config) {
         super(config, new PostgreSqlPlatform(), PostgreSqlConnection, ['kysely', 'pg']);
     }
+    /** @inheritDoc */
+    getORMClass() {
+        return PostgreSqlMikroORM;
+    }
 }

package/PostgreSqlMikroORM.d.ts

@@ -1,19 +1,18 @@
-import { MikroORM, type Options, type IDatabaseDriver, type EntityManager, type EntityManagerType } from '@mikro-orm/core';
+import { type AnyEntity, type EntityClass, type EntitySchema, MikroORM, type Options, type IDatabaseDriver, type EntityManager, type EntityManagerType } from '@mikro-orm/core';
+import type { SqlEntityManager } from '@mikro-orm/sql';
 import { PostgreSqlDriver } from './PostgreSqlDriver.js';
-import type { SqlEntityManager } from '@mikro-orm/knex';
+export type PostgreSqlOptions<EM extends SqlEntityManager<PostgreSqlDriver> = SqlEntityManager<PostgreSqlDriver>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> = Options<PostgreSqlDriver, EM, Entities>;
+export declare function definePostgreSqlConfig<EM extends SqlEntityManager<PostgreSqlDriver> = SqlEntityManager<PostgreSqlDriver>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Options<PostgreSqlDriver, EM, Entities>): Options<PostgreSqlDriver, EM, Entities>;
 /**
  * @inheritDoc
  */
-export declare class PostgreSqlMikroORM<EM extends EntityManager = SqlEntityManager> extends MikroORM<PostgreSqlDriver, EM> {
-    private static DRIVER;
+export declare class PostgreSqlMikroORM<EM extends SqlEntityManager<PostgreSqlDriver> = SqlEntityManager<PostgreSqlDriver>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends MikroORM<PostgreSqlDriver, EM, Entities> {
     /**
      * @inheritDoc
      */
-    static init<D extends IDatabaseDriver = PostgreSqlDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager>(options?: Options<D, EM>): Promise<MikroORM<D, EM>>;
+    static init<D extends IDatabaseDriver = PostgreSqlDriver, EM extends EntityManager<D> = D[typeof EntityManagerType] & EntityManager<D>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Options<D, EM, Entities>): Promise<MikroORM<D, EM, Entities>>;
     /**
      * @inheritDoc
      */
-    static initSync<D extends IDatabaseDriver = PostgreSqlDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager>(options: Options<D, EM>): MikroORM<D, EM>;
+    constructor(options: Options<PostgreSqlDriver, EM, Entities>);
 }
-export type PostgreSqlOptions = Options<PostgreSqlDriver>;
-export declare function definePostgreSqlConfig(options: PostgreSqlOptions): Options<PostgreSqlDriver, SqlEntityManager<PostgreSqlDriver> & EntityManager<IDatabaseDriver<import("@mikro-orm/core").Connection>>>;

package/PostgreSqlMikroORM.js

@@ -1,24 +1,22 @@
 import { defineConfig, MikroORM, } from '@mikro-orm/core';
 import { PostgreSqlDriver } from './PostgreSqlDriver.js';
+export function definePostgreSqlConfig(options) {
+    return defineConfig({ driver: PostgreSqlDriver, ...options });
+}
 /**
  * @inheritDoc
  */
 export class PostgreSqlMikroORM extends MikroORM {
-    static DRIVER = PostgreSqlDriver;
     /**
      * @inheritDoc
      */
     static async init(options) {
-        return super.init(options);
+        return super.init(definePostgreSqlConfig(options));
     }
     /**
      * @inheritDoc
      */
-    static initSync(options) {
-        return super.initSync(options);
+    constructor(options) {
+        super(definePostgreSqlConfig(options));
     }
 }
-/* v8 ignore next 3 */
-export function definePostgreSqlConfig(options) {
-    return defineConfig({ driver: PostgreSqlDriver, ...options });
-}

package/PostgreSqlPlatform.d.ts

@@ -1,110 +1,11 @@
 import { type IPostgresInterval } from 'postgres-interval';
-import { type IsolationLevel, type EntityProperty, Type, type SimpleColumnMeta, type Configuration } from '@mikro-orm/core';
-import { AbstractSqlPlatform, type IndexDef, PostgreSqlNativeQueryBuilder } from '@mikro-orm/knex';
-import { PostgreSqlSchemaHelper } from './PostgreSqlSchemaHelper.js';
-import { PostgreSqlExceptionConverter } from './PostgreSqlExceptionConverter.js';
-export declare class PostgreSqlPlatform extends AbstractSqlPlatform {
-    protected readonly schemaHelper: PostgreSqlSchemaHelper;
-    protected readonly exceptionConverter: PostgreSqlExceptionConverter;
-    setConfig(config: Configuration): void;
-    createNativeQueryBuilder(): PostgreSqlNativeQueryBuilder;
-    usesReturningStatement(): boolean;
-    usesCascadeStatement(): boolean;
-    supportsNativeEnums(): boolean;
-    usesEnumCheckConstraints(): boolean;
-    supportsCustomPrimaryKeyNames(): boolean;
-    getCurrentTimestampSQL(length: number): string;
-    getDateTimeTypeDeclarationSQL(column: {
-        length?: number;
-    }): string;
-    getDefaultDateTimeLength(): number;
+import { BasePostgreSqlPlatform } from '@mikro-orm/sql';
+export declare class PostgreSqlPlatform extends BasePostgreSqlPlatform {
     convertIntervalToJSValue(value: string): unknown;
     convertIntervalToDatabaseValue(value: IPostgresInterval): unknown;
-    getTimeTypeDeclarationSQL(): string;
-    getIntegerTypeDeclarationSQL(column: {
-        length?: number;
-        autoincrement?: boolean;
-        generated?: string;
-    }): string;
-    getBigIntTypeDeclarationSQL(column: {
-        autoincrement?: boolean;
-    }): string;
-    getTinyIntTypeDeclarationSQL(column: {
-        length?: number;
-        unsigned?: boolean;
-        autoincrement?: boolean;
-    }): string;
-    getUuidTypeDeclarationSQL(column: {
-        length?: number;
-    }): string;
-    getFullTextWhereClause(prop: EntityProperty): string;
-    supportsCreatingFullTextIndex(): boolean;
-    getFullTextIndexExpression(indexName: string, schemaName: string | undefined, tableName: string, columns: SimpleColumnMeta[]): string;
-    normalizeColumnType(type: string, options: {
-        length?: number;
-        precision?: number;
-        scale?: number;
-        autoincrement?: boolean;
-    }): string;
-    getMappedType(type: string): Type<unknown>;
-    getRegExpOperator(val?: unknown, flags?: string): string;
-    getRegExpValue(val: RegExp): {
-        $re: string;
-        $flags?: string;
-    };
-    isBigIntProperty(prop: EntityProperty): boolean;
-    getArrayDeclarationSQL(): string;
-    getFloatDeclarationSQL(): string;
-    getDoubleDeclarationSQL(): string;
-    getEnumTypeDeclarationSQL(column: {
-        fieldNames: string[];
-        items?: unknown[];
-        nativeEnumName?: string;
-    }): string;
-    supportsMultipleStatements(): boolean;
-    getBeginTransactionSQL(options?: {
-        isolationLevel?: IsolationLevel;
-        readOnly?: boolean;
-    }): string[];
-    marshallArray(values: string[]): string;
-    unmarshallArray(value: string): string[];
-    getVarcharTypeDeclarationSQL(column: {
-        length?: number;
-    }): string;
-    getCharTypeDeclarationSQL(column: {
-        length?: number;
-    }): string;
-    getIntervalTypeDeclarationSQL(column: {
-        length?: number;
-    }): string;
-    getBlobDeclarationSQL(): string;
-    getJsonDeclarationSQL(): string;
-    getSearchJsonPropertyKey(path: string[], type: string | undefined | Type, aliased: boolean, value?: unknown): string;
-    getJsonIndexDefinition(index: IndexDef): string[];
-    quoteIdentifier(id: string, quote?: string): string;
     escape(value: any): string;
-    private pad;
-    /** @internal */
-    formatDate(date: Date): string;
-    indexForeignKeys(): boolean;
-    getDefaultMappedType(type: string): Type<unknown>;
-    supportsSchemas(): boolean;
-    getDefaultSchemaName(): string | undefined;
-    /**
-     * Returns the default name of index for the given columns
-     * cannot go past 63 character length for identifiers in MySQL
-     */
-    getIndexName(tableName: string, columns: string[], type: 'index' | 'unique' | 'foreign' | 'primary' | 'sequence'): string;
-    getDefaultPrimaryName(tableName: string, columns: string[]): string;
-    /**
-     * @inheritDoc
-     */
-    castColumn(prop?: {
-        columnTypes?: string[];
-    }): string;
     /**
      * @inheritDoc
      */
     parseDate(value: string | number): Date;
-    getDefaultClientUrl(): string;
 }

package/PostgreSqlPlatform.js

@@ -1,48 +1,8 @@
 import { Client } from 'pg';
 import parseDate from 'postgres-date';
 import PostgresInterval from 'postgres-interval';
-import { raw, ALIAS_REPLACEMENT, Utils, Type, RawQueryFragment, } from '@mikro-orm/core';
-import { AbstractSqlPlatform, PostgreSqlNativeQueryBuilder } from '@mikro-orm/knex';
-import { PostgreSqlSchemaHelper } from './PostgreSqlSchemaHelper.js';
-import { PostgreSqlExceptionConverter } from './PostgreSqlExceptionConverter.js';
-import { FullTextType } from './types/FullTextType.js';
-export class PostgreSqlPlatform extends AbstractSqlPlatform {
-    schemaHelper = new PostgreSqlSchemaHelper(this);
-    exceptionConverter = new PostgreSqlExceptionConverter();
-    setConfig(config) {
-        if (config.get('forceUtcTimezone') == null) {
-            config.set('forceUtcTimezone', true);
-        }
-        super.setConfig(config);
-    }
-    createNativeQueryBuilder() {
-        return new PostgreSqlNativeQueryBuilder(this);
-    }
-    usesReturningStatement() {
-        return true;
-    }
-    usesCascadeStatement() {
-        return true;
-    }
-    supportsNativeEnums() {
-        return true;
-    }
-    usesEnumCheckConstraints() {
-        return true;
-    }
-    supportsCustomPrimaryKeyNames() {
-        return true;
-    }
-    getCurrentTimestampSQL(length) {
-        return `current_timestamp(${length})`;
-    }
-    getDateTimeTypeDeclarationSQL(column) {
-        /* v8 ignore next */
-        return 'timestamptz' + (column.length != null ? `(${column.length})` : '');
-    }
-    getDefaultDateTimeLength() {
-        return 6;
-    }
+import { BasePostgreSqlPlatform, Utils } from '@mikro-orm/sql';
+export class PostgreSqlPlatform extends BasePostgreSqlPlatform {
     convertIntervalToJSValue(value) {
         return PostgresInterval(value);
     }
@@ -52,215 +12,10 @@ export class PostgreSqlPlatform extends AbstractSqlPlatform {
         }
         return value;
     }
-    getTimeTypeDeclarationSQL() {
-        return 'time(0)';
-    }
-    getIntegerTypeDeclarationSQL(column) {
-        if (column.autoincrement && !column.generated) {
-            return 'serial';
-        }
-        return 'int';
-    }
-    getBigIntTypeDeclarationSQL(column) {
-        /* v8 ignore next 3 */
-        if (column.autoincrement) {
-            return `bigserial`;
-        }
-        return 'bigint';
-    }
-    getTinyIntTypeDeclarationSQL(column) {
-        return 'smallint';
-    }
-    getUuidTypeDeclarationSQL(column) {
-        return `uuid`;
-    }
-    getFullTextWhereClause(prop) {
-        if (prop.customType instanceof FullTextType) {
-            return `:column: @@ plainto_tsquery('${prop.customType.regconfig}', :query)`;
-        }
-        /* v8 ignore next 3 */
-        if (prop.columnTypes[0] === 'tsvector') {
-            return `:column: @@ plainto_tsquery('simple', :query)`;
-        }
-        return `to_tsvector('simple', :column:) @@ plainto_tsquery('simple', :query)`;
-    }
-    supportsCreatingFullTextIndex() {
-        return true;
-    }
-    getFullTextIndexExpression(indexName, schemaName, tableName, columns) {
-        /* v8 ignore next */
-        const quotedTableName = this.quoteIdentifier(schemaName ? `${schemaName}.${tableName}` : tableName);
-        const quotedColumnNames = columns.map(c => this.quoteIdentifier(c.name));
-        const quotedIndexName = this.quoteIdentifier(indexName);
-        if (columns.length === 1 && columns[0].type === 'tsvector') {
-            return `create index ${quotedIndexName} on ${quotedTableName} using gin(${quotedColumnNames[0]})`;
-        }
-        return `create index ${quotedIndexName} on ${quotedTableName} using gin(to_tsvector('simple', ${quotedColumnNames.join(` || ' ' || `)}))`;
-    }
-    normalizeColumnType(type, options) {
-        const simpleType = this.extractSimpleType(type);
-        if (['int', 'int4', 'integer'].includes(simpleType)) {
-            return this.getIntegerTypeDeclarationSQL({});
-        }
-        if (['bigint', 'int8'].includes(simpleType)) {
-            return this.getBigIntTypeDeclarationSQL({});
-        }
-        if (['smallint', 'int2'].includes(simpleType)) {
-            return this.getSmallIntTypeDeclarationSQL({});
-        }
-        if (['boolean', 'bool'].includes(simpleType)) {
-            return this.getBooleanTypeDeclarationSQL();
-        }
-        if (['varchar', 'character varying'].includes(simpleType)) {
-            return this.getVarcharTypeDeclarationSQL(options);
-        }
-        if (['char', 'bpchar'].includes(simpleType)) {
-            return this.getCharTypeDeclarationSQL(options);
-        }
-        if (['decimal', 'numeric'].includes(simpleType)) {
-            return this.getDecimalTypeDeclarationSQL(options);
-        }
-        if (['interval'].includes(simpleType)) {
-            return this.getIntervalTypeDeclarationSQL(options);
-        }
-        return super.normalizeColumnType(type, options);
-    }
-    getMappedType(type) {
-        switch (this.extractSimpleType(type)) {
-            case 'tsvector': return Type.getType(FullTextType);
-            default: return super.getMappedType(type);
-        }
-    }
-    getRegExpOperator(val, flags) {
-        /* v8 ignore next 3 */
-        if ((val instanceof RegExp && val.flags.includes('i')) || flags?.includes('i')) {
-            return '~*';
-        }
-        return '~';
-    }
-    /* v8 ignore next 8 */
-    getRegExpValue(val) {
-        if (val.flags.includes('i')) {
-            return { $re: val.source, $flags: val.flags };
-        }
-        return { $re: val.source };
-    }
-    isBigIntProperty(prop) {
-        return super.isBigIntProperty(prop) || (['bigserial', 'int8'].includes(prop.columnTypes?.[0]));
-    }
-    getArrayDeclarationSQL() {
-        return 'text[]';
-    }
-    getFloatDeclarationSQL() {
-        return 'real';
-    }
-    getDoubleDeclarationSQL() {
-        return 'double precision';
-    }
-    getEnumTypeDeclarationSQL(column) {
-        /* v8 ignore next 3 */
-        if (column.nativeEnumName) {
-            return column.nativeEnumName;
-        }
-        if (column.items?.every(item => Utils.isString(item))) {
-            return 'text';
-        }
-        return `smallint`;
-    }
-    supportsMultipleStatements() {
-        return true;
-    }
-    getBeginTransactionSQL(options) {
-        if (options?.isolationLevel || options?.readOnly) {
-            let sql = 'start transaction';
-            sql += options.isolationLevel ? ` isolation level ${options.isolationLevel}` : '';
-            sql += options.readOnly ? ` read only` : '';
-            return [sql];
-        }
-        return ['begin'];
-    }
-    marshallArray(values) {
-        const quote = (v) => v === '' || v.match(/["{},\\]/) ? JSON.stringify(v) : v;
-        return `{${values.map(v => quote('' + v)).join(',')}}`;
-    }
-    unmarshallArray(value) {
-        if (value === '{}') {
-            return [];
-        }
-        return value.substring(1, value.length - 1).split(',').map(v => {
-            if (v === `""`) {
-                return '';
-            }
-            if (v.match(/"(.*)"/)) {
-                return v.substring(1, v.length - 1).replaceAll('\\"', '"');
-            }
-            return v;
-        });
-    }
-    getVarcharTypeDeclarationSQL(column) {
-        if (column.length === -1) {
-            return 'varchar';
-        }
-        return super.getVarcharTypeDeclarationSQL(column);
-    }
-    getCharTypeDeclarationSQL(column) {
-        if (column.length === -1) {
-            return 'char';
-        }
-        return super.getCharTypeDeclarationSQL(column);
-    }
-    getIntervalTypeDeclarationSQL(column) {
-        return 'interval' + (column.length != null ? `(${column.length})` : '');
-    }
-    getBlobDeclarationSQL() {
-        return 'bytea';
-    }
-    getJsonDeclarationSQL() {
-        return 'jsonb';
-    }
-    getSearchJsonPropertyKey(path, type, aliased, value) {
-        const first = path.shift();
-        const last = path.pop();
-        const root = this.quoteIdentifier(aliased ? `${ALIAS_REPLACEMENT}.${first}` : first);
-        type = typeof type === 'string' ? this.getMappedType(type).runtimeType : String(type);
-        const types = {
-            number: 'float8',
-            bigint: 'int8',
-            boolean: 'bool',
-        };
-        const cast = (key) => raw(type in types ? `(${key})::${types[type]}` : key);
-        let lastOperator = '->>';
-        // force `->` for operator payloads with array values
-        if (Utils.isPlainObject(value) && Object.keys(value).every(key => Utils.isArrayOperator(key) && Array.isArray(value[key]))) {
-            lastOperator = '->';
-        }
-        if (path.length === 0) {
-            return cast(`${root}${lastOperator}'${last}'`);
-        }
-        return cast(`${root}->${path.map(a => this.quoteValue(a)).join('->')}${lastOperator}'${last}'`);
-    }
-    getJsonIndexDefinition(index) {
-        return index.columnNames
-            .map(column => {
-            if (!column.includes('.')) {
-                return column;
-            }
-            const path = column.split('.');
-            const first = path.shift();
-            const last = path.pop();
-            if (path.length === 0) {
-                return `(${this.quoteIdentifier(first)}->>${this.quoteValue(last)})`;
-            }
-            return `(${this.quoteIdentifier(first)}->${path.map(c => this.quoteValue(c)).join('->')}->>${this.quoteValue(last)})`;
-        });
-    }
-    quoteIdentifier(id, quote = '"') {
-        if (RawQueryFragment.isKnownFragment(id)) {
-            return super.quoteIdentifier(id);
-        }
-        return `${quote}${id.replace('.', `${quote}.${quote}`)}${quote}`;
-    }
     escape(value) {
+        if (typeof value === 'bigint') {
+            value = value.toString();
+        }
         if (typeof value === 'string') {
             return Client.prototype.escapeLiteral(value);
         }
@@ -270,104 +25,10 @@ export class PostgreSqlPlatform extends AbstractSqlPlatform {
         if (ArrayBuffer.isView(value)) {
             return `E'\\\\x${value.toString('hex')}'`;
         }
-        return super.escape(value);
-    }
-    pad(number, digits) {
-        return String(number).padStart(digits, '0');
-    }
-    /** @internal */
-    formatDate(date) {
-        if (this.timezone === 'Z') {
-            return date.toISOString();
-        }
-        let offset = -date.getTimezoneOffset();
-        let year = date.getFullYear();
-        const isBCYear = year < 1;
-        /* v8 ignore next 3 */
-        if (isBCYear) {
-            year = Math.abs(year) + 1;
-        }
-        const datePart = `${this.pad(year, 4)}-${this.pad(date.getMonth() + 1, 2)}-${this.pad(date.getDate(), 2)}`;
-        const timePart = `${this.pad(date.getHours(), 2)}:${this.pad(date.getMinutes(), 2)}:${this.pad(date.getSeconds(), 2)}.${this.pad(date.getMilliseconds(), 3)}`;
-        let ret = `${datePart}T${timePart}`;
-        /* v8 ignore next 4 */
-        if (offset < 0) {
-            ret += '-';
-            offset *= -1;
-        }
-        else {
-            ret += '+';
-        }
-        ret += this.pad(Math.floor(offset / 60), 2) + ':' + this.pad(offset % 60, 2);
-        /* v8 ignore next 3 */
-        if (isBCYear) {
-            ret += ' BC';
-        }
-        return ret;
-    }
-    indexForeignKeys() {
-        return false;
-    }
-    getDefaultMappedType(type) {
-        const normalizedType = this.extractSimpleType(type);
-        const map = {
-            'int2': 'smallint',
-            'smallserial': 'smallint',
-            'int': 'integer',
-            'int4': 'integer',
-            'serial': 'integer',
-            'serial4': 'integer',
-            'int8': 'bigint',
-            'bigserial': 'bigint',
-            'serial8': 'bigint',
-            'numeric': 'decimal',
-            'bool': 'boolean',
-            'real': 'float',
-            'float4': 'float',
-            'float8': 'double',
-            'timestamp': 'datetime',
-            'timestamptz': 'datetime',
-            'bytea': 'blob',
-            'jsonb': 'json',
-            'character varying': 'varchar',
-            'bpchar': 'character',
-        };
-        return super.getDefaultMappedType(map[normalizedType] ?? type);
-    }
-    supportsSchemas() {
-        return true;
-    }
-    getDefaultSchemaName() {
-        return 'public';
-    }
-    /**
-     * Returns the default name of index for the given columns
-     * cannot go past 63 character length for identifiers in MySQL
-     */
-    getIndexName(tableName, columns, type) {
-        const indexName = super.getIndexName(tableName, columns, type);
-        if (indexName.length > 63) {
-            const suffix = type === 'primary' ? 'pkey' : type;
-            return `${indexName.substring(0, 55 - type.length)}_${Utils.hash(indexName, 5)}_${suffix}`;
-        }
-        return indexName;
-    }
-    getDefaultPrimaryName(tableName, columns) {
-        const indexName = `${tableName}_pkey`;
-        if (indexName.length > 63) {
-            return `${indexName.substring(0, 55 - 'pkey'.length)}_${Utils.hash(indexName, 5)}_pkey`;
-        }
-        return indexName;
-    }
-    /**
-     * @inheritDoc
-     */
-    castColumn(prop) {
-        switch (prop?.columnTypes?.[0]) {
-            case this.getUuidTypeDeclarationSQL({}): return '::text';
-            case this.getBooleanTypeDeclarationSQL(): return '::int';
-            default: return '';
+        if (Array.isArray(value)) {
+            return value.map(v => this.escape(v)).join(', ');
         }
+        return value;
     }
     /**
      * @inheritDoc
@@ -377,19 +38,16 @@ export class PostgreSqlPlatform extends AbstractSqlPlatform {
         if (typeof value === 'string' && value.charAt(10) === 'T') {
             return new Date(value);
         }
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (typeof value === 'number') {
             return new Date(value);
         }
         // @ts-ignore fix wrong type resolution during build
         const parsed = parseDate(value);
-        /* v8 ignore next 3 */
+        /* v8 ignore next */
         if (parsed === null) {
             return value;
         }
         return parsed;
     }
-    getDefaultClientUrl() {
-        return 'postgresql://postgres@127.0.0.1:5432';
-    }
 }

package/README.md

@@ -11,7 +11,6 @@ TypeScript ORM for Node.js based on Data Mapper, [Unit of Work](https://mikro-or
 [![Chat on discord](https://img.shields.io/discord/1214904142443839538?label=discord&color=blue)](https://discord.gg/w8bjxFHS7X)
 [![Downloads](https://img.shields.io/npm/dm/@mikro-orm/core.svg)](https://www.npmjs.com/package/@mikro-orm/core)
 [![Coverage Status](https://img.shields.io/coveralls/mikro-orm/mikro-orm.svg)](https://coveralls.io/r/mikro-orm/mikro-orm?branch=master)
-[![Maintainability](https://api.codeclimate.com/v1/badges/27999651d3adc47cfa40/maintainability)](https://codeclimate.com/github/mikro-orm/mikro-orm/maintainability)
 [![Build Status](https://github.com/mikro-orm/mikro-orm/workflows/tests/badge.svg?branch=master)](https://github.com/mikro-orm/mikro-orm/actions?workflow=tests)
 
 ## 🤔 Unit of What?
@@ -141,7 +140,7 @@ There is also auto-generated [CHANGELOG.md](CHANGELOG.md) file based on commit m
 - [Composite and Foreign Keys as Primary Key](https://mikro-orm.io/docs/composite-keys)
 - [Filters](https://mikro-orm.io/docs/filters)
 - [Using `QueryBuilder`](https://mikro-orm.io/docs/query-builder)
-- [Preloading Deeply Nested Structures via populate](https://mikro-orm.io/docs/nested-populate)
+- [Populating relations](https://mikro-orm.io/docs/populating-relations)
 - [Property Validation](https://mikro-orm.io/docs/property-validation)
 - [Lifecycle Hooks](https://mikro-orm.io/docs/events#hooks)
 - [Vanilla JS Support](https://mikro-orm.io/docs/usage-with-js)
@@ -382,6 +381,8 @@ See also the list of contributors who [participated](https://github.com/mikro-or
 
 Please ⭐️ this repository if this project helped you!
 
+> If you'd like to support my open-source work, consider sponsoring me directly at [github.com/sponsors/b4nan](https://github.com/sponsors/b4nan).
+
 ## 📝 License
 
 Copyright © 2018 [Martin Adámek](https://github.com/b4nan).

package/index.d.ts

@@ -1,8 +1,6 @@
-export * from '@mikro-orm/knex';
+export * from '@mikro-orm/sql';
 export * from './PostgreSqlConnection.js';
 export * from './PostgreSqlDriver.js';
 export * from './PostgreSqlPlatform.js';
-export * from './PostgreSqlSchemaHelper.js';
-export * from './PostgreSqlExceptionConverter.js';
-export * from './types/index.js';
-export { PostgreSqlMikroORM as MikroORM, PostgreSqlOptions as Options, definePostgreSqlConfig as defineConfig, } from './PostgreSqlMikroORM.js';
+export { PostgreSqlMikroORM as MikroORM, type PostgreSqlOptions as Options, definePostgreSqlConfig as defineConfig, } from './PostgreSqlMikroORM.js';
+export { raw } from './raw.js';