remult 0.16.5 → 0.17.0-exp.10

package/README.md

@@ -27,6 +27,7 @@
   </a>
 </div>
 
+
 <br/>
 
 <div align="center">
@@ -40,12 +41,12 @@
 
 <a href="https://www.youtube.com/watch?v=rEoScmSVNUE" target="_blank">
   <p align="center">
-    <img src="https://github.com/remult/remult/raw/master/static/images/video-thumbnail.jpg" alt="Video thumbnail" width="320" />
+    <img src="https://github.com/remult/remult/raw/master/static/images/video-thumbnail.jpg" alt="Video thumbnail"  />
   </p>
 </a>
 
 <a href="https://www.youtube.com/watch?v=rEoScmSVNUE" target="_blank">
-  <p align="center">Watch code demo on YouTube here</p>
+  <p align="center">Watch code demo on YouTube here (14 mins)</p>
 </a>
 
 ## What is Remult?

package/esm/remult-express.js

@@ -1,6 +1,5 @@
 import * as express from 'express';
-import { createRemultServer } from './server/expressBridge';
-import { initAsyncHooks } from './server/initAsyncHooks';
+import { createRemultServer } from './server/index';
 export function remultExpress(options) {
     let app = express.Router();
     if (!options) {
@@ -13,7 +12,6 @@ export function remultExpress(options) {
         app.use(express.json({ limit: options.bodySizeLimit }));
         app.use(express.urlencoded({ extended: true, limit: options.bodySizeLimit }));
     }
-    initAsyncHooks();
     const server = createRemultServer(options);
     server.registerRouter(app);
     return Object.assign(app, {

package/esm/remult-fastify.js

@@ -1,5 +1,4 @@
-import { createRemultServer } from './server/expressBridge';
-import { initAsyncHooks } from './server/initAsyncHooks';
+import { createRemultServer } from './server/index';
 export function remultFastify(options) {
     function fastifyHandler(handler) {
         const response = (req, res) => {
@@ -19,7 +18,6 @@ export function remultFastify(options) {
         };
         return response;
     }
-    initAsyncHooks();
     const api = createRemultServer(options);
     const pluginFunction = async (instance, op) => {
         //@ts-ignore

package/esm/remult-fresh.js

@@ -1,6 +1,6 @@
-import { createRemultServer } from "./server/expressBridge";
+import { createRemultServerCore } from "./server/expressBridge";
 export function remultFresh(options, response) {
-    const server = createRemultServer(options);
+    const server = createRemultServerCore(options);
     return {
         getRemult: r => server.getRemult(r),
         openApiDoc: x => server.openApiDoc(x),

package/esm/server/core.d.ts

@@ -0,0 +1,2 @@
+export { queuedJobInfo, QueueStorage, GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, createRemultServerCore, RemultServerOptions, SpecificRoute, RemultServer } from './expressBridge';
+export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';

package/esm/server/core.js

@@ -0,0 +1,2 @@
+export { createRemultServerCore } from './expressBridge';
+export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';

package/esm/server/expressBridge.d.ts

@@ -20,7 +20,7 @@ export interface RemultServerOptions<RequestType extends GenericRequest> {
     controllers?: ClassType<any>[];
     rootPath?: string;
 }
-export declare function createRemultServer<RequestType extends GenericRequest = GenericRequest>(options?: RemultServerOptions<RequestType>): RemultServer;
+export declare function createRemultServerCore<RequestType extends GenericRequest = GenericRequest>(options?: RemultServerOptions<RequestType>): RemultServer;
 export declare type GenericRequestHandler = (req: GenericRequest, res: GenericResponse, next: VoidFunction) => void;
 export interface ServerHandleResponse {
     data?: any;

package/esm/server/expressBridge.js

@@ -6,7 +6,7 @@ import { Entity, Fields, getEntityKey } from '../src/remult3';
 import { IdEntity } from '../src/id-entity';
 import { remult } from '../src/remult-proxy';
 ;
-export function createRemultServer(options) {
+export function createRemultServerCore(options) {
     if (!options) {
         options = {};
     }

package/esm/server/index.d.ts

@@ -1,2 +1,4 @@
-export { queuedJobInfo, QueueStorage, GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, createRemultServer, RemultServerOptions, SpecificRoute, RemultServer } from './expressBridge';
+import { GenericRequest, RemultServer, RemultServerOptions } from './expressBridge';
+export { queuedJobInfo, QueueStorage, GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, RemultServerOptions, SpecificRoute, RemultServer } from './expressBridge';
 export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
+export declare function createRemultServer<RequestType extends GenericRequest = GenericRequest>(options?: RemultServerOptions<RequestType>): RemultServer;

package/esm/server/index.js

@@ -1,2 +1,7 @@
-export { createRemultServer } from './expressBridge';
+import { createRemultServerCore } from './expressBridge';
+import { initAsyncHooks } from './initAsyncHooks';
 export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
+export function createRemultServer(options) {
+    initAsyncHooks();
+    return createRemultServerCore(options);
+}

package/esm/src/shared-tests/db-tests-setup.js

@@ -2,8 +2,9 @@ import { Remult } from "../context";
 import { InMemoryDataProvider } from "../data-providers/in-memory-database";
 import { Categories } from "../tests/remult-3-entities";
 export function itWithFocus(key, what, focus = false) {
-    if (focus)
+    if (focus) {
         fit(key, what);
+    }
     else
         it(key, what);
 }

package/package.json

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

package/remult-express.js

@@ -3,8 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.remultExpress = void 0;
 var tslib_1 = require("tslib");
 var express = require("express");
-var expressBridge_1 = require("./server/expressBridge");
-var initAsyncHooks_1 = require("./server/initAsyncHooks");
+var index_1 = require("./server/index");
 function remultExpress(options) {
     var app = express.Router();
     if (!options) {
@@ -17,8 +16,7 @@ function remultExpress(options) {
         app.use(express.json({ limit: options.bodySizeLimit }));
         app.use(express.urlencoded({ extended: true, limit: options.bodySizeLimit }));
     }
-    initAsyncHooks_1.initAsyncHooks();
-    var server = expressBridge_1.createRemultServer(options);
+    var server = index_1.createRemultServer(options);
     server.registerRouter(app);
     return Object.assign(app, {
         getRemult: function (req) { return server.getRemult(req); },

package/remult-fastify.js

@@ -2,8 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.remultFastify = void 0;
 var tslib_1 = require("tslib");
-var expressBridge_1 = require("./server/expressBridge");
-var initAsyncHooks_1 = require("./server/initAsyncHooks");
+var index_1 = require("./server/index");
 function remultFastify(options) {
     var _this = this;
     function fastifyHandler(handler) {
@@ -24,8 +23,7 @@ function remultFastify(options) {
         };
         return response;
     }
-    initAsyncHooks_1.initAsyncHooks();
-    var api = expressBridge_1.createRemultServer(options);
+    var api = index_1.createRemultServer(options);
     var pluginFunction = function (instance, op) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
         var fastifyRouter;
         return tslib_1.__generator(this, function (_a) {

package/remult-fresh.js

@@ -5,7 +5,7 @@ var tslib_1 = require("tslib");
 var expressBridge_1 = require("./server/expressBridge");
 function remultFresh(options, response) {
     var _this = this;
-    var server = expressBridge_1.createRemultServer(options);
+    var server = expressBridge_1.createRemultServerCore(options);
     return {
         getRemult: function (r) { return server.getRemult(r); },
         openApiDoc: function (x) { return server.openApiDoc(x); },

package/server/core.d.ts

@@ -0,0 +1,2 @@
+export { queuedJobInfo, QueueStorage, GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, createRemultServerCore, RemultServerOptions, SpecificRoute, RemultServer } from './expressBridge';
+export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';

package/server/core.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonFileDataProvider = exports.JsonEntityFileStorage = exports.createRemultServerCore = void 0;
+var expressBridge_1 = require("./expressBridge");
+Object.defineProperty(exports, "createRemultServerCore", { enumerable: true, get: function () { return expressBridge_1.createRemultServerCore; } });
+var JsonEntityFileStorage_1 = require("./JsonEntityFileStorage");
+Object.defineProperty(exports, "JsonEntityFileStorage", { enumerable: true, get: function () { return JsonEntityFileStorage_1.JsonEntityFileStorage; } });
+Object.defineProperty(exports, "JsonFileDataProvider", { enumerable: true, get: function () { return JsonEntityFileStorage_1.JsonFileDataProvider; } });

package/server/expressBridge.d.ts

@@ -20,7 +20,7 @@ export interface RemultServerOptions<RequestType extends GenericRequest> {
     controllers?: ClassType<any>[];
     rootPath?: string;
 }
-export declare function createRemultServer<RequestType extends GenericRequest = GenericRequest>(options?: RemultServerOptions<RequestType>): RemultServer;
+export declare function createRemultServerCore<RequestType extends GenericRequest = GenericRequest>(options?: RemultServerOptions<RequestType>): RemultServer;
 export declare type GenericRequestHandler = (req: GenericRequest, res: GenericResponse, next: VoidFunction) => void;
 export interface ServerHandleResponse {
     data?: any;

package/server/expressBridge.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JobsInQueueEntity = exports.EntityQueueStorage = exports.RemultAsyncLocalStorage = exports.createRemultServer = void 0;
+exports.JobsInQueueEntity = exports.EntityQueueStorage = exports.RemultAsyncLocalStorage = exports.createRemultServerCore = void 0;
 var tslib_1 = require("tslib");
 var server_action_1 = require("../src/server-action");
 var data_api_1 = require("../src/data-api");
@@ -9,7 +9,7 @@ var remult3_1 = require("../src/remult3");
 var id_entity_1 = require("../src/id-entity");
 var remult_proxy_1 = require("../src/remult-proxy");
 ;
-function createRemultServer(options) {
+function createRemultServerCore(options) {
     var _this = this;
     if (!options) {
         options = {};
@@ -85,7 +85,7 @@ function createRemultServer(options) {
     var bridge = new RemultServerImplementation(new inProcessQueueHandler(options.queueStorage), options, dataProvider);
     return bridge;
 }
-exports.createRemultServer = createRemultServer;
+exports.createRemultServerCore = createRemultServerCore;
 ;
 var RemultAsyncLocalStorage = /** @class */ (function () {
     function RemultAsyncLocalStorage(remultObjectStorage) {

package/server/index.d.ts

@@ -1,2 +1,4 @@
-export { queuedJobInfo, QueueStorage, GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, createRemultServer, RemultServerOptions, SpecificRoute, RemultServer } from './expressBridge';
+import { GenericRequest, RemultServer, RemultServerOptions } from './expressBridge';
+export { queuedJobInfo, QueueStorage, GenericRequest, GenericRequestHandler, GenericResponse, GenericRouter, RemultServerOptions, SpecificRoute, RemultServer } from './expressBridge';
 export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
+export declare function createRemultServer<RequestType extends GenericRequest = GenericRequest>(options?: RemultServerOptions<RequestType>): RemultServer;

package/server/index.js

@@ -1,8 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JsonFileDataProvider = exports.JsonEntityFileStorage = exports.createRemultServer = void 0;
+exports.createRemultServer = exports.JsonFileDataProvider = exports.JsonEntityFileStorage = void 0;
 var expressBridge_1 = require("./expressBridge");
-Object.defineProperty(exports, "createRemultServer", { enumerable: true, get: function () { return expressBridge_1.createRemultServer; } });
+var initAsyncHooks_1 = require("./initAsyncHooks");
 var JsonEntityFileStorage_1 = require("./JsonEntityFileStorage");
 Object.defineProperty(exports, "JsonEntityFileStorage", { enumerable: true, get: function () { return JsonEntityFileStorage_1.JsonEntityFileStorage; } });
 Object.defineProperty(exports, "JsonFileDataProvider", { enumerable: true, get: function () { return JsonEntityFileStorage_1.JsonFileDataProvider; } });
+function createRemultServer(options) {
+    initAsyncHooks_1.initAsyncHooks();
+    return expressBridge_1.createRemultServerCore(options);
+}
+exports.createRemultServer = createRemultServer;

package/src/shared-tests/db-tests-setup.js

@@ -7,8 +7,9 @@ var in_memory_database_1 = require("../data-providers/in-memory-database");
 var remult_3_entities_1 = require("../tests/remult-3-entities");
 function itWithFocus(key, what, focus) {
     if (focus === void 0) { focus = false; }
-    if (focus)
+    if (focus) {
         fit(key, what);
+    }
     else
         it(key, what);
 }

package/esm/src/backend-tests/backend-database-test-setup.backend-spec.d.ts

@@ -1,6 +0,0 @@
-import { dbTestWhatSignature } from "../shared-tests/db-tests-setup";
-export declare const testKnexPGSqlImpl: (key: string, what: dbTestWhatSignature, focus?: boolean) => void;
-export declare const mySqlTest: import("../shared-tests/db-tests-setup").dbTestMethodSignature;
-export declare function testPostgresImplementation(key: string, what: dbTestWhatSignature, focus?: boolean): void;
-export declare function testMongo(key: string, what: dbTestWhatSignature, focus?: boolean): void;
-import '../shared-tests';

package/esm/src/backend-tests/backend-database-test-setup.backend-spec.js

@@ -1,123 +0,0 @@
-import { Remult } from "../context";
-import { KnexDataProvider, KnexSchemaBuilder } from '../../remult-knex';
-import * as Knex from 'knex';
-import { MongoClient } from 'mongodb';
-import { config } from 'dotenv';
-import { createPostgresConnection, PostgresSchemaBuilder } from "../../postgres";
-import { addDatabaseToTest, itWithFocus, testAll } from "../shared-tests/db-tests-setup";
-config();
-function testKnexSqlImpl(knex, name) {
-    return (key, what, focus = false) => {
-        itWithFocus(key + " " + name + " - knex", async () => {
-            let db = new KnexDataProvider(knex);
-            let remult = new Remult(db);
-            await what({
-                db, remult,
-                createEntity: async (entity) => {
-                    let repo = remult.repo(entity);
-                    let sb = new KnexSchemaBuilder(knex);
-                    await knex.schema.dropTableIfExists(await repo.metadata.getDbName());
-                    await sb.createIfNotExist(repo.metadata);
-                    await sb.verifyAllColumns(repo.metadata);
-                    await knex(await repo.metadata.getDbName()).delete();
-                    return repo;
-                }
-            });
-        }, focus);
-    };
-}
-export const testKnexPGSqlImpl = testKnexSqlImpl(Knex.default({
-    client: 'pg',
-    connection: process.env.DATABASE_URL,
-}), "postgres");
-addDatabaseToTest(testKnexPGSqlImpl);
-if (process.env['TESTS_SQL_SERVER'])
-    addDatabaseToTest(testKnexSqlImpl(Knex.default({
-        client: 'mssql',
-        connection: {
-            server: '127.0.0.1',
-            database: 'test2',
-            user: 'sa',
-            password: 'MASTERKEY',
-            options: {
-                enableArithAbort: true,
-                encrypt: false,
-                instanceName: 'sqlexpress'
-            }
-        } //,debug: true
-    }), "sql server"));
-if (true)
-    addDatabaseToTest(testKnexSqlImpl(Knex.default({
-        client: 'better-sqlite3',
-        connection: {
-            filename: ":memory:"
-        },
-    }), "sqlite3"));
-export const mySqlTest = addDatabaseToTest(testKnexSqlImpl(Knex.default({
-    client: 'mysql2',
-    connection: {
-        user: 'root',
-        password: 'MASTERKEY',
-        host: '127.0.0.1',
-        database: 'test'
-    }
-    //debug: true
-}), "mysql2"));
-let pg = createPostgresConnection({
-    autoCreateTables: false
-});
-export function testPostgresImplementation(key, what, focus = false) {
-    itWithFocus(key + " - postgres", async () => {
-        let db = await pg;
-        let remult = new Remult(db);
-        await what({
-            db, remult,
-            createEntity: async (entity) => {
-                let repo = remult.repo(entity);
-                let sb = new PostgresSchemaBuilder(db);
-                await db.execute("drop table if exists " + await repo.metadata.getDbName());
-                await sb.createIfNotExist(repo.metadata);
-                await sb.verifyAllColumns(repo.metadata);
-                await db.execute("delete from " + await repo.metadata.getDbName());
-                return repo;
-            }
-        });
-    }, focus);
-}
-addDatabaseToTest(testPostgresImplementation);
-import { Categories } from "../tests/remult-3-entities";
-import { MongoDataProvider } from "../../remult-mongo";
-testAll("transactions", async ({ db, createEntity }) => {
-    let x = await createEntity(Categories);
-    await db.transaction(async (db) => {
-        let remult = new Remult(db);
-        expect(await remult.repo(Categories).count()).toBe(0);
-    });
-});
-let client = new MongoClient("mongodb://localhost:27017/local");
-let done;
-let mongoDbPromise = client.connect().then(c => {
-    done = c;
-    return c.db("test");
-});
-afterAll(async () => {
-    if (done)
-        done.close();
-});
-export function testMongo(key, what, focus = false) {
-    itWithFocus(key + " - mongo", async () => {
-        let mongoDb = await mongoDbPromise;
-        let db = new MongoDataProvider(mongoDb, client);
-        let remult = new Remult(db);
-        await what({
-            db, remult,
-            createEntity: async (entity) => {
-                let repo = remult.repo(entity);
-                await mongoDb.collection(await repo.metadata.getDbName()).deleteMany({});
-                return repo;
-            }
-        });
-    }, focus);
-}
-addDatabaseToTest(testMongo);
-import '../shared-tests';

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

@@ -1 +0,0 @@
-export {};

package/esm/src/backend-tests/my-test.backend-spec.js

@@ -1,107 +0,0 @@
-import { Remult } from "../context";
-import { KnexDataProvider } from '../../remult-knex';
-import { config } from 'dotenv';
-import { testKnexPGSqlImpl, testPostgresImplementation } from "./backend-database-test-setup.backend-spec";
-import { entityWithValidations } from "../shared-tests/entityWithValidations";
-import { SqlDatabase } from "../data-providers/sql-database";
-import { RemultAsyncLocalStorage } from "../../server/expressBridge";
-import { initAsyncHooks } from "../../server/initAsyncHooks";
-import { remult } from "../remult-proxy";
-config();
-testPostgresImplementation("default order by", async ({ createEntity }) => {
-    let s = await entityWithValidations.create4RowsInDp(createEntity);
-    await s.update(1, { name: "updated name" });
-    expect((await s.find()).map(x => x.myId)).toEqual([1, 2, 3, 4]);
-}, false);
-testKnexPGSqlImpl("default order by", async ({ createEntity }) => {
-    let s = await entityWithValidations.create4RowsInDp(createEntity);
-    await s.update(1, { name: "updated name" });
-    expect((await s.find()).map(x => x.myId)).toEqual([1, 2, 3, 4]);
-}, false);
-testPostgresImplementation("sql filter", async ({ createEntity }) => {
-    let s = await entityWithValidations.create4RowsInDp(createEntity);
-    expect((await s.find({
-        where: SqlDatabase.customFilter(async (build) => {
-            build.sql = s.metadata.fields.myId.options.dbName + ' in (1,3)';
-        })
-    })).length).toBe(2);
-}, false);
-testPostgresImplementation("sql filter2", async ({ createEntity }) => {
-    let s = await entityWithValidations.create4RowsInDp(createEntity);
-    expect((await s.find({
-        where: {
-            $or: [
-                SqlDatabase.customFilter(async (build) => {
-                    build.sql = s.metadata.fields.myId.options.dbName + ' in (1,3)';
-                }),
-                {
-                    myId: 2
-                }
-            ]
-        }
-    })).length).toBe(3);
-}, false);
-testKnexPGSqlImpl("knex filter", async ({ createEntity }) => {
-    let s = await entityWithValidations.create4RowsInDp(createEntity);
-    expect((await s.find({
-        where: KnexDataProvider.customFilter(async () => {
-            return build => build.whereIn(s.metadata.fields.myId.options.dbName, [1, 3]);
-        })
-    })).length).toBe(2);
-}, false);
-testKnexPGSqlImpl("knex filter2", async ({ createEntity }) => {
-    let s = await entityWithValidations.create4RowsInDp(createEntity);
-    expect((await s.find({
-        where: {
-            $or: [KnexDataProvider.customFilter(async () => {
-                    return build => build.whereIn(s.metadata.fields.myId.options.dbName, [1, 3]);
-                }), {
-                    myId: 4
-                }]
-        }
-    })).length).toBe(3);
-}, false);
-it("test async hooks and static remult", async () => {
-    let gotException = true;
-    try {
-        RemultAsyncLocalStorage.instance.getRemult();
-        gotException = false;
-    }
-    catch { }
-    expect(gotException).toBe(true);
-    initAsyncHooks();
-    expect(RemultAsyncLocalStorage.instance.getRemult()).toBe(undefined);
-    RemultAsyncLocalStorage.enable();
-    try {
-        remult.isAllowed(false);
-        gotException = false;
-    }
-    catch { }
-    expect(gotException).toBe(true);
-    const promises = [];
-    RemultAsyncLocalStorage.instance.run(new Remult(), () => {
-        remult.user = { id: 'noam' };
-        promises.push(new Promise(res => {
-            setTimeout(() => {
-                expect(remult.user.id).toBe('noam');
-                res({});
-            }, 10);
-        }));
-        RemultAsyncLocalStorage.instance.run(new Remult(), () => {
-            remult.user = { id: 'yoni' };
-            promises.push(new Promise(res => {
-                setTimeout(() => {
-                    expect(remult.user.id).toBe('yoni');
-                    res({});
-                }, 10);
-            }));
-        });
-        promises.push(new Promise(res => {
-            setTimeout(() => {
-                expect(remult.user.id).toBe('noam');
-                res({});
-            }, 10);
-        }));
-    });
-    await Promise.all(promises);
-});

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

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