@typespec/emitter-framework 0.9.0-dev.3 → 0.9.0-dev.6

package/dist/test/test-host.js

@@ -0,0 +1,5 @@
+import { resolvePath } from "@typespec/compiler";
+import { createTester } from "@typespec/compiler/testing";
+export const Tester = createTester(resolvePath(import.meta.dirname, ".."), {
+  libraries: []
+});

package/dist/test/vitest.setup.d.ts

@@ -0,0 +1,2 @@
+import "@alloy-js/core/testing";
+//# sourceMappingURL=vitest.setup.d.ts.map

package/dist/test/vitest.setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest.setup.d.ts","sourceRoot":"","sources":["../../test/vitest.setup.ts"],"names":[],"mappings":"AAAA,OAAO,wBAAwB,CAAC"}

package/dist/test/vitest.setup.js

@@ -0,0 +1 @@
+import "@alloy-js/core/testing";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typespec/emitter-framework",
-  "version": "0.9.0-dev.3",
+  "version": "0.9.0-dev.6",
   "type": "module",
   "main": "dist/index.js",
   "repository": {
@@ -21,23 +21,26 @@
       "import": "./dist/src/testing/index.js"
     }
   },
+  "imports": {
+    "#test/*": "./test/*"
+  },
   "keywords": [],
   "author": "",
   "license": "MIT",
   "description": "",
   "peerDependencies": {
-    "@alloy-js/core": "^0.17.0",
-    "@alloy-js/typescript": "^0.17.0",
-    "@alloy-js/csharp": "^0.17.0",
+    "@alloy-js/core": "^0.18.0",
+    "@alloy-js/typescript": "^0.18.0",
+    "@alloy-js/csharp": "^0.18.0",
     "@typespec/compiler": "^1.1.0",
     "@typespec/http": "^1.1.0",
     "@typespec/rest": "^0.71.0 || >=0.72.0-dev <0.72.0"
   },
   "devDependencies": {
-    "@alloy-js/cli": "^0.17.0",
+    "@alloy-js/cli": "^0.18.0",
     "@alloy-js/rollup-plugin": "^0.1.0",
-    "@alloy-js/core": "^0.17.0",
-    "@alloy-js/typescript": "^0.17.0",
+    "@alloy-js/core": "^0.18.0",
+    "@alloy-js/typescript": "^0.18.0",
     "@types/minimist": "^1.2.5",
     "@typespec/compiler": "^1.1.0",
     "@typespec/http": "^1.1.0",

package/src/csharp/components/class/declaration.test.tsx

@@ -0,0 +1,401 @@
+import { Tester } from "#test/test-host.js";
+import { Children, render } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import { createCSharpNamePolicy, Namespace, SourceFile } from "@alloy-js/csharp";
+import { t, TesterInstance } from "@typespec/compiler/testing";
+import { beforeEach, describe, it } from "vitest";
+import { assertFileContents } from "../../../../test/csharp/utils.js";
+import { Output } from "../../../core/index.js";
+import { ClassDeclaration, EnumDeclaration } from "../../index.js";
+
+let runner: TesterInstance;
+
+beforeEach(async () => {
+  runner = await Tester.createInstance();
+});
+
+function Wrapper(props: { children: Children }) {
+  const policy = createCSharpNamePolicy();
+  return (
+    <Output program={runner.program} namePolicy={policy}>
+      <Namespace name="TestNamespace">
+        <SourceFile path="test.cs">{props.children}</SourceFile>
+      </Namespace>
+    </Output>
+  );
+}
+
+it("renders an empty class declaration", async () => {
+  const { TestModel } = await runner.compile(t.code`
+    model ${t.model("TestModel")} {}
+  `);
+
+  const res = render(
+    <Wrapper>
+      <ClassDeclaration type={TestModel} />
+    </Wrapper>,
+  );
+
+  assertFileContents(
+    res,
+    d`
+      namespace TestNamespace
+      {
+          class TestModel
+          {
+
+          }
+      }
+    `,
+  );
+});
+
+it("renders a class declaration with properties", async () => {
+  const { TestModel } = await runner.compile(t.code`
+    model ${t.model("TestModel")} {
+      @test Prop1: string;
+      @test Prop2: int32;
+    }
+  `);
+
+  const res = render(
+    <Wrapper>
+      <ClassDeclaration type={TestModel} />
+    </Wrapper>,
+  );
+
+  assertFileContents(
+    res,
+    d`
+      namespace TestNamespace
+      {
+          class TestModel
+          {
+              public required string Prop1 { get; set; }
+              public required int Prop2 { get; set; }
+          }
+      }
+    `,
+  );
+});
+
+it("can override class name", async () => {
+  const { TestModel } = await runner.compile(t.code`
+    model ${t.model("TestModel")} {}
+  `);
+
+  const res = render(
+    <Wrapper>
+      <ClassDeclaration type={TestModel} name="CustomClassName" />
+    </Wrapper>,
+  );
+
+  assertFileContents(
+    res,
+    d`
+      namespace TestNamespace
+      {
+          class CustomClassName
+          {
+
+          }
+      }
+    `,
+  );
+});
+
+it("renders a class with access modifiers", async () => {
+  const { TestModel } = await runner.compile(t.code`
+    model ${t.model("TestModel")} {
+    }
+  `);
+
+  const res = render(
+    <Wrapper>
+      <ClassDeclaration type={TestModel} protected />
+    </Wrapper>,
+  );
+
+  assertFileContents(
+    res,
+    d`
+      namespace TestNamespace
+      {
+          protected class TestModel
+          {
+
+          }
+      }
+    `,
+  );
+});
+
+describe("from an interface", () => {
+  it("renders an empty class", async () => {
+    const { TestInterface } = await runner.compile(t.code`
+    interface ${t.interface("TestInterface")} {
+    }
+  `);
+
+    const res = render(
+      <Wrapper>
+        <ClassDeclaration type={TestInterface} />
+      </Wrapper>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+      namespace TestNamespace
+      {
+          class TestInterface
+          {
+
+          }
+      }
+    `,
+    );
+  });
+
+  it("renders a class with operations", async () => {
+    const { TestInterface } = await runner.compile(t.code`
+    interface ${t.interface("TestInterface")} {
+      op getName(id: string): string;
+    }
+  `);
+
+    const res = render(
+      <Wrapper>
+        <ClassDeclaration type={TestInterface} />
+      </Wrapper>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+      namespace TestNamespace
+      {
+          class TestInterface
+          {
+              public abstract string GetName(string id);
+          }
+      }
+    `,
+    );
+  });
+});
+
+it("renders a class with model members", async () => {
+  const { TestModel, TestReference } = await runner.compile(t.code`
+    model ${t.model("TestReference")} { }
+    model ${t.model("TestModel")} {
+      prop1: TestReference;
+    }
+  `);
+
+  const res = render(
+    <Wrapper>
+      <ClassDeclaration type={TestReference} />
+      <hbr />
+      <ClassDeclaration type={TestModel} />
+    </Wrapper>,
+  );
+
+  assertFileContents(
+    res,
+    d`
+      namespace TestNamespace
+      {
+          class TestReference
+          {
+
+          }
+          class TestModel
+          {
+              public required TestReference Prop1 { get; set; }
+          }
+      }
+    `,
+  );
+});
+
+it("renders a class with enum members", async () => {
+  const { TestModel, TestEnum } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum")} {
+      Value1;
+      Value2;
+    }
+    model ${t.model("TestModel")} {
+      @test prop1: TestEnum;
+    }
+  `);
+
+  const res = render(
+    <Wrapper>
+      <EnumDeclaration type={TestEnum} />
+      <hbr />
+      <ClassDeclaration type={TestModel} />
+    </Wrapper>,
+  );
+
+  assertFileContents(
+    res,
+    d`
+      namespace TestNamespace
+      {
+          enum TestEnum
+          {
+              Value1,
+              Value2
+          }
+          class TestModel
+          {
+              public required TestEnum Prop1 { get; set; }
+          }
+      }
+    `,
+  );
+});
+
+it("maps prop: string | null to nullable property", async () => {
+  const { TestModel } = await runner.compile(t.code`
+    model ${t.model("TestModel")} {
+      prop1: string | null;
+    }
+  `);
+
+  const res = render(
+    <Wrapper>
+      <ClassDeclaration type={TestModel} />
+    </Wrapper>,
+  );
+
+  assertFileContents(
+    res,
+    d`
+      namespace TestNamespace
+      {
+          class TestModel
+          {
+              public required string? Prop1 { get; set; }
+          }
+      }
+    `,
+  );
+});
+
+it("renders a class with string enums", async () => {
+  const { TestModel, TestEnum } = await runner.compile(t.code`
+    @test enum ${t.enum("TestEnum")} {
+      Value1;
+      Value2;
+    }
+    model ${t.model("TestModel")} {
+      @test prop1: TestEnum;
+    }
+  `);
+
+  const res = render(
+    <Wrapper>
+      <EnumDeclaration type={TestEnum} />
+      <hbr />
+      <ClassDeclaration type={TestModel} />
+    </Wrapper>,
+  );
+
+  assertFileContents(
+    res,
+    d`
+      namespace TestNamespace
+      {
+          enum TestEnum
+          {
+              Value1,
+              Value2
+          }
+          class TestModel
+          {
+              public required TestEnum Prop1 { get; set; }
+          }
+      }
+    `,
+  );
+});
+
+describe("with doc comments", () => {
+  it("renders a model with docs", async () => {
+    const { TestModel } = await runner.compile(t.code`
+    @doc("This is a test model")
+    model ${t.model("TestModel")} {
+      @doc("This is a test property")
+        prop1: string;
+      }
+    
+  `);
+
+    const res = render(
+      <Wrapper>
+        <ClassDeclaration type={TestModel} />
+      </Wrapper>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+      namespace TestNamespace
+      {
+          /// <summary>
+          /// This is a test model
+          /// </summary>
+          class TestModel
+          {
+              /// <summary>
+              /// This is a test property
+              /// </summary>
+              public required string Prop1 { get; set; }
+          }
+      }
+    `,
+    );
+  });
+
+  it("renders an interface with docs", async () => {
+    const { TestInterface } = await runner.compile(t.code`
+      @doc("This is a test interface")
+      @test interface ${t.interface("TestInterface")} {
+        @doc("This is a test operation")
+        @returnsDoc("The name of the item")
+        op getName(id: string): string;
+      }
+    `);
+
+    const res = render(
+      <Wrapper>
+        <ClassDeclaration type={TestInterface} />
+      </Wrapper>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+      namespace TestNamespace
+      {
+          /// <summary>
+          /// This is a test interface
+          /// </summary>
+          class TestInterface
+          {
+              /// <summary>
+              /// This is a test operation
+              /// </summary>
+              ///
+              /// <returns>
+              /// The name of the item
+              /// </returns>
+              public abstract string GetName(string id);
+          }
+      }
+    `,
+    );
+  });
+});

package/src/csharp/components/class/declaration.tsx

@@ -0,0 +1,86 @@
+import * as ay from "@alloy-js/core";
+import * as cs from "@alloy-js/csharp";
+import { Interface, Model } from "@typespec/compiler";
+import { useTsp } from "../../../core/index.js";
+import { Property } from "../property/property.jsx";
+import { TypeExpression } from "../type-expression.jsx";
+import { getDocComments } from "../utils/doc-comments.jsx";
+import { declarationRefkeys } from "../utils/refkey.js";
+
+export interface ClassDeclarationProps extends Omit<cs.ClassDeclarationProps, "name"> {
+  /** Set an alternative name for the class. Otherwise default to the type name. */
+  name?: string;
+  /** Type to use to create this class. */
+  type: Model | Interface;
+  /** If set the property will add the json serialization attributes(using System.Text.Json). */
+  jsonAttributes?: boolean;
+}
+
+interface ClassPropertiesProps {
+  type: Model;
+  /** If set the property will add the json serialization attributes(using System.Text.Json). */
+  jsonAttributes?: boolean;
+}
+
+interface ClassMethodsProps {
+  type: Interface;
+}
+
+export function ClassDeclaration(props: ClassDeclarationProps): ay.Children {
+  const { $ } = useTsp();
+
+  const namePolicy = cs.useCSharpNamePolicy();
+  const className = props.name ?? namePolicy.getName(props.type.name, "class");
+
+  const refkeys = declarationRefkeys(props.refkey, props.type)[0]; // TODO: support multiple refkeys for declarations in alloy
+
+  return (
+    <>
+      <cs.ClassDeclaration
+        {...props}
+        name={className}
+        refkey={refkeys}
+        doc={getDocComments($, props.type)}
+      >
+        {props.type.kind === "Model" && (
+          <ClassProperties type={props.type} jsonAttributes={props.jsonAttributes} />
+        )}
+        {props.type.kind === "Interface" && <ClassMethods type={props.type} />}
+      </cs.ClassDeclaration>
+    </>
+  );
+}
+
+function ClassProperties(props: ClassPropertiesProps): ay.Children {
+  return (
+    <ay.For each={props.type.properties.entries()} hardline>
+      {([name, property]) => <Property type={property} jsonAttributes={props.jsonAttributes} />}
+    </ay.For>
+  );
+}
+
+function ClassMethods(props: ClassMethodsProps): ay.Children {
+  const { $ } = useTsp();
+  const namePolicy = cs.useCSharpNamePolicy();
+
+  const abstractMethods: ay.Children = [];
+  for (const [name, method] of props.type.operations) {
+    abstractMethods.push(
+      <cs.ClassMethod
+        name={namePolicy.getName(name, "class-method")}
+        abstract
+        parameters={[...method.parameters.properties.entries()].map(([name, prop]) => {
+          return {
+            name: namePolicy.getName(name, "type-parameter"),
+            type: <TypeExpression type={prop.type} />,
+          };
+        })}
+        public
+        doc={getDocComments($, method)}
+        returns={<TypeExpression type={method.returnType} />}
+      />,
+    );
+  }
+
+  return <>{abstractMethods}</>;
+}

package/src/csharp/components/enum-declaration.tsx

@@ -3,9 +3,10 @@ import * as cs from "@alloy-js/csharp";
 import { Enum, Union } from "@typespec/compiler";
 import { useTsp } from "../../core/index.js";
 import { reportDiagnostic } from "../../lib.js";
+import { getDocComments } from "./utils/doc-comments.jsx";
 import { declarationRefkeys, efRefkey } from "./utils/refkey.js";
 
-export interface EnumDeclarationProps extends Omit<cs.EnumProps, "name"> {
+export interface EnumDeclarationProps extends Omit<cs.EnumDeclarationProps, "name"> {
   name?: string;
   type: Union | Enum;
 }
@@ -30,19 +31,26 @@ export function EnumDeclaration(props: EnumDeclarationProps): ay.Children {
   const members = Array.from(type.members.entries());
 
   return (
-    <cs.Enum name={name} refkey={refkeys} accessModifier={props.accessModifier ?? "public"}>
-      <ay.For each={members} joiner={",\n"}>
-        {([key, value]) => {
-          return (
-            <cs.EnumMember
-              name={cs.useCSharpNamePolicy().getName(key, "enum-member")}
-              refkey={
-                $.union.is(props.type) ? efRefkey(props.type.variants.get(key)) : efRefkey(value)
-              }
-            />
-          );
-        }}
-      </ay.For>
-    </cs.Enum>
+    <>
+      <cs.EnumDeclaration name={name} refkey={refkeys} {...props}>
+        <ay.For each={members} joiner={",\n"}>
+          {([key, value]) => {
+            return (
+              <>
+                <cs.DocWhen doc={getDocComments($, value)} />
+                <cs.EnumMember
+                  name={cs.useCSharpNamePolicy().getName(key, "enum-member")}
+                  refkey={
+                    $.union.is(props.type)
+                      ? efRefkey(props.type.variants.get(key))
+                      : efRefkey(value)
+                  }
+                />
+              </>
+            );
+          }}
+        </ay.For>
+      </cs.EnumDeclaration>
+    </>
   );
 }

package/src/csharp/components/index.ts

@@ -1,3 +1,4 @@
-export * from "./class-declaration.jsx";
+export * from "./class/declaration.js";
 export * from "./enum-declaration.jsx";
+export * from "./property/property.jsx";
 export * from "./type-expression.jsx";

package/src/csharp/components/property/property.test.tsx

@@ -0,0 +1,97 @@
+import { Tester } from "#test/test-host.js";
+import { Children } from "@alloy-js/core";
+import { ClassDeclaration, createCSharpNamePolicy, Namespace, SourceFile } from "@alloy-js/csharp";
+import { t, TesterInstance } from "@typespec/compiler/testing";
+import { beforeEach, describe, expect, it } from "vitest";
+import { Output } from "../../../core/components/output.jsx";
+import { Property } from "./property.jsx";
+
+let tester: TesterInstance;
+
+beforeEach(async () => {
+  tester = await Tester.createInstance();
+});
+
+function Wrapper(props: { children: Children }) {
+  const policy = createCSharpNamePolicy();
+  return (
+    <Output program={tester.program} namePolicy={policy}>
+      <Namespace name="TestNamespace">
+        <SourceFile path="test.cs">
+          <ClassDeclaration name="Test">{props.children}</ClassDeclaration>
+        </SourceFile>
+      </Namespace>
+    </Output>
+  );
+}
+
+it("maps prop: string | null to nullable property", async () => {
+  const { prop1 } = await tester.compile(t.code`
+    model TestModel {
+      ${t.modelProperty("prop1")}: string | null;
+    }
+  `);
+
+  expect(
+    <Wrapper>
+      <Property type={prop1} />
+    </Wrapper>,
+  ).toRenderTo(`
+      namespace TestNamespace
+      {
+        class Test
+        {
+          public required string? Prop1 { get; set; }
+        }
+      }
+  `);
+});
+
+describe("jsonAttributes", () => {
+  it("adds [JsonNameAttribute]", async () => {
+    const { prop1 } = await tester.compile(t.code`
+    model TestModel {
+      ${t.modelProperty("prop1")}: string;
+    }
+  `);
+
+    expect(
+      <Wrapper>
+        <Property type={prop1} jsonAttributes />
+      </Wrapper>,
+    ).toRenderTo(`
+      namespace TestNamespace
+      {
+        class Test
+        {
+          [System.Text.Json.JsonPropertyName("prop1")]
+          public required string Prop1 { get; set; }
+        }
+      }
+  `);
+  });
+
+  it("adds [JsonNameAttribute] respecting encodedName", async () => {
+    const { prop1 } = await tester.compile(t.code`
+    model TestModel {
+      @encodedName("application/json", "prop_1")
+      ${t.modelProperty("prop1")}: string;
+    }
+  `);
+
+    expect(
+      <Wrapper>
+        <Property type={prop1} jsonAttributes />
+      </Wrapper>,
+    ).toRenderTo(`
+      namespace TestNamespace
+      {
+        class Test
+        {
+          [System.Text.Json.JsonPropertyName("prop_1")]
+          public required string Prop1 { get; set; }
+        }
+      }
+  `);
+  });
+});