remult 0.25.6-exp.6 → 0.25.6-exp.7

package/esm/src/context.js

@@ -6,12 +6,11 @@ import { RepositoryImplementation, createOldEntity, } from './remult3/Repository
 import { serverActionField } from './server-action-info.js';
 import { buildRestDataProvider, isExternalHttpProvider, } from './buildRestDataProvider.js';
 import { verifyFieldRelationInfo } from './remult3/relationInfoMember.js';
-import { remultStatic } from './remult-static.js';
+import { remultStatic, resetFactory } from './remult-static.js';
 export class RemultAsyncLocalStorage {
     remultObjectStorage;
     static enable() {
-        ;
-        remult.remultFactory = () => {
+        remultStatic.remultFactory = () => {
             const r = remultStatic.asyncContext.getRemult();
             if (r)
                 return r;
@@ -20,8 +19,7 @@ export class RemultAsyncLocalStorage {
         };
     }
     static disable() {
-        ;
-        remult.resetFactory();
+        resetFactory();
     }
     constructor(remultObjectStorage) {
         this.remultObjectStorage = remultObjectStorage;

package/esm/src/filter/filter-consumer-bridge-to-sql-request.js

@@ -159,15 +159,18 @@ export function shouldNotCreateField(field, dbNames) {
     return (field.isServerExpression ||
         (field.options.sqlExpression && field.dbName != dbNames.$dbNameOf(field)));
 }
-export async function dbNamesOf(repo, wrapIdentifier) {
+export async function dbNamesOf(repo, wrapIdentifierOrOptions) {
+    let options = typeof wrapIdentifierOrOptions === 'function'
+        ? { wrapIdentifier: wrapIdentifierOrOptions }
+        : wrapIdentifierOrOptions || {};
     var meta = getEntityMetadata(repo);
-    if (!wrapIdentifier) {
-        wrapIdentifier = remult.dataProvider.wrapIdentifier;
+    if (!options.wrapIdentifier) {
+        options.wrapIdentifier = remult.dataProvider.wrapIdentifier;
     }
-    if (!wrapIdentifier)
-        wrapIdentifier = (x) => x;
+    if (!options.wrapIdentifier)
+        options.wrapIdentifier = (x) => x;
     const result = {
-        $entityName: await entityDbName(meta, wrapIdentifier),
+        $entityName: await entityDbName(meta, options.wrapIdentifier),
         toString: () => result.$entityName,
         $dbNameOf: (field) => {
             var key;
@@ -179,7 +182,14 @@ export async function dbNamesOf(repo, wrapIdentifier) {
         },
     };
     for (const field of meta.fields) {
-        result[field.key] = await fieldDbName(field, meta, wrapIdentifier);
+        let r = await fieldDbName(field, meta, options.wrapIdentifier);
+        if (!field.options.sqlExpression)
+            if (typeof options.tableName === 'string')
+                r = options.wrapIdentifier(options.tableName) + '.' + r;
+            else if (options.tableName === true) {
+                r = result.$entityName + '.' + r;
+            }
+        result[field.key] = r;
     }
     return result;
 }
@@ -203,9 +213,9 @@ export async function fieldDbName(f, meta, wrapIdentifier = (x) => x) {
                     f.options.sqlExpression =
                         "recursive sqlExpression call for field '" + f.key + "'. ";
                     result = await prev(meta);
+                    f.options.sqlExpression = () => result;
                 }
                 finally {
-                    f.options.sqlExpression = prev;
                 }
             }
             else

package/esm/src/remult-proxy.js

@@ -1,79 +1,75 @@
-import { defaultFactory } from './remult-static.js';
+import { remultStatic } from './remult-static.js';
 import { getInternalKey } from './remult3/repository-internals.js';
 /*@internal*/
 export class RemultProxy {
+    /* @internal*/
+    iAmRemultProxy = true;
     /* @internal*/
     get liveQuerySubscriber() {
-        return this.remultFactory().liveQuerySubscriber;
+        return remultStatic.remultFactory().liveQuerySubscriber;
     }
     /* @internal*/
     set liveQuerySubscriber(val) {
-        this.remultFactory().liveQuerySubscriber = val;
+        remultStatic.remultFactory().liveQuerySubscriber = val;
     }
     /* @internal*/
     get liveQueryStorage() {
-        return this.remultFactory().liveQueryStorage;
+        return remultStatic.remultFactory().liveQueryStorage;
     }
     /* @internal*/
     set liveQueryStorage(val) {
-        this.remultFactory().liveQueryStorage = val;
+        remultStatic.remultFactory().liveQueryStorage = val;
     }
     /* @internal*/
     get liveQueryPublisher() {
-        return this.remultFactory().liveQueryPublisher;
+        return remultStatic.remultFactory().liveQueryPublisher;
     }
     /* @internal*/
     set liveQueryPublisher(val) {
-        this.remultFactory().liveQueryPublisher = val;
+        remultStatic.remultFactory().liveQueryPublisher = val;
     }
     call(backendMethod, self, ...args) {
-        return this.remultFactory().call(backendMethod, self, ...args);
+        return remultStatic.remultFactory().call(backendMethod, self, ...args);
     }
     get context() {
-        return this.remultFactory().context;
+        return remultStatic.remultFactory().context;
     }
     get dataProvider() {
-        return this.remultFactory().dataProvider;
+        return remultStatic.remultFactory().dataProvider;
     }
     set dataProvider(provider) {
-        this.remultFactory().dataProvider = provider;
+        remultStatic.remultFactory().dataProvider = provider;
     }
     /*@internal*/
     get repCache() {
-        return this.remultFactory().repCache;
+        return remultStatic.remultFactory().repCache;
     }
     authenticated() {
-        return this.remultFactory().authenticated();
+        return remultStatic.remultFactory().authenticated();
     }
     isAllowed(roles) {
-        return this.remultFactory().isAllowed(roles);
+        return remultStatic.remultFactory().isAllowed(roles);
     }
     isAllowedForInstance(instance, allowed) {
-        return this.remultFactory().isAllowedForInstance(instance, allowed);
+        return remultStatic.remultFactory().isAllowedForInstance(instance, allowed);
     }
     clearAllCache() {
-        return this.remultFactory().clearAllCache();
-    }
-    /*@internal*/
-    remultFactory = () => defaultFactory();
-    /*@internal*/
-    resetFactory() {
-        this.remultFactory = () => defaultFactory();
+        return remultStatic.remultFactory().clearAllCache();
     }
     repoCache = new Map();
     //@ts-ignore
     repo = (...args) => {
-        let self = this;
-        let entityCache = self.repoCache.get(args[0]);
+        let self = remultStatic;
+        let entityCache = this.repoCache.get(args[0]);
         if (!entityCache) {
-            self.repoCache.set(args[0], (entityCache = new Map()));
+            this.repoCache.set(args[0], (entityCache = new Map()));
         }
         let result = entityCache.get(args[1]);
         if (result)
             return result;
         result = {
             get fields() {
-                return self.remultFactory().repo(...args).metadata.fields;
+                return remultStatic.remultFactory().repo(...args).metadata.fields;
             },
             //@ts-ignore
             [getInternalKey]() {
@@ -144,7 +140,7 @@ export class RemultProxy {
                 .repo(...args)
                 .liveQuery(...args2),
             get metadata() {
-                return self.remultFactory().repo(...args).metadata;
+                return remultStatic.remultFactory().repo(...args).metadata;
             },
             query: (...args2) => self
                 .remultFactory()
@@ -163,22 +159,22 @@ export class RemultProxy {
         return result;
     };
     get user() {
-        return this.remultFactory().user;
+        return remultStatic.remultFactory().user;
     }
     set user(info) {
-        this.remultFactory().user = info;
+        remultStatic.remultFactory().user = info;
     }
     get apiClient() {
-        return this.remultFactory().apiClient;
+        return remultStatic.remultFactory().apiClient;
     }
     set apiClient(client) {
-        this.remultFactory().apiClient = client;
+        remultStatic.remultFactory().apiClient = client;
     }
     get subscriptionServer() {
-        return this.remultFactory().subscriptionServer;
+        return remultStatic.remultFactory().subscriptionServer;
     }
     set subscriptionServer(value) {
-        this.remultFactory().subscriptionServer = value;
+        remultStatic.remultFactory().subscriptionServer = value;
     }
 }
 export const remult = new RemultProxy();

package/esm/src/remult-static.js

@@ -1,6 +1,7 @@
 const remultStaticKey = Symbol.for('remult-static1');
 let x = {
     defaultRemultFactory: undefined,
+    remultFactory: undefined,
     defaultRemult: undefined,
     asyncContext: undefined,
     columnsOfType: new Map(),
@@ -34,3 +35,7 @@ export function defaultFactory() {
     }
     return remultStatic.defaultRemult;
 }
+export function resetFactory() {
+    remultStatic.remultFactory = () => defaultFactory();
+}
+resetFactory();

package/esm/src/remult3/RepositoryImplementation.js

@@ -785,8 +785,8 @@ class rowHelperBase {
         this.isNewRow = isNewRow;
         {
             let fac = remult;
-            if (fac != null && fac.remultFactory) {
-                remult = fac.remultFactory();
+            if (fac != null && fac.iAmRemultProxy) {
+                remult = remultStatic.remultFactory();
             }
         }
         for (const col of fieldsMetadata) {

package/index.d.ts

@@ -19,7 +19,7 @@ export { RestDataProvider } from './src/data-providers/rest-data-provider.js';
 export { InMemoryDataProvider } from './src/data-providers/in-memory-database.js';
 export { WebSqlDataProvider } from './src/data-providers/web-sql-data-provider.js';
 export { SqlDatabase } from './src/data-providers/sql-database.js';
-export { CustomSqlFilterObject, CustomSqlFilterBuilder, dbNamesOf, CustomSqlFilterBuilderFunction, EntityDbNames, } from './src/filter/filter-consumer-bridge-to-sql-request.js';
+export { CustomSqlFilterObject, CustomSqlFilterBuilder, dbNamesOf, dbNamesOfOptions, CustomSqlFilterBuilderFunction, EntityDbNames, } from './src/filter/filter-consumer-bridge-to-sql-request.js';
 export { JsonDataProvider, JsonEntityStorage, } from './src/data-providers/json-data-provider.js';
 export { JsonEntityOpfsStorage } from './src/data-providers/json-entity-opfs-storage.js';
 export { Controller, BackendMethodOptions, BackendMethod, ProgressListener, } from './src/server-action.js';

package/package.json

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

package/src/context.js

@@ -16,8 +16,7 @@ var RemultAsyncLocalStorage = /** @class */ (function () {
         this.remultObjectStorage = remultObjectStorage;
     }
     RemultAsyncLocalStorage.enable = function () {
-        ;
-        remult_proxy_js_1.remult.remultFactory = function () {
+        remult_static_js_1.remultStatic.remultFactory = function () {
             var r = remult_static_js_1.remultStatic.asyncContext.getRemult();
             if (r)
                 return r;
@@ -26,8 +25,7 @@ var RemultAsyncLocalStorage = /** @class */ (function () {
         };
     };
     RemultAsyncLocalStorage.disable = function () {
-        ;
-        remult_proxy_js_1.remult.resetFactory();
+        (0, remult_static_js_1.resetFactory)();
     };
     RemultAsyncLocalStorage.prototype.run = function (remult, callback) {
         if (this.remultObjectStorage)

package/src/filter/filter-consumer-bridge-to-sql-request.d.ts

@@ -49,6 +49,10 @@ export declare type EntityDbNamesBase = {
 export declare type EntityDbNames<entityType> = {
     [Properties in keyof Required<MembersOnly<entityType>>]: string;
 } & EntityDbNamesBase;
-export declare function dbNamesOf<entityType>(repo: EntityMetadataOverloads<entityType>, wrapIdentifier?: (name: string) => string): Promise<EntityDbNames<entityType>>;
+export interface dbNamesOfOptions {
+    wrapIdentifier?: (name: string) => string;
+    tableName?: boolean | string;
+}
+export declare function dbNamesOf<entityType>(repo: EntityMetadataOverloads<entityType>, wrapIdentifierOrOptions?: ((name: string) => string) | dbNamesOfOptions): Promise<EntityDbNames<entityType>>;
 export declare function entityDbName(metadata: EntityMetadata, wrapIdentifier?: (name: string) => string): Promise<string>;
 export declare function fieldDbName(f: FieldMetadata, meta: EntityMetadata, wrapIdentifier?: (name: string) => string): Promise<string>;

package/src/filter/filter-consumer-bridge-to-sql-request.js

@@ -269,25 +269,28 @@ function shouldNotCreateField(field, dbNames) {
         (field.options.sqlExpression && field.dbName != dbNames.$dbNameOf(field)));
 }
 exports.shouldNotCreateField = shouldNotCreateField;
-function dbNamesOf(repo, wrapIdentifier) {
+function dbNamesOf(repo, wrapIdentifierOrOptions) {
     return tslib_1.__awaiter(this, void 0, void 0, function () {
-        var meta, result, _a, _b, field, _c, _d, e_3_1;
-        var _e, e_3, _f;
-        return tslib_1.__generator(this, function (_g) {
-            switch (_g.label) {
+        var options, meta, result, _a, _b, field, r, e_3_1;
+        var _c, e_3, _d;
+        return tslib_1.__generator(this, function (_e) {
+            switch (_e.label) {
                 case 0:
+                    options = typeof wrapIdentifierOrOptions === 'function'
+                        ? { wrapIdentifier: wrapIdentifierOrOptions }
+                        : wrapIdentifierOrOptions || {};
                     meta = (0, RepositoryImplementation_js_1.getEntityMetadata)(repo);
-                    if (!wrapIdentifier) {
-                        wrapIdentifier = remult_proxy_js_1.remult.dataProvider.wrapIdentifier;
+                    if (!options.wrapIdentifier) {
+                        options.wrapIdentifier = remult_proxy_js_1.remult.dataProvider.wrapIdentifier;
                     }
-                    if (!wrapIdentifier)
-                        wrapIdentifier = function (x) { return x; };
-                    _e = {};
-                    return [4 /*yield*/, entityDbName(meta, wrapIdentifier)];
+                    if (!options.wrapIdentifier)
+                        options.wrapIdentifier = function (x) { return x; };
+                    _c = {};
+                    return [4 /*yield*/, entityDbName(meta, options.wrapIdentifier)];
                 case 1:
-                    result = (_e.$entityName = _g.sent(),
-                        _e.toString = function () { return result.$entityName; },
-                        _e.$dbNameOf = function (field) {
+                    result = (_c.$entityName = _e.sent(),
+                        _c.toString = function () { return result.$entityName; },
+                        _c.$dbNameOf = function (field) {
                             var key;
                             if (typeof field === 'string')
                                 key = field;
@@ -295,32 +298,37 @@ function dbNamesOf(repo, wrapIdentifier) {
                                 key = field.key;
                             return result[key];
                         },
-                        _e);
-                    _g.label = 2;
+                        _c);
+                    _e.label = 2;
                 case 2:
-                    _g.trys.push([2, 7, 8, 9]);
+                    _e.trys.push([2, 7, 8, 9]);
                     _a = tslib_1.__values(meta.fields), _b = _a.next();
-                    _g.label = 3;
+                    _e.label = 3;
                 case 3:
                     if (!!_b.done) return [3 /*break*/, 6];
                     field = _b.value;
-                    _c = result;
-                    _d = field.key;
-                    return [4 /*yield*/, fieldDbName(field, meta, wrapIdentifier)];
+                    return [4 /*yield*/, fieldDbName(field, meta, options.wrapIdentifier)];
                 case 4:
-                    _c[_d] = _g.sent();
-                    _g.label = 5;
+                    r = _e.sent();
+                    if (!field.options.sqlExpression)
+                        if (typeof options.tableName === 'string')
+                            r = options.wrapIdentifier(options.tableName) + '.' + r;
+                        else if (options.tableName === true) {
+                            r = result.$entityName + '.' + r;
+                        }
+                    result[field.key] = r;
+                    _e.label = 5;
                 case 5:
                     _b = _a.next();
                     return [3 /*break*/, 3];
                 case 6: return [3 /*break*/, 9];
                 case 7:
-                    e_3_1 = _g.sent();
+                    e_3_1 = _e.sent();
                     e_3 = { error: e_3_1 };
                     return [3 /*break*/, 9];
                 case 8:
                     try {
-                        if (_b && !_b.done && (_f = _a.return)) _f.call(_a);
+                        if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
                     }
                     finally { if (e_3) throw e_3.error; }
                     return [7 /*endfinally*/];
@@ -352,13 +360,12 @@ exports.entityDbName = entityDbName;
 function fieldDbName(f, meta, wrapIdentifier) {
     if (wrapIdentifier === void 0) { wrapIdentifier = function (x) { return x; }; }
     return tslib_1.__awaiter(this, void 0, void 0, function () {
-        var result, prev, rel, field, fInfo;
+        var result_1, prev, rel, field, fInfo;
         return tslib_1.__generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
                     _a.trys.push([0, , 8, 9]);
                     if (!f.options.sqlExpression) return [3 /*break*/, 7];
-                    result = void 0;
                     if (!(typeof f.options.sqlExpression === 'function')) return [3 /*break*/, 5];
                     prev = f.options.sqlExpression;
                     _a.label = 1;
@@ -368,19 +375,18 @@ function fieldDbName(f, meta, wrapIdentifier) {
                         "recursive sqlExpression call for field '" + f.key + "'. ";
                     return [4 /*yield*/, prev(meta)];
                 case 2:
-                    result = _a.sent();
+                    result_1 = _a.sent();
+                    f.options.sqlExpression = function () { return result_1; };
                     return [3 /*break*/, 4];
-                case 3:
-                    f.options.sqlExpression = prev;
-                    return [7 /*endfinally*/];
+                case 3: return [7 /*endfinally*/];
                 case 4: return [3 /*break*/, 6];
                 case 5:
-                    result = f.options.sqlExpression;
+                    result_1 = f.options.sqlExpression;
                     _a.label = 6;
                 case 6:
-                    if (!result)
+                    if (!result_1)
                         return [2 /*return*/, f.dbName];
-                    return [2 /*return*/, result];
+                    return [2 /*return*/, result_1];
                 case 7:
                     rel = (0, relationInfoMember_js_1.getRelationFieldInfo)(f);
                     field = (rel === null || rel === void 0 ? void 0 : rel.type) === 'toOne' &&

package/src/remult-proxy.js

@@ -8,8 +8,8 @@ var repository_internals_js_1 = require("./remult3/repository-internals.js");
 var RemultProxy = /** @class */ (function () {
     function RemultProxy() {
         var _this = this;
-        /*@internal*/
-        this.remultFactory = function () { return (0, remult_static_js_1.defaultFactory)(); };
+        /* @internal*/
+        this.iAmRemultProxy = true;
         this.repoCache = new Map();
         //@ts-ignore
         this.repo = function () {
@@ -18,10 +18,10 @@ var RemultProxy = /** @class */ (function () {
             for (var _i = 0; _i < arguments.length; _i++) {
                 args[_i] = arguments[_i];
             }
-            var self = _this;
-            var entityCache = self.repoCache.get(args[0]);
+            var self = remult_static_js_1.remultStatic;
+            var entityCache = _this.repoCache.get(args[0]);
             if (!entityCache) {
-                self.repoCache.set(args[0], (entityCache = new Map()));
+                _this.repoCache.set(args[0], (entityCache = new Map()));
             }
             var result = entityCache.get(args[1]);
             if (result)
@@ -29,7 +29,7 @@ var RemultProxy = /** @class */ (function () {
             result = (_a = {
                     get fields() {
                         var _a;
-                        return (_a = self.remultFactory()).repo.apply(_a, tslib_1.__spreadArray([], tslib_1.__read(args), false)).metadata.fields;
+                        return (_a = remult_static_js_1.remultStatic.remultFactory()).repo.apply(_a, tslib_1.__spreadArray([], tslib_1.__read(args), false)).metadata.fields;
                     }
                 },
                 //@ts-ignore
@@ -178,7 +178,7 @@ var RemultProxy = /** @class */ (function () {
                 Object.defineProperty(_a, "metadata", {
                     get: function () {
                         var _a;
-                        return (_a = self.remultFactory()).repo.apply(_a, tslib_1.__spreadArray([], tslib_1.__read(args), false)).metadata;
+                        return (_a = remult_static_js_1.remultStatic.remultFactory()).repo.apply(_a, tslib_1.__spreadArray([], tslib_1.__read(args), false)).metadata;
                     },
                     enumerable: false,
                     configurable: true
@@ -214,11 +214,11 @@ var RemultProxy = /** @class */ (function () {
     Object.defineProperty(RemultProxy.prototype, "liveQuerySubscriber", {
         /* @internal*/
         get: function () {
-            return this.remultFactory().liveQuerySubscriber;
+            return remult_static_js_1.remultStatic.remultFactory().liveQuerySubscriber;
         },
         /* @internal*/
         set: function (val) {
-            this.remultFactory().liveQuerySubscriber = val;
+            remult_static_js_1.remultStatic.remultFactory().liveQuerySubscriber = val;
         },
         enumerable: false,
         configurable: true
@@ -226,11 +226,11 @@ var RemultProxy = /** @class */ (function () {
     Object.defineProperty(RemultProxy.prototype, "liveQueryStorage", {
         /* @internal*/
         get: function () {
-            return this.remultFactory().liveQueryStorage;
+            return remult_static_js_1.remultStatic.remultFactory().liveQueryStorage;
         },
         /* @internal*/
         set: function (val) {
-            this.remultFactory().liveQueryStorage = val;
+            remult_static_js_1.remultStatic.remultFactory().liveQueryStorage = val;
         },
         enumerable: false,
         configurable: true
@@ -238,11 +238,11 @@ var RemultProxy = /** @class */ (function () {
     Object.defineProperty(RemultProxy.prototype, "liveQueryPublisher", {
         /* @internal*/
         get: function () {
-            return this.remultFactory().liveQueryPublisher;
+            return remult_static_js_1.remultStatic.remultFactory().liveQueryPublisher;
         },
         /* @internal*/
         set: function (val) {
-            this.remultFactory().liveQueryPublisher = val;
+            remult_static_js_1.remultStatic.remultFactory().liveQueryPublisher = val;
         },
         enumerable: false,
         configurable: true
@@ -253,21 +253,21 @@ var RemultProxy = /** @class */ (function () {
         for (var _i = 2; _i < arguments.length; _i++) {
             args[_i - 2] = arguments[_i];
         }
-        return (_a = this.remultFactory()).call.apply(_a, tslib_1.__spreadArray([backendMethod, self], tslib_1.__read(args), false));
+        return (_a = remult_static_js_1.remultStatic.remultFactory()).call.apply(_a, tslib_1.__spreadArray([backendMethod, self], tslib_1.__read(args), false));
     };
     Object.defineProperty(RemultProxy.prototype, "context", {
         get: function () {
-            return this.remultFactory().context;
+            return remult_static_js_1.remultStatic.remultFactory().context;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(RemultProxy.prototype, "dataProvider", {
         get: function () {
-            return this.remultFactory().dataProvider;
+            return remult_static_js_1.remultStatic.remultFactory().dataProvider;
         },
         set: function (provider) {
-            this.remultFactory().dataProvider = provider;
+            remult_static_js_1.remultStatic.remultFactory().dataProvider = provider;
         },
         enumerable: false,
         configurable: true
@@ -275,53 +275,49 @@ var RemultProxy = /** @class */ (function () {
     Object.defineProperty(RemultProxy.prototype, "repCache", {
         /*@internal*/
         get: function () {
-            return this.remultFactory().repCache;
+            return remult_static_js_1.remultStatic.remultFactory().repCache;
         },
         enumerable: false,
         configurable: true
     });
     RemultProxy.prototype.authenticated = function () {
-        return this.remultFactory().authenticated();
+        return remult_static_js_1.remultStatic.remultFactory().authenticated();
     };
     RemultProxy.prototype.isAllowed = function (roles) {
-        return this.remultFactory().isAllowed(roles);
+        return remult_static_js_1.remultStatic.remultFactory().isAllowed(roles);
     };
     RemultProxy.prototype.isAllowedForInstance = function (instance, allowed) {
-        return this.remultFactory().isAllowedForInstance(instance, allowed);
+        return remult_static_js_1.remultStatic.remultFactory().isAllowedForInstance(instance, allowed);
     };
     RemultProxy.prototype.clearAllCache = function () {
-        return this.remultFactory().clearAllCache();
-    };
-    /*@internal*/
-    RemultProxy.prototype.resetFactory = function () {
-        this.remultFactory = function () { return (0, remult_static_js_1.defaultFactory)(); };
+        return remult_static_js_1.remultStatic.remultFactory().clearAllCache();
     };
     Object.defineProperty(RemultProxy.prototype, "user", {
         get: function () {
-            return this.remultFactory().user;
+            return remult_static_js_1.remultStatic.remultFactory().user;
         },
         set: function (info) {
-            this.remultFactory().user = info;
+            remult_static_js_1.remultStatic.remultFactory().user = info;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(RemultProxy.prototype, "apiClient", {
         get: function () {
-            return this.remultFactory().apiClient;
+            return remult_static_js_1.remultStatic.remultFactory().apiClient;
         },
         set: function (client) {
-            this.remultFactory().apiClient = client;
+            remult_static_js_1.remultStatic.remultFactory().apiClient = client;
         },
         enumerable: false,
         configurable: true
     });
     Object.defineProperty(RemultProxy.prototype, "subscriptionServer", {
         get: function () {
-            return this.remultFactory().subscriptionServer;
+            return remult_static_js_1.remultStatic.remultFactory().subscriptionServer;
         },
         set: function (value) {
-            this.remultFactory().subscriptionServer = value;
+            remult_static_js_1.remultStatic.remultFactory().subscriptionServer = value;
         },
         enumerable: false,
         configurable: true

package/src/remult-static.d.ts

@@ -3,6 +3,7 @@ import type { ClassHelper, Remult, RemultAsyncLocalStorage } from './context.js'
 import type { columnInfo } from './remult3/columnInfo.js';
 export declare const remultStatic: {
     defaultRemultFactory: () => Remult;
+    remultFactory: () => Remult;
     defaultRemult: Remult;
     asyncContext: RemultAsyncLocalStorage;
     columnsOfType: Map<any, columnInfo[]>;
@@ -20,3 +21,4 @@ export declare const remultStatic: {
     captionTransformer: any;
 };
 export declare function defaultFactory(): Remult;
+export declare function resetFactory(): void;

package/src/remult-static.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultFactory = exports.remultStatic = void 0;
+exports.resetFactory = exports.defaultFactory = exports.remultStatic = void 0;
 var remultStaticKey = Symbol.for('remult-static1');
 var x = {
     defaultRemultFactory: undefined,
+    remultFactory: undefined,
     defaultRemult: undefined,
     asyncContext: undefined,
     columnsOfType: new Map(),
@@ -38,3 +39,8 @@ function defaultFactory() {
     return exports.remultStatic.defaultRemult;
 }
 exports.defaultFactory = defaultFactory;
+function resetFactory() {
+    exports.remultStatic.remultFactory = function () { return defaultFactory(); };
+}
+exports.resetFactory = resetFactory;
+resetFactory();

package/src/remult3/RepositoryImplementation.js

@@ -1258,8 +1258,8 @@ var rowHelperBase = /** @class */ (function () {
         this.originalValues = {};
         {
             var fac = remult;
-            if (fac != null && fac.remultFactory) {
-                remult = fac.remultFactory();
+            if (fac != null && fac.iAmRemultProxy) {
+                remult = remult_static_js_1.remultStatic.remultFactory();
             }
         }
         var _loop_5 = function (col) {