@mikro-orm/sql 7.0.2-dev.9 → 7.0.2

package/dialects/postgresql/FullTextType.d.ts

@@ -2,13 +2,17 @@ import { Type, type TransformContext, type RawQueryFragment } from '@mikro-orm/c
 import type { BasePostgreSqlPlatform } from './BasePostgreSqlPlatform.js';
 type FullTextWeight = 'A' | 'B' | 'C' | 'D';
 export type WeightedFullTextValue = {
-    [K in FullTextWeight]?: string | null;
+  [K in FullTextWeight]?: string | null;
 };
 export declare class FullTextType extends Type<string | WeightedFullTextValue, string | null | RawQueryFragment> {
-    regconfig: string;
-    constructor(regconfig?: string);
-    compareAsType(): string;
-    getColumnType(): string;
-    convertToDatabaseValue(value: string | WeightedFullTextValue, platform: BasePostgreSqlPlatform, context?: TransformContext | boolean): string | null | RawQueryFragment;
+  regconfig: string;
+  constructor(regconfig?: string);
+  compareAsType(): string;
+  getColumnType(): string;
+  convertToDatabaseValue(
+    value: string | WeightedFullTextValue,
+    platform: BasePostgreSqlPlatform,
+    context?: TransformContext | boolean,
+  ): string | null | RawQueryFragment;
 }
 export {};

package/dialects/postgresql/FullTextType.js

