@xrpckit/target-go-server 0.0.1 → 0.0.3

package/dist/index.d.ts

@@ -1,39 +1,6 @@
-import { BaseCodeGenerator, GeneratorConfig, GeneratedFiles, CodeWriter } from '@xrpckit/codegen';
-import { ContractDefinition, TypeReference } from '@xrpckit/parser';
+import { Target, CodeWriter, GeneratedUtility, ContractDefinition, TypeReference, TypeMapperBase, TypeMapping, ValidationMapperBase, ValidationMapping } from '@xrpckit/sdk';
 
-declare class GoCodeGenerator extends BaseCodeGenerator {
-    private typeGenerator;
-    private serverGenerator;
-    private validationGenerator;
-    constructor(config: GeneratorConfig);
-    generate(contract: ContractDefinition): GeneratedFiles;
-}
-
-declare class GoTypeGenerator {
-    private w;
-    private typeMapper;
-    private packageName;
-    constructor(packageName?: string);
-    generateTypes(contract: ContractDefinition): string;
-    private generateContextType;
-    private generateMiddlewareTypes;
-    private generateType;
-    private generateJSONTag;
-    private generateTypedHandlers;
-}
-
-declare class GoServerGenerator {
-    private w;
-    private packageName;
-    constructor(packageName?: string);
-    generateServer(contract: ContractDefinition): string;
-    private generateServeHTTP;
-}
-
-declare class GoTypeMapper {
-    mapType(typeRef: TypeReference): string;
-    mapPrimitive(type: string): string;
-}
+declare const goTarget: Target;
 
 /**
  * Go-specific code builder with fluent DSL for common Go patterns
@@ -63,4 +30,268 @@ declare class GoBuilder extends CodeWriter {
     blockComment(lines: string[]): this;
 }
 
-export { GoBuilder, GoCodeGenerator, GoServerGenerator, GoTypeGenerator, GoTypeMapper };
+/**
+ * Create a Go enum pattern with type, constants, IsValid, and Parse functions.
+ *
+ * @param name - The enum type name (PascalCase)
+ * @param values - The enum values (strings)
+ * @returns Generated utility with enum code
+ *
+ * @example
+ * ```typescript
+ * const utility = createGoEnumPattern("Status", ["active", "inactive", "pending"]);
+ * // Generates:
+ * // type Status string
+ * // const (
+ * //     StatusActive   Status = "active"
+ * //     StatusInactive Status = "inactive"
+ * //     StatusPending  Status = "pending"
+ * // )
+ * // func (s Status) IsValid() bool { ... }
+ * // func ParseStatus(s string) (Status, error) { ... }
+ * ```
+ */
+declare function createGoEnumPattern(name: string, values: (string | number)[]): GeneratedUtility;
+/**
+ * Create a Go BigInt pattern for handling large integers.
+ *
+ * @returns Generated utility with BigInt wrapper code
+ */
+declare function createGoBigIntPattern(): GeneratedUtility;
+/**
+ * Create a Go union wrapper pattern for discriminated unions.
+ *
+ * @param name - The union type name
+ * @param variants - The variant types (Go type names)
+ * @returns Generated utility with union wrapper code
+ *
+ * @example
+ * ```typescript
+ * const utility = createGoUnionPattern("Result", ["string", "int", "Error"]);
+ * // Generates a struct with Value interface{} and type assertion helpers
+ * ```
+ */
+declare function createGoUnionPattern(name: string, variants: string[]): GeneratedUtility;
+/**
+ * Create a Go tuple struct pattern.
+ *
+ * @param name - The tuple type name
+ * @param elements - The element types (Go type names)
+ * @returns Generated utility with tuple struct code
+ *
+ * @example
+ * ```typescript
+ * const utility = createGoTuplePattern("Coordinate", ["float64", "float64"]);
+ * // Generates:
+ * // type Coordinate struct {
+ * //     V0 float64 `json:"0"`
+ * //     V1 float64 `json:"1"`
+ * // }
+ * ```
+ */
+declare function createGoTuplePattern(name: string, elements: string[]): GeneratedUtility;
+/**
+ * Create a Go date/time utility pattern.
+ *
+ * @returns Generated utility with date helpers
+ */
+declare function createGoDatePattern(): GeneratedUtility;
+
+declare class GoServerGenerator {
+    private w;
+    private packageName;
+    constructor(packageName?: string);
+    generateServer(contract: ContractDefinition): string;
+    private generateServeHTTP;
+}
+
+interface CollectedType {
+    name: string;
+    typeRef: TypeReference;
+    source: string;
+}
+/**
+ * GoTypeCollector traverses a contract and collects all types that need
+ * Go struct generation, including nested inline objects that don't have names.
+ *
+ * This solves the problem where inline objects like:
+ *   tasks: z.array(z.object({ id: z.string() }))
+ *
+ * Would generate `[]interface{}` instead of a proper typed struct.
+ */
+declare class GoTypeCollector {
+    private collectedTypes;
+    private usedNames;
+    /**
+     * Collect all types from a contract that need Go struct generation.
+     * This includes:
+     * - Named types from contract.types
+     * - Anonymous inline objects nested in properties
+     * - Array element types that are inline objects
+     * - Optional/nullable wrapped inline objects
+     */
+    collectTypes(contract: ContractDefinition): CollectedType[];
+    /**
+     * Process a type definition and extract any nested inline types
+     */
+    private processTypeDefinition;
+    /**
+     * Process a property and extract any nested inline types
+     */
+    private processProperty;
+    /**
+     * Process a type reference and extract any nested inline types.
+     * This is the core function that handles all the different type kinds.
+     */
+    private processTypeReference;
+    /**
+     * Assign a unique name, adding numeric suffix if there's a collision
+     */
+    private assignUniqueName;
+    /**
+     * Get all collected nested types (not including the main contract types)
+     */
+    getCollectedTypes(): CollectedType[];
+}
+
+declare class GoTypeGenerator {
+    private w;
+    private typeMapper;
+    private packageName;
+    private generatedTypes;
+    constructor(packageName?: string);
+    /**
+     * Generate Go types from a contract definition.
+     * @param contract - The contract definition (should have names assigned to inline types)
+     * @param collectedTypes - Optional pre-collected nested types from GoTypeCollector
+     */
+    generateTypes(contract: ContractDefinition, collectedTypes?: CollectedType[]): string;
+    private generateContextType;
+    private generateMiddlewareTypes;
+    private generateType;
+    /**
+     * Generate a type from a TypeReference (used for nested inline types)
+     */
+    private generateTypeFromReference;
+    /**
+     * Generate struct types for tuples
+     */
+    private generateTupleTypes;
+    /**
+     * Generate wrapper struct types for unions
+     */
+    private generateUnionTypes;
+    /**
+     * Get a descriptive field name for a union variant
+     */
+    private getUnionFieldName;
+    private generateJSONTag;
+    private generateTypedHandlers;
+}
+
+/**
+ * Go type mapper that converts xRPC types to Go types.
+ * Extends TypeMapperBase to ensure all type kinds are handled.
+ */
+declare class GoTypeMapper extends TypeMapperBase<string> {
+    private tupleTypes;
+    private unionTypes;
+    /**
+     * Complete mapping of all type kinds to Go types.
+     * TypeScript enforces exhaustiveness at compile time.
+     */
+    readonly typeMapping: TypeMapping<string>;
+    /**
+     * Map a primitive base type to Go type.
+     */
+    mapPrimitive(type: string): string;
+    /**
+     * Get all registered tuple types that need struct generation
+     */
+    getTupleTypes(): Map<string, TypeReference>;
+    /**
+     * Get all registered union types that need wrapper struct generation
+     */
+    getUnionTypes(): Map<string, TypeReference>;
+    /**
+     * Reset the type registries (call between generation runs)
+     */
+    reset(): void;
+    private handleObject;
+    private handleArray;
+    private handlePrimitive;
+    private handleOptional;
+    private handleNullable;
+    private handleUnion;
+    private handleEnum;
+    private handleLiteral;
+    private handleRecord;
+    private handleTuple;
+    private handleDate;
+}
+
+declare class GoValidationGenerator {
+    private w;
+    private packageName;
+    private generatedValidations;
+    constructor(packageName?: string);
+    /**
+     * Generate Go validation functions from a contract definition.
+     * @param contract - The contract definition (should have names assigned to inline types)
+     * @param collectedTypes - Optional pre-collected nested types from GoTypeCollector
+     */
+    generateValidation(contract: ContractDefinition, collectedTypes?: CollectedType[]): string;
+    private generateErrorTypes;
+    private generateTypeValidation;
+    private generatePropertyValidation;
+    private generatePropertyValidationForValue;
+    private generateValidationRules;
+    private hasValidationRule;
+    private checkTypeForValidationRule;
+    private checkTypeRefForValidationRule;
+    private generateHelperFunctions;
+    private unwrapOptionalNullable;
+    private getActualType;
+    private getEnumValues;
+    private isPointerType;
+}
+
+/**
+ * Represents a Go validation check with its code and required imports.
+ */
+interface GoValidationCode {
+    /** The Go condition expression (e.g., "len(field) < 5") */
+    condition: string;
+    /** The error message to display if validation fails */
+    message: string;
+    /** Required Go imports for this validation */
+    imports?: string[];
+    /** Whether this validation should be wrapped in a non-empty check for optional fields */
+    skipIfEmpty?: boolean;
+}
+/**
+ * Go validation mapper that converts xRPC validation rules to Go validation code.
+ * Extends ValidationMapperBase to ensure all validation kinds are handled.
+ */
+declare class GoValidationMapper extends ValidationMapperBase<GoValidationCode> {
+    /**
+     * Complete mapping of all validation kinds to Go validation code.
+     * TypeScript enforces exhaustiveness at compile time.
+     */
+    readonly validationMapping: ValidationMapping<GoValidationCode>;
+    private handleMinLength;
+    private handleMaxLength;
+    private handleEmail;
+    private handleUrl;
+    private handleUuid;
+    private handleRegex;
+    private handleMin;
+    private handleMax;
+    private handleInt;
+    private handlePositive;
+    private handleNegative;
+    private handleMinItems;
+    private handleMaxItems;
+}
+
+export { type CollectedType, GoBuilder, GoServerGenerator, GoTypeCollector, GoTypeGenerator, GoTypeMapper, type GoValidationCode, GoValidationGenerator, GoValidationMapper, createGoBigIntPattern, createGoDatePattern, createGoEnumPattern, createGoTuplePattern, createGoUnionPattern, goTarget };