@technicity/data-service-generator 0.2.8 → 0.4.1

package/dist/ksql.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KSQL = void 0;
+const http2 = require("http2");
+class KSQL {
+    constructor(options) {
+        this.hostname = options.hostname;
+        this.port = options.port;
+    }
+    async streamQuery(s) {
+        return new Promise((resolve, reject) => {
+            const reqBody = JSON.stringify({
+                sql: s,
+                properties: {
+                    "ksql.streams.auto.offset.reset": "earliest",
+                    "ksql.query.pull.table.scan.enabled": true,
+                },
+            });
+            const client = http2.connect(`http://${this.hostname}:${this.port}`);
+            const req = client.request({
+                [http2.constants.HTTP2_HEADER_SCHEME]: "https",
+                "Content-Type": "application/json",
+                "Content-Length": reqBody.length,
+                ":method": "POST",
+                ":path": `/query-stream`,
+            });
+            req.setEncoding("utf8");
+            let columnNames = [];
+            let rows = [];
+            req.on("data", (d) => {
+                const resData = JSON.parse(d);
+                if (resData.error_code) {
+                    return reject(new Error(resData.message));
+                }
+                if (resData.columnNames) {
+                    columnNames = resData.columnNames;
+                }
+                else {
+                    let out = {};
+                    resData.forEach((rd, i) => {
+                        out[columnNames[i]] = rd;
+                    });
+                    rows.push(out);
+                }
+            });
+            req.on("close", () => resolve(rows));
+            req.on("error", (error) => reject(error));
+            req.write(reqBody);
+            req.end();
+        });
+    }
+}
+exports.KSQL = KSQL;

package/dist/mysql.d.ts

@@ -0,0 +1,2 @@
+export function init(opts: any): void;
+export function query(...args: any[]): any;

package/dist/mysql.js

@@ -14,9 +14,6 @@ async function getConnection() {
         .disposer((connection) => connection.release());
 }
 // http://bluebirdjs.com/docs/api/promise.using.html
-// Don't use `async` keyword. Need to return Bluebird promise for compat,
-// since there are services doing e.g. promise.map and promise.tap, which are
-// specific to Bluebird.
 function query(...args) {
     return Promise.using(getConnection(), (connection) => connection.queryAsync(...args));
 }

package/dist/runTransforms.d.ts

@@ -0,0 +1,2 @@
+import type { IGetSQLASTInput } from "./types";
+export declare function runTransforms(data: any, fields: IGetSQLASTInput["fields"]): void;

package/dist/runtime/IRuntime.d.ts

@@ -0,0 +1,47 @@
+import { IArtifacts, IGetSQLASTInput } from "../types";
+export interface IRuntime {
+    resolve(input: TResolveInput): Promise<any>;
+    post(input: TPostInput): Promise<any>;
+    patch(input: TPatchInput): Promise<any>;
+    patchList(input: TPatchListInput): Promise<any>;
+    del(input: TDelInput): Promise<any>;
+    deleteList(input: TDeleteListInput): Promise<any>;
+    whereNeedsProcessing(where: any): boolean;
+    _prepareWhere(artifacts: IArtifacts, table: string, data: any): Promise<any>;
+}
+export declare type TResolveInput = Omit<IGetSQLASTInput, "getWhere" | "where" | "dialect"> & {
+    fields: IGetSQLASTInput["fields"] | undefined;
+    kind?: "list" | "listPaginated";
+};
+export declare type TPostInput = {
+    table: TResolveInput["table"];
+    data: any;
+    artifacts: TResolveInput["artifacts"];
+    fields: TResolveInput["fields"];
+    fieldName: TResolveInput["fieldName"];
+};
+export declare type TPatchInput = {
+    table: TResolveInput["table"];
+    args: TResolveInput["args"];
+    data: any;
+    artifacts: TResolveInput["artifacts"];
+    fields: TResolveInput["fields"];
+    fieldName: TResolveInput["fieldName"];
+};
+export declare type TPatchListInput = {
+    table: TResolveInput["table"];
+    args: TResolveInput["args"];
+    data: any;
+    artifacts: TResolveInput["artifacts"];
+    fields: TResolveInput["fields"];
+    fieldName: TResolveInput["fieldName"];
+};
+export declare type TDelInput = {
+    table: TResolveInput["table"];
+    args: TResolveInput["args"];
+};
+export declare type TDeleteListInput = {
+    table: TResolveInput["table"];
+    args: TResolveInput["args"];
+    artifacts: IArtifacts;
+};

