@mikro-orm/sql 7.0.4 → 7.0.5-dev.1

package/dialects/sqlite/SqlitePlatform.js

@@ -3,143 +3,143 @@ import { SqliteNativeQueryBuilder } from './SqliteNativeQueryBuilder.js';
 import { SqliteSchemaHelper } from './SqliteSchemaHelper.js';
 import { SqliteExceptionConverter } from './SqliteExceptionConverter.js';
 export class SqlitePlatform extends AbstractSqlPlatform {
-  schemaHelper = new SqliteSchemaHelper(this);
-  exceptionConverter = new SqliteExceptionConverter();
-  /** @internal */
-  createNativeQueryBuilder() {
-    return new SqliteNativeQueryBuilder(this);
-  }
-  usesDefaultKeyword() {
-    return false;
-  }
-  usesReturningStatement() {
-    return true;
-  }
-  usesEnumCheckConstraints() {
-    return true;
-  }
-  getCurrentTimestampSQL(length) {
-    return `(strftime('%s', 'now') * 1000)`;
-  }
-  getDateTimeTypeDeclarationSQL(column) {
-    return 'datetime';
-  }
-  getBeginTransactionSQL(options) {
-    return ['begin'];
-  }
-  getEnumTypeDeclarationSQL(column) {
-    if (column.items?.every(item => typeof item === 'string')) {
-      return 'text';
-    }
-    /* v8 ignore next */
-    return this.getTinyIntTypeDeclarationSQL(column);
-  }
-  getTinyIntTypeDeclarationSQL(column) {
-    return this.getIntegerTypeDeclarationSQL(column);
-  }
-  getSmallIntTypeDeclarationSQL(column) {
-    return this.getIntegerTypeDeclarationSQL(column);
-  }
-  getIntegerTypeDeclarationSQL(column) {
-    return 'integer';
-  }
-  getFloatDeclarationSQL() {
-    return 'real';
-  }
-  getBooleanTypeDeclarationSQL() {
-    return 'integer';
-  }
-  getCharTypeDeclarationSQL(column) {
-    return 'text';
-  }
-  getVarcharTypeDeclarationSQL(column) {
-    return 'text';
-  }
-  normalizeColumnType(type, options) {
-    const simpleType = this.extractSimpleType(type);
-    if (['varchar', 'text'].includes(simpleType)) {
-      return this.getVarcharTypeDeclarationSQL(options);
-    }
-    return simpleType;
-  }
-  convertsJsonAutomatically() {
-    return false;
-  }
-  /**
-   * This is used to narrow the value of Date properties as they will be stored as timestamps in sqlite.
-   * We use this method to convert Dates to timestamps when computing the changeset, so we have the right
-   * data type in the payload as well as in original entity data. Without that, we would end up with diffs
-   * including all Date properties, as we would be comparing Date object with timestamp.
-   */
-  processDateProperty(value) {
-    if (value instanceof Date) {
-      return +value;
-    }
-    return value;
-  }
-  getIndexName(tableName, columns, type) {
-    if (type === 'primary') {
-      return this.getDefaultPrimaryName(tableName, columns);
-    }
-    return super.getIndexName(tableName, columns, type);
-  }
-  supportsDeferredUniqueConstraints() {
-    return false;
-  }
-  /**
-   * SQLite supports schemas via ATTACH DATABASE. Returns true when there are
-   * attached databases configured.
-   */
-  supportsSchemas() {
-    const attachDatabases = this.config.get('attachDatabases');
-    return !!attachDatabases?.length;
-  }
-  getDefaultSchemaName() {
-    // Return 'main' only when schema support is active (i.e., databases are attached)
-    return this.supportsSchemas() ? 'main' : undefined;
-  }
-  getFullTextWhereClause() {
-    return `:column: match :query`;
-  }
-  escape(value) {
-    if (value == null) {
-      return 'null';
-    }
-    if (typeof value === 'boolean') {
-      return value ? 'true' : 'false';
-    }
-    if (typeof value === 'number' || typeof value === 'bigint') {
-      return '' + value;
-    }
-    if (value instanceof Date) {
-      return '' + +value;
-    }
-    if (Array.isArray(value)) {
-      return value.map(v => this.escape(v)).join(', ');
-    }
-    if (Buffer.isBuffer(value)) {
-      return `X'${value.toString('hex')}'`;
-    }
-    return `'${String(value).replace(/'/g, "''")}'`;
-  }
-  convertVersionValue(value, prop) {
-    if (prop.runtimeType === 'Date') {
-      const ts = +value;
-      const str = new Date(ts)
-        .toISOString()
-        .replace('T', ' ')
-        .replace(/\.\d{3}Z$/, '');
-      return { $in: [ts, str] };
-    }
-    return value;
-  }
-  getJsonArrayElementPropertySQL(alias, property, _type) {
-    return `json_extract(${this.quoteIdentifier(alias)}.value, '$.${this.quoteJsonKey(property)}')`;
-  }
-  quoteValue(value) {
-    if (value instanceof Date) {
-      return '' + +value;
-    }
-    return super.quoteValue(value);
-  }
+    schemaHelper = new SqliteSchemaHelper(this);
+    exceptionConverter = new SqliteExceptionConverter();
+    /** @internal */
+    createNativeQueryBuilder() {
+        return new SqliteNativeQueryBuilder(this);
+    }
+    usesDefaultKeyword() {
+        return false;
+    }
+    usesReturningStatement() {
+        return true;
+    }
+    usesEnumCheckConstraints() {
+        return true;
+    }
+    getCurrentTimestampSQL(length) {
+        return `(strftime('%s', 'now') * 1000)`;
+    }
+    getDateTimeTypeDeclarationSQL(column) {
+        return 'datetime';
+    }
+    getBeginTransactionSQL(options) {
+        return ['begin'];
+    }
+    getEnumTypeDeclarationSQL(column) {
+        if (column.items?.every(item => typeof item === 'string')) {
+            return 'text';
+        }
+        /* v8 ignore next */
+        return this.getTinyIntTypeDeclarationSQL(column);
+    }
+    getTinyIntTypeDeclarationSQL(column) {
+        return this.getIntegerTypeDeclarationSQL(column);
+    }
+    getSmallIntTypeDeclarationSQL(column) {
+        return this.getIntegerTypeDeclarationSQL(column);
+    }
+    getIntegerTypeDeclarationSQL(column) {
+        return 'integer';
+    }
+    getFloatDeclarationSQL() {
+        return 'real';
+    }
+    getBooleanTypeDeclarationSQL() {
+        return 'integer';
+    }
+    getCharTypeDeclarationSQL(column) {
+        return 'text';
+    }
+    getVarcharTypeDeclarationSQL(column) {
+        return 'text';
+    }
+    normalizeColumnType(type, options) {
+        const simpleType = this.extractSimpleType(type);
+        if (['varchar', 'text'].includes(simpleType)) {
+            return this.getVarcharTypeDeclarationSQL(options);
+        }
+        return simpleType;
+    }
+    convertsJsonAutomatically() {
+        return false;
+    }
+    /**
+     * This is used to narrow the value of Date properties as they will be stored as timestamps in sqlite.
+     * We use this method to convert Dates to timestamps when computing the changeset, so we have the right
+     * data type in the payload as well as in original entity data. Without that, we would end up with diffs
+     * including all Date properties, as we would be comparing Date object with timestamp.
+     */
+    processDateProperty(value) {
+        if (value instanceof Date) {
+            return +value;
+        }
+        return value;
+    }
+    getIndexName(tableName, columns, type) {
+        if (type === 'primary') {
+            return this.getDefaultPrimaryName(tableName, columns);
+        }
+        return super.getIndexName(tableName, columns, type);
+    }
+    supportsDeferredUniqueConstraints() {
+        return false;
+    }
+    /**
+     * SQLite supports schemas via ATTACH DATABASE. Returns true when there are
+     * attached databases configured.
+     */
+    supportsSchemas() {
+        const attachDatabases = this.config.get('attachDatabases');
+        return !!attachDatabases?.length;
+    }
+    getDefaultSchemaName() {
+        // Return 'main' only when schema support is active (i.e., databases are attached)
+        return this.supportsSchemas() ? 'main' : undefined;
+    }
+    getFullTextWhereClause() {
+        return `:column: match :query`;
+    }
+    escape(value) {
+        if (value == null) {
+            return 'null';
+        }
+        if (typeof value === 'boolean') {
+            return value ? 'true' : 'false';
+        }
+        if (typeof value === 'number' || typeof value === 'bigint') {
+            return '' + value;
+        }
+        if (value instanceof Date) {
+            return '' + +value;
+        }
+        if (Array.isArray(value)) {
+            return value.map(v => this.escape(v)).join(', ');
+        }
+        if (Buffer.isBuffer(value)) {
+            return `X'${value.toString('hex')}'`;
+        }
+        return `'${String(value).replace(/'/g, "''")}'`;
+    }
+    convertVersionValue(value, prop) {
+        if (prop.runtimeType === 'Date') {
+            const ts = +value;
+            const str = new Date(ts)
+                .toISOString()
+                .replace('T', ' ')
+                .replace(/\.\d{3}Z$/, '');
+            return { $in: [ts, str] };
+        }
+        return value;
+    }
+    getJsonArrayElementPropertySQL(alias, property, _type) {
+        return `json_extract(${this.quoteIdentifier(alias)}.value, '$.${this.quoteJsonKey(property)}')`;
+    }
+    quoteValue(value) {
+        if (value instanceof Date) {
+            return '' + +value;
+        }
+        return super.quoteValue(value);
+    }
 }

