remult 0.18.1-exp.2 → 0.18.1-exp.21

package/esm/src/live-query/{LiveQueryPublisher.js → SubscriptionServer.js}

@@ -1,78 +1,17 @@
-import { v4 as uuid } from 'uuid';
-import { findOptionsFromJson, findOptionsToJson } from '../data-providers/rest-data-provider';
-export class LiveQueryStorageInMemoryImplementation {
-    constructor() {
-        this.debugFileSaver = (x) => { };
-        this.queries = [];
-    }
-    debug() {
-        this.debugFileSaver(this.queries);
-    }
-    async keepAliveAndReturnUnknownIds(ids) {
-        const result = [];
-        for (const id of ids) {
-            let q = this.queries.find(q => q.id === id);
-            if (q) {
-                q.lastUsed = new Date().toISOString();
-            }
-            else
-                result.push(id);
-        }
-        this.debug();
-        return result;
-    }
-    store(query) {
-        this.queries.push({ ...query, lastUsed: new Date().toISOString() });
-        this.debug();
-    }
-    remove(id) {
-        this.queries = this.queries.filter(q => q.id !== id);
-        this.debug();
-    }
-    async provideListeners(entityKey, handle) {
-        let d = new Date();
-        d.setMinutes(d.getMinutes() - 5);
-        this.queries = this.queries.filter(x => x.lastUsed > d.toISOString());
-        for (const q of this.queries) {
-            if (q.entityKey === entityKey) {
-                await handle({
-                    query: q,
-                    setLastIds: async (ids) => { q.lastIds = ids; },
-                });
-            }
-        }
-        this.debug();
-    }
-}
+import { findOptionsFromJson } from '../data-providers/rest-data-provider';
+/* @internal*/
 export class LiveQueryPublisher {
-    constructor(dispatcher, storage, performWithRequest) {
-        this.dispatcher = dispatcher;
-        this.storage = storage;
+    constructor(subscriptionServer, liveQueryStorage, performWithRequest) {
+        this.subscriptionServer = subscriptionServer;
+        this.liveQueryStorage = liveQueryStorage;
         this.performWithRequest = performWithRequest;
         this.debugFileSaver = (x) => { };
     }
-    stopLiveQuery(id) {
-        this.storage.remove(id);
-    }
-    sendChannelMessage(channel, message) {
-        this.dispatcher.sendChannelMessage(channel, message);
-    }
-    defineLiveQueryChannel(serializeRequest, entityKey, findOptions, ids, userId, repo) {
-        const id = `users:${userId}:queries:${uuid()}`;
-        this.storage.store({
-            requestJson: serializeRequest(),
-            entityKey,
-            id,
-            findOptionsJson: findOptionsToJson(findOptions, repo.metadata),
-            lastIds: ids
-        });
-        return id;
-    }
-    runPromise(p) {
-    }
+    runPromise(p) { }
     itemChanged(entityKey, changes) {
-        //TODO - optimize so that the user will get their messages first. Based on user id
-        this.runPromise(this.storage.provideListeners(entityKey, async ({ query, setLastIds }) => {
+        //TODO 2 - optimize so that the user will get their messages first. Based on user id
+        this.runPromise(this.liveQueryStorage().forEach(entityKey, async ({ query: q, setData }) => {
+            let query = { ...q.data };
             await this.performWithRequest(query.requestJson, entityKey, async (repo) => {
                 const messages = [];
                 const currentItems = await repo.find(findOptionsFromJson(query.findOptionsJson, repo.metadata));
@@ -107,15 +46,63 @@ export class LiveQueryPublisher {
                     }
                 }
                 this.debugFileSaver({
-                    query: query.id,
+                    query: q.id,
                     currentIds,
                     changes,
                     lastIds: query.lastIds,
                     messages
                 });
-                await setLastIds(currentIds);
-                this.dispatcher.sendChannelMessage(query.id, messages);
+                query.lastIds = currentIds;
+                await setData(query);
+                if (messages.length > 0)
+                    this.subscriptionServer().publishMessage(q.id, messages);
             });
         }));
     }
 }
+export class InMemoryLiveQueryStorage {
+    constructor() {
+        this.debugFileSaver = (x) => { };
+        this.queries = [];
+        this.removeCountForTesting = 0;
+    }
+    debug() {
+        this.debugFileSaver(this.queries);
+    }
+    async keepAliveAndReturnUnknownQueryIds(ids) {
+        const result = [];
+        for (const id of ids) {
+            let q = this.queries.find(q => q.id === id);
+            if (q) {
+                q.lastUsed = new Date().toISOString();
+            }
+            else
+                result.push(id);
+        }
+        this.debug();
+        return result;
+    }
+    add(query) {
+        this.queries.push({ ...query, lastUsed: new Date().toISOString() });
+        this.debug();
+    }
+    remove(id) {
+        this.queries = this.queries.filter(q => q.id !== id);
+        this.removeCountForTesting++;
+        this.debug();
+    }
+    async forEach(entityKey, handle) {
+        let d = new Date();
+        d.setMinutes(d.getMinutes() - 5);
+        this.queries = this.queries.filter(x => x.lastUsed > d.toISOString());
+        for (const q of this.queries) {
+            if (q.entityKey === entityKey) {
+                await handle({
+                    query: q,
+                    setData: async (data) => { q.data = data; },
+                });
+            }
+        }
+        this.debug();
+    }
+}

package/esm/src/remult-proxy.js

@@ -3,15 +3,47 @@ export class RemultProxy {
     constructor() {
         /*@internal*/
         this.remultFactory = () => RemultProxy.defaultRemult;
-        this.repo = (...args) => this.remultFactory().repo(...args);
+        //@ts-ignore
+        this.repo = (...args) => {
+            let self = this;
+            return {
+                addEventListener: (...args2) => self.remultFactory().repo(...args).addEventListener(...args2),
+                count: (...args2) => self.remultFactory().repo(...args).count(...args2),
+                create: (...args2) => self.remultFactory().repo(...args).create(...args2),
+                delete: (args2) => self.remultFactory().repo(...args).delete(args2),
+                find: (...args2) => self.remultFactory().repo(...args).find(...args2),
+                findFirst: (...args2) => self.remultFactory().repo(...args).findFirst(...args2),
+                findId: (...args2) => self.remultFactory().repo(...args).findId(...args2),
+                fromJson: (...args2) => self.remultFactory().repo(...args).fromJson(...args2),
+                getEntityRef: (...args2) => self.remultFactory().repo(...args).getEntityRef(...args2),
+                insert: (args2) => self.remultFactory().repo(...args).insert(args2),
+                liveQuery: (...args2) => self.remultFactory().repo(...args).liveQuery(...args2),
+                get metadata() {
+                    return self.remultFactory().repo(...args).metadata;
+                },
+                query: (...args2) => self.remultFactory().repo(...args).query(...args2),
+                save: (args2) => self.remultFactory().repo(...args).save(args2),
+                update: (...args2) => self.remultFactory().repo(...args).update(...args2),
+            };
+        };
     }
+    /* @internal*/
     get liveQuerySubscriber() { return this.remultFactory().liveQuerySubscriber; }
     ;
+    /* @internal*/
     set liveQuerySubscriber(val) { this.remultFactory().liveQuerySubscriber = val; }
     ;
+    /* @internal*/
+    get liveQueryStorage() { return this.remultFactory().liveQueryStorage; }
+    ;
+    /* @internal*/
+    set liveQueryStorage(val) { this.remultFactory().liveQueryStorage = val; }
+    ;
+    /* @internal*/
     get liveQueryPublisher() {
         return this.remultFactory().liveQueryPublisher;
     }
+    /* @internal*/
     set liveQueryPublisher(val) {
         this.remultFactory().liveQueryPublisher = val;
     }
@@ -24,6 +56,7 @@ export class RemultProxy {
     get dataProvider() { return this.remultFactory().dataProvider; }
     ;
     set dataProvider(provider) { this.remultFactory().dataProvider = provider; }
+    /*@internal*/
     get repCache() { return this.remultFactory().repCache; }
     ;
     authenticated() {
@@ -38,6 +71,10 @@ export class RemultProxy {
     clearAllCache() {
         return this.remultFactory().clearAllCache();
     }
+    /*@internal*/
+    resetFactory() {
+        this.remultFactory = () => RemultProxy.defaultRemult;
+    }
     get user() {
         return this.remultFactory().user;
     }
@@ -50,5 +87,11 @@ export class RemultProxy {
     set apiClient(client) {
         this.remultFactory().apiClient = client;
     }
+    get subscriptionServer() {
+        return this.remultFactory().subscriptionServer;
+    }
+    set subscriptionServer(value) {
+        this.remultFactory().subscriptionServer = value;
+    }
 }
 export const remult = new RemultProxy();

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

@@ -41,6 +41,7 @@ export declare class RepositoryImplementation<entityType> implements Repository<
     private getRefForExistingRow;
     save(item: Partial<OmitEB<entityType>>[]): Promise<entityType[]>;
     save(item: Partial<OmitEB<entityType>>): Promise<entityType>;
+    liveQuery(options?: FindOptions<entityType>): any;
     find(options: FindOptions<entityType>): Promise<entityType[]>;
     buildEntityDataProviderFindOptions(options: FindOptions<entityType>): Promise<EntityDataProviderFindOptions>;
     private mapRawDataToResult;
@@ -51,7 +52,6 @@ export declare class RepositoryImplementation<entityType> implements Repository<
     create(item?: Partial<OmitEB<entityType>>): entityType;
     fromJson(json: any, newRow?: boolean): Promise<entityType>;
     findId(id: any, options?: FindFirstOptionsBase<entityType>): Promise<entityType>;
-    private translateWhereToFilter;
 }
 export declare function __updateEntityBasedOnWhere<T>(entityDefs: EntityMetadata<T>, where: EntityFilter<T>, r: T): void;
 export declare type EntityOptionsFactory = (remult: Remult) => EntityOptions;
@@ -178,7 +178,6 @@ export declare class columnDefsImpl implements FieldMetadata {
     private settings;
     private entityDefs;
     constructor(settings: FieldOptions, entityDefs: EntityFullInfo<any>, remult: Remult);
-    dbNamePromise: Promise<string>;
     getDbName(): Promise<string>;
     options: FieldOptions<any, any>;
     target: ClassType<any>;
@@ -220,7 +219,10 @@ export declare class Fields {
     static integer<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): (target: any, key: any, c?: any) => void;
     static autoIncrement<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): (target: any, key: any, c?: any) => void;
     static number<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): (target: any, key: any, c?: any) => void;
+    static createdAt<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): (target: any, key: any, c?: any) => void;
+    static updatedAt<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): (target: any, key: any, c?: any) => void;
     static uuid<entityType = any>(...options: (FieldOptions<entityType, string> | ((options: FieldOptions<entityType, string>, remult: Remult) => void))[]): (target: any, key: any, c?: any) => void;
+    static cuid<entityType = any>(...options: (FieldOptions<entityType, string> | ((options: FieldOptions<entityType, string>, remult: Remult) => void))[]): (target: any, key: any, c?: any) => void;
     static string<entityType = any>(...options: (StringFieldOptions<entityType> | ((options: StringFieldOptions<entityType>, remult: Remult) => void))[]): (target: any, key: any, c?: any) => void;
     static boolean<entityType = any>(...options: (FieldOptions<entityType, boolean> | ((options: FieldOptions<entityType, boolean>, remult: Remult) => void))[]): (target: any, key: any, c?: any) => void;
 }
@@ -323,4 +325,8 @@ declare class SubscribableImp implements Subscribable {
         reportObserved: () => void;
     }): Unobserve;
 }
