remult 0.25.8-exp.10 → 0.25.8-exp.12

package/esm/remult-better-sqlite3.js

@@ -0,0 +1,47 @@
+import { SqliteCoreDataProvider } from './remult-sqlite-core.js';
+export class BetterSqlite3DataProvider extends SqliteCoreDataProvider {
+    constructor(db) {
+        super(() => new BetterSqlite3Command(db), async () => { db.close(); });
+    }
+}
+class BetterSqlite3Command {
+    db;
+    values = {};
+    i = 0;
+    constructor(db) {
+        this.db = db;
+    }
+    async execute(sql) {
+        const s = this.db.prepare(sql);
+        if (s.reader) {
+            return new BetterSqlite3SqlResult(s.all(this.values));
+        }
+        else {
+            const result = s.run(this.values);
+            return new BetterSqlite3SqlResult([]);
+        }
+    }
+    addParameterAndReturnSqlToken(val) {
+        return this.param(val);
+    }
+    param(val) {
+        if (val instanceof Date)
+            val = val.valueOf();
+        if (typeof val === "boolean")
+            val = val ? 1 : 0;
+        const key = ':' + (this.i++);
+        this.values[key.substring(1)] = (val);
+        return key;
+    }
+}
+export class BetterSqlite3SqlResult {
+    result;
+    constructor(result) {
+        this.result = result;
+        this.rows = result;
+    }
+    rows;
+    getColumnKeyInResultForIndexInSelect(index) {
+        return Object.keys(this.result[0])[index];
+    }
+}

package/esm/remult-bun-sqlite.js

@@ -0,0 +1,41 @@
+import { SqliteCoreDataProvider } from "./remult-sqlite-core.js";
+export class BunSqliteDataProvider extends SqliteCoreDataProvider {
+    constructor(db) {
+        super(() => new BunSqliteCommand(db), async () => { db.close(); });
+    }
+}
+class BunSqliteCommand {
+    db;
+    values = {};
+    i = 0;
+    constructor(db) {
+        this.db = db;
+    }
+    async execute(sql) {
+        const s = this.db.query(sql);
+        return new BunSqliteSqlResult(s.all(this.values));
+    }
+    addParameterAndReturnSqlToken(val) {
+        return this.param(val);
+    }
+    param(val) {
+        if (val instanceof Date)
+            val = val.valueOf();
+        if (typeof val === "boolean")
+            val = val ? 1 : 0;
+        const key = ':' + (this.i++);
+        this.values[key] = (val);
+        return key;
+    }
+}
+class BunSqliteSqlResult {
+    result;
+    constructor(result) {
+        this.result = result;
+        this.rows = result;
+    }
+    rows;
+    getColumnKeyInResultForIndexInSelect(index) {
+        return Object.keys(this.result[0])[index];
+    }
+}

package/esm/remult-knex/index.js

