@constructive-io/graphql-codegen 2.19.0 → 2.20.0

package/esm/cli/codegen/orm/input-types-generator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/cli/codegen/orm/input-types-generator.test.js

@@ -0,0 +1,73 @@
+// Jest globals - no import needed
+import { generateInputTypesFile } from './input-types-generator';
+const uuidType = { gqlType: 'UUID', isArray: false };
+const stringType = { gqlType: 'String', isArray: false };
+function createTable(table) {
+    return {
+        name: table.name,
+        fields: table.fields ?? [],
+        relations: table.relations ?? {
+            belongsTo: [],
+            hasOne: [],
+            hasMany: [],
+            manyToMany: [],
+        },
+        query: table.query,
+        inflection: table.inflection,
+        constraints: table.constraints,
+    };
+}
+describe('input-types-generator', () => {
+    it('emits relation helpers and select types with related names', () => {
+        const userTable = createTable({
+            name: 'User',
+            fields: [
+                { name: 'id', type: uuidType },
+                { name: 'name', type: stringType },
+            ],
+            relations: {
+                belongsTo: [],
+                hasOne: [],
+                hasMany: [
+                    {
+                        fieldName: 'posts',
+                        isUnique: false,
+                        referencedByTable: 'Post',
+                        type: null,
+                        keys: [],
+                    },
+                ],
+                manyToMany: [],
+            },
+        });
+        const postTable = createTable({
+            name: 'Post',
+            fields: [
+                { name: 'id', type: uuidType },
+                { name: 'title', type: stringType },
+            ],
+            relations: {
+                belongsTo: [
+                    {
+                        fieldName: 'author',
+                        isUnique: false,
+                        referencesTable: 'User',
+                        type: null,
+                        keys: [],
+                    },
+                ],
+                hasOne: [],
+                hasMany: [],
+                manyToMany: [],
+            },
+        });
+        const result = generateInputTypesFile(new Map(), new Set(), [userTable, postTable]);
+        expect(result.content).toContain('export interface ConnectionResult<T>');
+        expect(result.content).toContain('export interface UserRelations');
+        expect(result.content).toContain('posts?: ConnectionResult<Post>');
+        expect(result.content).toContain('export type UserWithRelations = User & UserRelations;');
+        expect(result.content).toContain('posts?: boolean | {');
+        expect(result.content).toContain('orderBy?: PostsOrderBy[];');
+        expect(result.content).toContain('author?: boolean | { select?: UserSelect };');
+    });
+});

package/esm/cli/codegen/orm/model-generator.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Model class generator for ORM client
+ *
+ * Generates per-table model classes with findMany, findFirst, create, update, delete methods.
+ *
+ * Example output:
+ * ```typescript
+ * export class UserModel {
+ *   constructor(private client: OrmClient) {}
+ *
+ *   findMany<S extends UserSelect>(args?: FindManyArgs<S, UserWhereInput, UserOrderBy>) {
+ *     return new QueryBuilder<...>({ ... });
+ *   }
+ *   // ...
+ * }
+ * ```
+ */
+import type { CleanTable } from '../../../types/schema';
+export interface GeneratedModelFile {
+    fileName: string;
+    content: string;
+    modelName: string;
+    tableName: string;
+}
+/**
+ * Generate a model class file for a table
+ */
+export declare function generateModelFile(table: CleanTable, _useSharedTypes: boolean): GeneratedModelFile;
+/**
+ * Generate all model files for a list of tables
+ */
+export declare function generateAllModelFiles(tables: CleanTable[], useSharedTypes: boolean): GeneratedModelFile[];

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

