@technicity/data-service-generator 0.22.2 → 0.23.0-next.0

package/dist/src/runtime/lib/shared.js

@@ -0,0 +1,1118 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MiddlewareHandler = void 0;
+exports.resolve = resolve;
+exports.postProcess = postProcess;
+exports.whereNeedsProcessing = whereNeedsProcessing;
+exports._prepareWhere = _prepareWhere;
+// @ts-ignore
+// import * as queryAST from "join-monster/dist/query-ast-to-sql-ast";
+// @ts-ignore
+// import arrToConnection from "join-monster/dist/array-to-connection";
+// @ts-ignore
+const batch_planner_1 = __importDefault(require("join-monster/dist/batch-planner"));
+// @ts-ignore
+const util_1 = require("join-monster/dist/util");
+const async_hooks_1 = require("async_hooks");
+const _ = __importStar(require("lodash/fp"));
+const uuid_1 = require("uuid");
+const getSqlAst_1 = require("./getSqlAst");
+const IRuntime_1 = require("../IRuntime");
+const getWhere_1 = require("./getWhere");
+const getDateTimeStringMySQL_1 = require("./getDateTimeStringMySQL");
+const cursor_1 = require("./cursor");
+const addNullFallbacks_1 = require("./addNullFallbacks");
+const SDKNotFoundError_1 = require("./SDKNotFoundError");
+const SDKBadWhereError_1 = require("./SDKBadWhereError");
+const stringifyWhere_1 = require("./stringifyWhere");
+const getOrderBy_1 = require("./getOrderBy");
+const Stats_1 = require("../Stats");
+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;
+    if (middlewareHandler.length() > 0) {
+        const resource = new async_hooks_1.AsyncResource("sdk-request");
+        const params = input;
+        const consumer = async (paramsMaybeMutated) => {
+            const nextMiddleware = middlewareHandler.get(++index);
+            if (nextMiddleware != null) {
+                return nextMiddleware(paramsMaybeMutated, consumer);
+            }
+            const paramsChanged = { ...input, ...params };
+            const onHandler = input.onHandler;
+            const asyncLocalStorage = input.asyncLocalStorage;
+            const shouldRunOnHandler = typeof onHandler === "function" &&
+                asyncLocalStorage != null &&
+                asyncLocalStorage?.getStore()?.isInOnHandler !== true;
+            const beforeValue = shouldRunOnHandler && input.passBeforeValueToAfterCallback
+                ? await _resolve({
+                    ...paramsChanged,
+                    action: paramsChanged.action === "updateMany" ||
+                        paramsChanged.action === "deleteMany"
+                        ? "findMany"
+                        : "findUnique",
+                    fields: undefined
+                }, dbCall, formatQuery, beginTransaction, dialect, context, cache)
+                : null;
+            const p = _resolve(paramsChanged, dbCall, formatQuery, beginTransaction, dialect, context, cache);
+            if (shouldRunOnHandler) {
+                return p.then((output) => asyncLocalStorage
+                    .run({ isInOnHandler: true }, async () => onHandler(input.sdk, { ...input.args, data: input.data }, output, beforeValue, context))
+                    .then(() => output)
+                    .catch((error) => {
+                    input.eventTarget.dispatchEvent(new IRuntime_1.EventOnHandlerError("error", {
+                        error,
+                        resource: input.resource,
+                        action: input.action
+                    }));
+                    return output;
+                }));
+            }
+            return p;
+        };
+        return resource.runInAsyncScope(() => consumer(params));
+    }
+    const onHandler = input.onHandler;
+    const asyncLocalStorage = input.asyncLocalStorage;
+    const shouldRunOnHandler = typeof onHandler === "function" &&
+        asyncLocalStorage != null &&
+        asyncLocalStorage?.getStore()?.isInOnHandler !== true;
+    const beforeValue = shouldRunOnHandler && input.passBeforeValueToAfterCallback
+        ? await _resolve({
+            ...input,
+            action: input.action === "updateMany" || input.action === "deleteMany"
+                ? "findMany"
+                : "findUnique",
+            fields: undefined
+        }, dbCall, formatQuery, beginTransaction, dialect, context, cache)
+        : null;
+    const p = _resolve(input, dbCall, formatQuery, beginTransaction, dialect, context, cache);
+    if (shouldRunOnHandler) {
+        return p.then((output) => asyncLocalStorage
+            .run({ isInOnHandler: true }, async () => onHandler(input.sdk, { ...input.args, data: input.data }, output, beforeValue, context))
+            .then(() => output)
+            .catch((error) => {
+            input.eventTarget.dispatchEvent(new IRuntime_1.EventOnHandlerError("error", {
+                error,
+                resource: input.resource,
+                action: input.action
+            }));
+            return output;
+        }));
+    }
+    return p;
+}
+function _resolve(input, dbCall, formatQuery, beginTransaction, dialect, context, cache) {
+    switch (input.action) {
+        case "findMany":
+            return cache && !input.skipCache
+                ? getCached(input, dbCall, formatQuery, dialect, cache)
+                : getData(input, dbCall, formatQuery, dialect);
+        case "findUnique":
+        case "findManyPaginated":
+            return getData(input, dbCall, formatQuery, dialect);
+        case "create":
+            return create(input, dbCall, formatQuery, beginTransaction, dialect, context);
+        case "update":
+            return update(input, dbCall, formatQuery, dialect, cache);
+        case "updateMany":
+            return updateMany(input, dbCall, formatQuery, dialect, cache);
+        case "delete":
+            return deleteOne(input, dbCall, formatQuery, dialect, cache);
+        case "deleteMany":
+            return deleteMany(input, dbCall, formatQuery, dialect, cache);
+        default:
+            throw new Error("Invalid action: " + input.action);
+    }
+}
+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;
+async function getData(input, dbCall, formatQuery, dialect) {
+    const context = {};
+    const action = input.action;
+    const primaryKey = input.artifacts[input.resource].primaryKey;
+    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 ??
+        getScalarFields(input.resource, input.artifacts).reduce((acc, x) => {
+            acc[x] = true;
+            return acc;
+        }, {});
+    const orderByListPaginatedRootResult = action === "findManyPaginated" ? (0, getOrderBy_1.getOrderBy)(input.args, primaryKey) : undefined;
+    const grabMany = action === "findMany" ||
+        action === "findManyPaginated" ||
+        action === "updateMany" ||
+        action === "deleteMany";
+    const escapeId = (0, stringifyWhere_1.getEscapeId)(dialect);
+    const sqlAST = (0, getSqlAst_1.getSqlAst)({
+        ...input,
+        table: input.resource,
+        fieldName: "data",
+        fields,
+        getWhere: getWhere_1.getWhere,
+        orderBy: orderByListPaginatedRootResult?.orderBy,
+        rowWithMatchingCursor,
+        dialect,
+        grabMany,
+        escapeId
+    });
+    const options = {
+        dialect: dialect === "postgresql" ? "pg" : dialect === "sqlite" ? "mysql" : 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, stringifyWhere_1.getEscape)(dialect);
+            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
+        postProcess(data, fields, shouldRemoveExtraKeys);
+        if (dialect === "sqlite") {
+            typeCastSqlite(data, fields, input.resource, input.artifacts);
+        }
+    }
+    // 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,
+                escapeId
+            });
+            // 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 getTotalCount(sqlASTTotalCount, dbCall, context, options);
+            if (paginationType === "cursor") {
+                data = wrapListPaginationCursor(data, input.args, orderByListPaginatedRootResult.flip, (xs) => {
+                    postProcess(xs, fields, shouldRemoveExtraKeys);
+                    if (dialect === "sqlite") {
+                        typeCastSqlite(data, fields, input.resource, input.artifacts);
+                    }
+                }, input.artifacts[input.resource].primaryKey, totalCount);
+            }
+            else {
+                postProcess(data, fields, shouldRemoveExtraKeys);
+                if (dialect === "sqlite") {
+                    typeCastSqlite(data, fields, input.resource, input.artifacts);
+                }
+                data = wrapListPaginationLimitOffset(data, totalCount);
+            }
+        }
+        return data;
+    }
+    if (data == null && !grabMany) {
+        throw new SDKNotFoundError_1.SDKNotFoundError();
+    }
+    return data;
+}
+async function getCached(input, dbCall, formatQuery, dialect, cache) {
+    const done = (0, Stats_1.timer)();
+    const { stats } = cache;
+    const { request, cached } = await cache.from(input);
+    let results;
+    if (cached) {
+        if (stats)
+            done(stats.updateStats, "get_redis");
+        results = cached;
+    }
+    else {
+        const remove = ensureUuidSelect(input);
+        results = await getData(input, dbCall, formatQuery, dialect);
+        if (!Array.isArray(results)) {
+            if ("results" in results)
+                results = results.results;
+            else {
+                throw new Error("Bad result returned by getData in SDK.");
+            }
+        }
+        for (const result of results)
+            for (const path of remove) {
+                let data = result;
+                for (const key of path)
+                    data = data[key];
+                // delete data.uuid;
+            }
+        cache.insert(request, results);
+        if (stats)
+            done(stats.updateStats, "get_mysql");
+    }
+    if (stats)
+        done(stats.updateStats, "get");
+    return results;
+}
+function ensureUuidSelect(input) {
+    const { resource, artifacts } = input;
+    const remove = [];
+    ensure(resource, input.fields);
+    function ensure(type, input, path = []) {
+        const { scalarFields, relationFields } = artifacts[type];
+        if (!scalarFields.includes("uuid"))
+            return;
+        const fields = input || {};
+        if (!Object.keys(fields).includes("uuid")) {
+            remove.push(path);
+            fields["uuid"] = true;
+        }
+        const entries = Object.entries(fields);
+        for (const [k, v] of entries)
+            if (typeof v === "object") {
+                const table = relationFields[k]?.table;
+                if (table != null) {
+                    ensure(table, v.$fields, path.concat(k));
+                }
+            }
+    }
+    return remove;
+}
+function wrapListPaginationLimitOffset(data, totalCount) {
+    return { paginationInfo: { totalCount }, results: data };
+}
+// Not recursive at the moment; only supported at the root.
+// TODO - remove if support for pagination for mysql dialect
+// is added (I doubt it)
+function wrapListPaginationCursor(data, args, flip, cb, primaryKey, totalCount) {
+    const limit = flip ? args.$paginate.last : args.$paginate.first;
+    const hasMoreResults = data.length === limit + 1;
+    if (hasMoreResults) {
+        // because we peeked
+        data = data.slice(0, -1);
+    }
+    if (flip) {
+        data = data.reverse();
+    }
+    const hasPreviousPage = flip ? hasMoreResults : false;
+    const hasNextPage = flip ? false : hasMoreResults;
+    const startKey = data?.[0]?.[primaryKey];
+    const endKey = data?.[data.length - 1]?.[primaryKey];
+    const startCursor = startKey == null ? null : (0, cursor_1.encodeCursor)(startKey);
+    const endCursor = endKey == null ? null : (0, cursor_1.encodeCursor)(endKey);
+    cb(data);
+    return {
+        paginationInfo: {
+            hasPreviousPage,
+            hasNextPage,
+            startCursor,
+            endCursor,
+            totalCount
+        },
+        results: data
+    };
+}
+async function getTotalCount(sqlASTTotalCount, dbCall, context, options) {
+    // Replace field selection with `COUNT(*)`
+    const fieldNameTotalCount = "totalCount";
+    sqlASTTotalCount.children = [
+        {
+            type: "expression",
+            sqlExpr: () => "COUNT(*)",
+            fieldName: fieldNameTotalCount,
+            as: fieldNameTotalCount
+        }
+    ];
+    const { sql: sqlTotalCount } = await (0, util_1.compileSqlAST)(sqlASTTotalCount, context, options);
+    const totalCount = await dbCall(sqlTotalCount).then((xs) => xs[0][fieldNameTotalCount]);
+    return totalCount;
+}
+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)));
+};
+const runCreateTreePostgreSQL = async (table, referencedKey, referencedKeyValue, columns, values, dbCall, formatQuery, artifacts) => {
+    if (artifacts == null) {
+        throw new Error("artifacts required for PostgreSQL runCreateTree");
+    }
+    const primaryKey = artifacts[table]?.primaryKey ?? "id";
+    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 (?) RETURNING ??`, [
+        table,
+        cs,
+        allValues[i],
+        primaryKey
+    ])).then((rows) => rows[0]?.[primaryKey])));
+};
+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 (hasMappedFields(input.artifacts, input.resource, data)) {
+            await 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 runCreateTreeSQL = dialect === "postgresql" ? runCreateTreePostgreSQL : runCreateTreeMySQL;
+            const id = await runCreateTree(getCreateTree([data], input.resource, null, context?.specialCaseUuidColumn, dialect, input.artifacts), null, runCreateTreeSQL, dbCallTransaction, formatQuery, dialect, input.artifacts).then((xs) => xs[0]);
+            await commit();
+            return id;
+        }
+        else {
+            data = processCreateData(data, tableArtifacts, dialect, context?.specialCaseUuidColumn);
+            const columns = Object.keys(data);
+            const values = Object.values(data);
+            if (dialect === "postgresql") {
+                const primaryKey = tableArtifacts.primaryKey;
+                const inserted = await dbCall(formatQuery(`INSERT INTO ?? (??) VALUES (?) RETURNING ??`, [
+                    input.resource,
+                    columns,
+                    values,
+                    primaryKey
+                ]));
+                return inserted[0]?.[primaryKey];
+            }
+            const inserted = await dbCall(formatQuery(`INSERT INTO ?? (??) VALUES (?)`, [
+                input.resource,
+                columns,
+                values
+            ]));
+            return inserted.insertId;
+        }
+    }
+    const id = await _create();
+    return getData({ ...input, args: { $where: { id } } }, dbCall, formatQuery, dialect);
+}
+function processCreateData(data, tableArtifacts, dialect, specialCaseUuidColumn) {
+    let out = { ...data };
+    if ((dialect === "mysql" || dialect === "postgresql") &&
+        tableArtifacts.dateTimeFieldsCount > 0) {
+        for (let k in tableArtifacts.dateTimeFields) {
+            if (out[k] != null) {
+                out[k] = (0, getDateTimeStringMySQL_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, artifacts) {
+    const ids = await runCreateTreeSQL(tree.table, tree.referencedKey, referencedKeyValue, tree.columns, tree.values, dbCall, formatQuery, artifacts);
+    if (tree.children?.length > 0) {
+        await Promise.all(ids.flatMap((id, i) => tree.children[i].map((c) => runCreateTree(c, id, runCreateTreeSQL, dbCall, formatQuery, dialect, artifacts))));
+    }
+    return ids;
+}
+function getCreateTree(data, table, referencedKey, specialCaseUuidColumn, dialect, artifacts) {
+    const tableArtifacts = artifacts[table];
+    const scalarFieldSet = new Set(tableArtifacts.scalarFields);
+    let 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;
+}
+async function update(input, dbCall, formatQuery, dialect, cache) {
+    async function _update() {
+        const escapeId = (0, stringifyWhere_1.getEscapeId)(dialect);
+        const tableArtifacts = input.artifacts[input.resource];
+        const where = (0, getWhere_1.getWhere)(escapeId(input.resource), input.args, dialect);
+        if (where == null) {
+            throw new Error("Null where");
+        }
+        const current = await dbCall(formatQuery("SELECT * FROM ?? WHERE " + where, [input.resource])).then((xs) => xs[0]);
+        if (current == null) {
+            throw new SDKNotFoundError_1.SDKNotFoundError();
+        }
+        if (cache && current.uuid)
+            cache.purge(current.uuid);
+        // Shallow clone, as we're going to mutate later
+        const data = { ...input.data };
+        if (hasMappedFields(input.artifacts, input.resource, data)) {
+            await mapMappedFields(tableArtifacts, data, dbCall, formatQuery);
+        }
+        if ((dialect === "mysql" || dialect === "postgresql") &&
+            tableArtifacts.dateTimeFieldsCount > 0) {
+            for (let k in tableArtifacts.dateTimeFields) {
+                if (data[k] != null) {
+                    data[k] = (0, getDateTimeStringMySQL_1.getDateTimeStringMySQL)(data[k]);
+                }
+            }
+        }
+        // Delete keys with value of undefined
+        for (let k in data) {
+            if (data[k] === void 0) {
+                delete data[k];
+            }
+        }
+        // Nothing to update
+        if (Object.keys(data).length === 0) {
+            return true;
+        }
+        await dbCall(getUpdateQuery(input.resource, data, where, dialect, formatQuery));
+        return true;
+    }
+    await _update();
+    return getData(input, dbCall, formatQuery, dialect);
+}
+function getUpdateQuery(table, data, where, dialect, formatQuery) {
+    // Assumes `data` is not empty
+    const escapeId = (0, stringifyWhere_1.getEscapeId)(dialect);
+    const escape = (0, stringifyWhere_1.getEscape)(dialect);
+    let q = "UPDATE ?? ";
+    let values = [table];
+    let opsStrs = [];
+    let dataRegular = {};
+    for (let k in data) {
+        const v = data[k];
+        if (typeof v === "object" && v != null && Object.keys(v).length === 1) {
+            const _entries = Object.entries(v)?.[0];
+            const op = _entries?.[0];
+            const vv = _entries?.[1];
+            if (op === "$prepend") {
+                opsStrs.push(`${escapeId(k)} = CASE WHEN ${escapeId(k)} IS NULL THEN NULL ELSE ${stringifyConcat(escape(vv), escapeId(k), dialect)} END`);
+                continue;
+            }
+            if (op === "$append") {
+                opsStrs.push(`${escapeId(k)} = CASE WHEN ${escapeId(k)} IS NULL THEN NULL ELSE ${stringifyConcat(escapeId(k), escape(vv), dialect)} END`);
+                continue;
+            }
+            if (op === "$increment") {
+                opsStrs.push(`${escapeId(k)} = ${escapeId(k)} + ${escape(vv)}`);
+                continue;
+            }
+            if (op === "$decrement") {
+                opsStrs.push(`${escapeId(k)} = ${escapeId(k)} - ${escape(vv)}`);
+                continue;
+            }
+            dataRegular[k] = v;
+        }
+        dataRegular[k] = v;
+    }
+    if (opsStrs.length > 0) {
+        q += `SET ${opsStrs.join(", ")}`;
+    }
+    const columns = Object.keys(dataRegular);
+    if (columns.length > 0) {
+        if (opsStrs.length > 0) {
+            q += ", ";
+        }
+        else {
+            q += "SET ";
+        }
+        q += columns.map((x) => `${escapeId(x)} = ?`).join(", ");
+        for (let k in dataRegular) {
+            values.push(dataRegular[k]);
+        }
+    }
+    q += ` WHERE ${where}`;
+    return formatQuery(q, values);
+}
+function stringifyConcat(operand1, operand2, dialect) {
+    if (dialect === "mysql") {
+        return `CONCAT(${operand1}, ${operand2})`;
+    }
+    // sqlite and postgresql use || for string concatenation
+    return `(${operand1} || ${operand2})`;
+}
+async function updateMany(input, dbCall, formatQuery, dialect, cache) {
+    async function _updateMany() {
+        const escapeId = (0, stringifyWhere_1.getEscapeId)(dialect);
+        const tableArtifacts = input.artifacts[input.resource];
+        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) { }
+        // Shallow clone, as we're going to mutate later
+        const data = { ...input.data };
+        if (hasMappedFields(input.artifacts, input.resource, data)) {
+            await mapMappedFields(tableArtifacts, data, dbCall, formatQuery);
+        }
+        if ((dialect === "mysql" || dialect === "postgresql") &&
+            tableArtifacts.dateTimeFieldsCount > 0) {
+            for (let k in tableArtifacts.dateTimeFields) {
+                if (data[k] != null) {
+                    data[k] = (0, getDateTimeStringMySQL_1.getDateTimeStringMySQL)(data[k]);
+                }
+            }
+        }
+        // Delete keys with value of undefined
+        for (let k in data) {
+            if (data[k] === void 0) {
+                delete data[k];
+            }
+        }
+        // Nothing to update
+        if (Object.keys(data).length === 0) {
+            return [];
+        }
+        await dbCall(getUpdateQuery(input.resource, data, where, dialect, formatQuery));
+        return true;
+    }
+    await _updateMany();
+    return getData(input, dbCall, formatQuery, dialect);
+}
+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 SDKNotFoundError_1.SDKNotFoundError();
+    }
+    if (cache && current.uuid)
+        cache.purge(current.uuid);
+    await dbCall(formatQuery("DELETE FROM ?? WHERE ?? = ?", [
+        input.resource,
+        findOne.key,
+        findOne.value
+    ]));
+    return true;
+}
+async function deleteMany(input, dbCall, formatQuery, dialect, cache) {
+    const escapeId = (0, stringifyWhere_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) { }
+    const sql = "DELETE FROM ?? WHERE " + where;
+    const values = [input.resource];
+    await dbCall(formatQuery(sql, values));
+    return true;
+}
+function getScalarFields(table, artifacts) {
+    return artifacts[table].scalarFields;
+}
+function hasMappedFields(artifacts, table, data) {
+    const mappedFields = artifacts[table].mappedFields;
+    if (mappedFields == null) {
+        return false;
+    }
+    const keys = new Set(Object.keys(mappedFields));
+    const dataKeys = Object.keys(data);
+    return dataKeys.some((k) => keys.has(k));
+}
+async function mapMappedFields(artifactsForTable, data, dbCall, formatQuery) {
+    for (let k in data) {
+        const v = data[k];
+        if (artifactsForTable.mappedFields == null) {
+            continue;
+        }
+        const mappedField = artifactsForTable.mappedFields[k];
+        if (mappedField == null) {
+            continue;
+        }
+        if (Object.prototype.hasOwnProperty.call(data, mappedField.foreignKey)) {
+            throw new Error("Must not supply both UUID and ID: " + mappedField.foreignKey);
+        }
+        if (v === null) {
+            data[mappedField.foreignKey] = v;
+            delete data[k];
+        }
+        else if (v === void 0) {
+            delete data[k];
+        }
+        else if (Array.isArray(v)) {
+            data[mappedField.foreignKey] = await Promise.all(v.map(async (w) => {
+                const result = await dbCall(formatQuery("SELECT ?? FROM ?? WHERE ?? = ?", [
+                    mappedField.referencedKey,
+                    mappedField.referencedTable,
+                    mappedField.name,
+                    w
+                ])).then((xs) => xs[0]?.[mappedField.referencedKey]);
+                if (result == null) {
+                    throw new SDKNotFoundError_1.SDKNotFoundError();
+                }
+                return result;
+            }));
+            delete data[k];
+        }
+        else {
+            const result = await dbCall(formatQuery("SELECT ?? FROM ?? WHERE ?? = ?", [
+                mappedField.referencedKey,
+                mappedField.referencedTable,
+                mappedField.name,
+                v
+            ])).then((xs) => xs[0]?.[mappedField.referencedKey]);
+            if (result == null) {
+                throw new SDKNotFoundError_1.SDKNotFoundError();
+            }
+            data[mappedField.foreignKey] = result;
+            delete data[k];
+        }
+    }
+}
+// 1. Remove additional keys added to data for batches and joins
+function postProcess(data, fields, shouldRemoveExtraKeys) {
+    if (shouldRemoveExtraKeys) {
+        removeExtraKeys(data, fields);
+    }
+}
+function removeExtraKeys(data, fields) {
+    if (data == null || (Array.isArray(data) && data[0] == null)) {
+        return;
+    }
+    let fieldKeys = Object.keys(fields);
+    const dataKeys = Array.isArray(data) ? Object.keys(data[0]) : Object.keys(data);
+    const extraDataKeys = _.difference(dataKeys, fieldKeys);
+    for (let k of extraDataKeys) {
+        if (Array.isArray(data)) {
+            for (let d of data) {
+                delete d[k];
+            }
+        }
+        else {
+            delete data[k];
+        }
+    }
+    const entries = Object.entries(fields);
+    for (let [k, v] of entries) {
+        if (typeof v === "object" && v.$fields != null) {
+            if (Array.isArray(data)) {
+                for (let d of data) {
+                    removeExtraKeys(d[k], v.$fields);
+                }
+            }
+            else {
+                removeExtraKeys(data[k], v.$fields);
+            }
+        }
+    }
+}
+const getTypeCastMap = _.memoize(function getTypeCastMap(artifacts) {
+    const typeCastMap = new Map();
+    for (let table in artifacts) {
+        let booleanColumns = new Set();
+        for (let field of artifacts[table].fields) {
+            if (field.kind === "scalar" && field.type === "boolean") {
+                booleanColumns.add(field.name);
+            }
+        }
+        typeCastMap.set(table, { boolean: booleanColumns });
+    }
+    return typeCastMap;
+});
+function typeCastSqlite(data, fields, table, artifacts) {
+    if (data == null || (Array.isArray(data) && data[0] == null)) {
+        return;
+    }
+    const typeCastMap = getTypeCastMap(artifacts);
+    const booleanColumns = typeCastMap.get(table)?.boolean;
+    if (booleanColumns == null) {
+        throw new Error(`Failed to resolve typeCastMap for table \`${table}\``);
+    }
+    if (booleanColumns.size > 0) {
+        const keys = Object.keys(fields);
+        for (let k of keys) {
+            if (booleanColumns.has(k)) {
+                if (Array.isArray(data)) {
+                    for (let d of data) {
+                        d[k] = !!d[k];
+                    }
+                }
+                else {
+                    data[k] = !!data[k];
+                }
+            }
+        }
+    }
+    const tableArtifacts = artifacts[table];
+    const entries = Object.entries(fields);
+    for (let [k, v] of entries) {
+        if (typeof v === "object") {
+            const relationFields = tableArtifacts.relationFields[k];
+            if (relationFields == null) {
+                throw new Error(`Failed to resolve relationFields for field \`${k}\``);
+            }
+            const fields = v.$fields ??
+                tableArtifacts.scalarFields.reduce((acc, x) => {
+                    acc[x] = true;
+                    return acc;
+                }, {});
+            if (Array.isArray(data)) {
+                for (let d of data) {
+                    typeCastSqlite(d[k], fields, relationFields.table, artifacts);
+                }
+            }
+            else {
+                typeCastSqlite(data[k], fields, relationFields.table, artifacts);
+            }
+        }
+    }
+}
+function whereNeedsProcessing(where) {
+    return JSON.stringify(where).includes("Uuid");
+}
+async function _prepareWhere(artifacts, table, data, dbCall, formatQuery) {
+    const mappedFields = artifacts[table].mappedFields;
+    let out = {};
+    await traverseWhere(data, async (where, ptr, parentPtr, root) => {
+        const path = ptr.split("/").slice(1);
+        const opIndex = path.length - 1;
+        if (ops.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 SDKBadWhereError_1.SDKBadWhereError();
+                        }
+                        else {
+                            const v = where[index];
+                            throw new SDKBadWhereError_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 SDKBadWhereError_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 SDKBadWhereError_1.SDKBadWhereError();
+                        }
+                        else {
+                            const v = where[index];
+                            throw new SDKBadWhereError_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 SDKBadWhereError_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;
+}
+function getPrepareWhereNotFoundMessage(mappedField, value) {
+    return `Not found: unable to map \`${mappedField.referencedTable}\`.\`${mappedField.name}\` to \`${mappedField.referencedTable}\`.\`${mappedField.referencedKey}\` for the value \`${value}\`.`;
+}
+const ops = [
+    "$eq",
+    "$neq",
+    "$gt",
+    "$gte",
+    "$lt",
+    "$lte",
+    "$in",
+    "$nin",
+    "$like",
+    "$nlike",
+    "$btwn",
+    "$nbtwn"
+];
+async function traverseWhere(where, cb) {
+    return await _traverseWhere(cb, where, "", where);
+}
+const _traverseWhere = async function (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");
+}