@technicity/data-service-generator 0.10.0-next.0 → 0.10.0-next.1

package/dist/runtime/lib/stringifyWhere.d.ts

@@ -0,0 +1,18 @@
+import type { IOrderBy, IDialect } from "../IRuntime";
+declare type IWhere = {
+    [k: string]: any;
+};
+declare type IArgs = {
+    [k: string]: any;
+};
+export declare function stringifyWhere(input: {
+    where: IWhere;
+    table: string;
+    dialect: IDialect;
+    args: IArgs;
+    orderBy?: IOrderBy | undefined;
+    rowWithMatchingCursor?: any;
+}): string;
+export declare function getEscapeId(dialect: IDialect): any;
+export declare function getEscape(dialect: IDialect): any;
+export {};

package/dist/runtime/lib/stringifyWhere.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEscape = exports.getEscapeId = exports.stringifyWhere = void 0;
+const _ = require("lodash/fp");
+const MySqlString = require("sqlstring");
+// @ts-ignore
+const TSqlString = require("tsqlstring");
+function stringifyWhere(input) {
+    const { where, table, dialect, args, orderBy, rowWithMatchingCursor } = input;
+    const escapeId = getEscapeId(dialect);
+    const escape = getEscape(dialect);
+    let result = _stringifyWhere(where, table, escapeId, escape, "");
+    const paginationWhere = stringifyPaginationWhere({
+        table,
+        args,
+        orderBy,
+        escapeId,
+        escape,
+        rowWithMatchingCursor,
+    });
+    if (paginationWhere) {
+        result =
+            result.length === 0
+                ? paginationWhere
+                : result + " AND " + paginationWhere;
+    }
+    return result;
+}
+exports.stringifyWhere = stringifyWhere;
+function _stringifyWhere(where, table, escapeId, escape, result) {
+    if (Object.prototype.hasOwnProperty.call(where, "$and")) {
+        if (Object.keys(where).length !== 1) {
+            throw new Error("Must have 1 key: " + JSON.stringify(where, null, 2));
+        }
+        const _xs = where.$and.filter((x) => x != null);
+        if (_xs.length === 0) {
+            return result;
+        }
+        const xs = _xs
+            .map((x) => _stringifyWhere(x, table, escapeId, escape, result))
+            .filter(Boolean);
+        if (xs.length === 0) {
+            return result;
+        }
+        return `(${xs.join(" AND ")})`;
+    }
+    if (Object.prototype.hasOwnProperty.call(where, "$or")) {
+        if (Object.keys(where).length !== 1) {
+            throw new Error("Must have 1 key: " + JSON.stringify(where, null, 2));
+        }
+        const _xs = where.$or.filter((x) => x != null);
+        if (_xs.length === 0) {
+            return result;
+        }
+        const xs = _xs
+            .map((x) => _stringifyWhere(x, table, escapeId, escape, result))
+            .filter(Boolean);
+        if (xs.length === 0) {
+            return result;
+        }
+        return `(${xs.join(" OR ")})`;
+    }
+    function printValue(v) {
+        if (v === true) {
+            v = 1;
+        }
+        if (v === false) {
+            v = 0;
+        }
+        return escape(v);
+    }
+    return Object.keys(where)
+        .map((k) => {
+        let v = where[k];
+        if (v === void 0) {
+            return null;
+        }
+        // Can't do this, since we need this function to be sync
+        // if (relationMap[k] !== null) {
+        //   const relationData = await getRelationData(k, v, relationMap);
+        //   k = relationData.k;
+        //   v = relationData.v;
+        // }
+        if (v === null) {
+            return `${table}.${escapeId(k)} IS NULL`;
+        }
+        if (typeof v === "string" ||
+            typeof v === "number" ||
+            typeof v === "boolean") {
+            return `${table}.${escapeId(k)} = ${printValue(v)}`;
+        }
+        if (_.isPlainObject(v)) {
+            const keys = Object.keys(v);
+            if (keys.length !== 1) {
+                throw new Error("Must have 1 key: " + JSON.stringify(v, null, 2));
+            }
+            const operator = keys[0];
+            const operand = v[operator];
+            if (operator === "$ne") {
+                return `${table}.${escapeId(k)} ${getOperatorNeq(v)} ${printValue(operand)}`;
+            }
+            if (operator === "$gt") {
+                return `${table}.${escapeId(k)} > ${printValue(operand)}`;
+            }
+            if (operator === "$gte") {
+                return `${table}.${escapeId(k)} >= ${printValue(operand)}`;
+            }
+            if (operator === "$lt") {
+                return `${table}.${escapeId(k)} < ${printValue(operand)}`;
+            }
+            if (operator === "$lte") {
+                return `${table}.${escapeId(k)} <= ${printValue(operand)}`;
+            }
+            if (operator === "$like") {
+                return `${table}.${escapeId(k)} LIKE ${printValue(operand)}`;
+            }
+            if (operator === "$nlike") {
+                return `${table}.${escapeId(k)} NOT LIKE ${printValue(operand)}`;
+            }
+            if (operator === "$in") {
+                if (operand.length === 0) {
+                    // Would do "FALSE" instead, as it's more readable, but it
+                    // causes a RequestError in MSSQL.
+                    return "(1=0)";
+                }
+                return `${table}.${escapeId(k)} IN (${operand
+                    .map((x) => printValue(x))
+                    .join(",")})`;
+            }
+            if (operator === "$nin") {
+                if (operand.length === 0) {
+                    // Would do "TRUE" instead, as it's more readable, but it
+                    // causes a RequestError in MSSQL.
+                    return "(1=1)";
+                }
+                return `${table}.${escapeId(k)} NOT IN (${operand
+                    .map((x) => printValue(x))
+                    .join(",")})`;
+            }
+            if (operator === "$btwn") {
+                if (operand.length !== 2) {
+                    throw new Error("Expected length of 2, got: " + operand.length);
+                }
+                return `${table}.${escapeId(k)} BETWEEN ${printValue(operand[0])} AND ${printValue(operand[1])}`;
+            }
+            if (operator === "$nbtwn") {
+                if (operand.length !== 2) {
+                    throw new Error("Expected length of 2, got: " + operand.length);
+                }
+                return `${table}.${escapeId(k)} NOT BETWEEN ${printValue(operand[0])} AND ${printValue(operand[1])}`;
+            }
+            throw new Error("Invalid operator: " + operator);
+        }
+        throw new Error("Invalid value: " + v);
+    })
+        .filter((x) => x != null)
+        .join(" AND ");
+}
+const valuesThatUseIsOrIsNot = new Set([null]);
+function getOperatorNeq(value) {
+    return valuesThatUseIsOrIsNot.has(value) ? "IS NOT" : "!=";
+}
+// async function getRelationData(k: string, v: any, relationMap: IRelationMap) {
+//   // TODO
+//   return { k, v };
+// }
+function stringifyPaginationWhere(input) {
+    const { table, args, orderBy, escapeId, escape, rowWithMatchingCursor } = input;
+    if (args?.$paginate?.after == null && args?.$paginate?.before == null) {
+        return "";
+    }
+    if (rowWithMatchingCursor == null) {
+        return "";
+    }
+    // orderBy should never be null because of getOrderBy, but add a check.
+    if (orderBy == null) {
+        throw new Error("orderBy cannot be null when paginating");
+    }
+    function getCompOp(dir) {
+        return dir === "asc" ? ">" : "<";
+    }
+    function printValue(v) {
+        if (v === true) {
+            v = 1;
+        }
+        if (v === false) {
+            v = 0;
+        }
+        return escape(v);
+    }
+    // https://gist.github.com/pcattori/2bb645d587e45c9fdbcabf5cef7a7106
+    const cond = orderBy
+        .map(({ column, direction }, i) => {
+        let a = orderBy.slice(0, i).map(({ column: col2 }) => {
+            const field = `${table}.${escapeId(col2)}`;
+            const op = "=";
+            const v = printValue(rowWithMatchingCursor[col2]);
+            return `${field} ${op} ${v}`;
+        });
+        const field = `${table}.${escapeId(column)}`;
+        const op = getCompOp(direction);
+        const v = printValue(rowWithMatchingCursor[column]);
+        a.push(`${field} ${op} ${v}`);
+        return "(" + a.join(" AND ") + ")";
+    })
+        .join(" OR ");
+    return "(" + cond + ")";
+}
+function getEscapeId(dialect) {
+    if (dialect === "mysql") {
+        return MySqlString.escapeId.bind(MySqlString);
+    }
+    if (dialect === "mssql") {
+        return TSqlString.escapeId.bind(TSqlString);
+    }
+    throw new Error("Unsupported dialect: " + dialect);
+}
+exports.getEscapeId = getEscapeId;
+function getEscape(dialect) {
+    if (dialect === "mysql") {
+        return MySqlString.escape.bind(MySqlString);
+    }
+    if (dialect === "mssql") {
+        return TSqlString.escape.bind(TSqlString);
+    }
+    throw new Error("Unsupported dialect: " + dialect);
+}
+exports.getEscape = getEscape;

