@gqlkit-ts/cli 0.0.1 → 0.1.0

package/dist/resolver-extractor/extractor/define-api-extractor.js

@@ -0,0 +1,685 @@
+import ts from "typescript";
+import { isInternalTypeSymbol, METADATA_PROPERTIES, RUNTIME_TYPE_NAMES, } from "../../shared/constants.js";
+import { detectDefaultValueMetadata } from "../../shared/default-value-detector.js";
+import { extractDirectivesFromType, hasDirectiveMetadata, unwrapDirectiveType, } from "../../shared/directive-detector.js";
+import { extractInlineObjectProperties } from "../../shared/inline-object-extractor.js";
+import { isInlineObjectType } from "../../shared/inline-object-utils.js";
+import { detectScalarMetadata, getActualMetadataType, } from "../../shared/metadata-detector.js";
+import { getSourceLocationFromNode } from "../../shared/source-location.js";
+import { extractTsDocFromSymbol, extractTsDocInfo, } from "../../shared/tsdoc-parser.js";
+import { extractPropertySymbols, getNonNullableTypes, hasUndefinedInType, isBuiltinUtilityType, isExported, isNullableUnion, shouldTreatIntersectionAsInline, } from "../../shared/typescript-utils.js";
+const RESOLVER_METADATA_PROPERTY = METADATA_PROPERTIES.RESOLVER;
+const ABSTRACT_RESOLVER_METADATA_PROPERTY = METADATA_PROPERTIES.ABSTRACT_RESOLVER;
+/**
+ * Detects abstract resolver kind and target type from metadata embedded in the type.
+ * Returns null if no abstract resolver metadata is found.
+ */
+function detectAbstractResolverFromMetadataType(callExpr, checker) {
+    const returnType = checker.getTypeAtLocation(callExpr);
+    const metadataProp = returnType.getProperty(ABSTRACT_RESOLVER_METADATA_PROPERTY);
+    if (!metadataProp) {
+        return null;
+    }
+    const metadataType = checker.getTypeOfSymbol(metadataProp);
+    const actualType = getActualMetadataType(metadataType);
+    if (!actualType) {
+        return null;
+    }
+    const kindProp = actualType.getProperty("kind");
+    if (!kindProp) {
+        return null;
+    }
+    const kindType = checker.getTypeOfSymbol(kindProp);
+    if (!kindType.isStringLiteral()) {
+        return null;
+    }
+    const kind = kindType.value;
+    if (kind !== "resolveType" && kind !== "isTypeOf") {
+        return null;
+    }
+    const targetTypeProp = actualType.getProperty("targetType");
+    if (!targetTypeProp) {
+        return null;
+    }
+    const targetType = checker.getTypeOfSymbol(targetTypeProp);
+    const targetTypeName = extractTypeNameFromType(targetType, checker);
+    if (!targetTypeName) {
+        return null;
+    }
+    return { kind, targetTypeName };
+}
+/**
+ * Extracts a type name from a TypeScript type.
+ * Handles internal type symbols (like __type) by falling back to typeToString.
+ * Returns null for unresolvable types (any, unknown).
+ */
+function extractTypeNameFromType(type, checker) {
+    if (type.flags & ts.TypeFlags.Any) {
+        return null;
+    }
+    if (type.aliasSymbol) {
+        const aliasName = type.aliasSymbol.getName();
+        if (!isInternalTypeSymbol(aliasName)) {
+            return aliasName;
+        }
+    }
+    const symbol = type.getSymbol();
+    if (symbol) {
+        const symbolName = symbol.getName();
+        if (!isInternalTypeSymbol(symbolName)) {
+            return symbolName;
+        }
+    }
+    const typeString = checker.typeToString(type);
+    if (typeString && typeString !== "unknown" && typeString !== "any") {
+        return typeString;
+    }
+    return null;
+}
+/**
+ * Detects resolver type from metadata embedded in the type.
+ * Follows the same pattern as scalar metadata detection.
+ */
+function detectResolverFromMetadataType(callExpr, checker) {
+    const returnType = checker.getTypeAtLocation(callExpr);
+    const metadataProp = returnType.getProperty(RESOLVER_METADATA_PROPERTY);
+    if (!metadataProp) {
+        return undefined;
+    }
+    const metadataType = checker.getTypeOfSymbol(metadataProp);
+    const actualType = getActualMetadataType(metadataType);
+    if (!actualType) {
+        return undefined;
+    }
+    const kindProp = actualType.getProperty("kind");
+    if (!kindProp) {
+        return undefined;
+    }
+    const kindType = checker.getTypeOfSymbol(kindProp);
+    if (kindType.isStringLiteral()) {
+        const kind = kindType.value;
+        if (kind === "query" || kind === "mutation" || kind === "field") {
+            return kind;
+        }
+    }
+    return undefined;
+}
+function convertTsTypeToReference(type, checker, typeNode) {
+    const metadataResult = detectScalarMetadata(type, checker);
+    // Skip scalar detection if it's an array of scalars (e.g., Int[])
+    // Array types should be handled by the array handling logic below
+    if (metadataResult.scalarName &&
+        !metadataResult.isPrimitive &&
+        !metadataResult.isList) {
+        return {
+            kind: "scalar",
+            name: metadataResult.scalarName,
+            elementType: null,
+            members: null,
+            nullable: metadataResult.nullable,
+            scalarInfo: {
+                scalarName: metadataResult.scalarName,
+                typeName: metadataResult.scalarName,
+                baseType: undefined,
+                isCustom: true,
+                only: metadataResult.only,
+            },
+            inlineObjectProperties: null,
+        };
+    }
+    const typeString = checker.typeToString(type);
+    if (type.isUnion()) {
+        const aliasSymbol = type.aliasSymbol;
+        if (aliasSymbol) {
+            const name = aliasSymbol.getName();
+            return {
+                kind: "reference",
+                name,
+                elementType: null,
+                members: null,
+                nullable: false,
+                scalarInfo: null,
+                inlineObjectProperties: null,
+            };
+        }
+        const nullable = isNullableUnion(type);
+        const nonNullTypes = getNonNullableTypes(type);
+        if (nonNullTypes.length === 1 && nonNullTypes[0]) {
+            const innerType = convertTsTypeToReference(nonNullTypes[0], checker);
+            return { ...innerType, nullable };
+        }
+        if (nonNullTypes.length > 1) {
+            // Check if this is a boolean literal union (true | false)
+            const isBooleanLiteralUnion = nonNullTypes.every((t) => t.flags & ts.TypeFlags.BooleanLiteral);
+            if (isBooleanLiteralUnion) {
+                return {
+                    kind: "primitive",
+                    name: "boolean",
+                    elementType: null,
+                    members: null,
+                    nullable,
+                    scalarInfo: null,
+                    inlineObjectProperties: null,
+                };
+            }
+            return {
+                kind: "union",
+                name: null,
+                elementType: null,
+                members: nonNullTypes.map((t) => convertTsTypeToReference(t, checker)),
+                nullable,
+                scalarInfo: null,
+                inlineObjectProperties: null,
+            };
+        }
+    }
+    if (checker.isArrayType(type)) {
+        const typeArgs = checker.getTypeArguments(type);
+        const elementType = typeArgs[0];
+        if (elementType) {
+            let elementTypeNode;
+            if (typeNode && ts.isArrayTypeNode(typeNode)) {
+                elementTypeNode = typeNode.elementType;
+            }
+            return {
+                kind: "array",
+                name: null,
+                elementType: convertTsTypeToReference(elementType, checker, elementTypeNode),
+                members: null,
+                nullable: false,
+                scalarInfo: null,
+                inlineObjectProperties: null,
+            };
+        }
+    }
+    if (isInlineObjectType(type)) {
+        const inlineProperties = extractInlineObjectProperties(type, checker, convertTsTypeToReference);
+        return {
+            kind: "inlineObject",
+            name: null,
+            elementType: null,
+            members: null,
+            nullable: false,
+            scalarInfo: null,
+            inlineObjectProperties: inlineProperties,
+        };
+    }
+    // Handle intersection types that should be treated as inline objects
+    // This includes intersections with anonymous/utility members OR intersections of
+    // named object types (interfaces) that need to be merged
+    // BUT only if the type itself is not a named type alias (like User = GqlObject<...>)
+    if (type.isIntersection() && !type.aliasSymbol) {
+        if (shouldTreatIntersectionAsInline(type, { checkBuiltinUtilityTypes: true })) {
+            const inlineProperties = extractInlineObjectProperties(type, checker, convertTsTypeToReference);
+            return {
+                kind: "inlineObject",
+                name: null,
+                elementType: null,
+                members: null,
+                nullable: false,
+                scalarInfo: null,
+                inlineObjectProperties: inlineProperties,
+            };
+        }
+    }
+    // Check if this is a utility type like Omit, Pick, etc.
+    // Utility types have aliasSymbol but their apparent type has resolved properties
+    if (type.flags & ts.TypeFlags.Object && isBuiltinUtilityType(type)) {
+        const inlineProperties = extractInlineObjectProperties(type, checker, convertTsTypeToReference);
+        return {
+            kind: "inlineObject",
+            name: null,
+            elementType: null,
+            members: null,
+            nullable: false,
+            scalarInfo: null,
+            inlineObjectProperties: inlineProperties,
+        };
+    }
+    const symbol = type.getSymbol();
+    if (symbol) {
+        const symbolName = symbol.getName();
+        if (!isInternalTypeSymbol(symbolName)) {
+            let name = symbolName;
+            if (typeNode && ts.isTypeReferenceNode(typeNode)) {
+                const typeName = typeNode.typeName;
+                if (ts.isIdentifier(typeName)) {
+                    name = typeName.text;
+                }
+                else if (ts.isQualifiedName(typeName)) {
+                    name = typeName.right.text;
+                }
+            }
+            return {
+                kind: "reference",
+                name,
+                elementType: null,
+                members: null,
+                nullable: false,
+                scalarInfo: null,
+                inlineObjectProperties: null,
+            };
+        }
+    }
+    if (type.flags & ts.TypeFlags.String) {
+        return {
+            kind: "primitive",
+            name: "string",
+            elementType: null,
+            members: null,
+            nullable: false,
+            scalarInfo: null,
+            inlineObjectProperties: null,
+        };
+    }
+    if (type.flags & ts.TypeFlags.Number) {
+        return {
+            kind: "primitive",
+            name: "number",
+            elementType: null,
+            members: null,
+            nullable: false,
+            scalarInfo: null,
+            inlineObjectProperties: null,
+        };
+    }
+    if (type.flags & ts.TypeFlags.Boolean) {
+        return {
+            kind: "primitive",
+            name: "boolean",
+            elementType: null,
+            members: null,
+            nullable: false,
+            scalarInfo: null,
+            inlineObjectProperties: null,
+        };
+    }
+    return {
+        kind: "reference",
+        name: typeString,
+        elementType: null,
+        members: null,
+        nullable: false,
+        scalarInfo: null,
+        inlineObjectProperties: null,
+    };
+}
+function getTypeNameFromNode(typeNode) {
+    if (ts.isTypeReferenceNode(typeNode)) {
+        const typeName = typeNode.typeName;
+        if (ts.isIdentifier(typeName)) {
+            return typeName.text;
+        }
+        if (ts.isQualifiedName(typeName)) {
+            return typeName.right.text;
+        }
+    }
+    return undefined;
+}
+function isInlineTypeLiteralDeclaration(declaration) {
+    if (!ts.isPropertySignature(declaration)) {
+        return false;
+    }
+    const parent = declaration.parent;
+    if (!ts.isTypeLiteralNode(parent)) {
+        return false;
+    }
+    const grandparent = parent.parent;
+    if (ts.isTypeAliasDeclaration(grandparent)) {
+        return false;
+    }
+    if (ts.isInterfaceDeclaration(grandparent)) {
+        return false;
+    }
+    return true;
+}
+function extractTSDocFromPropertyWithPriority(prop, checker) {
+    const declarations = prop.getDeclarations();
+    if (!declarations || declarations.length === 0) {
+        return { description: null, deprecated: null };
+    }
+    const inlineDeclaration = declarations.find(isInlineTypeLiteralDeclaration);
+    if (inlineDeclaration) {
+        const inlineSymbol = checker.getSymbolAtLocation(inlineDeclaration.name);
+        if (inlineSymbol) {
+            return extractTsDocFromSymbol(inlineSymbol, checker);
+        }
+    }
+    return extractTsDocFromSymbol(prop, checker);
+}
+/**
+ * Checks if a type should be unwrapped as a GqlField type.
+ * This handles cases where TypeScript represents the type differently
+ * when accessed through type references vs. direct declarations.
+ */
+function shouldUnwrapAsGqlField(type, checker) {
+    // First check using the standard method
+    if (hasDirectiveMetadata(type)) {
+        return true;
+    }
+    // Fallback: check if the type string contains GqlField
+    // This handles cases where TypeScript represents the type differently
+    const typeString = checker.typeToString(type);
+    if (typeString.startsWith(`${RUNTIME_TYPE_NAMES.GQL_FIELD}<`) ||
+        typeString === RUNTIME_TYPE_NAMES.GQL_FIELD) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Checks if a type is the NoArgs type (Record<string, never>).
+ * This is a special type that represents "no arguments".
+ */
+function isNoArgsType(type, checker) {
+    if (type.aliasSymbol?.getName() === "NoArgs") {
+        return true;
+    }
+    if (type.aliasSymbol?.getName() === "Record") {
+        return true;
+    }
+    const typeStr = checker.typeToString(type);
+    if (typeStr === "Record<string, never>") {
+        return true;
+    }
+    return false;
+}
+/**
+ * Checks if a type has only index signatures with no named properties.
+ * Types like `{ [key: string]: number }` return true.
+ * Does NOT return true for NoArgs type.
+ */
+function hasOnlyIndexSignatures(type, checker) {
+    if (isNoArgsType(type, checker)) {
+        return false;
+    }
+    const targetType = checker.getApparentType(type);
+    const indexInfos = checker.getIndexInfosOfType(targetType);
+    const hasIndexSignatures = indexInfos.length > 0;
+    if (!hasIndexSignatures) {
+        return false;
+    }
+    const properties = targetType
+        .getProperties()
+        .filter((p) => !p.getName().startsWith(" $"));
+    if (properties.length > 0) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Gets the type name for error messages.
+ */
+function getTypeNameForDiagnostic(type, checker) {
+    if (type.aliasSymbol) {
+        return type.aliasSymbol.getName();
+    }
+    if (type.symbol) {
+        return type.symbol.getName();
+    }
+    return checker.typeToString(type);
+}
+function extractArgsFromType(argsType, checker) {
+    const args = [];
+    const properties = extractPropertySymbols(argsType, checker);
+    for (const prop of properties) {
+        const propType = checker.getTypeOfSymbol(prop);
+        const optional = hasUndefinedInType(propType);
+        const tsdocInfo = extractTSDocFromPropertyWithPriority(prop, checker);
+        let defaultValue = null;
+        let actualPropType = propType;
+        if (shouldUnwrapAsGqlField(propType, checker)) {
+            const defaultValueResult = detectDefaultValueMetadata(propType, checker);
+            if (defaultValueResult.defaultValue) {
+                defaultValue = defaultValueResult.defaultValue;
+            }
+            actualPropType = unwrapDirectiveType(propType, checker);
+        }
+        args.push({
+            name: prop.getName(),
+            tsType: convertTsTypeToReference(actualPropType, checker),
+            optional,
+            description: tsdocInfo.description,
+            deprecated: tsdocInfo.deprecated,
+            defaultValue,
+        });
+    }
+    return args;
+}
+function extractDirectivesFromTypeNode(typeNode, checker) {
+    if (!typeNode) {
+        return null;
+    }
+    const type = checker.getTypeFromTypeNode(typeNode);
+    const directiveResult = extractDirectivesFromType(type, checker);
+    if (directiveResult.directives.length > 0) {
+        return directiveResult.directives;
+    }
+    return null;
+}
+/**
+ * Validates an args type and returns diagnostics for problematic types.
+ */
+function validateArgsType(argsType, argsTypeNode, checker) {
+    const diagnostics = [];
+    if (hasOnlyIndexSignatures(argsType, checker)) {
+        const typeName = getTypeNameForDiagnostic(argsType, checker);
+        diagnostics.push({
+            code: "INDEX_SIGNATURE_ONLY",
+            message: `Type '${typeName}' contains only index signatures and cannot be represented as a GraphQL type. Use a concrete object type instead.`,
+            severity: "error",
+            location: getSourceLocationFromNode(argsTypeNode),
+        });
+    }
+    return diagnostics;
+}
+/**
+ * Checks if the extracted args are empty and the original type was not NoArgs.
+ * This indicates the type resolved to an empty object.
+ * Does not emit warnings for types that only have index signatures (they get INDEX_SIGNATURE_ONLY error instead).
+ */
+function checkEmptyArgsType(argsType, argsTypeNode, args, checker) {
+    if (isNoArgsType(argsType, checker)) {
+        return null;
+    }
+    if (hasOnlyIndexSignatures(argsType, checker)) {
+        return null;
+    }
+    if (args !== null && args.length === 0) {
+        const typeName = getTypeNameForDiagnostic(argsType, checker);
+        return {
+            code: "EMPTY_TYPE_PROPERTIES",
+            message: `Type '${typeName}' has no properties. Consider adding properties or using a different type.`,
+            severity: "warning",
+            location: getSourceLocationFromNode(argsTypeNode),
+        };
+    }
+    return null;
+}
+function extractTypeArgumentsFromCall(node, checker, resolverType) {
+    const typeArgs = node.typeArguments;
+    if (!typeArgs) {
+        return null;
+    }
+    if (resolverType === "field") {
+        if (typeArgs.length < 3) {
+            return null;
+        }
+        const parentTypeNode = typeArgs[0];
+        const argsTypeNode = typeArgs[1];
+        const returnTypeNode = typeArgs[2];
+        const directiveTypeNode = typeArgs[3];
+        if (!parentTypeNode || !argsTypeNode || !returnTypeNode) {
+            return null;
+        }
+        const argsType = checker.getTypeFromTypeNode(argsTypeNode);
+        const returnType = checker.getTypeFromTypeNode(returnTypeNode);
+        const parentTypeName = getTypeNameFromNode(parentTypeNode);
+        const argsTypeRef = convertTsTypeToReference(argsType, checker);
+        const isNoArgs = argsTypeRef.kind === "reference" && argsTypeRef.name === "Record";
+        const diagnostics = [];
+        if (!isNoArgs) {
+            diagnostics.push(...validateArgsType(argsType, argsTypeNode, checker));
+        }
+        const args = isNoArgs ? null : extractArgsFromType(argsType, checker);
+        if (!isNoArgs) {
+            const emptyDiagnostic = checkEmptyArgsType(argsType, argsTypeNode, args, checker);
+            if (emptyDiagnostic) {
+                diagnostics.push(emptyDiagnostic);
+            }
+        }
+        const directives = extractDirectivesFromTypeNode(directiveTypeNode, checker);
+        return {
+            parentTypeName: parentTypeName ?? null,
+            argsType: isNoArgs ? null : argsTypeRef,
+            args: args && args.length > 0 ? args : null,
+            returnType: convertTsTypeToReference(returnType, checker, returnTypeNode),
+            directives,
+            diagnostics,
+        };
+    }
+    if (typeArgs.length < 2) {
+        return null;
+    }
+    const argsTypeNode = typeArgs[0];
+    const returnTypeNode = typeArgs[1];
+    const directiveTypeNode = typeArgs[2];
+    if (!argsTypeNode || !returnTypeNode) {
+        return null;
+    }
+    const argsType = checker.getTypeFromTypeNode(argsTypeNode);
+    const returnType = checker.getTypeFromTypeNode(returnTypeNode);
+    const argsTypeRef = convertTsTypeToReference(argsType, checker);
+    const isNoArgs = argsTypeRef.kind === "reference" && argsTypeRef.name === "Record";
+    const diagnostics = [];
+    if (!isNoArgs) {
+        diagnostics.push(...validateArgsType(argsType, argsTypeNode, checker));
+    }
+    const args = isNoArgs ? null : extractArgsFromType(argsType, checker);
+    if (!isNoArgs) {
+        const emptyDiagnostic = checkEmptyArgsType(argsType, argsTypeNode, args, checker);
+        if (emptyDiagnostic) {
+            diagnostics.push(emptyDiagnostic);
+        }
+    }
+    const directives = extractDirectivesFromTypeNode(directiveTypeNode, checker);
+    return {
+        parentTypeName: null,
+        argsType: isNoArgs ? null : argsTypeRef,
+        args: args && args.length > 0 ? args : null,
+        returnType: convertTsTypeToReference(returnType, checker, returnTypeNode),
+        directives,
+        diagnostics,
+    };
+}
+function extractExportedInputTypes(sourceFile, checker) {
+    const exportedTypes = [];
+    ts.forEachChild(sourceFile, (node) => {
+        if (ts.isTypeAliasDeclaration(node) && isExported(node)) {
+            const name = node.name.getText(sourceFile);
+            const type = checker.getTypeAtLocation(node.name);
+            const tsType = convertTsTypeToReference(type, checker);
+            exportedTypes.push({
+                name,
+                tsType,
+                sourceFile: sourceFile.fileName,
+            });
+        }
+    });
+    return exportedTypes;
+}
+export function extractDefineApiResolvers(program, files) {
+    const checker = program.getTypeChecker();
+    const resolvers = [];
+    const abstractTypeResolvers = [];
+    const diagnostics = [];
+    for (const filePath of files) {
+        const sourceFile = program.getSourceFile(filePath);
+        if (!sourceFile) {
+            continue;
+        }
+        const exportedInputTypes = extractExportedInputTypes(sourceFile, checker);
+        ts.forEachChild(sourceFile, (node) => {
+            if (!ts.isVariableStatement(node)) {
+                return;
+            }
+            if (!isExported(node)) {
+                return;
+            }
+            for (const declaration of node.declarationList.declarations) {
+                if (!ts.isIdentifier(declaration.name)) {
+                    continue;
+                }
+                const fieldName = declaration.name.getText(sourceFile);
+                const initializer = declaration.initializer;
+                if (!initializer) {
+                    continue;
+                }
+                if (!ts.isCallExpression(initializer)) {
+                    if (ts.isConditionalExpression(initializer) ||
+                        ts.isBinaryExpression(initializer)) {
+                        const hasDefineCall = initializer
+                            .getText(sourceFile)
+                            .match(/define(Query|Mutation|Field)/);
+                        if (hasDefineCall) {
+                            diagnostics.push({
+                                code: "INVALID_DEFINE_CALL",
+                                message: `Complex expressions with define* functions are not supported. Use a simple 'export const ${fieldName} = defineXxx(...)' pattern.`,
+                                severity: "error",
+                                location: getSourceLocationFromNode(declaration.name),
+                            });
+                        }
+                    }
+                    continue;
+                }
+                const abstractResolverInfo = detectAbstractResolverFromMetadataType(initializer, checker);
+                if (abstractResolverInfo) {
+                    const sourceLocation = getSourceLocationFromNode(declaration.name);
+                    if (sourceLocation) {
+                        abstractTypeResolvers.push({
+                            kind: abstractResolverInfo.kind,
+                            targetTypeName: abstractResolverInfo.targetTypeName,
+                            exportName: fieldName,
+                            sourceFile: filePath,
+                            sourceLocation,
+                        });
+                    }
+                    continue;
+                }
+                const resolverType = detectResolverFromMetadataType(initializer, checker);
+                if (!resolverType) {
+                    continue;
+                }
+                const funcName = ts.isIdentifier(initializer.expression)
+                    ? initializer.expression.text
+                    : undefined;
+                const typeInfo = extractTypeArgumentsFromCall(initializer, checker, resolverType);
+                if (!typeInfo) {
+                    diagnostics.push({
+                        code: "INVALID_DEFINE_CALL",
+                        message: `Failed to extract type arguments from ${funcName ?? "define*"} call for '${fieldName}'`,
+                        severity: "error",
+                        location: getSourceLocationFromNode(declaration.name),
+                    });
+                    continue;
+                }
+                diagnostics.push(...typeInfo.diagnostics);
+                const tsdocInfo = extractTsDocInfo(node, checker);
+                resolvers.push({
+                    fieldName,
+                    resolverType,
+                    parentTypeName: typeInfo.parentTypeName,
+                    argsType: typeInfo.argsType,
+                    args: typeInfo.args,
+                    returnType: typeInfo.returnType,
+                    sourceFile: filePath,
+                    exportedInputTypes,
+                    description: tsdocInfo.description,
+                    deprecated: tsdocInfo.deprecated,
+                    directives: typeInfo.directives,
+                });
+            }
+        });
+    }
+    return { resolvers, abstractTypeResolvers, diagnostics };
+}
+//# sourceMappingURL=define-api-extractor.js.map