remult 0.25.8-exp.0 → 0.25.8-exp.1

package/esm/migrations/generate-migrations.js

@@ -4,12 +4,13 @@ import { compareMigrationSnapshot, emptySnapshot, } from './compare-migration-sn
 import { updateMigrationsFile } from './update-migrations-ts-file.js';
 import { DefaultMigrationBuilder, } from './migration-types.js';
 import { isOfType } from '../src/isOfType.js';
+import { initDataProvider } from '../server/initDataProvider.js';
 export async function generateMigrations(options) {
-    const migrationDir = options.migrationsDir || path.join(process.cwd(), 'src/server/migrations');
-    const snapshotFileName = options.snapshotFileName ||
-        path.join(migrationDir, 'migrations-snapshot.json');
-    const migrationsTSFilename = options.migrationsTSFilename || path.join(migrationDir, 'migrations.ts');
-    const dataProvider = await options.dataProvider;
+    const migrationDir = options.migrationsFolder ||
+        path.join(process.cwd(), 'src/server/migrations');
+    const snapshotFileName = options.snapshotFile || path.join(migrationDir, 'migrations-snapshot.json');
+    const migrationsTSFilename = options.migrationsTSFile || path.join(migrationDir, 'migrations.ts');
+    const dataProvider = await initDataProvider(options.dataProvider);
     for (const p of [snapshotFileName, migrationsTSFilename]) {
         if (!fs.existsSync(path.dirname(p))) {
             fs.mkdirSync(path.dirname(p), { recursive: true });
@@ -44,4 +45,7 @@ export async function generateMigrations(options) {
             `async (${hasSql ? '{sql}' : ''})=>{\n${steps.join('\n')}\n}`,
         ]);
     fs.writeFileSync(snapshotFileName, JSON.stringify(snapshot, null, 2));
+    if (options.endConnection !== false && isOfType(dataProvider, 'end')) {
+        await dataProvider.end();
+    }
 }

package/esm/migrations/migrate.js

@@ -1,12 +1,11 @@
 import { __decorate, __metadata } from "tslib";
 import { Entity, IdEntity, Fields, remult, Remult, } from '../index.js';
+import { initDataProvider } from '../server/initDataProvider.js';
 import { doTransaction } from '../src/context.js';
-import { cast } from '../src/isOfType.js';
+import { cast, isOfType } from '../src/isOfType.js';
 export async function migrate(options) {
-    let migrationTableName = options.migrationTableName || '__remult_migration_version';
-    const dataProvider = options.dataProvider
-        ? await options.dataProvider
-        : remult.dataProvider;
+    let migrationTableName = options.migrationsTable || '__remult_migrations_version';
+    const dataProvider = await initDataProvider(options.dataProvider);
     const prev = remult.dataProvider;
     remult.dataProvider = dataProvider;
     try {
@@ -36,15 +35,24 @@ export async function migrate(options) {
                 throw new Error('Migration step number must be a non-negative integer');
             if (v.version >= step)
                 continue;
-            console.info('Executing migration step', step);
-            await doTransaction(remult, async (dp) => {
-                const utils = {
-                    sql: async (sql) => {
-                        await cast(dp, 'execute').execute(sql);
-                    },
-                };
-                await action(utils);
-            });
+            console.info('Executing migration step ' + step);
+            console.time('Completed migration step ' + step);
+            try {
+                await doTransaction(remult, async (dp) => {
+                    const utils = {
+                        sql: async (sql) => {
+                            await cast(dp, 'execute').execute(sql);
+                        },
+                    };
+                    await action(utils);
+                });
+                console.timeEnd('Completed migration step ' + step);
+            }
+            catch (err) {
+                console.error('Failed to execute migration step ' + step);
+                console.error(err);
+                throw err;
+            }
             v.version = step;
             await v.save();
         }
@@ -52,4 +60,7 @@ export async function migrate(options) {
     finally {
         remult.dataProvider = prev;
     }
+    if (options.endConnection !== false && isOfType(dataProvider, 'end')) {
+        await dataProvider.end();
+    }
 }

package/esm/migrations/update-migrations-ts-file.js

@@ -10,7 +10,7 @@ export async function updateMigrationsFile(filePath, steps) {
         fs.writeFileSync(filePath, '');
     }
     const importPath = 'remult/migrations';
-    const importName = 'MigrationSteps';
+    const importName = 'Migrations';
     // Load the file
     const sourceFile = ts.createSourceFile(filePath, fs.readFileSync(filePath).toString(), ts.ScriptTarget.Latest, true);
     let migrationsExportFound = false;

package/esm/postgres/postgres-data-provider.js

@@ -1,3 +1,4 @@
+import { remult as defaultRemult } from '../src/remult-proxy.js';
 import pg from 'pg';
 const { Pool } = pg;
 import { Remult } from '../src/context.js';
@@ -8,8 +9,10 @@ export class PostgresDataProvider {
     options;
     supportsJsonColumnType = true;
     static getDb(remult) {
-        const sql = SqlDatabase.getDb(remult);
-        const me = sql._getSourceSql();
+        const r = (remult || defaultRemult).dataProvider;
+        if (!r._getSourceSql)
+            throw 'the data provider is not an SqlDatabase';
+        const me = r._getSourceSql();
         if (!me.pool) {
             throw 'the data provider is not a PostgresDataProvider';
         }
@@ -35,6 +38,9 @@ export class PostgresDataProvider {
             this.pool = new PostgresSchemaWrapper(pool, options.schema);
         }
     }
+    end() {
+        return this.pool.end();
+    }
     provideMigrationBuilder(builder) {
         var db = new SqlDatabase(this);
         var sb = new PostgresSchemaBuilder(db, this.options?.schema);
@@ -184,4 +190,7 @@ export class PostgresSchemaWrapper {
             c.release();
         }
     }
+    end() {
+        return this.pool.end();
+    }
 }

package/esm/remult-knex/index.js

@@ -13,6 +13,10 @@ export class KnexDataProvider {
     constructor(knex) {
         this.knex = knex;
     }
+    end() {
+        return this.knex.destroy();
+    }
+    /* @internal */
     provideMigrationBuilder(builder) {
         var sb = new KnexSchemaBuilder(this.knex);
         return {

package/esm/remult-sql-js.js

@@ -6,6 +6,11 @@ export class SqlJsDataProvider {
     constructor(db) {
         this.db = db;
     }
+    orderByNullsFirst;
+    async end() {
+        ;
+        (await this.db).close();
+    }
     getLimitSqlSyntax(limit, offset) {
         return ' limit ' + limit + ' offset ' + offset;
     }

package/esm/src/data-providers/sql-database.js

@@ -76,6 +76,7 @@ export class SqlDatabase {
                     transaction: (z) => x.transaction(z),
                     supportsJsonColumnType: this.sql.supportsJsonColumnType,
                     wrapIdentifier: this.wrapIdentifier,
+                    end: this.end,
                 }));
             }
             finally {
@@ -121,10 +122,13 @@ export class SqlDatabase {
         if (isOfType(sql, 'provideMigrationBuilder')) {
             this.provideMigrationBuilder = sql.provideMigrationBuilder;
         }
+        if (isOfType(sql, 'end'))
+            this.end = () => sql.end();
     }
+    /* @internal */
     provideMigrationBuilder;
-    isProxy;
     createdEntities = [];
+    end;
 }
 const icons = new Map([
     // CRUD

package/esm/src/data-providers/web-sql-data-provider.js

@@ -13,15 +13,7 @@ export class WebSqlDataProvider {
         //@ts-ignore
         this.db = window.openDatabase(databaseName, '1.0', databaseName, databaseSize);
     }
-    // return instance of websql.Database class - see @types/websql
-    static getDb(remult) {
-        const sql = SqlDatabase.getDb(remult);
-        const me = sql._getSourceSql();
-        if (!me.db) {
-            throw 'the data provider is not a WebSqlDataProvider';
-        }
-        return me.db;
-    }
+    async end() { }
     getLimitSqlSyntax(limit, offset) {
         return ' limit ' + limit + ' offset ' + offset;
     }

package/esm/src/remult3/remult3.js

@@ -11,7 +11,7 @@ https://gitkraken.dev/link/dnNjb2RlOi8vZWFtb2Rpby5naXRsZW5zL2xpbmsvci9mMDgzMWU0O
 */
 //p1 - cleanup root directory of reult
 //p1 - in this video I'll use remult to turn a frontend app to a fullstack app
-/*y1 - discuss using delete & put - with url query language for deleteMany and updateMany -
+/*p1 - discuss using delete & put - with url query language for deleteMany and updateMany -
   - put & delete, similar to get
   - add where to count, deleteMany,updateMany,
   - prevent delete all and update all - must have meaningful where.
@@ -20,6 +20,12 @@ https://gitkraken.dev/link/dnNjb2RlOi8vZWFtb2Rpby5naXRsZW5zL2xpbmsvci9mMDgzMWU0O
   - protect against deleting of all rows by mistake
   - https://github.com/remult/remult/issues/221#issuecomment-2016519746
 
+*/
+/*p1 -  I want to change the signature of getDb from getting optional remult, to getting optional dataProvider.
+
+In most cases you will not send anything - and it'll be by default remult.dataProvider.
+
+I just findmyself creating remults to extract the data provider :)
 */
 //y1 - getFields didn't work for kobi in the home component
 //p1 - add section to Fields doc, explaining field type in db

package/migrations/generate-migrations.d.ts

@@ -1,8 +1,9 @@
 import type { DataProvider } from '../index.js';
 export declare function generateMigrations(options: {
     entities: any[];
-    dataProvider: Promise<DataProvider> | DataProvider;
-    migrationsDir?: string;
-    snapshotFileName?: string;
-    migrationsTSFilename?: string;
+    dataProvider: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>);
+    migrationsFolder?: string;
+    snapshotFile?: string;
+    migrationsTSFile?: string;
+    endConnection?: boolean;
 }): Promise<void>;

package/migrations/generate-migrations.js

@@ -8,6 +8,7 @@ var compare_migration_snapshots_js_1 = require("./compare-migration-snapshots.js
 var update_migrations_ts_file_js_1 = require("./update-migrations-ts-file.js");
 var migration_types_js_1 = require("./migration-types.js");
 var isOfType_js_1 = require("../src/isOfType.js");
+var initDataProvider_js_1 = require("../server/initDataProvider.js");
 function generateMigrations(options) {
     return tslib_1.__awaiter(this, void 0, void 0, function () {
         var migrationDir, snapshotFileName, migrationsTSFilename, dataProvider, _a, _b, p, snapshot, hasSql, steps, code, migrationBuilder;
@@ -15,11 +16,11 @@ function generateMigrations(options) {
         return tslib_1.__generator(this, function (_d) {
             switch (_d.label) {
                 case 0:
-                    migrationDir = options.migrationsDir || path_1.default.join(process.cwd(), 'src/server/migrations');
-                    snapshotFileName = options.snapshotFileName ||
-                        path_1.default.join(migrationDir, 'migrations-snapshot.json');
-                    migrationsTSFilename = options.migrationsTSFilename || path_1.default.join(migrationDir, 'migrations.ts');
-                    return [4 /*yield*/, options.dataProvider];
+                    migrationDir = options.migrationsFolder ||
+                        path_1.default.join(process.cwd(), 'src/server/migrations');
+                    snapshotFileName = options.snapshotFile || path_1.default.join(migrationDir, 'migrations-snapshot.json');
+                    migrationsTSFilename = options.migrationsTSFile || path_1.default.join(migrationDir, 'migrations.ts');
+                    return [4 /*yield*/, (0, initDataProvider_js_1.initDataProvider)(options.dataProvider)];
                 case 1:
                     dataProvider = _d.sent();
                     try {
@@ -74,7 +75,12 @@ function generateMigrations(options) {
                     _d.label = 4;
                 case 4:
                     fs_1.default.writeFileSync(snapshotFileName, JSON.stringify(snapshot, null, 2));
-                    return [2 /*return*/];
+                    if (!(options.endConnection !== false && (0, isOfType_js_1.isOfType)(dataProvider, 'end'))) return [3 /*break*/, 6];
+                    return [4 /*yield*/, dataProvider.end()];
+                case 5:
+                    _d.sent();
+                    _d.label = 6;
+                case 6: return [2 /*return*/];
             }
         });
     });

package/migrations/migrate.d.ts

@@ -2,6 +2,7 @@ import { type DataProvider } from '../index.js';
 import type { Migrations } from './migration-types.js';
 export declare function migrate(options: {
     migrations: Migrations;
-    dataProvider?: Promise<DataProvider> | DataProvider;
-    migrationTableName?: string;
+    dataProvider: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>);
+    migrationsTable?: string;
+    endConnection?: boolean;
 }): Promise<void>;

package/migrations/migrate.js

@@ -3,32 +3,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.migrate = void 0;
 var tslib_1 = require("tslib");
 var index_js_1 = require("../index.js");
+var initDataProvider_js_1 = require("../server/initDataProvider.js");
 var context_js_1 = require("../src/context.js");
 var isOfType_js_1 = require("../src/isOfType.js");
 function migrate(options) {
     return tslib_1.__awaiter(this, void 0, void 0, function () {
-        var migrationTableName, dataProvider, _a, prev, VersionInfo, repo, v, steps, _loop_1, steps_1, steps_1_1, _b, stepText, action, e_1_1;
-        var e_1, _c;
+        var migrationTableName, dataProvider, prev, VersionInfo, repo, v, steps, _loop_1, steps_1, steps_1_1, _a, stepText, action, e_1_1;
+        var e_1, _b;
         var _this = this;
-        return tslib_1.__generator(this, function (_d) {
-            switch (_d.label) {
+        return tslib_1.__generator(this, function (_c) {
+            switch (_c.label) {
                 case 0:
-                    migrationTableName = options.migrationTableName || '__remult_migration_version';
-                    if (!options.dataProvider) return [3 /*break*/, 2];
-                    return [4 /*yield*/, options.dataProvider];
+                    migrationTableName = options.migrationsTable || '__remult_migrations_version';
+                    return [4 /*yield*/, (0, initDataProvider_js_1.initDataProvider)(options.dataProvider)];
                 case 1:
-                    _a = _d.sent();
-                    return [3 /*break*/, 3];
-                case 2:
-                    _a = index_js_1.remult.dataProvider;
-                    _d.label = 3;
-                case 3:
-                    dataProvider = _a;
+                    dataProvider = _c.sent();
                     prev = index_js_1.remult.dataProvider;
                     index_js_1.remult.dataProvider = dataProvider;
-                    _d.label = 4;
-                case 4:
-                    _d.trys.push([4, , 16, 17]);
+                    _c.label = 2;
+                case 2:
+                    _c.trys.push([2, , 14, 15]);
                     VersionInfo = /** @class */ (function (_super) {
                         tslib_1.__extends(VersionInfo, _super);
                         function VersionInfo() {
@@ -46,14 +40,14 @@ function migrate(options) {
                         return VersionInfo;
                     }(index_js_1.IdEntity));
                     repo = new index_js_1.Remult(dataProvider).repo(VersionInfo);
-                    if (!dataProvider.ensureSchema) return [3 /*break*/, 6];
+                    if (!dataProvider.ensureSchema) return [3 /*break*/, 4];
                     return [4 /*yield*/, dataProvider.ensureSchema([repo.metadata])];
+                case 3:
+                    _c.sent();
+                    _c.label = 4;
+                case 4: return [4 /*yield*/, repo.findFirst()];
                 case 5:
-                    _d.sent();
-                    _d.label = 6;
-                case 6: return [4 /*yield*/, repo.findFirst()];
-                case 7:
-                    v = _d.sent();
+                    v = _c.sent();
                     if (!v) {
                         v = repo.create();
                         v.version = -1;
@@ -64,16 +58,20 @@ function migrate(options) {
                         return parseInt(a) - parseInt(b);
                     });
                     _loop_1 = function (stepText, action) {
-                        var step;
-                        return tslib_1.__generator(this, function (_e) {
-                            switch (_e.label) {
+                        var step, err_1;
+                        return tslib_1.__generator(this, function (_d) {
+                            switch (_d.label) {
                                 case 0:
                                     step = parseInt(stepText);
                                     if (step < 0)
                                         throw new Error('Migration step number must be a non-negative integer');
                                     if (v.version >= step)
                                         return [2 /*return*/, "continue"];
-                                    console.info('Executing migration step', step);
+                                    console.info('Executing migration step ' + step);
+                                    console.time('Completed migration step ' + step);
+                                    _d.label = 1;
+                                case 1:
+                                    _d.trys.push([1, 3, , 4]);
                                     return [4 /*yield*/, (0, context_js_1.doTransaction)(index_js_1.remult, function (dp) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
                                             var utils;
                                             var _this = this;
@@ -99,46 +97,60 @@ function migrate(options) {
                                                 }
                                             });
                                         }); })];
-                                case 1:
-                                    _e.sent();
+                                case 2:
+                                    _d.sent();
+                                    console.timeEnd('Completed migration step ' + step);
+                                    return [3 /*break*/, 4];
+                                case 3:
+                                    err_1 = _d.sent();
+                                    console.error('Failed to execute migration step ' + step);
+                                    console.error(err_1);
+                                    throw err_1;
+                                case 4:
                                     v.version = step;
                                     return [4 /*yield*/, v.save()];
-                                case 2:
-                                    _e.sent();
+                                case 5:
+                                    _d.sent();
                                     return [2 /*return*/];
                             }
                         });
                     };
-                    _d.label = 8;
-                case 8:
-                    _d.trys.push([8, 13, 14, 15]);
+                    _c.label = 6;
+                case 6:
+                    _c.trys.push([6, 11, 12, 13]);
                     steps_1 = tslib_1.__values(steps), steps_1_1 = steps_1.next();
-                    _d.label = 9;
-                case 9:
-                    if (!!steps_1_1.done) return [3 /*break*/, 12];
-                    _b = tslib_1.__read(steps_1_1.value, 2), stepText = _b[0], action = _b[1];
+                    _c.label = 7;
+                case 7:
+                    if (!!steps_1_1.done) return [3 /*break*/, 10];
+                    _a = tslib_1.__read(steps_1_1.value, 2), stepText = _a[0], action = _a[1];
                     return [5 /*yield**/, _loop_1(stepText, action)];
-                case 10:
-                    _d.sent();
-                    _d.label = 11;
-                case 11:
+                case 8:
+                    _c.sent();
+                    _c.label = 9;
+                case 9:
                     steps_1_1 = steps_1.next();
-                    return [3 /*break*/, 9];
-                case 12: return [3 /*break*/, 15];
-                case 13:
-                    e_1_1 = _d.sent();
+                    return [3 /*break*/, 7];
+                case 10: return [3 /*break*/, 13];
+                case 11:
+                    e_1_1 = _c.sent();
                     e_1 = { error: e_1_1 };
-                    return [3 /*break*/, 15];
-                case 14:
+                    return [3 /*break*/, 13];
+                case 12:
                     try {
-                        if (steps_1_1 && !steps_1_1.done && (_c = steps_1.return)) _c.call(steps_1);
+                        if (steps_1_1 && !steps_1_1.done && (_b = steps_1.return)) _b.call(steps_1);
                     }
                     finally { if (e_1) throw e_1.error; }
                     return [7 /*endfinally*/];
-                case 15: return [3 /*break*/, 17];
-                case 16:
+                case 13: return [3 /*break*/, 15];
+                case 14:
                     index_js_1.remult.dataProvider = prev;
                     return [7 /*endfinally*/];
+                case 15:
+                    if (!(options.endConnection !== false && (0, isOfType_js_1.isOfType)(dataProvider, 'end'))) return [3 /*break*/, 17];
+                    return [4 /*yield*/, dataProvider.end()];
+                case 16:
+                    _c.sent();
+                    _c.label = 17;
                 case 17: return [2 /*return*/];
             }
         });

package/migrations/update-migrations-ts-file.js

@@ -21,7 +21,7 @@ function updateMigrationsFile(filePath, steps) {
                         fs.writeFileSync(filePath, '');
                     }
                     importPath = 'remult/migrations';
-                    importName = 'MigrationSteps';
+                    importName = 'Migrations';
                     sourceFile = ts.createSourceFile(filePath, fs.readFileSync(filePath).toString(), ts.ScriptTarget.Latest, true);
                     migrationsExportFound = false;
                     updatedSourceFile = ts.transform(sourceFile, [

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.25.8-exp.0",
+    "version": "0.25.8-exp.1",
     "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev",
     "repository": {

package/postgres/postgres-data-provider.d.ts

@@ -6,6 +6,7 @@ import type { SqlCommand, SqlImplementation } from '../src/sql-command.js';
 import type { CanBuildMigrations, MigrationBuilder, MigrationCode } from '../migrations/migration-types.js';
 export interface PostgresPool extends PostgresCommandSource {
     connect(): Promise<PostgresClient>;
+    end(): Promise<void>;
 }
 export interface PostgresClient extends PostgresCommandSource {
     release(): void;
@@ -24,6 +25,7 @@ export declare class PostgresDataProvider implements SqlImplementation, CanBuild
         schema?: string;
         orderByNullsFirst?: boolean;
     });
+    end(): Promise<void>;
     provideMigrationBuilder(builder: MigrationCode): MigrationBuilder;
     wrapIdentifier: (name: any) => any;
     ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
@@ -50,4 +52,5 @@ export declare class PostgresSchemaWrapper implements PostgresPool {
     constructor(pool: PostgresPool, schema: string);
     connect(): Promise<PostgresClient>;
     query(queryText: string, values?: any[]): Promise<QueryResult>;
+    end(): Promise<void>;
 }

package/postgres/postgres-data-provider.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgresSchemaWrapper = exports.preparePostgresQueueStorage = exports.createPostgresDataProvider = exports.createPostgresConnection = exports.PostgresDataProvider = void 0;
 var tslib_1 = require("tslib");
+var remult_proxy_js_1 = require("../src/remult-proxy.js");
 var pg_1 = tslib_1.__importDefault(require("pg"));
 var Pool = pg_1.default.Pool;
 var context_js_1 = require("../src/context.js");
@@ -31,8 +32,10 @@ var PostgresDataProvider = /** @class */ (function () {
         }
     }
     PostgresDataProvider.getDb = function (remult) {
-        var sql = sql_database_js_1.SqlDatabase.getDb(remult);
-        var me = sql._getSourceSql();
+        var r = (remult || remult_proxy_js_1.remult).dataProvider;
+        if (!r._getSourceSql)
+            throw 'the data provider is not an SqlDatabase';
+        var me = r._getSourceSql();
         if (!me.pool) {
             throw 'the data provider is not a PostgresDataProvider';
         }
@@ -49,6 +52,9 @@ var PostgresDataProvider = /** @class */ (function () {
     PostgresDataProvider.prototype.createCommand = function () {
         return new PostgresBridgeToSQLCommand(this.pool);
     };
+    PostgresDataProvider.prototype.end = function () {
+        return this.pool.end();
+    };
     PostgresDataProvider.prototype.provideMigrationBuilder = function (builder) {
         var _this = this;
         var _a;
@@ -299,6 +305,9 @@ var PostgresSchemaWrapper = /** @class */ (function () {
             });
         });
     };
+    PostgresSchemaWrapper.prototype.end = function () {
+        return this.pool.end();
+    };
     return PostgresSchemaWrapper;
 }());
 exports.PostgresSchemaWrapper = PostgresSchemaWrapper;

package/remult-knex/index.d.ts

@@ -6,11 +6,11 @@ import type { DataProvider, EntityDataProvider } from '../src/data-interfaces.js
 import type { EntityFilter, EntityMetadata } from '../src/remult3/remult3.js';
 import type { RepositoryOverloads } from '../src/remult3/RepositoryImplementation.js';
 import type { HasWrapIdentifier, SqlCommand, SqlCommandFactory, SqlResult } from '../src/sql-command.js';
-import type { CanBuildMigrations, MigrationBuilder, MigrationCode } from '../migrations/migration-types.js';
+import type { CanBuildMigrations } from '../migrations/migration-types.js';
 export declare class KnexDataProvider implements DataProvider, HasWrapIdentifier, SqlCommandFactory, CanBuildMigrations {
     knex: Knex;
     constructor(knex: Knex);
-    provideMigrationBuilder(builder: MigrationCode): MigrationBuilder;
+    end(): Promise<void>;
     createCommand(): SqlCommand;
     execute(sql: string): Promise<SqlResult>;
     static getDb(remult?: Remult): Knex<any, any[]>;

package/remult-knex/index.js

@@ -18,6 +18,10 @@ var KnexDataProvider = /** @class */ (function () {
         this.knex = knex;
         this.wrapIdentifier = function (x) { return _this.knex.ref(x) + ''; };
     }
+    KnexDataProvider.prototype.end = function () {
+        return this.knex.destroy();
+    };
+    /* @internal */
     KnexDataProvider.prototype.provideMigrationBuilder = function (builder) {
         var sb = new KnexSchemaBuilder(this.knex);
         return {

package/remult-sql-js.d.ts

@@ -4,6 +4,8 @@ import type { Database } from 'sql.js';
 export declare class SqlJsDataProvider implements SqlImplementation {
     private db;
     constructor(db: Promise<Database>);
+    orderByNullsFirst?: boolean;
+    end(): Promise<void>;
     getLimitSqlSyntax(limit: number, offset: number): string;
     afterMutation?: VoidFunction;
     createCommand(): SqlCommand;

package/remult-sql-js.js

@@ -9,6 +9,20 @@ var SqlJsDataProvider = /** @class */ (function () {
     function SqlJsDataProvider(db) {
         this.db = db;
     }
+    SqlJsDataProvider.prototype.end = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        ;
+                        return [4 /*yield*/, this.db];
+                    case 1:
+                        (_a.sent()).close();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     SqlJsDataProvider.prototype.getLimitSqlSyntax = function (limit, offset) {
         return ' limit ' + limit + ' offset ' + offset;
     };

package/src/data-providers/sql-database.d.ts

@@ -4,7 +4,7 @@ import type { Remult } from '../context.js';
 import type { CustomSqlFilterBuilderFunction, EntityDbNamesBase } from '../filter/filter-consumer-bridge-to-sql-request.js';
 import type { EntityFilter, EntityMetadata } from '../remult3/remult3.js';
 import type { RepositoryOverloads } from '../remult3/RepositoryImplementation.js';
-import type { CanBuildMigrations, MigrationBuilder, MigrationCode } from '../../migrations/migration-types.js';
+import type { CanBuildMigrations } from '../../migrations/migration-types.js';
 export declare class SqlDatabase implements DataProvider, HasWrapIdentifier, CanBuildMigrations, SqlCommandFactory {
     private sql;
     static getDb(remult?: Remult): SqlDatabase;
@@ -31,7 +31,6 @@ export declare class SqlDatabase implements DataProvider, HasWrapIdentifier, Can
      */
     static durationThreshold: number;
     constructor(sql: SqlImplementation);
-    provideMigrationBuilder: (builder: MigrationCode) => MigrationBuilder;
-    isProxy?: boolean;
     private createdEntities;
+    end: () => Promise<void>;
 }

package/src/data-providers/sql-database.js

@@ -22,6 +22,8 @@ var SqlDatabase = /** @class */ (function () {
         if ((0, isOfType_js_1.isOfType)(sql, 'provideMigrationBuilder')) {
             this.provideMigrationBuilder = sql.provideMigrationBuilder;
         }
+        if ((0, isOfType_js_1.isOfType)(sql, 'end'))
+            this.end = function () { return sql.end(); };
     }
     SqlDatabase.getDb = function (remult) {
         var r = (remult || remult_proxy_js_1.remult).dataProvider;
@@ -134,6 +136,7 @@ var SqlDatabase = /** @class */ (function () {
                                 transaction: function (z) { return x.transaction(z); },
                                 supportsJsonColumnType: this.sql.supportsJsonColumnType,
                                 wrapIdentifier: this.wrapIdentifier,
+                                end: this.end,
                             }))];
                     case 2:
                         _a.sent();

package/src/data-providers/web-sql-data-provider.d.ts

@@ -1,6 +1,5 @@
 import type { __RowsOfDataForTesting } from '../__RowsOfDataForTesting.js';
 import type { SqlCommand, SqlImplementation } from '../sql-command.js';
-import type { Remult } from '../context.js';
 import type { EntityMetadata } from '../remult3/remult3.js';
 export declare class WebSqlDataProvider implements SqlImplementation, __RowsOfDataForTesting {
     private databaseName;
@@ -8,7 +7,7 @@ export declare class WebSqlDataProvider implements SqlImplementation, __RowsOfDa
         [tableName: string]: any;
     };
     constructor(databaseName: string, databaseSize?: number);
-    static getDb(remult?: Remult): any;
+    end(): Promise<void>;
     getLimitSqlSyntax(limit: number, offset: number): string;
     entityIsUsedForTheFirstTime(entity: EntityMetadata): Promise<void>;
     ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;

package/src/data-providers/web-sql-data-provider.js

@@ -13,14 +13,10 @@ var WebSqlDataProvider = /** @class */ (function () {
         //@ts-ignore
         this.db = window.openDatabase(databaseName, '1.0', databaseName, databaseSize);
     }
-    // return instance of websql.Database class - see @types/websql
-    WebSqlDataProvider.getDb = function (remult) {
-        var sql = sql_database_js_1.SqlDatabase.getDb(remult);
-        var me = sql._getSourceSql();
-        if (!me.db) {
-            throw 'the data provider is not a WebSqlDataProvider';
-        }
-        return me.db;
+    WebSqlDataProvider.prototype.end = function () {
+        return tslib_1.__awaiter(this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+            return [2 /*return*/];
+        }); });
     };
     WebSqlDataProvider.prototype.getLimitSqlSyntax = function (limit, offset) {
         return ' limit ' + limit + ' offset ' + offset;

package/src/remult3/remult3.js

@@ -12,7 +12,7 @@ https://gitkraken.dev/link/dnNjb2RlOi8vZWFtb2Rpby5naXRsZW5zL2xpbmsvci9mMDgzMWU0O
 */
 //p1 - cleanup root directory of reult
 //p1 - in this video I'll use remult to turn a frontend app to a fullstack app
-/*y1 - discuss using delete & put - with url query language for deleteMany and updateMany -
+/*p1 - discuss using delete & put - with url query language for deleteMany and updateMany -
   - put & delete, similar to get
   - add where to count, deleteMany,updateMany,
   - prevent delete all and update all - must have meaningful where.
@@ -21,6 +21,12 @@ https://gitkraken.dev/link/dnNjb2RlOi8vZWFtb2Rpby5naXRsZW5zL2xpbmsvci9mMDgzMWU0O
   - protect against deleting of all rows by mistake
   - https://github.com/remult/remult/issues/221#issuecomment-2016519746
 
+*/
+/*p1 -  I want to change the signature of getDb from getting optional remult, to getting optional dataProvider.
+
+In most cases you will not send anything - and it'll be by default remult.dataProvider.
+
+I just findmyself creating remults to extract the data provider :)
 */
 //y1 - getFields didn't work for kobi in the home component
 //p1 - add section to Fields doc, explaining field type in db

package/src/sql-command.d.ts

@@ -7,6 +7,7 @@ export interface SqlImplementation extends HasWrapIdentifier {
     ensureSchema?(entities: EntityMetadata[]): Promise<void>;
     supportsJsonColumnType?: boolean;
     orderByNullsFirst?: boolean;
+    end(): Promise<void>;
     afterMutation?: VoidFunction;
 }
 export interface HasWrapIdentifier {