@constructive-io/graphql-codegen 2.22.1 → 2.23.0

package/cli/introspect/transform.js

@@ -1,181 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformMetaToCleanTables = transformMetaToCleanTables;
 exports.getTableNames = getTableNames;
 exports.findTable = findTable;
 exports.filterTables = filterTables;
-/**
- * Transform _meta response to CleanTable array
- */
-function transformMetaToCleanTables(metaResponse) {
-    const { tables } = metaResponse._meta;
-    return tables.map((table) => transformTable(table));
-}
-/**
- * Transform a single MetaTable to CleanTable
- */
-function transformTable(table) {
-    return {
-        name: table.name,
-        fields: transformFields(table.fields),
-        relations: transformRelations(table.relations),
-        inflection: transformInflection(table.inflection),
-        query: transformQuery(table.query),
-        constraints: transformConstraints(table),
-    };
-}
-/**
- * Transform MetaField[] to CleanField[]
- */
-function transformFields(fields) {
-    return fields.map((field) => ({
-        name: field.name,
-        type: transformFieldType(field.type),
-    }));
-}
-/**
- * Transform MetaFieldType to CleanFieldType
- */
-function transformFieldType(type) {
-    return {
-        gqlType: type.gqlType,
-        isArray: type.isArray,
-        modifier: type.modifier,
-        pgAlias: type.pgAlias,
-        pgType: type.pgType,
-        subtype: type.subtype,
-        typmod: type.typmod,
-    };
-}
-/**
- * Transform table relations
- */
-function transformRelations(relations) {
-    return {
-        belongsTo: relations.belongsTo.map(transformBelongsTo),
-        hasOne: relations.hasOne.map(transformHasOne),
-        hasMany: relations.hasMany.map(transformHasMany),
-        manyToMany: relations.manyToMany.map(transformManyToMany),
-    };
-}
-/**
- * Transform belongsTo relation
- */
-function transformBelongsTo(rel) {
-    return {
-        fieldName: rel.fieldName,
-        isUnique: rel.isUnique,
-        referencesTable: rel.references.name,
-        type: rel.type,
-        keys: transformFields(rel.keys),
-    };
-}
-/**
- * Transform hasOne relation
- */
-function transformHasOne(rel) {
-    return {
-        fieldName: rel.fieldName,
-        isUnique: rel.isUnique,
-        referencedByTable: rel.referencedBy.name,
-        type: rel.type,
-        keys: transformFields(rel.keys),
-    };
-}
-/**
- * Transform hasMany relation
- */
-function transformHasMany(rel) {
-    return {
-        fieldName: rel.fieldName,
-        isUnique: rel.isUnique,
-        referencedByTable: rel.referencedBy.name,
-        type: rel.type,
-        keys: transformFields(rel.keys),
-    };
-}
-/**
- * Transform manyToMany relation
- */
-function transformManyToMany(rel) {
-    return {
-        fieldName: rel.fieldName,
-        rightTable: rel.rightTable.name,
-        junctionTable: rel.junctionTable.name,
-        type: rel.type,
-    };
-}
-/**
- * Transform inflection data
- */
-function transformInflection(inflection) {
-    return {
-        allRows: inflection.allRows,
-        allRowsSimple: inflection.allRowsSimple,
-        conditionType: inflection.conditionType,
-        connection: inflection.connection,
-        createField: inflection.createField,
-        createInputType: inflection.createInputType,
-        createPayloadType: inflection.createPayloadType,
-        deleteByPrimaryKey: inflection.deleteByPrimaryKey,
-        deletePayloadType: inflection.deletePayloadType,
-        edge: inflection.edge,
-        edgeField: inflection.edgeField,
-        enumType: inflection.enumType,
-        filterType: inflection.filterType,
-        inputType: inflection.inputType,
-        orderByType: inflection.orderByType,
-        patchField: inflection.patchField,
-        patchType: inflection.patchType,
-        tableFieldName: inflection.tableFieldName,
-        tableType: inflection.tableType,
-        typeName: inflection.typeName,
-        updateByPrimaryKey: inflection.updateByPrimaryKey,
-        updatePayloadType: inflection.updatePayloadType,
-    };
-}
-/**
- * Transform query names
- */
-function transformQuery(query) {
-    return {
-        all: query.all,
-        one: query.one,
-        create: query.create,
-        update: query.update,
-        delete: query.delete,
-    };
-}
-/**
- * Transform constraints
- */
-function transformConstraints(table) {
-    return {
-        primaryKey: table.primaryKeyConstraints.map(transformConstraint),
-        foreignKey: table.foreignKeyConstraints.map(transformForeignKeyConstraint),
-        unique: table.uniqueConstraints.map(transformConstraint),
-    };
-}
-/**
- * Transform a basic constraint
- */
-function transformConstraint(constraint) {
-    return {
-        name: constraint.name,
-        fields: transformFields(constraint.fields),
-    };
-}
-/**
- * Transform a foreign key constraint
- */
-function transformForeignKeyConstraint(constraint) {
-    return {
-        name: constraint.name,
-        fields: transformFields(constraint.fields),
-        refTable: constraint.refTable.name,
-        refFields: transformFields(constraint.refFields),
-    };
-}
 /**
  * Get table names from CleanTable array
  */

