@constructive-io/graphql-codegen 2.28.3 → 2.28.5

package/cli/codegen/orm/client-generator.js

@@ -377,6 +377,20 @@ function generateCreateClientFile(tables, hasCustomQueries, hasCustomMutations)
     ], t.stringLiteral('./query-builder')));
     // export * from './select-types';
     statements.push(t.exportAllDeclaration(t.stringLiteral('./select-types')));
+    // Re-export all models for backwards compatibility
+    // export * from './models';
+    statements.push(t.exportAllDeclaration(t.stringLiteral('./models')));
+    // Re-export custom operations for backwards compatibility
+    if (hasCustomQueries) {
+        statements.push(t.exportNamedDeclaration(null, [
+            t.exportSpecifier(t.identifier('createQueryOperations'), t.identifier('createQueryOperations')),
+        ], t.stringLiteral('./query')));
+    }
+    if (hasCustomMutations) {
+        statements.push(t.exportNamedDeclaration(null, [
+            t.exportSpecifier(t.identifier('createMutationOperations'), t.identifier('createMutationOperations')),
+        ], t.stringLiteral('./mutation')));
+    }
     // Build the return object properties
     const returnProperties = [];
     for (const table of tables) {

package/cli/codegen/orm/query-builder.ts

@@ -0,0 +1,670 @@
+/**
+ * Query Builder - Builds and executes GraphQL operations
+ *
+ * This is the RUNTIME code that gets copied to generated output.
+ * It uses gql-ast to build GraphQL documents programmatically.
+ *
+ * NOTE: This file is read at codegen time and written to output.
+ * Any changes here will affect all generated ORM clients.
+ */
+
+import * as t from 'gql-ast';
+import { parseType, print } from 'graphql';
+import type {
+  ArgumentNode,
+  FieldNode,
+  VariableDefinitionNode,
+  EnumValueNode,
+} from 'graphql';
+import { OrmClient, QueryResult, GraphQLRequestError } from './client';
+
+export interface QueryBuilderConfig {
+  client: OrmClient;
+  operation: 'query' | 'mutation';
+  operationName: string;
+  fieldName: string;
+  document: string;
+  variables?: Record<string, unknown>;
+}
+
+export class QueryBuilder<TResult> {
+  private config: QueryBuilderConfig;
+
+  constructor(config: QueryBuilderConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Execute the query and return a discriminated union result
+   * Use result.ok to check success, or .unwrap() to throw on error
+   */
+  async execute(): Promise<QueryResult<TResult>> {
+    return this.config.client.execute<TResult>(
+      this.config.document,
+      this.config.variables
+    );
+  }
+
+  /**
+   * Execute and unwrap the result, throwing GraphQLRequestError on failure
+   * @throws {GraphQLRequestError} If the query returns errors
+   */
+  async unwrap(): Promise<TResult> {
+    const result = await this.execute();
+    if (!result.ok) {
+      throw new GraphQLRequestError(result.errors, result.data);
+    }
+    return result.data;
+  }
+
+  /**
+   * Execute and unwrap, returning defaultValue on error instead of throwing
+   */
+  async unwrapOr<D>(defaultValue: D): Promise<TResult | D> {
+    const result = await this.execute();
+    if (!result.ok) {
+      return defaultValue;
+    }
+    return result.data;
+  }
+
+  /**
+   * Execute and unwrap, calling onError callback on failure
+   */
+  async unwrapOrElse<D>(
+    onError: (errors: import('./client').GraphQLError[]) => D
+  ): Promise<TResult | D> {
+    const result = await this.execute();
+    if (!result.ok) {
+      return onError(result.errors);
+    }
+    return result.data;
+  }
+
+  toGraphQL(): string {
+    return this.config.document;
+  }
+
+  getVariables(): Record<string, unknown> | undefined {
+    return this.config.variables;
+  }
+}
+
+// ============================================================================
+// Selection Builders
+// ============================================================================
+
+export function buildSelections(
+  select: Record<string, unknown> | undefined
+): FieldNode[] {
+  if (!select) {
+    return [];
+  }
+
+  const fields: FieldNode[] = [];
+
+  for (const [key, value] of Object.entries(select)) {
+    if (value === false || value === undefined) {
+      continue;
+    }
+
+    if (value === true) {
+      fields.push(t.field({ name: key }));
+      continue;
+    }
+
+    if (typeof value === 'object' && value !== null) {
+      const nested = value as {
+        select?: Record<string, unknown>;
+        first?: number;
+        filter?: Record<string, unknown>;
+        orderBy?: string[];
+        connection?: boolean;
+      };
+
+      if (nested.select) {
+        const nestedSelections = buildSelections(nested.select);
+        const isConnection =
+          nested.connection === true ||
+          nested.first !== undefined ||
+          nested.filter !== undefined;
+        const args = buildArgs([
+          buildOptionalArg('first', nested.first),
+          nested.filter
+            ? t.argument({ name: 'filter', value: buildValueAst(nested.filter) })
+            : null,
+          buildEnumListArg('orderBy', nested.orderBy),
+        ]);
+
+        if (isConnection) {
+          fields.push(
+            t.field({
+              name: key,
+              args,
+              selectionSet: t.selectionSet({
+                selections: buildConnectionSelections(nestedSelections),
+              }),
+            })
+          );
+        } else {
+          fields.push(
+            t.field({
+              name: key,
+              args,
+              selectionSet: t.selectionSet({ selections: nestedSelections }),
+            })
+          );
+        }
+      }
+    }
+  }
+
+  return fields;
+}
+
+// ============================================================================
+// Document Builders
+// ============================================================================
+
+export function buildFindManyDocument<TSelect, TWhere>(
+  operationName: string,
+  queryField: string,
+  select: TSelect,
+  args: {
+    where?: TWhere;
+    orderBy?: string[];
+    first?: number;
+    last?: number;
+    after?: string;
+    before?: string;
+    offset?: number;
+  },
+  filterTypeName: string,
+  orderByTypeName: string
+): { document: string; variables: Record<string, unknown> } {
+  const selections = select
+    ? buildSelections(select as Record<string, unknown>)
+    : [t.field({ name: 'id' })];
+
+  const variableDefinitions: VariableDefinitionNode[] = [];
+  const queryArgs: ArgumentNode[] = [];
+  const variables: Record<string, unknown> = {};
+
+  addVariable(
+    { varName: 'where', argName: 'filter', typeName: filterTypeName, value: args.where },
+    variableDefinitions,
+    queryArgs,
+    variables
+  );
+  addVariable(
+    {
+      varName: 'orderBy',
+      typeName: '[' + orderByTypeName + '!]',
+      value: args.orderBy?.length ? args.orderBy : undefined,
+    },
+    variableDefinitions,
+    queryArgs,
+    variables
+  );
+  addVariable(
+    { varName: 'first', typeName: 'Int', value: args.first },
+    variableDefinitions,
+    queryArgs,
+    variables
+  );
+  addVariable(
+    { varName: 'last', typeName: 'Int', value: args.last },
+    variableDefinitions,
+    queryArgs,
+    variables
+  );
+  addVariable(
+    { varName: 'after', typeName: 'Cursor', value: args.after },
+    variableDefinitions,
+    queryArgs,
+    variables
+  );
+  addVariable(
+    { varName: 'before', typeName: 'Cursor', value: args.before },
+    variableDefinitions,
+    queryArgs,
+    variables
+  );
+  addVariable(
+    { varName: 'offset', typeName: 'Int', value: args.offset },
+    variableDefinitions,
+    queryArgs,
+    variables
+  );
+
+  const document = t.document({
+    definitions: [
+      t.operationDefinition({
+        operation: 'query',
+        name: operationName + 'Query',
+        variableDefinitions: variableDefinitions.length ? variableDefinitions : undefined,
+        selectionSet: t.selectionSet({
+          selections: [
+            t.field({
+              name: queryField,
+              args: queryArgs.length ? queryArgs : undefined,
+              selectionSet: t.selectionSet({
+                selections: buildConnectionSelections(selections),
+              }),
+            }),
+          ],
+        }),
+      }),
+    ],
+  });
+
+  return { document: print(document), variables };
+}
+
+export function buildFindFirstDocument<TSelect, TWhere>(
+  operationName: string,
+  queryField: string,
+  select: TSelect,
+  args: { where?: TWhere },
+  filterTypeName: string
+): { document: string; variables: Record<string, unknown> } {
+  const selections = select
+    ? buildSelections(select as Record<string, unknown>)
+    : [t.field({ name: 'id' })];
+
+  const variableDefinitions: VariableDefinitionNode[] = [];
+  const queryArgs: ArgumentNode[] = [];
+  const variables: Record<string, unknown> = {};
+
+  // Always add first: 1 for findFirst
+  addVariable(
+    { varName: 'first', typeName: 'Int', value: 1 },
+    variableDefinitions,
+    queryArgs,
+    variables
+  );
+  addVariable(
+    { varName: 'where', argName: 'filter', typeName: filterTypeName, value: args.where },
+    variableDefinitions,
+    queryArgs,
+    variables
+  );
+
+  const document = t.document({
+    definitions: [
+      t.operationDefinition({
+        operation: 'query',
+        name: operationName + 'Query',
+        variableDefinitions,
+        selectionSet: t.selectionSet({
+          selections: [
+            t.field({
+              name: queryField,
+              args: queryArgs,
+              selectionSet: t.selectionSet({
+                selections: [
+                  t.field({
+                    name: 'nodes',
+                    selectionSet: t.selectionSet({ selections }),
+                  }),
+                ],
+              }),
+            }),
+          ],
+        }),
+      }),
+    ],
+  });
+
+  return { document: print(document), variables };
+}
+
+export function buildCreateDocument<TSelect, TData>(
+  operationName: string,
+  mutationField: string,
+  entityField: string,
+  select: TSelect,
+  data: TData,
+  inputTypeName: string
+): { document: string; variables: Record<string, unknown> } {
+  const selections = select
+    ? buildSelections(select as Record<string, unknown>)
+    : [t.field({ name: 'id' })];
+
+  return {
+    document: buildInputMutationDocument({
+      operationName,
+      mutationField,
+      inputTypeName,
+      resultSelections: [
+        t.field({
+          name: entityField,
+          selectionSet: t.selectionSet({ selections }),
+        }),
+      ],
+    }),
+    variables: {
+      input: {
+        [entityField]: data,
+      },
+    },
+  };
+}
+
+export function buildUpdateDocument<TSelect, TWhere extends { id: string }, TData>(
+  operationName: string,
+  mutationField: string,
+  entityField: string,
+  select: TSelect,
+  where: TWhere,
+  data: TData,
+  inputTypeName: string
+): { document: string; variables: Record<string, unknown> } {
+  const selections = select
+    ? buildSelections(select as Record<string, unknown>)
+    : [t.field({ name: 'id' })];
+
+  return {
+    document: buildInputMutationDocument({
+      operationName,
+      mutationField,
+      inputTypeName,
+      resultSelections: [
+        t.field({
+          name: entityField,
+          selectionSet: t.selectionSet({ selections }),
+        }),
+      ],
+    }),
+    variables: {
+      input: {
+        id: where.id,
+        patch: data,
+      },
+    },
+  };
+}
+
+export function buildDeleteDocument<TWhere extends { id: string }>(
+  operationName: string,
+  mutationField: string,
+  entityField: string,
+  where: TWhere,
+  inputTypeName: string
+): { document: string; variables: Record<string, unknown> } {
+  return {
+    document: buildInputMutationDocument({
+      operationName,
+      mutationField,
+      inputTypeName,
+      resultSelections: [
+        t.field({
+          name: entityField,
+          selectionSet: t.selectionSet({
+            selections: [t.field({ name: 'id' })],
+          }),
+        }),
+      ],
+    }),
+    variables: {
+      input: {
+        id: where.id,
+      },
+    },
+  };
+}
+
+export function buildCustomDocument<TSelect, TArgs>(
+  operationType: 'query' | 'mutation',
+  operationName: string,
+  fieldName: string,
+  select: TSelect,
+  args: TArgs,
+  variableDefinitions: Array<{ name: string; type: string }>
+): { document: string; variables: Record<string, unknown> } {
+  let actualSelect = select;
+  let isConnection = false;
+
+  if (select && typeof select === 'object' && 'select' in select) {
+    const wrapper = select as { select?: TSelect; connection?: boolean };
+    if (wrapper.select) {
+      actualSelect = wrapper.select;
+      isConnection = wrapper.connection === true;
+    }
+  }
+
+  const selections = actualSelect
+    ? buildSelections(actualSelect as Record<string, unknown>)
+    : [];
+
+  const variableDefs = variableDefinitions.map((definition) =>
+    t.variableDefinition({
+      variable: t.variable({ name: definition.name }),
+      type: parseType(definition.type),
+    })
+  );
+  const fieldArgs = variableDefinitions.map((definition) =>
+    t.argument({
+      name: definition.name,
+      value: t.variable({ name: definition.name }),
+    })
+  );
+
+  const fieldSelections = isConnection
+    ? buildConnectionSelections(selections)
+    : selections;
+
+  const document = t.document({
+    definitions: [
+      t.operationDefinition({
+        operation: operationType,
+        name: operationName,
+        variableDefinitions: variableDefs.length ? variableDefs : undefined,
+        selectionSet: t.selectionSet({
+          selections: [
+            t.field({
+              name: fieldName,
+              args: fieldArgs.length ? fieldArgs : undefined,
+              selectionSet: fieldSelections.length
+                ? t.selectionSet({ selections: fieldSelections })
+                : undefined,
+            }),
+          ],
+        }),
+      }),
+    ],
+  });
+
+  return {
+    document: print(document),
+    variables: (args ?? {}) as Record<string, unknown>,
+  };
+}
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+function buildArgs(args: Array<ArgumentNode | null>): ArgumentNode[] {
+  return args.filter((arg): arg is ArgumentNode => arg !== null);
+}
+
+function buildOptionalArg(
+  name: string,
+  value: number | string | undefined
+): ArgumentNode | null {
+  if (value === undefined) {
+    return null;
+  }
+  const valueNode =
+    typeof value === 'number'
+      ? t.intValue({ value: value.toString() })
+      : t.stringValue({ value });
+  return t.argument({ name, value: valueNode });
+}
+
+function buildEnumListArg(
+  name: string,
+  values: string[] | undefined
+): ArgumentNode | null {
+  if (!values || values.length === 0) {
+    return null;
+  }
+  return t.argument({
+    name,
+    value: t.listValue({
+      values: values.map((value) => buildEnumValue(value)),
+    }),
+  });
+}
+
+function buildEnumValue(value: string): EnumValueNode {
+  return {
+    kind: 'EnumValue',
+    value,
+  };
+}
+
+function buildPageInfoSelections(): FieldNode[] {
+  return [
+    t.field({ name: 'hasNextPage' }),
+    t.field({ name: 'hasPreviousPage' }),
+    t.field({ name: 'startCursor' }),
+    t.field({ name: 'endCursor' }),
+  ];
+}
+
+function buildConnectionSelections(nodeSelections: FieldNode[]): FieldNode[] {
+  return [
+    t.field({
+      name: 'nodes',
+      selectionSet: t.selectionSet({ selections: nodeSelections }),
+    }),
+    t.field({ name: 'totalCount' }),
+    t.field({
+      name: 'pageInfo',
+      selectionSet: t.selectionSet({ selections: buildPageInfoSelections() }),
+    }),
+  ];
+}
+
+interface VariableSpec {
+  varName: string;
+  argName?: string;
+  typeName: string;
+  value: unknown;
+}
+
+interface InputMutationConfig {
+  operationName: string;
+  mutationField: string;
+  inputTypeName: string;
+  resultSelections: FieldNode[];
+}
+
+function buildInputMutationDocument(config: InputMutationConfig): string {
+  const document = t.document({
+    definitions: [
+      t.operationDefinition({
+        operation: 'mutation',
+        name: config.operationName + 'Mutation',
+        variableDefinitions: [
+          t.variableDefinition({
+            variable: t.variable({ name: 'input' }),
+            type: parseType(config.inputTypeName + '!'),
+          }),
+        ],
+        selectionSet: t.selectionSet({
+          selections: [
+            t.field({
+              name: config.mutationField,
+              args: [
+                t.argument({
+                  name: 'input',
+                  value: t.variable({ name: 'input' }),
+                }),
+              ],
+              selectionSet: t.selectionSet({
+                selections: config.resultSelections,
+              }),
+            }),
+          ],
+        }),
+      }),
+    ],
+  });
+  return print(document);
+}
+
+function addVariable(
+  spec: VariableSpec,
+  definitions: VariableDefinitionNode[],
+  args: ArgumentNode[],
+  variables: Record<string, unknown>
+): void {
+  if (spec.value === undefined) return;
+
+  definitions.push(
+    t.variableDefinition({
+      variable: t.variable({ name: spec.varName }),
+      type: parseType(spec.typeName),
+    })
+  );
+  args.push(
+    t.argument({
+      name: spec.argName ?? spec.varName,
+      value: t.variable({ name: spec.varName }),
+    })
+  );
+  variables[spec.varName] = spec.value;
+}
+
+function buildValueAst(
+  value: unknown
+):
+  | ReturnType<typeof t.stringValue>
+  | ReturnType<typeof t.intValue>
+  | ReturnType<typeof t.floatValue>
+  | ReturnType<typeof t.booleanValue>
+  | ReturnType<typeof t.listValue>
+  | ReturnType<typeof t.objectValue>
+  | ReturnType<typeof t.nullValue>
+  | EnumValueNode {
+  if (value === null) {
+    return t.nullValue();
+  }
+
+  if (typeof value === 'boolean') {
+    return t.booleanValue({ value });
+  }
+
+  if (typeof value === 'number') {
+    return Number.isInteger(value)
+      ? t.intValue({ value: value.toString() })
+      : t.floatValue({ value: value.toString() });
+  }
+
+  if (typeof value === 'string') {
+    return t.stringValue({ value });
+  }
+
+  if (Array.isArray(value)) {
+    return t.listValue({
+      values: value.map((item) => buildValueAst(item)),
+    });
+  }
+
+  if (typeof value === 'object' && value !== null) {
+    const obj = value as Record<string, unknown>;
+    return t.objectValue({
+      fields: Object.entries(obj).map(([key, val]) =>
+        t.objectField({
+          name: key,
+          value: buildValueAst(val),
+        })
+      ),
+    });
+  }
+
+  throw new Error('Unsupported value type: ' + typeof value);
+}

package/esm/cli/codegen/orm/client-generator.js

@@ -338,6 +338,20 @@ export function generateCreateClientFile(tables, hasCustomQueries, hasCustomMuta
     ], t.stringLiteral('./query-builder')));
     // export * from './select-types';
     statements.push(t.exportAllDeclaration(t.stringLiteral('./select-types')));
