fix(emitter-typescript): fix namespace exporting

Author: codingmatty

.changeset/big-ants-beam.md

@@ -0,0 +1,7 @@
+---
+"@typespec-tools/emitter-typescript": patch
+"@typespec-tools/integration-tests": patch
+"@typespec-tools/emitter-express": patch
+---
+
+Fix namespace exporting

packages/emitter-express/src/emitter.ts

@@ -20,7 +20,6 @@ import {
   Declaration,
   EmittedSourceFile,
   EmitterOutput,
-  Scope,
   SourceFile,
   StringBuilder,
 } from "@typespec/compiler/emitter-framework";
@@ -35,24 +34,6 @@ type NamespaceDeclarations = {
   namespaceChain: string[];
 };
 
-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`;
-
-  return ns;
-}
-
 export class ExpressEmitter extends TypescriptEmitter<EmitterOptions> {
   operationDeclaration(
     operation: Operation,
@@ -220,7 +201,7 @@ export class ExpressEmitter extends TypescriptEmitter<EmitterOptions> {
       );
     }
 
-    emittedSourceFile.contents += emitNamespaces(sourceFile.globalScope);
+    emittedSourceFile.contents += this.emitNamespaces(sourceFile.globalScope);
 
     const namespaces = Array.from(declarationsByNamespace.values());
 

packages/emitter-typescript/src/emitter.ts

@@ -55,29 +55,29 @@ export const intrinsicNameToTSType = new Map<string, string>([
   ["void", "void"],
 ]);
 
-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 = `namespace ${scope.name} {\n`;
-  ns += emitNamespaces(scope);
-  for (const decl of scope.declarations) {
-    ns += decl.value + "\n";
-  }
-  ns += `}\n`;
-
-  return ns;
-}
-
 export class TypescriptEmitter<
   TEmitterOptions extends object = EmitterOptions,
 > extends CodeTypeEmitter<TEmitterOptions> {
   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`;
+    ns += this.emitNamespaces(scope);
+    for (const decl of scope.declarations) {
+      ns += decl.value + "\n";
+    }
+    ns += `}\n`;
+
+    return ns;
+  }
+
   declarationContext(
     decl: TypeSpecDeclaration & { namespace?: Namespace }
   ): Context {
@@ -409,7 +409,7 @@ export class TypescriptEmitter<
       emittedSourceFile.contents += decl.value + "\n";
     }
 
-    emittedSourceFile.contents += emitNamespaces(sourceFile.globalScope);
+    emittedSourceFile.contents += this.emitNamespaces(sourceFile.globalScope);
 
     emittedSourceFile.contents = await prettier.format(
       emittedSourceFile.contents,

packages/integration-tests/main.tsp

@@ -64,7 +64,7 @@ namespace Pets {
     @body error: NotFoundError;
   };
 
-  @route("/{petType}")
+  @route("/type/{petType}")
   namespace ByType {
     @get
     op listPets(@path petType: petType): {

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

@@ -243,4 +243,34 @@ describe("emitter-express", () => {
       expect(res.status).toBe(404);
     });
   });
+
+  describe("ByType", () => {
+    describe('GET "/pets/:type"', () => {
+      beforeAll(() => {
+        typedRouter.PetStorePets.ByType.listPets((req, res) => {
+          const filteredPets = pets.filter((pet) => {
+            return pet.kind === req.params.petType;
+          });
+          res.json({ pets: filteredPets });
+        });
+      });
+
+      it("should return 200", async () => {
+        const res = await fetch("http://localhost:3456/pets/type/dog");
+        expect(res.status).toBe(200);
+      });
+
+      it("should return the list of pets", async () => {
+        const res = await fetch("http://localhost:3456/pets/type/dog");
+        const data = await res.json();
+        expect(data).toMatchObject({ pets: [pets[0], pets[4]] });
+      });
+
+      it("should return an empty list", async () => {
+        const res = await fetch("http://localhost:3456/pets/type/zebra");
+        const data = await res.json();
+        expect(data).toMatchObject({ pets: [] });
+      });
+    });
+  });
 });

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

@@ -1,10 +1,12 @@
 import { describe, expectTypeOf, it } from "vitest";