package/dist/runtime/RuntimeKSQL.d.ts

@@ -0,0 +1,19 @@
+import type { IRuntime, TResolveInput, TPatchInput, TPatchListInput, TPostInput, TDelInput, TDeleteListInput } from "./IRuntime";
+import type { IArtifacts, ISupplementClientOpts } from "../types";
+import { KSQL } from "../ksql";
+import { MSSQL } from "./__MSSQL";
+export declare class RuntimeKSQL implements IRuntime {
+    #private;
+    constructor(clientOpts: ConstructorParameters<typeof KSQL>[0], otherOpts: {
+        mssql: ConstructorParameters<typeof MSSQL>[0];
+        supplementClientOpts?: ISupplementClientOpts;
+    }, artifacts: IArtifacts);
+    resolve(input: TResolveInput): Promise<any>;
+    post(input: TPostInput): Promise<void>;
+    patch(input: TPatchInput): Promise<void>;
+    patchList(input: TPatchListInput): Promise<void>;
+    del(input: TDelInput): Promise<void>;
+    deleteList(input: TDeleteListInput): Promise<void>;
+    whereNeedsProcessing(where: any): boolean;
+    _prepareWhere(artifacts: IArtifacts, table: string, data: any): Promise<{}>;
+}

package/dist/runtime/RuntimeKSQL.js

