remult 0.26.11 → 0.26.12-next.1

package/esm/live-query/data-provider-live-query-storage.js

@@ -1,15 +1,15 @@
 import { __decorate, __metadata } from "tslib";
-import { initDataProvider } from '../server/initDataProvider.js';
 import { Remult } from '../src/context.js';
 import { EntityBase } from '../src/remult3/RepositoryImplementation.js';
 import { Fields } from '../src/remult3/Fields.js';
 import { Entity } from '../src/remult3/entity.js';
 import { remultStatic } from '../src/remult-static.js';
+import { initDataProviderOrJson } from '../server/initDataProviderOrJson';
 export class DataProviderLiveQueryStorage {
     repo;
     dataProvider;
     constructor(dataProvider) {
-        this.dataProvider = initDataProvider(dataProvider);
+        this.dataProvider = initDataProviderOrJson(dataProvider);
         this.repo = this.dataProvider.then((dp) => new Remult(dp).repo(LiveQueryStorageEntity));
     }
     async ensureSchema() {

package/esm/migrations/generate-migrations.js

@@ -4,7 +4,7 @@ import { compareMigrationSnapshot, emptySnapshot, } from './compare-migration-sn
 import { updateMigrationsFile } from './update-migrations-ts-file.js';
 import { DefaultMigrationBuilder, } from './migration-types.js';
 import { isOfType } from '../src/isOfType.js';
-import { initDataProvider } from '../server/initDataProvider.js';
+import { initDataProviderOrJson } from '../server/initDataProviderOrJson';
 /**
  * Generates migration scripts based on changes in entities.
  *
@@ -21,7 +21,7 @@ export async function generateMigrations(options) {
     const migrationDir = options.migrationsFolder || path.join(process.cwd(), 'src/migrations');
     const snapshotFileName = options.snapshotFile || path.join(migrationDir, 'migrations-snapshot.json');
     const migrationsTSFilename = options.migrationsTSFile || path.join(migrationDir, 'migrations.ts');
-    const dataProvider = await initDataProvider(options.dataProvider);
+    const dataProvider = await initDataProviderOrJson(options.dataProvider);
     for (const p of [snapshotFileName, migrationsTSFilename]) {
         if (!fs.existsSync(path.dirname(p))) {
             fs.mkdirSync(path.dirname(p), { recursive: true });

package/esm/migrations/migrate.js

@@ -1,6 +1,6 @@
 import { __decorate, __metadata } from "tslib";
 import { Entity, IdEntity, Fields, remult, Remult, } from '../index.js';
-import { initDataProvider } from '../server/initDataProvider.js';
+import { initDataProviderOrJson } from '../server/initDataProviderOrJson';
 import { doTransaction } from '../src/context.js';
 import { cast, isOfType } from '../src/isOfType.js';
 /**
@@ -17,7 +17,7 @@ import { cast, isOfType } from '../src/isOfType.js';
  */
 export async function migrate(options) {
     let migrationTableName = options.migrationsTable || '__remult_migrations_version';
-    const dataProvider = await initDataProvider(options.dataProvider);
+    const dataProvider = await initDataProviderOrJson(options.dataProvider);
     const prev = remult.dataProvider;
     remult.dataProvider = dataProvider;
     try {

package/esm/remult-next.js

@@ -118,6 +118,6 @@ export function remultNextApp(options) {
         POST: handler,
         PUT: handler,
         DELETE: handler,
-        withRemult: (what) => result.withRemultAsync({}, what),
+        withRemult: (what, disableInitUserAndRequest) => result.withRemultAsync(disableInitUserAndRequest ? undefined : {}, what),
     };
 }

package/esm/remult-solid-start.js

@@ -86,8 +86,8 @@ export function remultSolidStart(options) {
     return Object.assign(handler, {
         getRemult: (req) => result.getRemult(req),
         openApiDoc: (options) => result.openApiDoc(options),
-        async withRemult(what) {
-            return result.withRemultAsync(await getRequestEvent(), what);
+        async withRemult(what, disableInitUserAndRequest) {
+            return result.withRemultAsync(disableInitUserAndRequest ? undefined : await getRequestEvent(), what);
         },
         GET: serverHandler,
         PUT: serverHandler,

package/esm/server/JsonEntityFileStorage.js

@@ -22,6 +22,6 @@ export class JsonEntityFileStorage {
 }
 export class JsonFileDataProvider extends JsonDataProvider {
     constructor(folderPath) {
-        super(new JsonEntityFileStorage(folderPath));
+        super(new JsonEntityFileStorage(folderPath), true);
     }
 }

package/esm/server/initDataProvider.js

@@ -1,4 +1,5 @@
-export function initDataProvider(optionsDataProvider) {
+import { remultStatic } from '../src/remult-static';
+export function initDataProvider(optionsDataProvider, useStaticDefault, defaultDataProvider) {
     let dataProvider;
     if (typeof optionsDataProvider === 'function') {
         dataProvider = optionsDataProvider();
@@ -8,7 +9,11 @@ export function initDataProvider(optionsDataProvider) {
     dataProvider = dataProvider.then(async (dp) => {
         if (dp)
             return dp;
-        return new (await import('./JsonEntityFileStorage.js')).JsonFileDataProvider('./db');
+        if (useStaticDefault)
+            dp = await remultStatic.defaultDataProvider();
+        if (dp)
+            return dp;
+        return defaultDataProvider?.();
     });
     return dataProvider;
 }

package/esm/server/initDataProviderOrJson.js

@@ -0,0 +1,6 @@
+import { initDataProvider } from './initDataProvider';
+export function initDataProviderOrJson(dataProvider) {
+    return initDataProvider(dataProvider, false, async () => {
+        return new (await import('./JsonEntityFileStorage.js')).JsonFileDataProvider('./db');
+    });
+}

package/esm/server/remult-api-server.js

@@ -10,10 +10,10 @@ import { Entity } from '../src/remult3/entity.js';
 import { getEntityKey } from '../src/remult3/getEntityRef.js';
 import { Action, classBackendMethodsArray } from '../src/server-action.js';
 import { serverActionField } from '../src/server-action-info.js';
-import { initDataProvider } from './initDataProvider.js';
 import { remultStatic } from '../src/remult-static.js';
 import remultAdminHtml from './remult-admin.js';
 import { isOfType } from '../src/isOfType.js';
+import { initDataProviderOrJson } from './initDataProviderOrJson';
 export function createRemultServerCore(options, serverCoreOptions) {
     if (!options) {
         options = {};
@@ -30,7 +30,8 @@ export function createRemultServerCore(options, serverCoreOptions) {
     if (!options.queueStorage) {
         options.queueStorage = new InMemoryQueueStorage();
     }
-    let dataProvider = initDataProvider(options.dataProvider);
+    let dataProvider = initDataProviderOrJson(options.dataProvider);
+    remultStatic.defaultDataProvider = () => dataProvider;
     if (options.ensureSchema === undefined)
         options.ensureSchema = true;
     RemultAsyncLocalStorage.enable();
@@ -104,15 +105,20 @@ export class RemultServerImplementation {
     withRemultAsync(request, what) {
         if (!request)
             return this.runWithRemult(what);
-        return new Promise((resolve, error) => {
-            return this.withRemult(request, undefined, () => {
-                try {
-                    what().then(resolve).catch(error);
-                }
-                catch (err) {
-                    error(err);
-                }
-            });
+        return new Promise(async (resolve, error) => {
+            try {
+                return await this.withRemult(request, undefined, async () => {
+                    try {
+                        what().then(resolve).catch(error);
+                    }
+                    catch (err) {
+                        error(err);
+                    }
+                });
+            }
+            catch (err) {
+                error(err);
+            }
         });
     }
     getEntities() {
@@ -145,9 +151,9 @@ export class RemultServerImplementation {
         throw new Error("Couldn't find entity " + entityKey);
     };
     subscriptionServer;
-    withRemult = (req, res, next) => {
-        this.process(async () => {
-            next();
+    withRemult = async (req, res, next) => {
+        await this.process(async () => {
+            await next();
         })(req, res);
     };
     routeImpl;
@@ -277,6 +283,8 @@ export class RemultServerImplementation {
             x.subscriptionServer = this.subscriptionServer;
             x.liveQueryStorage = this.liveQueryStorage;
             return await what(x);
+        }, {
+            dataProvider,
         });
     }
     process(what) {
@@ -291,38 +299,50 @@ export class RemultServerImplementation {
                 if (!genReq.params)
                     genReq.params = req['_tempParams'];
             }
-            let myReq = new ExpressRequestBridgeToDataApiRequest(genReq);
-            let myRes = new ExpressResponseBridgeToDataApiResponse(origRes, req, this.options.error);
+            let myReq = new RequestBridgeToDataApiRequest(genReq);
+            let myRes = new ResponseBridgeToDataApiResponse(origRes, req, this.options.error);
             try {
-                await this.runWithRemult(async (remult) => {
-                    if (req) {
-                        let user;
-                        if (this.options.getUser)
-                            user = await this.options.getUser(req);
-                        else {
-                            user = req['user'];
-                            if (!user)
-                                user = req['auth'];
-                        }
-                        if (user)
-                            remult.user = user;
-                        if (this.options.initRequest) {
-                            await this.options.initRequest(req, {
-                                remult,
-                                get liveQueryStorage() {
-                                    return remult.liveQueryStorage;
-                                },
-                                set liveQueryStorage(value) {
-                                    remult.liveQueryStorage = value;
-                                },
-                            });
+                if (remultStatic.asyncContext.isInInitRequest())
+                    return await what(remultStatic.asyncContext.getStore().remult, myReq, myRes, genReq, origRes, req);
+                else
+                    await this.runWithRemult(async (remult) => {
+                        if (req) {
+                            remultStatic.asyncContext.setInInitRequest(true);
+                            try {
+                                let user;
+                                if (this.options.getUser)
+                                    user = await this.options.getUser(req);
+                                else {
+                                    user = req['user'];
+                                    if (!user)
+                                        user = req['auth'];
+                                }
+                                if (user)
+                                    remult.user = user;
+                                if (this.options.initRequest) {
+                                    await this.options.initRequest(req, {
+                                        remult,
+                                        get liveQueryStorage() {
+                                            return remult.liveQueryStorage;
+                                        },
+                                        set liveQueryStorage(value) {
+                                            remult.liveQueryStorage = value;
+                                        },
+                                    });
+                                }
+                            }
+                            finally {
+                                remultStatic.asyncContext.setInInitRequest(false);
+                            }
                         }
-                    }
-                    await what(remult, myReq, myRes, genReq, origRes, req);
-                });
+                        await what(remult, myReq, myRes, genReq, origRes, req);
+                    });
             }
             catch (err) {
-                myRes.error(err, undefined);
+                if (origRes)
+                    myRes.error(err, undefined);
+                else
+                    throw err;
             }
         };
     }
@@ -735,7 +755,7 @@ export class RemultServerImplementation {
     /* internal */
     backendMethodsOpenApi = [];
 }
-class ExpressRequestBridgeToDataApiRequest {
+class RequestBridgeToDataApiRequest {
     r;
     get(key) {
         return this.r?.query[key];
@@ -744,7 +764,7 @@ class ExpressRequestBridgeToDataApiRequest {
         this.r = r;
     }
 }
-class ExpressResponseBridgeToDataApiResponse {
+class ResponseBridgeToDataApiResponse {
     r;
     req;
     handleError;

package/esm/src/context.js

@@ -7,13 +7,14 @@ import { serverActionField } from './server-action-info.js';
 import { buildRestDataProvider, isExternalHttpProvider, } from './buildRestDataProvider.js';
 import { verifyFieldRelationInfo } from './remult3/relationInfoMember.js';
 import { remultStatic, resetFactory } from './remult-static.js';
+import { initDataProvider } from '../server/initDataProvider';
 export class RemultAsyncLocalStorage {
     remultObjectStorage;
     static enable() {
         remultStatic.remultFactory = () => {
-            const r = remultStatic.asyncContext.getRemult();
+            const r = remultStatic.asyncContext.getStore();
             if (r)
-                return r;
+                return r.remult;
             else
                 throw new Error('remult object was requested outside of a valid context, try running it within initApi or a remult request cycle');
         };
@@ -26,12 +27,21 @@ export class RemultAsyncLocalStorage {
     }
     async run(remult, callback) {
         if (this.remultObjectStorage) {
-            return this.remultObjectStorage.run(remult, () => callback(remult));
+            return this.remultObjectStorage.run({ remult }, () => callback(remult));
         }
         else
             return callback(remult);
     }
-    getRemult() {
+    isInInitRequest() {
+        return this.remultObjectStorage?.getStore()?.inInitRequest;
+    }
+    setInInitRequest(val) {
+        const store = this.remultObjectStorage?.getStore();
+        if (!store)
+            return;
+        store.inInitRequest = val;
+    }
+    getStore() {
         if (!this.remultObjectStorage) {
             throw new Error("can't use static remult in this environment, `async_hooks` were not initialized");
         }
@@ -282,9 +292,8 @@ class transactionLiveQueryPublisher {
         }
     }
 }
-export function withRemult(callback, options) {
+export async function withRemult(callback, options) {
     const remult = new Remult();
-    if (options?.dataProvider)
-        remult.dataProvider = options.dataProvider;
+    remult.dataProvider = await initDataProvider(options?.dataProvider, true, async () => remult.dataProvider);
     return remultStatic.asyncContext.run(remult, (r) => callback(r));
 }

package/esm/src/data-providers/json-data-provider.js

@@ -1,11 +1,13 @@
 import { ArrayEntityDataProvider } from './array-entity-data-provider.js';
 export class JsonDataProvider {
     storage;
-    constructor(storage) {
+    formatted;
+    constructor(storage, formatted = false) {
         this.storage = storage;
+        this.formatted = formatted;
     }
     getEntityDataProvider(entity) {
-        return new JsonEntityDataProvider(entity, this.storage);
+        return new JsonEntityDataProvider(entity, this.storage, this.formatted);
     }
     async transaction(action) {
         await action(this);
@@ -14,9 +16,11 @@ export class JsonDataProvider {
 class JsonEntityDataProvider {
     entity;
     helper;
-    constructor(entity, helper) {
+    formatted;
+    constructor(entity, helper, formatted) {
         this.entity = entity;
         this.helper = helper;
+        this.formatted = formatted;
     }
     async loadEntityData(what) {
         let data = [];
@@ -25,7 +29,7 @@ class JsonEntityDataProvider {
         if (s)
             data = JSON.parse(s);
         let dp = new ArrayEntityDataProvider(this.entity, () => data);
-        return what(dp, async () => await this.helper.setItem(dbName, JSON.stringify(data, undefined, 2)));
+        return what(dp, async () => await this.helper.setItem(dbName, JSON.stringify(data, undefined, this.formatted ? 2 : undefined)));
     }
     p = Promise.resolve();
     find(options) {

package/esm/src/remult-static.js

@@ -19,6 +19,7 @@ let x = {
         }),
     },
     captionTransformer: undefined,
+    defaultDataProvider: () => undefined,
 };
 if ((typeof process !== 'undefined' &&
     process.env['IGNORE_GLOBAL_REMULT_IN_TESTS']) ||

package/esm/src/remult3/remult3.js

@@ -1,14 +1,17 @@
 export const flags = {
     error500RetryCount: 4,
 };
-//y2 - soft-delete-discussion https://discord.com/channels/975754286384418847/1230386433093533698/1230386433093533698
 //y1 - live query with count #436
+//y1 - https://github.com/remult/remult/discussions/438
+//p1 - discuss next auth withRemult paradox
+//p1 - maybe the default withRemult should by default use the data provider set by the remultExpress
+//p1 - withRemult to support the full  range of data provider.
 //y1 TODO - In the esm version of our tutorial - the imports are automatically .ts and not .js in react and not in vue
 //y1 TODO - consider id to also support keyof (id:['company','index']) - had problem with | (keyof Partial<entityType>)[] & `entity`
 //y1 TODO -  readonly key: keyof MembersOnly<entityType> & string
 //y1 - talk about insert / update / delete with relations
 /*
-  repo(Order).insert({},{
+repo(Order).insert({},{
   relations:{
     orderItems:[{},{},{}]
   }
@@ -16,14 +19,16 @@ export const flags = {
 */
 //y1 - repo batch - for multiple operations:
 /*
-  const result = await repo.batch(x=>({
-    data:x.find(),
-    count:x.count()
-  }))
+const result = await repo.batch(x=>({
+  data:x.find(),
+  count:x.count()
+}))
 */
+//p1 - consider in json storage, to store the json without spaces
 //p1 - consider upsert (where,set)
 //y1 - wait a second to close stream -see pr
 //p1 - Consider enforcing serial operations on JSON database to prevent data loss
+//y2 - soft-delete-discussion https://discord.com/channels/975754286384418847/1230386433093533698/1230386433093533698
 //p1 - prepare the createEntity discussion
 //p1 - return error on connection error
 //p1 - article on displayValue including it's definition for entities that is used in relations

package/live-query/data-provider-live-query-storage.js

@@ -2,15 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LiveQueryStorageEntity = exports.DataProviderLiveQueryStorage = void 0;
 var tslib_1 = require("tslib");
-var initDataProvider_js_1 = require("../server/initDataProvider.js");
 var context_js_1 = require("../src/context.js");
 var RepositoryImplementation_js_1 = require("../src/remult3/RepositoryImplementation.js");
 var Fields_js_1 = require("../src/remult3/Fields.js");
 var entity_js_1 = require("../src/remult3/entity.js");
 var remult_static_js_1 = require("../src/remult-static.js");
+var initDataProviderOrJson_1 = require("../server/initDataProviderOrJson");
 var DataProviderLiveQueryStorage = /** @class */ (function () {
     function DataProviderLiveQueryStorage(dataProvider) {
-        this.dataProvider = (0, initDataProvider_js_1.initDataProvider)(dataProvider);
+        this.dataProvider = (0, initDataProviderOrJson_1.initDataProviderOrJson)(dataProvider);
         this.repo = this.dataProvider.then(function (dp) {
             return new context_js_1.Remult(dp).repo(LiveQueryStorageEntity);
         });

package/migrations/generate-migrations.js

@@ -8,7 +8,7 @@ var compare_migration_snapshots_js_1 = require("./compare-migration-snapshots.js
 var update_migrations_ts_file_js_1 = require("./update-migrations-ts-file.js");
 var migration_types_js_1 = require("./migration-types.js");
 var isOfType_js_1 = require("../src/isOfType.js");
-var initDataProvider_js_1 = require("../server/initDataProvider.js");
+var initDataProviderOrJson_1 = require("../server/initDataProviderOrJson");
 /**
  * Generates migration scripts based on changes in entities.
  *
@@ -31,7 +31,7 @@ function generateMigrations(options) {
                     migrationDir = options.migrationsFolder || path_1.default.join(process.cwd(), 'src/migrations');
                     snapshotFileName = options.snapshotFile || path_1.default.join(migrationDir, 'migrations-snapshot.json');
                     migrationsTSFilename = options.migrationsTSFile || path_1.default.join(migrationDir, 'migrations.ts');
-                    return [4 /*yield*/, (0, initDataProvider_js_1.initDataProvider)(options.dataProvider)];
+                    return [4 /*yield*/, (0, initDataProviderOrJson_1.initDataProviderOrJson)(options.dataProvider)];
                 case 1:
                     dataProvider = _d.sent();
                     try {

package/migrations/migrate.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.migrate = void 0;
 var tslib_1 = require("tslib");
 var index_js_1 = require("../index.js");
-var initDataProvider_js_1 = require("../server/initDataProvider.js");
+var initDataProviderOrJson_1 = require("../server/initDataProviderOrJson");
 var context_js_1 = require("../src/context.js");
 var isOfType_js_1 = require("../src/isOfType.js");
 /**
@@ -26,7 +26,7 @@ function migrate(options) {
             switch (_a.label) {
                 case 0:
                     migrationTableName = options.migrationsTable || '__remult_migrations_version';
-                    return [4 /*yield*/, (0, initDataProvider_js_1.initDataProvider)(options.dataProvider)];
+                    return [4 /*yield*/, (0, initDataProviderOrJson_1.initDataProviderOrJson)(options.dataProvider)];
                 case 1:
                     dataProvider = _a.sent();
                     prev = index_js_1.remult.dataProvider;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.26.11",
+    "version": "0.26.12-next.1",
     "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev",
     "repository": {

package/remult-next.d.ts

@@ -22,5 +22,5 @@ export type RemultNextAppServer = RemultServerCore<Request> & {
     PUT: (req: Request) => Promise<Response>;
     POST: (req: Request) => Promise<Response>;
     DELETE: (req: Request) => Promise<Response>;
-    withRemult<T>(what: () => Promise<T>): Promise<T>;
+    withRemult<T>(what: () => Promise<T>, disableInitUserAndRequest?: boolean): Promise<T>;
 };

package/remult-next.js

@@ -174,7 +174,9 @@ function remultNextApp(options) {
         POST: handler,
         PUT: handler,
         DELETE: handler,
-        withRemult: function (what) { return result.withRemultAsync({}, what); },
+        withRemult: function (what, disableInitUserAndRequest) {
+            return result.withRemultAsync(disableInitUserAndRequest ? undefined : {}, what);
+        },
     };
 }
 exports.remultNextApp = remultNextApp;

package/remult-solid-start.d.ts

@@ -3,7 +3,7 @@ import type { RemultServerCore, RemultServerOptions } from './server/index.js';
 export declare function remultSolidStart(options: RemultServerOptions<RequestEvent>): RemultSolidStartServer;
 type RequestHandler = (event: RequestEvent) => Promise<Response>;
 export type RemultSolidStartServer = RemultServerCore<RequestEvent> & {
-    withRemult<T>(what: () => Promise<T>): Promise<T>;
+    withRemult<T>(what: () => Promise<T>, disableInitUserAndRequest?: boolean): Promise<T>;
     GET: RequestHandler;
     PUT: RequestHandler;
     POST: RequestHandler;

package/remult-solid-start.js

@@ -112,15 +112,21 @@ function remultSolidStart(options) {
     return Object.assign(handler, {
         getRemult: function (req) { return result.getRemult(req); },
         openApiDoc: function (options) { return result.openApiDoc(options); },
-        withRemult: function (what) {
+        withRemult: function (what, disableInitUserAndRequest) {
             return tslib_1.__awaiter(this, void 0, void 0, function () {
-                var _a, _b;
-                return tslib_1.__generator(this, function (_c) {
-                    switch (_c.label) {
+                var _a, _b, _c;
+                return tslib_1.__generator(this, function (_d) {
+                    switch (_d.label) {
                         case 0:
                             _b = (_a = result).withRemultAsync;
-                            return [4 /*yield*/, (0, web_1.getRequestEvent)()];
-                        case 1: return [2 /*return*/, _b.apply(_a, [_c.sent(), what])];
+                            if (!disableInitUserAndRequest) return [3 /*break*/, 1];
+                            _c = undefined;
+                            return [3 /*break*/, 3];
+                        case 1: return [4 /*yield*/, (0, web_1.getRequestEvent)()];
+                        case 2:
+                            _c = _d.sent();
+                            _d.label = 3;
+                        case 3: return [2 /*return*/, _b.apply(_a, [_c, what])];
                     }
                 });
             });

package/server/JsonEntityFileStorage.js

@@ -28,7 +28,7 @@ exports.JsonEntityFileStorage = JsonEntityFileStorage;
 var JsonFileDataProvider = /** @class */ (function (_super) {
     tslib_1.__extends(JsonFileDataProvider, _super);
     function JsonFileDataProvider(folderPath) {
-        return _super.call(this, new JsonEntityFileStorage(folderPath)) || this;
+        return _super.call(this, new JsonEntityFileStorage(folderPath), true) || this;
     }
     return JsonFileDataProvider;
 }(index_js_1.JsonDataProvider));

package/server/initDataProvider.d.ts

@@ -1,2 +1,2 @@
 import type { DataProvider } from '../src/data-interfaces.js';
-export declare function initDataProvider(optionsDataProvider?: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>)): Promise<DataProvider>;
+export declare function initDataProvider(optionsDataProvider: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>) | undefined, useStaticDefault: boolean, defaultDataProvider: () => Promise<DataProvider>): Promise<DataProvider>;

package/server/initDataProvider.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.initDataProvider = void 0;
 var tslib_1 = require("tslib");
-function initDataProvider(optionsDataProvider) {
+var remult_static_1 = require("../src/remult-static");
+function initDataProvider(optionsDataProvider, useStaticDefault, defaultDataProvider) {
     var _this = this;
     var dataProvider;
     if (typeof optionsDataProvider === 'function') {
@@ -16,8 +17,15 @@ function initDataProvider(optionsDataProvider) {
                 case 0:
                     if (dp)
                         return [2 /*return*/, dp];
-                    return [4 /*yield*/, Promise.resolve().then(function () { return tslib_1.__importStar(require('./JsonEntityFileStorage.js')); })];
-                case 1: return [2 /*return*/, new (_a.sent()).JsonFileDataProvider('./db')];
+                    if (!useStaticDefault) return [3 /*break*/, 2];
+                    return [4 /*yield*/, remult_static_1.remultStatic.defaultDataProvider()];
+                case 1:
+                    dp = _a.sent();
+                    _a.label = 2;
+                case 2:
+                    if (dp)
+                        return [2 /*return*/, dp];
+                    return [2 /*return*/, defaultDataProvider === null || defaultDataProvider === void 0 ? void 0 : defaultDataProvider()];
             }
         });
     }); });

package/server/initDataProviderOrJson.d.ts

@@ -0,0 +1,2 @@
+import { DataProvider } from '../src/data-interfaces';
+export declare function initDataProviderOrJson(dataProvider: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>) | undefined): Promise<DataProvider>;

package/server/initDataProviderOrJson.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initDataProviderOrJson = void 0;
+var tslib_1 = require("tslib");
+var initDataProvider_1 = require("./initDataProvider");
+function initDataProviderOrJson(dataProvider) {
+    var _this = this;
+    return (0, initDataProvider_1.initDataProvider)(dataProvider, false, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, Promise.resolve().then(function () { return tslib_1.__importStar(require('./JsonEntityFileStorage.js')); })];
+                case 1: return [2 /*return*/, new (_a.sent()).JsonFileDataProvider('./db')];
+            }
+        });
+    }); });
+}
+exports.initDataProviderOrJson = initDataProviderOrJson;

package/server/remult-api-server.js

@@ -13,10 +13,10 @@ var entity_js_1 = require("../src/remult3/entity.js");
 var getEntityRef_js_1 = require("../src/remult3/getEntityRef.js");
 var server_action_js_1 = require("../src/server-action.js");
 var server_action_info_js_1 = require("../src/server-action-info.js");
-var initDataProvider_js_1 = require("./initDataProvider.js");
 var remult_static_js_1 = require("../src/remult-static.js");
 var remult_admin_js_1 = tslib_1.__importDefault(require("./remult-admin.js"));
 var isOfType_js_1 = require("../src/isOfType.js");
+var initDataProviderOrJson_1 = require("./initDataProviderOrJson");
 function createRemultServerCore(options, serverCoreOptions) {
     if (!options) {
         options = {};
@@ -33,7 +33,8 @@ function createRemultServerCore(options, serverCoreOptions) {
     if (!options.queueStorage) {
         options.queueStorage = new InMemoryQueueStorage();
     }
-    var dataProvider = (0, initDataProvider_js_1.initDataProvider)(options.dataProvider);
+    var dataProvider = (0, initDataProviderOrJson_1.initDataProviderOrJson)(options.dataProvider);
+    remult_static_js_1.remultStatic.defaultDataProvider = function () { return dataProvider; };
     if (options.ensureSchema === undefined)
         options.ensureSchema = true;
     context_js_1.RemultAsyncLocalStorage.enable();
@@ -142,14 +143,26 @@ var RemultServerImplementation = /** @class */ (function () {
                 }
             });
         }); };
-        this.withRemult = function (req, res, next) {
-            _this.process(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                return tslib_1.__generator(this, function (_a) {
-                    next();
-                    return [2 /*return*/];
-                });
-            }); })(req, res);
-        };
+        this.withRemult = function (req, res, next) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.process(function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, next()];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })(req, res)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); };
         this.registeredRouter = false;
         this.hasQueue = false;
         /* internal */
@@ -240,16 +253,33 @@ var RemultServerImplementation = /** @class */ (function () {
         var _this = this;
         if (!request)
             return this.runWithRemult(what);
-        return new Promise(function (resolve, error) {
-            return _this.withRemult(request, undefined, function () {
-                try {
-                    what().then(resolve).catch(error);
-                }
-                catch (err) {
-                    error(err);
+        return new Promise(function (resolve, error) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var err_1;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.withRemult(request, undefined, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                return tslib_1.__generator(this, function (_a) {
+                                    try {
+                                        what().then(resolve).catch(error);
+                                    }
+                                    catch (err) {
+                                        error(err);
+                                    }
+                                    return [2 /*return*/];
+                                });
+                            }); })];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        err_1 = _a.sent();
+                        error(err_1);
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
                 }
             });
-        });
+        }); });
     };
     RemultServerImplementation.prototype.getEntities = function () {
         //TODO V2 - consider using entitiesMetaData - but it may require making it all awaitable
@@ -524,7 +554,9 @@ var RemultServerImplementation = /** @class */ (function () {
                                     case 1: return [2 /*return*/, _a.sent()];
                                 }
                             });
-                        }); })];
+                        }); }, {
+                            dataProvider: dataProvider,
+                        })];
                     case 3: return [2 /*return*/, _a.sent()];
                 }
             });
@@ -533,7 +565,7 @@ var RemultServerImplementation = /** @class */ (function () {
     RemultServerImplementation.prototype.process = function (what) {
         var _this = this;
         return function (req, origRes) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-            var genReq, myReq, myRes, err_1;
+            var genReq, myReq, myRes, err_2;
             var _this = this;
             return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
@@ -548,59 +580,74 @@ var RemultServerImplementation = /** @class */ (function () {
                             if (!genReq.params)
                                 genReq.params = req['_tempParams'];
                         }
-                        myReq = new ExpressRequestBridgeToDataApiRequest(genReq);
-                        myRes = new ExpressResponseBridgeToDataApiResponse(origRes, req, this.options.error);
+                        myReq = new RequestBridgeToDataApiRequest(genReq);
+                        myRes = new ResponseBridgeToDataApiResponse(origRes, req, this.options.error);
                         _a.label = 1;
                     case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, this.runWithRemult(function (remult) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                var user;
-                                return tslib_1.__generator(this, function (_a) {
-                                    switch (_a.label) {
-                                        case 0:
-                                            if (!req) return [3 /*break*/, 5];
-                                            user = void 0;
-                                            if (!this.options.getUser) return [3 /*break*/, 2];
-                                            return [4 /*yield*/, this.options.getUser(req)];
-                                        case 1:
-                                            user = _a.sent();
-                                            return [3 /*break*/, 3];
-                                        case 2:
-                                            user = req['user'];
-                                            if (!user)
-                                                user = req['auth'];
-                                            _a.label = 3;
-                                        case 3:
-                                            if (user)
-                                                remult.user = user;
-                                            if (!this.options.initRequest) return [3 /*break*/, 5];
-                                            return [4 /*yield*/, this.options.initRequest(req, {
-                                                    remult: remult,
-                                                    get liveQueryStorage() {
-                                                        return remult.liveQueryStorage;
-                                                    },
-                                                    set liveQueryStorage(value) {
-                                                        remult.liveQueryStorage = value;
-                                                    },
-                                                })];
-                                        case 4:
-                                            _a.sent();
-                                            _a.label = 5;
-                                        case 5: return [4 /*yield*/, what(remult, myReq, myRes, genReq, origRes, req)];
-                                        case 6:
-                                            _a.sent();
-                                            return [2 /*return*/];
-                                    }
-                                });
-                            }); })];
-                    case 2:
+                        _a.trys.push([1, 6, , 7]);
+                        if (!remult_static_js_1.remultStatic.asyncContext.isInInitRequest()) return [3 /*break*/, 3];
+                        return [4 /*yield*/, what(remult_static_js_1.remultStatic.asyncContext.getStore().remult, myReq, myRes, genReq, origRes, req)];
+                    case 2: return [2 /*return*/, _a.sent()];
+                    case 3: return [4 /*yield*/, this.runWithRemult(function (remult) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            var user;
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        if (!req) return [3 /*break*/, 8];
+                                        remult_static_js_1.remultStatic.asyncContext.setInInitRequest(true);
+                                        _a.label = 1;
+                                    case 1:
+                                        _a.trys.push([1, , 7, 8]);
+                                        user = void 0;
+                                        if (!this.options.getUser) return [3 /*break*/, 3];
+                                        return [4 /*yield*/, this.options.getUser(req)];
+                                    case 2:
+                                        user = _a.sent();
+                                        return [3 /*break*/, 4];
+                                    case 3:
+                                        user = req['user'];
+                                        if (!user)
+                                            user = req['auth'];
+                                        _a.label = 4;
+                                    case 4:
+                                        if (user)
+                                            remult.user = user;
+                                        if (!this.options.initRequest) return [3 /*break*/, 6];
+                                        return [4 /*yield*/, this.options.initRequest(req, {
+                                                remult: remult,
+                                                get liveQueryStorage() {
+                                                    return remult.liveQueryStorage;
+                                                },
+                                                set liveQueryStorage(value) {
+                                                    remult.liveQueryStorage = value;
+                                                },
+                                            })];
+                                    case 5:
+                                        _a.sent();
+                                        _a.label = 6;
+                                    case 6: return [3 /*break*/, 8];
+                                    case 7:
+                                        remult_static_js_1.remultStatic.asyncContext.setInInitRequest(false);
+                                        return [7 /*endfinally*/];
+                                    case 8: return [4 /*yield*/, what(remult, myReq, myRes, genReq, origRes, req)];
+                                    case 9:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
+                    case 4:
                         _a.sent();
-                        return [3 /*break*/, 4];
-                    case 3:
-                        err_1 = _a.sent();
-                        myRes.error(err_1, undefined);
-                        return [3 /*break*/, 4];
-                    case 4: return [2 /*return*/];
+                        _a.label = 5;
+                    case 5: return [3 /*break*/, 7];
+                    case 6:
+                        err_2 = _a.sent();
+                        if (origRes)
+                            myRes.error(err_2, undefined);
+                        else
+                            throw err_2;
+                        return [3 /*break*/, 7];
+                    case 7: return [2 /*return*/];
                 }
             });
         }); };
