remult 3.0.1 → 3.0.3-next.0

package/esm/remult-duckdb.js

@@ -1,10 +1,13 @@
+import { DuckDBTypeId } from '@duckdb/node-api';
 import { SqliteCoreDataProvider } from './remult-sqlite-core.js';
 import { ValueConverters, dbNamesOf, } from './index.js';
 import { shouldNotCreateField } from './src/filter/filter-consumer-bridge-to-sql-request.js';
 import { isAutoIncrement } from './src/remult3/RepositoryImplementation.js';
 export class DuckDBDataProvider extends SqliteCoreDataProvider {
-    constructor(db) {
-        super(() => new DuckDBCommand(db), async () => (await db).close(), false, true);
+    connection;
+    constructor(connection) {
+        super(() => new DuckDBCommand(this.connection), async () => this.connection.disconnectSync(), false, true);
+        this.connection = connection;
     }
     wrapIdentifier(name) {
         return `"${name}"`;
@@ -12,7 +15,8 @@ export class DuckDBDataProvider extends SqliteCoreDataProvider {
     async getCreateTableSql(entity) {
         let result = '';
         let e = await dbNamesOf(entity, this.wrapIdentifier);
-        let sql = '';
+        const createSequenceStatements = [];
+        let createTableSql = '';
         for (const x of entity.fields) {
             if (!shouldNotCreateField(x, e) || isAutoIncrement(x)) {
                 if (result.length != 0)
@@ -20,7 +24,7 @@ export class DuckDBDataProvider extends SqliteCoreDataProvider {
                 result += '\r\n  ';
                 if (isAutoIncrement(x)) {
                     const sequenceName = `${entity.dbName}_${x.dbName}_seq`;
-                    sql += `create sequence if not exists "${sequenceName}";\r\n`;
+                    createSequenceStatements.push(`create sequence if not exists "${sequenceName}";`);
                     result += `${e.$dbNameOf(x)} integer default nextval('${sequenceName}')`;
                 }
                 else {
@@ -31,9 +35,9 @@ export class DuckDBDataProvider extends SqliteCoreDataProvider {
         result += `,\r\n   primary key (${entity.idMetadata.fields
             .map((f) => e.$dbNameOf(f))
             .join(',')})`;
-        sql +=
+        createTableSql =
             'create table if not exists ' + e.$entityName + ' (' + result + '\r\n)';
-        return [sql];
+        return [...createSequenceStatements, createTableSql];
     }
     addColumnSqlSyntax(x, dbName, isAlterColumn) {
         let result = dbName;
@@ -74,38 +78,83 @@ export class DuckDBDataProvider extends SqliteCoreDataProvider {
     }
 }
 class DuckDBCommand {
-    db;
+    connection;
     values = [];
-    constructor(db) {
-        this.db = db;
+    constructor(connection) {
+        this.connection = connection;
     }
     async execute(sql) {
-        return new Promise((resolve, error) => {
-            this.db.all(sql, ...this.values, (err, rows) => {
-                if (err)
-                    error(err);
-                else
-                    resolve(new DuckDBSqlResult(rows));
-            });
-        });
+        try {
+            const result = await this.connection.run(sql, this.values);
+            this.values = [];
+            return new DuckDBSqlResult(result);
+        }
+        catch (err) {
+            this.values = [];
+            throw err;
+        }
+    }
+    addParamInternal(val) {
+        if (val === undefined) {
+            this.values.push(null);
+        }
+        else if (val instanceof Date) {
+            this.values.push(val.toISOString());
+        }
+        else {
+            this.values.push(val);
+        }
+        return '?';
     }
     addParameterAndReturnSqlToken(val) {
-        return this.param(val);
+        return this.addParamInternal(val);
     }
     param(val) {
-        const key = '?';
-        this.values.push(val);
-        return key;
+        return this.addParamInternal(val);
     }
 }
 class DuckDBSqlResult {
-    result;
-    constructor(result) {
-        this.result = result;
-        this.rows = result;
-    }
+    duckDbResult;
     rows;
+    constructor(duckDbResult) {
+        this.duckDbResult = duckDbResult;
+        this.rows = [];
+        const columnNames = this.duckDbResult.columnNames();
+        const columnTypes = this.duckDbResult.columnTypes();
+        const chunkCount = this.duckDbResult.chunkCount;
+        for (let i = 0; i < chunkCount; i++) {
+            const chunk = this.duckDbResult.getChunk(i);
+            const chunkRowObjects = chunk.getRowObjects(columnNames).map((row) => {
+                const convertedRow = {};
+                columnNames.forEach((colName, colIndex) => {
+                    const value = row[colName];
+                    if (value === null) {
+                        convertedRow[colName] = null;
+                    }
+                    else {
+                        const colType = columnTypes[colIndex];
+                        const typeId = colType.typeId;
+                        if (typeId === DuckDBTypeId.TIMESTAMP) {
+                            const timestampValue = value;
+                            const parts = timestampValue.toParts();
+                            convertedRow[colName] = new Date(Date.UTC(parts.date.year, parts.date.month - 1, parts.date.day, parts.time.hour, parts.time.min, parts.time.sec, Math.floor(parts.time.micros / 1000)));
+                        }
+                        else if (typeId === DuckDBTypeId.DATE) {
+                            const dateValue = value;
+                            const parts = dateValue.toParts();
+                            convertedRow[colName] = new Date(Date.UTC(parts.year, parts.month - 1, parts.day));
+                        }
+                        else {
+                            convertedRow[colName] = value;
+                        }
+                    }
+                });
+                return convertedRow;
+            });
+            this.rows.push(...chunkRowObjects);
+        }
+    }
     getColumnKeyInResultForIndexInSelect(index) {
-        return Object.keys(this.result[0])[index];
+        return this.duckDbResult.columnName(index);
     }
 }

package/esm/server/test-api-data-provider.js

@@ -14,17 +14,20 @@ export function TestApiDataProvider(options) {
         buildGenericRequestInfo: (req) => req,
         ignoreAsyncStorage: true,
     });
+    const lock = new AsyncLock();
     async function handleOnServer(req) {
-        return await MakeServerCallWithDifferentStaticRemult(async () => {
-            if (newEntities.length > 0 && options?.ensureSchema != false) {
-                await (await dp).ensureSchema?.(newEntities);
-                newEntities = [];
-            }
-            var result = await server.handle(req);
-            if ((result?.statusCode ?? 200) >= 400) {
-                throw { ...result?.data, status: result?.statusCode ?? 500 };
-            }
-            return result?.data;
+        return lock.runExclusive(async () => {
+            return await MakeServerCallWithDifferentStaticRemult(async () => {
+                if (newEntities.length > 0 && options?.ensureSchema != false) {
+                    await (await dp).ensureSchema?.(newEntities);
+                    newEntities = [];
+                }
+                var result = await server.handle(req);
+                if ((result?.statusCode ?? 200) >= 400) {
+                    throw { ...result?.data, status: result?.statusCode ?? 500 };
+                }
+                return result?.data;
+            });
         });
     }
     const registeredEntities = new Set();
@@ -58,6 +61,24 @@ export function TestApiDataProvider(options) {
         }
     });
 }
+export class AsyncLock {
+    static enabled = true;
+    current = Promise.resolve();
+    i = 0;
+    async runExclusive(fn) {
+        const previous = this.current;
+        let resolveNext;
+        this.current = new Promise((resolve) => (resolveNext = resolve));
+        if (AsyncLock.enabled)
+            await previous;
+        try {
+            return await fn();
+        }
+        finally {
+            resolveNext();
+        }
+    }
+}
 async function MakeServerCallWithDifferentStaticRemult(what) {
     var x = remultStatic.asyncContext;
     var y = remultStatic.remultFactory;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "3.0.1",
+    "version": "3.0.3-next.0",
     "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev",
     "repository": {

package/remult-duckdb.d.ts

@@ -1,8 +1,9 @@
-import type { Database } from 'duckdb';
+import type { DuckDBConnection } from '@duckdb/node-api';
 import { SqliteCoreDataProvider } from './remult-sqlite-core.js';
 import { type FieldMetadata, type EntityMetadata } from './index.js';
 export declare class DuckDBDataProvider extends SqliteCoreDataProvider {
-    constructor(db: Database);
+    private connection;
+    constructor(connection: DuckDBConnection);
     wrapIdentifier(name: string): string;
     getCreateTableSql(entity: EntityMetadata<any>): Promise<string[]>;
     addColumnSqlSyntax(x: FieldMetadata, dbName: string, isAlterColumn: boolean): string;

package/remult-duckdb.js

@@ -2,19 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DuckDBDataProvider = void 0;
 var tslib_1 = require("tslib");
+var node_api_1 = require("@duckdb/node-api");
 var remult_sqlite_core_js_1 = require("./remult-sqlite-core.js");
 var index_js_1 = require("./index.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 DuckDBDataProvider = /** @class */ (function (_super) {
     tslib_1.__extends(DuckDBDataProvider, _super);
-    function DuckDBDataProvider(db) {
-        var _this = _super.call(this, function () { return new DuckDBCommand(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()];
-            }
+    function DuckDBDataProvider(connection) {
+        var _this = _super.call(this, function () { return new DuckDBCommand(_this.connection); }, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+            return [2 /*return*/, this.connection.disconnectSync()];
         }); }); }, false, true) || this;
+        _this.connection = connection;
         return _this;
     }
     DuckDBDataProvider.prototype.wrapIdentifier = function (name) {
@@ -22,7 +21,7 @@ var DuckDBDataProvider = /** @class */ (function (_super) {
     };
     DuckDBDataProvider.prototype.getCreateTableSql = function (entity) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var result, e, sql, _a, _b, x, sequenceName;
+            var result, e, createSequenceStatements, createTableSql, _a, _b, x, sequenceName;
             var e_1, _c;
             return tslib_1.__generator(this, function (_d) {
                 switch (_d.label) {
@@ -31,7 +30,8 @@ var DuckDBDataProvider = /** @class */ (function (_super) {
                         return [4 /*yield*/, (0, index_js_1.dbNamesOf)(entity, this.wrapIdentifier)];
                     case 1:
                         e = _d.sent();
-                        sql = '';
+                        createSequenceStatements = [];
+                        createTableSql = '';
                         try {
                             for (_a = tslib_1.__values(entity.fields), _b = _a.next(); !_b.done; _b = _a.next()) {
                                 x = _b.value;
@@ -41,7 +41,7 @@ var DuckDBDataProvider = /** @class */ (function (_super) {
                                     result += '\r\n  ';
                                     if ((0, RepositoryImplementation_js_1.isAutoIncrement)(x)) {
                                         sequenceName = "".concat(entity.dbName, "_").concat(x.dbName, "_seq");
-                                        sql += "create sequence if not exists \"".concat(sequenceName, "\";\r\n");
+                                        createSequenceStatements.push("create sequence if not exists \"".concat(sequenceName, "\";"));
                                         result += "".concat(e.$dbNameOf(x), " integer default nextval('").concat(sequenceName, "')");
                                     }
                                     else {
@@ -60,9 +60,9 @@ var DuckDBDataProvider = /** @class */ (function (_super) {
                         result += ",\r\n   primary key (".concat(entity.idMetadata.fields
                             .map(function (f) { return e.$dbNameOf(f); })
                             .join(','), ")");
-                        sql +=
+                        createTableSql =
                             'create table if not exists ' + e.$entityName + ' (' + result + '\r\n)';
-                        return [2 /*return*/, [sql]];
+                        return [2 /*return*/, tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(createSequenceStatements), false), [createTableSql], false)];
                 }
             });
         });
@@ -108,43 +108,93 @@ var DuckDBDataProvider = /** @class */ (function (_super) {
 }(remult_sqlite_core_js_1.SqliteCoreDataProvider));
 exports.DuckDBDataProvider = DuckDBDataProvider;
 var DuckDBCommand = /** @class */ (function () {
-    function DuckDBCommand(db) {
-        this.db = db;
+    function DuckDBCommand(connection) {
+        this.connection = connection;
         this.values = [];
     }
     DuckDBCommand.prototype.execute = function (sql) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var _this = this;
+            var result, err_1;
             return tslib_1.__generator(this, function (_a) {
-                return [2 /*return*/, new Promise(function (resolve, error) {
-                        var _a;
-                        (_a = _this.db).all.apply(_a, tslib_1.__spreadArray(tslib_1.__spreadArray([sql], tslib_1.__read(_this.values), false), [function (err, rows) {
-                                if (err)
-                                    error(err);
-                                else
-                                    resolve(new DuckDBSqlResult(rows));
-                            }], false));
-                    })];
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.connection.run(sql, this.values)];
+                    case 1:
+                        result = _a.sent();
+                        this.values = [];
+                        return [2 /*return*/, new DuckDBSqlResult(result)];
+                    case 2:
+                        err_1 = _a.sent();
+                        this.values = [];
+                        throw err_1;
+                    case 3: return [2 /*return*/];
+                }
             });
         });
     };
+    DuckDBCommand.prototype.addParamInternal = function (val) {
+        if (val === undefined) {
+            this.values.push(null);
+        }
+        else if (val instanceof Date) {
+            this.values.push(val.toISOString());
+        }
+        else {
+            this.values.push(val);
+        }
+        return '?';
+    };
     DuckDBCommand.prototype.addParameterAndReturnSqlToken = function (val) {
-        return this.param(val);
+        return this.addParamInternal(val);
     };
     DuckDBCommand.prototype.param = function (val) {
-        var key = '?';
-        this.values.push(val);
-        return key;
+        return this.addParamInternal(val);
     };
     return DuckDBCommand;
 }());
 var DuckDBSqlResult = /** @class */ (function () {
-    function DuckDBSqlResult(result) {
-        this.result = result;
-        this.rows = result;
+    function DuckDBSqlResult(duckDbResult) {
+        var _a;
+        this.duckDbResult = duckDbResult;
+        this.rows = [];
+        var columnNames = this.duckDbResult.columnNames();
+        var columnTypes = this.duckDbResult.columnTypes();
+        var chunkCount = this.duckDbResult.chunkCount;
+        for (var i = 0; i < chunkCount; i++) {
+            var chunk = this.duckDbResult.getChunk(i);
+            var chunkRowObjects = chunk.getRowObjects(columnNames).map(function (row) {
+                var convertedRow = {};
+                columnNames.forEach(function (colName, colIndex) {
+                    var value = row[colName];
+                    if (value === null) {
+                        convertedRow[colName] = null;
+                    }
+                    else {
+                        var colType = columnTypes[colIndex];
+                        var typeId = colType.typeId;
+                        if (typeId === node_api_1.DuckDBTypeId.TIMESTAMP) {
+                            var timestampValue = value;
+                            var parts = timestampValue.toParts();
+                            convertedRow[colName] = new Date(Date.UTC(parts.date.year, parts.date.month - 1, parts.date.day, parts.time.hour, parts.time.min, parts.time.sec, Math.floor(parts.time.micros / 1000)));
+                        }
+                        else if (typeId === node_api_1.DuckDBTypeId.DATE) {
+                            var dateValue = value;
+                            var parts = dateValue.toParts();
+                            convertedRow[colName] = new Date(Date.UTC(parts.year, parts.month - 1, parts.day));
+                        }
+                        else {
+                            convertedRow[colName] = value;
+                        }
+                    }
+                });
+                return convertedRow;
+            });
+            (_a = this.rows).push.apply(_a, tslib_1.__spreadArray([], tslib_1.__read(chunkRowObjects), false));
+        }
     }
     DuckDBSqlResult.prototype.getColumnKeyInResultForIndexInSelect = function (index) {
-        return Object.keys(this.result[0])[index];
+        return this.duckDbResult.columnName(index);
     };
     return DuckDBSqlResult;
 }());

package/server/test-api-data-provider.d.ts

@@ -1,3 +1,9 @@
 import { RestDataProvider } from '../index.js';
 import type { RemultServerOptions } from './index.js';
 export declare function TestApiDataProvider(options?: Pick<RemultServerOptions<unknown>, 'ensureSchema' | 'dataProvider'>): RestDataProvider;
+export declare class AsyncLock {
+    static enabled: boolean;
+    private current;
+    i: number;
+    runExclusive<T>(fn: () => Promise<T>): Promise<T>;
+}

package/server/test-api-data-provider.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncLock = void 0;
 exports.TestApiDataProvider = TestApiDataProvider;
 var tslib_1 = require("tslib");
 var index_js_1 = require("../index.js");
@@ -23,36 +24,42 @@ function TestApiDataProvider(options) {
         buildGenericRequestInfo: function (req) { return req; },
         ignoreAsyncStorage: true,
     });
+    var lock = new AsyncLock();
     function handleOnServer(req) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var _this = this;
             return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, MakeServerCallWithDifferentStaticRemult(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                            var result;
-                            var _a, _b, _c, _d;
-                            return tslib_1.__generator(this, function (_e) {
-                                switch (_e.label) {
-                                    case 0:
-                                        if (!(newEntities.length > 0 && (options === null || options === void 0 ? void 0 : options.ensureSchema) != false)) return [3 /*break*/, 3];
-                                        return [4 /*yield*/, dp];
-                                    case 1: return [4 /*yield*/, ((_b = (_a = (_e.sent())).ensureSchema) === null || _b === void 0 ? void 0 : _b.call(_a, newEntities))];
-                                    case 2:
-                                        _e.sent();
-                                        newEntities = [];
-                                        _e.label = 3;
-                                    case 3: return [4 /*yield*/, server.handle(req)];
-                                    case 4:
-                                        result = _e.sent();
-                                        if (((_c = result === null || result === void 0 ? void 0 : result.statusCode) !== null && _c !== void 0 ? _c : 200) >= 400) {
-                                            throw tslib_1.__assign(tslib_1.__assign({}, result === null || result === void 0 ? void 0 : result.data), { status: (_d = result === null || result === void 0 ? void 0 : result.statusCode) !== null && _d !== void 0 ? _d : 500 });
-                                        }
-                                        return [2 /*return*/, result === null || result === void 0 ? void 0 : result.data];
-                                }
-                            });
-                        }); })];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
+                return [2 /*return*/, lock.runExclusive(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                        var _this = this;
+                        return tslib_1.__generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, MakeServerCallWithDifferentStaticRemult(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                        var result;
+                                        var _a, _b, _c, _d;
+                                        return tslib_1.__generator(this, function (_e) {
+                                            switch (_e.label) {
+                                                case 0:
+                                                    if (!(newEntities.length > 0 && (options === null || options === void 0 ? void 0 : options.ensureSchema) != false)) return [3 /*break*/, 3];
+                                                    return [4 /*yield*/, dp];
+                                                case 1: return [4 /*yield*/, ((_b = (_a = (_e.sent())).ensureSchema) === null || _b === void 0 ? void 0 : _b.call(_a, newEntities))];
+                                                case 2:
+                                                    _e.sent();
+                                                    newEntities = [];
+                                                    _e.label = 3;
+                                                case 3: return [4 /*yield*/, server.handle(req)];
+                                                case 4:
+                                                    result = _e.sent();
+                                                    if (((_c = result === null || result === void 0 ? void 0 : result.statusCode) !== null && _c !== void 0 ? _c : 200) >= 400) {
+                                                        throw tslib_1.__assign(tslib_1.__assign({}, result === null || result === void 0 ? void 0 : result.data), { status: (_d = result === null || result === void 0 ? void 0 : result.statusCode) !== null && _d !== void 0 ? _d : 500 });
+                                                    }
+                                                    return [2 /*return*/, result === null || result === void 0 ? void 0 : result.data];
+                                            }
+                                        });
+                                    }); })];
+                                case 1: return [2 /*return*/, _a.sent()];
+                            }
+                        });
+                    }); })];
             });
         });
     }
