remult 0.14.7 → 0.14.8

package/postgres/schema-builder.js

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresSchemaBuilder = exports.verifyStructureOfAllEntities = exports.postgresColumnSyntax = void 0;
+var tslib_1 = require("tslib");
+var context_1 = require("../src/context");
+var filter_consumer_bridge_to_sql_request_1 = require("../src/filter/filter-consumer-bridge-to-sql-request");
+var remult3_1 = require("../src/remult3");
+var valueConverters_1 = require("../valueConverters");
+function postgresColumnSyntax(x, dbName) {
+    var result = dbName;
+    if (x.valueType == Number) {
+        if (!x.valueConverter.fieldTypeInDb)
+            result += " numeric" + (x.allowNull ? "" : " default 0 not null");
+        else
+            result += " " + x.valueConverter.fieldTypeInDb + (x.allowNull ? "" : " default 0 not null");
+    }
+    else if (x.valueType == Date) {
+        if (!x.valueConverter.fieldTypeInDb)
+            if (x.valueConverter == valueConverters_1.ValueConverters.DateOnly)
+                result += " date";
+            else
+                result += " timestamp";
+        else
+            result += " " + x.valueConverter.fieldTypeInDb;
+    }
+    else if (x.valueType == Boolean)
+        result += " boolean" + (x.allowNull ? "" : " default false not null");
+    else if (x.valueConverter.fieldTypeInDb) {
+        result += " " + x.valueConverter.fieldTypeInDb;
+        if (!x.allowNull && x.valueConverter.fieldTypeInDb == 'integer') {
+            result += " default 0 not null";
+        }
+    }
+    else
+        result += " varchar" + (x.allowNull ? "" : " default '' not null");
+    return result;
+}
+exports.postgresColumnSyntax = postgresColumnSyntax;
+function verifyStructureOfAllEntities(db, remult) {
+    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*/, new PostgresSchemaBuilder(db).verifyStructureOfAllEntities(remult)];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
+}
+exports.verifyStructureOfAllEntities = verifyStructureOfAllEntities;
+var PostgresSchemaBuilder = /** @class */ (function () {
+    function PostgresSchemaBuilder(pool, schema) {
+        this.pool = pool;
+        this.additionalWhere = '';
+        if (schema) {
+            this.additionalWhere = ' and table_schema=\'' + schema + '\'';
+        }
+    }
+    PostgresSchemaBuilder.prototype.verifyStructureOfAllEntities = function (remult) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var allEntities_1, allEntities_1_1, entityClass, entity, e, err_1, e_1_1;
+            var e_1, _a;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        console.log("start verify structure");
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 12, 13, 14]);
+                        allEntities_1 = tslib_1.__values(context_1.allEntities), allEntities_1_1 = allEntities_1.next();
+                        _b.label = 2;
+                    case 2:
+                        if (!!allEntities_1_1.done) return [3 /*break*/, 11];
+                        entityClass = allEntities_1_1.value;
+                        entity = remult.repo(entityClass).metadata;
+                        return [4 /*yield*/, filter_consumer_bridge_to_sql_request_1.getDbNameProvider(entity)];
+                    case 3:
+                        e = _b.sent();
+                        _b.label = 4;
+                    case 4:
+                        _b.trys.push([4, 9, , 10]);
+                        if (!!entity.options.sqlExpression) return [3 /*break*/, 8];
+                        return [4 /*yield*/, e.entityName];
+                    case 5:
+                        if (!((_b.sent()).toLowerCase().indexOf('from ') < 0)) return [3 /*break*/, 8];
+                        return [4 /*yield*/, this.createIfNotExist(entity)];
+                    case 6:
+                        _b.sent();
+                        return [4 /*yield*/, this.verifyAllColumns(entity)];
+                    case 7:
+                        _b.sent();
+                        _b.label = 8;
+                    case 8: return [3 /*break*/, 10];
+                    case 9:
+                        err_1 = _b.sent();
+                        console.log("failed verify structure of " + e.entityName + " ", err_1);
+                        return [3 /*break*/, 10];
+                    case 10:
+                        allEntities_1_1 = allEntities_1.next();
+                        return [3 /*break*/, 2];
+                    case 11: return [3 /*break*/, 14];
+                    case 12:
+                        e_1_1 = _b.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 14];
+                    case 13:
+                        try {
+                            if (allEntities_1_1 && !allEntities_1_1.done && (_a = allEntities_1.return)) _a.call(allEntities_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 14: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    PostgresSchemaBuilder.prototype.createIfNotExist = function (entity) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var c, e;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        c = this.pool.createCommand();
+                        return [4 /*yield*/, filter_consumer_bridge_to_sql_request_1.getDbNameProvider(entity)];
+                    case 1:
+                        e = _a.sent();
+                        return [4 /*yield*/, c.execute("select 1 from information_Schema.tables where table_name=" + c.addParameterAndReturnSqlToken((e.entityName).toLowerCase()) + this.additionalWhere).then(function (r) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                var result, _a, _b, x, sql;
+                                var e_2, _c;
+                                return tslib_1.__generator(this, function (_d) {
+                                    switch (_d.label) {
+                                        case 0:
+                                            if (!(r.rows.length == 0)) return [3 /*break*/, 2];
+                                            result = '';
+                                            try {
+                                                for (_a = tslib_1.__values(entity.fields), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                                    x = _b.value;
+                                                    if (!e.isDbReadonly(x) || remult3_1.isAutoIncrement(x)) {
+                                                        if (result.length != 0)
+                                                            result += ',';
+                                                        result += '\r\n  ';
+                                                        if (remult3_1.isAutoIncrement(x))
+                                                            result += e.nameOf(x) + ' serial';
+                                                        else {
+                                                            result += postgresColumnSyntax(x, e.nameOf(x));
+                                                            if (x == entity.idMetadata.field)
+                                                                result += ' primary key';
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                                            finally {
+                                                try {
+                                                    if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                                                }
+                                                finally { if (e_2) throw e_2.error; }
+                                            }
+                                            sql = 'create table ' + e.entityName + ' (' + result + '\r\n)';
+                                            //console.log(sql);
+                                            return [4 /*yield*/, this.pool.execute(sql)];
+                                        case 1:
+                                            //console.log(sql);
+                                            _d.sent();
+                                            _d.label = 2;
+                                        case 2: return [2 /*return*/];
+                                    }
+                                });
+                            }); })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    PostgresSchemaBuilder.prototype.addColumnIfNotExist = function (entity, c) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var e, cmd, colName, sql, err_2;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, filter_consumer_bridge_to_sql_request_1.getDbNameProvider(entity)];
+                    case 1:
+                        e = _a.sent();
+                        if (e.isDbReadonly(c(entity)))
+                            return [2 /*return*/];
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 6, , 7]);
+                        cmd = this.pool.createCommand();
+                        colName = e.nameOf(c(entity));
+                        return [4 /*yield*/, cmd.execute("select 1   \n        FROM information_schema.columns \n        WHERE table_name=" + cmd.addParameterAndReturnSqlToken((e.entityName).toLocaleLowerCase()) + " and column_name=" + cmd.addParameterAndReturnSqlToken((colName).toLocaleLowerCase()) + this.additionalWhere)];
+                    case 3:
+                        if (!((_a.sent()).rows.length == 0)) return [3 /*break*/, 5];
+                        sql = "alter table " + e.entityName + " add column " + postgresColumnSyntax(c(entity), colName);
+                        //console.log(sql);
+                        return [4 /*yield*/, this.pool.execute(sql)];
+                    case 4:
+                        //console.log(sql);
+                        _a.sent();
+                        _a.label = 5;
+                    case 5: return [3 /*break*/, 7];
+                    case 6:
+                        err_2 = _a.sent();
+                        console.log(err_2);
+                        return [3 /*break*/, 7];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    PostgresSchemaBuilder.prototype.verifyAllColumns = function (entity) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var cmd, e, cols, _a, _b, col, sql, e_3_1, err_3;
+            var e_3, _c;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        _d.trys.push([0, 11, , 12]);
+                        cmd = this.pool.createCommand();
+                        return [4 /*yield*/, filter_consumer_bridge_to_sql_request_1.getDbNameProvider(entity)];
+                    case 1:
+                        e = _d.sent();
+                        return [4 /*yield*/, cmd.execute("select column_name   \n        FROM information_schema.columns \n        WHERE table_name=" + cmd.addParameterAndReturnSqlToken((e.entityName).toLocaleLowerCase()) + " " + this.additionalWhere)];
+                    case 2:
+                        cols = (_d.sent()).rows.map(function (x) { return x.column_name; });
+                        _d.label = 3;
+                    case 3:
+                        _d.trys.push([3, 8, 9, 10]);
+                        _a = tslib_1.__values(entity.fields), _b = _a.next();
+                        _d.label = 4;
+                    case 4:
+                        if (!!_b.done) return [3 /*break*/, 7];
+                        col = _b.value;
+                        if (!!e.isDbReadonly(col)) return [3 /*break*/, 6];
+                        if (!!cols.includes(e.nameOf(col).toLocaleLowerCase())) return [3 /*break*/, 6];
+                        sql = "alter table " + e.entityName + " add column " + postgresColumnSyntax(col, e.nameOf(col));
+                        //console.log(sql);
+                        return [4 /*yield*/, this.pool.execute(sql)];
+                    case 5:
+                        //console.log(sql);
+                        _d.sent();
+                        _d.label = 6;
+                    case 6:
+                        _b = _a.next();
+                        return [3 /*break*/, 4];
+                    case 7: return [3 /*break*/, 10];
+                    case 8:
+                        e_3_1 = _d.sent();
+                        e_3 = { error: e_3_1 };
+                        return [3 /*break*/, 10];
+                    case 9:
+                        try {
+                            if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                        return [7 /*endfinally*/];
+                    case 10: return [3 /*break*/, 12];
+                    case 11:
+                        err_3 = _d.sent();
+                        console.log(err_3);
+                        return [3 /*break*/, 12];
+                    case 12: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return PostgresSchemaBuilder;
+}());
+exports.PostgresSchemaBuilder = PostgresSchemaBuilder;