@@ -539,15 +539,17 @@ class KnexBridgeToSQLCommand {
     constructor(source) {
         this.source = source;
     }
-    values = [];
+    values = {};
+    i = 0;
     addParameterAndReturnSqlToken(val) {
         return this.param(val);
     }
     param(val) {
         if (Array.isArray(val))
             val = JSON.stringify(val);
-        this.values.push(val);
-        return '?';
+        const key = ':' + (this.i++);
+        this.values[key.substring(1)] = val;
+        return key;
     }
     async execute(sql) {
         return await this.source.raw(sql, this.values).then((r) => {

package/esm/remult-sql-js.js

@@ -1,87 +1,7 @@
-import { SqlDatabase } from './src/data-providers/sql-database.js';
-import { dbNamesOf, shouldNotCreateField, } from './src/filter/filter-consumer-bridge-to-sql-request.js';
-import { isAutoIncrement } from './src/remult3/RepositoryImplementation.js';
-export class SqlJsDataProvider {
-    db;
+import { SqliteCoreDataProvider } from './remult-sqlite-core.js';
+export class SqlJsDataProvider extends SqliteCoreDataProvider {
     constructor(db) {
-        this.db = db;
-    }
-    orderByNullsFirst;
-    async end() {
-        ;
-        (await this.db).close();
-    }
-    getLimitSqlSyntax(limit, offset) {
-        return ' limit ' + limit + ' offset ' + offset;
-    }
-    afterMutation;
-    createCommand() {
-        return new SqlJsCommand(this.db);
-    }
-    transaction(action) {
-        throw new Error('Method not implemented.');
-    }
-    async entityIsUsedForTheFirstTime(entity) {
-        await this.createTable(entity);
-    }
-    async ensureSchema(entities) {
-        for (const entity of entities) {
-            await this.createTable(entity);
-        }
-    }
-    async dropTable(entity) {
-        let e = await dbNamesOf(entity);
-        let sql = 'drop  table if exists ' + e.$entityName;
-        if (SqlDatabase.LogToConsole)
-            console.info(sql);
-        await this.createCommand().execute(sql);
-    }
-    addColumnSqlSyntax(x, dbName) {
-        let result = dbName;
-        const nullNumber = x.allowNull ? '' : ' default 0 not null';
-        if (x.valueType == Date)
-            result += ' integer';
-        else if (x.valueType == Boolean)
-            result += ' integer ' + nullNumber;
-        else if (x.valueType == Number) {
-            if (!x.valueConverter.fieldTypeInDb)
-                result += ' real ' + nullNumber;
-            else
-                result += ' ' + x.valueConverter.fieldTypeInDb + ' ' + nullNumber;
-        }
-        else
-            result += ' text' + (x.allowNull ? ' ' : " default '' not null ");
-        return result;
-    }
-    async createTable(entity) {
-        let result = '';
-        let e = await dbNamesOf(entity);
-        for (const x of entity.fields) {
-            if (!shouldNotCreateField(x, e) || isAutoIncrement(x)) {
-                if (result.length != 0)
-                    result += ',';
-                result += '\r\n  ';
-                if (isAutoIncrement(x)) {
-                    if (x.key != entity.idMetadata.field.key)
-                        throw 'in web sql, autoincrement is only allowed for primary key';
-                    result += e.$dbNameOf(x) + ' integer primary key autoincrement';
-                }
-                else {
-                    result += this.addColumnSqlSyntax(x, e.$dbNameOf(x));
-                    if (x.key == entity.idMetadata.field.key) {
-                        result += ' primary key';
-                    }
-                }
-            }
-        }
-        let sql = 'create table if not exists ' + e.$entityName + ' (' + result + '\r\n)';
-        if (SqlDatabase.LogToConsole)
-            console.log(sql);
-        await this.createCommand().execute(sql);
-    }
-    supportsJsonColumnType;
-    wrapIdentifier(name) {
-        return name;
+        super(() => new SqlJsCommand(db), async () => (await db).close());
     }
 }
 class SqlJsCommand {

package/esm/remult-sqlite-core.js

@@ -0,0 +1,105 @@
+import { SqlDatabase } from './src/data-providers/sql-database.js';
+import { dbNamesOf, shouldNotCreateField, } from './src/filter/filter-consumer-bridge-to-sql-request.js';
+import { isAutoIncrement } from './src/remult3/RepositoryImplementation.js';
+export class SqliteCoreDataProvider {
+    createCommand;
+    end;
+    constructor(createCommand, end) {
+        this.createCommand = createCommand;
+        this.end = end;
+    }
+    orderByNullsFirst;
+    getLimitSqlSyntax(limit, offset) {
+        return ' limit ' + limit + ' offset ' + offset;
+    }
+    afterMutation;
+    provideMigrationBuilder(builder) {
+        let self = this;
+        return {
+            createTable: async (entity) => {
+                builder.addSql(await self.getCreateTableSql(entity));
+            },
+            addColumn: async (entity, field) => {
+                let e = await dbNamesOf(entity);
+                let sql = `alter table ${e.$entityName} add column ${self.addColumnSqlSyntax(field, e.$dbNameOf(field))}`;
+                builder.addSql(sql);
+            }
+        };
+    }
+    async transaction(action) {
+        this.createCommand().execute("Begin Transaction");
+        try {
+            await action(this);
+            this.createCommand().execute("Commit");
+        }
+        catch (err) {
+            this.createCommand().execute("Rollback");
+            throw err;
+        }
+    }
+    async entityIsUsedForTheFirstTime(entity) {
+    }
+    async ensureSchema(entities) {
+        for (const entity of entities) {
+            await this.createTable(entity);
+        }
+    }
+    async dropTable(entity) {
+        let e = await dbNamesOf(entity);
+        let sql = 'drop  table if exists ' + e.$entityName;
+        if (SqlDatabase.LogToConsole)
+            console.info(sql);
+        await this.createCommand().execute(sql);
+    }
+    addColumnSqlSyntax(x, dbName) {
+        let result = dbName;
+        const nullNumber = x.allowNull ? '' : ' default 0 not null';
+        if (x.valueType == Date)
+            result += ' integer';
+        else if (x.valueType == Boolean)
+            result += ' integer ' + nullNumber;
+        else if (x.valueType == Number) {
+            if (!x.valueConverter.fieldTypeInDb)
+                result += ' numeric ' + nullNumber;
+            else
+                result += ' ' + x.valueConverter.fieldTypeInDb + ' ' + nullNumber;
+        }
+        else
+            result += ' text' + (x.allowNull ? ' ' : " default '' not null ");
+        return result;
+    }
+    async createTable(entity) {
+        let sql = await this.getCreateTableSql(entity);
+        if (SqlDatabase.LogToConsole)
+            console.log(sql);
+        await this.createCommand().execute(sql);
+    }
+    supportsJsonColumnType;
+    async getCreateTableSql(entity) {
+        let result = '';
+        let e = await dbNamesOf(entity);
+        for (const x of entity.fields) {
+            if (!shouldNotCreateField(x, e) || isAutoIncrement(x)) {
+                if (result.length != 0)
+                    result += ',';
+                result += '\r\n  ';
+                if (isAutoIncrement(x)) {
+                    if (x.key != entity.idMetadata.field.key)
+                        throw 'in web sql, autoincrement is only allowed for primary key';
+                    result += e.$dbNameOf(x) + ' integer primary key autoincrement';
+                }
+                else {
+                    result += this.addColumnSqlSyntax(x, e.$dbNameOf(x));
+                    if (x.key == entity.idMetadata.field.key) {
+                        result += ' primary key';
+                    }
+                }
+            }
+        }
+        let sql = 'create table if not exists ' + e.$entityName + ' (' + result + '\r\n)';
+        return sql;
+    }
+    wrapIdentifier(name) {
+        return name;
+    }
+}

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

@@ -120,7 +120,7 @@ export class SqlDatabase {
         if (sql.wrapIdentifier)
             this.wrapIdentifier = (x) => sql.wrapIdentifier(x);
         if (isOfType(sql, 'provideMigrationBuilder')) {
-            this.provideMigrationBuilder = sql.provideMigrationBuilder;
+            this.provideMigrationBuilder = x => sql.provideMigrationBuilder(x);
         }
         if (isOfType(sql, 'end'))
             this.end = () => sql.end();
@@ -347,6 +347,8 @@ class ActualSQLServerDataProvider {
         statement += ' returning ' + select;
         return r.execute(statement).then((sqlResult) => {
             this.sql._getSourceSql().afterMutation?.();
+            if (sqlResult.rows.length != 1)
+                throw new Error('Failed to update row with id ' + id + ", rows updated: " + sqlResult.rows.length);
             return this.buildResultRow(colKeys, sqlResult.rows[0], sqlResult);
         });
     }

package/esm/src/remult3/remult3.js

@@ -1,11 +1,13 @@
 export {};
+//p1 - implement generic sqlite support better-sqlite3/ bun sqlite
 //p1 - `preprocessApiFindOptions`,  naming - allow find options preprocessor for api calls, to use for authorization
 //p1 - admin url1 - pocketbase use /_ for the admin //{allowed?:Allowed,url?:string}
-//p1 - Make async hooks gracefully handle non async hooks environment
-//p1 - implement generic sqlite support better-sqlite3/ bun sqlite
+//p1 - document new sqlite providers
 //p1 - article auth.js with express
 //p1 - document offline support
+//p1 - fix getting started article
 //y2 - should we validate relations
+//y1 - dependency of live query tables
 //y1 - consider replacing all errors with error classes that extend the base Error class
 //y2 - should enforce integer - currently we probably round / truncate it
 /*y1 - talk about modules in init express with entities/controllers,initRequest,initApi

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.25.8-exp.10",
+    "version": "0.25.8-exp.12",
     "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev",
     "repository": {
@@ -101,6 +101,21 @@
             "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",

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;
+}());

package/remult-knex/index.js

@@ -1030,7 +1030,8 @@ function translateValueAndHandleArrayAndHandleArray(field, val) {
 var KnexBridgeToSQLCommand = /** @class */ (function () {
     function KnexBridgeToSQLCommand(source) {
         this.source = source;
-        this.values = [];
+        this.values = {};
+        this.i = 0;
     }
     KnexBridgeToSQLCommand.prototype.addParameterAndReturnSqlToken = function (val) {
         return this.param(val);
@@ -1038,8 +1039,9 @@ var KnexBridgeToSQLCommand = /** @class */ (function () {
     KnexBridgeToSQLCommand.prototype.param = function (val) {
         if (Array.isArray(val))
             val = JSON.stringify(val);
-        this.values.push(val);
-        return '?';
+        var key = ':' + (this.i++);
+        this.values[key.substring(1)] = val;
+        return key;
     };
     KnexBridgeToSQLCommand.prototype.execute = function (sql) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {

package/remult-sql-js.d.ts

@@ -1,20 +1,5 @@
-import type { EntityMetadata } from './src/remult3/remult3.js';
-import type { SqlCommand, SqlImplementation } from './src/sql-command.js';
 import type { Database } from 'sql.js';
-export declare class SqlJsDataProvider implements SqlImplementation {
-    private db;
+import { SqliteCoreDataProvider } from './remult-sqlite-core.js';
+export declare class SqlJsDataProvider extends SqliteCoreDataProvider {
     constructor(db: Promise<Database>);
-    orderByNullsFirst?: boolean;
-    end(): Promise<void>;
-    getLimitSqlSyntax(limit: number, offset: number): string;
-    afterMutation?: VoidFunction;
-    createCommand(): SqlCommand;
-    transaction(action: (sql: SqlImplementation) => Promise<void>): Promise<void>;
-    entityIsUsedForTheFirstTime(entity: EntityMetadata): Promise<void>;
-    ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
-    dropTable(entity: EntityMetadata): Promise<void>;
-    private addColumnSqlSyntax;
-    createTable(entity: EntityMetadata<any>): Promise<void>;
-    supportsJsonColumnType?: boolean;
-    wrapIdentifier?(name: string): string;
 }

package/remult-sql-js.js

@@ -2,175 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SqlJsDataProvider = void 0;
 var tslib_1 = require("tslib");
-var sql_database_js_1 = require("./src/data-providers/sql-database.js");
-var filter_consumer_bridge_to_sql_request_js_1 = require("./src/filter/filter-consumer-bridge-to-sql-request.js");
-var RepositoryImplementation_js_1 = require("./src/remult3/RepositoryImplementation.js");
-var SqlJsDataProvider = /** @class */ (function () {
+var remult_sqlite_core_js_1 = require("./remult-sqlite-core.js");
+var SqlJsDataProvider = /** @class */ (function (_super) {
+    tslib_1.__extends(SqlJsDataProvider, _super);
     function SqlJsDataProvider(db) {
-        this.db = db;
+        var _this = _super.call(this, function () { return new SqlJsCommand(db); }, 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*/, db];
+                case 1: return [2 /*return*/, (_a.sent()).close()];
+            }
+        }); }); }) || this;
+        return _this;
     }
-    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;
-    };
-    SqlJsDataProvider.prototype.createCommand = function () {
-        return new SqlJsCommand(this.db);
-    };
-    SqlJsDataProvider.prototype.transaction = function (action) {
-        throw new Error('Method not implemented.');
-    };
-    SqlJsDataProvider.prototype.entityIsUsedForTheFirstTime = function (entity) {
-        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.createTable(entity)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    SqlJsDataProvider.prototype.ensureSchema = function (entities) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var entities_1, entities_1_1, entity, e_1_1;
-            var e_1, _a;
-            return tslib_1.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _b.trys.push([0, 5, 6, 7]);
-                        entities_1 = tslib_1.__values(entities), entities_1_1 = entities_1.next();
-                        _b.label = 1;
-                    case 1:
-                        if (!!entities_1_1.done) return [3 /*break*/, 4];
-                        entity = entities_1_1.value;
-                        return [4 /*yield*/, this.createTable(entity)];
-                    case 2:
-                        _b.sent();
-                        _b.label = 3;
-                    case 3:
-                        entities_1_1 = entities_1.next();
-                        return [3 /*break*/, 1];
-                    case 4: return [3 /*break*/, 7];
-                    case 5:
-                        e_1_1 = _b.sent();
-                        e_1 = { error: e_1_1 };
-                        return [3 /*break*/, 7];
-                    case 6:
-                        try {
-                            if (entities_1_1 && !entities_1_1.done && (_a = entities_1.return)) _a.call(entities_1);
-                        }
-                        finally { if (e_1) throw e_1.error; }
-                        return [7 /*endfinally*/];
-                    case 7: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    SqlJsDataProvider.prototype.dropTable = function (entity) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var e, sql;
-            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)];
-                    case 1:
-                        e = _a.sent();
-                        sql = 'drop  table if exists ' + e.$entityName;
-                        if (sql_database_js_1.SqlDatabase.LogToConsole)
-                            console.info(sql);
-                        return [4 /*yield*/, this.createCommand().execute(sql)];
-                    case 2:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    SqlJsDataProvider.prototype.addColumnSqlSyntax = function (x, dbName) {
-        var result = dbName;
-        var nullNumber = x.allowNull ? '' : ' default 0 not null';
-        if (x.valueType == Date)
-            result += ' integer';
-        else if (x.valueType == Boolean)
-            result += ' integer ' + nullNumber;
-        else if (x.valueType == Number) {
-            if (!x.valueConverter.fieldTypeInDb)
-                result += ' real ' + nullNumber;
-            else
-                result += ' ' + x.valueConverter.fieldTypeInDb + ' ' + nullNumber;
-        }
-        else
-            result += ' text' + (x.allowNull ? ' ' : " default '' not null ");
-        return result;
-    };
-    SqlJsDataProvider.prototype.createTable = function (entity) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var result, e, _a, _b, x, sql;
-            var e_2, _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)];
-                    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)) {
-                                        if (x.key != entity.idMetadata.field.key)
-                                            throw 'in web sql, autoincrement is only allowed for primary key';
-                                        result += e.$dbNameOf(x) + ' integer primary key autoincrement';
-                                    }
-                                    else {
-                                        result += this.addColumnSqlSyntax(x, e.$dbNameOf(x));
-                                        if (x.key == entity.idMetadata.field.key) {
-                                            result += ' primary key';
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                        finally {
-                            try {
-                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
-                            }
-                            finally { if (e_2) throw e_2.error; }
-                        }
-                        sql = 'create table if not exists ' + e.$entityName + ' (' + result + '\r\n)';
-                        if (sql_database_js_1.SqlDatabase.LogToConsole)
-                            console.log(sql);
-                        return [4 /*yield*/, this.createCommand().execute(sql)];
-                    case 2:
-                        _d.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    SqlJsDataProvider.prototype.wrapIdentifier = function (name) {
-        return name;
-    };
     return SqlJsDataProvider;
-}());
+}(remult_sqlite_core_js_1.SqliteCoreDataProvider));
 exports.SqlJsDataProvider = SqlJsDataProvider;
 var SqlJsCommand = /** @class */ (function () {
     function SqlJsCommand(db) {

package/remult-sqlite-core.d.ts

@@ -0,0 +1,21 @@
+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';
+export declare class SqliteCoreDataProvider implements SqlImplementation, CanBuildMigrations {
+    createCommand: () => SqlCommand;
+    end: () => Promise<void>;
+    constructor(createCommand: () => SqlCommand, end: () => Promise<void>);
+    orderByNullsFirst?: boolean;
+    getLimitSqlSyntax(limit: number, offset: number): string;
+    afterMutation?: VoidFunction;
+    provideMigrationBuilder(builder: MigrationCode): MigrationBuilder;
+    transaction(action: (sql: SqlImplementation) => Promise<void>): Promise<void>;
+    entityIsUsedForTheFirstTime(entity: EntityMetadata): Promise<void>;
+    ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
+    dropTable(entity: EntityMetadata): Promise<void>;
+    private addColumnSqlSyntax;
+    createTable(entity: EntityMetadata<any>): Promise<void>;
+    supportsJsonColumnType?: boolean;
+    private getCreateTableSql;
+    wrapIdentifier?(name: string): string;
+}

package/remult-sqlite-core.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqliteCoreDataProvider = void 0;
+var tslib_1 = require("tslib");
+var sql_database_js_1 = require("./src/data-providers/sql-database.js");
+var filter_consumer_bridge_to_sql_request_js_1 = require("./src/filter/filter-consumer-bridge-to-sql-request.js");
+var RepositoryImplementation_js_1 = require("./src/remult3/RepositoryImplementation.js");
+var SqliteCoreDataProvider = /** @class */ (function () {
+    function SqliteCoreDataProvider(createCommand, end) {
+        this.createCommand = createCommand;
+        this.end = end;
+    }
+    SqliteCoreDataProvider.prototype.getLimitSqlSyntax = function (limit, offset) {
+        return ' limit ' + limit + ' offset ' + offset;
+    };
+    SqliteCoreDataProvider.prototype.provideMigrationBuilder = function (builder) {
+        var _this = this;
+        var self = this;
+        return {
+            createTable: function (entity) { 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*/, self.getCreateTableSql(entity)];
+                        case 1:
+                            _b.apply(_a, [_c.sent()]);
+                            return [2 /*return*/];
+                    }
+                });
+            }); },
+            addColumn: function (entity, field) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                var e, sql;
+                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)];
+                        case 1:
+                            e = _a.sent();
+                            sql = "alter table ".concat(e.$entityName, " add column ").concat(self.addColumnSqlSyntax(field, e.$dbNameOf(field)));
+                            builder.addSql(sql);
+                            return [2 /*return*/];
+                    }
+                });
+            }); }
+        };
+    };
+    SqliteCoreDataProvider.prototype.transaction = function (action) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var err_1;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.createCommand().execute("Begin Transaction");
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, action(this)];
+                    case 2:
+                        _a.sent();
+                        this.createCommand().execute("Commit");
+                        return [3 /*break*/, 4];
+                    case 3:
+                        err_1 = _a.sent();
+                        this.createCommand().execute("Rollback");
+                        throw err_1;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SqliteCoreDataProvider.prototype.entityIsUsedForTheFirstTime = function (entity) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                return [2 /*return*/];
+            });
+        });
+    };
+    SqliteCoreDataProvider.prototype.ensureSchema = function (entities) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var entities_1, entities_1_1, entity, e_1_1;
+            var e_1, _a;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 5, 6, 7]);
+                        entities_1 = tslib_1.__values(entities), entities_1_1 = entities_1.next();
+                        _b.label = 1;
+                    case 1:
+                        if (!!entities_1_1.done) return [3 /*break*/, 4];
+                        entity = entities_1_1.value;
+                        return [4 /*yield*/, this.createTable(entity)];
+                    case 2:
+                        _b.sent();
+                        _b.label = 3;
+                    case 3:
+                        entities_1_1 = entities_1.next();
+                        return [3 /*break*/, 1];
+                    case 4: return [3 /*break*/, 7];
+                    case 5:
+                        e_1_1 = _b.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 7];
+                    case 6:
+                        try {
+                            if (entities_1_1 && !entities_1_1.done && (_a = entities_1.return)) _a.call(entities_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SqliteCoreDataProvider.prototype.dropTable = function (entity) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var e, sql;
+            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)];
+                    case 1:
+                        e = _a.sent();
+                        sql = 'drop  table if exists ' + e.$entityName;
+                        if (sql_database_js_1.SqlDatabase.LogToConsole)
+                            console.info(sql);
+                        return [4 /*yield*/, this.createCommand().execute(sql)];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SqliteCoreDataProvider.prototype.addColumnSqlSyntax = function (x, dbName) {
+        var result = dbName;
+        var nullNumber = x.allowNull ? '' : ' default 0 not null';
+        if (x.valueType == Date)
+            result += ' integer';
+        else if (x.valueType == Boolean)
+            result += ' integer ' + nullNumber;
+        else if (x.valueType == Number) {
+            if (!x.valueConverter.fieldTypeInDb)
+                result += ' numeric ' + nullNumber;
+            else
+                result += ' ' + x.valueConverter.fieldTypeInDb + ' ' + nullNumber;
+        }
+        else
+            result += ' text' + (x.allowNull ? ' ' : " default '' not null ");
+        return result;
+    };
+    SqliteCoreDataProvider.prototype.createTable = function (entity) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var sql;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getCreateTableSql(entity)];
+                    case 1:
+                        sql = _a.sent();
+                        if (sql_database_js_1.SqlDatabase.LogToConsole)
+                            console.log(sql);
+                        return [4 /*yield*/, this.createCommand().execute(sql)];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    SqliteCoreDataProvider.prototype.getCreateTableSql = function (entity) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var result, e, _a, _b, x, sql;
+            var e_2, _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)];
+                    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)) {
+                                        if (x.key != entity.idMetadata.field.key)
+                                            throw 'in web sql, autoincrement is only allowed for primary key';
+                                        result += e.$dbNameOf(x) + ' integer primary key autoincrement';
+                                    }
+                                    else {
+                                        result += this.addColumnSqlSyntax(x, e.$dbNameOf(x));
+                                        if (x.key == entity.idMetadata.field.key) {
+                                            result += ' primary key';
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                        finally {
+                            try {
+                                if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                            }
+                            finally { if (e_2) throw e_2.error; }
+                        }
+                        sql = 'create table if not exists ' + e.$entityName + ' (' + result + '\r\n)';
+                        return [2 /*return*/, sql];
+                }
+            });
+        });
+    };
+    SqliteCoreDataProvider.prototype.wrapIdentifier = function (name) {
+        return name;
+    };
+    return SqliteCoreDataProvider;
+}());
+exports.SqliteCoreDataProvider = SqliteCoreDataProvider;

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

