remult 0.22.3 → 0.22.4

package/esm/core/src/data-providers/sql-database.js

@@ -0,0 +1,384 @@
+import { CompoundIdField } from "../column";
+import { dbNamesOf, FilterConsumerBridgeToSqlRequest, isDbReadonly } from "../filter/filter-consumer-bridge-to-sql-request";
+import { customDatabaseFilterToken, Filter } from '../filter/filter-interfaces';
+import { Sort } from '../sort';
+import { getRepository } from "../remult3";
+import { remult as defaultRemult } from "../remult-proxy";
+import { ValueConverters } from "../valueConverters";
+// @dynamic
+export class SqlDatabase {
+    sql;
+    static getDb(remult) {
+        const r = (remult || defaultRemult).dataProvider;
+        if (!r.createCommand)
+            throw "the data provider is not an SqlDatabase";
+        return r;
+    }
+    createCommand() {
+        return new LogSQLCommand(this.sql.createCommand(), SqlDatabase.LogToConsole);
+    }
+    async execute(sql) {
+        return await this.createCommand().execute(sql);
+    }
+    /* @internal*/
+    _getSourceSql() {
+        return this.sql;
+    }
+    async ensureSchema(entities) {
+        if (this.sql.ensureSchema)
+            await this.sql.ensureSchema(entities);
+    }
+    getEntityDataProvider(entity) {
+        if (!this.sql.supportsJsonColumnType) {
+            for (const f of entity.fields.toArray()) {
+                if (f.valueConverter.fieldTypeInDb === "json") {
+                    //@ts-ignore
+                    f.valueConverter = { ...f.valueConverter, toDb: ValueConverters.JsonString.toDb, fromDb: ValueConverters.JsonString.fromDb };
+                }
+            }
+        }
+        return new ActualSQLServerDataProvider(entity, this, async (dbName) => {
+            if (this.createdEntities.indexOf(dbName.$entityName) < 0) {
+                this.createdEntities.push(dbName.$entityName);
+                await this.sql.entityIsUsedForTheFirstTime(entity);
+            }
+        }, this.sql);
+    }
+    transaction(action) {
+        return this.sql.transaction(async (x) => {
+            let completed = false;
+            try {
+                await action(new SqlDatabase({
+                    createCommand: () => {
+                        let c = x.createCommand();
+                        return {
+                            addParameterAndReturnSqlToken: x => c.addParameterAndReturnSqlToken(x),
+                            execute: async (sql) => {
+                                if (completed)
+                                    throw "can't run a command after the transaction was completed";
+                                return c.execute(sql);
+                            }
+                        };
+                    },
+                    getLimitSqlSyntax: this.sql.getLimitSqlSyntax,
+                    entityIsUsedForTheFirstTime: y => x.entityIsUsedForTheFirstTime(y),
+                    transaction: z => x.transaction(z),
+                    supportsJsonColumnType: this.sql.supportsJsonColumnType
+                }));
+            }
+            finally {
+                completed = true;
+            }
+        });
+    }
+    static rawFilter(build) {
+        return {
+            [customDatabaseFilterToken]: {
+                buildSql: build
+            }
+        };
+    }
+    static async filterToRaw(repo, condition, sqlCommand) {
+        if (!sqlCommand) {
+            sqlCommand = new myDummySQLCommand();
+        }
+        const r = getRepository(repo);
+        var b = new FilterConsumerBridgeToSqlRequest(sqlCommand, await dbNamesOf(r.metadata));
+        b._addWhere = false;
+        await (await (r.translateWhereToFilter(condition))).__applyToConsumer(b);
+        return await b.resolveWhere();
+    }
+    /**
+     * `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 = false;
+    /**
+     * Threshold in milliseconds for logging queries to the console.
+     */
+    static durationThreshold = 0;
+    constructor(sql) {
+        this.sql = sql;
+    }
+    createdEntities = [];
+}
+const icons = new Map([
+    // CRUD
+    ['INSERT', '⚪'],
+    ['SELECT', '🔵'],
+    ['UPDATE', '🟣'],
+    ['DELETE', '🟤'],
+    // Additional
+    ['CREATE', '🟩'],
+    ['ALTER', '🟨'],
+    ['DROP', '🟥'],
+    ['TRUNCATE', '⬛'],
+    ['GRANT', '🟪'],
+    ['REVOKE', '🟫'], // Used to take back permissions from a user.
+]);
+class LogSQLCommand {
+    origin;
+    logToConsole;
+    constructor(origin, logToConsole) {
+        this.origin = origin;
+        this.logToConsole = logToConsole;
+    }
+    args = {};
+    addParameterAndReturnSqlToken(val) {
+        let r = this.origin.addParameterAndReturnSqlToken(val);
+        this.args[r] = val;
+        return r;
+    }
+    async execute(sql) {
+        try {
+            let start = new Date();
+            let r = await this.origin.execute(sql);
+            if (this.logToConsole !== false) {
+                var d = new Date().valueOf() - start.valueOf();
+                if (d > SqlDatabase.durationThreshold) {
+                    const duration = d / 1000;
+                    if (this.logToConsole === "oneLiner") {
+                        const rawSql = sql.replace(/(\r\n|\n|\r|\t)/gm, ' ').replace(/  +/g, ' ').trim();
+                        const first = rawSql.split(' ')[0].toUpperCase();
+                        console.info(`${icons.get(first) || '💢'} (${(duration).toFixed(3)}) ${rawSql} ${JSON.stringify(this.args)}`);
+                    }
+                    else if (typeof this.logToConsole === "function") {
+                        this.logToConsole(duration, sql, this.args);
+                    }
+                    else {
+                        console.info({ query: sql, arguments: this.args, duration });
+                    }
+                }
+            }
+            return r;
+        }
+        catch (err) {
+            console.error({ error: err, query: sql, arguments: this.args });
+            throw err;
+        }
+    }
+}
+class ActualSQLServerDataProvider {
+    entity;
+    sql;
+    iAmUsed;
+    strategy;
+    static LogToConsole = false;
+    constructor(entity, sql, iAmUsed, strategy) {
+        this.entity = entity;
+        this.sql = sql;
+        this.iAmUsed = iAmUsed;
+        this.strategy = strategy;
+    }
+    async init() {
+        let dbNameProvider = await dbNamesOf(this.entity);
+        await this.iAmUsed(dbNameProvider);
+        return dbNameProvider;
+    }
+    async count(where) {
+        let e = await this.init();
+        let select = 'select count(*) count from ' + e.$entityName;
+        let r = this.sql.createCommand();
+        if (where) {
+            let wc = new FilterConsumerBridgeToSqlRequest(r, e);
+            where.__applyToConsumer(wc);
+            select += await wc.resolveWhere();
+        }
+        return r.execute(select).then(r => {
+            return Number(r.rows[0].count);
+        });
+    }
+    async find(options) {
+        let e = await this.init();
+        let { colKeys, select } = this.buildSelect(e);
+        select = 'select ' + select;
+        select += '\n from ' + e.$entityName;
+        let r = this.sql.createCommand();
+        if (options) {
+            if (options.where) {
+                let where = new FilterConsumerBridgeToSqlRequest(r, e);
+                options.where.__applyToConsumer(where);
+                select += await where.resolveWhere();
+            }
+            if (options.limit) {
+                options.orderBy = Sort.createUniqueSort(this.entity, options.orderBy);
+            }
+            if (!options.orderBy) {
+                options.orderBy = Sort.createUniqueSort(this.entity, new Sort());
+            }
+            if (options.orderBy) {
+                let first = true;
+                let segs = [];
+                for (const s of options.orderBy.Segments) {
+                    if (s.field instanceof CompoundIdField) {
+                        segs.push(...s.field.fields.map(c => ({ field: c, isDescending: s.isDescending })));
+                    }
+                    else
+                        segs.push(s);
+                }
+                for (const c of segs) {
+                    if (first) {
+                        select += ' Order By ';
+                        first = false;
+                    }
+                    else
+                        select += ', ';
+                    select += e.$dbNameOf(c.field);
+                    if (c.isDescending)
+                        select += ' desc';
+                }
+            }
+            if (options.limit) {
+                let page = 1;
+                if (options.page)
+                    page = options.page;
+                if (page < 1)
+                    page = 1;
+                select += ' ' + this.strategy.getLimitSqlSyntax(options.limit, (page - 1) * options.limit);
+            }
+        }
+        return r.execute(select).then(r => {
+            return r.rows.map(y => {
+                return this.buildResultRow(colKeys, y, r);
+            });
+        });
+    }
+    buildResultRow(colKeys, y, r) {
+        let result = {};
+        for (let index = 0; index < colKeys.length; index++) {
+            const col = colKeys[index];
+            try {
+                result[col.key] = col.valueConverter.fromDb(y[r.getColumnKeyInResultForIndexInSelect(index)]);
+            }
+            catch (err) {
+                throw new Error("Failed to load from db:" + col.key + "\r\n" + err);
+            }
+        }
+        return result;
+    }
+    buildSelect(e) {
+        let select = '';
+        let colKeys = [];
+        for (const x of this.entity.fields) {
+            if (x.isServerExpression) {
+            }
+            else {
+                if (colKeys.length > 0)
+                    select += ', ';
+                select += e.$dbNameOf(x);
+                colKeys.push(x);
+            }
+        }
+        return { colKeys, select };
+    }
+    async update(id, data) {
+        let e = await this.init();
+        let r = this.sql.createCommand();
+        let f = new FilterConsumerBridgeToSqlRequest(r, e);
+        Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
+        let statement = 'update ' + e.$entityName + ' set ';
+        let added = false;
+        for (const x of this.entity.fields) {
+            if (x instanceof CompoundIdField) {
+            }
+            if (isDbReadonly(x, e)) { }
+            else if (data[x.key] !== undefined) {
+                let v = x.valueConverter.toDb(data[x.key]);
+                if (v !== undefined) {
+                    if (!added)
+                        added = true;
+                    else
+                        statement += ', ';
+                    statement += e.$dbNameOf(x) + ' = ' + r.addParameterAndReturnSqlToken(v);
+                }
+            }
+        }
+        statement += await f.resolveWhere();
+        let { colKeys, select } = this.buildSelect(e);
+        statement += ' returning ' + select;
+        return r.execute(statement).then(sqlResult => {
+            return this.buildResultRow(colKeys, sqlResult.rows[0], sqlResult);
+        });
+    }
+    async delete(id) {
+        let e = await this.init();
+        let r = this.sql.createCommand();
+        let f = new FilterConsumerBridgeToSqlRequest(r, e);
+        Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(f);
+        let statement = 'delete from ' + e.$entityName;
+        statement += await f.resolveWhere();
+        return r.execute(statement).then(() => { });
+    }
+    async insert(data) {
+        let e = await this.init();
+        let r = this.sql.createCommand();
+        let cols = '';
+        let vals = '';
+        let added = false;
+        for (const x of this.entity.fields) {
+            if (isDbReadonly(x, e)) { }
+            else {
+                let v = x.valueConverter.toDb(data[x.key]);
+                if (v != undefined) {
+                    if (!added)
+                        added = true;
+                    else {
+                        cols += ', ';
+                        vals += ', ';
+                    }
+                    cols += e.$dbNameOf(x);
+                    vals += r.addParameterAndReturnSqlToken(v);
+                }
+            }
+        }
+        let statement = `insert into ${e.$entityName} (${cols}) values (${vals})`;
+        let { colKeys, select } = this.buildSelect(e);
+        statement += ' returning ' + select;
+        return await r.execute(statement).then(sql => this.buildResultRow(colKeys, sql.rows[0], sql));
+    }
+}
+class myDummySQLCommand {
+    execute(sql) {
+        throw new Error("Method not implemented.");
+    }
+    addParameterAndReturnSqlToken(val) {
+        if (val === null)
+            return "null";
+        if (val instanceof Date)
+            val = val.toISOString();
+        if (typeof (val) == "string") {
+            if (val == undefined)
+                val = '';
+            return '\'' + val.replace(/'/g, '\'\'') + '\'';
+        }
+        return val.toString();
+    }
+}
+async function bulkInsert(array, db) {
+    if (array.length == 0)
+        return;
+    const chunkSize = 250;
+    for (let i = 0; i < array.length; i += chunkSize) {
+        const items = array.slice(i, i + chunkSize);
+        // do whatever
+        const c = db.createCommand();
+        let sql = 'insert into ' +
+            (await items[0]._.metadata.getDbName()) +
+            ' (' +
+            (await Promise.all(items[0]._.metadata.fields.toArray().map((f) => f.getDbName()))).join(',') +
+            ') values ';
+        sql += items
+            .map((row) => '(' +
+            row.$.toArray()
+                .map((f) => c.addParameterAndReturnSqlToken(f.metadata.valueConverter.toDb(f.value)))
+                .join(', ') +
+            ')')
+            .join(',');
+        await c.execute(sql);
+    }
+}

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

