remult 0.25.5-exp.0 → 0.25.5-exp.10

package/esm/graphql.js

@@ -1,6 +1,7 @@
-import { getRelationInfo } from './internals.js';
+import { getRelationFieldInfo } from './internals.js';
 import { Remult, remult } from './index.js';
 import { DataApi } from './src/data-api.js';
+import { getRepositoryInternals } from './src/remult3/repository-internals.js';
 const v2ConnectionAndPagination = false;
 const andImplementation = false;
 let _removeComments = false;
@@ -151,6 +152,12 @@ export function remultGraphql(options) {
                     });
                 };
             };
+            const handleRequestWithDataApiContextBasedOnRepo = (repo, work) => {
+                return createResultPromise(async (response, setResult, arg1, req) => {
+                    const dApi = new DataApi(repo, remult);
+                    await work(dApi, response, setResult, arg1, repo.metadata);
+                });
+            };
             const handleRequestWithDataApiContext = (work) => {
                 return createResultPromise(async (response, setResult, arg1, req) => {
                     const remult = await options.getRemultFromRequest(req);
@@ -206,7 +213,9 @@ export function remultGraphql(options) {
                 });
             };
             const queryArgsConnection = getQueryArgsConnection(key);
-            const getSingleEntityKey = toCamelCase(getMetaType(meta));
+            let getSingleEntityKey = toCamelCase(getMetaType(meta));
+            if (getSingleEntityKey === toCamelCase(key))
+                getSingleEntityKey = 'single' + key;
             root_query.fields.push({
                 key: getSingleEntityKey,
                 args: [argId],
@@ -217,7 +226,8 @@ export function remultGraphql(options) {
                 await dApi.get({
                     ...response,
                     success: (y) => {
-                        currentType.query.resultProcessors.forEach((z) => z(y));
+                        const orig = { ...y };
+                        currentType.query.resultProcessors.forEach((z) => z(y, orig));
                         setResult(y);
                     },
                 }, arg1.id);
@@ -267,29 +277,7 @@ export function remultGraphql(options) {
                 });
             }
             root[key] = handleRequestWithDataApiContext(async (dApi, response, setResult, arg1, meta) => {
-                setResult({
-                    [itemsKey]: createResultPromise(async (response, setResult) => {
-                        await dApi.getArray({
-                            ...response,
-                            success: (x) => {
-                                setResult(x.map((y) => {
-                                    currentType.query.resultProcessors.forEach((z) => z(y));
-                                    return y;
-                                }));
-                            },
-                        }, {
-                            get: bridgeQueryOptionsToDataApiGet(arg1),
-                        }, translateWhereToRestBody(meta.fields, arg1));
-                    }),
-                    [totalCountKey]: createResultPromise(async (response, setResult) => {
-                        await dApi.count({
-                            ...response,
-                            success: (x) => setResult(x.count),
-                        }, {
-                            get: bridgeQueryOptionsToDataApiGet(arg1),
-                        }, translateWhereToRestBody(meta.fields, arg1));
-                    }),
-                });
+                connectionImplementation(setResult, itemsKey, createResultPromise, dApi, currentType, arg1, meta, totalCountKey);
             });
             resolversQuery[key] = (origItem, args, req, gqlInfo) => {
                 return root[key](args, req, gqlInfo);
@@ -324,7 +312,8 @@ export function remultGraphql(options) {
                     await dApi.post({
                         ...response,
                         created: (y) => {
-                            currentType.query.resultProcessors.forEach((z) => z(y));
+                            const orig = { ...y };
+                            currentType.query.resultProcessors.forEach((z) => z(y, orig));
                             setResult({
                                 [toCamelCase(getMetaType(meta))]: y,
                             });
@@ -358,7 +347,8 @@ export function remultGraphql(options) {
                     await dApi.put({
                         ...response,
                         success: (y) => {
-                            currentType.query.resultProcessors.forEach((z) => z(y));
+                            const orig = { ...y };
+                            currentType.query.resultProcessors.forEach((z) => z(y, orig));
                             setResult({
                                 [toCamelCase(getMetaType(meta))]: y,
                             });
@@ -395,8 +385,7 @@ export function remultGraphql(options) {
             }
             const whereTypeFields = [];
             for (const f of meta.fields) {
-                const ri = getRelationInfo(f.options);
-                // let's not consider toMany relations for now
+                const ri = getRelationFieldInfo(f);
                 if (f.options.includeInApi === false)
                     continue;
                 let type = 'String';
@@ -421,9 +410,12 @@ export function remultGraphql(options) {
                 let notARealField = false;
                 if (ri) {
                     {
-                        const refType = ri.toType();
+                        const refType = ri.toEntity;
                         ref = entities.find((i) => i.entityType === refType);
                     }
+                    if (!ref) {
+                        throw new Error(`Entity "${ri.toEntity.name}" that is used by the relation "${f.key}" in "${meta.entityType.name}" was not found in the 'entities' array.`);
+                    }
                     notARealField = ri.type === 'toOne' || ri.type === 'toMany';
                     const refKey = ref.key;
                     switch (ri.type) {
@@ -434,19 +426,19 @@ export function remultGraphql(options) {
                                 value: `${getMetaType(ref)}${f.allowNull ? '' : '!'}`,
                                 comment: f.caption,
                             });
-                            currentType.query.resultProcessors.push((r) => {
-                                const val = r[ri.type == 'reference' ? f.key : f.options.field]; //p1 - fix
-                                if (val === null || val === undefined)
-                                    return null;
+                            currentType.query.resultProcessors.push((r, orig) => {
                                 r[f.key] = async (args, req, gqlInfo) => {
-                                    const queryResult = await (await root[refKey]({
-                                        ...args.where,
-                                        where: { id: { eq: val } },
-                                        options: { limit: 1 },
-                                    }, req, gqlInfo)).items();
-                                    if (queryResult.length > 0)
-                                        return queryResult[0];
-                                    return null;
+                                    const remult = await options.getRemultFromRequest(req);
+                                    const myRepo = remult.repo(meta.entityType);
+                                    const item = myRepo.fromJson(orig);
+                                    let { toRepo, returnNull, returnUndefined } = getRepositoryInternals(myRepo).getFocusedRelationRepo(myRepo.fields.find(f), item);
+                                    if (returnNull || returnUndefined)
+                                        return null;
+                                    const result = await handleRequestWithDataApiContextBasedOnRepo(toRepo, async (dApi, response, setResult, arg1, meta) => {
+                                        return await connectionImplementation(setResult, itemsKey, createResultPromise, dApi, upsertTypes(getMetaType(ref)), arg1, meta, totalCountKey);
+                                    })({ ...args, options: { limit: 1 } }, req);
+                                    const resultItems = await result.items();
+                                    return resultItems[0];
                                 };
                             });
                             break;
@@ -459,16 +451,15 @@ export function remultGraphql(options) {
                                 order: 10,
                                 comment: `List all \`${getMetaType(meta)}\` of \`${refKey}\``,
                             });
-                            currentType.query.resultProcessors.push((r) => {
-                                const val = r.id;
+                            currentType.query.resultProcessors.push((r, y) => {
                                 r[f.key] = async (args, req, gqlInfo) => {
-                                    return await root[ref.key]({
-                                        where: {
-                                            ...args.where,
-                                            [f.options.field /*//p1 to fix*/]: { eq: val },
-                                        },
-                                        options: { ...args.limit, ...args.page, ...args.orderBy },
-                                    }, req, gqlInfo);
+                                    const remult = await options.getRemultFromRequest(req);
+                                    const myRepo = remult.repo(meta.entityType);
+                                    const item = myRepo.fromJson(y);
+                                    let relRepo = myRepo.relations(item)[f.key];
+                                    return handleRequestWithDataApiContextBasedOnRepo(relRepo, async (dApi, response, setResult, arg1, meta) => {
+                                        return await connectionImplementation(setResult, itemsKey, createResultPromise, dApi, upsertTypes(getMetaType(ref)), arg1, meta, totalCountKey);
+                                    })(args, req);
                                 };
                             });
                     }
@@ -677,6 +668,32 @@ export function remultGraphql(options) {
             .join(`\n\n`)}
 `,
     };
+    function connectionImplementation(setResult, itemsKey, createResultPromise, dApi, currentType, arg1, meta, totalCountKey) {
+        setResult({
+            [itemsKey]: createResultPromise(async (response, setResult) => {
+                await dApi.getArray({
+                    ...response,
+                    success: (x) => {
+                        setResult(x.map((y) => {
+                            const orig = { ...y };
+                            currentType.query.resultProcessors.forEach((z) => z(y, orig));
+                            return y;
+                        }));
+                    },
+                }, {
+                    get: bridgeQueryOptionsToDataApiGet(arg1),
+                }, translateWhereToRestBody(meta.fields, arg1));
+            }),
+            [totalCountKey]: createResultPromise(async (response, setResult) => {
+                await dApi.count({
+                    ...response,
+                    success: (x) => setResult(x.count),
+                }, {
+                    get: bridgeQueryOptionsToDataApiGet(arg1),
+                }, translateWhereToRestBody(meta.fields, arg1));
+            }),
+        });
+    }
 }
 function getQueryArgsConnection(key) {
     const queryArgsConnection = [

package/esm/internals.js

@@ -1,5 +1,6 @@
-export { getRelationInfo } from './src/remult3/relationInfoMember.js';
+import { remultStatic } from './src/remult-static.js';
+export { getRelationInfo, getRelationFieldInfo, } from './src/remult3/relationInfoMember.js';
 export { decorateColumnSettings, controllerRefImpl, getControllerRef, } from './src/remult3/RepositoryImplementation.js';
 export { getEntitySettings } from './src/remult3/getEntityRef.js';
 export { __updateEntityBasedOnWhere } from './src/filter/filter-interfaces.js';
-export { actionInfo } from './src/server-action-info.js';
+export const actionInfo = remultStatic.actionInfo;

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

@@ -1,9 +1,10 @@
 import { __decorate, __metadata } from "tslib";
 import { initDataProvider } from '../server/initDataProvider.js';
-import { allEntities, Remult } from '../src/context.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';
 export class DataProviderLiveQueryStorage {
     repo;
     dataProvider;
@@ -89,4 +90,4 @@ LiveQueryStorageEntity = __decorate([
     /*@internal */
 ], LiveQueryStorageEntity);
 export { LiveQueryStorageEntity };
-allEntities.splice(allEntities.indexOf(LiveQueryStorageEntity), 1);
+remultStatic.allEntities.splice(remultStatic.allEntities.indexOf(LiveQueryStorageEntity), 1);

package/esm/postgres/schema-builder.js

@@ -1,6 +1,6 @@
-import { allEntities } from '../src/context.js';
 import { dbNamesOf, shouldNotCreateField, } from '../src/filter/filter-consumer-bridge-to-sql-request.js';
 import { remult as defaultRemult } from '../src/remult-proxy.js';
+import { remultStatic } from '../src/remult-static.js';
 import { isAutoIncrement } from '../src/remult3/RepositoryImplementation.js';
 import { ValueConverters } from '../src/valueConverters.js';
 export function postgresColumnSyntax(x, dbName) {
@@ -95,7 +95,7 @@ export class PostgresSchemaBuilder {
         }
         const completed = new Set();
         const entities = [];
-        for (const entityClass of [...allEntities].reverse()) {
+        for (const entityClass of [...remultStatic.allEntities].reverse()) {
             let entity = remult.repo(entityClass).metadata;
             let e = await dbNamesOf(entity, this.pool.wrapIdentifier);
             if (completed.has(e.$entityName))

package/esm/remult-knex/index.js

@@ -1,4 +1,3 @@
-import { allEntities } from '../src/context.js';
 import { dbNamesOf, isDbReadonly, shouldNotCreateField, } from '../src/filter/filter-consumer-bridge-to-sql-request.js';
 import { customDatabaseFilterToken, Filter, } from '../src/filter/filter-interfaces.js';
 import { CompoundIdField } from '../src/CompoundIdField.js';
@@ -8,6 +7,7 @@ import { Sort } from '../src/sort.js';
 import { ValueConverters } from '../src/valueConverters.js';
 import { resultCompoundIdFilter as resultCompoundIdFilter } from '../src/resultCompoundIdFilter.js';
 import { getRepositoryInternals } from '../src/remult3/repository-internals.js';
+import { remultStatic } from '../src/remult-static.js';
 export class KnexDataProvider {
     knex;
     constructor(knex) {
@@ -20,7 +20,7 @@ export class KnexDataProvider {
         return r.knex;
     }
     getEntityDataProvider(entity) {
-        if (!supportsJson(this.knex))
+        if (!supportsJsonLoadingAndSaving(this.knex))
             for (const f of entity.fields.toArray()) {
                 if (f.valueConverter.fieldTypeInDb === 'json') {
                     //@ts-ignore
@@ -31,6 +31,17 @@ export class KnexDataProvider {
                     };
                 }
             }
+        else if (this.knex.client.config.client === 'mysql2') {
+            for (const f of entity.fields.toArray()) {
+                if (f.valueConverter.fieldTypeInDb === 'json') {
+                    //@ts-ignore
+                    f.valueConverter = {
+                        ...f.valueConverter,
+                        toDb: ValueConverters.JsonString.toDb,
+                    };
+                }
+            }
+        }
         return new KnexEntityDataProvider(entity, this.knex);
     }
     async transaction(action) {
@@ -331,7 +342,7 @@ export class KnexSchemaBuilder {
     async verifyStructureOfAllEntities(remult) {
         if (!remult)
             remult = remultContext;
-        const entities = allEntities.map((x) => remult.repo(x).metadata);
+        const entities = remultStatic.allEntities.map((x) => remult.repo(x).metadata);
         await this.ensureSchema(entities);
     }
     async ensureSchema(entities) {
@@ -367,7 +378,7 @@ export class KnexSchemaBuilder {
                         if (isAutoIncrement(x))
                             b.increments(cols.get(x).name);
                         else {
-                            buildColumn(x, cols.get(x).name, b, supportsJson(this.knex));
+                            buildColumn(x, cols.get(x).name, b, supportsJsonDataStorage(this.knex));
                             if (x == entity.idMetadata.field)
                                 b.primary([cols.get(x).name]);
                         }
@@ -384,7 +395,7 @@ export class KnexSchemaBuilder {
         let colName = e.$dbNameOf(col);
         if (!(await this.knex.schema.hasColumn(e.$entityName, colName))) {
             await logSql(this.knex.schema.alterTable(e.$entityName, (b) => {
-                buildColumn(col, colName, b, supportsJson(this.knex));
+                buildColumn(col, colName, b, supportsJsonDataStorage(this.knex));
             }));
         }
     }
@@ -406,11 +417,17 @@ export class KnexSchemaBuilder {
         this.knex = knex;
     }
 }
-function supportsJson(knex) {
+function supportsJsonDataStorage(knex) {
+    const client = knex.client.config.client;
+    if (client?.includes('sqlite3') || client?.includes('mssql'))
+        return false;
+    return true;
+}
+function supportsJsonLoadingAndSaving(knex) {
     const client = knex.client.config.client;
     if (client?.includes('sqlite3') ||
         client?.includes('mssql') ||
-        client?.includes('mysql'))
+        client == 'mysql')
         return false;
     return true;
 }

package/esm/server/expressBridge.js

@@ -1,6 +1,6 @@
 import { __decorate, __metadata } from "tslib";
 import { SseSubscriptionServer } from '../SseSubscriptionServer.js';
-import { Remult, RemultAsyncLocalStorage, allEntities, withRemult, } from '../src/context.js';
+import { Remult, RemultAsyncLocalStorage, withRemult } from '../src/context.js';
 import { DataApi, serializeError } from '../src/data-api.js';
 import { liveQueryKeepAliveRoute, streamUrl, } from '../src/live-query/SubscriptionChannel.js';
 import { InMemoryLiveQueryStorage, LiveQueryPublisher, } from '../src/live-query/SubscriptionServer.js';
@@ -9,8 +9,9 @@ import { Fields } from '../src/remult3/Fields.js';
 import { Entity } from '../src/remult3/entity.js';
 import { getEntityKey } from '../src/remult3/getEntityRef.js';
 import { Action, classBackendMethodsArray } from '../src/server-action.js';
-import { actionInfo, serverActionField } from '../src/server-action-info.js';
+import { serverActionField } from '../src/server-action-info.js';
 import { initDataProvider } from './initDataProvider.js';
+import { remultStatic } from '../src/remult-static.js';
 export function createRemultServerCore(options, serverCoreOptions) {
     if (!options) {
         options = {};
@@ -20,7 +21,7 @@ export function createRemultServerCore(options, serverCoreOptions) {
     }
     if (options.logApiEndPoints === undefined)
         options.logApiEndPoints = true;
-    actionInfo.runningOnServer = true;
+    remultStatic.actionInfo.runningOnServer = true;
     if (options.defaultGetLimit) {
         DataApi.defaultGetLimit = options.defaultGetLimit;
     }
@@ -34,7 +35,7 @@ export function createRemultServerCore(options, serverCoreOptions) {
     {
         let allControllers = [];
         if (!options.entities)
-            options.entities = [...allEntities];
+            options.entities = [...remultStatic.allEntities];
         if (options.entities)
             allControllers.push(...options.entities);
         if (options.controllers)
@@ -43,7 +44,7 @@ export function createRemultServerCore(options, serverCoreOptions) {
     }
     if (options.rootPath === undefined)
         options.rootPath = '/api';
-    actionInfo.runningOnServer = true;
+    remultStatic.actionInfo.runningOnServer = true;
     let bridge = new RemultServerImplementation(new inProcessQueueHandler(options.queueStorage), options, dataProvider, serverCoreOptions);
     return bridge;
 }
@@ -987,4 +988,4 @@ JobsInQueueEntity = __decorate([
     })
 ], JobsInQueueEntity);
 export { JobsInQueueEntity };
-allEntities.splice(allEntities.indexOf(JobsInQueueEntity), 1);
+remultStatic.allEntities.splice(remultStatic.allEntities.indexOf(JobsInQueueEntity), 1);

package/esm/server/initAsyncHooks.js

@@ -1,9 +1,10 @@
 import { AsyncLocalStorage } from 'async_hooks';
 import { RemultAsyncLocalStorage } from '../src/context.js';
+import { remultStatic } from '../src/remult-static.js';
 let init = false;
 export function initAsyncHooks() {
     if (init)
         return;
     init = true;
-    RemultAsyncLocalStorage.instance = new RemultAsyncLocalStorage(new AsyncLocalStorage());
+    remultStatic.asyncContext = new RemultAsyncLocalStorage(new AsyncLocalStorage());
 }

package/esm/src/context.js

@@ -1,16 +1,18 @@
 import { RestDataProvider } from './data-providers/rest-data-provider.js';
 import { LiveQueryClient } from './live-query/LiveQueryClient.js';
 import { SseSubscriptionClient } from './live-query/SseSubscriptionClient.js';
-import { RemultProxy, remult } from './remult-proxy.js';
+import { remult } from './remult-proxy.js';
 import { RepositoryImplementation, createOldEntity, } from './remult3/RepositoryImplementation.js';
-import { actionInfo, serverActionField } from './server-action-info.js';
+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';
 export class RemultAsyncLocalStorage {
     remultObjectStorage;
     static enable() {
         ;
         remult.remultFactory = () => {
-            const r = RemultAsyncLocalStorage.instance.getRemult();
+            const r = remultStatic.asyncContext.getRemult();
             if (r)
                 return r;
             else
@@ -36,10 +38,11 @@ export class RemultAsyncLocalStorage {
         }
         return this.remultObjectStorage.getStore();
     }
-    static instance = new RemultAsyncLocalStorage(undefined);
 }
+if (!remultStatic.asyncContext)
+    remultStatic.asyncContext = new RemultAsyncLocalStorage(undefined);
 export function isBackend() {
-    return actionInfo.runningOnServer || !remult.dataProvider.isProxy;
+    return remultStatic.actionInfo.runningOnServer || !remult.dataProvider.isProxy;
 }
 export class Remult {
     /**Return's a `Repository` of the specific entity type
@@ -58,6 +61,7 @@ export class Remult {
         let r = dpCache.get(entity);
         if (!r) {
             dpCache.set(entity, (r = new RepositoryImplementation(entity, this, dataProvider, createOldEntity(entity, this))));
+            verifyFieldRelationInfo(r, this, dataProvider);
         }
         return r;
     }
@@ -178,18 +182,16 @@ export class Remult {
         subscriptionClient: new SseSubscriptionClient(),
     };
 }
-RemultProxy.defaultRemultFactory = () => new Remult();
-export const allEntities = [];
-export const classHelpers = new Map();
+remultStatic.defaultRemultFactory = () => new Remult();
 export class ClassHelper {
     classes = new Map();
 }
 export function setControllerSettings(target, options) {
     let r = target;
     while (true) {
-        let helper = classHelpers.get(r);
+        let helper = remultStatic.classHelpers.get(r);
         if (!helper)
-            classHelpers.set(r, (helper = new ClassHelper()));
+            remultStatic.classHelpers.set(r, (helper = new ClassHelper()));
         helper.classes.set(target, options);
         let p = Object.getPrototypeOf(r.prototype);
         if (p == null)
@@ -280,7 +282,7 @@ export function withRemult(callback, options) {
     if (options?.dataProvider)
         remult.dataProvider = options.dataProvider;
     let r;
-    RemultAsyncLocalStorage.instance.run(remult, () => {
+    remultStatic.asyncContext.run(remult, () => {
         r = new Promise(async (res, rej) => {
             try {
                 res(await callback(remult));

package/esm/src/data-api.js

@@ -1,7 +1,7 @@
-import { getRelationInfo } from '../internals.js';
 import { doTransaction } from './context.js';
 import { findOptionsToJson, liveQueryAction, } from './data-providers/rest-data-provider.js';
 import { Filter, buildFilterFromRequestParameters, customUrlToken, } from './filter/filter-interfaces.js';
+import { getRelationFieldInfo } from './remult3/relationInfoMember.js';
 import { ForbiddenError } from './server-action.js';
 export class DataApi {
     repository;
@@ -118,7 +118,7 @@ export class DataApi {
     includeNone() {
         let include = {};
         for (const field of this.repository.metadata.fields) {
-            if (getRelationInfo(field.options)) {
+            if (getRelationFieldInfo(field)) {
                 include[field.key] = false;
             }
         }

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

@@ -1,9 +1,8 @@
 import { UrlBuilder } from '../../urlBuilder.js';
 import { buildRestDataProvider, retry } from '../buildRestDataProvider.js';
-import { Remult } from '../context.js';
 import { customUrlToken, Filter } from '../filter/filter-interfaces.js';
-import { actionInfo } from '../server-action-info.js';
-import { getRelationInfo } from '../remult3/relationInfoMember.js';
+import { getRelationFieldInfo } from '../remult3/relationInfoMember.js';
+import { remultStatic } from '../remult-static.js';
 export class RestDataProvider {
     apiProvider;
     constructor(apiProvider) {
@@ -32,9 +31,9 @@ export function findOptionsToJson(options, meta) {
             if (Object.prototype.hasOwnProperty.call(options.include, key)) {
                 let element = options.include[key];
                 if (typeof element === 'object') {
-                    const rel = getRelationInfo(meta.fields.find(key).options);
+                    const rel = getRelationFieldInfo(meta.fields.find(key));
                     if (rel) {
-                        element = findOptionsToJson(element, new Remult().repo(rel.toType()).metadata);
+                        element = findOptionsToJson(element, rel.toRepo.metadata);
                     }
                 }
                 newInclude[key] = element;
@@ -74,9 +73,9 @@ export function findOptionsFromJson(json, meta) {
                     if (Object.prototype.hasOwnProperty.call(newInclude, key)) {
                         let element = newInclude[key];
                         if (typeof element === 'object') {
-                            const rel = getRelationInfo(meta.fields.find(key).options);
+                            const rel = getRelationFieldInfo(meta.fields.find(key));
                             if (rel) {
-                                element = findOptionsFromJson(element, new Remult().repo(rel.toType()).metadata);
+                                element = findOptionsFromJson(element, rel.toRepo.metadata);
                             }
                         }
                         newInclude[key] = element;
@@ -179,7 +178,7 @@ export class RestEntityDataProvider {
                 return {
                     result,
                     unsubscribe: async () => {
-                        return actionInfo.runActionWithoutBlockingUI(() => this.http().post(this.url() + '?__action=endLiveQuery', {
+                        return remultStatic.actionInfo.runActionWithoutBlockingUI(() => this.http().post(this.url() + '?__action=endLiveQuery', {
                             id: queryId,
                         }));
                     },

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

@@ -1,6 +1,6 @@
 import { SqlDatabase } from '../data-providers/sql-database.js';
 import { getEntityMetadata } from '../remult3/RepositoryImplementation.js';
-import { getRelationInfo } from '../remult3/relationInfoMember.js';
+import { getRelationFieldInfo } from '../remult3/relationInfoMember.js';
 export class FilterConsumerBridgeToSqlRequest {
     r;
     nameProvider;
@@ -200,7 +200,7 @@ export async function fieldDbName(f, meta, wrapIdentifier = (x) => x) {
                 return f.dbName;
             return result;
         }
-        const rel = getRelationInfo(f.options);
+        const rel = getRelationFieldInfo(f);
         let field = rel?.type === 'toOne' &&
             f.options.field;
         if (field) {

package/esm/src/filter/filter-interfaces.js

@@ -1,6 +1,5 @@
-import { Remult } from '../context.js';
 import { getEntityRef, getEntitySettings } from '../remult3/getEntityRef.js';
-import { getRelationInfo } from '../remult3/relationInfoMember.js';
+import { getRelationFieldInfo } from '../remult3/relationInfoMember.js';
 export class Filter {
     apply;
     constructor(apply) {
@@ -49,7 +48,7 @@ export class Filter {
                     }
                     else {
                         const field = entity.fields[key];
-                        const rel = getRelationInfo(field.options);
+                        const rel = getRelationFieldInfo(field);
                         const op = field.options;
                         let fh = rel?.type === 'toOne'
                             ? op.fields
@@ -167,10 +166,9 @@ class filterHelper {
         if (ei) {
             if (!val) {
                 if (val === null && !this.metadata.allowNull) {
-                    const rel = getRelationInfo(this.metadata.options);
+                    const rel = getRelationFieldInfo(this.metadata);
                     if (rel?.type === 'reference')
-                        if (new Remult().repo(rel.toType()).metadata.idMetadata.field.options
-                            .valueType === Number)
+                        if (rel.toRepo.metadata.idMetadata.field.options.valueType === Number)
                             return 0;
                         else
                             return '';

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

@@ -1,5 +1,6 @@
 import { buildRestDataProvider } from '../buildRestDataProvider.js';
 import { RestDataProvider } from '../data-providers/rest-data-provider.js';
+import { remultStatic } from '../remult-static.js';
 import { getRepositoryInternals } from '../remult3/repository-internals.js';
 import { liveQueryKeepAliveRoute, LiveQuerySubscriber, } from './SubscriptionChannel.js';
 /* @internal*/
@@ -165,8 +166,7 @@ export class LiveQueryClient {
                 }
                 if (ids.length > 0) {
                     let p = this.apiProvider();
-                    let { actionInfo } = await import('../server-action-info.js');
-                    const invalidIds = await this.runPromise(await actionInfo.runActionWithoutBlockingUI(() => buildRestDataProvider(p.httpClient).post(p.url + '/' + liveQueryKeepAliveRoute, ids)));
+                    const invalidIds = await this.runPromise(await remultStatic.actionInfo.runActionWithoutBlockingUI(() => buildRestDataProvider(p.httpClient).post(p.url + '/' + liveQueryKeepAliveRoute, ids)));
                     for (const id of invalidIds) {
                         for (const q of this.queries.values()) {
                             if (q.queryChannel === id)

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

@@ -1,6 +1,6 @@
 import { buildRestDataProvider } from '../buildRestDataProvider.js';
 import { remult } from '../remult-proxy.js';
-import { actionInfo } from '../server-action-info.js';
+import { remultStatic } from '../remult-static.js';
 import { streamUrl } from './SubscriptionChannel.js';
 export class SseSubscriptionClient {
     openConnection(onReconnect) {
@@ -23,7 +23,7 @@ export class SseSubscriptionClient {
                 return () => {
                     listeners.splice(listeners.indexOf(handler, 1));
                     if (listeners.length == 0) {
-                        actionInfo.runActionWithoutBlockingUI(() => provider.post(remult.apiClient.url + '/' + streamUrl + '/unsubscribe', {
+                        remultStatic.actionInfo.runActionWithoutBlockingUI(() => provider.post(remult.apiClient.url + '/' + streamUrl + '/unsubscribe', {
                             channel: channel,
                             clientId: connectionId,
                         }));
@@ -69,7 +69,7 @@ export class SseSubscriptionClient {
         });
         return createConnectionPromise();
         async function subscribeToChannel(channel) {
-            const result = await actionInfo.runActionWithoutBlockingUI(() => {
+            const result = await remultStatic.actionInfo.runActionWithoutBlockingUI(() => {
                 return provider.post(remult.apiClient.url + '/' + streamUrl + '/subscribe', {
                     channel: channel,
                     clientId: connectionId,