remult 0.26.11-next.1 → 0.26.12-next.0

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-sqlite-core.js

@@ -29,13 +29,13 @@ export class SqliteCoreDataProvider {
         };
     }
     async transaction(action) {
-        this.createCommand().execute('Begin Transaction');
+        await this.createCommand().execute('Begin Transaction');
         try {
             await action(this);
-            this.createCommand().execute('Commit');
+            await this.createCommand().execute('Commit');
         }
         catch (err) {
-            this.createCommand().execute('Rollback');
+            await this.createCommand().execute('Rollback');
             throw err;
         }
     }

package/esm/remult-turso.js

@@ -0,0 +1,59 @@
+import { SqliteCoreDataProvider } from './remult-sqlite-core.js';
+import { cast } from './src/isOfType.js';
+export class TursoDataProvider extends SqliteCoreDataProvider {
+    client;
+    constructor(client) {
+        super(() => new TursoCommand(client), async () => {
+            await cast(this.client, 'close').close();
+        }, false);
+        this.client = client;
+    }
+    async transaction(action) {
+        const trans = await cast(this.client, 'transaction').transaction();
+        try {
+            await action(new TursoDataProvider(trans));
+            await trans.commit();
+        }
+        catch (err) {
+            await trans.rollback();
+            throw err;
+        }
+    }
+}
+class TursoCommand {
+    db;
+    values = {};
+    i = 1;
+    constructor(db) {
+        this.db = db;
+    }
+    async execute(sql) {
+        return new TursoSqlResult(await this.db.execute({
+            sql,
+            args: this.values,
+        }));
+    }
+    addParameterAndReturnSqlToken(val) {
+        return this.param(val);
+    }
+    param(val) {
+        if (val instanceof Date)
+            val = val.valueOf();
+        if (typeof val === 'boolean')
+            val = val ? 1 : 0;
+        const key = ':' + this.i++;
+        this.values[key.substring(1)] = val;
+        return key;
+    }
+}
+class TursoSqlResult {
+    result;
+    constructor(result) {
+        this.result = result;
+        this.rows = result.rows;
+    }
+    rows;
+    getColumnKeyInResultForIndexInSelect(index) {
+        return this.result.columns[index];
+    }
+}

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();
@@ -277,6 +278,8 @@ export class RemultServerImplementation {
             x.subscriptionServer = this.subscriptionServer;
             x.liveQueryStorage = this.liveQueryStorage;
             return await what(x);
+        }, {
+            dataProvider,
         });
     }
     process(what) {
@@ -293,37 +296,46 @@ export class RemultServerImplementation {
             }
             let myReq = new ExpressRequestBridgeToDataApiRequest(genReq);
             let myRes = new ExpressResponseBridgeToDataApiResponse(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
+                try {
+                    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);
-                });
-            }
-            catch (err) {
-                myRes.error(err, undefined);
-            }
+                        await what(remult, myReq, myRes, genReq, origRes, req);
+                    });
+                }
+                catch (err) {
+                    myRes.error(err, undefined);
+                }
         };
     }
     async getRemult(req) {

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/live-query/LiveQueryClient.js

@@ -67,7 +67,7 @@ export class LiveQueryClient {
             onUnsubscribe = () => { };
         };
     }