@@ -0,0 +1,128 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _ksql, _mssqlClient, _tableKeyMap;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeKSQL = void 0;
+const SqlString = require("sqlstring");
+const __shared_1 = require("./__shared");
+const getWhere_1 = require("../getWhere");
+const ksql_1 = require("../ksql");
+const SDKNotFoundError_1 = require("../SDKNotFoundError");
+const __MSSQL_1 = require("./__MSSQL");
+const __typeCastMSSQL_1 = require("./__typeCastMSSQL");
+class RuntimeKSQL {
+    constructor(clientOpts, otherOpts, artifacts) {
+        _ksql.set(this, void 0);
+        _mssqlClient.set(this, void 0);
+        _tableKeyMap.set(this, void 0);
+        __classPrivateFieldSet(this, _ksql, new ksql_1.KSQL(clientOpts));
+        __classPrivateFieldSet(this, _mssqlClient, new __MSSQL_1.MSSQL(otherOpts.mssql, otherOpts?.supplementClientOpts ? __typeCastMSSQL_1.typeCastMSSQL() : undefined));
+        __classPrivateFieldSet(this, _tableKeyMap, {});
+        for (let table in artifacts) {
+            let map = {};
+            for (let kk of artifacts[table].scalarFields) {
+                map[kk.toLocaleUpperCase()] = kk;
+            }
+            __classPrivateFieldGet(this, _tableKeyMap)[table] = map;
+        }
+    }
+    async resolve(input) {
+        if (input.kind === "list" || input.kind === "listPaginated") {
+            const primaryKey = input.artifacts[input.table].primaryKey;
+            // Overwrite
+            input.fields = [primaryKey];
+            const resolved = await __shared_1.resolve(input, __classPrivateFieldGet(this, _mssqlClient).dbCall.bind(__classPrivateFieldGet(this, _mssqlClient)), __classPrivateFieldGet(this, _mssqlClient).formatQuery.bind(__classPrivateFieldGet(this, _mssqlClient)), { dialect: "mssql" });
+            const keys = input.kind === "list"
+                ? resolved.map((x) => x[primaryKey])
+                : resolved.results.map((x) => x[primaryKey]);
+            if (keys.length === 0) {
+                return resolved;
+            }
+            const sql = SqlString.format("SELECT * FROM ?? WHERE ?? IN (?);", [
+                getKSQLTablename(input.table),
+                primaryKey.toLocaleUpperCase(),
+                keys,
+            ]);
+            const results = await __classPrivateFieldGet(this, _ksql).streamQuery(sql);
+            for (let x of results) {
+                mapKeys(x, __classPrivateFieldGet(this, _tableKeyMap)[input.table]);
+            }
+            if (input.kind == "list") {
+                return results;
+            }
+            resolved.results = results;
+            return resolved;
+        }
+        else {
+            const table = input.table;
+            const tableKSQL = getKSQLTablename(input.table);
+            if (input.args?.$where) {
+                for (let k in input.args.$where) {
+                    input.args.$where[k.toLocaleUpperCase()] = input.args.$where[k];
+                    delete input.args.$where[k];
+                }
+            }
+            const where = getWhere_1.getWhere(tableKSQL, input.args, "mysql");
+            if (!where) {
+                throw new Error("Invalid $where");
+            }
+            const sql = SqlString.format(`SELECT * FROM ?? WHERE ${where};`, [
+                tableKSQL,
+            ]);
+            let out = await __classPrivateFieldGet(this, _ksql).streamQuery(sql).then((xs) => xs[0]);
+            if (out == null) {
+                throw new SDKNotFoundError_1.SDKNotFoundError();
+            }
+            mapKeys(out, __classPrivateFieldGet(this, _tableKeyMap)[table]);
+            return out;
+        }
+    }
+    async post(input) {
+        throw new Error("Not implemented.");
+    }
+    async patch(input) {
+        throw new Error("Not implemented.");
+    }
+    async patchList(input) {
+        throw new Error("Not implemented.");
+    }
+    async del(input) {
+        throw new Error("Not implemented.");
+    }
+    async deleteList(input) {
+        throw new Error("Not implemented.");
+    }
+    whereNeedsProcessing(where) {
+        return __shared_1.whereNeedsProcessing(where);
+    }
+    async _prepareWhere(artifacts, table, data) {
+        return __shared_1._prepareWhere(artifacts, table, data, __classPrivateFieldGet(this, _mssqlClient).dbCall.bind(__classPrivateFieldGet(this, _mssqlClient)), __classPrivateFieldGet(this, _mssqlClient).formatQuery.bind(__classPrivateFieldGet(this, _mssqlClient)));
+    }
+}
+exports.RuntimeKSQL = RuntimeKSQL;
+_ksql = new WeakMap(), _mssqlClient = new WeakMap(), _tableKeyMap = new WeakMap();
+function getKSQLTablename(tablename) {
+    return `${tablename.toLocaleUpperCase()}_TAB`;
+}
+// Mutates item
+function mapKeys(item, keyMap) {
+    for (let k in item) {
+        const v = keyMap[k];
+        if (v) {
+            item[v] = item[k];
+            delete item[k];
+        }
+    }
+}

package/dist/runtime/RuntimeMSSQL.d.ts

@@ -0,0 +1,21 @@
+import * as mssql from "mssql";
+import type { IRuntime, TResolveInput, TPatchInput, TPatchListInput, TPostInput, TDelInput, TDeleteListInput } from "./IRuntime";
+import type { IArtifacts, ISupplementClientOpts } from "../types";
+import { typeCastMSSQL } from "./__typeCastMSSQL";
+export declare class RuntimeMSSQL implements IRuntime {
+    #private;
+    constructor(clientOpts: mssql.config, otherOpts: {
+        supplementClientOpts?: ISupplementClientOpts;
+        typeCast?: Parameters<typeof typeCastMSSQL>[0];
+    }, artifacts: IArtifacts);
+    resolve(input: TResolveInput): Promise<any>;
+    post(input: TPostInput): Promise<any>;
+    patch(input: TPatchInput): Promise<any>;
+    patchList(input: TPatchListInput): Promise<any>;
+    del(input: TDelInput): Promise<boolean>;
+    deleteList(input: TDeleteListInput): Promise<boolean>;
+    whereNeedsProcessing(where: any): boolean;
+    _prepareWhere(artifacts: IArtifacts, table: string, data: any): Promise<{}>;
+    private dbCall;
+    private formatQuery;
+}

