remult 0.14.7 → 0.14.8

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

@@ -0,0 +1,261 @@
+import { CompoundIdField } from "../column";
+import { FilterConsumerBridgeToSqlRequest, getDbNameProvider } from "../filter/filter-consumer-bridge-to-sql-request";
+import { customDatabaseFilterToken, Filter } from '../filter/filter-interfaces';
+import { Sort } from '../sort';
+// @dynamic
+export class SqlDatabase {
+    constructor(sql) {
+        this.sql = sql;
+        this.createdEntities = [];
+    }
+    createCommand() {
+        return new LogSQLCommand(this.sql.createCommand(), SqlDatabase.LogToConsole);
+    }
+    async execute(sql) {
+        return await this.createCommand().execute(sql);
+    }
+    getEntityDataProvider(entity) {
+        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),
+                }));
+            }
+            finally {
+                completed = true;
+            }
+        });
+    }
+    static customFilter(build) {
+        return {
+            [customDatabaseFilterToken]: {
+                buildSql: build
+            }
+        };
+    }
+}
+SqlDatabase.LogToConsole = false;
+SqlDatabase.durationThreshold = 0;
+class LogSQLCommand {
+    constructor(origin, allQueries) {
+        this.origin = origin;
+        this.allQueries = allQueries;
+        this.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.allQueries) {
+                var d = new Date().valueOf() - start.valueOf();
+                if (d > SqlDatabase.durationThreshold) {
+                    console.log({ query: sql, arguments: this.args, duration: d / 1000 });
+                }
+            }
+            return r;
+        }
+        catch (err) {
+            console.error({ error: err, query: sql, arguments: this.args });
+            throw err;
+        }
+    }
+}
+class ActualSQLServerDataProvider {
+    constructor(entity, sql, iAmUsed, strategy) {
+        this.entity = entity;
+        this.sql = sql;
+        this.iAmUsed = iAmUsed;
+        this.strategy = strategy;
+    }
+    async init() {
+        let dbNameProvider = await getDbNameProvider(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 +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) {
+                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.nameOf(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.nameOf(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 (e.isDbReadonly(x)) { }
+            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.nameOf(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 (e.isDbReadonly(x)) { }
+            else {
+                let v = x.valueConverter.toDb(data[x.key]);
+                if (v != undefined) {
+                    if (!added)
+                        added = true;
+                    else {
+                        cols += ', ';
+                        vals += ', ';
+                    }
+                    cols += e.nameOf(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));
+    }
+}
+ActualSQLServerDataProvider.LogToConsole = false;

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

@@ -0,0 +1,18 @@
+import { __RowsOfDataForTesting } from "../__RowsOfDataForTesting";
+import { SqlCommand, SqlImplementation } from "../sql-command";
+import { EntityMetadata } from "../remult3";
+export declare class WebSqlDataProvider implements SqlImplementation, __RowsOfDataForTesting {
+    private databaseName;
+    rows: {
+        [tableName: string]: any;
+    };
+    constructor(databaseName: string, databaseSize?: number);
+    getLimitSqlSyntax(limit: number, offset: number): string;
+    entityIsUsedForTheFirstTime(entity: EntityMetadata): 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/src/data-providers/web-sql-data-provider.js

@@ -0,0 +1,121 @@
+import { isAutoIncrement } from "../remult3";
+import { SqlDatabase } from "./sql-database";
+import { getDbNameProvider } from "../filter/filter-consumer-bridge-to-sql-request";
+//SqlDatabase.LogToConsole = true;
+export class WebSqlDataProvider {
+    constructor(databaseName, databaseSize = 2 * 1024 * 1024) {
+        this.databaseName = databaseName;
+        //@ts-ignore
+        this.db = window.openDatabase(databaseName, '1.0', databaseName, databaseSize);
+    }
+    getLimitSqlSyntax(limit, offset) {
+        return ' limit ' + limit + ' offset ' + offset;
+    }
+    async entityIsUsedForTheFirstTime(entity) {
+        await this.createTable(entity);
+    }
+    async dropTable(entity) {
+        let e = await getDbNameProvider(entity);
+        let sql = 'drop  table if exists ' + e.entityName;
+        if (SqlDatabase.LogToConsole)
+            console.log(sql);
+        await this.createCommand().execute(sql);
+    }
+    async createTable(entity) {
+        let result = '';
+        let e = await getDbNameProvider(entity);
+        for (const x of entity.fields) {
+            if (!e.isDbReadonly(x) || 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.nameOf(x) + ' integer primary key autoincrement';
+                }
+                else {
+                    result += this.addColumnSqlSyntax(x, e.nameOf(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 {
+    //@ts-ignore
+    constructor(source) {
+        this.source = source;
+        this.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 {
+    //@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));
+        }
+    }
+    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;
+    }
+}

package/esm/src/entity.d.ts

@@ -0,0 +1,82 @@
+import { Allowed, AllowedForInstance } from "./context";
+import { FieldMetadata as FieldMetadata } from './column-interfaces';
+import { EntityOrderBy, FieldsMetadata, EntityFilter, EntityRef } 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
+     * @see [allowed](http://remult.dev/docs/allowed.html)*/
+    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.
+    * @example
+    * apiPrefilter: { 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 it's 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: FieldsMetadata<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/src/entity.js

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

package/esm/src/filter/filter-consumer-bridge-to-sql-request.d.ts

@@ -0,0 +1,50 @@
+import { SqlCommand } from "../sql-command";
+import { Filter, FilterConsumer } from './filter-interfaces';
+import { FieldMetadata } from "../column-interfaces";
+import { EntityMetadata } from "../remult3/remult3";
+export declare class FilterConsumerBridgeToSqlRequest implements FilterConsumer {
+    private r;
+    private nameProvider;
+    private where;
+    _addWhere: boolean;
+    promises: Promise<void>[];
+    resolveWhere(): Promise<string>;
+    constructor(r: SqlCommand, nameProvider: dbNameProvider);
+    custom(key: string, customItem: any): void;
+    or(orElements: Filter[]): void;
+    isNull(col: FieldMetadata): void;
+    isNotNull(col: FieldMetadata): void;
+    isIn(col: FieldMetadata, val: any[]): void;
+    isEqualTo(col: FieldMetadata, val: any): void;
+    isDifferentFrom(col: FieldMetadata, val: any): void;
+    isGreaterOrEqualTo(col: FieldMetadata, val: any): void;
+    isGreaterThan(col: FieldMetadata, val: any): void;
+    isLessOrEqualTo(col: FieldMetadata, val: any): void;
+    isLessThan(col: FieldMetadata, val: any): void;
+    containsCaseInsensitive(col: FieldMetadata, val: any): void;
+    private add;
+    private addToWhere;
+    databaseCustom(databaseCustom: CustomSqlFilterObject): void;
+}
+export declare type CustomSqlFilterBuilderFunction = (builder: CustomSqlFilterBuilder) => void | Promise<any>;
+export interface CustomSqlFilterObject {
+    buildSql: CustomSqlFilterBuilderFunction;
+}
+export declare class CustomSqlFilterBuilder {
+    private r;
+    constructor(r: SqlCommand);
+    sql: string;
+    addParameterAndReturnSqlToken<valueType>(val: valueType, field?: FieldMetadata<valueType>): string;
+}
+export declare function getDbNameProvider(meta: EntityMetadata): Promise<dbNameProvider>;
+export declare class dbNameProviderImpl {
+    map: Map<string, string>;
+    nameOf(field: FieldMetadata<any>): string;
+    entityName: string;
+    isDbReadonly(x: FieldMetadata): boolean;
+}
+export interface dbNameProvider {
+    nameOf(field: FieldMetadata<any>): string;
+    entityName: string;
+    isDbReadonly(x: FieldMetadata): boolean;
+}

package/esm/src/filter/filter-consumer-bridge-to-sql-request.js

@@ -0,0 +1,139 @@
+export class FilterConsumerBridgeToSqlRequest {
+    constructor(r, nameProvider) {
+        this.r = r;
+        this.nameProvider = nameProvider;
+        this.where = "";
+        this._addWhere = true;
+        this.promises = [];
+    }
+    async resolveWhere() {
+        while (this.promises.length > 0) {
+            let p = this.promises;
+            this.promises = [];
+            for (const pr of p) {
+                await pr;
+            }
+        }
+        return this.where;
+    }
+    custom(key, customItem) {
+        throw new Error("Custom filter should be translated before it gets here");
+    }
+    or(orElements) {
+        let statement = '';
+        this.promises.push((async () => {
+            for (const element of orElements) {
+                let f = new FilterConsumerBridgeToSqlRequest(this.r, this.nameProvider);
+                f._addWhere = false;
+                element.__applyToConsumer(f);
+                let where = await f.resolveWhere();
+                if (!where)
+                    return; //since if any member of or is empty, then the entire or is irrelevant
+                if (where.length > 0) {
+                    if (statement.length > 0) {
+                        statement += " or ";
+                    }
+                    if (orElements.length > 1) {
+                        statement += "(" + where + ")";
+                    }
+                    else
+                        statement += where;
+                }
+            }
+            this.addToWhere("(" + statement + ")");
+        })());
+    }
+    isNull(col) {
+        this.promises.push((async () => this.addToWhere(this.nameProvider.nameOf(col) + ' is null'))());
+    }
+    isNotNull(col) {
+        this.promises.push((async () => this.addToWhere(this.nameProvider.nameOf(col) + ' is not null'))());
+    }
+    isIn(col, val) {
+        this.promises.push((async () => {
+            if (val && val.length > 0)
+                this.addToWhere(this.nameProvider.nameOf(col) + " in (" + val.map(x => this.r.addParameterAndReturnSqlToken(col.valueConverter.toDb(x))).join(",") + ")");
+            else
+                this.addToWhere('1 = 0 /*isIn with no values*/');
+        })());
+    }
+    isEqualTo(col, val) {
+        this.add(col, val, "=");
+    }
+    isDifferentFrom(col, val) {
+        this.add(col, val, "<>");
+    }
+    isGreaterOrEqualTo(col, val) {
+        this.add(col, val, ">=");
+    }
+    isGreaterThan(col, val) {
+        this.add(col, val, ">");
+    }
+    isLessOrEqualTo(col, val) {
+        this.add(col, val, "<=");
+    }
+    isLessThan(col, val) {
+        this.add(col, val, "<");
+    }
+    containsCaseInsensitive(col, val) {
+        this.promises.push((async () => {
+            this.addToWhere('lower (' + this.nameProvider.nameOf(col) + ") like lower ('%" + val.replace(/'/g, '\'\'') + "%')");
+        })());
+    }
+    add(col, val, operator) {
+        this.promises.push((async () => {
+            let x = this.nameProvider.nameOf(col) + ' ' + operator + ' ' + this.r.addParameterAndReturnSqlToken(col.valueConverter.toDb(val));
+            this.addToWhere(x);
+        })());
+    }
+    addToWhere(x) {
+        if (this.where.length == 0) {
+            if (this._addWhere)
+                this.where += ' where ';
+        }
+        else
+            this.where += ' and ';
+        this.where += x;
+    }
+    databaseCustom(databaseCustom) {
+        this.promises.push((async () => {
+            if (databaseCustom?.buildSql) {
+                let item = new CustomSqlFilterBuilder(this.r);
+                await databaseCustom.buildSql(item);
+                if (item.sql) {
+                    this.addToWhere("(" + item.sql + ")");
+                }
+            }
+        })());
+    }
+}
+export class CustomSqlFilterBuilder {
+    constructor(r) {
+        this.r = r;
+        this.sql = '';
+    }
+    addParameterAndReturnSqlToken(val, field) {
+        if (field)
+            val = field.valueConverter.toDb(val);
+        return this.r.addParameterAndReturnSqlToken(val);
+    }
+}
+export async function getDbNameProvider(meta) {
+    var result = new dbNameProviderImpl();
+    for (const f of meta.fields) {
+        result.map.set(f.key, await f.getDbName());
+    }
+    result.entityName = await meta.getDbName();
+    return result;
+}
+export class dbNameProviderImpl {
+    constructor() {
+        this.map = new Map();
+    }
+    nameOf(field) {
+        return this.map.get(field.key);
+    }
+    isDbReadonly(x) {
+        return (x.dbReadOnly || x.isServerExpression || this.nameOf(x) != x.options.dbName);
+    }
+}

package/esm/src/filter/filter-consumer-bridge-to-url-builder.d.ts

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

package/esm/src/filter/filter-consumer-bridge-to-url-builder.js

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