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

package/dialects/sqlite/BaseSqliteConnection.d.ts

@@ -2,7 +2,9 @@ import { type Dialect } from 'kysely';
 import type { Dictionary } from '@mikro-orm/core';
 import { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
 export declare class BaseSqliteConnection extends AbstractSqlConnection {
-  createKyselyDialect(options: Dictionary): Dialect;
-  connect(options?: { skipOnConnect?: boolean }): Promise<void>;
-  protected attachDatabases(): Promise<void>;
+    createKyselyDialect(options: Dictionary): Dialect;
+    connect(options?: {
+        skipOnConnect?: boolean;
+    }): Promise<void>;
+    protected attachDatabases(): Promise<void>;
 }

package/dialects/sqlite/BaseSqliteConnection.js

@@ -1,27 +1,25 @@
 import { CompiledQuery } from 'kysely';
 import { AbstractSqlConnection } from '../../AbstractSqlConnection.js';
 export class BaseSqliteConnection extends AbstractSqlConnection {
-  createKyselyDialect(options) {
-    throw new Error(
-      'No SQLite dialect configured. Pass a Kysely dialect via the `driverOptions` config option, ' +
-        'e.g. `new NodeSqliteDialect(...)` for node:sqlite or a custom dialect for other libraries.',
-    );
-  }
-  async connect(options) {
-    await super.connect(options);
-    await this.getClient().executeQuery(CompiledQuery.raw('pragma foreign_keys = on'));
-    await this.attachDatabases();
-  }
-  async attachDatabases() {
-    const attachDatabases = this.config.get('attachDatabases');
-    if (!attachDatabases?.length) {
-      return;
+    createKyselyDialect(options) {
+        throw new Error('No SQLite dialect configured. Pass a Kysely dialect via the `driverOptions` config option, ' +
+            'e.g. `new NodeSqliteDialect(...)` for node:sqlite or a custom dialect for other libraries.');
     }
-    const { fs } = await import('@mikro-orm/core/fs-utils');
-    const baseDir = this.config.get('baseDir');
-    for (const db of attachDatabases) {
-      const path = fs.absolutePath(db.path, baseDir);
-      await this.execute(`attach database '${path}' as ${this.platform.quoteIdentifier(db.name)}`);
+    async connect(options) {
+        await super.connect(options);
+        await this.getClient().executeQuery(CompiledQuery.raw('pragma foreign_keys = on'));
+        await this.attachDatabases();
+    }
+    async attachDatabases() {
+        const attachDatabases = this.config.get('attachDatabases');
+        if (!attachDatabases?.length) {
+            return;
+        }
+        const { fs } = await import('@mikro-orm/core/fs-utils');
+        const baseDir = this.config.get('baseDir');
+        for (const db of attachDatabases) {
+            const path = fs.absolutePath(db.path, baseDir);
+            await this.execute(`attach database '${path}' as ${this.platform.quoteIdentifier(db.name)}`);
+        }
     }
-  }
 }

package/dialects/sqlite/NodeSqliteDialect.d.ts

@@ -17,5 +17,5 @@ import { SqliteDialect } from 'kysely';
  * ```
  */
 export declare class NodeSqliteDialect extends SqliteDialect {
-  constructor(dbName: string);
+    constructor(dbName: string);
 }

package/dialects/sqlite/NodeSqliteDialect.js

@@ -17,27 +17,27 @@ import { SqliteDialect } from 'kysely';
  * ```
  */
 export class NodeSqliteDialect extends SqliteDialect {
-  constructor(dbName) {
-    const { DatabaseSync } = globalThis.process.getBuiltinModule('node:sqlite');
-    super({
-      database: () => {
-        const db = new DatabaseSync(dbName);
-        return {
-          prepare(sql) {
-            const stmt = db.prepare(sql);
-            return {
-              reader: /^\s*(select|pragma|explain|with)/i.test(sql) || /\breturning\b/i.test(sql),
-              all: params => stmt.all(...params),
-              run: params => stmt.run(...params),
-              /* v8 ignore next */
-              get: params => stmt.get(...params),
-            };
-          },
-          close() {
-            db.close();
-          },
-        };
-      },
-    });
-  }
+    constructor(dbName) {
+        const { DatabaseSync } = globalThis.process.getBuiltinModule('node:sqlite');
+        super({
+            database: () => {
+                const db = new DatabaseSync(dbName);
+                return {
+                    prepare(sql) {
+                        const stmt = db.prepare(sql);
+                        return {
+                            reader: /^\s*(select|pragma|explain|with)/i.test(sql) || /\breturning\b/i.test(sql),
+                            all: (params) => stmt.all(...params),
+                            run: (params) => stmt.run(...params),
+                            /* v8 ignore next */
+                            get: (params) => stmt.get(...params),
+                        };
+                    },
+                    close() {
+                        db.close();
+                    },
+                };
+            },
+        });
+    }
 }

package/dialects/sqlite/SqliteDriver.d.ts

@@ -8,5 +8,5 @@ import { BaseSqliteConnection } from './BaseSqliteConnection.js';
  * For the default better-sqlite3 experience, use `@mikro-orm/sqlite` instead.
  */
 export declare class SqliteDriver extends AbstractSqlDriver<BaseSqliteConnection> {
-  constructor(config: Configuration);
+    constructor(config: Configuration);
 }

package/dialects/sqlite/SqliteDriver.js

@@ -8,7 +8,7 @@ import { SqlitePlatform } from './SqlitePlatform.js';
  * For the default better-sqlite3 experience, use `@mikro-orm/sqlite` instead.
  */
 export class SqliteDriver extends AbstractSqlDriver {
-  constructor(config) {
-    super(config, new SqlitePlatform(), BaseSqliteConnection, ['kysely']);
-  }
+    constructor(config) {
+        super(config, new SqlitePlatform(), BaseSqliteConnection, ['kysely']);
+    }
 }

package/dialects/sqlite/SqliteExceptionConverter.d.ts

@@ -1,9 +1,9 @@
 import { ExceptionConverter, type Dictionary, type DriverException } from '@mikro-orm/core';
 export declare class SqliteExceptionConverter extends ExceptionConverter {
-  /**
-   * @inheritDoc
-   * @see http://www.sqlite.org/c3ref/c_abort.html
-   * @see https://github.com/doctrine/dbal/blob/master/src/Driver/AbstractSQLiteDriver.php
-   */
-  convertException(exception: Error & Dictionary): DriverException;
+    /**
+     * @inheritDoc
+     * @see http://www.sqlite.org/c3ref/c_abort.html
+     * @see https://github.com/doctrine/dbal/blob/master/src/Driver/AbstractSQLiteDriver.php
+     */
+    convertException(exception: Error & Dictionary): DriverException;
 }

package/dialects/sqlite/SqliteExceptionConverter.js

@@ -1,70 +1,54 @@
-import {
-  ConnectionException,
-  ExceptionConverter,
-  InvalidFieldNameException,
-  LockWaitTimeoutException,
-  NonUniqueFieldNameException,
-  CheckConstraintViolationException,
-  NotNullConstraintViolationException,
-  ReadOnlyException,
-  SyntaxErrorException,
-  TableExistsException,
-  TableNotFoundException,
-  UniqueConstraintViolationException,
-  ForeignKeyConstraintViolationException,
-} from '@mikro-orm/core';
+import { ConnectionException, ExceptionConverter, InvalidFieldNameException, LockWaitTimeoutException, NonUniqueFieldNameException, CheckConstraintViolationException, NotNullConstraintViolationException, ReadOnlyException, SyntaxErrorException, TableExistsException, TableNotFoundException, UniqueConstraintViolationException, ForeignKeyConstraintViolationException, } from '@mikro-orm/core';
 export class SqliteExceptionConverter extends ExceptionConverter {
-  /**
-   * @inheritDoc
-   * @see http://www.sqlite.org/c3ref/c_abort.html
-   * @see https://github.com/doctrine/dbal/blob/master/src/Driver/AbstractSQLiteDriver.php
-   */
-  convertException(exception) {
-    /* v8 ignore next */
-    if (exception.message.includes('database is locked')) {
-      return new LockWaitTimeoutException(exception);
+    /**
+     * @inheritDoc
+     * @see http://www.sqlite.org/c3ref/c_abort.html
+     * @see https://github.com/doctrine/dbal/blob/master/src/Driver/AbstractSQLiteDriver.php
+     */
+    convertException(exception) {
+        /* v8 ignore next */
+        if (exception.message.includes('database is locked')) {
+            return new LockWaitTimeoutException(exception);
+        }
+        if (exception.message.includes('must be unique') ||
+            exception.message.includes('is not unique') ||
+            exception.message.includes('are not unique') ||
+            exception.message.includes('UNIQUE constraint failed')) {
+            return new UniqueConstraintViolationException(exception);
+        }
+        if (exception.message.includes('may not be NULL') || exception.message.includes('NOT NULL constraint failed')) {
+            return new NotNullConstraintViolationException(exception);
+        }
+        /* v8 ignore next */
+        if (exception.message.includes('CHECK constraint failed')) {
+            return new CheckConstraintViolationException(exception);
+        }
+        if (exception.message.includes('no such table:')) {
+            return new TableNotFoundException(exception);
+        }
+        if (exception.message.includes('already exists')) {
+            return new TableExistsException(exception);
+        }
+        if (exception.message.includes('no such column:')) {
+            return new InvalidFieldNameException(exception);
+        }
+        if (exception.message.includes('ambiguous column name')) {
+            return new NonUniqueFieldNameException(exception);
+        }
+        if (exception.message.includes('syntax error')) {
+            return new SyntaxErrorException(exception);
+        }
+        /* v8 ignore next */
+        if (exception.message.includes('attempt to write a readonly database')) {
+            return new ReadOnlyException(exception);
+        }
+        /* v8 ignore next */
+        if (exception.message.includes('unable to open database file')) {
+            return new ConnectionException(exception);
+        }
+        if (exception.message.includes('FOREIGN KEY constraint failed')) {
+            return new ForeignKeyConstraintViolationException(exception);
+        }
+        return super.convertException(exception);
     }
-    if (
-      exception.message.includes('must be unique') ||
-      exception.message.includes('is not unique') ||
-      exception.message.includes('are not unique') ||
-      exception.message.includes('UNIQUE constraint failed')
-    ) {
-      return new UniqueConstraintViolationException(exception);
-    }
-    if (exception.message.includes('may not be NULL') || exception.message.includes('NOT NULL constraint failed')) {
-      return new NotNullConstraintViolationException(exception);
-    }
-    /* v8 ignore next */
-    if (exception.message.includes('CHECK constraint failed')) {
-      return new CheckConstraintViolationException(exception);
-    }
-    if (exception.message.includes('no such table:')) {
-      return new TableNotFoundException(exception);
-    }
-    if (exception.message.includes('already exists')) {
-      return new TableExistsException(exception);
-    }
-    if (exception.message.includes('no such column:')) {
-      return new InvalidFieldNameException(exception);
-    }
-    if (exception.message.includes('ambiguous column name')) {
-      return new NonUniqueFieldNameException(exception);
-    }
-    if (exception.message.includes('syntax error')) {
-      return new SyntaxErrorException(exception);
-    }
-    /* v8 ignore next */
-    if (exception.message.includes('attempt to write a readonly database')) {
-      return new ReadOnlyException(exception);
-    }
-    /* v8 ignore next */
-    if (exception.message.includes('unable to open database file')) {
-      return new ConnectionException(exception);
-    }
-    if (exception.message.includes('FOREIGN KEY constraint failed')) {
-      return new ForeignKeyConstraintViolationException(exception);
-    }
-    return super.convertException(exception);
-  }
 }

package/dialects/sqlite/SqliteNativeQueryBuilder.d.ts

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

package/dialects/sqlite/SqliteNativeQueryBuilder.js

@@ -1,11 +1,11 @@
 import { NativeQueryBuilder } from '../../query/NativeQueryBuilder.js';
 /** @internal */
 export class SqliteNativeQueryBuilder extends NativeQueryBuilder {
-  compileTruncate() {
-    const sql = `delete from ${this.getTableName()}`;
-    this.parts.push(sql);
-  }
-  addLockClause() {
-    return; // not supported
-  }
+    compileTruncate() {
+        const sql = `delete from ${this.getTableName()}`;
+        this.parts.push(sql);
+    }
+    addLockClause() {
+        return; // not supported
+    }
 }

package/dialects/sqlite/SqlitePlatform.d.ts

@@ -4,68 +4,77 @@ import { SqliteNativeQueryBuilder } from './SqliteNativeQueryBuilder.js';
 import { SqliteSchemaHelper } from './SqliteSchemaHelper.js';
 import { SqliteExceptionConverter } from './SqliteExceptionConverter.js';
 export declare class SqlitePlatform extends AbstractSqlPlatform {
-  protected readonly schemaHelper: SqliteSchemaHelper;
-  protected readonly exceptionConverter: SqliteExceptionConverter;
-  /** @internal */
-  createNativeQueryBuilder(): SqliteNativeQueryBuilder;
-  usesDefaultKeyword(): boolean;
-  usesReturningStatement(): boolean;
-  usesEnumCheckConstraints(): boolean;
-  getCurrentTimestampSQL(length: number): string;
-  getDateTimeTypeDeclarationSQL(column: { length: number }): string;
-  getBeginTransactionSQL(options?: { isolationLevel?: IsolationLevel; readOnly?: boolean }): string[];
-  getEnumTypeDeclarationSQL(column: {
-    items?: unknown[];
-    fieldNames: string[];
-    length?: number;
-    unsigned?: boolean;
-    autoincrement?: boolean;
-  }): string;
-  getTinyIntTypeDeclarationSQL(column: { length?: number; unsigned?: boolean; autoincrement?: boolean }): string;
-  getSmallIntTypeDeclarationSQL(column: { length?: number; unsigned?: boolean; autoincrement?: boolean }): string;
-  getIntegerTypeDeclarationSQL(column: { length?: number; unsigned?: boolean; autoincrement?: boolean }): string;
-  getFloatDeclarationSQL(): string;
-  getBooleanTypeDeclarationSQL(): string;
-  getCharTypeDeclarationSQL(column: { length?: number }): string;
-  getVarcharTypeDeclarationSQL(column: { length?: number }): string;
-  normalizeColumnType(
-    type: string,
-    options: {
-      length?: number;
-      precision?: number;
-      scale?: number;
-    },
-  ): string;
-  convertsJsonAutomatically(): boolean;
-  /**
-   * 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: unknown): string | number | Date;
-  getIndexName(
-    tableName: string,
-    columns: string[],
-    type: 'index' | 'unique' | 'foreign' | 'primary' | 'sequence',
-  ): string;
-  supportsDeferredUniqueConstraints(): boolean;
-  /**
-   * SQLite supports schemas via ATTACH DATABASE. Returns true when there are
-   * attached databases configured.
-   */
-  supportsSchemas(): boolean;
-  getDefaultSchemaName(): string | undefined;
-  getFullTextWhereClause(): string;
-  escape(value: any): string;
-  convertVersionValue(
-    value: Date | number,
-    prop: EntityProperty,
-  ):
-    | number
-    | {
+    protected readonly schemaHelper: SqliteSchemaHelper;
+    protected readonly exceptionConverter: SqliteExceptionConverter;
+    /** @internal */
+    createNativeQueryBuilder(): SqliteNativeQueryBuilder;
+    usesDefaultKeyword(): boolean;
+    usesReturningStatement(): boolean;
+    usesEnumCheckConstraints(): boolean;
+    getCurrentTimestampSQL(length: number): string;
+    getDateTimeTypeDeclarationSQL(column: {
+        length: number;
+    }): string;
+    getBeginTransactionSQL(options?: {
+        isolationLevel?: IsolationLevel;
+        readOnly?: boolean;
+    }): string[];
+    getEnumTypeDeclarationSQL(column: {
+        items?: unknown[];
+        fieldNames: string[];
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getTinyIntTypeDeclarationSQL(column: {
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getSmallIntTypeDeclarationSQL(column: {
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getIntegerTypeDeclarationSQL(column: {
+        length?: number;
+        unsigned?: boolean;
+        autoincrement?: boolean;
+    }): string;
+    getFloatDeclarationSQL(): string;
+    getBooleanTypeDeclarationSQL(): string;
+    getCharTypeDeclarationSQL(column: {
+        length?: number;
+    }): string;
+    getVarcharTypeDeclarationSQL(column: {
+        length?: number;
+    }): string;
+    normalizeColumnType(type: string, options: {
+        length?: number;
+        precision?: number;
+        scale?: number;
+    }): string;
+    convertsJsonAutomatically(): boolean;
+    /**
+     * 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: unknown): string | number | Date;
+    getIndexName(tableName: string, columns: string[], type: 'index' | 'unique' | 'foreign' | 'primary' | 'sequence'): string;
+    supportsDeferredUniqueConstraints(): boolean;
+    /**
+     * SQLite supports schemas via ATTACH DATABASE. Returns true when there are
+     * attached databases configured.
+     */
+    supportsSchemas(): boolean;
+    getDefaultSchemaName(): string | undefined;
+    getFullTextWhereClause(): string;
+    escape(value: any): string;
+    convertVersionValue(value: Date | number, prop: EntityProperty): number | {
         $in: (string | number)[];
-      };
-  getJsonArrayElementPropertySQL(alias: string, property: string, _type: string): string;
-  quoteValue(value: any): string;
+    };
+    getJsonArrayElementPropertySQL(alias: string, property: string, _type: string): string;
+    quoteValue(value: any): string;
 }