remult 0.25.8-exp.1 → 0.25.8-exp.11

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

@@ -5,6 +5,18 @@ 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.migrationsFolder ||
         path.join(process.cwd(), 'src/server/migrations');

package/esm/migrations/migrate.js

@@ -3,6 +3,16 @@ import { Entity, IdEntity, Fields, remult, Remult, } from '../index.js';
 import { initDataProvider } from '../server/initDataProvider.js';
 import { doTransaction } from '../src/context.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.migrationsTable || '__remult_migrations_version';
     const dataProvider = await initDataProvider(options.dataProvider);

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;

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

@@ -8,8 +8,8 @@ export class PostgresDataProvider {
     pool;
     options;
     supportsJsonColumnType = true;
-    static getDb(remult) {
-        const r = (remult || defaultRemult).dataProvider;
+    static getDb(dataProvider) {
+        const r = (dataProvider || defaultRemult.dataProvider);
         if (!r._getSourceSql)
             throw 'the data provider is not an SqlDatabase';
         const me = r._getSourceSql();

package/esm/remult-better-sqlite3.js

@@ -0,0 +1,48 @@
+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.map((row) => Object.keys(row).reduce((prev, curr) => ({ ...prev, [curr]: row[curr] }), {}));
+    }
+    rows;
+    getColumnKeyInResultForIndexInSelect(index) {
+        return Object.keys(this.result[0])[index];
+    }
+}

package/esm/remult-knex/index.js

@@ -41,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;
@@ -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-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

@@ -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/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) {