@@ -0,0 +1,260 @@
+import { createProject, createSourceFile, getFormattedOutput, createFileHeader, createImport, } from '../ts-ast';
+import { getTableNames, lcFirst } from '../utils';
+/**
+ * Generate a model class file for a table
+ */
+export function generateModelFile(table, _useSharedTypes) {
+    const project = createProject();
+    const { typeName, singularName, pluralName } = getTableNames(table);
+    const modelName = `${typeName}Model`;
+    const fileName = `${lcFirst(typeName)}.ts`;
+    const entityLower = singularName;
+    // Type names for this entity
+    const selectTypeName = `${typeName}Select`;
+    const relationTypeName = `${typeName}WithRelations`;
+    const whereTypeName = `${typeName}Filter`;
+    const orderByTypeName = `${typeName}sOrderBy`; // PostGraphile uses plural
+    const createInputTypeName = `Create${typeName}Input`;
+    const updateInputTypeName = `Update${typeName}Input`;
+    const deleteInputTypeName = `Delete${typeName}Input`;
+    const patchTypeName = `${typeName}Patch`;
+    const createDataType = `${createInputTypeName}['${singularName}']`;
+    // Query names from PostGraphile
+    const pluralQueryName = table.query?.all ?? pluralName;
+    const createMutationName = table.query?.create ?? `create${typeName}`;
+    const updateMutationName = table.query?.update;
+    const deleteMutationName = table.query?.delete;
+    const sourceFile = createSourceFile(project, fileName);
+    // Add file header
+    sourceFile.insertText(0, createFileHeader(`${typeName} model for ORM client`) + '\n\n');
+    // Add imports - import types from respective modules
+    sourceFile.addImportDeclarations([
+        createImport({
+            moduleSpecifier: '../client',
+            namedImports: ['OrmClient'],
+        }),
+        createImport({
+            moduleSpecifier: '../query-builder',
+            namedImports: [
+                'QueryBuilder',
+                'buildFindManyDocument',
+                'buildFindFirstDocument',
+                'buildCreateDocument',
+                'buildUpdateDocument',
+                'buildDeleteDocument',
+            ],
+        }),
+        createImport({
+            moduleSpecifier: '../select-types',
+            typeOnlyNamedImports: [
+                'ConnectionResult',
+                'FindManyArgs',
+                'FindFirstArgs',
+                'CreateArgs',
+                'UpdateArgs',
+                'DeleteArgs',
+                'InferSelectResult',
+            ],
+        }),
+    ]);
+    // Build complete set of input-types imports
+    // Select types are now centralized in input-types.ts with relations included
+    const inputTypeImports = new Set([
+        typeName,
+        relationTypeName,
+        selectTypeName,
+        whereTypeName,
+        orderByTypeName,
+        createInputTypeName,
+        updateInputTypeName,
+        patchTypeName,
+    ]);
+    // Add single combined import from input-types
+    sourceFile.addImportDeclaration(createImport({
+        moduleSpecifier: '../input-types',
+        typeOnlyNamedImports: Array.from(inputTypeImports),
+    }));
+    // Add Model class
+    sourceFile.addStatements('\n// ============================================================================');
+    sourceFile.addStatements('// Model Class');
+    sourceFile.addStatements('// ============================================================================\n');
+    // Generate the model class
+    const classDeclaration = sourceFile.addClass({
+        name: modelName,
+        isExported: true,
+    });
+    // Constructor
+    classDeclaration.addConstructor({
+        parameters: [
+            {
+                name: 'client',
+                type: 'OrmClient',
+                scope: 'private',
+            },
+        ],
+    });
+    // findMany method - uses const generic for proper literal type inference
+    classDeclaration.addMethod({
+        name: 'findMany',
+        typeParameters: [`const S extends ${selectTypeName}`],
+        parameters: [
+            {
+                name: 'args',
+                type: `FindManyArgs<S, ${whereTypeName}, ${orderByTypeName}>`,
+                hasQuestionToken: true,
+            },
+        ],
+        returnType: `QueryBuilder<{ ${pluralQueryName}: ConnectionResult<InferSelectResult<${relationTypeName}, S>> }>`,
+        statements: `const { document, variables } = buildFindManyDocument(
+      '${typeName}',
+      '${pluralQueryName}',
+      args?.select,
+      {
+        where: args?.where,
+        orderBy: args?.orderBy as string[] | undefined,
+        first: args?.first,
+        last: args?.last,
+        after: args?.after,
+        before: args?.before,
+        offset: args?.offset,
+      },
+      '${whereTypeName}'
+    );
+    return new QueryBuilder({
+      client: this.client,
+      operation: 'query',
+      operationName: '${typeName}',
+      fieldName: '${pluralQueryName}',
+      document,
+      variables,
+    });`,
+    });
+    // findFirst method - uses const generic for proper literal type inference
+    classDeclaration.addMethod({
+        name: 'findFirst',
+        typeParameters: [`const S extends ${selectTypeName}`],
+        parameters: [
+            {
+                name: 'args',
+                type: `FindFirstArgs<S, ${whereTypeName}>`,
+                hasQuestionToken: true,
+            },
+        ],
+        returnType: `QueryBuilder<{ ${pluralQueryName}: { nodes: InferSelectResult<${relationTypeName}, S>[] } }>`,
+        statements: `const { document, variables } = buildFindFirstDocument(
+      '${typeName}',
+      '${pluralQueryName}',
+      args?.select,
+      { where: args?.where },
+      '${whereTypeName}'
+    );
+    return new QueryBuilder({
+      client: this.client,
+      operation: 'query',
+      operationName: '${typeName}',
+      fieldName: '${pluralQueryName}',
+      document,
+      variables,
+    });`,
+    });
+    // create method - uses const generic for proper literal type inference
+    classDeclaration.addMethod({
+        name: 'create',
+        typeParameters: [`const S extends ${selectTypeName}`],
+        parameters: [
+            {
+                name: 'args',
+                type: `CreateArgs<S, ${createDataType}>`,
+            },
+        ],
+        returnType: `QueryBuilder<{ ${createMutationName}: { ${entityLower}: InferSelectResult<${relationTypeName}, S> } }>`,
+        statements: `const { document, variables } = buildCreateDocument(
+      '${typeName}',
+      '${createMutationName}',
+      '${entityLower}',
+      args.select,
+      args.data,
+      '${createInputTypeName}'
+    );
+    return new QueryBuilder({
+      client: this.client,
+      operation: 'mutation',
+      operationName: '${typeName}',
+      fieldName: '${createMutationName}',
+      document,
+      variables,
+    });`,
+    });
+    // update method (if available) - uses const generic for proper literal type inference
+    if (updateMutationName) {
+        classDeclaration.addMethod({
+            name: 'update',
+            typeParameters: [`const S extends ${selectTypeName}`],
+            parameters: [
+                {
+                    name: 'args',
+                    type: `UpdateArgs<S, { id: string }, ${patchTypeName}>`,
+                },
+            ],
+            returnType: `QueryBuilder<{ ${updateMutationName}: { ${entityLower}: InferSelectResult<${relationTypeName}, S> } }>`,
+            statements: `const { document, variables } = buildUpdateDocument(
+      '${typeName}',
+      '${updateMutationName}',
+      '${entityLower}',
+      args.select,
+      args.where,
+      args.data,
+      '${updateInputTypeName}'
+    );
+    return new QueryBuilder({
+      client: this.client,
+      operation: 'mutation',
+      operationName: '${typeName}',
+      fieldName: '${updateMutationName}',
+      document,
+      variables,
+    });`,
+        });
+    }
+    // delete method (if available)
+    if (deleteMutationName) {
+        classDeclaration.addMethod({
+            name: 'delete',
+            parameters: [
+                {
+                    name: 'args',
+                    type: `DeleteArgs<{ id: string }>`,
+                },
+            ],
+            returnType: `QueryBuilder<{ ${deleteMutationName}: { ${entityLower}: { id: string } } }>`,
+            statements: `const { document, variables } = buildDeleteDocument(
+      '${typeName}',
+      '${deleteMutationName}',
+      '${entityLower}',
+      args.where,
+      '${deleteInputTypeName}'
+    );
+    return new QueryBuilder({
+      client: this.client,
+      operation: 'mutation',
+      operationName: '${typeName}',
+      fieldName: '${deleteMutationName}',
+      document,
+      variables,
+    });`,
+        });
+    }
+    return {
+        fileName,
+        content: getFormattedOutput(sourceFile),
+        modelName,
+        tableName: table.name,
+    };
+}
+// Select types with relations are now generated in input-types.ts
+/**
+ * Generate all model files for a list of tables
+ */
+export function generateAllModelFiles(tables, useSharedTypes) {
+    return tables.map((table) => generateModelFile(table, useSharedTypes));
+}

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