package/cli/watch/cache.d.ts

@@ -4,11 +4,10 @@
  * Only stores the hash in memory - no file I/O during normal operation.
  * Touch file feature is optional and only writes when explicitly configured.
  */
-import type { MetaQueryResponse } from '../introspect/meta-query';
 import type { IntrospectionQueryResponse } from '../../types/introspection';
 /**
  * Lightweight in-memory schema cache
- * Only stores the combined hash string to detect changes
+ * Only stores the schema hash string to detect changes
  */
 export declare class SchemaCache {
     /** Current schema hash (in-memory only) */
@@ -17,7 +16,7 @@ export declare class SchemaCache {
      * Check if schema has changed by comparing hashes
      * This is the hot path - must be efficient
      */
-    hasChanged(meta: MetaQueryResponse, schema: IntrospectionQueryResponse): Promise<{
+    hasChanged(schema: IntrospectionQueryResponse): Promise<{
         changed: boolean;
         newHash: string;
     }>;
@@ -34,7 +33,7 @@ export declare class SchemaCache {
      */
     clear(): void;
     /**
-     * Compute hash from meta and schema responses
+     * Compute hash from schema response
      */
     private computeHash;
 }

package/cli/watch/cache.js

@@ -46,7 +46,7 @@ const path = __importStar(require("node:path"));
 const hash_1 = require("./hash");
 /**
  * Lightweight in-memory schema cache
- * Only stores the combined hash string to detect changes
+ * Only stores the schema hash string to detect changes
  */
 class SchemaCache {
     /** Current schema hash (in-memory only) */
@@ -55,8 +55,8 @@ class SchemaCache {
      * Check if schema has changed by comparing hashes
      * This is the hot path - must be efficient
      */
-    async hasChanged(meta, schema) {
-        const newHash = await this.computeHash(meta, schema);
+    async hasChanged(schema) {
+        const newHash = await this.computeHash(schema);
         const changed = this.currentHash === null || this.currentHash !== newHash;
         return { changed, newHash };
     }
@@ -79,14 +79,10 @@ class SchemaCache {
         this.currentHash = null;
     }
     /**
-     * Compute hash from meta and schema responses
+     * Compute hash from schema response
      */
-    async computeHash(meta, schema) {
-        // Hash each response separately then combine
-        // This is more efficient than stringifying both together
-        const metaHash = await (0, hash_1.hashObject)(meta);
-        const schemaHash = await (0, hash_1.hashObject)(schema);
-        return (0, hash_1.combineHashes)(metaHash, schemaHash);
+    async computeHash(schema) {
+        return (0, hash_1.hashObject)(schema);
     }
 }
 exports.SchemaCache = SchemaCache;

package/cli/watch/poller.d.ts

@@ -5,7 +5,6 @@
  * No file I/O during normal polling - only touchFile is optional file write.
  */
 import { EventEmitter } from 'node:events';
-import type { MetaQueryResponse } from '../introspect/meta-query';
 import type { IntrospectionQueryResponse } from '../../types/introspection';
 import { SchemaCache } from './cache';
 import type { PollResult, WatchOptions } from './types';
@@ -62,4 +61,4 @@ export declare class SchemaPoller extends EventEmitter {
 /**
  * Utility to compute schema hash without full poll
  */
-export declare function computeSchemaHash(meta: MetaQueryResponse, schema: IntrospectionQueryResponse): Promise<string>;
+export declare function computeSchemaHash(schema: IntrospectionQueryResponse): Promise<string>;

package/cli/watch/poller.js

@@ -9,7 +9,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SchemaPoller = void 0;
 exports.computeSchemaHash = computeSchemaHash;
 const node_events_1 = require("node:events");
-const fetch_meta_1 = require("../introspect/fetch-meta");
 const fetch_schema_1 = require("../introspect/fetch-schema");
 const cache_1 = require("./cache");
 const hash_1 = require("./hash");
@@ -60,39 +59,31 @@ class SchemaPoller extends node_events_1.EventEmitter {
     async poll() {
         // Prevent concurrent polls
         if (this.isPolling) {
-            return { success: false, changed: false, error: 'Poll already in progress' };
+            return {
+                success: false,
+                changed: false,
+                error: 'Poll already in progress',
+            };
         }
         this.isPolling = true;
         const startTime = Date.now();
         this.emit('poll-start', this.createEvent('poll-start'));
         try {
-            // Fetch both _meta and __schema
-            const [metaResult, schemaResult] = await Promise.all([
-                (0, fetch_meta_1.fetchMeta)({
-                    endpoint: this.options.endpoint,
-                    authorization: this.options.authorization,
-                    headers: this.options.headers,
-                    timeout: 30000,
-                }),
-                (0, fetch_schema_1.fetchSchema)({
-                    endpoint: this.options.endpoint,
-                    authorization: this.options.authorization,
-                    headers: this.options.headers,
-                    timeout: 30000,
-                }),
-            ]);
+            // Fetch __schema via standard introspection
+            const schemaResult = await (0, fetch_schema_1.fetchSchema)({
+                endpoint: this.options.endpoint,
+                authorization: this.options.authorization,
+                headers: this.options.headers,
+                timeout: 30000,
+            });
             const duration = Date.now() - startTime;
             // Check for errors
-            if (!metaResult.success) {
-                return this.handleError(`_meta fetch failed: ${metaResult.error}`, duration);
-            }
             if (!schemaResult.success) {
                 return this.handleError(`__schema fetch failed: ${schemaResult.error}`, duration);
             }
-            const meta = metaResult.data;
             const schema = schemaResult.data;
             // Check if schema changed
-            const { changed, newHash } = await this.cache.hasChanged(meta, schema);
+            const { changed, newHash } = await this.cache.hasChanged(schema);
             // Reset error counter on success
             this.consecutiveErrors = 0;
             if (changed) {
@@ -103,11 +94,11 @@ class SchemaPoller extends node_events_1.EventEmitter {
                     (0, cache_1.touchFile)(this.options.touchFile);
                 }
                 this.emit('schema-changed', this.createEvent('schema-changed', { hash: newHash, duration }));
-                return { success: true, changed: true, hash: newHash, meta, schema };
+                return { success: true, changed: true, hash: newHash, schema };
             }
             this.emit('schema-unchanged', this.createEvent('schema-unchanged', { duration }));
             this.emit('poll-success', this.createEvent('poll-success', { duration }));
-            return { success: true, changed: false, hash: newHash, meta, schema };
+            return { success: true, changed: false, hash: newHash, schema };
         }
         catch (err) {
             const duration = Date.now() - startTime;
@@ -130,22 +121,14 @@ class SchemaPoller extends node_events_1.EventEmitter {
      */
     async seedCache() {
         try {
-            const [metaResult, schemaResult] = await Promise.all([
-                (0, fetch_meta_1.fetchMeta)({
-                    endpoint: this.options.endpoint,
-                    authorization: this.options.authorization,
-                    headers: this.options.headers,
-                    timeout: 30000,
-                }),
-                (0, fetch_schema_1.fetchSchema)({
-                    endpoint: this.options.endpoint,
-                    authorization: this.options.authorization,
-                    headers: this.options.headers,
-                    timeout: 30000,
-                }),
-            ]);
-            if (metaResult.success && schemaResult.success) {
-                const { newHash } = await this.cache.hasChanged(metaResult.data, schemaResult.data);
+            const schemaResult = await (0, fetch_schema_1.fetchSchema)({
+                endpoint: this.options.endpoint,
+                authorization: this.options.authorization,
+                headers: this.options.headers,
+                timeout: 30000,
+            });
+            if (schemaResult.success) {
+                const { newHash } = await this.cache.hasChanged(schemaResult.data);
                 this.cache.updateHash(newHash);
             }
         }
@@ -175,7 +158,8 @@ class SchemaPoller extends node_events_1.EventEmitter {
         this.consecutiveErrors++;
         this.emit('poll-error', this.createEvent('poll-error', { error, duration }));
         // Slow down polling after multiple consecutive errors
-        if (this.consecutiveErrors >= this.MAX_CONSECUTIVE_ERRORS && this.pollTimer) {
+        if (this.consecutiveErrors >= this.MAX_CONSECUTIVE_ERRORS &&
+            this.pollTimer) {
             this.stop();
             const newInterval = this.options.pollInterval * 2;
             this.pollTimer = setInterval(() => {
@@ -196,8 +180,6 @@ exports.SchemaPoller = SchemaPoller;
 /**
  * Utility to compute schema hash without full poll
  */
-async function computeSchemaHash(meta, schema) {
-    const metaHash = await (0, hash_1.hashObject)(meta);
-    const schemaHash = await (0, hash_1.hashObject)(schema);
-    return (0, hash_1.combineHashes)(metaHash, schemaHash);
+async function computeSchemaHash(schema) {
+    return (0, hash_1.hashObject)(schema);
 }

package/cli/watch/types.d.ts

@@ -1,7 +1,6 @@
 /**
  * Watch mode types
  */
-import type { MetaQueryResponse } from '../introspect/meta-query';
 import type { IntrospectionQueryResponse } from '../../types/introspection';
 /**
  * Result of a schema poll operation
@@ -14,8 +13,6 @@ export interface PollResult {
     error?: string;
     /** The new hash if successful */
     hash?: string;
-    /** Meta response if successful */
-    meta?: MetaQueryResponse;
     /** Schema response if successful */
     schema?: IntrospectionQueryResponse;
 }

package/esm/cli/codegen/barrel.d.ts

@@ -19,7 +19,11 @@ export declare function generateMutationsBarrel(tables: CleanTable[]): string;
  * @param tables - The tables to include in the SDK
  * @param hasSchemaTypes - Whether schema-types.ts was generated
  */
-export declare function generateMainBarrel(tables: CleanTable[], hasSchemaTypes?: boolean): string;
+export interface MainBarrelOptions {
+    hasSchemaTypes?: boolean;
+    hasMutations?: boolean;
+}
+export declare function generateMainBarrel(tables: CleanTable[], options?: MainBarrelOptions | boolean): string;
 /**
  * Generate queries barrel including custom query operations
  */

package/esm/cli/codegen/barrel.js

@@ -39,18 +39,23 @@ export function generateMutationsBarrel(tables) {
     }
     return lines.join('\n') + '\n';
 }
-/**
- * Generate the main index.ts barrel file
- *
- * @param tables - The tables to include in the SDK
- * @param hasSchemaTypes - Whether schema-types.ts was generated
- */
-export function generateMainBarrel(tables, hasSchemaTypes = false) {
+export function generateMainBarrel(tables, options = {}) {
+    // Support legacy signature where second arg was just hasSchemaTypes boolean
+    const opts = typeof options === 'boolean'
+        ? { hasSchemaTypes: options, hasMutations: true }
+        : options;
+    const { hasSchemaTypes = false, hasMutations = true } = opts;
     const tableNames = tables.map((t) => t.name).join(', ');
     const schemaTypesExport = hasSchemaTypes
         ? `
 // Schema types (input, payload, enum types)
 export * from './schema-types';
+`
+        : '';
+    const mutationsExport = hasMutations
+        ? `
+// Mutation hooks
+export * from './mutations';
 `
         : '';
     return `/**
@@ -91,10 +96,7 @@ export * from './types';
 ${schemaTypesExport}
 // Query hooks
 export * from './queries';
-
-// Mutation hooks
-export * from './mutations';
-`;
+${mutationsExport}`;
 }
 // ============================================================================
 // Custom operation barrels (includes both table and custom hooks)

package/esm/cli/codegen/index.d.ts

@@ -64,8 +64,8 @@ export declare function generateAllFiles(tables: CleanTable[], config: ResolvedC
 export declare function generate(options: GenerateOptions): GenerateResult;
 export { generateClientFile } from './client';
 export { generateTypesFile } from './types';
-export { generateAllQueryHooks, generateListQueryHook, generateSingleQueryHook } from './queries';
+export { generateAllQueryHooks, generateListQueryHook, generateSingleQueryHook, } from './queries';
 export { generateAllMutationHooks, generateCreateMutationHook, generateUpdateMutationHook, generateDeleteMutationHook, } from './mutations';
-export { generateAllCustomQueryHooks, generateCustomQueryHook } from './custom-queries';
-export { generateAllCustomMutationHooks, generateCustomMutationHook } from './custom-mutations';
+export { generateAllCustomQueryHooks, generateCustomQueryHook, } from './custom-queries';
+export { generateAllCustomMutationHooks, generateCustomMutationHook, } from './custom-mutations';
 export { generateQueriesBarrel, generateMutationsBarrel, generateMainBarrel, generateCustomQueriesBarrel, generateCustomMutationsBarrel, } from './barrel';

package/esm/cli/codegen/index.js

@@ -55,7 +55,9 @@ export function generate(options) {
     // 3. Generate types.ts (can now import enums from schema-types)
     files.push({
         path: 'types.ts',
-        content: generateTypesFile(tables, { enumsFromSchemaTypes: generatedEnumNames }),
+        content: generateTypesFile(tables, {
+            enumsFromSchemaTypes: generatedEnumNames,
+        }),
     });
     // 4. Generate table-based query hooks (queries/*.ts)
     const queryHooks = generateAllQueryHooks(tables, { reactQueryEnabled });
@@ -119,17 +121,21 @@ export function generate(options) {
             });
         }
     }
-    // 8. Generate mutations/index.ts barrel (includes both table and custom mutations)
-    files.push({
-        path: 'mutations/index.ts',
-        content: customMutationHooks.length > 0
-            ? generateCustomMutationsBarrel(tables, customMutationHooks.map((h) => h.operationName))
-            : generateMutationsBarrel(tables),
-    });
+    // 8. Generate mutations/index.ts barrel (only if React Query is enabled)
+    // When reactQuery is disabled, no mutation hooks are generated, so skip the barrel
+    const hasMutations = mutationHooks.length > 0 || customMutationHooks.length > 0;
+    if (hasMutations) {
+        files.push({
+            path: 'mutations/index.ts',
+            content: customMutationHooks.length > 0
+                ? generateCustomMutationsBarrel(tables, customMutationHooks.map((h) => h.operationName))
+                : generateMutationsBarrel(tables),
+        });
+    }
     // 9. Generate main index.ts barrel (with schema-types if present)
     files.push({
         path: 'index.ts',
-        content: generateMainBarrel(tables, hasSchemaTypes),
+        content: generateMainBarrel(tables, { hasSchemaTypes, hasMutations }),
     });
     return {
         files,
@@ -148,8 +154,8 @@ export function generate(options) {
 // ============================================================================
 export { generateClientFile } from './client';
 export { generateTypesFile } from './types';
-export { generateAllQueryHooks, generateListQueryHook, generateSingleQueryHook } from './queries';
+export { generateAllQueryHooks, generateListQueryHook, generateSingleQueryHook, } from './queries';
 export { generateAllMutationHooks, generateCreateMutationHook, generateUpdateMutationHook, generateDeleteMutationHook, } from './mutations';
-export { generateAllCustomQueryHooks, generateCustomQueryHook } from './custom-queries';
-export { generateAllCustomMutationHooks, generateCustomMutationHook } from './custom-mutations';
+export { generateAllCustomQueryHooks, generateCustomQueryHook, } from './custom-queries';
+export { generateAllCustomMutationHooks, generateCustomMutationHook, } from './custom-mutations';
 export { generateQueriesBarrel, generateMutationsBarrel, generateMainBarrel, generateCustomQueriesBarrel, generateCustomMutationsBarrel, } from './barrel';

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

@@ -276,7 +276,8 @@ export function buildFindManyDocument<TSelect, TWhere>(
     before?: string;
     offset?: number;
   },
-  filterTypeName: string
+  filterTypeName: string,
+  orderByTypeName: string
 ): { document: string; variables: Record<string, unknown> } {
   const selections = select ? buildSelections(select) : 'id';
 
@@ -290,7 +291,7 @@ export function buildFindManyDocument<TSelect, TWhere>(
     variables.where = args.where;
   }
   if (args.orderBy?.length) {
-    varDefs.push(\`$orderBy: [\${operationName}sOrderBy!]\`);
+    varDefs.push(\`$orderBy: [\${orderByTypeName}!]\`);
     queryArgs.push('orderBy: $orderBy');
     variables.orderBy = args.orderBy;
   }

package/esm/cli/codegen/orm/custom-ops-generator.js

@@ -1,16 +1,21 @@
 import { createProject, createSourceFile, getFormattedOutput, createFileHeader, createImport, } from '../ts-ast';
 import { ucFirst } from '../utils';
-import { typeRefToTsType, isTypeRequired, getTypeBaseName } from '../type-resolver';
+import { typeRefToTsType, isTypeRequired, getTypeBaseName, } from '../type-resolver';
 import { SCALAR_NAMES } from '../scalars';
 /**
  * Collect all input type names used by operations
+ * Includes Input, Filter, OrderBy, and Condition types
  */
 function collectInputTypeNamesFromOps(operations) {
     const inputTypes = new Set();
     for (const op of operations) {
         for (const arg of op.args) {
             const baseName = getTypeBaseName(arg.type);
-            if (baseName && (baseName.endsWith('Input') || baseName.endsWith('Filter'))) {
+            if (baseName &&
+                (baseName.endsWith('Input') ||
+                    baseName.endsWith('Filter') ||
+                    baseName.endsWith('OrderBy') ||
+                    baseName.endsWith('Condition'))) {
                 inputTypes.add(baseName);
             }
         }
@@ -18,7 +23,11 @@ function collectInputTypeNamesFromOps(operations) {
     return Array.from(inputTypes);
 }
 // Types that don't need Select types
-const NON_SELECT_TYPES = new Set([...SCALAR_NAMES, 'Query', 'Mutation']);
+const NON_SELECT_TYPES = new Set([
+    ...SCALAR_NAMES,
+    'Query',
+    'Mutation',
+]);
 /**
  * Collect all payload/return type names from operations (for Select types)
  * Filters out scalar types
@@ -64,7 +73,9 @@ export function generateCustomQueryOpsFile(operations) {
     // Generate Select type names for payloads
     const selectTypeNames = payloadTypeNames.map((p) => `${p}Select`);
     // Combine all type imports
-    const allTypeImports = [...new Set([...inputTypeNames, ...payloadTypeNames, ...selectTypeNames])];
+    const allTypeImports = [
+        ...new Set([...inputTypeNames, ...payloadTypeNames, ...selectTypeNames]),
+    ];
     // Add file header
     sourceFile.insertText(0, createFileHeader('Custom query operations') + '\n\n');
     // Add imports
@@ -197,7 +208,9 @@ export function generateCustomMutationOpsFile(operations) {
     // Generate Select type names for payloads
     const selectTypeNames = payloadTypeNames.map((p) => `${p}Select`);
     // Combine all type imports
-    const allTypeImports = [...new Set([...inputTypeNames, ...payloadTypeNames, ...selectTypeNames])];
+    const allTypeImports = [
+        ...new Set([...inputTypeNames, ...payloadTypeNames, ...selectTypeNames]),
+    ];
     // Add file header
     sourceFile.insertText(0, createFileHeader('Custom mutation operations') + '\n\n');
     // Add imports