remult 0.22.5 → 0.22.6-exp.2

package/esm/src/CompoundIdField.js

@@ -0,0 +1,62 @@
+export class CompoundIdField {
+    fields;
+    constructor(...columns) {
+        this.fields = columns;
+    }
+    apiUpdateAllowed(item) {
+        throw new Error('Method not implemented.');
+    }
+    displayValue(item) {
+        throw new Error('Method not implemented.');
+    }
+    includedInApi(item) {
+        throw new Error('Method not implemented.');
+    }
+    toInput(value, inputType) {
+        throw new Error('Method not implemented.');
+    }
+    fromInput(inputValue, inputType) {
+        throw new Error('Method not implemented.');
+    }
+    getDbName() {
+        return Promise.resolve('');
+    }
+    getId(instance) {
+        let get = (field) => {
+            return instance[field.key];
+        };
+        if (typeof instance === 'function') {
+            get = instance;
+        }
+        let r = '';
+        this.fields.forEach((c) => {
+            if (r.length > 0)
+                r += ',';
+            r += c.valueConverter.toJson(get(c));
+        });
+        return r;
+    }
+    options = {};
+    get valueConverter() {
+        throw new Error('cant get value converter of compound id');
+    }
+    target;
+    readonly = true;
+    allowNull = false;
+    dbReadOnly = false;
+    isServerExpression = false;
+    key = '';
+    caption = '';
+    inputType = '';
+    dbName = '';
+    valueType;
+    isEqualTo(value) {
+        let result = {};
+        let val = value.toString();
+        let id = val.split(',');
+        this.fields.forEach((c, i) => {
+            result[c.key] = c.valueConverter.fromJson(id[i]);
+        });
+        return result;
+    }
+}

package/esm/src/backend-tests/backend-database-test-setup.backend-spec.js

@@ -64,16 +64,17 @@ export const mySqlTest = addDatabaseToTest(testKnexSqlImpl(Knex.default({
         database: 'test',
     },
 }), 'mysql2'));
