remult 0.14.7 → 0.14.10

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

@@ -0,0 +1,264 @@
+import { customDatabaseFilterToken, Filter } from '../filter/filter-interfaces';
+import { CompoundIdField } from '../column';
+export class ArrayEntityDataProvider {
+    constructor(entity, rows) {
+        this.entity = entity;
+        this.rows = rows;
+        if (!rows)
+            rows = [];
+        else {
+            for (const r of rows) {
+                this.verifyThatRowHasAllNotNullColumns(r);
+            }
+        }
+    }
+    static customFilter(filter) {
+        return {
+            [customDatabaseFilterToken]: {
+                arrayFilter: filter
+            }
+        };
+    }
+    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) => {
+                    let r = 0;
+                    for (let i = 0; i < options.orderBy.Segments.length; i++) {
+                        let seg = options.orderBy.Segments[i];
+                        let left = a[seg.field.key];
+                        let right = b[seg.field.key];
+                        if (left > right)
+                            r = 1;
+                        else if (left < right)
+                            r = -1;
+                        if (r != 0) {
+                            if (seg.isDescending)
+                                r *= -1;
+                            return r;
+                        }
+                    }
+                    return r;
+                });
+            }
+            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 {
+    constructor(row) {
+        this.row = row;
+        this.ok = true;
+    }
+    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/src/data-providers/in-memory-database.d.ts

@@ -0,0 +1,9 @@
+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/src/data-providers/in-memory-database.js

@@ -0,0 +1,16 @@
+import { ArrayEntityDataProvider } from './array-entity-data-provider';
+export class InMemoryDataProvider {
+    constructor() {
+        this.rows = {};
+    }
+    async transaction(action) {
+        await action(this);
+    }
+    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/src/data-providers/json-data-provider.d.ts

@@ -0,0 +1,12 @@
+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/src/data-providers/json-data-provider.js

@@ -0,0 +1,52 @@
+import { ArrayEntityDataProvider } from './array-entity-data-provider';
+export class JsonDataProvider {
+    constructor(storage) {
+        this.storage = storage;
+    }
+    getEntityDataProvider(entity) {
+        return new JsonEntityDataProvider(entity, this.storage);
+    }
+    async transaction(action) {
+        await action(this);
+    }
+}
+class JsonEntityDataProvider {
+    constructor(entity, helper) {
+        this.entity = entity;
+        this.helper = helper;
+        this.p = Promise.resolve();
+    }
+    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)));
+    }
+    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/src/data-providers/rest-data-provider.d.ts

@@ -0,0 +1,35 @@
+import { EntityDataProvider, DataProvider, EntityDataProviderFindOptions, RestDataProviderHttpProvider } from '../data-interfaces';
+import { UrlBuilder } from '../../urlBuilder';
+import { Filter } from '../filter/filter-interfaces';
+import { EntityMetadata } from '../remult3';
+export declare class RestDataProvider implements DataProvider {
+    private url;
+    private http;
+    constructor(url: string, http: RestDataProviderHttpProvider);
+    getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
+    transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
+    supportsCustomFilter: boolean;
+}
+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>>;
+    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>);
+    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, init?: RequestInit): Promise<any>;
+}
+export declare function addFilterToUrlAndReturnTrueIfSuccessful(filter: any, url: UrlBuilder): boolean;

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

@@ -0,0 +1,188 @@
+import { UrlBuilder } from '../../urlBuilder';
+import { customUrlToken } from '../filter/filter-interfaces';
+import { retry } from '../context';
+export class RestDataProvider {
+    constructor(url, http) {
+        this.url = url;
+        this.http = http;
+        this.supportsCustomFilter = true;
+    }
+    getEntityDataProvider(entity) {
+        return new RestEntityDataProvider(this.url + '/' + entity.key, this.http, entity);
+    }
+    async transaction(action) {
+        throw new Error("Method not implemented.");
+    }
+}
+export class RestEntityDataProvider {
+    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) {
+        let url = new UrlBuilder(this.url);
+        url.add("__action", "count");
+        let filterObject;
+        if (where) {
+            filterObject = where.toJson();
+            if (addFilterToUrlAndReturnTrueIfSuccessful(filterObject, url))
+                filterObject = undefined;
+        }
+        if (filterObject)
+            return this.http.post(url.url, filterObject).then(r => +(r.count));
+        else
+            return this.http.get(url.url).then(r => +(r.count));
+    }
+    find(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 = '';
+                options.orderBy.Segments.forEach(c => {
+                    if (sort.length > 0) {
+                        sort += ",";
+                        order += ",";
+                    }
+                    sort += c.field.key;
+                    order += c.isDescending ? "desc" : "asc";
+                });
+                url.add('_sort', sort);
+                url.add('_order', order);
+            }
+            if (options.limit)
+                url.add('_limit', options.limit);
+            if (options.page)
+                url.add('_page', options.page);
+        }
+        if (filterObject) {
+            url.add("__action", "get");
+            return this.http.post(url.url, filterObject).then(x => x.map(y => this.translateFromJson(y)));
+        }
+        else
+            return this.http.get(url.url).then(x => x.map(y => this.translateFromJson(y)));
+        ;
+    }
+    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 {
+    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', credentials: 'include' });
+    }
+    async post(url, data) {
+        return await retry(() => this.myFetch(url, {
+            method: 'post',
+            body: JSON.stringify(data)
+        }));
+    }
+    myFetch(url, init) {
+        if (!init)
+            init = {};
+        if (!init.headers)
+            init.headers = new Headers();
+        var h = init.headers;
+        h.append('Content-type', "application/json");
+        init.credentials = 'include';
+        return (this.fetch || fetch)(url, init).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;
+}

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

@@ -0,0 +1,16 @@
+import { EntityDataProvider, DataProvider } from "../data-interfaces";
+import { SqlCommand, SqlImplementation, SqlResult } from "../sql-command";
+import { CustomSqlFilterBuilderFunction } from "../filter/filter-consumer-bridge-to-sql-request";
+import { EntityMetadata, EntityFilter } from "../remult3";
+export declare class SqlDatabase implements DataProvider {
+    private sql;
+    createCommand(): SqlCommand;
+    execute(sql: string): Promise<SqlResult>;
+    getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
+    transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
+    static customFilter(build: CustomSqlFilterBuilderFunction): EntityFilter<any>;
+    static LogToConsole: boolean;
+    static durationThreshold: number;
+    constructor(sql: SqlImplementation);
+    private createdEntities;
+}