-    _actuallyClose() {
+    closeIfNoListeners() {
         if (this.client)
             if (this.queries.size === 0 && this.channels.size === 0) {
                 this.runPromise(this.client.then((x) => x.close()));
@@ -76,12 +76,6 @@ export class LiveQueryClient {
                 this.interval = undefined;
             }
     }
-    keepAliveMs = 1000;
-    closeIfNoListeners() {
-        setTimeout(() => {
-            this._actuallyClose();
-        }, this.keepAliveMs);
-    }
     subscribe(repo, options, listener) {
         let alive = true;
         let onUnsubscribe = () => {
@@ -168,8 +162,7 @@ export class LiveQueryClient {
             this.interval = setInterval(async () => {
                 const ids = [];
                 for (const q of this.queries.values()) {
-                    if (q.gotAnyResult)
-                        ids.push(q.queryChannel);
+                    ids.push(q.queryChannel);
                 }
                 if (ids.length > 0) {
                     let p = this.apiProvider();

package/esm/src/live-query/SubscriptionChannel.js

@@ -10,12 +10,10 @@ export class LiveQuerySubscriber {
     sendDefaultState(onResult) {
         onResult(this.createReducerType(() => [...this.defaultQueryState], this.allItemsMessage(this.defaultQueryState)));
     }
-    gotAnyResult = false;
     queryChannel;
     subscribeCode;
     unsubscribe = () => { };
     async setAllItems(result) {
-        this.gotAnyResult = true;
         const items = await getRepositoryInternals(this.repo)._fromJsonArray(result, this.query.options);
         this.forListeners((listener) => {
             listener(() => {

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,15 +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 - live query errort that appears in tests but I can't understand why - `open connection error `
+//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:[{},{},{}]
   }
@@ -17,13 +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)
-//p1 - wait a second to close stream
+//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
@@ -81,6 +86,8 @@ export const flags = {
 //p1 - when a tasks table exists in a different schema - we get many errors
 //p1 - live query with include
 //p1 - adjust angular tutorial starter kit for latest angular (as is in tutorial)
+//y2 - Fix problem with promise all in sql expression recurssion - when using PromiseAll in row relation loading, some sql expressions appear is recursion call even if they are not
+//p2 - when subscribe is forbidden - the query still runs after the renew process
 //p2 - 'update tasks set  where id = $1
 //p2 - type metadata.key - to keyof entity - based on cwis input
 //y2 - remove __dirname from tutorials

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-next.1",
+    "version": "0.26.12-next.0",
     "description": "A CRUD framework for full-stack TypeScript",
     "homepage": "https://remult.dev",
     "repository": {
@@ -116,6 +116,11 @@
             "import": "./esm/remult-sqlite3.js",
             "types": "./remult-sqlite3.d.ts"
         },
+        "./remult-turso": {
+            "require": "./remult-turso.js",
+            "import": "./esm/remult-turso.js",
+            "types": "./remult-turso.d.ts"
+        },
         "./remult-bun-sqlite": {
             "require": "./remult-bun-sqlite.js",
             "import": "./esm/remult-bun-sqlite.js",

package/remult-sqlite-core.js

@@ -52,21 +52,26 @@ var SqliteCoreDataProvider = /** @class */ (function () {
             var err_1;
             return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
-                        this.createCommand().execute('Begin Transaction');
-                        _a.label = 1;
+                    case 0: return [4 /*yield*/, this.createCommand().execute('Begin Transaction')];
                     case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, action(this)];
-                    case 2:
                         _a.sent();
-                        this.createCommand().execute('Commit');
-                        return [3 /*break*/, 4];
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 5, , 7]);
+                        return [4 /*yield*/, action(this)];
                     case 3:
+                        _a.sent();
+                        return [4 /*yield*/, this.createCommand().execute('Commit')];
+                    case 4:
+                        _a.sent();
+                        return [3 /*break*/, 7];
+                    case 5:
                         err_1 = _a.sent();
-                        this.createCommand().execute('Rollback');
+                        return [4 /*yield*/, this.createCommand().execute('Rollback')];
+                    case 6:
+                        _a.sent();
                         throw err_1;
-                    case 4: return [2 /*return*/];
+                    case 7: return [2 /*return*/];
                 }
             });
         });

package/remult-sqlite3.d.ts

@@ -1,5 +1,5 @@
 import { SqliteCoreDataProvider } from './remult-sqlite-core.js';
-import { Database } from 'sqlite3';
+import type { Database } from 'sqlite3';
 export declare class Sqlite3DataProvider extends SqliteCoreDataProvider {
     constructor(db: Database);
 }

package/remult-turso.d.ts

@@ -0,0 +1,8 @@
+import { SqlImplementation } from './index.js';
+import { SqliteCoreDataProvider } from './remult-sqlite-core.js';
+import type { Client } from '@libsql/client';
+export declare class TursoDataProvider extends SqliteCoreDataProvider {
+    private client;
+    constructor(client: Pick<Client, 'execute'>);
+    transaction(action: (sql: SqlImplementation) => Promise<void>): Promise<void>;
+}

package/remult-turso.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TursoDataProvider = void 0;
+var tslib_1 = require("tslib");
+var remult_sqlite_core_js_1 = require("./remult-sqlite-core.js");
+var isOfType_js_1 = require("./src/isOfType.js");
+var TursoDataProvider = /** @class */ (function (_super) {
+    tslib_1.__extends(TursoDataProvider, _super);
+    function TursoDataProvider(client) {
+        var _this = _super.call(this, function () { return new TursoCommand(client); }, 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*/, (0, isOfType_js_1.cast)(this.client, 'close').close()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); }, false) || this;
+        _this.client = client;
+        return _this;
+    }
+    TursoDataProvider.prototype.transaction = function (action) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var trans, err_1;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, isOfType_js_1.cast)(this.client, 'transaction').transaction()];
+                    case 1:
+                        trans = _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        _a.trys.push([2, 5, , 7]);
+                        return [4 /*yield*/, action(new TursoDataProvider(trans))];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, trans.commit()];
+                    case 4:
+                        _a.sent();
+                        return [3 /*break*/, 7];
+                    case 5:
+                        err_1 = _a.sent();
+                        return [4 /*yield*/, trans.rollback()];
+                    case 6:
+                        _a.sent();
+                        throw err_1;
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return TursoDataProvider;
+}(remult_sqlite_core_js_1.SqliteCoreDataProvider));
+exports.TursoDataProvider = TursoDataProvider;
+var TursoCommand = /** @class */ (function () {
+    function TursoCommand(db) {
+        this.db = db;
+        this.values = {};
+        this.i = 1;
+    }
+    TursoCommand.prototype.execute = function (sql) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var _a;
+            return tslib_1.__generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _a = TursoSqlResult.bind;
+                        return [4 /*yield*/, this.db.execute({
+                                sql: sql,
+                                args: this.values,
+                            })];
+                    case 1: return [2 /*return*/, new (_a.apply(TursoSqlResult, [void 0, _b.sent()]))()];
+                }
+            });
+        });
+    };
+    TursoCommand.prototype.addParameterAndReturnSqlToken = function (val) {
+        return this.param(val);
+    };
+    TursoCommand.prototype.param = function (val) {
+        if (val instanceof Date)
+            val = val.valueOf();
+        if (typeof val === 'boolean')
+            val = val ? 1 : 0;
+        var key = ':' + this.i++;
+        this.values[key.substring(1)] = val;
+        return key;
+    };
+    return TursoCommand;
+}());
+var TursoSqlResult = /** @class */ (function () {
+    function TursoSqlResult(result) {
+        this.result = result;
+        this.rows = result.rows;
+    }
+    TursoSqlResult.prototype.getColumnKeyInResultForIndexInSelect = function (index) {
+        return this.result.columns[index];
+    };
+    return TursoSqlResult;
+}());

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();
@@ -524,7 +525,9 @@ var RemultServerImplementation = /** @class */ (function () {
                                     case 1: return [2 /*return*/, _a.sent()];
                                 }
                             });
