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

package/dist/runtime/lib/create.js

@@ -0,0 +1,175 @@
+"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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,43 @@
+"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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,22 @@
+"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

@@ -0,0 +1,4 @@
+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>;

package/dist/runtime/lib/getData.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getData = exports.getCacheableData = void 0;
+// @ts-ignore
+const batch_planner_1 = require("join-monster/dist/batch-planner");
+// @ts-ignore
+const util_1 = require("join-monster/dist/util");
+const _ = require("lodash/fp");
+const error_1 = require("./error");
+const addNullFallbacks_1 = require("./addNullFallbacks");
+const cursor_1 = require("./cursor");
+const getOrderBy_1 = require("./getOrderBy");
+const getSqlAst_1 = require("./getSqlAst");
+const getWhere_1 = require("./getWhere");
+const shared_1 = require("./shared");
+async function getCacheableData(input, dbCall, formatQuery, dialect, cache) {
+    const { request, cached } = await cache.from(input);
+    if (cached)
+        return cached;
+    ensureUuidSelect(input);
+    const results = await getData(input, dbCall, formatQuery, dialect);
+    cache.insert(request, results);
+    return results;
+}
+exports.getCacheableData = getCacheableData;
+async function getData(input, dbCall, formatQuery, dialect) {
+    const context = {};
+    const { action } = input;
+    const { primaryKey } = input.artifacts[input.resource];
+    let paginationType;
+    let limit = undefined;
+    let offset = undefined;
+    let rowWithMatchingCursor = undefined;
+    if (action === "findManyPaginated") {
+        if (input.args?.$paginate == null) {
+            throw new Error("$paginate required but not supplied");
+        }
+        if (typeof input?.args?.$paginate?.limit === "number") {
+            paginationType = "limit-offset";
+            limit = input.args.$paginate.limit;
+            offset = input.args.$paginate.offset;
+        }
+        else if (typeof input?.args?.$paginate?.first === "number" ||
+            typeof input?.args?.$paginate?.last === "number") {
+            paginationType = "cursor";
+            limit = (typeof input?.args?.$paginate?.first === "number"
+                ? input?.args?.$paginate?.first
+                : input?.args?.$paginate?.last);
+            // + 1 to peek if there is more data
+            limit += 1;
+            if (input.args.$paginate.after != null ||
+                input.args.$paginate.before != null) {
+                const cursor = input.args.$paginate.after != null
+                    ? input.args.$paginate.after
+                    : input.args.$paginate.before;
+                rowWithMatchingCursor = await dbCall(formatQuery("SELECT * FROM ?? WHERE ?? = ?", [
+                    input.resource,
+                    primaryKey,
+                    (0, cursor_1.decodeCursor)(cursor),
+                ])).then((xs) => xs[0]);
+                if (rowWithMatchingCursor == null) {
+                    throw new Error(`Invalid cursor: ${cursor}`);
+                }
+            }
+        }
+        else {
+            throw new Error(`Invalid $paginate: ${input?.args?.$paginate}`);
+        }
+    }
+    else if (action === "findMany") {
+        if (typeof input?.args?.$limit === "number") {
+            limit = input?.args?.$limit;
+        }
+    }
+    // we need to read the query AST and build a new "SQL AST" from which the SQL and
+    // const sqlAST = queryAST.queryASTToSqlAST(resolveInfo, options, context);
+    const fields = input.fields ?? (0, shared_1.getScalarFields)(input.resource, input.artifacts);
+    const orderByListPaginatedRootResult = 
+    // MSSQL's OFFSET and FETCH requires ORDER BY, so we need to provide a fallback
+    dialect === "mssql" && paginationType === "limit-offset"
+        ? {
+            orderBy: (0, getOrderBy_1.getOrderBy)(input.args, primaryKey)?.orderBy ?? [
+                { column: primaryKey, direction: "asc" },
+            ],
+            flip: false,
+        }
+        : action === "findManyPaginated"
+            ? (0, getOrderBy_1.getOrderBy)(input.args, primaryKey)
+            : undefined;
+    const grabMany = action === "findMany" ||
+        action === "findManyPaginated" ||
+        action === "updateMany" ||
+        action === "deleteMany";
+    const sqlAST = (0, getSqlAst_1.getSqlAst)({
+        ...input,
+        table: input.resource,
+        fieldName: "data",
+        fields,
+        getWhere: getWhere_1.getWhere,
+        orderBy: orderByListPaginatedRootResult?.orderBy,
+        rowWithMatchingCursor,
+        dialect,
+        grabMany,
+    });
+    const options = { dialect };
+    let { sql, shapeDefinition } = await (0, util_1.compileSqlAST)(sqlAST, context, options);
+    if (!sql) {
+        // return {};
+        throw new Error("No SQL");
+    }
+    // TODO - remove if limit support added for mysql dialect
+    if (action === "findMany" || action === "findManyPaginated") {
+        if (typeof limit === "number") {
+            const escape = (0, getWhere_1.getEscape)(dialect);
+            if (dialect === "mssql") {
+                if (typeof offset === "number") {
+                    sql += ` OFFSET ${escape(offset)} ROWS FETCH NEXT ${escape(limit)} ROWS ONLY`;
+                }
+                else {
+                    sql = sql.replace("SELECT", `SELECT TOP ${escape(limit)}`);
+                }
+            }
+            else {
+                sql += ` LIMIT ${escape(limit)}`;
+                if (typeof offset === "number") {
+                    sql += ` OFFSET ${escape(offset)}`;
+                }
+            }
+        }
+    }
+    // call their function for querying the DB, handle the different cases, do some validation, return a promise of the object
+    let data = await (0, util_1.handleUserDbCall)(dbCall, sql, sqlAST, shapeDefinition);
+    // if they are paginating, we'll get back an array which is essentially a "slice" of the whole data.
+    // this function goes through the data tree and converts the arrays to Connection Objects
+    // data = arrToConnection(data, sqlAST);
+    // so far we handled the first "batch". up until now, additional batches were ignored
+    // this function recursively scanss the sqlAST and runs remaining batches
+    await (0, batch_planner_1.default)(sqlAST, data, dbCall, context, options);
+    (0, addNullFallbacks_1.addNullFallbacks)(sqlAST, data);
+    // We only need to remove extra keys if input.fields isn't
+    // specified, since otherwise there wouldn't be extra keys
+    const shouldRemoveExtraKeys = input.fields != null;
+    if (action !== "findManyPaginated") {
+        // Remove additional keys that are added for batches and joins
+        // Do later for `listPaginated`, since the `id` is needed for
+        // creating the cursor
+        (0, shared_1.postProcess)(data, fields, shouldRemoveExtraKeys);
+    }
+    // check for batch data
+    if (Array.isArray(data)) {
+        // TODO - not sure why this code exists in original
+        // source code of join-monster; doesn't make sense to me.
+        // const childrenToCheck = sqlAST.children.filter(
+        //   (child: any) => child.sqlBatch
+        // );
+        // data = data.filter((d) => {
+        //   for (const child of childrenToCheck) {
+        //     if (d[child.fieldName] == null) {
+        //       return false;
+        //     }
+        //   }
+        //   return true;
+        // });
+        if (action === "findManyPaginated") {
+            const argsTotalCount = input.args && _.cloneDeep(input.args);
+            if (argsTotalCount != null) {
+                if (argsTotalCount.$paginate != null) {
+                    // We don't want the where clause to include cursor-related stuff
+                    delete argsTotalCount.$paginate.after;
+                    delete argsTotalCount.$paginate.before;
+                    // We don't need offset
+                    delete argsTotalCount.$paginate.offset;
+                }
+            }
+            const sqlASTTotalCount = (0, getSqlAst_1.getSqlAst)({
+                ...input,
+                table: input.resource,
+                fieldName: "data",
+                args: argsTotalCount,
+                // Because we're going to manually set children anyway
+                fields: [],
+                getWhere: getWhere_1.getWhere,
+                // We don't want the where clause to include cursor-related stuff
+                rowWithMatchingCursor: null,
+                dialect,
+                grabMany: true,
+            });
+            // Because orderBy doesn't matter for total count.
+            // getOrderBy adds an element if paginating, so deleting args.$orderBy
+            // isn't sufficient.
+            delete sqlASTTotalCount.orderBy;
+            const totalCount = await (0, shared_1.getTotalCount)(sqlASTTotalCount, dbCall, context, options);
+            if (paginationType === "cursor") {
+                data = (0, shared_1.wrapListPaginationCursor)(data, input.args, orderByListPaginatedRootResult.flip, (xs) => {
+                    (0, shared_1.postProcess)(xs, fields, shouldRemoveExtraKeys);
+                }, input.artifacts[input.resource].primaryKey, totalCount);
+            }
+            else {
+                (0, shared_1.postProcess)(data, fields, shouldRemoveExtraKeys);
+                data = (0, shared_1.wrapListPaginationLimitOffset)(data, totalCount);
+            }
+        }
+        return data;
+    }
+    if (data == null && !grabMany) {
+        throw new error_1.SDKNotFoundError();
+    }
+    return data;
+}
+exports.getData = getData;
+function ensureUuidSelect(input) {
+    const { resource, artifacts } = input;
+    ensure(resource, input);
+    function ensure(type, input) {
+        const { scalarFields, relationFields } = artifacts[type];
+        if (!scalarFields.includes("uuid"))
+            return;
+        const fields = input.fields;
+        if (!fields.includes("uuid"))
+            fields.unshift("uuid");
+        for (const field of fields)
+            if (typeof field == "object") {
+                const { table } = relationFields[field.name];
+                ensure(table, field);
+            }
+    }
+}

package/dist/runtime/lib/getSqlAst.js

@@ -12,12 +12,12 @@ const namespace = new alias_namespace_1.default(true);
 function getSqlAst(input) {
     const { table, fieldName, fields, args, grabMany, sqlJoin, sqlBatch, junction, getWhere, artifacts, rowWithMatchingCursor, dialect, } = input;
     const tableArtifacts = artifacts[table];
-    const primaryKey = tableArtifacts.primaryKey;
+    const { primaryKey } = tableArtifacts;
     const format = dialect === "mysql"
         ? SqlString.format.bind(SqlString)
         : TSqlString.format.bind(TSqlString);
     const orderBy = input.orderBy ?? (0, getOrderBy_1.getOrderBy)(args, primaryKey)?.orderBy;
-    let where = input.where;
+    let { where } = input;
     if (input.where == null) {
         where = (table, args) => {
             let argsMapped = args;

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

@@ -1,2 +1,19 @@
 import type { IOrderBy, IDialect } from "../IRuntime";
 export declare function getWhere(table: string, args: any, dialect: IDialect, orderBy?: IOrderBy | undefined, rowWithMatchingCursor?: any): string | null;
+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 {};