remult 0.25.8 → 0.26.0

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

@@ -0,0 +1,141 @@
+"use strict";
+// consider replacing with https://www.npmjs.com/package/ts-morph
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateMigrationsFile = void 0;
+var tslib_1 = require("tslib");
+function updateMigrationsFile(filePath, steps) {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        function buildSteps() {
+            return steps.map(function (step) {
+                return ts.factory.createPropertyAssignment(ts.factory.createIdentifier((++maxStep).toString()), ts.factory.createIdentifier(step));
+            });
+        }
+        var ts, fs, maxStep, importPath, importName, sourceFile, migrationsExportFound, updatedSourceFile, importFound_1, newMigrationsExport, code, prettier, err_1, options, err_2;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, Promise.resolve().then(function () { return tslib_1.__importStar(require('typescript')); })];
+                case 1:
+                    ts = _a.sent();
+                    //@ts-ignore
+                    if (ts.default)
+                        ts = ts.default;
+                    return [4 /*yield*/, Promise.resolve().then(function () { return tslib_1.__importStar(require('fs')); })];
+                case 2:
+                    fs = _a.sent();
+                    maxStep = -1;
+                    if (!fs.existsSync(filePath)) {
+                        fs.writeFileSync(filePath, '');
+                    }
+                    importPath = 'remult/migrations';
+                    importName = 'Migrations';
+                    sourceFile = ts.createSourceFile(filePath, fs.readFileSync(filePath).toString(), ts.ScriptTarget.Latest, true);
+                    migrationsExportFound = false;
+                    updatedSourceFile = ts.transform(sourceFile, [
+                        function (context) {
+                            return function (node) {
+                                var visitor = function (node) {
+                                    if (ts.isVariableStatement(node) &&
+                                        node.declarationList.declarations.length > 0) {
+                                        var declaration = node.declarationList.declarations[0];
+                                        if (ts.isIdentifier(declaration.name) &&
+                                            declaration.name.text === 'migrations' &&
+                                            declaration.initializer &&
+                                            ts.isObjectLiteralExpression(declaration.initializer)) {
+                                            migrationsExportFound = true;
+                                            declaration.initializer.properties.forEach(function (property) {
+                                                if (ts.isPropertyAssignment(property)) {
+                                                    if (ts.isNumericLiteral(property.name)) {
+                                                        var step = parseInt(property.name.text);
+                                                        if (step > maxStep) {
+                                                            maxStep = step;
+                                                        }
+                                                    }
+                                                }
+                                            });
+                                            var steps_1 = buildSteps();
+                                            // Found the "migrations" array
+                                            // Update the initializer with the new steps
+                                            var updatedInitializer = ts.factory.updateObjectLiteralExpression(declaration.initializer, tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(declaration.initializer.properties), false), tslib_1.__read(steps_1), false));
+                                            // Update the declaration with the new initializer
+                                            var updatedDeclaration = ts.factory.updateVariableDeclaration(declaration, declaration.name, undefined, declaration.type, // Preserve the original type annotation if present
+                                            updatedInitializer);
+                                            return ts.factory.updateVariableStatement(node, node.modifiers, ts.factory.updateVariableDeclarationList(node.declarationList, [
+                                                updatedDeclaration,
+                                            ]));
+                                        }
+                                    }
+                                    return ts.visitEachChild(node, visitor, context);
+                                };
+                                return ts.visitNode(node, visitor);
+                            };
+                        },
+                    ]).transformed[0];
+                    if (!migrationsExportFound) {
+                        importFound_1 = false;
+                        // Check if the import statement already exists
+                        sourceFile.statements.forEach(function (statement) {
+                            var _a, _b;
+                            if (ts.isImportDeclaration(statement) &&
+                                ts.isStringLiteral(statement.moduleSpecifier) &&
+                                statement.moduleSpecifier.text === "".concat(importPath)) {
+                                (_b = (_a = statement.importClause) === null || _a === void 0 ? void 0 : _a.namedBindings) === null || _b === void 0 ? void 0 : _b.forEachChild(function (namedBinding) {
+                                    if (ts.isImportSpecifier(namedBinding) &&
+                                        namedBinding.name.text === importName) {
+                                        importFound_1 = true;
+                                    }
+                                });
+                            }
+                        });
+                        // If the import statement doesn't exist, create it
+                        if (!importFound_1) {
+                            updatedSourceFile = ts.factory.updateSourceFile(updatedSourceFile, tslib_1.__spreadArray([
+                                ts.factory.createExpressionStatement(ts.factory.createIdentifier("import type { ".concat(importName, " } from '").concat(importPath, "'")))
+                            ], tslib_1.__read(updatedSourceFile.statements), false));
+                        }
+                        newMigrationsExport = ts.factory.createVariableStatement([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
+                            ts.factory.createVariableDeclaration('migrations', undefined, // You can add a type annotation here if needed
+                            ts.factory.createTypeReferenceNode(importName, undefined), ts.factory.createObjectLiteralExpression(buildSteps(), false)),
+                        ], ts.NodeFlags.Const));
+                        // Add the new export to the end of the file
+                        updatedSourceFile = ts.factory.updateSourceFile(updatedSourceFile, tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(updatedSourceFile.statements), false), [
+                            newMigrationsExport,
+                        ], false));
+                    }
+                    code = ts.createPrinter().printFile(updatedSourceFile);
+                    _a.label = 3;
+                case 3:
+                    _a.trys.push([3, 11, , 12]);
+                    prettier = void 0;
+                    _a.label = 4;
+                case 4:
+                    _a.trys.push([4, 6, , 7]);
+                    return [4 /*yield*/, Promise.resolve("".concat('prettier' + '')).then(function (s) { return tslib_1.__importStar(require(s)); })];
+                case 5:
+                    prettier = _a.sent();
+                    return [3 /*break*/, 7];
+                case 6:
+                    err_1 = _a.sent();
+                    console.warn('error importing prettier,for better formatting run `npm i -D prettier`. Writing raw code to file.');
+                    return [3 /*break*/, 7];
+                case 7:
+                    if (!prettier) return [3 /*break*/, 10];
+                    return [4 /*yield*/, prettier.resolveConfig()];
+                case 8:
+                    options = _a.sent();
+                    return [4 /*yield*/, prettier.format(code, tslib_1.__assign(tslib_1.__assign({}, options), { parser: 'typescript' }))];
+                case 9:
+                    code = _a.sent();
+                    _a.label = 10;
+                case 10: return [3 /*break*/, 12];
+                case 11:
+                    err_2 = _a.sent();
+                    console.log('error formatting code, writing raw code to file.');
+                    return [3 /*break*/, 12];
+                case 12:
+                    fs.writeFileSync(filePath, code);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+exports.updateMigrationsFile = updateMigrationsFile;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.25.8",
+    "version": "0.26.0",
     "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev",
     "repository": {
@@ -101,6 +101,26 @@
             "import": "./esm/remult-sql-js.js",
             "types": "./remult-sql-js.d.ts"
         },
