remult 0.25.5-exp.1 → 0.25.5-exp.3

package/esm/graphql.js

@@ -1,4 +1,4 @@
-import { getRelationInfo } from './internals.js';
+import { getRelationFieldInfo } from './internals.js';
 import { Remult, remult } from './index.js';
 import { DataApi } from './src/data-api.js';
 const v2ConnectionAndPagination = false;
@@ -397,8 +397,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';
@@ -423,7 +422,7 @@ export function remultGraphql(options) {
                 let notARealField = false;
                 if (ri) {
                     {
-                        const refType = ri.toType();
+                        const refType = ri.toEntity;
                         ref = entities.find((i) => i.entityType === refType);
                     }
                     notARealField = ri.type === 'toOne' || ri.type === 'toMany';

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) {
@@ -331,7 +331,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) {

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,

package/esm/src/remult-proxy.js

@@ -1,14 +1,7 @@
+import { defaultFactory } from './remult-static.js';
 import { getInternalKey } from './remult3/repository-internals.js';
-let defaultRemult;
-function defaultFactory() {
-    if (!defaultRemult) {
-        defaultRemult = RemultProxy.defaultRemultFactory();
-    }
-    return defaultRemult;
-}
 /*@internal*/
 export class RemultProxy {
-    static defaultRemultFactory;
     /* @internal*/
     get liveQuerySubscriber() {
         return this.remultFactory().liveQuerySubscriber;
@@ -82,6 +75,7 @@ export class RemultProxy {
             get fields() {
                 return self.remultFactory().repo(...args).metadata.fields;
             },
+            //@ts-ignore
             [getInternalKey]() {
                 return self
                     .remultFactory()

package/esm/src/remult-static.js

@@ -0,0 +1,36 @@
+const remultStaticKey = Symbol.for('remult-static1');
+let x = {
+    defaultRemultFactory: undefined,
+    defaultRemult: undefined,
+    asyncContext: undefined,
+    columnsOfType: new Map(),
+    allEntities: [],
+    classHelpers: new Map(),
+    actionInfo: {
+        allActions: [],
+        runningOnServer: false,
+        runActionWithoutBlockingUI: (what) => {
+            return what();
+        },
+        startBusyWithProgress: () => ({
+            progress: (percent) => { },
+            close: () => { },
+        }),
+    },
+    captionTransformer: undefined,
+};
+if ((typeof process !== 'undefined' &&
+    process.env['IGNORE_GLOBAL_REMULT_IN_TESTS']) ||
+    typeof globalThis[remultStaticKey] === 'undefined') {
+    globalThis[remultStaticKey] = x;
+}
+else {
+    x = globalThis[remultStaticKey];
+}
+export const remultStatic = x;
+export function defaultFactory() {
+    if (!remultStatic.defaultRemult) {
+        remultStatic.defaultRemult = remultStatic.defaultRemultFactory();
+    }
+    return remultStatic.defaultRemult;
+}

package/esm/src/remult3/Fields.js

@@ -1,9 +1,10 @@
 import { createId } from '@paralleldrive/cuid2';
 import { v4 as uuid } from 'uuid';
 import { ValueConverters } from '../valueConverters.js';
-import { buildOptions, columnsOfType } from './RepositoryImplementation.js';
-import { relationInfoMember } from './relationInfoMember.js';
+import { buildOptions } from './RepositoryImplementation.js';
 import { Validators } from '../validators.js';
+import { relationInfoMemberInOptions } from './relationInfoMember.js';
+import { remultStatic } from '../remult-static.js';
 export class Fields {
     /**
      * Stored as a JSON.stringify - to store as json use Fields.json
@@ -146,22 +147,12 @@ export class Relations {
             //@ts-ignore
             return Field(toEntityType, {
                 ...op,
-                //@ts-ignore
-                [relationInfoMember]: {
-                    //field,
-                    toType: toEntityType,
-                    type: 'reference',
-                },
+                ...relationInfoMemberInOptions(toEntityType, 'reference'),
             });
         return Field(() => undefined, {
             ...op,
             serverExpression: () => undefined,
-            //@ts-ignore
-            [relationInfoMember]: {
-                //field,
-                toType: toEntityType,
-                type: 'toOne',
-            },
+            ...relationInfoMemberInOptions(toEntityType, 'toOne'),
         });
     }
     static toMany(toEntityType, options) {
@@ -171,12 +162,7 @@ export class Relations {
         return Field(() => undefined, {
             ...op,
             serverExpression: () => undefined,
-            //@ts-ignore
-            [relationInfoMember]: {
-                //field,
-                toType: toEntityType,
-                type: 'toMany',
-            },
+            ...relationInfoMemberInOptions(toEntityType, 'toMany'),
         });
     }
 }
@@ -223,10 +209,10 @@ export function Field(valueType, ...options) {
             return r;
         };
         checkTarget(target);
-        let names = columnsOfType.get(target.constructor);
+        let names = remultStatic.columnsOfType.get(target.constructor);
         if (!names) {
             names = [];
-            columnsOfType.set(target.constructor, names);
+            remultStatic.columnsOfType.set(target.constructor, names);
         }
         let set = names.find((x) => x.key == key);
         if (!set)