remult 0.22.2 → 0.22.3

package/esm/core/src/data-providers/array-entity-data-provider.js

@@ -1,252 +0,0 @@
-import { customDatabaseFilterToken, Filter } from '../filter/filter-interfaces';
-import { CompoundIdField } from '../column';
-export class ArrayEntityDataProvider {
-    entity;
-    rows;
-    static rawFilter(filter) {
-        return {
-            [customDatabaseFilterToken]: {
-                arrayFilter: filter
-            }
-        };
-    }
-    constructor(entity, rows) {
-        this.entity = entity;
-        this.rows = rows;
-        if (!rows)
-            rows = [];
-        else {
-            for (const r of rows) {
-                this.verifyThatRowHasAllNotNullColumns(r);
-            }
-        }
-    }
-    verifyThatRowHasAllNotNullColumns(r) {
-        for (const f of this.entity.fields) {
-            if (!f.isServerExpression)
-                if (!f.allowNull) {
-                    if (r[f.key] === undefined || r[f.key] === null) {
-                        let val = undefined;
-                        if (f.valueType === Boolean)
-                            val = false;
-                        else if (f.valueType === Number)
-                            val = 0;
-                        else if (f.valueType === String)
-                            val = '';
-                        r[f.key] = val;
-                    }
-                }
-                else if (r[f.key] === undefined)
-                    r[f.key] = null;
-        }
-    }
-    async count(where) {
-        let rows = this.rows;
-        let j = 0;
-        for (let i = 0; i < rows.length; i++) {
-            if (!where) {
-                j++;
-            }
-            else {
-                let x = new FilterConsumerBridgeToObject(rows[i]);
-                where.__applyToConsumer(x);
-                if (x.ok)
-                    j++;
-            }
-        }
-        return j;
-    }
-    async find(options) {
-        let rows = this.rows;
-        if (options) {
-            if (options.where) {
-                rows = rows.filter(i => {
-                    let x = new FilterConsumerBridgeToObject(i);
-                    options.where.__applyToConsumer(x);
-                    return x.ok;
-                });
-            }
-            if (options.orderBy) {
-                rows = rows.sort((a, b) => {
-                    return options.orderBy.compare(a, b);
-                });
-            }
-            rows = pageArray(rows, options);
-        }
-        if (rows)
-            return rows.map(i => {
-                return this.translateFromJson(i);
-            });
-    }
-    translateFromJson(row) {
-        let result = {};
-        for (const col of this.entity.fields) {
-            result[col.key] = col.valueConverter.fromJson(row[col.key]);
-        }
-        return result;
-    }
-    translateToJson(row) {
-        let result = {};
-        for (const col of this.entity.fields) {
-            result[col.key] = col.valueConverter.toJson(row[col.key]);
-        }
-        return result;
-    }
-    idMatches(id) {
-        return item => {
-            let x = new FilterConsumerBridgeToObject(item);
-            Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(x);
-            return x.ok;
-        };
-    }
-    update(id, data) {
-        let idMatches = this.idMatches(id);
-        let keys = Object.keys(data);
-        for (let i = 0; i < this.rows.length; i++) {
-            let r = this.rows[i];
-            if (idMatches(r)) {
-                let newR = { ...r };
-                for (const f of this.entity.fields) {
-                    if (!f.dbReadOnly && !f.isServerExpression) {
-                        if (keys.includes(f.key)) {
-                            newR[f.key] = f.valueConverter.toJson(data[f.key]);
-                        }
-                    }
-                }
-                this.verifyThatRowHasAllNotNullColumns(newR);
-                this.rows[i] = newR;
-                return Promise.resolve(this.translateFromJson(this.rows[i]));
-            }
-        }
-        throw new Error("couldn't find id to update: " + id);
-    }
-    delete(id) {
-        let idMatches = this.idMatches(id);
-        for (let i = 0; i < this.rows.length; i++) {
-            if (idMatches(this.rows[i])) {
-                this.rows.splice(i, 1);
-                return Promise.resolve();
-            }
-        }
-        throw new Error("couldn't find id to delete: " + id);
-    }
-    async insert(data) {
-        let idf = this.entity.idMetadata.field;
-        if (!(idf instanceof CompoundIdField)) {
-            if (idf.options.valueConverter?.fieldTypeInDb === 'autoincrement') {
-                data[idf.key] = 1;
-                for (const row of this.rows) {
-                    if (row[idf.key] >= data[idf.key])
-                        data[idf.key] = row[idf.key] + 1;
-                }
-            }
-            if (data[idf.key])
-                this.rows.forEach(i => {
-                    if (data[idf.key] == i[idf.key])
-                        throw Error("id already exists");
-                });
-        }
-        let j = this.translateToJson(data);
-        this.verifyThatRowHasAllNotNullColumns(j);
-        this.rows.push(j);
-        return Promise.resolve(this.translateFromJson(j));
-    }
-}
-function pageArray(rows, options) {
-    if (!options)
-        return rows;
-    if (!options.limit)
-        return rows;
-    let page = 1;
-    if (options.page)
-        page = options.page;
-    if (page < 1)
-        page = 1;
-    let x = 0;
-    return rows.filter(i => {
-        x++;
-        let max = page * options.limit;
-        let min = max - options.limit;
-        return x > min && x <= max;
-    });
-}
-class FilterConsumerBridgeToObject {
-    row;
-    ok = true;
-    constructor(row) {
-        this.row = row;
-    }
-    databaseCustom(databaseCustom) {
-        if (databaseCustom && databaseCustom.arrayFilter) {
-            if (!databaseCustom.arrayFilter(this.row))
-                this.ok = false;
-        }
-    }
-    custom(key, customItem) {
-        throw new Error('Custom Filter should be translated before it gets here');
-    }
-    or(orElements) {
-        for (const element of orElements) {
-            let filter = new FilterConsumerBridgeToObject(this.row);
-            element.__applyToConsumer(filter);
-            if (filter.ok) {
-                return;
-            }
-        }
-        this.ok = false;
-    }
-    isNull(col) {
-        if (this.row[col.key] != null)
-            this.ok = false;
-    }
-    isNotNull(col) {
-        if (this.row[col.key] == null)
-            this.ok = false;
-    }
-    isIn(col, val) {
-        for (const v of val) {
-            if (this.row[col.key] == col.valueConverter.toJson(v)) {
-                return;
-            }
-        }
-        this.ok = false;
-    }
-    isEqualTo(col, val) {
-        if (this.row[col.key] != col.valueConverter.toJson(val))
-            this.ok = false;
-    }
-    isDifferentFrom(col, val) {
-        if (this.row[col.key] == col.valueConverter.toJson(val))
-            this.ok = false;
-    }
-    isGreaterOrEqualTo(col, val) {
-        if (this.row[col.key] < col.valueConverter.toJson(val))
-            this.ok = false;
-    }
-    isGreaterThan(col, val) {
-        if (this.row[col.key] <= col.valueConverter.toJson(val))
-            this.ok = false;
-    }
-    isLessOrEqualTo(col, val) {
-        if (this.row[col.key] > col.valueConverter.toJson(val))
-            this.ok = false;
-    }
-    isLessThan(col, val) {
-        if (this.row[col.key] >= col.valueConverter.toJson(val))
-            this.ok = false;
-    }
-    containsCaseInsensitive(col, val) {
-        let v = this.row[col.key];
-        if (!v) {
-            this.ok = false;
-            return;
-        }
-        let s = '' + v;
-        if (val)
-            val = col.valueConverter.toJson(val);
-        if (val)
-            val = val.toString().toLowerCase();
-        if (s.toLowerCase().indexOf(val) < 0)
-            this.ok = false;
-    }
-}

