remult 0.22.2 → 0.22.3

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

@@ -1,477 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,188 +0,0 @@
-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

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