package/dist/runtime/RuntimeMSSQL.js

@@ -0,0 +1,88 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _dialect, _mssqlClient;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeMSSQL = void 0;
+const __shared_1 = require("./__shared");
+const __MSSQL_1 = require("./__MSSQL");
+const __typeCastMSSQL_1 = require("./__typeCastMSSQL");
+class RuntimeMSSQL {
+    constructor(clientOpts, otherOpts, artifacts) {
+        _dialect.set(this, "mssql");
+        _mssqlClient.set(this, void 0);
+        __classPrivateFieldSet(this, _mssqlClient, new __MSSQL_1.MSSQL(clientOpts, otherOpts?.supplementClientOpts
+            ? __typeCastMSSQL_1.typeCastMSSQL(otherOpts?.typeCast)
+            : undefined));
+    }
+    async resolve(input) {
+        return __shared_1.resolve(input, this.dbCall.bind(this), this.formatQuery.bind(this), {
+            dialect: __classPrivateFieldGet(this, _dialect),
+        });
+    }
+    async post(input) {
+        return __shared_1.post({
+            ...input,
+            dbCall: this.dbCall.bind(this),
+            formatQuery: this.formatQuery.bind(this),
+            dialect: __classPrivateFieldGet(this, _dialect),
+        });
+    }
+    async patch(input) {
+        return __shared_1.patch({
+            ...input,
+            dbCall: this.dbCall.bind(this),
+            formatQuery: this.formatQuery.bind(this),
+            dialect: __classPrivateFieldGet(this, _dialect),
+        });
+    }
+    async patchList(input) {
+        return __shared_1.patchList({
+            ...input,
+            dbCall: this.dbCall.bind(this),
+            formatQuery: this.formatQuery.bind(this),
+            dialect: __classPrivateFieldGet(this, _dialect),
+        });
+    }
+    async del(input) {
+        return __shared_1.del({
+            ...input,
+            dbCall: this.dbCall.bind(this),
+            formatQuery: this.formatQuery.bind(this),
+            dialect: __classPrivateFieldGet(this, _dialect),
+        });
+    }
+    async deleteList(input) {
+        return __shared_1.deleteList({
+            ...input,
+            dbCall: this.dbCall.bind(this),
+            formatQuery: this.formatQuery.bind(this),
+            dialect: __classPrivateFieldGet(this, _dialect),
+        });
+    }
+    whereNeedsProcessing(where) {
+        return __shared_1.whereNeedsProcessing(where);
+    }
+    async _prepareWhere(artifacts, table, data) {
+        return __shared_1._prepareWhere(artifacts, table, data, this.dbCall.bind(this), this.formatQuery.bind(this));
+    }
+    async dbCall(q) {
+        return __classPrivateFieldGet(this, _mssqlClient).dbCall(q);
+    }
+    formatQuery(q, values) {
+        return __classPrivateFieldGet(this, _mssqlClient).formatQuery(q, values);
+    }
+}
+exports.RuntimeMSSQL = RuntimeMSSQL;
+_dialect = new WeakMap(), _mssqlClient = new WeakMap();

package/dist/runtime/RuntimeMySQL.d.ts

