@constructive-io/graphql-codegen 2.17.11

package/esm/gql.js

@@ -0,0 +1,721 @@
+// TODO: use inflection for all the things
+// const { singularize } = require('inflection');
+import * as t from 'gql-ast';
+// @ts-ignore
+import inflection from 'inflection';
+import plz from 'pluralize';
+const NON_MUTABLE_PROPS = [
+    'id',
+    'createdAt',
+    'createdBy',
+    'updatedAt',
+    'updatedBy',
+];
+const objectToArray = (obj) => Object.keys(obj).map((k) => ({ name: k, ...obj[k] }));
+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: 'nodes',
+                        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, }) => {
+    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 });
+        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, }) => {
+    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([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 variableDefinitions = attrs.map(({ name, type, isNotNull, isArray, isArrayNotNull }) => {
+        let gqlType = t.namedType({ type });
+        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 = [
+        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 ast = createGqlMutation({
+        operationName,
+        mutationName,
+        selectArgs,
+        selections: [t.field({ name: 'clientMutationId' })],
+        variableDefinitions,
+        modelName,
+        useModel: false,
+    });
+    return { name: mutationName, ast };
+};
+export const patchOne = ({ operationName, mutation, }) => {
+    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([plz.singular(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 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 patchByVarDefs = patchByAttrs.map(({ name, type, isNotNull, isArray, isArrayNotNull }) => {
+        let gqlType = t.namedType({ type });
+        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 = [
+        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 selections = [t.field({ name: 'clientMutationId' })];
+    const ast = createGqlMutation({
+        operationName,
+        mutationName,
+        selectArgs,
+        selections,
+        variableDefinitions: [...patchByVarDefs, ...patchAttrVarDefs],
+        modelName,
+        useModel: false,
+    });
+    return { name: mutationName, ast };
+};
+export const deleteOne = ({ operationName, mutation, }) => {
+    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([plz.singular(mutation.model)].join('_'), true);
+    // @ts-ignore
+    const deleteAttrs = objectToArray(mutation.properties.input.properties);
+    const variableDefinitions = deleteAttrs.map(({ name, type, isNotNull, isArray }) => {
+        let gqlType = t.namedType({ type });
+        if (isNotNull) {
+            gqlType = t.nonNullType({ type: gqlType });
+        }
+        if (isArray) {
+            gqlType = t.listType({ type: gqlType });
+            // Always non-null list for deletion fields
+            gqlType = t.nonNullType({ type: gqlType });
+        }
+        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 selections = [t.field({ name: 'clientMutationId' })];
+    const ast = createGqlMutation({
+        operationName,
+        mutationName,
+        selectArgs,
+        selections,
+        variableDefinitions,
+        modelName,
+        useModel: false,
+    });
+    return { name: mutationName, ast };
+};
+export const createMutation = ({ operationName, mutation, }) => {
+    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 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 });
+            }
+        }
+        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 outputFields = mutation.outputs
+        ?.filter((field) => field.type.kind === 'SCALAR')
+        .map((f) => f.name) || [];
+    if (outputFields.length === 0) {
+        outputFields.push('clientMutationId');
+    }
+    const selections = outputFields.map((o) => t.field({ name: o }));
+    const ast = createGqlMutation({
+        operationName,
+        mutationName,
+        selectArgs,
+        selections,
+        variableDefinitions,
+    });
+    return { name: mutationName, ast };
+};
+export const generate = (gql) => {
+    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 }) ?? {});
+            }
+            else if (defn.mutationType === 'patch') {
+                ({ name, ast } = patchOne({ operationName, mutation: defn }) ?? {});
+            }
+            else if (defn.mutationType === 'delete') {
+                ({ name, ast } = deleteOne({ operationName, mutation: defn }) ?? {});
+            }
+            else {
+                ({ name, ast } = createMutation({ operationName, mutation: defn }) ?? {});
+            }
+        }
+        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;
+                }
+            });
+        }
+        else if (defn.qtype === 'getOne') {
+            // @ts-ignore
+            ({ name, ast } = getOne({ operationName, query: defn }) ?? {});
+        }
+        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 mapItem = (item) => {
+        if (typeof item === 'string') {
+            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: 'nodes',
+                                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.map((field) => mapItem(field)).filter((i) => Boolean(i));
+}