@@ -20,7 +20,7 @@ var SqlDatabase = /** @class */ (function () {
         if (sql.wrapIdentifier)
             this.wrapIdentifier = function (x) { return sql.wrapIdentifier(x); };
         if ((0, isOfType_js_1.isOfType)(sql, 'provideMigrationBuilder')) {
-            this.provideMigrationBuilder = sql.provideMigrationBuilder;
+            this.provideMigrationBuilder = function (x) { return sql.provideMigrationBuilder(x); };
         }
         if ((0, isOfType_js_1.isOfType)(sql, 'end'))
             this.end = function () { return sql.end(); };
@@ -523,6 +523,8 @@ var ActualSQLServerDataProvider = /** @class */ (function () {
                         return [2 /*return*/, r.execute(statement).then(function (sqlResult) {
                                 var _a, _b;
                                 (_b = (_a = _this.sql._getSourceSql()).afterMutation) === null || _b === void 0 ? void 0 : _b.call(_a);
+                                if (sqlResult.rows.length != 1)
+                                    throw new Error('Failed to update row with id ' + id + ", rows updated: " + sqlResult.rows.length);
                                 return _this.buildResultRow(colKeys, sqlResult.rows[0], sqlResult);
                             })];
                 }

package/src/remult3/remult3.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+//p1 - implement generic sqlite support better-sqlite3/ bun sqlite
 //p1 - `preprocessApiFindOptions`,  naming - allow find options preprocessor for api calls, to use for authorization
 //p1 - admin url1 - pocketbase use /_ for the admin //{allowed?:Allowed,url?:string}
-//p1 - Make async hooks gracefully handle non async hooks environment
-//p1 - implement generic sqlite support better-sqlite3/ bun sqlite
+//p1 - document new sqlite providers
 //p1 - article auth.js with express
 //p1 - document offline support
+//p1 - fix getting started article
 //y2 - should we validate relations
+//y1 - dependency of live query tables
 //y1 - consider replacing all errors with error classes that extend the base Error class
 //y2 - should enforce integer - currently we probably round / truncate it
 /*y1 - talk about modules in init express with entities/controllers,initRequest,initApi