remult 0.17.3 → 0.18.0

package/esm/src/data-api.js

@@ -1,23 +1,38 @@
 import { customUrlToken, buildFilterFromRequestParameters } from './filter/filter-interfaces';
+import { doTransaction } from './context';
 import { Filter } from './filter/filter-interfaces';
+import { ForbiddenError } from './server-action';
+import { getId } from './remult3/getId';
+import { findOptionsToJson, liveQueryAction } from './data-providers/rest-data-provider';
 export class DataApi {
     constructor(repository, remult) {
         this.repository = repository;
         this.remult = remult;
     }
-    httpGet(res, req) {
-        if (req.get("__action") == "count") {
-            return this.count(res, req);
+    httpGet(res, req, serializeRequest) {
+        const action = req?.get("__action");
+        if (action?.startsWith(liveQueryAction))
+            return this.liveQuery(res, req, undefined, serializeRequest, getLiveQueryChannel(action.substring(liveQueryAction.length), this.remult.user?.id));
+        switch (action) {
+            case "get":
+            case "count":
+                return this.count(res, req, undefined);
         }
-        else
-            return this.getArray(res, req);
+        return this.getArray(res, req, undefined);
     }
-    httpPost(res, req, body) {
-        switch (req.get("__action")) {
+    async httpPost(res, req, body, serializeRequest) {
+        const action = req?.get("__action");
+        if (action?.startsWith(liveQueryAction))
+            return this.liveQuery(res, req, undefined, serializeRequest, getLiveQueryChannel(action.substring(liveQueryAction.length), this.remult.user?.id));
+        switch (action) {
             case "get":
                 return this.getArray(res, req, body);
             case "count":
                 return this.count(res, req, body);
+            case "endLiveQuery":
+                await this.remult.liveQueryStorage.remove(getLiveQueryChannel(body.id, this.remult.user?.id));
+                res.success("ok");
+                return;
             default:
                 return this.post(res, body);
         }
@@ -41,61 +56,95 @@ export class DataApi {
             response.error(err);
         }
     }
+    async getArrayImpl(response, request, filterBody) {
+        let findOptions = { load: () => [] };
+        findOptions.where = await this.buildWhere(request, filterBody);
+        if (request) {
+            let sort = request.get("_sort");
+            if (sort != undefined) {
+                let dir = request.get('_order');
+                findOptions.orderBy = determineSort(sort, dir);
+            }
+            let limit = +request.get("_limit");
+            if (!limit && DataApi.defaultGetLimit)
+                limit = DataApi.defaultGetLimit;
+            findOptions.limit = limit;
+            findOptions.page = +request.get("_page");
+        }
+        if (this.remult.isAllowed(this.repository.metadata.options.apiRequireId)) {
+            let hasId = false;
+            let w = await Filter.fromEntityFilter(this.repository.metadata, findOptions.where);
+            if (w) {
+                w.__applyToConsumer({
+                    containsCaseInsensitive: () => { },
+                    isDifferentFrom: () => { },
+                    isEqualTo: (col, val) => {
+                        if (this.repository.metadata.idMetadata.isIdField(col))
+                            hasId = true;
+                    },
+                    custom: () => { },
+                    databaseCustom: () => { },
+                    isGreaterOrEqualTo: () => { },
+                    isGreaterThan: () => { },
+                    isIn: () => { },
+                    isLessOrEqualTo: () => { },
+                    isLessThan: () => { },
+                    isNotNull: () => { },
+                    isNull: () => { },
+                    or: () => { }
+                });
+            }
+            if (!hasId) {
+                response.forbidden();
+                throw new ForbiddenError();
+            }
+        }
+        const r = await this.repository.find(findOptions)
+            .then(async (r) => {
+            return await Promise.all(r.map(async (y) => this.repository.getEntityRef(y).toApiJson()));
+        });
+        return { r, findOptions };
+    }
     async getArray(response, request, filterBody) {
         if (!this.repository.metadata.apiReadAllowed) {
             response.forbidden();
             return;
         }
         try {
-            let findOptions = { load: () => [] };
-            findOptions.where = await this.buildWhere(request, filterBody);
-            if (this.remult.isAllowed(this.repository.metadata.options.apiRequireId)) {
-                let hasId = false;
-                let w = await Filter.fromEntityFilter(this.repository.metadata, findOptions.where);
-                if (w) {
-                    w.__applyToConsumer({
-                        containsCaseInsensitive: () => { },
-                        isDifferentFrom: () => { },
-                        isEqualTo: (col, val) => {
-                            if (this.repository.metadata.idMetadata.isIdField(col))
-                                hasId = true;
-                        },
-                        custom: () => { },
-                        databaseCustom: () => { },
-                        isGreaterOrEqualTo: () => { },
-                        isGreaterThan: () => { },
-                        isIn: () => { },
-                        isLessOrEqualTo: () => { },
-                        isLessThan: () => { },
-                        isNotNull: () => { },
-                        isNull: () => { },
-                        or: () => { }
-                    });
-                }
-                if (!hasId) {
-                    response.forbidden();
-                    return;
-                }
-            }
-            if (request) {
-                let sort = request.get("_sort");
-                if (sort != undefined) {
-                    let dir = request.get('_order');
-                    findOptions.orderBy = determineSort(sort, dir);
-                }
-                let limit = +request.get("_limit");
-                if (!limit && DataApi.defaultGetLimit)
-                    limit = DataApi.defaultGetLimit;
-                findOptions.limit = limit;
-                findOptions.page = +request.get("_page");
-            }
-            await this.repository.find(findOptions)
-                .then(async (r) => {
-                response.success(await Promise.all(r.map(async (y) => this.repository.getEntityRef(y).toApiJson())));
+            const { r } = await this.getArrayImpl(response, request, filterBody);
+            response.success(r);
+        }
+        catch (err) {
+            if (err.isForbiddenError)
+                response.forbidden();
+            else
+                response.error(err);
+        }
+    }
+    async liveQuery(response, request, filterBody, serializeRequest, queryChannel) {
+        if (!this.repository.metadata.apiReadAllowed) {
+            response.forbidden();
+            return;
+        }
+        try {
+            const r = await this.getArrayImpl(response, request, filterBody);
+            const data = {
+                requestJson: serializeRequest(),
+                findOptionsJson: findOptionsToJson(r.findOptions, this.repository.metadata),
+                lastIds: r.r.map(y => getId(this.repository.metadata, y))
+            };
+            await this.remult.liveQueryStorage.add({
+                entityKey: this.repository.metadata.key,
+                id: queryChannel,
+                data
             });
+            response.success(r.r);
         }
         catch (err) {
-            response.error(err);
+            if (err.isForbiddenError)
+                response.forbidden();
+            else
+                response.error(err);
         }
     }
     async buildWhere(request, filterBody) {
@@ -146,8 +195,8 @@ export class DataApi {
                 response.forbidden();
                 return;
             }
-            await this.repository.getEntityRef(row).save();
-            response.success(this.repository.getEntityRef(row).toApiJson());
+            await ref.save();
+            response.success(ref.toApiJson());
         });
     }
     async delete(response, id) {
@@ -162,17 +211,32 @@ export class DataApi {
     }
     async post(response, body) {
         try {
-            let newr = this.repository.create();
-            await this.repository.getEntityRef(newr)._updateEntityBasedOnApi(body);
-            if (!this.repository.getEntityRef(newr).apiInsertAllowed) {
-                response.forbidden();
-                return;
+            const insert = async (what) => {
+                let newr = this.repository.create();
+                await this.repository.getEntityRef(newr)._updateEntityBasedOnApi(what);
+                if (!this.repository.getEntityRef(newr).apiInsertAllowed) {
+                    throw new ForbiddenError();
+                }
+                await this.repository.getEntityRef(newr).save();
+                return this.repository.getEntityRef(newr).toApiJson();
+            };
+            if (Array.isArray(body)) {
+                const result = [];
+                await doTransaction(this.remult, async () => {
+                    for (const item of body) {
+                        result.push(await insert(item));
+                    }
+                });
+                response.created(result);
             }
-            await this.repository.getEntityRef(newr).save();
-            response.created(this.repository.getEntityRef(newr).toApiJson());
+            else
+                response.created(await insert(body));
         }
         catch (err) {
-            response.error(err);
+            if (err.isForbiddenError)
+                response.forbidden();
+            else
+                response.error(err);
         }
     }
 }
@@ -202,3 +266,6 @@ export function serializeError(data) {
         data = { message: x };
     return data;
 }
+export function getLiveQueryChannel(queryId, userId) {
+    return `users:${userId}:queries:${queryId}`;
+}

package/esm/src/data-interfaces.d.ts

@@ -4,7 +4,11 @@ import { EntityMetadata, OmitEB } from './remult3';
 export interface DataProvider {
     getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-    supportsCustomFilter?: boolean;
+    supportsRawFilter?: boolean;
+    ensureSchema?(entities: EntityMetadata[]): Promise<void>;
+}
+export interface Storage {
+    ensureSchema(): Promise<void>;
 }
 export interface EntityDataProvider {
     count(where: Filter): Promise<number>;

package/esm/src/data-providers/array-entity-data-provider.d.ts

@@ -4,7 +4,7 @@ import { EntityMetadata, EntityFilter } from '../remult3';
 export declare class ArrayEntityDataProvider implements EntityDataProvider {
     private entity;
     private rows?;
-    static customFilter(filter: CustomArrayFilter): EntityFilter<any>;
+    static rawFilter(filter: CustomArrayFilter): EntityFilter<any>;
     constructor(entity: EntityMetadata, rows?: any[]);
     private verifyThatRowHasAllNotNullColumns;
     count(where?: Filter): Promise<number>;

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

@@ -12,7 +12,7 @@ export class ArrayEntityDataProvider {
             }
         }
     }
-    static customFilter(filter) {
+    static rawFilter(filter) {
         return {
             [customDatabaseFilterToken]: {
                 arrayFilter: filter
@@ -66,22 +66,7 @@ export class ArrayEntityDataProvider {
             }
             if (options.orderBy) {
                 rows = rows.sort((a, b) => {
-                    let r = 0;
-                    for (let i = 0; i < options.orderBy.Segments.length; i++) {
-                        let seg = options.orderBy.Segments[i];
-                        let left = a[seg.field.key];
-                        let right = b[seg.field.key];
-                        if (left > right)
-                            r = 1;
-                        else if (left < right)
-                            r = -1;
-                        if (r != 0) {
-                            if (seg.isDescending)
-                                r *= -1;
-                            return r;
-                        }
-                    }
-                    return r;
+                    return options.orderBy.compare(a, b);
                 });
             }
             rows = pageArray(rows, options);

package/esm/src/data-providers/rest-data-provider.d.ts

@@ -6,9 +6,9 @@ import { ApiClient } from '../context';
 export declare class RestDataProvider implements DataProvider {
     private apiProvider;
     constructor(apiProvider: () => ApiClient);
-    getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
+    getEntityDataProvider(entity: EntityMetadata): RestEntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-    supportsCustomFilter: boolean;
+    supportsRawFilter: boolean;
 }
 export declare class RestEntityDataProvider implements EntityDataProvider {
     private url;
@@ -18,7 +18,7 @@ export declare class RestEntityDataProvider implements EntityDataProvider {
     translateFromJson(row: any): {};
     translateToJson(row: any): {};
     count(where: Filter): Promise<number>;
-    find(options: EntityDataProviderFindOptions): Promise<Array<any>>;
+    find(options?: EntityDataProviderFindOptions): Promise<Array<any>>;
     update(id: any, data: any): Promise<any>;
     delete(id: any): Promise<void>;
     insert(data: any): Promise<any>;
@@ -36,3 +36,4 @@ export declare class RestDataProviderHttpProviderUsingFetch implements RestDataP
     }): Promise<any>;
 }
 export declare function addFilterToUrlAndReturnTrueIfSuccessful(filter: any, url: UrlBuilder): boolean;
+export declare const liveQueryAction = "liveQuery-";

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

@@ -1,10 +1,11 @@
 import { UrlBuilder } from '../../urlBuilder';
-import { customUrlToken } from '../filter/filter-interfaces';
-import { buildRestDataProvider, retry } from '../context';
+import { customUrlToken, Filter } from '../filter/filter-interfaces';
+import { buildRestDataProvider, retry } from "../buildRestDataProvider";
+import { actionInfo } from '../server-action';
 export class RestDataProvider {
     constructor(apiProvider) {
         this.apiProvider = apiProvider;
-        this.supportsCustomFilter = true;
+        this.supportsRawFilter = true;
     }
     getEntityDataProvider(entity) {
         return new RestEntityDataProvider(() => {
@@ -20,6 +21,29 @@ export class RestDataProvider {
         throw new Error("Method not implemented.");
     }
 }
+//@internal
+export function findOptionsToJson(options, meta) {
+    return {
+        limit: options.limit,
+        page: options.page,
+        where: Filter.entityFilterToJson(meta, options.where),
+        orderBy: options.orderBy
+    };
+}
+//@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];
+        }
+    }
+    return r;
+}
 export class RestEntityDataProvider {
     constructor(url, http, entity) {
         this.url = url;
@@ -41,20 +65,15 @@ export class RestEntityDataProvider {
         return result;
     }
     async count(where) {
-        let url = new UrlBuilder(this.url());
-        url.add("__action", "count");
-        let filterObject;
-        if (where) {
-            filterObject = where.toJson();
-            if (addFilterToUrlAndReturnTrueIfSuccessful(filterObject, url))
-                filterObject = undefined;
-        }
-        if (filterObject)
-            return this.http().post(url.url, filterObject).then(r => +(r.count));
-        else
-            return this.http().get(url.url).then(r => +(r.count));
+        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) {
@@ -82,13 +101,34 @@ export class RestEntityDataProvider {
             if (options.page)
                 url.add('_page', options.page);
         }
-        if (filterObject) {
-            url.add("__action", "get");
-            return this.http().post(url.url, filterObject).then(x => x.map(y => this.translateFromJson(y)));
-        }
-        else
-            return this.http().get(url.url).then(x => x.map(y => this.translateFromJson(y)));
-        ;
+        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 = {};
@@ -186,7 +226,7 @@ export function addFilterToUrlAndReturnTrueIfSuccessful(filter, url) {
         if (Object.prototype.hasOwnProperty.call(filter, key)) {
             const element = filter[key];
             if (Array.isArray(element)) {
-                if (key.endsWith("_in"))
+                if (key.endsWith(".in"))
                     url.add(key, JSON.stringify(element));
                 else
                     element.forEach(e => url.add(key, e));
@@ -199,3 +239,4 @@ export function addFilterToUrlAndReturnTrueIfSuccessful(filter, url) {
     }
     return true;
 }
+export const liveQueryAction = "liveQuery-";

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

@@ -1,14 +1,18 @@
 import { EntityDataProvider, DataProvider } from "../data-interfaces";
-import { SqlCommand, SqlImplementation, SqlResult } from "../sql-command";
+import { SqlCommand, SqlCommandWithParameters, SqlImplementation, SqlResult } from "../sql-command";
 import { CustomSqlFilterBuilderFunction } from "../filter/filter-consumer-bridge-to-sql-request";
-import { EntityMetadata, EntityFilter } from "../remult3";
+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>;
+    ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
     getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
     transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-    static customFilter(build: CustomSqlFilterBuilderFunction): EntityFilter<any>;
+    static rawFilter(build: CustomSqlFilterBuilderFunction): EntityFilter<any>;
+    static filterToRaw<entityType>(repo: RepositoryOverloads<entityType>, condition: EntityFilter<entityType>, sqlCommand?: SqlCommandWithParameters): Promise<string>;
     static LogToConsole: boolean;
     static durationThreshold: number;
     constructor(sql: SqlImplementation);

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

@@ -1,23 +1,39 @@
 import { CompoundIdField } from "../column";
-import { FilterConsumerBridgeToSqlRequest, getDbNameProvider } from "../filter/filter-consumer-bridge-to-sql-request";
+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 { RemultProxy } from "../remult-proxy";
 // @dynamic
 export class SqlDatabase {
     constructor(sql) {
         this.sql = sql;
         this.createdEntities = [];
     }
+    static getDb(remult) {
+        const r = (remult || RemultProxy.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) {
         return new ActualSQLServerDataProvider(entity, this, async (dbName) => {
-            if (this.createdEntities.indexOf(dbName.entityName) < 0) {
-                this.createdEntities.push(dbName.entityName);
+            if (this.createdEntities.indexOf(dbName.$entityName) < 0) {
+                this.createdEntities.push(dbName.$entityName);
                 await this.sql.entityIsUsedForTheFirstTime(entity);
             }
         }, this.sql);
@@ -48,13 +64,23 @@ export class SqlDatabase {
             }
         });
     }
-    static customFilter(build) {
+    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();
+    }
 }
 SqlDatabase.LogToConsole = false;
 SqlDatabase.durationThreshold = 0;
@@ -76,7 +102,7 @@ class LogSQLCommand {
             if (this.allQueries) {
                 var d = new Date().valueOf() - start.valueOf();
                 if (d > SqlDatabase.durationThreshold) {
-                    console.log({ query: sql, arguments: this.args, duration: d / 1000 });
+                    console.info({ query: sql, arguments: this.args, duration: d / 1000 });
                 }
             }
             return r;
@@ -95,13 +121,13 @@ class ActualSQLServerDataProvider {
         this.strategy = strategy;
     }
     async init() {
-        let dbNameProvider = await getDbNameProvider(this.entity);
+        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 select = 'select count(*) count from ' + e.$entityName;
         let r = this.sql.createCommand();
         if (where) {
             let wc = new FilterConsumerBridgeToSqlRequest(r, e);
@@ -116,7 +142,7 @@ class ActualSQLServerDataProvider {
         let e = await this.init();
         let { colKeys, select } = this.buildSelect(e);
         select = 'select ' + select;
-        select += '\n from ' + e.entityName;
+        select += '\n from ' + e.$entityName;
         let r = this.sql.createCommand();
         if (options) {
             if (options.where) {
@@ -147,7 +173,7 @@ class ActualSQLServerDataProvider {
                     }
                     else
                         select += ', ';
-                    select += e.nameOf(c.field);
+                    select += e.$dbNameOf(c.field);
                     if (c.isDescending)
                         select += ' desc';
                 }
@@ -189,7 +215,7 @@ class ActualSQLServerDataProvider {
             else {
                 if (colKeys.length > 0)
                     select += ', ';
-                select += e.nameOf(x);
+                select += e.$dbNameOf(x);
                 colKeys.push(x);
             }
         }
@@ -200,12 +226,12 @@ class ActualSQLServerDataProvider {
         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 statement = 'update ' + e.$entityName + ' set ';
         let added = false;
         for (const x of this.entity.fields) {
             if (x instanceof CompoundIdField) {
             }
-            if (e.isDbReadonly(x)) { }
+            if (isDbReadonly(x, e)) { }
             else if (data[x.key] !== undefined) {
                 let v = x.valueConverter.toDb(data[x.key]);
                 if (v !== undefined) {
@@ -213,7 +239,7 @@ class ActualSQLServerDataProvider {
                         added = true;
                     else
                         statement += ', ';
-                    statement += e.nameOf(x) + ' = ' + r.addParameterAndReturnSqlToken(v);
+                    statement += e.$dbNameOf(x) + ' = ' + r.addParameterAndReturnSqlToken(v);
                 }
             }
         }
@@ -229,7 +255,7 @@ class ActualSQLServerDataProvider {
         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;
+        let statement = 'delete from ' + e.$entityName;
         statement += await f.resolveWhere();
         return r.execute(statement).then(() => { });
     }
@@ -240,7 +266,7 @@ class ActualSQLServerDataProvider {
         let vals = '';
         let added = false;
         for (const x of this.entity.fields) {
-            if (e.isDbReadonly(x)) { }
+            if (isDbReadonly(x, e)) { }
             else {
                 let v = x.valueConverter.toDb(data[x.key]);
                 if (v != undefined) {
@@ -250,15 +276,32 @@ class ActualSQLServerDataProvider {
                         cols += ', ';
                         vals += ', ';
                     }
-                    cols += e.nameOf(x);
+                    cols += e.$dbNameOf(x);
                     vals += r.addParameterAndReturnSqlToken(v);
                 }
             }
         }
-        let statement = `insert into ${e.entityName} (${cols}) values (${vals})`;
+        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;
+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();
+    }
+}