remult 0.22.9 → 0.22.11-exp2.0

package/README.md

@@ -278,6 +278,7 @@ with a Node.js Express backend.
 - [Tutorial with Angular](https://remult.dev/tutorials/angular/)
 - [Tutorial with Vue](https://remult.dev/tutorials/vue/)
 - [Tutorial with Next.js](https://remult.dev/tutorials/react-next/)
+- [Tutorial with Sveltekit](https://remult.dev/tutorials/sveltekit/)
 
 ## Documentation
 

package/esm/server/JsonEntityFileStorage.d.ts

@@ -2,8 +2,8 @@ import type { JsonEntityStorage } from '../index';
 import { JsonDataProvider } from '../index';
 export declare class JsonEntityFileStorage implements JsonEntityStorage {
     private folderPath;
-    getItem(entityDbName: string): string;
-    setItem(entityDbName: string, json: string): void;
+    getItem(entityDbName: string): Promise<string>;
+    setItem(entityDbName: string, json: string): Promise<void>;
     constructor(folderPath: string);
 }
 export declare class JsonFileDataProvider extends JsonDataProvider {

package/esm/server/JsonEntityFileStorage.js

@@ -1,16 +1,18 @@
-import * as fs from 'fs';
-import * as path from 'path';
 import { JsonDataProvider } from '../index';
 export class JsonEntityFileStorage {
     folderPath;
-    getItem(entityDbName) {
+    async getItem(entityDbName) {
+        const path = await import('path');
+        const fs = await import('fs');
         let fn = path.join(this.folderPath, entityDbName) + '.json';
         if (fs.existsSync(fn)) {
             return fs.readFileSync(fn).toString();
         }
         return undefined;
     }
-    setItem(entityDbName, json) {
+    async setItem(entityDbName, json) {
+        const path = await import('path');
+        const fs = await import('fs');
         if (!fs.existsSync(this.folderPath)) {
             fs.mkdirSync(this.folderPath);
         }

package/esm/src/context.js

@@ -285,3 +285,6 @@ class transactionLiveQueryPublisher {
         }
     }
 }
+//p1 - seems that after backend methods relations are loaded for some reason - see trempim - intake doRequest backend method
+//p1 - reconsider the case in tremping where create user id was updated with some user and not the actual user
+//[ ] - when value changes for field with error, clear error - so the user will feel comfortable

package/esm/src/data-providers/json-data-provider.d.ts

@@ -1,8 +1,8 @@
 import type { DataProvider, EntityDataProvider } from '../data-interfaces';
 import type { EntityMetadata } from '../remult3/remult3';
 export interface JsonEntityStorage {
-    getItem(entityDbName: string): string | null;
-    setItem(entityDbName: string, json: string): any;
+    getItem(entityDbName: string): Promise<string | null>;
+    setItem(entityDbName: string, json: string): Promise<void>;
 }
 export declare class JsonDataProvider implements DataProvider {
     private storage;

package/esm/src/data-providers/json-data-provider.js

@@ -21,11 +21,11 @@ class JsonEntityDataProvider {
     async loadEntityData(what) {
         let data = [];
         let dbName = await this.entity.getDbName();
-        let s = this.helper.getItem(dbName);
+        let s = await this.helper.getItem(dbName);
         if (s)
             data = JSON.parse(s);
         let dp = new ArrayEntityDataProvider(this.entity, data);
-        return what(dp, () => this.helper.setItem(dbName, JSON.stringify(data, undefined, 2)));
+        return what(dp, async () => await this.helper.setItem(dbName, JSON.stringify(data, undefined, 2)));
     }
     p = Promise.resolve();
     find(options) {
@@ -35,20 +35,20 @@ class JsonEntityDataProvider {
         return (this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.count(where))));
     }
     update(id, data) {
-        return (this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.update(id, data).then((x) => {
-            save();
+        return (this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.update(id, data).then(async (x) => {
+            await save();
             return x;
         }))));
     }
     delete(id) {
-        return (this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.delete(id).then((x) => {
-            save();
+        return (this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.delete(id).then(async (x) => {
+            await save();
             return x;
         }))));
     }
     async insert(data) {
-        return (this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.insert(data).then((x) => {
-            save();
+        return (this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.insert(data).then(async (x) => {
+            await save();
             return x;
         }))));
     }

package/esm/src/remult-proxy.js

@@ -81,10 +81,11 @@ export class RemultProxy {
             get fields() {
                 return self.remultFactory().repo(...args).metadata.fields;
             },
-            validate: (a, b) => self
+            validate: (a, ...b) => self
                 .remultFactory()
                 .repo(...args)
-                .validate(a, b),
+                //@ts-ignore
+                .validate(a, ...b),
             addEventListener: (...args2) => self
                 .remultFactory()
                 .repo(...args)

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

@@ -21,15 +21,128 @@ export declare class Fields {
     static boolean<entityType = any>(...options: (FieldOptions<entityType, boolean> | ((options: FieldOptions<entityType, boolean>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, boolean | undefined>;
 }
 export declare class Relations {
-    /** A to one relation with an automatically generated field */
+    /**
+     * 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>;
-    /** A to one relation with fields defined in the second parameter */
+    /**
+     * 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>;
-    /** A to one relation with fields defined in the field/fields parameter */
+    /**
+     * 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.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.22.9",
+    "version": "0.22.11-exp2.0",
     "description": "A CRUD framework for full-stack TypeScript",
     "types": "index.d.ts",
     "module": "esm/index.js",

package/server/JsonEntityFileStorage.d.ts

@@ -2,8 +2,8 @@ import type { JsonEntityStorage } from '../index';
 import { JsonDataProvider } from '../index';
 export declare class JsonEntityFileStorage implements JsonEntityStorage {
     private folderPath;
-    getItem(entityDbName: string): string;
-    setItem(entityDbName: string, json: string): void;
+    getItem(entityDbName: string): Promise<string>;
+    setItem(entityDbName: string, json: string): Promise<void>;
     constructor(folderPath: string);
 }
 export declare class JsonFileDataProvider extends JsonDataProvider {

package/server/JsonEntityFileStorage.js

@@ -2,25 +2,49 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JsonFileDataProvider = exports.JsonEntityFileStorage = void 0;
 var tslib_1 = require("tslib");
-var fs = tslib_1.__importStar(require("fs"));
-var path = tslib_1.__importStar(require("path"));
 var index_1 = require("../index");
 var JsonEntityFileStorage = /** @class */ (function () {
     function JsonEntityFileStorage(folderPath) {
         this.folderPath = folderPath;
     }
     JsonEntityFileStorage.prototype.getItem = function (entityDbName) {
-        var fn = path.join(this.folderPath, entityDbName) + '.json';
-        if (fs.existsSync(fn)) {
-            return fs.readFileSync(fn).toString();
-        }
-        return undefined;
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var path, fs, fn;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.resolve().then(function () { return tslib_1.__importStar(require('path')); })];
+                    case 1:
+                        path = _a.sent();
+                        return [4 /*yield*/, Promise.resolve().then(function () { return tslib_1.__importStar(require('fs')); })];
+                    case 2:
+                        fs = _a.sent();
+                        fn = path.join(this.folderPath, entityDbName) + '.json';
+                        if (fs.existsSync(fn)) {
+                            return [2 /*return*/, fs.readFileSync(fn).toString()];
+                        }
+                        return [2 /*return*/, undefined];
+                }
+            });
+        });
     };
     JsonEntityFileStorage.prototype.setItem = function (entityDbName, json) {
-        if (!fs.existsSync(this.folderPath)) {
-            fs.mkdirSync(this.folderPath);
-        }
-        return fs.writeFileSync(path.join(this.folderPath, entityDbName) + '.json', json);
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var path, fs;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.resolve().then(function () { return tslib_1.__importStar(require('path')); })];
+                    case 1:
+                        path = _a.sent();
+                        return [4 /*yield*/, Promise.resolve().then(function () { return tslib_1.__importStar(require('fs')); })];
+                    case 2:
+                        fs = _a.sent();
+                        if (!fs.existsSync(this.folderPath)) {
+                            fs.mkdirSync(this.folderPath);
+                        }
+                        return [2 /*return*/, fs.writeFileSync(path.join(this.folderPath, entityDbName) + '.json', json)];
+                }
+            });
+        });
     };
     return JsonEntityFileStorage;
 }());

package/src/context.js

@@ -449,3 +449,6 @@ var transactionLiveQueryPublisher = /** @class */ (function () {
     };
     return transactionLiveQueryPublisher;
 }());
+//p1 - seems that after backend methods relations are loaded for some reason - see trempim - intake doRequest backend method
+//p1 - reconsider the case in tremping where create user id was updated with some user and not the actual user
+//[ ] - when value changes for field with error, clear error - so the user will feel comfortable

package/src/data-providers/json-data-provider.d.ts

@@ -1,8 +1,8 @@
 import type { DataProvider, EntityDataProvider } from '../data-interfaces';
 import type { EntityMetadata } from '../remult3/remult3';
 export interface JsonEntityStorage {
-    getItem(entityDbName: string): string | null;
-    setItem(entityDbName: string, json: string): any;
+    getItem(entityDbName: string): Promise<string | null>;
+    setItem(entityDbName: string, json: string): Promise<void>;
 }
 export declare class JsonDataProvider implements DataProvider {
     private storage;

package/src/data-providers/json-data-provider.js

@@ -42,13 +42,18 @@ var JsonEntityDataProvider = /** @class */ (function () {
                         return [4 /*yield*/, this.entity.getDbName()];
                     case 1:
                         dbName = _a.sent();
-                        s = this.helper.getItem(dbName);
+                        return [4 /*yield*/, this.helper.getItem(dbName)];
+                    case 2:
+                        s = _a.sent();
                         if (s)
                             data = JSON.parse(s);
                         dp = new array_entity_data_provider_1.ArrayEntityDataProvider(this.entity, data);
-                        return [2 /*return*/, what(dp, function () {
-                                return _this.helper.setItem(dbName, JSON.stringify(data, undefined, 2));
-                            })];
+                        return [2 /*return*/, what(dp, function () { return tslib_1.__awaiter(_this, void 0, void 0, function () { return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.helper.setItem(dbName, JSON.stringify(data, undefined, 2))];
+                                    case 1: return [2 /*return*/, _a.sent()];
+                                }
+                            }); }); })];
                 }
             });
         });