package/esm/core/src/data-providers/in-memory-database.d.ts

@@ -1,9 +0,0 @@
-import { DataProvider, EntityDataProvider } from '../data-interfaces';
-import { __RowsOfDataForTesting } from "../__RowsOfDataForTesting";
-import { EntityMetadata } from '../remult3';
-export declare class InMemoryDataProvider implements DataProvider, __RowsOfDataForTesting {
-    transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-    rows: any;
-    getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
-    toString(): string;
-}

package/esm/core/src/data-providers/in-memory-database.js

@@ -1,14 +0,0 @@
-import { ArrayEntityDataProvider } from './array-entity-data-provider';
-export class InMemoryDataProvider {
-    async transaction(action) {
-        await action(this);
-    }
-    rows = {};
-    getEntityDataProvider(entity) {
-        let name = entity.key;
-        if (!this.rows[name])
-            this.rows[name] = [];
-        return new ArrayEntityDataProvider(entity, this.rows[name]);
-    }
-    toString() { return "InMemoryDataProvider"; }
-}

package/esm/core/src/data-providers/json-data-provider.d.ts

@@ -1,12 +0,0 @@
-import { EntityDataProvider, DataProvider } from '../data-interfaces';
-import { EntityMetadata } from '../remult3';
-export interface JsonEntityStorage {
-    getItem(entityDbName: string): string | null;
-    setItem(entityDbName: string, json: string): any;
-}
-export declare class JsonDataProvider implements DataProvider {
-    private storage;
-    constructor(storage: JsonEntityStorage);
-    getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
-    transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-}

