remult 0.22.6 → 0.22.7-exp.0

package/esm/server/expressBridge.js

@@ -1,12 +1,15 @@
 import { __decorate, __metadata } from "tslib";
-import { Action, actionInfo, classBackendMethodsArray, serverActionField, } from '../src/server-action';
-import { DataApi, serializeError, } from '../src/data-api';
-import { allEntities, Remult, RemultAsyncLocalStorage, } from '../src/context';
-import { Entity, Fields, getEntityKey, IdEntity, } from '../src/remult3';
-import { LiveQueryPublisher, InMemoryLiveQueryStorage, } from '../src/live-query/SubscriptionServer';
+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 { Fields, IdEntity } from '../src/remult3/RepositoryImplementation';
+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';
 export function createRemultServerCore(options, serverCoreOptions) {
     if (!options) {
         options = {};
@@ -38,7 +41,7 @@ export function createRemultServerCore(options, serverCoreOptions) {
                         if (started)
                             return;
                         started = true;
-                        console.time('Ensure Schema');
+                        console.time('Schema ensured');
                     };
                     entitiesMetaData.push(...options.entities.map((e) => remult.repo(e).metadata));
                     if (dp.ensureSchema) {
@@ -55,7 +58,7 @@ export function createRemultServerCore(options, serverCoreOptions) {
                         }
                     }
                     if (started)
-                        console.timeEnd('Ensure Schema');
+                        console.timeEnd('Schema ensured');
                 }
                 if (options.initApi)
                     await options.initApi(remult);

package/esm/server/index.d.ts

@@ -1,6 +1,6 @@
-import { RemultServer, RemultServerOptions, ServerCoreOptions } from './expressBridge';
-export { queuedJobInfo, QueueStorage, GenericRequestInfo, GenericRequestHandler, RemultServerCore, GenericResponse, GenericRouter, RemultServerOptions, SpecificRoute, RemultServer, InitRequestOptions, } from './expressBridge';
-export { JsonEntityFileStorage, JsonFileDataProvider, } from './JsonEntityFileStorage';
-export { DataProviderLiveQueryStorage } from '../live-query/data-provider-live-query-storage';
+import type { RemultServer, RemultServerOptions, ServerCoreOptions } from './expressBridge';
 export { SseSubscriptionServer } from '../SseSubscriptionServer';
+export { DataProviderLiveQueryStorage } from '../live-query/data-provider-live-query-storage';
+export { JsonEntityFileStorage, JsonFileDataProvider, } from './JsonEntityFileStorage';
+export { GenericRequestHandler, GenericRequestInfo, GenericResponse, GenericRouter, InitRequestOptions, QueueStorage, RemultServer, RemultServerCore, RemultServerOptions, SpecificRoute, queuedJobInfo, } from './expressBridge';
 export declare function createRemultServer<RequestType>(options: RemultServerOptions<RequestType>, serverCoreOptions?: ServerCoreOptions<RequestType>): RemultServer<RequestType>;

package/esm/server/index.js

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

package/esm/server/initDataProvider.d.ts

@@ -1,2 +1,2 @@
-import { DataProvider } from '../src/data-interfaces';
+import type { DataProvider } from '../src/data-interfaces';
 export declare function initDataProvider(optionsDataProvider?: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>)): Promise<DataProvider>;

package/esm/src/CompoundIdField.d.ts

