@mikro-orm/sql 7.0.3 → 7.0.4-dev.0

package/dialects/postgresql/FullTextType.d.ts

@@ -2,17 +2,13 @@ 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;
-  }
-  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;
+    regconfig;
+    constructor(regconfig = 'simple') {
+        super();
+        this.regconfig = regconfig;
     }
-    // Null values should not be processed
-    if (!value) {
-      return null;
+    compareAsType() {
+        return 'any';
     }
-    // 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.');
+    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;
         }
-        // Ignore all values that are not a string
-        if (typeof data === 'string') {
-          sqlParts.push('setweight(to_tsvector(?, ?), ?)');
-          bindings.push(this.regconfig, data, weight);
+        // 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);
         }
-      }
-      // 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]);
     }
-    // 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,59 +1,47 @@
-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);
+    /**
+     * @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);
         }
-        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);
     }
-    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,106 +5,86 @@ 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;
 }