@constructive-io/graphql-codegen 2.17.29 → 2.17.31

package/esm/gql.js

@@ -12,6 +12,52 @@ const NON_MUTABLE_PROPS = [
     'updatedBy',
 ];
 const objectToArray = (obj) => Object.keys(obj).map((k) => ({ name: k, ...obj[k] }));
+function refToTypeNode(ref, overrides) {
+    if (!ref)
+        return null;
+    if (ref.kind === 'NON_NULL') {
+        const inner = refToTypeNode(ref.ofType, overrides);
+        return t.nonNullType({ type: inner });
+    }
+    if (ref.kind === 'LIST') {
+        const inner = refToTypeNode(ref.ofType, overrides);
+        return t.listType({ type: inner });
+    }
+    const name = (overrides && overrides[ref.name]) || ref.name;
+    return t.namedType({ type: name });
+}
+function resolveTypeName(name, type, overrides) {
+    if (typeof type === 'string') {
+        const base = type;
+        const mapped = overrides && overrides[base];
+        return mapped || base;
+    }
+    if (type && typeof type === 'object') {
+        if (typeof type.name === 'string' && type.name.length > 0)
+            return type.name;
+        let t = type;
+        while (t && typeof t === 'object' && t.ofType)
+            t = t.ofType;
+        if (t && typeof t.name === 'string' && t.name.length > 0) {
+            const base = t.name;
+            const mapped = overrides && overrides[base];
+            return mapped || base;
+        }
+    }
+    return 'JSON';
+}
+function refToNamedTypeName(ref) {
+    let r = ref;
+    while (r && (r.kind === 'NON_NULL' || r.kind === 'LIST'))
+        r = r.ofType;
+    return r && r.name ? r.name : null;
+}
+function extractNamedTypeName(node) {
+    let n = node;
+    while (n && !n.name && n.type)
+        n = n.type;
+    return n && n.name ? n.name : null;
+}
 export const createGqlMutation = ({ operationName, mutationName, selectArgs, variableDefinitions, modelName, selections, useModel = true, }) => {
     const opSel = !modelName
         ? [
@@ -58,8 +104,27 @@ export const getMany = ({ operationName, query, fields, }) => {
                 selections: [
                     t.field({ name: 'totalCount' }),
                     t.field({
-                        name: 'nodes',
-                        selectionSet: t.selectionSet({ selections }),
+                        name: 'pageInfo',
+                        selectionSet: t.selectionSet({
+                            selections: [
+                                t.field({ name: 'hasNextPage' }),
+                                t.field({ name: 'hasPreviousPage' }),
+                                t.field({ name: 'endCursor' }),
+                                t.field({ name: 'startCursor' }),
+                            ],
+                        }),
+                    }),
+                    t.field({
+                        name: 'edges',
+                        selectionSet: t.selectionSet({
+                            selections: [
+                                t.field({ name: 'cursor' }),
+                                t.field({
+                                    name: 'node',
+                                    selectionSet: t.selectionSet({ selections }),
+                                }),
+                            ],
+                        }),
                     }),
                 ],
             }),
@@ -307,12 +372,13 @@ export const getFragment = ({ operationName, query, }) => {
     });
     return { name: queryName, ast };
 };
