@constructive-io/graphql-codegen 2.18.0 → 2.20.0

package/esm/gql.js

@@ -1,939 +0,0 @@
-// TODO: use inflection for all the things
-// const { singularize } = require('inflection');
-import * as t from 'gql-ast';
-import inflection from 'inflection';
-const NON_MUTABLE_PROPS = [
-    'id',
-    'createdAt',
-    'createdBy',
-    'updatedAt',
-    '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;
-}
-function singularModel(name) {
-    return inflection.singularize(name);
-}
-export const createGqlMutation = ({ operationName, mutationName, selectArgs, variableDefinitions, modelName, selections, useModel = true, }) => {
-    const opSel = !modelName
-        ? [
-            t.field({
-                name: operationName,
-                args: selectArgs,
-                selectionSet: t.selectionSet({ selections }),
-            }),
-        ]
-        : [
-            t.field({
-                name: operationName,
-                args: selectArgs,
-                selectionSet: t.selectionSet({
-                    selections: useModel
-                        ? [
-                            t.field({
-                                name: modelName,
-                                selectionSet: t.selectionSet({ selections }),
-                            }),
-                        ]
-                        : selections,
-                }),
-            }),
-        ];
-    return t.document({
-        definitions: [
-            t.operationDefinition({
-                operation: 'mutation',
-                name: mutationName,
-                variableDefinitions,
-                selectionSet: t.selectionSet({ selections: opSel }),
-            }),
-        ],
-    });
-};
-export const getMany = ({ operationName, query, fields, }) => {
-    const queryName = inflection.camelize(['get', inflection.underscore(operationName), 'query', 'all'].join('_'), true);
-    const selections = getSelections(query, fields);
-    const opSel = [
-        t.field({
-            name: operationName,
-            selectionSet: t.selectionSet({
-                selections: [
-                    t.field({ name: 'totalCount' }),
-                    t.field({
-                        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 }),
-                                }),
-                            ],
-                        }),
-                    }),
-                ],
-            }),
-        }),
-    ];
-    const ast = t.document({
-        definitions: [
-            t.operationDefinition({
-                operation: 'query',
-                name: queryName,
-                selectionSet: t.selectionSet({ selections: opSel }),
-            }),
-        ],
-    });
-    return { name: queryName, ast };
-};
-export const getManyPaginatedEdges = ({ operationName, query, fields, }) => {
-    const queryName = inflection.camelize(['get', inflection.underscore(operationName), 'paginated'].join('_'), true);
-    const Plural = operationName.charAt(0).toUpperCase() + operationName.slice(1);
-    const Singular = query.model;
-    const Condition = `${Singular}Condition`;
-    const Filter = `${Singular}Filter`;
-    const OrderBy = `${Plural}OrderBy`;
-    const selections = getSelections(query, fields);
-    const variableDefinitions = [
-        'first',
-        'last',
-        'offset',
-        'after',
-        'before',
-    ].map((name) => t.variableDefinition({
-        variable: t.variable({ name }),
-        type: t.namedType({ type: name === 'after' || name === 'before' ? 'Cursor' : 'Int' }),
-    }));
-    variableDefinitions.push(t.variableDefinition({
-        variable: t.variable({ name: 'condition' }),
-        type: t.namedType({ type: Condition }),
-    }), t.variableDefinition({
-        variable: t.variable({ name: 'filter' }),
-        type: t.namedType({ type: Filter }),
-    }), t.variableDefinition({
-        variable: t.variable({ name: 'orderBy' }),
-        type: t.listType({
-            type: t.nonNullType({
-                type: t.namedType({ type: OrderBy }),
-            }),
-        }),
-    }));
-    const args = [
-        'first',
-        'last',
-        'offset',
-        'after',
-        'before',
-        'condition',
-        'filter',
-        'orderBy',
-    ].map((name) => t.argument({
-        name,
-        value: t.variable({ name }),
-    }));
-    const ast = t.document({
-        definitions: [
-            t.operationDefinition({
-                operation: 'query',
-                name: queryName,
-                variableDefinitions,
-                selectionSet: t.selectionSet({
-                    selections: [
-                        t.field({
-                            name: operationName,
-                            args,
-                            selectionSet: t.selectionSet({
-                                selections: [
-                                    t.field({ name: 'totalCount' }),
-                                    t.field({
-                                        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 }),
-                                                }),
-                                            ],
-                                        }),
-                                    }),
-                                ],
-                            }),
-                        }),
-                    ],
-                }),
-            }),
-        ],
-    });
-    return { name: queryName, ast };
-};
-export const getManyPaginatedNodes = ({ operationName, query, fields, }) => {
-    const queryName = inflection.camelize(['get', inflection.underscore(operationName), 'query'].join('_'), true);
-    const Singular = query.model;
-    const Plural = operationName.charAt(0).toUpperCase() + operationName.slice(1);
-    const Condition = `${Singular}Condition`;
-    const Filter = `${Singular}Filter`;
-    const OrderBy = `${Plural}OrderBy`;
-    const selections = getSelections(query, fields);
-    const variableDefinitions = [
-        'first',
-        'last',
-        'after',
-        'before',
-        'offset',
-    ].map((name) => t.variableDefinition({
-        variable: t.variable({ name }),
-        type: t.namedType({ type: name === 'after' || name === 'before' ? 'Cursor' : 'Int' }),
-    }));
-    variableDefinitions.push(t.variableDefinition({
-        variable: t.variable({ name: 'condition' }),
-        type: t.namedType({ type: Condition }),
-    }), t.variableDefinition({
-        variable: t.variable({ name: 'filter' }),
-        type: t.namedType({ type: Filter }),
-    }), t.variableDefinition({
-        variable: t.variable({ name: 'orderBy' }),
-        type: t.listType({
-            type: t.nonNullType({
-                type: t.namedType({ type: OrderBy }),
-            }),
-        }),
-    }));
-    const args = [
-        'first',
-        'last',
-        'offset',
-        'after',
-        'before',
-        'condition',
-        'filter',
-        'orderBy',
-    ].map((name) => t.argument({
-        name,
-        value: t.variable({ name }),
-    }));
-    const ast = t.document({
-        definitions: [
-            t.operationDefinition({
-                operation: 'query',
-                name: queryName,
-                variableDefinitions,
-                selectionSet: t.selectionSet({
-                    selections: [
-                        t.field({
-                            name: operationName,
-                            args,
-                            selectionSet: t.selectionSet({
-                                selections: [
-                                    t.field({ name: 'totalCount' }),
-                                    t.field({
-                                        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: 'nodes',
-                                        selectionSet: t.selectionSet({ selections }),
-                                    }),
-                                ],
-                            }),
-                        }),
-                    ],
-                }),
-            }),
-        ],
-    });
-    return { name: queryName, ast };
-};
-export const getOrderByEnums = ({ operationName, query, }) => {
-    const queryName = inflection.camelize(['get', inflection.underscore(operationName), 'Order', 'By', 'Enums'].join('_'), true);
-    const Model = operationName.charAt(0).toUpperCase() + operationName.slice(1);
-    const OrderBy = `${Model}OrderBy`;
-    const ast = t.document({
-        definitions: [
-            t.operationDefinition({
-                operation: 'query',
-                name: queryName,
-                selectionSet: t.selectionSet({
-                    selections: [
-                        t.field({
-                            name: '__type',
-                            args: [
-                                t.argument({
-                                    name: 'name',
-                                    value: t.stringValue({ value: OrderBy }),
-                                }),
-                            ],
-                            selectionSet: t.selectionSet({
-                                selections: [
-                                    t.field({
-                                        name: 'enumValues',
-                                        selectionSet: t.selectionSet({
-                                            selections: [t.field({ name: 'name' })],
-                                        }),
-                                    }),
-                                ],
-                            }),
-                        }),
-                    ],
-                }),
-            }),
-        ],
-    });
-    return { name: queryName, ast };
-};
-export const getFragment = ({ operationName, query, }) => {
-    const queryName = inflection.camelize([inflection.underscore(query.model), 'Fragment'].join('_'), true);
-    const selections = getSelections(query);
-    const ast = t.document({
-        definitions: [
-            t.fragmentDefinition({
-                name: queryName,
-                typeCondition: t.namedType({
-                    type: query.model,
-                }),
-                selectionSet: t.selectionSet({
-                    selections,
-                }),
-            }),
-        ],
-    });
-    return { name: queryName, ast };
-};
-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 }) => {
-        const typeName = resolveTypeName(name, type, typeNameOverrides);
-        let 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 selectArgs = objectToArray(query.properties)
-        .filter((field) => field.isNotNull)
-        .map((field) => t.argument({
-        name: field.name,
-        value: t.variable({ name: field.name }),
-    }));
-    const selections = getSelections(query, fields);
-    const opSel = [
-        t.field({
-            name: operationName,
-            args: selectArgs,
-            selectionSet: t.selectionSet({ selections }),
-        }),
-    ];
-    const ast = t.document({
-        definitions: [
-            t.operationDefinition({
-                operation: 'query',
-                name: queryName,
-                variableDefinitions,
-                selectionSet: t.selectionSet({ selections: opSel }),
-            }),
-        ],
-    });
-    return { name: queryName, ast };
-};
-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);
-        return;
-    }
-    const modelName = inflection.camelize([singularModel(mutation.model)].join('_'), true);
-    const allAttrs = objectToArray(mutation.properties.input.properties[modelName].properties);
-    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 = null;
-        if (typeIndex && modelInputName) {
-            const fieldTypeRef = typeIndex.getInputFieldType(modelInputName, name);
-            const tn = refToTypeNode(fieldTypeRef, typeNameOverrides);
-            if (tn)
-                gqlType = tn;
-        }
-        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 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 }) })),
-                            }),
-                        }),
-                    ],
-                }),
-            }),
-        ];
-    let idExists = true;
-    let availableFieldNames = [];
-    if (typeIndex) {
-        const typ = typeIndex.byName?.[mutation.model];
-        const fields = (typ && Array.isArray(typ.fields)) ? typ.fields : [];
-        idExists = fields.some((f) => f && f.name === 'id');
-        availableFieldNames = fields
-            .filter((f) => {
-            let r = f.type;
-            while (r && (r.kind === 'NON_NULL' || r.kind === 'LIST'))
-                r = r.ofType;
-            const kind = r?.kind;
-            return kind === 'SCALAR' || kind === 'ENUM';
-        })
-            .map((f) => f.name);
-    }
-    const finalFields = Array.from(new Set([...(idExists ? ['id'] : []), ...availableFieldNames]));
-    const nested = (finalFields.length > 0)
-        ? [t.field({
-                name: modelName,
-                selectionSet: t.selectionSet({ selections: finalFields.map((f) => t.field({ name: f })) }),
-            })]
-        : [];
-    const ast = createGqlMutation({
-        operationName,
-        mutationName,
-        selectArgs,
-        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, 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);
-        return;
-    }
-    const modelName = inflection.camelize([singularModel(mutation.model)].join('_'), true);
-    // @ts-ignore
-    const allAttrs = objectToArray(mutation.properties.input.properties['patch']?.properties || {});
-    const patchAttrs = allAttrs.filter(
-    // @ts-ignore
-    (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 useCollapsedOpt = selection?.mutationInputMode === 'patchCollapsed';
-    const ModelPascal = inflection.camelize(singularModel(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 = 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 });
-            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 mustUseRaw = 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 }) })),
-                            }),
-                        }),
-                    ],
-                }),
-            }),
-        ];
-    let idExistsPatch = true;
-    if (typeIndex) {
-        const typ = typeIndex.byName?.[mutation.model];
-        const fields = (typ && Array.isArray(typ.fields)) ? typ.fields : [];
-        idExistsPatch = fields.some((f) => f && f.name === 'id');
-    }
-    const shouldDropIdPatch = /Extension$/i.test(modelName) || !idExistsPatch;
-    const idSelection = shouldDropIdPatch ? [] : ['id'];
-    const nestedPatch = (idSelection.length > 0)
-        ? [t.field({
-                name: modelName,
-                selectionSet: t.selectionSet({ selections: idSelection.map((f) => t.field({ name: f })) }),
-            })]
-        : [];
-    const ast = createGqlMutation({
-        operationName,
-        mutationName,
-        selectArgs,
-        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, }, 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);
-        return;
-    }
-    const modelName = inflection.camelize([singularModel(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 = 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 });
-            if (isNotNull) {
-                gqlType = t.nonNullType({ type: gqlType });
-            }
-            if (isArray) {
-                gqlType = t.listType({ type: gqlType });
-                gqlType = t.nonNullType({ type: gqlType });
-            }
-        }
-        const nn = extractNamedTypeName(gqlType);
-        if (nn === 'JSON')
-            unresolved++;
-        return t.variableDefinition({ variable: t.variable({ name }), type: gqlType });
-    });
-    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: 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, 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);
-        return;
-    }
-    // @ts-ignore
-    const otherAttrs = objectToArray(mutation.properties.input.properties);
-    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 });
-    });
-    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 scalarOutputs = (mutation.outputs || [])
-        .filter((field) => field.type.kind === 'SCALAR')
-        .map((f) => f.name);
-    let objectOutputName = (mutation.outputs || [])
-        .find((field) => field.type.kind === 'OBJECT')?.name;
-    if (!objectOutputName) {
-        const payloadTypeName = mutation?.output?.name;
-        if (typeIndex && payloadTypeName) {
-            const payloadType = typeIndex.byName?.[payloadTypeName];
-            const fields = (payloadType && Array.isArray(payloadType.fields)) ? payloadType.fields : [];
-            const match = fields
-                .filter((f) => f && f.name !== 'clientMutationId')
-                .filter((f) => (refToNamedTypeName(f.type) || f.type?.name) !== 'Query')
-                .find((f) => (refToNamedTypeName(f.type) || f.type?.name) === mutation?.model);
-            if (match)
-                objectOutputName = match.name;
-        }
-    }
-    const selections = [];
-    if (objectOutputName) {
-        const modelTypeName = mutation?.model;
-        const modelType = typeIndex && modelTypeName ? typeIndex.byName?.[modelTypeName] : null;
-        const fieldNames = (modelType && Array.isArray(modelType.fields))
-            ? modelType.fields
-                .filter((f) => {
-                let r = f.type;
-                while (r && (r.kind === 'NON_NULL' || r.kind === 'LIST'))
-                    r = r.ofType;
-                const kind = r?.kind;
-                return kind === 'SCALAR' || kind === 'ENUM';
-            })
-                .map((f) => f.name)
-            : [];
-        selections.push(t.field({
-            name: objectOutputName,
-            selectionSet: t.selectionSet({ selections: fieldNames.map((n) => t.field({ name: n })) }),
-        }));
-    }
-    if (scalarOutputs.length > 0) {
-        selections.push(...scalarOutputs.map((o) => t.field({ name: o })));
-    }
-    else {
-        selections.push(t.field({ name: 'clientMutationId' }));
-    }
-    const ast = createGqlMutation({
-        operationName,
-        mutationName,
-        selectArgs,
-        selections,
-        variableDefinitions,
-    });
-    return { name: mutationName, ast };
-};
-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, selection }, typeNameOverrides, typeIndex) ?? {});
-            }
-            else if (defn.mutationType === 'patch') {
-                ({ name, ast } = patchOne({ operationName, mutation: defn, selection }, typeNameOverrides, typeIndex) ?? {});
-            }
-            else if (defn.mutationType === 'delete') {
-                ({ name, ast } = deleteOne({ operationName, mutation: defn }, typeNameOverrides, typeIndex) ?? {});
-            }
-            else {
-                ({ name, ast } = createMutation({ operationName, mutation: defn, selection }, typeNameOverrides, typeIndex) ?? {});
-            }
-        }
-        else if (defn.qtype === 'getMany') {
-            [
-                getMany,
-                getManyPaginatedEdges,
-                getOrderByEnums,
-                getFragment
-            ].forEach(fn => {
-                const result = fn({ operationName, query: defn });
-                if (result?.name && result?.ast) {
-                    m[result.name] = result;
-                }
-            });
-        }
-        else if (defn.qtype === 'getOne') {
-            // @ts-ignore
-            ({ name, ast } = getOne({ operationName, query: defn }, typeNameOverrides) ?? {});
-        }
-        else {
-            console.warn('Unknown qtype for key: ' + operationName);
-        }
-        if (name && ast) {
-            m[name] = { name, ast };
-        }
-        return m;
-    }, {});
-};
-export const generateGranular = (gql, model, fields) => {
-    return Object.keys(gql).reduce((m, operationName) => {
-        const defn = gql[operationName];
-        const matchModel = defn.model;
-        let name;
-        let ast;
-        if (defn.qtype === 'getMany') {
-            const many = getMany({ operationName, query: defn, fields });
-            if (many?.name && many?.ast && model === matchModel) {
-                m[many.name] = many;
-            }
-            const paginatedEdges = getManyPaginatedEdges({
-                operationName,
-                query: defn,
-                fields,
-            });
-            if (paginatedEdges?.name && paginatedEdges?.ast && model === matchModel) {
-                m[paginatedEdges.name] = paginatedEdges;
-            }
-            const paginatedNodes = getManyPaginatedNodes({
-                operationName,
-                query: defn,
-                fields,
-            });
-            if (paginatedNodes?.name && paginatedNodes?.ast && model === matchModel) {
-                m[paginatedNodes.name] = paginatedNodes;
-            }
-        }
-        else if (defn.qtype === 'getOne') {
-            const one = getOne({ operationName, query: defn, fields });
-            if (one?.name && one?.ast && model === matchModel) {
-                m[one.name] = one;
-            }
-        }
-        return m;
-    }, {});
-};
-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 });
-        }
-        if (typeof item === 'object' &&
-            item !== null &&
-            'name' in item &&
-            'selection' in item &&
-            Array.isArray(item.selection)) {
-            if (!useAll && !fields.includes(item.name))
-                return null;
-            const isMany = item.qtype === 'getMany';
-            if (isMany) {
-                return t.field({
-                    name: item.name,
-                    args: [t.argument({ name: 'first', value: t.intValue({ value: '3' }) })],
-                    selectionSet: t.selectionSet({
-                        selections: [
-                            t.field({
-                                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) }),
-                                        }),
-                                    ],
-                                }),
-                            }),
-                        ],
-                    }),
-                });
-            }
-            return t.field({
-                name: item.name,
-                selectionSet: t.selectionSet({ selections: item.selection.map((s) => mapItem(s)).filter(Boolean) }),
-            });
-        }
-        return null;
-    };
-    return query.selection
-        .filter((s) => !(shouldDropId && s === 'id'))
-        .map((field) => mapItem(field))
-        .filter((i) => Boolean(i));
-}