@@ -0,0 +1,161 @@
+/**
+ * Runtime query builder for ORM client
+ *
+ * This module provides the runtime functionality that builds GraphQL
+ * queries/mutations from the fluent API calls and executes them.
+ *
+ * This file will be copied to the generated output (not generated via AST)
+ * since it's runtime code that doesn't change based on schema.
+ */
+import type { QueryResult } from './select-types';
+/**
+ * ORM client configuration
+ */
+export interface OrmClientConfig {
+    endpoint: string;
+    headers?: Record<string, string>;
+}
+/**
+ * Internal client state
+ */
+export declare class OrmClient {
+    private endpoint;
+    private headers;
+    constructor(config: OrmClientConfig);
+    /**
+     * Execute a GraphQL query/mutation
+     */
+    execute<T>(document: string, variables?: Record<string, unknown>): Promise<QueryResult<T>>;
+    /**
+     * Update headers (e.g., for auth token refresh)
+     */
+    setHeaders(headers: Record<string, string>): void;
+    /**
+     * Get current endpoint
+     */
+    getEndpoint(): string;
+}
+/**
+ * Configuration for building a query
+ */
+export interface QueryBuilderConfig {
+    client: OrmClient;
+    operation: 'query' | 'mutation';
+    operationName: string;
+    fieldName: string;
+    document: string;
+    variables?: Record<string, unknown>;
+}
+/**
+ * Query builder that holds the query configuration and executes it
+ *
+ * Usage:
+ * ```typescript
+ * const result = await new QueryBuilder(config).execute();
+ * ```
+ */
+export declare class QueryBuilder<TResult> {
+    private config;
+    constructor(config: QueryBuilderConfig);
+    /**
+     * Execute the query and return the result
+     */
+    execute(): Promise<QueryResult<TResult>>;
+    /**
+     * Get the GraphQL document (useful for debugging)
+     */
+    toGraphQL(): string;
+    /**
+     * Get the variables (useful for debugging)
+     */
+    getVariables(): Record<string, unknown> | undefined;
+}
+/**
+ * Build field selections from a select object
+ *
+ * Converts:
+ * { id: true, name: true, posts: { select: { title: true } } }
+ *
+ * To:
+ * id
+ * name
+ * posts {
+ *   nodes { title }
+ *   totalCount
+ *   pageInfo { hasNextPage hasPreviousPage startCursor endCursor }
+ * }
+ */
+export declare function buildSelections(select: Record<string, unknown> | undefined, fieldMeta?: Record<string, FieldMeta>): string;
+/**
+ * Field metadata for determining connection vs direct relation
+ */
+export interface FieldMeta {
+    isConnection: boolean;
+    isNullable: boolean;
+    typeName: string;
+}
+/**
+ * Build a findMany query document
+ */
+export declare function buildFindManyDocument(operationName: string, queryField: string, select: Record<string, unknown> | undefined, args: {
+    where?: Record<string, unknown>;
+    orderBy?: string[];
+    first?: number;
+    last?: number;
+    after?: string;
+    before?: string;
+    offset?: number;
+}, filterTypeName: string): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+/**
+ * Build a findFirst query document
+ */
+export declare function buildFindFirstDocument(operationName: string, queryField: string, select: Record<string, unknown> | undefined, args: {
+    where?: Record<string, unknown>;
+}, filterTypeName: string): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+/**
+ * Build a create mutation document
+ */
+export declare function buildCreateDocument(operationName: string, mutationField: string, entityField: string, select: Record<string, unknown> | undefined, data: Record<string, unknown>, inputTypeName: string): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+/**
+ * Build an update mutation document
+ */
+export declare function buildUpdateDocument(operationName: string, mutationField: string, entityField: string, select: Record<string, unknown> | undefined, where: Record<string, unknown>, data: Record<string, unknown>, inputTypeName: string): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+/**
+ * Build a delete mutation document
+ */
+export declare function buildDeleteDocument(operationName: string, mutationField: string, entityField: string, where: Record<string, unknown>, inputTypeName: string): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+/**
+ * Build a custom query document
+ */
+export declare function buildCustomQueryDocument(operationName: string, queryField: string, select: Record<string, unknown> | undefined, args: Record<string, unknown> | undefined, variableDefinitions: Array<{
+    name: string;
+    type: string;
+}>): {
+    document: string;
+    variables: Record<string, unknown>;
+};
+/**
+ * Build a custom mutation document
+ */
+export declare function buildCustomMutationDocument(operationName: string, mutationField: string, select: Record<string, unknown> | undefined, args: Record<string, unknown> | undefined, variableDefinitions: Array<{
+    name: string;
+    type: string;
+}>): {
+    document: string;
+    variables: Record<string, unknown>;
+};