@@ -0,0 +1,27 @@
+import type { ClassType } from '../classType';
+import type { FieldMetadata, FieldOptions, ValueConverter } from './column-interfaces';
+import type { EntityFilter } from './remult3/remult3';
+export declare class CompoundIdField implements FieldMetadata<string> {
+    fields: FieldMetadata[];
+    constructor(...columns: FieldMetadata[]);
+    apiUpdateAllowed(item: any): boolean;
+    displayValue(item: any): string;
+    includedInApi: boolean;
+    toInput(value: string, inputType?: string): string;
+    fromInput(inputValue: string, inputType?: string): string;
+    getDbName(): Promise<string>;
+    getId(instance: any): string;
+    options: FieldOptions<any, any>;
+    get valueConverter(): Required<ValueConverter<string>>;
+    target: ClassType<any>;
+    readonly: true;
+    allowNull: boolean;
+    dbReadOnly: boolean;
+    isServerExpression: boolean;
+    key: string;
+    caption: string;
+    inputType: string;
+    dbName: string;
+    valueType: any;
+    isEqualTo(value: FieldMetadata<string> | string): EntityFilter<any>;
+}

package/esm/src/CompoundIdField.js

@@ -0,0 +1,41 @@
+export class CompoundIdField {
+    constructor(...columns) {
+        this.fields = columns;
+    }
+    apiUpdateAllowed(item) {
+        throw new Error('Method not implemented.');
+    }
+    displayValue(item) {
+        throw new Error('Method not implemented.');
+    }
+    toInput(value, inputType) {
+        throw new Error('Method not implemented.');
+    }
+    fromInput(inputValue, inputType) {
+        throw new Error('Method not implemented.');
+    }
+    getDbName() {
+        return Promise.resolve('');
+    }
+    getId(instance) {
+        let r = '';
+        this.fields.forEach((c) => {
+            if (r.length > 0)
+                r += ',';
+            r += instance[c.key];
+        });
+        return r;
+    }
+    get valueConverter() {
+        throw new Error('cant get value converter of compound id');
+    }
+    isEqualTo(value) {
+        let result = {};
+        let val = value.toString();
+        let id = val.split(',');
+        this.fields.forEach((c, i) => {
+            result[c.key] = id[i];
+        });
+        return result;
+    }
+}

package/esm/src/buildRestDataProvider.d.ts

@@ -1,4 +1,4 @@
-import { RestDataProviderHttpProvider } from './data-interfaces';
+import type { RestDataProviderHttpProvider } from './data-interfaces';
 import { RestDataProviderHttpProviderUsingFetch } from './data-providers/rest-data-provider';
 export declare function buildRestDataProvider(provider: ExternalHttpProvider | typeof fetch): RestDataProviderHttpProviderUsingFetch | RestDataProviderHttpProvider;
 export declare function isExternalHttpProvider(item: any): boolean;

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