@@ -0,0 +1,20 @@
+import type { IRuntime, TResolveInput, TPatchInput, TPostInput, TPatchListInput, TDelInput, TDeleteListInput } from "./IRuntime";
+import type { IArtifacts, ISupplementClientOpts } from "../types";
+export declare class RuntimeMySQL implements IRuntime {
+    #private;
+    constructor(clientOpts: {
+        [k: string]: any;
+    }, otherOpts: {
+        supplementClientOpts?: ISupplementClientOpts;
+    }, artifacts: IArtifacts);
+    resolve(input: TResolveInput): Promise<any>;
+    post(input: TPostInput): Promise<any>;
+    patch(input: TPatchInput): Promise<any>;
+    patchList(input: TPatchListInput): Promise<any>;
+    del(input: TDelInput): Promise<boolean>;
+    deleteList(input: TDeleteListInput): Promise<boolean>;
+    whereNeedsProcessing(where: any): boolean;
+    _prepareWhere(artifacts: IArtifacts, table: string, data: any): Promise<{}>;
+    private dbCall;
+    private formatQuery;
+}

package/dist/runtime/RuntimeMySQL.js

@@ -0,0 +1,117 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _dialect;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeMySQL = void 0;
+const SqlString = require("sqlstring");
+const mysql_1 = require("../mysql");
+const __shared_1 = require("./__shared");
+class RuntimeMySQL {
+    constructor(clientOpts, otherOpts, artifacts) {
+        _dialect.set(this, "mysql");
+        if (otherOpts.supplementClientOpts) {
+            clientOpts = {
+                supportBigNumbers: true,
+                typeCast: (field, next) => {
+                    if (field.type == "TINY" && field.length == 1) {
+                        return field.string() == "1";
+                    }
+                    // if (field.type === "DATE") {
+                    //   return field.string();
+                    // }
+                    // if (
+                    //   field.type === "TIMESTAMP" ||
+                    //   field.type === "DATE" ||
+                    //   field.type === "DATETIME"
+                    // ) {
+                    //   return new Date(field.string()).toISOString();
+                    // }
+                    if (field.type === "VAR_STRING" || field.type === "STRING") {
+                        return field.string();
+                    }
+                    return next();
+                },
+                ...clientOpts,
+            };
+        }
+        else {
+            clientOpts = {
+                typeCast: (field, next) => {
+                    if (field.type == "TINY" && field.length == 1) {
+                        return field.string() == "1";
+                    }
+                    if (field.type === "VAR_STRING" || field.type === "STRING") {
+                        return field.string();
+                    }
+                    return next();
+                },
+                ...clientOpts,
+            };
+        }
+        mysql_1.init(clientOpts);
+    }
+    async resolve(input) {
+        return __shared_1.resolve(input, this.dbCall.bind(this), this.formatQuery.bind(this), {
+            dialect: __classPrivateFieldGet(this, _dialect),
+        });
+    }
+    async post(input) {
+        return __shared_1.post({
+            ...input,
+            dbCall: this.dbCall.bind(this),
+            formatQuery: this.formatQuery.bind(this),
+            dialect: __classPrivateFieldGet(this, _dialect),
+        });
+    }
+    async patch(input) {
+        return __shared_1.patch({
+            ...input,
+            dbCall: this.dbCall.bind(this),
+            formatQuery: this.formatQuery.bind(this),
+            dialect: __classPrivateFieldGet(this, _dialect),
+        });
+    }
+    async patchList(input) {
+        return __shared_1.patchList({
+            ...input,
+            dbCall: this.dbCall.bind(this),
+            formatQuery: this.formatQuery.bind(this),
+            dialect: __classPrivateFieldGet(this, _dialect),
+        });
+    }
+    async del(input) {
+        return __shared_1.del({
+            ...input,
+            dbCall: this.dbCall.bind(this),
+            formatQuery: this.formatQuery.bind(this),
+            dialect: __classPrivateFieldGet(this, _dialect),
+        });
+    }
+    async deleteList(input) {
+        return __shared_1.deleteList({
+            ...input,
+            dbCall: this.dbCall.bind(this),
+            formatQuery: this.formatQuery.bind(this),
+            dialect: __classPrivateFieldGet(this, _dialect),
+        });
+    }
+    whereNeedsProcessing(where) {
+        return __shared_1.whereNeedsProcessing(where);
+    }
+    async _prepareWhere(artifacts, table, data) {
+        return __shared_1._prepareWhere(artifacts, table, data, this.dbCall.bind(this), this.formatQuery.bind(this));
+    }
+    dbCall(q) {
+        return mysql_1.query(q);
+    }
+    formatQuery(q, values) {
+        return SqlString.format(q, values);
+    }
+}
+exports.RuntimeMySQL = RuntimeMySQL;
+_dialect = new WeakMap();