-                        }); })];
+                        }); }, {
+                            dataProvider: dataProvider,
+                        })];
                     case 3: return [2 /*return*/, _a.sent()];
                 }
             });
@@ -550,30 +553,36 @@ var RemultServerImplementation = /** @class */ (function () {
                         }
                         myReq = new ExpressRequestBridgeToDataApiRequest(genReq);
                         myRes = new ExpressResponseBridgeToDataApiResponse(origRes, req, this.options.error);
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 4]);
+                        if (!remult_static_js_1.remultStatic.asyncContext.isInInitRequest()) return [3 /*break*/, 2];
+                        return [4 /*yield*/, what(remult_static_js_1.remultStatic.asyncContext.getStore().remult, myReq, myRes, genReq, origRes, req)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                    case 2:
+                        _a.trys.push([2, 4, , 5]);
                         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];
+                                            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*/, 2];
+                                            if (!this.options.getUser) return [3 /*break*/, 3];
                                             return [4 /*yield*/, this.options.getUser(req)];
-                                        case 1:
-                                            user = _a.sent();
-                                            return [3 /*break*/, 3];
                                         case 2:
+                                            user = _a.sent();
+                                            return [3 /*break*/, 4];
+                                        case 3:
                                             user = req['user'];
                                             if (!user)
                                                 user = req['auth'];
-                                            _a.label = 3;
-                                        case 3:
+                                            _a.label = 4;
+                                        case 4:
                                             if (user)
                                                 remult.user = user;