package/readme.md

@@ -25,51 +25,40 @@
 	<img alt="Twitter Follow" src="https://img.shields.io/twitter/follow/remultjs?style=social">
 	</a>
 </div>
+<hr/>
+
+[Getting Started](#getting-started) | [Documentation](#documentation) | [Example App](#example-app)
 
 ## What is Remult?
 
-**Remult** is a full-stack CRUD framework that uses your TypeScript model types to provide:
+**Remult** is a full-stack CRUD framework that uses your **TypeScript entities as a single source of truth for your API, frontend type-safe API client and backend ORM**.
 
-* Secure REST API (highly configurable)
-* Type-safe frontend API client
-* Type-safe backend query builder
+### Status
 
-#### Remult :heart: Code Sharing
+Remult is **production-ready** and, in fact, used in production apps since 2017. However, we’re keeping the major version at zero so we can use community feedback to finalize the v1 API.
 
-With model types shared between frontend and backend code, Remult can **enforce data validation and constraints, defined once, both in the front-end and within back-end API routes**.
+## Motivation
 
-## Getting started
-The best way to learn Remult is by following a tutorial of a simple Todo web app with a Node.js Express backend. 
+Full-stack web development is (still) too complicated. **Simple CRUD, a common requirement of any business application, should be simple to build, maintain, and extend** when the need arises.
 
-* [Tutorial with React](https://remult.dev/tutorials/react/) 
-* [Tutorial with Angular](https://remult.dev/tutorials/angular/)
-* [Tutorial with Vue](https://remult.dev/tutorials/vue/)
-* [Tutorial with Next.js](https://remult.dev/tutorials/react-next/)
+Remult abstracts away repetitive, boilerplate, error-prone, and poorly designed code on the one hand, and enables total flexibility and control on the other. **Remult let you write TypeScript code you can follow and safely refactor**, and fits nicely into any existing or new project by being minimalistic and completely unopinionated regarding the developer’s choice of other frameworks and tools.
+
+Other frameworks tend to fall into either too much abstraction (no-code, low-code, BaaS) or partial abstraction (MVC frameworks, GraphQL, ORMs, API generators, code generators), and tend to be opinionated regarding the development tool-chain, deployment environment, configuration/conventions or DSL. Remult attempts to strike a better balance.
 
 ## Installation
+
+The *remult* package is one and the same for both the frontend bundle and the backend. Install it once for a monolith project or per-repo in a monorepo.
+
 ```sh
 npm i remult
 ```
 
 ## Usage
 
-### Setup API backend using a Node.js Express middleware
-```ts
-import express from 'express';
-import { remultExpress } from 'remult/remult-express';
-
-const port = 3001;
-const app = express();
-
-app.use(remultExpress());
-
-app.listen(port, () => {
-  console.log(`Example API listening at http://localhost:${port}`);
-});
-```
-
 ### Define model classes
 ```ts
+// shared/product.ts
+
 import { Entity, Fields } from 'remult';
 
 @Entity('products', {
@@ -84,6 +73,26 @@ export class Product {
 }
 ```
 
+### Setup API backend using an Express middleware
+```ts
+// backend/index.ts
+
+import express from 'express';
+import { remultExpress } from 'remult/remult-express';
+import { Product } from '../shared/product';
+
+const port = 3001;
+const app = express();
+
+app.use(remultExpress({
+  entities: [Product]
+}));
+
+app.listen(port, () => {
+  console.log(`Example API listening at http://localhost:${port}`);
+});
+```
+
 ### :rocket: API Ready
 ```sh
 > curl http://localhost:3001/api/products
@@ -93,12 +102,19 @@ export class Product {
 
 ### Find and manipulate data in type-safe frontend code
 ```ts
+// frontend/code.ts
+
+import { Remult } from 'remult';
+import { Product } from '../shared/product';
+
+const remult = new Remult();
+
 async function increasePriceOfTofu(priceIncrease: number) {
   const productsRepo = remult.repo(Product);
 
-  const product = await productsRepo.findFirst({ name: 'Tofu' });
+  const product = await productsRepo.findFirst({ name: 'Tofu' }); // filter is passed through API request all the way to the db
   product.unitPrice += priceIncrease;
-  productsRepo.save(product);
+  productsRepo.save(product); // mutation request updates the db with no boilerplate code
 }
 ```
 
@@ -108,7 +124,7 @@ async function increasePriceOfTofu(priceIncrease: number) {
 static async increasePriceOfTofu(priceIncrease: number, remult?: Remult) {
   const productsRepo = remult!.repo(Product);
 
-  const product = await productsRepo.findFirst({ name: 'Tofu' });
+  const product = await productsRepo.findFirst({ name: 'Tofu' }); // use Remult in the backend as an ORM
   product.unitPrice += priceIncrease;
   productsRepo.save(product);
 }
@@ -184,6 +200,28 @@ export class Article {
 }
 ```
 
+## What about complex CRUD?
+
+While simple CRUD shouldn’t require any backend coding, using Remult means having the ability to handle any complex scenario by controlling the backend in numerous ways:
+
+* Backend computed (read-only) fields - from simple [expressions](https://remult.dev/docs/ref_field.html#serverexpression) to complex data lookups or even direct db access (SQL)
+* Custom side-effects with [entity lifecycle hooks](https://remult.dev/docs/ref_entity.html#saving) (before/after saving/deleting)
+* Backend only updatable fields (e.g. “last updated at”)
+* Many-to-one [relations](https://remult.dev/docs/entity-relations.html) with [lazy/eager loading](https://remult.dev/docs/lazy-loading-of-related-entities.html)
+* Roll-your-own type-safe endpoints with [Backend Methods](https://remult.dev/docs/backendMethods.html)
+* Roll-your-own low-level endpoints (Express, Fastify, koa, others…)
+
+## Getting started
+The best way to learn Remult is by following a tutorial of a simple Todo web app with a Node.js Express backend. 
+
+* [Tutorial with React](https://remult.dev/tutorials/react/) 
+* [Tutorial with Angular](https://remult.dev/tutorials/angular/)
+* [Tutorial with Vue](https://remult.dev/tutorials/vue/)
+* [Tutorial with Next.js](https://remult.dev/tutorials/react-next/)
+
+## Documentation
+The [documentation](https://remult.dev/docs) covers the main features of Remult. However, it is still a work-in-progress.
+
 ## Example App
 
 [CRM demo](https://github.com/remult/crm-demo) with a React + [MUI](https://mui.com) front-end and Postgres database.

package/src/data-providers/web-sql-data-provider.js

@@ -109,15 +109,16 @@ var WebSqlDataProvider = /** @class */ (function () {
     };
     WebSqlDataProvider.prototype.addColumnSqlSyntax = function (x, dbName) {
         var result = dbName;
+        var nullNumber = x.allowNull ? "" : " default 0 not null";
         if (x.valueType == Date)
             result += " integer";
         else if (x.valueType == Boolean)
-            result += " integer default 0 not null";
+            result += " integer " + nullNumber;
         else if (x.valueType == Number) {
             if (!x.valueConverter.fieldTypeInDb)
-                result += ' real default 0 not null';
+                result += ' real ' + nullNumber;
             else
-                result += ' ' + x.valueConverter.fieldTypeInDb + ' default 0 not null';
+                result += ' ' + x.valueConverter.fieldTypeInDb + ' ' + nullNumber;
         }
         else
             result += " text" + (x.allowNull ? " " : " default '' not null ");

package/src/entity.d.ts

@@ -68,8 +68,15 @@ export interface EntityOptions<entityType = any> {
     dbName?: string;
     /** For entities that are based on SQL expressions instead of a physical table or view*/
     sqlExpression?: string | ((entity: FieldsMetadata<entityType>) => string | Promise<string>);
-    /** An arrow function that identifies the `id` column to use for this entity */
-    id?: (entity: FieldsMetadata<entityType>) => FieldMetadata;
+    /** An arrow function that identifies the `id` column to use for this entity
+     * @example
+     * //Single column id
+     * @Entity<Products>("products", { id:p=>p.productCode })
+     * @example
+     * //Multiple columns id
+     * @Entity<OrderDetails>("orderDetails", { id:od=> [od.orderId, od.productCode] })
+    */
+    id?: (entity: FieldsMetadata<entityType>) => FieldMetadata | FieldMetadata[];
     entityRefInit?: (ref: EntityRef<entityType>, row: entityType) => void;
     apiRequireId?: Allowed;
 }

package/src/remult3/RepositoryImplementation.js

@@ -2181,7 +2181,15 @@ var EntityFullInfo = /** @class */ (function () {
         this.fields = r;
         this.caption = buildCaption(entityInfo.caption, this.key, remult);
         if (entityInfo.id) {
-            this.idMetadata.field = entityInfo.id(this.fields);
+            var r_2 = entityInfo.id(this.fields);
+            if (Array.isArray(r_2)) {
+                if (r_2.length > 1)
+                    this.idMetadata.field = new (column_1.CompoundIdField.bind.apply(column_1.CompoundIdField, tslib_1.__spread([void 0], r_2)))();
+                else if (r_2.length == 1)
+                    this.idMetadata.field = r_2[0];
+            }
+            else
+                this.idMetadata.field = r_2;
         }
         else {
             if (this.fields["id"])
@@ -2331,8 +2339,8 @@ var Fields = /** @class */ (function () {
 }());
 exports.Fields = Fields;
 function isAutoIncrement(f) {
-    var _a;
-    return ((_a = f.options.valueConverter) === null || _a === void 0 ? void 0 : _a.fieldTypeInDb) === 'autoincrement';
+    var _a, _b;
+    return ((_b = (_a = f.options) === null || _a === void 0 ? void 0 : _a.valueConverter) === null || _b === void 0 ? void 0 : _b.fieldTypeInDb) === 'autoincrement';
 }
 exports.isAutoIncrement = isAutoIncrement;
 function ValueListFieldType() {

package/src/shared-tests/test-update-with-null.spec.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
+var sql_database_1 = require("../data-providers/sql-database");
 var remult3_1 = require("../remult3");
 var db_tests_setup_1 = require("./db-tests-setup");
 var testNull = /** @class */ (function (_super) {
@@ -8,6 +9,7 @@ var testNull = /** @class */ (function (_super) {
     function testNull() {
         var _this = _super !== null && _super.apply(this, arguments) || this;
         _this.id = 0;
+        _this.numberWithNull = null;
         return _this;
     }
     tslib_1.__decorate([
@@ -18,6 +20,10 @@ var testNull = /** @class */ (function (_super) {
         remult3_1.Field(undefined, { allowNull: true }),
         tslib_1.__metadata("design:type", Object)
     ], testNull.prototype, "myCol", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.integer({ allowNull: true }),
+        tslib_1.__metadata("design:type", Number)
+    ], testNull.prototype, "numberWithNull", void 0);
     testNull = tslib_1.__decorate([
         remult3_1.Entity('testNull', { allowApiCrud: true })
     ], testNull);
@@ -49,3 +55,35 @@ db_tests_setup_1.testAll("test that update null works", function (_a) {
         });
     });
 }, false);
+db_tests_setup_1.testAll("test number with null", function (_a) {
+    var createEntity = _a.createEntity;
+    return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var r, i, _b, _c;
+        return tslib_1.__generator(this, function (_d) {
+            switch (_d.label) {
+                case 0: return [4 /*yield*/, createEntity(testNull)];
+                case 1:
+                    r = _d.sent();
+                    return [4 /*yield*/, r.insert({ id: 1, myCol: { value: 'abc' }, numberWithNull: null })];
+                case 2:
+                    i = _d.sent();
+                    expect(i.numberWithNull).toBe(null);
+                    _b = expect;
+                    return [4 /*yield*/, r.count({ numberWithNull: null })];
+                case 3:
+                    _b.apply(void 0, [_d.sent()]).toBe(1);
+                    i.numberWithNull = 0;
+                    return [4 /*yield*/, i.save()];
+                case 4:
+                    _d.sent();
+                    expect(i.numberWithNull).toBe(0);
+                    sql_database_1.SqlDatabase.LogToConsole = true;
+                    _c = expect;
+                    return [4 /*yield*/, r.count({ numberWithNull: null })];
+                case 5:
+                    _c.apply(void 0, [_d.sent()]).toBe(0);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}, false);

package/valueConverters.js

@@ -86,6 +86,8 @@ var ValueConverters = /** @class */ (function () {
                 return undefined;
             return val.replace(/-/g, '');
         }, fromDb: function (val) {
+            if (val === null)
+                return null;
             if (!val)
                 return undefined;
             return new Date(val.substring(0, 4) + '-' + val.substring(4, 6) + '-' + val.substring(6, 8));
@@ -110,6 +112,8 @@ var ValueConverters = /** @class */ (function () {
     };
     ValueConverters.Number = {
         fromDb: function (value) {
+            if (value === null)
+                return null;
             if (value !== undefined)
                 return +value;
             return undefined;