remult 0.25.8 → 0.26.0

package/esm/remult-sql-js.js

@@ -1,82 +1,7 @@
-import { SqlDatabase } from './src/data-providers/sql-database.js';
-import { dbNamesOf, isDbReadonly, } 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;
-    }
-    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 (!isDbReadonly(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,104 @@
+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.createTableIfNotExist(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 createTableIfNotExist(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/server/expressBridge.js

@@ -13,6 +13,7 @@ import { serverActionField } from '../src/server-action-info.js';
 import { initDataProvider } from './initDataProvider.js';
 import { remultStatic } from '../src/remult-static.js';
 import remultAdminHtml from './remult-admin.js';
+import { isOfType } from '../src/isOfType.js';
 export function createRemultServerCore(options, serverCoreOptions) {
     if (!options) {
         options = {};
@@ -249,8 +250,8 @@ export class RemultServerImplementation {
             console.info('[remult] ' + myRoute);
         r.route(myRoute)
             .get(this.process((c, req, res, orig) => dataApiFactory(c).httpGet(res, req, () => this.serializeContext(c))))
-            .put(this.process(async (c, req, res, _, __, orig) => dataApiFactory(c).put(res, '', await this.coreOptions.getRequestBody(orig))))
-            .delete(this.process(async (c, req, res, orig) => dataApiFactory(c).delete(res, '')))
+            .put(this.process(async (c, req, res, _, __, orig) => dataApiFactory(c).updateManyThroughPutRequest(res, req, await this.coreOptions.getRequestBody(orig))))
+            .delete(this.process(async (c, req, res, _, __, orig) => dataApiFactory(c).deleteMany(res, req, undefined)))
             .post(this.process(async (c, req, res, _, __, orig) => dataApiFactory(c).httpPost(res, req, await this.coreOptions.getRequestBody(orig), () => this.serializeContext(c))));
         r.route(myRoute + '/:id')
             //@ts-ignore
@@ -285,7 +286,7 @@ export class RemultServerImplementation {
                     genReq.params = req['_tempParams'];
             }
             let myReq = new ExpressRequestBridgeToDataApiRequest(genReq);
-            let myRes = new ExpressResponseBridgeToDataApiResponse(origRes, req);
+            let myRes = new ExpressResponseBridgeToDataApiResponse(origRes, req, this.options.error);
             try {
                 await this.runWithRemult(async (remult) => {
                     if (req) {
@@ -315,7 +316,7 @@ export class RemultServerImplementation {
                 });
             }
             catch (err) {
-                myRes.error(serializeError(err));
+                myRes.error(err, undefined);
             }
         };
     }
@@ -466,6 +467,17 @@ export class RemultServerImplementation {
                     return secureBase(condition, def, item);
                 };
                 let apiPath = (spec.paths[this.options.rootPath + '/' + key] = {});
+                let itemInBody = {
+                    requestBody: {
+                        content: {
+                            'application/json': {
+                                schema: {
+                                    $ref: '#/components/schemas/' + mutationKey,
+                                },
+                            },
+                        },
+                    },
+                };
                 let apiPathWithId = (spec.paths[this.options.rootPath + '/' + key + '/{id}'] = {});
                 //https://github.com/2fd/open-api.d.ts
                 apiPath.get = secure(meta.options.allowApiRead, true, {
@@ -518,6 +530,73 @@ export class RemultServerImplementation {
                         },
                     },
                 });
+                apiPath.delete = secure(meta.options.allowApiDelete, true, {
+                    description: 'deletes row of ' +
+                        key +
+                        '. supports filter operators. For more info on filtering [see this article](https://remult.dev/docs/rest-api.html#filter)',
+                    parameters: [...parameters],
+                    responses: {
+                        '400': {
+                            description: 'Error: Bad Request',
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        $ref: '#/components/schemas/InvalidResponse',
+                                    },
+                                },
+                            },
+                        },
+                        '200': {
+                            description: 'returns the number of deleted rows ' + key,
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        type: 'object',
+                                        properties: {
+                                            deleted: {
+                                                type: 'number',
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                });
+                apiPath.put = secure(meta.options.allowApiDelete, true, {
+                    description: 'updates row of ' +
+                        key +
+                        '. supports filter operators. For more info on filtering [see this article](https://remult.dev/docs/rest-api.html#filter)',
+                    parameters: [...parameters],
+                    ...itemInBody,
+                    responses: {
+                        '400': {
+                            description: 'Error: Bad Request',
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        $ref: '#/components/schemas/InvalidResponse',
+                                    },
+                                },
+                            },
+                        },
+                        '200': {
+                            description: 'returns the number of updated rows ' + key,
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        type: 'object',
+                                        properties: {
+                                            updated: {
+                                                type: 'number',
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                });
                 let idParameter = {
                     name: 'id',
                     in: 'path',
@@ -525,17 +604,6 @@ export class RemultServerImplementation {
                     required: true,
                     schema: { type: 'string' },
                 };
-                let itemInBody = {
-                    requestBody: {
-                        content: {
-                            'application/json': {
-                                schema: {
-                                    $ref: '#/components/schemas/' + mutationKey,
-                                },
-                            },
-                        },
-                    },
-                };
                 apiPath.post = secure(meta.options.allowApiInsert, false, {
                     //"summary": "insert a " + key,
                     //"description": "insert a " + key,
@@ -673,15 +741,17 @@ class ExpressRequestBridgeToDataApiRequest {
 class ExpressResponseBridgeToDataApiResponse {
     r;
     req;
+    handleError;
     forbidden() {
-        this.setStatus(403).end();
+        this.error({ message: 'Forbidden' }, undefined, 403);
     }
     setStatus(status) {
         return this.r.status(status);
     }
-    constructor(r, req) {
+    constructor(r, req, handleError) {
         this.r = r;
         this.req = req;
+        this.handleError = handleError;
     }
     progress(progress) { }
     success(data) {
@@ -694,22 +764,53 @@ class ExpressResponseBridgeToDataApiResponse {
         this.setStatus(204).end();
     }
     notFound() {
-        this.setStatus(404).end();
+        this.error({ message: 'Forbidden' }, undefined, 404);
     }
-    error(data) {
-        data = serializeError(data);
-        console.error({
-            message: data.message,
-            stack: data.stack?.split('\n'),
-            url: this.req?.url,
-            method: this.req?.method,
+    async error(exception, entity, httpStatusCode) {
+        let data = serializeError(exception);
+        if (!httpStatusCode) {
+            if (data.httpStatusCode) {
+                httpStatusCode = data.httpStatusCode;
+            }
+            else if (isOfType(exception, 'isForbiddenError') &&
+                exception.isForbiddenError) {
+                httpStatusCode = 403;
+            }
+            else if (data.modelState) {
+                httpStatusCode = 400;
+            }
+            else {
+                httpStatusCode = 500;
+            }
+        }
+        let responseSent = false;
+        const sendError = (httpStatusCode, body) => {
+            if (responseSent) {
+                throw Error('Error response already sent');
+            }
+            responseSent = true;
+            console.error({
+                message: body.message,
+                httpStatusCode,
+                stack: data.stack?.split('\n'),
+                url: this.req?.url,
+                method: this.req?.method,
+            });
+            this.setStatus(httpStatusCode).json(body);
+        };
+        await this.handleError?.({
+            httpStatusCode,
+            req: this.req,
+            entity,
+            exception,
+            responseBody: data,
+            sendError,
         });
-        this.setStatus(400).json(data);
+        if (!responseSent) {
+            sendError(httpStatusCode, data);
+        }
     }
 }
-function throwError() {
-    throw 'Invalid';
-}
 class inProcessQueueHandler {
     storage;
     constructor(storage) {

package/esm/server/initAsyncHooks.js

@@ -6,5 +6,79 @@ export function initAsyncHooks() {
     if (init)
         return;
     init = true;
-    remultStatic.asyncContext = new RemultAsyncLocalStorage(new AsyncLocalStorage());
+    remultStatic.asyncContext = new RemultAsyncLocalStorage(new AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore());
+    let test = new AsyncLocalStorage();
+    test.run(1, async () => {
+        await Promise.resolve();
+        if (test.getStore() === undefined) {
+            console.log("async_hooks.AsyncLocalStorage not working, using sequential implementation (You're probably running on stackblitz, this will work on a normal nodejs environment");
+            remultStatic.asyncContext = new RemultAsyncLocalStorage(new SequentialRemultAsyncLocalStorageCore());
+        }
+    });
+}
+export class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl {
+    asyncLocalStorage = new AsyncLocalStorage();
+    wasImplemented;
+    run(store, callback) {
+        let r;
+        this.asyncLocalStorage.run(store, () => {
+            r = new Promise(async (res, rej) => {
+                try {
+                    res(await callback());
+                }
+                catch (err) {
+                    rej(err);
+                }
+            });
+        });
+        return r;
+    }
+    getStore() {
+        return this.asyncLocalStorage.getStore();
+    }
+}
+const ignoreInStack = ["AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore.run", "RemultAsyncLocalStorage.run", "Module.withRemult", "RemultServerImplementation.runWithRemult"];
+export class SequentialRemultAsyncLocalStorageCore {
+    wasImplemented;
+    async run(store, callback) {
+        let log = (msg) => {
+        };
+        if (false) {
+            let stack = new Error().stack;
+            let y = stack.split('\n');
+            while (y.length > 0 && (y[0].trim().startsWith("Error") || ignoreInStack.includes(y[0].trim().split(' ')[1]))) {
+                y.splice(0, 1);
+            }
+            stack = y.join('\n');
+            log = (msg) => {
+                console.log(msg, stack);
+            };
+        }
+        log('waiting on ');
+        const nextPromise = this.lastPromise.then(async () => {
+            log('executing  ');
+            const previousValue = this.currentValue;
+            this.currentValue = store;
+            const result = await callback();
+            this.currentValue = previousValue;
+            return result;
+        });
+        this.lastPromise = nextPromise.catch(() => {
+            log("Error on ");
+            return undefined;
+        });
+        try {
+            return await nextPromise;
+        }
+        finally {
+            log('completed  ');
+        }
+    }
+    getStore() {
+        return this.currentValue;
+    }
+    lastPromise = Promise.resolve(undefined);
+    currentValue;
+}
+export class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore extends AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl {
 }

package/esm/src/CompoundIdField.js

@@ -22,11 +22,17 @@ export class CompoundIdField {
         return Promise.resolve('');
     }
     getId(instance) {
+        let get = (field) => {
+            return instance[field.key];
+        };
+        if (typeof instance === 'function') {
+            get = instance;
+        }
         let r = '';
         this.fields.forEach((c) => {
             if (r.length > 0)
                 r += ',';
-            r += instance[c.key];
+            r += c.valueConverter.toJson(get(c));
         });
         return r;
     }
@@ -49,7 +55,7 @@ export class CompoundIdField {
         let val = value.toString();
         let id = val.split(',');
         this.fields.forEach((c, i) => {
-            result[c.key] = id[i];
+            result[c.key] = c.valueConverter.fromJson(id[i]);
         });
         return result;
     }

package/esm/src/context.js

@@ -24,11 +24,12 @@ export class RemultAsyncLocalStorage {
     constructor(remultObjectStorage) {
         this.remultObjectStorage = remultObjectStorage;
     }
-    run(remult, callback) {
-        if (this.remultObjectStorage)
-            this.remultObjectStorage.run(remult, () => callback(remult));
+    async run(remult, callback) {
+        if (this.remultObjectStorage) {
+            return this.remultObjectStorage.run(remult, () => callback(remult));
+        }
         else
-            callback(remult);
+            return callback(remult);
     }
     getRemult() {
         if (!this.remultObjectStorage) {
@@ -233,14 +234,20 @@ export class EventSource {
 export async function doTransaction(remult, what) {
     const trans = new transactionLiveQueryPublisher(remult.liveQueryPublisher);
     let ok = true;
-    const result = await remult.dataProvider.transaction(async (ds) => {
-        remult.dataProvider = ds;
-        remult.liveQueryPublisher = trans;
-        await what();
-        ok = true;
-    });
-    if (ok)
-        await trans.flush();
+    const prev = remult.dataProvider;
+    try {
+        await remult.dataProvider.transaction(async (ds) => {
+            remult.dataProvider = ds;
+            remult.liveQueryPublisher = trans;
+            await what(ds);
+            ok = true;
+        });
+        if (ok)
+            await trans.flush();
+    }
+    finally {
+        remult.dataProvider = prev;
+    }
 }
 class transactionLiveQueryPublisher {
     orig;
@@ -279,16 +286,5 @@ export function withRemult(callback, options) {
     const remult = new Remult();
     if (options?.dataProvider)
         remult.dataProvider = options.dataProvider;
-    let r;
-    remultStatic.asyncContext.run(remult, () => {
-        r = new Promise(async (res, rej) => {
-            try {
-                res(await callback(remult));
-            }
-            catch (err) {
-                rej(err);
-            }
-        });
-    });
-    return r;
+    return remultStatic.asyncContext.run(remult, r => callback(r));
 }