@constructive-io/graphql-codegen 4.6.1 → 4.7.0

package/esm/generators/mutations.js

@@ -1,200 +1,7 @@
 /**
- * Mutation generators for CREATE, UPDATE, and DELETE operations
- * Uses AST-based approach for PostGraphile-compatible mutations
+ * Re-export mutation generators from @constructive-io/graphql-query.
+ *
+ * The canonical implementations of buildPostGraphileCreate, buildPostGraphileUpdate,
+ * and buildPostGraphileDelete now live in graphql-query.
  */
-import * as t from 'gql-ast';
-import { OperationTypeNode, print } from 'graphql';
-import { TypedDocumentString } from '../client/typed-document';
-import { getCustomAstForCleanField, requiresSubfieldSelection, } from '../core/custom-ast';
-import { isRelationalField } from './field-selector';
-import { toCamelCaseSingular, toCreateInputTypeName, toCreateMutationName, toDeleteInputTypeName, toDeleteMutationName, toUpdateInputTypeName, toUpdateMutationName, } from './naming-helpers';
-/**
- * Generate field selections for PostGraphile mutations using custom AST logic
- * This handles both scalar fields and complex types that require subfield selections
- */
-function generateFieldSelections(table) {
-    return table.fields
-        .filter((field) => !isRelationalField(field.name, table)) // Exclude relational fields
-        .map((field) => {
-        if (requiresSubfieldSelection(field)) {
-            // Use custom AST generation for complex types
-            return getCustomAstForCleanField(field);
-        }
-        else {
-            // Use simple field selection for scalar types
-            return t.field({ name: field.name });
-        }
-    });
-}
-/**
- * Build PostGraphile-style CREATE mutation
- * PostGraphile expects: mutation { createTableName(input: { tableName: TableNameInput! }) { tableName { ... } } }
- */
-export function buildPostGraphileCreate(table, _allTables, _options = {}) {
-    const mutationName = toCreateMutationName(table.name, table);
-    const singularName = toCamelCaseSingular(table.name, table);
-    const inputTypeName = toCreateInputTypeName(table.name, table);
-    // Create the variable definition for $input
-    const variableDefinitions = [
-        t.variableDefinition({
-            variable: t.variable({ name: 'input' }),
-            type: t.nonNullType({
-                type: t.namedType({ type: inputTypeName }),
-            }),
-        }),
-    ];
-    // Create the mutation arguments
-    const mutationArgs = [
-        t.argument({
-            name: 'input',
-            value: t.variable({ name: 'input' }),
-        }),
-    ];
-    // Get the field selections for the return value using custom AST logic
-    const fieldSelections = generateFieldSelections(table);
-    // Build the mutation AST
-    const ast = t.document({
-        definitions: [
-            t.operationDefinition({
-                operation: OperationTypeNode.MUTATION,
-                name: `${mutationName}Mutation`,
-                variableDefinitions,
-                selectionSet: t.selectionSet({
-                    selections: [
-                        t.field({
-                            name: mutationName,
-                            args: mutationArgs,
-                            selectionSet: t.selectionSet({
-                                selections: [
-                                    t.field({
-                                        name: singularName,
-                                        selectionSet: t.selectionSet({
-                                            selections: fieldSelections,
-                                        }),
-                                    }),
-                                ],
-                            }),
-                        }),
-                    ],
-                }),
-            }),
-        ],
-    });
-    // Print the AST to get the query string
-    const queryString = print(ast);
-    return new TypedDocumentString(queryString, {
-        __ast: ast,
-    });
-}
-/**
- * Build PostGraphile-style UPDATE mutation
- * PostGraphile expects: mutation { updateTableName(input: { id: UUID!, patch: TableNamePatch! }) { tableName { ... } } }
- */
-export function buildPostGraphileUpdate(table, _allTables, _options = {}) {
-    const mutationName = toUpdateMutationName(table.name, table);
-    const singularName = toCamelCaseSingular(table.name, table);
-    const inputTypeName = toUpdateInputTypeName(table.name);
-    // Create the variable definition for $input
-    const variableDefinitions = [
-        t.variableDefinition({
-            variable: t.variable({ name: 'input' }),
-            type: t.nonNullType({
-                type: t.namedType({ type: inputTypeName }),
-            }),
-        }),
-    ];
-    // Create the mutation arguments
-    const mutationArgs = [
-        t.argument({
-            name: 'input',
-            value: t.variable({ name: 'input' }),
-        }),
-    ];
-    // Get the field selections for the return value using custom AST logic
-    const fieldSelections = generateFieldSelections(table);
-    // Build the mutation AST
-    const ast = t.document({
-        definitions: [
-            t.operationDefinition({
-                operation: OperationTypeNode.MUTATION,
-                name: `${mutationName}Mutation`,
-                variableDefinitions,
-                selectionSet: t.selectionSet({
-                    selections: [
-                        t.field({
-                            name: mutationName,
-                            args: mutationArgs,
-                            selectionSet: t.selectionSet({
-                                selections: [
-                                    t.field({
-                                        name: singularName,
-                                        selectionSet: t.selectionSet({
-                                            selections: fieldSelections,
-                                        }),
-                                    }),
-                                ],
-                            }),
-                        }),
-                    ],
-                }),
-            }),
-        ],
-    });
-    // Print the AST to get the query string
-    const queryString = print(ast);
-    return new TypedDocumentString(queryString, {
-        __ast: ast,
-    });
-}
-/**
- * Build PostGraphile-style DELETE mutation
- * PostGraphile expects: mutation { deleteTableName(input: { id: UUID! }) { clientMutationId } }
- */
-export function buildPostGraphileDelete(table, _allTables, _options = {}) {
-    const mutationName = toDeleteMutationName(table.name, table);
-    const inputTypeName = toDeleteInputTypeName(table.name);
-    // Create the variable definition for $input
-    const variableDefinitions = [
-        t.variableDefinition({
-            variable: t.variable({ name: 'input' }),
-            type: t.nonNullType({
-                type: t.namedType({ type: inputTypeName }),
-            }),
-        }),
-    ];
-    // Create the mutation arguments
-    const mutationArgs = [
-        t.argument({
-            name: 'input',
-            value: t.variable({ name: 'input' }),
-        }),
-    ];
-    // PostGraphile delete mutations typically return clientMutationId
-    const fieldSelections = [t.field({ name: 'clientMutationId' })];
-    // Build the mutation AST
-    const ast = t.document({
-        definitions: [
-            t.operationDefinition({
-                operation: OperationTypeNode.MUTATION,
-                name: `${mutationName}Mutation`,
-                variableDefinitions,
-                selectionSet: t.selectionSet({
-                    selections: [
-                        t.field({
-                            name: mutationName,
-                            args: mutationArgs,
-                            selectionSet: t.selectionSet({
-                                selections: fieldSelections,
-                            }),
-                        }),
-                    ],
-                }),
-            }),
-        ],
-    });
-    // Print the AST to get the query string
-    const queryString = print(ast);
-    return new TypedDocumentString(queryString, {
-        __ast: ast,
-    });
-}
+export { buildPostGraphileCreate, buildPostGraphileUpdate, buildPostGraphileDelete, } from '@constructive-io/graphql-query';

