@vertikalx/vtx-backend-client 1.0.0-dev.0

package/runtime/generateGraphqlOperation.ts

@@ -0,0 +1,225 @@
+// @ts-nocheck
+import type { LinkedField, LinkedType } from './types'
+
+export interface Args {
+    [arg: string]: any | undefined
+}
+
+export interface Fields {
+    [field: string]: Request
+}
+
+export type Request = boolean | number | Fields
+
+export interface Variables {
+    [name: string]: {
+        value: any
+        typing: [LinkedType, string]
+    }
+}
+
+export interface Context {
+    root: LinkedType
+    varCounter: number
+    variables: Variables
+    fragmentCounter: number
+    fragments: string[]
+}
+
+export interface GraphqlOperation {
+    query: string
+    variables?: { [name: string]: any }
+    operationName?: string
+}
+
+const parseRequest = (
+    request: Request | undefined,
+    ctx: Context,
+    path: string[],
+): string => {
+    if (typeof request === 'object' && '__args' in request) {
+        const args: any = request.__args
+        let fields: Request | undefined = { ...request }
+        delete fields.__args
+        const argNames = Object.keys(args)
+
+        if (argNames.length === 0) {
+            return parseRequest(fields, ctx, path)
+        }
+
+        const field = getFieldFromPath(ctx.root, path)
+
+        const argStrings = argNames.map((argName) => {
+            ctx.varCounter++
+            const varName = `v${ctx.varCounter}`
+
+            const typing = field.args && field.args[argName] // typeMap used here, .args
+
+            if (!typing) {
+                throw new Error(
+                    `no typing defined for argument \`${argName}\` in path \`${path.join(
+                        '.',
+                    )}\``,
+                )
+            }
+
+            ctx.variables[varName] = {
+                value: args[argName],
+                typing,
+            }
+
+            return `${argName}:$${varName}`
+        })
+        return `(${argStrings})${parseRequest(fields, ctx, path)}`
+    } else if (typeof request === 'object' && Object.keys(request).length > 0) {
+        const fields = request
+        const fieldNames = Object.keys(fields).filter((k) => Boolean(fields[k]))
+
+        if (fieldNames.length === 0) {
+            throw new Error(
+                `field selection should not be empty: ${path.join('.')}`,
+            )
+        }
+
+        const type =
+            path.length > 0 ? getFieldFromPath(ctx.root, path).type : ctx.root
+        const scalarFields = type.scalar
+
+        let scalarFieldsFragment: string | undefined
+
+        if (fieldNames.includes('__scalar')) {
+            const falsyFieldNames = new Set(
+                Object.keys(fields).filter((k) => !Boolean(fields[k])),
+            )
+            if (scalarFields?.length) {
+                ctx.fragmentCounter++
+                scalarFieldsFragment = `f${ctx.fragmentCounter}`
+
+                ctx.fragments.push(
+                    `fragment ${scalarFieldsFragment} on ${
+                        type.name
+                    }{${scalarFields
+                        .filter((f) => !falsyFieldNames.has(f))
+                        .join(',')}}`,
+                )
+            }
+        }
+
+        const fieldsSelection = fieldNames
+            .filter((f) => !['__scalar', '__name'].includes(f))
+            .map((f) => {
+                const parsed = parseRequest(fields[f], ctx, [...path, f])
+
+                if (f.startsWith('on_')) {
+                    ctx.fragmentCounter++
+                    const implementationFragment = `f${ctx.fragmentCounter}`
+
+                    const typeMatch = f.match(/^on_(.+)/)
+
+                    if (!typeMatch || !typeMatch[1])
+                        throw new Error('match failed')
+
+                    ctx.fragments.push(
+                        `fragment ${implementationFragment} on ${typeMatch[1]}${parsed}`,
+                    )
+
+                    return `...${implementationFragment}`
+                } else {
+                    return `${f}${parsed}`
+                }
+            })
+            .concat(scalarFieldsFragment ? [`...${scalarFieldsFragment}`] : [])
+            .join(',')
+
+        return `{${fieldsSelection}}`
+    } else {
+        return ''
+    }
+}
+
+export const generateGraphqlOperation = (
+    operation: 'query' | 'mutation' | 'subscription',
+    root: LinkedType,
+    fields?: Fields,
+): GraphqlOperation => {
+    const ctx: Context = {
+        root: root,
+        varCounter: 0,
+        variables: {},
+        fragmentCounter: 0,
+        fragments: [],
+    }
+    const result = parseRequest(fields, ctx, [])
+
+    const varNames = Object.keys(ctx.variables)
+
+    const varsString =
+        varNames.length > 0
+            ? `(${varNames.map((v) => {
+                  const variableType = ctx.variables[v].typing[1]
+                  return `$${v}:${variableType}`
+              })})`
+            : ''
+
+    const operationName = fields?.__name || ''
+
+    return {
+        query: [
+            `${operation} ${operationName}${varsString}${result}`,
+            ...ctx.fragments,
+        ].join(','),
+        variables: Object.keys(ctx.variables).reduce<{ [name: string]: any }>(
+            (r, v) => {
+                r[v] = ctx.variables[v].value
+                return r
+            },
+            {},
+        ),
+        ...(operationName ? { operationName: operationName.toString() } : {}),
+    }
+}
+
+export const getFieldFromPath = (
+    root: LinkedType | undefined,
+    path: string[],
+) => {
+    let current: LinkedField | undefined
+
+    if (!root) throw new Error('root type is not provided')
+
+    if (path.length === 0) throw new Error(`path is empty`)
+
+    path.forEach((f) => {
+        const type = current ? current.type : root
+
+        if (!type.fields)
+            throw new Error(`type \`${type.name}\` does not have fields`)
+
+        const possibleTypes = Object.keys(type.fields)
+            .filter((i) => i.startsWith('on_'))
+            .reduce(
+                (types, fieldName) => {
+                    const field = type.fields && type.fields[fieldName]
+                    if (field) types.push(field.type)
+                    return types
+                },
+                [type],
+            )
+
+        let field: LinkedField | null = null
+
+        possibleTypes.forEach((type) => {
+            const found = type.fields && type.fields[f]
+            if (found) field = found
+        })
+
+        if (!field)
+            throw new Error(
+                `type \`${type.name}\` does not have a field \`${f}\``,
+            )
+
+        current = field
+    })
+
+    return current as LinkedField
+}

