remult 0.17.3 → 0.18.0

package/esm/src/remult3/RepositoryImplementation.js

@@ -3,9 +3,12 @@ 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, RemultProxy } from "../remult-proxy";
+import { getId } from "./getId";
 //import { remult } from "../remult-proxy";
 let classValidatorValidate = undefined;
 // import("class-validator".toString())
@@ -165,8 +168,10 @@ export class RepositoryImplementation {
                 instance[field.key] = entity[field.key];
             }
             let row = new rowHelperImplementation(this._info, instance, this, this.edp, this.remult, false);
-            if (id)
+            if (id) {
                 row.id = id;
+                row.originalId = id;
+            }
             else
                 row.id = row.getId();
             ref = row;
@@ -195,19 +200,30 @@ 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);
-        let opt = {};
         if (!options)
             options = {};
-        opt = {};
-        if (!options.orderBy || Object.keys(options.orderBy).length === 0) {
-            options.orderBy = this._info.entityInfo.defaultOrderBy;
-        }
-        opt.where = await this.translateWhereToFilter(options.where);
-        opt.orderBy = Sort.translateOrderByToSort(this.metadata, options.orderBy);
-        opt.limit = options.limit;
-        opt.page = options.page;
+        let opt = await this.buildEntityDataProviderFindOptions(options);
         let rawRows = await this.edp.find(opt);
         let loadFields = undefined;
         if (options.load)
@@ -242,6 +258,18 @@ export class RepositoryImplementation {
             }
         }
     }
+    async buildEntityDataProviderFindOptions(options) {
+        let opt = {};
+        opt = {};
+        if (!options.orderBy || Object.keys(options.orderBy).length === 0) {
+            options.orderBy = this._info.entityInfo.defaultOrderBy;
+        }
+        opt.where = await this.translateWhereToFilter(options.where);
+        opt.orderBy = Sort.translateOrderByToSort(this.metadata, options.orderBy);
+        opt.limit = options.limit;
+        opt.page = options.page;
+        return opt;
+    }
     async mapRawDataToResult(r, loadFields) {
         if (!r)
             return undefined;
@@ -355,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;
@@ -365,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;
@@ -452,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) {
@@ -622,6 +657,9 @@ class rowHelperBase {
     }
     saveOriginalData() {
         this.originalValues = this.copyDataToObject();
+        this.saveMoreOriginalData();
+    }
+    saveMoreOriginalData() {
     }
     async validate() {
         this.__clearErrorsAndReportChanged();
@@ -711,10 +749,10 @@ export class rowHelperImplementation extends rowHelperBase {
     get apiDeleteAllowed() { return this.remult.isAllowedForInstance(this.instance, this.metadata.options.allowApiDelete); }
     get apiInsertAllowed() { return this.remult.isAllowedForInstance(this.instance, this.metadata.options.allowApiInsert); }
     getId() {
-        if (this.info.idMetadata.field instanceof CompoundIdField)
-            return this.info.idMetadata.field.getId(this.instance);
-        else
-            return this.instance[this.info.idMetadata.field.key];
+        return getId(this.info, this.instance);
+    }
+    saveMoreOriginalData() {
+        this.originalId = this.getId();
     }
     wasDeleted() {
         this._subscribers?.reportObserved();
@@ -807,6 +845,7 @@ export class rowHelperImplementation extends rowHelperBase {
                 await this.loadDataFrom(updatedRow);
                 if (this.info.entityInfo.saved)
                     await this.info.entityInfo.saved(this.instance);
+                await this.repository.remult.liveQueryPublisher.itemChanged(this.repository.metadata.key, [{ id: this.getId(), oldId: this.getOriginalId(), deleted: false }]);
                 this.saveOriginalData();
                 this._isNew = false;
                 return this.instance;
@@ -837,6 +876,7 @@ export class rowHelperImplementation extends rowHelperBase {
                 for (const listener of this.repository.listeners.filter(x => x.deleted)) {
                     await listener.deleted(this.instance);
                 }
+            await this.repository.remult.liveQueryPublisher.itemChanged(this.repository.metadata.key, [{ id: this.getId(), oldId: this.getOriginalId(), deleted: true }]);
             this._wasDeleted = true;
         }
         catch (err) {
@@ -861,14 +901,10 @@ export class rowHelperImplementation extends rowHelperBase {
                 this.instance[col.key] = data[col.key];
         }
         await this.calcServerExpression();
-        if (this.repository.metadata.idMetadata.field instanceof CompoundIdField) {
-            this.id = this.repository.metadata.idMetadata.field.getId(this.instance);
-        }
-        else
-            this.id = data[this.repository.metadata.idMetadata.field.key];
+        this.id = getId(this.info, this.instance);
     }
     getOriginalId() {
-        return this.id;
+        return this.originalId;
     }
     async calcServerExpression() {
         if (isBackend())
@@ -913,7 +949,7 @@ export function getFields(container, remult) {
     return getControllerRef(container, remult).fields;
 }
 export function getControllerRef(container, remultArg) {
-    const remultVar = remultArg || RepositoryImplementation.defaultRemult;
+    const remultVar = remultArg || defaultRemult;
     let result = container[controllerColumns];
     if (!result)
         result = container[entityMember];
@@ -1142,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;
@@ -1273,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)
@@ -1324,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) {
@@ -1344,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);
     };
 }
@@ -1604,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;
                 }
             }
         }
