remult 0.18.1 → 0.19.0-exp.2

package/esm/live-query/data-provider-live-query-storage.js

@@ -8,7 +8,9 @@ export class DataProviderLiveQueryStorage {
         this.repo = this.dataProvider.then(dp => new Remult(dp).repo(LiveQueryStorageEntity));
     }
     async ensureSchema() {
-        await (await this.dataProvider).ensureSchema([(await this.repo).metadata]);
+        const dp = await this.dataProvider;
+        if (dp.ensureSchema)
+            await dp.ensureSchema([(await this.repo).metadata]);
     }
     async add({ id, entityKey, data }) {
         await this.repo.then(async (repo) => {
@@ -17,7 +19,11 @@ export class DataProviderLiveQueryStorage {
         });
     }
     async remove(queryId) {
-        await this.repo.then(repo => repo.delete(queryId)).catch(() => { });
+        await this.repo.then(async (repo) => {
+            const r = await repo.findId(queryId);
+            if (r)
+                await repo.delete(r);
+        }).catch(() => { });
     }
     async forEach(entityKey, callback) {
         const repo = await this.repo;

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

@@ -1,6 +1,6 @@
 import { ClassType } from '../classType';
 import { Allowed, AllowedForInstance } from './context';
-import { EntityMetadata, FieldRef } from './remult3';
+import { EntityMetadata, FieldRef, OmitEB } from './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
@@ -75,7 +75,7 @@ export interface FieldOptions<entityType = any, valueType = any> {
     key?: string;
 }
 /**Metadata for a `Field`, this metadata can be used in the user interface to provide a richer UI experience */
-export interface FieldMetadata<valueType = any> {
+export interface FieldMetadata<valueType = any, entityType = any> {
     /** The field's member name in an object.
      * @example
      * const taskRepo = remult.repo(Task);
@@ -109,15 +109,38 @@ export interface FieldMetadata<valueType = any> {
     /** indicates that this field should only be included in select statement, and excluded from update or insert. useful for db generated ids etc... */
     readonly dbReadOnly: boolean;
     /** the Value converter for this field */
-    readonly valueConverter: ValueConverter<valueType>;
+    readonly valueConverter: Required<ValueConverter<valueType>>;
+    /** Get the display value for a specific item
+     * @example
+     * repo.fields.createDate.displayValue(task) //will display the date as defined in the `displayValue` option defined for it.
+    */
+    displayValue(item: Partial<OmitEB<entityType>>): string;
+    apiUpdateAllowed(item: Partial<OmitEB<entityType>>): boolean;
+    readonly includedInApi: boolean;
+    /** Adapts the value for usage with html input
+     * @example
+     * @Fields.dateOnly()
+     * birthDate = new Date(1976,5,16)
+     * //...
+     * input.value = repo.fields.birthDate.toInput(person) // will return '1976-06-16'
+     */
+    toInput(value: valueType, inputType?: string): string;
+    /** Adapts the value for usage with html input
+     * @example
+     * @Fields.dateOnly()
+     * birthDate = new Date(1976,5,16)
+     * //...
+     * person.birthDate = repo.fields.birthDate.fromInput(personFormState) // will return Date
+     */
+    fromInput(inputValue: string, inputType?: string): valueType;
 }
 export interface ValueConverter<valueType> {
     fromJson?(val: any): valueType;
     toJson?(val: valueType): any;
     fromDb?(val: any): valueType;
     toDb?(val: valueType): any;
-    toInput?(val: valueType, inputType: string): string;
-    fromInput?(val: string, inputType: string): valueType;
+    toInput?(val: valueType, inputType?: string): string;
+    fromInput?(val: string, inputType?: string): valueType;
     displayValue?(val: valueType): string;
     readonly fieldTypeInDb?: string;
     readonly inputType?: string;

package/esm/src/column.d.ts

@@ -6,10 +6,15 @@ 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(): ValueConverter<string>;
+    get valueConverter(): Required<ValueConverter<string>>;
     target: ClassType<any>;
     readonly: true;
     allowNull: boolean;

package/esm/src/column.js

@@ -11,6 +11,18 @@ 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("");
     }

package/esm/src/data-api.js

@@ -2,7 +2,6 @@ import { customUrlToken, buildFilterFromRequestParameters } from './filter/filte
 import { doTransaction } from './context';
 import { Filter } from './filter/filter-interfaces';
 import { ForbiddenError } from './server-action';
-import { getId } from './remult3/getId';
 import { findOptionsToJson, liveQueryAction } from './data-providers/rest-data-provider';
 export class DataApi {
     constructor(repository, remult) {
@@ -131,7 +130,7 @@ export class DataApi {
             const data = {
                 requestJson: serializeRequest(),
                 findOptionsJson: findOptionsToJson(r.findOptions, this.repository.metadata),
-                lastIds: r.r.map(y => getId(this.repository.metadata, y))
+                lastIds: r.r.map(y => this.repository.metadata.idMetadata.getId(y))
             };
             await this.remult.liveQueryStorage.add({
                 entityKey: this.repository.metadata.key,

package/esm/src/entity.d.ts

@@ -1,5 +1,5 @@
 import { Allowed, AllowedForInstance } from "./context";
-import { FieldMetadata as FieldMetadata } from './column-interfaces';
+import { FieldMetadata } from './column-interfaces';
 import { EntityOrderBy, FieldsMetadata, EntityFilter, EntityRef, EntityMetadata } from "./remult3";
 export interface EntityOptions<entityType = any> {
     /**A human readable name for the entity */

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

@@ -1,5 +1,4 @@
 import { remult as defaultRemult, Sort } from '../../index';
-import { getId } from '../remult3/getId';
 import { v4 as uuid } from 'uuid';
 import { getLiveQueryChannel } from '../data-api';
 export const streamUrl = 'stream';
@@ -75,15 +74,15 @@ export class LiveQuerySubscriber {
                             this.setAllItems(message.data);
                             break;
                         case "replace": {
-                            items = items.map(x => getId(this.repo.metadata, x) === message.data.oldId ? message.data.item : x);
+                            items = items.map(x => this.repo.metadata.idMetadata.getId(x) === message.data.oldId ? message.data.item : x);
                             break;
                         }
                         case "add":
-                            items = items.filter(x => getId(this.repo.metadata, x) !== getId(this.repo.metadata, message.data.item));
+                            items = items.filter(x => this.repo.metadata.idMetadata.getId(x) !== this.repo.metadata.idMetadata.getId(message.data.item));
                             items.push(message.data.item);
                             break;
                         case "remove":
-                            items = items.filter(x => getId(this.repo.metadata, x) !== message.data.id);
+                            items = items.filter(x => this.repo.metadata.idMetadata.getId(x) !== message.data.id);
                             break;
                     }
                     ;

package/esm/src/remult-proxy.js

@@ -7,6 +7,10 @@ export class RemultProxy {
         this.repo = (...args) => {
             let self = this;
             return {
+                get fields() {
+                    return self.remultFactory().repo(...args).metadata.fields;
+                },
+                validate: (...args2) => self.remultFactory().repo(...args).validate(...args2),
                 addEventListener: (...args2) => self.remultFactory().repo(...args).addEventListener(...args2),
                 count: (...args2) => self.remultFactory().repo(...args).count(...args2),
                 create: (...args2) => self.remultFactory().repo(...args).create(...args2),

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

@@ -5,7 +5,7 @@ import { EntityMetadata, FieldRef, FieldsRef, EntityFilter, FindOptions, Reposit
 import { ClassType } from "../../classType";
 import { Remult } from "../context";
 import { entityEventListener } from "../__EntityValueProvider";
-import { DataProvider, EntityDataProvider, EntityDataProviderFindOptions } from "../data-interfaces";
+import { DataProvider, EntityDataProvider, EntityDataProviderFindOptions, ErrorInfo } from "../data-interfaces";
 import { RefSubscriber } from ".";
 import { Unsubscribe } from "../live-query/SubscriptionChannel";
 export declare class RepositoryImplementation<entityType> implements Repository<entityType> {
@@ -34,6 +34,8 @@ export declare class RepositoryImplementation<entityType> implements Repository<
     delete(item: entityType): Promise<void>;
     insert(item: Partial<OmitEB<entityType>>[]): Promise<entityType[]>;
     insert(item: Partial<OmitEB<entityType>>): Promise<entityType>;
+    get fields(): FieldsMetadata<entityType>;
+    validate(entity: Partial<OmitEB<entityType>>, ...fields: (Extract<keyof OmitEB<entityType>, string>)[]): Promise<ErrorInfo<entityType> | undefined>;
     update(id: (entityType extends {
         id?: number;
     } ? number : entityType extends {
@@ -54,6 +56,7 @@ export declare class RepositoryImplementation<entityType> implements Repository<
     findFirst(where?: EntityFilter<entityType>, options?: FindFirstOptions<entityType>, skipOrderByAndLimit?: boolean): Promise<entityType>;
     private fieldsOf;
     create(item?: Partial<OmitEB<entityType>>): entityType;
+    fixTypes(item: any): Promise<any>;
     findId(id: any, options?: FindFirstOptionsBase<entityType>): Promise<entityType>;
 }
 export declare function __updateEntityBasedOnWhere<T>(entityDefs: EntityMetadata<T>, where: EntityFilter<T>, r: T): void;
@@ -84,6 +87,7 @@ declare abstract class rowHelperBase<T> {
         [key: string]: string;
     };
     protected __assertValidity(): void;
+    buildErrorInfoObject(): ErrorInfo<any>;
     abstract get fields(): FieldsRef<T>;
     catchSaveErrors(err: any): any;
     __clearErrorsAndReportChanged(): void;
@@ -93,7 +97,7 @@ declare abstract class rowHelperBase<T> {
     originalValues: any;
     saveOriginalData(): void;
     saveMoreOriginalData(): void;
-    validate(): Promise<boolean>;
+    validate(): Promise<ErrorInfo<any>>;
     __validateEntity(): Promise<void>;
     __performColumnAndEntityValidations(): Promise<void>;
     toApiJson(): any;
@@ -180,12 +184,18 @@ export declare function buildCaption(caption: string | ((remult: Remult) => stri
 export declare class columnDefsImpl implements FieldMetadata {
     private settings;
     private entityDefs;
+    private remult;
     constructor(settings: FieldOptions, entityDefs: EntityFullInfo<any>, remult: Remult);
+    apiUpdateAllowed(item: any): boolean;
+    displayValue(item: any): string;
+    get includedInApi(): boolean;
+    toInput(value: any, inputType?: string): string;
+    fromInput(inputValue: string, inputType?: string): any;
     getDbName(): Promise<string>;
     options: FieldOptions<any, any>;
     target: ClassType<any>;
     readonly: boolean;
-    valueConverter: ValueConverter<any>;
+    valueConverter: Required<ValueConverter<any>>;
     allowNull: boolean;
     caption: string;
     get dbName(): any;
@@ -203,10 +213,10 @@ declare class EntityFullInfo<T> implements EntityMetadata<T> {
     readonly key: string;
     options: EntityOptions<any>;
     constructor(columnsInfo: FieldOptions[], entityInfo: EntityOptions, remult: Remult, entityType: ClassType<T>, key: string);
-    get apiUpdateAllowed(): boolean;
+    apiUpdateAllowed(item: T): boolean;
     get apiReadAllowed(): boolean;
-    get apiDeleteAllowed(): boolean;
-    get apiInsertAllowed(): boolean;
+    apiDeleteAllowed(item: T): boolean;
+    apiInsertAllowed(item: T): boolean;
     dbNamePromise: Promise<string>;
     getDbName(): Promise<string>;
     idMetadata: IdMetadata<T>;

package/esm/src/remult3/RepositoryImplementation.js

@@ -8,7 +8,6 @@ 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())
@@ -101,7 +100,7 @@ export class RepositoryImplementation {
         this.idCache.set(id, row);
         return await row;
     }
-    //TODO - Used to prevent unnecessary many to one relations
+    //TODO2 - Used to prevent unnecessary many to one relations
     addToCache(item) {
         if (item)
             this.idCache.set(this.getEntityRef(item).getId() + '', item);
@@ -122,6 +121,7 @@ export class RepositoryImplementation {
     getEntityRef(entity) {
         let x = entity[entityMember];
         if (!x) {
+            this.fixTypes(entity);
             x = new rowHelperImplementation(this._info, entity, this, this.edp, this.remult, true);
             Object.defineProperty(entity, entityMember, {
                 get: () => x
@@ -157,6 +157,28 @@ export class RepositoryImplementation {
             }
         }
     }
+    get fields() {
+        return this.metadata.fields;
+    }
+    async validate(entity, ...fields) {
+        {
+            let ref = this.getEntityRef(entity);
+            if (!fields || fields.length === 0) {
+                return await ref.validate();
+            }
+            else {
+                ref.__clearErrorsAndReportChanged();
+                let hasError = false;
+                for (const f of fields) {
+                    if (!await ref.fields.find(f).validate())
+                        hasError = true;
+                }
+                if (!hasError)
+                    return undefined;
+                return ref.buildErrorInfoObject();
+            }
+        }
+    }
     async update(id, entity) {
         let ref = this.getRefForExistingRow(entity, id);
         return (await ref.save());
@@ -168,6 +190,7 @@ export class RepositoryImplementation {
             for (const field of this.fieldsOf(entity)) {
                 instance[field.key] = entity[field.key];
             }
+            this.fixTypes(instance);
             let row = new rowHelperImplementation(this._info, instance, this, this.edp, this.remult, false);
             if (id) {
                 row.id = id;
@@ -300,7 +323,7 @@ export class RepositoryImplementation {
         helper.saveOriginalData();
         return x;
     }
-    // TODO - consider replacing with fromJsonArray - also consider having a TOJSON for similar cases
+    // TODO2 - consider replacing with fromJsonArray - also consider having a TOJSON for similar cases
     async fromJson(json, newRow) {
         let obj = {};
         for (const col of this.fieldsOf(json)) {
@@ -384,13 +407,30 @@ export class RepositoryImplementation {
     }
     create(item) {
         let r = new this.entity(this.remult);
-        if (item)
+        if (item) {
             for (const field of this.fieldsOf(item)) {
                 r[field.key] = item[field.key];
             }
+            this.fixTypes(r);
+        }
         let z = this.getEntityRef(r);
         return r;
     }
+    async fixTypes(item) {
+        for (const field of this.fieldsOf(item)) {
+            const val = item[field.key];
+            if (val !== null && val !== undefined) {
+                if (field.valueType === Date && !(val instanceof Date))
+                    item[field.key] = field.valueConverter.fromJson(field.valueConverter.toJson(val));
+                else
+                    for (const [type, typeName] of [[String, "string"], [Number, "number"], [Boolean, "boolean"]]) {
+                        if (field.valueType === type && typeof val !== typeName)
+                            item[field.key] = field.valueConverter.fromJson(field.valueConverter.toJson(val));
+                    }
+            }
+        }
+        return item;
+    }
     findId(id, options) {
         if (id === null || id === undefined)
             return null;
@@ -599,22 +639,24 @@ class rowHelperBase {
         await Promise.all([...this.lookups.values()].map(x => x.waitLoad()));
     }
     __assertValidity() {
-        if (!this.hasErrors()) {
-            let error = {
-                modelState: Object.assign({}, this.errors),
-                message: this.error
-            };
-            if (!error.message) {
-                for (const col of this.columnsInfo) {
-                    if (this.errors[col.key]) {
-                        error.message = this.fields[col.key].metadata.caption + ": " + this.errors[col.key];
-                        this.error = error.message;
-                        break;
-                    }
+        if (!this.hasErrors())
+            throw this.buildErrorInfoObject();
+    }
+    buildErrorInfoObject() {
+        let error = {
+            modelState: Object.assign({}, this.errors),
+            message: this.error
+        };
+        if (!error.message) {
+            for (const col of this.columnsInfo) {
+                if (this.errors[col.key]) {
+                    error.message = this.fields[col.key].metadata.caption + ": " + this.errors[col.key];
+                    this.error = error.message;
+                    break;
                 }
             }
-            throw error;
         }
+        return error;
     }
     catchSaveErrors(err) {
         let e = err;
@@ -686,7 +728,10 @@ class rowHelperBase {
             await classValidatorValidate(this.instance, this);
         await this.__performColumnAndEntityValidations();
         let r = this.hasErrors();
-        return r;
+        if (!this.hasErrors())
+            return this.buildErrorInfoObject();
+        else
+            return undefined;
     }
     async __validateEntity() {
         this.__clearErrorsAndReportChanged();
@@ -768,7 +813,7 @@ 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() {
-        return getId(this.info, this.instance);
+        return this.info.idMetadata.getId(this.instance);
     }
     saveMoreOriginalData() {
         this.originalId = this.getId();
@@ -925,7 +970,7 @@ export class rowHelperImplementation extends rowHelperBase {
                 this.instance[col.key] = data[col.key];
         }
         await this.calcServerExpression();
-        this.id = getId(this.info, this.instance);
+        this.id = this.getId();
     }
     getOriginalId() {
         return this.originalId;
@@ -1187,6 +1232,7 @@ export class columnDefsImpl {
     constructor(settings, entityDefs, remult) {
         this.settings = settings;
         this.entityDefs = entityDefs;
+        this.remult = remult;
         this.options = this.settings;
         this.target = this.settings.target;
         this.valueConverter = this.settings.valueConverter;
@@ -1202,6 +1248,23 @@ export class columnDefsImpl {
             this.inputType = this.valueConverter.inputType;
         this.caption = buildCaption(settings.caption, settings.key, remult);
     }
+    apiUpdateAllowed(item) {
+        return this.remult.isAllowedForInstance(item, this.options.allowApiUpdate);
+    }
+    displayValue(item) {
+        return this.remult.repo(this.entityDefs.entityType).getEntityRef(item).fields.find(this.key).displayValue;
+    }
+    get includedInApi() {
+        if (this.options.includeInApi === undefined)
+            return true;
+        return this.remult.isAllowed(this.options.includeInApi); //TODO - consolidate other code paths to go through here
+    }
+    toInput(value, inputType) {
+        return this.valueConverter.toInput(value, inputType);
+    }
+    fromInput(inputValue, inputType) {
+        return this.valueConverter.fromInput(inputValue, inputType);
+    }
     async getDbName() {
         try {
             if (this.settings.sqlExpression) {
@@ -1247,6 +1310,12 @@ class EntityFullInfo {
         this.key = key;
         this.options = this.entityInfo;
         this.idMetadata = {
+            getId: item => {
+                if (this.idMetadata.field instanceof CompoundIdField)
+                    return this.idMetadata.field.getId(item);
+                else
+                    return item[this.idMetadata.field.key];
+            },
             field: undefined,
             createIdInFilter: (items) => {
                 if (items.length > 0)
@@ -1319,10 +1388,10 @@ class EntityFullInfo {
                 this.idMetadata.field = [...this.fields][0];
         }
     }
-    get apiUpdateAllowed() { return this.remult.isAllowedForInstance(undefined, this.options.allowApiUpdate); }
+    apiUpdateAllowed(item) { return this.remult.repo(this.entityType).getEntityRef(item).apiUpdateAllowed; }
     get apiReadAllowed() { return this.remult.isAllowed(this.options.allowApiRead); }
-    get apiDeleteAllowed() { return this.remult.isAllowedForInstance(undefined, this.options.allowApiDelete); }
-    get apiInsertAllowed() { return this.remult.isAllowedForInstance(undefined, this.options.allowApiInsert); }
+    apiDeleteAllowed(item) { return this.remult.repo(this.entityType).getEntityRef(item).apiDeleteAllowed; }
+    apiInsertAllowed(item) { return this.remult.repo(this.entityType).getEntityRef(item).apiInsertAllowed; }
     getDbName() {
         if (this.dbNamePromise)
             return this.dbNamePromise;

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

@@ -4,6 +4,7 @@ import { LiveQueryChange, SubscriptionListener, Unsubscribe } from "../live-quer
 import { EntityOptions } from "../entity";
 import { SortSegment } from "../sort";
 import { entityEventListener } from "../__EntityValueProvider";
+import { ErrorInfo } from "../..";
 export interface EntityRef<entityType> extends Subscribable {
     hasErrors(): boolean;
     undoChanges(): any;
@@ -20,7 +21,7 @@ export interface EntityRef<entityType> extends Subscribable {
     repository: Repository<entityType>;
     metadata: EntityMetadata<entityType>;
     toApiJson(): any;
-    validate(): Promise<boolean>;
+    validate(): Promise<ErrorInfo<entityType> | undefined>;
     readonly apiUpdateAllowed: boolean;
     readonly apiDeleteAllowed: boolean;
     readonly apiInsertAllowed: boolean;
@@ -30,7 +31,7 @@ export interface ControllerRef<entityType> extends Subscribable {
     hasErrors(): boolean;
     fields: FieldsRef<entityType>;
     error: string;
-    validate(): Promise<boolean>;
+    validate(): Promise<ErrorInfo<entityType> | undefined>;
     readonly isLoading: boolean;
 }
 export interface RefSubscriberBase {
@@ -51,11 +52,11 @@ export declare type FieldsRef<entityType> = {
     toArray(): FieldRef<entityType, any>[];
 };
 export declare type FieldsMetadata<entityType> = {
-    [Properties in keyof OmitEB<entityType>]: FieldMetadata<entityType[Properties]>;
+    [Properties in keyof OmitEB<entityType>]: FieldMetadata<entityType[Properties], entityType>;
 } & {
-    find(fieldMetadataOrKey: FieldMetadata | string): FieldMetadata;
-    [Symbol.iterator]: () => IterableIterator<FieldMetadata>;
-    toArray(): FieldMetadata<any>[];
+    find(fieldMetadataOrKey: FieldMetadata | string): FieldMetadata<any, entityType>;
+    [Symbol.iterator]: () => IterableIterator<FieldMetadata<any, entityType>>;
+    toArray(): FieldMetadata<any, entityType>[];
 };
 export declare type SortSegments<entityType> = {
     [Properties in keyof entityType]: SortSegment & {
@@ -90,6 +91,11 @@ export interface FieldRef<entityType = any, valueType = any> extends Subscribabl
     validate(): Promise<boolean>;
 }
 export interface IdMetadata<entityType = any> {
+    /** Extracts the id value of an entity item. Useful in cases where the id column is not called id
+     * @example
+     * repo.metadata.idMetadata.getId(task)
+     */
+    getId(item: entityType): any;
     field: FieldMetadata<any>;
     getIdFilter(...ids: any[]): EntityFilter<entityType>;
     isIdField(col: FieldMetadata): boolean;
@@ -113,11 +119,11 @@ export interface EntityMetadata<entityType = any> {
     /** true if the current user is allowed to update an entity instance
      * @example
      * const taskRepo = remult.repo(Task);
-     * if (taskRepo.metadata.apiUpdateAllowed){
+     * if (taskRepo.metadata.apiUpdateAllowed(task)){
      *   // Allow user to edit the entity
      * }
     */
-    readonly apiUpdateAllowed: boolean;
+    apiUpdateAllowed(item: entityType): boolean;
     /** true if the current user is allowed to read from entity
      * @example
      * const taskRepo = remult.repo(Task);
@@ -129,19 +135,19 @@ export interface EntityMetadata<entityType = any> {
     /** true if the current user is allowed to delete an entity instance
      * @example
      * const taskRepo = remult.repo(Task);
-     * if (taskRepo.metadata.apiDeleteAllowed){
+     * if (taskRepo.metadata.apiDeleteAllowed(task)){
      *   // display delete button
      * }
     */
-    readonly apiDeleteAllowed: boolean;
+    apiDeleteAllowed(item: entityType): boolean;
     /** true if the current user is allowed to create an entity instance
      * @example
      * const taskRepo = remult.repo(Task);
-     * if (taskRepo.metadata.apiInsertAllowed){
+     * if (taskRepo.metadata.apiInsertAllowed(task)){
      *   // display insert button
      * }
     */
-    readonly apiInsertAllowed: boolean;
+    apiInsertAllowed(item: entityType): boolean;
     /** Returns the dbName - based on it's `dbName` option and it's `sqlExpression` option */
     getDbName(): Promise<string>;
     /** Metadata for the Entity's id */
@@ -184,8 +190,19 @@ export interface Repository<entityType> {
      * @see [EntityFilter](http://remult.dev/docs/entityFilter.html)
      * @example
      * await taskRepo.count({ completed:false })
-     */
+    */
     count(where?: EntityFilter<entityType>): Promise<number>;
+    /**Validates an item
+     * @example
+     * const error = repo.validate(task);
+     * if (error){
+     *   alert(error.message);
+     *   alert(error.modelState.title);//shows the specific error for the title field
+     * }
+     * // Can also be used to validate specific fields
+     * const error = repo.validate(task,"title")
+     */
+    validate(item: Partial<entityType>, ...fields: (Extract<keyof OmitEB<entityType>, string>)[]): Promise<ErrorInfo<entityType> | undefined>;
     /** saves an item or item[] to the data source. It assumes that if an `id` value exists, it's an existing row - otherwise it's a new row
      * @example
      * await taskRepo.save({...task, completed:true })
@@ -222,6 +239,12 @@ 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>;
+    /** Provides information about the fields of the Repository's entity
+     * @example
+     * console.log(repo.fields.title.caption) // displays the caption of a specific field
+     * console.log(repo.fields.title.options)// writes the options that were defined for this field
+    */
+    fields: FieldsMetadata<entityType>;
     /**The metadata for the `entity`
      * @See [EntityMetadata](https://remult.dev/docs/ref_entitymetadata.html)
     */

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

@@ -797,6 +797,19 @@ testAll("test contains with names with casing", async ({ createEntity }) => {
     await r.insert({ a: 1, firstName: "noam" });
     let item = await r.findFirst({ firstName: { $contains: "oa" } });
     expect(item.firstName).toBe("noam");
-}, true, {
+}, false, {
     exclude: [TestDbs.mongo]
 });
+testAll("test live query storage", async (x) => {
+    const s = new DataProviderLiveQueryStorage(x.db);
+    await s.ensureSchema();
+    const entityKey = "ek";
+    const id = 'id';
+    await s.add({ id, entityKey, data: {} });
+    await s.add({ id, entityKey, data: {} });
+    x.remult.clearAllCache();
+    await s.add({ id, entityKey, data: {} });
+    await s.keepAliveAndReturnUnknownQueryIds([id]);
+    await s.remove(id);
+    await s.remove(id);
+}, false, { exclude: [TestDbs.restDataProvider] });

package/esm/src/valueConverters.d.ts

@@ -6,7 +6,7 @@ export declare class ValueConverters {
     static readonly Boolean: ValueConverter<Boolean>;
     static readonly Number: ValueConverter<number>;
     static readonly Integer: ValueConverter<number>;
-    static readonly Default: ValueConverter<any>;
+    static readonly Default: Required<ValueConverter<any>>;
     static readonly JsonString: ValueConverter<any>;
     static readonly JsonValue: ValueConverter<any>;
 }

package/esm/src/valueConverters.js

@@ -158,7 +158,10 @@ ValueConverters.Default = {
     fromDb: x => ValueConverters.JsonString.fromDb(x),
     toDb: x => ValueConverters.JsonString.toDb(x),
     fromInput: x => ValueConverters.Default.fromJson(x),
-    toInput: x => ValueConverters.Default.toJson(x)
+    toInput: x => ValueConverters.Default.toJson(x),
+    displayValue: x => x + '',
+    fieldTypeInDb: '',
+    inputType: 'text'
 };
 ValueConverters.JsonString = {
     fromJson: x => x,