+        "./remult-sqlite-core-js": {
+            "require": "./remult-sqlite-core.js",
+            "import": "./esm/remult-sqlite-core.js",
+            "types": "./remult-sqlite-core.d.ts"
+        },
+        "./remult-better-sqlite3": {
+            "require": "./remult-better-sqlite3.js",
+            "import": "./esm/remult-better-sqlite3.js",
+            "types": "./remult-better-sqlite3.d.ts"
+        },
+        "./remult-bun-sqlite": {
+            "require": "./remult-bun-sqlite.js",
+            "import": "./esm/remult-bun-sqlite.js",
+            "types": "./remult-bun-sqlite.d.ts"
+        },
+        "./migrations": {
+            "require": "./migrations/index.js",
+            "import": "./esm/migrations/index.js",
+            "types": "./migrations/index.d.ts"
+        },
         "./ably": {
             "require": "./ably.js",
             "import": "./esm/ably.js",

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

@@ -1,19 +1,21 @@
 import type { ClientBase, PoolConfig, QueryResult } from 'pg';
-import { Remult } from '../src/context.js';
 import { SqlDatabase } from '../src/data-providers/sql-database.js';
 import type { EntityMetadata } from '../src/remult3/remult3.js';
 import type { SqlCommand, SqlImplementation } from '../src/sql-command.js';
+import type { CanBuildMigrations, MigrationBuilder, MigrationCode } from '../migrations/migration-types.js';
+import type { DataProvider } from '../index.js';
 export interface PostgresPool extends PostgresCommandSource {
     connect(): Promise<PostgresClient>;
+    end(): Promise<void>;
 }
 export interface PostgresClient extends PostgresCommandSource {
     release(): void;
 }
-export declare class PostgresDataProvider implements SqlImplementation {
+export declare class PostgresDataProvider implements SqlImplementation, CanBuildMigrations {
     private pool;
     private options?;
     supportsJsonColumnType: boolean;
-    static getDb(remult?: Remult): ClientBase;
+    static getDb(dataProvider?: DataProvider): ClientBase;
     entityIsUsedForTheFirstTime(entity: EntityMetadata): Promise<void>;
     getLimitSqlSyntax(limit: number, offset: number): string;
     createCommand(): SqlCommand;
@@ -23,6 +25,8 @@ export declare class PostgresDataProvider implements SqlImplementation {
         schema?: string;
         orderByNullsFirst?: boolean;
     });
+    end(): Promise<void>;
+    provideMigrationBuilder(builder: MigrationCode): MigrationBuilder;
     wrapIdentifier: (name: any) => any;
     ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
     orderByNullsFirst?: boolean;
@@ -48,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");
@@ -30,9 +31,11 @@ var PostgresDataProvider = /** @class */ (function () {
             this.pool = new PostgresSchemaWrapper(pool, options.schema);
         }
     }
-    PostgresDataProvider.getDb = function (remult) {
-        var sql = sql_database_js_1.SqlDatabase.getDb(remult);
-        var me = sql._getSourceSql();
+    PostgresDataProvider.getDb = function (dataProvider) {
+        var r = (dataProvider || 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,43 @@ 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;
+        var db = new sql_database_js_1.SqlDatabase(this);
+        var sb = new schema_builder_js_1.PostgresSchemaBuilder(db, (_a = this.options) === null || _a === void 0 ? void 0 : _a.schema);
+        return {
+            addColumn: function (meta, field) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                var _a, _b;
+                return tslib_1.__generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            _b = (_a = builder).addSql;
+                            return [4 /*yield*/, sb.getAddColumnScript(meta, field)];
+                        case 1:
+                            _b.apply(_a, [_c.sent()]);
+                            return [2 /*return*/];
+                    }
+                });
+            }); },
+            createTable: function (meta) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                var _a, _b;
+                return tslib_1.__generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            _b = (_a = builder).addSql;
+                            return [4 /*yield*/, sb.createTableScript(meta)];
+                        case 1:
+                            _b.apply(_a, [_c.sent()]);
+                            return [2 /*return*/];
+                    }
+                });
+            }); },
+        };
+    };
     PostgresDataProvider.prototype.ensureSchema = function (entities) {
         var _a;
         return tslib_1.__awaiter(this, void 0, void 0, function () {
@@ -265,6 +305,9 @@ var PostgresSchemaWrapper = /** @class */ (function () {
             });
         });
     };