package/esm/generators/naming-helpers.d.ts

@@ -1,48 +1,6 @@
-import type { CleanTable } from '../types/schema';
 /**
- * Safely normalise a server-provided inflection value.
- * Returns `null` for null, undefined, or whitespace-only strings.
- */
-export declare function normalizeInflectionValue(value: string | null | undefined): string | null;
-/**
- * Convert PascalCase table name to camelCase plural for GraphQL queries.
- * Prefers server-provided `table.query.all` / `table.inflection.allRows`
- * when available, with guards against naive pluralisation drift and
- * missing camelCase boundaries.
+ * Re-export naming helpers from @constructive-io/graphql-query.
  *
- * Example: "ActionGoal" -> "actionGoals", "User" -> "users", "Person" -> "people"
- */
-export declare function toCamelCasePlural(tableName: string, table?: CleanTable | null): string;
-/**
- * Convert PascalCase table name to camelCase singular field name.
- * Prefers server-provided names when available.
- */
-export declare function toCamelCaseSingular(tableName: string, table?: CleanTable | null): string;
-export declare function toCreateMutationName(tableName: string, table?: CleanTable | null): string;
-export declare function toUpdateMutationName(tableName: string, table?: CleanTable | null): string;
-export declare function toDeleteMutationName(tableName: string, table?: CleanTable | null): string;
-export declare function toCreateInputTypeName(tableName: string, table?: CleanTable | null): string;
-export declare function toUpdateInputTypeName(tableName: string): string;
-export declare function toDeleteInputTypeName(tableName: string): string;
-export declare function toFilterTypeName(tableName: string, table?: CleanTable | null): string;
-/**
- * Resolve PostGraphile patch field name.
- * In v5 this is typically entity-specific: e.g. "userPatch", "contactPatch".
- * Prefers the value discovered from the schema (`table.query.patchFieldName`
- * or `table.inflection.patchField`), falls back to `${singularName}Patch`.
- */
-export declare function toPatchFieldName(tableName: string, table?: CleanTable | null): string;
-/**
- * Convert camelCase field name to SCREAMING_SNAKE_CASE for PostGraphile
- * orderBy enums.
- *
- * "displayName" -> "DISPLAY_NAME_ASC"
- * "createdAt"   -> "CREATED_AT_DESC"
- * "id"          -> "ID_ASC"
- */
-export declare function toOrderByEnumValue(fieldName: string, direction: 'asc' | 'desc'): string;
-/**
- * Generate the PostGraphile OrderBy enum type name for a table.
- * Prefers server-provided `table.inflection.orderByType` when available.
+ * Server-aware inflection naming functions now live in graphql-query.
  */