@@ -1,6 +1,6 @@
-import { ClassType } from '../classType';
-import { Allowed, AllowedForInstance } from './context';
-import { EntityMetadata, FieldRef, OmitEB } from './remult3';
+import type { ClassType } from '../classType';
+import type { Allowed, AllowedForInstance } from './context';
+import type { EntityMetadata, FieldRef, OmitEB } from './remult3/remult3';
 export interface FieldOptions<entityType = any, valueType = any> {
     /** A human readable name for the field. Can be used to achieve a consistent caption for a field throughout the app
      * @example
@@ -40,7 +40,13 @@ export interface FieldOptions<entityType = any, valueType = any> {
     saving?: (entity: entityType, fieldRef: FieldRef<entityType, valueType>) => any | Promise<any>;
     /**  An expression that will determine this fields value on the backend and be provided to the front end*/
     serverExpression?: (entity: entityType) => valueType | Promise<valueType>;
-    /** The name of the column in the database that holds the data for this field. If no name is set, the key will be used instead. */
+    /** The name of the column in the database that holds the data for this field. If no name is set, the key will be used instead.
+     * Be aware that if you are using postgres and want to keep your casing, you have to escape your string with double quotes.
+     * @example
+     *
+     * @Fields.string({ dbName: '"userName"'})
+     * userName=''
+     */
     dbName?: string;
     /** Used or fields that are based on an sql expressions, instead of a physical table column
      * @example

package/esm/src/column.d.ts

@@ -1,33 +1,6 @@
-import { ClassType } from '../classType';
-import { FieldMetadata, FieldOptions, ValueConverter } from './column-interfaces';
-import { Filter } from './filter/filter-interfaces';
-import { EntityFilter, FindOptions, idType, Repository, RepositoryImplementation } from './remult3';
+import type { FindOptions, idType, Repository } from './remult3/remult3';
+import type { RepositoryImplementation } from './remult3/RepositoryImplementation';
 export declare function makeTitle(name: string): string;
-export declare class CompoundIdField implements FieldMetadata<string> {
-    fields: FieldMetadata[];
-    constructor(...columns: FieldMetadata[]);
-    apiUpdateAllowed(item: any): boolean;
-    displayValue(item: any): string;
-    includedInApi: boolean;
-    toInput(value: string, inputType?: string): string;
-    fromInput(inputValue: string, inputType?: string): string;
-    getDbName(): Promise<string>;
-    getId(instance: any): string;
-    options: FieldOptions<any, any>;
-    get valueConverter(): Required<ValueConverter<string>>;
-    target: ClassType<any>;
-    readonly: true;
-    allowNull: boolean;
-    dbReadOnly: boolean;
-    isServerExpression: boolean;
-    key: string;
-    caption: string;
-    inputType: string;
-    dbName: string;
-    valueType: any;
-    isEqualTo(value: FieldMetadata<string> | string): EntityFilter<any>;
-    resultIdFilter(id: string, data: any): Filter;
-}
 export declare class LookupColumn<T> {
     private repository;
     id: idType<T>;

package/esm/src/column.js

@@ -1,6 +1,6 @@
 import { assign } from '../assign';
-import { Filter } from './filter/filter-interfaces';
-import { getEntityRef, __updateEntityBasedOnWhere, } from './remult3';
+import { __updateEntityBasedOnWhere } from './remult3/__updateEntityBasedOnWhere';
+import { getEntityRef } from './remult3/getEntityRef';
 export function makeTitle(name) {
     // insert a space before all caps
     return (name
@@ -10,62 +10,6 @@ export function makeTitle(name) {
         .replace('Email', 'eMail')
         .replace(' I D', ' ID'));
 }
-export class CompoundIdField {
-    constructor(...columns) {
-        this.fields = columns;
-    }
-    apiUpdateAllowed(item) {
-        throw new Error('Method not implemented.');
-    }
-    displayValue(item) {
-        throw new Error('Method not implemented.');
-    }
-    toInput(value, inputType) {
-        throw new Error('Method not implemented.');
-    }
-    fromInput(inputValue, inputType) {
-        throw new Error('Method not implemented.');
-    }
-    getDbName() {
-        return Promise.resolve('');
-    }
-    getId(instance) {
-        let r = '';
-        this.fields.forEach((c) => {
-            if (r.length > 0)
-                r += ',';
-            r += instance[c.key];
-        });
-        return r;
-    }
-    get valueConverter() {
-        throw new Error('cant get value converter of compound id');
-    }
-    isEqualTo(value) {
-        let result = {};
-        let val = value.toString();
-        let id = val.split(',');
-        this.fields.forEach((c, i) => {
-            result[c.key] = id[i];
-        });
-        return result;
-    }
-    resultIdFilter(id, data) {
-        return new Filter((add) => {
-            let idParts = [];
-            if (id != undefined)
-                idParts = id.split(',');
-            this.fields.forEach((c, i) => {
-                let val = undefined;
-                if (i < idParts.length)
-                    val = idParts[i];
-                if (data[c.key] != undefined)
-                    val = data[c.key];
-                add.isEqualTo(c, val);
-            });
-        });
-    }
-}
 export class LookupColumn {
     constructor(repository, id) {
         this.repository = repository;

package/esm/src/context.d.ts

@@ -1,9 +1,9 @@
-import { DataProvider } from './data-interfaces';
-import { EntityMetadata, EntityRef, FindOptions, Repository } from './remult3';
-import { ClassType } from '../classType';
+import type { ClassType } from '../classType';
+import type { DataProvider } from './data-interfaces';
+import type { EntityMetadata, EntityRef, FindOptions, Repository } from './remult3/remult3';
+import type { ExternalHttpProvider } from './buildRestDataProvider';
+import type { SubscriptionClient, Unsubscribe } from './live-query/SubscriptionChannel';
 import type { SubscriptionServer } from './live-query/SubscriptionServer';
-import { ExternalHttpProvider } from './buildRestDataProvider';
-import { SubscriptionClient, Unsubscribe } from './live-query/SubscriptionChannel';
 export declare class RemultAsyncLocalStorage {
     private readonly remultObjectStorage;
     static enable(): void;

package/esm/src/context.js

@@ -1,9 +1,9 @@
-import { actionInfo, serverActionField } from './server-action';
 import { RestDataProvider } from './data-providers/rest-data-provider';
-import { RepositoryImplementation } from './remult3/RepositoryImplementation';
 import { LiveQueryClient } from './live-query/LiveQueryClient';
 import { SseSubscriptionClient } from './live-query/SseSubscriptionClient';
 import { RemultProxy, remult } from './remult-proxy';
+import { RepositoryImplementation } from './remult3/RepositoryImplementation';
+import { actionInfo, serverActionField } from './server-action-info';
 import { buildRestDataProvider, isExternalHttpProvider, } from './buildRestDataProvider';
 export class RemultAsyncLocalStorage {
     constructor(remultObjectStorage) {
@@ -180,7 +180,7 @@ export class Remult {
 }
 /** A helper callback that can be used to debug and trace all find operations. Useful in debugging scenarios */
 Remult.onFind = (metadata, options) => { };
-RemultProxy.defaultRemult = new Remult();
+RemultProxy.defaultRemultFactory = () => new Remult();
 export const allEntities = [];
 export const classHelpers = new Map();
 export class ClassHelper {

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

@@ -1,6 +1,6 @@
-import { Remult } from './context';
-import type { FindOptions, Repository } from './remult3';
+import type { Remult } from './context';
 import type { ErrorInfo } from './data-interfaces';
+import type { FindOptions, Repository } from './remult3/remult3';
 export declare class DataApi<T = any> {
     private repository;
     private remult;

package/esm/src/data-api.js

@@ -1,8 +1,7 @@
-import { customUrlToken, buildFilterFromRequestParameters, } from './filter/filter-interfaces';
 import { doTransaction } from './context';
-import { Filter } from './filter/filter-interfaces';
-import { ForbiddenError } from './server-action';
 import { findOptionsToJson, liveQueryAction, } from './data-providers/rest-data-provider';
+import { Filter, buildFilterFromRequestParameters, customUrlToken, } from './filter/filter-interfaces';
+import { ForbiddenError } from './server-action';
 export class DataApi {
     constructor(repository, remult) {
         this.repository = repository;
@@ -159,7 +158,9 @@ export class DataApi {
             where.push(buildFilterFromRequestParameters(this.repository.metadata, {
                 get: (key) => {
                     let result = request.get(key);
-                    if (key.startsWith(customUrlToken) && result && typeof result === "string")
+                    if (key.startsWith(customUrlToken) &&
+                        result &&
+                        typeof result === 'string')
                         return JSON.parse(result);
                     return result;
                 },

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

@@ -1,6 +1,6 @@
+import type { Filter } from './filter/filter-interfaces';
+import type { EntityMetadata, OmitEB } from './remult3/remult3';
 import { Sort } from './sort';
-import { Filter } from './filter/filter-interfaces';
-import { EntityMetadata, OmitEB } from './remult3';
 export interface DataProvider {
     getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;

package/esm/src/data-providers/array-entity-data-provider.d.ts

@@ -1,6 +1,6 @@
-import { EntityDataProvider, EntityDataProviderFindOptions } from '../data-interfaces';
+import type { EntityDataProvider, EntityDataProviderFindOptions } from '../data-interfaces';
 import { Filter } from '../filter/filter-interfaces';
-import { EntityMetadata, EntityFilter } from '../remult3';
+import type { EntityFilter, EntityMetadata } from '../remult3/remult3';
 export declare class ArrayEntityDataProvider implements EntityDataProvider {
     private entity;
     private rows?;

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

@@ -1,5 +1,5 @@
-import { customDatabaseFilterToken, Filter, } from '../filter/filter-interfaces';
-import { CompoundIdField } from '../column';
+import { CompoundIdField } from '../CompoundIdField';
+import { Filter, customDatabaseFilterToken } from '../filter/filter-interfaces';
 export class ArrayEntityDataProvider {
     constructor(entity, rows) {
         this.entity = entity;

package/esm/src/data-providers/in-memory-database.d.ts

@@ -1,6 +1,6 @@
-import { DataProvider, EntityDataProvider } from '../data-interfaces';
-import { __RowsOfDataForTesting } from '../__RowsOfDataForTesting';
-import { EntityMetadata } from '../remult3';
+import type { __RowsOfDataForTesting } from '../__RowsOfDataForTesting';
+import type { DataProvider, EntityDataProvider } from '../data-interfaces';
+import type { EntityMetadata } from '../remult3/remult3';
 export declare class InMemoryDataProvider implements DataProvider, __RowsOfDataForTesting {
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
     rows: any;

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

@@ -1,5 +1,5 @@
-import { EntityDataProvider, DataProvider } from '../data-interfaces';
-import { EntityMetadata } from '../remult3';
+import type { DataProvider, EntityDataProvider } from '../data-interfaces';
+import type { EntityMetadata } from '../remult3/remult3';
 export interface JsonEntityStorage {
     getItem(entityDbName: string): string | null;
     setItem(entityDbName: string, json: string): any;

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

@@ -1,8 +1,8 @@
-import { EntityDataProvider, DataProvider, EntityDataProviderFindOptions, RestDataProviderHttpProvider } from '../data-interfaces';
+import type { DataProvider, EntityDataProvider, EntityDataProviderFindOptions, RestDataProviderHttpProvider } from '../data-interfaces';
 import { UrlBuilder } from '../../urlBuilder';
+import type { ApiClient } from '../context';
 import { Filter } from '../filter/filter-interfaces';
-import { EntityMetadata } from '../remult3';
-import { ApiClient } from '../context';
+import type { EntityMetadata } from '../remult3/remult3';
 export declare class RestDataProvider implements DataProvider {
     private apiProvider;
     constructor(apiProvider: () => ApiClient);

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

@@ -1,7 +1,7 @@
 import { UrlBuilder } from '../../urlBuilder';
-import { customUrlToken, Filter } from '../filter/filter-interfaces';
 import { buildRestDataProvider, retry } from '../buildRestDataProvider';
-import { actionInfo } from '../server-action';
+import { customUrlToken, Filter } from '../filter/filter-interfaces';
+import { actionInfo } from '../server-action-info';
 export class RestDataProvider {
     constructor(apiProvider) {
         this.apiProvider = apiProvider;

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

@@ -1,8 +1,9 @@
-import { EntityDataProvider, DataProvider } from '../data-interfaces';
-import { SqlCommand, SqlCommandWithParameters, SqlImplementation, SqlResult } from '../sql-command';
-import { CustomSqlFilterBuilderFunction } from '../filter/filter-consumer-bridge-to-sql-request';
-import { EntityMetadata, EntityFilter, RepositoryOverloads } from '../remult3';
-import { Remult } from '../context';
+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 { EntityFilter, EntityMetadata } from '../remult3/remult3';
+import type { RepositoryOverloads } from '../remult3/RepositoryImplementation';
 export declare class SqlDatabase implements DataProvider {
     private sql;
     static getDb(remult?: Remult): SqlDatabase;

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

@@ -1,9 +1,9 @@
-import { CompoundIdField } from '../column';
-import { dbNamesOf, FilterConsumerBridgeToSqlRequest, isDbReadonly, } from '../filter/filter-consumer-bridge-to-sql-request';
-import { customDatabaseFilterToken, Filter } from '../filter/filter-interfaces';
-import { Sort } from '../sort';
-import { getRepository, } from '../remult3';
+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';
 // @dynamic
 export class SqlDatabase {

package/esm/src/data-providers/web-sql-data-provider.d.ts

@@ -1,7 +1,7 @@
-import { __RowsOfDataForTesting } from '../__RowsOfDataForTesting';
-import { SqlCommand, SqlImplementation } from '../sql-command';
-import { EntityMetadata } from '../remult3';
-import { Remult } from '../context';
+import type { __RowsOfDataForTesting } from '../__RowsOfDataForTesting';
+import type { SqlCommand, SqlImplementation } from '../sql-command';
+import type { Remult } from '../context';
+import type { EntityMetadata } from '../remult3/remult3';
 export declare class WebSqlDataProvider implements SqlImplementation, __RowsOfDataForTesting {
     private databaseName;
     rows: {

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

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

package/esm/src/entity.d.ts

@@ -1,6 +1,6 @@
-import { Allowed, AllowedForInstance } from './context';
-import { FieldMetadata } from './column-interfaces';
-import { EntityOrderBy, FieldsMetadata, EntityFilter, EntityRef, EntityMetadata } from './remult3';
+import type { Allowed, AllowedForInstance } from './context';
+import type { FieldMetadata } from './column-interfaces';
+import type { EntityFilter, EntityMetadata, EntityOrderBy, EntityRef, FieldsMetadata } from './remult3/remult3';
 export interface EntityOptions<entityType = any> {
     /**A human readable name for the entity */
     caption?: string;
@@ -73,6 +73,10 @@ export interface EntityOptions<entityType = any> {
      * If no name is set, the `key` will be used instead.
      * @example
      * dbName:'myProducts'
+     *
+     * You can also add your schema name to the table name
+     * @example
+     * dbName:'public."myProducts"'
      */
     dbName?: string;
     /** For entities that are based on SQL expressions instead of a physical table or view*/

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

@@ -1,8 +1,8 @@
-import { SqlCommandWithParameters } from '../sql-command';
-import { Filter, FilterConsumer } from './filter-interfaces';
-import { FieldMetadata } from '../column-interfaces';
-import { EntityFilter, OmitEB } from '../remult3/remult3';
-import { EntityMetadataOverloads, RepositoryOverloads } from '../remult3';
+import type { FieldMetadata } from '../column-interfaces';
+import type { EntityMetadataOverloads, RepositoryOverloads } from '../remult3/RepositoryImplementation';
+import type { EntityFilter, OmitEB } from '../remult3/remult3';
+import type { SqlCommandWithParameters } from '../sql-command';
+import type { Filter, FilterConsumer } from './filter-interfaces';
 export declare class FilterConsumerBridgeToSqlRequest implements FilterConsumer {
     private r;
     private nameProvider;

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

@@ -1,5 +1,5 @@
-import { getEntityMetadata, } from '../remult3';
 import { SqlDatabase } from '../data-providers/sql-database';
+import { getEntityMetadata } from '../remult3/RepositoryImplementation';
 export class FilterConsumerBridgeToSqlRequest {
     constructor(r, nameProvider) {
         this.r = r;

package/esm/src/filter/filter-consumer-bridge-to-url-builder.d.ts

@@ -1 +0,0 @@
-export {};

package/esm/src/filter/filter-consumer-bridge-to-url-builder.js

@@ -1 +0,0 @@
-export {};

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

@@ -1,6 +1,6 @@
-import { FieldMetadata } from '../column-interfaces';
-import { Remult } from '../context';
-import { EntityMetadata, EntityFilter } from '../remult3';
+import type { FieldMetadata } from '../column-interfaces';
+import type { Remult } from '../context';
+import type { EntityFilter, EntityMetadata } from '../remult3/remult3';
 export declare class Filter {
     private apply?;
     constructor(apply?: (add: FilterConsumer) => void);
@@ -83,3 +83,4 @@ export interface customFilterInfo<entityType> {
         rawFilterTranslator: (args: any, r: Remult) => EntityFilter<entityType> | Promise<EntityFilter<entityType>>;
     };
 }
+export declare function __updateEntityBasedOnWhere<T>(entityDefs: EntityMetadata<T>, where: EntityFilter<T>, r: T): void;

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

@@ -1,4 +1,4 @@
-import { getEntityRef, getEntitySettings, } from '../remult3';
+import { getEntityRef, getEntitySettings } from '../remult3/getEntityRef';
 export class Filter {
     constructor(apply) {
         this.apply = apply;
@@ -490,3 +490,26 @@ class customTranslator {
         }
     }
 }
+export function __updateEntityBasedOnWhere(entityDefs, where, r) {
+    let w = Filter.fromEntityFilter(entityDefs, where);
+    const emptyFunction = () => { };
+    if (w) {
+        w.__applyToConsumer({
+            custom: emptyFunction,
+            databaseCustom: emptyFunction,
+            containsCaseInsensitive: emptyFunction,
+            isDifferentFrom: emptyFunction,
+            isEqualTo: (col, val) => {
+                r[col.key] = val;
+            },
+            isGreaterOrEqualTo: emptyFunction,
+            isGreaterThan: emptyFunction,
+            isIn: emptyFunction,
+            isLessOrEqualTo: emptyFunction,
+            isLessThan: emptyFunction,
+            isNotNull: emptyFunction,
+            isNull: emptyFunction,
+            or: emptyFunction,
+        });
+    }
+}

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

@@ -1,6 +1,6 @@
-import { RestDataProvider, } from '../data-providers/rest-data-provider';
 import { buildRestDataProvider } from '../buildRestDataProvider';
-import { LiveQuerySubscriber, liveQueryKeepAliveRoute, } from './SubscriptionChannel';
+import { RestDataProvider } from '../data-providers/rest-data-provider';
+import { liveQueryKeepAliveRoute, LiveQuerySubscriber, } from './SubscriptionChannel';
 /* @internal*/
 export class LiveQueryClient {
     constructor(apiProvider, getUserId) {
@@ -160,7 +160,7 @@ export class LiveQueryClient {
                 }
                 if (ids.length > 0) {
                     let p = this.apiProvider();
-                    let { actionInfo } = await import('../server-action');
+                    let { actionInfo } = await import('../server-action-info');
                     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.d.ts

@@ -1,4 +1,4 @@
-import { SubscriptionClient, SubscriptionClientConnection } from './SubscriptionChannel';
+import type { SubscriptionClient, SubscriptionClientConnection } from './SubscriptionChannel';
 export declare class SseSubscriptionClient implements SubscriptionClient {
     openConnection(onReconnect: VoidFunction): Promise<SubscriptionClientConnection>;
 }

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';
-import { streamUrl, } from './SubscriptionChannel';
+import { actionInfo } from '../server-action-info';
+import { streamUrl } from './SubscriptionChannel';
 export class SseSubscriptionClient {
     openConnection(onReconnect) {
         let connectionId;

package/esm/src/live-query/SubscriptionChannel.d.ts

@@ -1,4 +1,4 @@
-import { Remult } from '../../index';
+import type { Remult } from '../context';
 export declare const streamUrl = "stream";
 export interface SubscriptionListener<type> {
     next(message: type): void;