@@ -69,10 +74,16 @@ var JsonEntityDataProvider = /** @class */ (function () {
         var _this = this;
         return (this.p = this.p.then(function () {
             return _this.loadEntityData(function (dp, save) {
-                return dp.update(id, data).then(function (x) {
-                    save();
-                    return x;
-                });
+                return dp.update(id, data).then(function (x) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                    return tslib_1.__generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, save()];
+                            case 1:
+                                _a.sent();
+                                return [2 /*return*/, x];
+                        }
+                    });
+                }); });
             });
         }));
     };
@@ -80,10 +91,16 @@ var JsonEntityDataProvider = /** @class */ (function () {
         var _this = this;
         return (this.p = this.p.then(function () {
             return _this.loadEntityData(function (dp, save) {
-                return dp.delete(id).then(function (x) {
-                    save();
-                    return x;
-                });
+                return dp.delete(id).then(function (x) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                    return tslib_1.__generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, save()];
+                            case 1:
+                                _a.sent();
+                                return [2 /*return*/, x];
+                        }
+                    });
+                }); });
             });
         }));
     };
@@ -93,10 +110,16 @@ var JsonEntityDataProvider = /** @class */ (function () {
             return tslib_1.__generator(this, function (_a) {
                 return [2 /*return*/, (this.p = this.p.then(function () {
                         return _this.loadEntityData(function (dp, save) {
-                            return dp.insert(data).then(function (x) {
-                                save();
-                                return x;
-                            });
+                            return dp.insert(data).then(function (x) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                                return tslib_1.__generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, save()];
+                                        case 1:
+                                            _a.sent();
+                                            return [2 /*return*/, x];
+                                    }
+                                });
+                            }); });
                         });
                     }))];
             });