-import {
-  petType,
-  Pet,
-  listPets,
-  getPet,
-} from "../tsp-output/@typespec-tools/emitter-typescript/output";
+import { PetStore } from "../tsp-output/@typespec-tools/emitter-typescript/output";
+
+const petType = PetStore.petType;
+type Pet = PetStore.Pet;
+type listPetsParams = PetStore.Pets.listPetsParams;
+type listPetsReturnType = PetStore.Pets.listPetsReturnType;
+type getPetParams = PetStore.Pets.getPetParams;
+type getPetReturnType = PetStore.Pets.getPetReturnType;
 
 describe("emitter-zod", () => {
   describe("PetSchema", () => {
@@ -28,21 +30,19 @@ describe("emitter-zod", () => {
 
   describe("listPetsSchema", () => {
     it("validates a valid function", () => {
-      const validFn = () => ({
+      const validFn = (type?: PetStore.petType) => ({
         pets: [{ id: 123, name: "Fluffy", age: 3, kind: petType.dog }],
       });
-      expectTypeOf(validFn).parameters.toEqualTypeOf<Parameters<listPets>>();
-      expectTypeOf(validFn).returns.toEqualTypeOf<ReturnType<listPets>>();
+      expectTypeOf(validFn).parameters.toEqualTypeOf<listPetsParams>();
+      expectTypeOf(validFn).returns.toEqualTypeOf<listPetsReturnType>();
     });
 
     it("validates an invalid function", () => {
       const invalidFn = (x: number) => ({
         pets: [{ id: "invalid", name: 123, kind: "invalid" }],
       });
-      expectTypeOf(invalidFn).parameters.not.toEqualTypeOf<
-        Parameters<listPets>
-      >();
-      expectTypeOf(invalidFn).returns.not.toEqualTypeOf<ReturnType<listPets>>();
+      expectTypeOf(invalidFn).parameters.not.toEqualTypeOf<listPetsParams>();
+      expectTypeOf(invalidFn).returns.not.toEqualTypeOf<listPetsReturnType>();
     });
   });
 
@@ -52,20 +52,18 @@ describe("emitter-zod", () => {
         const validFn = (x: number) => ({
           pet: { id: 123, name: "Fluffy", age: 3, kind: petType.dog },
         });
-        expectTypeOf(validFn).parameters.toEqualTypeOf<Parameters<getPet>>();
+        expectTypeOf(validFn).parameters.toEqualTypeOf<getPetParams>();
         expectTypeOf(validFn).returns.toEqualTypeOf<
-          Extract<ReturnType<getPet>, { pet: any }>
+          Extract<getPetReturnType, { pet: any }>
         >();
       });
 
       it("validates an invalid function", () => {
         const invalidFn = () => ({
           pet: { id: "invalid", name: 123, kind: "invalid" },
         });
-        expectTypeOf(invalidFn).parameters.not.toEqualTypeOf<
-          Parameters<getPet>
-        >();
-        expectTypeOf(invalidFn).returns.not.toEqualTypeOf<ReturnType<getPet>>();
+        expectTypeOf(invalidFn).parameters.not.toEqualTypeOf<getPetParams>();
+        expectTypeOf(invalidFn).returns.not.toEqualTypeOf<getPetReturnType>();
       });
     });
 
@@ -74,20 +72,18 @@ describe("emitter-zod", () => {
         const validFn = (x: number) => ({
           error: { code: "NOT_FOUND" as const, message: "Testing" },
         });
-        expectTypeOf(validFn).parameters.toEqualTypeOf<Parameters<getPet>>();
+        expectTypeOf(validFn).parameters.toEqualTypeOf<getPetParams>();
         expectTypeOf(validFn).returns.toEqualTypeOf<
-          Extract<ReturnType<getPet>, { error: any }>
+          Extract<getPetReturnType, { error: any }>
         >();
       });
 
       it("validates an invalid function", () => {
         const invalidFn = () => ({
           error: { code: "NOT_FOUND", message: 123 },
         });
-        expectTypeOf(invalidFn).parameters.not.toEqualTypeOf<
-          Parameters<getPet>
-        >();
-        expectTypeOf(invalidFn).returns.not.toEqualTypeOf<ReturnType<getPet>>();
+        expectTypeOf(invalidFn).parameters.not.toEqualTypeOf<getPetParams>();
+        expectTypeOf(invalidFn).returns.not.toEqualTypeOf<getPetReturnType>();
       });
     });
   });