@@ -95,6 +102,40 @@ function TestApiDataProvider(options) {
         }
     });
 }
+var AsyncLock = /** @class */ (function () {
+    function AsyncLock() {
+        this.current = Promise.resolve();
+        this.i = 0;
+    }
+    AsyncLock.prototype.runExclusive = function (fn) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var previous, resolveNext;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        previous = this.current;
+                        this.current = new Promise(function (resolve) { return (resolveNext = resolve); });
+                        if (!AsyncLock.enabled) return [3 /*break*/, 2];
+                        return [4 /*yield*/, previous];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, , 4, 5]);
+                        return [4 /*yield*/, fn()];
+                    case 3: return [2 /*return*/, _a.sent()];
+                    case 4:
+                        resolveNext();
+                        return [7 /*endfinally*/];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AsyncLock.enabled = true;
+    return AsyncLock;
+}());
+exports.AsyncLock = AsyncLock;
 function MakeServerCallWithDifferentStaticRemult(what) {
     return tslib_1.__awaiter(this, void 0, void 0, function () {
         var x, y, user, store;

package/src/column-interfaces.d.ts

@@ -35,6 +35,10 @@ export interface FieldOptions<entityType = unknown, valueType = unknown> {
      * // Prevent API from updating this field
      * @Fields.string({ allowApiUpdate: false })
      * createdBy = remult.user?.id;
+     * @example
+     * // Allow API update only on new items
+     * @Fields.string<Category>({ allowApiUpdate: (c) => getEntityRef(c).isNew() })
+     * Description = ""
      * @see [allowed](https://remult.dev/docs/allowed.html)
      * @see [Access Control](https://remult.dev/docs/access-control)
      * @type {AllowedForInstance<entityType>}