package/esm/core/src/data-providers/json-data-provider.js

@@ -1,55 +0,0 @@
-import { ArrayEntityDataProvider } from './array-entity-data-provider';
-export class JsonDataProvider {
-    storage;
-    constructor(storage) {
-        this.storage = storage;
-    }
-    getEntityDataProvider(entity) {
-        return new JsonEntityDataProvider(entity, this.storage);
-    }
-    async transaction(action) {
-        await action(this);
-    }
-}
-class JsonEntityDataProvider {
-    entity;
-    helper;
-    constructor(entity, helper) {
-        this.entity = entity;
-        this.helper = helper;
-    }
-    async loadEntityData(what) {
-        let data = [];
-        let dbName = await this.entity.getDbName();
-        let s = this.helper.getItem(dbName);
-        if (s)
-            data = JSON.parse(s);
-        let dp = new ArrayEntityDataProvider(this.entity, data);
-        return what(dp, () => this.helper.setItem(dbName, JSON.stringify(data, undefined, 2)));
-    }
-    p = Promise.resolve();
-    find(options) {
-        return this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.find(options)));
-    }
-    count(where) {
-        return this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.count(where)));
-    }
-    update(id, data) {
-        return this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.update(id, data).then(x => {
-            save();
-            return x;
-        })));
-    }
-    delete(id) {
-        return this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.delete(id).then(x => {
-            save();
-            return x;
-        })));
-    }
-    async insert(data) {
-        return this.p = this.p.then(() => this.loadEntityData((dp, save) => dp.insert(data).then(x => {
-            save();
-            return x;
-        })));
-    }
-}

package/esm/core/src/data-providers/rest-data-provider.d.ts

@@ -1,49 +0,0 @@
-import { EntityDataProvider, DataProvider, EntityDataProviderFindOptions, RestDataProviderHttpProvider } from '../data-interfaces';
-import { UrlBuilder } from '../../urlBuilder';
-import { Filter } from '../filter/filter-interfaces';
-import { EntityMetadata, FindOptions } from '../remult3';
-import { ApiClient } from '../context';
-export declare class RestDataProvider implements DataProvider {
-    private apiProvider;
-    constructor(apiProvider: () => ApiClient);
-    getEntityDataProvider(entity: EntityMetadata): RestEntityDataProvider;
-    transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-    isProxy: boolean;
-}
-export declare function findOptionsToJson(options: FindOptions<any>, meta: EntityMetadata): any;
-export declare function findOptionsFromJson(json: any, meta: EntityMetadata): FindOptions<any>;
-export declare class RestEntityDataProvider implements EntityDataProvider {
-    private url;
-    private http;
-    private entity;
-    constructor(url: () => string, http: () => RestDataProviderHttpProvider, entity: EntityMetadata);
-    translateFromJson(row: any): {};
-    translateToJson(row: any): {};
-    count(where: Filter): Promise<number>;
-    find(options?: EntityDataProviderFindOptions): Promise<Array<any>>;
-    buildFindRequest(options: EntityDataProviderFindOptions): {
-        createKey: () => string;
-        run: (action?: string) => Promise<any>;
-        subscribe: (queryId: any) => Promise<{
-            result: any[];
-            unsubscribe: () => Promise<any>;
-        }>;
-    };
-    update(id: any, data: any): Promise<any>;
-    delete(id: any): Promise<void>;
-    insert(data: any): Promise<any>;
-}
-export declare class RestDataProviderHttpProviderUsingFetch implements RestDataProviderHttpProvider {
-    private fetch?;
-    constructor(fetch?: ((input: RequestInfo, init?: RequestInit) => Promise<Response>) | undefined);
-    get(url: string): Promise<any>;
-    put(url: string, data: any): Promise<any>;
-    delete(url: string): Promise<any>;
-    post(url: string, data: any): Promise<any>;
-    myFetch(url: string, options?: {
-        method?: string;
-        body?: string;
-    }): Promise<any>;
-}
-export declare function addFilterToUrlAndReturnTrueIfSuccessful(filter: any, url: UrlBuilder): boolean;
-export declare const liveQueryAction = "liveQuery-";

package/esm/core/src/data-providers/rest-data-provider.js

