remult 0.21.1 → 0.22.0

package/esm/server/index.d.ts

@@ -1,6 +1,6 @@
 import { RemultServer, RemultServerOptions, ServerCoreOptions } from './expressBridge';
-export { queuedJobInfo, QueueStorage, GenericRequestInfo, GenericRequestHandler, RemultServerCore, GenericResponse, GenericRouter, RemultServerOptions, SpecificRoute, RemultServer, InitRequestOptions } from './expressBridge';
-export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
+export { queuedJobInfo, QueueStorage, GenericRequestInfo, GenericRequestHandler, RemultServerCore, GenericResponse, GenericRouter, RemultServerOptions, SpecificRoute, RemultServer, InitRequestOptions, } from './expressBridge';
+export { JsonEntityFileStorage, JsonFileDataProvider, } from './JsonEntityFileStorage';
 export { DataProviderLiveQueryStorage } from '../live-query/data-provider-live-query-storage';
 export { SseSubscriptionServer } from '../SseSubscriptionServer';
 export declare function createRemultServer<RequestType>(options: RemultServerOptions<RequestType>, serverCoreOptions?: ServerCoreOptions<RequestType>): RemultServer<RequestType>;

package/esm/server/index.js

@@ -1,9 +1,12 @@
 import { createRemultServerCore, } from './expressBridge';
 import { initAsyncHooks } from './initAsyncHooks';
-export { JsonEntityFileStorage, JsonFileDataProvider } from './JsonEntityFileStorage';
+export { JsonEntityFileStorage, JsonFileDataProvider, } from './JsonEntityFileStorage';
 export { DataProviderLiveQueryStorage } from '../live-query/data-provider-live-query-storage';
 export { SseSubscriptionServer } from '../SseSubscriptionServer';
 export function createRemultServer(options, serverCoreOptions) {
     initAsyncHooks();
-    return createRemultServerCore(options, serverCoreOptions || { buildGenericRequestInfo: req => req, getRequestBody: async (req) => req.body });
+    return createRemultServerCore(options, serverCoreOptions || {
+        buildGenericRequestInfo: (req) => req,
+        getRequestBody: async (req) => req.body,
+    });
 }

package/esm/server/initAsyncHooks.js

@@ -1,5 +1,5 @@
 import { AsyncLocalStorage } from 'async_hooks';
