bunsane 0.1.4 → 0.2.0

package/gql/strategies/TypeGenerationStrategy.ts

@@ -0,0 +1,329 @@
+import type { GraphQLType } from "../helpers";
+import type { ZodType } from "zod";
+import BaseArcheType from "../../core/ArcheType";
+import { logger } from "../../core/Logger";
+
+export interface TypeGenerationResult {
+  typeDef: string;
+  fieldType?: string;
+  resolverWrapper?: (resolver: Function) => Function;
+  inputTypeName?: string;
+}
+
+export interface TypeGenerationContext {
+  isInput: boolean;
+  operationName: string;
+  definedInputTypes: Set<string>;
+  scalarTypes: Set<string>;
+}
+
+export interface TypeGenerationStrategy {
+  canHandle(meta: any): boolean;
+  generateTypeDef(meta: any, context: TypeGenerationContext): TypeGenerationResult;
+  generateResolver?(originalResolver: Function, meta: any): Function;
+}
+
+/**
+ * Strategy for Zod schema-based input generation
+ */
+export class ZodTypeStrategy implements TypeGenerationStrategy {
+  canHandle(meta: any): boolean {
+    return !!(meta && typeof meta === 'object' && '_def' in meta);
+  }
+
+  generateTypeDef(meta: ZodType, context: TypeGenerationContext): TypeGenerationResult {
+    // Extracted logic from existing generator for Zod inputs
+    const inputName = `${context.operationName}Input`;
+    let originalInput = meta;
+
+    // Handle optional schemas
+    let innerInput: any = meta;
+    const ZodOptional = (require('zod')).ZodOptional;
+    const wasOptional = meta instanceof ZodOptional;
+    if (wasOptional && 'unwrap' in (meta as any)) {
+      innerInput = (meta as any).unwrap();
+    }
+
+    // Preprocess schema for unions with scalar literals
+    const innerDef = (innerInput as any)._def;
+    const shape = innerDef && (typeof innerDef.shape === 'function' ? innerDef.shape() : innerDef.shape);
+    if (shape) {
+      const processedShape: any = {};
+      for (const [key, value] of Object.entries(shape)) {
+        const fieldSchema = value as any;
+        const typeName = fieldSchema._def?.typeName || fieldSchema._def?.type;
+
+        if (typeName === 'ZodUnion' || typeName === 'union') {
+          const options = fieldSchema._def?.options || [];
+          let foundScalarLiteral = null;
+
+          for (const option of options) {
+            const optionTypeName = option._def?.typeName || option._def?.type;
+            if (optionTypeName === 'ZodLiteral' || optionTypeName === 'literal') {
+              const value = option._def?.value ?? (option._def?.values ? option._def.values[0] : undefined);
+              if (typeof value === 'string' && context.scalarTypes.has(value)) {
+                foundScalarLiteral = option;
+                break;
+              }
+            }
+          }
+
+          processedShape[key] = foundScalarLiteral || fieldSchema;
+        } else {
+          processedShape[key] = fieldSchema;
+        }
+      }
+
+      innerInput = (require('zod')).object(processedShape);
+    }
+
+    // Add __typename field if extend is available
+    const z = require('zod');
+    if (innerInput && typeof (innerInput as any).extend === 'function') {
+      innerInput = (innerInput as any).extend({ __typename: z.literal(inputName).nullish() });
+    }
+    if (wasOptional) {
+      meta = innerInput.optional();
+    } else {
+      meta = innerInput;
+    }
+
+    const { weave, ZodWeaver } = require('@gqloom/core');
+    const { printSchema } = require('graphql');
+    const gqlInputSchema = weave(ZodWeaver, meta as ZodType) as any;
+    const schemaString = printSchema(gqlInputSchema);
+
+    const typeNames: string[] = [];
+    schemaString.replace(/type (\w+)/g, (_match: string, name: string) => {
+      typeNames.push(name);
+      return _match;
+    });
+
+    let inputTypeDefs = schemaString.replace(/\btype\b/g, 'input');
+    inputTypeDefs = inputTypeDefs.replace(/input (\w+)/g, (_match: string, name: string) => {
+      if (name.endsWith('Input')) {
+        return `input ${name}`;
+      } else {
+        return `input ${name}Input`;
+      }
+    });
+
+    inputTypeDefs = inputTypeDefs.replace(/: (\[?)(\w+)([!\[\]]*)(\s|$)/g, (_match: string, bracketStart: string, type: string, suffix: string, end: string) => {
+      if (typeNames.includes(type)) {
+        return `: ${bracketStart}${type.endsWith('Input') ? type : type + 'Input'}${suffix}${end}`;
+      } else {
+        return _match;
+      }
+    });
+
+    // Deduplicate
+    const deduplicatedInputTypeDefs = this.deduplicateInputTypes(inputTypeDefs, context.definedInputTypes);
+    let typeDef = deduplicatedInputTypeDefs + '\n';
+
+    // Post-process for literal scalars
+    let schemaToTraverse: any = originalInput;
+    const defType = (schemaToTraverse._def as any)?.typeName || (schemaToTraverse._def as any)?.type;
+    if (defType === 'ZodOptional' || defType === 'optional') {
+      schemaToTraverse = (schemaToTraverse as any)._def.innerType;
+    }
+
+    const literalFields: Record<string, string> = {};
+    this.traverseZod(schemaToTraverse, literalFields, context.scalarTypes);
+
+    for (const [fieldPath, scalarName] of Object.entries(literalFields)) {
+      const fieldName = fieldPath.split('.').pop()!;
+      typeDef = typeDef.replace(new RegExp(`(\\s+${fieldName}:\\s+)String!`, 'g'), `$1${scalarName}!`);
+    }
+
+    // Determine nullability based on whether the input was optional
+    const inputNullability = wasOptional ? '' : '!';
+
+    return {
+      typeDef,
+      fieldType: `(input: ${inputName}${inputNullability})`,
+      inputTypeName: inputName,
+      resolverWrapper: (resolver) => this.wrapResolverWithZodValidation(resolver, originalInput)
+    };
+  }
+
+  private deduplicateInputTypes(inputTypeDefs: string, definedTypes: Set<string>): string {
+    const lines = inputTypeDefs.split('\n');
+    const result: string[] = [];
+    let currentType = '';
+    let currentTypeName = '';
+    let inTypeDefinition = false;
+
+    for (const line of lines) {
+      if (line.startsWith('input ')) {
+        currentTypeName = line.split(' ')[1] ?? '';
+        if (definedTypes.has(currentTypeName)) {
+          inTypeDefinition = false;
+          currentType = '';
+          continue;
+        } else {
+          definedTypes.add(currentTypeName);
+          inTypeDefinition = true;
+          currentType = line + '\n';
+        }
+      } else if (inTypeDefinition) {
+        currentType += line + '\n';
+        if (line.trim() === '}') {
+          result.push(currentType);
+          inTypeDefinition = false;
+          currentType = '';
+        }
+      } else if (!inTypeDefinition && line.trim()) {
+        result.push(line + '\n');
+      }
+    }
+
+    return result.join('');
+  }
+
+  private traverseZod(obj: any, literalFields: Record<string, string>, scalarTypes: Set<string>, path: string[] = []) {
+    if (!obj || !obj._def) return;
+    const typeName = (obj._def as any).typeName || (obj._def as any).type;
+    if (typeName === 'ZodLiteral' || typeName === 'literal') {
+      const defObj = obj._def as any;
+      const value = defObj.value ?? (defObj.values ? defObj.values[0] : undefined);
+      if (typeof value === 'string' && scalarTypes.has(value)) {
+        literalFields[path.join('.')] = value;
+      }
+    } else if (typeName === 'ZodUnion' || typeName === 'union') {
+      const options = (obj._def as any).options || [];
+      for (const option of options) {
+        const optionTypeName = (option._def as any)?.typeName || (option._def as any)?.type;
+        if (optionTypeName === 'ZodLiteral' || optionTypeName === 'literal') {
+          const defObj = option._def as any;
+          const value = defObj.value ?? (defObj.values ? defObj.values[0] : undefined);
+          if (typeof value === 'string' && scalarTypes.has(value)) {
+            literalFields[path.join('.')] = value;
+            break;
+          }
+        }
+      }
+    } else if (typeName === 'ZodObject' || typeName === 'object') {
+      const shape = typeof obj._def.shape === 'function' ? obj._def.shape() : obj._def.shape;
+      if (shape) {
+        for (const [key, value] of Object.entries(shape)) {
+          this.traverseZod(value, literalFields, scalarTypes, [...path, key]);
+        }
+      }
+    }
+  }
+
+  private wrapResolverWithZodValidation(resolver: Function, zodSchema: ZodType): Function {
+    return async (_: any, args: any, context: any, info: any) => {
+      try {
+        const inputArgs = args.input || args;
+        const validated = zodSchema.parse(inputArgs);
+        return await resolver(validated, context, info);
+      } catch (error) {
+        if (error instanceof (require('zod')).ZodError) {
+          const { handleGraphQLError } = await import("../../core/ErrorHandler");
+          handleGraphQLError(error);
+        }
+        throw error;
+      }
+    };
+  }
+}
+
+/**
+ * Strategy for archetype output types
+ */
+export class ArchetypeTypeStrategy implements TypeGenerationStrategy {
+  canHandle(meta: any): boolean {
+    return meta instanceof BaseArcheType || (Array.isArray(meta) && meta[0] instanceof BaseArcheType);
+  }
+
+  generateTypeDef(meta: BaseArcheType | BaseArcheType[], context: TypeGenerationContext): TypeGenerationResult {
+    const { getArchetypeTypeName } = require("../../core/ArcheType");
+
+    if (Array.isArray(meta)) {
+      const archetypeInstance = meta[0];
+      const typeName = getArchetypeTypeName(archetypeInstance);
+      if (typeName) {
+        return { typeDef: '', fieldType: `: [${typeName}]` };
+      } else {
+        logger.warn(`Invalid array output type for ${context.operationName}, expected archetype instance`);
+        return { typeDef: '', fieldType: `: [Any]` };
+      }
+    } else {
+      const typeName = getArchetypeTypeName(meta);
+      if (typeName) {
+        return { typeDef: '', fieldType: `: ${typeName}` };
+      } else {
+        logger.warn(`Could not determine type name for archetype in ${context.operationName}`);
+        return { typeDef: '', fieldType: `: Any` };
+      }
+    }
+  }
+}
+
+/**
+ * Strategy for legacy Record<string, GraphQLType> format
+ */
+export class LegacyTypeStrategy implements TypeGenerationStrategy {
+  canHandle(meta: any): boolean {
+    return meta && typeof meta === 'object' && !('_def' in meta) && !this.isArchetype(meta);
+  }
+
+  private isArchetype(meta: any): boolean {
+    return meta instanceof BaseArcheType || (Array.isArray(meta) && meta[0] instanceof BaseArcheType);
+  }
+
+  generateTypeDef(meta: Record<string, GraphQLType>, context: TypeGenerationContext): TypeGenerationResult {
+    if (context.isInput) {
+      // Input type
+      const inputName = `${context.operationName}Input`;
+      const typeDef = `input ${inputName} {\n${Object.entries(meta).map(([k, v]) => `  ${k}: ${v}`).join('\n')}\n}\n`;
+      return { typeDef, fieldType: `(input: ${inputName}!)`, inputTypeName: inputName };
+    } else {
+      // Output type
+      const outputName = `${context.operationName}Output`;
+      const typeDef = `type ${outputName} {\n${Object.entries(meta).map(([k, v]) => `  ${k}: ${v}`).join('\n')}\n}\n`;
+      return { typeDef, fieldType: `: ${outputName}` };
+    }
+  }
+
+  private isInputLike(meta: Record<string, GraphQLType>): boolean {
+    // Heuristic: if operationName ends with 'Input' or has input-like fields, treat as input
+    // For now, assume if it's used as input in context, but since we don't have context, check field names
+    return true; // Default to input for legacy, adjust based on usage
+  }
+}
+
+/**
+ * Strategy for primitive string-based types
+ */
+export class PrimitiveTypeStrategy implements TypeGenerationStrategy {
+  canHandle(meta: any): boolean {
+    return typeof meta === 'string';
+  }
+
+  generateTypeDef(meta: string, context: TypeGenerationContext): TypeGenerationResult {
+    return { typeDef: '', fieldType: `: ${meta}` };
+  }
+}
+
+/**
+ * Factory to select the appropriate strategy
+ */
+export class TypeGenerationStrategyFactory {
+  private static strategies: TypeGenerationStrategy[] = [
+    new ZodTypeStrategy(),
+    new ArchetypeTypeStrategy(),
+    new LegacyTypeStrategy(),
+    new PrimitiveTypeStrategy()
+  ];
+
+  static getStrategy(meta: any): TypeGenerationStrategy {
+    for (const strategy of this.strategies) {
+      if (strategy.canHandle(meta)) {
+        return strategy;
+      }
+    }
+    throw new Error(`No strategy found for meta: ${JSON.stringify(meta)}`);
+  }
+}

package/gql/types.ts

@@ -24,6 +24,7 @@ export interface GraphQLField {
 
 
 // TODO: Remove this when we have a better way to define GraphQL type
+// Current usage is for custom input types in Operation decorators
 export enum GraphQLFieldTypes {
     ID = "ID",
     ID_REQUIRED = "ID!",

package/gql/utils/TypeSignature.ts

@@ -0,0 +1,220 @@
+import type { ZodType } from "zod";
+
+/**
+ * Generate a structural signature for a Zod schema to enable type matching.
+ * The signature is based on field names and their types, sorted alphabetically.
+ * This allows us to detect when two schemas are structurally equivalent,
+ * even if they were created through different transformations (.omit(), .extend(), etc.)
+ */
+export function generateZodStructuralSignature(schema: ZodType | any): string {
+    if (!schema || !schema._def) return 'unknown';
+
+    const typeName = schema._def.typeName || schema._def.type;
+
+    // Handle object types - the main case for input type matching
+    if (typeName === 'ZodObject' || typeName === 'object') {
+        let shape: Record<string, any> | undefined;
+        
+        try {
+            shape = typeof schema._def.shape === 'function'
+                ? schema._def.shape()
+                : schema._def.shape;
+        } catch {
+            // If shape access fails, try alternative methods
+            if (schema.shape && typeof schema.shape === 'object') {
+                shape = schema.shape;
+            }
+        }
+
+        if (!shape || Object.keys(shape).length === 0) {
+            return 'object:{}';
+        }
+
+        // Sort keys for consistent hashing
+        const fieldSignatures = Object.entries(shape)
+            .filter(([key]) => key !== '__typename') // Exclude __typename from signature
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, value]) => `${key}:${generateZodStructuralSignature(value as ZodType)}`)
+            .join(',');
+
+        return `object:{${fieldSignatures}}`;
+    }
+
+    // Primitive types
+    if (typeName === 'ZodNumber' || typeName === 'number') return 'number';
+    if (typeName === 'ZodString' || typeName === 'string') return 'string';
+    if (typeName === 'ZodBoolean' || typeName === 'boolean') return 'boolean';
+    if (typeName === 'ZodDate' || typeName === 'date') return 'date';
+    if (typeName === 'ZodAny' || typeName === 'any') return 'any';
+    if (typeName === 'ZodUnknown' || typeName === 'unknown') return 'unknown';
+    if (typeName === 'ZodVoid' || typeName === 'void') return 'void';
+    if (typeName === 'ZodNull' || typeName === 'null') return 'null';
+    if (typeName === 'ZodUndefined' || typeName === 'undefined') return 'undefined';
+    if (typeName === 'ZodNaN' || typeName === 'nan') return 'nan';
+    if (typeName === 'ZodBigInt' || typeName === 'bigint') return 'bigint';
+    if (typeName === 'ZodSymbol' || typeName === 'symbol') return 'symbol';
+
+    // Wrapper types - unwrap and include wrapper info
+    if (typeName === 'ZodOptional' || typeName === 'optional') {
+        const inner = generateZodStructuralSignature(schema._def.innerType);
+        return `optional:${inner}`;
+    }
+
+    if (typeName === 'ZodNullable' || typeName === 'nullable') {
+        const inner = generateZodStructuralSignature(schema._def.innerType);
+        return `nullable:${inner}`;
+    }
+
+    if (typeName === 'ZodDefault' || typeName === 'default') {
+        const inner = generateZodStructuralSignature(schema._def.innerType);
+        return `default:${inner}`;
+    }
+
+    if (typeName === 'ZodEffects' || typeName === 'effects') {
+        const inner = generateZodStructuralSignature(schema._def.schema);
+        return `effects:${inner}`;
+    }
+
+    if (typeName === 'ZodReadonly' || typeName === 'readonly') {
+        const inner = generateZodStructuralSignature(schema._def.innerType);
+        return `readonly:${inner}`;
+    }
+
+    if (typeName === 'ZodBranded' || typeName === 'branded') {
+        const inner = generateZodStructuralSignature(schema._def.type);
+        return `branded:${inner}`;
+    }
+
+    if (typeName === 'ZodCatch' || typeName === 'catch') {
+        const inner = generateZodStructuralSignature(schema._def.innerType);
+        return `catch:${inner}`;
+    }
+
+    if (typeName === 'ZodPipeline' || typeName === 'pipeline') {
+        const inner = generateZodStructuralSignature(schema._def.in);
+        const outer = generateZodStructuralSignature(schema._def.out);
+        return `pipeline:${inner}->${outer}`;
+    }
+
+    // Array type
+    if (typeName === 'ZodArray' || typeName === 'array') {
+        const elementType = schema._def.type;
+        const elementSignature = generateZodStructuralSignature(elementType);
+        return `array:${elementSignature}`;
+    }
+
+    // Tuple type
+    if (typeName === 'ZodTuple' || typeName === 'tuple') {
+        const items = schema._def.items || [];
+        const itemSignatures = items.map((item: ZodType) => generateZodStructuralSignature(item)).join(',');
+        const rest = schema._def.rest ? `,rest:${generateZodStructuralSignature(schema._def.rest)}` : '';
+        return `tuple:[${itemSignatures}${rest}]`;
+    }
+
+    // Union type - sort options for consistent signature
+    if (typeName === 'ZodUnion' || typeName === 'union') {
+        const options = schema._def.options || [];
+        const optionSignatures = options
+            .map((opt: ZodType) => generateZodStructuralSignature(opt))
+            .sort()
+            .join('|');
+        return `union:(${optionSignatures})`;
+    }
+
+    // Discriminated union - include discriminator key
+    if (typeName === 'ZodDiscriminatedUnion' || typeName === 'discriminatedUnion') {
+        const discriminator = schema._def.discriminator;
+        const options = schema._def.options || [];
+        const optionSignatures = options
+            .map((opt: ZodType) => generateZodStructuralSignature(opt))
+            .sort()
+            .join('|');
+        return `discUnion:${discriminator}:(${optionSignatures})`;
+    }
+
+    // Intersection type
+    if (typeName === 'ZodIntersection' || typeName === 'intersection') {
+        const left = generateZodStructuralSignature(schema._def.left);
+        const right = generateZodStructuralSignature(schema._def.right);
+        return `intersection:(${left}&${right})`;
+    }
+
+    // Literal type - include the literal value
+    if (typeName === 'ZodLiteral' || typeName === 'literal') {
+        const value = schema._def.value ?? (schema._def.values ? schema._def.values[0] : undefined);
+        return `literal:${JSON.stringify(value)}`;
+    }
+
+    // Enum type
+    if (typeName === 'ZodEnum' || typeName === 'enum') {
+        const values = schema._def.values || [];
+        return `enum:[${values.sort().join(',')}]`;
+    }
+
+    // Native enum type
+    if (typeName === 'ZodNativeEnum' || typeName === 'nativeEnum') {
+        const values = Object.values(schema._def.values || {}).sort();
+        return `nativeEnum:[${values.join(',')}]`;
+    }
+
+    // Record type
+    if (typeName === 'ZodRecord' || typeName === 'record') {
+        const keyType = generateZodStructuralSignature(schema._def.keyType);
+        const valueType = generateZodStructuralSignature(schema._def.valueType);
+        return `record:<${keyType},${valueType}>`;
+    }
+
+    // Map type
+    if (typeName === 'ZodMap' || typeName === 'map') {
+        const keyType = generateZodStructuralSignature(schema._def.keyType);
+        const valueType = generateZodStructuralSignature(schema._def.valueType);
+        return `map:<${keyType},${valueType}>`;
+    }
+
+    // Set type
+    if (typeName === 'ZodSet' || typeName === 'set') {
+        const valueType = generateZodStructuralSignature(schema._def.valueType);
+        return `set:<${valueType}>`;
+    }
+
+    // Promise type
+    if (typeName === 'ZodPromise' || typeName === 'promise') {
+        const inner = generateZodStructuralSignature(schema._def.type);
+        return `promise:${inner}`;
+    }
+
+    // Function type
+    if (typeName === 'ZodFunction' || typeName === 'function') {
+        const args = generateZodStructuralSignature(schema._def.args);
+        const returns = generateZodStructuralSignature(schema._def.returns);
+        return `function:(${args})=>${returns}`;
+    }
+
+    // Lazy type - be careful with infinite recursion
+    if (typeName === 'ZodLazy' || typeName === 'lazy') {
+        // For lazy types, we can't fully resolve without risking infinite recursion
+        // Use a placeholder that indicates it's a lazy type
+        return 'lazy:deferred';
+    }
+
+    // Fallback for unknown types
+    return typeName || 'unknown';
+}
+
+/**
+ * Normalize a signature for comparison.
+ * Currently just returns the signature as-is, but can be extended
+ * to handle canonicalization if needed.
+ */
+export function normalizeSignature(signature: string): string {
+    return signature;
+}
+
+/**
+ * Compare two schemas for structural equivalence.
+ */
+export function areStructurallyEquivalent(schema1: ZodType, schema2: ZodType): boolean {
+    const sig1 = normalizeSignature(generateZodStructuralSignature(schema1));
+    const sig2 = normalizeSignature(generateZodStructuralSignature(schema2));
+    return sig1 === sig2;
+}