@@ -0,0 +1,24 @@
+/// <reference types="websql" />
+import { __RowsOfDataForTesting } from "../__RowsOfDataForTesting";
+import { SqlCommand, SqlImplementation } from "../sql-command";
+import { EntityMetadata } from "../remult3";
+import { Remult } from "../context";
+export declare class WebSqlDataProvider implements SqlImplementation, __RowsOfDataForTesting {
+    private databaseName;
+    rows: {
+        [tableName: string]: any;
+    };
+    /** @internal */
+    db: Database;
+    constructor(databaseName: string, databaseSize?: number);
+    static getDb(remult?: Remult): any;
+    getLimitSqlSyntax(limit: number, offset: number): string;
+    entityIsUsedForTheFirstTime(entity: EntityMetadata): Promise<void>;
+    ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
+    dropTable(entity: EntityMetadata): Promise<void>;
+    createTable(entity: EntityMetadata<any>): Promise<void>;
+    createCommand(): SqlCommand;
+    transaction(action: (dataProvider: SqlImplementation) => Promise<void>): Promise<void>;
+    private addColumnSqlSyntax;
+    toString(): string;
+}

package/esm/core/src/data-providers/web-sql-data-provider.js

@@ -0,0 +1,143 @@
+import { isAutoIncrement } from "../remult3";
+import { SqlDatabase } from "./sql-database";
+import { dbNamesOf, isDbReadonly } from "../filter/filter-consumer-bridge-to-sql-request";
+//SqlDatabase.LogToConsole = true;
+export class WebSqlDataProvider {
+    databaseName;
+    rows;
+    /** @internal */
+    //@ts-ignore
+    db;
+    constructor(databaseName, databaseSize = 2 * 1024 * 1024) {
+        this.databaseName = databaseName;
+        //@ts-ignore
+        this.db = window.openDatabase(databaseName, '1.0', databaseName, databaseSize);
+    }
+    // return instance of websql.Database class - see @types/websql
+    static getDb(remult) {
+        const sql = SqlDatabase.getDb(remult);
+        const me = sql._getSourceSql();
+        if (!me.db) {
+            throw "the data provider is not a WebSqlDataProvider";
+        }
+        return me.db;
+    }
+    getLimitSqlSyntax(limit, offset) {
+        return ' limit ' + limit + ' offset ' + offset;
+    }
+    async entityIsUsedForTheFirstTime(entity) {
+        await this.createTable(entity);
+    }
+    async ensureSchema(entities) {
+        for (const entity of entities) {
+            await this.createTable(entity);
+        }
+    }
+    async dropTable(entity) {
+        let e = await dbNamesOf(entity);
+        let sql = 'drop  table if exists ' + e.$entityName;
+        if (SqlDatabase.LogToConsole)
+            console.info(sql);
+        await this.createCommand().execute(sql);
+    }
+    async createTable(entity) {
+        let result = '';
+        let e = await dbNamesOf(entity);
+        for (const x of entity.fields) {
+            if (!isDbReadonly(x, e) || isAutoIncrement(x)) {
+                if (result.length != 0)
+                    result += ',';
+                result += '\r\n  ';
+                if (isAutoIncrement(x)) {
+                    if (x.key != entity.idMetadata.field.key)
+                        throw "in web sql, autoincrement is only allowed for primary key";
+                    result += e.$dbNameOf(x) + ' integer primary key autoincrement';
+                }
+                else {
+                    result += this.addColumnSqlSyntax(x, e.$dbNameOf(x));
+                    if (x.key == entity.idMetadata.field.key) {
+                        result += ' primary key';
+                    }
+                }
+            }
+        }
+        let sql = 'create table if not exists ' + e.$entityName + ' (' + result + '\r\n)';
+        if (SqlDatabase.LogToConsole)
+            console.log(sql);
+        await this.createCommand().execute(sql);
+    }
+    createCommand() {
+        return new WebSqlBridgeToSQLCommand(this.db);
+    }
+    async transaction(action) {
+        throw new Error("Method not implemented.");
+    }
+    addColumnSqlSyntax(x, dbName) {
+        let result = dbName;
+        const nullNumber = x.allowNull ? "" : " default 0 not null";
+        if (x.valueType == Date)
+            result += " integer";
+        else if (x.valueType == Boolean)
+            result += " integer " + nullNumber;
+        else if (x.valueType == Number) {
+            if (!x.valueConverter.fieldTypeInDb)
+                result += ' real ' + nullNumber;
+            else
+                result += ' ' + x.valueConverter.fieldTypeInDb + ' ' + nullNumber;
+        }
+        else
+            result += " text" + (x.allowNull ? " " : " default '' not null ");
+        return result;
+    }
+    toString() { return "WebSqlDataProvider"; }
+}
+class WebSqlBridgeToSQLCommand {
+    source;
+    //@ts-ignore
+    constructor(source) {
+        this.source = source;
+    }
+    values = [];
+    addParameterAndReturnSqlToken(val) {
+        this.values.push(val);
+        return '~' + this.values.length + '~';
+    }
+    execute(sql) {
+        return new Promise((resolve, reject) => this.source.transaction(t => {
+            let s = sql;
+            let v = [];
+            var m = s.match(/~\d+~/g);
+            if (m != null)
+                m.forEach(mr => {
+                    s = s.replace(mr, '?');
+                    v.push(this.values[Number.parseInt(mr.substring(1, mr.length - 1)) - 1]);
+                });
+            t.executeSql(s, v, (t1, r) => resolve(new WebSqlBridgeToSQLQueryResult(r)), (t2, err) => {
+                reject(err.message);
+                return undefined;
+            });
+        }));
+    }
+}
+class WebSqlBridgeToSQLQueryResult {
+    r;
+    getColumnKeyInResultForIndexInSelect(index) {
+        if (this.rows.length == 0)
+            return undefined;
+        let i = 0;
+        for (let m in this.rows[0]) {
+            if (i++ == index)
+                return m;
+        }
+        return undefined;
+    }
+    //@ts-ignore
+    constructor(r) {
+        this.r = r;
+        this.rows = [];
+        for (let i = 0; i < r.rows.length; i++) {
+            this.rows.push(r.rows.item(i));
+        }
+    }
+    rows;
+}

