remult 0.23.0-exp.34 → 0.23.0-exp.36

package/esm/index.d.ts

@@ -1,5 +1,6 @@
 import type { ClassType } from './classType';
-export { OmitEB, OmitFunctions, 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, ObjectMembersOnly, MembersToInclude, RepositoryRelations, EntityIdFields, ClassFieldDecorator, ClassFieldDecoratorContextStub, //n1 consider removing in ts5
+export type { ClassType } from './classType';
+export { MembersOnly, 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, ObjectMembersOnly, MembersToInclude, RepositoryRelations, EntityIdFields, ClassFieldDecorator, ClassFieldDecoratorContextStub, //n1 consider removing in ts5
 LifecycleEvent, } from './src/remult3/remult3';
 export { EntityBase, ControllerBase, FieldType, getFields, ValueListFieldType, getValueList, ValueListFieldOptions, ValueListInfo, CaptionTransformer, } from './src/remult3/RepositoryImplementation';
 export { Entity } from './src/remult3/entity';

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

@@ -1,6 +1,6 @@
 import type { ClassType } from '../classType';
 import type { AllowedForInstance } from './context';
-import type { EntityMetadata, FieldRef, LifecycleEvent, OmitEB } from './remult3/remult3';
+import type { EntityMetadata, FieldRef, LifecycleEvent } 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
@@ -132,9 +132,9 @@ export interface FieldMetadata<valueType = any, entityType = any> {
      * @example
      * repo.fields.createDate.displayValue(task) //will display the date as defined in the `displayValue` option defined for it.
      */
-    displayValue(item: Partial<OmitEB<entityType>>): string;
-    apiUpdateAllowed(item?: Partial<OmitEB<entityType>>): boolean;
-    includedInApi(item?: Partial<OmitEB<entityType>>): boolean;
+    displayValue(item: Partial<entityType>): string;
+    apiUpdateAllowed(item?: Partial<entityType>): boolean;
+    includedInApi(item?: Partial<entityType>): boolean;
     /** Adapts the value for usage with html input
      * @example
      * @Fields.dateOnly()

package/esm/src/column.d.ts

@@ -3,6 +3,7 @@ export declare function makeTitle(name: string): string;
 export declare class LookupColumn<T> {
     private repository;
     private isReferenceRelation;
+    private allowNull;
     toJson(): any;
     setId(val: any): void;
     waitLoadOf(id: any): Promise<T>;
@@ -12,7 +13,7 @@ export declare class LookupColumn<T> {
     };
     set(item: T): void;
     id: idType<T>;
-    constructor(repository: Repository<T>, isReferenceRelation: any);
+    constructor(repository: Repository<T>, isReferenceRelation: any, allowNull: any);
     get item(): T;
     waitLoad(): Promise<T>;
 }

package/esm/src/column.js

@@ -12,6 +12,7 @@ export function makeTitle(name) {
 export class LookupColumn {
     repository;
     isReferenceRelation;
+    allowNull;
     toJson() {
         if (!this.storedItem)
             return undefined;
@@ -32,12 +33,23 @@ export class LookupColumn {
     get(id) {
         if (id === undefined || id === null)
             return null;
-        if (this.isReferenceRelation && !this.storedItem)
+        const result = getRepositoryInternals(this.repository).getCachedById(id, this.isReferenceRelation);
+        if (this.isReferenceRelation && !this.storedItem) {
+            if (!this.allowNull && (this.id === 0 || this.id === ''))
+                return null;
             return undefined;
-        return getRepositoryInternals(this.repository).getCachedById(id, this.isReferenceRelation);
+        }
+        return result;
     }
     storedItem;
     set(item) {
+        if (item === null &&
+            !this.allowNull &&
+            this.isReferenceRelation &&
+            (this.id == 0 || this.id == '')) {
+            this.storedItem = { item: null };
+            return;
+        }
         this.storedItem = undefined;
         if (item) {
             if (typeof item === 'string' || typeof item === 'number')
@@ -62,9 +74,10 @@ export class LookupColumn {
         }
     }
     id;
-    constructor(repository, isReferenceRelation) {
+    constructor(repository, isReferenceRelation, allowNull) {
         this.repository = repository;
         this.isReferenceRelation = isReferenceRelation;
+        this.allowNull = allowNull;
     }
     get item() {
         if (this.storedItem)

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

@@ -1,5 +1,5 @@
 import type { Filter } from './filter/filter-interfaces';
-import type { EntityMetadata, OmitEB, OmitFunctions } from './remult3/remult3';
+import type { EntityMetadata, MembersOnly } from './remult3/remult3';
 import { Sort } from './sort';
 export interface DataProvider {
     getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
@@ -33,7 +33,7 @@ export declare function extractSort(sort: any): Sort;
 export interface ErrorInfo<entityType = any> {
     message?: string;
     modelState?: {
-        [Properties in keyof Partial<OmitFunctions<OmitEB<entityType>>>]?: string;
+        [Properties in keyof Partial<MembersOnly<entityType>>]?: string;
     };
     stack?: string;
     exception?: any;

package/esm/src/data-providers/array-entity-data-provider.d.ts

@@ -1,24 +1,3 @@
-import type { EntityDataProvider, EntityDataProviderFindOptions } from '../data-interfaces';
-import { type EntityDbNamesBase } from '../filter/filter-consumer-bridge-to-sql-request';
-import { Filter } from '../filter/filter-interfaces';
-import type { EntityFilter, EntityMetadata } from '../remult3/remult3';
-export declare class ArrayEntityDataProvider implements EntityDataProvider {
-    private entity;
-    static rawFilter(filter: CustomArrayFilter): EntityFilter<any>;
-    private rows;
-    constructor(entity: EntityMetadata, rows?: any[]);
-    __names: EntityDbNamesBase;
-    init(): Promise<EntityDbNamesBase>;
-    private verifyThatRowHasAllNotNullColumns;
-    count(where?: Filter): Promise<number>;
-    find(options?: EntityDataProviderFindOptions): Promise<any[]>;
-    translateFromJson(row: any, dbNames: EntityDbNamesBase): {};
-    translateToJson(row: any, dbNames: EntityDbNamesBase): {};
-    private idMatches;
-    update(id: any, data: any): Promise<any>;
-    delete(id: any): Promise<void>;
-    insert(data: any): Promise<any>;
-}
 export type CustomArrayFilter = (item: any) => boolean;
 export interface CustomArrayFilterObject {
     arrayFilter: CustomArrayFilter;

package/esm/src/data-providers/array-entity-data-provider.js

@@ -1,6 +1,7 @@
 import { CompoundIdField } from '../CompoundIdField';
 import { dbNamesOf, isDbReadonly, } from '../filter/filter-consumer-bridge-to-sql-request';
 import { Filter, customDatabaseFilterToken } from '../filter/filter-interfaces';
+//@internal
 export class ArrayEntityDataProvider {
     entity;
     static rawFilter(filter) {
@@ -10,6 +11,7 @@ export class ArrayEntityDataProvider {
             },
         };
     }
+    //@internal
     rows;
     constructor(entity, rows) {
         this.entity = entity;
@@ -18,7 +20,9 @@ export class ArrayEntityDataProvider {
         else
             this.rows = rows;
     }
+    //@internal
     __names;
+    //@internal
     async init() {
         if (this.__names)
             return this.__names;
@@ -28,6 +32,7 @@ export class ArrayEntityDataProvider {
         }
         return this.__names;
     }
+    //@internal
     verifyThatRowHasAllNotNullColumns(r, names) {
         for (const f of this.entity.fields) {
             const key = names.$dbNameOf(f);
@@ -89,6 +94,7 @@ export class ArrayEntityDataProvider {
             });
         return [];
     }
+    //@internal
     translateFromJson(row, dbNames) {
         let result = {};
         for (const col of this.entity.fields) {
@@ -96,6 +102,7 @@ export class ArrayEntityDataProvider {
         }
         return result;
     }
+    //@internal
     translateToJson(row, dbNames) {
         let result = {};
         for (const col of this.entity.fields) {
@@ -104,6 +111,7 @@ export class ArrayEntityDataProvider {
         }
         return result;
     }
+    //@internal
     idMatches(id, names) {
         return (item) => {
             let x = new FilterConsumerBridgeToObject(item, names);

package/esm/src/filter/filter-consumer-bridge-to-sql-request.d.ts

@@ -1,6 +1,6 @@
 import type { FieldMetadata } from '../column-interfaces';
 import type { EntityMetadataOverloads, RepositoryOverloads } from '../remult3/RepositoryImplementation';
-import type { EntityFilter, OmitEB, OmitFunctions } from '../remult3/remult3';
+import type { EntityFilter, MembersOnly } from '../remult3/remult3';
 import type { SqlCommandWithParameters } from '../sql-command';
 import type { Filter, FilterConsumer } from './filter-interfaces';
 export declare class FilterConsumerBridgeToSqlRequest implements FilterConsumer {
@@ -45,6 +45,6 @@ export declare type EntityDbNamesBase = {
     toString(): string;
 };
 export declare type EntityDbNames<entityType> = {
-    [Properties in keyof Required<OmitFunctions<OmitEB<entityType>>>]: string;
+    [Properties in keyof Required<MembersOnly<entityType>>]: string;
 } & EntityDbNamesBase;
 export declare function dbNamesOf<entityType>(repo: EntityMetadataOverloads<entityType>): Promise<EntityDbNames<entityType>>;

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

@@ -1,7 +1,6 @@
-import type { OmitEB } from './remult3';
 type Decorator<T = any> = (a: T, b: string, c?: any) => void;
 type Decorators<T> = T extends new (...args: any[]) => infer R ? {
-    [K in keyof OmitEB<R>]?: Decorator;
+    [K in keyof R]?: Decorator;
 } : never;
 type StaticDecorators<T> = {
     [K in keyof T]?: Decorator;

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

@@ -35,37 +35,27 @@ export declare class Relations {
      * @Relations.toOne(() => Customer)
      * customer?: Customer;
      * ```
-     */
-    static toOne<entityType, toEntityType>(toEntityType: () => ClassType<toEntityType>, options?: FieldOptions<entityType, toEntityType> & Pick<RelationOptions<entityType, toEntityType, any, any>, 'defaultIncluded'>): ClassFieldDecorator<entityType, toEntityType | undefined>;
-    /**
-     * Define a to-one relation between entities, indicating a one-to-one relationship.
-     * If no `fieldInMyEntity` is provided, this overload will automatically create a field in the database
-     * to represent the relation.
-     *
-     * @param toEntityType A function that returns the target entity type.
-     * @param fieldInMyEntity (Optional): The field in the current entity that represents the relation.
-     *                        Use this if you want to specify a custom field name for the relation.
-     * @returns A decorator function to apply the to-one relation to an entity field.
-     *
-     * Example usage:
      * ```
-     * @Relations.toOne(() => Customer)
+     * Fields.string()
+     * customerId?: string;
+     *
+     * @Relations.toOne(() => Customer, "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.
+     * ```
+     * Fields.string()
+     * customerId?: string;
      *
-     * Example usage:
+     * @Relations.toOne(() => Customer, {
+     *   field: "customerId",
+     *   defaultIncluded: true
+     * })
+     * customer?: Customer;
      * ```
+     * ```
+     * Fields.string()
+     * customerId?: string;
+     *
      * @Relations.toOne(() => Customer, {
      *   fields: {
      *     customerId: "id",
@@ -73,10 +63,8 @@ export declare class Relations {
      * })
      * 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>;
+    */
+    static toOne<entityType, toEntityType>(toEntityType: () => ClassType<toEntityType>, options?: FieldOptions<entityType, toEntityType> & Pick<RelationOptions<entityType, toEntityType, any, any>, 'defaultIncluded'> | RelationOptions<entityType, toEntityType, entityType> | keyof entityType): (target: any, context: string | ClassFieldDecoratorContextStub<any, toEntityType>, c?: any) => void;
     /**
      * 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.

package/esm/src/remult3/Fields.js

@@ -88,6 +88,49 @@ export class Fields {
     }
 }
 export class Relations {
+    /**
+     * Define a to-one relation between entities, indicating a one-to-one relationship.
+     * If no field or fields are provided, it will automatically create a field in the database
+     * to represent the relation.
+     *
+     * @param toEntityType A function that returns the target entity type.
+     * @param options (Optional): An object containing options for configuring the to-one relation.
+     * @returns A decorator function to apply the to-one relation to an entity field.
+     *
+     * Example usage:
+     * ```
+     * @Relations.toOne(() => Customer)
+     * customer?: Customer;
+     * ```
+     * ```
+     * Fields.string()
+     * customerId?: string;
+     *
+     * @Relations.toOne(() => Customer, "customerId")
+     * customer?: Customer;
+     * ```
+     * ```
+     * Fields.string()
+     * customerId?: string;
+     *
+     * @Relations.toOne(() => Customer, {
+     *   field: "customerId",
+     *   defaultIncluded: true
+     * })
+     * customer?: Customer;
+     * ```
+     * ```
+     * Fields.string()
+     * customerId?: string;
+     *
+     * @Relations.toOne(() => Customer, {
+     *   fields: {
+     *     customerId: "id",
+     *   },
+     * })
+     * customer?: Customer;
+     * ```
+    */
     static toOne(toEntityType, options) {
         let op = (typeof options === 'string'
             ? { field: options }

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

@@ -3,7 +3,7 @@ import { LookupColumn } from '../column';
 import type { FieldMetadata, FieldOptions, ValueConverter, ValueListItem } from '../column-interfaces';
 import { Remult } from '../context';
 import type { EntityOptions } from '../entity';
-import type { ControllerRef, EntityFilter, EntityMetadata, EntityOrderBy, EntityRef, FieldRef, FieldsMetadata, FieldsRef, FindFirstOptions, FindFirstOptionsBase, FindOptions, IdMetadata, LiveQuery, LoadOptions, OmitEB, QueryOptions, QueryResult, Repository, RepositoryRelations, Subscribable } from './remult3';
+import type { ControllerRef, ControllerRefForEntityBase, EntityFilter, EntityMetadata, EntityOrderBy, EntityRef, EntityRefForEntityBase, FieldRef, FieldsMetadata, FieldsRef, FieldsRefForEntityBase, FindFirstOptions, FindFirstOptionsBase, FindOptions, IdMetadata, LiveQuery, LoadOptions, MembersOnly, QueryOptions, QueryResult, Repository, RepositoryRelations, Subscribable } from './remult3';
 import type { RefSubscriber } from './remult3';
 import type { entityEventListener } from '../__EntityValueProvider';
 import type { DataProvider, EntityDataProvider, EntityDataProviderFindOptions, ErrorInfo } from '../data-interfaces';
@@ -38,19 +38,19 @@ export declare class RepositoryImplementation<entityType> implements Repository<
         id?: string;
     } ? string : string | number): Promise<void>;
     delete(item: entityType): Promise<void>;
-    insert(item: Partial<OmitEB<entityType>>[]): Promise<entityType[]>;
-    insert(item: Partial<OmitEB<entityType>>): Promise<entityType>;
+    insert(item: Partial<MembersOnly<entityType>>[]): Promise<entityType[]>;
+    insert(item: Partial<MembersOnly<entityType>>): Promise<entityType>;
     get fields(): FieldsMetadata<entityType>;
-    validate(entity: Partial<OmitEB<entityType>>, ...fields: Extract<keyof OmitEB<entityType>, string>[]): Promise<ErrorInfo<entityType> | undefined>;
+    validate(entity: Partial<MembersOnly<entityType>>, ...fields: Extract<keyof MembersOnly<entityType>, string>[]): Promise<ErrorInfo<entityType> | undefined>;
     update(id: entityType extends {
         id?: number;
     } ? number : entityType extends {
         id?: string;
-    } ? string : string | number, item: Partial<OmitEB<entityType>>): Promise<entityType>;
-    update(originalItem: Partial<OmitEB<entityType>>, item: Partial<OmitEB<entityType>>): Promise<entityType>;
+    } ? string : string | number, item: Partial<MembersOnly<entityType>>): Promise<entityType>;
+    update(originalItem: Partial<MembersOnly<entityType>>, item: Partial<MembersOnly<entityType>>): Promise<entityType>;
     private getRefForExistingRow;
