minor(emitter-zod): add options to transform schema declaration names

Author: codingmatty

.changeset/eight-coins-add.md

@@ -0,0 +1,5 @@
+---
+"@typespec-tools/emitter-zod": minor
+---
+
+add options to transform schema declaration names

packages/emitter-zod/README.md

@@ -51,6 +51,8 @@ options:
 
 ### Emitter options
 
-| Option        | Type   | Default     | Description             |
-| ------------- | ------ | ----------- | ----------------------- |
-| `output-file` | string | "output.ts" | Name of the output file |
+| Option          | Type   | Default     | Description                                                                                |
+| --------------- | ------ | ----------- | ------------------------------------------------------------------------------------------ |
+| `output-file`   | string | "output.ts" | Name of the output file                                                                    |
+| `schema-prefix` | string | ""          | Prefix for schema declarations, i.e. a setting of "s\_" would result in "s_Example"        |
+| `schema-suffix` | string | "Schema"    | Suffix for schema declarations, i.e. a setting of "Schema" would result in "ExampleSchema" |

packages/emitter-zod/src/emitter.ts

@@ -57,6 +57,18 @@ export const intrinsicNameToTSType = new Map<string, string>([
 export class ZodEmitter extends CodeTypeEmitter<EmitterOptions> {
   protected nsByName: Map<string, Scope<string>> = new Map();
 
+  getPrefix() {
+    const options = this.emitter.getOptions();
+    return options["schema-prefix"] ?? "";
+  }
+  getSuffix() {
+    const options = this.emitter.getOptions();
+    return options["schema-suffix"] ?? "Schema";
+  }
+  wrapIdentifier(name: string) {
+    return `${this.getPrefix()}${name}${this.getSuffix()}`;
+  }
+
   emitNamespaces(scope: Scope<string>) {
     let res = "";
     for (const childScope of scope.childScopes) {
@@ -197,7 +209,7 @@ export class ZodEmitter extends CodeTypeEmitter<EmitterOptions> {
 
     return this.emitter.result.declaration(
       name,
-      code`${commentCode}\nexport const ${name}Schema = z.object({
+      code`${commentCode}\nexport const ${this.wrapIdentifier(name)} = z.object({
         ${this.emitter.emitModelProperties(model)}
     })`
     );
@@ -238,7 +250,7 @@ export class ZodEmitter extends CodeTypeEmitter<EmitterOptions> {
   ): EmitterOutput<string> {
     return this.emitter.result.declaration(
       name,
-      code`export const ${name}Schema = z.array(${this.emitter.emitTypeReference(elementType)});`
+      code`export const ${this.wrapIdentifier(name)} = z.array(${this.emitter.emitTypeReference(elementType)});`
     );
   }
 
@@ -257,7 +269,7 @@ export class ZodEmitter extends CodeTypeEmitter<EmitterOptions> {
     const returnsOutput = code`.returns(${this.emitter.emitOperationReturnType(operation)})`;
     return this.emitter.result.declaration(
       name,
-      code`export const ${name}Schema = z.function()${argsOutput}${returnsOutput}`
+      code`export const ${this.wrapIdentifier(name)} = z.function()${argsOutput}${returnsOutput}`
     );
   }
 
@@ -289,7 +301,7 @@ export class ZodEmitter extends CodeTypeEmitter<EmitterOptions> {
     return this.emitter.result.declaration(
       name,
       code`
-      export const ${name}Schema = z.object({
+      export const ${this.wrapIdentifier(name)} = z.object({
         ${this.emitter.emitInterfaceOperations(iface)}
       })
     `
@@ -330,7 +342,7 @@ export class ZodEmitter extends CodeTypeEmitter<EmitterOptions> {
   unionDeclaration(union: Union, name: string): EmitterOutput<string> {
     return this.emitter.result.declaration(
       name,
-      code`export const ${name}Schema = ${this.emitter.emitUnionVariants(union)}`
+      code`export const ${this.wrapIdentifier(name)} = ${this.emitter.emitUnionVariants(union)}`
     );
   }
 
@@ -391,9 +403,9 @@ export class ZodEmitter extends CodeTypeEmitter<EmitterOptions> {
     const basePath = pathDown.map((s) => s.name).join(".");
     return basePath
       ? this.emitter.result.rawCode(
-          `${basePath}.${targetDeclaration.name}Schema`
+          `${basePath}.${this.wrapIdentifier(targetDeclaration.name)}`
         )
-      : this.emitter.result.rawCode(`${targetDeclaration.name}Schema`);
+      : this.emitter.result.rawCode(this.wrapIdentifier(targetDeclaration.name));
   }
 
   async sourceFile(sourceFile: SourceFile<string>): Promise<EmittedSourceFile> {

packages/emitter-zod/src/lib.ts

@@ -2,13 +2,17 @@ import { createTypeSpecLibrary, JSONSchemaType } from "@typespec/compiler";
 
 export interface EmitterOptions {
   "output-file"?: string;
+  "schema-prefix"?: string;
+  "schema-suffix"?: string;
 }
 
 const EmitterOptionsSchema: JSONSchemaType<EmitterOptions> = {
   type: "object",
   additionalProperties: false,
   properties: {
     "output-file": { type: "string", nullable: true },
+    "schema-prefix": { type: "string", nullable: true },
+    "schema-suffix": { type: "string", nullable: true, default: "Schema" },
   },
   required: [],
 };

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

@@ -11,6 +11,7 @@ import { describe, it } from "vitest";
 
 import { SingleFileZodEmitter, ZodEmitter } from "../src/emitter.js";
 import { emitTypeSpec, getHostForTypeSpecFile } from "./host.js";
+import { EmitterOptions } from "../src/lib.js";
 
 const testCode = `
 model Basic { x: string }
@@ -63,8 +64,8 @@ class SingleFileTestEmitter extends SingleFileZodEmitter {
   }
 }
 
-async function emitTypeSpecToTs(code: string) {
-  const emitter = await emitTypeSpec(SingleFileTestEmitter, code);
+async function emitTypeSpecToTs(code: string, options?: EmitterOptions) {
+  const emitter = await emitTypeSpec(SingleFileTestEmitter, code, options);
 
   const sf = await emitter.getProgram().host.readFile("./tsp-output/output.ts");
   return sf.text;
@@ -434,6 +435,45 @@ describe("emitter-framework: zod emitter", () => {
     assert.match(contents, /y: z.number\(\)/);
   });
 
+  it("emits declaration with custom prefix", async () => {
+    const contents = await emitTypeSpecToTs(
+      `
+      model Foo {
+        x: string;
+      }
+      `,
+      { "schema-prefix": "My", "schema-suffix": "" }
+    );
+
+    assert.match(contents, /export const MyFoo = z.object\(/);
+  });
+
+  it("emits declaration with custom suffix", async () => {
+    const contents = await emitTypeSpecToTs(
+      `
+      model Foo {
+        x: string;
+      }
+      `,
+      { "schema-suffix": "Testing" }
+    );
+
+    assert.match(contents, /export const FooTesting = z.object\(/);
+  });
+
+  it("emits declaration with custom prefix and suffix", async () => {
+    const contents = await emitTypeSpecToTs(
+      `
+      model Foo {
+        x: string;
+      }
+      `,
+      { "schema-prefix": "My_", "schema-suffix": "_Schema" }
+    );
+
+    assert.match(contents, /export const My_Foo_Schema = z.object\(/);
+  });
+
   it("emits models to a single file", async () => {
     const host = await getHostForTypeSpecFile(testCode);
     const emitter = createAssetEmitter(host.program, SingleFileTestEmitter, {

packages/emitter-zod/test/host.ts

@@ -1,5 +1,6 @@
 import { createAssetEmitter } from "@typespec/compiler/emitter-framework";
 import { createTestHost } from "@typespec/compiler/testing";
+import { EmitterOptions } from "../src/lib.js";
 
 export async function getHostForTypeSpecFile(
   contents: string,
@@ -17,13 +18,15 @@ export async function getHostForTypeSpecFile(
   return host;
 }
 
-export async function emitTypeSpec(Emitter: any, code: string) {
+export async function emitTypeSpec(
+  Emitter: any,
+  code: string,
+  options: EmitterOptions = {}
+) {
   const host = await getHostForTypeSpecFile(code);
   const emitter = createAssetEmitter(host.program, Emitter, {
     emitterOutputDir: "tsp-output",
-    options: {
-      fileName: "testing.ts",
-    },
+    options,
   } as any);
 
   emitter.emitProgram();