package/gql/utils/index.ts

@@ -0,0 +1 @@
+export { generateZodStructuralSignature, normalizeSignature, areStructurallyEquivalent } from './TypeSignature';

package/gql/visitors/ArchetypePreprocessorVisitor.ts

@@ -0,0 +1,80 @@
+import { GraphVisitor } from "./GraphVisitor";
+import { TypeNode, OperationNode, FieldNode, InputNode, ScalarNode } from "../graph/GraphNode";
+import { weaveAllArchetypes, getAllArchetypeSchemas } from "../../core/ArcheType";
+
+/**
+ * Visitor that pre-processes archetype schemas before other visitors run.
+ * Ensures all archetype GraphQL schemas are generated and cached.
+ */
+export class ArchetypePreprocessorVisitor extends GraphVisitor {
+    private processedArchetypes: Set<string> = new Set();
+    private archetypeSchemas: any[] = [];
+
+    override beforeVisit(): void {
+        // Pre-weave all archetypes to ensure schemas are generated
+        try {
+            const schema = weaveAllArchetypes();
+            if (schema) {
+                this.archetypeSchemas = getAllArchetypeSchemas();
+            }
+        } catch (error) {
+            console.warn("Failed to pre-process archetype schemas:", error);
+        }
+    }
+
+    visitTypeNode(node: TypeNode): void {
+        // Check if this is an archetype type
+        if (node.metadata.isArchetype) {
+            this.processedArchetypes.add(node.name);
+        }
+    }
+
+    visitOperationNode(node: OperationNode): void {
+        // Operations may reference archetype types
+        // We don't need to do anything special here
+    }
+
+    visitFieldNode(node: FieldNode): void {
+        // Fields may be part of archetype types
+    }
+
+    visitInputNode(node: InputNode): void {
+        // Input nodes don't need archetype preprocessing
+    }
+
+    visitScalarNode(node: ScalarNode): void {
+        // Scalar nodes don't need archetype preprocessing
+    }
+
+    getResults(): {
+        processedArchetypes: string[];
+        archetypeSchemas: any[];
+    } {
+        return {
+            processedArchetypes: Array.from(this.processedArchetypes),
+            archetypeSchemas: [...this.archetypeSchemas]
+        };
+    }
+
+    /**
+     * Check if an archetype has been processed
+     */
+    isArchetypeProcessed(archetypeName: string): boolean {
+        return this.processedArchetypes.has(archetypeName);
+    }
+
+    /**
+     * Get all processed archetype names
+     */
+    getProcessedArchetypes(): string[] {
+        return Array.from(this.processedArchetypes);
+    }
+
+    /**
+     * Clear all processed data
+     */
+    clear(): void {
+        this.processedArchetypes.clear();
+        this.archetypeSchemas = [];
+    }
+}