remult 0.22.3 → 0.22.5

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

@@ -0,0 +1,477 @@
+import { getEntityRef, getEntitySettings } from "../remult3";
+export class Filter {
+    apply;
+    constructor(apply) {
+        this.apply = apply;
+        if (!this.apply) {
+            this.apply = () => { };
+        }
+    }
+    __applyToConsumer(add) {
+        this.apply(add);
+    }
+    static async resolve(filter) {
+        if (typeof filter === "function")
+            return await filter();
+        return filter;
+    }
+    static createCustom(rawFilterTranslator, key = '') {
+        let rawFilterInfo = { key: key, rawFilterTranslator };
+        return Object.assign((x) => {
+            let z = {};
+            if (x == undefined)
+                x = {};
+            if (!rawFilterInfo.key)
+                throw "Usage of custom filter before a key was assigned to it";
+            return {
+                [customUrlToken + rawFilterInfo.key]: x
+            };
+        }, { rawFilterInfo });
+    }
+    static fromEntityFilter(entity, whereItem) {
+        let result = [];
+        for (const key in whereItem) {
+            if (Object.prototype.hasOwnProperty.call(whereItem, key)) {
+                let fieldToFilter = whereItem[key];
+                {
+                    if (key == "$or") {
+                        result.push(new OrFilter(...fieldToFilter.map(x => Filter.fromEntityFilter(entity, x))));
+                    }
+                    else if (key == "$and") {
+                        result.push(new AndFilter(...fieldToFilter.map(x => Filter.fromEntityFilter(entity, x))));
+                    }
+                    else if (key.startsWith(customUrlToken)) {
+                        result.push(new Filter(x => {
+                            x.custom(key.substring(customUrlToken.length), fieldToFilter);
+                        }));
+                    }
+                    else if (key == customDatabaseFilterToken) {
+                        result.push(new Filter(x => x.databaseCustom(fieldToFilter)));
+                    }
+                    else {
+                        let fh = new filterHelper(entity.fields[key]);
+                        let found = false;
+                        if (fieldToFilter !== undefined && fieldToFilter != null) {
+                            if (fieldToFilter.$id)
+                                fieldToFilter = fieldToFilter.$id;
+                            for (const key in fieldToFilter) {
+                                if (Object.prototype.hasOwnProperty.call(fieldToFilter, key)) {
+                                    const element = fieldToFilter[key];
+                                    switch (key) {
+                                        case "$gte":
+                                        case ">=":
+                                            result.push(fh.isGreaterOrEqualTo(element));
+                                            found = true;
+                                            break;
+                                        case "$gt":
+                                        case ">":
+                                            result.push(fh.isGreaterThan(element));
+                                            found = true;
+                                            break;
+                                        case "$lte":
+                                        case "<=":
+                                            result.push(fh.isLessOrEqualTo(element));
+                                            found = true;
+                                            break;
+                                        case "$lt":
+                                        case "<":
+                                            result.push(fh.isLessThan(element));
+                                            found = true;
+                                            break;
+                                        case "$ne":
+                                        case "!=":
+                                        case "$nin":
+                                            found = true;
+                                            if (Array.isArray(element)) {
+                                                result.push(fh.isNotIn(element));
+                                            }
+                                            else
+                                                result.push(fh.isDifferentFrom(element));
+                                            break;
+                                        case "$in":
+                                            found = true;
+                                            result.push(fh.isIn(element));
+                                            break;
+                                        case "$contains":
+                                            found = true;
+                                            result.push(fh.contains(element));
+                                            break;
+                                    }
+                                }
+                            }
+                            if (Array.isArray(fieldToFilter)) {
+                                found = true;
+                                result.push(fh.isIn(fieldToFilter));
+                            }
+                        }
+                        if (!found && fieldToFilter !== undefined) {
+                            result.push(fh.isEqualTo(fieldToFilter));
+                        }
+                    }
+                }
+            }
+        }
+        return new AndFilter(...result);
+    }
+    toJson() {
+        let r = new FilterSerializer();
+        this.__applyToConsumer(r);
+        return r.result;
+    }
+    static entityFilterToJson(entityDefs, where) {
+        return Filter.fromEntityFilter(entityDefs, where).toJson();
+    }
+    static entityFilterFromJson(entityDefs, packed) {
+        return buildFilterFromRequestParameters(entityDefs, { get: (key) => packed[key] });
+    }
+    static async translateCustomWhere(r, entity, remult) {
+        let f = new customTranslator(async (filterKey, custom) => {
+            let r = [];
+            for (const key in entity.entityType) {
+                const element = entity.entityType[key];
+                if (element && element.rawFilterInfo && element.rawFilterInfo.rawFilterTranslator) {
+                    if (element.rawFilterInfo.key == filterKey) {
+                        r.push(await Filter.fromEntityFilter(entity, await element.rawFilterInfo.rawFilterTranslator(custom, remult)));
+                    }
+                }
+            }
+            return r;
+        });
+        r.__applyToConsumer(f);
+        await f.resolve();
+        r = new Filter(x => f.applyTo(x));
+        return r;
+    }
+}
+export class filterHelper {
+    metadata;
+    constructor(metadata) {
+        this.metadata = metadata;
+    }
+    processVal(val) {
+        let ei = getEntitySettings(this.metadata.valueType, false);
+        if (ei) {
+            if (!val)
+                return null;
+            if (typeof val === "string" || typeof val === "number")
+                return val;
+            return getEntityRef(val).getId();
+        }
+        return val;
+    }
+    contains(val) {
+        return new Filter(add => add.containsCaseInsensitive(this.metadata, val));
+    }
+    isLessThan(val) {
+        val = this.processVal(val);
+        return new Filter(add => add.isLessThan(this.metadata, val));
+    }
+    isGreaterOrEqualTo(val) {
+        val = this.processVal(val);
+        return new Filter(add => add.isGreaterOrEqualTo(this.metadata, val));
+    }
+    isNotIn(values) {
+        return new Filter(add => {
+            for (const v of values) {
+                add.isDifferentFrom(this.metadata, this.processVal(v));
+            }
+        });
+    }
+    isDifferentFrom(val) {
+        val = this.processVal(val);
+        if ((val === null || val === undefined) && this.metadata.allowNull)
+            return new Filter(add => add.isNotNull(this.metadata));
+        return new Filter(add => add.isDifferentFrom(this.metadata, val));
+    }
+    isLessOrEqualTo(val) {
+        val = this.processVal(val);
+        return new Filter(add => add.isLessOrEqualTo(this.metadata, val));
+    }
+    isGreaterThan(val) {
+        val = this.processVal(val);
+        return new Filter(add => add.isGreaterThan(this.metadata, val));
+    }
+    isEqualTo(val) {
+        val = this.processVal(val);
+        if ((val === null || val === undefined) && this.metadata.allowNull)
+            return new Filter(add => add.isNull(this.metadata));
+        return new Filter(add => add.isEqualTo(this.metadata, val));
+    }
+    isIn(val) {
+        val = val.map(x => this.processVal(x));
+        return new Filter(add => add.isIn(this.metadata, val));
+    }
+}
+export class AndFilter extends Filter {
+    filters;
+    constructor(...filters) {
+        super(add => {
+            for (const iterator of this.filters) {
+                if (iterator)
+                    iterator.__applyToConsumer(add);
+            }
+        });
+        this.filters = filters;
+    }
+    add(filter) {
+        this.filters.push(filter);
+    }
+}
+export class OrFilter extends Filter {
+    filters;
+    constructor(...filters) {
+        super(add => {
+            let f = this.filters.filter(x => x !== undefined);
+            if (f.length > 1) {
+                add.or(f);
+            }
+            else if (f.length == 1)
+                f[0].__applyToConsumer(add);
+        });
+        this.filters = filters;
+    }
+}
+export const customUrlToken = "$custom$";
+export const customDatabaseFilterToken = "$db$";
+export class FilterSerializer {
+    result = {};
+    constructor() {
+    }
+    databaseCustom(databaseCustom) {
+        throw new Error("database custom is not allowed with api calls.");
+    }
+    custom(key, customItem) {
+        this.add(customUrlToken + key, customItem);
+    }
+    hasUndefined = false;
+    add(key, val) {
+        if (val === undefined)
+            this.hasUndefined = true;
+        let r = this.result;
+        if (!r[key]) {
+            r[key] = val;
+            return;
+        }
+        let v = r[key];
+        if (v instanceof Array) {
+            v.push(val);
+        }
+        else
+            v = [v, val];
+        r[key] = v;
+    }
+    or(orElements) {
+        this.add("OR", orElements.map(x => {
+            let f = new FilterSerializer();
+            x.__applyToConsumer(f);
+            return f.result;
+        }));
+    }
+    isNull(col) {
+        this.add(col.key + ".null", true);
+    }
+    isNotNull(col) {
+        this.add(col.key + ".null", false);
+    }
+    isIn(col, val) {
+        this.add(col.key + ".in", val.map(x => col.valueConverter.toJson(x)));
+    }
+    isEqualTo(col, val) {
+        this.add(col.key, col.valueConverter.toJson(val));
+    }
+    isDifferentFrom(col, val) {
+        this.add(col.key + '.ne', col.valueConverter.toJson(val));
+    }
+    isGreaterOrEqualTo(col, val) {
+        this.add(col.key + '.gte', col.valueConverter.toJson(val));
+    }
+    isGreaterThan(col, val) {
+        this.add(col.key + '.gt', col.valueConverter.toJson(val));
+    }
+    isLessOrEqualTo(col, val) {
+        this.add(col.key + '.lte', col.valueConverter.toJson(val));
+    }
+    isLessThan(col, val) {
+        this.add(col.key + '.lt', col.valueConverter.toJson(val));
+    }
+    containsCaseInsensitive(col, val) {
+        this.add(col.key + ".contains", val);
+    }
+}
+export function entityFilterToJson(entityDefs, where) {
+    if (!where)
+        return {};
+    return (Filter.fromEntityFilter(entityDefs, where)).toJson();
+}
+export function buildFilterFromRequestParameters(entity, filterInfo) {
+    let where = [];
+    [...entity.fields].forEach(col => {
+        function addFilter(operation, theFilter, jsonArray = false, asString = false) {
+            let val = filterInfo.get(col.key + operation);
+            if (val !== undefined) {
+                let addFilter = (val) => {
+                    let theVal = val;
+                    if (jsonArray) {
+                        let arr;
+                        if (typeof val === 'string')
+                            arr = JSON.parse(val);
+                        else
+                            arr = val;
+                        theVal = arr.map(x => asString ? x : col.valueConverter.fromJson(x));
+                    }
+                    else {
+                        theVal = asString ? theVal : col.valueConverter.fromJson(theVal);
+                    }
+                    let f = theFilter(theVal);
+                    if (f !== undefined) {
+                        where.push({ [col.key]: f });
+                    }
+                };
+                if (!jsonArray && val instanceof Array) {
+                    val.forEach(v => {
+                        addFilter(v);
+                    });
+                }
+                else {
+                    if (jsonArray) {
+                        if (typeof val === 'string')
+                            val = JSON.parse(val);
+                    }
+                    const array = separateArrayFromInnerArray(val);
+                    for (const x of array) {
+                        addFilter(x);
+                    }
+                }
+            }
+        }
+        let c = new filterHelper(col);
+        addFilter('', val => val);
+        addFilter('.gt', val => ({ "$gt": val }));
+        addFilter('.gte', val => ({ "$gte": val }));
+        addFilter('.lt', val => ({ "$lt": val }));
+        addFilter('.lte', val => ({ "$lte": val }));
+        addFilter('.ne', val => ({ "$ne": val }));
+        addFilter('.in', val => val, true);
+        var nullFilter = filterInfo.get(col.key + ".null");
+        if (nullFilter) {
+            nullFilter = nullFilter.toString().trim().toLowerCase();
+            switch (nullFilter) {
+                case "y":
+                case "true":
+                case "yes":
+                    where.push({ [col.key]: null });
+                    break;
+                default:
+                    where.push({ [col.key]: { "$ne": null } });
+                    break;
+            }
+        }
+        addFilter('.contains', val => ({ $contains: val }), false, true);
+    });
+    let val = filterInfo.get('OR');
+    if (val) {
+        const array = separateArrayFromInnerArray(val);
+        where.push({
+            $and: array.map(v => ({
+                $or: v.map(x => buildFilterFromRequestParameters(entity, { get: (key) => x[key] }))
+            }))
+        });
+    }
+    for (const key in entity.entityType) {
+        const element = entity.entityType[key];
+        if (element && element.rawFilterInfo && element.rawFilterInfo.rawFilterTranslator) {
+            let custom = filterInfo.get(customUrlToken + key);
+            if (custom !== undefined) {
+                where.push({ [customUrlToken + key]: custom });
+            }
+        }
+    }
+    return { $and: where };
+    function separateArrayFromInnerArray(val) {
+        if (!Array.isArray(val))
+            return [val];
+        const nonArray = [], array = [];
+        for (const v of val) {
+            if (Array.isArray(v)) {
+                array.push(v);
+            }
+            else
+                nonArray.push(v);
+        }
+        array.push(nonArray);
+        return array;
+    }
+}
+class customTranslator {
+    translateCustom;
+    applyTo(x) {
+        this.commands.forEach(y => y(x));
+    }
+    constructor(translateCustom) {
+        this.translateCustom = translateCustom;
+    }
+    commands = [];
+    promises = [];
+    or(orElements) {
+        let newOrElements;
+        this.promises.push(Promise.all(orElements.map(async (element) => {
+            let c = new customTranslator(this.translateCustom);
+            element.__applyToConsumer(c);
+            await c.resolve();
+            return new Filter(x => c.applyTo(x));
+        })).then(x => {
+            newOrElements = x;
+        }));
+        this.commands.push(x => x.or(newOrElements));
+    }
+    isEqualTo(col, val) {
+        this.commands.push(x => x.isEqualTo(col, val));
+    }
+    isDifferentFrom(col, val) {
+        this.commands.push(x => x.isDifferentFrom(col, val));
+    }
+    isNull(col) {
+        this.commands.push(x => x.isNull(col));
+    }
+    isNotNull(col) {
+        this.commands.push(x => x.isNotNull(col));
+    }
+    isGreaterOrEqualTo(col, val) {
+        this.commands.push(x => x.isGreaterOrEqualTo(col, val));
+    }
+    isGreaterThan(col, val) {
+        this.commands.push(x => x.isGreaterThan(col, val));
+    }
+    isLessOrEqualTo(col, val) {
+        this.commands.push(x => x.isLessOrEqualTo(col, val));
+    }
+    isLessThan(col, val) {
+        this.commands.push(x => x.isLessThan(col, val));
+    }
+    containsCaseInsensitive(col, val) {
+        this.commands.push(x => x.containsCaseInsensitive(col, val));
+    }
+    isIn(col, val) {
+        this.commands.push(x => x.isIn(col, val));
+    }
+    custom(key, customItem) {
+        this.promises.push((async () => {
+            let r = await this.translateCustom(key, customItem);
+            if (r)
+                if (Array.isArray(r))
+                    r.forEach(x => x.__applyToConsumer(this));
+                else
+                    r.__applyToConsumer(this);
+        })());
+    }
+    databaseCustom(custom) {
+        this.commands.push(x => x.databaseCustom(custom));
+    }
+    async resolve() {
+        while (this.promises.length > 0) {
+            let p = this.promises;
+            this.promises = [];
+            await Promise.all(p);
+        }
+    }
+}