-                                            if (!this.options.initRequest) return [3 /*break*/, 5];
+                                            if (!this.options.initRequest) return [3 /*break*/, 6];
                                             return [4 /*yield*/, this.options.initRequest(req, {
                                                     remult: remult,
                                                     get liveQueryStorage() {
@@ -583,24 +592,28 @@ var RemultServerImplementation = /** @class */ (function () {
                                                         remult.liveQueryStorage = value;
                                                     },
                                                 })];
-                                        case 4:
+                                        case 5:
                                             _a.sent();
-                                            _a.label = 5;
-                                        case 5: return [4 /*yield*/, what(remult, myReq, myRes, genReq, origRes, req)];
-                                        case 6:
+                                            _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 2:
-                        _a.sent();
-                        return [3 /*break*/, 4];
                     case 3:
+                        _a.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
                         err_1 = _a.sent();
                         myRes.error(err_1, undefined);
-                        return [3 /*break*/, 4];
-                    case 4: return [2 /*return*/];
+                        return [3 /*break*/, 5];
+                    case 5: return [2 /*return*/];
                 }
             });
         }); };

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/live-query/LiveQueryClient.js

@@ -14,7 +14,6 @@ var LiveQueryClient = /** @class */ (function () {
         this.getUserId = getUserId;
         this.queries = new Map();
         this.channels = new Map();
-        this.keepAliveMs = 1000;
     }
     LiveQueryClient.prototype.wrapMessageHandling = function (handleMessage) {
         var x = this.apiProvider().wrapMessageHandling;
@@ -88,7 +87,7 @@ var LiveQueryClient = /** @class */ (function () {
             });
         });
     };
-    LiveQueryClient.prototype._actuallyClose = function () {
+    LiveQueryClient.prototype.closeIfNoListeners = function () {
         if (this.client)
             if (this.queries.size === 0 && this.channels.size === 0) {
                 this.runPromise(this.client.then(function (x) { return x.close(); }));
@@ -97,12 +96,6 @@ var LiveQueryClient = /** @class */ (function () {
                 this.interval = undefined;
             }
     };
-    LiveQueryClient.prototype.closeIfNoListeners = function () {
-        var _this = this;
-        setTimeout(function () {
-            _this._actuallyClose();
-        }, this.keepAliveMs);
-    };
     LiveQueryClient.prototype.subscribe = function (repo, options, listener) {
         var _this = this;
         var alive = true;
@@ -196,8 +189,7 @@ var LiveQueryClient = /** @class */ (function () {
                             try {
                                 for (_a = tslib_1.__values(this.queries.values()), _b = _a.next(); !_b.done; _b = _a.next()) {
                                     q = _b.value;
-                                    if (q.gotAnyResult)
-                                        ids.push(q.queryChannel);
+                                    ids.push(q.queryChannel);
                                 }
                             }
                             catch (e_1_1) { e_1 = { error: e_1_1 }; }

package/src/live-query/SubscriptionChannel.js

@@ -12,7 +12,6 @@ var LiveQuerySubscriber = /** @class */ (function () {
     function LiveQuerySubscriber(repo, query, userId) {
         this.repo = repo;
         this.query = query;
-        this.gotAnyResult = false;
         this.unsubscribe = function () { };
         this.defaultQueryState = [];
         this.listeners = [];
@@ -29,9 +28,7 @@ var LiveQuerySubscriber = /** @class */ (function () {
             var items;
             return tslib_1.__generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0:
-                        this.gotAnyResult = true;
-                        return [4 /*yield*/, (0, repository_internals_js_1.getRepositoryInternals)(this.repo)._fromJsonArray(result, this.query.options)];
+                    case 0: return [4 /*yield*/, (0, repository_internals_js_1.getRepositoryInternals)(this.repo)._fromJsonArray(result, this.query.options)];
                     case 1:
                         items = _a.sent();
                         this.forListeners(function (listener) {

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,15 +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 - live query errort that appears in tests but I can't understand why - `open connection error `
+//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:[{},{},{}]
   }
@@ -20,13 +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)
-//p1 - wait a second to close stream
+//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
@@ -84,6 +89,8 @@ exports.flags = {
 //p1 - when a tasks table exists in a different schema - we get many errors
 //p1 - live query with include
 //p1 - adjust angular tutorial starter kit for latest angular (as is in tutorial)
+//y2 - Fix problem with promise all in sql expression recurssion - when using PromiseAll in row relation loading, some sql expressions appear is recursion call even if they are not
+//p2 - when subscribe is forbidden - the query still runs after the renew process
 //p2 - 'update tasks set  where id = $1
 //p2 - type metadata.key - to keyof entity - based on cwis input
 //y2 - remove __dirname from tutorials