-import { RemultAsyncLocalStorage } from './expressBridge';
+import { RemultAsyncLocalStorage } from '../src/context';
 let init = false;
 export function initAsyncHooks() {
     if (init)

package/esm/server/initDataProvider.js

@@ -1,6 +1,6 @@
 export function initDataProvider(optionsDataProvider) {
     let dataProvider;
-    if (typeof optionsDataProvider === "function") {
+    if (typeof optionsDataProvider === 'function') {
         dataProvider = optionsDataProvider();
     }
     else

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

@@ -1,4 +1,4 @@
-import { dbTestWhatSignature } from "../shared-tests/db-tests-setup";
+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;

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

@@ -1,28 +1,29 @@
-import { Remult } from "../context";
+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, TestDbs } from "../shared-tests/db-tests-setup";
-import { describeClass } from "../remult3/DecoratorReplacer";
-import { Entity, Fields } from "../remult3";
+import { createPostgresConnection, PostgresSchemaBuilder, } from '../../postgres';
+import { addDatabaseToTest, itWithFocus, testAll, TestDbs, } from '../shared-tests/db-tests-setup';
+import { describeClass } from '../remult3/DecoratorReplacer';
+import { Entity, Fields } from '../remult3';
 KnexSchemaBuilder.logToConsole = false;
 PostgresSchemaBuilder.logToConsole = false;
 config();
 function testKnexSqlImpl(knex, name) {
     return (key, what, focus = false) => {
-        itWithFocus(key + " " + name + " - knex", async () => {
+        itWithFocus(key + ' ' + name + ' - knex', async () => {
             let db = new KnexDataProvider(knex);
             let remult = new Remult(db);
             await what({
-                db, remult,
+                db,
+                remult,
                 createEntity: async (entity) => {
                     let repo = remult.repo(entity);
                     await knex.schema.dropTableIfExists(await repo.metadata.getDbName());
                     await db.ensureSchema([repo.metadata]);
                     return repo;
-                }
+                },
             });
         }, focus);
     };
@@ -30,7 +31,7 @@ function testKnexSqlImpl(knex, name) {
 export const testKnexPGSqlImpl = testKnexSqlImpl(Knex.default({
     client: 'pg',
     connection: process.env.DATABASE_URL,
-}), "postgres");
+}), 'postgres');
 addDatabaseToTest(testKnexPGSqlImpl);
 if (process.env['TESTS_SQL_SERVER'])
     addDatabaseToTest(testKnexSqlImpl(Knex.default({
@@ -43,47 +44,47 @@ if (process.env['TESTS_SQL_SERVER'])
             options: {
                 enableArithAbort: true,
                 encrypt: false,
-                instanceName: 'sqlexpress'
-            }
-        } //,debug: true
-    }), "sql server"));
+                instanceName: 'sqlexpress',
+            },
+        },
+    }), 'sql server'));
 if (true)
     addDatabaseToTest(testKnexSqlImpl(Knex.default({
         client: 'better-sqlite3',
         connection: {
-            filename: ":memory:"
+            filename: ':memory:',
         },
-    }), "sqlite3"));
+    }), '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"));
+        database: 'test',
+    },
+}), 'mysql2'));
 let pg = createPostgresConnection();
 export function testPostgresImplementation(key, what, focus = false) {
-    itWithFocus(key + " - postgres", async () => {
+    itWithFocus(key + ' - postgres', async () => {
         let db = await pg;
         let remult = new Remult(db);
         await what({
-            db, remult,
+            db,
+            remult,
             createEntity: async (entity) => {
                 let repo = remult.repo(entity);
-                await db.execute("drop table if exists " + await repo.metadata.getDbName());
+                await db.execute('drop table if exists ' + (await repo.metadata.getDbName()));
                 await db.ensureSchema([repo.metadata]);
                 return repo;
-            }
+            },
         });
     }, focus);
 }
 addDatabaseToTest(testPostgresImplementation);
-import { Categories } from "../tests/remult-3-entities";
-import { MongoDataProvider } from "../../remult-mongo";
-testAll("transactions", async ({ db, createEntity }) => {
+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);
@@ -93,35 +94,40 @@ testAll("transactions", async ({ db, createEntity }) => {
 const mongoConnectionString = process.env['MONGO_TEST_URL']; //"mongodb://localhost:27017/local"
 let client = new MongoClient(mongoConnectionString);
 let done;
-let mongoDbPromise = client.connect().then(c => {
+let mongoDbPromise = client.connect().then((c) => {
     done = c;
-    return c.db("test");
+    return c.db('test');
 });
 afterAll(async () => {
     if (done)
         done.close();
 });
 export function testMongo(key, what, focus = false) {
-    itWithFocus(key + " - mongo", async () => {
+    itWithFocus(key + ' - mongo', async () => {
         let mongoDb = await mongoDbPromise;
         let db = new MongoDataProvider(mongoDb, client);
         let remult = new Remult(db);
         await what({
-            db, remult,
+            db,
+            remult,
             createEntity: async (entity) => {
                 let repo = remult.repo(entity);
-                await mongoDb.collection(await repo.metadata.getDbName()).deleteMany({});
+                await mongoDb
+                    .collection(await repo.metadata.getDbName())
+                    .deleteMany({});
                 return repo;
-            }
+            },
         });
     }, focus);
 }
 addDatabaseToTest(testMongo, TestDbs.mongo);
-it("test mongo without transaction", async () => {
-    const client = new MongoClient("mongodb://localhost:27017/local");
+it('test mongo without transaction', async () => {
+    const client = new MongoClient('mongodb://localhost:27017/local');
     await client.connect();
     const mongoDb = client.db('test');
-    const db = new MongoDataProvider(mongoDb, client, { disableTransactions: true });
+    const db = new MongoDataProvider(mongoDb, client, {
+        disableTransactions: true,
+    });
     var remult = new Remult(db);
     const entity = class {
         constructor() {
@@ -129,15 +135,18 @@ it("test mongo without transaction", async () => {
             this.title = '';
         }
     };
-    describeClass(entity, Entity("testNoTrans"), { id: Fields.number(), title: Fields.string() });
+    describeClass(entity, Entity('testNoTrans'), {
+        id: Fields.number(),
+        title: Fields.string(),
+    });
     const repo = remult.repo(entity);
     for (const item of await repo.find()) {
         await repo.delete(item);
     }
-    await repo.insert({ id: 1, title: "a" });
+    await repo.insert({ id: 1, title: 'a' });
     try {
         await db.transaction(async () => {
-            await repo.insert({ id: 2, title: "b" });
+            await repo.insert({ id: 2, title: 'b' });
             throw new Error();
         });
     }

package/esm/src/buildRestDataProvider.d.ts

@@ -1,4 +1,4 @@
-import { RestDataProviderHttpProvider } from "./data-interfaces";
+import { RestDataProviderHttpProvider } from './data-interfaces';
 import { RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider';
 export declare function buildRestDataProvider(provider: ExternalHttpProvider | typeof fetch): RestDataProviderHttpProviderUsingFetch | RestDataProviderHttpProvider;
 export declare function isExternalHttpProvider(item: any): boolean;

package/esm/src/buildRestDataProvider.js

@@ -9,7 +9,7 @@ export function buildRestDataProvider(provider) {
         }
     }
     if (!httpDataProvider) {
-        if (typeof provider === "function") {
+        if (typeof provider === 'function') {
             httpDataProvider = new RestDataProviderHttpProviderUsingFetch(provider);
         }
     }
@@ -45,11 +45,12 @@ export async function retry(what) {
             return await what();
         }
         catch (err) {
-            if ((err.message?.startsWith("Error occurred while trying to proxy") ||
-                err.message?.startsWith("Error occured while trying to proxy") ||
-                err.message?.includes("http proxy error") ||
-                err.message?.startsWith("Gateway Timeout") ||
-                err.status == 500) && i++ < 50) {
+            if ((err.message?.startsWith('Error occurred while trying to proxy') ||
+                err.message?.startsWith('Error occured while trying to proxy') ||
+                err.message?.includes('http proxy error') ||
+                err.message?.startsWith('Gateway Timeout') ||
+                err.status == 500) &&
+                i++ < 50) {
                 await new Promise((res, req) => {
                     setTimeout(() => {
                         res({});
@@ -63,17 +64,24 @@ export async function retry(what) {
 }
 export function toPromise(p) {
     let r;
-    if (p["toPromise"] !== undefined) {
-        r = p["toPromise"]();
+    if (p['toPromise'] !== undefined) {
+        r = p['toPromise']();
     }
     //@ts-ignore
     else
         r = p;
-    return r.then((x) => {
-        if (x && (x.status == 200 || x.status == 201) && x.headers && x.request && x.data) //for axios
+    return r
+        .then((x) => {
+        if (x &&
+            (x.status == 200 || x.status == 201) &&
+            x.headers &&
+            x.request &&
+            x.data)
+            //for axios
             return x.data;
         return x;
-    }).catch(async (ex) => {
+    })
+        .catch(async (ex) => {
         throw await processHttpException(ex);
     });
 }
@@ -83,7 +91,7 @@ export async function processHttpException(ex) {
     if (z.error)
         error = z.error;
     else if (z.isAxiosError) {
-        if (typeof z.response?.data === "string")
+        if (typeof z.response?.data === 'string')
             error = z.response.data;
         else
             error = z?.response?.data;
@@ -91,7 +99,7 @@ export async function processHttpException(ex) {
     if (!error)
         error = z.message;
     if (z.status == 0 && z.error.isTrusted)
-        error = "Network Error";
+        error = 'Network Error';
     if (typeof error === 'string') {
         error = {
             message: error,

package/esm/src/column-interfaces.d.ts

@@ -3,9 +3,9 @@ import { Allowed, AllowedForInstance } from './context';
 import { EntityMetadata, FieldRef, OmitEB } from './remult3';
 export interface FieldOptions<entityType = any, valueType = any> {
     /** A human readable name for the field. Can be used to achieve a consistent caption for a field throughout the app
-    * @example
-    * <input placeholder={taskRepo.metadata.fields.title.caption}/>
-    */
+     * @example
+     * <input placeholder={taskRepo.metadata.fields.title.caption}/>
+     */
     caption?: string;
     /** If it can store null in the database */
     allowNull?: boolean;
@@ -13,7 +13,7 @@ export interface FieldOptions<entityType = any, valueType = any> {
      * @see [allowed](http://remult.dev/docs/allowed.html)*/
     includeInApi?: Allowed;
     /** If this field data can be updated in the api.
-    * @see [allowed](http://remult.dev/docs/allowed.html)*/
+     * @see [allowed](http://remult.dev/docs/allowed.html)*/
     allowApiUpdate?: AllowedForInstance<entityType>;
     /** An arrow function that'll be used to perform validations on it
      * @example
@@ -35,9 +35,9 @@ export interface FieldOptions<entityType = any, valueType = any> {
      *   }
      * })
      */
-    validate?: ((entity: entityType, fieldRef: FieldRef<entityType, valueType>) => (any | Promise<any>)) | ((entity: entityType, fieldRef: FieldRef<entityType, valueType>) => (any | Promise<any>))[];
+    validate?: ((entity: entityType, fieldRef: FieldRef<entityType, valueType>) => any | Promise<any>) | ((entity: entityType, fieldRef: FieldRef<entityType, valueType>) => any | Promise<any>)[];
     /** Will be fired before this field is saved to the server/database */
-    saving?: ((entity: entityType, fieldRef: FieldRef<entityType, valueType>) => (any | Promise<any>));
+    saving?: (entity: entityType, fieldRef: FieldRef<entityType, valueType>) => any | Promise<any>;
     /**  An expression that will determine this fields value on the backend and be provided to the front end*/
     serverExpression?: (entity: entityType) => valueType | Promise<valueType>;
     /** The name of the column in the database that holds the data for this field. If no name is set, the key will be used instead. */
@@ -51,7 +51,7 @@ export interface FieldOptions<entityType = any, valueType = any> {
      * titleLength = 0;
      * @Fields.string()
      * title='';
-    */
+     */
     sqlExpression?: string | ((entity: EntityMetadata<entityType>) => string | Promise<string>);
     /** For fields that shouldn't be part of an update or insert statement */
     dbReadOnly?: boolean;
@@ -100,7 +100,7 @@ export interface FieldMetadata<valueType = any, entityType = any> {
      * @example
      * const taskRepo = remult.repo(Task);
      * Task == taskRepo.metadata.fields.title.target //will return true
-    */
+     */
     readonly target: ClassType<valueType>;
     /** Returns the dbName - based on it's `dbName` option and it's `sqlExpression` option */
     getDbName(): Promise<string>;
@@ -113,7 +113,7 @@ export interface FieldMetadata<valueType = any, entityType = any> {
     /** Get the display value for a specific item
      * @example
      * repo.fields.createDate.displayValue(task) //will display the date as defined in the `displayValue` option defined for it.
-    */
+     */
     displayValue(item: Partial<OmitEB<entityType>>): string;
     apiUpdateAllowed(item?: Partial<OmitEB<entityType>>): boolean;
     readonly includedInApi: boolean;

package/esm/src/column.d.ts

@@ -31,9 +31,13 @@ export declare class CompoundIdField implements FieldMetadata<string> {
 export declare class LookupColumn<T> {
     private repository;
     id: idType<T>;
+    toJson(): any;
     setId(val: any): void;
     waitLoadOf(id: any): Promise<T>;
     get(id: any): any;
+    storedItem: {
+        item: T;
+    };
     set(item: T): void;
     constructor(repository: RepositoryImplementation<T>, id: idType<T>);
     get item(): T;

package/esm/src/column.js

@@ -1,11 +1,14 @@
 import { assign } from '../assign';
 import { Filter } from './filter/filter-interfaces';
-import { getEntityRef, __updateEntityBasedOnWhere } from './remult3';
+import { getEntityRef, __updateEntityBasedOnWhere, } from './remult3';
 export function makeTitle(name) {
     // insert a space before all caps
-    return name.replace(/([A-Z])/g, ' $1')
+    return (name
+        .replace(/([A-Z])/g, ' $1')
         // uppercase the first character
-        .replace(/^./, (str) => str.toUpperCase()).replace('Email', 'eMail').replace(" I D", " ID");
+        .replace(/^./, (str) => str.toUpperCase())
+        .replace('Email', 'eMail')
+        .replace(' I D', ' ID'));
 }
 export class CompoundIdField {
     constructor(...columns) {
@@ -24,11 +27,11 @@ export class CompoundIdField {
         throw new Error('Method not implemented.');
     }
     getDbName() {
-        return Promise.resolve("");
+        return Promise.resolve('');
     }
     getId(instance) {
-        let r = "";
-        this.fields.forEach(c => {
+        let r = '';
+        this.fields.forEach((c) => {
             if (r.length > 0)
                 r += ',';
             r += instance[c.key];
@@ -36,7 +39,7 @@ export class CompoundIdField {
         return r;
     }
     get valueConverter() {
-        throw new Error("cant get value converter of compound id");
+        throw new Error('cant get value converter of compound id');
     }
     isEqualTo(value) {
         let result = {};
@@ -48,7 +51,7 @@ export class CompoundIdField {
         return result;
     }
     resultIdFilter(id, data) {
-        return new Filter(add => {
+        return new Filter((add) => {
             let idParts = [];
             if (id != undefined)
                 idParts = id.split(',');
@@ -68,6 +71,11 @@ export class LookupColumn {
         this.repository = repository;
         this.id = id;
     }
+    toJson() {
+        if (this.item === null)
+            return null;
+        return this.repository.toJson(this.item);
+    }
     setId(val) {
         if (this.repository.metadata.idMetadata.field.valueType == Number)
             val = +val;
@@ -84,8 +92,9 @@ export class LookupColumn {
         return this.repository.getCachedById(id);
     }
     set(item) {
+        this.storedItem = undefined;
         if (item) {
-            if (typeof item === "string" || typeof item === "number")
+            if (typeof item === 'string' || typeof item === 'number')
                 this.id = item;
             else {
                 let eo = getEntityRef(item, false);
@@ -94,6 +103,7 @@ export class LookupColumn {
                     this.id = eo.getId();
                 }
                 else {
+                    this.storedItem = { item };
                     this.id = item[this.repository.metadata.idMetadata.field.key];
                 }
             }
@@ -106,6 +116,8 @@ export class LookupColumn {
         }
     }
     get item() {
+        if (this.storedItem)
+            return this.storedItem.item;
         return this.get(this.id);
     }
     async waitLoad() {
@@ -127,11 +139,11 @@ export class OneToMany {
             return this._currentPromise;
         if (this._items === undefined)
             this._items = [];
-        return this._currentPromise = this.find().then(x => {
+        return (this._currentPromise = this.find().then((x) => {
             this._items.splice(0);
             this._items.push(...x);
             return this._items;
-        });
+        }));
     }
     async find() {
         return this.provider.find(this.settings);

package/esm/src/context.d.ts

@@ -1,9 +1,18 @@
-import { DataProvider } from "./data-interfaces";
-import { EntityMetadata, EntityRef, FindOptions, Repository } from "./remult3";
-import { ClassType } from "../classType";
-import type { SubscriptionServer } from "./live-query/SubscriptionServer";
-import { ExternalHttpProvider } from "./buildRestDataProvider";
-import { SubscriptionClient, Unsubscribe } from "./live-query/SubscriptionChannel";
+import { DataProvider } from './data-interfaces';
+import { EntityMetadata, EntityRef, FindOptions, Repository } from './remult3';
+import { ClassType } from '../classType';
+import type { SubscriptionServer } from './live-query/SubscriptionServer';
+import { ExternalHttpProvider } from './buildRestDataProvider';
+import { SubscriptionClient, Unsubscribe } from './live-query/SubscriptionChannel';
+export declare class RemultAsyncLocalStorage {
+    private readonly remultObjectStorage;
+    static enable(): void;
+    static disable(): void;
+    constructor(remultObjectStorage: import('async_hooks').AsyncLocalStorage<Remult>);
+    run(remult: Remult, callback: VoidFunction): void;
+    getRemult(): Remult;
+    static instance: RemultAsyncLocalStorage;
+}
 export declare function isBackend(): boolean;
 export declare class Remult {
     /**Return's a `Repository` of the specific entity type
@@ -48,8 +57,8 @@ export declare class Remult {
      * @param backendMethod - the backend method to call
      * @param classInstance - the class instance of the backend method, for static backend methods use undefined
      * @param args - the arguments to send to the backend method
-    */
-    call<T extends ((...args: any[]) => Promise<any>)>(backendMethod: T, classInstance?: any, ...args: GetArguments<T>): ReturnType<T>;
+     */
+    call<T extends (...args: any[]) => Promise<any>>(backendMethod: T, classInstance?: any, ...args: GetArguments<T>): ReturnType<T>;
     /** A helper callback that can be used to debug and trace all find operations. Useful in debugging scenarios */
     static onFind: (metadata: EntityMetadata, options: FindOptions<any>) => void;
     clearAllCache(): any;
@@ -59,6 +68,9 @@ export declare class Remult {
     readonly context: RemultContext;
     /** The api client that will be used by `remult` to perform calls to the `api` */
     apiClient: ApiClient;
+    static run<T>(callback: () => T, options: {
+        dataProvider: DataProvider;
+    }): T;
 }
 export declare type GetArguments<T> = T extends (...args: infer FirstArgument) => any ? FirstArgument : never;
 export interface RemultContext {