package/esm/core/src/live-query/LiveQueryClient.d.ts

@@ -0,0 +1,20 @@
+import { FindOptions } from '../../index';
+import type { LiveQueryChangeInfo, RepositoryImplementation } from '../remult3';
+import { SubscriptionClientConnection, Unsubscribe, SubscriptionListener } from './SubscriptionChannel';
+import type { ApiClient } from '../../index';
+export declare class LiveQueryClient {
+    private apiProvider;
+    private getUserId;
+    wrapMessageHandling(handleMessage: any): void;
+    private queries;
+    private channels;
+    constructor(apiProvider: () => ApiClient, getUserId: () => string);
+    runPromise<X>(p: Promise<X>): Promise<X>;
+    close(): void;
+    subscribeChannel<T>(key: string, onResult: SubscriptionListener<T>): Promise<Unsubscribe>;
+    private closeIfNoListeners;
+    subscribe<entityType>(repo: RepositoryImplementation<entityType>, options: FindOptions<entityType>, listener: SubscriptionListener<LiveQueryChangeInfo<entityType>>): () => void;
+    client: Promise<SubscriptionClientConnection>;
+    interval: any;
+    private openIfNoOpened;
+}

package/esm/core/src/live-query/LiveQueryClient.js

@@ -0,0 +1,188 @@
+import { RestDataProvider } from '../data-providers/rest-data-provider';
+import { buildRestDataProvider } from "../buildRestDataProvider";
+import { LiveQuerySubscriber, liveQueryKeepAliveRoute } from './SubscriptionChannel';
+/* @internal*/
+export class LiveQueryClient {
+    apiProvider;
+    getUserId;
+    wrapMessageHandling(handleMessage) {
+        var x = this.apiProvider().wrapMessageHandling;
+        if (x)
+            x(handleMessage);
+        else
+            handleMessage();
+    }
+    ;
+    queries = new Map();
+    channels = new Map();
+    constructor(apiProvider, getUserId) {
+        this.apiProvider = apiProvider;
+        this.getUserId = getUserId;
+    }
+    runPromise(p) {
+        return p;
+    }
+    close() {
+        this.queries.clear();
+        this.channels.clear();
+        this.closeIfNoListeners();
+    }
+    async subscribeChannel(key, onResult) {
+        let onUnsubscribe = () => { };
+        const client = await this.openIfNoOpened();
+        try {
+            let q = this.channels.get(key);
+            if (!q) {
+                this.channels.set(key, q = new MessageChannel());
+                try {
+                    q.unsubscribe = await client.subscribe(key, value => this.wrapMessageHandling(() => q.handle(value)), err => {
+                        onResult.error(err);
+                    });
+                }
+                catch (err) {
+                    onResult.error(err);
+                    throw err;
+                }
+            }
+            q.listeners.push(onResult);
+            onUnsubscribe = () => {
+                q.listeners.splice(q.listeners.indexOf(onResult), 1);
+                if (q.listeners.length == 0) {
+                    this.channels.delete(key);
+                    q.unsubscribe();
+                }
+                this.closeIfNoListeners();
+            };
+        }
+        catch (err) {
+            onResult.error(err);
+            throw err;
+        }
+        return () => {
+            onUnsubscribe();
+            onUnsubscribe = () => { };
+        };
+    }
+    closeIfNoListeners() {
+        if (this.client)
+            if (this.queries.size === 0 && this.channels.size === 0) {
+                this.runPromise(this.client.then(x => x.close()));
+                this.client = undefined;
+                clearInterval(this.interval);
+                this.interval = undefined;
+            }
+    }
+    subscribe(repo, options, listener) {
+        let alive = true;
+        let onUnsubscribe = () => { alive = false; };
+        this.runPromise(repo.buildEntityDataProviderFindOptions(options)
+            .then(opts => {
+            if (!alive)
+                return;
+            const { createKey, subscribe } = new RestDataProvider(this.apiProvider).getEntityDataProvider(repo.metadata).buildFindRequest(opts);
+            const eventTypeKey = createKey();
+            let q = this.queries.get(eventTypeKey);
+            if (!q) {
+                this.queries.set(eventTypeKey, q = new LiveQuerySubscriber(repo, { entityKey: repo.metadata.key, options }, this.getUserId()));
+                q.subscribeCode = () => {
+                    if (q.unsubscribe) {
+                        q.unsubscribe();
+                        q.unsubscribe = () => { };
+                    }
+                    this.runPromise(this.subscribeChannel(q.queryChannel, {
+                        next: (value) => this.runPromise(q.handle(value)),
+                        complete: () => { },
+                        error: er => {
+                            q.listeners.forEach(l => l.error(er));
+                        }
+                    }).then(unsubscribeToChannel => {
+                        if (q.listeners.length == 0) {
+                            unsubscribeToChannel();
+                            return;
+                        }
+                        this.runPromise(subscribe(q.id)
+                            .then(r => {
+                            if (q.listeners.length === 0) {
+                                r.unsubscribe();
+                                unsubscribeToChannel();
+                                return;
+                            }
+                            this.runPromise(q.setAllItems(r.result));
+                            q.unsubscribe = () => {
+                                q.unsubscribe = () => { };
+                                unsubscribeToChannel();
+                                this.runPromise(r.unsubscribe());
+                            };
+                        })
+                            .catch(err => {
+                            listener.error(err);
+                        }));
+                    })).catch(err => {
+                        q.listeners.forEach(l => l.error(err));
+                    });
+                };
+                q.subscribeCode();
+            }
+            else {
+                q.sendDefaultState(listener.next);
+            }
+            q.listeners.push(listener);
+            onUnsubscribe = () => {
+                q.listeners.splice(q.listeners.indexOf(listener), 1);
+                listener.complete();
+                if (q.listeners.length == 0) {
+                    this.queries.delete(eventTypeKey);
+                    q.unsubscribe();
+                }
+                this.closeIfNoListeners();
+            };
+        })
+            .catch(err => {
+            listener.error(err);
+        }));
+        return () => {
+            onUnsubscribe();
+        };
+    }
+    client;
+    interval;
+    openIfNoOpened() {
+        if (!this.client) {
+            this.interval = setInterval(async () => {
+                const ids = [];
+                for (const q of this.queries.values()) {
+                    ids.push(q.queryChannel);
+                }
+                if (ids.length > 0) {
+                    let p = this.apiProvider();
+                    let { actionInfo } = await import('../server-action');
+                    const invalidIds = await this.runPromise(await actionInfo.runActionWithoutBlockingUI(() => buildRestDataProvider(p.httpClient).post(p.url + '/' + liveQueryKeepAliveRoute, ids)));
+                    for (const id of invalidIds) {
+                        for (const q of this.queries.values()) {
+                            if (q.queryChannel === id)
+                                q.subscribeCode();
+                        }
+                    }
+                }
+            }, 30000);
+            return this.runPromise(this.client =
+                this.apiProvider().subscriptionClient.openConnection(() => {
+                    for (const q of this.queries.values()) {
+                        q.subscribeCode();
+                    }
+                }));
+        }
+        return this.client;
+    }
+}
+class MessageChannel {
+    id;
+    unsubscribe = () => { };
+    async handle(message) {
+        for (const l of this.listeners) {
+            l.next(message);
+        }
+    }
+    listeners = [];
+    constructor() { }
+}

package/esm/core/src/live-query/SseSubscriptionClient.d.ts

@@ -0,0 +1,5 @@
+import { SubscriptionClient, SubscriptionClientConnection } from "./SubscriptionChannel";
+export declare class SseSubscriptionClient implements SubscriptionClient {
+    openConnection(onReconnect: VoidFunction): Promise<SubscriptionClientConnection>;
+}
+export declare const ConnectionNotFoundError = "client connection not found";