@xrpckit/target-go-server 0.0.1 → 0.0.3

package/package.json

@@ -1,13 +1,29 @@
 {
   "name": "@xrpckit/target-go-server",
-  "version": "0.0.1",
+  "version": "0.0.3",
+  "description": "Go server code generator for xRPC - generates idiomatic Go HTTP handlers from contracts",
   "type": "module",
   "license": "MIT",
+  "author": "mwesox",
   "repository": {
     "type": "git",
-    "url": "https://github.com/mwesox/xrpc.git",
+    "url": "git+https://github.com/mwesox/xrpc.git",
     "directory": "packages/target-go-server"
   },
+  "bugs": {
+    "url": "https://github.com/mwesox/xrpc/issues"
+  },
+  "homepage": "https://github.com/mwesox/xrpc#readme",
+  "keywords": [
+    "xrpc",
+    "rpc",
+    "go",
+    "golang",
+    "server",
+    "codegen",
+    "api",
+    "type-safe"
+  ],
   "publishConfig": {
     "access": "public"
   },
@@ -21,14 +37,14 @@
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "src"
   ],
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts --clean"
   },
   "dependencies": {
-    "@xrpckit/codegen": "^0.0.1",
-    "@xrpckit/parser": "^0.0.1"
+    "@xrpckit/sdk": "^0.0.3"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",

package/src/generator.ts

@@ -0,0 +1,204 @@
+import {
+  type ContractDefinition,
+  type Property,
+  type Target,
+  type TargetInput,
+  type TargetOutput,
+  type TargetSupport,
+  TYPE_KINDS,
+  type TypeDefinition,
+  type TypeReference,
+  toPascalCase,
+  VALIDATION_KINDS,
+  validateSupport,
+} from "@xrpckit/sdk";
+import { GoServerGenerator } from "./server-generator";
+import { GoTypeCollector } from "./type-collector";
+import { GoTypeGenerator } from "./type-generator";
+import { GoValidationGenerator } from "./validation-generator";
+
+/**
+ * Go server code generator that produces idiomatic Go HTTP handlers from xRPC contracts.
+ *
+ * Generates three files:
+ * - types.go: Struct definitions, handler types, middleware types
+ * - router.go: HTTP routing and JSON handling
+ * - validation.go: Input validation functions
+ */
+const support: TargetSupport = {
+  supportedTypes: [...TYPE_KINDS],
+  supportedValidations: [...VALIDATION_KINDS],
+  notes: [
+    "Generates idiomatic Go code using standard library only",
+    "Uses net/http for HTTP handling",
+    "Uses encoding/json for JSON marshaling",
+    "Validation uses net/mail for email, net/url for URLs, regexp for patterns",
+  ],
+};
+
+function getPackageName(options?: Record<string, unknown>): string {
+  if (
+    options &&
+    typeof options.packageName === "string" &&
+    options.packageName
+  ) {
+    return options.packageName;
+  }
+  return "server";
+}
+
+function isNullableType(typeRef: TypeReference): boolean {
+  if (typeRef.kind === "nullable") {
+    return true;
+  }
+
+  if (typeRef.kind === "optional" && typeof typeRef.baseType === "object") {
+    return isNullableType(typeRef.baseType);
+  }
+
+  if (typeRef.kind === "union" && typeRef.unionTypes) {
+    const nonNullVariants = typeRef.unionTypes.filter(
+      (variant) =>
+        !(variant.kind === "literal" && variant.literalValue === null),
+    );
+    return nonNullVariants.length === 1;
+  }
+
+  return false;
+}
+
+function collectRequiredNullableFields(contract: ContractDefinition): string[] {
+  const results = new Set<string>();
+  const visited = new Set<string>();
+
+  const collectFromProperties = (
+    properties: Property[],
+    parentName: string,
+  ): void => {
+    for (const prop of properties) {
+      const propPath = `${parentName}.${prop.name}`;
+      if (prop.required && isNullableType(prop.type)) {
+        results.add(propPath);
+      }
+      collectFromTypeRef(prop.type, `${parentName}${toPascalCase(prop.name)}`);
+    }
+  };
+
+  const collectFromTypeRef = (
+    typeRef: TypeReference,
+    contextName: string,
+  ): void => {
+    if (typeRef.kind === "optional" || typeRef.kind === "nullable") {
+      if (typeof typeRef.baseType === "object") {
+        collectFromTypeRef(typeRef.baseType, contextName);
+      }
+      return;
+    }
+
+    if (typeRef.kind === "object" && typeRef.properties) {
+      const typeName = typeRef.name ? toPascalCase(typeRef.name) : contextName;
+      collectFromProperties(typeRef.properties, typeName);
+      return;
+    }
+
+    if (typeRef.kind === "array" && typeRef.elementType) {
+      collectFromTypeRef(typeRef.elementType, `${contextName}Item`);
+      return;
+    }
+
+    if (typeRef.kind === "record" && typeRef.valueType) {
+      collectFromTypeRef(typeRef.valueType, `${contextName}Value`);
+      return;
+    }
+
+    if (typeRef.kind === "tuple" && typeRef.tupleElements) {
+      typeRef.tupleElements.forEach((elem, index) => {
+        collectFromTypeRef(elem, `${contextName}V${index}`);
+      });
+      return;
+    }
+
+    if (typeRef.kind === "union" && typeRef.unionTypes) {
+      typeRef.unionTypes.forEach((variant, index) => {
+        collectFromTypeRef(variant, `${contextName}Variant${index}`);
+      });
+    }
+  };
+
+  const collectFromTypeDefinition = (
+    typeDef: TypeDefinition,
+    typeName: string,
+  ): void => {
+    if (visited.has(typeName)) return;
+    visited.add(typeName);
+
+    if (typeDef.properties) {
+      collectFromProperties(typeDef.properties, typeName);
+    }
+
+    if (typeDef.kind === "array" && typeDef.elementType) {
+      collectFromTypeRef(typeDef.elementType, `${typeName}Item`);
+    }
+  };
+
+  for (const type of contract.types) {
+    collectFromTypeDefinition(type, toPascalCase(type.name));
+  }
+
+  for (const endpoint of contract.endpoints) {
+    collectFromTypeRef(endpoint.input, `${endpoint.fullName}.input`);
+    collectFromTypeRef(endpoint.output, `${endpoint.fullName}.output`);
+  }
+
+  return Array.from(results);
+}
+
+function generateGoServer(input: TargetInput): TargetOutput {
+  const { contract } = input;
+  const diagnostics = validateSupport(contract, support, "go-server");
+  const requiredNullableFields = collectRequiredNullableFields(contract);
+  for (const field of requiredNullableFields) {
+    diagnostics.push({
+      severity: "warning",
+      message: `Field "${field}" is required and nullable. Go cannot distinguish missing values from null, so validation only runs when the value is present.`,
+    });
+  }
+  const hasErrors = diagnostics.some((issue) => issue.severity === "error");
+  if (hasErrors) {
+    return { files: [], diagnostics };
+  }
+
+  const packageName = getPackageName(input.options);
+  const typeCollector = new GoTypeCollector();
+  const collectedTypes = typeCollector.collectTypes(contract);
+
+  const typeGenerator = new GoTypeGenerator(packageName);
+  const serverGenerator = new GoServerGenerator(packageName);
+  const validationGenerator = new GoValidationGenerator(packageName);
+
+  return {
+    files: [
+      {
+        path: "types.go",
+        content: typeGenerator.generateTypes(contract, collectedTypes),
+      },
+      {
+        path: "router.go",
+        content: serverGenerator.generateServer(contract),
+      },
+      {
+        path: "validation.go",
+        content: validationGenerator.generateValidation(
+          contract,
+          collectedTypes,
+        ),
+      },
+    ],
+    diagnostics,
+  };
+}
+
+export const goTarget: Target = {
+  name: "go-server",
+  generate: generateGoServer,
+};

package/src/go-builder.ts

@@ -0,0 +1,148 @@
+import { CodeWriter } from "@xrpckit/sdk";
+
+/**
+ * Go-specific code builder with fluent DSL for common Go patterns
+ */
+export class GoBuilder extends CodeWriter {
+  // Short aliases
+  l(text: string): this {
+    return this.writeLine(text);
+  }
+
+  n(): this {
+    return this.newLine();
+  }
+
+  i(): this {
+    return this.indent();
+  }
+
+  u(): this {
+    return this.unindent();
+  }
+
+  // Go-specific patterns
+  package(name: string): this {
+    return this.l(`package ${name}`).n();
+  }
+
+  import(...packages: string[]): this {
+    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: string, typeDef: string): this {
+    return this.l(`type ${name} ${typeDef}`).n();
+  }
+
+  struct(name: string, fn: (b: this) => void): this {
+    this.l(`type ${name} struct {`).i();
+    fn(this);
+    return this.u().l("}").n();
+  }
+
+  // Anonymous struct
+  anonStruct(fn: (b: this) => void): this {
+    this.l("struct {").i();
+    fn(this);
+    return this.u().l("}");
+  }
+
+  func(signature: string, fn?: (b: this) => void): this {
+    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: string,
+    name: string,
+    params: string,
+    returns: string,
+    fn: (b: this) => void,
+  ): this {
+    const sig = returns
+      ? `${name}(${params}) ${returns}`
+      : `${name}(${params})`;
+    return this.func(`(${receiver}) ${sig}`, fn);
+  }
+
+  if(condition: string, fn: (b: this) => void): this {
+    this.l(`if ${condition} {`).i();
+    fn(this);
+    return this.u().l("}");
+  }
+
+  ifErr(fn: (b: this) => void): this {
+    return this.if("err != nil", fn);
+  }
+
+  return(value?: string): this {
+    return value ? this.l(`return ${value}`) : this.l("return");
+  }
+
+  var(name: string, type?: string, value?: string): this {
+    if (type && value) {
+      return this.l(`var ${name} ${type} = ${value}`);
+    }
+    if (type) {
+      return this.l(`var ${name} ${type}`);
+    }
+    if (value) {
+      return this.l(`${name} := ${value}`);
+    }
+    return this.l(`var ${name}`);
+  }
+
+  // Declare variable with type inference
+  decl(name: string, value: string): this {
+    return this.l(`${name} := ${value}`);
+  }
+
+  switch(
+    value: string,
+    cases: Array<{ value: string; fn: (b: GoBuilder) => void }>,
+    defaultCase?: (b: GoBuilder) => void,
+  ): this {
+    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: string): this {
+    return this.l(`// ${text}`);
+  }
+
+  blockComment(lines: string[]): this {
+    this.l("/*");
+    for (const line of lines) {
+      this.l(` * ${line}`);
+    }
+    return this.l(" */");
+  }
+}

package/src/index.ts

@@ -0,0 +1,15 @@
+export { goTarget } from "./generator";
+export { GoBuilder } from "./go-builder";
+export {
+  createGoBigIntPattern,
+  createGoDatePattern,
+  createGoEnumPattern,
+  createGoTuplePattern,
+  createGoUnionPattern,
+} from "./patterns";
+export { GoServerGenerator } from "./server-generator";
+export { type CollectedType, GoTypeCollector } from "./type-collector";
+export { GoTypeGenerator } from "./type-generator";
+export { GoTypeMapper } from "./type-mapper";
+export { GoValidationGenerator } from "./validation-generator";
+export { type GoValidationCode, GoValidationMapper } from "./validation-mapper";

package/src/patterns.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, it } from "bun:test";
+import {
+  createGoBigIntPattern,
+  createGoDatePattern,
+  createGoEnumPattern,
+  createGoTuplePattern,
+  createGoUnionPattern,
+} from "./patterns";
+
+describe("Go patterns", () => {
+  describe("createGoEnumPattern", () => {
+    it("should generate valid Go enum code", () => {
+      const utility = createGoEnumPattern("Status", [
+        "active",
+        "inactive",
+        "pending",
+      ]);
+
+      expect(utility.id).toBe("enum_Status");
+      expect(utility.code).toContain("type Status string");
+      expect(utility.code).toContain("StatusActive");
+      expect(utility.code).toContain("StatusInactive");
+      expect(utility.code).toContain("StatusPending");
+      expect(utility.code).toContain("func (e Status) IsValid() bool");
+      expect(utility.code).toContain(
+        "func ParseStatus(s string) (Status, error)",
+      );
+      expect(utility.includeOnce).toBe(true);
+    });
+
+    it("should filter out non-string values", () => {
+      const utility = createGoEnumPattern("Mixed", ["a", 1, "b", 2] as any);
+
+      expect(utility.code).toContain("MixedA");
+      expect(utility.code).toContain("MixedB");
+      expect(utility.code).not.toContain("Mixed1");
+    });
+  });
+
+  describe("createGoTuplePattern", () => {
+    it("should generate valid Go tuple struct", () => {
+      const utility = createGoTuplePattern("Coordinate", [
+        "float64",
+        "float64",
+      ]);
+
+      expect(utility.id).toBe("tuple_Coordinate");
+      expect(utility.code).toContain("type Coordinate struct");
+      expect(utility.code).toContain("V0 float64");
+      expect(utility.code).toContain("V1 float64");
+      expect(utility.code).toContain("MarshalJSON");
+      expect(utility.code).toContain("UnmarshalJSON");
+      expect(utility.imports).toContain("encoding/json");
+      expect(utility.imports).toContain("fmt");
+    });
+
+    it("should handle different element types", () => {
+      const utility = createGoTuplePattern("Mixed", ["string", "int", "bool"]);
+
+      expect(utility.code).toContain("V0 string");
+      expect(utility.code).toContain("V1 int");
+      expect(utility.code).toContain("V2 bool");
+      expect(utility.code).toContain("expected 3 elements");
+    });
+  });
+
+  describe("createGoUnionPattern", () => {
+    it("should generate valid Go union wrapper", () => {
+      const utility = createGoUnionPattern("Result", ["string", "int"]);
+
+      expect(utility.id).toBe("union_Result");
+      expect(utility.code).toContain("type Result struct");
+      expect(utility.code).toContain("Value interface{}");
+      expect(utility.code).toContain("AsString");
+      expect(utility.code).toContain("AsInt");
+      expect(utility.imports).toContain("encoding/json");
+    });
+
+    it("should handle pointer types", () => {
+      const utility = createGoUnionPattern("Optional", ["*string", "*int"]);
+
+      expect(utility.code).toContain("AsString");
+      expect(utility.code).toContain("AsInt");
+    });
+  });
+
+  describe("createGoBigIntPattern", () => {
+    it("should generate BigInt wrapper code", () => {
+      const utility = createGoBigIntPattern();
+
+      expect(utility.id).toBe("bigint");
+      expect(utility.code).toContain("type BigInt struct");
+      expect(utility.code).toContain("*big.Int");
+      expect(utility.code).toContain("MarshalJSON");
+      expect(utility.code).toContain("UnmarshalJSON");
+      expect(utility.imports).toContain("math/big");
+      expect(utility.imports).toContain("fmt");
+    });
+  });
+
+  describe("createGoDatePattern", () => {
+    it("should generate DateTime wrapper code", () => {
+      const utility = createGoDatePattern();
+
+      expect(utility.id).toBe("datetime");
+      expect(utility.code).toContain("type DateTime struct");
+      expect(utility.code).toContain("time.Time");
+      expect(utility.code).toContain("dateTimeFormats");
+      expect(utility.code).toContain("RFC3339");
+      expect(utility.imports).toContain("time");
+      expect(utility.imports).toContain("encoding/json");
+    });
+  });
+});