@constructive-io/graphql-query 2.4.7 → 2.5.1

package/ast.js

@@ -1,5 +1,4 @@
 "use strict";
-// @ts-nocheck
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -33,26 +32,30 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deleteOne = exports.patchOne = exports.createOne = exports.getOne = exports.getMany = exports.getAll = void 0;
+exports.deleteOne = exports.patchOne = exports.createOne = exports.getOne = exports.getMany = exports.getCount = exports.getAll = void 0;
 exports.getSelections = getSelections;
 const t = __importStar(require("gql-ast"));
-const inflection_1 = __importDefault(require("inflection"));
+const inflection_1 = require("inflection");
 const custom_ast_1 = require("./custom-ast");
-const isObject = val => val !== null && typeof val === 'object';
 const NON_MUTABLE_PROPS = ['createdAt', 'createdBy', 'updatedAt', 'updatedBy'];
-const objectToArray = (obj) => Object.keys(obj).map((k) => ({ name: k, ...obj[k] }));
-const createGqlMutation = ({ operationName, mutationName, selectArgs, selections, variableDefinitions, modelName, useModel = true }) => {
+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 })
-            })
+                selectionSet: t.selectionSet({ selections }),
+            }),
         ]
         : [
             t.field({
@@ -63,12 +66,12 @@ const createGqlMutation = ({ operationName, mutationName, selectArgs, selections
                         ? [
                             t.field({
                                 name: modelName,
-                                selectionSet: t.selectionSet({ selections })
-                            })
+                                selectionSet: t.selectionSet({ selections }),
+                            }),
                         ]
-                        : selections
-                })
-            })
+                        : selections,
+                }),
+            }),
         ];
     return t.document({
         definitions: [
@@ -76,227 +79,197 @@ const createGqlMutation = ({ operationName, mutationName, selectArgs, selections
                 operation: 'mutation',
                 name: mutationName,
                 variableDefinitions,
-                selectionSet: t.selectionSet({ selections: opSel })
-            })
-        ]
+                selectionSet: t.selectionSet({ selections: opSel }),
+            }),
+        ],
     });
 };
-const getAll = ({ queryName, operationName, query, selection }) => {
+const getAll = ({ queryName, operationName, query: _query, selection, }) => {
     const selections = getSelections(selection);
     const opSel = [
         t.field({
             name: operationName,
-            selectionSet: t.objectValue({
-                fields: [
+            selectionSet: t.selectionSet({
+                selections: [
                     t.field({
-                        name: 'totalCount'
+                        name: 'totalCount',
                     }),
                     t.field({
                         name: 'nodes',
-                        selectionSet: t.selectionSet({ selections })
-                    })
-                ]
-            })
-        })
+                        selectionSet: t.selectionSet({ selections }),
+                    }),
+                ],
+            }),
+        }),
     ];
     const ast = t.document({
         definitions: [
             t.operationDefinition({
                 operation: 'query',
                 name: queryName,
-                selectionSet: t.selectionSet({ selections: opSel })
-            })
-        ]
+                selectionSet: t.selectionSet({ selections: opSel }),
+            }),
+        ],
     });
     return ast;
 };
 exports.getAll = getAll;
-const getMany = ({ builder, // we can use props here to enable pagination, etc
-queryName, operationName, query, selection }) => {
+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;
+};
+exports.getCount = getCount;
+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: [
-                    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 }) })
-                        })
-                    })
-                ],
+                variableDefinitions,
                 selectionSet: t.selectionSet({
                     selections: [
                         t.field({
                             name: operationName,
-                            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'
-                                    })
-                                })
-                            ],
-                            selectionSet: t.objectValue({
-                                fields: [
-                                    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' })
-                                            ]
-                                        })
-                                    }),
-                                    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
-                                            })
-                                        })
-                                ]
-                            })
-                        })
-                    ]
-                })
-            })
-        ]
+                            args,
+                            selectionSet: t.selectionSet({ selections: connectionFields }),
+                        }),
+                    ],
+                }),
+            }),
+        ],
     });
     return ast;
 };
 exports.getMany = getMany;
