remult 0.22.9 → 0.22.10

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/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/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.10",
     "description": "A CRUD framework for full-stack TypeScript",
     "types": "index.d.ts",
     "module": "esm/index.js",

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/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.