+    // Re-export all models for backwards compatibility
+    // export * from './models';
+    statements.push(t.exportAllDeclaration(t.stringLiteral('./models')));
+    // Re-export custom operations for backwards compatibility
+    if (hasCustomQueries) {
+        statements.push(t.exportNamedDeclaration(null, [
+            t.exportSpecifier(t.identifier('createQueryOperations'), t.identifier('createQueryOperations')),
+        ], t.stringLiteral('./query')));
+    }
+    if (hasCustomMutations) {
+        statements.push(t.exportNamedDeclaration(null, [
+            t.exportSpecifier(t.identifier('createMutationOperations'), t.identifier('createMutationOperations')),
+        ], t.stringLiteral('./mutation')));
+    }
     // Build the return object properties
     const returnProperties = [];
     for (const table of tables) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@constructive-io/graphql-codegen",
-  "version": "2.28.3",
+  "version": "2.28.5",
   "description": "CLI-based GraphQL SDK generator for PostGraphile endpoints with React Query hooks",
   "keywords": [
     "graphql",
@@ -35,8 +35,9 @@
   "scripts": {
     "clean": "makage clean",
     "prepack": "npm run build",
-    "build": "makage build",
-    "build:dev": "makage build --dev",
+    "copy:ts": "makage copy src/cli/codegen/orm/query-builder.ts dist/cli/codegen/orm --flat",
+    "build": "makage build && npm run copy:ts",
+    "build:dev": "makage build --dev && npm run copy:ts",
     "dev": "ts-node ./src/index.ts",
     "lint": "eslint . --fix",
     "fmt": "prettier --write .",
@@ -88,5 +89,5 @@
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   },
-  "gitHead": "06cc06455356911bf9a24245849138892267b87d"
+  "gitHead": "64fdb385977ead1f08cb95f63be2f3299ac90cd4"
 }