remult 0.22.8 → 0.22.9-exp.0

package/esm/src/remult3/Fields.js

@@ -0,0 +1,199 @@
+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 {
+    /**
+     * Stored as a JSON.stringify - to store as json use Fields.json
+     */
+    static object(...options) {
+        return Field(undefined, ...options);
+    }
+    static json(...options) {
+        return Field(undefined, {
+            valueConverter: {
+                fieldTypeInDb: 'json',
+            },
+        }, ...options);
+    }
+    static dateOnly(...options) {
+        return Field(() => Date, {
+            valueConverter: ValueConverters.DateOnly,
+        }, ...options);
+    }
+    static date(...options) {
+        return Field(() => Date, ...options);
+    }
+    static integer(...options) {
+        return Field(() => Number, {
+            valueConverter: ValueConverters.Integer,
+        }, ...options);
+    }
+    static autoIncrement(...options) {
+        return Field(() => Number, {
+            allowApiUpdate: false,
+            dbReadOnly: true,
+            valueConverter: {
+                ...ValueConverters.Integer,
+                fieldTypeInDb: 'autoincrement',
+            },
+        }, ...options);
+    }
+    static number(...options) {
+        return Field(() => Number, ...options);
+    }
+    static createdAt(...options) {
+        return Field(() => Date, {
+            allowApiUpdate: false,
+            saving: (_, ref) => {
+                if (getEntityRef(_).isNew())
+                    ref.value = new Date();
+            },
+        }, ...options);
+    }
+    static updatedAt(...options) {
+        return Field(() => Date, {
+            allowApiUpdate: false,
+            saving: (_, ref) => {
+                ref.value = new Date();
+            },
+        }, ...options);
+    }
+    static uuid(...options) {
+        return Field(() => String, {
+            allowApiUpdate: false,
+            defaultValue: () => uuid(),
+            saving: (_, r) => {
+                if (!r.value)
+                    r.value = uuid();
+            },
+        }, ...options);
+    }
+    static cuid(...options) {
+        return Field(() => String, {
+            allowApiUpdate: false,
+            defaultValue: () => createId(),
+            saving: (_, r) => {
+                if (!r.value)
+                    r.value = createId();
+            },
+        }, ...options);
+    }
+    static string(...options) {
+        return Field(() => String, ...options);
+    }
+    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) {
+        let op = (typeof options === 'string'
+            ? { field: options }
+            : options);
+        return Field(() => undefined, {
+            ...op,
+            serverExpression: () => undefined,
+            //@ts-ignore
+            [relationInfoMember]: {
+                //field,
+                toType: toEntityType,
+                type: 'toMany',
+            },
+        });
+    }
+    static one(entity, toEntityType, options) {
+        let op = (typeof options === 'string'
+            ? { field: options }
+            : !options
+                ? {}
+                : options);
+        return Field(() => undefined, {
+            ...op,
+            serverExpression: () => undefined,
+            //@ts-ignore
+            [relationInfoMember]: {
+                //field,
+                toType: toEntityType,
+                type: 'toOne',
+            },
+        });
+    }
+}
+/**Decorates fields that should be used as fields.
+ * for more info see: [Field Types](https://remult.dev/docs/field-types.html)
+ *
+ * FieldOptions can be set in two ways:
+ * @example
+ * // as an object
+ * @Fields.string({ includeInApi:false })
+ * title='';
+ * @example
+ * // as an arrow function that receives `remult` as a parameter
+ * @Fields.string((options,remult) => options.includeInApi = true)
+ * title='';
+ */
+export function Field(valueType, ...options) {
+    // import ANT!!!! if you call this in another decorator, make sure to set It's return type correctly with the | undefined
+    return (target, context, c) => {
+        const key = typeof context === 'string' ? context : context.name.toString();
+        let factory = (remult) => {
+            let r = buildOptions(options, remult);
+            if (!r.valueType && valueType) {
+                r.valueType = valueType();
+            }
+            if (!r.key) {
+                r.key = key;
+            }
+            if (!r.dbName)
+                r.dbName = r.key;
+            let type = r.valueType;
+            if (!type) {
+                type = Reflect.getMetadata('design:type', target, key);
+                r.valueType = type;
+            }
+            if (!r.target)
+                r.target = target;
+            return r;
+        };
+        checkTarget(target);
+        let names = columnsOfType.get(target.constructor);
+        if (!names) {
+            names = [];
+            columnsOfType.set(target.constructor, names);
+        }
+        let set = names.find((x) => x.key == key);
+        if (!set)
+            names.push({
+                key,
+                settings: factory,
+            });
+        else {
+            let prev = set.settings;
+            set.settings = (c) => {
+                let prevO = prev(c);
+                let curr = factory(c);
+                return Object.assign(prevO, curr);
+            };
+        }
+    };
+}
+export function checkTarget(target) {
+    if (!target)
+        throw new Error("Set the 'experimentalDecorators:true' option in your 'tsconfig' or 'jsconfig' (target undefined)");
+}

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

