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

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; }
+        }
+      }
+  `);
+  });
+});

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

@@ -0,0 +1,62 @@
+import { Children } from "@alloy-js/core";
+import * as cs from "@alloy-js/csharp";
+import { Attribute } from "@alloy-js/csharp";
+import { ModelProperty, resolveEncodedName, Type } from "@typespec/compiler";
+import { useTsp } from "../../../core/index.js";
+import { TypeExpression } from "../type-expression.jsx";
+import { getDocComments } from "../utils/doc-comments.jsx";
+
+export interface PropertyProps {
+  type: ModelProperty;
+  /** If set the property will add the json serialization attributes(using System.Text.Json). */
+  jsonAttributes?: boolean;
+}
+
+/**
+ * Create a C# property declaration from a TypeSpec property type.
+ */
+export function Property(props: PropertyProps): Children {
+  const result = preprocessPropertyType(props.type.type);
+  const { $ } = useTsp();
+
+  return (
+    <cs.Property
+      name={props.type.name}
+      type={<TypeExpression type={result.type} />}
+      public
+      required={!props.type.optional}
+      nullable={result.nullable}
+      doc={getDocComments($, props.type)}
+      attributes={props.jsonAttributes ? [<JsonNameAttribute type={props.type} />] : undefined}
+      get
+      set
+    />
+  );
+}
+
+export interface JsonNameAttributeProps {
+  type: ModelProperty;
+}
+
+function JsonNameAttribute(props: JsonNameAttributeProps): Children {
+  const { program } = useTsp();
+  const jsonName = resolveEncodedName(program, props.type, "application/json");
+  return <Attribute name="System.Text.Json.JsonPropertyName" args={[JSON.stringify(jsonName)]} />;
+}
+
+function preprocessPropertyType(type: Type): { type: Type; nullable: boolean } {
+  const { $ } = useTsp();
+
+  if (type.kind === "Union") {
+    const variants = type.variants;
+    const nonNullVariant = [...variants.values()].find((v) => v.type !== $.intrinsic.null);
+    const nullVariant = [...variants.values()].find((v) => v.type !== $.intrinsic.null);
+    if (nonNullVariant && nullVariant && variants.size === 2) {
+      return { type: nonNullVariant.type, nullable: true };
+    } else {
+      return { type, nullable: false };
+    }
+  } else {
+    return { type, nullable: false };
+  }
+}

package/src/csharp/components/type-expression.test.tsx

@@ -0,0 +1,133 @@
+import { Children, render } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import { Namespace, SourceFile } from "@alloy-js/csharp";
+import { Model, ModelProperty } from "@typespec/compiler";
+import { BasicTestRunner } from "@typespec/compiler/testing";
+import { beforeEach, describe, it } from "vitest";
+import { createEmitterFrameworkTestRunner } from "../../../test/typescript/test-host.js";
+import { assertFileContents } from "../../../test/utils.js";
+import { Output } from "../../core/index.js";
+import { ClassDeclaration } from "./class/declaration.js";
+import { TypeExpression } from "./type-expression.jsx";
+
+let runner: BasicTestRunner;
+
+beforeEach(async () => {
+  runner = await createEmitterFrameworkTestRunner();
+});
+
+function Wrapper(props: { children: Children }) {
+  return (
+    <Output program={runner.program}>
+      <Namespace name="TestNamespace">
+        <SourceFile path="test.ts">{props.children}</SourceFile>
+      </Namespace>
+    </Output>
+  );
+}
+
+async function compileType(ref: string) {
+  const { test } = await runner.compile(`
+    model Test {
+      @test test: ${ref};
+    }
+  `);
+
+  return (test as ModelProperty).type;
+}
+
+describe("map scalar to c# built-in types", () => {
+  it.each([
+    ["string", "string"],
+    ["int32", "int"],
+    ["int64", "long"],
+  ])("%s => %s", async (tspType, csType) => {
+    const type = await compileType(tspType);
+    const res = render(
+      <Wrapper>
+        <TypeExpression type={type} />
+      </Wrapper>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+          namespace TestNamespace
+          {
+              ${csType}
+          }
+        `,
+    );
+  });
+});
+
+it("maps array to c# array", async () => {
+  const type = await compileType("int32[]");
+  const res = render(
+    <Wrapper>
+      <TypeExpression type={type} />
+    </Wrapper>,
+  );
+
+  assertFileContents(
+    res,
+    d`
+          namespace TestNamespace
+          {
+              int[]
+          }
+        `,
+  );
+});
+
+describe("Record map to IDictionary", () => {
+  it("for primitive types", async () => {
+    const type = await compileType("Record<int32>");
+    const res = render(
+      <Wrapper>
+        <TypeExpression type={type} />
+      </Wrapper>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+          namespace TestNamespace
+          {
+              IDictionary<string, int>
+          }
+        `,
+    );
+  });
+
+  it("for models", async () => {
+    const { test, Pet } = (await runner.compile(`
+      model Test {
+        @test test: Record<Pet>;
+      }
+      @test model Pet {}
+    `)) as { test: ModelProperty; Pet: Model };
+
+    const res = render(
+      <Wrapper>
+        <ClassDeclaration type={Pet} />
+        <hbr />
+        <TypeExpression type={test.type} />
+      </Wrapper>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+          namespace TestNamespace
+          {
+              class Pet
+              {
+          
+              }
+              IDictionary<string, Pet>
+          }
+        `,
+    );
+  });
+});