package/runtime/index.d.ts

@@ -0,0 +1,11 @@
+export { createClient } from './createClient';
+export type { ClientOptions } from './createClient';
+export type { FieldsSelection } from './typeSelection';
+export { generateGraphqlOperation } from './generateGraphqlOperation';
+export type { GraphqlOperation } from './generateGraphqlOperation';
+export { linkTypeMap } from './linkTypeMap';
+export { createFetcher } from './fetcher';
+export { GenqlError } from './error';
+export declare const everything: {
+    __scalar: boolean;
+};

package/runtime/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.everything = exports.GenqlError = exports.createFetcher = exports.linkTypeMap = exports.generateGraphqlOperation = exports.createClient = void 0;
+var createClient_1 = require("./createClient");
+Object.defineProperty(exports, "createClient", { enumerable: true, get: function () { return createClient_1.createClient; } });
+var generateGraphqlOperation_1 = require("./generateGraphqlOperation");
+Object.defineProperty(exports, "generateGraphqlOperation", { enumerable: true, get: function () { return generateGraphqlOperation_1.generateGraphqlOperation; } });
+var linkTypeMap_1 = require("./linkTypeMap");
+Object.defineProperty(exports, "linkTypeMap", { enumerable: true, get: function () { return linkTypeMap_1.linkTypeMap; } });
+var fetcher_1 = require("./fetcher");
+Object.defineProperty(exports, "createFetcher", { enumerable: true, get: function () { return fetcher_1.createFetcher; } });
+var error_1 = require("./error");
+Object.defineProperty(exports, "GenqlError", { enumerable: true, get: function () { return error_1.GenqlError; } });
+exports.everything = {
+    __scalar: true,
+};
+//# sourceMappingURL=index.js.map