+    PostgresSchemaWrapper.prototype.end = function () {
+        return this.pool.end();
+    };
     return PostgresSchemaWrapper;
 }());
 exports.PostgresSchemaWrapper = PostgresSchemaWrapper;

package/postgres/schema-builder.js

@@ -23,7 +23,7 @@ function postgresColumnSyntax(x, dbName) {
             if (x.valueConverter == valueConverters_js_1.ValueConverters.DateOnly)
                 result += ' date';
             else
-                result += ' timestamp';
+                result += ' timestamptz';
         else
             result += ' ' + x.valueConverter.fieldTypeInDb;
     }
@@ -176,8 +176,7 @@ var PostgresSchemaBuilder = /** @class */ (function () {
                         _b.label = 3;
                     case 3:
                         _b.trys.push([3, 7, , 8]);
-                        if (!!entity.options.sqlExpression) return [3 /*break*/, 6];
-                        if (!(e.$entityName.toLowerCase().indexOf('from ') < 0)) return [3 /*break*/, 6];
+                        if (!(0, filter_consumer_bridge_to_sql_request_js_1.shouldCreateEntity)(entity, e)) return [3 /*break*/, 6];
                         return [4 /*yield*/, this.createIfNotExist(entity)];
                     case 4:
                         _b.sent();
@@ -224,45 +223,21 @@ var PostgresSchemaBuilder = /** @class */ (function () {
                                 .execute("SELECT 1 FROM information_Schema.tables WHERE " +
                                 "".concat(this.whereTableAndSchema(c, e)))
                                 .then(function (r) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                var result, _a, _b, x, sql;
-                                var e_3, _c;
-                                return tslib_1.__generator(this, function (_d) {
-                                    switch (_d.label) {
+                                var sql;
+                                return tslib_1.__generator(this, function (_a) {
+                                    switch (_a.label) {
                                         case 0:
-                                            if (!(r.rows.length == 0)) return [3 /*break*/, 2];
-                                            result = '';
-                                            try {
-                                                for (_a = tslib_1.__values(entity.fields), _b = _a.next(); !_b.done; _b = _a.next()) {
-                                                    x = _b.value;
-                                                    if (!(0, filter_consumer_bridge_to_sql_request_js_1.shouldNotCreateField)(x, e) || (0, RepositoryImplementation_js_1.isAutoIncrement)(x)) {
-                                                        if (result.length != 0)
-                                                            result += ',';
-                                                        result += '\r\n  ';
-                                                        if ((0, RepositoryImplementation_js_1.isAutoIncrement)(x))
-                                                            result += e.$dbNameOf(x) + ' serial';
-                                                        else {
-                                                            result += postgresColumnSyntax(x, e.$dbNameOf(x));
-                                                        }
-                                                        if (x == entity.idMetadata.field)
-                                                            result += ' primary key';
-                                                    }
-                                                }
-                                            }
-                                            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                                            finally {
-                                                try {
-                                                    if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
-                                                }
-                                                finally { if (e_3) throw e_3.error; }
-                                            }
-                                            sql = "CREATE SCHEMA IF NOT EXISTS ".concat(this.schemaOnly(e), ";\nCREATE table ").concat(this.schemaAndName(e), " (").concat(result, "\r\n)");
+                                            if (!(r.rows.length == 0)) return [3 /*break*/, 3];
+                                            return [4 /*yield*/, this.createTableScript(entity)];
+                                        case 1:
+                                            sql = _a.sent();
                                             if (PostgresSchemaBuilder.logToConsole)
                                                 console.info(sql);
                                             return [4 /*yield*/, this.pool.execute(sql)];
-                                        case 1:
-                                            _d.sent();
-                                            _d.label = 2;
-                                        case 2: return [2 /*return*/];
+                                        case 2:
+                                            _a.sent();
+                                            _a.label = 3;
+                                        case 3: return [2 /*return*/];
                                     }
                                 });
                             }); })];
@@ -273,6 +248,63 @@ var PostgresSchemaBuilder = /** @class */ (function () {
             });
         });
     };
