remult 0.25.8-exp.0 → 0.25.8-exp.10

package/esm/graphql.js

@@ -904,7 +904,7 @@ export function translateWhereToRestBody(fields, { where }) {
         }
     }
     if (where.OR) {
-        result.OR = where.OR.map((where) => translateWhereToRestBody(fields, { where }));
+        result.OR = where.OR.map((where) => translateWhereToRestBody(fields, { where }).where);
     }
-    return result;
+    return { where: result };
 }

package/esm/migrations/compare-migration-snapshots.js

@@ -28,8 +28,8 @@ export async function compareMigrationSnapshot({ entities, snapshot, migrationBu
                 }
             }
         }
-        return snapshot;
     }
+    return snapshot;
 }
 export function emptySnapshot() {
     return {

package/esm/migrations/generate-migrations.js

@@ -4,12 +4,25 @@ import { compareMigrationSnapshot, emptySnapshot, } from './compare-migration-sn
 import { updateMigrationsFile } from './update-migrations-ts-file.js';
 import { DefaultMigrationBuilder, } from './migration-types.js';
 import { isOfType } from '../src/isOfType.js';
+import { initDataProvider } from '../server/initDataProvider.js';
+/**
+ * Generates migration scripts based on changes in entities.
+ *
+ * @param options - Configuration options for generating migrations.
+ * @param options.entities - An array of entity classes to be included in the migration.
+ * @param options.dataProvider - The data provider instance or a function returning a promise of the data provider.
+ * @param options.migrationsFolder - (Optional) The path to the folder where migration scripts will be stored. Default is 'src/server/migrations'.
+ * @param options.snapshotFile - (Optional) The path to the file where the snapshot of the last known state will be stored. Default is 'migrations-snapshot.json' in the `migrationsFolder`.
+ * @param options.migrationsTSFile - (Optional) The path to the TypeScript file where the generated migrations will be written. Default is 'migrations.ts' in the `migrationsFolder`.
+ * @param options.endConnection - (Optional) Determines whether to close the database connection after generating migrations. Default is true.
+ * @see [Migrations](http://remult.dev/docs/migrations.html)
+ */
 export async function generateMigrations(options) {
-    const migrationDir = options.migrationsDir || path.join(process.cwd(), 'src/server/migrations');
-    const snapshotFileName = options.snapshotFileName ||
-        path.join(migrationDir, 'migrations-snapshot.json');
-    const migrationsTSFilename = options.migrationsTSFilename || path.join(migrationDir, 'migrations.ts');
-    const dataProvider = await options.dataProvider;
+    const migrationDir = options.migrationsFolder ||
+        path.join(process.cwd(), 'src/server/migrations');
+    const snapshotFileName = options.snapshotFile || path.join(migrationDir, 'migrations-snapshot.json');
+    const migrationsTSFilename = options.migrationsTSFile || path.join(migrationDir, 'migrations.ts');
+    const dataProvider = await initDataProvider(options.dataProvider);
     for (const p of [snapshotFileName, migrationsTSFilename]) {
         if (!fs.existsSync(path.dirname(p))) {
             fs.mkdirSync(path.dirname(p), { recursive: true });
@@ -44,4 +57,7 @@ export async function generateMigrations(options) {
             `async (${hasSql ? '{sql}' : ''})=>{\n${steps.join('\n')}\n}`,
         ]);
     fs.writeFileSync(snapshotFileName, JSON.stringify(snapshot, null, 2));
+    if (options.endConnection !== false && isOfType(dataProvider, 'end')) {
+        await dataProvider.end();
+    }
 }

package/esm/migrations/migrate.js

@@ -1,12 +1,21 @@
 import { __decorate, __metadata } from "tslib";
 import { Entity, IdEntity, Fields, remult, Remult, } from '../index.js';
+import { initDataProvider } from '../server/initDataProvider.js';
 import { doTransaction } from '../src/context.js';
-import { cast } from '../src/isOfType.js';
+import { cast, isOfType } from '../src/isOfType.js';
+/**
+ * Applies migration scripts to update the database schema.
+ *
+ * @param options - Configuration options for applying migrations.
+ * @param options.migrations - An object containing the migration scripts, each keyed by a unique identifier.
+ * @param options.dataProvider - The data provider instance or a function returning a promise of the data provider.
+ * @param options.migrationsTable - (Optional) The name of the table that tracks applied migrations. Default is '__remult_migrations_version'.
+ * @param options.endConnection - (Optional) Determines whether to close the database connection after applying migrations. Default is true.
+* @see [Migrations](http://remult.dev/docs/migrations.html)
+*/
 export async function migrate(options) {
-    let migrationTableName = options.migrationTableName || '__remult_migration_version';
-    const dataProvider = options.dataProvider
-        ? await options.dataProvider
-        : remult.dataProvider;
+    let migrationTableName = options.migrationsTable || '__remult_migrations_version';
+    const dataProvider = await initDataProvider(options.dataProvider);
     const prev = remult.dataProvider;
     remult.dataProvider = dataProvider;
     try {
@@ -36,15 +45,24 @@ export async function migrate(options) {
                 throw new Error('Migration step number must be a non-negative integer');
             if (v.version >= step)
                 continue;
-            console.info('Executing migration step', step);
-            await doTransaction(remult, async (dp) => {
-                const utils = {
-                    sql: async (sql) => {
-                        await cast(dp, 'execute').execute(sql);
-                    },
-                };
-                await action(utils);
-            });
+            console.info('Executing migration step ' + step);
+            console.time('Completed migration step ' + step);
+            try {
+                await doTransaction(remult, async (dp) => {
+                    const utils = {
+                        sql: async (sql) => {
+                            await cast(dp, 'execute').execute(sql);
+                        },
+                    };
+                    await action(utils);
+                });
+                console.timeEnd('Completed migration step ' + step);
+            }
+            catch (err) {
+                console.error('Failed to execute migration step ' + step);
+                console.error(err);
+                throw err;
+            }
             v.version = step;
             await v.save();
         }
@@ -52,4 +70,7 @@ export async function migrate(options) {
     finally {
         remult.dataProvider = prev;
     }
+    if (options.endConnection !== false && isOfType(dataProvider, 'end')) {
+        await dataProvider.end();
+    }
 }

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

@@ -1,5 +1,5 @@
 // consider replacing with https://www.npmjs.com/package/ts-morph
-import * as ts from 'typescript';
+import ts from 'typescript';
 import * as fs from 'fs';
 export async function updateMigrationsFile(filePath, steps) {
     let maxStep = -1;
@@ -10,7 +10,7 @@ export async function updateMigrationsFile(filePath, steps) {
         fs.writeFileSync(filePath, '');
     }
     const importPath = 'remult/migrations';
-    const importName = 'MigrationSteps';
+    const importName = 'Migrations';
     // Load the file
     const sourceFile = ts.createSourceFile(filePath, fs.readFileSync(filePath).toString(), ts.ScriptTarget.Latest, true);
     let migrationsExportFound = false;

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

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

package/esm/remult-knex/index.js

@@ -13,6 +13,10 @@ export class KnexDataProvider {
     constructor(knex) {
         this.knex = knex;
     }
+    end() {
+        return this.knex.destroy();
+    }
+    /* @internal */
     provideMigrationBuilder(builder) {
         var sb = new KnexSchemaBuilder(this.knex);
         return {
@@ -37,8 +41,8 @@ export class KnexDataProvider {
     execute(sql) {
         return this.createCommand().execute(sql);
     }
-    static getDb(remult) {
-        const r = (remult || remultContext).dataProvider;
+    static getDb(dataProvider) {
+        const r = (dataProvider || remultContext.dataProvider);
         if (!r.knex)
             throw 'the data provider is not an KnexDataProvider';
         return r.knex;

package/esm/remult-mongo.js

@@ -16,8 +16,8 @@ export class MongoDataProvider {
     }
     session;
     disableTransactions = false;
-    static getDb(remult) {
-        const r = (remult || remultContext).dataProvider;
+    static getDb(dataProvider) {
+        const r = (dataProvider || remultContext.dataProvider);
         if (!r.db)
             throw 'the data provider is not a MongoDataProvider';
         return { db: r.db, session: r.session };

package/esm/remult-sql-js.js

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

package/esm/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).updateMany(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) {
@@ -285,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));
 }