@technicity/data-service-generator 0.14.0 → 0.14.1

package/dist/ksql.d.ts

@@ -0,0 +1,15 @@
+declare type THeaders = {
+    [k: string]: any;
+};
+export declare class KSQL {
+    hostname: string;
+    port: number;
+    headers?: THeaders;
+    constructor(options: {
+        hostname: string;
+        port: number;
+        headers?: THeaders;
+    });
+    streamQuery(s: string): Promise<any[]>;
+}
+export {};

package/dist/ksql.js

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

package/dist/runtime/Cache.js

@@ -1,13 +1,10 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const crypto_1 = require("crypto");
-const ioredis_1 = __importDefault(require("ioredis"));
-const loglevel_1 = __importDefault(require("loglevel"));
+const ioredis_1 = require("ioredis");
+const loglevel_1 = require("loglevel");
 const utility_1 = require("./lib/utility");
-const Stats_1 = __importDefault(require("./Stats"));
+const Stats_1 = require("./Stats");
 class Cache {
     constructor(redisConfig, debug) {
         this.waiting = new Set();

package/dist/runtime/IRuntime.d.ts

@@ -5,35 +5,28 @@ export interface IRuntime {
     $whereNeedsProcessing(where: any): boolean;
     $prepareWhere(artifacts: IArtifacts, table: string, data: any): Promise<any>;
     $shutdown(): Promise<void>;
-    $startTransaction(input?: {
-        isolationLevel?: "READ UNCOMMITTED" | "READ COMMITTED" | "REPEATABLE READ" | "SERIALIZABLE";
-    }): Promise<TBeginTransactionResult>;
 }
-export declare type TAction = "findUnique" | "findMany" | "findManyPaginated" | "create" | "update" | "updateMany" | "delete" | "deleteMany";
 export declare type TResolveParams = {
     resource: string;
-    action: TAction;
-    args?: IArgs;
+    action: "findUnique" | "findMany" | "findManyPaginated" | "create" | "update" | "updateMany" | "delete" | "deleteMany";
+    args?: IArgs | undefined;
     data?: any;
     artifacts: IArtifacts;
-    fields?: TSelect;
-    context?: TContext;
+    fields?: IField[] | undefined;
+    context?: TContext | undefined;
     skipCache?: boolean;
-    dbCall?: TDbCall;
 };
 export declare type TContext = {
     [k: string]: any;
 };
 export declare type TMiddleware = (params: TResolveParams, next: (params: TResolveParams) => Promise<any>) => Promise<any>;
-export declare type IDialect = "mysql" | "mssql" | "sqlite";
+export declare type IDialect = "mysql" | "mssql" | "ksql";
 export declare type TDbCall = (q: string) => Promise<any>;
 export declare type TFormatQuery = (q: string, values: any[]) => string;
-export declare type TBeginTransaction = () => Promise<TBeginTransactionResult>;
-declare type TBeginTransactionResult = {
+export declare type TBeginTransaction = () => Promise<{
     dbCall: (q: string) => Promise<any>;
     commit: () => Promise<void>;
-    rollback: () => Promise<void>;
-};
+}>;
 export declare type ISupplementClientOpts = boolean;
 export declare type IOrderBy = {
     column: string;
@@ -42,10 +35,12 @@ export declare type IOrderBy = {
 export declare type IArgs = {
     [k: string]: any;
 };
-export declare type TSelect = {
-    [k: string]: boolean | {
-        $fields?: TSelect;
-    };
+export declare type IField = string | {
+    name: string;
+    as?: string;
+    fields: IField[];
+    args?: IArgs;
+    transform?: (record: any) => any;
 };
 declare type IWhere = (table: string, args: IArgs) => string | undefined;
 declare type IASTChildColumn = {
@@ -53,14 +48,14 @@ declare type IASTChildColumn = {
     name: string;
     fieldName: string;
     as: string;
-    fromOtherTable?: string;
+    fromOtherTable?: string | undefined;
 };
 declare type IASTChildComposite = {
     type: "composite";
     name: string[];
     fieldName: string;
     as: string;
-    fromOtherTable?: string;
+    fromOtherTable?: string | undefined;
 };
 declare type ISqlJoin = (t1: string, t2: string, args: IArgs) => string;
 declare type ISqlBatch = {
@@ -86,7 +81,7 @@ declare type IJunction = {
 export declare type IGetSQLASTInput = {
     table: string;
     fieldName: string;
-    fields: TSelect;
+    fields: IField[];
     args?: IArgs;
     where?: IWhere;
     sqlJoin?: ISqlJoin;
@@ -94,7 +89,7 @@ export declare type IGetSQLASTInput = {
     junction?: IJunction;
     grabMany: boolean;
     getWhere: (table: string, args: any, dialect: IDialect, orderBy?: IOrderBy | undefined, rowWithMatchingCursor?: any) => string | null;
-    orderBy?: IOrderBy;
+    orderBy?: IOrderBy | undefined;
     rowWithMatchingCursor?: any;
     artifacts: IArtifacts;
     dialect: IDialect;
@@ -158,30 +153,6 @@ export declare type IArtifacts = {
             [k: string]: boolean;
         };
         dateTimeFieldsCount: number;
-        fields: TField[];
-        dump: {
-            schema: string;
-        } | null;
     };
 };
-export declare type TFieldType = "string" | "boolean" | "number" | "integer";
-export declare type TField = {
-    kind: "scalar";
-    type: TFieldType;
-    name: string;
-    nullable: boolean;
-    hasDefaultValue: boolean;
-    mapped?: true;
-} | {
-    kind: "enum";
-    values: unknown[];
-    name: string;
-    nullable: boolean;
-} | {
-    kind: "object";
-    type: string;
-    name: string;
-    isList: boolean;
-    nullable: boolean;
-};
 export {};

package/dist/runtime/RuntimeKSQL.d.ts

@@ -0,0 +1,19 @@
+import type { IRuntime, TMiddleware, TResolveParams, IArtifacts, TDbCall } from "./IRuntime";
+import { KSQL } from "../ksql";
+declare type TGetTableName = (table: string) => string;
+export declare class RuntimeKSQL implements IRuntime {
+    #private;
+    constructor(clientOpts: ConstructorParameters<typeof KSQL>[0], otherOpts: {
+        getBaseTableName: TGetTableName;
+        getMaterializedViewName: TGetTableName;
+        doNotUseMaterializedViews?: boolean;
+        _dbCall: TDbCall;
+    }, artifacts: IArtifacts);
+    resolve(input: TResolveParams): Promise<any>;
+    $queryRaw(sql: string, values?: any[]): Promise<any>;
+    $use(middleware: TMiddleware): Promise<void>;
+    $whereNeedsProcessing(where: any): boolean;
+    $prepareWhere(artifacts: IArtifacts, table: string, data: any): Promise<{}>;
+    $shutdown(): Promise<void>;
+}
+export {};

package/dist/runtime/RuntimeKSQL.js

@@ -0,0 +1,446 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _RuntimeKSQL_ksql, _RuntimeKSQL_middlewareHandler, _RuntimeKSQL_dbCall, _RuntimeKSQL_formatQuery, _RuntimeKSQL_getBaseTableName, _RuntimeKSQL_getMaterializedViewName, _RuntimeKSQL_doNotUseMaterializedViews;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeKSQL = void 0;
+const SqlString = require("sqlstring");
+const async_hooks_1 = require("async_hooks");
+const _ = require("lodash");
+const graphql_relay_1 = require("graphql-relay");
+const shared_1 = require("./lib/shared");
+const ksql_1 = require("../ksql");
+const SDKNotFoundError_1 = require("./lib/SDKNotFoundError");
+const stringifyWhere_1 = require("./lib/stringifyWhere");
+const cursor_1 = require("./lib/cursor");
+const escapeId = SqlString.escapeId.bind(SqlString);
+class RuntimeKSQL {
+    constructor(clientOpts, otherOpts, artifacts) {
+        _RuntimeKSQL_ksql.set(this, void 0);
+        _RuntimeKSQL_middlewareHandler.set(this, void 0);
+        _RuntimeKSQL_dbCall.set(this, void 0);
+        _RuntimeKSQL_formatQuery.set(this, void 0);
+        _RuntimeKSQL_getBaseTableName.set(this, void 0);
+        _RuntimeKSQL_getMaterializedViewName.set(this, void 0);
+        _RuntimeKSQL_doNotUseMaterializedViews.set(this, void 0);
+        __classPrivateFieldSet(this, _RuntimeKSQL_ksql, new ksql_1.KSQL(clientOpts ?? {}), "f");
+        __classPrivateFieldSet(this, _RuntimeKSQL_middlewareHandler, new shared_1.MiddlewareHandler(), "f");
+        __classPrivateFieldSet(this, _RuntimeKSQL_dbCall, typeof otherOpts._dbCall === "function"
+            ? (q) => otherOpts._dbCall(q).then(mapResult)
+            : (q) => __classPrivateFieldGet(this, _RuntimeKSQL_ksql, "f").streamQuery(q).then(mapResult), "f");
+        __classPrivateFieldSet(this, _RuntimeKSQL_getBaseTableName, otherOpts.getBaseTableName, "f");
+        __classPrivateFieldSet(this, _RuntimeKSQL_getMaterializedViewName, otherOpts.getMaterializedViewName, "f");
+        __classPrivateFieldSet(this, _RuntimeKSQL_doNotUseMaterializedViews, otherOpts.doNotUseMaterializedViews ?? false, "f");
+        __classPrivateFieldSet(this, _RuntimeKSQL_formatQuery, SqlString.format.bind(SqlString), "f");
+    }
+    async resolve(input) {
+        return resolve(input, __classPrivateFieldGet(this, _RuntimeKSQL_dbCall, "f").bind(this), __classPrivateFieldGet(this, _RuntimeKSQL_formatQuery, "f").bind(this), __classPrivateFieldGet(this, _RuntimeKSQL_middlewareHandler, "f"), __classPrivateFieldGet(this, _RuntimeKSQL_getBaseTableName, "f"), __classPrivateFieldGet(this, _RuntimeKSQL_getMaterializedViewName, "f"), __classPrivateFieldGet(this, _RuntimeKSQL_doNotUseMaterializedViews, "f"));
+    }
+    async $queryRaw(sql, values) {
+        return __classPrivateFieldGet(this, _RuntimeKSQL_dbCall, "f").call(this, SqlString.format(sql, values ?? []));
+    }
+    async $use(middleware) {
+        __classPrivateFieldGet(this, _RuntimeKSQL_middlewareHandler, "f").register(middleware);
+    }
+    $whereNeedsProcessing(where) {
+        return (0, shared_1.whereNeedsProcessing)(where);
+    }
+    async $prepareWhere(artifacts, table, data) {
+        return (0, shared_1._prepareWhere)(artifacts, table, data, __classPrivateFieldGet(this, _RuntimeKSQL_dbCall, "f").bind(this), __classPrivateFieldGet(this, _RuntimeKSQL_formatQuery, "f").bind(this));
+    }
+    async $shutdown() {
+        // Nothing to do here, I think
+    }
+}
+exports.RuntimeKSQL = RuntimeKSQL;
+_RuntimeKSQL_ksql = new WeakMap(), _RuntimeKSQL_middlewareHandler = new WeakMap(), _RuntimeKSQL_dbCall = new WeakMap(), _RuntimeKSQL_formatQuery = new WeakMap(), _RuntimeKSQL_getBaseTableName = new WeakMap(), _RuntimeKSQL_getMaterializedViewName = new WeakMap(), _RuntimeKSQL_doNotUseMaterializedViews = new WeakMap();
+async function resolve(input, dbCall, formatQuery, middlewareHandler, getBaseTableName, getMaterializedViewName, doNotUseMaterializedViews) {
+    // 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 = (paramsMaybeMutated) => {
+            const nextMiddleware = middlewareHandler.get(++index);
+            if (nextMiddleware != null) {
+                return nextMiddleware(paramsMaybeMutated, consumer);
+            }
+            const paramsChanged = { ...input, ...params };
+            return _resolve(paramsChanged, dbCall, formatQuery, getBaseTableName, getMaterializedViewName, doNotUseMaterializedViews);
+        };
+        return resource.runInAsyncScope(() => consumer(params));
+    }
+    return _resolve(input, dbCall, formatQuery, getBaseTableName, getMaterializedViewName, doNotUseMaterializedViews);
+}
+function _resolve(input, dbCall, formatQuery, getBaseTableName, getMaterializedViewName, doNotUseMaterializedViews) {
+    if (input.action === "findUnique") {
+        return getData(input, dbCall, formatQuery, getBaseTableName, getMaterializedViewName, doNotUseMaterializedViews);
+    }
+    if (input.action === "findMany") {
+        return getData(input, dbCall, formatQuery, getBaseTableName, getMaterializedViewName, doNotUseMaterializedViews);
+    }
+    if (input.action === "findManyPaginated") {
+        return getData(input, dbCall, formatQuery, getBaseTableName, getMaterializedViewName, doNotUseMaterializedViews);
+    }
+    if (input.action === "create") {
+        throw new Error("Not implemented.");
+    }
+    if (input.action === "update") {
+        throw new Error("Not implemented.");
+    }
+    if (input.action === "updateMany") {
+        throw new Error("Not implemented.");
+    }
+    if (input.action === "delete") {
+        throw new Error("Not implemented.");
+    }
+    if (input.action === "deleteMany") {
+        throw new Error("Not implemented.");
+    }
+    throw new Error("Invalid action: " + input.action);
+}
+async function getData(input, dbCall, formatQuery, getBaseTableName, getMaterializedViewName, doNotUseMaterializedViews) {
+    const { action } = input;
+    const grabMany = action === "findMany" ||
+        action === "findManyPaginated" ||
+        action === "updateMany" ||
+        action === "deleteMany";
+    const data = await _getData(input, grabMany, dbCall, formatQuery, getBaseTableName, getMaterializedViewName, doNotUseMaterializedViews);
+    if (data == null && !grabMany) {
+        throw new SDKNotFoundError_1.SDKNotFoundError();
+    }
+    const scalarFields = input.artifacts[input.resource].scalarFields;
+    if (action === "findManyPaginated" && data?.results != null) {
+        (0, shared_1.postProcess)(data.results, input.fields ?? scalarFields, true);
+    }
+    else {
+        (0, shared_1.postProcess)(data, input.fields ?? scalarFields, true);
+    }
+    return data;
+}
+async function _getData(input, grabMany, dbCall, formatQuery, getBaseTableName, getMaterializedViewName, doNotUseMaterializedViews) {
+    const { resource: table, artifacts, args, action } = input;
+    const tableArtifacts = artifacts[table];
+    const isInputFieldAnArray = Array.isArray(input.fields);
+    let fields = input.fields;
+    if (!Array.isArray(fields)) {
+        fields = tableArtifacts.scalarFields;
+    }
+    let useMaterializedView = !doNotUseMaterializedViews &&
+        // If fields isn't an array, we're only getting scalar fields,
+        // so no point using the materialized view.
+        isInputFieldAnArray &&
+        // We're getting relation fields
+        fields.some((x) => typeof x === "object") &&
+        Object.values(tableArtifacts.relationFields).filter((x) => x.type === "one-to-many__many-to-one" && x.kind === "many-to-one").length > 0 &&
+        !Object.values(tableArtifacts.relationFields).some((x) => x.type === "one-to-many__many-to-one" &&
+            x.kind === "many-to-one" &&
+            x.nullable === true);
+    const getTableName = useMaterializedView
+        ? getMaterializedViewName
+        : getBaseTableName;
+    let where = undefined;
+    if (args?.$where != null) {
+        let argsMapped = args;
+        if (typeof argsMapped.$where === "object" &&
+            argsMapped.$where[table] != null) {
+            argsMapped = _.cloneDeep(argsMapped);
+            argsMapped.$where = argsMapped.$where[table];
+        }
+        const whereResult = (0, stringifyWhere_1.stringifyWhere)({
+            where: argsMapped.$where,
+            table: escapeId(getTableName(table)),
+            dialect: "mysql",
+            args: argsMapped,
+        });
+        if (whereResult) {
+            where = whereResult;
+        }
+    }
+    let columns = [];
+    let mappedFields = [];
+    let relationFields = [];
+    for (let x of fields) {
+        if (typeof x === "string") {
+            const mappedField = tableArtifacts.mappedFields?.[x];
+            if (mappedField != null) {
+                mappedFields.push(x);
+                if (!columns.includes(mappedField.foreignKey)) {
+                    columns.push(mappedField.foreignKey);
+                }
+            }
+            else {
+                columns.push(x);
+            }
+        }
+        else {
+            const relationField = tableArtifacts.relationFields?.[x.name];
+            if (relationField == null) {
+                throw new Error(`Invalid relation field: ${x.name}`);
+            }
+            if (relationField.type === "one-to-many__many-to-one") {
+                relationFields.push(x);
+                if (!columns.includes(relationField.relation.foreignKey)) {
+                    columns.push(relationField.relation.foreignKey);
+                }
+            }
+            else if (relationField.type === "many-to-many") {
+                relationFields.push(x);
+                if (!columns.includes(relationField.relations[0].referencedKey)) {
+                    columns.push(relationField.relations[0].referencedKey);
+                }
+            }
+        }
+    }
+    if (action === "findManyPaginated") {
+        // For cursor
+        if (!columns.includes(tableArtifacts.primaryKey)) {
+            columns.push(tableArtifacts.primaryKey);
+        }
+    }
+    if (useMaterializedView) {
+        relationFields = relationFields.filter((x) => {
+            if (typeof x === "string") {
+                return true;
+            }
+            const relationField = tableArtifacts.relationFields?.[x.name];
+            if (relationField == null) {
+                throw new Error(`Invalid relation field: ${x.name}`);
+            }
+            // Since we're going to use the materialized view,
+            // filter out non-nullable many-to-one relations.
+            return !(relationField.type === "one-to-many__many-to-one" &&
+                relationField.kind === "many-to-one" &&
+                relationField.nullable === false);
+        });
+    }
+    let s = useMaterializedView
+        ? formatQuery(`SELECT * FROM ??`, [getTableName(table)])
+        : formatQuery(`SELECT ?? FROM ??`, [columns, getTableName(table)]);
+    if (where) {
+        s += ` WHERE ${where}`;
+    }
+    s += ";";
+    return dbCall(s).then((_result) => {
+        let result = grabMany ? _result : _result[0];
+        if (result == null) {
+            return null;
+        }
+        if (grabMany && Array.isArray(result)) {
+            // Important: ordering must be before pagination, since pagination is done in code
+            let orderBy;
+            if (args == null || args.$orderBy == null) {
+                orderBy = [{ column: tableArtifacts.primaryKey, direction: "asc" }];
+            }
+            else if (Array.isArray(args.$orderBy)) {
+                orderBy = args.$orderBy.map((x) => {
+                    const [column, direction] = Object.entries(x)[0];
+                    return { column, direction };
+                });
+            }
+            else {
+                const [column, direction] = Object.entries(args.$orderBy)[0];
+                orderBy = [{ column, direction }];
+            }
+            for (let x of orderBy) {
+                if (!["asc", "desc"].includes(x.direction)) {
+                    throw new Error(`Expected \`asc\` or \`desc\` for \`direction\` but got: ${x.direction}`);
+                }
+            }
+            result = _.orderBy(result, orderBy.map((x) => x.column), orderBy.map((x) => x.direction));
+            if (action === "findManyPaginated") {
+                result = paginate(result, args, tableArtifacts.primaryKey, action);
+                return Promise.all(result.results.map((x) => resolveDependentFields(table, x, mappedFields, relationFields, artifacts, dbCall, formatQuery, getBaseTableName, getMaterializedViewName, doNotUseMaterializedViews).then((xx) => mergeSubResults(x, xx)))).then((xx) => {
+                    result.results = xx;
+                    return result;
+                });
+            }
+            const limit = args?.$limit;
+            if (typeof limit === "number") {
+                result = result.slice(0, limit);
+            }
+            return Promise.all(result.map((x) => resolveDependentFields(table, x, mappedFields, relationFields, artifacts, dbCall, formatQuery, getBaseTableName, getMaterializedViewName, doNotUseMaterializedViews).then((xx) => mergeSubResults(x, xx))));
+        }
+        return resolveDependentFields(table, result, mappedFields, relationFields, artifacts, dbCall, formatQuery, getBaseTableName, getMaterializedViewName, doNotUseMaterializedViews).then((xx) => mergeSubResults(result, xx));
+    });
+}
+async function resolveDependentFields(table, parentData, mappedFields, relationFields, artifacts, dbCall, formatQuery, getBaseTableName, getMaterializedViewName, doNotUseMaterializedViews) {
+    const tableArtifacts = artifacts[table];
+    return Promise.all([]
+        .concat(mappedFields.map((x) => {
+        const mappedField = tableArtifacts.mappedFields?.[x];
+        if (mappedField == null) {
+            throw new Error(`Invalid mappedField: ${x}`);
+        }
+        if (parentData?.[mappedField.foreignKey] == null) {
+            return { [x]: null };
+        }
+        const s = formatQuery(`SELECT ?? FROM ?? WHERE ?? = ?;`, [
+            mappedField.name,
+            getBaseTableName(mappedField.referencedTable),
+            mappedField.referencedKey,
+            parentData?.[mappedField.foreignKey],
+        ]);
+        return dbCall(s).then((xs) => ({
+            [x]: xs?.[0]?.[mappedField.name] ?? null,
+        }));
+    }))
+        .concat(relationFields.map((x) => {
+        if (typeof x === "string") {
+            throw new Error(`Invalid field: ${x}`);
+        }
+        const relationField = tableArtifacts.relationFields?.[x.name];
+        if (relationField == null) {
+            throw new Error("Invalid field: " + table + "." + x.name);
+        }
+        if (relationField.type === "many-to-many") {
+            const junctionReferencedKey = relationField.relations[0].referencedKey;
+            const junctionKeyValue = parentData?.[junctionReferencedKey];
+            if (junctionKeyValue == null) {
+                return { [x.as ?? x.name]: [] };
+            }
+            let whereJunction = typeof x?.args?.$where === "object" &&
+                x.args.$where != null &&
+                x.args.$where[relationField.junctionTable] != null
+                ? _.cloneDeep(x.args.$where[relationField.junctionTable])
+                : {};
+            whereJunction = {
+                $and: [
+                    { [relationField.relations[0].foreignKey]: junctionKeyValue },
+                    whereJunction,
+                ],
+            };
+            const key = relationField.relations[1].foreignKey;
+            const s = formatQuery(`SELECT ?? FROM ?? WHERE ${(0, stringifyWhere_1.stringifyWhere)({
+                where: whereJunction,
+                table: escapeId(getBaseTableName(relationField.junctionTable)),
+                dialect: "mysql",
+                // Since we're paginating, empty is fine
+                args: {},
+            })};`, [key, getBaseTableName(relationField.junctionTable)]);
+            return dbCall(s)
+                .then((xs) => xs.map((x) => x?.[key]))
+                .then((keys) => {
+                const whereDest = {
+                    [relationField.relations[1].referencedKey]: { $in: keys },
+                };
+                const argsMapped = x.args == null ? {} : _.cloneDeep(x.args);
+                if (typeof argsMapped?.$where === "object" &&
+                    argsMapped.$where != null &&
+                    argsMapped.$where[relationField.table] != null) {
+                    argsMapped.$where = {
+                        $and: [whereDest, argsMapped.$where[relationField.table]],
+                    };
+                }
+                else if (argsMapped.$where != null) {
+                    argsMapped.$where = { $and: [whereDest, argsMapped.$where] };
+                }
+                else {
+                    argsMapped.$where = whereDest;
+                }
+                return _getData({
+                    resource: relationField.table,
+                    args: argsMapped,
+                    fields: x.fields,
+                    artifacts,
+                    action: relationField.grabMany ? "findMany" : "findUnique",
+                }, relationField.grabMany, dbCall, formatQuery, getBaseTableName, getMaterializedViewName, doNotUseMaterializedViews).then((xx) => ({ [x.as ?? x.name]: xx }));
+            });
+        }
+        if (relationField.type === "one-to-many__many-to-one") {
+            const referencedKey = relationField.relation.referencedKey;
+            const foreignKeyValue = parentData?.[relationField.relation.foreignKey];
+            if (foreignKeyValue == null) {
+                return { [x.as ?? x.name]: relationField.grabMany ? [] : null };
+            }
+            const whereRef = { [referencedKey]: foreignKeyValue };
+            const argsMapped = x.args == null ? {} : _.cloneDeep(x.args);
+            if (argsMapped.$where == null) {
+                argsMapped.$where = whereRef;
+            }
+            else {
+                argsMapped.$where = { $and: [whereRef, argsMapped.$where] };
+            }
+            return _getData({
+                resource: relationField.table,
+                args: argsMapped,
+                fields: x.fields,
+                artifacts,
+                action: relationField.grabMany ? "findMany" : "findUnique",
+            }, relationField.grabMany, dbCall, formatQuery, getBaseTableName, getMaterializedViewName, doNotUseMaterializedViews).then((xx) => ({ [x.as ?? x.name]: xx }));
+        }
+        throw new Error(`Invalid relationField.type`);
+    })));
+}
+function mergeSubResults(result, subResults) {
+    for (let x of subResults) {
+        result = { ...result, ...x };
+    }
+    return result;
+}
+function paginate(data, args, primaryKey, action) {
+    if (action === "findManyPaginated") {
+        if (typeof args?.$paginate?.limit === "number") {
+            const totalCount = data.length;
+            const limit = args.$paginate.limit;
+            const offset = args.$paginate.offset ?? 0;
+            data = data.slice(offset, offset + limit);
+            return {
+                results: data,
+                paginationInfo: { totalCount },
+            };
+        }
+        if (typeof args?.$paginate?.first === "number" ||
+            typeof args?.$paginate?.last === "number") {
+            const totalCount = data.length;
+            let argsMapped = args;
+            // Convert cursor(s) for graphql-relay
+            for (let k of ["after", "before"]) {
+                if (args?.$paginate?.[k] != null) {
+                    argsMapped = _.cloneDeep(argsMapped);
+                    const offset = data.findIndex((x) => x[primaryKey] === (0, cursor_1.decodeCursor)(args.$paginate[k]));
+                    if (offset === -1) {
+                        throw new Error(`Invalid cursor: ${args.$paginate[k]}`);
+                    }
+                    argsMapped.$paginate[k] = (0, graphql_relay_1.offsetToCursor)(offset);
+                }
+            }
+            const connection = (0, graphql_relay_1.connectionFromArray)(data, argsMapped.$paginate);
+            const results = connection.edges.map((x) => x.node);
+            // Convert cursors back
+            const startKey = results[0]?.[primaryKey];
+            const endKey = results[results.length - 1]?.[primaryKey];
+            const startCursor = startKey == null ? null : (0, cursor_1.encodeCursor)(startKey);
+            const endCursor = endKey == null ? null : (0, cursor_1.encodeCursor)(endKey);
+            return {
+                results,
+                paginationInfo: {
+                    ...connection.pageInfo,
+                    startCursor,
+                    endCursor,
+                    totalCount,
+                },
+            };
+        }
+    }
+    throw new Error(`Invalid pagination action: ${action}`);
+}
+function mapResult(data) {
+    return data.map((x) => {
+        for (let k of Object.keys(x)) {
+            if (typeof x[k] === "string" && (k === "uuid" || k.endsWith("Uuid"))) {
+                x[k] = x[k].toLocaleLowerCase();
+            }
+        }
+        return x;
+    });
+}