@@ -1058,42 +1105,42 @@ var RemultServerImplementation = /** @class */ (function () {
     return RemultServerImplementation;
 }());
 exports.RemultServerImplementation = RemultServerImplementation;
-var ExpressRequestBridgeToDataApiRequest = /** @class */ (function () {
-    function ExpressRequestBridgeToDataApiRequest(r) {
+var RequestBridgeToDataApiRequest = /** @class */ (function () {
+    function RequestBridgeToDataApiRequest(r) {
         this.r = r;
     }
-    ExpressRequestBridgeToDataApiRequest.prototype.get = function (key) {
+    RequestBridgeToDataApiRequest.prototype.get = function (key) {
         var _a;
         return (_a = this.r) === null || _a === void 0 ? void 0 : _a.query[key];
     };
-    return ExpressRequestBridgeToDataApiRequest;
+    return RequestBridgeToDataApiRequest;
 }());
-var ExpressResponseBridgeToDataApiResponse = /** @class */ (function () {
-    function ExpressResponseBridgeToDataApiResponse(r, req, handleError) {
+var ResponseBridgeToDataApiResponse = /** @class */ (function () {
+    function ResponseBridgeToDataApiResponse(r, req, handleError) {
         this.r = r;
         this.req = req;
         this.handleError = handleError;
     }
-    ExpressResponseBridgeToDataApiResponse.prototype.forbidden = function () {
+    ResponseBridgeToDataApiResponse.prototype.forbidden = function () {
         this.error({ message: 'Forbidden' }, undefined, 403);
     };
-    ExpressResponseBridgeToDataApiResponse.prototype.setStatus = function (status) {
+    ResponseBridgeToDataApiResponse.prototype.setStatus = function (status) {
         return this.r.status(status);
     };
-    ExpressResponseBridgeToDataApiResponse.prototype.progress = function (progress) { };
-    ExpressResponseBridgeToDataApiResponse.prototype.success = function (data) {
+    ResponseBridgeToDataApiResponse.prototype.progress = function (progress) { };
+    ResponseBridgeToDataApiResponse.prototype.success = function (data) {
         this.r.json(data);
     };
-    ExpressResponseBridgeToDataApiResponse.prototype.created = function (data) {
+    ResponseBridgeToDataApiResponse.prototype.created = function (data) {
         this.setStatus(201).json(data);
     };
-    ExpressResponseBridgeToDataApiResponse.prototype.deleted = function () {
+    ResponseBridgeToDataApiResponse.prototype.deleted = function () {
         this.setStatus(204).end();
     };
-    ExpressResponseBridgeToDataApiResponse.prototype.notFound = function () {
+    ResponseBridgeToDataApiResponse.prototype.notFound = function () {
         this.error({ message: 'NotFound' }, undefined, 404);
     };
-    ExpressResponseBridgeToDataApiResponse.prototype.error = function (exception, entity, httpStatusCode) {
+    ResponseBridgeToDataApiResponse.prototype.error = function (exception, entity, httpStatusCode) {
         var _a;
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             var data, responseSent, sendError;
@@ -1151,7 +1198,7 @@ var ExpressResponseBridgeToDataApiResponse = /** @class */ (function () {
             });
         });
     };
-    return ExpressResponseBridgeToDataApiResponse;
+    return ResponseBridgeToDataApiResponse;
 }());
 var inProcessQueueHandler = /** @class */ (function () {
     function inProcessQueueHandler(storage) {

package/src/context.d.ts

@@ -8,9 +8,17 @@ export declare class RemultAsyncLocalStorage {
     private readonly remultObjectStorage;
     static enable(): void;
     static disable(): void;
-    constructor(remultObjectStorage: RemultAsyncLocalStorageCore<Remult>);
+    constructor(remultObjectStorage: RemultAsyncLocalStorageCore<{
+        remult: Remult;
+        inInitRequest?: boolean;
+    }>);
     run<T>(remult: Remult, callback: (remult: Remult) => Promise<T>): Promise<T>;
-    getRemult(): Remult;
+    isInInitRequest(): boolean;
+    setInInitRequest(val: boolean): void;
+    getStore(): {
+        remult: Remult;
+        inInitRequest?: boolean;
+    };
 }
 export type RemultAsyncLocalStorageCore<T> = {
     run<R>(store: T, callback: () => Promise<R>): Promise<R>;
@@ -195,5 +203,5 @@ export interface itemChange {
 }
 export declare function doTransaction(remult: Remult, what: (dp: DataProvider) => Promise<void>): Promise<void>;
 export declare function withRemult<T>(callback: (remult: any) => Promise<T>, options?: {
-    dataProvider?: DataProvider;
+    dataProvider?: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>);
 }): Promise<T>;

package/src/context.js

@@ -11,15 +11,16 @@ var server_action_info_js_1 = require("./server-action-info.js");
 var buildRestDataProvider_js_1 = require("./buildRestDataProvider.js");
 var relationInfoMember_js_1 = require("./remult3/relationInfoMember.js");
 var remult_static_js_1 = require("./remult-static.js");
+var initDataProvider_1 = require("../server/initDataProvider");
 var RemultAsyncLocalStorage = /** @class */ (function () {
     function RemultAsyncLocalStorage(remultObjectStorage) {
         this.remultObjectStorage = remultObjectStorage;
     }
     RemultAsyncLocalStorage.enable = function () {
         remult_static_js_1.remultStatic.remultFactory = function () {
-            var r = remult_static_js_1.remultStatic.asyncContext.getRemult();
+            var r = remult_static_js_1.remultStatic.asyncContext.getStore();
             if (r)
-                return r;
+                return r.remult;
             else
                 throw new Error('remult object was requested outside of a valid context, try running it within initApi or a remult request cycle');
         };
@@ -31,7 +32,7 @@ var RemultAsyncLocalStorage = /** @class */ (function () {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             return tslib_1.__generator(this, function (_a) {
                 if (this.remultObjectStorage) {
-                    return [2 /*return*/, this.remultObjectStorage.run(remult, function () { return callback(remult); })];
+                    return [2 /*return*/, this.remultObjectStorage.run({ remult: remult }, function () { return callback(remult); })];
                 }
                 else
                     return [2 /*return*/, callback(remult)];
@@ -39,7 +40,18 @@ var RemultAsyncLocalStorage = /** @class */ (function () {
             });
         });
     };
-    RemultAsyncLocalStorage.prototype.getRemult = function () {
+    RemultAsyncLocalStorage.prototype.isInInitRequest = function () {
+        var _a, _b;
+        return (_b = (_a = this.remultObjectStorage) === null || _a === void 0 ? void 0 : _a.getStore()) === null || _b === void 0 ? void 0 : _b.inInitRequest;
+    };
+    RemultAsyncLocalStorage.prototype.setInInitRequest = function (val) {
+        var _a;
+        var store = (_a = this.remultObjectStorage) === null || _a === void 0 ? void 0 : _a.getStore();
+        if (!store)
+            return;
+        store.inInitRequest = val;
+    };
+    RemultAsyncLocalStorage.prototype.getStore = function () {
         if (!this.remultObjectStorage) {
             throw new Error("can't use static remult in this environment, `async_hooks` were not initialized");
         }
@@ -455,9 +467,22 @@ var transactionLiveQueryPublisher = /** @class */ (function () {
     return transactionLiveQueryPublisher;
 }());
 function withRemult(callback, options) {
-    var remult = new Remult();
-    if (options === null || options === void 0 ? void 0 : options.dataProvider)
-        remult.dataProvider = options.dataProvider;
-    return remult_static_js_1.remultStatic.asyncContext.run(remult, function (r) { return callback(r); });
+    return tslib_1.__awaiter(this, void 0, void 0, function () {
+        var remult, _a;
+        var _this = this;
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    remult = new Remult();
+                    _a = remult;
+                    return [4 /*yield*/, (0, initDataProvider_1.initDataProvider)(options === null || options === void 0 ? void 0 : options.dataProvider, true, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+                            return [2 /*return*/, remult.dataProvider];
+                        }); }); })];
+                case 1:
+                    _a.dataProvider = _b.sent();
+                    return [2 /*return*/, remult_static_js_1.remultStatic.asyncContext.run(remult, function (r) { return callback(r); })];
+            }
+        });
+    });
 }
 exports.withRemult = withRemult;

package/src/data-providers/json-data-provider.d.ts

@@ -6,7 +6,8 @@ export interface JsonEntityStorage {
 }
 export declare class JsonDataProvider implements DataProvider {
     private storage;
-    constructor(storage: JsonEntityStorage);
+    private formatted;
+    constructor(storage: JsonEntityStorage, formatted?: boolean);
     getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
 }

package/src/data-providers/json-data-provider.js

@@ -4,11 +4,13 @@ exports.JsonDataProvider = void 0;
 var tslib_1 = require("tslib");
 var array_entity_data_provider_js_1 = require("./array-entity-data-provider.js");
 var JsonDataProvider = /** @class */ (function () {
-    function JsonDataProvider(storage) {
+    function JsonDataProvider(storage, formatted) {
+        if (formatted === void 0) { formatted = false; }
         this.storage = storage;
+        this.formatted = formatted;
     }
     JsonDataProvider.prototype.getEntityDataProvider = function (entity) {
-        return new JsonEntityDataProvider(entity, this.storage);
+        return new JsonEntityDataProvider(entity, this.storage, this.formatted);
     };
     JsonDataProvider.prototype.transaction = function (action) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
@@ -26,9 +28,10 @@ var JsonDataProvider = /** @class */ (function () {
 }());
 exports.JsonDataProvider = JsonDataProvider;
 var JsonEntityDataProvider = /** @class */ (function () {
-    function JsonEntityDataProvider(entity, helper) {
+    function JsonEntityDataProvider(entity, helper, formatted) {
         this.entity = entity;
         this.helper = helper;
+        this.formatted = formatted;
         this.p = Promise.resolve();
     }
     JsonEntityDataProvider.prototype.loadEntityData = function (what) {
@@ -48,12 +51,14 @@ var JsonEntityDataProvider = /** @class */ (function () {
                         if (s)
                             data = JSON.parse(s);
                         dp = new array_entity_data_provider_js_1.ArrayEntityDataProvider(this.entity, function () { return data; });
-                        return [2 /*return*/, what(dp, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, this.helper.setItem(dbName, JSON.stringify(data, undefined, 2))];
-                                    case 1: return [2 /*return*/, _a.sent()];
-                                }
-                            }); }); })];
+                        return [2 /*return*/, what(dp, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                return tslib_1.__generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, this.helper.setItem(dbName, JSON.stringify(data, undefined, this.formatted ? 2 : undefined))];
+                                        case 1: return [2 /*return*/, _a.sent()];
+                                    }
+                                });
+                            }); })];
                 }
             });
         });

package/src/remult-static.d.ts

@@ -1,5 +1,6 @@
 import type { ClassType } from '../classType.js';
 import type { ClassHelper, Remult, RemultAsyncLocalStorage } from './context.js';
+import { DataProvider } from './data-interfaces';
 import type { columnInfo } from './remult3/columnInfo.js';
 export declare const remultStatic: {
     defaultRemultFactory: () => Remult;
@@ -19,6 +20,7 @@ export declare const remultStatic: {
         };
     };
     captionTransformer: any;
+    defaultDataProvider: () => Promise<DataProvider>;
 };
 export declare function defaultFactory(): Remult;
 export declare function resetFactory(): void;

package/src/remult-static.js

@@ -22,6 +22,7 @@ var x = {
         }); },
     },
     captionTransformer: undefined,
