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

package/src/remult3/entity.d.ts

@@ -1,6 +1,6 @@
 import type { Remult } from '../context';
 import type { EntityOptions } from '../entity';
-import type { ClassDecoratorContextStub } from './RepositoryImplementation';
+import type { ClassDecoratorContextStub } from './remult3';
 /**Decorates classes that should be used as entities.
  * Receives a key and an array of EntityOptions.
  * @example

package/src/remult3/entity.js

@@ -4,7 +4,6 @@ exports.Entity = void 0;
 var tslib_1 = require("tslib");
 var context_1 = require("../context");
 var getEntityRef_1 = require("./getEntityRef");
-//[ ] YONI - in Typescript 5 I do get the name of the class, what would we like to change because of that?
 /**Decorates classes that should be used as entities.
  * Receives a key and an array of EntityOptions.
  * @example

package/src/remult3/getEntityRef.d.ts

@@ -5,5 +5,5 @@ export declare function getEntityRef<entityType>(entity: entityType, throwExcept
 export declare const entityMember: unique symbol;
 export declare const entityInfo: unique symbol;
 export declare const entityInfo_key: unique symbol;
-export declare function getEntitySettings<T>(entity: ClassType<T>, throwError?: boolean): EntityOptionsFactory;
+export declare function getEntitySettings<T>(entity: ClassType<T>, throwError?: boolean): EntityOptionsFactory | undefined;
 export declare function getEntityKey(entity: ClassType<any>): string;

package/src/remult3/getEntityRef.js

@@ -2,11 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getEntityKey = exports.getEntitySettings = exports.entityInfo_key = exports.entityInfo = exports.entityMember = exports.getEntityRef = void 0;
 function getEntityRef(entity, throwException) {
+    var _a;
     if (throwException === void 0) { throwException = true; }
     var x = entity[exports.entityMember];
     if (!x && throwException)
         throw new Error('item ' +
-            entity.constructor.name +
+            (((_a = entity.constructor) === null || _a === void 0 ? void 0 : _a.name) || entity) +
             ' was not initialized using a context');
     return x;
 }

package/src/remult3/relation-loader.js

@@ -96,7 +96,10 @@ var QueryVariation = /** @class */ (function () {
         var w = this.whereVariations.get(whereKey);
         if (!w) {
             var keys = Object.keys(where);
-            if (keys.length === 1 && typeof where[keys[0]] !== 'object') {
+            if (keys.length === 1 &&
+                typeof where[keys[0]] !== 'object' &&
+                !findOptions.limit // because merging calls in that case may bring non more rows than the limit
+            ) {
                 var inVariation = this.pendingInStatements.get(keys[0]);
                 if (!inVariation) {
                     this.pendingInStatements.set(keys[0], (inVariation = new PendingInStatements(this.rel, keys[0], findOptions)));

package/src/remult3/remult3.d.ts

@@ -23,11 +23,56 @@ export interface EntityRef<entityType> extends Subscribable {
     metadata: EntityMetadata<entityType>;
     toApiJson(): any;
     validate(): Promise<ErrorInfo<entityType> | undefined>;
+    relations: RepositoryRelations<entityType>;
     readonly apiUpdateAllowed: boolean;
     readonly apiDeleteAllowed: boolean;
     readonly apiInsertAllowed: boolean;
     readonly isLoading: boolean;
 }
+/**
+ * Represents a lifecycle event associated with an entity instance. These events
+ * are triggered during various stages of the entity's lifecycle, such as validation,
+ * saving, saved, deleting, and deleted.
+ *
+ * @template entityType The type of the entity associated with the event.
+ * @see [Entity Lifecycle Hooks](http://remult.dev/docs/lifecycle-hooks)
+ */
+export interface LifecycleEvent<entityType> {
+    /**
+     * Indicates whether the entity is new or existing.
+     */
+    isNew: boolean;
+    /**
+     * A reference to the fields of the entity, providing access to its properties.
+     */
+    fields: FieldsRef<entityType>;
+    /**
+     * The ID of the entity.
+     */
+    id: idType<entityType>;
+    /**
+     * The original ID of the entity, useful for tracking changes.
+     */
+    originalId: idType<entityType>;
+    /**
+     * The repository associated with the entity, providing access to repository methods.
+     */
+    repository: Repository<entityType>;
+    /**
+     * Metadata describing the entity's structure and configuration.
+     */
+    metadata: EntityMetadata<entityType>;
+    /**
+     * A function that can be used to prevent the default behavior associated with
+     * the lifecycle event.
+     */
+    preventDefault: VoidFunction;
+    /**
+     * A reference to the repository relations associated with the entity, providing
+     * access to related entities and their data.
+     */
+    relations: RepositoryRelations<entityType>;
+}
 export interface ControllerRef<entityType> extends Subscribable {
     hasErrors(): boolean;
     fields: FieldsRef<entityType>;
@@ -44,7 +89,7 @@ export interface Subscribable {
     subscribe(listener: RefSubscriber): Unsubscribe;
 }
 export type FieldsRef<entityType> = {
-    [Properties in keyof OmitEB<entityType>]: entityType[Properties] extends {
+    [Properties in keyof OmitEB<entityType>]: NonNullable<entityType[Properties]> extends {
         id?: number | string;
     } ? IdFieldRef<entityType, entityType[Properties]> : FieldRef<entityType, entityType[Properties]>;
 } & {
@@ -301,7 +346,7 @@ export declare type EntityOrderBy<entityType> = {
 export declare type EntityFilter<entityType> = {
     [Properties in keyof Partial<OmitEB<entityType>>]?: (Partial<OmitEB<entityType>>[Properties] extends number | Date | undefined ? ComparisonValueFilter<Partial<OmitEB<entityType>>[Properties]> : Partial<OmitEB<entityType>>[Properties] extends string | undefined ? ContainsStringValueFilter & ComparisonValueFilter<string> : Partial<OmitEB<entityType>>[Properties] extends boolean | undefined ? ValueFilter<boolean> : Partial<OmitEB<entityType>>[Properties] extends {
         id?: string | number;
-    } | undefined ? IdFilter<Partial<OmitEB<entityType>>[Properties]> : ValueFilter<Partial<OmitEB<entityType>>[Properties]>) & ContainsStringValueFilter;
+    } | undefined ? IdFilter<Partial<OmitEB<entityType>>[Properties]> : ValueFilter<Partial<OmitEB<entityType>>[Properties]>) | ContainsStringValueFilter;
 } & {
     $or?: EntityFilter<entityType>[];
     $and?: EntityFilter<entityType>[];
@@ -331,7 +376,46 @@ export type IdFilter<valueType> = ValueFilter<valueType> | {
     } ? number : string>;
 };
 export interface LoadOptions<entityType> {
+    /**
+     * @deprecated The 'load' option is deprecated and will be removed in future versions.
+     * Use 'Relations.toOne' along with the 'include' option instead.
+     *
+     * Example usage:
+     * ```
+     * // Deprecated usage with 'load' option
+     * await remult.repo(Order).find({
+     *   load: (o) => [o.customer],
+     * });
+     *
+     *
+     * // Preferred usage with 'Relations.toOne' and 'include' option
+     * await remult.repo(Order).find({
+     *   include: { customer: true },
+     * });
+     * ```
+     */
     load?: (entity: FieldsMetadata<entityType>) => FieldMetadata[];
+    /**
+     * An option used in the `find` and `findFirst` methods to specify which related entities should be included
+     * when querying the source entity. It allows you to eagerly load related data to avoid N+1 query problems.
+     *
+     * @param include An object specifying the related entities to include, their options, and filtering criteria.
+     *
+     * Example usage:
+     * ```
+     * const orders = await customerRepo.find({
+     *   include: {
+     *     // Include the 'tags' relation for each customer.
+     *     tags: true,
+     *   },
+     * });
+     * ```
+     * In this example, the `tags` relation for each customer will be loaded and included in the query result.
+     *
+     * @see {@link Relations.toMany}
+     * @see {@link Relations.toOne}
+     * @see {@link RelationOptions}
+     */
     include?: MembersToInclude<entityType>;
 }
 export interface FindOptionsBase<entityType> extends LoadOptions<entityType> {
@@ -402,26 +486,67 @@ export interface RelationInfo {
     toType: () => any;
     type: 'reference' | 'toOne' | 'toMany';
 }
+/**
+ * Options for configuring a relation between entities.
+ *
+ * @template fromEntity The type of the source entity (the entity defining the relation).
+ * @template toEntity The type of the target entity (the related entity).
+ * @template matchIdEntity The type used for matching IDs in the relation.
+ * @template optionsType The type of find options to apply to the relation (default is FindOptionsBase<toEntity>).
+ */
 export type RelationOptions<fromEntity, toEntity, matchIdEntity, optionsType extends FindOptionsBase<toEntity> = FindOptionsBase<toEntity>> = {
+    /**
+     * An object specifying custom field names for the relation.
+     * Each key represents a field in the related entity, and its value is the corresponding field in the source entity.
+     * For example, `{ customerId: 'id' }` maps the 'customerId' field in the related entity to the 'id' field in the source entity.
+     * This is useful when you want to define custom field mappings for the relation.
+     */
     fields?: {
         [K in keyof toEntity]?: keyof fromEntity;
     };
+    /**
+     * The name of the field for this relation.
+     */
     field?: keyof matchIdEntity;
-} & RelationOptionsBase<fromEntity, toEntity, optionsType>;
-export type RelationOptionsBase<fromEntity, toEntity, optionsType extends LoadOptions<toEntity> = LoadOptions<toEntity>> = {
+    /**
+     * Find options to apply to the relation when fetching related entities.
+     * You can specify a predefined set of find options or provide a function that takes the source entity
+     * and returns find options dynamically.
+     * These options allow you to customize how related entities are retrieved.
+     */
     findOptions?: optionsType | ((entity: fromEntity) => optionsType);
+    /**
+     * Determines whether the relation should be included by default when querying the source entity.
+     * When set to true, related entities will be automatically included when querying the source entity.
+     * If false or not specified, related entities will need to be explicitly included using the `include` option.
+     */
     defaultIncluded?: boolean;
-} & FieldOptions<fromEntity, toEntity>;
+} & Pick<FieldOptions, 'caption'>;
 export type ObjectMembersOnly<T> = {
     [K in keyof Pick<T, {
         [K in keyof T]: T[K] extends object | undefined | null ? T[K] extends Date | undefined | null ? never : K : never;
     }[keyof T]>]: T[K];
 };
 export type MembersToInclude<T> = {
-    [K in keyof ObjectMembersOnly<T>]?: true | (T[K] extends Array<any> ? FindOptions<T[K][number]> : FindFirstOptions<T[K]>);
+    [K in keyof ObjectMembersOnly<T>]?: boolean | (NonNullable<T[K]> extends Array<any> ? FindOptions<NonNullable<T[K]>[number]> : FindFirstOptions<NonNullable<T[K]>>);
 };
 export type RepositoryRelations<entityType> = {
-    [K in keyof ObjectMembersOnly<entityType>]: entityType[K] extends Array<infer R> ? Repository<R> : entityType[K] extends infer R ? {
+    [K in keyof ObjectMembersOnly<entityType>]-?: NonNullable<entityType[K]> extends Array<infer R> ? Repository<R> : entityType[K] extends infer R ? {
         findOne: (options?: FindOptionsBase<R>) => Promise<R>;
     } : never;
 };
+export declare type EntityIdFields<entityType> = {
+    [Properties in keyof Partial<OmitEB<entityType>>]?: true;
+};
+export interface ClassFieldDecoratorContextStub<entityType, valueType> {
+    readonly access: {
+        set(object: entityType, value: valueType): void;
+    };
+    readonly name: string;
+}
+export interface ClassDecoratorContextStub<Class extends new (...args: any) => any = new (...args: any) => any> {
+    readonly kind: 'class';
+    readonly name: string | undefined;
+    addInitializer(initializer: (this: Class) => void): void;
+}
+export type ClassFieldDecorator<entityType, valueType> = (target: any, context: string | ClassFieldDecoratorContextStub<entityType, valueType | undefined>, c?: any) => void;

package/src/remult3/remult3.js

@@ -1,2 +1,32 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+//p1 - include relations in the api docs
+//p1 - include Relation options in the api docs
+//p1 - fix { allowApiRead: r => r.user.name === 'superman' } } in allowed for instace docs
+//p1 - fix seeallowed in ref_entity
+//p1 - write doc about controlling updates of rows...
+//p1 - 'eventId' autocomplete in task app did not work
+//p1 - need a way to extract the fields from the relation - for generating relation based sql
+//p1 - remult object was used outside context
+// ```
+// sqlExpression: async (e) => {
+//   const v = await dbNamesOf(volunteerInTask)
+//   return `select true from ${v} where ${
+//     v.task
+//   }=${await e.getDbName()}.${await e.fields.id.getDbName()} and ${SqlDatabase.filterToRaw<volunteerInTask>(
+//     repo(volunteerInTask),
+//     {
+//       canceled: false,
+//     }
+//   )}`
+// },
+// })
+// ```
+//p2 - consider includeInApi as AllowedForInstance
+//p1 - why didn't this._.relations.statusChanges.insert({})work?
+//p1 - active record with include thinks that the row was change!
+//p1 - add docs for apply changes
+//p1 - update related field with null should respect it's allowed null - otherwise we get a null error for that field.
+//p1 - when the include doesn't find the many to one - it deletes the id!!!
+//y1 - discuss a default date formatter
+//p1 - consider using this in saving etc...

package/src/remult3/repository-internals.d.ts

@@ -0,0 +1,14 @@
+import type { EntityDataProviderFindOptions } from '../data-interfaces';
+import type { Filter } from '../filter/filter-interfaces';
+import type { EntityFilter, EntityOrderBy, FindOptions, LoadOptions, Repository } from './remult3';
+export interface RepositoryInternal<entityType> {
+    createAfterFilter(orderBy: EntityOrderBy<entityType>, lastRow: entityType): Promise<EntityFilter<entityType>>;
+    fromJsonArray(jsonItems: any[], loadOptions: LoadOptions<entityType>): Promise<entityType[]>;
+    buildEntityDataProviderFindOptions(options: FindOptions<entityType>): Promise<EntityDataProviderFindOptions>;
+    translateWhereToFilter(where: EntityFilter<entityType>): Promise<Filter>;
+    getCachedById(id: any, doNotLoadIfNotFound: boolean): entityType;
+    getCachedByIdAsync(id: any, doNotLoadIfNotFound: boolean): Promise<entityType>;
+    addToCache(item: entityType): any;
+}
+export declare function getRepositoryInternals<entityType>(repo: Repository<entityType>): RepositoryInternal<entityType>;
+export declare const getInternalKey = "getInternal";

package/src/remult3/repository-internals.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInternalKey = exports.getRepositoryInternals = void 0;
+function getRepositoryInternals(repo) {
+    var x = repo;
+    if (typeof x[exports.getInternalKey] === 'function')
+        return x[exports.getInternalKey]();
+    throw Error('Error getting repository internal from ' + repo);
+}
+exports.getRepositoryInternals = getRepositoryInternals;
+exports.getInternalKey = 'getInternal';

package/src/server-action.js

@@ -440,7 +440,7 @@ function BackendMethod(options) {
                                     http])];
                             case 4:
                                 r = _h.sent();
-                                return [4 /*yield*/, defs._updateEntityBasedOnApi(r.rowInfo.data)];
+                                return [4 /*yield*/, defs._updateEntityBasedOnApi(r.rowInfo.data, true)];
                             case 5:
                                 _h.sent();
                                 return [2 /*return*/, r.result];

package/src/sort.d.ts

@@ -6,9 +6,9 @@ export declare class Sort {
     Segments: SortSegment[];
     reverse(): Sort;
     compare(a: any, b: any, getFieldKey?: (field: FieldMetadata) => string): number;
-    static translateOrderByToSort<T>(entityDefs: EntityMetadata<T>, orderBy: EntityOrderBy<T>): Sort;
-    static createUniqueSort<T>(entityMetadata: EntityMetadata<T>, orderBy: Sort): Sort;
-    static createUniqueEntityOrderBy<T>(entityMetadata: EntityMetadata<T>, orderBy: EntityOrderBy<T>): EntityOrderBy<T>;
+    static translateOrderByToSort<T>(entityDefs: EntityMetadata<T>, orderBy?: EntityOrderBy<T>): Sort;
+    static createUniqueSort<T>(entityMetadata: EntityMetadata<T>, orderBy?: Sort): Sort;
+    static createUniqueEntityOrderBy<T>(entityMetadata: EntityMetadata<T>, orderBy?: EntityOrderBy<T>): EntityOrderBy<T>;
 }
 export interface SortSegment {
     field: FieldMetadata;

package/src/sort.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Sort = void 0;
 var tslib_1 = require("tslib");
+var internals_1 = require("../internals");
 var CompoundIdField_1 = require("./CompoundIdField");
 var Sort = /** @class */ (function () {
     function Sort() {
@@ -57,8 +58,8 @@ var Sort = /** @class */ (function () {
         var r = 0;
         for (var i = 0; i < this.Segments.length; i++) {
             var seg = this.Segments[i];
-            var left = a[getFieldKey(seg.field)];
-            var right = b[getFieldKey(seg.field)];
+            var left = fixValueForSort(a[getFieldKey(seg.field)]);
+            var right = fixValueForSort(b[getFieldKey(seg.field)]);
             if (left > right)
                 r = 1;
             else if (left < right)
@@ -74,35 +75,59 @@ var Sort = /** @class */ (function () {
     Sort.translateOrderByToSort = function (entityDefs, orderBy) {
         if (!orderBy)
             return undefined;
-        var sort;
+        var sort = new Sort();
         if (orderBy) {
-            sort = new Sort();
-            for (var key in orderBy) {
+            var _loop_1 = function (key) {
                 if (Object.prototype.hasOwnProperty.call(orderBy, key)) {
-                    var element = orderBy[key];
+                    var element_1 = orderBy[key];
                     var field = entityDefs.fields.find(key);
-                    if (field) {
-                        switch (element) {
+                    var addSegment = function (field) {
+                        switch (element_1) {
                             case 'desc':
                                 sort.Segments.push({ field: field, isDescending: true });
                                 break;
                             case 'asc':
                                 sort.Segments.push({ field: field });
                         }
+                    };
+                    if (field) {
+                        var rel = (0, internals_1.getRelationInfo)(field.options);
+                        var op = field.options;
+                        if ((rel === null || rel === void 0 ? void 0 : rel.type) === 'toOne') {
+                            if (typeof op.field === 'string') {
+                                addSegment(entityDefs.fields.find(op.field));
+                            }
+                            else {
+                                if (op.fields) {
+                                    for (var key_1 in op.fields) {
+                                        if (Object.prototype.hasOwnProperty.call(op.fields, key_1)) {
+                                            var keyInMyEntity = op.fields[key_1];
+                                            addSegment(entityDefs.fields.find(keyInMyEntity.toString()));
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        else
+                            addSegment(field);
                     }
                 }
+            };
+            for (var key in orderBy) {
+                _loop_1(key);
             }
         }
         return sort;
     };
     Sort.createUniqueSort = function (entityMetadata, orderBy) {
         var e_3, _a;
-        if (!orderBy || Object.keys(orderBy).length === 0)
+        if ((!orderBy || Object.keys(orderBy).length === 0) &&
+            entityMetadata.options.defaultOrderBy)
             orderBy = Sort.translateOrderByToSort(entityMetadata, entityMetadata.options.defaultOrderBy);
         if (!orderBy)
             orderBy = new Sort({ field: entityMetadata.idMetadata.field });
         if (entityMetadata.idMetadata.field instanceof CompoundIdField_1.CompoundIdField) {
-            var _loop_1 = function (field) {
+            var _loop_2 = function (field) {
                 if (!orderBy.Segments.find(function (x) { return x.field == field; })) {
                     orderBy.Segments.push({ field: field });
                 }
@@ -110,7 +135,7 @@ var Sort = /** @class */ (function () {
             try {
                 for (var _b = tslib_1.__values(entityMetadata.idMetadata.field.fields), _c = _b.next(); !_c.done; _c = _b.next()) {
                     var field = _c.value;
-                    _loop_1(field);
+                    _loop_2(field);
                 }
             }
             catch (e_3_1) { e_3 = { error: e_3_1 }; }
@@ -161,3 +186,10 @@ var Sort = /** @class */ (function () {
     return Sort;
 }());
 exports.Sort = Sort;
+function fixValueForSort(a) {
+    if (a == undefined || a == null)
+        return a;
+    if (a.id !== undefined)
+        return a.id;
+    return a;
+}