package/runtime/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../libs/vtx-backend-client/runtime/index.ts"],"names":[],"mappings":";;;AACA,+CAA6C;AAApC,4GAAA,YAAY,OAAA;AAGrB,uEAAqE;AAA5D,oIAAA,wBAAwB,OAAA;AAEjC,6CAA2C;AAAlC,0GAAA,WAAW,OAAA;AAEpB,qCAAyC;AAAhC,wGAAA,aAAa,OAAA;AACtB,iCAAoC;AAA3B,mGAAA,UAAU,OAAA;AACN,QAAA,UAAU,GAAG;IACtB,QAAQ,EAAE,IAAI;CACjB,CAAA"}

package/runtime/index.ts

@@ -0,0 +1,13 @@
+// @ts-nocheck
+export { createClient } from './createClient'
+export type { ClientOptions } from './createClient'
+export type { FieldsSelection } from './typeSelection'
+export { generateGraphqlOperation } from './generateGraphqlOperation'
+export type { GraphqlOperation } from './generateGraphqlOperation'
+export { linkTypeMap } from './linkTypeMap'
+// export { Observable } from 'zen-observable-ts'
+export { createFetcher } from './fetcher'
+export { GenqlError } from './error'
+export const everything = {
+    __scalar: true,
+}

package/runtime/linkTypeMap.d.ts

@@ -0,0 +1,9 @@
+import type { CompressedTypeMap, LinkedArgMap, LinkedTypeMap } from './types';
+export interface PartialLinkedFieldMap {
+    [field: string]: {
+        type: string;
+        args?: LinkedArgMap;
+    };
+}
+export declare const linkTypeMap: (typeMap: CompressedTypeMap<number>) => LinkedTypeMap;
+export declare const resolveConcreteTypes: (linkedTypeMap: LinkedTypeMap) => LinkedTypeMap;

package/runtime/linkTypeMap.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConcreteTypes = exports.linkTypeMap = void 0;
+const linkTypeMap = (typeMap) => {
+    const indexToName = Object.assign({}, ...Object.keys(typeMap.types).map((k, i) => ({ [i]: k })));
+    let intermediaryTypeMap = Object.assign({}, ...Object.keys(typeMap.types || {}).map((k) => {
+        const type = typeMap.types[k];
+        const fields = type || {};
+        return {
+            [k]: {
+                name: k,
+                scalar: Object.keys(fields).filter((f) => {
+                    const [type] = fields[f] || [];
+                    const isScalar = type && typeMap.scalars.includes(type);
+                    if (!isScalar) {
+                        return false;
+                    }
+                    const args = fields[f]?.[1];
+                    const argTypes = Object.values(args || {})
+                        .map((x) => x?.[1])
+                        .filter(Boolean);
+                    const hasRequiredArgs = argTypes.some((str) => str && str.endsWith('!'));
+                    if (hasRequiredArgs) {
+                        return false;
+                    }
+                    return true;
+                }),
+                fields: Object.assign({}, ...Object.keys(fields).map((f) => {
+                    const [typeIndex, args] = fields[f] || [];
+                    if (typeIndex == null) {
+                        return {};
+                    }
+                    return {
+                        [f]: {
+                            type: indexToName[typeIndex],
+                            args: Object.assign({}, ...Object.keys(args || {}).map((k) => {
+                                if (!args || !args[k]) {
+                                    return;
+                                }
+                                const [argTypeName, argTypeString,] = args[k];
+                                return {
+                                    [k]: [
+                                        indexToName[argTypeName],
+                                        argTypeString ||
+                                            indexToName[argTypeName],
+                                    ],
+                                };
+                            })),
+                        },
+                    };
+                })),
+            },
+        };
+    }));
+    const res = (0, exports.resolveConcreteTypes)(intermediaryTypeMap);
+    return res;
+};
+exports.linkTypeMap = linkTypeMap;
+const resolveConcreteTypes = (linkedTypeMap) => {
+    Object.keys(linkedTypeMap).forEach((typeNameFromKey) => {
+        const type = linkedTypeMap[typeNameFromKey];
+        if (!type.fields) {
+            return;
+        }
+        const fields = type.fields;
+        Object.keys(fields).forEach((f) => {
+            const field = fields[f];
+            if (field.args) {
+                const args = field.args;
+                Object.keys(args).forEach((key) => {
+                    const arg = args[key];
+                    if (arg) {
+                        const [typeName] = arg;
+                        if (typeof typeName === 'string') {
+                            if (!linkedTypeMap[typeName]) {
+                                linkedTypeMap[typeName] = { name: typeName };
+                            }
+                            arg[0] = linkedTypeMap[typeName];
+                        }
+                    }
+                });
+            }
+            const typeName = field.type;
+            if (typeof typeName === 'string') {
+                if (!linkedTypeMap[typeName]) {
+                    linkedTypeMap[typeName] = { name: typeName };
+                }
+                field.type = linkedTypeMap[typeName];
+            }
+        });
+    });
+    return linkedTypeMap;
+};
+exports.resolveConcreteTypes = resolveConcreteTypes;
+//# sourceMappingURL=linkTypeMap.js.map