-    save(item: Partial<OmitEB<entityType>>[]): Promise<entityType[]>;
-    save(item: Partial<OmitEB<entityType>>): Promise<entityType>;
+    save(item: Partial<MembersOnly<entityType>>[]): Promise<entityType[]>;
+    save(item: Partial<MembersOnly<entityType>>): Promise<entityType>;
     liveQuery(options?: FindOptions<entityType>): LiveQuery<entityType>;
     rawFind(options: FindOptions<entityType>, skipOrderByAndLimit: boolean, loader: RelationLoader): Promise<entityType[]>;
     find(options: FindOptions<entityType>, skipOrderByAndLimit?: boolean): Promise<entityType[]>;
@@ -64,7 +64,7 @@ export declare class RepositoryImplementation<entityType> implements Repository<
     private cache;
     findFirst(where?: EntityFilter<entityType>, options?: FindFirstOptions<entityType>, skipOrderByAndLimit?: boolean): Promise<entityType>;
     private fieldsOf;
-    create(item?: Partial<OmitEB<entityType>>): entityType;
+    create(item?: Partial<MembersOnly<entityType>>): entityType;
     fixTypes(item: any): Promise<any>;
     findId(id: any, options?: FindFirstOptionsBase<entityType>): Promise<entityType>;
 }