+    /* @internal*/
+    PostgresSchemaBuilder.prototype.getAddColumnScript = function (entity, field) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var e;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, filter_consumer_bridge_to_sql_request_js_1.dbNamesOf)(entity, this.pool.wrapIdentifier)];
+                    case 1:
+                        e = _a.sent();
+                        return [2 /*return*/, ("ALTER table ".concat(this.schemaAndName(e), " ") +
+                                "ADD column ".concat(postgresColumnSyntax(field, e.$dbNameOf(field))))];
+                }
+            });
+        });
+    };
+    /* @internal*/
+    PostgresSchemaBuilder.prototype.createTableScript = function (entity) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var result, e, _a, _b, x, sql;
+            var e_3, _c;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        result = '';
+                        return [4 /*yield*/, (0, filter_consumer_bridge_to_sql_request_js_1.dbNamesOf)(entity, this.pool.wrapIdentifier)];
+                    case 1:
+                        e = _d.sent();
+                        try {
+                            for (_a = tslib_1.__values(entity.fields), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                x = _b.value;
+                                if (!(0, filter_consumer_bridge_to_sql_request_js_1.shouldNotCreateField)(x, e) || (0, RepositoryImplementation_js_1.isAutoIncrement)(x)) {
+                                    if (result.length != 0)
+                                        result += ',';
+                                    result += '\r\n  ';
+                                    if ((0, RepositoryImplementation_js_1.isAutoIncrement)(x))
+                                        result += e.$dbNameOf(x) + ' serial';
+                                    else {
+                                        result += postgresColumnSyntax(x, e.$dbNameOf(x));
+                                    }
+                                    if (x == entity.idMetadata.field)
+                                        result += ' primary key';
+                                }
+                            }
+                        }
+                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                        finally {
+                            try {
+                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                            }
+                            finally { if (e_3) throw e_3.error; }
+                        }
+                        sql = "CREATE SCHEMA IF NOT EXISTS ".concat(this.schemaOnly(e), ";\nCREATE table ").concat(this.schemaAndName(e), " (").concat(result, "\r\n)");
+                        return [2 /*return*/, sql];
+                }
+            });
+        });
+    };
     PostgresSchemaBuilder.prototype.addColumnIfNotExist = function (entity, c) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var e, cmd, colName, sql, err_2;