package/runtime/linkTypeMap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"linkTypeMap.js","sourceRoot":"","sources":["../../../../libs/vtx-backend-client/runtime/linkTypeMap.ts"],"names":[],"mappings":";;;AAiBO,MAAM,WAAW,GAAG,CACvB,OAAkC,EACrB,EAAE;IACf,MAAM,WAAW,GAA2B,MAAM,CAAC,MAAM,CACrD,EAAE,EACF,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAC5D,CAAA;IAED,IAAI,mBAAmB,GAAG,MAAM,CAAC,MAAM,CACnC,EAAE,EACF,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,GAAG,CACnC,CAAC,CAAC,EAA8B,EAAE;QAC9B,MAAM,IAAI,GAAmB,OAAO,CAAC,KAAK,CAAC,CAAC,CAAE,CAAA;QAC9C,MAAM,MAAM,GAAG,IAAI,IAAI,EAAE,CAAA;QACzB,OAAO;YACH,CAAC,CAAC,CAAC,EAAE;gBACD,IAAI,EAAE,CAAC;gBAEP,MAAM,EAAE,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE;oBACrC,MAAM,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,IAAI,EAAE,CAAA;oBAE9B,MAAM,QAAQ,GACV,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA;oBAC1C,IAAI,CAAC,QAAQ,EAAE,CAAC;wBACZ,OAAO,KAAK,CAAA;oBAChB,CAAC;oBACD,MAAM,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;oBAC3B,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC;yBACrC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;yBAClB,MAAM,CAAC,OAAO,CAAC,CAAA;oBAEpB,MAAM,eAAe,GAAG,QAAQ,CAAC,IAAI,CACjC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CACpC,CAAA;oBACD,IAAI,eAAe,EAAE,CAAC;wBAClB,OAAO,KAAK,CAAA;oBAChB,CAAC;oBACD,OAAO,IAAI,CAAA;gBACf,CAAC,CAAC;gBAEF,MAAM,EAAE,MAAM,CAAC,MAAM,CACjB,EAAE,EACF,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,CACtB,CAAC,CAAC,EAAyB,EAAE;oBACzB,MAAM,CAAC,SAAS,EAAE,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,IAAI,EAAE,CAAA;oBACzC,IAAI,SAAS,IAAI,IAAI,EAAE,CAAC;wBACpB,OAAO,EAAE,CAAA;oBACb,CAAC;oBACD,OAAO;wBACH,CAAC,CAAC,CAAC,EAAE;4BAED,IAAI,EAAE,WAAW,CAAC,SAAS,CAAC;4BAC5B,IAAI,EAAE,MAAM,CAAC,MAAM,CACf,EAAE,EACF,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,GAAG,CAC1B,CAAC,CAAC,EAAE,EAAE;gCAEF,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;oCACpB,OAAM;gCACV,CAAC;gCACD,MAAM,CACF,WAAW,EACX,aAAa,EAChB,GAAG,IAAI,CAAC,CAAC,CAAQ,CAAA;gCAClB,OAAO;oCACH,CAAC,CAAC,CAAC,EAAE;wCACD,WAAW,CACP,WAAW,CACd;wCACD,aAAa;4CACT,WAAW,CACP,WAAW,CACd;qCACR;iCACJ,CAAA;4BACL,CAAC,CACJ,CACJ;yBACJ;qBACJ,CAAA;gBACL,CAAC,CACJ,CACJ;aACJ;SACJ,CAAA;IACL,CAAC,CACJ,CACJ,CAAA;IACD,MAAM,GAAG,GAAG,IAAA,4BAAoB,EAAC,mBAAmB,CAAC,CAAA;IACrD,OAAO,GAAG,CAAA;AACd,CAAC,CAAA;AA1FY,QAAA,WAAW,eA0FvB;AAGM,MAAM,oBAAoB,GAAG,CAAC,aAA4B,EAAE,EAAE;IACjE,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,OAAO,CAAC,CAAC,eAAe,EAAE,EAAE;QACnD,MAAM,IAAI,GAAe,aAAa,CAAC,eAAe,CAAE,CAAA;QAExD,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACf,OAAM;QACV,CAAC;QAED,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAA;QAE1B,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE;YAC9B,MAAM,KAAK,GAAgB,MAAM,CAAC,CAAC,CAAE,CAAA;YAErC,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;gBACb,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAA;gBACvB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;oBAC9B,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAA;oBAErB,IAAI,GAAG,EAAE,CAAC;wBACN,MAAM,CAAC,QAAQ,CAAC,GAAG,GAAG,CAAA;wBAEtB,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;4BAC/B,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,EAAE,CAAC;gCAC3B,aAAa,CAAC,QAAQ,CAAC,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAA;4BAChD,CAAC;4BAED,GAAG,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC,QAAQ,CAAE,CAAA;wBACrC,CAAC;oBACL,CAAC;gBACL,CAAC,CAAC,CAAA;YACN,CAAC;YAED,MAAM,QAAQ,GAAG,KAAK,CAAC,IAA2B,CAAA;YAElD,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;gBAC/B,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,EAAE,CAAC;oBAC3B,aAAa,CAAC,QAAQ,CAAC,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAA;gBAChD,CAAC;gBAED,KAAK,CAAC,IAAI,GAAG,aAAa,CAAC,QAAQ,CAAE,CAAA;YACzC,CAAC;QACL,CAAC,CAAC,CAAA;IACN,CAAC,CAAC,CAAA;IAEF,OAAO,aAAa,CAAA;AACxB,CAAC,CAAA;AA7CY,QAAA,oBAAoB,wBA6ChC"}

