@constructive-io/graphql-codegen 2.19.0 → 2.20.1

package/esm/core/ast.js

@@ -0,0 +1,549 @@
+import * as t from 'gql-ast';
+import * as inflection from 'inflection';
+import { getCustomAst } from './custom-ast';
+const NON_MUTABLE_PROPS = ['createdAt', 'createdBy', 'updatedAt', 'updatedBy'];
+const objectToArray = (obj) => Object.keys(obj).map((k) => ({
+    key: k,
+    name: obj[k].name || k,
+    type: obj[k].type,
+    isNotNull: obj[k].isNotNull,
+    isArray: obj[k].isArray,
+    isArrayNotNull: obj[k].isArrayNotNull,
+    properties: obj[k].properties,
+}));
+const createGqlMutation = ({ operationName, mutationName, selectArgs, selections, variableDefinitions, modelName, 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 getAll = ({ queryName, operationName, selection, }) => {
+    const selections = getSelections(selection);
+    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 ast;
+};
+export const getCount = ({ queryName, operationName, query, }) => {
+    const Singular = query.model;
+    const Filter = `${Singular}Filter`;
+    const Condition = `${Singular}Condition`;
+    const variableDefinitions = [
+        t.variableDefinition({
+            variable: t.variable({ name: 'condition' }),
+            type: t.namedType({ type: Condition }),
+        }),
+        t.variableDefinition({
+            variable: t.variable({ name: 'filter' }),
+            type: t.namedType({ type: Filter }),
+        }),
+    ];
+    const args = [
+        t.argument({ name: 'condition', value: t.variable({ name: 'condition' }) }),
+        t.argument({ name: 'filter', value: t.variable({ name: 'filter' }) }),
+    ];
+    // PostGraphile supports totalCount through connections
+    const opSel = [
+        t.field({
+            name: operationName,
+            args,
+            selectionSet: t.selectionSet({
+                selections: [
+                    t.field({
+                        name: 'totalCount',
+                    }),
+                ],
+            }),
+        }),
+    ];
+    const ast = t.document({
+        definitions: [
+            t.operationDefinition({
+                operation: 'query',
+                name: queryName,
+                variableDefinitions,
+                selectionSet: t.selectionSet({ selections: opSel }),
+            }),
+        ],
+    });
+    return ast;
+};
+export const getMany = ({ builder, queryName, operationName, query, selection, }) => {
+    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(selection);
+    const variableDefinitions = [
+        t.variableDefinition({
+            variable: t.variable({ name: 'first' }),
+            type: t.namedType({ type: 'Int' }),
+        }),
+        t.variableDefinition({
+            variable: t.variable({ name: 'last' }),
+            type: t.namedType({ type: 'Int' }),
+        }),
+        t.variableDefinition({
+            variable: t.variable({ name: 'after' }),
+            type: t.namedType({ type: 'Cursor' }),
+        }),
+        t.variableDefinition({
+            variable: t.variable({ name: 'before' }),
+            type: t.namedType({ type: 'Cursor' }),
+        }),
+        t.variableDefinition({
+            variable: t.variable({ name: 'offset' }),
+            type: t.namedType({ type: 'Int' }),
+        }),
+        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 = [
+        t.argument({ name: 'first', value: t.variable({ name: 'first' }) }),
+        t.argument({ name: 'last', value: t.variable({ name: 'last' }) }),
+        t.argument({ name: 'offset', value: t.variable({ name: 'offset' }) }),
+        t.argument({ name: 'after', value: t.variable({ name: 'after' }) }),
+        t.argument({ name: 'before', value: t.variable({ name: 'before' }) }),
+        t.argument({
+            name: 'condition',
+            value: t.variable({ name: 'condition' }),
+        }),
+        t.argument({ name: 'filter', value: t.variable({ name: 'filter' }) }),
+        t.argument({ name: 'orderBy', value: t.variable({ name: 'orderBy' }) }),
+    ];
+    const pageInfoFields = [
+        t.field({ name: 'hasNextPage' }),
+        t.field({ name: 'hasPreviousPage' }),
+        t.field({ name: 'endCursor' }),
+        t.field({ name: 'startCursor' }),
+    ];
+    const dataField = builder?._edges
+        ? t.field({
+            name: 'edges',
+            selectionSet: t.selectionSet({
+                selections: [
+                    t.field({ name: 'cursor' }),
+                    t.field({
+                        name: 'node',
+                        selectionSet: t.selectionSet({ selections }),
+                    }),
+                ],
+            }),
+        })
+        : t.field({
+            name: 'nodes',
+            selectionSet: t.selectionSet({ selections }),
+        });
+    const connectionFields = [
+        t.field({ name: 'totalCount' }),
+        t.field({
+            name: 'pageInfo',
+            selectionSet: t.selectionSet({ selections: pageInfoFields }),
+        }),
+        dataField,
+    ];
+    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: connectionFields }),
+                        }),
+                    ],
+                }),
+            }),
+        ],
+    });
+    return ast;
+};
+export const getOne = ({ queryName, operationName, query, selection, }) => {
+    const variableDefinitions = Object.keys(query.properties)
+        .map((key) => ({ key, ...query.properties[key] }))
+        .filter((field) => field.isNotNull)
+        .map((field) => {
+        const { key: fieldName, type: fieldType, isNotNull, isArray, isArrayNotNull, } = field;
+        let type = t.namedType({ type: fieldType });
+        if (isNotNull)
+            type = t.nonNullType({ type });
+        if (isArray) {
+            type = t.listType({ type });
+            if (isArrayNotNull)
+                type = t.nonNullType({ type });
+        }
+        return t.variableDefinition({
+            variable: t.variable({ name: fieldName }),
+            type,
+        });
+    });
+    const props = objectToArray(query.properties);
+    const selectArgs = props
+        .filter((field) => field.isNotNull)
+        .map((field) => {
+        return t.argument({
+            name: field.name,
+            value: t.variable({ name: field.name }),
+        });
+    });
+    const selections = getSelections(selection);
+    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 ast;
+};
+export const createOne = ({ mutationName, operationName, mutation, selection, }) => {
+    if (!mutation.properties?.input?.properties) {
+        throw new Error(`No input field for mutation: ${mutationName}`);
+    }
+    const modelName = inflection.camelize([inflection.singularize(mutation.model)].join('_'), true);
+    const inputProperties = mutation.properties.input
+        .properties;
+    const modelProperties = inputProperties[modelName];
+    if (!modelProperties.properties) {
+        throw new Error(`No properties found for model: ${modelName}`);
+    }
+    const allAttrs = objectToArray(modelProperties.properties);
+    const attrs = allAttrs.filter((field) => !NON_MUTABLE_PROPS.includes(field.name));
+    const variableDefinitions = getCreateVariablesAst(attrs);
+    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 = selection
+        ? getSelections(selection)
+        : allAttrs.map((field) => t.field({ name: field.name }));
+    const ast = createGqlMutation({
+        operationName,
+        mutationName,
+        selectArgs,
+        selections,
+        variableDefinitions,
+        modelName,
+    });
+    return ast;
+};
+export const patchOne = ({ mutationName, operationName, mutation, selection, }) => {
+    if (!mutation.properties?.input?.properties) {
+        throw new Error(`No input field for mutation: ${mutationName}`);
+    }
+    const modelName = inflection.camelize([inflection.singularize(mutation.model)].join('_'), true);
+    const inputProperties = mutation.properties.input
+        .properties;
+    const patchProperties = inputProperties['patch'];
+    const allAttrs = patchProperties?.properties
+        ? objectToArray(patchProperties.properties)
+        : [];
+    const patchAttrs = allAttrs.filter((prop) => !NON_MUTABLE_PROPS.includes(prop.name));
+    const patchByAttrs = objectToArray(inputProperties).filter((n) => n.name !== 'patch');
+    const patchers = patchByAttrs.map((p) => p.name);
+    const variableDefinitions = getUpdateVariablesAst(patchAttrs, patchers);
+    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
+                                .filter((field) => !patchers.includes(field.name))
+                                .map((field) => t.objectField({
+                                name: field.name,
+                                value: t.variable({ name: field.name }),
+                            })),
+                        }),
+                    }),
+                ],
+            }),
+        }),
+    ];
+    const selections = selection
+        ? getSelections(selection)
+        : allAttrs.map((field) => t.field({ name: field.name }));
+    const ast = createGqlMutation({
+        operationName,
+        mutationName,
+        selectArgs,
+        selections,
+        variableDefinitions,
+        modelName,
+    });
+    return ast;
+};
+export const deleteOne = ({ mutationName, operationName, mutation, }) => {
+    if (!mutation.properties?.input?.properties) {
+        throw new Error(`No input field for mutation: ${mutationName}`);
+    }
+    const modelName = inflection.camelize([inflection.singularize(mutation.model)].join('_'), true);
+    const inputProperties = mutation.properties.input
+        .properties;
+    const deleteAttrs = objectToArray(inputProperties);
+    const variableDefinitions = deleteAttrs.map((field) => {
+        const { name: fieldName, type: fieldType, isNotNull, isArray } = field;
+        let type = t.namedType({ type: fieldType });
+        if (isNotNull)
+            type = t.nonNullType({ type });
+        if (isArray) {
+            type = t.listType({ type });
+            // no need to check isArrayNotNull since we need this field for deletion
+            type = t.nonNullType({ type });
+        }
+        return t.variableDefinition({
+            variable: t.variable({ name: fieldName }),
+            type,
+        });
+    });
+    const selectArgs = [
+        t.argument({
+            name: 'input',
+            value: t.objectValue({
+                fields: deleteAttrs.map((f) => t.objectField({
+                    name: f.name,
+                    value: t.variable({ name: f.name }),
+                })),
+            }),
+        }),
+    ];
+    // so we can support column select grants plugin
+    const selections = [t.field({ name: 'clientMutationId' })];
+    const ast = createGqlMutation({
+        operationName,
+        mutationName,
+        selectArgs,
+        selections,
+        useModel: false,
+        variableDefinitions,
+        modelName,
+    });
+    return ast;
+};
+export function getSelections(selection = []) {
+    const selectionAst = (field) => {
+        if (typeof field === 'string') {
+            return t.field({ name: field });
+        }
+        // Check if fieldDefn has MetaField shape (has type.pgType)
+        const fieldDefn = field.fieldDefn;
+        if (fieldDefn &&
+            'type' in fieldDefn &&
+            fieldDefn.type &&
+            typeof fieldDefn.type === 'object' &&
+            'pgType' in fieldDefn.type) {
+            const customAst = getCustomAst(fieldDefn);
+            if (customAst)
+                return customAst;
+        }
+        return t.field({ name: field.name });
+    };
+    return selection
+        .map((selectionDefn) => {
+        if (selectionDefn.isObject) {
+            const { name, selection, variables = {}, isBelongTo } = selectionDefn;
+            const args = Object.entries(variables).reduce((acc, variable) => {
+                const [argName, argValue] = variable;
+                const argAst = t.argument({
+                    name: argName,
+                    value: getComplexValueAst(argValue),
+                });
+                return argAst ? [...acc, argAst] : acc;
+            }, []);
+            const subSelections = selection?.map((field) => selectionAst(field)) || [];
+            const selectionSet = isBelongTo
+                ? t.selectionSet({ selections: subSelections })
+                : t.selectionSet({
+                    selections: [
+                        t.field({ name: 'totalCount' }),
+                        t.field({
+                            name: 'nodes',
+                            selectionSet: t.selectionSet({ selections: subSelections }),
+                        }),
+                    ],
+                });
+            return t.field({
+                name,
+                args,
+                selectionSet,
+            });
+        }
+        else {
+            return selectionAst(selectionDefn);
+        }
+    })
+        .filter((node) => node !== null);
+}
+function getComplexValueAst(value) {
+    // Handle null
+    if (value === null) {
+        return t.nullValue();
+    }
+    // Handle primitives
+    if (typeof value === 'boolean') {
+        return t.booleanValue({ value });
+    }
+    if (typeof value === 'number') {
+        return t.intValue({ value: value.toString() });
+    }
+    if (typeof value === 'string') {
+        return t.stringValue({ value });
+    }
+    // Handle arrays
+    if (Array.isArray(value)) {
+        return t.listValue({
+            values: value.map((item) => getComplexValueAst(item)),
+        });
+    }
+    // Handle objects
+    if (typeof value === 'object' && value !== null) {
+        const obj = value;
+        return t.objectValue({
+            fields: Object.entries(obj).map(([key, val]) => t.objectField({
+                name: key,
+                value: getComplexValueAst(val),
+            })),
+        });
+    }
+    throw new Error(`Unsupported value type: ${typeof value}`);
+}
+function getCreateVariablesAst(attrs) {
+    return attrs.map((field) => {
+        const { name: fieldName, type: fieldType, isNotNull, isArray, isArrayNotNull, } = field;
+        let type = t.namedType({ type: fieldType });
+        if (isNotNull)
+            type = t.nonNullType({ type });
+        if (isArray) {
+            type = t.listType({ type });
+            if (isArrayNotNull)
+                type = t.nonNullType({ type });
+        }
+        return t.variableDefinition({
+            variable: t.variable({ name: fieldName }),
+            type,
+        });
+    });
+}
+function getUpdateVariablesAst(attrs, patchers) {
+    const patchVariables = attrs
+        .filter((field) => !patchers.includes(field.name))
+        .map((field) => {
+        const { name: fieldName, type: fieldType, isArray, isArrayNotNull } = field;
+        let type = t.namedType({ type: fieldType });
+        if (isArray) {
+            type = t.listType({ type });
+            if (isArrayNotNull)
+                type = t.nonNullType({ type });
+        }
+        return t.variableDefinition({
+            variable: t.variable({ name: fieldName }),
+            type,
+        });
+    });
+    const patcherVariables = patchers.map((patcher) => {
+        return t.variableDefinition({
+            variable: t.variable({ name: patcher }),
+            type: t.nonNullType({ type: t.namedType({ type: 'String' }) }),
+        });
+    });
+    return [...patchVariables, ...patcherVariables];
+}

