remult 0.23.0-exp.2 → 0.23.0-exp.3

package/esm/index.d.ts

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

package/esm/index.js

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

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

@@ -1,6 +1,6 @@
 import type { ClassType } from '../classType';
 import type { Allowed, AllowedForInstance } from './context';
-import type { EntityMetadata, FieldRef, OmitEB } from './remult3/remult3';
+import type { EntityMetadata, FieldRef, LifeCycleEvent, OmitEB } from './remult3/remult3';
 export interface FieldOptions<entityType = any, valueType = any> {
     /** A human readable name for the field. Can be used to achieve a consistent caption for a field throughout the app
      * @example
@@ -37,7 +37,7 @@ export interface FieldOptions<entityType = any, valueType = any> {
      */
     validate?: ((entity: entityType, fieldRef: FieldRef<entityType, valueType>) => any | Promise<any>) | ((entity: entityType, fieldRef: FieldRef<entityType, valueType>) => any | Promise<any>)[];
     /** Will be fired before this field is saved to the server/database */
-    saving?: (entity: entityType, fieldRef: FieldRef<entityType, valueType>) => any | Promise<any>;
+    saving?: (entity: entityType, e: LifeCycleEvent<entityType>, fieldRef: FieldRef<entityType, valueType>) => any | Promise<any>;
     /**  An expression that will determine this fields value on the backend and be provided to the front end*/
     serverExpression?: (entity: entityType) => valueType | Promise<valueType>;
     /** The name of the column in the database that holds the data for this field. If no name is set, the key will be used instead.

package/esm/src/column.d.ts

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

package/esm/src/column.js

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

package/esm/src/entity.d.ts

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

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

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

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

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

package/esm/src/remult-proxy.js

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

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

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

package/esm/src/remult3/Fields.js

@@ -1,7 +1,6 @@
 import { createId } from '@paralleldrive/cuid2';
 import { v4 as uuid } from 'uuid';
 import { ValueConverters } from '../valueConverters';
-import { getEntityRef } from './getEntityRef';
 import { buildOptions, columnsOfType, } from './RepositoryImplementation';
 import { relationInfoMember } from './relationInfoMember';
 export class Fields {
@@ -47,8 +46,8 @@ export class Fields {
     static createdAt(...options) {
         return Field(() => Date, {
             allowApiUpdate: false,
-            saving: (_, ref) => {
-                if (getEntityRef(_).isNew())
+            saving: (_, { isNew }, ref) => {
+                if (isNew)
                     ref.value = new Date();
             },
         }, ...options);
@@ -56,7 +55,7 @@ export class Fields {
     static updatedAt(...options) {
         return Field(() => Date, {
             allowApiUpdate: false,
-            saving: (_, ref) => {
+            saving: (_, _1, ref) => {
                 ref.value = new Date();
             },
         }, ...options);
@@ -65,7 +64,7 @@ export class Fields {
         return Field(() => String, {
             allowApiUpdate: false,
             defaultValue: () => uuid(),
-            saving: (_, r) => {
+            saving: (_, _1, r) => {
                 if (!r.value)
                     r.value = uuid();
             },
@@ -75,7 +74,7 @@ export class Fields {
         return Field(() => String, {
             allowApiUpdate: false,
             defaultValue: () => createId(),
-            saving: (_, r) => {
+            saving: (_, _1, r) => {
                 if (!r.value)
                     r.value = createId();
             },
@@ -87,25 +86,24 @@ export class Fields {
     static boolean(...options) {
         return Field(() => Boolean, ...options);
     }
-    //[ ] docking the move from reference to one will not be fun,since the parameter order changes
-    static reference(toEntityType, options) {
-        let op = (!options
-            ? {}
-            : options);
-        return Field(toEntityType, {
-            ...op,
-            //@ts-ignore
-            [relationInfoMember]: {
-                //field,
-                toType: toEntityType,
-                type: 'reference',
-            },
-        });
-    }
-    static many(toEntityType, options) {
+}
+export class Relations {
+    static toOne(toEntityType, options) {
         let op = (typeof options === 'string'
             ? { field: options }
-            : options);
+            : !options
+                ? {}
+                : options);
+        if (!op.field && !op.fields && !op.findOptions)
+            return Field(toEntityType, {
+                ...op,
+                //@ts-ignore
+                [relationInfoMember]: {
+                    //field,
+                    toType: toEntityType,
+                    type: 'reference',
+                },
+            });
         return Field(() => undefined, {
             ...op,
             serverExpression: () => undefined,
@@ -113,16 +111,14 @@ export class Fields {
             [relationInfoMember]: {
                 //field,
                 toType: toEntityType,
-                type: 'toMany',
+                type: 'toOne',
             },
         });
     }
-    static one(entity, toEntityType, options) {
+    static toMany(toEntityType, options) {
         let op = (typeof options === 'string'
             ? { field: options }
-            : !options
-                ? {}
-                : options);
+            : options);
         return Field(() => undefined, {
             ...op,
             serverExpression: () => undefined,
@@ -130,7 +126,7 @@ export class Fields {
             [relationInfoMember]: {
                 //field,
                 toType: toEntityType,
-                type: 'toOne',
+                type: 'toMany',
             },
         });
     }
@@ -197,3 +193,4 @@ export function checkTarget(target) {
     if (!target)
         throw new Error("Set the 'experimentalDecorators:true' option in your 'tsconfig' or 'jsconfig' (target undefined)");
 }
+//[ ] there is a duplicity between the oneToMany and manyToOne - maybe we should allow some derivation from one to another?

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

@@ -111,6 +111,7 @@ export declare class rowHelperImplementation<T> extends rowHelperBase<T> impleme
     private edp;
     private _isNew;
     constructor(info: EntityFullInfo<T>, instance: T, repository: RepositoryImplementation<T>, edp: EntityDataProvider, remult: Remult, _isNew: boolean);
+    get relations(): RepositoryRelations<T>;
     get apiUpdateAllowed(): boolean;
     get apiDeleteAllowed(): boolean;
     get apiInsertAllowed(): boolean;
@@ -125,6 +126,7 @@ export declare class rowHelperImplementation<T> extends rowHelperBase<T> impleme
     get fields(): FieldsRef<T>;
     private _saving;
     save(onlyTheseFieldsSentOnlyInTheCaseOfProxySaveWithPartialObject?: string[]): Promise<T>;
+    private buildLifeCycleEvent;
     private getIdFilter;
     delete(): Promise<void>;
     loadDataFrom(data: any, loadItems?: FieldMetadata[]): Promise<void>;