@@ -0,0 +1,4 @@
+import { EntityBase } from './RepositoryImplementation';
+export declare class IdEntity extends EntityBase {
+    id: string;
+}

package/esm/src/remult3/IdEntity.js

@@ -0,0 +1,10 @@
+import { __decorate, __metadata } from "tslib";
+import { Fields } from './Fields';
+import { EntityBase } from './RepositoryImplementation';
+export class IdEntity extends EntityBase {
+    id;
+}
+__decorate([
+    Fields.uuid(),
+    __metadata("design:type", String)
+], IdEntity.prototype, "id", void 0);

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

@@ -3,23 +3,27 @@ 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, OmitEB, QueryOptions, QueryResult, Repository, Subscribable } from './remult3';
+import type { ControllerRef, EntityFilter, EntityMetadata, EntityOrderBy, EntityRef, FieldRef, FieldsMetadata, FieldsRef, FindFirstOptions, FindFirstOptionsBase, FindOptions, IdMetadata, LiveQuery, OmitEB, 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';
 import type { Unsubscribe } from '../live-query/SubscriptionChannel';
+import type { columnInfo } from './columnInfo';
+import { RelationLoader } from './relation-loader';
 export declare class RepositoryImplementation<entityType> implements Repository<entityType> {
     private entity;
     remult: Remult;
     private dataProvider;
-    createAfterFilter(orderBy: EntityOrderBy<entityType>, lastRow: entityType): Promise<EntityFilter<entityType>>;
     private _info;
+    private defaultFindOptions?;
+    createAfterFilter(orderBy: EntityOrderBy<entityType>, lastRow: entityType): Promise<EntityFilter<entityType>>;
+    relations(item: entityType): RepositoryRelations<entityType>;
     private __edp;
     private get edp();
-    constructor(entity: ClassType<entityType>, remult: Remult, dataProvider: DataProvider);
+    constructor(entity: ClassType<entityType>, remult: Remult, dataProvider: DataProvider, _info: EntityFullInfo<entityType>, defaultFindOptions?: FindOptions<entityType>);
     idCache: Map<any, any>;
-    getCachedById(id: any): entityType;
-    getCachedByIdAsync(id: any): Promise<entityType>;
+    getCachedById(id: any, doNotLoadIfNotFound: boolean): entityType;
+    getCachedByIdAsync(id: any, doNotLoadIfNotFound: boolean): Promise<entityType>;
     addToCache(item: entityType): void;
     get metadata(): EntityMetadata<entityType>;
     listeners: entityEventListener<entityType>[];
@@ -46,6 +50,7 @@ export declare class RepositoryImplementation<entityType> implements Repository<
     save(item: Partial<OmitEB<entityType>>[]): Promise<entityType[]>;
     save(item: Partial<OmitEB<entityType>>): Promise<entityType>;
     liveQuery(options?: FindOptions<entityType>): LiveQuery<entityType>;
+    rawFind(options: FindOptions<entityType>, skipOrderByAndLimit: boolean, loader: RelationLoader): Promise<Awaited<entityType>[]>;
     find(options: FindOptions<entityType>, skipOrderByAndLimit?: boolean): Promise<entityType[]>;
     buildEntityDataProviderFindOptions(options: FindOptions<entityType>): Promise<EntityDataProviderFindOptions>;
     fromJsonArray(jsonItems: any[], load?: (entity: FieldsMetadata<entityType>) => FieldMetadata[]): Promise<Awaited<entityType>[]>;
@@ -218,28 +223,7 @@ declare class EntityFullInfo<T> implements EntityMetadata<T> {
     caption: string;
 }
 export declare function FieldType<valueType = any>(...options: (FieldOptions<any, valueType> | ((options: FieldOptions<any, valueType>, remult: Remult) => void))[]): (target: any, context?: any) => any;
-export declare class Fields {
-    /**
-     * Stored as a JSON.stringify - to store as json use Fields.json
-     */
-    static object<entityType = any, valueType = any>(...options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, valueType | undefined>, c?: any) => void;
-    static json<entityType = any, valueType = any>(...options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, valueType | undefined>, c?: any) => void;
-    static dateOnly<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, Date | undefined>, c?: any) => void;
-    static date<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, Date | undefined>, c?: any) => void;
-    static integer<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, number | undefined>, c?: any) => void;
-    static autoIncrement<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, number | undefined>, c?: any) => void;
-    static number<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, number | undefined>, c?: any) => void;
-    static createdAt<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, Date | undefined>, c?: any) => void;
-    static updatedAt<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, Date | undefined>, c?: any) => void;
-    static uuid<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 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;
-}
 export declare function isAutoIncrement(f: FieldMetadata): boolean;
