@constructive-io/graphql-codegen 2.24.0 → 2.24.1

package/cli/codegen/queries.js

@@ -72,6 +72,7 @@ function generateListQueryHook(table, options = {}) {
     const hookName = (0, utils_1.getListQueryHookName)(table);
     const queryName = (0, utils_1.getAllRowsQueryName)(table);
     const filterTypeName = (0, utils_1.getFilterTypeName)(table);
+    const conditionTypeName = (0, utils_1.getConditionTypeName)(table);
     const orderByTypeName = (0, utils_1.getOrderByTypeName)(table);
     const scalarFields = (0, utils_1.getScalarFields)(table);
     const keysName = `${(0, utils_1.lcFirst)(typeName)}Keys`;
@@ -136,6 +137,59 @@ function generateListQueryHook(table, options = {}) {
     })
         .filter((f) => f !== null);
     statements.push(createFilterInterfaceDeclaration(filterTypeName, fieldFilters, false));
+    // Generate Condition interface (simple equality filter with scalar types)
+    // Track non-primitive types (enums) that need to be imported
+    const enumTypesUsed = new Set();
+    const conditionProperties = scalarFields.map((field) => {
+        const tsType = (0, utils_1.fieldTypeToTs)(field.type);
+        const isPrimitive = tsType === 'string' ||
+            tsType === 'number' ||
+            tsType === 'boolean' ||
+            tsType === 'unknown' ||
+            tsType.endsWith('[]');
+        let typeAnnotation;
+        if (field.type.isArray) {
+            const baseType = tsType.replace('[]', '');
+            const isBasePrimitive = baseType === 'string' ||
+                baseType === 'number' ||
+                baseType === 'boolean' ||
+                baseType === 'unknown';
+            if (!isBasePrimitive) {
+                enumTypesUsed.add(baseType);
+            }
+            typeAnnotation = t.tsArrayType(baseType === 'string'
+                ? t.tsStringKeyword()
+                : baseType === 'number'
+                    ? t.tsNumberKeyword()
+                    : baseType === 'boolean'
+                        ? t.tsBooleanKeyword()
+                        : t.tsTypeReference(t.identifier(baseType)));
+        }
+        else {
+            if (!isPrimitive) {
+                enumTypesUsed.add(tsType);
+            }
+            typeAnnotation =
+                tsType === 'string'
+                    ? t.tsStringKeyword()
+                    : tsType === 'number'
+                        ? t.tsNumberKeyword()
+                        : tsType === 'boolean'
+                            ? t.tsBooleanKeyword()
+                            : t.tsTypeReference(t.identifier(tsType));
+        }
+        const prop = t.tsPropertySignature(t.identifier(field.name), t.tsTypeAnnotation(typeAnnotation));
+        prop.optional = true;
+        return prop;
+    });
+    // Add import for enum types if any are used
+    if (enumTypesUsed.size > 0) {
+        const schemaTypesImport = t.importDeclaration(Array.from(enumTypesUsed).map((et) => t.importSpecifier(t.identifier(et), t.identifier(et))), t.stringLiteral('../schema-types'));
+        schemaTypesImport.importKind = 'type';
+        statements.push(schemaTypesImport);
+    }
+    const conditionInterface = t.tsInterfaceDeclaration(t.identifier(conditionTypeName), null, null, t.tsInterfaceBody(conditionProperties));
+    statements.push(conditionInterface);
     const orderByValues = [
         ...scalarFields.flatMap((f) => [
             `${(0, utils_1.toScreamingSnake)(f.name)}_ASC`,
@@ -153,16 +207,36 @@ function generateListQueryHook(table, options = {}) {
             p.optional = true;
             return p;
         })(),
+        (() => {
+            const p = t.tsPropertySignature(t.identifier('last'), t.tsTypeAnnotation(t.tsNumberKeyword()));
+            p.optional = true;
+            return p;
+        })(),
         (() => {
             const p = t.tsPropertySignature(t.identifier('offset'), t.tsTypeAnnotation(t.tsNumberKeyword()));
             p.optional = true;
             return p;
         })(),
+        (() => {
+            const p = t.tsPropertySignature(t.identifier('before'), t.tsTypeAnnotation(t.tsStringKeyword()));
+            p.optional = true;
+            return p;
+        })(),
+        (() => {
+            const p = t.tsPropertySignature(t.identifier('after'), t.tsTypeAnnotation(t.tsStringKeyword()));
+            p.optional = true;
+            return p;
+        })(),
         (() => {
             const p = t.tsPropertySignature(t.identifier('filter'), t.tsTypeAnnotation(t.tsTypeReference(t.identifier(filterTypeName))));
             p.optional = true;
             return p;
         })(),
+        (() => {
+            const p = t.tsPropertySignature(t.identifier('condition'), t.tsTypeAnnotation(t.tsTypeReference(t.identifier(conditionTypeName))));
+            p.optional = true;
+            return p;
+        })(),
         (() => {
             const p = t.tsPropertySignature(t.identifier('orderBy'), t.tsTypeAnnotation(t.tsArrayType(t.tsTypeReference(t.identifier(orderByTypeName)))));
             p.optional = true;
@@ -222,9 +296,9 @@ function generateListQueryHook(table, options = {}) {
             hookBodyStatements.push(t.returnStatement(t.callExpression(t.identifier('useQuery'), [
                 t.objectExpression([
                     t.objectProperty(t.identifier('queryKey'), t.callExpression(t.memberExpression(t.identifier(keysName), t.identifier('list')), [t.identifier('variables'), t.identifier('scope')])),
-                    t.objectProperty(t.identifier('queryFn'), t.arrowFunctionExpression([], t.callExpression(t.identifier('execute'), [
-                        t.identifier(`${queryName}QueryDocument`),
-                        t.identifier('variables'),
+                    t.objectProperty(t.identifier('queryFn'), t.arrowFunctionExpression([], (0, babel_ast_1.createTypedCallExpression)(t.identifier('execute'), [t.identifier(`${queryName}QueryDocument`), t.identifier('variables')], [
+                        t.tsTypeReference(t.identifier(`${(0, utils_1.ucFirst)(pluralName)}QueryResult`)),
+                        t.tsTypeReference(t.identifier(`${(0, utils_1.ucFirst)(pluralName)}QueryVariables`)),
                     ]))),
                     t.spreadElement(t.identifier('queryOptions')),
                 ]),
@@ -234,9 +308,9 @@ function generateListQueryHook(table, options = {}) {
             hookBodyStatements.push(t.returnStatement(t.callExpression(t.identifier('useQuery'), [
                 t.objectExpression([
                     t.objectProperty(t.identifier('queryKey'), t.callExpression(t.memberExpression(t.identifier(keysName), t.identifier('list')), [t.identifier('variables')])),
-                    t.objectProperty(t.identifier('queryFn'), t.arrowFunctionExpression([], t.callExpression(t.identifier('execute'), [
-                        t.identifier(`${queryName}QueryDocument`),
-                        t.identifier('variables'),
+                    t.objectProperty(t.identifier('queryFn'), t.arrowFunctionExpression([], (0, babel_ast_1.createTypedCallExpression)(t.identifier('execute'), [t.identifier(`${queryName}QueryDocument`), t.identifier('variables')], [
+                        t.tsTypeReference(t.identifier(`${(0, utils_1.ucFirst)(pluralName)}QueryResult`)),
+                        t.tsTypeReference(t.identifier(`${(0, utils_1.ucFirst)(pluralName)}QueryVariables`)),
                     ]))),
                     t.spreadElement(t.identifier('options')),
                 ]),
@@ -248,9 +322,9 @@ function generateListQueryHook(table, options = {}) {
                     t.objectProperty(t.identifier('queryKey'), t.callExpression(t.identifier(`${queryName}QueryKey`), [
                         t.identifier('variables'),
                     ])),
-                    t.objectProperty(t.identifier('queryFn'), t.arrowFunctionExpression([], t.callExpression(t.identifier('execute'), [
-                        t.identifier(`${queryName}QueryDocument`),
-                        t.identifier('variables'),
+                    t.objectProperty(t.identifier('queryFn'), t.arrowFunctionExpression([], (0, babel_ast_1.createTypedCallExpression)(t.identifier('execute'), [t.identifier(`${queryName}QueryDocument`), t.identifier('variables')], [
+                        t.tsTypeReference(t.identifier(`${(0, utils_1.ucFirst)(pluralName)}QueryResult`)),
+                        t.tsTypeReference(t.identifier(`${(0, utils_1.ucFirst)(pluralName)}QueryVariables`)),
                     ]))),
                     t.spreadElement(t.identifier('options')),
                 ]),
@@ -298,10 +372,9 @@ function generateListQueryHook(table, options = {}) {
         statements.push(hookExport);
     }
     const fetchFuncBody = t.blockStatement([
-        t.returnStatement(t.callExpression(t.identifier('execute'), [
-            t.identifier(`${queryName}QueryDocument`),
-            t.identifier('variables'),
-            t.identifier('options'),
+        t.returnStatement((0, babel_ast_1.createTypedCallExpression)(t.identifier('execute'), [t.identifier(`${queryName}QueryDocument`), t.identifier('variables'), t.identifier('options')], [
+            t.tsTypeReference(t.identifier(`${(0, utils_1.ucFirst)(pluralName)}QueryResult`)),
+            t.tsTypeReference(t.identifier(`${(0, utils_1.ucFirst)(pluralName)}QueryVariables`)),
         ])),
     ]);
     const fetchFunc = t.functionDeclaration(t.identifier(`fetch${(0, utils_1.ucFirst)(pluralName)}Query`), [
@@ -352,10 +425,9 @@ function generateListQueryHook(table, options = {}) {
             t.expressionStatement(t.awaitExpression(t.callExpression(t.memberExpression(t.identifier('queryClient'), t.identifier('prefetchQuery')), [
                 t.objectExpression([
                     t.objectProperty(t.identifier('queryKey'), prefetchQueryKeyExpr),
-                    t.objectProperty(t.identifier('queryFn'), t.arrowFunctionExpression([], t.callExpression(t.identifier('execute'), [
-                        t.identifier(`${queryName}QueryDocument`),
-                        t.identifier('variables'),
-                        t.identifier('options'),
+                    t.objectProperty(t.identifier('queryFn'), t.arrowFunctionExpression([], (0, babel_ast_1.createTypedCallExpression)(t.identifier('execute'), [t.identifier(`${queryName}QueryDocument`), t.identifier('variables'), t.identifier('options')], [
+                        t.tsTypeReference(t.identifier(`${(0, utils_1.ucFirst)(pluralName)}QueryResult`)),
+                        t.tsTypeReference(t.identifier(`${(0, utils_1.ucFirst)(pluralName)}QueryVariables`)),
                     ]))),
                 ]),
             ]))),
@@ -385,6 +457,10 @@ function generateListQueryHook(table, options = {}) {
     };
 }
 function generateSingleQueryHook(table, options = {}) {
+    // Skip tables with composite keys - they are handled as custom queries
+    if (!(0, utils_1.hasValidPrimaryKey)(table)) {
+        return null;
+    }
     const { reactQueryEnabled = true, useCentralizedKeys = true, hasRelationships = false, } = options;
     const { typeName, singularName } = (0, utils_1.getTableNames)(table);
     const hookName = (0, utils_1.getSingleQueryHookName)(table);
@@ -492,9 +568,9 @@ function generateSingleQueryHook(table, options = {}) {
                         t.memberExpression(t.identifier('variables'), t.identifier(pkName)),
                         t.identifier('scope'),
                     ])),
-                    t.objectProperty(t.identifier('queryFn'), t.arrowFunctionExpression([], t.callExpression(t.identifier('execute'), [
-                        t.identifier(`${queryName}QueryDocument`),
-                        t.identifier('variables'),
+                    t.objectProperty(t.identifier('queryFn'), t.arrowFunctionExpression([], (0, babel_ast_1.createTypedCallExpression)(t.identifier('execute'), [t.identifier(`${queryName}QueryDocument`), t.identifier('variables')], [
+                        t.tsTypeReference(t.identifier(`${(0, utils_1.ucFirst)(singularName)}QueryResult`)),
+                        t.tsTypeReference(t.identifier(`${(0, utils_1.ucFirst)(singularName)}QueryVariables`)),
                     ]))),
                     t.spreadElement(t.identifier('queryOptions')),
                 ]),
@@ -506,9 +582,9 @@ function generateSingleQueryHook(table, options = {}) {
                     t.objectProperty(t.identifier('queryKey'), t.callExpression(t.memberExpression(t.identifier(keysName), t.identifier('detail')), [
                         t.memberExpression(t.identifier('variables'), t.identifier(pkName)),
                     ])),
-                    t.objectProperty(t.identifier('queryFn'), t.arrowFunctionExpression([], t.callExpression(t.identifier('execute'), [
-                        t.identifier(`${queryName}QueryDocument`),
-                        t.identifier('variables'),
+                    t.objectProperty(t.identifier('queryFn'), t.arrowFunctionExpression([], (0, babel_ast_1.createTypedCallExpression)(t.identifier('execute'), [t.identifier(`${queryName}QueryDocument`), t.identifier('variables')], [
+                        t.tsTypeReference(t.identifier(`${(0, utils_1.ucFirst)(singularName)}QueryResult`)),
+                        t.tsTypeReference(t.identifier(`${(0, utils_1.ucFirst)(singularName)}QueryVariables`)),
                     ]))),
                     t.spreadElement(t.identifier('options')),
                 ]),
@@ -520,9 +596,9 @@ function generateSingleQueryHook(table, options = {}) {
                     t.objectProperty(t.identifier('queryKey'), t.callExpression(t.identifier(`${queryName}QueryKey`), [
                         t.memberExpression(t.identifier('variables'), t.identifier(pkName)),
                     ])),
-                    t.objectProperty(t.identifier('queryFn'), t.arrowFunctionExpression([], t.callExpression(t.identifier('execute'), [
-                        t.identifier(`${queryName}QueryDocument`),
-                        t.identifier('variables'),
+                    t.objectProperty(t.identifier('queryFn'), t.arrowFunctionExpression([], (0, babel_ast_1.createTypedCallExpression)(t.identifier('execute'), [t.identifier(`${queryName}QueryDocument`), t.identifier('variables')], [
+                        t.tsTypeReference(t.identifier(`${(0, utils_1.ucFirst)(singularName)}QueryResult`)),
+                        t.tsTypeReference(t.identifier(`${(0, utils_1.ucFirst)(singularName)}QueryVariables`)),
                     ]))),
                     t.spreadElement(t.identifier('options')),
                 ]),
@@ -566,10 +642,9 @@ function generateSingleQueryHook(table, options = {}) {
         statements.push(hookExport);
     }
     const fetchFuncBody = t.blockStatement([
-        t.returnStatement(t.callExpression(t.identifier('execute'), [
-            t.identifier(`${queryName}QueryDocument`),
-            t.identifier('variables'),
-            t.identifier('options'),
+        t.returnStatement((0, babel_ast_1.createTypedCallExpression)(t.identifier('execute'), [t.identifier(`${queryName}QueryDocument`), t.identifier('variables'), t.identifier('options')], [
+            t.tsTypeReference(t.identifier(`${(0, utils_1.ucFirst)(singularName)}QueryResult`)),
+            t.tsTypeReference(t.identifier(`${(0, utils_1.ucFirst)(singularName)}QueryVariables`)),
         ])),
     ]);
     const fetchFunc = t.functionDeclaration(t.identifier(`fetch${(0, utils_1.ucFirst)(singularName)}Query`), [
@@ -616,10 +691,9 @@ function generateSingleQueryHook(table, options = {}) {
             t.expressionStatement(t.awaitExpression(t.callExpression(t.memberExpression(t.identifier('queryClient'), t.identifier('prefetchQuery')), [
                 t.objectExpression([
                     t.objectProperty(t.identifier('queryKey'), prefetchQueryKeyExpr),
-                    t.objectProperty(t.identifier('queryFn'), t.arrowFunctionExpression([], t.callExpression(t.identifier('execute'), [
-                        t.identifier(`${queryName}QueryDocument`),
-                        t.identifier('variables'),
-                        t.identifier('options'),
+                    t.objectProperty(t.identifier('queryFn'), t.arrowFunctionExpression([], (0, babel_ast_1.createTypedCallExpression)(t.identifier('execute'), [t.identifier(`${queryName}QueryDocument`), t.identifier('variables'), t.identifier('options')], [
+                        t.tsTypeReference(t.identifier(`${(0, utils_1.ucFirst)(singularName)}QueryResult`)),
+                        t.tsTypeReference(t.identifier(`${(0, utils_1.ucFirst)(singularName)}QueryVariables`)),
                     ]))),
                 ]),
             ]))),
@@ -652,7 +726,10 @@ function generateAllQueryHooks(tables, options = {}) {
     const files = [];
     for (const table of tables) {
         files.push(generateListQueryHook(table, options));
-        files.push(generateSingleQueryHook(table, options));
+        const singleHook = generateSingleQueryHook(table, options);
+        if (singleHook) {
+            files.push(singleHook);
+        }
     }
     return files;
 }

package/cli/codegen/utils.d.ts

@@ -171,6 +171,12 @@ export declare function getPrimaryKeyInfo(table: CleanTable): PrimaryKeyField[];
  * Get primary key field names (convenience wrapper)
  */
 export declare function getPrimaryKeyFields(table: CleanTable): string[];
+/**
+ * Check if table has a valid single-field primary key
+ * Used to determine if a single query hook can be generated
+ * Tables with composite keys return false (handled as custom queries)
+ */
+export declare function hasValidPrimaryKey(table: CleanTable): boolean;
 /**
  * Generate query key prefix for a table
  * e.g., "cars" for list queries, "car" for detail queries

package/cli/codegen/utils.js

@@ -35,6 +35,7 @@ exports.isRelationField = isRelationField;
 exports.getScalarFields = getScalarFields;
 exports.getPrimaryKeyInfo = getPrimaryKeyInfo;
 exports.getPrimaryKeyFields = getPrimaryKeyFields;
+exports.hasValidPrimaryKey = hasValidPrimaryKey;
 exports.getQueryKeyPrefix = getQueryKeyPrefix;
 exports.getGeneratedFileHeader = getGeneratedFileHeader;
 exports.indent = indent;
@@ -331,6 +332,24 @@ function getPrimaryKeyInfo(table) {
 function getPrimaryKeyFields(table) {
     return getPrimaryKeyInfo(table).map((pk) => pk.name);
 }
+/**
+ * Check if table has a valid single-field primary key
+ * Used to determine if a single query hook can be generated
+ * Tables with composite keys return false (handled as custom queries)
+ */
+function hasValidPrimaryKey(table) {
+    // Check for explicit primary key constraint with single field
+    const pk = table.constraints?.primaryKey?.[0];
+    if (pk && pk.fields.length === 1) {
+        return true;
+    }
+    // Check for 'id' field as fallback
+    const idField = table.fields.find((f) => f.name.toLowerCase() === 'id');
+    if (idField) {
+        return true;
+    }
+    return false;
+}
 // ============================================================================
 // Query key generation
 // ============================================================================

package/esm/cli/codegen/babel-ast.d.ts

@@ -44,3 +44,10 @@ export declare function typedParam(name: string, typeAnnotation: t.TSType, optio
  * Create keyof typeof expression - complex nested type operators
  */
 export declare function keyofTypeof(name: string): t.TSTypeOperator;
+/**
+ * Create a call expression with TypeScript type parameters
+ *
+ * This is used to generate typed function calls like:
+ * execute<ResultType, VariablesType>(document, variables)
+ */
+export declare function createTypedCallExpression(callee: t.Expression, args: (t.Expression | t.SpreadElement)[], typeParams: t.TSType[]): t.CallExpression;

package/esm/cli/codegen/babel-ast.js

@@ -95,3 +95,17 @@ export function keyofTypeof(name) {
     keyofOp.operator = 'keyof';
     return keyofOp;
 }
+/**
+ * Create a call expression with TypeScript type parameters
+ *
+ * This is used to generate typed function calls like:
+ * execute<ResultType, VariablesType>(document, variables)
+ */
+export function createTypedCallExpression(callee, args, typeParams) {
+    const call = t.callExpression(callee, args);
+    if (typeParams.length > 0) {
+        // @ts-ignore - Babel types support typeParameters on CallExpression for TS
+        call.typeParameters = t.tsTypeParameterInstantiation(typeParams);
+    }
+    return call;
+}

package/esm/cli/codegen/barrel.js

@@ -1,6 +1,6 @@
 import * as t from '@babel/types';
 import { generateCode, addJSDocComment } from './babel-ast';
-import { getListQueryHookName, getSingleQueryHookName, getCreateMutationHookName, getUpdateMutationHookName, getDeleteMutationHookName, } from './utils';
+import { getListQueryHookName, getSingleQueryHookName, getCreateMutationHookName, getUpdateMutationHookName, getDeleteMutationHookName, hasValidPrimaryKey, } from './utils';
 import { getOperationHookName } from './type-resolver';
 /**
  * Helper to create export * from './module' statement
@@ -16,9 +16,12 @@ export function generateQueriesBarrel(tables) {
     // Export all query hooks
     for (const table of tables) {
         const listHookName = getListQueryHookName(table);
-        const singleHookName = getSingleQueryHookName(table);
         statements.push(exportAllFrom(`./${listHookName}`));
-        statements.push(exportAllFrom(`./${singleHookName}`));
+        // Only export single query hook if table has valid primary key
+        if (hasValidPrimaryKey(table)) {
+            const singleHookName = getSingleQueryHookName(table);
+            statements.push(exportAllFrom(`./${singleHookName}`));
+        }
     }
     // Add file header as leading comment on first statement
     if (statements.length > 0) {
@@ -135,17 +138,30 @@ export function generateMainBarrel(tables, options = {}) {
  */
 export function generateCustomQueriesBarrel(tables, customQueryNames) {
     const statements = [];
+    const exportedHooks = new Set();
     // Export all table query hooks
     for (const table of tables) {
         const listHookName = getListQueryHookName(table);
-        const singleHookName = getSingleQueryHookName(table);
-        statements.push(exportAllFrom(`./${listHookName}`));
-        statements.push(exportAllFrom(`./${singleHookName}`));
+        if (!exportedHooks.has(listHookName)) {
+            statements.push(exportAllFrom(`./${listHookName}`));
+            exportedHooks.add(listHookName);
+        }
+        // Only export single query hook if table has valid primary key
+        if (hasValidPrimaryKey(table)) {
+            const singleHookName = getSingleQueryHookName(table);
+            if (!exportedHooks.has(singleHookName)) {
+                statements.push(exportAllFrom(`./${singleHookName}`));
+                exportedHooks.add(singleHookName);
+            }
+        }
     }
-    // Add custom query hooks
+    // Add custom query hooks (skip if already exported from table hooks)
     for (const name of customQueryNames) {
         const hookName = getOperationHookName(name, 'query');
-        statements.push(exportAllFrom(`./${hookName}`));
+        if (!exportedHooks.has(hookName)) {
+            statements.push(exportAllFrom(`./${hookName}`));
+            exportedHooks.add(hookName);
+        }
     }
     // Add file header as leading comment on first statement
     if (statements.length > 0) {
@@ -162,24 +178,37 @@ export function generateCustomQueriesBarrel(tables, customQueryNames) {
  */
 export function generateCustomMutationsBarrel(tables, customMutationNames) {
     const statements = [];
+    const exportedHooks = new Set();
     // Export all table mutation hooks
     for (const table of tables) {
         const createHookName = getCreateMutationHookName(table);
-        const updateHookName = getUpdateMutationHookName(table);
-        const deleteHookName = getDeleteMutationHookName(table);
-        statements.push(exportAllFrom(`./${createHookName}`));
+        if (!exportedHooks.has(createHookName)) {
+            statements.push(exportAllFrom(`./${createHookName}`));
+            exportedHooks.add(createHookName);
+        }
         // Only add update/delete if they exist
         if (table.query?.update !== null) {
-            statements.push(exportAllFrom(`./${updateHookName}`));
+            const updateHookName = getUpdateMutationHookName(table);
+            if (!exportedHooks.has(updateHookName)) {
+                statements.push(exportAllFrom(`./${updateHookName}`));
+                exportedHooks.add(updateHookName);
+            }
         }
         if (table.query?.delete !== null) {
-            statements.push(exportAllFrom(`./${deleteHookName}`));
+            const deleteHookName = getDeleteMutationHookName(table);
+            if (!exportedHooks.has(deleteHookName)) {
+                statements.push(exportAllFrom(`./${deleteHookName}`));
+                exportedHooks.add(deleteHookName);
+            }
         }
     }
-    // Add custom mutation hooks
+    // Add custom mutation hooks (skip if already exported from table hooks)
     for (const name of customMutationNames) {
         const hookName = getOperationHookName(name, 'mutation');
-        statements.push(exportAllFrom(`./${hookName}`));
+        if (!exportedHooks.has(hookName)) {
+            statements.push(exportAllFrom(`./${hookName}`));
+            exportedHooks.add(hookName);
+        }
     }
     // Add file header as leading comment on first statement
     if (statements.length > 0) {

package/esm/cli/codegen/custom-mutations.js

@@ -1,5 +1,5 @@
 import * as t from '@babel/types';
-import { generateCode, addJSDocComment, typedParam } from './babel-ast';
+import { generateCode, addJSDocComment, typedParam, createTypedCallExpression } from './babel-ast';
 import { buildCustomMutationString } from './schema-gql-ast';
 import { typeRefToTsType, isTypeRequired, getOperationHookName, getOperationFileName, getOperationVariablesTypeName, getOperationResultTypeName, getDocumentConstName, createTypeTracker, } from './type-resolver';
 import { getGeneratedFileHeader } from './utils';
@@ -94,13 +94,13 @@ function generateCustomMutationHookInternal(options) {
         mutationOptions.push(t.objectProperty(t.identifier('mutationKey'), t.callExpression(t.memberExpression(t.identifier('customMutationKeys'), t.identifier(operation.name)), [])));
     }
     if (hasArgs) {
-        mutationOptions.push(t.objectProperty(t.identifier('mutationFn'), t.arrowFunctionExpression([typedParam('variables', t.tsTypeReference(t.identifier(variablesTypeName)))], t.callExpression(t.identifier('execute'), [
-            t.identifier(documentConstName),
-            t.identifier('variables'),
+        mutationOptions.push(t.objectProperty(t.identifier('mutationFn'), t.arrowFunctionExpression([typedParam('variables', t.tsTypeReference(t.identifier(variablesTypeName)))], createTypedCallExpression(t.identifier('execute'), [t.identifier(documentConstName), t.identifier('variables')], [
+            t.tsTypeReference(t.identifier(resultTypeName)),
+            t.tsTypeReference(t.identifier(variablesTypeName)),
         ]))));
     }
     else {
-        mutationOptions.push(t.objectProperty(t.identifier('mutationFn'), t.arrowFunctionExpression([], t.callExpression(t.identifier('execute'), [t.identifier(documentConstName)]))));
+        mutationOptions.push(t.objectProperty(t.identifier('mutationFn'), t.arrowFunctionExpression([], createTypedCallExpression(t.identifier('execute'), [t.identifier(documentConstName)], [t.tsTypeReference(t.identifier(resultTypeName))]))));
     }
     mutationOptions.push(t.spreadElement(t.identifier('options')));
     hookBodyStatements.push(t.returnStatement(t.callExpression(t.identifier('useMutation'), [t.objectExpression(mutationOptions)])));

package/esm/cli/codegen/custom-queries.js

@@ -1,5 +1,5 @@
 import * as t from '@babel/types';
-import { generateCode, addJSDocComment, typedParam } from './babel-ast';
+import { generateCode, addJSDocComment, typedParam, createTypedCallExpression } from './babel-ast';
 import { buildCustomQueryString } from './schema-gql-ast';
 import { typeRefToTsType, isTypeRequired, getOperationHookName, getOperationFileName, getOperationVariablesTypeName, getOperationResultTypeName, getDocumentConstName, getQueryKeyName, createTypeTracker, } from './type-resolver';
 import { ucFirst, getGeneratedFileHeader } from './utils';
@@ -115,9 +115,9 @@ export function generateCustomQueryHook(options) {
         const useQueryOptions = [];
         if (hasArgs) {
             useQueryOptions.push(t.objectProperty(t.identifier('queryKey'), t.callExpression(t.identifier(queryKeyName), [t.identifier('variables')])));
-            useQueryOptions.push(t.objectProperty(t.identifier('queryFn'), t.arrowFunctionExpression([], t.callExpression(t.identifier('execute'), [
-                t.identifier(documentConstName),
-                t.identifier('variables'),
+            useQueryOptions.push(t.objectProperty(t.identifier('queryFn'), t.arrowFunctionExpression([], createTypedCallExpression(t.identifier('execute'), [t.identifier(documentConstName), t.identifier('variables')], [
+                t.tsTypeReference(t.identifier(resultTypeName)),
+                t.tsTypeReference(t.identifier(variablesTypeName)),
             ]))));
             if (hasRequiredArgs) {
                 useQueryOptions.push(t.objectProperty(t.identifier('enabled'), t.logicalExpression('&&', t.unaryExpression('!', t.unaryExpression('!', t.identifier('variables'))), t.binaryExpression('!==', t.optionalMemberExpression(t.identifier('options'), t.identifier('enabled'), false, true), t.booleanLiteral(false)))));
@@ -125,7 +125,7 @@ export function generateCustomQueryHook(options) {
         }
         else {
             useQueryOptions.push(t.objectProperty(t.identifier('queryKey'), t.callExpression(t.identifier(queryKeyName), [])));
-            useQueryOptions.push(t.objectProperty(t.identifier('queryFn'), t.arrowFunctionExpression([], t.callExpression(t.identifier('execute'), [t.identifier(documentConstName)]))));
+            useQueryOptions.push(t.objectProperty(t.identifier('queryFn'), t.arrowFunctionExpression([], createTypedCallExpression(t.identifier('execute'), [t.identifier(documentConstName)], [t.tsTypeReference(t.identifier(resultTypeName))]))));
         }
         useQueryOptions.push(t.spreadElement(t.identifier('options')));
         hookBodyStatements.push(t.returnStatement(t.callExpression(t.identifier('useQuery'), [t.objectExpression(useQueryOptions)])));
@@ -162,18 +162,13 @@ export function generateCustomQueryHook(options) {
     const hasRequiredArgs = operation.args.some((arg) => isTypeRequired(arg.type));
     const fetchBodyStatements = [];
     if (hasArgs) {
-        fetchBodyStatements.push(t.returnStatement(t.callExpression(t.identifier('execute'), [
-            t.identifier(documentConstName),
-            t.identifier('variables'),
-            t.identifier('options'),
+        fetchBodyStatements.push(t.returnStatement(createTypedCallExpression(t.identifier('execute'), [t.identifier(documentConstName), t.identifier('variables'), t.identifier('options')], [
+            t.tsTypeReference(t.identifier(resultTypeName)),
+            t.tsTypeReference(t.identifier(variablesTypeName)),
         ])));
     }
     else {
-        fetchBodyStatements.push(t.returnStatement(t.callExpression(t.identifier('execute'), [
-            t.identifier(documentConstName),
-            t.identifier('undefined'),
-            t.identifier('options'),
-        ])));
+        fetchBodyStatements.push(t.returnStatement(createTypedCallExpression(t.identifier('execute'), [t.identifier(documentConstName), t.identifier('undefined'), t.identifier('options')], [t.tsTypeReference(t.identifier(resultTypeName))])));
     }
     const fetchParams = [];
     if (hasArgs) {
@@ -201,19 +196,14 @@ export function generateCustomQueryHook(options) {
         const prefetchQueryOptions = [];
         if (hasArgs) {
             prefetchQueryOptions.push(t.objectProperty(t.identifier('queryKey'), t.callExpression(t.identifier(queryKeyName), [t.identifier('variables')])));
-            prefetchQueryOptions.push(t.objectProperty(t.identifier('queryFn'), t.arrowFunctionExpression([], t.callExpression(t.identifier('execute'), [
-                t.identifier(documentConstName),
-                t.identifier('variables'),
-                t.identifier('options'),
+            prefetchQueryOptions.push(t.objectProperty(t.identifier('queryFn'), t.arrowFunctionExpression([], createTypedCallExpression(t.identifier('execute'), [t.identifier(documentConstName), t.identifier('variables'), t.identifier('options')], [
+                t.tsTypeReference(t.identifier(resultTypeName)),
+                t.tsTypeReference(t.identifier(variablesTypeName)),
             ]))));
         }
         else {
             prefetchQueryOptions.push(t.objectProperty(t.identifier('queryKey'), t.callExpression(t.identifier(queryKeyName), [])));
-            prefetchQueryOptions.push(t.objectProperty(t.identifier('queryFn'), t.arrowFunctionExpression([], t.callExpression(t.identifier('execute'), [
-                t.identifier(documentConstName),
-                t.identifier('undefined'),
-                t.identifier('options'),
-            ]))));
+            prefetchQueryOptions.push(t.objectProperty(t.identifier('queryFn'), t.arrowFunctionExpression([], createTypedCallExpression(t.identifier('execute'), [t.identifier(documentConstName), t.identifier('undefined'), t.identifier('options')], [t.tsTypeReference(t.identifier(resultTypeName))]))));
         }
         prefetchBodyStatements.push(t.expressionStatement(t.awaitExpression(t.callExpression(t.memberExpression(t.identifier('queryClient'), t.identifier('prefetchQuery')), [t.objectExpression(prefetchQueryOptions)]))));
         const prefetchParams = [

package/esm/cli/codegen/gql-ast.js

@@ -6,7 +6,7 @@
  */
 import * as t from 'gql-ast';
 import { print } from 'graphql';
-import { getTableNames, getAllRowsQueryName, getSingleRowQueryName, getCreateMutationName, getUpdateMutationName, getDeleteMutationName, getFilterTypeName, getOrderByTypeName, getScalarFields, getPrimaryKeyInfo, ucFirst, } from './utils';
+import { getTableNames, getAllRowsQueryName, getSingleRowQueryName, getCreateMutationName, getUpdateMutationName, getDeleteMutationName, getFilterTypeName, getConditionTypeName, getOrderByTypeName, getScalarFields, getPrimaryKeyInfo, ucFirst, } from './utils';
 // ============================================================================
 // Field selection builders
 // ============================================================================
@@ -39,22 +39,39 @@ export function buildListQueryAST(config) {
     const { table } = config;
     const queryName = getAllRowsQueryName(table);
     const filterType = getFilterTypeName(table);
+    const conditionType = getConditionTypeName(table);
     const orderByType = getOrderByTypeName(table);
     const scalarFields = getScalarFields(table);
-    // Variable definitions
+    // Variable definitions - all pagination arguments from PostGraphile
     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: 'offset' }),
             type: t.namedType({ type: 'Int' }),
         }),
+        t.variableDefinition({
+            variable: t.variable({ name: 'before' }),
+            type: t.namedType({ type: 'Cursor' }),
+        }),
+        t.variableDefinition({
+            variable: t.variable({ name: 'after' }),
+            type: t.namedType({ type: 'Cursor' }),
+        }),
         t.variableDefinition({
             variable: t.variable({ name: 'filter' }),
             type: t.namedType({ type: filterType }),
         }),
+        t.variableDefinition({
+            variable: t.variable({ name: 'condition' }),
+            type: t.namedType({ type: conditionType }),
+        }),
         t.variableDefinition({
             variable: t.variable({ name: 'orderBy' }),
             type: t.listType({
@@ -65,8 +82,12 @@ export function buildListQueryAST(config) {
     // Query arguments
     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: 'before', value: t.variable({ name: 'before' }) }),
+        t.argument({ name: 'after', value: t.variable({ name: 'after' }) }),
         t.argument({ name: 'filter', value: t.variable({ name: 'filter' }) }),
+        t.argument({ name: 'condition', value: t.variable({ name: 'condition' }) }),
         t.argument({ name: 'orderBy', value: t.variable({ name: 'orderBy' }) }),
     ];
     // Field selections

package/esm/cli/codegen/index.js

@@ -152,6 +152,7 @@ export function generate(options) {
         enumsFromSchemaTypes: generatedEnumNames,
         useCentralizedKeys,
         hasRelationships,
+        tableTypeNames,
     });
     for (const hook of mutationHooks) {
         files.push({

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

@@ -17,6 +17,8 @@ export interface MutationGeneratorOptions {
     enumsFromSchemaTypes?: string[];
     useCentralizedKeys?: boolean;
     hasRelationships?: boolean;
+    /** All table type names for determining which types to import from types.ts vs schema-types.ts */
+    tableTypeNames?: Set<string>;
 }
 export declare function generateCreateMutationHook(table: CleanTable, options?: MutationGeneratorOptions): GeneratedMutationFile | null;
 export declare function generateUpdateMutationHook(table: CleanTable, options?: MutationGeneratorOptions): GeneratedMutationFile | null;