remult 0.22.2 → 0.22.3

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

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

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

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

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

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