package/dist/runtime/lib/typeCastMSSQL.js

@@ -5,7 +5,7 @@ const mssql = require("mssql");
 // TODO: see https://github.com/tediousjs/node-mssql/pull/1171
 function typeCastMSSQL(customTypeCast) {
     return function (result, meta) {
-        const typeCasts = {};
+        let typeCasts = {};
         for (let k in meta) {
             const v = meta[k];
             if (typeof customTypeCast === "function") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@technicity/data-service-generator",
-  "version": "0.10.0-next.0",
+  "version": "0.10.0-next.1",
   "main": "./dist/index.js",
   "files": [
     "dist"

package/dist/runtime/Runtime.d.ts

@@ -1,23 +0,0 @@
-import Cache from './Cache';
-import { IArtifacts, IRuntime, TMiddleware, TResolveParams } from './IRuntime';
-import { MiddlewareHandler } from './lib/resolve';
-declare abstract class Runtime implements IRuntime {
-    protected abstract $dialect: "mysql" | "mssql";
-    protected $clientCache?: Cache;
-    protected $middlewareHandler: MiddlewareHandler<TMiddleware>;
-    constructor(otherOpts: {
-        redisHost?: string;
-    }, clientOpts?: {
-        [k: string]: any;
-    });
-    protected abstract formatQuery(q: string, values: any[]): string;
-    protected abstract beginTransaction(): Promise<any>;
-    protected abstract dbCall(q: string): Promise<any>;
-    abstract $shutdown(): Promise<void>;
-    $queryRaw(sql: string, values?: any[]): Promise<any>;
-    resolve(input: TResolveParams): Promise<any>;
-    $use(middleware: TMiddleware): Promise<void>;
-    $prepareWhere(artifacts: IArtifacts, table: string, data: any): Promise<{}>;
-    $whereNeedsProcessing(where: any): boolean;
-}
-export default Runtime;

package/dist/runtime/Runtime.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const Cache_1 = require("./Cache");
-const prepareWhere_1 = require("./lib/prepareWhere");
-const resolve_1 = require("./lib/resolve");
-class Runtime {
-    constructor(otherOpts, clientOpts) {
-        this.$middlewareHandler = new resolve_1.MiddlewareHandler();
-        const debugCache = clientOpts?.debug?.includes("Cache");
-        if (otherOpts.redisHost)
-            this.$clientCache = new Cache_1.default(otherOpts.redisHost, debugCache);
-    }
-    async $queryRaw(sql, values) {
-        return this.dbCall(this.formatQuery(sql, values ?? []));
-    }
-    async resolve(input) {
-        return (0, resolve_1.resolve)(input, this.dbCall.bind(this), this.formatQuery.bind(this), this.beginTransaction.bind(this), this.$dialect, this.$middlewareHandler, input.context ?? {}, this.$clientCache);
-    }
-    async $use(middleware) {
-        this.$middlewareHandler.register(middleware);
-    }
-    async $prepareWhere(artifacts, table, data) {
-        return (0, prepareWhere_1.prepareWhere)(artifacts, table, data, this.dbCall.bind(this), this.formatQuery.bind(this));
-    }
-    $whereNeedsProcessing(where) {
-        return JSON.stringify(where).includes("Uuid");
-    }
-}
-exports.default = Runtime;

package/dist/runtime/lib/create.d.ts

@@ -1,12 +0,0 @@
-import { IDialect, TBeginTransaction, TContext, TDbCall, TFormatQuery, TResolveParams } from '../IRuntime';
-export declare function create(input: TResolveParams, dbCall: TDbCall, formatQuery: TFormatQuery, beginTransaction: TBeginTransaction, dialect: IDialect, context: TContext): Promise<any>;
-declare type TRunCreateTreeSQL = (table: string, referencedKey: string | null, referencedKeyValue: number | string | null, columns: string[][], values: any[][], dbCall: TDbCall, formatQuery: TFormatQuery) => Promise<any[]>;
-export declare function runCreateTree(tree: TCreateTree, referencedKeyValue: number | string | null, runCreateTreeSQL: TRunCreateTreeSQL, dbCall: TDbCall, formatQuery: TFormatQuery, dialect: IDialect): Promise<any[]>;
-declare type TCreateTree = {
-    table: string;
-    referencedKey: string | null;
-    columns: string[][];
-    values: any[][];
-    children: TCreateTree[][];
-};
-export {};

package/dist/runtime/lib/create.js

@@ -1,175 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runCreateTree = exports.create = void 0;
-const uuid_1 = require("uuid");
-const getData_1 = require("./getData");
-const shared_1 = require("./shared");
-async function create(input, dbCall, formatQuery, beginTransaction, dialect, context) {
-    async function _create() {
-        // Shallow clone, as we're going to mutate later
-        let data = { ...input.data };
-        const tableArtifacts = input.artifacts[input.resource];
-        // Top-level only
-        if ((0, shared_1.hasMappedFields)(input.artifacts, input.resource, data)) {
-            await (0, shared_1.mapMappedFields)(tableArtifacts, data, dbCall, formatQuery);
-        }
-        const hasChildren = Object.keys(data).some((k) => {
-            const oneToManyRelation = tableArtifacts.relationFields[k];
-            if (oneToManyRelation == null) {
-                return false;
-            }
-            if (oneToManyRelation.type === "one-to-many__many-to-one" &&
-                oneToManyRelation.kind === "one-to-many") {
-                return true;
-            }
-        });
-        if (hasChildren) {
-            const { dbCall: dbCallTransaction, commit } = await beginTransaction();
-            const id = await runCreateTree(getCreateTree([data], input.resource, null, context?.specialCaseUuidColumn, dialect, input.artifacts), null, dialect === "mssql" ? runCreateTreeMSSQL : runCreateTreeMySQL, dbCallTransaction, formatQuery, dialect).then((xs) => xs[0]);
-            await commit();
-            return id;
-        }
-        else {
-            data = processCreateData(data, tableArtifacts, dialect, context?.specialCaseUuidColumn);
-            if (dialect === "mysql") {
-                const inserted = await dbCall(formatQuery("INSERT INTO ?? SET ?", [input.resource, data]));
-                return inserted.insertId;
-            }
-            else {
-                const columns = Object.keys(data);
-                const values = Object.values(data);
-                const inserted = await dbCall(formatQuery(`INSERT INTO ?? (??) VALUES (?) SELECT SCOPE_IDENTITY() AS [SCOPE_IDENTITY]`, [input.resource, columns, values]));
-                return inserted[0]["SCOPE_IDENTITY"];
-            }
-        }
-    }
-    const id = await _create();
-    return (0, getData_1.getData)({ ...input, args: { $where: { id } } }, dbCall, formatQuery, dialect);
-}
-exports.create = create;
-function processCreateData(data, tableArtifacts, dialect, specialCaseUuidColumn) {
-    const out = { ...data };
-    if (dialect === "mysql" && tableArtifacts.dateTimeFieldsCount > 0) {
-        for (let k in tableArtifacts.dateTimeFields) {
-            if (out[k] != null) {
-                out[k] = (0, shared_1.getDateTimeStringMySQL)(out[k]);
-            }
-        }
-    }
-    // Delete keys with value of undefined
-    for (let k in out) {
-        if (out[k] === void 0) {
-            delete out[k];
-        }
-    }
-    const scalarFieldSet = new Set(tableArtifacts.scalarFields);
-    if (specialCaseUuidColumn &&
-        scalarFieldSet.has("uuid") &&
-        !Object.prototype.hasOwnProperty.call(out, "uuid")) {
-        out["uuid"] = (0, uuid_1.v4)();
-    }
-    return out;
-}
-async function runCreateTree(tree, referencedKeyValue, runCreateTreeSQL, dbCall, formatQuery, dialect) {
-    const ids = await runCreateTreeSQL(tree.table, tree.referencedKey, referencedKeyValue, tree.columns, tree.values, dbCall, formatQuery);
-    if (tree.children?.length > 0) {
-        // https://github.com/tediousjs/node-mssql/issues/302
-        if (dialect === "mssql") {
-            const idIndexes = Array(ids.length)
-                .fill(null)
-                .map((_, i) => i);
-            for (let i of idIndexes) {
-                for (let c of tree.children[i]) {
-                    await runCreateTree(c, ids[i], runCreateTreeSQL, dbCall, formatQuery, dialect);
-                }
-            }
-        }
-        else {
-            await Promise.all(ids.flatMap((id, i) => tree.children[i].map((c) => runCreateTree(c, id, runCreateTreeSQL, dbCall, formatQuery, dialect))));
-        }
-    }
-    return ids;
-}
-exports.runCreateTree = runCreateTree;
-function getCreateTree(data, table, referencedKey, specialCaseUuidColumn, dialect, artifacts) {
-    const tableArtifacts = artifacts[table];
-    const scalarFieldSet = new Set(tableArtifacts.scalarFields);
-    const out = {
-        table,
-        referencedKey,
-        columns: [],
-        values: [],
-        children: [],
-    };
-    for (let i = 0; i < data.length; i++) {
-        let d = data[i];
-        if (Object.keys(d).length === 0) {
-            continue;
-        }
-        d = processCreateData(d, tableArtifacts, dialect, specialCaseUuidColumn);
-        out.columns[i] = [];
-        out.values[i] = [];
-        out.children[i] = [];
-        for (let k in d) {
-            if (scalarFieldSet.has(k)) {
-                out.columns[i].push(k);
-                const v = d[k];
-                out.values[i].push(v);
-                continue;
-            }
-            const oneToManyRelation = tableArtifacts.relationFields[k];
-            if (oneToManyRelation == null ||
-                oneToManyRelation.type !== "one-to-many__many-to-one" ||
-                oneToManyRelation.kind !== "one-to-many") {
-                continue;
-            }
-            if (!Array.isArray(d[k]?.$create)) {
-                throw new Error("Invalid data: " + k);
-            }
-            out.children[i].push(getCreateTree(d[k].$create, oneToManyRelation.table, oneToManyRelation.relation.referencedKey, specialCaseUuidColumn, dialect, artifacts));
-        }
-    }
-    return out;
-}
-const runCreateTreeMySQL = async (table, referencedKey, referencedKeyValue, columns, values, dbCall, formatQuery) => {
-    let allColumns = columns;
-    if (typeof referencedKey === "string") {
-        allColumns = allColumns.slice().map((xs) => xs.concat(referencedKey));
-    }
-    let allValues = values;
-    if (referencedKeyValue != null) {
-        allValues = allValues.slice().map((xs) => xs.concat(referencedKeyValue));
-    }
-    return Promise.all(allColumns.map((cs, i) => dbCall(formatQuery(`INSERT INTO ?? (??) VALUES (?)`, [table, cs, allValues[i]])).then((x) => x.insertId)));
-};
-// This doesn't use bulk inserts because:
-// 1. columns aren't necessarily uniform
-// 2. We don't want to do backflips to get all the inserted IDs
-const runCreateTreeMSSQL = async (table, referencedKey, referencedKeyValue, columns, values, dbCall, formatQuery) => {
-    let allColumns = columns;
-    if (typeof referencedKey === "string") {
-        allColumns = allColumns.slice().map((xs) => xs.concat(referencedKey));
-    }
-    let allValues = values;
-    if (referencedKeyValue != null) {
-        allValues = allValues.slice().map((xs) => xs.concat(referencedKeyValue));
-    }
-    // https://github.com/tediousjs/node-mssql/issues/302
-    // return Promise.all(
-    //   allColumns.map((cs, i) =>
-    //     dbCall(
-    //       formatQuery(
-    //         `INSERT INTO ?? (??) VALUES (?) SELECT SCOPE_IDENTITY() AS [SCOPE_IDENTITY]`,
-    //         [table, cs, allValues[i]]
-    //       )
-    //     ).then((xs) => xs[0]["SCOPE_IDENTITY"])
-    //   )
-    // );
-    const out = [];
-    let i = 0;
-    for (let cs of allColumns) {
-        out.push(await dbCall(formatQuery(`INSERT INTO ?? (??) VALUES (?) SELECT SCOPE_IDENTITY() AS [SCOPE_IDENTITY]`, [table, cs, allValues[i]])).then((xs) => xs[0]["SCOPE_IDENTITY"]));
-        i += 1;
-    }
-    return out;
-};

package/dist/runtime/lib/delete.d.ts

@@ -1,5 +0,0 @@
-import { IDialect, TDbCall, TFormatQuery } from '../IRuntime';
-import type { TResolveParams } from "../IRuntime";
-import Cache from '../Cache';
-export declare function deleteOne(input: TResolveParams, dbCall: TDbCall, formatQuery: TFormatQuery, dialect: IDialect, cache?: Cache): Promise<boolean>;
-export declare function deleteMany(input: TResolveParams, dbCall: TDbCall, formatQuery: TFormatQuery, dialect: IDialect, cache?: Cache): Promise<boolean>;

package/dist/runtime/lib/delete.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deleteMany = exports.deleteOne = void 0;
-const error_1 = require("./error");
-const getWhere_1 = require("./getWhere");
-async function deleteOne(input, dbCall, formatQuery, dialect, cache) {
-    const _findOne = Object.entries(input.args.$where)[0];
-    const findOne = { key: _findOne[0], value: _findOne[1] };
-    const current = await dbCall(formatQuery("SELECT * FROM ?? WHERE ?? = ?", [
-        input.resource,
-        findOne.key,
-        findOne.value,
-    ])).then((xs) => xs[0]);
-    if (current == null) {
-        throw new error_1.SDKNotFoundError();
-    }
-    if (cache && current.uuid)
-        cache.purge(current.uuid);
-    await dbCall(formatQuery("DELETE FROM ?? WHERE ?? = ?", [
-        input.resource,
-        findOne.key,
-        findOne.value,
-    ]));
-    return true;
-}
-exports.deleteOne = deleteOne;
-async function deleteMany(input, dbCall, formatQuery, dialect, cache) {
-    const escapeId = (0, getWhere_1.getEscapeId)(dialect);
-    const where = (0, getWhere_1.getWhere)(escapeId(input.resource), input.args, dialect);
-    if (where == null)
-        throw new Error("Null where");
-    if (cache)
-        try {
-            const query = formatQuery(`SELECT uuid FROM ?? WHERE ${where}`, [input.resource]);
-            const matches = await dbCall(query);
-            const uuids = matches.map((x) => x.uuid);
-            cache.purge(...uuids);
-        }
-        catch (err) { }
-    await dbCall(formatQuery(`DELETE FROM ?? WHERE ${where}`, [input.resource]));
-    return true;
-}
-exports.deleteMany = deleteMany;

package/dist/runtime/lib/error.d.ts

@@ -1,9 +0,0 @@
-export declare class CustomError extends Error {
-    constructor(message: string);
-}
-export declare class SDKBadWhereError extends CustomError {
-    constructor(message?: string);
-}
-export declare class SDKNotFoundError extends CustomError {
-    constructor();
-}

package/dist/runtime/lib/error.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SDKNotFoundError = exports.SDKBadWhereError = exports.CustomError = void 0;
-class CustomError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = this.constructor.name;
-    }
-}
-exports.CustomError = CustomError;
-class SDKBadWhereError extends CustomError {
-    constructor(message) {
-        super(message || "Invalid $where");
-    }
-}
-exports.SDKBadWhereError = SDKBadWhereError;
-class SDKNotFoundError extends CustomError {
-    constructor() {
-        super("Not found");
-    }
-}
-exports.SDKNotFoundError = SDKNotFoundError;

package/dist/runtime/lib/getData.d.ts

@@ -1,4 +0,0 @@
-import Cache from '../Cache';
-import { IDialect, TDbCall, TFormatQuery, TResolveParams } from '../IRuntime';
-export declare function getCacheableData(input: TResolveParams, dbCall: TDbCall, formatQuery: TFormatQuery, dialect: IDialect, cache: Cache): Promise<any>;
-export declare function getData(input: TResolveParams, dbCall: TDbCall, formatQuery: TFormatQuery, dialect: IDialect): Promise<any>;