@@ -285,28 +317,29 @@ var PostgresSchemaBuilder = /** @class */ (function () {
                             return [2 /*return*/];
                         _a.label = 2;
                     case 2:
-                        _a.trys.push([2, 6, , 7]);
+                        _a.trys.push([2, 7, , 8]);
                         cmd = this.pool.createCommand();
                         colName = e.$dbNameOf(c(entity));
                         return [4 /*yield*/, cmd.execute("SELECT 1 FROM information_schema.columns WHERE " +
                                 "".concat(this.whereTableAndSchema(cmd, e), " ") +
                                 "AND column_name=".concat(cmd.param(colName.toLocaleLowerCase())))];
                     case 3:
-                        if (!((_a.sent()).rows.length == 0)) return [3 /*break*/, 5];
-                        sql = "ALTER table ".concat(this.schemaAndName(e), " ") +
-                            "ADD column ".concat(postgresColumnSyntax(c(entity), colName));
+                        if (!((_a.sent()).rows.length == 0)) return [3 /*break*/, 6];
+                        return [4 /*yield*/, this.getAddColumnScript(entity, c(entity))];
+                    case 4:
+                        sql = _a.sent();
                         if (PostgresSchemaBuilder.logToConsole)
                             console.info(sql);
                         return [4 /*yield*/, this.pool.execute(sql)];
-                    case 4:
+                    case 5:
                         _a.sent();
-                        _a.label = 5;
-                    case 5: return [3 /*break*/, 7];
-                    case 6:
+                        _a.label = 6;
+                    case 6: return [3 /*break*/, 8];
+                    case 7:
                         err_2 = _a.sent();
                         console.error(err_2);
-                        return [3 /*break*/, 7];
-                    case 7: return [2 /*return*/];
+                        return [3 /*break*/, 8];
+                    case 8: return [2 /*return*/];
                 }
             });
         });

package/remult-better-sqlite3.d.ts

@@ -0,0 +1,12 @@
+import type { Database } from 'better-sqlite3';
+import { SqliteCoreDataProvider } from './remult-sqlite-core.js';
+import type { SqlResult } from './src/sql-command.js';
+export declare class BetterSqlite3DataProvider extends SqliteCoreDataProvider {
+    constructor(db: Database);
+}
+export declare class BetterSqlite3SqlResult implements SqlResult {
+    private result;
+    constructor(result: any[]);
+    rows: any[];
+    getColumnKeyInResultForIndexInSelect(index: number): string;
+}