@@ -1658,7 +1722,7 @@ export class EntityBase {
 }
 export class ControllerBase {
     constructor(remult) {
-        this.remult = remult || RepositoryImplementation.defaultRemult;
+        this.remult = remult || defaultRemult;
     }
     assign(values) {
         assign(this, values);
@@ -1797,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/getId.d.ts

@@ -0,0 +1,2 @@
+import type { EntityMetadata } from "./remult3";
+export declare function getId<entityType>(meta: EntityMetadata<entityType>, instance: entityType): any;

package/esm/src/remult3/getId.js

@@ -0,0 +1,7 @@
+import { CompoundIdField } from '../column';
+export function getId(meta, instance) {
+    if (meta.idMetadata.field instanceof CompoundIdField)
+        return meta.idMetadata.field.getId(instance);
+    else
+        return instance[meta.idMetadata.field.key];
+}

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 {
@@ -15,7 +16,8 @@ export interface EntityRef<entityType> extends Subscribable {
     wasDeleted(): boolean;
     fields: FieldsRef<entityType>;
     error: string;
-    getId(): any;
+    getId(): idType<entityType>;
+    getOriginalId(): idType<entityType>;
     repository: Repository<entityType>;
     metadata: EntityMetadata<entityType>;
     toApiJson(): any;
@@ -94,24 +96,70 @@ 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 {
+    id?: number;
+} ? number : entityType extends {
+    id?: string;
+} ? string : (string | number);
 /**used to perform CRUD operations on an `entityType` */
 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 })
@@ -120,16 +168,12 @@ export interface Repository<entityType> {
      *      */
     findFirst(where?: EntityFilter<entityType>, options?: FindFirstOptions<entityType>): Promise<entityType>;
     /** returns the items that matches the idm the result is cached unless specified differently in the `options` parameter */
-    findId(id: entityType extends {
-        id?: number;
-    } ? number : entityType extends {
-        id?: string;
-    } ? string : (string | number), options?: FindFirstOptionsBase<entityType>): Promise<entityType>;
+    findId(id: idType<entityType>, options?: FindFirstOptionsBase<entityType>): Promise<entityType>;
     /**  An alternative form of fetching data from the API server, which is intended for operating on large numbers of entity objects.
      *
      * 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()) {
@@ -179,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
@@ -224,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;

package/esm/src/remult3/remult3.js

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

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

@@ -19,6 +19,10 @@ export declare abstract class Action<inParam, outParam> implements ActionInterfa
     protected abstract execute(info: inParam, req: Remult, res: DataApiResponse): Promise<outParam>;
     __register(reg: (url: string, queue: boolean, allowed: AllowedForInstance<any>, what: ((data: any, req: Remult, res: DataApiResponse) => void)) => void): void;
 }
+export declare class ForbiddenError extends Error {
+    constructor();
+    isForbiddenError: true;
+}
 export declare class myServerAction extends Action<inArgs, result> {
     private types;
     private options;
@@ -38,7 +42,7 @@ export interface BackendMethodOptions<type> {
 export declare const actionInfo: {
     allActions: any[];
     runningOnServer: boolean;
-    runActionWithoutBlockingUI: (what: () => Promise<any>) => Promise<any>;
+    runActionWithoutBlockingUI: <T>(what: () => Promise<T>) => Promise<T>;
     startBusyWithProgress: () => {
         progress: (percent: number) => void;
         close: () => void;

package/esm/src/server-action.js

@@ -1,7 +1,9 @@
 import 'reflect-metadata';
-import { Remult, allEntities, classHelpers, ClassHelper, setControllerSettings, buildRestDataProvider } from './context';
+import { Remult, allEntities, classHelpers, ClassHelper, setControllerSettings, doTransaction } from './context';
+import { buildRestDataProvider } from "./buildRestDataProvider";
 import { SqlDatabase } from './data-providers/sql-database';
-import { getEntityRef, decorateColumnSettings, getEntitySettings, getControllerRef, RepositoryImplementation } from './remult3';
+import { getEntityRef, decorateColumnSettings, getEntitySettings, getControllerRef } from './remult3';
+import { remult } from './remult-proxy';
 export class Action {
     constructor(actionUrl, queue, allowed) {
         this.actionUrl = actionUrl;
@@ -10,9 +12,9 @@ export class Action {
     }
     async run(pIn, baseUrl, http) {
         if (baseUrl === undefined)
-            baseUrl = RepositoryImplementation.defaultRemult.apiClient.url;
+            baseUrl = remult.apiClient.url;
         if (!http)
-            http = buildRestDataProvider(RepositoryImplementation.defaultRemult.apiClient.httpClient);
+            http = buildRestDataProvider(remult.apiClient.httpClient);
         let r = await http.post(baseUrl + '/' + this.actionUrl, pIn);
         let p = r;
         if (p && p.queuedJobId) {
@@ -59,7 +61,7 @@ export class Action {
     }
 }
 Action.apiUrlForJobStatus = 'jobStatusInQueue';
-class ForbiddenError extends Error {
+export class ForbiddenError extends Error {
     constructor() {
         super("Forbidden");
         this.isForbiddenError = true;
@@ -75,8 +77,7 @@ export class myServerAction extends Action {
     async execute(info, remult, res) {
         let result = { data: {} };
         let ds = remult.dataProvider;
-        await ds.transaction(async (ds) => {
-            remult.dataProvider = (ds);
+        await doTransaction(remult, async () => {
             if (!remult.isAllowedForInstance(undefined, this.options.allowed))
                 throw new ForbiddenError();
             info.args = await prepareReceivedArgs(this.types, info.args, remult, ds, res);
@@ -160,11 +161,9 @@ export function BackendMethod(options) {
                         let allowed = options.allowed;
                         try {
                             let remult = req;
-                            let ds = remult.dataProvider;
                             let r;
-                            await ds.transaction(async (ds) => {
-                                remult.dataProvider = (ds);
-                                d.args = await prepareReceivedArgs(types, d.args, remult, ds, res);
+                            await doTransaction(remult, async () => {
+                                d.args = await prepareReceivedArgs(types, d.args, remult, remult.dataProvider, res);
                                 if (allEntities.includes(constructor)) {
                                     let repo = remult.repo(constructor);
                                     let y;
@@ -205,7 +204,7 @@ export function BackendMethod(options) {
                                     }
                                 }
                                 else {
-                                    let y = new constructor(remult, ds);
+                                    let y = new constructor(remult, remult.dataProvider);
                                     let controllerRef = getControllerRef(y, remult);
                                     await controllerRef._updateEntityBasedOnApi(d.fields);
                                     if (!remult.isAllowedForInstance(y, allowed))

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

@@ -5,15 +5,22 @@ import { Repository } from "../remult3";
 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): dbTestMethodSignature;
+export declare function testAll(key: string, what: dbTestWhatSignature, focus?: boolean, options?: {
+    exclude?: string[];
+}): void;
+export declare function addDatabaseToTest(tester: dbTestMethodSignature, key?: string): dbTestMethodSignature;
 export declare function testInMemory(key: string, what: dbTestWhatSignature, focus?: boolean): void;
-export declare type dbTestWhatSignature = (db: {
+export declare const TestDbs: {
+    restDataProvider: string;
+};
+export declare type dbTestWhatSignature = ((db: {
     db: DataProvider;
     remult: Remult;
     createEntity<entityType>(entity: ClassType<entityType>): Promise<Repository<entityType>>;
-}) => Promise<void>;
-export declare type dbTestMethodSignature = (key: string, what: dbTestWhatSignature, focus: boolean) => void;
+}) => Promise<void>);
+export declare type dbTestMethodSignature = ((key: string, what: dbTestWhatSignature, focus: boolean) => void) & {
+    key?: string;
+};
 export declare function testAllDbs<T extends CategoriesForTesting>(key: string, doTest: (helper: {
     remult: Remult;
     createData: (doInsert?: (insert: (id: number, name: string, description?: string, status?: Status) => Promise<void>) => Promise<void>, entity?: {

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

@@ -8,17 +8,23 @@ export function itWithFocus(key, what, focus = false) {
     else
         it(key, what);
 }
-export function testAll(key, what, focus = false) {
+export function testAll(key, what, focus = false, options) {
+    function runTest(m) {
+        return !options?.exclude?.includes(m.key);
+    }
     for (const test of databasesTesters) {
-        test(key, what, focus);
+        if (runTest(test))
+            test(key, what, focus);
     }
     loadedTests.push(x => {
-        x(key, what, focus);
+        if (runTest(x))
+            x(key, what, focus);
     });
 }
 const databasesTesters = [];
 const loadedTests = [];
-export function addDatabaseToTest(tester) {
+export function addDatabaseToTest(tester, key) {
+    tester.key = key;
     for (const test of loadedTests) {
         test(tester);
     }
@@ -27,12 +33,14 @@ export function addDatabaseToTest(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);
 }
+export const TestDbs = {
+    restDataProvider: "restDataProvider"
+};
 databasesTesters.push(testInMemory);
 export async function testAllDbs(key, doTest, focus = false) {
     testAll(key, async ({ remult, createEntity }) => {