-export const getOne = ({ operationName, query, fields, }) => {
+export const getOne = ({ operationName, query, fields, }, typeNameOverrides) => {
     const queryName = inflection.camelize(['get', inflection.underscore(operationName), 'query'].join('_'), true);
     const variableDefinitions = objectToArray(query.properties)
         .filter((field) => field.isNotNull)
         .map(({ name, type, isNotNull, isArray, isArrayNotNull }) => {
-        let gqlType = t.namedType({ type });
+        const typeName = resolveTypeName(name, type, typeNameOverrides);
+        let gqlType = t.namedType({ type: typeName });
         if (isNotNull) {
             gqlType = t.nonNullType({ type: gqlType });
         }
@@ -353,7 +419,7 @@ export const getOne = ({ operationName, query, fields, }) => {
     });
     return { name: queryName, ast };
 };
-export const createOne = ({ operationName, mutation, }) => {
+export const createOne = ({ operationName, mutation, selection, }, typeNameOverrides, typeIndex) => {
     const mutationName = inflection.camelize([inflection.underscore(operationName), 'mutation'].join('_'), true);
     if (!mutation.properties?.input?.properties) {
         console.log('no input field for mutation for ' + mutationName);
@@ -361,54 +427,80 @@ export const createOne = ({ operationName, mutation, }) => {
     }
     const modelName = inflection.camelize([plz.singular(mutation.model)].join('_'), true);
     const allAttrs = objectToArray(mutation.properties.input.properties[modelName].properties);
-    const attrs = allAttrs.filter((field) => !NON_MUTABLE_PROPS.includes(field.name));
+    const attrs = allAttrs.filter((field) => field.name === 'id' ? Boolean(field.isNotNull) : !NON_MUTABLE_PROPS.includes(field.name));
+    const useRaw = selection?.mutationInputMode === 'raw';
+    const inputTypeName = resolveTypeName('input', mutation.properties?.input?.type || mutation.properties?.input, typeNameOverrides);
+    let unresolved = 0;
+    let modelInputName = null;
+    if (typeIndex && inputTypeName) {
+        const modelRef = typeIndex.getInputFieldType(inputTypeName, modelName);
+        modelInputName = refToNamedTypeName(modelRef);
+    }
     const variableDefinitions = attrs.map(({ name, type, isNotNull, isArray, isArrayNotNull }) => {
-        let gqlType = t.namedType({ type });
-        if (isNotNull) {
-            gqlType = t.nonNullType({ type: gqlType });
+        let gqlType = null;
+        if (typeIndex && modelInputName) {
+            const fieldTypeRef = typeIndex.getInputFieldType(modelInputName, name);
+            const tn = refToTypeNode(fieldTypeRef, typeNameOverrides);
+            if (tn)
+                gqlType = tn;
         }
-        if (isArray) {
-            gqlType = t.listType({ type: gqlType });
-            if (isArrayNotNull) {
+        if (!gqlType) {
+            const typeName = resolveTypeName(name, type, typeNameOverrides);
+            gqlType = t.namedType({ type: typeName });
+            if (isNotNull) {
                 gqlType = t.nonNullType({ type: gqlType });
             }
+            if (isArray) {
+                gqlType = t.listType({ type: gqlType });
+                if (isArrayNotNull) {
+                    gqlType = t.nonNullType({ type: gqlType });
+                }
+            }
         }
-        return t.variableDefinition({
-            variable: t.variable({ name }),
-            type: gqlType,
-        });
+        const nn = extractNamedTypeName(gqlType);
+        if (nn === 'JSON')
+            unresolved++;
+        return t.variableDefinition({ variable: t.variable({ name }), type: gqlType });
     });
-    const selectArgs = [
-        t.argument({
-            name: 'input',
-            value: t.objectValue({
-                fields: [
-                    t.objectField({
-                        name: modelName,
-                        value: t.objectValue({
-                            fields: attrs.map((field) => t.objectField({
-                                name: field.name,
-                                value: t.variable({ name: field.name }),
-                            })),
+    const mustUseRaw = useRaw || unresolved > 0;
+    const selectArgs = mustUseRaw
+        ? [t.argument({ name: 'input', value: t.variable({ name: 'input' }) })]
+        : [
+            t.argument({
+                name: 'input',
+                value: t.objectValue({
+                    fields: [
+                        t.objectField({
+                            name: modelName,
+                            value: t.objectValue({
+                                fields: attrs.map((field) => t.objectField({ name: field.name, value: t.variable({ name: field.name }) })),
+                            }),
                         }),
-                    }),
-                ],
+                    ],
+                }),
             }),
-        }),
-    ];
+        ];
     const selections = allAttrs.map((field) => t.field({ name: 'id' }));
+    const modelFields = selection?.modelFields?.[modelName] || selection?.defaultMutationModelFields || ['id'];
+    const nested = (modelFields.length > 0)
+        ? [t.field({
+                name: modelName,
+                selectionSet: t.selectionSet({ selections: modelFields.map((f) => t.field({ name: f })) }),
+            })]
+        : [];
     const ast = createGqlMutation({
         operationName,
         mutationName,
         selectArgs,
-        selections: [t.field({ name: 'clientMutationId' })],
-        variableDefinitions,
-        modelName,
+        selections: [...nested, t.field({ name: 'clientMutationId' })],
+        variableDefinitions: mustUseRaw
+            ? [t.variableDefinition({ variable: t.variable({ name: 'input' }), type: t.nonNullType({ type: t.namedType({ type: inputTypeName }) }) })]
+            : variableDefinitions,
         useModel: false,
     });
     return { name: mutationName, ast };
 };
-export const patchOne = ({ operationName, mutation, }) => {
+export const patchOne = ({ operationName, mutation, selection, }, typeNameOverrides, typeIndex) => {
     const mutationName = inflection.camelize([inflection.underscore(operationName), 'mutation'].join('_'), true);
     if (!mutation.properties?.input?.properties) {
         console.log('no input field for mutation for ' + mutationName);
@@ -422,79 +514,110 @@ export const patchOne = ({ operationName, mutation, }) => {
     (prop) => !NON_MUTABLE_PROPS.includes(prop.name));
     const patchByAttrs = objectToArray(mutation.properties.input.properties).filter((n) => n.name !== 'patch');
     const patchers = patchByAttrs.map((p) => p.name);
-    const patchAttrVarDefs = patchAttrs
-        // @ts-ignore
-        .filter((field) => !patchers.includes(field.name))
-        .map(
-    // @ts-ignore
-    ({ name, type, isArray }) => {
-        let gqlType = t.namedType({ type });
-        if (isArray) {
-            gqlType = t.listType({ type: gqlType });
-        }
-        // @ts-ignore
-        if (patchers.includes(name)) {
-            gqlType = t.nonNullType({ type: gqlType });
-        }
-        return t.variableDefinition({
-            // @ts-ignore
-            variable: t.variable({ name }),
-            type: gqlType,
+    const useCollapsedOpt = selection?.mutationInputMode === 'patchCollapsed';
+    const ModelPascal = inflection.camelize(plz.singular(mutation.model), false);
+    const patchTypeName = `${ModelPascal}Patch`;
+    const inputTypeName = resolveTypeName('input', mutation.properties?.input?.type || mutation.properties?.input, typeNameOverrides);
+    let unresolved = 0;
+    const patchAttrVarDefs = useCollapsedOpt
+        ? [
+            t.variableDefinition({
+                variable: t.variable({ name: 'patch' }),
+                type: t.nonNullType({ type: t.namedType({ type: patchTypeName }) }),
+            }),
+        ]
+        : patchAttrs
+            .filter((field) => !patchers.includes(field.name))
+            .map(({ name, type, isArray }) => {
+            let gqlType = null;
+            if (typeIndex) {
+                const pType = typeIndex.byName[patchTypeName];
+                const f = pType && pType.inputFields && pType.inputFields.find((x) => x.name === name);
+                if (f && f.type)
+                    gqlType = refToTypeNode(f.type, typeNameOverrides);
+            }
+            if (!gqlType) {
+                const typeName = resolveTypeName(name, type, typeNameOverrides);
+                gqlType = t.namedType({ type: typeName });
+                if (isArray) {
+                    gqlType = t.listType({ type: gqlType });
+                }
+                if (patchers.includes(name)) {
+                    gqlType = t.nonNullType({ type: gqlType });
+                }
+            }
+            const nn = extractNamedTypeName(gqlType);
+            if (nn === 'JSON')
+                unresolved++;
+            return t.variableDefinition({ variable: t.variable({ name }), type: gqlType });
         });
-    });
     const patchByVarDefs = patchByAttrs.map(({ name, type, isNotNull, isArray, isArrayNotNull }) => {
-        let gqlType = t.namedType({ type });
-        if (isNotNull) {
-            gqlType = t.nonNullType({ type: gqlType });
+        let gqlType = null;
+        if (typeIndex && inputTypeName) {
+            const ref = typeIndex.getInputFieldType(inputTypeName, name);
+            const tn = refToTypeNode(ref, typeNameOverrides);
+            if (tn)
+                gqlType = tn;
         }
-        if (isArray) {
-            gqlType = t.listType({ type: gqlType });
-            if (isArrayNotNull) {
+        if (!gqlType) {
+            const typeName = resolveTypeName(name, type, typeNameOverrides);
+            gqlType = t.namedType({ type: typeName });
+            if (isNotNull) {
                 gqlType = t.nonNullType({ type: gqlType });
             }
+            if (isArray) {
+                gqlType = t.listType({ type: gqlType });
+                if (isArrayNotNull) {
+                    gqlType = t.nonNullType({ type: gqlType });
+                }
+            }
         }
+        const nn = extractNamedTypeName(gqlType);
+        if (nn === 'JSON')
+            unresolved++;
         return t.variableDefinition({ variable: t.variable({ name }), type: gqlType });
     });
-    const selectArgs = [
-        t.argument({
-            name: 'input',
-            value: t.objectValue({
-                fields: [
-                    ...patchByAttrs.map((field) => t.objectField({
-                        name: field.name,
-                        value: t.variable({ name: field.name }),
-                    })),
-                    t.objectField({
-                        name: 'patch',
-                        value: t.objectValue({
-                            fields: patchAttrs
-                                // @ts-ignore
-                                .filter((field) => !patchers.includes(field.name))
-                                .map((field) => t.objectField({
-                                // @ts-ignore
-                                name: field.name,
-                                // @ts-ignore
-                                value: t.variable({ name: field.name }),
-                            })),
+    const mustUseRaw = useCollapsedOpt || unresolved > 0;
+    const selectArgs = mustUseRaw
+        ? [t.argument({ name: 'input', value: t.variable({ name: 'input' }) })]
+        : [
+            t.argument({
+                name: 'input',
+                value: t.objectValue({
+                    fields: [
+                        ...patchByAttrs.map((field) => t.objectField({ name: field.name, value: t.variable({ name: field.name }) })),
+                        t.objectField({
+                            name: 'patch',
+                            value: useCollapsedOpt ? t.variable({ name: 'patch' }) : t.objectValue({
+                                fields: patchAttrs
+                                    .filter((field) => !patchers.includes(field.name))
+                                    .map((field) => t.objectField({ name: field.name, value: t.variable({ name: field.name }) })),
+                            }),
                         }),
-                    }),
-                ],
+                    ],
+                }),
             }),
-        }),
-    ];
-    const selections = [t.field({ name: 'clientMutationId' })];
+        ];
+    const modelFields = selection?.modelFields?.[modelName] || selection?.defaultMutationModelFields || ['id'];
+    const nestedPatch = (modelFields.length > 0)
+        ? [t.field({
+                name: modelName,
+                selectionSet: t.selectionSet({ selections: modelFields.map((f) => t.field({ name: f })) }),
+            })]
+        : [];
     const ast = createGqlMutation({
         operationName,
         mutationName,
         selectArgs,
-        selections,
-        variableDefinitions: [...patchByVarDefs, ...patchAttrVarDefs],
-        modelName,
+        selections: [...nestedPatch, t.field({ name: 'clientMutationId' })],
+        variableDefinitions: mustUseRaw
+            ? [t.variableDefinition({ variable: t.variable({ name: 'input' }), type: t.nonNullType({ type: t.namedType({ type: inputTypeName }) }) })]
+            : [...patchByVarDefs, ...patchAttrVarDefs],
         useModel: false,
     });
     return { name: mutationName, ast };
 };
-export const deleteOne = ({ operationName, mutation, }) => {
+export const deleteOne = ({ operationName, mutation, }, typeNameOverrides, typeIndex) => {
     const mutationName = inflection.camelize([inflection.underscore(operationName), 'mutation'].join('_'), true);
     if (!mutation.properties?.input?.properties) {
         console.log('no input field for mutation for ' + mutationName);
@@ -503,45 +626,58 @@ export const deleteOne = ({ operationName, mutation, }) => {
     const modelName = inflection.camelize([plz.singular(mutation.model)].join('_'), true);
     // @ts-ignore
     const deleteAttrs = objectToArray(mutation.properties.input.properties);
+    const inputTypeName = resolveTypeName('input', mutation.properties?.input?.type || mutation.properties?.input, typeNameOverrides);
+    let unresolved = 0;
     const variableDefinitions = deleteAttrs.map(({ name, type, isNotNull, isArray }) => {
-        let gqlType = t.namedType({ type });
-        if (isNotNull) {
-            gqlType = t.nonNullType({ type: gqlType });
+        let gqlType = null;
+        if (typeIndex && inputTypeName) {
+            const ref = typeIndex.getInputFieldType(inputTypeName, name);
+            const tn = refToTypeNode(ref, typeNameOverrides);
+            if (tn)
+                gqlType = tn;
         }
-        if (isArray) {
-            gqlType = t.listType({ type: gqlType });
-            // Always non-null list for deletion fields
-            gqlType = t.nonNullType({ type: gqlType });
+        if (!gqlType) {
+            const typeName = resolveTypeName(name, type, typeNameOverrides);
+            gqlType = t.namedType({ type: typeName });
+            if (isNotNull) {
+                gqlType = t.nonNullType({ type: gqlType });
+            }
+            if (isArray) {
+                gqlType = t.listType({ type: gqlType });
+                gqlType = t.nonNullType({ type: gqlType });
+            }
         }
-        return t.variableDefinition({
-            variable: t.variable({ name }),
-            type: gqlType,
-        });
+        const nn = extractNamedTypeName(gqlType);
+        if (nn === 'JSON')
+            unresolved++;
+        return t.variableDefinition({ variable: t.variable({ name }), type: gqlType });
     });
-    const selectArgs = [
-        t.argument({
-            name: 'input',
-            value: t.objectValue({
-                fields: deleteAttrs.map((f) => t.objectField({
-                    name: f.name,
-                    value: t.variable({ name: f.name }),
-                })),
+    const mustUseRaw = unresolved > 0;
+    const selectArgs = mustUseRaw
+        ? [t.argument({ name: 'input', value: t.variable({ name: 'input' }) })]
+        : [
+            t.argument({
+                name: 'input',
+                value: t.objectValue({
+                    fields: deleteAttrs.map((f) => t.objectField({ name: f.name, value: t.variable({ name: f.name }) })),
+                }),
             }),
-        }),
-    ];
+        ];
     const selections = [t.field({ name: 'clientMutationId' })];
     const ast = createGqlMutation({
         operationName,
         mutationName,
         selectArgs,
         selections,
-        variableDefinitions,
+        variableDefinitions: mustUseRaw
+            ? [t.variableDefinition({ variable: t.variable({ name: 'input' }), type: t.nonNullType({ type: t.namedType({ type: inputTypeName }) }) })]
+            : variableDefinitions,
         modelName,
         useModel: false,
     });
     return { name: mutationName, ast };
 };
-export const createMutation = ({ operationName, mutation, }) => {
+export const createMutation = ({ operationName, mutation, selection, }, typeNameOverrides, typeIndex) => {
     const mutationName = inflection.camelize([inflection.underscore(operationName), 'mutation'].join('_'), true);
     if (!mutation.properties?.input?.properties) {
         console.log('no input field for mutation for ' + mutationName);
@@ -549,41 +685,70 @@ export const createMutation = ({ operationName, mutation, }) => {
     }
     // @ts-ignore
     const otherAttrs = objectToArray(mutation.properties.input.properties);
-    const variableDefinitions = otherAttrs.map(({ name, type, isArray, isArrayNotNull }) => {
-        let gqlType = t.namedType({ type });
-        // Force as non-nullable for mutation reliability (as per your comment)
-        gqlType = t.nonNullType({ type: gqlType });
-        if (isArray) {
-            gqlType = t.listType({ type: gqlType });
-            if (isArrayNotNull) {
-                gqlType = t.nonNullType({ type: gqlType });
+    const useRaw = selection?.mutationInputMode === 'raw';
+    const inputTypeName = resolveTypeName('input', mutation.properties?.input?.type || mutation.properties?.input, typeNameOverrides);
+    let unresolved = 0;
+    const builtVarDefs = otherAttrs.map(({ name, type, isArray, isArrayNotNull }) => {
+        let gqlType = null;
+        if (typeIndex && inputTypeName) {
+            const ref = typeIndex.getInputFieldType(inputTypeName, name);
+            const tn = refToTypeNode(ref, typeNameOverrides);
+            if (tn)
+                gqlType = tn;
+        }
+        if (!gqlType) {
+            const typeName = resolveTypeName(name, type, typeNameOverrides);
+            gqlType = t.namedType({ type: typeName });
+            gqlType = t.nonNullType({ type: gqlType });
+            if (isArray) {
+                gqlType = t.listType({ type: gqlType });
+                if (isArrayNotNull) {
+                    gqlType = t.nonNullType({ type: gqlType });
+                }
+            }
+            if (gqlType.type && gqlType.type.type && gqlType.type.type.name === 'JSON') {
+                unresolved++;
             }
         }
-        return t.variableDefinition({
-            variable: t.variable({ name }),
-            type: gqlType,
-        });
+        return t.variableDefinition({ variable: t.variable({ name }), type: gqlType });
     });
-    const selectArgs = otherAttrs.length > 0
-        ? [
-            t.argument({
-                name: 'input',
-                value: t.objectValue({
-                    fields: otherAttrs.map((f) => t.objectField({
-                        name: f.name,
-                        value: t.variable({ name: f.name }),
-                    })),
+    const mustUseRaw = useRaw || otherAttrs.length === 0 || unresolved > 0;
+    const variableDefinitions = mustUseRaw
+        ? [t.variableDefinition({ variable: t.variable({ name: 'input' }), type: t.nonNullType({ type: t.namedType({ type: inputTypeName }) }) })]
+        : builtVarDefs;
+    const selectArgs = [
+        t.argument({
+            name: 'input',
+            value: mustUseRaw
+                ? t.variable({ name: 'input' })
+                : t.objectValue({
+                    fields: otherAttrs.map((f) => t.objectField({ name: f.name, value: t.variable({ name: f.name }) })),
                 }),
-            }),
-        ]
-        : [];
-    const outputFields = mutation.outputs
-        ?.filter((field) => field.type.kind === 'SCALAR')
-        .map((f) => f.name) || [];
-    if (outputFields.length === 0) {
-        outputFields.push('clientMutationId');
+        }),
+    ];
+    const scalarOutputs = (mutation.outputs || [])
+        .filter((field) => field.type.kind === 'SCALAR')
+        .map((f) => f.name);
+    const objectOutput = (mutation.outputs || []).find((field) => field.type.kind === 'OBJECT');
+    const selections = [];
+    if (objectOutput?.name) {
+        const modelFieldsRaw = selection?.modelFields?.[objectOutput.name] || selection?.defaultMutationModelFields || [];
+        const shouldDropId = /Extension$/i.test(objectOutput.name);
+        const fallbackFields = shouldDropId ? [] : ['id'];
+        const modelFields = (selection?.forceModelOutput && modelFieldsRaw.length === 0) ? fallbackFields : (modelFieldsRaw.length > 0 ? modelFieldsRaw : []);
+        if (modelFields.length > 0) {
+            selections.push(t.field({
+                name: objectOutput.name,
+                selectionSet: t.selectionSet({ selections: modelFields.map((f) => t.field({ name: f })) }),
+            }));
+        }
+    }
+    if (scalarOutputs.length > 0) {
+        selections.push(...scalarOutputs.map((o) => t.field({ name: o })));
+    }
+    else {
+        selections.push(t.field({ name: 'clientMutationId' }));
     }
-    const selections = outputFields.map((o) => t.field({ name: o }));
     const ast = createGqlMutation({
         operationName,
         mutationName,
@@ -593,35 +758,32 @@ export const createMutation = ({ operationName, mutation, }) => {
     });
     return { name: mutationName, ast };
 };
-export const generate = (gql) => {
+export const generate = (gql, selection, typeNameOverrides, typeIndex) => {
     return Object.keys(gql).reduce((m, operationName) => {
         const defn = gql[operationName];
         let name;
         let ast;
         if (defn.qtype === 'mutation') {
             if (defn.mutationType === 'create') {
-                ({ name, ast } = createOne({ operationName, mutation: defn }) ?? {});
+                ({ name, ast } = createOne({ operationName, mutation: defn, selection }, typeNameOverrides, typeIndex) ?? {});
             }
             else if (defn.mutationType === 'patch') {
-                ({ name, ast } = patchOne({ operationName, mutation: defn }) ?? {});
+                ({ name, ast } = patchOne({ operationName, mutation: defn, selection }, typeNameOverrides, typeIndex) ?? {});
             }
             else if (defn.mutationType === 'delete') {
-                ({ name, ast } = deleteOne({ operationName, mutation: defn }) ?? {});
+                ({ name, ast } = deleteOne({ operationName, mutation: defn }, typeNameOverrides, typeIndex) ?? {});
             }
             else {
-                ({ name, ast } = createMutation({ operationName, mutation: defn }) ?? {});
+                ({ name, ast } = createMutation({ operationName, mutation: defn, selection }, typeNameOverrides, typeIndex) ?? {});
             }
         }
         else if (defn.qtype === 'getMany') {
-            // getMany + related
             [
                 getMany,
                 getManyPaginatedEdges,
-                getManyPaginatedNodes,
                 getOrderByEnums,
                 getFragment
             ].forEach(fn => {
-                // @ts-ignore
                 const result = fn({ operationName, query: defn });
                 if (result?.name && result?.ast) {
                     m[result.name] = result;
@@ -630,7 +792,7 @@ export const generate = (gql) => {
         }
         else if (defn.qtype === 'getOne') {
             // @ts-ignore
-            ({ name, ast } = getOne({ operationName, query: defn }) ?? {});
+            ({ name, ast } = getOne({ operationName, query: defn }, typeNameOverrides) ?? {});
         }
         else {
             console.warn('Unknown qtype for key: ' + operationName);
@@ -680,8 +842,11 @@ export const generateGranular = (gql, model, fields) => {
 };
 export function getSelections(query, fields = []) {
     const useAll = fields.length === 0;
+    const shouldDropId = typeof query.model === 'string' && /Extension$/i.test(query.model);
     const mapItem = (item) => {
         if (typeof item === 'string') {
+            if (shouldDropId && item === 'id')
+                return null;
             if (!useAll && !fields.includes(item))
                 return null;
             return t.field({ name: item });
@@ -697,14 +862,20 @@ export function getSelections(query, fields = []) {
             if (isMany) {
                 return t.field({
                     name: item.name,
-                    args: [
-                        t.argument({ name: 'first', value: t.intValue({ value: '3' }) }),
-                    ],
+                    args: [t.argument({ name: 'first', value: t.intValue({ value: '3' }) })],
                     selectionSet: t.selectionSet({
                         selections: [
                             t.field({
-                                name: 'nodes',
-                                selectionSet: t.selectionSet({ selections: item.selection.map((s) => mapItem(s)).filter(Boolean) }),
+                                name: 'edges',
+                                selectionSet: t.selectionSet({
+                                    selections: [
+                                        t.field({ name: 'cursor' }),
+                                        t.field({
+                                            name: 'node',
+                                            selectionSet: t.selectionSet({ selections: item.selection.map((s) => mapItem(s)).filter(Boolean) }),
+                                        }),
+                                    ],
+                                }),
                             }),
                         ],
                     }),
@@ -717,5 +888,8 @@ export function getSelections(query, fields = []) {
         }
         return null;
     };
-    return query.selection.map((field) => mapItem(field)).filter((i) => Boolean(i));
+    return query.selection
+        .filter((s) => !(shouldDropId && s === 'id'))
+        .map((field) => mapItem(field))
+        .filter((i) => Boolean(i));
 }