@technicity/data-service-generator 0.5.16 → 0.6.0

package/dist/generation/generate.js

@@ -114,7 +114,7 @@ async function generate(input) {
     const tmpBuildOutputPath = path.join(tmpDirPath, "sdk-ts");
     const outdir = path.resolve(input.outdir);
     const sdkOutputPath = path.join(outdir, "sdk-ts");
-    const nccVersion = "^0.29.0";
+    const nccVersion = "^0.33.0";
     child_process.execSync("npm i", { cwd: tmpDirPath, stdio: "inherit" });
     child_process.execSync(`npx -p @vercel/ncc@${nccVersion} ncc build ./${sdkFilename} -o ${tmpBuildOutputPath} -e ./artifacts`, { cwd: tmpDirPath, stdio: "inherit" });
     // TODO: workaround for artifacts.js not being output by ncc
@@ -815,27 +815,23 @@ async function getJSONSchemaWhere(table) {
     };
 }
 async function getTypeOrderBy(table, name) {
-    return (0, json_schema_to_typescript_1.compile)((await getJSONSchemaOrderBy(table)), name, json2TsOpts);
+    return (0, json_schema_to_typescript_1.compile)((await getJSONSchemaOrderBy(table, name)), name, json2TsOpts);
 }
-async function getJSONSchemaOrderBy(table) {
+async function getJSONSchemaOrderBy(table, name) {
     const fieldNames = await getTableMeta(table).then((xs) => xs.map((x) => x.Field));
-    const fieldSchemas = fieldNames.map((k) => ({
-        type: "object",
-        properties: { [k]: { enum: ["asc", "desc"] } },
-        required: [k],
-        additionalProperties: false,
-    }));
+    const def = {
+        oneOf: fieldNames.map((k) => ({
+            type: "object",
+            properties: { [k]: { enum: ["asc", "desc"] } },
+            required: [k],
+            additionalProperties: false,
+        })),
+    };
+    const defName = `_${name}`;
+    const _schema = { $ref: `#/definitions/${defName}` };
     return {
-        oneOf: [
-            ...fieldSchemas,
-            {
-                type: "array",
-                items: { oneOf: fieldSchemas },
-                // minItems: 1,
-                // maxItems: fieldNames.length,
-                // uniqueItems: true,
-            },
-        ],
+        definitions: { [defName]: def },
+        oneOf: [_schema, { type: "array", items: _schema }],
     };
 }
 function getTypeShared() {

package/dist/runtime/IRuntime.d.ts

@@ -26,10 +26,10 @@ export declare type TBeginTransaction = () => Promise<{
     commit: () => Promise<void>;
 }>;
 export declare type ISupplementClientOpts = boolean;
-export declare type IOrderBy = Array<{
+export declare type IOrderBy = {
     column: string;
     direction: any;
-}>;
+}[];
 export declare type IArgs = {
     [k: string]: any;
 };

package/dist/runtime/RuntimeKSQL.d.ts

@@ -1,20 +1,16 @@
-import type { IRuntime, TMiddleware, TResolveParams, IArtifacts, ISupplementClientOpts } from "./IRuntime";
+import type { IRuntime, TMiddleware, TResolveParams, IArtifacts, TDbCall } from "./IRuntime";
 import { KSQL } from "../ksql";
-import { MSSQL } from "./lib/MSSQL";
+declare type TGetTableName = (table: string) => string;
 export declare class RuntimeKSQL implements IRuntime {
     #private;
     constructor(clientOpts: ConstructorParameters<typeof KSQL>[0], otherOpts: {
-        mssql: ConstructorParameters<typeof MSSQL>[0];
-        supplementClientOpts?: ISupplementClientOpts;
+        getBaseTableName: TGetTableName;
+        _dbCall: TDbCall;
     }, artifacts: IArtifacts);
     resolve(input: TResolveParams): Promise<any>;
-    $queryRaw(sql: string, values?: any[]): 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<{}>;
-    private post;
-    private patch;
-    private patchList;
-    private del;
-    private deleteList;
 }
+export {};

package/dist/runtime/RuntimeKSQL.js

@@ -10,81 +10,37 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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_mssqlClient, _RuntimeKSQL_middlewareHandler, _RuntimeKSQL_tableKeyMap;
+var _RuntimeKSQL_ksql, _RuntimeKSQL_middlewareHandler, _RuntimeKSQL_dbCall, _RuntimeKSQL_formatQuery, _RuntimeKSQL_getBaseTableName;
 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 getWhere_1 = require("./lib/getWhere");
 const ksql_1 = require("../ksql");
 const SDKNotFoundError_1 = require("./lib/SDKNotFoundError");
-const MSSQL_1 = require("./lib/MSSQL");
-const typeCastMSSQL_1 = require("./lib/typeCastMSSQL");
+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_mssqlClient.set(this, void 0);
         _RuntimeKSQL_middlewareHandler.set(this, void 0);
-        _RuntimeKSQL_tableKeyMap.set(this, void 0);
-        __classPrivateFieldSet(this, _RuntimeKSQL_ksql, new ksql_1.KSQL(clientOpts), "f");
-        __classPrivateFieldSet(this, _RuntimeKSQL_mssqlClient, new MSSQL_1.MSSQL(otherOpts.mssql, otherOpts?.supplementClientOpts ? (0, typeCastMSSQL_1.typeCastMSSQL)() : undefined), "f");
+        _RuntimeKSQL_dbCall.set(this, void 0);
+        _RuntimeKSQL_formatQuery.set(this, void 0);
+        _RuntimeKSQL_getBaseTableName.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_tableKeyMap, {}, "f");
-        for (let table in artifacts) {
-            let map = {};
-            for (let kk of artifacts[table].scalarFields) {
-                map[kk.toLocaleUpperCase()] = kk;
-            }
-            __classPrivateFieldGet(this, _RuntimeKSQL_tableKeyMap, "f")[table] = map;
-        }
+        __classPrivateFieldSet(this, _RuntimeKSQL_dbCall, otherOpts._dbCall ?? __classPrivateFieldGet(this, _RuntimeKSQL_ksql, "f").streamQuery.bind(__classPrivateFieldGet(this, _RuntimeKSQL_ksql, "f")), "f");
+        __classPrivateFieldSet(this, _RuntimeKSQL_getBaseTableName, otherOpts.getBaseTableName, "f");
+        __classPrivateFieldSet(this, _RuntimeKSQL_formatQuery, SqlString.format.bind(SqlString), "f");
     }
     async resolve(input) {
-        if (input.action === "findMany" || input.action === "findManyPaginated") {
-            const primaryKey = input.artifacts[input.resource].primaryKey;
-            // Overwrite
-            input.fields = [primaryKey];
-            const resolved = await (0, shared_1.resolve)(input, __classPrivateFieldGet(this, _RuntimeKSQL_mssqlClient, "f").dbCall.bind(__classPrivateFieldGet(this, _RuntimeKSQL_mssqlClient, "f")), __classPrivateFieldGet(this, _RuntimeKSQL_mssqlClient, "f").formatQuery.bind(__classPrivateFieldGet(this, _RuntimeKSQL_mssqlClient, "f")), __classPrivateFieldGet(this, _RuntimeKSQL_mssqlClient, "f").beginTransaction.bind(__classPrivateFieldGet(this, _RuntimeKSQL_mssqlClient, "f")), "mssql", __classPrivateFieldGet(this, _RuntimeKSQL_middlewareHandler, "f"), input.context ?? {});
-            const keys = input.action === "findMany"
-                ? resolved.map((x) => x[primaryKey])
-                : resolved.results.map((x) => x[primaryKey]);
-            if (keys.length === 0) {
-                return resolved;
-            }
-            const sql = SqlString.format("SELECT * FROM ?? WHERE ?? IN (?);", [
-                getKSQLTablename(input.resource, input?.context?.hydrate),
-                primaryKey,
-                keys,
-            ]);
-            const results = await __classPrivateFieldGet(this, _RuntimeKSQL_ksql, "f").streamQuery(sql);
-            for (let x of results) {
-                mapKeys(x, __classPrivateFieldGet(this, _RuntimeKSQL_tableKeyMap, "f")[input.resource]);
-            }
-            if (input.action == "findMany") {
-                return results;
-            }
-            resolved.results = results;
-            return resolved;
-        }
-        else {
-            const table = input.resource;
-            const tableKSQL = getKSQLTablename(input.resource, input?.context?.hydrate);
-            const where = (0, getWhere_1.getWhere)(SqlString.escapeId(tableKSQL), input.args, "mysql");
-            if (!where) {
-                throw new Error("Invalid $where");
-            }
-            const sql = SqlString.format(`SELECT * FROM ?? WHERE ${where};`, [
-                tableKSQL,
-            ]);
-            let out = await __classPrivateFieldGet(this, _RuntimeKSQL_ksql, "f").streamQuery(sql).then((xs) => xs[0]);
-            if (out == null) {
-                throw new SDKNotFoundError_1.SDKNotFoundError();
-            }
-            mapKeys(out, __classPrivateFieldGet(this, _RuntimeKSQL_tableKeyMap, "f")[table]);
-            return out;
-        }
+        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"));
     }
     async $queryRaw(sql, values) {
-        return __classPrivateFieldGet(this, _RuntimeKSQL_ksql, "f").streamQuery(SqlString.format(sql, values ?? []));
+        return __classPrivateFieldGet(this, _RuntimeKSQL_dbCall, "f").call(this, SqlString.format(sql, values ?? []));
     }
     async $use(middleware) {
         __classPrivateFieldGet(this, _RuntimeKSQL_middlewareHandler, "f").register(middleware);
@@ -93,39 +49,340 @@ class RuntimeKSQL {
         return (0, shared_1.whereNeedsProcessing)(where);
     }
     async $prepareWhere(artifacts, table, data) {
-        return (0, shared_1._prepareWhere)(artifacts, table, data, __classPrivateFieldGet(this, _RuntimeKSQL_mssqlClient, "f").dbCall.bind(__classPrivateFieldGet(this, _RuntimeKSQL_mssqlClient, "f")), __classPrivateFieldGet(this, _RuntimeKSQL_mssqlClient, "f").formatQuery.bind(__classPrivateFieldGet(this, _RuntimeKSQL_mssqlClient, "f")));
+        return (0, shared_1._prepareWhere)(artifacts, table, data, __classPrivateFieldGet(this, _RuntimeKSQL_dbCall, "f").bind(this), __classPrivateFieldGet(this, _RuntimeKSQL_formatQuery, "f").bind(this));
+    }
+}
+exports.RuntimeKSQL = RuntimeKSQL;
+_RuntimeKSQL_ksql = new WeakMap(), _RuntimeKSQL_middlewareHandler = new WeakMap(), _RuntimeKSQL_dbCall = new WeakMap(), _RuntimeKSQL_formatQuery = new WeakMap(), _RuntimeKSQL_getBaseTableName = new WeakMap();
+async function resolve(input, dbCall, formatQuery, middlewareHandler, getBaseTableName) {
+    // 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);
+        };
+        return resource.runInAsyncScope(() => consumer(params));
+    }
+    return _resolve(input, dbCall, formatQuery, getBaseTableName);
+}
+function _resolve(input, dbCall, formatQuery, getBaseTableName) {
+    if (input.action === "findUnique") {
+        return getData(input, dbCall, formatQuery, getBaseTableName);
     }
-    async post(input) {
+    if (input.action === "findMany") {
+        return getData(input, dbCall, formatQuery, getBaseTableName);
+    }
+    if (input.action === "findManyPaginated") {
+        return getData(input, dbCall, formatQuery, getBaseTableName);
+    }
+    if (input.action === "create") {
         throw new Error("Not implemented.");
     }
-    async patch(input) {
+    if (input.action === "update") {
         throw new Error("Not implemented.");
     }
-    async patchList(input) {
+    if (input.action === "updateMany") {
         throw new Error("Not implemented.");
     }
-    async del(input) {
+    if (input.action === "delete") {
         throw new Error("Not implemented.");
     }
-    async deleteList(input) {
+    if (input.action === "deleteMany") {
         throw new Error("Not implemented.");
     }
+    throw new Error("Invalid action: " + input.action);
 }
-exports.RuntimeKSQL = RuntimeKSQL;
-_RuntimeKSQL_ksql = new WeakMap(), _RuntimeKSQL_mssqlClient = new WeakMap(), _RuntimeKSQL_middlewareHandler = new WeakMap(), _RuntimeKSQL_tableKeyMap = new WeakMap();
-function getKSQLTablename(tablename, hydrate = true) {
-    return hydrate
-        ? `${tablename.toLocaleUpperCase()}_TAB_HYD`
-        : `${tablename.toLocaleUpperCase()}_TAB`;
+async function getData(input, dbCall, formatQuery, getBaseTableName) {
+    const { action } = input;
+    const grabMany = action === "findMany" ||
+        action === "findManyPaginated" ||
+        action === "updateMany" ||
+        action === "deleteMany";
+    const data = await _getData(input, grabMany, dbCall, formatQuery, getBaseTableName);
+    if (data == null && !grabMany) {
+        throw new SDKNotFoundError_1.SDKNotFoundError();
+    }
+    // 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" && data?.results != null) {
+        (0, shared_1.postProcess)(data.results, input.fields ?? [], shouldRemoveExtraKeys);
+    }
+    else {
+        (0, shared_1.postProcess)(data, input.fields ?? [], shouldRemoveExtraKeys);
+    }
+    return data;
+}
+async function _getData(input, grabMany, dbCall, formatQuery, getBaseTableName) {
+    const { resource: table, artifacts, args, action } = input;
+    const tableArtifacts = artifacts[table];
+    let fields = input.fields;
+    if (!Array.isArray(fields)) {
+        fields = tableArtifacts.scalarFields;
+    }
+    let where = undefined;
+    if (args?.$where != null) {
+        let argsMapped = args;
+        if (Array.isArray(argsMapped?.$where)) {
+            argsMapped = _.cloneDeep(argsMapped);
+            argsMapped.$where = argsMapped.$where[0];
+        }
+        const whereResult = (0, stringifyWhere_1.stringifyWhere)({
+            where: argsMapped.$where,
+            table: escapeId(getBaseTableName(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 {
+            relationFields.push(x);
+            const relationField = tableArtifacts.relationFields?.[x.name];
+            if (relationField != null) {
+                if (relationField.type === "one-to-many__many-to-one" &&
+                    !columns.includes(relationField.relation.foreignKey)) {
+                    columns.push(relationField.relation.foreignKey);
+                }
+                else if (relationField.type === "many-to-many" &&
+                    !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);
+        }
+    }
+    let s = formatQuery(`SELECT ?? FROM ??`, [columns, getBaseTableName(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).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).then((xx) => mergeSubResults(x, xx))));
+        }
+        return resolveDependentFields(table, result, mappedFields, relationFields, artifacts, dbCall, formatQuery, getBaseTableName).then((xx) => mergeSubResults(result, xx));
+    });
 }
-// Mutates item
-function mapKeys(item, keyMap) {
-    delete item.__deleted;
-    // for (let k in item) {
-    //   const v = keyMap[k];
-    //   if (v) {
-    //     item[v] = item[k];
-    //     delete item[k];
-    //   }
-    // }
+async function resolveDependentFields(table, parentData, mappedFields, relationFields, artifacts, dbCall, formatQuery, getBaseTableName) {
+    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 = x.args != null && Array.isArray(x.args.$where)
+                ? _.cloneDeep(x.args.$where[1])
+                : {};
+            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 (Array.isArray(argsMapped.$where)) {
+                    argsMapped.$where = {
+                        $and: [whereDest, argsMapped.$where[0]],
+                    };
+                }
+                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).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).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}`);
 }

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

@@ -1,4 +1,4 @@
-import type { IArtifacts, IDialect, TDbCall, TFormatQuery, TBeginTransaction, TContext } from "../IRuntime";
+import type { IGetSQLASTInput, IArtifacts, IDialect, TDbCall, TFormatQuery, TBeginTransaction, TContext } from "../IRuntime";
 import type { TMiddleware, TResolveParams } from "../IRuntime";
 export declare function resolve(input: TResolveParams, dbCall: TDbCall, formatQuery: TFormatQuery, beginTransaction: TBeginTransaction, dialect: IDialect, middlewareHandler: MiddlewareHandler<TMiddleware>, context: TContext): Promise<any>;
 export declare class MiddlewareHandler<M extends Function> {
@@ -8,5 +8,6 @@ export declare class MiddlewareHandler<M extends Function> {
     has(id: number): boolean;
     length(): number;
 }
+export declare function postProcess(data: any, fields: IGetSQLASTInput["fields"], shouldRemoveExtraKeys: boolean): void;
 export declare function whereNeedsProcessing(where: any): boolean;
 export declare function _prepareWhere(artifacts: IArtifacts, table: string, data: any, dbCall: TDbCall, formatQuery: TFormatQuery): Promise<{}>;

package/dist/runtime/lib/shared.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._prepareWhere = exports.whereNeedsProcessing = exports.MiddlewareHandler = exports.resolve = void 0;
+exports._prepareWhere = exports.whereNeedsProcessing = exports.postProcess = exports.MiddlewareHandler = exports.resolve = void 0;
 // @ts-ignore
 // import * as queryAST from "join-monster/dist/query-ast-to-sql-ast";
 // @ts-ignore
@@ -709,6 +709,7 @@ function postProcess(data, fields, shouldRemoveExtraKeys) {
     }
     (0, runTransforms_1.runTransforms)(data, fields);
 }
+exports.postProcess = postProcess;
 function removeExtraKeys(data, fields) {
     if (data == null || (Array.isArray(data) && data[0] == null)) {
         return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@technicity/data-service-generator",
-  "version": "0.5.16",
+  "version": "0.6.0",
   "main": "./dist/index.js",
   "files": [
     "dist"
@@ -15,8 +15,9 @@
     "bluebird": "^3.7.2",
     "change-case": "^4.1.1",
     "fs-extra": "10.0.0",
-    "graphql": "14.7.0",
-    "join-monster": "apalm/join-monster#125168ac665480f5df1e16ebea49f223e0ebf84a",
+    "graphql": "15.8.0",
+    "graphql-relay": "^0.9.0",
+    "join-monster": "apalm/join-monster#340bcad96da4c268e874d07552d564c98ecf39ea",
     "json-schema-to-typescript": "10.1.5",
     "lodash": "^4.17.20",
     "mssql": "^6.3.1",