remult 3.0.1 → 3.0.2

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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "3.0.1",
+    "version": "3.0.2",
     "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;
 }());