+export declare function getEntityMetadata<entityType>(entity: EntityMetadataOverloads<entityType>): EntityMetadata<entityType>;
+export declare function getRepository<entityType>(entity: RepositoryOverloads<entityType>): Repository<entityType>;
+export declare type EntityMetadataOverloads<entityType> = Repository<entityType> | EntityMetadata<entityType> | ClassType<entityType>;
+export declare type RepositoryOverloads<entityType> = Repository<entityType> | ClassType<entityType>;
 export {};

package/esm/src/remult3/RepositoryImplementation.js

@@ -3,10 +3,11 @@ import { allEntities, Remult, isBackend, queryConfig as queryConfig, setControll
 import { entityFilterToJson, Filter } from "../filter/filter-interfaces";
 import { Sort } from "../sort";
 import { v4 as uuid } from 'uuid';
+import cuid from 'cuid';
 import { ValueConverters } from "../valueConverters";
 import { filterHelper } from "../filter/filter-interfaces";
 import { assign } from "../../assign";
-import { remult as defaultRemult } from "../remult-proxy";
+import { remult as defaultRemult, RemultProxy } from "../remult-proxy";
 import { getId } from "./getId";
 //import { remult } from "../remult-proxy";
 let classValidatorValidate = undefined;
@@ -199,6 +200,25 @@ export class RepositoryImplementation {
             }
         }
     }