@@ -1,59 +1,59 @@
 import { raw, Type } from '@mikro-orm/core';
 export class FullTextType extends Type {
-    regconfig;
-    constructor(regconfig = 'simple') {
-        super();
-        this.regconfig = regconfig;
+  regconfig;
+  constructor(regconfig = 'simple') {
+    super();
+    this.regconfig = regconfig;
+  }
+  compareAsType() {
+    return 'any';
+  }
+  getColumnType() {
+    return 'tsvector';
+  }
+  // Use convertToDatabaseValue to prepare insert queries as this method has
+  // access to the raw JS value. Return Knex#raw to prevent QueryBuilderHelper#mapData
+  // from sanitizing the returned chaing of SQL functions.
+  convertToDatabaseValue(value, platform, context) {
+    // Don't convert to values from select queries to the to_tsvector notation
+    // these should be compared as string using a special oparator or function
+    // this behaviour is defined in Platform#getFullTextWhereClause.
+    // This is always a string.
+    if (typeof context === 'object' && context.fromQuery) {
+      return value;
     }
-    compareAsType() {
-        return 'any';
+    // Null values should not be processed
+    if (!value) {
+      return null;
     }
-    getColumnType() {
-        return 'tsvector';
-    }
-    // Use convertToDatabaseValue to prepare insert queries as this method has
-    // access to the raw JS value. Return Knex#raw to prevent QueryBuilderHelper#mapData
-    // from sanitizing the returned chaing of SQL functions.
-    convertToDatabaseValue(value, platform, context) {
-        // Don't convert to values from select queries to the to_tsvector notation
-        // these should be compared as string using a special oparator or function
-        // this behaviour is defined in Platform#getFullTextWhereClause.
-        // This is always a string.
-        if (typeof context === 'object' && context.fromQuery) {
-            return value;
-        }
-        // Null values should not be processed
-        if (!value) {
-            return null;
+    // the object from that looks like { A: 'test data', B: 'test data2' ... }
+    // must be converted to
+    // setweight(to_tsvector(regconfig, value), A) || setweight(to_tsvector(regconfig, value), B)... etc
+    // use Knex#raw to do binding of the values sanitization of the boundvalues
+    // as we return a raw string which should not be sanitzed anymore
+    if (typeof value === 'object') {
+      const bindings = [];
+      const sqlParts = [];
+      for (const [weight, data] of Object.entries(value)) {
+        // Check whether the weight is valid according to Postgres,
+        // Postgres allows the weight to be upper and lowercase.
+        if (!['A', 'B', 'C', 'D'].includes(weight.toUpperCase())) {
+          throw new Error('Weight should be one of A, B, C, D.');
         }
-        // the object from that looks like { A: 'test data', B: 'test data2' ... }
-        // must be converted to
-        // setweight(to_tsvector(regconfig, value), A) || setweight(to_tsvector(regconfig, value), B)... etc
-        // use Knex#raw to do binding of the values sanitization of the boundvalues
-        // as we return a raw string which should not be sanitzed anymore
-        if (typeof value === 'object') {
-            const bindings = [];
-            const sqlParts = [];
-            for (const [weight, data] of Object.entries(value)) {
-                // Check whether the weight is valid according to Postgres,
-                // Postgres allows the weight to be upper and lowercase.
-                if (!['A', 'B', 'C', 'D'].includes(weight.toUpperCase())) {
-                    throw new Error('Weight should be one of A, B, C, D.');
-                }
-                // Ignore all values that are not a string
-                if (typeof data === 'string') {
-                    sqlParts.push('setweight(to_tsvector(?, ?), ?)');
-                    bindings.push(this.regconfig, data, weight);
-                }
-            }
-            // Return null if the object has no valid strings
-            if (sqlParts.length === 0) {
-                return null;
-            }
-            // Join all the `setweight` parts using the PostgreSQL tsvector `||` concatenation operator
-            return raw(sqlParts.join(' || '), bindings);
+        // Ignore all values that are not a string
+        if (typeof data === 'string') {
+          sqlParts.push('setweight(to_tsvector(?, ?), ?)');
+          bindings.push(this.regconfig, data, weight);
         }
-        // if it's not an object, it is expected to be string which does not have to be wrapped in setweight.
-        return raw('to_tsvector(?, ?)', [this.regconfig, value]);
+      }
+      // Return null if the object has no valid strings
+      if (sqlParts.length === 0) {
+        return null;
+      }
+      // Join all the `setweight` parts using the PostgreSQL tsvector `||` concatenation operator
+      return raw(sqlParts.join(' || '), bindings);
     }
+    // if it's not an object, it is expected to be string which does not have to be wrapped in setweight.
+    return raw('to_tsvector(?, ?)', [this.regconfig, value]);
+  }
 }

package/dialects/postgresql/PostgreSqlExceptionConverter.d.ts

@@ -1,8 +1,8 @@
 import { ExceptionConverter, type Dictionary, type DriverException } from '@mikro-orm/core';
 export declare class PostgreSqlExceptionConverter extends ExceptionConverter {
-    /**
-     * @see http://www.postgresql.org/docs/9.4/static/errcodes-appendix.html
-     * @see https://github.com/doctrine/dbal/blob/master/src/Driver/AbstractPostgreSQLDriver.php
-     */
-    convertException(exception: Error & Dictionary): DriverException;
+  /**
+   * @see http://www.postgresql.org/docs/9.4/static/errcodes-appendix.html
+   * @see https://github.com/doctrine/dbal/blob/master/src/Driver/AbstractPostgreSQLDriver.php
+   */
+  convertException(exception: Error & Dictionary): DriverException;
 }

package/dialects/postgresql/PostgreSqlExceptionConverter.js

@@ -1,47 +1,59 @@
-import { DeadlockException, ExceptionConverter, ForeignKeyConstraintViolationException, InvalidFieldNameException, NonUniqueFieldNameException, NotNullConstraintViolationException, SyntaxErrorException, TableExistsException, TableNotFoundException, UniqueConstraintViolationException, CheckConstraintViolationException, } from '@mikro-orm/core';
+import {
+  DeadlockException,
+  ExceptionConverter,
+  ForeignKeyConstraintViolationException,
+  InvalidFieldNameException,
+  NonUniqueFieldNameException,
+  NotNullConstraintViolationException,
+  SyntaxErrorException,
+  TableExistsException,
+  TableNotFoundException,
+  UniqueConstraintViolationException,
+  CheckConstraintViolationException,
+} from '@mikro-orm/core';
 export class PostgreSqlExceptionConverter extends ExceptionConverter {
-    /**
-     * @see http://www.postgresql.org/docs/9.4/static/errcodes-appendix.html
-     * @see https://github.com/doctrine/dbal/blob/master/src/Driver/AbstractPostgreSQLDriver.php
-     */
-    convertException(exception) {
-        if (exception.detail?.toString().trim()) {
-            exception.message += '\n - detail: ' + exception.detail;
-        }
-        if (exception.hint?.toString().trim()) {
-            exception.message += '\n - hint: ' + exception.hint;
-        }
-        /* v8 ignore next */
-        switch (exception.code) {
-            case '40001':
-            case '40P01':
-                return new DeadlockException(exception);
-            case '0A000':
-                // Foreign key constraint violations during a TRUNCATE operation
-                // are considered "feature not supported" in PostgreSQL.
-                if (exception.message.includes('truncate')) {
-                    return new ForeignKeyConstraintViolationException(exception);
-                }
-                break;
-            case '23502':
-                return new NotNullConstraintViolationException(exception);
-            case '23503':
-                return new ForeignKeyConstraintViolationException(exception);
-            case '23505':
-                return new UniqueConstraintViolationException(exception);
-            case '23514':
-                return new CheckConstraintViolationException(exception);
-            case '42601':
-                return new SyntaxErrorException(exception);
-            case '42702':
-                return new NonUniqueFieldNameException(exception);
-            case '42703':
-                return new InvalidFieldNameException(exception);
-            case '42P01':
-                return new TableNotFoundException(exception);
-            case '42P07':
-                return new TableExistsException(exception);
+  /**
+   * @see http://www.postgresql.org/docs/9.4/static/errcodes-appendix.html
+   * @see https://github.com/doctrine/dbal/blob/master/src/Driver/AbstractPostgreSQLDriver.php
+   */
+  convertException(exception) {
+    if (exception.detail?.toString().trim()) {
+      exception.message += '\n - detail: ' + exception.detail;
+    }
+    if (exception.hint?.toString().trim()) {
+      exception.message += '\n - hint: ' + exception.hint;
+    }
+    /* v8 ignore next */
+    switch (exception.code) {
+      case '40001':
+      case '40P01':
+        return new DeadlockException(exception);
+      case '0A000':
+        // Foreign key constraint violations during a TRUNCATE operation
+        // are considered "feature not supported" in PostgreSQL.
+        if (exception.message.includes('truncate')) {
+          return new ForeignKeyConstraintViolationException(exception);
         }
-        return super.convertException(exception);
+        break;
+      case '23502':
+        return new NotNullConstraintViolationException(exception);
+      case '23503':
+        return new ForeignKeyConstraintViolationException(exception);
+      case '23505':
+        return new UniqueConstraintViolationException(exception);
+      case '23514':
+        return new CheckConstraintViolationException(exception);
+      case '42601':
+        return new SyntaxErrorException(exception);
+      case '42702':
+        return new NonUniqueFieldNameException(exception);
+      case '42703':
+        return new InvalidFieldNameException(exception);
+      case '42P01':
+        return new TableNotFoundException(exception);
+      case '42P07':
+        return new TableExistsException(exception);
     }
+    return super.convertException(exception);
+  }
 }

package/dialects/postgresql/PostgreSqlNativeQueryBuilder.d.ts

@@ -1,5 +1,5 @@
 import { NativeQueryBuilder } from '../../query/NativeQueryBuilder.js';
 /** @internal */
 export declare class PostgreSqlNativeQueryBuilder extends NativeQueryBuilder {
-    protected compileTruncate(): void;
+  protected compileTruncate(): void;
 }

package/dialects/postgresql/PostgreSqlNativeQueryBuilder.js

@@ -1,8 +1,8 @@
 import { NativeQueryBuilder } from '../../query/NativeQueryBuilder.js';
 /** @internal */
 export class PostgreSqlNativeQueryBuilder extends NativeQueryBuilder {
-    compileTruncate() {
-        super.compileTruncate();
-        this.parts.push('restart identity cascade');
-    }
+  compileTruncate() {
+    super.compileTruncate();
+    this.parts.push('restart identity cascade');
+  }
 }

package/dialects/postgresql/PostgreSqlSchemaHelper.d.ts

@@ -5,86 +5,106 @@ import type { CheckDef, Column, ForeignKey, IndexDef, Table, TableDifference } f
 import type { DatabaseSchema } from '../../schema/DatabaseSchema.js';
 import type { DatabaseTable } from '../../schema/DatabaseTable.js';
 export declare class PostgreSqlSchemaHelper extends SchemaHelper {
-    static readonly DEFAULT_VALUES: {
-        'now()': string[];
-        'current_timestamp(?)': string[];
-        "('now'::text)::timestamp(?) with time zone": string[];
-        "('now'::text)::timestamp(?) without time zone": string[];
-        'null::character varying': string[];
-        'null::timestamp with time zone': string[];
-        'null::timestamp without time zone': string[];
-    };
-    getSchemaBeginning(charset: string, disableForeignKeys?: boolean): string;
-    getCreateDatabaseSQL(name: string): string;
-    getListTablesSQL(): string;
-    private getIgnoredViewsCondition;
-    getListViewsSQL(): string;
-    loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection): Promise<void>;
-    getListMaterializedViewsSQL(): string;
-    loadMaterializedViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string): Promise<void>;
-    createMaterializedView(name: string, schema: string | undefined, definition: string, withData?: boolean): string;
-    dropMaterializedViewIfExists(name: string, schema?: string): string;
-    refreshMaterializedView(name: string, schema?: string, concurrently?: boolean): string;
-    getNamespaces(connection: AbstractSqlConnection): Promise<string[]>;
-    private getIgnoredNamespacesConditionSQL;
-    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[]): Promise<void>;
-    getAllIndexes(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<IndexDef[]>>;
-    /**
-     * Parses column definitions from the full CREATE INDEX expression.
-     * Since pg_get_indexdef(oid, col_num, true) doesn't include sort modifiers,
-     * we extract them from the full expression instead.
-     *
-     * We use columnDefs (from individual pg_get_indexdef calls) as the source
-     * of column names, and find their modifiers in the expression.
-     */
-    private parseIndexColumnsFromExpression;
-    /**
-     * Extracts the content inside parentheses starting at the given position.
-     * Handles nested parentheses correctly.
-     */
-    private extractParenthesizedContent;
-    getAllColumns(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>, nativeEnums?: Dictionary<{
-        name: string;
-        schema?: string;
-        items: string[];
-    }>): Promise<Dictionary<Column[]>>;
-    getAllChecks(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>): Promise<Dictionary<CheckDef[]>>;
-    getAllForeignKeys(connection: AbstractSqlConnection, tablesBySchemas: Map<string | undefined, Table[]>): Promise<Dictionary<Dictionary<ForeignKey>>>;
-    getNativeEnumDefinitions(connection: AbstractSqlConnection, schemas: string[]): Promise<Dictionary<{
-        name: string;
-        schema?: string;
-        items: string[];
-    }>>;
-    getCreateNativeEnumSQL(name: string, values: unknown[], schema?: string): string;
-    getDropNativeEnumSQL(name: string, schema?: string): string;
-    getAlterNativeEnumSQL(name: string, schema?: string, value?: string, items?: string[], oldItems?: string[]): string;
-    private getEnumDefinitions;
-    createTableColumn(column: Column, table: DatabaseTable): string | undefined;
-    getPreAlterTable(tableDiff: TableDifference, safe: boolean): string[];
-    castColumn(name: string, type: string): string;
-    dropForeignKey(tableName: string, constraintName: string): string;
-    getPostAlterTable(tableDiff: TableDifference, safe: boolean): string[];
-    private getAlterColumnAutoincrement;
-    getChangeColumnCommentSQL(tableName: string, to: Column, schemaName?: string): string;
-    alterTableComment(table: DatabaseTable, comment?: string): string;
-    normalizeDefaultValue(defaultValue: string, length: number): string | number;
-    appendComments(table: DatabaseTable): string[];
-    getDatabaseExistsSQL(name: string): string;
-    getDatabaseNotExistsError(dbName: string): string;
-    getManagementDbName(): string;
-    disableForeignKeysSQL(): string;
-    enableForeignKeysSQL(): string;
-    getRenameIndexSQL(tableName: string, index: IndexDef, oldIndexName: string): string[];
-    dropIndex(table: string, index: IndexDef, oldIndexName?: string): string;
-    /**
-     * Build the column list for a PostgreSQL index.
-     */
-    protected getIndexColumns(index: IndexDef): string;
-    /**
-     * PostgreSQL-specific index options like fill factor.
-     */
-    protected getCreateIndexSuffix(index: IndexDef): string;
-    private getIndexesSQL;
-    private getChecksSQL;
-    inferLengthFromColumnType(type: string): number | undefined;
+  static readonly DEFAULT_VALUES: {
+    'now()': string[];
+    'current_timestamp(?)': string[];
+    "('now'::text)::timestamp(?) with time zone": string[];
+    "('now'::text)::timestamp(?) without time zone": string[];
+    'null::character varying': string[];
+    'null::timestamp with time zone': string[];
+    'null::timestamp without time zone': string[];
+  };
+  getSchemaBeginning(charset: string, disableForeignKeys?: boolean): string;
+  getCreateDatabaseSQL(name: string): string;
+  getListTablesSQL(): string;
+  private getIgnoredViewsCondition;
+  getListViewsSQL(): string;
+  loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection): Promise<void>;
+  getListMaterializedViewsSQL(): string;
+  loadMaterializedViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string): Promise<void>;
+  createMaterializedView(name: string, schema: string | undefined, definition: string, withData?: boolean): string;
+  dropMaterializedViewIfExists(name: string, schema?: string): string;
+  refreshMaterializedView(name: string, schema?: string, concurrently?: boolean): string;
+  getNamespaces(connection: AbstractSqlConnection): Promise<string[]>;
+  private getIgnoredNamespacesConditionSQL;
+  loadInformationSchema(
+    schema: DatabaseSchema,
+    connection: AbstractSqlConnection,
+    tables: Table[],
+    schemas?: string[],
+  ): Promise<void>;
+  getAllIndexes(connection: AbstractSqlConnection, tables: Table[]): Promise<Dictionary<IndexDef[]>>;
+  /**
+   * Parses column definitions from the full CREATE INDEX expression.
+   * Since pg_get_indexdef(oid, col_num, true) doesn't include sort modifiers,
+   * we extract them from the full expression instead.
+   *
+   * We use columnDefs (from individual pg_get_indexdef calls) as the source
+   * of column names, and find their modifiers in the expression.
+   */
+  private parseIndexColumnsFromExpression;
+  /**
+   * Extracts the content inside parentheses starting at the given position.
+   * Handles nested parentheses correctly.
+   */
+  private extractParenthesizedContent;
+  getAllColumns(
+    connection: AbstractSqlConnection,
+    tablesBySchemas: Map<string | undefined, Table[]>,
+    nativeEnums?: Dictionary<{
+      name: string;
+      schema?: string;
+      items: string[];
+    }>,
+  ): Promise<Dictionary<Column[]>>;
+  getAllChecks(
+    connection: AbstractSqlConnection,
+    tablesBySchemas: Map<string | undefined, Table[]>,
+  ): Promise<Dictionary<CheckDef[]>>;
+  getAllForeignKeys(
+    connection: AbstractSqlConnection,
+    tablesBySchemas: Map<string | undefined, Table[]>,
+  ): Promise<Dictionary<Dictionary<ForeignKey>>>;
+  getNativeEnumDefinitions(
+    connection: AbstractSqlConnection,
+    schemas: string[],
+  ): Promise<
+    Dictionary<{
+      name: string;
+      schema?: string;
+      items: string[];
+    }>
+  >;
+  getCreateNativeEnumSQL(name: string, values: unknown[], schema?: string): string;
+  getDropNativeEnumSQL(name: string, schema?: string): string;
+  getAlterNativeEnumSQL(name: string, schema?: string, value?: string, items?: string[], oldItems?: string[]): string;
+  private getEnumDefinitions;
+  createTableColumn(column: Column, table: DatabaseTable): string | undefined;
+  getPreAlterTable(tableDiff: TableDifference, safe: boolean): string[];
+  castColumn(name: string, type: string): string;
+  dropForeignKey(tableName: string, constraintName: string): string;
+  getPostAlterTable(tableDiff: TableDifference, safe: boolean): string[];
+  private getAlterColumnAutoincrement;
+  getChangeColumnCommentSQL(tableName: string, to: Column, schemaName?: string): string;
+  alterTableComment(table: DatabaseTable, comment?: string): string;
+  normalizeDefaultValue(defaultValue: string, length: number): string | number;
+  appendComments(table: DatabaseTable): string[];
+  getDatabaseExistsSQL(name: string): string;
+  getDatabaseNotExistsError(dbName: string): string;
+  getManagementDbName(): string;
+  disableForeignKeysSQL(): string;
+  enableForeignKeysSQL(): string;
+  getRenameIndexSQL(tableName: string, index: IndexDef, oldIndexName: string): string[];
+  dropIndex(table: string, index: IndexDef, oldIndexName?: string): string;
+  /**
+   * Build the column list for a PostgreSQL index.
+   */
+  protected getIndexColumns(index: IndexDef): string;
+  /**
+   * PostgreSQL-specific index options like fill factor.
+   */
+  protected getCreateIndexSuffix(index: IndexDef): string;
+  private getIndexesSQL;
+  private getChecksSQL;
+  inferLengthFromColumnType(type: string): number | undefined;
 }