@xrpckit/target-go-server 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,66 @@
+import { BaseCodeGenerator, GeneratorConfig, GeneratedFiles, CodeWriter } from '@xrpckit/codegen';
+import { ContractDefinition, TypeReference } from '@xrpckit/parser';
+
+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;
+}
+
+/**
+ * Go-specific code builder with fluent DSL for common Go patterns
+ */
+declare class GoBuilder extends CodeWriter {
+    l(text: string): this;
+    n(): this;
+    i(): this;
+    u(): this;
+    package(name: string): this;
+    import(...packages: string[]): this;
+    type(name: string, typeDef: string): this;
+    struct(name: string, fn: (b: this) => void): this;
+    anonStruct(fn: (b: this) => void): this;
+    func(signature: string, fn?: (b: this) => void): this;
+    method(receiver: string, name: string, params: string, returns: string, fn: (b: this) => void): this;
+    if(condition: string, fn: (b: this) => void): this;
+    ifErr(fn: (b: this) => void): this;
+    return(value?: string): this;
+    var(name: string, type?: string, value?: string): this;
+    decl(name: string, value: string): this;
+    switch(value: string, cases: Array<{
+        value: string;
+        fn: (b: GoBuilder) => void;
+    }>, defaultCase?: (b: GoBuilder) => void): this;
+    comment(text: string): this;
+    blockComment(lines: string[]): this;
+}
+
+export { GoBuilder, GoCodeGenerator, GoServerGenerator, GoTypeGenerator, GoTypeMapper };

package/dist/index.js