-const getOne = ({ builder, // we can use props here to enable pagination, etc
-queryName, operationName, query, selection }) => {
+const getOne = ({ queryName, operationName, query, selection, }) => {
     const variableDefinitions = Object.keys(query.properties)
-        .map((key) => ({ name: key, ...query.properties[key] }))
+        .map((key) => ({ key, ...query.properties[key] }))
         .filter((field) => field.isNotNull)
         .map((field) => {
-        const { name: fieldName, type: fieldType, isNotNull, isArray, isArrayNotNull } = field;
+        const { key: fieldName, type: fieldType, isNotNull, isArray, isArrayNotNull, } = field;
         let type = t.namedType({ type: fieldType });
         if (isNotNull)
             type = t.nonNullType({ type });
@@ -307,7 +280,7 @@ queryName, operationName, query, selection }) => {
         }
         return t.variableDefinition({
             variable: t.variable({ name: fieldName }),
-            type
+            type,
         });
     });
     const props = objectToArray(query.properties);
@@ -316,7 +289,7 @@ queryName, operationName, query, selection }) => {
         .map((field) => {
         return t.argument({
             name: field.name,
-            value: t.variable({ name: field.name })
+            value: t.variable({ name: field.name }),
         });
     });
     const selections = getSelections(selection);
@@ -324,8 +297,8 @@ queryName, operationName, query, selection }) => {
         t.field({
             name: operationName,
             args: selectArgs,
-            selectionSet: t.selectionSet({ selections })
-        })
+            selectionSet: t.selectionSet({ selections }),
+        }),
     ];
     const ast = t.document({
         definitions: [
@@ -333,20 +306,25 @@ queryName, operationName, query, selection }) => {
                 operation: 'query',
                 name: queryName,
                 variableDefinitions,
-                selectionSet: t.selectionSet({ selections: opSel })
-            })
-        ]
+                selectionSet: t.selectionSet({ selections: opSel }),
+            }),
+        ],
     });
     return ast;
 };
 exports.getOne = getOne;
-const createOne = ({ mutationName, operationName, mutation, selection }) => {
+const createOne = ({ mutationName, operationName, mutation, selection, }) => {
     if (!mutation.properties?.input?.properties) {
-        console.log('no input field for mutation for' + mutationName);
-        return;
+        throw new Error(`No input field for mutation: ${mutationName}`);
+    }
+    const modelName = (0, inflection_1.camelize)([(0, inflection_1.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 modelName = inflection_1.default.camelize([inflection_1.default.singularize(mutation.model)].join('_'), true);
-    const allAttrs = objectToArray(mutation.properties.input.properties[modelName].properties);
+    const allAttrs = objectToArray(modelProperties.properties);
     const attrs = allAttrs.filter((field) => !NON_MUTABLE_PROPS.includes(field.name));
     const variableDefinitions = getCreateVariablesAst(attrs);
     const selectArgs = [
@@ -359,15 +337,13 @@ const createOne = ({ mutationName, operationName, mutation, selection }) => {
                         value: t.objectValue({
                             fields: attrs.map((field) => t.objectField({
                                 name: field.name,
-                                value: t.variable({
-                                    name: field.name
-                                })
-                            }))
-                        })
-                    })
-                ]
-            })
-        })
+                                value: t.variable({ name: field.name }),
+                            })),
+                        }),
+                    }),
+                ],
+            }),
+        }),
     ];
     const selections = selection
         ? getSelections(selection)
@@ -378,20 +354,24 @@ const createOne = ({ mutationName, operationName, mutation, selection }) => {
         selectArgs,
         selections,
         variableDefinitions,
-        modelName
+        modelName,
     });
     return ast;
 };
 exports.createOne = createOne;