package/remult-better-sqlite3.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BetterSqlite3SqlResult = exports.BetterSqlite3DataProvider = void 0;
+var tslib_1 = require("tslib");
+var remult_sqlite_core_js_1 = require("./remult-sqlite-core.js");
+var BetterSqlite3DataProvider = /** @class */ (function (_super) {
+    tslib_1.__extends(BetterSqlite3DataProvider, _super);
+    function BetterSqlite3DataProvider(db) {
+        var _this = _super.call(this, function () { return new BetterSqlite3Command(db); }, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+            db.close();
+            return [2 /*return*/];
+        }); }); }) || this;
+        return _this;
+    }
+    return BetterSqlite3DataProvider;
+}(remult_sqlite_core_js_1.SqliteCoreDataProvider));
+exports.BetterSqlite3DataProvider = BetterSqlite3DataProvider;
+var BetterSqlite3Command = /** @class */ (function () {
+    function BetterSqlite3Command(db) {
+        this.db = db;
+        this.values = {};
+        this.i = 0;
+    }
+    BetterSqlite3Command.prototype.execute = function (sql) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var s, result;
+            return tslib_1.__generator(this, function (_a) {
+                s = this.db.prepare(sql);
+                if (s.reader) {
+                    return [2 /*return*/, new BetterSqlite3SqlResult(s.all(this.values))];
+                }
+                else {
+                    result = s.run(this.values);
+                    return [2 /*return*/, new BetterSqlite3SqlResult([])];
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    BetterSqlite3Command.prototype.addParameterAndReturnSqlToken = function (val) {
+        return this.param(val);
+    };
+    BetterSqlite3Command.prototype.param = function (val) {
+        if (val instanceof Date)
+            val = val.valueOf();
+        if (typeof val === "boolean")
+            val = val ? 1 : 0;
+        var key = ':' + (this.i++);
+        this.values[key.substring(1)] = (val);
+        return key;
+    };
+    return BetterSqlite3Command;
+}());
+var BetterSqlite3SqlResult = /** @class */ (function () {
+    function BetterSqlite3SqlResult(result) {
+        this.result = result;
+        this.rows = result;
+    }
+    BetterSqlite3SqlResult.prototype.getColumnKeyInResultForIndexInSelect = function (index) {
+        return Object.keys(this.result[0])[index];
+    };
+    return BetterSqlite3SqlResult;
+}());
+exports.BetterSqlite3SqlResult = BetterSqlite3SqlResult;

package/remult-bun-sqlite.d.ts

@@ -0,0 +1,11 @@
+import { SqliteCoreDataProvider } from "./remult-sqlite-core.js";
+type Database = {
+    close(): void;
+    query(sql: string): {
+        all(args?: any): any[];
+    };
+};
+export declare class BunSqliteDataProvider extends SqliteCoreDataProvider {
+    constructor(db: Database);
+}
+export {};

package/remult-bun-sqlite.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BunSqliteDataProvider = void 0;
+var tslib_1 = require("tslib");
+var remult_sqlite_core_js_1 = require("./remult-sqlite-core.js");
+var BunSqliteDataProvider = /** @class */ (function (_super) {
+    tslib_1.__extends(BunSqliteDataProvider, _super);
+    function BunSqliteDataProvider(db) {
+        var _this = _super.call(this, function () { return new BunSqliteCommand(db); }, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+            db.close();
+            return [2 /*return*/];
+        }); }); }) || this;
+        return _this;
+    }
+    return BunSqliteDataProvider;
+}(remult_sqlite_core_js_1.SqliteCoreDataProvider));
+exports.BunSqliteDataProvider = BunSqliteDataProvider;
+var BunSqliteCommand = /** @class */ (function () {
+    function BunSqliteCommand(db) {
+        this.db = db;
+        this.values = {};
+        this.i = 0;
+    }
+    BunSqliteCommand.prototype.execute = function (sql) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var s;
+            return tslib_1.__generator(this, function (_a) {
+                s = this.db.query(sql);
+                return [2 /*return*/, new BunSqliteSqlResult(s.all(this.values))];
+            });
+        });
+    };
+    BunSqliteCommand.prototype.addParameterAndReturnSqlToken = function (val) {
+        return this.param(val);
+    };
+    BunSqliteCommand.prototype.param = function (val) {
+        if (val instanceof Date)
+            val = val.valueOf();
+        if (typeof val === "boolean")
+            val = val ? 1 : 0;
+        var key = ':' + (this.i++);
+        this.values[key] = (val);
+        return key;
+    };
+    return BunSqliteCommand;
+}());
+var BunSqliteSqlResult = /** @class */ (function () {
+    function BunSqliteSqlResult(result) {
+        this.result = result;
+        this.rows = result;
+    }
+    BunSqliteSqlResult.prototype.getColumnKeyInResultForIndexInSelect = function (index) {
+        return Object.keys(this.result[0])[index];
+    };
+    return BunSqliteSqlResult;
+}());