minor(emitter-zod): emit namespace blocks

Author: codingmatty

.changeset/giant-donuts-relate.md

@@ -0,0 +1,5 @@
+---
+"@typespec-tools/emitter-zod": minor
+---
+
+Emit namespace blocks

packages/emitter-typescript/src/emitter.ts

@@ -69,10 +69,10 @@ export class TypescriptEmitter<
   }
   emitNamespace(scope: Scope<string>) {
     let ns = `export namespace ${scope.name} {\n`;
-    ns += this.emitNamespaces(scope);
     for (const decl of scope.declarations) {
       ns += decl.value + "\n";
     }
+    ns += this.emitNamespaces(scope);
     ns += `}\n`;
 
     return ns;

packages/emitter-zod/src/emitter.ts

@@ -5,10 +5,12 @@ import {
   Enum,
   EnumMember,
   getDoc,
+  getNamespaceFullName,
   Interface,
   IntrinsicType,
   Model,
   ModelProperty,
+  Namespace,
   NumericLiteral,
   Operation,
   Scalar,
@@ -53,6 +55,96 @@ export const intrinsicNameToTSType = new Map<string, string>([
 ]);
 
 export class ZodEmitter extends CodeTypeEmitter<EmitterOptions> {
+  protected nsByName: Map<string, Scope<string>> = new Map();
+
+  emitNamespaces(scope: Scope<string>) {
+    let res = "";
+    for (const childScope of scope.childScopes) {
+      res += this.emitNamespace(childScope);
+    }
+    return res;
+  }
+  emitNamespace(scope: Scope<string>) {
+    let ns = `export namespace ${scope.name} {\n`;
+    for (const decl of scope.declarations) {
+      ns += decl.value + "\n";
+    }
+    ns += this.emitNamespaces(scope);
+    ns += `}\n`;
+
+    return ns;
+  }
+
+  declarationContext(decl: { namespace?: Namespace }): Context {
+    const name = decl.namespace?.name;
+    if (!name) return {};
+
+    const namespaceChain = decl.namespace
+      ? getNamespaceFullName(decl.namespace).split(".")
+      : [];
+
+    let nsScope = this.nsByName.get(name);
+    if (!nsScope) {
+      // If there is no scope for the namespace, create one for each
+      // namespace in the chain.
+      let parentScope: Scope<string> | undefined;
+      while (namespaceChain.length > 0) {
+        const ns = namespaceChain.shift();
+        if (!ns) {
+          break;
+        }
+        nsScope = this.nsByName.get(ns);
+        if (nsScope) {
+          parentScope = nsScope;
+          continue;
+        }
+        nsScope = this.emitter.createScope(
+          {},
+          ns,
+          parentScope ?? this.emitter.getContext().scope
+        );
+        this.nsByName.set(ns, nsScope);
+        parentScope = nsScope;
+      }
+    }
+
+    return {
+      scope: nsScope,
+    };
+  }
+
+  modelDeclarationContext(model: Model): Context {
+    return this.declarationContext(model);
+  }
+
+  modelInstantiationContext(model: Model): Context {
+    return this.declarationContext(model);
+  }
+
+  unionDeclarationContext(union: Union): Context {
+    return this.declarationContext(union);
+  }
+
+  unionInstantiationContext(union: Union): Context {
+    return this.declarationContext(union);
+  }
+
+  enumDeclarationContext(en: Enum): Context {
+    return this.declarationContext(en);
+  }
+
+  arrayDeclarationContext(array: Model): Context {
+    return this.declarationContext(array);
+  }
+
+  interfaceDeclarationContext(iface: Interface): Context {
+    return this.declarationContext(iface);
+  }
+
+  operationDeclarationContext(operation: Operation): Context {
+    return this.declarationContext(operation);
+  }
+
   // type literals
   booleanLiteral(boolean: BooleanLiteral): EmitterOutput<string> {
     return code`z.literal(${JSON.stringify(boolean.value)})`;
@@ -318,6 +410,8 @@ export class ZodEmitter extends CodeTypeEmitter<EmitterOptions> {
       emittedSourceFile.contents += decl.value + "\n";
     }
 
+    emittedSourceFile.contents += this.emitNamespaces(sourceFile.globalScope);
+
     emittedSourceFile.contents = await prettier.format(
       emittedSourceFile.contents,
       {

packages/emitter-zod/test/emitter.test.ts

@@ -1,21 +1,15 @@
 import { Enum, Interface, Model, Operation, Union } from "@typespec/compiler";
 import {
-  AssetEmitter,
   Context,
-  EmittedSourceFile,
   EmitterOutput,
-  Scope,
-  SourceFile,
   TypeSpecDeclaration,
   createAssetEmitter,
 } from "@typespec/compiler/emitter-framework";
 
 import assert from "assert";
-import * as prettier from "prettier";
 import { describe, it } from "vitest";
 
 import { SingleFileZodEmitter, ZodEmitter } from "../src/emitter.js";
-import { EmitterOptions } from "../src/lib.js";
 import { emitTypeSpec, getHostForTypeSpecFile } from "./host.js";
 
 const testCode = `
@@ -534,106 +528,36 @@ describe("emitter-framework: zod emitter", () => {
     });
   });
 
-  it("emits to namespaces", async () => {
-    const host = await getHostForTypeSpecFile(testCode);
-
-    class NamespacedEmitter extends ZodEmitter {
-      private nsByName: Map<string, Scope<string>> = new Map();
-      programContext(): Context {
-        const outputFile = emitter.createSourceFile("output.ts");
-        return {
-          scope: outputFile.globalScope,
-        };
-      }
-
-      modelDeclarationContext(model: Model): Context {
-        const name = this.emitter.emitDeclarationName(model);
-        if (!name) return {};
-        const nsName = name.slice(0, 1);
-        let nsScope = this.nsByName.get(nsName);
-        if (!nsScope) {
-          nsScope = this.emitter.createScope(
-            {},
-            nsName,
-            this.emitter.getContext().scope
-          );
-          this.nsByName.set(nsName, nsScope);
-        }
+  it("emits namespaces", async () => {
+    const contents = await emitTypeSpecToTs(`
+      namespace A;
 
-        return {
-          scope: nsScope,
-        };
+      enum MyEnum {
+        a: "hi";
+        b: "bye";
       }
 
-      async sourceFile(
-        sourceFile: SourceFile<string>
-      ): Promise<EmittedSourceFile> {
-        const emittedSourceFile = await super.sourceFile(sourceFile);
-        emittedSourceFile.contents += emitNamespaces(sourceFile.globalScope);
-        emittedSourceFile.contents = await prettier.format(
-          emittedSourceFile.contents,
-          {
-            parser: "typescript",
+      namespace B {
+        namespace C {
+          model X {
+            x: string;
           }
-        );
-        return emittedSourceFile;
-
-        function emitNamespaces(scope: Scope<string>) {
-          let res = "";
-          for (const childScope of scope.childScopes) {
-            res += emitNamespace(childScope);
-          }
-          return res;
         }
-        function emitNamespace(scope: Scope<string>) {
-          let ns = `export namespace ${scope.name} {\n`;
-          ns += emitNamespaces(scope);
-          for (const decl of scope.declarations) {
-            ns += decl.value + ",\n";
-          }
-          ns += `}\n`;
+        op SomeOp(x: string): string;
 
-          return ns;
+        interface MyInterface {
+          op get(): string;
         }
       }
-    }
-    const emitter = createAssetEmitter(host.program, NamespacedEmitter, {
-      emitterOutputDir: host.program.compilerOptions.outputDir!,
-      options: {},
-    } as any);
-    emitter.emitProgram();
-    await emitter.writeOutput();
-    const contents = (await host.compilerHost.readFile("tsp-output/output.ts"))
-      .text;
-
-    assert.match(contents, /export namespace B \{/);
-    assert.match(contents, /export namespace R \{/);
-    assert.match(contents, /export namespace H \{/);
-    assert.match(contents, /export namespace I \{/);
-    assert.match(contents, /export namespace D \{/);
-    assert.match(contents, /y: B\.BasicSchema/);
-    assert.match(contents, /prop: B\.BasicSchema/);
-  });
-
-  it("handles circular references", async () => {
-    const host = await getHostForTypeSpecFile(`
-      model Foo { prop: Baz }
-      model Baz { prop: Foo }
     `);
 
-    const emitter: AssetEmitter<string, EmitterOptions> = createAssetEmitter(
-      host.program,
-      SingleFileZodEmitter,
-      {
-        emitterOutputDir: host.program.compilerOptions.outputDir!,
-        options: {},
-      } as any
+    assert.match(
+      contents,
+      /export namespace A \{(\n|.)*export namespace B \{(\n|.)*export namespace C \{(\n|.)*\}(\n|.)*\}(\n|.)*\}/
+    );
+    assert.match(
+      contents,
+      /export namespace C \{(\n|.)*export const XSchema = z.object\((\n|.)*x: z.string\(\)(\n|.)*\)(\n|.)*\}/
     );
-    emitter.emitProgram();
-    await emitter.writeOutput();
-    const contents = (await host.compilerHost.readFile("tsp-output/output.ts"))
-      .text;
-    assert.match(contents, /prop: Foo/);
-    assert.match(contents, /prop: Baz/);
   });
 });

packages/integration-tests/tests/emitter-zod.test.ts

@@ -1,12 +1,13 @@
 import { assert, describe, it } from "vitest";
 import { z } from "zod";
 
-import {
-  PetSchema,
-  getPetSchema,
-  listPetsSchema,
+import { PetStore } from "../tsp-output/@typespec-tools/emitter-zod/output";
+
+const {
   petTypeEnum,
-} from "../tsp-output/@typespec-tools/emitter-zod/output";
+  PetSchema,
+  Pets: { getPetSchema, listPetsSchema },
+} = PetStore;
 
 const validPet: z.infer<typeof PetSchema> = {
   id: 123,
@@ -31,7 +32,7 @@ describe("emitter-zod", () => {
     it("invalidates an invalid pet", () => {
       const result = PetSchema.safeParse(invalidPet);
       assert.isFalse(result.success);
-      assert.equal(result.error.errors.length, 3);
+      assert.equal(result.error?.errors.length, 3);
     });
   });