package/dialects/sqlite/SqliteSchemaHelper.d.ts

@@ -5,74 +5,64 @@ import type { Column, IndexDef, Table, TableDifference } from '../../typings.js'
 import type { DatabaseTable } from '../../schema/DatabaseTable.js';
 import type { DatabaseSchema } from '../../schema/DatabaseSchema.js';
 export declare class SqliteSchemaHelper extends SchemaHelper {
-  disableForeignKeysSQL(): string;
-  enableForeignKeysSQL(): string;
-  supportsSchemaConstraints(): boolean;
-  getCreateNamespaceSQL(name: string): string;
-  getDropNamespaceSQL(name: string): string;
-  getListTablesSQL(): string;
-  getAllTables(connection: AbstractSqlConnection, schemas?: string[]): Promise<Table[]>;
-  getNamespaces(connection: AbstractSqlConnection): Promise<string[]>;
-  private getIgnoredViewsCondition;
-  getListViewsSQL(): string;
-  loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string): Promise<void>;
-  getDropDatabaseSQL(name: string): string;
-  loadInformationSchema(
-    schema: DatabaseSchema,
-    connection: AbstractSqlConnection,
-    tables: Table[],
-    schemas?: string[],
-  ): Promise<void>;
-  createTable(table: DatabaseTable, alter?: boolean): string[];
-  createTableColumn(column: Column, table: DatabaseTable, _changedProperties?: Set<string>): string | undefined;
-  getAddColumnsSQL(table: DatabaseTable, columns: Column[], diff?: TableDifference): string[];
-  dropForeignKey(tableName: string, constraintName: string): string;
-  getDropColumnsSQL(tableName: string, columns: Column[], schemaName?: string): string;
-  getCreateIndexSQL(tableName: string, index: IndexDef): string;
-  private parseTableDefinition;
-  /**
-   * Returns schema prefix for pragma and sqlite_master queries.
-   * Returns empty string for main database (no prefix needed).
-   */
-  private getSchemaPrefix;
-  /**
-   * Returns all database names excluding 'temp'.
-   */
-  private getDatabaseList;
-  /**
-   * Extracts the SELECT part from a CREATE VIEW statement.
-   */
-  private extractViewDefinition;
-  private getColumns;
-  /**
-   * SQLite strips outer parentheses from expression defaults (`DEFAULT (expr)` → `expr` in pragma).
-   * We need to add them back so they match what we generate in DDL.
-   */
-  private wrapExpressionDefault;
-  private getEnumDefinitions;
-  getPrimaryKeys(
-    connection: AbstractSqlConnection,
-    indexes: IndexDef[],
-    tableName: string,
-    schemaName?: string,
-  ): Promise<string[]>;
-  private getIndexes;
-  private getChecks;
-  private getColumnDefinitions;
-  private getForeignKeys;
-  getManagementDbName(): string;
-  getCreateDatabaseSQL(name: string): string;
-  databaseExists(connection: Connection, name: string): Promise<boolean>;
-  /**
-   * Implicit indexes will be ignored when diffing
-   */
-  isImplicitIndex(name: string): boolean;
-  dropIndex(table: string, index: IndexDef, oldIndexName?: string): string;
-  /**
-   * SQLite does not support schema-qualified table names in REFERENCES clauses.
-   * Foreign key references can only point to tables in the same database.
-   */
-  getReferencedTableName(referencedTableName: string, schema?: string): string;
-  alterTable(diff: TableDifference, safe?: boolean): string[];
-  private getAlterTempTableSQL;
+    disableForeignKeysSQL(): string;
+    enableForeignKeysSQL(): string;
+    supportsSchemaConstraints(): boolean;
+    getCreateNamespaceSQL(name: string): string;
+    getDropNamespaceSQL(name: string): string;
+    getListTablesSQL(): string;
+    getAllTables(connection: AbstractSqlConnection, schemas?: string[]): Promise<Table[]>;
+    getNamespaces(connection: AbstractSqlConnection): Promise<string[]>;
+    private getIgnoredViewsCondition;
+    getListViewsSQL(): string;
+    loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string): Promise<void>;
+    getDropDatabaseSQL(name: string): string;
+    loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[]): Promise<void>;
+    createTable(table: DatabaseTable, alter?: boolean): string[];
+    createTableColumn(column: Column, table: DatabaseTable, _changedProperties?: Set<string>): string | undefined;
+    getAddColumnsSQL(table: DatabaseTable, columns: Column[], diff?: TableDifference): string[];
+    dropForeignKey(tableName: string, constraintName: string): string;
+    getDropColumnsSQL(tableName: string, columns: Column[], schemaName?: string): string;
+    getCreateIndexSQL(tableName: string, index: IndexDef): string;
+    private parseTableDefinition;
+    /**
+     * Returns schema prefix for pragma and sqlite_master queries.
+     * Returns empty string for main database (no prefix needed).
+     */
+    private getSchemaPrefix;
+    /**
+     * Returns all database names excluding 'temp'.
+     */
+    private getDatabaseList;
+    /**
+     * Extracts the SELECT part from a CREATE VIEW statement.
+     */
+    private extractViewDefinition;
+    private getColumns;
+    /**
+     * SQLite strips outer parentheses from expression defaults (`DEFAULT (expr)` → `expr` in pragma).
+     * We need to add them back so they match what we generate in DDL.
+     */
+    private wrapExpressionDefault;
+    private getEnumDefinitions;
+    getPrimaryKeys(connection: AbstractSqlConnection, indexes: IndexDef[], tableName: string, schemaName?: string): Promise<string[]>;
+    private getIndexes;
+    private getChecks;
+    private getColumnDefinitions;
+    private getForeignKeys;
+    getManagementDbName(): string;
+    getCreateDatabaseSQL(name: string): string;
+    databaseExists(connection: Connection, name: string): Promise<boolean>;
+    /**
+     * Implicit indexes will be ignored when diffing
+     */
+    isImplicitIndex(name: string): boolean;
+    dropIndex(table: string, index: IndexDef, oldIndexName?: string): string;
+    /**
+     * SQLite does not support schema-qualified table names in REFERENCES clauses.
+     * Foreign key references can only point to tables in the same database.
+     */
+    getReferencedTableName(referencedTableName: string, schema?: string): string;
+    alterTable(diff: TableDifference, safe?: boolean): string[];
+    private getAlterTempTableSQL;
 }