@mikro-orm/sql 7.0.0-dev.196 → 7.0.0-dev.198

package/dialects/sqlite/BaseSqliteConnection.d.ts

@@ -3,4 +3,5 @@ export declare abstract class BaseSqliteConnection extends AbstractSqlConnection
     connect(options?: {
         skipOnConnect?: boolean;
     }): Promise<void>;
+    protected attachDatabases(): Promise<void>;
 }

package/dialects/sqlite/BaseSqliteConnection.js

@@ -4,5 +4,18 @@ export class BaseSqliteConnection extends AbstractSqlConnection {
     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/BaseSqlitePlatform.d.ts

@@ -64,6 +64,12 @@ export declare abstract class BaseSqlitePlatform extends AbstractSqlPlatform {
     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;
     quoteVersionValue(value: Date | number, prop: EntityProperty): Date | string | number;
     quoteValue(value: any): string;

package/dialects/sqlite/BaseSqlitePlatform.js

@@ -86,6 +86,18 @@ export class BaseSqlitePlatform extends AbstractSqlPlatform {
     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`;
     }

package/dialects/sqlite/SqliteSchemaHelper.d.ts

@@ -8,7 +8,11 @@ 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[]>;
     getListViewsSQL(): string;
     loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection, schemaName?: string): Promise<void>;
     getDropDatabaseSQL(name: string): string;
@@ -20,6 +24,19 @@ export declare class SqliteSchemaHelper extends SchemaHelper {
     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;
     private getEnumDefinitions;
     getPrimaryKeys(connection: AbstractSqlConnection, indexes: IndexDef[], tableName: string, schemaName?: string): Promise<string[]>;
@@ -35,6 +52,11 @@ export declare class SqliteSchemaHelper extends SchemaHelper {
      */
     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;
 }

package/dialects/sqlite/SqliteSchemaHelper.js

@@ -10,20 +10,62 @@ export class SqliteSchemaHelper extends SchemaHelper {
     supportsSchemaConstraints() {
         return false;
     }
+    getCreateNamespaceSQL(name) {
+        return '';
+    }
+    getDropNamespaceSQL(name) {
+        return '';
+    }
     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`;
     }
+    async getAllTables(connection, schemas) {
+        const databases = await this.getDatabaseList(connection);
+        const hasAttachedDbs = databases.length > 1; // More than just 'main'
+        // If no attached databases, use original behavior
+        if (!hasAttachedDbs && !schemas?.length) {
+            return connection.execute(this.getListTablesSQL());
+        }
+        // With attached databases, query each one
+        const targetSchemas = schemas?.length ? schemas : databases;
+        const allTables = [];
+        for (const dbName of targetSchemas) {
+            const prefix = this.getSchemaPrefix(dbName);
+            const tables = await connection.execute(`select name from ${prefix}sqlite_master where type = 'table' ` +
+                `and name != 'sqlite_sequence' and name != 'geometry_columns' and name != 'spatial_ref_sys'`);
+            for (const t of tables) {
+                allTables.push({ table_name: t.name, schema_name: dbName });
+            }
+        }
+        return allTables;
+    }
+    async getNamespaces(connection) {
+        return this.getDatabaseList(connection);
+    }
     getListViewsSQL() {
         return `select name as view_name, sql as view_definition from sqlite_master where type = 'view' order by name`;
     }
     async loadViews(schema, connection, schemaName) {
-        const views = await connection.execute(this.getListViewsSQL());
-        for (const view of views) {
-            // Extract the definition from CREATE VIEW statement
-            const match = view.view_definition.match(/create\s+view\s+[`"']?\w+[`"']?\s+as\s+(.*)/i);
-            const definition = match ? match[1] : view.view_definition;
-            schema.addView(view.view_name, schemaName, definition);
+        const databases = await this.getDatabaseList(connection);
+        const hasAttachedDbs = databases.length > 1; // More than just 'main'
+        // If no attached databases and no specific schema, use original behavior
+        if (!hasAttachedDbs && !schemaName) {
+            const views = await connection.execute(this.getListViewsSQL());
+            for (const view of views) {
+                schema.addView(view.view_name, schemaName, this.extractViewDefinition(view.view_definition));
+            }
+            return;
+        }
+        // With attached databases, query each one
+        /* v8 ignore next - schemaName branch not commonly used */
+        const targetDbs = schemaName ? [schemaName] : databases;
+        for (const dbName of targetDbs) {
+            const prefix = this.getSchemaPrefix(dbName);
+            const views = await connection.execute(`select name as view_name, sql as view_definition from ${prefix}sqlite_master where type = 'view' order by name`);
+            for (const view of views) {
+                schema.addView(view.view_name, dbName, this.extractViewDefinition(view.view_definition));
+            }
         }
     }
     getDropDatabaseSQL(name) {
@@ -41,7 +83,7 @@ export class SqliteSchemaHelper extends SchemaHelper {
             const checks = await this.getChecks(connection, table.name, table.schema);
             const pks = await this.getPrimaryKeys(connection, indexes, table.name, table.schema);
             const fks = await this.getForeignKeys(connection, table.name, table.schema);
-            const enums = await this.getEnumDefinitions(connection, table.name);
+            const enums = await this.getEnumDefinitions(connection, table.name, table.schema);
             table.init(cols, indexes, checks, pks, fks, enums);
         }
     }
@@ -73,6 +115,9 @@ export class SqliteSchemaHelper extends SchemaHelper {
             sql += ', ' + parts.join(', ');
         }
         sql += ')';
+        if (table.comment) {
+            sql += ` /* ${table.comment} */`;
+        }
         const ret = [];
         this.append(ret, sql);
         for (const index of table.getIndexes()) {
@@ -130,16 +175,26 @@ export class SqliteSchemaHelper extends SchemaHelper {
         if (index.expression) {
             return index.expression;
         }
-        tableName = this.quote(tableName);
-        const keyName = this.quote(index.keyName);
-        const sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName} `;
+        // SQLite requires: CREATE INDEX schema.index_name ON table_name (columns)
+        // NOT: CREATE INDEX index_name ON schema.table_name (columns)
+        const [schemaName, rawTableName] = this.splitTableName(tableName);
+        const quotedTableName = this.quote(rawTableName);
+        // If there's a schema, prefix the index name with it
+        let keyName;
+        if (schemaName && schemaName !== 'main') {
+            keyName = `${this.quote(schemaName)}.${this.quote(index.keyName)}`;
+        }
+        else {
+            keyName = this.quote(index.keyName);
+        }
+        const sqlPrefix = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${quotedTableName}`;
+        /* v8 ignore next 4 */
         if (index.columnNames.some(column => column.includes('.'))) {
             // JSON columns can have unique index but not unique constraint, and we need to distinguish those, so we can properly drop them
-            const sql = `create ${index.unique ? 'unique ' : ''}index ${keyName} on ${tableName} `;
             const columns = this.platform.getJsonIndexDefinition(index);
-            return `${sql}(${columns.join(', ')})`;
+            return `${sqlPrefix} (${columns.join(', ')})`;
         }
-        return `${sql}(${index.columnNames.map(c => this.quote(c)).join(', ')})`;
+        return `${sqlPrefix} (${index.columnNames.map(c => this.quote(c)).join(', ')})`;
     }
     parseTableDefinition(sql, cols) {
         const columns = {};
@@ -164,9 +219,35 @@ export class SqliteSchemaHelper extends SchemaHelper {
         }
         return { columns, constraints };
     }
+    /**
+     * Returns schema prefix for pragma and sqlite_master queries.
+     * Returns empty string for main database (no prefix needed).
+     */
+    getSchemaPrefix(schemaName) {
+        if (!schemaName || schemaName === 'main') {
+            return '';
+        }
+        return `${this.platform.quoteIdentifier(schemaName)}.`;
+    }
+    /**
+     * Returns all database names excluding 'temp'.
+     */
+    async getDatabaseList(connection) {
+        const databases = await connection.execute('pragma database_list');
+        return databases.filter(d => d.name !== 'temp').map(d => d.name);
+    }
+    /**
+     * Extracts the SELECT part from a CREATE VIEW statement.
+     */
+    extractViewDefinition(viewDefinition) {
+        const match = viewDefinition?.match(/create\s+view\s+[`"']?\w+[`"']?\s+as\s+(.*)/i);
+        /* v8 ignore next - fallback for non-standard view definitions */
+        return match ? match[1] : viewDefinition;
+    }
     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 prefix = this.getSchemaPrefix(schemaName);
+        const columns = await connection.execute(`pragma ${prefix}table_xinfo('${tableName}')`);
+        const sql = `select sql from ${prefix}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
@@ -197,8 +278,9 @@ export class SqliteSchemaHelper extends SchemaHelper {
             };
         });
     }
-    async getEnumDefinitions(connection, tableName) {
-        const sql = `select sql from sqlite_master where type = ? and name = ?`;
+    async getEnumDefinitions(connection, tableName, schemaName) {
+        const prefix = this.getSchemaPrefix(schemaName);
+        const sql = `select sql from ${prefix}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) => {
@@ -213,14 +295,16 @@ export class SqliteSchemaHelper extends SchemaHelper {
         }, {});
     }
     async getPrimaryKeys(connection, indexes, tableName, schemaName) {
-        const sql = `pragma table_info(\`${tableName}\`)`;
+        const prefix = this.getSchemaPrefix(schemaName);
+        const sql = `pragma ${prefix}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 prefix = this.getSchemaPrefix(schemaName);
+        const sql = `pragma ${prefix}table_info(\`${tableName}\`)`;
         const cols = await connection.execute(sql);
-        const indexes = await connection.execute(`pragma index_list(\`${tableName}\`)`);
+        const indexes = await connection.execute(`pragma ${prefix}index_list(\`${tableName}\`)`);
         const ret = [];
         for (const col of cols.filter(c => c.pk)) {
             ret.push({
@@ -232,7 +316,7 @@ export class SqliteSchemaHelper extends SchemaHelper {
             });
         }
         for (const index of indexes.filter(index => !this.isImplicitIndex(index.name))) {
-            const res = await connection.execute(`pragma index_info(\`${index.name}\`)`);
+            const res = await connection.execute(`pragma ${prefix}index_info(\`${index.name}\`)`);
             ret.push(...res.map(row => ({
                 columnNames: [row.name],
                 keyName: index.name,
@@ -271,14 +355,17 @@ export class SqliteSchemaHelper extends SchemaHelper {
         return checks;
     }
     async getColumnDefinitions(connection, tableName, schemaName) {
-        const columns = await connection.execute(`pragma table_xinfo('${tableName}')`);
-        const sql = `select sql from sqlite_master where type = ? and name = ?`;
+        const prefix = this.getSchemaPrefix(schemaName);
+        const columns = await connection.execute(`pragma ${prefix}table_xinfo('${tableName}')`);
+        const sql = `select sql from ${prefix}sqlite_master where type = ? and name = ?`;
         const tableDefinition = await connection.execute(sql, ['table', tableName], 'get');
         return this.parseTableDefinition(tableDefinition.sql, columns);
     }
     async getForeignKeys(connection, tableName, schemaName) {
         const { constraints } = await this.getColumnDefinitions(connection, tableName, schemaName);
-        const fks = await connection.execute(`pragma foreign_key_list(\`${tableName}\`)`);
+        const prefix = this.getSchemaPrefix(schemaName);
+        const fks = await connection.execute(`pragma ${prefix}foreign_key_list(\`${tableName}\`)`);
+        const qualifiedTableName = schemaName ? `${schemaName}.${tableName}` : tableName;
         return fks.reduce((ret, fk) => {
             const constraintName = this.platform.getIndexName(tableName, [fk.from], 'foreign');
             const constraint = constraints?.find(c => c.includes(constraintName));
@@ -286,7 +373,7 @@ export class SqliteSchemaHelper extends SchemaHelper {
                 constraintName,
                 columnName: fk.from,
                 columnNames: [fk.from],
-                localTableName: tableName,
+                localTableName: qualifiedTableName,
                 referencedTableName: fk.table,
                 referencedColumnName: fk.to,
                 referencedColumnNames: [fk.to],
@@ -317,6 +404,15 @@ export class SqliteSchemaHelper extends SchemaHelper {
     dropIndex(table, index, oldIndexName = index.keyName) {
         return `drop index ${this.quote(oldIndexName)}`;
     }
+    /**
+     * 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, schema) {
+        const [schemaName, tableName] = this.splitTableName(referencedTableName);
+        // Strip any schema prefix - SQLite REFERENCES clause doesn't support it
+        return tableName;
+    }
     alterTable(diff, safe) {
         const ret = [];
         const [schemaName, tableName] = this.splitTableName(diff.name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/sql",
-  "version": "7.0.0-dev.196",
+  "version": "7.0.0-dev.198",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "type": "module",
   "exports": {
@@ -56,6 +56,6 @@
     "@mikro-orm/core": "^6.6.4"
   },
   "peerDependencies": {
-    "@mikro-orm/core": "7.0.0-dev.196"
+    "@mikro-orm/core": "7.0.0-dev.198"
   }
 }

package/schema/DatabaseSchema.js

@@ -77,7 +77,7 @@ export class DatabaseSchema {
     }
     static async create(connection, platform, config, schemaName, schemas, takeTables, skipTables) {
         const schema = new DatabaseSchema(platform, schemaName ?? config.get('schema') ?? platform.getDefaultSchemaName());
-        const allTables = await connection.execute(platform.getSchemaHelper().getListTablesSQL());
+        const allTables = await platform.getSchemaHelper().getAllTables(connection, schemas);
         const parts = config.get('migrations').tableName.split('.');
         const migrationsTableName = parts[1] ?? parts[0];
         const migrationsSchemaName = parts.length > 1 ? parts[0] : config.get('schema', platform.getDefaultSchemaName());

package/schema/SchemaHelper.d.ts

@@ -22,6 +22,7 @@ export declare abstract class SchemaHelper {
     getAlterNativeEnumSQL(name: string, schema?: string, value?: string, items?: string[], oldItems?: string[]): string;
     abstract loadInformationSchema(schema: DatabaseSchema, connection: AbstractSqlConnection, tables: Table[], schemas?: string[]): Promise<void>;
     getListTablesSQL(): string;
+    getAllTables(connection: AbstractSqlConnection, schemas?: string[]): Promise<Table[]>;
     getListViewsSQL(): string;
     loadViews(schema: DatabaseSchema, connection: AbstractSqlConnection): Promise<void>;
     getRenameColumnSQL(tableName: string, oldColumnName: string, to: Column, schemaName?: string): string;

package/schema/SchemaHelper.js

@@ -65,6 +65,9 @@ export class SchemaHelper {
     getListTablesSQL() {
         throw new Error('Not supported by given driver');
     }
+    async getAllTables(connection, schemas) {
+        return connection.execute(this.getListTablesSQL());
+    }
     getListViewsSQL() {
         throw new Error('Not supported by given driver');
     }