remult 0.22.8 → 0.22.9

package/esm/internals.d.ts

@@ -0,0 +1,7 @@
+export { getRelationInfo } from './src/remult3/relationInfoMember';
+export { decorateColumnSettings, controllerRefImpl, getControllerRef, } from './src/remult3/RepositoryImplementation';
+export { getEntitySettings } from './src/remult3/getEntityRef';
+export { __updateEntityBasedOnWhere } from './src/filter/filter-interfaces';
+export { actionInfo } from './src/server-action-info';
+export { RelationInfo } from './src/remult3/remult3';
+export { ClassType } from './classType';

package/esm/internals.js

@@ -0,0 +1,5 @@
+export { getRelationInfo } from './src/remult3/relationInfoMember';
+export { decorateColumnSettings, controllerRefImpl, getControllerRef, } from './src/remult3/RepositoryImplementation';
+export { getEntitySettings } from './src/remult3/getEntityRef';
+export { __updateEntityBasedOnWhere } from './src/filter/filter-interfaces';
+export { actionInfo } from './src/server-action-info';

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

@@ -0,0 +1,52 @@
+import type { ClassType } from '../../classType';
+import type { FieldOptions } from '../column-interfaces';
+import type { Remult } from '../context';
+import type { FindOptions, RelationOptions, ClassFieldDecorator, ClassFieldDecoratorContextStub } from './remult3';
+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))[]): ClassFieldDecorator<entityType, valueType | undefined>;
+    static json<entityType = any, valueType = any>(...options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, valueType | undefined>;
+    static dateOnly<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, Date | undefined>;
+    static date<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, Date | undefined>;
+    static integer<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, number | undefined>;
+    static autoIncrement<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, number | undefined>;
+    static number<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, number | undefined>;
+    static createdAt<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, Date | undefined>;
+    static updatedAt<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, Date | undefined>;
+    static uuid<entityType = any>(...options: (FieldOptions<entityType, string> | ((options: FieldOptions<entityType, string>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, string | undefined>;
+    static cuid<entityType = any>(...options: (FieldOptions<entityType, string> | ((options: FieldOptions<entityType, string>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, string | undefined>;
+    static string<entityType = any>(...options: (StringFieldOptions<entityType> | ((options: StringFieldOptions<entityType>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, string | undefined>;
+    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 */
+    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 */
+    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 */
+    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 toMany<entityType, toEntityType>(toEntityType: () => ClassType<toEntityType>, fieldInToEntity?: keyof toEntityType): ClassFieldDecorator<entityType, toEntityType[] | undefined>;
+    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.
+ * 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>) | undefined, ...options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[]): (target: any, context: ClassFieldDecoratorContextStub<entityType, valueType | undefined> | string, c?: any) => void;
+export interface StringFieldOptions<entityType = any> extends FieldOptions<entityType, string> {
+    maxLength?: number;
+}
+export declare function checkTarget(target: any): void;

package/esm/src/remult3/Fields.js

@@ -0,0 +1,195 @@
+import { createId } from '@paralleldrive/cuid2';
+import { v4 as uuid } from 'uuid';
+import { ValueConverters } from '../valueConverters';
+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: (_, { isNew }, ref) => {
+                if (isNew)
+                    ref.value = new Date();
+            },
+        }, ...options);
+    }
+    static updatedAt(...options) {
+        return Field(() => Date, {
+            allowApiUpdate: false,
+            saving: (_, _1, ref) => {
+                ref.value = new Date();
+            },
+        }, ...options);
+    }
+    static uuid(...options) {
+        return Field(() => String, {
+            allowApiUpdate: false,
+            defaultValue: () => uuid(),
+            saving: (_, _1, r) => {
+                if (!r.value)
+                    r.value = uuid();
+            },
+        }, ...options);
+    }
+    static cuid(...options) {
+        return Field(() => String, {
+            allowApiUpdate: false,
+            defaultValue: () => createId(),
+            saving: (_, _1, r) => {
+                if (!r.value)
+                    r.value = createId();
+            },
+        }, ...options);
+    }
+    static string(...options) {
+        return Field(() => String, ...options);
+    }
+    static boolean(...options) {
+        return Field(() => Boolean, ...options);
+    }
+}
+export class Relations {
+    static toOne(toEntityType, options) {
+        let op = (typeof options === 'string'
+            ? { field: 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,
+            //@ts-ignore
+            [relationInfoMember]: {
+                //field,
+                toType: toEntityType,
+                type: 'toOne',
+            },
+        });
+    }
+    static toMany(toEntityType, options) {
+        let op = (typeof options === 'string'
+            ? { field: options }
+            : options);
+        return Field(() => undefined, {
+            ...op,
+            serverExpression: () => undefined,
+            //@ts-ignore
+            [relationInfoMember]: {
+                //field,
+                toType: toEntityType,
+                type: 'toMany',
+            },
+        });
+    }
+}
+/**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

@@ -98,7 +98,7 @@ declare abstract class rowHelperBase<T> {
     __validateEntity(): Promise<void>;
     __performColumnAndEntityValidations(): Promise<void>;
     toApiJson(includeRelatedEntities?: boolean): any;
-    _updateEntityBasedOnApi(body: any): Promise<void>;
+    _updateEntityBasedOnApi(body: any, ignoreApiAllowed?: boolean): Promise<void>;
 }
 export declare class rowHelperImplementation<T> extends rowHelperBase<T> implements EntityRef<T> {
     private info;

package/esm/src/remult3/RepositoryImplementation.js

@@ -815,13 +815,14 @@ class rowHelperBase {
         }
         return result;
     }
-    async _updateEntityBasedOnApi(body) {
+    async _updateEntityBasedOnApi(body, ignoreApiAllowed = false) {
         let keys = Object.keys(body);
         for (const col of this.columnsInfo) {
             if (keys.includes(col.key))
                 if (col.includeInApi === undefined ||
                     this.remult.isAllowed(col.includeInApi)) {
                     if (!this.remult ||
+                        ignoreApiAllowed ||
                         col.allowApiUpdate === undefined ||
                         this.remult.isAllowedForInstance(this.instance, col.allowApiUpdate)) {
                         let lu = this.lookups.get(col.key);

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

@@ -0,0 +1,6 @@
+import type { FieldOptions } from '../column-interfaces';
+import { Remult } from '../context';
+export interface columnInfo {
+    key: string;
+    settings: (remult: Remult) => FieldOptions;
+}

package/esm/src/remult3/columnInfo.js

@@ -0,0 +1 @@
+export {};

package/esm/src/remult3/relation-loader-types.d.ts

@@ -0,0 +1,7 @@
+import type { ClassType } from '../../classType';
+import type { EntityMetadata, FindOptions } from './remult3';
+export interface RelationLoaderHelper<toEntity> {
+    metadata: EntityMetadata<toEntity>;
+    entityType: ClassType<toEntity>;
+    find(options: FindOptions<toEntity>): Promise<toEntity[]>;
+}

package/esm/src/remult3/relation-loader-types.js

@@ -0,0 +1 @@
+export {};

package/esm/src/remult3/relation-loader.d.ts

@@ -0,0 +1,40 @@
+import type { RelationLoaderHelper } from './relation-loader-types';
+import type { FindOptions } from './remult3';
+export declare class RelationLoader {
+    entityLoaders: Map<any, EntityLoader>;
+    promises: any[];
+    load(rel: RelationLoaderHelper<any>, findOptions: FindOptions<any>): Promise<any[]>;
+    constructor();
+    resolveAll(): Promise<void>;
+}
+declare class EntityLoader {
+    private rel;
+    queries: Map<string, QueryVariation>;
+    find(findOptions: FindOptions<any>): Promise<any[]>;
+    constructor(rel: RelationLoaderHelper<any>);
+}
+declare class QueryVariation {
+    private rel;
+    find(findOptions: FindOptions<any>, where: any): Promise<any[]>;
+    constructor(rel: RelationLoaderHelper<any>);
+    resolve(): void;
+    pendingInStatements: Map<string, PendingInStatements>;
+    whereVariations: Map<string, {
+        result: Promise<any[]>;
+    }>;
+}
+declare class PendingInStatements {
+    private rel;
+    private key;
+    private options;
+    resolve(): void;
+    find(where: any): Promise<any[]>;
+    values: Map<any, {
+        value: any;
+        resolve: (value: any[]) => void;
+        reject: (error: any) => void;
+        result: Promise<any[]>;
+    }>;
+    constructor(rel: RelationLoaderHelper<any>, key: string, options: FindOptions<any>);
+}
+export {};

package/esm/src/remult3/relation-loader.js

@@ -0,0 +1,142 @@
+import { findOptionsToJson } from '../data-providers/rest-data-provider';
+import { getEntityRef } from './getEntityRef';
+import { getRelationInfo } from './relationInfoMember';
+export class RelationLoader {
+    entityLoaders = new Map();
+    promises = [];
+    load(rel, findOptions) {
+        let e = this.entityLoaders.get(rel.entityType);
+        if (!e) {
+            this.entityLoaders.set(rel.entityType, (e = new EntityLoader(rel)));
+        }
+        const p = e.find(findOptions);
+        this.promises.push(p);
+        return p;
+    }
+    constructor() { }
+    async resolveAll() {
+        for (const entity of this.entityLoaders.values()) {
+            for (const variation of entity.queries.values()) {
+                variation.resolve();
+            }
+        }
+        if (this.promises.length === 0)
+            return;
+        const x = this.promises;
+        this.promises = [];
+        await Promise.all(x);
+        await this.resolveAll();
+    }
+}
+class EntityLoader {
+    rel;
+    queries = new Map();
+    find(findOptions) {
+        const { where, ...options } = findOptionsToJson(findOptions, this.rel.metadata);
+        const optionKeys = JSON.stringify(options);
+        let q = this.queries.get(optionKeys);
+        if (!q) {
+            this.queries.set(optionKeys, (q = new QueryVariation(this.rel)));
+        }
+        return q.find(findOptions, where);
+    }
+    constructor(rel) {
+        this.rel = rel;
+    }
+}
+class QueryVariation {
+    rel;
+    find(findOptions, where) {
+        const whereKey = JSON.stringify(where);
+        let w = this.whereVariations.get(whereKey);
+        if (!w) {
+            const keys = Object.keys(where);
+            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
+            ) {
+                let inVariation = this.pendingInStatements.get(keys[0]);
+                if (!inVariation) {
+                    this.pendingInStatements.set(keys[0], (inVariation = new PendingInStatements(this.rel, keys[0], findOptions)));
+                }
+                this.whereVariations.set(whereKey, (w = {
+                    result: inVariation.find(where),
+                }));
+            }
+            else {
+                this.whereVariations.set(whereKey, (w = {
+                    result: this.rel.find(findOptions),
+                }));
+            }
+        }
+        return w.result;
+    }
+    constructor(rel) {
+        this.rel = rel;
+    }
+    resolve() {
+        const statements = [...this.pendingInStatements.values()];
+        this.pendingInStatements.clear();
+        for (const statement of statements) {
+            statement.resolve();
+        }
+    }
+    pendingInStatements = new Map();
+    whereVariations = new Map();
+}
+class PendingInStatements {
+    rel;
+    key;
+    options;
+    resolve() {
+        const values = [...this.values.values()];
+        if (values.length == 1) {
+            this.rel.find(this.options).then(values[0].resolve, values[0].reject);
+            return;
+        }
+        var op = { ...this.options };
+        op.where = { [this.key]: values.map((v) => v.value) };
+        this.rel.find(op).then((val) => {
+            for (const value of this.values.values()) {
+                value.resolve(val.filter((x) => {
+                    const ref = getEntityRef(x);
+                    const field = ref.fields.find(this.key);
+                    const rel = getRelationInfo(field.metadata.options);
+                    const val = rel?.type === 'reference'
+                        ? field.getId()
+                        : x[this.key];
+                    return value.value == val;
+                }));
+            }
+        }, (err) => {
+            for (const value of this.values.values()) {
+                value.reject(err);
+            }
+        });
+    }
+    find(where) {
+        const val = where[this.key];
+        let valHandler = this.values.get(val);
+        if (!valHandler) {
+            let resolve;
+            let reject;
+            let result = new Promise((resolve1, reject1) => {
+                resolve = resolve1;
+                reject = reject1;
+            });
+            this.values.set(val, (valHandler = {
+                value: val,
+                resolve,
+                reject,
+                result,
+            }));
+        }
+        return valHandler.result;
+    }
+    values = new Map();
+    constructor(rel, key, options) {
+        this.rel = rel;
+        this.key = key;
+        this.options = options;
+    }
+}

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

@@ -0,0 +1,4 @@
+import type { FieldOptions } from '../column-interfaces';
+import type { RelationInfo } from './remult3';
+export declare const relationInfoMember: unique symbol;
+export declare function getRelationInfo(options: FieldOptions): RelationInfo;

package/esm/src/remult3/relationInfoMember.js

@@ -0,0 +1,4 @@
+export const relationInfoMember = Symbol('relationInfo');
+export function getRelationInfo(options) {
+    return options?.[relationInfoMember];
+}

package/esm/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/esm/src/remult3/repository-internals.js

@@ -0,0 +1,7 @@
+export function getRepositoryInternals(repo) {
+    const x = repo;
+    if (typeof x[getInternalKey] === 'function')
+        return x[getInternalKey]();
+    throw Error('Error getting repository internal from ' + repo);
+}
+export const getInternalKey = 'getInternal';

package/esm/src/server-action.js

@@ -267,7 +267,7 @@ export function BackendMethod(options) {
                                 id: defs.getOriginalId(),
                             },
                         }, baseUrl, http);
-                        await defs._updateEntityBasedOnApi(r.rowInfo.data);
+                        await defs._updateEntityBasedOnApi(r.rowInfo.data, true);
                         return r.result;
                     }
                     catch (err) {

package/internals.d.ts

@@ -0,0 +1,7 @@
+export { getRelationInfo } from './src/remult3/relationInfoMember';
+export { decorateColumnSettings, controllerRefImpl, getControllerRef, } from './src/remult3/RepositoryImplementation';
+export { getEntitySettings } from './src/remult3/getEntityRef';
+export { __updateEntityBasedOnWhere } from './src/filter/filter-interfaces';
+export { actionInfo } from './src/server-action-info';
+export { RelationInfo } from './src/remult3/remult3';
+export { ClassType } from './classType';

package/internals.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.actionInfo = exports.__updateEntityBasedOnWhere = exports.getEntitySettings = exports.getControllerRef = exports.controllerRefImpl = exports.decorateColumnSettings = exports.getRelationInfo = void 0;
+var relationInfoMember_1 = require("./src/remult3/relationInfoMember");
+Object.defineProperty(exports, "getRelationInfo", { enumerable: true, get: function () { return relationInfoMember_1.getRelationInfo; } });
+var RepositoryImplementation_1 = require("./src/remult3/RepositoryImplementation");
+Object.defineProperty(exports, "decorateColumnSettings", { enumerable: true, get: function () { return RepositoryImplementation_1.decorateColumnSettings; } });
+Object.defineProperty(exports, "controllerRefImpl", { enumerable: true, get: function () { return RepositoryImplementation_1.controllerRefImpl; } });
+Object.defineProperty(exports, "getControllerRef", { enumerable: true, get: function () { return RepositoryImplementation_1.getControllerRef; } });
+var getEntityRef_1 = require("./src/remult3/getEntityRef");
+Object.defineProperty(exports, "getEntitySettings", { enumerable: true, get: function () { return getEntityRef_1.getEntitySettings; } });
+var filter_interfaces_1 = require("./src/filter/filter-interfaces");
+Object.defineProperty(exports, "__updateEntityBasedOnWhere", { enumerable: true, get: function () { return filter_interfaces_1.__updateEntityBasedOnWhere; } });
+var server_action_info_1 = require("./src/server-action-info");
+Object.defineProperty(exports, "actionInfo", { enumerable: true, get: function () { return server_action_info_1.actionInfo; } });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "remult",
-    "version": "0.22.8",
+    "version": "0.22.9",
     "description": "A CRUD framework for full-stack TypeScript",
     "types": "index.d.ts",
     "module": "esm/index.js",

package/src/remult3/Fields.d.ts

@@ -0,0 +1,52 @@
+import type { ClassType } from '../../classType';
+import type { FieldOptions } from '../column-interfaces';
+import type { Remult } from '../context';
+import type { FindOptions, RelationOptions, ClassFieldDecorator, ClassFieldDecoratorContextStub } from './remult3';
+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))[]): ClassFieldDecorator<entityType, valueType | undefined>;
+    static json<entityType = any, valueType = any>(...options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, valueType | undefined>;
+    static dateOnly<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, Date | undefined>;
+    static date<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, Date | undefined>;
+    static integer<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, number | undefined>;
+    static autoIncrement<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, number | undefined>;
+    static number<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, number | undefined>;
+    static createdAt<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, Date | undefined>;
+    static updatedAt<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, Date | undefined>;
+    static uuid<entityType = any>(...options: (FieldOptions<entityType, string> | ((options: FieldOptions<entityType, string>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, string | undefined>;
+    static cuid<entityType = any>(...options: (FieldOptions<entityType, string> | ((options: FieldOptions<entityType, string>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, string | undefined>;
+    static string<entityType = any>(...options: (StringFieldOptions<entityType> | ((options: StringFieldOptions<entityType>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, string | undefined>;
+    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 */
+    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 */
+    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 */
+    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 toMany<entityType, toEntityType>(toEntityType: () => ClassType<toEntityType>, fieldInToEntity?: keyof toEntityType): ClassFieldDecorator<entityType, toEntityType[] | undefined>;
+    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.
+ * 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>) | undefined, ...options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[]): (target: any, context: ClassFieldDecoratorContextStub<entityType, valueType | undefined> | string, c?: any) => void;
+export interface StringFieldOptions<entityType = any> extends FieldOptions<entityType, string> {
+    maxLength?: number;
+}
+export declare function checkTarget(target: any): void;