@@ -98,7 +98,7 @@ declare abstract class rowHelperBase<T> {
     __clearErrorsAndReportChanged(): void;
     _reportChangedToEntityAndFields(): void;
     hasErrors(): boolean;
-    copyDataToObject(): any;
+    copyDataToObject(isNew?: boolean): any;
     originalValues: any;
     saveOriginalData(): void;
     saveMoreOriginalData(): void;
@@ -259,19 +259,19 @@ export declare const storableMember: unique symbol;
 export declare function buildOptions<entityType = any, valueType = any>(options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[], remult: Remult): FieldOptions<entityType, valueType>;
 export declare function decorateColumnSettings<valueType>(settings: FieldOptions<any, valueType>, remult: Remult): FieldOptions<any, valueType>;
 export declare class EntityBase {
-    get _(): EntityRef<this>;
+    get _(): EntityRefForEntityBase<this>;
     save(): Promise<this>;
     assign(values: Partial<Omit<this, keyof EntityBase>>): this;
     delete(): Promise<void>;
     isNew(): boolean;
-    get $(): FieldsRef<this>;
+    get $(): FieldsRefForEntityBase<this>;
 }
 export declare class ControllerBase {
     protected remult: Remult;
     constructor(remult?: Remult);
     assign(values: Partial<Omit<this, keyof EntityBase>>): this;
-    get $(): FieldsRef<this>;
-    get _(): ControllerRef<this>;
+    get $(): FieldsRefForEntityBase<this>;
+    get _(): ControllerRefForEntityBase<this>;
 }
 declare class SubscribableImp implements Subscribable {
     reportChanged(): void;

package/esm/src/remult3/RepositoryImplementation.js

@@ -259,6 +259,7 @@ export class RepositoryImplementation {
                     let f = ref.fields[key];
                     if (entity[key] === undefined && getRelationInfo(f.metadata.options))
                         continue;
+                    //@ts-ignore
                     if (f)
                         r[key] = entity[key];
                 }
@@ -559,6 +560,8 @@ export class RepositoryImplementation {
             let val = rel.type === 'reference'
                 ? getEntityRef(row).fields.find(requireField(field.key, this.metadata)).getId()
                 : row[field.key];
+            if (!field.allowNull && (val === 0 || val === ''))
+                val = null;
             if (val === null)
                 returnNull = true;
             if (val === undefined)
@@ -827,7 +830,7 @@ class rowHelperBase {
         for (const col of columnsInfo) {
             let ei = getEntitySettings(col.valueType, false);
             if (ei && remult) {
-                let lookup = new LookupColumn(remult.repo(col.valueType), Boolean(col?.[relationInfoMember]));
+                let lookup = new LookupColumn(remult.repo(col.valueType), Boolean(col?.[relationInfoMember]), col.allowNull);
                 this.lookups.set(col.key, lookup);
                 let val = instance[col.key];
                 let refImpl;
@@ -1003,21 +1006,28 @@ class rowHelperBase {
         this._subscribers?.reportObserved();
         return !!!this.error && this.errors == undefined;
     }
-    copyDataToObject() {
+    copyDataToObject(isNew = false) {
         let d = {};
         for (const col of this.columnsInfo) {
             let lu = this.lookups.get(col.key);
             let val = undefined;
+            const rel = getRelationInfo(col);
             if (lu)
                 val = lu.id;
             else
                 val = this.instance[col.key];
+            if (rel && isNew && !col.allowNull && (val === undefined || null)) {
+                if (this.remult.repo(rel.toType()).metadata.idMetadata.field.valueType ===
+                    Number)
+                    val = 0;
+                else
+                    val = '';
+            }
             if (val !== undefined) {
                 val = col.valueConverter.toJson(val);
                 if (val !== undefined && val !== null)
                     val = col.valueConverter.fromJson(JSON.parse(JSON.stringify(val)));
             }
-            const rel = getRelationInfo(col);
             if (!rel || rel.type === 'reference')
                 d[col.key] = val;
         }
@@ -1216,7 +1226,7 @@ export class rowHelperImplementation extends rowHelperBase {
                 }
             }
             this.__assertValidity();
-            let d = this.copyDataToObject();
+            let d = this.copyDataToObject(this.isNew());
             let ignoreKeys = [];
             for (const field of this.metadata.fields) {
                 if (field.dbReadOnly ||
@@ -2118,7 +2128,7 @@ export class EntityBase {
         return getEntityRef(this);
     }
     save() {
-        return this._.save();
+        return getEntityRef(this).save();
     }
     assign(values) {
         assign(this, values);