remult 0.16.0-exp.8 → 0.16.0-exp.9

package/esm/index.d.ts

@@ -12,7 +12,7 @@ export { SqlDatabase, } from './src/data-providers/sql-database';
 export { CustomSqlFilterObject, CustomSqlFilterBuilder } from './src/filter/filter-consumer-bridge-to-sql-request';
 export { JsonDataProvider, JsonEntityStorage } from './src/data-providers/json-data-provider';
 export { Controller, BackendMethodOptions, BackendMethod, ProgressListener } from './src/server-action';
-export { Allowed, Allow, Remult, RemultContext, isBackend, AllowedForInstance, EventDispatcher, EventSource, HttpProvider, Unobserve, UserInfo } from './src/context';
+export { Allowed, Allow, Remult, RemultContext, ApiClient, isBackend, AllowedForInstance, EventDispatcher, EventSource, ExternalHttpProvider, Unobserve, UserInfo } from './src/context';
 export { IdEntity } from './src/id-entity';
 export { SortSegment, Sort } from './src/sort';
 export { OneToMany, CompoundIdField } from './src/column';

package/esm/postgres/postgres-data-provider.js

@@ -81,14 +81,14 @@ export async function createPostgresConnection(options) {
     }
     const db = new SqlDatabase(new PostgresDataProvider(new Pool(config)));
     let remult = new Remult();
-    remult.setDataProvider(db);
+    remult.dataProvider = (db);
     if (options.autoCreateTables === undefined || options.autoCreateTables)
         await verifyStructureOfAllEntities(db, remult);
     return db;
 }
 export async function preparePostgresQueueStorage(sql) {
     let c = new Remult();
-    c.setDataProvider(sql);
+    c.dataProvider = (sql);
     let JobsInQueueEntity = (await import('../server/expressBridge')).JobsInQueueEntity;
     let e = c.repo(JobsInQueueEntity);
     await new PostgresSchemaBuilder(sql).createIfNotExist(e.metadata);

package/esm/server/expressBridge.js

@@ -54,7 +54,7 @@ export function createRemultServer(options) {
         options.controllers = allControllers;
     }
     if (options.rootPath === undefined)
-        options.rootPath = Remult.apiBaseUrl;
+        options.rootPath = '/api';
     actionInfo.runningOnServer = true;
     let bridge = new RemultServerImplementation(new inProcessQueueHandler(options.queueStorage), options, dataProvider);
     return bridge;
@@ -123,7 +123,8 @@ class RemultServerImplementation {
                             else
                                 res.success(job.info);
                         });