-export declare function toOrderByTypeName(tableName: string, table?: CleanTable | null): string;
+export { normalizeInflectionValue, toCamelCaseSingular, toCreateMutationName, toUpdateMutationName, toDeleteMutationName, toCreateInputTypeName, toUpdateInputTypeName, toDeleteInputTypeName, toFilterTypeName, toPatchFieldName, toOrderByEnumValue, } from '@constructive-io/graphql-query';

package/esm/generators/naming-helpers.js

@@ -1,154 +1,6 @@
 /**
- * Server-aware naming helpers for GraphQL query/mutation generation.
+ * Re-export naming helpers from @constructive-io/graphql-query.
  *
- * These functions prefer names already discovered from the GraphQL schema
- * (stored on `table.query` and `table.inflection` by `infer-tables.ts`)
- * and fall back to local inflection when introspection data is unavailable.
- *
- * Back-ported from Dashboard's `packages/data/src/query-generator.ts`.
- */
-import { camelize, pluralize } from 'inflekt';
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-/**
- * Safely normalise a server-provided inflection value.
- * Returns `null` for null, undefined, or whitespace-only strings.
- */
-export function normalizeInflectionValue(value) {
-    if (typeof value !== 'string')
-        return null;
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : null;
-}
-// ---------------------------------------------------------------------------
-// Plural / Singular
-// ---------------------------------------------------------------------------
-/**
- * Convert PascalCase table name to camelCase plural for GraphQL queries.
- * Prefers server-provided `table.query.all` / `table.inflection.allRows`
- * when available, with guards against naive pluralisation drift and
- * missing camelCase boundaries.
- *
- * Example: "ActionGoal" -> "actionGoals", "User" -> "users", "Person" -> "people"
- */
-export function toCamelCasePlural(tableName, table) {
-    const singular = camelize(tableName, true);
-    const inflectedPlural = pluralize(singular);
-    const serverPluralCandidates = [
-        table?.query?.all,
-        table?.inflection?.allRows,
-    ];
-    for (const candidateRaw of serverPluralCandidates) {
-        const candidate = normalizeInflectionValue(candidateRaw);
-        if (!candidate)
-            continue;
-        // Guard against known fallback drift:
-        // 1. Naive pluralisation: "activitys" instead of "activities"
-        const isNaivePlural = candidate === `${singular}s` && candidate !== inflectedPlural;
-        // 2. Missing camelCase boundaries: "deliveryzones" instead of "deliveryZones"
-        const isMiscased = candidate !== inflectedPlural &&
-            candidate.toLowerCase() === inflectedPlural.toLowerCase();
-        if (isNaivePlural || isMiscased)
-            continue;
-        return candidate;
-    }
-    return inflectedPlural;
-}
-/**
- * Convert PascalCase table name to camelCase singular field name.
- * Prefers server-provided names when available.
- */
-export function toCamelCaseSingular(tableName, table) {
-    const localSingular = camelize(tableName, true);
-    for (const candidateRaw of [
-        table?.query?.one,
-        table?.inflection?.tableFieldName,
-    ]) {
-        const candidate = normalizeInflectionValue(candidateRaw);
-        if (!candidate)
-            continue;
-        // Reject miscased versions: "deliveryzone" vs "deliveryZone"
-        if (candidate !== localSingular &&
-            candidate.toLowerCase() === localSingular.toLowerCase())
-            continue;
-        return candidate;
-    }
-    return localSingular;
-}
-// ---------------------------------------------------------------------------
-// Mutation names
-// ---------------------------------------------------------------------------
-export function toCreateMutationName(tableName, table) {
-    return (normalizeInflectionValue(table?.query?.create) ?? `create${tableName}`);
-}
-export function toUpdateMutationName(tableName, table) {
-    return (normalizeInflectionValue(table?.query?.update) ?? `update${tableName}`);
-}
-export function toDeleteMutationName(tableName, table) {
-    return (normalizeInflectionValue(table?.query?.delete) ?? `delete${tableName}`);
-}
-// ---------------------------------------------------------------------------
-// Input / type names
-// ---------------------------------------------------------------------------
-export function toCreateInputTypeName(tableName, table) {
-    return (normalizeInflectionValue(table?.inflection?.createInputType) ??
-        `Create${tableName}Input`);
-}
-export function toUpdateInputTypeName(tableName) {
-    return `Update${tableName}Input`;
-}
-export function toDeleteInputTypeName(tableName) {
-    return `Delete${tableName}Input`;
-}
-export function toFilterTypeName(tableName, table) {
-    return (normalizeInflectionValue(table?.inflection?.filterType) ??
-        `${tableName}Filter`);
-}
-// ---------------------------------------------------------------------------
-// Patch field name
-// ---------------------------------------------------------------------------
-/**
- * Resolve PostGraphile patch field name.
- * In v5 this is typically entity-specific: e.g. "userPatch", "contactPatch".
- * Prefers the value discovered from the schema (`table.query.patchFieldName`
- * or `table.inflection.patchField`), falls back to `${singularName}Patch`.
- */
-export function toPatchFieldName(tableName, table) {
-    // First check the patch field name discovered from UpdateXxxInput
-    const introspectedPatch = normalizeInflectionValue(table?.query?.patchFieldName);
-    if (introspectedPatch)
-        return introspectedPatch;
-    // Then check the inflection table
-    const explicitPatchField = normalizeInflectionValue(table?.inflection?.patchField);
-    if (explicitPatchField)
-        return explicitPatchField;
-    return `${toCamelCaseSingular(tableName, table)}Patch`;
-}
-// ---------------------------------------------------------------------------
-// OrderBy helpers
-// ---------------------------------------------------------------------------
-/**
- * Convert camelCase field name to SCREAMING_SNAKE_CASE for PostGraphile
- * orderBy enums.
- *
- * "displayName" -> "DISPLAY_NAME_ASC"
- * "createdAt"   -> "CREATED_AT_DESC"
- * "id"          -> "ID_ASC"
- */
-export function toOrderByEnumValue(fieldName, direction) {
-    const screaming = fieldName
-        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
-        .toUpperCase();
-    return `${screaming}_${direction.toUpperCase()}`;
-}
-/**
- * Generate the PostGraphile OrderBy enum type name for a table.
- * Prefers server-provided `table.inflection.orderByType` when available.
+ * Server-aware inflection naming functions now live in graphql-query.
  */