-const patchOne = ({ mutationName, operationName, mutation, selection }) => {
+const patchOne = ({ mutationName, operationName, mutation, selection, }) => {
     if (!mutation.properties?.input?.properties) {
-        console.log('no input field for mutation for' + mutationName);
-        return;
+        throw new Error(`No input field for mutation: ${mutationName}`);
     }
-    const modelName = inflection_1.default.camelize([inflection_1.default.singularize(mutation.model)].join('_'), true);
-    const allAttrs = objectToArray(mutation.properties.input.properties['patch']?.properties || {});
+    const modelName = (0, inflection_1.camelize)([(0, inflection_1.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(mutation.properties.input.properties).filter((n) => n.name !== 'patch');
+    const patchByAttrs = objectToArray(inputProperties).filter((n) => n.name !== 'patch');
     const patchers = patchByAttrs.map((p) => p.name);
     const variableDefinitions = getUpdateVariablesAst(patchAttrs, patchers);
     const selectArgs = [
@@ -401,7 +381,7 @@ const patchOne = ({ mutationName, operationName, mutation, selection }) => {
                 fields: [
                     ...patchByAttrs.map((field) => t.objectField({
                         name: field.name,
-                        value: t.variable({ name: field.name })
+                        value: t.variable({ name: field.name }),
                     })),
                     t.objectField({
                         name: 'patch',
@@ -410,15 +390,13 @@ const patchOne = ({ mutationName, operationName, mutation, selection }) => {
                                 .filter((field) => !patchers.includes(field.name))
                                 .map((field) => t.objectField({
                                 name: field.name,
-                                value: t.variable({
-                                    name: field.name
-                                })
-                            }))
-                        })
-                    })
-                ]
-            })
-        })
+                                value: t.variable({ name: field.name }),
+                            })),
+                        }),
+                    }),
+                ],
+            }),
+        }),
     ];
     const selections = selection
         ? getSelections(selection)
@@ -429,20 +407,21 @@ const patchOne = ({ mutationName, operationName, mutation, selection }) => {
         selectArgs,
         selections,
         variableDefinitions,
-        modelName
+        modelName,
     });
     return ast;
 };
 exports.patchOne = patchOne;
-const deleteOne = ({ mutationName, operationName, mutation }) => {
+const deleteOne = ({ mutationName, operationName, mutation, }) => {
     if (!mutation.properties?.input?.properties) {
-        console.log('no input field for mutation for' + mutationName);
-        return;
+        throw new Error(`No input field for mutation: ${mutationName}`);
     }
-    const modelName = inflection_1.default.camelize([inflection_1.default.singularize(mutation.model)].join('_'), true);
-    const deleteAttrs = objectToArray(mutation.properties.input.properties);
+    const modelName = (0, inflection_1.camelize)([(0, inflection_1.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, isArrayNotNull } = field;
+        const { name: fieldName, type: fieldType, isNotNull, isArray } = field;
         let type = t.namedType({ type: fieldType });
         if (isNotNull)
             type = t.nonNullType({ type });
@@ -453,7 +432,7 @@ const deleteOne = ({ mutationName, operationName, mutation }) => {
         }
         return t.variableDefinition({
             variable: t.variable({ name: fieldName }),
-            type
+            type,
         });
     });
     const selectArgs = [
@@ -462,10 +441,10 @@ const deleteOne = ({ mutationName, operationName, mutation }) => {
             value: t.objectValue({
                 fields: deleteAttrs.map((f) => t.objectField({
                     name: f.name,
-                    value: t.variable({ name: f.name })
-                }))
-            })
-        })
+                    value: t.variable({ name: f.name }),
+                })),
+            }),
+        }),
     ];
     // so we can support column select grants plugin
     const selections = [t.field({ name: 'clientMutationId' })];
@@ -476,7 +455,7 @@ const deleteOne = ({ mutationName, operationName, mutation }) => {
         selections,
         useModel: false,
         variableDefinitions,
-        modelName
+        modelName,
     });
     return ast;
 };
@@ -484,110 +463,82 @@ exports.deleteOne = deleteOne;
 function getSelections(selection = []) {
     const selectionAst = (field) => {
         return typeof field === 'string'
-            ? t.field({
-                name: field
-            })
-            : (0, custom_ast_1.getCustomAst)(field.fieldDefn);
+            ? t.field({ name: field })
+            : (0, custom_ast_1.getCustomAst)(field.fieldDefn) || 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: Object.entries(variables).reduce((args, variable) => {
-                    const [argName, argValue] = variable;
-                    const argAst = t.argument({
-                        name: argName,
-                        value: getValueAst(argValue)
-                    });
-                    args = argAst ? [...args, argAst] : args;
-                    return args;
-                }, []),
-                selectionSet: isBelongTo
-                    ? t.selectionSet({
-                        selections: selection.map((field) => selectionAst(field))
-                    })
-                    : t.objectValue({
-                        fields: [
-                            t.field({
-                                name: 'totalCount'
-                            }),
-                            t.field({
-                                name: 'nodes',
-                                selectionSet: t.selectionSet({
-                                    selections: selection.map((field) => selectionAst(field))
-                                })
-                            })
-                        ]
-                    })
+                args,
+                selectionSet,
             });
         }
         else {
-            const { fieldDefn } = selectionDefn;
-            // Field is not found in model meta, do nothing
-            if (!fieldDefn)
-                return null;
-            return (0, custom_ast_1.getCustomAst)(fieldDefn);
+            return selectionAst(selectionDefn);
         }
     })