@@ -1,256 +0,0 @@
-import { UrlBuilder } from '../../urlBuilder';
-import { customUrlToken, Filter } from '../filter/filter-interfaces';
-import { buildRestDataProvider, retry } from "../buildRestDataProvider";
-import { actionInfo } from '../server-action';
-export class RestDataProvider {
-    apiProvider;
-    constructor(apiProvider) {
-        this.apiProvider = apiProvider;
-    }
-    getEntityDataProvider(entity) {
-        return new RestEntityDataProvider(() => {
-            let url = this.apiProvider()?.url;
-            if (url === undefined || url === null)
-                url = '/api';
-            return url + '/' + entity.key;
-        }, () => {
-            return buildRestDataProvider(this.apiProvider().httpClient);
-        }, entity);
-    }
-    async transaction(action) {
-        throw new Error("Method not implemented.");
-    }
-    isProxy = true;
-}
-//@internal
-export function findOptionsToJson(options, meta) {
-    const r = {
-        ...options,
-        where: Filter.entityFilterToJson(meta, options.where),
-    };
-    if (options.load)
-        r.load = options.load(meta.fields).map(y => y.key);
-    return r;
-}
-//@internal
-export function findOptionsFromJson(json, meta) {
-    let r = {};
-    for (const key of ["limit", "page", "where", "orderBy"]) {
-        if (json[key] !== undefined) {
-            if (key === "where") {
-                r[key] = Filter.entityFilterFromJson(meta, json.where);
-            }
-            else
-                r[key] = json[key];
-        }
-    }
-    if (json.load) {
-        r.load = (z) => json.load.map(y => z.find(y));
-    }
-    return r;
-}
-export class RestEntityDataProvider {
-    url;
-    http;
-    entity;
-    constructor(url, http, entity) {
-        this.url = url;
-        this.http = http;
-        this.entity = entity;
-    }
-    translateFromJson(row) {
-        let result = {};
-        for (const col of this.entity.fields) {
-            result[col.key] = col.valueConverter.fromJson(row[col.key]);
-        }
-        return result;
-    }
-    translateToJson(row) {
-        let result = {};
-        for (const col of this.entity.fields) {
-            result[col.key] = col.valueConverter.toJson(row[col.key]);
-        }
-        return result;
-    }
-    async count(where) {
-        const { run } = this.buildFindRequest({ where });
-        return run("count").then(r => +r.count);
-    }
-    find(options) {
-        let { run } = this.buildFindRequest(options);
-        return run().then(x => x.map(y => this.translateFromJson(y)));
-    }
-    //@internal
-    buildFindRequest(options) {
-        let url = new UrlBuilder(this.url());
-        let filterObject;
-        if (options) {
-            if (options.where) {
-                filterObject = options.where.toJson(); //        options.where.__applyToConsumer(new FilterConsumnerBridgeToUrlBuilder(url));
-                if (addFilterToUrlAndReturnTrueIfSuccessful(filterObject, url))
-                    filterObject = undefined;
-            }
-            if (options.orderBy && options.orderBy.Segments) {
-                let sort = '';
-                let order = '';
-                let hasDescending = false;
-                options.orderBy.Segments.forEach(c => {
-                    if (sort.length > 0) {
-                        sort += ",";
-                        order += ",";
-                    }
-                    sort += c.field.key;
-                    order += c.isDescending ? "desc" : "asc";
-                    if (c.isDescending)
-                        hasDescending = true;
-                });
-                if (sort)
-                    url.add('_sort', sort);
-                if (hasDescending)
-                    url.add('_order', order);
-            }
-            if (options.limit)
-                url.add('_limit', options.limit);
-            if (options.page)
-                url.add('_page', options.page);
-        }
-        const run = (action) => {
-            let u = new UrlBuilder(url.url);
-            if (!action && filterObject) {
-                action = "get";
-            }
-            if (action)
-                u.add("__action", action);
-            if (filterObject) {
-                return this.http().post(u.url, filterObject);
-            }
-            else
-                return this.http().get(u.url);
-        };
-        return {
-            createKey: () => JSON.stringify({ url, filterObject }),
-            run,
-            subscribe: async (queryId) => {
-                const result = await run(liveQueryAction + queryId);
-                return {
-                    result,
-                    unsubscribe: async () => {
-                        return actionInfo.runActionWithoutBlockingUI(() => this.http().post(this.url() + "?__action=endLiveQuery", {
-                            id: queryId
-                        }));
-                    }
-                };
-            }
-        };
-    }
-    update(id, data) {
-        let result = {};
-        let keys = Object.keys(data);
-        for (const col of this.entity.fields) {
-            if (keys.includes(col.key))
-                result[col.key] = col.valueConverter.toJson(data[col.key]);
-        }
-        return this.http().put(this.url() + '/' + encodeURIComponent(id), result).then(y => this.translateFromJson(y));
-    }
-    delete(id) {
-        return this.http().delete(this.url() + '/' + encodeURIComponent(id));
-    }
-    insert(data) {
-        return this.http().post(this.url(), this.translateToJson(data)).then(y => this.translateFromJson(y));
-    }
-}
-export class RestDataProviderHttpProviderUsingFetch {
-    fetch;
-    constructor(fetch) {
-        this.fetch = fetch;
-    }
-    async get(url) {
-        return await retry(async () => this.myFetch(url).then(r => {
-            return r;
-        }));
-    }
-    put(url, data) {
-        return this.myFetch(url, {
-            method: 'put',
-            body: JSON.stringify(data)
-        });
-    }
-    delete(url) {
-        return this.myFetch(url, { method: 'delete' });
-    }
-    async post(url, data) {
-        return await retry(() => this.myFetch(url, {
-            method: 'post',
-            body: JSON.stringify(data)
-        }));
-    }
-    myFetch(url, options) {
-        const headers = {};
-        if (options?.body)
-            headers["Content-type"] = "application/json";
-        if (typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof (window.document.cookie !== 'undefined'))
-            for (const cookie of window.document.cookie.split(';')) {
-                if (cookie.trim().startsWith('XSRF-TOKEN=')) {
-                    headers['X-XSRF-TOKEN'] = cookie.split('=')[1];
-                }
-            }
-        return (this.fetch || fetch)(url, {
-            credentials: 'include',
-            method: options?.method,
-            body: options?.body,
-            headers
-        }).then(response => {
-            return onSuccess(response);
-        }).catch(async (error) => {
-            let r = await error;
-            throw r;
-        });
-    }
-}
-function onSuccess(response) {
-    if (response.status == 204)
-        return;
-    if (response.status >= 200 && response.status < 300)
-        return response.json();
-    else {
-        throw response.json().then(x => {
-            return { ...x, message: x.message || response.statusText, url: response.url, status: response.status };
-        }).catch(() => {
-            throw {
-                message: response.statusText,
-                url: response.url,
-                status: response.status
-            };
-        });
-    }
-}
-export function addFilterToUrlAndReturnTrueIfSuccessful(filter, url) {
-    for (const key in filter) {
-        if (Object.prototype.hasOwnProperty.call(filter, key)) {
-            const element = filter[key];
-            if (Array.isArray(element)) {
-                if (element.length > 0 && typeof element[0] === 'object')
-                    return false;
-                if (element.length > 10)
-                    return false;
-            }
-        }
-    }
-    for (const key in filter) {
-        if (Object.prototype.hasOwnProperty.call(filter, key)) {
-            const element = filter[key];
-            if (Array.isArray(element)) {
-                if (key.endsWith(".in"))
-                    url.add(key, JSON.stringify(element));
-                else
-                    element.forEach(e => url.add(key, e));
-            }
-            else if (key.startsWith(customUrlToken))
-                url.add(key, JSON.stringify(element));
-            else
-                url.add(key, element);
-        }
-    }
-    return true;
-}
-export const liveQueryAction = "liveQuery-";