package/esm/core/src/entity.d.ts

@@ -0,0 +1,91 @@
+import { Allowed, AllowedForInstance } from "./context";
+import { FieldMetadata } from './column-interfaces';
+import { EntityOrderBy, FieldsMetadata, EntityFilter, EntityRef, EntityMetadata } from "./remult3";
+export interface EntityOptions<entityType = any> {
+    /**A human readable name for the entity */
+    caption?: string;
+    /**
+     * Determines if this Entity is available for get requests using Rest Api
+     * @description
+     * Determines if one has any access to the data of an entity.
+     * @see [allowed](http://remult.dev/docs/allowed.html)
+     * @see to restrict data based on a criteria, use [apiPrefilter](https://remult.dev/docs/ref_entity.html#apiprefilter)
+     * */
+    allowApiRead?: Allowed;
+    /**
+     * Determines if this entity can be updated through the api.
+     * @see [allowed](http://remult.dev/docs/allowed.html)*/
+    allowApiUpdate?: AllowedForInstance<entityType>;
+    /** Determines if entries for this entity can be deleted through the api.
+     * @see [allowed](http://remult.dev/docs/allowed.html)*/
+    allowApiDelete?: AllowedForInstance<entityType>;
+    /** Determines if new entries for this entity can be posted through the api.
+     * @see [allowed](http://remult.dev/docs/allowed.html)*/
+    allowApiInsert?: AllowedForInstance<entityType>;
+    /** sets  the `allowApiUpdate`, `allowApiDelete` and `allowApiInsert` properties in a single set */
+    allowApiCrud?: Allowed;
+    /** A filter that determines which rows can be queries using the api.
+     * @description
+     * Use apiPrefilter in cases where you to restrict data based on user profile
+    * @example
+    * apiPrefilter: { archive:false }
+    *
+    * @example
+    * apiPrefilter: ()=> remult.isAllowed("admin")?{}:{ archive:false }
+    * @see [EntityFilter](http://remult.dev/docs/entityFilter.html)
+    *
+    */
+    apiPrefilter?: EntityFilter<entityType> | (() => EntityFilter<entityType> | Promise<EntityFilter<entityType>>);
+    /** A filter that will be used for all queries from this entity both from the API and from within the backend.
+     * @example
+     * backendPrefilter: { archive:false }
+     * @see [EntityFilter](http://remult.dev/docs/entityFilter.html)
+     */
+    backendPrefilter?: EntityFilter<entityType> | (() => EntityFilter<entityType> | Promise<EntityFilter<entityType>>);
+    /** An order by to be used, in case no order by was specified
+     * @example
+     * defaultOrderBy: { name: "asc" }
+     *
+     * @example
+     * defaultOrderBy: { price: "desc", name: "asc" }
+     */
+    defaultOrderBy?: EntityOrderBy<entityType>;
+    /** An event that will be fired before the Entity will be saved to the database.
+    * If the `error` property of the entity's ref or any of its fields will be set, the save will be aborted and an exception will be thrown.
+    * this is the place to run logic that we want to run in any case before an entity is saved.
+    * @example
+    * @Entity<Task>("tasks", {
+    * saving: async task => {
+    *      task.lastUpdated = new Date()
+    *  }
+    *})
+    */
+    saving?: (row: entityType, proceedWithoutSavingToDb: () => void) => Promise<any> | any;
+    /** will be called after the Entity was saved to the data source. */
+    saved?: (row: entityType) => Promise<any> | any;
+    /** Will be called before an Entity is deleted. */
+    deleting?: (row: entityType) => Promise<any> | any;
+    /** Will be called after an Entity is deleted */
+    deleted?: (row: entityType) => Promise<any> | any;
+    /** Will be called when the entity is being validated, usually prior to the `saving` event */
+    validation?: (row: entityType, ref: EntityRef<entityType>) => Promise<any> | any;
+    /** The name of the table in the database that holds the data for this entity.
+   * If no name is set, the `key` will be used instead.
+   * @example
+   * dbName:'myProducts'
+   */
+    dbName?: string;
+    /** For entities that are based on SQL expressions instead of a physical table or view*/
+    sqlExpression?: string | ((entity: EntityMetadata<entityType>) => string | Promise<string>);
+    /** An arrow function that identifies the `id` column to use for this entity
+     * @example
+     * //Single column id
+     * @Entity<Products>("products", { id:p=>p.productCode })
+     * @example
+     * //Multiple columns id
+     * @Entity<OrderDetails>("orderDetails", { id:od=> [od.orderId, od.productCode] })
+    */
+    id?: (entity: FieldsMetadata<entityType>) => FieldMetadata | FieldMetadata[];
+    entityRefInit?: (ref: EntityRef<entityType>, row: entityType) => void;
+    apiRequireId?: Allowed;
+}

package/esm/core/src/entity.js

@@ -0,0 +1 @@
+export {};