remult 0.23.0-exp.2 → 0.23.0-exp.4

package/README.md

@@ -22,7 +22,6 @@
 	<a href="https://discord.gg/GXHk7ZfuG5" rel="nofollow">
 		<img alt="Join Discord" src="https://badgen.net/discord/online-members/GXHk7ZfuG5?icon=discord&label=Discord"/>
 	</a>
-  </a>
 </div>
 
 <br/>
@@ -101,14 +100,14 @@ npm i remult
 ```ts
 // shared/product.ts
 
-import { Entity, Fields } from "remult"
+import { Entity, Fields } from 'remult'
 
-@Entity("products", {
-  allowApiCrud: true
+@Entity('products', {
+  allowApiCrud: true,
 })
 export class Product {
   @Fields.string()
-  name = ""
+  name = ''
 
   @Fields.number()
   unitPrice = 0
@@ -120,17 +119,17 @@ export class Product {
 ```ts
 // backend/index.ts
 
-import express from "express"
-import { remultExpress } from "remult/remult-express"
-import { Product } from "../shared/product"
+import express from 'express'
+import { remultExpress } from 'remult/remult-express'
+import { Product } from '../shared/product'
 
 const port = 3001
 const app = express()
 
 app.use(
   remultExpress({
-    entities: [Product]
-  })
+    entities: [Product],
+  }),
 )
 
 app.listen(port, () => {
@@ -151,13 +150,13 @@ app.listen(port, () => {
 ```ts
 // frontend/code.ts
 
-import { remult } from "remult"
-import { Product } from "../shared/product"
+import { remult } from 'remult'
+import { Product } from '../shared/product'
 
 async function increasePriceOfTofu(priceIncrease: number) {
   const productsRepo = remult.repo(Product)
 
-  const product = await productsRepo.findFirst({ name: "Tofu" }) // filter is passed through API request all the way to the db
+  const product = await productsRepo.findFirst({ name: 'Tofu' }) // filter is passed through API request all the way to the db
   product.unitPrice += priceIncrease
   productsRepo.save(product) // mutation request updates the db with no boilerplate code
 }
@@ -179,32 +178,32 @@ static async increasePriceOfTofu(priceIncrease: number) {
 ### :ballot_box_with_check: Data validation and constraints - defined once
 
 ```ts
-import { Entity, Fields, Validators } from "remult"
+import { Entity, Fields, Validators } from 'remult'
 
-@Entity("products", {
-  allowApiCrud: true
+@Entity('products', {
+  allowApiCrud: true,
 })
 export class Product {
   @Fields.string({
-    validate: Validators.required
+    validate: Validators.required,
   })
-  name = ""
+  name = ''
 
   @Fields.string<Product>({
     validate: (product) => {
       if (product.description.trim().length < 50) {
-        throw "too short"
+        throw 'too short'
       }
-    }
+    },
   })
-  description = ""
+  description = ''
 
   @Fields.number({
     validate: (_, field) => {
       if (field.value < 0) {
-        field.error = "must not be less than 0" // or: throw "must not be less than 0";
+        field.error = 'must not be less than 0' // or: throw "must not be less than 0";
       }
-    }
+    },
   })
   unitPrice = 0
 }
@@ -233,20 +232,20 @@ try {
 ### :lock: Secure the API with fine-grained authorization
 
 ```ts
-@Entity<Article>("Articles", {
+@Entity<Article>('Articles', {
   allowApiRead: true,
   allowApiInsert: (_, remult) => remult.authenticated(),
-  allowApiUpdate: (article, remult) => article.author.id == remult.user.id
+  allowApiUpdate: (article, remult) => article.author.id == remult.user.id,
 })
 export class Article {
   @Fields.string({ allowApiUpdate: false })
-  slug = ""
+  slug = ''
 
   @Field(() => Profile, { allowApiUpdate: false })
   author!: Profile
 
   @Fields.string()
-  content = ""
+  content = ''
 }
 ```
 

package/esm/index.d.ts

@@ -1,8 +1,9 @@
-export { OmitEB, FieldsMetadata, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, QueryResult, QueryOptions, Repository, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, EntityRef, SortSegments, Paginator, LiveQuery, LiveQueryChangeInfo, Subscribable, RefSubscriber, RefSubscriberBase, RelationOptions, RelationOptionsBase, ObjectMembersOnly, MembersToInclude, RepositoryRelations, } from './src/remult3/remult3';
+import type { ClassType } from './classType';
+export { OmitEB, FieldsMetadata, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, QueryResult, QueryOptions, Repository, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, EntityRef, SortSegments, Paginator, LiveQuery, LiveQueryChangeInfo, Subscribable, RefSubscriber, RefSubscriberBase, RelationOptions, RelationOptionsBase, ObjectMembersOnly, MembersToInclude, RepositoryRelations, EntityIdFields, } from './src/remult3/remult3';
 export { EntityBase, ControllerBase, FieldType, getFields, ValueListFieldType, getValueList, ValueListFieldOptions, ValueListInfo, CaptionTransformer, } from './src/remult3/RepositoryImplementation';
 export { Entity } from './src/remult3/entity';
 export { getEntityRef } from './src/remult3/getEntityRef';
-export { Field, Fields, StringFieldOptions } from './src/remult3/Fields';
+export { Field, Fields, StringFieldOptions, Relations, } from './src/remult3/Fields';
 export { IdEntity } from './src/remult3/IdEntity';
 export { describeClass } from './src/remult3/DecoratorReplacer';
 export { EntityOptions } from './src/entity';
@@ -21,7 +22,6 @@ export { Controller, BackendMethodOptions, BackendMethod, ProgressListener, } fr
 export { Allowed, Allow, Remult, RemultContext, ApiClient, isBackend, AllowedForInstance, EventDispatcher, EventSource, UserInfo, } from './src/context';
 export { ExternalHttpProvider } from './src/buildRestDataProvider';
 export { SortSegment, Sort } from './src/sort';
-export { OneToMany } from './src/column';
 export { CompoundIdField } from './src/CompoundIdField';
 export { Filter } from './src/filter/filter-interfaces';
 export { UrlBuilder } from './urlBuilder';
@@ -30,3 +30,4 @@ export { ValueConverters } from './src/valueConverters';
 export { remult } from './src/remult-proxy';
 export { SubscriptionServer, LiveQueryStorage, StoredQuery, InMemoryLiveQueryStorage, } from './src/live-query/SubscriptionServer';
 export { SubscriptionListener, SubscriptionClientConnection, SubscriptionClient, SubscriptionChannel, LiveQueryChange, Unsubscribe, } from './src/live-query/SubscriptionChannel';
+export declare function repo<entityType>(entity: ClassType<entityType>): import("./src/remult3/remult3").Repository<entityType>;

package/esm/index.js

@@ -1,7 +1,7 @@
 export { EntityBase, ControllerBase, FieldType, getFields, ValueListFieldType, getValueList, ValueListInfo, CaptionTransformer, } from './src/remult3/RepositoryImplementation';
 export { Entity } from './src/remult3/entity';
 export { getEntityRef } from './src/remult3/getEntityRef';
-export { Field, Fields } from './src/remult3/Fields';
+export { Field, Fields, Relations, } from './src/remult3/Fields';
 export { IdEntity } from './src/remult3/IdEntity';
 export { describeClass } from './src/remult3/DecoratorReplacer';
 export { RestDataProvider } from './src/data-providers/rest-data-provider'; //V
@@ -15,13 +15,16 @@ export { JsonDataProvider, } from './src/data-providers/json-data-provider'; //V
 export { Controller, BackendMethod, ProgressListener, } from './src/server-action';
 export { Allow, Remult, isBackend, EventSource, } from './src/context';
 export { Sort } from './src/sort';
-export { OneToMany } from './src/column';
 export { CompoundIdField } from './src/CompoundIdField';
 export { Filter } from './src/filter/filter-interfaces';
 export { UrlBuilder } from './urlBuilder';
 export { Validators } from './src/validators';
 export { ValueConverters } from './src/valueConverters';
 export { remult } from './src/remult-proxy';
+import { remult } from './src/remult-proxy';
 //export { getId } from './src/remult3/getId';
 export { InMemoryLiveQueryStorage, } from './src/live-query/SubscriptionServer';
 export { SubscriptionChannel, } from './src/live-query/SubscriptionChannel';
+export function repo(entity) {
+    return remult.repo(entity);
+}

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

@@ -1,6 +1,6 @@
 import type { ClassType } from '../classType';
 import type { Allowed, AllowedForInstance } from './context';
-import type { EntityMetadata, FieldRef, OmitEB } from './remult3/remult3';
+import type { EntityMetadata, FieldRef, LifeCycleEvent, 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
@@ -37,7 +37,7 @@ export interface FieldOptions<entityType = any, valueType = any> {
      */
     validate?: ((entity: entityType, fieldRef: FieldRef<entityType, valueType>) => any | Promise<any>) | ((entity: entityType, fieldRef: FieldRef<entityType, valueType>) => any | Promise<any>)[];
     /** Will be fired before this field is saved to the server/database */
-    saving?: (entity: entityType, fieldRef: FieldRef<entityType, valueType>) => any | Promise<any>;
+    saving?: (entity: entityType, e: LifeCycleEvent<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.

package/esm/src/column.d.ts

@@ -1,9 +1,9 @@
-import type { FindOptions, idType, Repository } from './remult3/remult3';
+import type { idType } from './remult3/remult3';
 import type { RepositoryImplementation } from './remult3/RepositoryImplementation';
 export declare function makeTitle(name: string): string;
 export declare class LookupColumn<T> {
     private repository;
-    private isManyToOneRelation;
+    private isReferenceRelation;
     toJson(): any;
     setId(val: any): void;
     waitLoadOf(id: any): Promise<T>;
@@ -13,20 +13,7 @@ export declare class LookupColumn<T> {
     };
     set(item: T): void;
     id: idType<T>;
-    constructor(repository: RepositoryImplementation<T>, isManyToOneRelation: any);
+    constructor(repository: RepositoryImplementation<T>, isReferenceRelation: any);
     get item(): T;
     waitLoad(): Promise<T>;
 }
-export declare class OneToMany<T> {
-    private provider;
-    private settings?;
-    constructor(provider: Repository<T>, settings?: {
-        create?: (newItem: T) => void;
-    } & FindOptions<T>);
-    private _items;
-    private _currentPromise;
-    get lazyItems(): T[];
-    load(): Promise<T[]>;
-    private find;
-    create(item?: Partial<T>): T;
-}

package/esm/src/column.js

@@ -1,5 +1,3 @@
-import { assign } from '../assign';
-import { __updateEntityBasedOnWhere } from './remult3/__updateEntityBasedOnWhere';
 import { getEntityRef } from './remult3/getEntityRef';
 export function makeTitle(name) {
     // insert a space before all caps
@@ -12,7 +10,7 @@ export function makeTitle(name) {
 }
 export class LookupColumn {
     repository;
-    isManyToOneRelation;
+    isReferenceRelation;
     toJson() {
         if (!this.storedItem)
             return undefined;
@@ -33,7 +31,9 @@ export class LookupColumn {
     get(id) {
         if (id === undefined || id === null)
             return null;
-        return this.repository.getCachedById(id, this.isManyToOneRelation);
+        if (this.isReferenceRelation && !this.storedItem)
+            return undefined;
+        return this.repository.getCachedById(id, this.isReferenceRelation);
     }
     storedItem;
     set(item) {
@@ -43,7 +43,7 @@ export class LookupColumn {
                 this.id = item;
             else {
                 let eo = getEntityRef(item, false);
-                if (eo) {
+                if (eo && !this.isReferenceRelation) {
                     this.repository.addToCache(item);
                     this.id = eo.getId();
                 }
@@ -61,9 +61,9 @@ export class LookupColumn {
         }
     }
     id;
-    constructor(repository, isManyToOneRelation) {
+    constructor(repository, isReferenceRelation) {
         this.repository = repository;
-        this.isManyToOneRelation = isManyToOneRelation;
+        this.isReferenceRelation = isReferenceRelation;
     }
     get item() {
         if (this.storedItem)
@@ -74,38 +74,3 @@ export class LookupColumn {
         return this.waitLoadOf(this.id);
     }
 }
-9000;
-export class OneToMany {
-    provider;
-    settings;
-    constructor(provider, settings) {
-        this.provider = provider;
-        this.settings = settings;
-    }
-    _items;
-    _currentPromise;
-    get lazyItems() {
-        this.load();
-        return this._items;
-    }
-    async load() {
-        if (this._currentPromise != null)
-            return this._currentPromise;
-        if (this._items === undefined)
-            this._items = [];
-        return (this._currentPromise = this.find().then((x) => {
-            this._items.splice(0);
-            this._items.push(...x);
-            return this._items;
-        }));
-    }
-    async find() {
-        return this.provider.find(this.settings);
-    }
-    create(item) {
-        let r = this.provider.create();
-        __updateEntityBasedOnWhere(this.provider.metadata, this.settings.where, r);
-        assign(r, item);
-        return r;
-    }
-}

package/esm/src/entity.d.ts

@@ -1,6 +1,6 @@
 import type { Allowed, AllowedForInstance } from './context';
 import type { FieldMetadata } from './column-interfaces';
-import type { EntityFilter, EntityMetadata, EntityOrderBy, EntityRef, FieldsMetadata } from './remult3/remult3';
+import type { EntityFilter, EntityIdFields, EntityMetadata, EntityOrderBy, EntityRef, FieldsMetadata, LifeCycleEvent } from './remult3/remult3';
 export interface EntityOptions<entityType = any> {
     /**A human readable name for the entity */
     caption?: string;
@@ -60,13 +60,13 @@ export interface EntityOptions<entityType = any> {
      *  }
      *})
      */
-    saving?: (row: entityType, proceedWithoutSavingToDb: () => void) => Promise<any> | any;
+    saving?: (row: entityType, e: LifeCycleEvent<entityType>) => Promise<any> | any;
     /** will be called after the Entity was saved to the data source. */
-    saved?: (row: entityType) => Promise<any> | any;
+    saved?: (row: entityType, e: LifeCycleEvent<entityType>) => Promise<any> | any;
     /** Will be called before an Entity is deleted. */
-    deleting?: (row: entityType) => Promise<any> | any;
+    deleting?: (row: entityType, e: LifeCycleEvent<entityType>) => Promise<any> | any;
     /** Will be called after an Entity is deleted */
-    deleted?: (row: entityType) => Promise<any> | any;
+    deleted?: (row: entityType, e: LifeCycleEvent<entityType>) => Promise<any> | any;
     /** Will be called when the entity is being validated, usually prior to the `saving` event */
     validation?: (row: entityType, ref: EntityRef<entityType>) => Promise<any> | any;
     /** The name of the table in the database that holds the data for this entity.
@@ -89,7 +89,7 @@ export interface EntityOptions<entityType = any> {
      * //Multiple columns id
      * @Entity<OrderDetails>("orderDetails", { id:od=> [od.orderId, od.productCode] })
      */
-    id?: (entity: FieldsMetadata<entityType>) => FieldMetadata | FieldMetadata[];
+    id?: EntityIdFields<entityType> | ((entity: FieldsMetadata<entityType>) => FieldMetadata | FieldMetadata[]);
     entityRefInit?: (ref: EntityRef<entityType>, row: entityType) => void;
     apiRequireId?: Allowed;
 }

package/esm/src/entity.js

@@ -1 +1,2 @@
 export {};
+//[ ]  make lazy only on field and not in Field Options

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

@@ -14,20 +14,6 @@ export declare class Filter {
     static entityFilterFromJson<T>(entityDefs: EntityMetadata<T>, packed: any): EntityFilter<T>;
     static translateCustomWhere<T>(r: Filter, entity: EntityMetadata<T>, remult: Remult): Promise<Filter>;
 }
-export declare class filterHelper {
-    metadata: FieldMetadata;
-    constructor(metadata: FieldMetadata);
-    processVal(val: any): any;
-    contains(val: string): Filter;
-    isLessThan(val: any): Filter;
-    isGreaterOrEqualTo(val: any): Filter;
-    isNotIn(values: any[]): Filter;
-    isDifferentFrom(val: any): Filter;
-    isLessOrEqualTo(val: any): Filter;
-    isGreaterThan(val: any): Filter;
-    isEqualTo(val: any): Filter;
-    isIn(val: any[]): Filter;
-}
 export interface FilterConsumer {
     or(orElements: Filter[]): any;
     isEqualTo(col: FieldMetadata, val: any): void;

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

@@ -1,4 +1,5 @@
 import { getEntityRef, getEntitySettings } from '../remult3/getEntityRef';
+import { getRelationInfo } from '../remult3/relationInfoMember';
 export class Filter {
     apply;
     constructor(apply) {
@@ -49,7 +50,14 @@ export class Filter {
                         result.push(new Filter((x) => x.databaseCustom(fieldToFilter)));
                     }
                     else {
-                        let fh = new filterHelper(entity.fields[key]);
+                        const field = entity.fields[key];
+                        const rel = getRelationInfo(field.options);
+                        const op = field.options;
+                        let fh = rel?.type === 'toOne'
+                            ? op.fields
+                                ? new manyToOneFilterHelper(field, entity.fields, op)
+                                : new toOneFilterHelper(entity.fields[op.field])
+                            : new filterHelper(field);
                         let found = false;
                         if (fieldToFilter !== undefined && fieldToFilter != null) {
                             if (fieldToFilter.$id)
@@ -147,7 +155,7 @@ export class Filter {
         return r;
     }
 }
-export class filterHelper {
+class filterHelper {
     metadata;
     constructor(metadata) {
         this.metadata = metadata;
@@ -206,6 +214,79 @@ export class filterHelper {
         return new Filter((add) => add.isIn(this.metadata, val));
     }
 }
+class toOneFilterHelper extends filterHelper {
+    processVal(val) {
+        if (!val)
+            return null;
+        if (typeof val === 'string' || typeof val === 'number')
+            return val;
+        return getEntityRef(val).getId();
+    }
+}
+class manyToOneFilterHelper {
+    metadata;
+    fields;
+    relationOptions;
+    constructor(metadata, fields, relationOptions) {
+        this.metadata = metadata;
+        this.fields = fields;
+        this.relationOptions = relationOptions;
+    }
+    processVal(val) {
+        throw new Error('Invalid for Many To One Relation Field');
+    }
+    contains(val) {
+        throw new Error('Invalid for Many To One Relation Field');
+    }
+    isLessThan(val) {
+        throw new Error('Invalid for Many To One Relation Field');
+    }
+    isGreaterOrEqualTo(val) {
+        throw new Error('Invalid for Many To One Relation Field');
+    }
+    isNotIn(values) {
+        return new Filter((add) => {
+            values.forEach((v) => this.isDifferentFrom(v).__applyToConsumer(add));
+        });
+    }
+    isDifferentFrom(val) {
+        return new Filter((add) => {
+            const or = [];
+            for (const key in this.relationOptions.fields) {
+                if (Object.prototype.hasOwnProperty.call(this.relationOptions.fields, key)) {
+                    const keyInMyEntity = this.relationOptions.fields[key];
+                    or.push(new Filter((add) => new filterHelper(this.fields.find(keyInMyEntity))
+                        .isDifferentFrom(val[key])
+                        .__applyToConsumer(add)));
+                }
+            }
+            add.or(or);
+        });
+    }
+    isLessOrEqualTo(val) {
+        throw new Error('Invalid for Many To One Relation Field');
+    }
+    isGreaterThan(val) {
+        throw new Error('Invalid for Many To One Relation Field');
+    }
+    isEqualTo(val) {
+        return new Filter((add) => {
+            for (const key in this.relationOptions.fields) {
+                if (Object.prototype.hasOwnProperty.call(this.relationOptions.fields, key)) {
+                    const keyInMyEntity = this.relationOptions.fields[key];
+                    new filterHelper(this.fields.find(keyInMyEntity))
+                        .isEqualTo(val[key])
+                        .__applyToConsumer(add);
+                }
+            }
+        });
+    }
+    isIn(val) {
+        return new Filter((add) => {
+            add.or(val.map((v) => this.isEqualTo(v)));
+        });
+    }
+}
 export class AndFilter extends Filter {
     filters;
     constructor(...filters) {
@@ -350,7 +431,6 @@ export function buildFilterFromRequestParameters(entity, filterInfo) {
                 }
             }
         }
-        let c = new filterHelper(col);
         addFilter('', (val) => val);
         addFilter('.gt', (val) => ({ $gt: val }));
         addFilter('.gte', (val) => ({ $gte: val }));

package/esm/src/remult-proxy.js

@@ -81,6 +81,10 @@ export class RemultProxy {
             get fields() {
                 return self.remultFactory().repo(...args).metadata.fields;
             },
+            relations: (args2) => self
+                .remultFactory()
+                .repo(...args)
+                .relations(args2),
             validate: (a, b) => self
                 .remultFactory()
                 .repo(...args)
@@ -135,7 +139,9 @@ export class RemultProxy {
                 .repo(...args)
                 .liveQuery(...args2),
             //@ts-ignore
-            addToCache: (a) => self.remultFactory().repo(...args).addToCache(a),
+            addToCache: (a) => self
+                .remultFactory()
+                .repo(...args).addToCache(a),
             get metadata() {
                 return self.remultFactory().repo(...args).metadata;
             },

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

@@ -1,7 +1,7 @@
 import type { ClassType } from '../../classType';
 import type { FieldOptions } from '../column-interfaces';
 import type { Remult } from '../context';
-import type { FindOptions, RelationOptions, RelationOptionsBase } from './remult3';
+import type { FindOptions, RelationOptions } from './remult3';
 import { type ClassFieldDecoratorContextStub } from './RepositoryImplementation';
 export declare class Fields {
     /**
@@ -20,11 +20,12 @@ export declare class Fields {
     static cuid<entityType = any>(...options: (FieldOptions<entityType, string> | ((options: FieldOptions<entityType, string>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, string | undefined>, c?: any) => void;
     static string<entityType = any>(...options: (StringFieldOptions<entityType> | ((options: StringFieldOptions<entityType>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, string | undefined>, c?: any) => void;
     static boolean<entityType = any>(...options: (FieldOptions<entityType, boolean> | ((options: FieldOptions<entityType, boolean>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, boolean | undefined>, c?: any) => void;
-    static reference<entityType, toEntityType>(toEntityType: () => ClassType<toEntityType>, options?: RelationOptionsBase<entityType, toEntityType>): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, toEntityType>, c?: any) => void;
-    static many<entityType, toEntityType>(toEntityType: () => ClassType<toEntityType>, options: (RelationOptions<entityType, toEntityType, toEntityType, FindOptions<toEntityType>> & {
+}
+export declare class Relations {
+    static toOne<entityType, toEntityType>(toEntityType: () => ClassType<toEntityType>, options?: RelationOptions<entityType, toEntityType, entityType> | keyof entityType): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, toEntityType>, c?: any) => void;
+    static toMany<entityType, toEntityType>(toEntityType: () => ClassType<toEntityType>, options: (RelationOptions<entityType, toEntityType, toEntityType, FindOptions<toEntityType>> & {
         fromEntityType?: ClassType<entityType>;
     }) | keyof toEntityType): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, any>, c?: any) => void;
-    static one<entityType, toEntityType>(entity: ClassType<entityType>, toEntityType: () => ClassType<toEntityType>, options?: RelationOptions<entityType, toEntityType, entityType> | keyof entityType): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, any>, c?: any) => void;
 }
 /**Decorates fields that should be used as fields.
  * for more info see: [Field Types](https://remult.dev/docs/field-types.html)