-export function toOrderByTypeName(tableName, table) {
-    if (table?.inflection?.orderByType)
-        return table.inflection.orderByType;
-    const plural = toCamelCasePlural(tableName, table);
-    return `${plural.charAt(0).toUpperCase() + plural.slice(1)}OrderBy`;
-}
+export { normalizeInflectionValue, toCamelCaseSingular, toCreateMutationName, toUpdateMutationName, toDeleteMutationName, toCreateInputTypeName, toUpdateInputTypeName, toDeleteInputTypeName, toFilterTypeName, toPatchFieldName, toOrderByEnumValue, } from '@constructive-io/graphql-query';

package/esm/generators/select.d.ts

@@ -1,39 +1,8 @@
-import { TypedDocumentString } from '../client/typed-document';
-import { QueryBuilder } from '../core/query-builder';
-import type { IntrospectionSchema, MetaObject } from '../core/types';
-import type { QueryOptions } from '../types/query';
-import type { CleanTable } from '../types/schema';
-export { toCamelCasePlural, toOrderByTypeName } from './naming-helpers';
 /**
- * Convert CleanTable to MetaObject format for QueryBuilder
+ * Re-export select query generators from @constructive-io/graphql-query.
+ *
+ * The canonical implementations of buildSelect, buildFindOne, buildCount,
+ * cleanTableToMetaObject, createASTQueryBuilder, generateIntrospectionSchema,
+ * toCamelCasePlural, and toOrderByTypeName now live in graphql-query.
  */
