remult 0.25.8 → 0.26.0

package/remult-sql-js.d.ts

@@ -1,18 +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>);
-    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,161 +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.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.isDbReadonly)(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;
+    createTableIfNotExist(entity: EntityMetadata<any>): Promise<void>;
+    supportsJsonColumnType?: boolean;
+    private getCreateTableSql;
+    wrapIdentifier?(name: string): string;
+}

package/remult-sqlite-core.js

@@ -0,0 +1,217 @@
+"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.createTableIfNotExist(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.createTableIfNotExist = 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/server/expressBridge.d.ts

@@ -4,7 +4,7 @@ import { Remult } from '../src/context.js';
 import type { DataProvider } from '../src/data-interfaces.js';
 import type { LiveQueryStorage, SubscriptionServer } from '../src/live-query/SubscriptionServer.js';
 import { IdEntity } from '../src/remult3/IdEntity.js';
-import type { Repository } from '../src/remult3/remult3.js';
+import type { EntityMetadata, Repository } from '../src/remult3/remult3.js';
 import type { queuedJobInfoResponse } from '../src/server-action.js';
 export interface RemultServerOptions<RequestType> {
     /**Entities to use for the api */
@@ -55,6 +55,35 @@ export interface RemultServerOptions<RequestType> {
     admin?: Allowed;
     /** Storage to use for backend methods that use queue */
     queueStorage?: QueueStorage;
+    /**
+     * This method is called whenever there is an error in the API lifecycle.
+     *
+     * @param info - Information about the error.
+     * @param info.req - The request object.
+     * @param info.entity - (Optional) The entity metadata associated with the error, if applicable.
+     * @param info.exception - (Optional) The exception object or error that occurred.
+     * @param info.httpStatusCode - The HTTP status code.
+     * @param info.responseBody - The body of the response.
+     * @param info.sendError - A method to send a custom error response. Call this method with the desired HTTP status code and response body.
+     *
+     * @returns A promise that resolves when the error handling is complete.
+     * @example
+     * export const api = remultExpress({
+     *   error: async (e) => {
+     *     if (e.httpStatusCode == 500) {
+     *       e.sendError(500, { message: "An error occurred" })
+     *     }
+     *   }
+     * })
+     */
+    error?: (info: {
+        req: RequestType;
+        entity?: EntityMetadata;
+        exception?: any;
+        httpStatusCode: number;
+        responseBody: any;
+        sendError: (httpStatusCode: number, body: any) => void;
+    }) => Promise<void>;
 }
 export interface InitRequestOptions {
     liveQueryStorage: LiveQueryStorage;