package/runtime/linkTypeMap.ts

@@ -0,0 +1,156 @@
+// @ts-nocheck
+import type {
+    CompressedType,
+    CompressedTypeMap,
+    LinkedArgMap,
+    LinkedField,
+    LinkedType,
+    LinkedTypeMap,
+} from './types'
+
+export interface PartialLinkedFieldMap {
+    [field: string]: {
+        type: string
+        args?: LinkedArgMap
+    }
+}
+
+export const linkTypeMap = (
+    typeMap: CompressedTypeMap<number>,
+): LinkedTypeMap => {
+    const indexToName: Record<number, string> = Object.assign(
+        {},
+        ...Object.keys(typeMap.types).map((k, i) => ({ [i]: k })),
+    )
+
+    let intermediaryTypeMap = Object.assign(
+        {},
+        ...Object.keys(typeMap.types || {}).map(
+            (k): Record<string, LinkedType> => {
+                const type: CompressedType = typeMap.types[k]!
+                const fields = type || {}
+                return {
+                    [k]: {
+                        name: k,
+                        // type scalar properties
+                        scalar: Object.keys(fields).filter((f) => {
+                            const [type] = fields[f] || []
+
+                            const isScalar =
+                                type && typeMap.scalars.includes(type)
+                            if (!isScalar) {
+                                return false
+                            }
+                            const args = fields[f]?.[1]
+                            const argTypes = Object.values(args || {})
+                                .map((x) => x?.[1])
+                                .filter(Boolean)
+
+                            const hasRequiredArgs = argTypes.some(
+                                (str) => str && str.endsWith('!'),
+                            )
+                            if (hasRequiredArgs) {
+                                return false
+                            }
+                            return true
+                        }),
+                        // fields with corresponding `type` and `args`
+                        fields: Object.assign(
+                            {},
+                            ...Object.keys(fields).map(
+                                (f): PartialLinkedFieldMap => {
+                                    const [typeIndex, args] = fields[f] || []
+                                    if (typeIndex == null) {
+                                        return {}
+                                    }
+                                    return {
+                                        [f]: {
+                                            // replace index with type name
+                                            type: indexToName[typeIndex],
+                                            args: Object.assign(
+                                                {},
+                                                ...Object.keys(args || {}).map(
+                                                    (k) => {
+                                                        // if argTypeString == argTypeName, argTypeString is missing, need to readd it
+                                                        if (!args || !args[k]) {
+                                                            return
+                                                        }
+                                                        const [
+                                                            argTypeName,
+                                                            argTypeString,
+                                                        ] = args[k] as any
+                                                        return {
+                                                            [k]: [
+                                                                indexToName[
+                                                                    argTypeName
+                                                                ],
+                                                                argTypeString ||
+                                                                    indexToName[
+                                                                        argTypeName
+                                                                    ],
+                                                            ],
+                                                        }
+                                                    },
+                                                ),
+                                            ),
+                                        },
+                                    }
+                                },
+                            ),
+                        ),
+                    },
+                }
+            },
+        ),
+    )
+    const res = resolveConcreteTypes(intermediaryTypeMap)
+    return res
+}
+
+// replace typename with concrete type
+export const resolveConcreteTypes = (linkedTypeMap: LinkedTypeMap) => {
+    Object.keys(linkedTypeMap).forEach((typeNameFromKey) => {
+        const type: LinkedType = linkedTypeMap[typeNameFromKey]!
+        // type.name = typeNameFromKey
+        if (!type.fields) {
+            return
+        }
+
+        const fields = type.fields
+
+        Object.keys(fields).forEach((f) => {
+            const field: LinkedField = fields[f]!
+
+            if (field.args) {
+                const args = field.args
+                Object.keys(args).forEach((key) => {
+                    const arg = args[key]
+
+                    if (arg) {
+                        const [typeName] = arg
+
+                        if (typeof typeName === 'string') {
+                            if (!linkedTypeMap[typeName]) {
+                                linkedTypeMap[typeName] = { name: typeName }
+                            }
+
+                            arg[0] = linkedTypeMap[typeName]!
+                        }
+                    }
+                })
+            }
+
+            const typeName = field.type as LinkedType | string
+
+            if (typeof typeName === 'string') {
+                if (!linkedTypeMap[typeName]) {
+                    linkedTypeMap[typeName] = { name: typeName }
+                }
+
+                field.type = linkedTypeMap[typeName]!
+            }
+        })
+    })
+
+    return linkedTypeMap
+}