package/esm/core/src/data-providers/sql-database.d.ts

@@ -1,33 +0,0 @@
-import { EntityDataProvider, DataProvider } from "../data-interfaces";
-import { SqlCommand, SqlCommandWithParameters, SqlImplementation, SqlResult } from "../sql-command";
-import { CustomSqlFilterBuilderFunction } from "../filter/filter-consumer-bridge-to-sql-request";
-import { EntityMetadata, EntityFilter, RepositoryOverloads } from "../remult3";
-import { Remult } from "../context";
-export declare class SqlDatabase implements DataProvider {
-    private sql;
-    static getDb(remult?: Remult): SqlDatabase;
-    createCommand(): SqlCommand;
-    execute(sql: string): Promise<SqlResult>;
-    _getSourceSql(): SqlImplementation;
-    ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
-    getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
-    transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-    static rawFilter(build: CustomSqlFilterBuilderFunction): EntityFilter<any>;
-    static filterToRaw<entityType>(repo: RepositoryOverloads<entityType>, condition: EntityFilter<entityType>, sqlCommand?: SqlCommandWithParameters): Promise<string>;
-    /**
-     * `false` _(default)_ - No logging
-     *
-     * `true` - to log all queries to the console
-     *
-     * `oneLiner` - to log all queries to the console as one line
-     *
-     * a `function` - to log all queries to the console as a custom format
-     */
-    static LogToConsole: boolean | 'oneLiner' | ((duration: number, query: string, args: Record<string, any>) => void);
-    /**
-     * Threshold in milliseconds for logging queries to the console.
-     */
-    static durationThreshold: number;
-    constructor(sql: SqlImplementation);
-    private createdEntities;
-}