remult 0.14.11 → 0.14.14

package/esm/postgres/postgresColumnSyntax.d.ts

@@ -0,0 +1,2 @@
+import { FieldMetadata } from '../src/column-interfaces';
+export declare function postgresColumnSyntax(x: FieldMetadata, dbName: string): string;

package/esm/postgres/postgresColumnSyntax.js

@@ -0,0 +1,30 @@
+import { ValueConverters } from '../valueConverters';
+export function postgresColumnSyntax(x, dbName) {
+    let 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.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;
+}

package/esm/remult-mongo.js

@@ -33,9 +33,10 @@ class MongoEntityDataProvider {
     translateFromJson(row, nameProvider) {
         let result = {};
         for (const col of this.entity.fields) {
-            result[col.key] = col.valueConverter.fromDb(row[nameProvider.nameOf(col)]);
-            if (isNull(result[col.key]))
-                result[col.key] = null;
+            let val = row[nameProvider.nameOf(col)];
+            if (isNull(val))
+                val = null;
+            result[col.key] = col.valueConverter.fromDb(val);
         }
         return result;
     }

package/esm/server/expressBridge.d.ts

@@ -39,12 +39,8 @@ export interface GenericRequest {
     params: any;
 }
 export interface GenericResponse {
-    status(arg0: number): any;
     statusCode: number;
     json(data: any): any;
-    writeHead(status: number): {
-        end: VoidFunction;
-    };
 }
 export declare type GenericRouter = GenericRequestHandler & {
     route(path: string): SpecificRoute;

package/esm/server/expressBridge.js

@@ -482,7 +482,8 @@ class ExpressResponseBridgeToDataApiResponse {
         this.sendStatus(403);
     }
     sendStatus(status) {
-        this.r.writeHead(status).end();
+        this.r.statusCode = status;
+        this.r.json({});
     }
     progress(progress) {
     }
@@ -507,7 +508,8 @@ class ExpressResponseBridgeToDataApiResponse {
             url: this.req.originalUrl ?? this.req.path,
             method: this.req.method
         });
-        this.r.status(400).json(data);
+        this.r.statusCode = 400;
+        this.r.json(data);
     }
 }
 function throwError() {

package/esm/src/backend-tests/test-http-server.backend-spec.d.ts

@@ -0,0 +1,6 @@
+export declare class Task {
+    id: string;
+    title: string;
+    completed: boolean;
+    static testForbidden(): void;
+}

package/esm/src/backend-tests/test-http-server.backend-spec.js

@@ -0,0 +1,117 @@
+import { __decorate, __metadata } from "tslib";
+import axios from 'axios';
+import { HttpProviderBridgeToRestDataProviderHttpProvider, Remult } from '../context';
+import { Entity, Fields } from '../remult3';
+import { Action, BackendMethod } from '../server-action';
+Remult.apiBaseUrl = 'http://localhost:3001/api';
+const path = Remult.apiBaseUrl + '/tasks';
+fit("works", async () => {
+    const repo = await create3Tasks();
+    const tasks = await repo.find({ where: { completed: true } });
+    expect(tasks.length).toBe(1);
+    await repo.save({ ...tasks[0], completed: false });
+    expect(await repo.count({ completed: true })).toBe(0);
+});
+fit("test multiple items", async () => {
+    const repo = await create3Tasks();
+    expect(await repo.count({
+        title: { "!=": ["a", "c"] }
+    })).toBe(1);
+});
+fit("validation", async () => {
+    const r = await create3Tasks();
+    let err = undefined;
+    try {
+        await r.insert({ "title": "" });
+    }
+    catch (error) {
+        err = error;
+    }
+    expect(err).toEqual({
+        message: "Title: Should not be empty",
+        httpStatusCode: 400,
+        modelState: {
+            title: "Should not be empty"
+        }
+    });
+});
+fit("forbidden", async () => {
+    let err = undefined;
+    try {
+        await Task.testForbidden();
+    }
+    catch (error) {
+        err = error;
+    }
+    expect(err).toEqual({
+        httpStatusCode: 403
+    });
+});
+fit("test http 404", async () => {
+    const repo = create3Tasks();
+    const task = await (await repo).findFirst();
+    let result = await axios.get(path + "/" + task.id);
+    expect(result.data.id).toBe(task.id);
+    expect(result.status).toBe(200);
+    let error = undefined;
+    try {
+        result = await axios.get(path + "/123");
+    }
+    catch (err) {
+        error = err;
+    }
+    expect(error.response.status).toBe(404);
+});
+fit("test http 201", async () => {
+    let result = await axios.post('http://localhost:3001/api/tasks', { title: "z", id: "" });
+    expect(result.data.title).toBe("z");
+    expect(result.status).toBe(201);
+    result = await axios.delete(path + "/" + result.data.id);
+    expect(result.status).toBe(204);
+});
+let Task = class Task {
+    constructor() {
+        this.title = '';
+        this.completed = false;
+    }
+    static testForbidden() {
+    }
+};
+__decorate([
+    Fields.uuid(),
+    __metadata("design:type", String)
+], Task.prototype, "id", void 0);
+__decorate([
+    Fields.string({
+    //  validate: Validators.required should only be on backend
+    }),
+    __metadata("design:type", Object)
+], Task.prototype, "title", void 0);
+__decorate([
+    Fields.boolean(),
+    __metadata("design:type", Object)
+], Task.prototype, "completed", void 0);
+__decorate([
+    BackendMethod({ allowed: false }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], Task, "testForbidden", null);
+Task = __decorate([
+    Entity("tasks", {
+        allowApiCrud: true
+    })
+], Task);
+export { Task };
+async function create3Tasks() {
+    const remult = new Remult(axios);
+    Action.provider = new HttpProviderBridgeToRestDataProviderHttpProvider(axios);
+    const taskRepo = remult.repo(Task);
+    for (const task of await taskRepo.find()) {
+        await taskRepo.delete(task);
+    }
+    expect(await taskRepo.count()).toBe(0);
+    await taskRepo.insert([{ title: "a" }, { title: "b", completed: true }, { title: "c" }]);
+    expect(await taskRepo.count()).toBe(3);
+    return taskRepo;
+}

package/esm/src/data-providers/sql-database.js

@@ -109,7 +109,7 @@ class ActualSQLServerDataProvider {
             select += await wc.resolveWhere();
         }
         return r.execute(select).then(r => {
-            return +r.rows[0].count;
+            return Number(r.rows[0].count);
         });
     }
     async find(options) {

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

@@ -1,5 +1,4 @@
 import { __decorate, __metadata } from "tslib";
-import { SqlDatabase } from "../data-providers/sql-database";
 import { Entity, EntityBase, Field, Fields } from "../remult3";
 import { testAll } from "./db-tests-setup";
 let testNull = class testNull extends EntityBase {
@@ -42,6 +41,5 @@ testAll("test number with null", async ({ createEntity }) => {
     i.numberWithNull = 0;
     await i.save();
     expect(i.numberWithNull).toBe(0);
-    SqlDatabase.LogToConsole = true;
     expect(await r.count({ numberWithNull: null })).toBe(0);
 }, false);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.14.11",
+    "version": "0.14.14",
     "description": "A CRUD framework for full-stack TypeScript",
     "main": "index.js",
     "types": "index.d.ts",

package/remult-mongo.js

@@ -60,9 +60,10 @@ var MongoEntityDataProvider = /** @class */ (function () {
         try {
             for (var _b = tslib_1.__values(this.entity.fields), _c = _b.next(); !_c.done; _c = _b.next()) {
                 var col = _c.value;
-                result[col.key] = col.valueConverter.fromDb(row[nameProvider.nameOf(col)]);
-                if (isNull(result[col.key]))
-                    result[col.key] = null;
+                var val = row[nameProvider.nameOf(col)];
+                if (isNull(val))
+                    val = null;
+                result[col.key] = col.valueConverter.fromDb(val);
             }
         }
         catch (e_1_1) { e_1 = { error: e_1_1 }; }

package/server/expressBridge.d.ts

@@ -39,12 +39,8 @@ export interface GenericRequest {
     params: any;
 }
 export interface GenericResponse {
-    status(arg0: number): any;
     statusCode: number;
     json(data: any): any;
-    writeHead(status: number): {
-        end: VoidFunction;
-    };
 }
 export declare type GenericRouter = GenericRequestHandler & {
     route(path: string): SpecificRoute;

package/server/expressBridge.js

@@ -580,7 +580,8 @@ var ExpressResponseBridgeToDataApiResponse = /** @class */ (function () {
         this.sendStatus(403);
     };
     ExpressResponseBridgeToDataApiResponse.prototype.sendStatus = function (status) {
-        this.r.writeHead(status).end();
+        this.r.statusCode = status;
+        this.r.json({});
     };
     ExpressResponseBridgeToDataApiResponse.prototype.progress = function (progress) {
     };
@@ -606,7 +607,8 @@ var ExpressResponseBridgeToDataApiResponse = /** @class */ (function () {
             url: (_b = this.req.originalUrl) !== null && _b !== void 0 ? _b : this.req.path,
             method: this.req.method
         });
-        this.r.status(400).json(data);
+        this.r.statusCode = 400;
+        this.r.json(data);
     };
     return ExpressResponseBridgeToDataApiResponse;
 }());

package/src/backend-tests/test-http-server.backend-spec.d.ts

@@ -0,0 +1,6 @@
+export declare class Task {
+    id: string;
+    title: string;
+    completed: boolean;
+    static testForbidden(): void;
+}

package/src/backend-tests/test-http-server.backend-spec.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Task = void 0;
+var tslib_1 = require("tslib");
+var axios_1 = require("axios");
+var context_1 = require("../context");
+var remult3_1 = require("../remult3");
+var server_action_1 = require("../server-action");
+context_1.Remult.apiBaseUrl = 'http://localhost:3001/api';
+var path = context_1.Remult.apiBaseUrl + '/tasks';
+fit("works", function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var repo, tasks, _a;
+    return tslib_1.__generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4 /*yield*/, create3Tasks()];
+            case 1:
+                repo = _b.sent();
+                return [4 /*yield*/, repo.find({ where: { completed: true } })];
+            case 2:
+                tasks = _b.sent();
+                expect(tasks.length).toBe(1);
+                return [4 /*yield*/, repo.save(tslib_1.__assign(tslib_1.__assign({}, tasks[0]), { completed: false }))];
+            case 3:
+                _b.sent();
+                _a = expect;
+                return [4 /*yield*/, repo.count({ completed: true })];
+            case 4:
+                _a.apply(void 0, [_b.sent()]).toBe(0);
+                return [2 /*return*/];
+        }
+    });
+}); });
+fit("test multiple items", function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var repo, _a;
+    return tslib_1.__generator(this, function (_b) {
+        switch (_b.label) {
+            case 0: return [4 /*yield*/, create3Tasks()];
+            case 1:
+                repo = _b.sent();
+                _a = expect;
+                return [4 /*yield*/, repo.count({
+                        title: { "!=": ["a", "c"] }
+                    })];
+            case 2:
+                _a.apply(void 0, [_b.sent()]).toBe(1);
+                return [2 /*return*/];
+        }
+    });
+}); });
+fit("validation", function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var r, err, error_1;
+    return tslib_1.__generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, create3Tasks()];
+            case 1:
+                r = _a.sent();
+                err = undefined;
+                _a.label = 2;
+            case 2:
+                _a.trys.push([2, 4, , 5]);
+                return [4 /*yield*/, r.insert({ "title": "" })];
+            case 3:
+                _a.sent();
+                return [3 /*break*/, 5];
+            case 4:
+                error_1 = _a.sent();
+                err = error_1;
+                return [3 /*break*/, 5];
+            case 5:
+                expect(err).toEqual({
+                    message: "Title: Should not be empty",
+                    httpStatusCode: 400,
+                    modelState: {
+                        title: "Should not be empty"
+                    }
+                });
+                return [2 /*return*/];
+        }
+    });
+}); });
+fit("forbidden", function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var err, error_2;
+    return tslib_1.__generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                err = undefined;
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, Task.testForbidden()];
+            case 2:
+                _a.sent();
+                return [3 /*break*/, 4];
+            case 3:
+                error_2 = _a.sent();
+                err = error_2;
+                return [3 /*break*/, 4];
+            case 4:
+                expect(err).toEqual({
+                    httpStatusCode: 403
+                });
+                return [2 /*return*/];
+        }
+    });
+}); });
+fit("test http 404", function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var repo, task, result, error, err_1;
+    return tslib_1.__generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                repo = create3Tasks();
+                return [4 /*yield*/, repo];
+            case 1: return [4 /*yield*/, (_a.sent()).findFirst()];
+            case 2:
+                task = _a.sent();
+                return [4 /*yield*/, axios_1.default.get(path + "/" + task.id)];
+            case 3:
+                result = _a.sent();
+                expect(result.data.id).toBe(task.id);
+                expect(result.status).toBe(200);
+                error = undefined;
+                _a.label = 4;
+            case 4:
+                _a.trys.push([4, 6, , 7]);
+                return [4 /*yield*/, axios_1.default.get(path + "/123")];
+            case 5:
+                result = _a.sent();
+                return [3 /*break*/, 7];
+            case 6:
+                err_1 = _a.sent();
+                error = err_1;
+                return [3 /*break*/, 7];
+            case 7:
+                expect(error.response.status).toBe(404);
+                return [2 /*return*/];
+        }
+    });
+}); });
+fit("test http 201", function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+    var result;
+    return tslib_1.__generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, axios_1.default.post('http://localhost:3001/api/tasks', { title: "z", id: "" })];
+            case 1:
+                result = _a.sent();
+                expect(result.data.title).toBe("z");
+                expect(result.status).toBe(201);
+                return [4 /*yield*/, axios_1.default.delete(path + "/" + result.data.id)];
+            case 2:
+                result = _a.sent();
+                expect(result.status).toBe(204);
+                return [2 /*return*/];
+        }
+    });
+}); });
+var Task = /** @class */ (function () {
+    function Task() {
+        this.title = '';
+        this.completed = false;
+    }
+    Task.testForbidden = function () {
+    };
+    tslib_1.__decorate([
+        remult3_1.Fields.uuid(),
+        tslib_1.__metadata("design:type", String)
+    ], Task.prototype, "id", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.string({
+        //  validate: Validators.required should only be on backend
+        }),
+        tslib_1.__metadata("design:type", Object)
+    ], Task.prototype, "title", void 0);
+    tslib_1.__decorate([
+        remult3_1.Fields.boolean(),
+        tslib_1.__metadata("design:type", Object)
+    ], Task.prototype, "completed", void 0);
+    tslib_1.__decorate([
+        server_action_1.BackendMethod({ allowed: false }),
+        tslib_1.__metadata("design:type", Function),
+        tslib_1.__metadata("design:paramtypes", []),
+        tslib_1.__metadata("design:returntype", void 0)
+    ], Task, "testForbidden", null);
+    Task = tslib_1.__decorate([
+        remult3_1.Entity("tasks", {
+            allowApiCrud: true
+        })
+    ], Task);
+    return Task;
+}());
+exports.Task = Task;
+function create3Tasks() {
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var remult, taskRepo, _a, _b, task, e_1_1, _c, _d;
+        var e_1, _e;
+        return tslib_1.__generator(this, function (_f) {
+            switch (_f.label) {
+                case 0:
+                    remult = new context_1.Remult(axios_1.default);
+                    server_action_1.Action.provider = new context_1.HttpProviderBridgeToRestDataProviderHttpProvider(axios_1.default);
+                    taskRepo = remult.repo(Task);
+                    _f.label = 1;
+                case 1:
+                    _f.trys.push([1, 7, 8, 9]);
+                    return [4 /*yield*/, taskRepo.find()];
+                case 2:
+                    _a = tslib_1.__values.apply(void 0, [_f.sent()]), _b = _a.next();
+                    _f.label = 3;
+                case 3:
+                    if (!!_b.done) return [3 /*break*/, 6];
+                    task = _b.value;
+                    return [4 /*yield*/, taskRepo.delete(task)];
+                case 4:
+                    _f.sent();
+                    _f.label = 5;
+                case 5:
+                    _b = _a.next();
+                    return [3 /*break*/, 3];
+                case 6: return [3 /*break*/, 9];
+                case 7:
+                    e_1_1 = _f.sent();
+                    e_1 = { error: e_1_1 };
+                    return [3 /*break*/, 9];
+                case 8:
+                    try {
+                        if (_b && !_b.done && (_e = _a.return)) _e.call(_a);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                    return [7 /*endfinally*/];
+                case 9:
+                    _c = expect;
+                    return [4 /*yield*/, taskRepo.count()];
+                case 10:
+                    _c.apply(void 0, [_f.sent()]).toBe(0);
+                    return [4 /*yield*/, taskRepo.insert([{ title: "a" }, { title: "b", completed: true }, { title: "c" }])];
+                case 11:
+                    _f.sent();
+                    _d = expect;
+                    return [4 /*yield*/, taskRepo.count()];
+                case 12:
+                    _d.apply(void 0, [_f.sent()]).toBe(3);
+                    return [2 /*return*/, taskRepo];
+            }
+        });
+    });
+}

package/src/data-providers/sql-database.js

@@ -178,7 +178,7 @@ var ActualSQLServerDataProvider = /** @class */ (function () {
                         select = _a + _b.sent();
                         _b.label = 3;
                     case 3: return [2 /*return*/, r.execute(select).then(function (r) {
-                            return +r.rows[0].count;
+                            return Number(r.rows[0].count);
                         })];
                 }
             });

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

@@ -1,7 +1,6 @@
 "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) {
@@ -77,7 +76,6 @@ db_tests_setup_1.testAll("test number with null", function (_a) {
                 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: