@mikro-orm/sql 7.0.3-dev.8 → 7.0.3

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,64 +5,74 @@ 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;
 }