+    liveQuery(options) {
+        if (!options)
+            options = {};
+        return {
+            subscribe: (l) => {
+                let listener = l;
+                if (typeof l === "function") {
+                    listener = {
+                        next: l,
+                        complete: () => { },
+                        error: () => { }
+                    };
+                }
+                listener.error ??= () => { };
+                listener.complete ??= () => { };
+                return this.remult.liveQuerySubscriber.subscribe(this, options, listener);
+            }
+        };
+    }
     async find(options) {
         Remult.onFind(this._info, options);
         if (!options)
@@ -363,6 +383,7 @@ export class RepositoryImplementation {
             where: this.metadata.idMetadata.getIdFilter(id),
         });
     }
+    /* @internal*/
     async translateWhereToFilter(where) {
         if (this.metadata.options.backendPrefilter && isBackend()) {
             let z = where;
@@ -373,7 +394,7 @@ export class RepositoryImplementation {
             };
         }
         let r = await Filter.fromEntityFilter(this.metadata, where);
-        if (r && !this.dataProvider.supportsCustomFilter) {
+        if (r && !this.dataProvider.supportsrawFilter) {
             r = await Filter.translateCustomWhere(r, this.metadata, this.remult);
         }
         return r;
@@ -460,6 +481,12 @@ class rowHelperBase {
         this._isLoading = false;
         this.lookups = new Map();
         this.originalValues = {};
+        {
+            let fac = remult;
+            if (fac != null && fac.remultFactory) {
+                remult = fac.remultFactory();
+            }
+        }
         for (const col of columnsInfo) {
             let ei = getEntitySettings(col.valueType, false);
             if (ei && remult) {
@@ -1151,24 +1178,23 @@ export class columnDefsImpl {
             this.inputType = this.valueConverter.inputType;
         this.caption = buildCaption(settings.caption, settings.key, remult);
     }
-    getDbName() {
-        if (this.dbNamePromise)
-            return this.dbNamePromise;
-        this.dbNamePromise = (async () => {
+    async getDbName() {
+        try {
             if (this.settings.sqlExpression) {
+                let result;
                 if (typeof this.settings.sqlExpression === "function") {
-                    return this.settings.sqlExpression(this.entityDefs);
+                    result = await this.settings.sqlExpression(this.entityDefs);
                 }
                 else
-                    return this.settings.sqlExpression;
+                    result = this.settings.sqlExpression;
+                if (!result)
+                    return this.settings.dbName;
+                return result;
             }
             return this.settings.dbName;
-        })().then(x => {
-            if (x)
-                return x;
-            return this.settings.dbName;
-        });
-        return this.dbNamePromise;
+        }
+        finally {
+        }
     }
     get dbName() {
         let result;
@@ -1282,7 +1308,7 @@ class EntityFullInfo {
         if (typeof this.options.sqlExpression === "string")
             this.dbNamePromise = Promise.resolve(this.options.sqlExpression);
         else if (typeof this.options.sqlExpression === "function") {
-            let r = this.options.sqlExpression(this.fields);
+            let r = this.options.sqlExpression(this);
             if (r instanceof Promise)
                 this.dbNamePromise = r;
             else if (r)
@@ -1333,10 +1359,39 @@ export class Fields {
     static number(...options) {
         return Field(() => Number, ...options);
     }
+    static createdAt(...options) {
+        return Field(() => Date, {
+            saving: (_, ref) => {
+                if (getEntityRef(_).isNew())
+                    ref.value = new Date();
+            }
+        }, ...options);
+    }
+    static updatedAt(...options) {
+        return Field(() => Date, {
+            saving: (_, ref) => {
+                ref.value = new Date();
+            }
+        }, ...options);
+    }
     static uuid(...options) {
         return Field(() => String, {
             allowApiUpdate: false,
-            defaultValue: () => uuid()
+            defaultValue: () => uuid(),
+            saving: (_, r) => {
+                if (!r.value)
+                    r.value = uuid();
+            }
+        }, ...options);
+    }
+    static cuid(...options) {
+        return Field(() => String, {
+            allowApiUpdate: false,
+            defaultValue: () => cuid(),
+            saving: (_, r) => {
+                if (!r.value)
+                    r.value = cuid();
+            }
         }, ...options);
     }
     static string(...options) {
@@ -1353,7 +1408,7 @@ export function ValueListFieldType(...options) {
     return (type) => {
         FieldType(o => {
             o.valueConverter = ValueListInfo.get(type),
-                o.displayValue = (item, val) => val.caption;
+                o.displayValue = (item, val) => val?.caption;
         }, ...options)(type);
     };
 }
@@ -1613,12 +1668,12 @@ export function decorateColumnSettings(settings, remult) {
  */
 export function Entity(key, ...options) {
     return target => {
-        for (const customFilterMember in target) {
-            if (Object.prototype.hasOwnProperty.call(target, customFilterMember)) {
-                const element = target[customFilterMember];
-                if (element?.customFilterInfo?.customFilterTranslator) {
-                    if (!element.customFilterInfo.key)
-                        element.customFilterInfo.key = customFilterMember;
+        for (const rawFilterMember in target) {
+            if (Object.prototype.hasOwnProperty.call(target, rawFilterMember)) {
+                const element = target[rawFilterMember];
+                if (element?.rawFilterInfo?.rawFilterTranslator) {
+                    if (!element.rawFilterInfo.key)
+                        element.rawFilterInfo.key = rawFilterMember;
                 }
             }
         }
@@ -1687,13 +1742,6 @@ class QueryResultImpl {
             this.options.pageSize = queryConfig.defaultPageSize;
         }
     }
-    subscribe(onResult) {
-        return this.repo.remult.liveQuerySubscriber.subscribe(this.repo, {
-            load: this.options.load,
-            orderBy: this.options.orderBy,
-            where: this.options.where
-        }, onResult);
-    }
     async getPage(page) {
         if (page < 1)
             page = 1;
@@ -1813,3 +1861,19 @@ class SubscribableImp {
         return () => this._subscribers = this._subscribers.filter(x => x != list);
     }
 }
+export function getEntityMetadata(entity) {
+    if (entity.metadata)
+        return entity.metadata;
+    const settings = getEntitySettings(entity, false);
+    if (settings) {
+        return RemultProxy.defaultRemult.repo(entity).metadata;
+    }
+    return entity;
+}
+export function getRepository(entity) {
+    const settings = getEntitySettings(entity, false);
+    if (settings) {
+        return RemultProxy.defaultRemult.repo(entity);
+    }
+    return entity;
+}

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

@@ -1,7 +1,8 @@
 import { ClassType } from "../../classType";
 import { FieldMetadata } from "../column-interfaces";
 import { Unobserve } from "../context";
-import { EntityOptions as EntityOptions } from "../entity";
+import { LiveQueryChange, SubscriptionListener, Unsubscribe } from "../live-query/SubscriptionChannel";
+import { EntityOptions } from "../entity";
 import { SortSegment } from "../sort";
 import { entityEventListener } from "../__EntityValueProvider";
 export interface EntityRef<entityType> extends Subscribable {
@@ -95,18 +96,57 @@ export interface IdMetadata<entityType = any> {
     isIdField(col: FieldMetadata): boolean;
     createIdInFilter(items: entityType[]): EntityFilter<entityType>;
 }
+/** Metadata for an `Entity`, this metadata can be used in the user interface to provide a richer UI experience  */
 export interface EntityMetadata<entityType = any> {
-    readonly idMetadata: IdMetadata<entityType>;
+    /** The Entity's key also used as it's url  */
     readonly key: string;
+    /** Metadata for the Entity's fields */
     readonly fields: FieldsMetadata<entityType>;
+    /** A human readable caption for the entity. Can be used to achieve a consistent caption for a field throughout the app
+     * @example
+     * <h1>Create a new item in {taskRepo.metadata.caption}</h1>
+    */
     readonly caption: string;
+    /** The options send to the `Entity`'s decorator */
     readonly options: EntityOptions;
+    /** The class type of the entity */
     readonly entityType: ClassType<entityType>;
+    /** true if the current user is allowed to update an entity instance
+     * @example
+     * const taskRepo = remult.repo(Task);
+     * if (taskRepo.metadata.apiUpdateAllowed){
+     *   //Allow user to edit the entity
+     * }
+    */
     readonly apiUpdateAllowed: boolean;
+    /** true if the current user is allowed to read from entity
+     * @example
+     * const taskRepo = remult.repo(Task);
+     * if (taskRepo.metadata.apiReadAllowed){
+     *   taskRepo.find()
+     * }
+     */
     readonly apiReadAllowed: boolean;
+    /** true if the current user is allowed to delete an entity instance
+     * @example
+     * const taskRepo = remult.repo(Task);
+     * if (taskRepo.metadata.apiDeleteAllowed){
+     *   //display delete button
+     * }
+    */
     readonly apiDeleteAllowed: boolean;
+    /** true if the current user is allowed to create an entity instance
+     * @example
+     * const taskRepo = remult.repo(Task);
+     * if (taskRepo.metadata.apiInsertAllowed){
+     *   //display insert button
+     * }
+    */
     readonly apiInsertAllowed: boolean;
+    /** Returns the dbName - based on it's `dbName` option and it's `sqlExpression` option */
     getDbName(): Promise<string>;
+    /** Metadata for the Entity's id */
+    readonly idMetadata: IdMetadata<entityType>;
 }
 export declare type OmitEB<T> = Omit<T, keyof import('./RepositoryImplementation').EntityBase>;
 export declare type idType<entityType> = entityType extends {
@@ -118,6 +158,8 @@ export declare type idType<entityType> = entityType extends {
 export interface Repository<entityType> {
     /** returns a result array based on the provided options */
     find(options?: FindOptions<entityType>): Promise<entityType[]>;
+    /** returns a result array based on the provided options */
+    liveQuery(options?: FindOptions<entityType>): LiveQuery<entityType>;
     /** returns the first item that matchers the `where` condition
      * @example
      * await taskRepo.findFirst({ completed:false })
@@ -131,7 +173,7 @@ export interface Repository<entityType> {
      *
      * It also has it's own paging mechanism that can be used n paging scenarios.
      *
-     * The `query` method doesn't return an array (as the `find` method) and instead returns an `iteratable` `QueryResult` object
+     * The `query` method doesn't return an array (as the `find` method) and instead returns an `iterable` `QueryResult` object
      * which supports iterations using the JavaScript `for await` statement.
      * @example
      * for await (const task of taskRepo.query()) {
@@ -181,10 +223,21 @@ export interface Repository<entityType> {
     fromJson(x: any, isNew?: boolean): Promise<entityType>;
     /** returns an `entityRef` for an item returned by `create`, `find` etc... */
     getEntityRef(item: entityType): EntityRef<entityType>;
-    /**The metadata for the `entity` */
+    /**The metadata for the `entity`
+     * @See [EntityMetadata](https://remult.dev/docs/ref_entitymetadata.html)
+    */
     metadata: EntityMetadata<entityType>;
     addEventListener(listener: entityEventListener<entityType>): Unobserve;
 }
+export interface LiveQuery<entityType> {
+    subscribe(next: (info: LiveQueryChangeInfo<entityType>) => void): Unsubscribe;
+    subscribe(listener: Partial<SubscriptionListener<LiveQueryChangeInfo<entityType>>>): Unsubscribe;
+}
+export interface LiveQueryChangeInfo<entityType> {
+    items: entityType[];
+    changes: LiveQueryChange[];
+    applyChanges(prevState: entityType[]): entityType[];
+}
 export interface FindOptions<entityType> extends FindOptionsBase<entityType> {
     /** Determines the number of rows returned by the request, on the browser the default is 100 rows
      * @example
@@ -226,6 +279,8 @@ export declare type EntityFilter<entityType> = {
 export declare type ValueFilter<valueType> = valueType | valueType[] | {
     $ne?: valueType | valueType[];
     "!="?: valueType | valueType[];
+    $in?: valueType[];
+    $nin?: valueType[];
 };
 export declare type ComparisonValueFilter<valueType> = ValueFilter<valueType> & {
     $gt?: valueType;
@@ -300,8 +355,6 @@ export interface QueryResult<entityType> {
     getPage(pageNumber?: number): Promise<entityType[]>;
     /** Performs an operation on all the items matching the query criteria */
     forEach(what: (item: entityType) => Promise<any>): Promise<number>;
-    /**@Experimental */
-    subscribe(onResult: (reducer: (prevState: entityType[]) => entityType[]) => void): VoidFunction;
 }
 /** An interface used to paginating using the `query` method in the `Repository` object */
 export interface Paginator<entityType> {

package/esm/src/remult3/remult3.js

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

package/esm/src/server-action.d.ts

@@ -21,7 +21,7 @@ export declare abstract class Action<inParam, outParam> implements ActionInterfa
 }
 export declare class ForbiddenError extends Error {
     constructor();
-    isForbiddenError: boolean;
+    isForbiddenError: true;
 }
 export declare class myServerAction extends Action<inArgs, result> {
     private types;

package/esm/src/shared-tests/db-tests-setup.d.ts

@@ -6,7 +6,7 @@ import { CategoriesForTesting } from "../tests/remult-3-entities";
 import { Status } from "../tests/testModel/models";
 export declare function itWithFocus(key: string, what: () => Promise<void>, focus?: boolean): void;
 export declare function testAll(key: string, what: dbTestWhatSignature, focus?: boolean): void;
-export declare function addDatabaseToTest(tester: dbTestMethodSignature): void;
+export declare function addDatabaseToTest(tester: dbTestMethodSignature): dbTestMethodSignature;
 export declare function testInMemory(key: string, what: dbTestWhatSignature, focus?: boolean): void;
 export declare type dbTestWhatSignature = (db: {
     db: DataProvider;

package/esm/src/shared-tests/db-tests-setup.js

@@ -2,8 +2,9 @@ import { Remult } from "../context";
 import { InMemoryDataProvider } from "../data-providers/in-memory-database";
 import { Categories } from "../tests/remult-3-entities";
 export function itWithFocus(key, what, focus = false) {
-    if (focus)
+    if (focus) {
         fit(key, what);
+    }
     else
         it(key, what);
 }
@@ -22,12 +23,12 @@ export function addDatabaseToTest(tester) {
         test(tester);
     }
     databasesTesters.push(tester);
+    return tester;
 }
 export function testInMemory(key, what, focus = false) {
     itWithFocus(key + " - in memory", async () => {
-        let remult = new Remult();
         let db = new InMemoryDataProvider();
-        remult.dataProvider = (db);
+        let remult = new Remult(db);
         await what({ db, remult, createEntity: async (x) => remult.repo(x) });
     }, focus);
 }