remult 3.3.18-next.0 → 3.3.18

package/esm/internals.js

@@ -9,4 +9,3 @@ export { isOfType } from './src/isOfType.js';
 export { flags } from './src/remult3/remult3.js';
 export { DataProviderPromiseWrapper } from './src/data-interfaces.js';
 export { pagedQueryResult } from './src/remult3/pagedQueryResult.js';
-export { withFetch } from './src/context.js';

package/esm/server/initAsyncHooks.js

@@ -16,7 +16,7 @@ export function initAsyncHooks() {
         }
     });
 }
-export class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore {
+export class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl {
     asyncLocalStorage = new AsyncLocalStorage();
     wasImplemented = 'yes';
     run(store, callback) {
@@ -36,14 +36,8 @@ export class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore {
     getStore() {
         return this.asyncLocalStorage.getStore();
     }
-    createDataProviderAsyncLocalStorage() {
-        return new AsyncLocalStorage();
-    }
 }
 export class StubRemultAsyncLocalStorageCore {
-    createDataProviderAsyncLocalStorage() {
-        return undefined;
-    }
     isStub = true;
     wasImplemented = 'yes';
     async run(store, callback) {
@@ -56,3 +50,5 @@ export class StubRemultAsyncLocalStorageCore {
     lastPromise = Promise.resolve(undefined);
     currentValue;
 }
+export class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore extends AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl {
+}

package/esm/server/test-api-data-provider.js

@@ -98,7 +98,6 @@ async function MakeServerCallWithDifferentStaticRemult(what) {
                 store.remult.user = user;
                 return callback();
             },
-            createDataProviderAsyncLocalStorage: () => undefined,
             wasImplemented: 'yes',
         });
         return await what();

package/esm/src/context.js

@@ -45,9 +45,6 @@ export class RemultAsyncLocalStorage {
         if (val || this.remultObjectStorage?.isStub)
             store.inInitRequest = val;
     }
-    createDataProviderAsyncLocalStorage() {
-        return this.remultObjectStorage?.createDataProviderAsyncLocalStorage();
-    }
     getStore() {
         if (!this.remultObjectStorage) {
             throw new Error("can't use static remult in this environment, `async_hooks` were not initialized");
@@ -186,15 +183,8 @@ export class Remult {
             httpClient: fetch,
         }));
     }
-    /* @internal */
-    _myDataProviderStore = new RemultInstanceDataProviderStore(new RestDataProvider(() => this.apiClient));
     /** The current data provider */
-    set dataProvider(dataProvider) {
-        this._myDataProviderStore.getStore().dataProvider = dataProvider;
-    }
-    get dataProvider() {
-        return this._myDataProviderStore.getStore().dataProvider;
-    }
+    dataProvider = new RestDataProvider(() => this.apiClient);
     /* @internal */
     repCache = new Map();
     constructor(provider) {
@@ -321,11 +311,10 @@ export async function doTransaction(remult, what) {
     const prev = remult.dataProvider;
     try {
         await remult.dataProvider.transaction(async (ds) => {
-            await withRemultDataProvider({ dataProvider: ds, remult }, async () => {
-                remult.liveQueryPublisher = trans;
-                await what(ds);
-                ok = true;
-            });
+            remult.dataProvider = ds;
+            remult.liveQueryPublisher = trans;
+            await what(ds);
+            ok = true;
         });
         if (ok)
             await trans.flush();
@@ -369,54 +358,6 @@ class transactionLiveQueryPublisher {
 }
 export async function withRemult(callback, options) {
     const remult = new Remult();
-    return remultStatic.asyncContext.run(remult, async (r) => {
-        remult.dataProvider = await initDataProvider(options?.dataProvider, true, async () => remult.dataProvider);
-        return await callback(r);
-    });
-}
-export class RemultInstanceDataProviderStore {
-    constructor(dataProvider) {
-        this._myDataProviderStore = { dataProvider };
-    }
-    _myDataProviderStore;
-    getStore = () => this._myDataProviderStore;
-    asyncStore;
-    async withDataProvider(dataProvider, callback) {
-        if (!this.asyncStore) {
-            this.asyncStore =
-                remultStatic.asyncContext.createDataProviderAsyncLocalStorage();
-            if (this.asyncStore) {
-                this.getStore = () => this.asyncStore.getStore() ?? this._myDataProviderStore;
-            }
-        }
-        if (this.asyncStore) {
-            return this.asyncStore.run({ dataProvider }, async () => {
-                return await callback();
-            });
-        }
-        else {
-            const prev = this._myDataProviderStore;
-            try {
-                this._myDataProviderStore = { dataProvider };
-                return await callback();
-            }
-            finally {
-                this._myDataProviderStore = prev;
-            }
-        }
-    }
-}
-export function withRemultDataProvider({ dataProvider, remult }, callback) {
-    remult = remult ?? remultStatic.remultFactory();
-    return remult._myDataProviderStore.withDataProvider(dataProvider, callback);
-}
-export function withFetch(fetch, callback) {
-    const remult = remultStatic.remultFactory();
-    return withRemultDataProvider({
-        remult,
-        dataProvider: new RestDataProvider(() => ({
-            ...remult.apiClient,
-            httpClient: fetch,
-        })),
-    }, callback);
+    remult.dataProvider = await initDataProvider(options?.dataProvider, true, async () => remult.dataProvider);
+    return remultStatic.asyncContext.run(remult, (r) => callback(r));
 }

package/esm/src/data-providers/array-entity-data-provider.js

@@ -267,8 +267,14 @@ export class ArrayEntityDataProvider {
     translateToJson(row, dbNames) {
         let result = {};
         for (const col of this.entity.fields) {
-            if (!isDbReadonly(col, dbNames))
-                result[dbNames.$dbNameOf(col)] = col.valueConverter.toJson(row[col.key]);
+            if (!isDbReadonly(col, dbNames)) {
+                let val = row[col.key];
+                if (val === undefined) {
+                    if (col.allowNull)
+                        val = null;
+                }
+                result[dbNames.$dbNameOf(col)] = col.valueConverter.toJson(val);
+            }
         }
         return result;
     }

package/esm/src/remult-proxy.js

@@ -215,9 +215,5 @@ export class RemultProxy {
     set subscriptionServer(value) {
         remultStatic.remultFactory().subscriptionServer = value;
     }
-    /** @internal */
-    get _myDataProviderStore() {
-        return remultStatic.remultFactory()._myDataProviderStore;
-    }
 }
 export const remult = new RemultProxy();

package/internals.d.ts

@@ -17,4 +17,3 @@ export type { ClassType } from './classType.js';
 export { flags } from './src/remult3/remult3.js';
 export { DataProviderPromiseWrapper } from './src/data-interfaces.js';
 export { pagedQueryResult } from './src/remult3/pagedQueryResult.js';
-export { withFetch } from './src/context.js';

package/internals.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.withFetch = exports.pagedQueryResult = exports.DataProviderPromiseWrapper = exports.flags = exports.isOfType = exports.actionInfo = exports.__updateEntityBasedOnWhere = exports.getEntitySettings = exports.fieldOptionsEnricher = exports.getControllerRef = exports.controllerRefImpl = exports.decorateColumnSettings = exports.getRelationFieldInfo = exports.getRelationInfo = exports.sqlRelationsFilter = exports.sqlRelations = void 0;
+exports.pagedQueryResult = exports.DataProviderPromiseWrapper = exports.flags = exports.isOfType = exports.actionInfo = exports.__updateEntityBasedOnWhere = exports.getEntitySettings = exports.fieldOptionsEnricher = exports.getControllerRef = exports.controllerRefImpl = exports.decorateColumnSettings = exports.getRelationFieldInfo = exports.getRelationInfo = exports.sqlRelationsFilter = exports.sqlRelations = void 0;
 var remult_static_js_1 = require("./src/remult-static.js");
 var sql_relations_js_1 = require("./src/data-providers/sql-relations.js");
 Object.defineProperty(exports, "sqlRelations", { enumerable: true, get: function () { return sql_relations_js_1.sqlRelations; } });
@@ -26,5 +26,3 @@ var data_interfaces_js_1 = require("./src/data-interfaces.js");
 Object.defineProperty(exports, "DataProviderPromiseWrapper", { enumerable: true, get: function () { return data_interfaces_js_1.DataProviderPromiseWrapper; } });
 var pagedQueryResult_js_1 = require("./src/remult3/pagedQueryResult.js");
 Object.defineProperty(exports, "pagedQueryResult", { enumerable: true, get: function () { return pagedQueryResult_js_1.pagedQueryResult; } });
-var context_js_1 = require("./src/context.js");
-Object.defineProperty(exports, "withFetch", { enumerable: true, get: function () { return context_js_1.withFetch; } });

package/package.json

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

package/server/initAsyncHooks.d.ts

@@ -1,22 +1,18 @@
-import { AsyncLocalStorage } from 'async_hooks';
-import { type RemultAsyncLocalStorageCore, type RemultInAsyncLocalStorage } from '../src/context.js';
-import type { DataProvider } from '../src/data-interfaces.js';
+import { type RemultAsyncLocalStorageCore } from '../src/context.js';
 export declare function initAsyncHooks(): void;
-export declare class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore implements RemultAsyncLocalStorageCore {
+export declare class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl<T> implements RemultAsyncLocalStorageCore<T> {
     private asyncLocalStorage;
     wasImplemented: "yes";
-    run<R>(store: RemultInAsyncLocalStorage, callback: () => Promise<R>): Promise<R>;
-    getStore(): RemultInAsyncLocalStorage | undefined;
-    createDataProviderAsyncLocalStorage(): AsyncLocalStorage<{
-        dataProvider: DataProvider;
-    }>;
+    run<R>(store: T, callback: () => Promise<R>): Promise<R>;
+    getStore(): T | undefined;
 }
-export declare class StubRemultAsyncLocalStorageCore implements RemultAsyncLocalStorageCore {
-    createDataProviderAsyncLocalStorage(): undefined;
+export declare class StubRemultAsyncLocalStorageCore<T> implements RemultAsyncLocalStorageCore<T> {
     isStub: boolean;
     wasImplemented: "yes";
-    run<R>(store: RemultInAsyncLocalStorage, callback: () => Promise<R>): Promise<R>;
-    getStore(): RemultInAsyncLocalStorage | undefined;
-    lastPromise: Promise<RemultInAsyncLocalStorage | undefined>;
-    currentValue?: RemultInAsyncLocalStorage;
+    run<R>(store: T, callback: () => Promise<R>): Promise<R>;
+    getStore(): T | undefined;
+    lastPromise: Promise<T | undefined>;
+    currentValue?: T;
+}
+export declare class AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore<T> extends AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl<T> {
 }

package/server/initAsyncHooks.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StubRemultAsyncLocalStorageCore = exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore = void 0;
+exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore = exports.StubRemultAsyncLocalStorageCore = exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl = void 0;
 exports.initAsyncHooks = initAsyncHooks;
 var tslib_1 = require("tslib");
 var async_hooks_1 = require("async_hooks");
@@ -29,12 +29,12 @@ function initAsyncHooks() {
         });
     }); });
 }
-var AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore = /** @class */ (function () {
-    function AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore() {
+var AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl = /** @class */ (function () {
+    function AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl() {
         this.asyncLocalStorage = new async_hooks_1.AsyncLocalStorage();
         this.wasImplemented = 'yes';
     }
-    AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore.prototype.run = function (store, callback) {
+    AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl.prototype.run = function (store, callback) {
         var _this = this;
         var r;
         this.asyncLocalStorage.run(store, function () {
@@ -60,24 +60,18 @@ var AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore = /** @class */ (functi
         });
         return r;
     };
-    AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore.prototype.getStore = function () {
+    AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl.prototype.getStore = function () {
         return this.asyncLocalStorage.getStore();
     };
-    AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore.prototype.createDataProviderAsyncLocalStorage = function () {
-        return new async_hooks_1.AsyncLocalStorage();
-    };
-    return AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore;
+    return AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl;
 }());
-exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore = AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore;
+exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl = AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl;
 var StubRemultAsyncLocalStorageCore = /** @class */ (function () {
     function StubRemultAsyncLocalStorageCore() {
         this.isStub = true;
         this.wasImplemented = 'yes';
         this.lastPromise = Promise.resolve(undefined);
     }
-    StubRemultAsyncLocalStorageCore.prototype.createDataProviderAsyncLocalStorage = function () {
-        return undefined;
-    };
     StubRemultAsyncLocalStorageCore.prototype.run = function (store, callback) {
         return tslib_1.__awaiter(this, void 0, void 0, function () {
             return tslib_1.__generator(this, function (_a) {
@@ -96,3 +90,11 @@ var StubRemultAsyncLocalStorageCore = /** @class */ (function () {
     return StubRemultAsyncLocalStorageCore;
 }());
 exports.StubRemultAsyncLocalStorageCore = StubRemultAsyncLocalStorageCore;
+var AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore = /** @class */ (function (_super) {
+    tslib_1.__extends(AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore, _super);
+    function AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    return AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore;
+}(AsyncLocalStorageBridgeToRemultAsyncLocalStorageCoreImpl));
+exports.AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore = AsyncLocalStorageBridgeToRemultAsyncLocalStorageCore;

package/server/test-api-data-provider.js

@@ -161,7 +161,6 @@ function MakeServerCallWithDifferentStaticRemult(what) {
                             store.remult.user = user;
                             return callback();
                         },
-                        createDataProviderAsyncLocalStorage: function () { return undefined; },
                         wasImplemented: 'yes',
                     });
                     return [4 /*yield*/, what()];

package/src/context.d.ts

@@ -8,31 +8,23 @@ export declare class RemultAsyncLocalStorage {
     private readonly remultObjectStorage;
     static enable(): void;
     static disable(): void;
-    constructor(remultObjectStorage: RemultAsyncLocalStorageCore | undefined);
+    constructor(remultObjectStorage: RemultAsyncLocalStorageCore<{
+        remult: Remult;
+        inInitRequest?: boolean;
+    }> | undefined);
     run<T>(remult: Remult, callback: (remult: Remult) => Promise<T>): Promise<T>;
     isInInitRequest(): boolean | undefined;
     setInInitRequest(val: boolean): void;
-    createDataProviderAsyncLocalStorage(): DataProviderAsyncLocalStorage | undefined;
-    getStore(): RemultInAsyncLocalStorage | undefined;
+    getStore(): {
+        remult: Remult;
+        inInitRequest?: boolean;
+    } | undefined;
 }
-export type RemultAsyncLocalStorageCore = {
-    run<R>(store: RemultInAsyncLocalStorage, callback: () => Promise<R>): Promise<R>;
-    getStore(): RemultInAsyncLocalStorage | undefined;
+export type RemultAsyncLocalStorageCore<T> = {
+    run<R>(store: T, callback: () => Promise<R>): Promise<R>;
+    getStore(): T | undefined;
     wasImplemented: 'yes';
     isStub?: boolean;
-    createDataProviderAsyncLocalStorage(): DataProviderAsyncLocalStorage | undefined;
-};
-export type RemultInAsyncLocalStorage = {
-    remult: Remult;
-    inInitRequest?: boolean;
-};
-export type DataProviderAsyncLocalStorage = {
-    run<R>(data: {
-        dataProvider: DataProvider;
-    }, callback: () => Promise<R>): Promise<R>;
-    getStore(): {
-        dataProvider: DataProvider;
-    } | undefined;
 };
 export declare function isBackend(): boolean;
 export declare class Remult {
@@ -80,8 +72,7 @@ export declare class Remult {
      */
     useFetch(fetch: ApiClient['httpClient']): void;
     /** The current data provider */
-    set dataProvider(dataProvider: DataProvider);
-    get dataProvider(): DataProvider;
+    dataProvider: DataProvider;
     /** Creates a new instance of the `remult` object.
      *
      * Can receive either an HttpProvider or a DataProvider as a parameter - which will be used to fetch data from.
@@ -259,19 +250,3 @@ export declare function doTransaction(remult: Remult, what: (dp: DataProvider) =
 export declare function withRemult<T>(callback: (remult: Remult) => Promise<T>, options?: {
     dataProvider?: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>);
 }): Promise<T>;
-export declare class RemultInstanceDataProviderStore {
-    constructor(dataProvider: DataProvider);
-    _myDataProviderStore: {
-        dataProvider: DataProvider;
-    };
-    getStore: () => {
-        dataProvider: DataProvider;
-    };
-    asyncStore?: DataProviderAsyncLocalStorage;
-    withDataProvider<T>(dataProvider: DataProvider, callback: () => Promise<T>): Promise<T>;
-}
-export declare function withRemultDataProvider<T>({ dataProvider, remult }: {
-    dataProvider: DataProvider;
-    remult?: Remult;
-}, callback: () => Promise<T>): Promise<T>;
-export declare function withFetch<T>(fetch: ApiClient['httpClient'], callback: () => Promise<T>): Promise<T>;

package/src/context.js

@@ -1,12 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RemultInstanceDataProviderStore = exports.EventSource = exports.queryConfig = exports.Allow = exports.ClassHelper = exports.Remult = exports.RemultAsyncLocalStorage = void 0;
+exports.EventSource = exports.queryConfig = exports.Allow = exports.ClassHelper = exports.Remult = exports.RemultAsyncLocalStorage = void 0;
 exports.isBackend = isBackend;
 exports.setControllerSettings = setControllerSettings;
 exports.doTransaction = doTransaction;
 exports.withRemult = withRemult;
-exports.withRemultDataProvider = withRemultDataProvider;
-exports.withFetch = withFetch;
 var tslib_1 = require("tslib");
 var data_interfaces_js_1 = require("./data-interfaces.js");
 var rest_data_provider_js_1 = require("./data-providers/rest-data-provider.js");
@@ -61,10 +59,6 @@ var RemultAsyncLocalStorage = /** @class */ (function () {
         if (val || ((_b = this.remultObjectStorage) === null || _b === void 0 ? void 0 : _b.isStub))
             store.inInitRequest = val;
     };
-    RemultAsyncLocalStorage.prototype.createDataProviderAsyncLocalStorage = function () {
-        var _a;
-        return (_a = this.remultObjectStorage) === null || _a === void 0 ? void 0 : _a.createDataProviderAsyncLocalStorage();
-    };
     RemultAsyncLocalStorage.prototype.getStore = function () {
         if (!this.remultObjectStorage) {
             throw new Error("can't use static remult in this environment, `async_hooks` were not initialized");
@@ -115,8 +109,8 @@ var Remult = /** @class */ (function () {
             }
             return r;
         };
-        /* @internal */
-        this._myDataProviderStore = new RemultInstanceDataProviderStore(new rest_data_provider_js_1.RestDataProvider(function () { return _this.apiClient; }));
+        /** The current data provider */
+        this.dataProvider = new rest_data_provider_js_1.RestDataProvider(function () { return _this.apiClient; });
         /* @internal */
         this.repCache = new Map();
         /* @internal*/
@@ -293,17 +287,6 @@ var Remult = /** @class */ (function () {
             httpClient: fetch,
         }); });
     };
-    Object.defineProperty(Remult.prototype, "dataProvider", {
-        get: function () {
-            return this._myDataProviderStore.getStore().dataProvider;
-        },
-        /** The current data provider */
-        set: function (dataProvider) {
-            this._myDataProviderStore.getStore().dataProvider = dataProvider;
-        },
-        enumerable: false,
-        configurable: true
-    });
     //@ts-ignore // type error of typescript regarding args that doesn't appear in my normal development
     /** Used to call a `backendMethod` using a specific `remult` object
      * @example
@@ -451,24 +434,15 @@ function doTransaction(remult, what) {
                 case 1:
                     _a.trys.push([1, , 5, 6]);
                     return [4 /*yield*/, remult.dataProvider.transaction(function (ds) { 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*/, withRemultDataProvider({ dataProvider: ds, remult: remult }, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                                            return tslib_1.__generator(this, function (_a) {
-                                                switch (_a.label) {
-                                                    case 0:
-                                                        remult.liveQueryPublisher = trans;
-                                                        return [4 /*yield*/, what(ds)];
-                                                    case 1:
-                                                        _a.sent();
-                                                        ok = true;
-                                                        return [2 /*return*/];
-                                                }
-                                            });
-                                        }); })];
+                                    case 0:
+                                        remult.dataProvider = ds;
+                                        remult.liveQueryPublisher = trans;
+                                        return [4 /*yield*/, what(ds)];
                                     case 1:
                                         _a.sent();
+                                        ok = true;
                                         return [2 /*return*/];
                                 }
                             });
@@ -575,87 +549,20 @@ var transactionLiveQueryPublisher = /** @class */ (function () {
 }());
 function withRemult(callback, options) {
     return tslib_1.__awaiter(this, void 0, void 0, function () {
-        var remult;
+        var remult, _a;
         var _this = this;
-        return tslib_1.__generator(this, function (_a) {
-            remult = new Remult();
-            return [2 /*return*/, remult_static_js_1.remultStatic.asyncContext.run(remult, function (r) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                    var _a;
-                    var _this = this;
-                    return tslib_1.__generator(this, function (_b) {
-                        switch (_b.label) {
-                            case 0:
-                                _a = remult;
-                                return [4 /*yield*/, (0, initDataProvider_js_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 [4 /*yield*/, callback(r)];
-                            case 2: return [2 /*return*/, _b.sent()];
-                        }
-                    });
-                }); })];
+        return tslib_1.__generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    remult = new Remult();
+                    _a = remult;
+                    return [4 /*yield*/, (0, initDataProvider_js_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); })];
+            }
         });
     });
 }
-var RemultInstanceDataProviderStore = /** @class */ (function () {
-    function RemultInstanceDataProviderStore(dataProvider) {
-        var _this = this;
-        this.getStore = function () { return _this._myDataProviderStore; };
-        this._myDataProviderStore = { dataProvider: dataProvider };
-    }
-    RemultInstanceDataProviderStore.prototype.withDataProvider = function (dataProvider, callback) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var prev;
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!this.asyncStore) {
-                            this.asyncStore =
-                                remult_static_js_1.remultStatic.asyncContext.createDataProviderAsyncLocalStorage();
-                            if (this.asyncStore) {
-                                this.getStore = function () { var _a; return (_a = _this.asyncStore.getStore()) !== null && _a !== void 0 ? _a : _this._myDataProviderStore; };
-                            }
-                        }
-                        if (!this.asyncStore) return [3 /*break*/, 1];
-                        return [2 /*return*/, this.asyncStore.run({ dataProvider: dataProvider }, 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*/, callback()];
-                                        case 1: return [2 /*return*/, _a.sent()];
-                                    }
-                                });
-                            }); })];
-                    case 1:
-                        prev = this._myDataProviderStore;
-                        _a.label = 2;
-                    case 2:
-                        _a.trys.push([2, , 4, 5]);
-                        this._myDataProviderStore = { dataProvider: dataProvider };
-                        return [4 /*yield*/, callback()];
-                    case 3: return [2 /*return*/, _a.sent()];
-                    case 4:
-                        this._myDataProviderStore = prev;
-                        return [7 /*endfinally*/];
-                    case 5: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    return RemultInstanceDataProviderStore;
-}());
-exports.RemultInstanceDataProviderStore = RemultInstanceDataProviderStore;
-function withRemultDataProvider(_a, callback) {
-    var dataProvider = _a.dataProvider, remult = _a.remult;
-    remult = remult !== null && remult !== void 0 ? remult : remult_static_js_1.remultStatic.remultFactory();
-    return remult._myDataProviderStore.withDataProvider(dataProvider, callback);
-}
-function withFetch(fetch, callback) {
-    var remult = remult_static_js_1.remultStatic.remultFactory();
-    return withRemultDataProvider({
-        remult: remult,
-        dataProvider: new rest_data_provider_js_1.RestDataProvider(function () { return (tslib_1.__assign(tslib_1.__assign({}, remult.apiClient), { httpClient: fetch })); }),
-    }, callback);
-}