package/dist/runtime/__MSSQL.d.ts

@@ -0,0 +1,7 @@
+import * as mssql from "mssql";
+export declare class MSSQL {
+    #private;
+    constructor(clientOpts: mssql.config, typeCast?: Function);
+    dbCall(q: string): Promise<any>;
+    formatQuery(q: string, values: any[]): any;
+}

package/dist/runtime/__MSSQL.js

@@ -0,0 +1,46 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to set private field on non-instance");
+    }
+    privateMap.set(receiver, value);
+    return value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return privateMap.get(receiver);
+};
+var _pool, _poolConnect, _typeCast;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MSSQL = void 0;
+const mssql = require("mssql");
+// @ts-ignore
+const TSqlString = require("tsqlstring");
+class MSSQL {
+    constructor(clientOpts, typeCast) {
+        _pool.set(this, void 0);
+        _poolConnect.set(this, void 0);
+        _typeCast.set(this, void 0);
+        __classPrivateFieldSet(this, _typeCast, typeCast);
+        __classPrivateFieldSet(this, _pool, new mssql.ConnectionPool(clientOpts));
+        __classPrivateFieldSet(this, _poolConnect, __classPrivateFieldGet(this, _pool).connect());
+    }
+    async dbCall(q) {
+        await __classPrivateFieldGet(this, _poolConnect);
+        const request = __classPrivateFieldGet(this, _pool).request();
+        const result = await request.query(q);
+        // TODO: see https://github.com/tediousjs/node-mssql/pull/1171
+        const meta = result.recordset?.columns;
+        if (meta != null && typeof __classPrivateFieldGet(this, _typeCast) === "function") {
+            return __classPrivateFieldGet(this, _typeCast).call(this, result, meta);
+        }
+        return result.recordset;
+    }
+    formatQuery(q, values) {
+        return TSqlString.format(q, values);
+    }
+}
+exports.MSSQL = MSSQL;
+_pool = new WeakMap(), _poolConnect = new WeakMap(), _typeCast = new WeakMap();

package/dist/runtime/__shared.d.ts

@@ -0,0 +1,32 @@
+import type { IArtifacts, IDialect, TDbCall, TFormatQuery } from "../types";
+import { TResolveInput, TPatchInput, TPatchListInput, TPostInput, TDelInput, TDeleteListInput } from "./IRuntime";
+export declare function resolve(input: TResolveInput, dbCall: TDbCall, formatQuery: TFormatQuery, options: {
+    dialect: IDialect;
+}): Promise<any>;
+export declare function post(input: TPostInput & {
+    dialect: IDialect;
+    dbCall: TDbCall;
+    formatQuery: TFormatQuery;
+}): Promise<any>;
+export declare function patch(input: TPatchInput & {
+    dialect: IDialect;
+    dbCall: TDbCall;
+    formatQuery: TFormatQuery;
+}): Promise<any>;
+export declare function patchList(input: TPatchListInput & {
+    dialect: IDialect;
+    dbCall: TDbCall;
+    formatQuery: TFormatQuery;
+}): Promise<any>;
+export declare function del(input: TDelInput & {
+    dialect: IDialect;
+    dbCall: TDbCall;
+    formatQuery: TFormatQuery;
+}): Promise<boolean>;
+export declare function deleteList(input: TDeleteListInput & {
+    dialect: IDialect;
+    dbCall: TDbCall;
+    formatQuery: TFormatQuery;
+}): Promise<boolean>;
+export declare function whereNeedsProcessing(where: any): boolean;
+export declare function _prepareWhere(artifacts: IArtifacts, table: string, data: any, dbCall: TDbCall, formatQuery: TFormatQuery): Promise<{}>;