package/runtime/typeSelection.d.ts

@@ -0,0 +1,28 @@
+export type FieldsSelection<SRC extends Anify<DST> | undefined, DST> = {
+    scalar: SRC;
+    union: Handle__isUnion<SRC, DST>;
+    object: HandleObject<SRC, DST>;
+    array: SRC extends Nil ? never : SRC extends Array<infer T | null> ? Array<FieldsSelection<T, DST>> : never;
+    __scalar: Handle__scalar<SRC, DST>;
+    never: never;
+}[DST extends Nil ? 'never' : DST extends false | 0 ? 'never' : SRC extends Scalar ? 'scalar' : SRC extends any[] ? 'array' : SRC extends {
+    __isUnion?: any;
+} ? 'union' : DST extends {
+    __scalar?: any;
+} ? '__scalar' : DST extends {} ? 'object' : 'never'];
+type HandleObject<SRC extends Anify<DST>, DST> = DST extends boolean ? SRC : SRC extends Nil ? never : Pick<{
+    [Key in keyof SRC]: Key extends keyof DST ? FieldsSelection<SRC[Key], NonNullable<DST[Key]>> : SRC[Key];
+}, Exclude<keyof DST, FieldsToRemove>>;
+type Handle__scalar<SRC extends Anify<DST>, DST> = SRC extends Nil ? never : Pick<{
+    [Key in keyof SRC]: Key extends keyof DST ? FieldsSelection<SRC[Key], DST[Key]> : SRC[Key];
+}, {
+    [Key in keyof SRC]: SRC[Key] extends Nil ? never : Key extends FieldsToRemove ? never : SRC[Key] extends Scalar ? Key : Key extends keyof DST ? Key : never;
+}[keyof SRC]>;
+type Handle__isUnion<SRC extends Anify<DST>, DST> = SRC extends Nil ? never : Omit<SRC, FieldsToRemove>;
+type Scalar = string | number | Date | boolean | null | undefined;
+type Anify<T> = {
+    [P in keyof T]?: any;
+};
+type FieldsToRemove = '__isUnion' | '__scalar' | '__name' | '__args';
+type Nil = undefined | null;
+export {};