package/src/data-providers/array-entity-data-provider.js

@@ -441,8 +441,14 @@ var ArrayEntityDataProvider = /** @class */ (function () {
         try {
             for (var _b = tslib_1.__values(this.entity.fields), _c = _b.next(); !_c.done; _c = _b.next()) {
                 var col = _c.value;
-                if (!(0, filter_consumer_bridge_to_sql_request_js_1.isDbReadonly)(col, dbNames))
-                    result[dbNames.$dbNameOf(col)] = col.valueConverter.toJson(row[col.key]);
+                if (!(0, filter_consumer_bridge_to_sql_request_js_1.isDbReadonly)(col, dbNames)) {
+                    var val = row[col.key];
+                    if (val === undefined) {
+                        if (col.allowNull)
+                            val = null;
+                    }
+                    result[dbNames.$dbNameOf(col)] = col.valueConverter.toJson(val);
+                }
             }
         }
         catch (e_13_1) { e_13 = { error: e_13_1 }; }

package/src/remult-proxy.js

@@ -379,14 +379,6 @@ var RemultProxy = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
-    Object.defineProperty(RemultProxy.prototype, "_myDataProviderStore", {
-        /** @internal */
-        get: function () {
-            return remult_static_js_1.remultStatic.remultFactory()._myDataProviderStore;
-        },
-        enumerable: false,
-        configurable: true
-    });
     return RemultProxy;
 }());
 exports.RemultProxy = RemultProxy;