-export declare function cleanTableToMetaObject(tables: CleanTable[]): MetaObject;
-/**
- * Generate basic IntrospectionSchema from CleanTable array
- * This creates a minimal schema for AST generation
- */
-export declare function generateIntrospectionSchema(tables: CleanTable[]): IntrospectionSchema;
-/**
- * Create AST-based query builder for a table
- */
-export declare function createASTQueryBuilder(tables: CleanTable[]): QueryBuilder;
-/**
- * Build a SELECT query for a table with optional filtering, sorting, and pagination
- * Uses direct AST generation without intermediate conversions
- */
-export declare function buildSelect(table: CleanTable, allTables: readonly CleanTable[], options?: QueryOptions): TypedDocumentString<Record<string, unknown>, QueryOptions>;
-/**
- * Build a single row query by primary key or unique field
- */
-export declare function buildFindOne(table: CleanTable, _pkField?: string): TypedDocumentString<Record<string, unknown>, Record<string, unknown>>;
-/**
- * Build a count query for a table
- */
-export declare function buildCount(table: CleanTable): TypedDocumentString<{
-    [key: string]: {
-        totalCount: number;
-    };
-}, {
-    condition?: Record<string, unknown>;
-    filter?: Record<string, unknown>;
-}>;
+export { buildSelect, buildFindOne, buildCount, cleanTableToMetaObject, createASTQueryBuilder, generateIntrospectionSchema, toCamelCasePlural, toOrderByTypeName, } from '@constructive-io/graphql-query';