remult 0.23.0-exp.2 → 0.23.0-exp.21

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

@@ -116,7 +116,7 @@ class WebSqlBridgeToSQLCommand {
                 });
             t.executeSql(s, v, (t1, r) => resolve(new WebSqlBridgeToSQLQueryResult(r)), (t2, err) => {
                 reject(err.message);
-                return undefined;
+                return false;
             });
         }));
     }
@@ -125,13 +125,13 @@ class WebSqlBridgeToSQLQueryResult {
     r;
     getColumnKeyInResultForIndexInSelect(index) {
         if (this.rows.length == 0)
-            return undefined;
+            throw Error('No rows');
         let i = 0;
         for (let m in this.rows[0]) {
             if (i++ == index)
                 return m;
         }
-        return undefined;
+        throw Error('index not found');
     }
     //@ts-ignore
     constructor(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;
@@ -55,20 +55,51 @@ export interface EntityOptions<entityType = any> {
      * this is the place to run logic that we want to run in any case before an entity is saved.
      * @example
      * @Entity<Task>("tasks", {
-     * saving: async task => {
-     *      task.lastUpdated = new Date()
-     *  }
-     *})
+     *   saving: async (task, e) => {
+     *     if (e.isNew) {
+     *       task.createdAt = new Date(); // Set the creation date for new tasks.
+     *     }
+     *     task.lastUpdated = new Date(); // Update the last updated date.
+     *   },
+     * })
+     * @param entity - The instance of the entity being saved.
+     * @param event - an @link LifeCycleEvent object
+     * @see [Entity Lifecycle Hooks](http://remult.dev/docs/lifecycle-hooks)
      */
-    saving?: (row: entityType, proceedWithoutSavingToDb: () => void) => Promise<any> | any;
-    /** will be called after the Entity was saved to the data source. */
-    saved?: (row: entityType) => Promise<any> | any;
-    /** Will be called before an Entity is deleted. */
-    deleting?: (row: entityType) => Promise<any> | any;
-    /** Will be called after an Entity is deleted */
-    deleted?: (row: 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;
+    saving?: (entity: entityType, event: LifecycleEvent<entityType>) => Promise<any> | any;
+    /**
+     * A hook that runs after an entity has been successfully saved.
+     *
+     * @param entity The instance of the entity that was saved.
+     * @param event - an @link LifeCycleEvent object
+     * @see [Entity Lifecycle Hooks](http://remult.dev/docs/lifecycle-hooks)
+     */
+    saved?: (entity: entityType, e: LifecycleEvent<entityType>) => Promise<any> | any;
+    /**
+     * A hook that runs before an entity is deleted.
+     *
+     * @param entity The instance of the entity being deleted.
+     * @param event - an @link LifeCycleEvent object
+     * @see [Entity Lifecycle Hooks](http://remult.dev/docs/lifecycle-hooks)
+     */
+    deleting?: (entity: entityType, e: LifecycleEvent<entityType>) => Promise<any> | any;
+    /**
+     * A hook that runs after an entity has been successfully deleted.
+     *
+     * @param entity The instance of the entity that was deleted.
+     * @param event - an @link LifeCycleEvent object
+     * @see [Entity Lifecycle Hooks](http://remult.dev/docs/lifecycle-hooks)
+     */
+    deleted?: (entity: entityType, e: LifecycleEvent<entityType>) => Promise<any> | any;
+    /**
+     * A hook that runs to perform validation checks on an entity before saving.
+     * This hook is also executed on the frontend.
+     *
+     * @param entity The instance of the entity being validated.
+     * @param event - an @link LifeCycleEvent object
+     * @see [Entity Lifecycle Hooks](http://remult.dev/docs/lifecycle-hooks)
+     */
+    validation?: (entity: entityType, ref: LifecycleEvent<entityType>) => Promise<any> | any;
     /** The name of the table in the database that holds the data for this entity.
      * If no name is set, the `key` will be used instead.
      * @example
@@ -84,12 +115,12 @@ export interface EntityOptions<entityType = any> {
     /** An arrow function that identifies the `id` column to use for this entity
      * @example
      * //Single column id
-     * @Entity<Products>("products", { id:p=>p.productCode })
+     * @Entity<Products>("products", { id: {productCode: true} })
      * @example
      * //Multiple columns id
-     * @Entity<OrderDetails>("orderDetails", { id:od=> [od.orderId, od.productCode] })
+     * @Entity<OrderDetails>("orderDetails", { id:{ orderId:true, productCode:true} })
      */
-    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/filter/filter-interfaces.d.ts

@@ -2,8 +2,8 @@ import type { FieldMetadata } from '../column-interfaces';
 import type { Remult } from '../context';
 import type { EntityFilter, EntityMetadata } from '../remult3/remult3';
 export declare class Filter {
-    private apply?;
-    constructor(apply?: (add: FilterConsumer) => void);
+    private apply;
+    constructor(apply: (add: FilterConsumer) => void);
     __applyToConsumer(add: FilterConsumer): void;
     static resolve<entityType>(filter: EntityFilter<entityType> | (() => EntityFilter<entityType> | Promise<EntityFilter<entityType>>)): Promise<EntityFilter<entityType>>;
     static createCustom<entityType>(rawFilterTranslator: (unused: never, r: Remult) => EntityFilter<entityType> | Promise<EntityFilter<entityType>>, key?: string): (() => EntityFilter<entityType>) & customFilterInfo<entityType>;
@@ -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,11 +1,9 @@
 import { getEntityRef, getEntitySettings } from '../remult3/getEntityRef';
+import { getRelationInfo } from '../remult3/relationInfoMember';
 export class Filter {
     apply;
     constructor(apply) {
         this.apply = apply;
-        if (!this.apply) {
-            this.apply = () => { };
-        }
     }
     __applyToConsumer(add) {
         this.apply(add);
@@ -49,7 +47,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 +152,7 @@ export class Filter {
         return r;
     }
 }
-export class filterHelper {
+class filterHelper {
     metadata;
     constructor(metadata) {
         this.metadata = metadata;
@@ -203,9 +208,84 @@ export class filterHelper {
     }
     isIn(val) {
         val = val.map((x) => this.processVal(x));
+        if (val?.length == 1 && val[0] != undefined && val[0] !== null)
+            return new Filter((add) => add.isEqualTo(this.metadata, val[0]));
         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 +430,6 @@ export function buildFilterFromRequestParameters(entity, filterInfo) {
                 }
             }
         }
-        let c = new filterHelper(col);
         addFilter('', (val) => val);
         addFilter('.gt', (val) => ({ $gt: val }));
         addFilter('.gte', (val) => ({ $gte: val }));
@@ -523,3 +602,5 @@ export function __updateEntityBasedOnWhere(entityDefs, where, r) {
         });
     }
 }
+// toRaw of default remult threw and exception
+// toRaw didn't respect

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

@@ -1,5 +1,6 @@
 import { buildRestDataProvider } from '../buildRestDataProvider';
 import { RestDataProvider } from '../data-providers/rest-data-provider';
+import { getRepositoryInternals } from '../remult3/repository-internals';
 import { liveQueryKeepAliveRoute, LiveQuerySubscriber, } from './SubscriptionChannel';
 /* @internal*/
 export class LiveQueryClient {
@@ -79,7 +80,7 @@ export class LiveQueryClient {
         let onUnsubscribe = () => {
             alive = false;
         };
-        this.runPromise(repo
+        this.runPromise(getRepositoryInternals(repo)
             .buildEntityDataProviderFindOptions(options)
             .then((opts) => {
             if (!alive)

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

@@ -1,6 +1,7 @@
 import { v4 as uuid } from 'uuid';
 import { Sort } from '../sort';
 import { remult as defaultRemult } from '../remult-proxy';
+import { getRepositoryInternals } from '../remult3/repository-internals';
 export const streamUrl = 'stream';
 //@internal
 export class LiveQuerySubscriber {
@@ -13,9 +14,9 @@ export class LiveQuerySubscriber {
     subscribeCode;
     unsubscribe = () => { };
     async setAllItems(result) {
-        const items = await this.repo.fromJsonArray(result, this.query.options);
+        const items = await getRepositoryInternals(this.repo).fromJsonArray(result, this.query.options);
         this.forListeners((listener) => {
-            listener((x) => {
+            listener(() => {
                 return items;
             });
         }, this.allItemsMessage(items));
@@ -54,7 +55,7 @@ export class LiveQuerySubscriber {
     async handle(messages) {
         {
             let x = messages.filter(({ type }) => type == 'add' || type == 'replace');
-            let loadedItems = await this.repo.fromJsonArray(x.map((m) => m.data.item), this.query.options);
+            let loadedItems = await getRepositoryInternals(this.repo).fromJsonArray(x.map((m) => m.data.item), this.query.options);
             for (let index = 0; index < x.length; index++) {
                 const element = x[index];
                 element.data.item = loadedItems[index];

package/esm/src/remult-proxy.js

@@ -1,3 +1,4 @@
+import { getInternalKey } from './remult3/repository-internals';
 let defaultRemult;
 function defaultFactory() {
     if (!defaultRemult) {
@@ -81,6 +82,15 @@ export class RemultProxy {
             get fields() {
                 return self.remultFactory().repo(...args).metadata.fields;
             },
+            [getInternalKey]() {
+                return self
+                    .remultFactory()
+                    .repo(...args)[getInternalKey]();
+            },
+            relations: (args2) => self
+                .remultFactory()
+                .repo(...args)
+                .relations(args2),
             validate: (a, b) => self
                 .remultFactory()
                 .repo(...args)
@@ -134,8 +144,6 @@ export class RemultProxy {
                 .remultFactory()
                 .repo(...args)
                 .liveQuery(...args2),
-            //@ts-ignore
-            addToCache: (a) => self.remultFactory().repo(...args).addToCache(a),
             get metadata() {
                 return self.remultFactory().repo(...args).metadata;
             },

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

@@ -1,30 +1,149 @@
 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 ClassFieldDecoratorContextStub } from './RepositoryImplementation';
+import type { FindOptions, RelationOptions, ClassFieldDecorator, ClassFieldDecoratorContextStub } from './remult3';
 export declare class Fields {
     /**
      * Stored as a JSON.stringify - to store as json use Fields.json
      */
-    static object<entityType = any, valueType = any>(...options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, valueType | undefined>, c?: any) => void;
-    static json<entityType = any, valueType = any>(...options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, valueType | undefined>, c?: any) => void;
-    static dateOnly<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, Date | undefined>, c?: any) => void;
-    static date<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, Date | undefined>, c?: any) => void;
-    static integer<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, number | undefined>, c?: any) => void;
-    static autoIncrement<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, number | undefined>, c?: any) => void;
-    static number<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, number | undefined>, c?: any) => void;
-    static createdAt<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, Date | undefined>, c?: any) => void;
-    static updatedAt<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, Date | undefined>, c?: any) => void;
-    static uuid<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 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>> & {
-        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;
+    static object<entityType = any, valueType = any>(...options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, valueType | undefined>;
+    static json<entityType = any, valueType = any>(...options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, valueType | undefined>;
+    static dateOnly<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, Date | undefined>;
+    static date<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, Date | undefined>;
+    static integer<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, number | undefined>;
+    static autoIncrement<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, number | undefined>;
+    static number<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, number | undefined>;
+    static createdAt<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, Date | undefined>;
+    static updatedAt<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, Date | undefined>;
+    static uuid<entityType = any>(...options: (FieldOptions<entityType, string> | ((options: FieldOptions<entityType, string>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, string | undefined>;
+    static cuid<entityType = any>(...options: (FieldOptions<entityType, string> | ((options: FieldOptions<entityType, string>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, string | undefined>;
+    static string<entityType = any>(...options: (StringFieldOptions<entityType> | ((options: StringFieldOptions<entityType>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, string | undefined>;
+    static boolean<entityType = any>(...options: (FieldOptions<entityType, boolean> | ((options: FieldOptions<entityType, boolean>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, boolean | undefined>;
+}
+export declare class Relations {
+    /**
+     * Define a to-one relation between entities, indicating a one-to-one relationship.
+     * If no field or fields are provided, it will automatically create a field in the database
+     * to represent the relation.
+     *
+     * @param toEntityType A function that returns the target entity type.
+     * @param options (Optional): An object containing options for configuring the to-one relation.
+     * @returns A decorator function to apply the to-one relation to an entity field.
+     *
+     * Example usage:
+     * ```
+     * @Relations.toOne(() => Customer)
+     * customer?: Customer;
+     * ```
+     */
+    static toOne<entityType, toEntityType>(toEntityType: () => ClassType<toEntityType>, options?: FieldOptions<entityType, toEntityType> & Pick<RelationOptions<entityType, toEntityType, any, any>, 'defaultIncluded'>): ClassFieldDecorator<entityType, toEntityType | undefined>;
+    /**
+     * Define a to-one relation between entities, indicating a one-to-one relationship.
+     * If no `fieldInMyEntity` is provided, this overload will automatically create a field in the database
+     * to represent the relation.
+     *
+     * @param toEntityType A function that returns the target entity type.
+     * @param fieldInMyEntity (Optional): The field in the current entity that represents the relation.
+     *                        Use this if you want to specify a custom field name for the relation.
+     * @returns A decorator function to apply the to-one relation to an entity field.
+     *
+     * Example usage:
+     * ```
+     * @Relations.toOne(() => Customer)
+     * customer?: Customer;
+     * ```
+     */
+    static toOne<entityType, toEntityType>(toEntityType: () => ClassType<toEntityType>, fieldInMyEntity?: keyof entityType): ClassFieldDecorator<entityType, toEntityType | undefined>;
+    /**
+     * Define a to-one relation between entities, indicating a one-to-one relationship.
+     * This overload allows you to define the relation using options.
+     * If no field or fields are provided, it will automatically create a field in the database
+     * to represent the relation.
+     *
+     * @param toEntityType A function that returns the target entity type.
+     * @param options An object containing options for configuring the to-one relation.
+     *                - field (Optional): The name of the field in the related entity that corresponds to this relation.
+     * @returns A decorator function to apply the virtual to-one relation to an entity field.
+     *
+     * Example usage:
+     * ```
+     * @Relations.toOne(() => Customer, {
+     *   field: "customerId",
+     * })
+     * customer?: Customer;
+     * ```
+     */
+    static toOne<entityType, toEntityType>(toEntityType: () => ClassType<toEntityType>, fieldInMyEntity?: keyof entityType): ClassFieldDecorator<entityType, toEntityType | undefined>;
+    /**
+     * Define a to-one relation between entities, indicating a one-to-one relationship.
+     * If no field or fields are provided, it will automatically create a field in the database
+     * to represent the relation.
+     *
+     * @param toEntityType A function that returns the target entity type.
+     * @param options An object containing options for configuring the to-one relation.
+     *                - fields (Optional): An object specifying custom field names for the relation.
+     * @returns A decorator function to apply the virtual to-one relation to an entity field.
+     *
+     * Example usage:
+     * ```
+     * @Relations.toOne(() => Customer, {
+     *   fields: {
+     *     customerId: "id",
+     *   },
+     * })
+     * customer?: Customer;
+     * ```
+     */
+    static toOne<entityType, toEntityType>(toEntityType: () => ClassType<toEntityType>, options: Omit<RelationOptions<entityType, toEntityType, entityType>, keyof Pick<RelationOptions<entityType, toEntityType, entityType>, 'field'>>): ClassFieldDecorator<entityType, toEntityType | undefined>;
+    /** A to one relation with fields defined in the field/fields parameter */
+    static toOne<entityType, toEntityType>(toEntityType: () => ClassType<toEntityType>, options: Omit<RelationOptions<entityType, toEntityType, entityType>, keyof Pick<RelationOptions<entityType, toEntityType, entityType>, 'fields'>>): ClassFieldDecorator<entityType, toEntityType | undefined>;
+    /**
+     * Define a toMany relation between entities, indicating a one-to-many relationship.
+     * This method allows you to establish a relationship where one entity can have multiple related entities.
+     *
+     * @param toEntityType A function that returns the target entity type.
+     * @param fieldInToEntity (Optional) The field in the target entity that represents the relation.
+     *                       Use this if you want to specify a custom field name for the relation.
+     * @returns A decorator function to apply the toMany relation to an entity field.
+     *
+     * Example usage:
+     * ```
+     * @Relations.toMany(() => Order)
+     * orders?: Order[];
+     *
+     * // or with a custom field name:
+     * @Relations.toMany(() => Order, "customerId")
+     * orders?: Order[];
+     * ```
+     */
+    static toMany<entityType, toEntityType>(toEntityType: () => ClassType<toEntityType>, fieldInToEntity?: keyof toEntityType): ClassFieldDecorator<entityType, toEntityType[] | undefined>;
+    /**
+     * Define a toMany relation between entities, indicating a one-to-many relationship.
+     * This method allows you to establish a relationship where one entity can have multiple related entities.
+     * You can also specify various options to customize the relation and control related data retrieval.
+     *
+     * @param toEntityType A function that returns the target entity type.
+     * @param options An object containing options for configuring the toMany relation.
+     *                - field (Optional): The field in the target entity that represents the relation.
+     *                  Use this if you want to specify a custom field name for the relation.
+     *                - findOptions (Optional): Customize the options for finding related entities.
+     *                  You can set limits, order, where conditions, and more.
+     * @returns A decorator function to apply the toMany relation to an entity field.
+     *
+     * Example usage:
+     * ```
+     * @Relations.toMany(() => Order, {
+     *   field: "customerOrders",
+     *   findOptions: {
+     *     limit: 10,
+     *     orderBy: { amount: "desc" },
+     *     where: { completed: true },
+     *   },
+     * })
+     * orders?: Order[];
+     * ```
+     */
+    static toMany<entityType, toEntityType>(toEntityType: () => ClassType<toEntityType>, options: RelationOptions<entityType, toEntityType, toEntityType, FindOptions<toEntityType>>): ClassFieldDecorator<entityType, toEntityType[] | undefined>;
 }
 /**Decorates fields that should be used as fields.
  * for more info see: [Field Types](https://remult.dev/docs/field-types.html)
@@ -39,7 +158,7 @@ export declare class Fields {
  * @Fields.string((options,remult) => options.includeInApi = true)
  * title='';
  */
-export declare function Field<entityType = any, valueType = any>(valueType: () => ClassType<valueType>, ...options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[]): (target: any, context: ClassFieldDecoratorContextStub<entityType, valueType | undefined> | string, c?: any) => void;
+export declare function Field<entityType = any, valueType = any>(valueType: (() => ClassType<valueType>) | undefined, ...options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[]): (target: any, context: ClassFieldDecoratorContextStub<entityType, valueType | undefined> | string, c?: any) => void;
 export interface StringFieldOptions<entityType = any> extends FieldOptions<entityType, string> {
     maxLength?: number;
 }