package/esm/core/custom-ast.d.ts

@@ -0,0 +1,35 @@
+import type { FieldNode } from 'graphql';
+import type { CleanField } from '../types/schema';
+import type { MetaField } from './types';
+/**
+ * Get custom AST for MetaField type - handles PostgreSQL types that need subfield selections
+ */
+export declare function getCustomAst(fieldDefn?: MetaField): FieldNode | null;
+/**
+ * Generate custom AST for CleanField type - handles GraphQL types that need subfield selections
+ */
+export declare function getCustomAstForCleanField(field: CleanField): FieldNode;
+/**
+ * Check if a CleanField requires subfield selection based on its GraphQL type
+ */
+export declare function requiresSubfieldSelection(field: CleanField): boolean;
+/**
+ * Generate AST for GeometryPoint type
+ */
+export declare function geometryPointAst(name: string): FieldNode;
+/**
+ * Generate AST for GeometryGeometryCollection type
+ */
+export declare function geometryCollectionAst(name: string): FieldNode;
+/**
+ * Generate AST for generic geometry type (returns geojson)
+ */
+export declare function geometryAst(name: string): FieldNode;
+/**
+ * Generate AST for interval type
+ */
+export declare function intervalAst(name: string): FieldNode;
+/**
+ * Check if an object has interval type shape
+ */
+export declare function isIntervalType(obj: unknown): boolean;