-        .filter(Boolean);
+        .filter((node) => node !== null);
 }
-/**
- * Get argument AST from a value
- * @param {*} value
- * @returns {Object} AST for the argument
- */
-function getValueAst(value) {
-    if (value == 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 });
+        return t.intValue({ value: value.toString() });
     }
     if (typeof value === 'string') {
         return t.stringValue({ value });
     }
-    if (typeof value === 'boolean') {
-        return t.booleanValue({ value });
-    }
+    // Handle arrays
     if (Array.isArray(value)) {
-        return t.listValue({ values: value.map((v) => getValueAst(v)) });
+        return t.listValue({
+            values: value.map((item) => getComplexValueAst(item)),
+        });
     }
-    if (isObject(value)) {
+    // Handle objects
+    if (typeof value === 'object' && value !== null) {
+        const obj = value;
         return t.objectValue({
-            fields: Object.entries(value).reduce((fields, entry) => {
-                const [objKey, objValue] = entry;
-                fields = [
-                    ...fields,
-                    t.objectField({
-                        name: objKey,
-                        value: getValueAst(objValue)
-                    })
-                ];
-                return fields;
-            }, [])
+            fields: Object.entries(obj).map(([key, val]) => t.objectField({
+                name: key,
+                value: getComplexValueAst(val),
+            })),
         });
     }
+    throw new Error(`Unsupported value type: ${typeof value}`);
 }
-const CustomInputTypes = {
-    interval: 'IntervalInput'
-};
-/**
- * Get mutation variables AST from attributes array
- * @param {Array} attrs
- * @returns {Object} AST for the variables
- */
 function getCreateVariablesAst(attrs) {
     return attrs.map((field) => {
-        const { name: fieldName, type: fieldType, isNotNull, isArray, isArrayNotNull, properties } = field;
-        let type;
-        if (properties == null) {
-            type = t.namedType({ type: fieldType });
-        }
-        else if ((0, custom_ast_1.isIntervalType)(properties)) {
-            type = t.namedType({ type: CustomInputTypes.interval });
-        }
+        const { name: fieldName, type: fieldType, isNotNull, isArray, isArrayNotNull, } = field;
+        let type = t.namedType({ type: fieldType });
         if (isNotNull)
             type = t.nonNullType({ type });
         if (isArray) {
@@ -597,34 +548,31 @@ function getCreateVariablesAst(attrs) {
         }
         return t.variableDefinition({
             variable: t.variable({ name: fieldName }),
-            type
+            type,
         });
     });
 }
-/**
- * Get mutation variables AST from attributes array
- * @param {Array} attrs
- * @returns {Object} AST for the variables
- */
 function getUpdateVariablesAst(attrs, patchers) {
-    return attrs.map((field) => {
-        const { name: fieldName, type: fieldType, isNotNull, isArray, properties } = field;
-        let type;
-        if (properties == null) {
-            type = t.namedType({ type: fieldType });
-        }
-        else if ((0, custom_ast_1.isIntervalType)(properties)) {
-            type = t.namedType({ type: CustomInputTypes.interval });
-        }
-        if (isNotNull)
-            type = t.nonNullType({ type });
-        if (isArray)
+    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 (patchers.includes(field.name))
-            type = t.nonNullType({ type });
+            if (isArrayNotNull)
+                type = t.nonNullType({ type });
+        }
         return t.variableDefinition({
             variable: t.variable({ name: fieldName }),
-            type
+            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];
 }