package/runtime/typeSelection.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=typeSelection.js.map

package/runtime/typeSelection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeSelection.js","sourceRoot":"","sources":["../../../../libs/vtx-backend-client/runtime/typeSelection.ts"],"names":[],"mappings":""}

package/runtime/typeSelection.ts

@@ -0,0 +1,95 @@
+// @ts-nocheck
+//////////////////////////////////////////////////
+
+// SOME THINGS TO KNOW BEFORE DIVING IN
+/*
+0. DST is the request type, SRC is the response type
+
+1. FieldsSelection uses an object because currently is impossible to make recursive types
+
+2. FieldsSelection is a recursive type that makes a type based on request type and fields
+
+3. HandleObject handles object types
+
+4. Handle__scalar adds all scalar properties excluding non scalar props
+*/
+
+export type FieldsSelection<SRC extends Anify<DST> | undefined, DST> = {
+    scalar: SRC
+    union: Handle__isUnion<SRC, DST>
+    object: HandleObject<SRC, DST>
+    array: SRC extends Nil
+        ? never
+        : SRC extends Array<infer T | null>
+        ? Array<FieldsSelection<T, DST>>
+        : never
+    __scalar: Handle__scalar<SRC, DST>
+    never: never
+}[DST extends Nil
+    ? 'never'
+    : DST extends false | 0
+    ? 'never'
+    : SRC extends Scalar
+    ? 'scalar'
+    : SRC extends any[]
+    ? 'array'
+    : SRC extends { __isUnion?: any }
+    ? 'union'
+    : DST extends { __scalar?: any }
+    ? '__scalar'
+    : DST extends {}
+    ? 'object'
+    : 'never']
+
+type HandleObject<SRC extends Anify<DST>, DST> = DST extends boolean
+    ? SRC
+    : SRC extends Nil
+    ? never
+    : Pick<
+          {
+              // using keyof SRC to maintain ?: relations of SRC type
+              [Key in keyof SRC]: Key extends keyof DST
+                  ? FieldsSelection<SRC[Key], NonNullable<DST[Key]>>
+                  : SRC[Key]
+          },
+          Exclude<keyof DST, FieldsToRemove>
+          //   {
+          //       // remove falsy values
+          //       [Key in keyof DST]: DST[Key] extends false | 0 ? never : Key
+          //   }[keyof DST]
+      >
+
+type Handle__scalar<SRC extends Anify<DST>, DST> = SRC extends Nil
+    ? never
+    : Pick<
+          // continue processing fields that are in DST, directly pass SRC type if not in DST
+          {
+              [Key in keyof SRC]: Key extends keyof DST
+                  ? FieldsSelection<SRC[Key], DST[Key]>
+                  : SRC[Key]
+          },
+          // remove fields that are not scalars or are not in DST
+          {
+              [Key in keyof SRC]: SRC[Key] extends Nil
+                  ? never
+                  : Key extends FieldsToRemove
+                  ? never
+                  : SRC[Key] extends Scalar
+                  ? Key
+                  : Key extends keyof DST
+                  ? Key
+                  : never
+          }[keyof SRC]
+      >
+
+type Handle__isUnion<SRC extends Anify<DST>, DST> = SRC extends Nil
+    ? never
+    : Omit<SRC, FieldsToRemove> // just return the union type
+
+type Scalar = string | number | Date | boolean | null | undefined
+
+type Anify<T> = { [P in keyof T]?: any }
+
+type FieldsToRemove = '__isUnion' | '__scalar' | '__name' | '__args'
+
+type Nil = undefined | null