+    defaultDataProvider: function () { return undefined; },
 };
 if ((typeof process !== 'undefined' &&
     process.env['IGNORE_GLOBAL_REMULT_IN_TESTS']) ||

package/src/remult3/remult3.js

@@ -4,14 +4,17 @@ exports.flags = void 0;
 exports.flags = {
     error500RetryCount: 4,
 };
-//y2 - soft-delete-discussion https://discord.com/channels/975754286384418847/1230386433093533698/1230386433093533698
 //y1 - live query with count #436
+//y1 - https://github.com/remult/remult/discussions/438
+//p1 - discuss next auth withRemult paradox
+//p1 - maybe the default withRemult should by default use the data provider set by the remultExpress
+//p1 - withRemult to support the full  range of data provider.
 //y1 TODO - In the esm version of our tutorial - the imports are automatically .ts and not .js in react and not in vue
 //y1 TODO - consider id to also support keyof (id:['company','index']) - had problem with | (keyof Partial<entityType>)[] & `entity`
 //y1 TODO -  readonly key: keyof MembersOnly<entityType> & string
 //y1 - talk about insert / update / delete with relations
 /*
-  repo(Order).insert({},{
+repo(Order).insert({},{
   relations:{
     orderItems:[{},{},{}]
   }
@@ -19,14 +22,16 @@ exports.flags = {
 */
 //y1 - repo batch - for multiple operations:
 /*
-  const result = await repo.batch(x=>({
-    data:x.find(),
-    count:x.count()
-  }))
+const result = await repo.batch(x=>({
+  data:x.find(),
+  count:x.count()
+}))
 */
+//p1 - consider in json storage, to store the json without spaces
 //p1 - consider upsert (where,set)
 //y1 - wait a second to close stream -see pr
 //p1 - Consider enforcing serial operations on JSON database to prevent data loss
+//y2 - soft-delete-discussion https://discord.com/channels/975754286384418847/1230386433093533698/1230386433093533698
 //p1 - prepare the createEntity discussion
 //p1 - return error on connection error
 //p1 - article on displayValue including it's definition for entities that is used in relations