package/src/remult-proxy.js

@@ -35,11 +35,16 @@ var RemultProxy = /** @class */ (function () {
                     var _a;
                     return (_a = self.remultFactory()).repo.apply(_a, tslib_1.__spreadArray([], tslib_1.__read(args), false)).metadata.fields;
                 },
-                validate: function (a, b) {
-                    var _a;
-                    return (_a = self
+                validate: function (a) {
+                    var _a, _b;
+                    var b = [];
+                    for (var _i = 1; _i < arguments.length; _i++) {
+                        b[_i - 1] = arguments[_i];
+                    }
+                    return (_a = (_b = self
                         .remultFactory())
-                        .repo.apply(_a, tslib_1.__spreadArray([], tslib_1.__read(args), false)).validate(a, b);
+                        .repo.apply(_b, tslib_1.__spreadArray([], tslib_1.__read(args), false)))
+                        .validate.apply(_a, tslib_1.__spreadArray([a], tslib_1.__read(b), false));
                 },
                 addEventListener: function () {
                     var _a, _b;

package/src/remult3/Fields.d.ts

@@ -21,15 +21,128 @@ export declare class Fields {
     static boolean<entityType = any>(...options: (FieldOptions<entityType, boolean> | ((options: FieldOptions<entityType, boolean>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, boolean | undefined>;
 }
 export declare class Relations {
-    /** A to one relation with an automatically generated field */
+    /**
+     * 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>;
-    /** A to one relation with fields defined in the second parameter */
+    /**
+     * 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>;
-    /** A to one relation with fields defined in the field/fields parameter */
+    /**
+     * 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.