-addDatabaseToTest(testKnexSqlImpl(Knex.default({
-    client: 'mysql',
-    connection: {
-        user: 'root',
-        password: 'MASTERKEY',
-        host: '127.0.0.1',
-        database: 'test',
-        port: 3307
-    },
-}), 'mysql'));
+if (false)
+    addDatabaseToTest(testKnexSqlImpl(Knex.default({
+        client: 'mysql',
+        connection: {
+            user: 'root',
+            password: 'MASTERKEY',
+            host: '127.0.0.1',
+            database: 'test',
+            port: 3307,
+        },
+    }), 'mysql'));
 let pg = createPostgresConnection();
 export function testPostgresImplementation(key, what, focus = false) {
     itWithFocus(key + ' - postgres', async () => {

package/esm/src/data-api.js

@@ -22,7 +22,7 @@ export class DataApi {
     async httpPost(res, req, body, serializeContext) {
         const action = req?.get('__action');
         if (action?.startsWith(liveQueryAction))
-            return this.liveQuery(res, req, undefined, serializeContext, action.substring(liveQueryAction.length));
+            return this.liveQuery(res, req, body, serializeContext, action.substring(liveQueryAction.length));
         switch (action) {
             case 'get':
                 return this.getArray(res, req, body);
@@ -159,7 +159,9 @@ export class DataApi {
             where.push(buildFilterFromRequestParameters(this.repository.metadata, {
                 get: (key) => {
                     let result = request.get(key);
-                    if (key.startsWith(customUrlToken) && result && typeof result === "string")
+                    if (key.startsWith(customUrlToken) &&
+                        result &&
+                        typeof result === 'string')
                         return JSON.parse(result);
                     return result;
                 },

package/esm/src/data-providers/json-entity-opfs-storage.js

@@ -0,0 +1,26 @@
+export class JsonEntityOpfsStorage {
+    //@internal
+    opfsRoot;
+    async getItem(entityDbName) {
+        const opfsFile = await (await this.init()).getFileHandle(entityDbName + '.json', {
+            create: true,
+        });
+        const readable = await opfsFile.getFile();
+        return await readable.text();
+    }
+    //@internal
+    async init() {
+        if (!this.opfsRoot) {
+            this.opfsRoot = await navigator.storage.getDirectory();
+        }
+        return this.opfsRoot;
+    }
+    async setItem(entityDbName, json) {
+        const opfsFile = await await (await this.init()).getFileHandle(entityDbName + '.json', {
+            create: true,
+        });
+        const writable = await opfsFile.createWritable();
+        await writable.write(json);
+        await writable.close();
+    }
+}

package/esm/src/isOfType.js

@@ -0,0 +1,9 @@
+export function isOfType(obj, checkMethod) {
+    return typeof obj[checkMethod] !== 'undefined';
+}
+export function cast(obj, checkMethod) {
+    if (isOfType(obj, checkMethod)) {
+        return obj;
+    }
+    throw new Error(`Object is not of type ${checkMethod.toString()}`);
+}

package/esm/src/live-query/SubscriptionServer.js

@@ -10,7 +10,7 @@ export class LiveQueryPublisher {
     runPromise(p) { }
     async itemChanged(entityKey, changes) {
         //TODO 2 - optimize so that the user will get their messages first. Based on user id
-        await this.liveQueryStorage().forEach(entityKey, async ({ query: q, setData }) => {
+        await this.runPromise(this.liveQueryStorage().forEach(entityKey, async ({ query: q, setData }) => {
             let query = { ...q.data };
             await this.performWithContext(query.requestJson, entityKey, async (repo) => {
                 const messages = [];
@@ -59,7 +59,7 @@ export class LiveQueryPublisher {
                 if (messages.length > 0)
                     this.subscriptionServer().publishMessage(q.id, messages);
             });
-        });
+        }));
     }
 }
 export class InMemoryLiveQueryStorage {

package/esm/src/remult-static.js

@@ -0,0 +1,43 @@
+const remultStaticKey = Symbol.for('remult-static1');
+let x = {
+    defaultRemultFactory: undefined,
+    remultFactory: undefined,
+    defaultRemult: undefined,
+    asyncContext: undefined,
+    columnsOfType: new Map(),
+    allEntities: [],
+    classHelpers: new Map(),
+    actionInfo: {
+        allActions: [],
+        runningOnServer: false,
+        runActionWithoutBlockingUI: (what) => {
+            return what();
+        },
+        startBusyWithProgress: () => ({
+            progress: (percent) => { },
+            close: () => { },
+        }),
+    },
+    captionTransformer: undefined,
+    defaultDataProvider: () => undefined,
+};
+if ((typeof process !== 'undefined' &&
+    process.env['IGNORE_GLOBAL_REMULT_IN_TESTS']) ||
+    typeof globalThis[remultStaticKey] === 'undefined') {
+    ;
+    globalThis[remultStaticKey] = x;
+    x.remultFactory = () => defaultFactory();
+}
+else {
+    x = globalThis[remultStaticKey];
+}
+export const remultStatic = x;
+export function defaultFactory() {
+    if (!remultStatic.defaultRemult) {
+        remultStatic.defaultRemult = remultStatic.defaultRemultFactory();
+    }
+    return remultStatic.defaultRemult;
+}
+export function resetFactory() {
+    remultStatic.remultFactory = () => defaultFactory();
+}

package/esm/src/remult3/Fields.js

@@ -0,0 +1,335 @@
+import { createId } from '@paralleldrive/cuid2';
+import { v4 as uuid } from 'uuid';
+import { ValueConverters } from '../valueConverters.js';
+import { buildOptions, fieldOptionalValuesFunctionKey, } from './RepositoryImplementation.js';
+import { Validators, createValueValidator, getEnumValues, } from '../validators.js';
+import { relationInfoMemberInOptions } from './relationInfoMember.js';
+import { remultStatic } from '../remult-static.js';
+import { addValidator } from './addValidator.js';
+import { isOfType } from '../isOfType.js';
+const validateNumber = createValueValidator((x) => {
+    return !isNaN(x) && isFinite(x);
+});
+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) {
+        let op = options;
+        if (op.valueConverter && !op.valueConverter.fieldTypeInDb)
+            //@ts-ignore
+            op.valueConverter.fieldTypeInDb = 'json';
+        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,
+            validate: validateNumber,
+        }, ...options);
+    }
+    static autoIncrement(...options) {
+        return Field(() => Number, {
+            allowApiUpdate: false,
+            dbReadOnly: true,
+            valueConverter: {
+                ...ValueConverters.Integer,
+                fieldTypeInDb: 'autoincrement',
+            },
+        }, ...options);
+    }
+    static number(...options) {
+        return Field(() => Number, {
+            validate: validateNumber,
+        }, ...options);
+    }
+    static createdAt(...options) {
+        return Field(() => Date, {
+            allowApiUpdate: false,
+            saving: (_, ref, { isNew }) => {
+                if (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);
+    }
+    /**
+     * A CUID (Collision Resistant Unique Identifier) field.
+     * This id value is determined on the backend on insert, and can't be updated through the API.
+     * The CUID is generated using the `@paralleldrive/cuid2` npm package.
+     */
+    static cuid(...options) {
+        return Field(() => String, {
+            allowApiUpdate: false,
+            defaultValue: () => createId(),
+            saving: (_, r) => {
+                if (!r.value)
+                    r.value = createId();
+            },
+        }, ...options);
+    }
+    // static id<entityType = unknown>(
+    //   options?: FieldOptions<entityType, string> & { idFactory?: () => string },
+    // ): ClassFieldDecorator<entityType, string | undefined> {
+    //   let buildId = options?.idFactory ?? createId
+    //   return Field(() => String, {
+    //     allowApiUpdate: false,
+    //     defaultValue: () => buildId(),
+    //     saving: (_, r) => {
+    //       if (!r.value) r.value = buildId()
+    //     },
+    //   })
+    // }
+    /**
+   * Defines a field that can hold a value from a specified set of string literals.
+   * @param {() => readonly valueType[]} optionalValues - A function that returns an array of allowed string literals.
+   * @returns {ClassFieldDecorator<entityType, valueType | undefined>} - A class field decorator.
+   *
+   * @example
+   
+   * class MyEntity {
+   *   .@Fields.literal(() => ['open', 'closed', 'frozen', 'in progress'] as const)
+   *   status: 'open' | 'closed' | 'frozen' | 'in progress' = 'open';
+   * }
+   
+   *
+   * // This defines a field `status` in `MyEntity` that can only hold the values 'open', 'closed', 'frozen', or 'in progress'.
+   *
+   * @example
+   * // For better reusability and maintainability:
+   
+   * const statuses = ['open', 'closed', 'frozen', 'in progress'] as const;
+   * type StatusType = typeof statuses[number];
+   *
+   * class MyEntity {
+   *   .@Fields.literal(() => statuses)
+   *   status: StatusType = 'open';
+   * }
+   
+   *
+   * // This approach allows easy management and updates of the allowed values for the `status` field.
+   */
+    static literal(optionalValues, ...options) {
+        return Fields.string({
+            validate: (entity, event) => Validators.in(optionalValues())(entity, event),
+            //@ts-expect-error as we are adding this to options without it being defined in options
+            [fieldOptionalValuesFunctionKey]: optionalValues,
+        }, ...options);
+    }
+    static enum(enumType, ...options) {
+        let valueConverter;
+        return Field(
+        //@ts-ignore
+        () => enumType(), {
+            validate: (entity, event) => Validators.enum(enumType())(entity, event),
+            [fieldOptionalValuesFunctionKey]: () => getEnumValues(enumType()),
+        }, ...options, (options) => {
+            ;
+            options[fieldOptionalValuesFunctionKey] = () => getEnumValues(enumType());
+            if (valueConverter === undefined) {
+                let enumObj = enumType();
+                let enumValues = getEnumValues(enumObj);
+                valueConverter = enumValues.find((x) => typeof x === 'string')
+                    ? ValueConverters.String
+                    : ValueConverters.Integer;
+            }
+            if (!options.valueConverter) {
+                options.valueConverter = valueConverter;
+            }
+            else if (!options.valueConverter.fieldTypeInDb) {
+                //@ts-ignore
+                options.valueConverter.fieldTypeInDb = valueConverter.fieldTypeInDb;
+            }
+        });
+    }
+    static string(...options) {
+        return Field(() => String, ...options);
+    }
+    static boolean(...options) {
+        return Field(() => Boolean, ...options);
+    }
+}
+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 }
+            : !options
+                ? {}
+                : options);
+        if (!op.field && !op.fields && !op.findOptions)
+            //@ts-ignore
+            return Field(toEntityType, {
+                ...op,
+                ...relationInfoMemberInOptions(toEntityType, 'reference'),
+            });
+        return Field(() => undefined, {
+            ...op,
+            serverExpression: () => undefined,
+            ...relationInfoMemberInOptions(toEntityType, 'toOne'),
+        });
+    }
+    static toMany(toEntityType, options) {
+        let op = (typeof options === 'string'
+            ? { field: options }
+            : options);
+        return Field(() => undefined, {
+            ...op,
+            serverExpression: () => undefined,
+            ...relationInfoMemberInOptions(toEntityType, '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.required) {
+                r.validate = addValidator(r.validate, Validators.required, true);
+            }
+            if (isOfType(r, 'maxLength')) {
+                let z = r;
+                if (z.maxLength) {
+                    z.validate = addValidator(z.validate, Validators.maxLength(z.maxLength));
+                }
+            }
+            if (isOfType(r, 'minLength')) {
+                let z = r;
+                if (z.minLength) {
+                    z.validate = addValidator(z.validate, Validators.minLength(z.minLength));
+                }
+            }
+            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 =
+                    typeof Reflect.getMetadata == 'function'
+                        ? Reflect.getMetadata('design:type', target, key)
+                        : [];
+                r.valueType = type;
+            }
+            if (!r.target)
+                r.target = target;
+            return r;
+        };
+        checkTarget(target);
+        let names = remultStatic.columnsOfType.get(target.constructor);
+        if (!names) {
+            names = [];
+            remultStatic.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.js

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

package/esm/src/remult3/RepositoryImplementation.js

@@ -937,7 +937,9 @@ export class rowHelperImplementation extends rowHelperBase {
             if (this.wasDeleted())
                 throw new Error('cannot save a deleted row');
             this.isLoading = true;
-            if (onlyTheseFieldsSentOnlyInTheCaseOfProxySaveWithPartialObject === undefined) // no need
+            if (onlyTheseFieldsSentOnlyInTheCaseOfProxySaveWithPartialObject ===
+                undefined)
+                // no need
                 await this.__validateEntity();
             let doNotSave = false;
             for (const col of this.fields) {
@@ -952,7 +954,8 @@ export class rowHelperImplementation extends rowHelperBase {
             let ignoreKeys = [];
             for (const field of this.metadata.fields) {
                 if (field.dbReadOnly ||
-                    (onlyTheseFieldsSentOnlyInTheCaseOfProxySaveWithPartialObject !== undefined &&
+                    (onlyTheseFieldsSentOnlyInTheCaseOfProxySaveWithPartialObject !==
+                        undefined &&
                         !onlyTheseFieldsSentOnlyInTheCaseOfProxySaveWithPartialObject.includes(field.key))) {
                     d[field.key] = undefined;
                     ignoreKeys.push(field.key);
@@ -998,7 +1001,7 @@ export class rowHelperImplementation extends rowHelperBase {
                     for (const listener of this.repository.listeners.filter((x) => x.saved)) {
                         await listener.saved(this.instance, isNew);
                     }
-                await this.repository.remult.liveQueryPublisher.itemChanged(this.repository.metadata.key, [{ id: this.getId(), oldId: this.getOriginalId(), deleted: false }]);
+                this.repository.remult.liveQueryPublisher.itemChanged(this.repository.metadata.key, [{ id: this.getId(), oldId: this.getOriginalId(), deleted: false }]);
                 this.saveOriginalData();
                 this._isNew = false;
                 return this.instance;
@@ -1029,7 +1032,7 @@ export class rowHelperImplementation extends rowHelperBase {
                 for (const listener of this.repository.listeners.filter((x) => x.deleted)) {
                     await listener.deleted(this.instance);
                 }
-            await this.repository.remult.liveQueryPublisher.itemChanged(this.repository.metadata.key, [{ id: this.getId(), oldId: this.getOriginalId(), deleted: true }]);
+            this.repository.remult.liveQueryPublisher.itemChanged(this.repository.metadata.key, [{ id: this.getId(), oldId: this.getOriginalId(), deleted: true }]);
             this._wasDeleted = true;
         }
         catch (err) {

package/esm/src/remult3/__updateEntityBasedOnWhere.js

@@ -0,0 +1,28 @@
+import { Filter } from '../filter/filter-interfaces.js';
+export function __updateEntityBasedOnWhere(entityDefs, where, r) {
+    let w = Filter.fromEntityFilter(entityDefs, where);
+    const emptyFunction = () => { };
+    if (w) {
+        w.__applyToConsumer({
+            custom: emptyFunction,
+            databaseCustom: emptyFunction,
+            containsCaseInsensitive: emptyFunction,
+            notContainsCaseInsensitive: emptyFunction,
+            startsWithCaseInsensitive: emptyFunction,
+            endsWithCaseInsensitive: emptyFunction,
+            isDifferentFrom: emptyFunction,
+            isEqualTo: (col, val) => {
+                r[col.key] = val;
+            },
+            isGreaterOrEqualTo: emptyFunction,
+            isGreaterThan: emptyFunction,
+            isIn: emptyFunction,
+            isLessOrEqualTo: emptyFunction,
+            isLessThan: emptyFunction,
+            isNotNull: emptyFunction,
+            isNull: emptyFunction,
+            not: emptyFunction,
+            or: emptyFunction,
+        });
+    }
+}

package/esm/src/remult3/addValidator.js

@@ -0,0 +1,15 @@
+export function addValidator(validators, newValidator, atStart = false) {
+    if (!newValidator)
+        return validators;
+    const newValidators = Array.isArray(newValidator)
+        ? newValidator
+        : [newValidator];
+    const validatorsArray = Array.isArray(validators)
+        ? validators
+        : validators
+            ? [validators]
+            : [];
+    return atStart
+        ? [...newValidators, ...validatorsArray]
+        : [...validatorsArray, ...newValidators];
+}

package/esm/{core/src/remult3/DecoratorReplacer.js → src/remult3/classDescribers.js}

@@ -1,6 +1,8 @@
-export function describeClass(classType, classDecorator, members, staticMembers) {
-    if (classDecorator)
-        classDecorator(classType);
+import { BackendMethod } from '../server-action.js';
+import { Entity } from './entity.js';
+export function describeClass(classType, classDescriber, members, staticMembers) {
+    if (classDescriber)
+        classDescriber(classType);
     for (const fieldKey in members) {
         if (Object.prototype.hasOwnProperty.call(members, fieldKey)) {
             const element = members[fieldKey];
@@ -18,3 +20,16 @@ export function describeClass(classType, classDecorator, members, staticMembers)
             Object.defineProperty(classType, staticFieldKey, prop);
     }
 }
+export function describeBackendMethods(classType, backendMethods) {
+    let result = {};
+    for (const key in backendMethods) {
+        if (Object.prototype.hasOwnProperty.call(backendMethods, key)) {
+            const options = backendMethods[key];
+            result[key] = BackendMethod(options);
+        }
+    }
+    describeClass(classType, undefined, undefined, result);
+}
+export function describeEntity(classType, key, fields, options) {
+    describeClass(classType, Entity(key, options), fields);
+}