@@ -0,0 +1,725 @@
+// src/generator.ts
+import { BaseCodeGenerator } from "@xrpckit/codegen";
+
+// src/go-builder.ts
+import { CodeWriter } from "@xrpckit/codegen";
+var GoBuilder = class extends CodeWriter {
+  // Short aliases
+  l(text) {
+    return this.writeLine(text);
+  }
+  n() {
+    return this.newLine();
+  }
+  i() {
+    return this.indent();
+  }
+  u() {
+    return this.unindent();
+  }
+  // Go-specific patterns
+  package(name) {
+    return this.l(`package ${name}`).n();
+  }
+  import(...packages) {
+    if (packages.length === 0) return this;
+    if (packages.length === 1) {
+      return this.l(`import "${packages[0]}"`).n();
+    }
+    this.l("import (").i();
+    for (const pkg of packages) {
+      this.l(`"${pkg}"`);
+    }
+    return this.u().l(")").n();
+  }
+  type(name, typeDef) {
+    return this.l(`type ${name} ${typeDef}`).n();
+  }
+  struct(name, fn) {
+    this.l(`type ${name} struct {`).i();
+    fn(this);
+    return this.u().l("}").n();
+  }
+  // Anonymous struct
+  anonStruct(fn) {
+    this.l("struct {").i();
+    fn(this);
+    return this.u().l("}");
+  }
+  func(signature, fn) {
+    if (fn) {
+      this.write(`func ${signature} {`);
+      this.indent();
+      fn(this);
+      this.unindent();
+      this.writeLine("}");
+      this.newLine();
+    } else {
+      this.l(`func ${signature}`);
+      this.n();
+    }
+    return this;
+  }
+  method(receiver, name, params, returns, fn) {
+    const sig = returns ? `${name}(${params}) ${returns}` : `${name}(${params})`;
+    return this.func(`(${receiver}) ${sig}`, fn);
+  }
+  if(condition, fn) {
+    this.l(`if ${condition} {`).i();
+    fn(this);
+    return this.u().l("}");
+  }
+  ifErr(fn) {
+    return this.if("err != nil", fn);
+  }
+  return(value) {
+    return value ? this.l(`return ${value}`) : this.l("return");
+  }
+  var(name, type, value) {
+    if (type && value) {
+      return this.l(`var ${name} ${type} = ${value}`);
+    } else if (type) {
+      return this.l(`var ${name} ${type}`);
+    } else if (value) {
+      return this.l(`${name} := ${value}`);
+    }
+    return this.l(`var ${name}`);
+  }
+  // Declare variable with type inference
+  decl(name, value) {
+    return this.l(`${name} := ${value}`);
+  }
+  switch(value, cases, defaultCase) {
+    this.l(`switch ${value} {`).i();
+    for (const c of cases) {
+      this.l(`case ${c.value}:`).i();
+      c.fn(this);
+      this.u();
+    }
+    if (defaultCase) {
+      this.l("default:").i();
+      defaultCase(this);
+      this.u();
+    }
+    return this.u().l("}");
+  }
+  comment(text) {
+    return this.l(`// ${text}`);
+  }
+  blockComment(lines) {
+    this.l("/*");
+    for (const line of lines) {
+      this.l(` * ${line}`);
+    }
+    return this.l(" */");
+  }
+};
+
+// src/type-mapper.ts
+import { toPascalCase } from "@xrpckit/codegen";
+var GoTypeMapper = class {
+  mapType(typeRef) {
+    if (typeRef.kind === "optional") {
+      if (typeof typeRef.baseType === "object") {
+        return this.mapType(typeRef.baseType);
+      }
+      return "interface{}";
+    }
+    if (typeRef.kind === "nullable") {
+      if (typeof typeRef.baseType === "object") {
+        return `*${this.mapType(typeRef.baseType)}`;
+      }
+      return "*interface{}";
+    }
+    if (typeRef.kind === "array") {
+      return `[]${this.mapType(typeRef.elementType)}`;
+    }
+    if (typeRef.kind === "object") {
+      if (typeRef.name) {
+        return toPascalCase(typeRef.name);
+      }
+      return "interface{}";
+    }
+    if (typeRef.kind === "record") {
+      const valueType = typeRef.valueType ? this.mapType(typeRef.valueType) : "interface{}";
+      return `map[string]${valueType}`;
+    }
+    if (typeRef.kind === "tuple") {
+      return "[]interface{}";
+    }
+    if (typeRef.kind === "union") {
+      return "interface{}";
+    }
+    if (typeRef.kind === "enum") {
+      return "string";
+    }
+    if (typeRef.kind === "literal") {
+      if (typeof typeRef.literalValue === "string") {
+        return "string";
+      } else if (typeof typeRef.literalValue === "number") {
+        return "float64";
+      } else if (typeof typeRef.literalValue === "boolean") {
+        return "bool";
+      }
+      return "interface{}";
+    }
+    if (typeRef.kind === "date") {
+      return "time.Time";
+    }
+    if (typeRef.kind === "primitive") {
+      const baseType = typeof typeRef.baseType === "string" ? typeRef.baseType : "unknown";
+      return this.mapPrimitive(baseType);
+    }
+    return "interface{}";
+  }
+  mapPrimitive(type) {
+    const mapping = {
+      string: "string",
+      number: "float64",
+      integer: "int",
+      boolean: "bool",
+      date: "time.Time",
+      uuid: "string",
+      email: "string"
+    };
+    return mapping[type] || "interface{}";
+  }
+};
+
+// src/type-generator.ts
+import { toPascalCase as toPascalCase2 } from "@xrpckit/codegen";
+function toMethodName(fullName) {
+  return fullName.split(".").map((part) => toPascalCase2(part)).join("");
+}
+var GoTypeGenerator = class {
+  w;
+  typeMapper;
+  packageName;
+  constructor(packageName = "server") {
+    this.w = new GoBuilder();
+    this.typeMapper = new GoTypeMapper();
+    this.packageName = packageName;
+  }
+  generateTypes(contract) {
+    const w = this.w.reset();
+    w.package(this.packageName).import("net/http");
+    this.generateContextType();
+    this.generateMiddlewareTypes();
+    for (const type of contract.types) {
+      this.generateType(type);
+    }
+    this.generateTypedHandlers(contract);
+    return w.toString();
+  }
+  generateContextType() {
+    this.w.struct("Context", (b) => {
+      b.l("Request        *http.Request").l("ResponseWriter http.ResponseWriter").l("Data           map[string]interface{}");
+    }).n();
+    this.w.comment("GetUserId retrieves userId from context if set by middleware").n().func("GetUserId(ctx *Context) (string, bool)", (b) => {
+      b.if('val, ok := ctx.Data["userId"].(string); ok', (b2) => {
+        b2.return("val, true");
+      });
+      b.return('"", false');
+    }).n();
+    this.w.comment("GetSessionId retrieves sessionId from context if set by middleware").n().func("GetSessionId(ctx *Context) (string, bool)", (b) => {
+      b.if('val, ok := ctx.Data["sessionId"].(string); ok', (b2) => {
+        b2.return("val, true");
+      });
+      b.return('"", false');
+    }).n();
+  }
+  generateMiddlewareTypes() {
+    this.w.comment("MiddlewareFunc is a function that processes a request and extends context").n().type("MiddlewareFunc", "func(ctx *Context) *MiddlewareResult").n();
+    this.w.struct("MiddlewareResult", (b) => {
+      b.l("Context  *Context").l("Error    error").l("Response *http.Response");
+    }).n();
+    this.w.comment("NewMiddlewareResult creates a successful middleware result").n().func("NewMiddlewareResult(ctx *Context) *MiddlewareResult", (b) => {
+      b.return("&MiddlewareResult{Context: ctx}");
+    }).n();
+    this.w.comment("NewMiddlewareError creates a middleware result with an error").n().func("NewMiddlewareError(err error) *MiddlewareResult", (b) => {
+      b.return("&MiddlewareResult{Error: err}");
+    }).n();
+    this.w.comment("NewMiddlewareResponse creates a middleware result that short-circuits with a response").n().func("NewMiddlewareResponse(resp *http.Response) *MiddlewareResult", (b) => {
+      b.return("&MiddlewareResult{Response: resp}");
+    }).n();
+  }
+  generateType(type) {
+    const typeName = toPascalCase2(type.name);
+    if (type.kind === "array" && type.elementType) {
+      if (type.elementType.kind === "object" && type.elementType.properties) {
+        const elementTypeName = typeName + "Item";
+        this.w.struct(elementTypeName, (b) => {
+          for (const prop of type.elementType.properties) {
+            const goType = this.typeMapper.mapType(prop.type);
+            const jsonTag = this.generateJSONTag(prop);
+            b.l(`${toPascalCase2(prop.name)} ${goType} \`${jsonTag}\``);
+          }
+        });
+        this.w.type(typeName, `[]${elementTypeName}`);
+      } else {
+        const elementGoType = this.typeMapper.mapType(type.elementType);
+        this.w.type(typeName, `[]${elementGoType}`);
+      }
+      return;
+    }
+    this.w.struct(typeName, (b) => {
+      if (type.properties) {
+        for (const prop of type.properties) {
+          const goType = this.typeMapper.mapType(prop.type);
+          const jsonTag = this.generateJSONTag(prop);
+          b.l(`${toPascalCase2(prop.name)} ${goType} \`${jsonTag}\``);
+        }
+      }
+    });
+  }
+  generateJSONTag(prop) {
+    if (prop.required) {
+      return `json:"${prop.name}"`;
+    }
+    return `json:"${prop.name},omitempty"`;
+  }
+  generateTypedHandlers(contract) {
+    this.w.comment("Typed handler types for each endpoint").n();
+    for (const endpoint of contract.endpoints) {
+      const handlerName = toMethodName(endpoint.fullName) + "Handler";
+      const inputType = toPascalCase2(endpoint.input.name);
+      const outputType = toPascalCase2(endpoint.output.name);
+      this.w.comment(`Handler type for ${endpoint.fullName}`).type(handlerName, `func(ctx *Context, input ${inputType}) (${outputType}, error)`).n();
+    }
+  }
+};
+
+// src/server-generator.ts
+import { toPascalCase as toPascalCase3 } from "@xrpckit/codegen";
+function toMethodName2(fullName) {
+  return fullName.split(".").map((part) => toPascalCase3(part)).join("");
+}
+function toFieldName(fullName) {
+  return fullName.split(".").map((part, i) => i === 0 ? part : toPascalCase3(part)).join("");
+}
+var GoServerGenerator = class {
+  w;
+  packageName;
+  constructor(packageName = "server") {
+    this.w = new GoBuilder();
+    this.packageName = packageName;
+  }
+  generateServer(contract) {
+    const w = this.w.reset();
+    w.package(this.packageName).import("encoding/json", "net/http", "fmt");
+    w.struct("Router", (b) => {
+      b.l("middleware []MiddlewareFunc");
+      for (const endpoint of contract.endpoints) {
+        const fieldName = toFieldName(endpoint.fullName);
+        const handlerType = toMethodName2(endpoint.fullName) + "Handler";
+        b.l(`${fieldName} ${handlerType}`);
+      }
+    });
+    w.func("NewRouter() *Router", (b) => {
+      b.l("return &Router{").i().l("middleware: make([]MiddlewareFunc, 0),").u().l("}");
+    });
+    for (const endpoint of contract.endpoints) {
+      const methodName = toMethodName2(endpoint.fullName);
+      const fieldName = toFieldName(endpoint.fullName);
+      const handlerType = methodName + "Handler";
+      w.method("r *Router", methodName, `handler ${handlerType}`, "*Router", (b) => {
+        b.l(`r.${fieldName} = handler`).return("r");
+      });
+    }
+    w.method("r *Router", "Use", "middleware MiddlewareFunc", "*Router", (b) => {
+      b.l("r.middleware = append(r.middleware, middleware)").return("r");
+    });
+    this.generateServeHTTP(contract.endpoints, w);
+    return w.toString();
+  }
+  generateServeHTTP(endpoints, w) {
+    w.method("r *Router", "ServeHTTP", "w http.ResponseWriter, req *http.Request", "", (b) => {
+      b.if("req.Method != http.MethodPost", (b2) => {
+        b2.l('http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)').return();
+      }).n();
+      b.var("request", "struct {").i().l('Method string          `json:"method"`').l('Params json.RawMessage `json:"params"`').u().l("}").n();
+      b.if("err := json.NewDecoder(req.Body).Decode(&request); err != nil", (b2) => {
+        b2.l('http.Error(w, fmt.Sprintf("Invalid request: %v", err), http.StatusBadRequest)').return();
+      }).n();
+      b.decl("ctx", "&Context{").i().l("Request:        req,").l("ResponseWriter: w,").l("Data:           make(map[string]interface{}),").u().l("}").n();
+      b.comment("Execute middleware chain").l("for _, middleware := range r.middleware {").i().decl("result", "middleware(ctx)").if("result.Error != nil", (b2) => {
+        b2.l('http.Error(w, fmt.Sprintf("Middleware error: %v", result.Error), http.StatusInternalServerError)').return();
+      }).if("result.Response != nil", (b2) => {
+        b2.comment("Middleware short-circuited with response").return();
+      }).l("ctx = result.Context").u().l("}").n();
+      const cases = endpoints.map((endpoint) => ({
+        value: `"${endpoint.fullName}"`,
+        fn: (b2) => {
+          const fieldName = toFieldName(endpoint.fullName);
+          b2.if(`r.${fieldName} == nil`, (b3) => {
+            b3.l('http.Error(w, "Handler not registered", http.StatusNotFound)').return();
+          }).n();
+          const inputTypeName = toPascalCase3(endpoint.input.name);
+          b2.var("input", inputTypeName);
+          b2.if("err := json.Unmarshal(request.Params, &input); err != nil", (b3) => {
+            b3.l('http.Error(w, fmt.Sprintf("Invalid params: %v", err), http.StatusBadRequest)').return();
+          }).n();
+          const validationFuncName = `Validate${inputTypeName}`;
+          b2.if(`err := ${validationFuncName}(input); err != nil`, (b3) => {
+            b3.l('w.Header().Set("Content-Type", "application/json")').l("w.WriteHeader(http.StatusBadRequest)");
+            b3.l("if validationErrs, ok := err.(ValidationErrors); ok {").i().l("json.NewEncoder(w).Encode(map[string]interface{}{").i().l('"error": "Validation failed",').l('"errors": validationErrs,').u().l("})").u().l("} else {").i().l("json.NewEncoder(w).Encode(map[string]interface{}{").i().l('"error": err.Error(),').u().l("})").u().l("}");
+            b3.return();
+          }).n();
+          b2.decl("result, err", `r.${fieldName}(ctx, input)`);
+          b2.ifErr((b3) => {
+            b3.l('w.Header().Set("Content-Type", "application/json")').l('json.NewEncoder(w).Encode(map[string]interface{}{"error": err.Error()})').return();
+          }).n();
+          b2.l('w.Header().Set("Content-Type", "application/json")').l('json.NewEncoder(w).Encode(map[string]interface{}{"result": result})').return();
+        }
+      }));
+      w.switch("request.Method", cases, (b2) => {
+        b2.l('http.Error(w, "Method not found", http.StatusNotFound)').return();
+      });
+    });
+  }
+};
+
+// src/validation-generator.ts
+import { toPascalCase as toPascalCase4 } from "@xrpckit/codegen";
+var GoValidationGenerator = class {
+  w;
+  packageName;
+  constructor(packageName = "server") {
+    this.w = new GoBuilder();
+    this.packageName = packageName;
+  }
+  generateValidation(contract) {
+    const w = this.w.reset();
+    const imports = /* @__PURE__ */ new Set(["fmt", "strings"]);
+    const needsRegex = this.hasValidationRule(
+      contract,
+      (rules) => rules.uuid || rules.regex && !rules.email
+      // regex but not email (email uses mail)
+    );
+    const needsMail = this.hasValidationRule(
+      contract,
+      (rules) => rules.email
+    );
+    const needsURL = this.hasValidationRule(
+      contract,
+      (rules) => rules.url
+    );
+    if (needsRegex) imports.add("regexp");
+    if (needsMail) imports.add("net/mail");
+    if (needsURL) imports.add("net/url");
+    w.package(this.packageName);
+    if (imports.size > 0) {
+      w.import(...Array.from(imports));
+    }
+    this.generateErrorTypes(w);
+    for (const type of contract.types) {
+      if (type.kind === "object" && type.properties) {
+        this.generateTypeValidation(type, w);
+      } else if (type.kind === "array" && type.elementType?.kind === "object" && type.elementType.properties) {
+        const elementTypeName = toPascalCase4(type.name) + "Item";
+        const elementType = {
+          name: elementTypeName,
+          kind: "object",
+          properties: type.elementType.properties
+        };
+        this.generateTypeValidation(elementType, w);
+      }
+    }
+    this.generateHelperFunctions(w);
+    return w.toString();
+  }
+  generateErrorTypes(w) {
+    w.struct("ValidationError", (b) => {
+      b.l('Field   string `json:"field"`').l('Message string `json:"message"`');
+    }).n();
+    w.type("ValidationErrors", "[]*ValidationError").n();
+    w.method("e *ValidationError", "Error", "", "string", (b) => {
+      b.return('fmt.Sprintf("%s: %s", e.Field, e.Message)');
+    }).n();
+    w.method("e ValidationErrors", "Error", "", "string", (b) => {
+      b.var("msgs", "[]string");
+      b.l("for _, err := range e {").i().l("msgs = append(msgs, err.Error())").u().l("}");
+      b.return('strings.Join(msgs, "; ")');
+    }).n();
+  }
+  generateTypeValidation(type, w) {
+    const typeName = toPascalCase4(type.name);
+    const funcName = `Validate${typeName}`;
+    w.func(`${funcName}(input ${typeName}) error`, (b) => {
+      b.var("errs", "ValidationErrors");
+      if (type.properties) {
+        for (const prop of type.properties) {
+          this.generatePropertyValidation(prop, "input", type, b);
+        }
+      }
+      b.if("len(errs) > 0", (b2) => {
+        b2.return("errs");
+      });
+      b.return("nil");
+    }).n();
+  }
+  generatePropertyValidation(prop, prefix, parentType, w) {
+    const fieldName = toPascalCase4(prop.name);
+    const fieldPath = `${prefix}.${fieldName}`;
+    const fieldPathStr = prop.name;
+    const actualType = this.getActualType(prop.type);
+    const isString = actualType === "string";
+    const isNumber = actualType === "number";
+    const isArray = prop.type.kind === "array";
+    if (prop.required) {
+      w.comment(`Validate ${prop.name}`);
+      if (isString) {
+        w.if(`${fieldPath} == ""`, (b) => {
+          b.l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: "is required",`).u().l(`})`);
+        });
+      } else if (isNumber) {
+      } else if (isArray) {
+        w.if(`${fieldPath} == nil`, (b) => {
+          b.l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: "is required",`).u().l(`})`);
+        });
+      }
+    }
+    const validationRules = prop.validation || prop.type.validation;
+    if (validationRules) {
+      if (!prop.required) {
+        if (isString) {
+          w.if(`${fieldPath} != ""`, (b) => {
+            const validationTypeRef = {
+              kind: "primitive",
+              baseType: actualType
+            };
+            this.generateValidationRules(validationRules, fieldPath, fieldPathStr, validationTypeRef, b, false);
+          });
+        } else if (isNumber) {
+          const validationTypeRef = {
+            kind: "primitive",
+            baseType: actualType
+          };
+          this.generateValidationRules(validationRules, fieldPath, fieldPathStr, validationTypeRef, w, false);
+        } else if (isArray) {
+          w.if(`${fieldPath} != nil`, (b) => {
+            this.generateValidationRules(validationRules, fieldPath, fieldPathStr, prop.type, b, false);
+          });
+        } else {
+          this.generateValidationRules(validationRules, fieldPath, fieldPathStr, prop.type, w, false);
+        }
+      } else {
+        if (isArray) {
+          this.generateValidationRules(validationRules, fieldPath, fieldPathStr, prop.type, w, prop.required);
+        } else {
+          const validationTypeRef = {
+            kind: "primitive",
+            baseType: actualType
+          };
+          this.generateValidationRules(validationRules, fieldPath, fieldPathStr, validationTypeRef, w, prop.required);
+        }
+      }
+    }
+    if (prop.type.kind === "object" && prop.type.name) {
+      const nestedTypeName = toPascalCase4(prop.type.name);
+      const nestedFuncName = `Validate${nestedTypeName}`;
+      w.if(`${fieldPath} != nil`, (b) => {
+        b.l(`if err := ${nestedFuncName}(${fieldPath}); err != nil {`).i().l(`if nestedErrs, ok := err.(ValidationErrors); ok {`).i().l(`errs = append(errs, nestedErrs...)`).u().l(`} else {`).i().l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: err.Error(),`).u().l(`})`).u().l(`}`).u().l(`}`);
+      });
+    } else if (prop.type.kind === "object" && prop.type.properties) {
+      w.if(`${fieldPath} != nil`, (b) => {
+        for (const nestedProp of prop.type.properties || []) {
+          const inlineType = {
+            name: "",
+            kind: "object",
+            properties: prop.type.properties
+          };
+          this.generatePropertyValidation(nestedProp, fieldPath, inlineType, b);
+        }
+      });
+    }
+    if (prop.type.kind === "array" && prop.type.elementType) {
+      if (prop.type.elementType.kind === "object" && prop.type.elementType.name) {
+        const elementTypeName = toPascalCase4(prop.type.elementType.name);
+        const elementFuncName = `Validate${elementTypeName}`;
+        w.l(`for i, item := range ${fieldPath} {`).i().l(`if err := ${elementFuncName}(item); err != nil {`).i().l(`if nestedErrs, ok := err.(ValidationErrors); ok {`).i().l(`for _, nestedErr := range nestedErrs {`).i().l(`errs = append(errs, &ValidationError{`).i().l(`Field:   fmt.Sprintf("${fieldPathStr}[%%d].%%s", i, nestedErr.Field),`).l(`Message: nestedErr.Message,`).u().l(`})`).u().l(`}`).u().l(`}`).u().l(`}`).u().l(`}`);
+      } else if (prop.type.elementType.kind === "object" && prop.type.elementType.properties) {
+        w.l(`for i, item := range ${fieldPath} {`).i();
+        const inlineType = {
+          name: "",
+          kind: "object",
+          properties: prop.type.elementType.properties
+        };
+        for (const nestedProp of prop.type.elementType.properties || []) {
+          this.generatePropertyValidation(nestedProp, "item", inlineType, w);
+        }
+        w.u().l(`}`);
+      }
+    }
+  }
+  generateValidationRules(rules, fieldPath, fieldPathStr, typeRef, w, isRequired = false) {
+    if (typeRef.baseType === "string") {
+      if (rules.minLength !== void 0) {
+        const minLengthCondition = isRequired ? `${fieldPath} != "" && len(${fieldPath}) < ${rules.minLength}` : `len(${fieldPath}) < ${rules.minLength}`;
+        w.if(minLengthCondition, (b) => {
+          b.l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: fmt.Sprintf("must be at least %d character(s)", ${rules.minLength}),`).u().l(`})`);
+        });
+      }
+      if (rules.maxLength !== void 0) {
+        w.if(`len(${fieldPath}) > ${rules.maxLength}`, (b) => {
+          b.l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: fmt.Sprintf("must be at most %d character(s)", ${rules.maxLength}),`).u().l(`})`);
+        });
+      }
+      if (rules.email) {
+        if (isRequired) {
+          w.if(`${fieldPath} != ""`, (b) => {
+            b.l(`if _, err := mail.ParseAddress(${fieldPath}); err != nil {`).i().l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must be a valid email address",`).u().l(`})`).u().l(`}`);
+          });
+        } else {
+          w.l(`if _, err := mail.ParseAddress(${fieldPath}); err != nil {`).i().l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must be a valid email address",`).u().l(`})`).u().l(`}`);
+        }
+      }
+      if (rules.url) {
+        if (isRequired) {
+          w.if(`${fieldPath} != ""`, (b) => {
+            b.l(`if u, err := url.Parse(${fieldPath}); err != nil || u.Scheme == "" || u.Host == "" {`).i().l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must be a valid URL",`).u().l(`})`).u().l(`}`);
+          });
+        } else {
+          w.l(`if u, err := url.Parse(${fieldPath}); err != nil || u.Scheme == "" || u.Host == "" {`).i().l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must be a valid URL",`).u().l(`})`).u().l(`}`);
+        }
+      }
+      if (rules.uuid) {
+        if (isRequired) {
+          w.if(`${fieldPath} != ""`, (b) => {
+            b.l(`matched, _ := regexp.MatchString("^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", ${fieldPath})`).n().l(`if !matched {`).i().l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must be a valid UUID",`).u().l(`})`).u().l(`}`);
+          });
+        } else {
+          w.l(`matched, _ := regexp.MatchString("^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", ${fieldPath})`).n().l(`if !matched {`).i().l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must be a valid UUID",`).u().l(`})`).u().l(`}`);
+        }
+      }
+      if (rules.regex && !rules.email && !rules.url && !rules.uuid) {
+        if (isRequired) {
+          w.if(`${fieldPath} != ""`, (b) => {
+            const escapedRegex = rules.regex.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+            b.l(`matched, _ := regexp.MatchString("${escapedRegex}", ${fieldPath})`).n().l(`if !matched {`).i().l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must match the required pattern",`).u().l(`})`).u().l(`}`);
+          });
+        } else {
+          const escapedRegex = rules.regex.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+          w.l(`matched, _ := regexp.MatchString("${escapedRegex}", ${fieldPath})`).n().l(`if !matched {`).i().l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must match the required pattern",`).u().l(`})`).u().l(`}`);
+        }
+      }
+    } else if (typeRef.baseType === "number") {
+      if (rules.min !== void 0) {
+        w.if(`${fieldPath} < ${rules.min}`, (b) => {
+          b.l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: fmt.Sprintf("must be at least %v", ${rules.min}),`).u().l(`})`);
+        });
+      }
+      if (rules.max !== void 0) {
+        w.if(`${fieldPath} > ${rules.max}`, (b) => {
+          b.l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: fmt.Sprintf("must be at most %v", ${rules.max}),`).u().l(`})`);
+        });
+      }
+      if (rules.int) {
+        w.if(`float64(${fieldPath}) != float64(int64(${fieldPath}))`, (b) => {
+          b.l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must be an integer",`).u().l(`})`);
+        });
+      }
+      if (rules.positive) {
+        w.if(`${fieldPath} <= 0`, (b) => {
+          b.l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must be positive",`).u().l(`})`);
+        });
+      }
+      if (rules.negative) {
+        w.if(`${fieldPath} >= 0`, (b) => {
+          b.l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: "must be negative",`).u().l(`})`);
+        });
+      }
+    } else if (typeRef.kind === "array") {
+      const arrayCheckCondition = isRequired ? `${fieldPath} != nil` : `${fieldPath} != nil`;
+      if (rules.minItems !== void 0) {
+        w.if(`${arrayCheckCondition} && len(${fieldPath}) < ${rules.minItems}`, (b) => {
+          b.l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: fmt.Sprintf("must have at least %d item(s)", ${rules.minItems}),`).u().l(`})`);
+        });
+      }
+      if (rules.maxItems !== void 0) {
+        w.if(`${arrayCheckCondition} && len(${fieldPath}) > ${rules.maxItems}`, (b) => {
+          b.l(`errs = append(errs, &ValidationError{`).i().l(`Field:   "${fieldPathStr}",`).l(`Message: fmt.Sprintf("must have at most %d item(s)", ${rules.maxItems}),`).u().l(`})`);
+        });
+      }
+    }
+  }
+  hasValidationRule(contract, check) {
+    for (const type of contract.types) {
+      if (type.properties) {
+        for (const prop of type.properties) {
+          if (prop.validation && check(prop.validation)) {
+            return true;
+          }
+          if (prop.type.properties) {
+            for (const nestedProp of prop.type.properties) {
+              if (nestedProp.validation && check(nestedProp.validation)) {
+                return true;
+              }
+            }
+          }
+          if (prop.type.elementType?.properties) {
+            for (const elemProp of prop.type.elementType.properties) {
+              if (elemProp.validation && check(elemProp.validation)) {
+                return true;
+              }
+            }
+          }
+        }
+      }
+      if (type.elementType?.validation && check(type.elementType.validation)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  generateHelperFunctions(w) {
+  }
+  getActualType(typeRef) {
+    if (typeRef.kind === "optional" || typeRef.kind === "nullable") {
+      if (typeRef.baseType) {
+        if (typeof typeRef.baseType === "string") {
+          return typeRef.baseType;
+        }
+        return this.getActualType(typeRef.baseType);
+      }
+    }
+    if (typeof typeRef.baseType === "string") {
+      return typeRef.baseType;
+    }
+    if (typeRef.baseType) {
+      return this.getActualType(typeRef.baseType);
+    }
+    return "unknown";
+  }
+  toPascalCase(str) {
+    return str.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+  }
+};
+
+// src/generator.ts
+var GoCodeGenerator = class extends BaseCodeGenerator {
+  typeGenerator;
+  serverGenerator;
+  validationGenerator;
+  constructor(config) {
+    super(config);
+    const packageName = config.packageName || "server";
+    this.typeGenerator = new GoTypeGenerator(packageName);
+    this.serverGenerator = new GoServerGenerator(packageName);
+    this.validationGenerator = new GoValidationGenerator(packageName);
+  }
+  generate(contract) {
+    return {
+      types: this.typeGenerator.generateTypes(contract),
+      server: this.serverGenerator.generateServer(contract),
+      validation: this.validationGenerator.generateValidation(contract)
+    };
+  }
+};
+export {
+  GoBuilder,
+  GoCodeGenerator,
+  GoServerGenerator,
+  GoTypeGenerator,
+  GoTypeMapper
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@xrpckit/target-go-server",
+  "version": "0.0.1",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mwesox/xrpc.git",
+    "directory": "packages/target-go-server"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean"
+  },
+  "dependencies": {
+    "@xrpckit/codegen": "^0.0.1",
+    "@xrpckit/parser": "^0.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}