-export interface StringFieldOptions<entityType = any> extends FieldOptions<entityType, string> {
-    maxLength?: number;
-}
 export declare function ValueListFieldType<valueType extends ValueListItem = any>(...options: (ValueListFieldOptions<any, valueType> | ((options: FieldOptions<any, valueType>, remult: Remult) => void))[]): (type: ClassType<valueType>, context?: any) => void;
 export interface ValueListFieldOptions<entityType, valueType> extends FieldOptions<entityType, valueType> {
     getValues?: () => valueType[];
@@ -277,26 +261,9 @@ export interface ClassDecoratorContextStub<Class extends new (...args: any) => a
     readonly name: string | undefined;
     addInitializer(initializer: (this: Class) => void): void;
 }
-/**Decorates fields that should be used as fields.
- * for more info see: [Field Types](https://remult.dev/docs/field-types.html)
- *
- * FieldOptions can be set in two ways:
- * @example
- * // as an object
- * @Fields.string({ includeInApi:false })
- * title='';
- * @example
- * // as an arrow function that receives `remult` as a parameter
- * @Fields.string((options,remult) => options.includeInApi = true)
- * title='';
- */
-export declare function Field<entityType = any, valueType = any>(valueType: () => ClassType<valueType>, ...options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[]): (target: any, context: ClassFieldDecoratorContextStub<entityType, valueType | undefined> | string, c?: any) => void;
 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>;
-interface columnInfo {
-    key: string;
-    settings: (remult: Remult) => FieldOptions;
-}
 export declare class EntityBase {
     get _(): EntityRef<this>;
     save(): Promise<this>;
@@ -305,9 +272,6 @@ export declare class EntityBase {
     isNew(): boolean;
     get $(): FieldsRef<this>;
 }
-export declare class IdEntity extends EntityBase {
-    id: string;
-}
 export declare class ControllerBase {
     protected remult: Remult;
     constructor(remult?: Remult);
@@ -328,5 +292,4 @@ export declare function getEntityMetadata<entityType>(entity: EntityMetadataOver
 export declare function getRepository<entityType>(entity: RepositoryOverloads<entityType>): Repository<entityType>;
 export type EntityMetadataOverloads<entityType> = Repository<entityType> | EntityMetadata<entityType> | ClassType<entityType>;
 export type RepositoryOverloads<entityType> = Repository<entityType> | ClassType<entityType>;
-export declare function checkTarget(target: any): void;
 export {};