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

package/dialects/sqlite/BaseSqliteConnection.d.ts

@@ -2,9 +2,7 @@ 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,25 +1,27 @@
 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.');
+  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;
     }
-    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)}`);
-        }
+    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,54 +1,70 @@
-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);
-        }
-        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);
+  /**
+   * @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);
+  }
 }

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,78 +4,69 @@ 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;
-    getDefaultVersionLength(): number;
-    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;
+  getDefaultVersionLength(): number;
+  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;
 }