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

package/dist/runtime/lib/getWhere.js

@@ -1,15 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getWhere = void 0;
-const stringifyWhere_1 = require("./stringifyWhere");
+exports.getEscape = exports.getEscapeId = exports.stringifyWhere = exports.getWhere = void 0;
+const _ = require("lodash/fp");
+const MySqlString = require("sqlstring");
+// @ts-ignore
+const TSqlString = require("tsqlstring");
 function getWhere(
 // Note: `table` is not escaped in getWhere, so it should be escaped beforehand.
 table, args, dialect, orderBy, rowWithMatchingCursor) {
     if (args?.$where == null && args?.$paginate == null) {
         return null;
     }
-    let where = args?.$where ?? {};
-    return ((0, stringifyWhere_1.stringifyWhere)({
+    const where = args?.$where ?? {};
+    return (stringifyWhere({
         where,
         table,
         dialect,
@@ -19,3 +22,224 @@ table, args, dialect, orderBy, rowWithMatchingCursor) {
     }) || null);
 }
 exports.getWhere = getWhere;
+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) => {
+        const 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) => {
+        const 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/prepareWhere.d.ts

@@ -0,0 +1,2 @@
+import { IArtifacts, TDbCall, TFormatQuery } from '../IRuntime';
+export declare function prepareWhere(artifacts: IArtifacts, table: string, data: any, dbCall: TDbCall, formatQuery: TFormatQuery): Promise<{}>;

package/dist/runtime/lib/prepareWhere.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareWhere = void 0;
+const _ = require("lodash/fp");
+const error_1 = require("./error");
+const OPERATIONS = [
+    "$eq",
+    "$neq",
+    "$gt",
+    "$gte",
+    "$lt",
+    "$lte",
+    "$in",
+    "$nin",
+    "$like",
+    "$nlike",
+    "$btwn",
+    "$nbtwn",
+];
+async function prepareWhere(artifacts, table, data, dbCall, formatQuery) {
+    const { mappedFields } = artifacts[table];
+    let out = {};
+    await traverseWhere(data, async (where, ptr, parentPtr, root) => {
+        const path = ptr.split("/").slice(1);
+        const opIndex = path.length - 1;
+        if (OPERATIONS.includes(path[opIndex])) {
+            const newPath = path.slice();
+            const index = newPath.length - 2;
+            const key = newPath[index];
+            const mappedField = mappedFields?.[key];
+            if (mappedField != null) {
+                newPath[index] = mappedField.foreignKey;
+                if (Array.isArray(where)) {
+                    const newVal = await Promise.all(where.map((v) => dbCall(formatQuery("SELECT ?? FROM ?? WHERE ?? = ?", [
+                        mappedField.referencedKey,
+                        mappedField.referencedTable,
+                        mappedField.name,
+                        v,
+                    ])).then((xs) => xs[0]?.[mappedField.referencedKey])));
+                    if (newVal.some((x) => x == null)) {
+                        const index = newVal.findIndex((x) => x == null);
+                        if (index === -1) {
+                            throw new error_1.SDKBadWhereError();
+                        }
+                        else {
+                            const v = where[index];
+                            throw new error_1.SDKBadWhereError(getPrepareWhereNotFoundMessage(mappedField, v));
+                        }
+                    }
+                    out = _.set(newPath, newVal, out);
+                }
+                else {
+                    const newVal = await dbCall(formatQuery("SELECT ?? FROM ?? WHERE ?? = ?", [
+                        mappedField.referencedKey,
+                        mappedField.referencedTable,
+                        mappedField.name,
+                        where,
+                    ])).then((xs) => xs[0]?.[mappedField.referencedKey]);
+                    if (newVal == null) {
+                        throw new error_1.SDKBadWhereError(getPrepareWhereNotFoundMessage(mappedField, where));
+                    }
+                    out = _.set(newPath, newVal, out);
+                }
+                out = _.unset(path.slice(0, path.length - 1), out);
+                return;
+            }
+        }
+        else {
+            const key = path[path.length - 1];
+            const mappedField = mappedFields?.[key];
+            if (mappedField != null) {
+                const newPath = path
+                    .slice(0, path.length - 1)
+                    .concat(mappedField.foreignKey);
+                if (Array.isArray(where)) {
+                    const newVal = await Promise.all(where.map((v) => dbCall(formatQuery("SELECT ?? FROM ?? WHERE ?? = ?", [
+                        mappedField.referencedKey,
+                        mappedField.referencedTable,
+                        mappedField.name,
+                        v,
+                    ])).then((xs) => xs[0]?.[mappedField.referencedKey])));
+                    if (newVal.some((x) => x == null)) {
+                        const index = newVal.findIndex((x) => x == null);
+                        if (index === -1) {
+                            throw new error_1.SDKBadWhereError();
+                        }
+                        else {
+                            const v = where[index];
+                            throw new error_1.SDKBadWhereError(getPrepareWhereNotFoundMessage(mappedField, v));
+                        }
+                    }
+                    out = _.set(newPath, newVal, out);
+                }
+                else {
+                    const newVal = await dbCall(formatQuery("SELECT ?? FROM ?? WHERE ?? = ?", [
+                        mappedField.referencedKey,
+                        mappedField.referencedTable,
+                        mappedField.name,
+                        where,
+                    ])).then((xs) => xs[0]?.[mappedField.referencedKey]);
+                    if (newVal == null) {
+                        throw new error_1.SDKBadWhereError(getPrepareWhereNotFoundMessage(mappedField, where));
+                    }
+                    out = _.set(newPath, newVal, out);
+                }
+                out = _.unset(path, out);
+            }
+            else {
+                out = path.length > 0 ? _.set(path, where, out) : where;
+            }
+        }
+    });
+    return out;
+}
+exports.prepareWhere = prepareWhere;
+function getPrepareWhereNotFoundMessage(mappedField, value) {
+    return `Not found: unable to map \`${mappedField.referencedTable}\`.\`${mappedField.name}\` to \`${mappedField.referencedTable}\`.\`${mappedField.referencedKey}\` for the value \`${value}\`.`;
+}
+async function traverseWhere(where, cb) {
+    return await _traverseWhere(cb, where, "", where);
+}
+async function _traverseWhere(cb, where, ptr, root, parentPtr) {
+    await cb(where, ptr, parentPtr, root);
+    if (where && typeof where == "object" && !Array.isArray(where)) {
+        for (let key in where) {
+            const sch = where[key];
+            if (key === "$and" || key == "$or") {
+                await Promise.all(sch.map(async (s, i) => {
+                    await _traverseWhere(cb, s, ptr + "/" + key + "/" + i, root, ptr
+                    // key,
+                    // where,
+                    // parentPtr,
+                    // i
+                    );
+                }));
+            }
+            else if (typeof sch === "object") {
+                for (let prop in sch) {
+                    await _traverseWhere(cb, sch[prop], ptr + "/" + key + "/" + escapePtr(prop), root, ptr
+                    // key,
+                    // where,
+                    // prop
+                    );
+                }
+            }
+            else {
+                await _traverseWhere(cb, sch, ptr + "/" + key, root, ptr
+                // key,
+                // where
+                );
+            }
+        }
+    }
+}
+;
+function escapePtr(str) {
+    return str.replace(/~/g, "~0").replace(/\//g, "~1");
+}

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

@@ -0,0 +1,10 @@
+import Cache from '../Cache';
+import { IDialect, TBeginTransaction, TContext, TDbCall, TFormatQuery, TMiddleware, TResolveParams } from '../IRuntime';
+export declare function resolve(input: TResolveParams, dbCall: TDbCall, formatQuery: TFormatQuery, beginTransaction: TBeginTransaction, dialect: IDialect, middlewareHandler: MiddlewareHandler<TMiddleware>, context: TContext, cache?: Cache): Promise<any>;
+export declare class MiddlewareHandler<M extends Function> {
+    private _middlewares;
+    register(middleware: M): void;
+    get(id: number): M | undefined;
+    has(id: number): boolean;
+    length(): number;
+}

package/dist/runtime/lib/resolve.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MiddlewareHandler = exports.resolve = void 0;
+const async_hooks_1 = require("async_hooks");
+const create_1 = require("./create");
+const delete_1 = require("./delete");
+const getData_1 = require("./getData");
+const update_1 = require("./update");
+async function resolve(input, dbCall, formatQuery, beginTransaction, dialect, middlewareHandler, context, cache) {
+    // https://github.com/prisma/prisma/blob/822198e5ba21535364d20c86901b8c3778ebf6a3/packages/client/src/runtime/getPrismaClient.ts#L1087
+    let index = -1;
+    const resolve = (extra) => {
+        const inputs = { ...input, ...extra };
+        switch (inputs.action) {
+            case "findUnique":
+            case "findMany":
+            case "findManyPaginated":
+                return cache ?
+                    (0, getData_1.getCacheableData)(inputs, dbCall, formatQuery, dialect, cache) :
+                    (0, getData_1.getData)(inputs, dbCall, formatQuery, dialect);
+            case "create":
+                return (0, create_1.create)(inputs, dbCall, formatQuery, beginTransaction, dialect, context);
+            case "update":
+                return (0, update_1.update)(inputs, dbCall, formatQuery, dialect, cache);
+            case "updateMany":
+                return (0, update_1.updateMany)(inputs, dbCall, formatQuery, dialect, cache);
+            case "delete":
+                return (0, delete_1.deleteOne)(inputs, dbCall, formatQuery, dialect, cache);
+            case "deleteMany":
+                return (0, delete_1.deleteMany)(inputs, dbCall, formatQuery, dialect, cache);
+            default:
+                throw new Error("Invalid action: " + inputs.action);
+        }
+    };
+    if (middlewareHandler.length() > 0) {
+        const resource = new async_hooks_1.AsyncResource("sdk-request");
+        const params = input;
+        const consumer = (paramsMaybeMutated) => {
+            const nextMiddleware = middlewareHandler.get(++index);
+            if (nextMiddleware != null)
+                return nextMiddleware(paramsMaybeMutated, consumer);
+            return resolve(params);
+        };
+        return resource.runInAsyncScope(() => consumer(params));
+    }
+    return resolve();
+}
+exports.resolve = resolve;
+class MiddlewareHandler {
+    constructor() {
+        this._middlewares = [];
+    }
+    register(middleware) {
+        this._middlewares.push(middleware);
+    }
+    get(id) {
+        return this._middlewares[id];
+    }
+    has(id) {
+        return !!this._middlewares[id];
+    }
+    length() {
+        return this._middlewares.length;
+    }
+}
+exports.MiddlewareHandler = MiddlewareHandler;

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

@@ -1,13 +1,23 @@
-import type { IGetSQLASTInput, IArtifacts, IDialect, TDbCall, TFormatQuery, TBeginTransaction, TContext } from "../IRuntime";
-import type { TMiddleware, TResolveParams } from "../IRuntime";
-export declare function resolve(input: TResolveParams, dbCall: TDbCall, formatQuery: TFormatQuery, beginTransaction: TBeginTransaction, dialect: IDialect, middlewareHandler: MiddlewareHandler<TMiddleware>, context: TContext): Promise<any>;
-export declare class MiddlewareHandler<M extends Function> {
-    private _middlewares;
-    register(middleware: M): void;
-    get(id: number): M | undefined;
-    has(id: number): boolean;
-    length(): number;
-}
+import { IArtifacts, IGetSQLASTInput, TDbCall, TFormatQuery } from '../IRuntime';
+export declare function wrapListPaginationLimitOffset(data: any[], totalCount: number): {
+    paginationInfo: {
+        totalCount: number;
+    };
+    results: any[];
+};
+export declare function getDateTimeStringMySQL(dateTimeString: string): string;
+export declare function wrapListPaginationCursor(data: any[], args: any, flip: boolean, cb: (data: any[]) => void, primaryKey: string, totalCount: number): {
+    paginationInfo: {
+        hasPreviousPage: boolean;
+        hasNextPage: boolean;
+        startCursor: string | null;
+        endCursor: string | null;
+        totalCount: number;
+    };
+    results: any[];
+};
+export declare function getTotalCount(sqlASTTotalCount: any, dbCall: TDbCall, context: any, options: any): Promise<any>;
+export declare function getScalarFields(table: string, artifacts: IArtifacts): string[];
+export declare function hasMappedFields(artifacts: IArtifacts, table: string, data: any): boolean;
+export declare function mapMappedFields(artifactsForTable: IArtifacts[string], data: any, dbCall: TDbCall, formatQuery: TFormatQuery): Promise<void>;
 export declare function postProcess(data: any, fields: IGetSQLASTInput["fields"], shouldRemoveExtraKeys: boolean): void;
-export declare function whereNeedsProcessing(where: any): boolean;
-export declare function _prepareWhere(artifacts: IArtifacts, table: string, data: any, dbCall: TDbCall, formatQuery: TFormatQuery): Promise<{}>;