remult 0.23.5 → 0.24.0-exp.2

package/esm/server/expressBridge.js

@@ -1,16 +1,16 @@
 import { __decorate, __metadata } from "tslib";
-import { SseSubscriptionServer } from '../SseSubscriptionServer';
-import { Remult, RemultAsyncLocalStorage, allEntities } from '../src/context';
-import { DataApi, serializeError } from '../src/data-api';
-import { liveQueryKeepAliveRoute, streamUrl, } from '../src/live-query/SubscriptionChannel';
-import { InMemoryLiveQueryStorage, LiveQueryPublisher, } from '../src/live-query/SubscriptionServer';
-import { IdEntity } from '../src/remult3/IdEntity';
-import { Fields } from '../src/remult3/Fields';
-import { Entity } from '../src/remult3/entity';
-import { getEntityKey } from '../src/remult3/getEntityRef';
-import { Action, classBackendMethodsArray } from '../src/server-action';
-import { actionInfo, serverActionField } from '../src/server-action-info';
-import { initDataProvider } from './initDataProvider';
+import { SseSubscriptionServer } from '../SseSubscriptionServer.js';
+import { Remult, RemultAsyncLocalStorage, allEntities, 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';
+import { IdEntity } from '../src/remult3/IdEntity.js';
+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 { initDataProvider } from './initDataProvider.js';
 export function createRemultServerCore(options, serverCoreOptions) {
     if (!options) {
         options = {};
@@ -98,7 +98,9 @@ export class RemultServerImplementation {
             return dp;
         });
     }
-    withRemultPromise(request, what) {
+    withRemultAsync(request, what) {
+        if (!request)
+            return this.runWithRemult(what);
         return new Promise((resolve, error) => {
             return this.withRemult(request, undefined, () => {
                 try {
@@ -246,16 +248,14 @@ export class RemultServerImplementation {
     }
     //runs with remult but without init request
     async runWithRemult(what, options) {
-        let remult = new Remult();
-        remult.liveQueryPublisher = new LiveQueryPublisher(() => remult.subscriptionServer, () => remult.liveQueryStorage, this.runWithSerializedJsonContextData);
-        if (!options?.skipDataProvider)
-            remult.dataProvider = await this.dataProvider;
-        remult.subscriptionServer = this.subscriptionServer;
-        remult.liveQueryStorage = this.liveQueryStorage;
-        await new Promise((res) => {
-            RemultAsyncLocalStorage.instance.run(remult, async () => {
-                res(await what(remult));
-            });
+        return await withRemult(async (remult) => {
+            var x = remult;
+            x.liveQueryPublisher = new LiveQueryPublisher(() => remult.subscriptionServer, () => remult.liveQueryStorage, this.runWithSerializedJsonContextData);
+            if (!options?.skipDataProvider)
+                x.dataProvider = await this.dataProvider;
+            x.subscriptionServer = this.subscriptionServer;
+            x.liveQueryStorage = this.liveQueryStorage;
+            return await what(x);
         });
     }
     process(what) {

package/esm/server/index.js

@@ -1,8 +1,8 @@
-import { createRemultServerCore } from './expressBridge';
-import { initAsyncHooks } from './initAsyncHooks';
-export { SseSubscriptionServer } from '../SseSubscriptionServer';
-export { DataProviderLiveQueryStorage } from '../live-query/data-provider-live-query-storage';
-export { JsonEntityFileStorage, JsonFileDataProvider, } from './JsonEntityFileStorage';
+import { createRemultServerCore } from './expressBridge.js';
+import { initAsyncHooks } from './initAsyncHooks.js';
+export { SseSubscriptionServer } from '../SseSubscriptionServer.js';
+export { DataProviderLiveQueryStorage } from '../live-query/data-provider-live-query-storage.js';
+export { JsonEntityFileStorage, JsonFileDataProvider, } from './JsonEntityFileStorage.js';
 export function createRemultServer(options, serverCoreOptions) {
     initAsyncHooks();
     return createRemultServerCore(options, serverCoreOptions || {

package/esm/server/initAsyncHooks.js

@@ -1,5 +1,5 @@
 import { AsyncLocalStorage } from 'async_hooks';
-import { RemultAsyncLocalStorage } from '../src/context';
+import { RemultAsyncLocalStorage } from '../src/context.js';
 let init = false;
 export function initAsyncHooks() {
     if (init)

package/esm/server/initDataProvider.js

@@ -8,7 +8,7 @@ export function initDataProvider(optionsDataProvider) {
     dataProvider = dataProvider.then(async (dp) => {
         if (dp)
             return dp;
-        return new (await import('./JsonEntityFileStorage')).JsonFileDataProvider('./db');
+        return new (await import('./JsonEntityFileStorage.js')).JsonFileDataProvider('./db');
     });
     return dataProvider;
 }

package/esm/src/buildRestDataProvider.js

@@ -1,4 +1,4 @@
-import { RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider';
+import { RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider.js';
 export function buildRestDataProvider(provider) {
     if (!provider)
         return new RestDataProviderHttpProviderUsingFetch();

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

@@ -120,7 +120,8 @@ export interface FieldMetadata<valueType = any, entityType = any> {
      * Task == taskRepo.metadata.fields.title.target //will return true
      */
     readonly target: ClassType<valueType>;
-    /** Returns the dbName - based on it's `dbName` option and it's `sqlExpression` option */
+    /**
+     * @deprecated Returns the dbName - based on it's `dbName` option and it's `sqlExpression` option */
     getDbName(): Promise<string>;
     /** Indicates if this field is based on a server express */
     readonly isServerExpression: boolean;

package/esm/src/column.js

@@ -1,5 +1,5 @@
-import { getEntityRef } from './remult3/getEntityRef';
-import { getRepositoryInternals } from './remult3/repository-internals';
+import { getEntityRef } from './remult3/getEntityRef.js';
+import { getRepositoryInternals } from './remult3/repository-internals.js';
 export function makeTitle(name) {
     // insert a space before all caps
     return (name

package/esm/src/context.js

@@ -1,10 +1,10 @@
-import { RestDataProvider } from './data-providers/rest-data-provider';
-import { LiveQueryClient } from './live-query/LiveQueryClient';
-import { SseSubscriptionClient } from './live-query/SseSubscriptionClient';
-import { RemultProxy, remult } from './remult-proxy';
-import { RepositoryImplementation, createOldEntity, } from './remult3/RepositoryImplementation';
-import { actionInfo, serverActionField } from './server-action-info';
-import { buildRestDataProvider, isExternalHttpProvider, } from './buildRestDataProvider';
+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 { RepositoryImplementation, createOldEntity, } from './remult3/RepositoryImplementation.js';
+import { actionInfo, serverActionField } from './server-action-info.js';
+import { buildRestDataProvider, isExternalHttpProvider, } from './buildRestDataProvider.js';
 export class RemultAsyncLocalStorage {
     remultObjectStorage;
     static enable() {
@@ -26,9 +26,9 @@ export class RemultAsyncLocalStorage {
     }
     run(remult, callback) {
         if (this.remultObjectStorage)
-            this.remultObjectStorage.run(remult, callback);
+            this.remultObjectStorage.run(remult, () => callback(remult));
         else
-            callback();
+            callback(remult);
     }
     getRemult() {
         if (!this.remultObjectStorage) {
@@ -140,7 +140,6 @@ export class Remult {
                 this.apiClient.wrapMessageHandling = apiClient.wrapMessageHandling;
         }
     }
-    /* @internal*/
     liveQueryStorage;
     subscriptionServer;
     /* @internal*/
@@ -178,16 +177,6 @@ export class Remult {
         url: '/api',
         subscriptionClient: new SseSubscriptionClient(),
     };
-    static run(callback, options) {
-        const remult = new Remult();
-        if (options.dataProvider)
-            remult.dataProvider = options.dataProvider;
-        let r;
-        RemultAsyncLocalStorage.instance.run(remult, () => {
-            r = callback();
-        });
-        return r;
-    }
 }
 RemultProxy.defaultRemultFactory = () => new Remult();
 export const allEntities = [];
@@ -286,3 +275,20 @@ class transactionLiveQueryPublisher {
         }
     }
 }
+export function withRemult(callback, options) {
+    const remult = new Remult();
+    if (options?.dataProvider)
+        remult.dataProvider = options.dataProvider;
+    let r;
+    RemultAsyncLocalStorage.instance.run(remult, () => {
+        r = new Promise(async (res, rej) => {
+            try {
+                res(await callback(remult));
+            }
+            catch (err) {
+                rej(err);
+            }
+        });
+    });
+    return r;
+}

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

@@ -14,7 +14,6 @@ export declare class DataApi<T = any> {
         r: any[];
         findOptions: FindOptions<T>;
     }>;
-    private includeNone;
     getArray(response: DataApiResponse, request: DataApiRequest, filterBody?: any): Promise<void>;
     liveQuery(response: DataApiResponse, request: DataApiRequest, filterBody: any, serializeContext: () => Promise<any>, queryChannel: string): Promise<void>;
     private buildWhere;

package/esm/src/data-api.js

@@ -1,8 +1,8 @@
-import { getRelationInfo } from '../internals';
-import { doTransaction } from './context';
-import { findOptionsToJson, liveQueryAction, } from './data-providers/rest-data-provider';
-import { Filter, buildFilterFromRequestParameters, customUrlToken, } from './filter/filter-interfaces';
-import { ForbiddenError } from './server-action';
+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 { ForbiddenError } from './server-action.js';
 export class DataApi {
     repository;
     remult;

package/esm/src/data-interfaces.js

@@ -1,4 +1,4 @@
-import { Sort } from './sort';
+import { Sort } from './sort.js';
 export function extractSort(sort) {
     if (sort instanceof Array) {
         let r = new Sort();

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

@@ -1,6 +1,6 @@
-import { CompoundIdField } from '../CompoundIdField';
-import { dbNamesOf, isDbReadonly, } from '../filter/filter-consumer-bridge-to-sql-request';
-import { Filter, customDatabaseFilterToken } from '../filter/filter-interfaces';
+import { CompoundIdField } from '../CompoundIdField.js';
+import { dbNamesOf, isDbReadonly, } from '../filter/filter-consumer-bridge-to-sql-request.js';
+import { Filter, customDatabaseFilterToken, } from '../filter/filter-interfaces.js';
 //@internal
 export class ArrayEntityDataProvider {
     entity;

package/esm/src/data-providers/in-memory-database.js

@@ -1,4 +1,4 @@
-import { ArrayEntityDataProvider } from './array-entity-data-provider';
+import { ArrayEntityDataProvider } from './array-entity-data-provider.js';
 export class InMemoryDataProvider {
     async transaction(action) {
         await action(this);

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

@@ -1,4 +1,4 @@
-import { ArrayEntityDataProvider } from './array-entity-data-provider';
+import { ArrayEntityDataProvider } from './array-entity-data-provider.js';
 export class JsonDataProvider {
     storage;
     constructor(storage) {
@@ -20,7 +20,7 @@ class JsonEntityDataProvider {
     }
     async loadEntityData(what) {
         let data = [];
-        let dbName = await this.entity.getDbName();
+        let dbName = await this.entity.options.dbName;
         let s = this.helper.getItem(dbName);
         if (s)
             data = JSON.parse(s);

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

@@ -1,9 +1,9 @@
-import { UrlBuilder } from '../../urlBuilder';
-import { buildRestDataProvider, retry } from '../buildRestDataProvider';
-import { Remult } from '../context';
-import { customUrlToken, Filter } from '../filter/filter-interfaces';
-import { actionInfo } from '../server-action-info';
-import { getRelationInfo } from '../remult3/relationInfoMember';
+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';
 export class RestDataProvider {
     apiProvider;
     constructor(apiProvider) {

package/esm/src/data-providers/sql-database.d.ts

@@ -1,7 +1,7 @@
 import type { DataProvider, EntityDataProvider } from '../data-interfaces';
 import type { SqlCommand, SqlCommandWithParameters, SqlImplementation, SqlResult } from '../sql-command';
 import type { Remult } from '../context';
-import type { CustomSqlFilterBuilderFunction } from '../filter/filter-consumer-bridge-to-sql-request';
+import type { CustomSqlFilterBuilderFunction, EntityDbNamesBase } from '../filter/filter-consumer-bridge-to-sql-request';
 import type { EntityFilter, EntityMetadata } from '../remult3/remult3';
 import type { RepositoryOverloads } from '../remult3/RepositoryImplementation';
 export declare class SqlDatabase implements DataProvider {
@@ -9,11 +9,12 @@ export declare class SqlDatabase implements DataProvider {
     static getDb(remult?: Remult): SqlDatabase;
     createCommand(): SqlCommand;
     execute(sql: string): Promise<SqlResult>;
+    wrapIdentifier: (name: string) => string;
     ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
     getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
     static rawFilter(build: CustomSqlFilterBuilderFunction): EntityFilter<any>;
-    static filterToRaw<entityType>(repo: RepositoryOverloads<entityType>, condition: EntityFilter<entityType>, sqlCommand?: SqlCommandWithParameters): Promise<string>;
+    static filterToRaw<entityType>(repo: RepositoryOverloads<entityType>, condition: EntityFilter<entityType>, sqlCommand?: SqlCommandWithParameters, dbNames?: EntityDbNamesBase): Promise<string>;
     /**
      * `false` _(default)_ - No logging
      *

package/esm/src/data-providers/sql-database.js

@@ -1,11 +1,11 @@
-import { CompoundIdField } from '../CompoundIdField';
-import { FilterConsumerBridgeToSqlRequest, dbNamesOf, isDbReadonly, } from '../filter/filter-consumer-bridge-to-sql-request';
-import { Filter, customDatabaseFilterToken } from '../filter/filter-interfaces';
-import { remult as defaultRemult } from '../remult-proxy';
-import { getRepository } from '../remult3/RepositoryImplementation';
-import { Sort } from '../sort';
-import { ValueConverters } from '../valueConverters';
-import { getRepositoryInternals } from '../remult3/repository-internals';
+import { CompoundIdField } from '../CompoundIdField.js';
+import { FilterConsumerBridgeToSqlRequest, dbNamesOf, isDbReadonly, } from '../filter/filter-consumer-bridge-to-sql-request.js';
+import { Filter, customDatabaseFilterToken, } from '../filter/filter-interfaces.js';
+import { remult as defaultRemult } from '../remult-proxy.js';
+import { getRepository } from '../remult3/RepositoryImplementation.js';
+import { Sort } from '../sort.js';
+import { ValueConverters } from '../valueConverters.js';
+import { getRepositoryInternals } from '../remult3/repository-internals.js';
 // @dynamic
 export class SqlDatabase {
     sql;
@@ -21,6 +21,7 @@ export class SqlDatabase {
     async execute(sql) {
         return await this.createCommand().execute(sql);
     }
+    wrapIdentifier = (x) => x;
     /* @internal*/
     _getSourceSql() {
         return this.sql;
@@ -69,6 +70,7 @@ export class SqlDatabase {
                     entityIsUsedForTheFirstTime: (y) => x.entityIsUsedForTheFirstTime(y),
                     transaction: (z) => x.transaction(z),
                     supportsJsonColumnType: this.sql.supportsJsonColumnType,
+                    wrapIdentifier: this.wrapIdentifier,
                 }));
             }
             finally {
@@ -83,12 +85,12 @@ export class SqlDatabase {
             },
         };
     }
-    static async filterToRaw(repo, condition, sqlCommand) {
+    static async filterToRaw(repo, condition, sqlCommand, dbNames) {
         if (!sqlCommand) {
             sqlCommand = new myDummySQLCommand();
         }
         const r = getRepository(repo);
-        var b = new FilterConsumerBridgeToSqlRequest(sqlCommand, await dbNamesOf(r.metadata));
+        var b = new FilterConsumerBridgeToSqlRequest(sqlCommand, dbNames || (await dbNamesOf(r.metadata)));
         b._addWhere = false;
         await (await getRepositoryInternals(r).translateWhereToFilter(condition)).__applyToConsumer(b);
         return await b.resolveWhere();
@@ -109,6 +111,8 @@ export class SqlDatabase {
     static durationThreshold = 0;
     constructor(sql) {
         this.sql = sql;
+        if (sql.wrapIdentifier)
+            this.wrapIdentifier = (x) => sql.wrapIdentifier(x);
     }
     createdEntities = [];
 }
@@ -159,14 +163,17 @@ class LogSQLCommand {
                         this.logToConsole(duration, sql, this.args);
                     }
                     else {
-                        console.info({ query: sql, arguments: this.args, duration });
+                        console.info(sql + '\n', { arguments: this.args, duration });
                     }
                 }
             }
             return r;
         }
         catch (err) {
-            console.error({ error: err, query: sql, arguments: this.args });
+            console.error((err.message || 'Sql Error') + ':\n', sql, {
+                arguments: this.args,
+                error: err,
+            });
             throw err;
         }
     }
@@ -184,7 +191,7 @@ class ActualSQLServerDataProvider {
         this.strategy = strategy;
     }
     async init() {
-        let dbNameProvider = await dbNamesOf(this.entity);
+        let dbNameProvider = await dbNamesOf(this.entity, (x) => this.sql.wrapIdentifier(x));
         await this.iAmUsed(dbNameProvider);
         return dbNameProvider;
     }
@@ -386,9 +393,9 @@ async function bulkInsert(array, db) {
         // do whatever
         const c = db.createCommand();
         let sql = 'insert into ' +
-            (await items[0]._.metadata.getDbName()) +
+            (await items[0]._.metadata.options.dbName) +
             ' (' +
-            (await Promise.all(items[0]._.metadata.fields.toArray().map((f) => f.getDbName()))).join(',') +
+            (await Promise.all(items[0]._.metadata.fields.toArray().map((f) => f.options.dbName))).join(',') +
             ') values ';
         sql += items
             .map((row) => '(' +

package/esm/src/data-providers/web-sql-data-provider.js

@@ -1,6 +1,6 @@
-import { dbNamesOf, isDbReadonly, } from '../filter/filter-consumer-bridge-to-sql-request';
-import { isAutoIncrement } from '../remult3/RepositoryImplementation';
-import { SqlDatabase } from './sql-database';
+import { dbNamesOf, isDbReadonly, } from '../filter/filter-consumer-bridge-to-sql-request.js';
+import { isAutoIncrement } from '../remult3/RepositoryImplementation.js';
+import { SqlDatabase } from './sql-database.js';
 //SqlDatabase.LogToConsole = true;
 export class WebSqlDataProvider {
     databaseName;

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

@@ -1,6 +1,6 @@
 import type { FieldMetadata } from '../column-interfaces';
 import type { EntityMetadataOverloads, RepositoryOverloads } from '../remult3/RepositoryImplementation';
-import type { EntityFilter, MembersOnly } from '../remult3/remult3';
+import type { EntityFilter, EntityMetadata, MembersOnly } from '../remult3/remult3';
 import type { SqlCommandWithParameters } from '../sql-command';
 import type { Filter, FilterConsumer } from './filter-interfaces';
 export declare class FilterConsumerBridgeToSqlRequest implements FilterConsumer {
@@ -48,4 +48,6 @@ 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>): Promise<EntityDbNames<entityType>>;
+export declare function dbNamesOf<entityType>(repo: EntityMetadataOverloads<entityType>, wrapIdentifier?: (name: string) => string): 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/esm/src/filter/filter-consumer-bridge-to-sql-request.js

@@ -1,5 +1,6 @@
-import { SqlDatabase } from '../data-providers/sql-database';
-import { getEntityMetadata } from '../remult3/RepositoryImplementation';
+import { SqlDatabase } from '../data-providers/sql-database.js';
+import { getEntityMetadata } from '../remult3/RepositoryImplementation.js';
+import { getRelationInfo } from '../remult3/relationInfoMember.js';
 export class FilterConsumerBridgeToSqlRequest {
     r;
     nameProvider;
@@ -151,12 +152,13 @@ export class CustomSqlFilterBuilder {
 export function isDbReadonly(field, dbNames) {
     return (field.dbReadOnly ||
         field.isServerExpression ||
-        dbNames.$dbNameOf(field) != field.options.dbName);
+        (field.options.sqlExpression &&
+            field.options.dbName != dbNames.$dbNameOf(field)));
 }
-export async function dbNamesOf(repo) {
+export async function dbNamesOf(repo, wrapIdentifier = (x) => x) {
     var meta = getEntityMetadata(repo);
     const result = {
-        $entityName: await meta.getDbName(),
+        $entityName: await entityDbName(meta, wrapIdentifier),
         toString: () => result.$entityName,
         $dbNameOf: (field) => {
             var key;
@@ -168,7 +170,43 @@ export async function dbNamesOf(repo) {
         },
     };
     for (const field of meta.fields) {
-        result[field.key] = await field.getDbName();
+        result[field.key] = await fieldDbName(field, meta, wrapIdentifier);
     }
     return result;
 }
+export async function entityDbName(metadata, wrapIdentifier = (x) => x) {
+    if (metadata.options.sqlExpression) {
+        if (typeof metadata.options.sqlExpression === 'string')
+            return metadata.options.sqlExpression;
+        else if (typeof metadata.options.sqlExpression === 'function') {
+            return await metadata.options.sqlExpression(metadata);
+        }
+    }
+    return wrapIdentifier(metadata.options.dbName);
+}
+export async function fieldDbName(f, meta, wrapIdentifier = (x) => x) {
+    try {
+        if (f.options.sqlExpression) {
+            let result;
+            if (typeof f.options.sqlExpression === 'function') {
+                result = await f.options.sqlExpression(meta);
+            }
+            else
+                result = f.options.sqlExpression;
+            if (!result)
+                return f.options.dbName;
+            return result;
+        }
+        const rel = getRelationInfo(f.options);
+        let field = rel?.type === 'toOne' &&
+            f.options.field;
+        if (field) {
+            let fInfo = meta.fields.find(field);
+            if (fInfo)
+                return fieldDbName(fInfo, meta, wrapIdentifier);
+        }
+        return wrapIdentifier(f.options.dbName);
+    }
+    finally {
+    }
+}

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

@@ -1,5 +1,5 @@
 import type { FieldMetadata } from '../column-interfaces';
-import { Remult } from '../context';
+import type { Remult } from '../context';
 import type { EntityFilter, EntityMetadata } from '../remult3/remult3';
 export declare class Filter {
     private apply;

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

@@ -1,6 +1,6 @@
-import { Remult } from '../context';
-import { getEntityRef, getEntitySettings } from '../remult3/getEntityRef';
-import { getRelationInfo } from '../remult3/relationInfoMember';
+import { Remult } from '../context.js';
+import { getEntityRef, getEntitySettings } from '../remult3/getEntityRef.js';
+import { getRelationInfo } from '../remult3/relationInfoMember.js';
 export class Filter {
     apply;
     constructor(apply) {

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

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

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

@@ -1,7 +1,7 @@
-import { buildRestDataProvider } from '../buildRestDataProvider';
-import { remult } from '../remult-proxy';
-import { actionInfo } from '../server-action-info';
-import { streamUrl } from './SubscriptionChannel';
+import { buildRestDataProvider } from '../buildRestDataProvider.js';
+import { remult } from '../remult-proxy.js';
+import { actionInfo } from '../server-action-info.js';
+import { streamUrl } from './SubscriptionChannel.js';
 export class SseSubscriptionClient {
     openConnection(onReconnect) {
         let connectionId;
@@ -37,9 +37,7 @@ export class SseSubscriptionClient {
             function createConnection() {
                 if (source)
                     source.close();
-                source = new EventSource(remult.apiClient.url + '/' + streamUrl, {
-                    withCredentials: true,
-                });
+                source = SseSubscriptionClient.createEventSource(remult.apiClient.url + '/' + streamUrl);
                 source.onmessage = (e) => {
                     let message = JSON.parse(e.data);
                     const listeners = channels.get(message.channel);
@@ -82,5 +80,10 @@ export class SseSubscriptionClient {
             }
         }
     }
+    static createEventSource(url) {
+        return new EventSource(url, {
+            withCredentials: true,
+        });
+    }
 }
 export const ConnectionNotFoundError = 'client connection not found';

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

@@ -1,7 +1,7 @@
 import { v4 as uuid } from 'uuid';
-import { Sort } from '../sort';
-import { remult as defaultRemult } from '../remult-proxy';
-import { getRepositoryInternals } from '../remult3/repository-internals';
+import { Sort } from '../sort.js';
+import { remult as defaultRemult } from '../remult-proxy.js';
+import { getRepositoryInternals } from '../remult3/repository-internals.js';
 export const streamUrl = 'stream';
 //@internal
 export class LiveQuerySubscriber {

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

@@ -1,4 +1,4 @@
-import { findOptionsFromJson } from '../data-providers/rest-data-provider';
+import { findOptionsFromJson } from '../data-providers/rest-data-provider.js';
 /* @internal*/
 export class LiveQueryPublisher {
     subscriptionServer;

package/esm/src/remult-proxy.js

@@ -1,4 +1,4 @@
-import { getInternalKey } from './remult3/repository-internals';
+import { getInternalKey } from './remult3/repository-internals.js';
 let defaultRemult;
 function defaultFactory() {
     if (!defaultRemult) {