package/src/csharp/components/type-expression.tsx

@@ -1,6 +1,6 @@
-import { Children } from "@alloy-js/core";
+import { Children, code } from "@alloy-js/core";
 import { Reference } from "@alloy-js/csharp";
-import { IntrinsicType, Scalar, Type } from "@typespec/compiler";
+import { getTypeName, IntrinsicType, Scalar, Type } from "@typespec/compiler";
 import { Typekit } from "@typespec/compiler/typekit";
 import { useTsp } from "../../core/index.js";
 import { reportTypescriptDiagnostic } from "../../typescript/lib.js";
@@ -17,8 +17,15 @@ export function TypeExpression(props: TypeExpressionProps): Children {
   }
   if ($.scalar.is(props.type)) {
     return getScalarIntrinsicExpression($, props.type);
+  } else if ($.array.is(props.type)) {
+    return code`${(<TypeExpression type={props.type.indexer.value} />)}[]`;
+  } else if ($.record.is(props.type)) {
+    return code`IDictionary<string, ${(<TypeExpression type={props.type.indexer.value} />)}>`;
   }
-  throw new Error("not implemented");
+
+  throw new Error(
+    `Unsupported type for TypeExpression: ${props.type.kind} (${getTypeName(props.type)})`,
+  );
 }
 
 const intrinsicNameToCSharpType = new Map<string, string | null>([

package/src/csharp/components/utils/doc-comments.tsx

@@ -0,0 +1,58 @@
+import * as ay from "@alloy-js/core";
+import * as cs from "@alloy-js/csharp";
+import { getReturnsDoc, Type } from "@typespec/compiler";
+import { Typekit } from "@typespec/compiler/typekit";
+
+/**
+ * Helper to render a doc string for a given TypeSpec type.
+ *
+ * This is not a JSX component as it needs to return undefined if there is no doc.
+ *
+ * @param $ The Typekit instance
+ * @param type The TypeSpec type to generate documentation for
+ * @returns A DocSummary component containing the rendered doc string, or undefined if no doc is available.
+ */
+export function getDocComments($: Typekit, type: Type): ay.Children {
+  const typeDoc = $.type.getDoc(type);
+  if (!typeDoc) {
+    return undefined;
+  }
+
+  const docElements: ay.Children[] = [];
+
+  // Add main type documentation
+  docElements.push(
+    <cs.DocSummary>
+      <cs.DocFromMarkdown markdown={typeDoc} />
+    </cs.DocSummary>,
+  );
+
+  // Add operation-specific documentation if applicable
+  if ($.operation.is(type)) {
+    // Add parameter documentation
+    const paramDocs = [];
+    for (const param of type.parameters.properties.values()) {
+      const paramDoc = $.type.getDoc(param);
+      if (paramDoc) {
+        paramDocs.push(
+          <cs.DocParam name={param.name}>
+            <cs.DocFromMarkdown markdown={paramDoc} />
+          </cs.DocParam>,
+        );
+      }
+    }
+    docElements.push(...paramDocs);
+
+    // Add return documentation
+    const returnDoc = getReturnsDoc($.program, type);
+    if (returnDoc) {
+      docElements.push(
+        <cs.DocReturns>
+          <cs.DocFromMarkdown markdown={returnDoc} />
+        </cs.DocReturns>,
+      );
+    }
+  }
+
+  return <ay.List doubleHardline>{docElements}</ay.List>;
+}

package/src/typescript/components/arrow-function.tsx

@@ -1,4 +1,4 @@
-import { splitProps } from "@alloy-js/core/jsx-runtime";
+import { splitProps } from "@alloy-js/core";
 import * as ts from "@alloy-js/typescript";
 import { Operation } from "@typespec/compiler";
 import { buildParameterDescriptors, getReturnType } from "../utils/operation.js";

package/src/typescript/components/function-expression.tsx

@@ -1,4 +1,4 @@
-import { splitProps } from "@alloy-js/core/jsx-runtime";
+import { splitProps } from "@alloy-js/core";
 import * as ts from "@alloy-js/typescript";
 import { Operation } from "@typespec/compiler";
 import { buildParameterDescriptors, getReturnType } from "../utils/operation.js";

package/src/typescript/components/function-type.tsx

@@ -1,4 +1,4 @@
-import { splitProps } from "@alloy-js/core/jsx-runtime";
+import { splitProps } from "@alloy-js/core";
 import * as ts from "@alloy-js/typescript";
 import { Operation } from "@typespec/compiler";
 import { buildParameterDescriptors, getReturnType } from "../utils/operation.js";

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

@@ -40,7 +40,7 @@ it("renders a basic enum declaration", async () => {
     d`
       namespace TestNamespace
       {
-          public enum TestEnum
+          enum TestEnum
           {
               Value1,
               Value2,
@@ -71,7 +71,7 @@ it("renders an empty enum declaration", async () => {
     d`
       namespace TestNamespace
       {
-          public enum TestEnum
+          enum TestEnum
           {
 
           }
@@ -103,7 +103,7 @@ it("can override enum name", async () => {
     d`
       namespace TestNamespace
       {
-          public enum CustomEnumName
+          enum CustomEnumName
           {
               Value1,
               Value2
@@ -125,7 +125,7 @@ it("renders an enum with access modifiers", async () => {
     <Output program={runner.program}>
       <Namespace name="TestNamespace">
         <SourceFile path="test.cs">
-          <EnumDeclaration type={TestEnum} accessModifier="internal" />
+          <EnumDeclaration type={TestEnum} internal />
         </SourceFile>
       </Namespace>
     </Output>,
@@ -170,7 +170,7 @@ it("renders enum with C# naming conventions", async () => {
     d`
       namespace TestNamespace
       {
-          public enum TestEnum
+          enum TestEnum
           {
               ValueOne,
               ValueTwo,
@@ -203,7 +203,7 @@ it("renders enum with single value", async () => {
     d`
       namespace TestNamespace
       {
-          public enum TestEnum
+          enum TestEnum
           {
               OnlyValue
           }
@@ -237,7 +237,7 @@ it("renders enum with numeric-like member names", async () => {
     d`
       namespace TestNamespace
       {
-          public enum TestEnum
+          enum TestEnum
           {
               Value0,
               Value1,
@@ -279,12 +279,12 @@ it("renders multiple enums in the same namespace", async () => {
     d`
       namespace TestNamespace
       {
-          public enum TestEnum1
+          enum TestEnum1
           {
               Value1,
               Value2
           }
-          public enum TestEnum2
+          enum TestEnum2
           {
               OptionA,
               OptionB,
@@ -294,3 +294,44 @@ it("renders multiple enums in the same namespace", async () => {
     `,
   );
 });
+
+it("renders an enum with doc comments", async () => {
+  const { TestEnum } = (await runner.compile(`
+    @test enum TestEnum {
+      @doc("This is value one")
+      Value1;
+      /** This is value two */
+      Value2;
+    }
+  `)) as { TestEnum: Enum };
+
+  const res = render(
+    <Output program={runner.program}>
+      <Namespace name="TestNamespace">
+        <SourceFile path="test.cs">
+          <EnumDeclaration type={TestEnum} />
+        </SourceFile>
+      </Namespace>
+    </Output>,
+  );
+
+  assertFileContents(
+    res,
+    d`
+      namespace TestNamespace
+      {
+          enum TestEnum
+          {
+              /// <summary>
+              /// This is value one
+              /// </summary>
+              Value1,
+              /// <summary>
+              /// This is value two
+              /// </summary>
+              Value2
+          }
+      }
+    `,
+  );
+});

package/test/test-host.ts

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

package/test/vitest.setup.ts

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

package/tsconfig.json

@@ -14,7 +14,8 @@
     "jsxImportSource": "@alloy-js/core",
     "emitDeclarationOnly": true,
     "outDir": "dist",
-    "rootDir": "./"
+    "rootDir": "./",
+    "types": ["@alloy-js/core/testing/matchers"]
   },
   "include": ["src/**/*.ts", "src/**/*.tsx", "test/**/*.ts", "test/**/*.tsx"],
   "exclude": ["node_modules", "dist"]

package/vitest.config.ts

@@ -6,8 +6,9 @@ export default mergeConfig(
   defaultTypeSpecVitestConfig,
   defineConfig({
     test: {
-      include: ["test/**/*.test.ts", "test/**/*.test.tsx"],
+      include: ["src/**/*.test.ts", "src/**/*.test.tsx", "test/**/*.test.ts", "test/**/*.test.tsx"],
       passWithNoTests: true,
+      setupFiles: ["./test/vitest.setup.ts"],
     },
     esbuild: {
       jsx: "preserve",

package/dist/src/csharp/components/class-declaration.d.ts

@@ -1,9 +0,0 @@
-import * as ay from "@alloy-js/core";
-import * as cs from "@alloy-js/csharp";
-import { Interface, Model } from "@typespec/compiler";
-export interface ClassDeclarationProps extends Omit<cs.ClassProps, "name"> {
-    name?: string;
-    type: Model | Interface;
-}
-export declare function ClassDeclaration(props: ClassDeclarationProps): ay.Children;
-//# sourceMappingURL=class-declaration.d.ts.map

package/dist/src/csharp/components/class-declaration.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"class-declaration.d.ts","sourceRoot":"","sources":["../../../../src/csharp/components/class-declaration.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,gBAAgB,CAAC;AACrC,OAAO,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACvC,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAKtD,MAAM,WAAW,qBAAsB,SAAQ,IAAI,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,CAAC;IACxE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,KAAK,GAAG,SAAS,CAAC;CACzB;AAUD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,GAAG,EAAE,CAAC,QAAQ,CAgB1E"}

package/dist/test/csharp/components/class-declaration.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=class-declaration.test.d.ts.map

package/dist/test/csharp/components/class-declaration.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"class-declaration.test.d.ts","sourceRoot":"","sources":["../../../../test/csharp/components/class-declaration.test.tsx"],"names":[],"mappings":""}