@yandjin-mikro-orm/better-sqlite 6.1.4-rc-sti-changes-1

package/BetterSqliteConnection.d.ts

@@ -0,0 +1,16 @@
+import { AbstractSqlConnection, type Knex } from "@yandjin-mikro-orm/knex";
+export declare class BetterSqliteConnection extends AbstractSqlConnection {
+    createKnex(): void;
+    connect(): Promise<void>;
+    getDefaultClientUrl(): string;
+    getClientUrl(): string;
+    loadFile(path: string): Promise<void>;
+    protected getKnexOptions(type: string): Knex.Config;
+    protected transformRawResult<T>(res: any, method: "all" | "get" | "run"): T;
+    /**
+     * monkey patch knex' BetterSqlite Dialect so it returns inserted id when doing raw insert query
+     */
+    private getPatchedDialect;
+    private isRunQuery;
+    private getCallMethod;
+}

package/BetterSqliteConnection.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BetterSqliteConnection = void 0;
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const knex_1 = require("@yandjin-mikro-orm/knex");
+const core_1 = require("@yandjin-mikro-orm/core");
+class BetterSqliteConnection extends knex_1.AbstractSqlConnection {
+    createKnex() {
+        this.getPatchedDialect();
+        this.client = this.createKnexClient("better-sqlite3");
+        this.connected = true;
+    }
+    async connect() {
+        this.createKnex();
+        await (0, fs_extra_1.ensureDir)((0, path_1.dirname)(this.config.get("dbName")));
+        await this.client.raw("pragma foreign_keys = on");
+    }
+    getDefaultClientUrl() {
+        return "";
+    }
+    getClientUrl() {
+        return "";
+    }
+    async loadFile(path) {
+        const conn = await this.client.client.acquireConnection();
+        await conn.exec((await (0, fs_extra_1.readFile)(path)).toString());
+        await this.client.client.releaseConnection(conn);
+    }
+    getKnexOptions(type) {
+        return core_1.Utils.mergeConfig({
+            client: type,
+            connection: {
+                filename: this.config.get("dbName"),
+            },
+            pool: this.config.get("pool"),
+            useNullAsDefault: true,
+        }, this.config.get("driverOptions"));
+    }
+    transformRawResult(res, method) {
+        if (method === "get") {
+            return res[0];
+        }
+        if (method === "all") {
+            return res;
+        }
+        if (Array.isArray(res)) {
+            return {
+                insertId: res[res.length - 1]?.id ?? 0,
+                affectedRows: res.length,
+                row: res[0],
+                rows: res,
+            };
+        }
+        return {
+            insertId: res.lastInsertRowid,
+            affectedRows: res.changes,
+        };
+    }
+    /**
+     * monkey patch knex' BetterSqlite Dialect so it returns inserted id when doing raw insert query
+     */
+    getPatchedDialect() {
+        const { Sqlite3Dialect, Sqlite3DialectTableCompiler } = knex_1.MonkeyPatchable;
+        if (Sqlite3Dialect.prototype.__patched) {
+            return Sqlite3Dialect;
+        }
+        const processResponse = Sqlite3Dialect.prototype.processResponse;
+        Sqlite3Dialect.prototype.__patched = true;
+        Sqlite3Dialect.prototype.processResponse = (obj, runner) => {
+            if (obj.method === "raw" && this.isRunQuery(obj.sql)) {
+                return obj.response ?? obj.context;
+            }
+            return processResponse(obj, runner);
+        };
+        Sqlite3Dialect.prototype._query = (connection, obj) => {
+            const callMethod = this.getCallMethod(obj);
+            return new Promise((resolve, reject) => {
+                /* istanbul ignore if */
+                if (!connection?.[callMethod]) {
+                    return reject(new Error(`Error calling ${callMethod} on connection.`));
+                }
+                connection[callMethod](obj.sql, obj.bindings, function (err, response) {
+                    if (err) {
+                        return reject(err);
+                    }
+                    obj.response = response;
+                    obj.context = this;
+                    return resolve(obj);
+                });
+            });
+        };
+        /* istanbul ignore next */
+        Sqlite3DialectTableCompiler.prototype.foreign = function (foreignInfo) {
+            foreignInfo.column = this.formatter.columnize(foreignInfo.column);
+            foreignInfo.column = Array.isArray(foreignInfo.column)
+                ? foreignInfo.column
+                : [foreignInfo.column];
+            foreignInfo.column = foreignInfo.column.map((column) => this.client.customWrapIdentifier(column, (a) => a));
+            foreignInfo.inTable = this.client.customWrapIdentifier(foreignInfo.inTable, (a) => a);
+            foreignInfo.references = Array.isArray(foreignInfo.references)
+                ? foreignInfo.references
+                : [foreignInfo.references];
+            foreignInfo.references = foreignInfo.references.map((column) => this.client.customWrapIdentifier(column, (a) => a));
+            // quoted versions
+            const column = this.formatter.columnize(foreignInfo.column);
+            const inTable = this.formatter.columnize(foreignInfo.inTable);
+            const references = this.formatter.columnize(foreignInfo.references);
+            const keyName = this.formatter.columnize(foreignInfo.keyName);
+            const addColumnQuery = this.sequence.find((query) => query.sql.includes(`add column ${column[0]}`));
+            // no need for temp tables if we just add a column
+            if (addColumnQuery) {
+                const onUpdate = foreignInfo.onUpdate
+                    ? ` on update ${foreignInfo.onUpdate}`
+                    : "";
+                const deleteRule = foreignInfo.deleteRule
+                    ? ` on delete ${foreignInfo.deleteRule}`
+                    : "";
+                addColumnQuery.sql += ` constraint ${keyName} references ${inTable} (${references})${onUpdate}${deleteRule}`;
+                return;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-this-alias
+            const compiler = this;
+            if (this.method !== "create" && this.method !== "createIfNot") {
+                this.pushQuery({
+                    sql: `PRAGMA table_info(${this.tableName()})`,
+                    statementsProducer(pragma, connection) {
+                        return compiler.client
+                            .ddl(compiler, pragma, connection)
+                            .foreign(foreignInfo);
+                    },
+                });
+            }
+        };
+        return Sqlite3Dialect;
+    }
+    isRunQuery(query) {
+        query = query.trim().toLowerCase();
+        if ((query.startsWith("insert into") || query.startsWith("update ")) &&
+            query.includes(" returning ")) {
+            return false;
+        }
+        return (query.startsWith("insert into") ||
+            query.startsWith("update") ||
+            query.startsWith("delete") ||
+            query.startsWith("truncate"));
+    }
+    getCallMethod(obj) {
+        if (obj.method === "raw") {
+            const query = obj.sql.trim().toLowerCase();
+            if ((query.startsWith("insert into") || query.startsWith("update ")) &&
+                query.includes(" returning ")) {
+                return "all";
+            }
+            if (this.isRunQuery(query)) {
+                return "run";
+            }
+        }
+        /* istanbul ignore next */
+        switch (obj.method) {
+            case "insert":
+            case "update":
+                return obj.returning ? "all" : "run";
+            case "counter":
+            case "del":
+                return "run";
+            default:
+                return "all";
+        }
+    }
+}
+exports.BetterSqliteConnection = BetterSqliteConnection;

package/BetterSqliteDriver.d.ts

@@ -0,0 +1,6 @@
+import type { Configuration } from "@yandjin-mikro-orm/core";
+import { AbstractSqlDriver } from "@yandjin-mikro-orm/knex";
+import { BetterSqliteConnection } from "./BetterSqliteConnection";
+export declare class BetterSqliteDriver extends AbstractSqlDriver<BetterSqliteConnection> {
+    constructor(config: Configuration);
+}

package/BetterSqliteDriver.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BetterSqliteDriver = void 0;
+const knex_1 = require("@yandjin-mikro-orm/knex");
+const BetterSqliteConnection_1 = require("./BetterSqliteConnection");
+const BetterSqlitePlatform_1 = require("./BetterSqlitePlatform");
+class BetterSqliteDriver extends knex_1.AbstractSqlDriver {
+    constructor(config) {
+        super(config, new BetterSqlitePlatform_1.BetterSqlitePlatform(), BetterSqliteConnection_1.BetterSqliteConnection, [
+            "knex",
+            "better-sqlite3",
+        ]);
+    }
+}
+exports.BetterSqliteDriver = BetterSqliteDriver;

package/BetterSqliteExceptionConverter.d.ts

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

package/BetterSqliteExceptionConverter.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BetterSqliteExceptionConverter = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+class BetterSqliteExceptionConverter extends core_1.ExceptionConverter {
+    /* istanbul ignore next */
+    /**
+     * @inheritDoc
+     * @link http://www.sqlite.org/c3ref/c_abort.html
+     * @link https://github.com/doctrine/dbal/blob/master/src/Driver/AbstractSQLiteDriver.php
+     */
+    convertException(exception) {
+        if (exception.message.includes("database is locked")) {
+            return new core_1.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 core_1.UniqueConstraintViolationException(exception);
+        }
+        if (exception.message.includes("may not be NULL") ||
+            exception.message.includes("NOT NULL constraint failed")) {
+            return new core_1.NotNullConstraintViolationException(exception);
+        }
+        if (exception.message.includes("CHECK constraint failed")) {
+            return new core_1.CheckConstraintViolationException(exception);
+        }
+        if (exception.message.includes("no such table:")) {
+            return new core_1.TableNotFoundException(exception);
+        }
+        if (exception.message.includes("already exists")) {
+            return new core_1.TableExistsException(exception);
+        }
+        if (exception.message.includes("no such column:")) {
+            return new core_1.InvalidFieldNameException(exception);
+        }
+        if (exception.message.includes("ambiguous column name")) {
+            return new core_1.NonUniqueFieldNameException(exception);
+        }
+        if (exception.message.includes("syntax error")) {
+            return new core_1.SyntaxErrorException(exception);
+        }
+        if (exception.message.includes("attempt to write a readonly database")) {
+            return new core_1.ReadOnlyException(exception);
+        }
+        if (exception.message.includes("unable to open database file")) {
+            return new core_1.ConnectionException(exception);
+        }
+        if (exception.message.includes("FOREIGN KEY constraint failed")) {
+            return new core_1.ForeignKeyConstraintViolationException(exception);
+        }
+        return super.convertException(exception);
+    }
+}
+exports.BetterSqliteExceptionConverter = BetterSqliteExceptionConverter;

package/BetterSqliteMikroORM.d.ts

@@ -0,0 +1,19 @@
+import { MikroORM, type Options, type IDatabaseDriver, type EntityManager, type EntityManagerType } from "@yandjin-mikro-orm/core";
+import { BetterSqliteDriver } from "./BetterSqliteDriver";
+import type { SqlEntityManager } from "@yandjin-mikro-orm/knex";
+/**
+ * @inheritDoc
+ */
+export declare class BetterSqliteMikroORM<EM extends EntityManager = SqlEntityManager> extends MikroORM<BetterSqliteDriver, EM> {
+    private static DRIVER;
+    /**
+     * @inheritDoc
+     */
+    static init<D extends IDatabaseDriver = BetterSqliteDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager>(options?: Options<D, EM>): Promise<MikroORM<D, EM>>;
+    /**
+     * @inheritDoc
+     */
+    static initSync<D extends IDatabaseDriver = BetterSqliteDriver, EM extends EntityManager = D[typeof EntityManagerType] & EntityManager>(options: Options<D, EM>): MikroORM<D, EM>;
+}
+export type BetterSqliteOptions = Options<BetterSqliteDriver>;
+export declare function defineBetterSqliteConfig(options: BetterSqliteOptions): Options<BetterSqliteDriver, SqlEntityManager<BetterSqliteDriver> & EntityManager<IDatabaseDriver<import("@yandjin-mikro-orm/core").Connection>>>;

package/BetterSqliteMikroORM.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineBetterSqliteConfig = exports.BetterSqliteMikroORM = void 0;
+const core_1 = require("@yandjin-mikro-orm/core");
+const BetterSqliteDriver_1 = require("./BetterSqliteDriver");
+/**
+ * @inheritDoc
+ */
+class BetterSqliteMikroORM extends core_1.MikroORM {
+    static DRIVER = BetterSqliteDriver_1.BetterSqliteDriver;
+    /**
+     * @inheritDoc
+     */
+    static async init(options) {
+        return super.init(options);
+    }
+    /**
+     * @inheritDoc
+     */
+    static initSync(options) {
+        return super.initSync(options);
+    }
+}
+exports.BetterSqliteMikroORM = BetterSqliteMikroORM;
+/* istanbul ignore next */
+function defineBetterSqliteConfig(options) {
+    return (0, core_1.defineConfig)({ driver: BetterSqliteDriver_1.BetterSqliteDriver, ...options });
+}
+exports.defineBetterSqliteConfig = defineBetterSqliteConfig;

package/BetterSqlitePlatform.d.ts

@@ -0,0 +1,55 @@
+import { type EntityProperty } from "@yandjin-mikro-orm/core";
+import { AbstractSqlPlatform } from "@yandjin-mikro-orm/knex";
+import { BetterSqliteSchemaHelper } from "./BetterSqliteSchemaHelper";
+import { BetterSqliteExceptionConverter } from "./BetterSqliteExceptionConverter";
+export declare class BetterSqlitePlatform extends AbstractSqlPlatform {
+    protected readonly schemaHelper: BetterSqliteSchemaHelper;
+    protected readonly exceptionConverter: BetterSqliteExceptionConverter;
+    usesDefaultKeyword(): boolean;
+    usesReturningStatement(): boolean;
+    getCurrentTimestampSQL(length: number): string;
+    getDateTimeTypeDeclarationSQL(column: {
+        length: number;
+    }): 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;
+    getVarcharTypeDeclarationSQL(column: {
+        length?: number;
+    }): string;
+    convertsJsonAutomatically(): boolean;
+    allowsComparingTuples(): 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;
+    quoteVersionValue(value: Date | number, prop: EntityProperty): Date | string | number;
+    quoteValue(value: any): string;
+    getIndexName(tableName: string, columns: string[], type: "index" | "unique" | "foreign" | "primary" | "sequence"): string;
+    getDefaultPrimaryName(tableName: string, columns: string[]): string;
+    supportsDownMigrations(): boolean;
+}

package/BetterSqlitePlatform.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BetterSqlitePlatform = void 0;
+// @ts-ignore
+const sqlstring_sqlite_1 = require("sqlstring-sqlite");
+const core_1 = require("@yandjin-mikro-orm/core");
+const knex_1 = require("@yandjin-mikro-orm/knex");
+const BetterSqliteSchemaHelper_1 = require("./BetterSqliteSchemaHelper");
+const BetterSqliteExceptionConverter_1 = require("./BetterSqliteExceptionConverter");
+class BetterSqlitePlatform extends knex_1.AbstractSqlPlatform {
+    schemaHelper = new BetterSqliteSchemaHelper_1.BetterSqliteSchemaHelper(this);
+    exceptionConverter = new BetterSqliteExceptionConverter_1.BetterSqliteExceptionConverter();
+    usesDefaultKeyword() {
+        return false;
+    }
+    usesReturningStatement() {
+        return true;
+    }
+    getCurrentTimestampSQL(length) {
+        return super.getCurrentTimestampSQL(0);
+    }
+    getDateTimeTypeDeclarationSQL(column) {
+        return "datetime";
+    }
+    getEnumTypeDeclarationSQL(column) {
+        if (column.items?.every((item) => core_1.Utils.isString(item))) {
+            return "text";
+        }
+        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";
+    }
+    getVarcharTypeDeclarationSQL(column) {
+        return "text";
+    }
+    convertsJsonAutomatically() {
+        return false;
+    }
+    allowsComparingTuples() {
+        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;
+    }
+    quoteVersionValue(value, prop) {
+        if (prop.runtimeType === "Date") {
+            return (0, sqlstring_sqlite_1.escape)(value, true, this.timezone).replace(/^'|\.\d{3}'$/g, "");
+        }
+        return value;
+    }
+    quoteValue(value) {
+        /* istanbul ignore if */
+        if (core_1.Utils.isPlainObject(value) || value?.[core_1.JsonProperty]) {
+            return (0, sqlstring_sqlite_1.escape)(JSON.stringify(value), true, this.timezone);
+        }
+        if (value instanceof Date) {
+            return "" + +value;
+        }
+        return (0, sqlstring_sqlite_1.escape)(value, true, this.timezone);
+    }
+    getIndexName(tableName, columns, type) {
+        if (type === "primary") {
+            return this.getDefaultPrimaryName(tableName, columns);
+        }
+        return super.getIndexName(tableName, columns, type);
+    }
+    getDefaultPrimaryName(tableName, columns) {
+        return "primary";
+    }
+    supportsDownMigrations() {
+        return false;
+    }
+}
+exports.BetterSqlitePlatform = BetterSqlitePlatform;

package/BetterSqliteSchemaHelper.d.ts

@@ -0,0 +1,23 @@
+import type { Connection, Dictionary } from "@yandjin-mikro-orm/core";
+import { SchemaHelper, type AbstractSqlConnection, type IndexDef, type CheckDef } from "@yandjin-mikro-orm/knex";
+export declare class BetterSqliteSchemaHelper extends SchemaHelper {
+    disableForeignKeysSQL(): string;
+    enableForeignKeysSQL(): string;
+    supportsSchemaConstraints(): boolean;
+    getListTablesSQL(): string;
+    private parseTableDefinition;
+    getColumns(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<any[]>;
+    getEnumDefinitions(connection: AbstractSqlConnection, checks: CheckDef[], tableName: string, schemaName: string): Promise<Dictionary<string[]>>;
+    getPrimaryKeys(connection: AbstractSqlConnection, indexes: IndexDef[], tableName: string, schemaName?: string): Promise<string[]>;
+    getIndexes(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<IndexDef[]>;
+    getChecks(connection: AbstractSqlConnection, tableName: string, schemaName?: string): Promise<CheckDef[]>;
+    getForeignKeysSQL(tableName: string): string;
+    mapForeignKeys(fks: any[], tableName: string): Dictionary;
+    getManagementDbName(): string;
+    getCreateDatabaseSQL(name: string): string;
+    databaseExists(connection: Connection, name: string): Promise<boolean>;
+    /**
+     * Implicit indexes will be ignored when diffing
+     */
+    isImplicitIndex(name: string): boolean;
+}

package/BetterSqliteSchemaHelper.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BetterSqliteSchemaHelper = void 0;
+const knex_1 = require("@yandjin-mikro-orm/knex");
+class BetterSqliteSchemaHelper extends knex_1.SchemaHelper {
+    disableForeignKeysSQL() {
+        return "pragma foreign_keys = off;";
+    }
+    enableForeignKeysSQL() {
+        return "pragma foreign_keys = on;";
+    }
+    supportsSchemaConstraints() {
+        return false;
+    }
+    getListTablesSQL() {
+        return (`select name as table_name from sqlite_master where type = 'table' and name != 'sqlite_sequence' and name != 'geometry_columns' and name != 'spatial_ref_sys' ` +
+            `union all select name as table_name from sqlite_temp_master where type = 'table' order by name`);
+    }
+    parseTableDefinition(sql, cols) {
+        const columns = {};
+        // extract all columns definitions
+        let columnsDef = sql
+            .replaceAll("\n", "")
+            .match(new RegExp(`create table [\`"']?.*?[\`"']? \\((.*)\\)`, "i"))?.[1];
+        /* istanbul ignore else */
+        if (columnsDef) {
+            for (let i = cols.length - 1; i >= 0; i--) {
+                const col = cols[i];
+                const re = ` *, *[\`"']?${col.name}[\`"']? (.*)`;
+                const columnDef = columnsDef.match(new RegExp(re, "i"));
+                /* istanbul ignore else */
+                if (columnDef) {
+                    columns[col.name] = { name: col.name, definition: columnDef[1] };
+                    columnsDef = columnsDef.substring(0, columnDef.index);
+                }
+            }
+        }
+        return columns;
+    }
+    async getColumns(connection, tableName, schemaName) {
+        const columns = await connection.execute(`pragma table_xinfo('${tableName}')`);
+        const sql = `select sql from sqlite_master where type = ? and name = ?`;
+        const tableDefinition = await connection.execute(sql, ["table", tableName], "get");
+        const composite = columns.reduce((count, col) => count + (col.pk ? 1 : 0), 0) > 1;
+        // there can be only one, so naive check like this should be enough
+        const hasAutoincrement = tableDefinition.sql
+            .toLowerCase()
+            .includes("autoincrement");
+        const columnDefinitions = this.parseTableDefinition(tableDefinition.sql, columns);
+        return columns.map((col) => {
+            const mappedType = connection.getPlatform().getMappedType(col.type);
+            let generated;
+            if (col.hidden > 1) {
+                const storage = col.hidden === 2 ? "virtual" : "stored";
+                const re = `(generated always)? as \\((.*)\\)( ${storage})?$`;
+                const match = columnDefinitions[col.name].definition.match(re);
+                if (match) {
+                    generated = `${match[2]} ${storage}`;
+                }
+            }
+            return {
+                name: col.name,
+                type: col.type,
+                default: col.dflt_value,
+                nullable: !col.notnull,
+                primary: !!col.pk,
+                mappedType,
+                unsigned: false,
+                autoincrement: !composite &&
+                    col.pk &&
+                    this.platform.isNumericColumn(mappedType) &&
+                    hasAutoincrement,
+                generated,
+            };
+        });
+    }
+    async getEnumDefinitions(connection, checks, tableName, schemaName) {
+        const sql = `select sql from sqlite_master where type = ? and name = ?`;
+        const tableDefinition = await connection.execute(sql, ["table", tableName], "get");
+        const checkConstraints = [
+            ...(tableDefinition.sql.match(/[`["'][^`\]"']+[`\]"'] text check \(.*?\)/gi) ?? []),
+        ];
+        return checkConstraints.reduce((o, item) => {
+            // check constraints are defined as (note that last closing paren is missing):
+            // `type` text check (`type` in ('local', 'global')
+            const match = item.match(/[`["']([^`\]"']+)[`\]"'] text check \(.* \((.*)\)/i);
+            /* istanbul ignore else */
+            if (match) {
+                o[match[1]] = match[2]
+                    .split(",")
+                    .map((item) => item.trim().match(/^\(?'(.*)'/)[1]);
+            }
+            return o;
+        }, {});
+    }
+    async getPrimaryKeys(connection, indexes, tableName, schemaName) {
+        const sql = `pragma table_info(\`${tableName}\`)`;
+        const cols = await connection.execute(sql);
+        return cols.filter((col) => !!col.pk).map((col) => col.name);
+    }
+    async getIndexes(connection, tableName, schemaName) {
+        const sql = `pragma table_info(\`${tableName}\`)`;
+        const cols = await connection.execute(sql);
+        const indexes = await connection.execute(`pragma index_list(\`${tableName}\`)`);
+        const ret = [];
+        for (const col of cols.filter((c) => c.pk)) {
+            ret.push({
+                columnNames: [col.name],
+                keyName: "primary",
+                constraint: true,
+                unique: true,
+                primary: true,
+            });
+        }
+        for (const index of indexes.filter((index) => !this.isImplicitIndex(index.name))) {
+            const res = await connection.execute(`pragma index_info(\`${index.name}\`)`);
+            ret.push(...res.map((row) => ({
+                columnNames: [row.name],
+                keyName: index.name,
+                unique: !!index.unique,
+                constraint: !!index.unique,
+                primary: false,
+            })));
+        }
+        return this.mapIndexes(ret);
+    }
+    async getChecks(connection, tableName, schemaName) {
+        // Not supported at the moment.
+        return [];
+    }
+    getForeignKeysSQL(tableName) {
+        return `pragma foreign_key_list(\`${tableName}\`)`;
+    }
+    mapForeignKeys(fks, tableName) {
+        return fks.reduce((ret, fk) => {
+            ret[fk.from] = {
+                constraintName: this.platform.getIndexName(tableName, [fk.from], "foreign"),
+                columnName: fk.from,
+                columnNames: [fk.from],
+                localTableName: tableName,
+                referencedTableName: fk.table,
+                referencedColumnName: fk.to,
+                referencedColumnNames: [fk.to],
+                updateRule: fk.on_update.toLowerCase(),
+                deleteRule: fk.on_delete.toLowerCase(),
+            };
+            return ret;
+        }, {});
+    }
+    getManagementDbName() {
+        return "";
+    }
+    getCreateDatabaseSQL(name) {
+        return "";
+    }
+    async databaseExists(connection, name) {
+        const tables = await connection.execute(this.getListTablesSQL());
+        return tables.length > 0;
+    }
+    /**
+     * Implicit indexes will be ignored when diffing
+     */
+    isImplicitIndex(name) {
+        // Ignore indexes with reserved names, e.g. autoindexes
+        return name.startsWith("sqlite_");
+    }
+}
+exports.BetterSqliteSchemaHelper = BetterSqliteSchemaHelper;