remult 0.21.1 → 0.22.0

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

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

@@ -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/core/src/data-providers/in-memory-database.js

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

@@ -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/core/src/data-providers/json-data-provider.js

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

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

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

@@ -0,0 +1,33 @@
+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;
+}