@constructive-io/graphql-codegen 4.6.1 → 4.7.1

package/core/ast.js

@@ -1,594 +1,19 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
-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 graphql_1 = require("graphql");
-const inflekt_1 = require("inflekt");
-const custom_ast_1 = require("./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: graphql_1.OperationTypeNode.MUTATION,
-                name: mutationName,
-                variableDefinitions,
-                selectionSet: t.selectionSet({ selections: opSel }),
-            }),
-        ],
-    });
-};
-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: graphql_1.OperationTypeNode.QUERY,
-                name: queryName,
-                selectionSet: t.selectionSet({ selections: opSel }),
-            }),
-        ],
-    });
-    return ast;
-};
-exports.getAll = getAll;
-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: graphql_1.OperationTypeNode.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: graphql_1.OperationTypeNode.QUERY,
-                name: queryName,
-                variableDefinitions,
-                selectionSet: t.selectionSet({
-                    selections: [
-                        t.field({
-                            name: operationName,
-                            args,
-                            selectionSet: t.selectionSet({ selections: connectionFields }),
-                        }),
-                    ],
-                }),
-            }),
-        ],
-    });
-    return ast;
-};
-exports.getMany = getMany;
-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: graphql_1.OperationTypeNode.QUERY,
-                name: queryName,
-                variableDefinitions,
-                selectionSet: t.selectionSet({ selections: opSel }),
-            }),
-        ],
-    });
-    return ast;
-};
-exports.getOne = getOne;
-const createOne = ({ mutationName, operationName, mutation, selection, }) => {
-    if (!mutation.properties?.input?.properties) {
-        throw new Error(`No input field for mutation: ${mutationName}`);
-    }
-    const modelName = (0, inflekt_1.camelize)([(0, inflekt_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 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;
-};
-exports.createOne = createOne;
-const patchOne = ({ mutationName, operationName, mutation, selection, }) => {
-    if (!mutation.properties?.input?.properties) {
-        throw new Error(`No input field for mutation: ${mutationName}`);
-    }
-    const modelName = (0, inflekt_1.camelize)([(0, inflekt_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(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;
-};
-exports.patchOne = patchOne;
-const deleteOne = ({ mutationName, operationName, mutation, }) => {
-    if (!mutation.properties?.input?.properties) {
-        throw new Error(`No input field for mutation: ${mutationName}`);
-    }
-    const modelName = (0, inflekt_1.camelize)([(0, inflekt_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 } = 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;
-};
-exports.deleteOne = deleteOne;
-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 = (0, custom_ast_1.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];
-}
+exports.getSelections = exports.deleteOne = exports.patchOne = exports.createOne = exports.getOne = exports.getMany = exports.getCount = exports.getAll = void 0;
+/**
+ * Re-export AST builders from @constructive-io/graphql-query.
+ *
+ * These are the low-level AST generation functions (getAll, getMany, getOne,
+ * createOne, patchOne, deleteOne, getSelections). The canonical implementations
+ * now live in graphql-query.
+ */
+var graphql_query_1 = require("@constructive-io/graphql-query");
+Object.defineProperty(exports, "getAll", { enumerable: true, get: function () { return graphql_query_1.getAll; } });
+Object.defineProperty(exports, "getCount", { enumerable: true, get: function () { return graphql_query_1.getCount; } });
+Object.defineProperty(exports, "getMany", { enumerable: true, get: function () { return graphql_query_1.getMany; } });
+Object.defineProperty(exports, "getOne", { enumerable: true, get: function () { return graphql_query_1.getOne; } });
+Object.defineProperty(exports, "createOne", { enumerable: true, get: function () { return graphql_query_1.createOne; } });
+Object.defineProperty(exports, "patchOne", { enumerable: true, get: function () { return graphql_query_1.patchOne; } });
+Object.defineProperty(exports, "deleteOne", { enumerable: true, get: function () { return graphql_query_1.deleteOne; } });
+Object.defineProperty(exports, "getSelections", { enumerable: true, get: function () { return graphql_query_1.getSelections; } });

package/core/custom-ast.d.ts

@@ -1,35 +1,7 @@
-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
+ * Re-export custom AST utilities from @constructive-io/graphql-query.
+ *
+ * These custom AST builders handle PostgreSQL types that need subfield selections
+ * (geometry, interval, etc.). The canonical implementations now live in graphql-query.
  */
-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;
+export { getCustomAst, getCustomAstForCleanField, requiresSubfieldSelection, geometryPointAst, geometryCollectionAst, geometryAst, intervalAst, isIntervalType, } from '@constructive-io/graphql-query';