-                    }
+                    },
+                    doWork: undefined
                 }, r);
         }
         this.options.entities.forEach(e => {
@@ -155,7 +156,7 @@ class RemultServerImplementation {
             let myReq = new ExpressRequestBridgeToDataApiRequest(req);
             let myRes = new ExpressResponseBridgeToDataApiResponse(res, req);
             let remult = new Remult();
-            remult.setDataProvider(await this.dataProvider);
+            remult.dataProvider = (await this.dataProvider);
             await new Promise(res => {
                 remultObjectStorage.run(remult, async () => {
                     if (req) {
@@ -168,7 +169,7 @@ class RemultServerImplementation {
                                 user = req['auth'];
                         }
                         if (user)
-                            remult.setUser(user);
+                            remult.user = (user);
                     }
                     if (this.options.initRequest) {
                         await this.options.initRequest(remult, req);

package/esm/src/backend-tests/test-http-server.backend-spec.js

@@ -1,13 +1,14 @@
 import { __decorate, __metadata } from "tslib";
 import axios from 'axios';
 import { remultFresh } from '../../remult-fresh';
-import { HttpProviderBridgeToRestDataProviderHttpProvider, Remult } from '../context';
+import { Remult } from '../context';
 import { InMemoryDataProvider } from '../data-providers/in-memory-database';
+import { remult } from '../remult-proxy';
 import { Entity, Fields } from '../remult3';
 import { BackendMethod } from '../server-action';
 import { Categories } from '../tests/remult-3-entities';
-Remult.apiBaseUrl = 'http://localhost:3003/api';
-let path = Remult.apiBaseUrl + '/tasks';
+remult.apiClient.url = 'http://localhost:3003/api';
+let path = remult.apiClient.url + '/tasks';
 const environments = [
 // ["next", 3000],
 // ["nest", 3001],
@@ -21,8 +22,8 @@ const environments = [
 function test(name, test) {
     for (const [env, port] of environments) {
         const theTest = async () => {
-            Remult.apiBaseUrl = `http://localhost:${port}/api`;
-            path = Remult.apiBaseUrl + '/tasks';
+            remult.apiClient.url = `http://localhost:${port}/api`;
+            path = remult.apiClient.url + '/tasks';
             await test();
         };
         const testName = env + ` ${port}: ${name}`;
@@ -93,7 +94,7 @@ test("test http 201", async () => {
 });
 test("test regular api call", async () => {
     await create3Tasks();
-    let result = await axios.get(Remult.apiBaseUrl + "/test");
+    let result = await axios.get(remult.apiClient.url + "/test");
     expect(result.data.result).toBe(3);
 });
 class FreshResponseTest {
@@ -106,9 +107,11 @@ class FreshResponseTest {
     }
 }
 it("test fresh", async () => {
-    const api = remultFresh({ entities: [Categories],
+    const api = remultFresh({
+        entities: [Categories],
         dataProvider: new InMemoryDataProvider(),
-        rootPath: '/api' }, FreshResponseTest);
+        rootPath: '/api'
+    }, FreshResponseTest);
     const r = await api.handle({
         url: '/api/Categories',
         json() {
@@ -158,7 +161,7 @@ Task = __decorate([
 export { Task };
 async function create3Tasks() {
     const remult = new Remult(axios);
-    Remult.defaultHttpProvider = new HttpProviderBridgeToRestDataProviderHttpProvider(axios);
+    remult.apiClient.httpClient = axios;
     const taskRepo = remult.repo(Task);
     for (const task of await taskRepo.find()) {
         await taskRepo.delete(task);

package/esm/src/context.d.ts

@@ -1,7 +1,8 @@
 import { DataProvider, RestDataProviderHttpProvider } from "./data-interfaces";
+import { RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider';
 import { EntityMetadata, EntityRef, FindOptions, Repository } from "./remult3";
 import { ClassType } from "../classType";
-export interface HttpProvider {
+export interface ExternalHttpProvider {
     post(url: string, data: any): Promise<any> | {
         toPromise(): Promise<any>;
     };
@@ -17,7 +18,7 @@ export interface HttpProvider {
 }
 export declare class HttpProviderBridgeToRestDataProviderHttpProvider implements RestDataProviderHttpProvider {
     private http;
-    constructor(http: HttpProvider);
+    constructor(http: ExternalHttpProvider);
     post(url: string, data: any): Promise<any>;
     delete(url: string): Promise<void>;
     put(url: string, data: any): Promise<any>;
@@ -37,10 +38,7 @@ export declare class Remult {
      *
      */
     repo<T>(entity: ClassType<T>, dataProvider?: DataProvider): Repository<T>;
-    /** Returns the current user's info */
-    get user(): UserInfo;
-    /** Set's the current user info */
-    setUser(info: UserInfo | undefined): Promise<void>;
+    user?: UserInfo;
     /** Checks if a user was authenticated */
     authenticated(): boolean;
     /** checks if the user has any of the roles specified in the parameters
@@ -55,35 +53,32 @@ export declare class Remult {
      * [Allowed](https://remult.dev/docs/allowed.html)
      */
     isAllowedForInstance(instance: any, allowed?: AllowedForInstance<any>): boolean;
-    /** returns a dispatcher object that fires once a user has changed*/
-    get userChange(): EventDispatcher;
-    static defaultHttpProvider: RestDataProviderHttpProvider;
-    static setDefaultHttpProvider(provider: HttpProvider | typeof fetch): void;
     /** 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.
      *
      * If no provider is specified, `fetch` will be used as an http provider
      */
-    constructor(provider?: HttpProvider | DataProvider | typeof fetch);
-    /** The api Base Url to be used in all remult calls. by default it's set to `/api`.
-     *
-     * Set this property in case you want to determine a non relative api url
-     */
-    static apiBaseUrl: string;
+    constructor(http: ExternalHttpProvider | typeof fetch | ApiClient);
+    constructor(p: DataProvider);
+    constructor();
+    call<T extends ((...args: any[]) => Promise<Y>), Y>(backendMethod: T, self?: any): T;
     /** The current data provider */
-    _dataSource: DataProvider;
-    /** sets the current data provider */
-    setDataProvider(dataProvider: DataProvider): void;
+    dataProvider: DataProvider;
     /** A helper callback that can be used to debug and trace all find operations. Useful in debugging scenarios */
     static onFind: (metadata: EntityMetadata, options: FindOptions<any>) => void;
     clearAllCache(): any;
     /** A helper callback that is called whenever an entity is created. */
     static entityRefInit?: (ref: EntityRef<any>, row: any) => void;
     readonly context: RemultContext;
+    apiClient: ApiClient;
 }
 export interface RemultContext {
 }
+export interface ApiClient {
+    httpClient?: ExternalHttpProvider | typeof fetch;
+    url?: string;
+}
 export declare const allEntities: ClassType<any>[];
 export interface ControllerOptions {
     key: string;
@@ -95,6 +90,7 @@ export declare class ClassHelper {
 export declare class MethodHelper {
     classes: Map<any, ControllerOptions>;
 }
+export declare function buildRestDataProvider(provider: ExternalHttpProvider | typeof fetch): RestDataProviderHttpProvider | RestDataProviderHttpProviderUsingFetch;
 export declare function setControllerSettings(target: any, options: ControllerOptions): void;
 export interface UserInfo {
     id: string;

package/esm/src/context.js

@@ -1,4 +1,4 @@
-import { actionInfo } from './server-action';
+import { actionInfo, serverActionField } from './server-action';
 import { RestDataProvider, RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider';
 import { RepositoryImplementation } from "./remult3/RepositoryImplementation";
 export class HttpProviderBridgeToRestDataProviderHttpProvider {
@@ -75,6 +75,8 @@ export async function processHttpException(ex) {
             message: error,
         };
     }
+    if (z.modelState)
+        error.modelState = z.modelState;
     let httpStatusCode = z.status;
     if (httpStatusCode === undefined)
         httpStatusCode = z.response?.status;
@@ -90,27 +92,31 @@ export function isBackend() {
     return actionInfo.runningOnServer;
 }
 export class Remult {
-    /** 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.
-     *
-     * If no provider is specified, `fetch` will be used as an http provider
-     */
     constructor(provider) {
-        /* @internal */
-        this._userChangeEvent = new EventSource();
         /* @internal */
         this.repCache = new Map();
+        /** The current data provider */
+        this.dataProvider = new RestDataProvider(() => this.apiClient);
         this.context = {};
+        this.apiClient = {
+            url: '/api'
+        };
         if (provider && provider.getEntityDataProvider) {
-            this._dataSource = provider;
+            this.dataProvider = provider;
             return;
         }
-        let httpDataProvider = buildRestDataProvider(provider);
-        if (!httpDataProvider) {
-            httpDataProvider = new UseDefaultRestDataProviderHttpProvider();
+        if (isExternalHttpProvider(provider)) {
+            this.apiClient.httpClient = provider;
+        }
+        else if (typeof (provider) === "function")
+            this.apiClient.httpClient = provider;
+        else if (provider) {
+            const apiClient = provider;
+            if (apiClient.httpClient)
+                this.apiClient.httpClient = apiClient.httpClient;
+            if (apiClient.url)
+                this.apiClient.url = apiClient.url;
         }
-        this._dataSource = new RestDataProvider(null, httpDataProvider);
     }
     /**Return's a `Repository` of the specific entity type
      * @example
@@ -120,7 +126,7 @@ export class Remult {
      */
     repo(entity, dataProvider) {
         if (dataProvider === undefined)
-            dataProvider = this._dataSource;
+            dataProvider = this.dataProvider;
         let dpCache = this.repCache.get(dataProvider);
         if (!dpCache)
             this.repCache.set(dataProvider, dpCache = new Map());
@@ -130,39 +136,10 @@ export class Remult {
         }
         return r;
     }
-    /** Returns the current user's info */
-    get user() {
-        if (this._user === undefined) {
-            return {
-                id: undefined,
-                name: '',
-                roles: []
-            };
-        }
-        return this._user;
-    }
-    /** Set's the current user info */
-    async setUser(info) {
-        this._user = info;
-        if (this._user === null)
-            this._user = undefined;
-        let auth = info;
-        if (auth) {
-            if (!this._user.id && auth.sub)
-                this._user.id = auth.sub;
-            if (!this._user.roles && auth.permissions) {
-                this._user.roles = auth.permissions;
-            }
-            if (!this._user.name)
-                this._user.name = auth.username;
-        }
-        if (this._user && !this._user.roles)
-            this._user.roles = [];
-        await this._userChangeEvent.fire();
-    }
+    /*  delete me */
     /** Checks if a user was authenticated */
     authenticated() {
-        return this.user.id !== undefined;
+        return this.user?.id !== undefined;
     }
     /** checks if the user has any of the roles specified in the parameters
      * @example
@@ -187,7 +164,7 @@ export class Remult {
         if (typeof roles === 'boolean')
             return roles;
         if (typeof roles === 'string')
-            if (this.user.roles.indexOf(roles.toString()) >= 0)
+            if (this.user?.roles?.indexOf(roles.toString()) >= 0)
                 return true;
         return false;
     }
@@ -210,46 +187,22 @@ export class Remult {
         else
             return this.isAllowed(allowed);
     }
-    /** returns a dispatcher object that fires once a user has changed*/
-    get userChange() {
-        return this._userChangeEvent.dispatcher;
-    }
-    static setDefaultHttpProvider(provider) {
-        const r = buildRestDataProvider(provider);
-        if (!r)
-            throw provider + " doesn't match http provider or fetch interface";
-        Remult.defaultHttpProvider = r;
-    }
-    /** sets the current data provider */
-    setDataProvider(dataProvider) {
-        this._dataSource = dataProvider;
+    call(backendMethod, self) {
+        const z = (backendMethod[serverActionField]);
+        if (!z.doWork)
+            throw Error("The method received is not a valid backend method");
+        //@ts-ignore
+        return (...args) => {
+            return z.doWork(args, self, this.apiClient.url, buildRestDataProvider(this.apiClient.httpClient));
+        };
     }
     clearAllCache() {
         this.repCache.clear();
     }
 }
-Remult.defaultHttpProvider = new RestDataProviderHttpProviderUsingFetch();
-/** The api Base Url to be used in all remult calls. by default it's set to `/api`.
- *
- * Set this property in case you want to determine a non relative api url
- */
-Remult.apiBaseUrl = '/api';
 /** A helper callback that can be used to debug and trace all find operations. Useful in debugging scenarios */
 Remult.onFind = (metadata, options) => { };
-class UseDefaultRestDataProviderHttpProvider {
-    post(url, data) {
-        return Remult.defaultHttpProvider.post(url, data);
-    }
-    delete(url) {
-        return Remult.defaultHttpProvider.delete(url);
-    }
-    put(url, data) {
-        return Remult.defaultHttpProvider.put(url, data);
-    }
-    get(url) {
-        return Remult.defaultHttpProvider.get(url);
-    }
-}
+;
 export const allEntities = [];
 export const classHelpers = new Map();
 export class ClassHelper {
@@ -262,12 +215,19 @@ export class MethodHelper {
         this.classes = new Map();
     }
 }
-function buildRestDataProvider(provider) {
+function isExternalHttpProvider(item) {
+    let http = item;
+    if (http && http.get && http.put && http.post && http.delete)
+        return true;
+    return false;
+}
+export function buildRestDataProvider(provider) {
+    if (!provider)
+        return new RestDataProviderHttpProviderUsingFetch();
     let httpDataProvider;
     if (!httpDataProvider) {
-        let http = provider;
-        if (http && http.get && http.put && http.post && http.delete) {
-            httpDataProvider = new HttpProviderBridgeToRestDataProviderHttpProvider(http);
+        if (isExternalHttpProvider(provider)) {
+            httpDataProvider = new HttpProviderBridgeToRestDataProviderHttpProvider(provider);
         }
     }
     if (!httpDataProvider) {

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

@@ -1,7 +1,6 @@
 import { Sort } from './sort';
 import { Filter } from './filter/filter-interfaces';
 import { EntityMetadata, OmitEB } from './remult3';
-import { HttpProvider } from './context';
 export interface DataProvider {
     getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
@@ -20,7 +19,7 @@ export interface EntityDataProviderFindOptions {
     page?: number;
     orderBy?: Sort;
 }
-export interface RestDataProviderHttpProvider extends HttpProvider {
+export interface RestDataProviderHttpProvider {
     post(url: string, data: any): Promise<any>;
     delete(url: string): Promise<void>;
     put(url: string, data: any): Promise<any>;

package/esm/src/data-providers/rest-data-provider.d.ts

@@ -2,10 +2,10 @@ import { EntityDataProvider, DataProvider, EntityDataProviderFindOptions, RestDa
 import { UrlBuilder } from '../../urlBuilder';
 import { Filter } from '../filter/filter-interfaces';
 import { EntityMetadata } from '../remult3';
+import { ApiClient } from '../context';
 export declare class RestDataProvider implements DataProvider {
-    private url;
-    private http;
-    constructor(url: string | null, http: RestDataProviderHttpProvider);
+    private apiProvider;
+    constructor(apiProvider: () => ApiClient);
     getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
     supportsCustomFilter: boolean;
@@ -14,7 +14,7 @@ export declare class RestEntityDataProvider implements EntityDataProvider {
     private url;
     private http;
     private entity;
-    constructor(url: string, http: RestDataProviderHttpProvider, entity: EntityMetadata);
+    constructor(url: () => string, http: () => RestDataProviderHttpProvider, entity: EntityMetadata);
     translateFromJson(row: any): {};
     translateToJson(row: any): {};
     count(where: Filter): Promise<number>;

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

@@ -1,17 +1,20 @@
 import { UrlBuilder } from '../../urlBuilder';
 import { customUrlToken } from '../filter/filter-interfaces';
-import { Remult, retry } from '../context';
+import { buildRestDataProvider, retry } from '../context';
 export class RestDataProvider {
-    constructor(url, http) {
-        this.url = url;
-        this.http = http;
+    constructor(apiProvider) {
+        this.apiProvider = apiProvider;
         this.supportsCustomFilter = true;
     }
     getEntityDataProvider(entity) {
-        let url = this.url;
-        if (url === undefined || url === null)
-            url = Remult.apiBaseUrl;
-        return new RestEntityDataProvider(url + '/' + entity.key, this.http, entity);
+        return new RestEntityDataProvider(() => {
+            let url = this.apiProvider()?.url;
+            if (url === undefined || url === null)
+                url = '/api';
+            return url + '/' + entity.key;
+        }, () => {
+            return buildRestDataProvider(this.apiProvider().httpClient);
+        }, entity);
     }
     async transaction(action) {
         throw new Error("Method not implemented.");
@@ -38,7 +41,7 @@ export class RestEntityDataProvider {
         return result;
     }
     async count(where) {
-        let url = new UrlBuilder(this.url);
+        let url = new UrlBuilder(this.url());
         url.add("__action", "count");
         let filterObject;
         if (where) {
@@ -47,12 +50,12 @@ export class RestEntityDataProvider {
                 filterObject = undefined;
         }
         if (filterObject)
-            return this.http.post(url.url, filterObject).then(r => +(r.count));
+            return this.http().post(url.url, filterObject).then(r => +(r.count));
         else
-            return this.http.get(url.url).then(r => +(r.count));
+            return this.http().get(url.url).then(r => +(r.count));
     }
     find(options) {
-        let url = new UrlBuilder(this.url);
+        let url = new UrlBuilder(this.url());
         let filterObject;
         if (options) {
             if (options.where) {
@@ -81,10 +84,10 @@ export class RestEntityDataProvider {
         }
         if (filterObject) {
             url.add("__action", "get");
-            return this.http.post(url.url, filterObject).then(x => x.map(y => this.translateFromJson(y)));
+            return this.http().post(url.url, filterObject).then(x => x.map(y => this.translateFromJson(y)));
         }
         else
-            return this.http.get(url.url).then(x => x.map(y => this.translateFromJson(y)));
+            return this.http().get(url.url).then(x => x.map(y => this.translateFromJson(y)));
         ;
     }
     update(id, data) {
@@ -94,13 +97,13 @@ export class RestEntityDataProvider {
             if (keys.includes(col.key))
                 result[col.key] = col.valueConverter.toJson(data[col.key]);
         }
-        return this.http.put(this.url + '/' + encodeURIComponent(id), result).then(y => this.translateFromJson(y));
+        return this.http().put(this.url() + '/' + encodeURIComponent(id), result).then(y => this.translateFromJson(y));
     }
     delete(id) {
-        return this.http.delete(this.url + '/' + encodeURIComponent(id));
+        return this.http().delete(this.url() + '/' + encodeURIComponent(id));
     }
     insert(data) {
-        return this.http.post(this.url, this.translateToJson(data)).then(y => this.translateFromJson(y));
+        return this.http().post(this.url(), this.translateToJson(data)).then(y => this.translateFromJson(y));
     }
 }
 export class RestDataProviderHttpProviderUsingFetch {

package/esm/src/remult-proxy.js

@@ -1,4 +1,5 @@
 import { Remult } from "./context";
+import { RepositoryImplementation } from "./remult3";
 let defaultRemult = new Remult();
 /*@internal*/
 export class RemultProxy {
@@ -7,45 +8,41 @@ export class RemultProxy {
         this.remultFactory = () => defaultRemult;
         this.repo = (...args) => this.remultFactory().repo(...args);
     }
-    get context() {
-        return this.instance.context;
+    call(backendMethod, self) {
+        return this.remultFactory().call(backendMethod, self);
     }
-    get _user() {
-        return this.instance._user;
+    get context() {
+        return this.remultFactory().context;
     }
+    get dataProvider() { return this.remultFactory().dataProvider; }
     ;
-    get _userChangeEvent() { return this.instance._userChangeEvent; }
-    ;
-    get _dataSource() { return this.instance._dataSource; }
+    set dataProvider(provider) { this.remultFactory().dataProvider = provider; }
+    get repCache() { return this.remultFactory().repCache; }
     ;
-    get repCache() { return this.instance.repCache; }
-    ;
-    setUser(info) {
-        return this.instance.setUser(info);
-    }
     authenticated() {
-        return this.instance.authenticated();
+        return this.remultFactory().authenticated();
     }
     isAllowed(roles) {
-        return this.instance.isAllowed(roles);
+        return this.remultFactory().isAllowed(roles);
     }
     isAllowedForInstance(instance, allowed) {
-        return this.instance.isAllowedForInstance(instance, allowed);
-    }
-    get userChange() {
-        return this.instance.userChange;
-    }
-    setDataProvider(dataProvider) {
-        return this.instance.setDataProvider(dataProvider);
+        return this.remultFactory().isAllowedForInstance(instance, allowed);
     }
     clearAllCache() {
-        return this.instance.clearAllCache();
-    }
-    get instance() {
-        return this.remultFactory();
+        return this.remultFactory().clearAllCache();
     }
     get user() {
         return this.remultFactory().user;
     }
+    set user(info) {
+        this.remultFactory().user = info;
+    }
+    get apiClient() {
+        return this.remultFactory().apiClient;
+    }
+    set apiClient(client) {
+        this.remultFactory().apiClient = client;
+    }
 }
 export const remult = new RemultProxy();
+RepositoryImplementation.defaultRemult = remult;

package/esm/src/remult3/RepositoryImplementation.d.ts

@@ -11,6 +11,7 @@ export declare class RepositoryImplementation<entityType> implements Repository<
     private entity;
     private remult;
     private dataProvider;
+    static defaultRemult: Remult;
     createAfterFilter(orderBy: EntityOrderBy<entityType>, lastRow: entityType): Promise<EntityFilter<entityType>>;
     private _info;
     private __edp;

package/esm/src/remult3/RepositoryImplementation.js

@@ -6,7 +6,7 @@ import { v4 as uuid } from 'uuid';
 import { ValueConverters } from "../valueConverters";
 import { filterHelper } from "../filter/filter-interfaces";
 import { assign } from "../../assign";
-import { remult } from "../remult-proxy";
+//import { remult } from "../remult-proxy";
 let classValidatorValidate = undefined;
 // import("class-validator".toString())
 //     .then((v) => {
@@ -913,7 +913,7 @@ export function getFields(container, remult) {
     return getControllerRef(container, remult).fields;
 }
 export function getControllerRef(container, remultArg) {
-    const remultVar = remultArg || remult;
+    const remultVar = remultArg || RepositoryImplementation.defaultRemult;
     let result = container[controllerColumns];
     if (!result)
         result = container[entityMember];