@typespec/emitter-framework 0.6.0-dev.1 → 0.6.0-dev.4

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

@@ -0,0 +1,85 @@
+import { Output, render } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import { SourceFile } from "@alloy-js/typescript";
+import { Operation } from "@typespec/compiler";
+import { BasicTestRunner } from "@typespec/compiler/testing";
+import { beforeEach, describe, it } from "vitest";
+import { ArrowFunction } from "../../../src/typescript/components/arrow-function.jsx";
+import { assertFileContents } from "../../utils.js";
+import { createEmitterFrameworkTestRunner } from "../test-host.js";
+
+describe("arrow functions with a `type` prop", () => {
+  let runner: BasicTestRunner;
+
+  beforeEach(async () => {
+    runner = await createEmitterFrameworkTestRunner();
+  });
+
+  it("creates a function", async () => {
+    const { getName } = (await runner.compile(`
+      @test op getName(id: string): string;
+    `)) as { getName: Operation };
+
+    const res = render(
+      <Output>
+        <SourceFile path="test.ts">
+          <ArrowFunction type={getName}>console.log("Hello!");</ArrowFunction>
+        </SourceFile>
+      </Output>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+        (id: string): string => {
+          console.log("Hello!");
+        }
+      `,
+    );
+  });
+
+  it("creates an async function", async () => {
+    const { getName } = (await runner.compile(`
+      @test op getName(id: string): string;
+    `)) as { getName: Operation };
+
+    const res = render(
+      <Output>
+        <SourceFile path="test.ts">
+          <ArrowFunction async type={getName} />
+        </SourceFile>
+      </Output>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+        async (id: string): Promise<string> => {}
+      `,
+    );
+  });
+
+  it("can append extra parameters with raw params provided", async () => {
+    const { getName } = (await runner.compile(`
+      @test op getName(id: string): string;
+    `)) as { getName: Operation };
+
+    const res = render(
+      <Output>
+        <SourceFile path="test.ts">
+          <ArrowFunction
+            type={getName}
+            parameters={[{ name: "additionalParam", type: "number" }]}
+          />
+        </SourceFile>
+      </Output>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+        (additionalParam: number, id: string): string => {}
+      `,
+    );
+  });
+});

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

@@ -0,0 +1,85 @@
+import { Output, render } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import { SourceFile } from "@alloy-js/typescript";
+import { Operation } from "@typespec/compiler";
+import { BasicTestRunner } from "@typespec/compiler/testing";
+import { beforeEach, describe, it } from "vitest";
+import { FunctionExpression } from "../../../src/typescript/components/function-expression.jsx";
+import { assertFileContents } from "../../utils.js";
+import { createEmitterFrameworkTestRunner } from "../test-host.js";
+
+describe("function expressions with a `type` prop", () => {
+  let runner: BasicTestRunner;
+
+  beforeEach(async () => {
+    runner = await createEmitterFrameworkTestRunner();
+  });
+
+  it("creates a function", async () => {
+    const { getName } = (await runner.compile(`
+      @test op getName(id: string): string;
+    `)) as { getName: Operation };
+
+    const res = render(
+      <Output>
+        <SourceFile path="test.ts">
+          <FunctionExpression type={getName}>console.log("Hello!");</FunctionExpression>
+        </SourceFile>
+      </Output>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+        function (id: string): string {
+          console.log("Hello!");
+        }
+      `,
+    );
+  });
+
+  it("creates an async function", async () => {
+    const { getName } = (await runner.compile(`
+      @test op getName(id: string): string;
+    `)) as { getName: Operation };
+
+    const res = render(
+      <Output>
+        <SourceFile path="test.ts">
+          <FunctionExpression async type={getName} />
+        </SourceFile>
+      </Output>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+        async function (id: string): Promise<string> {}
+      `,
+    );
+  });
+
+  it("can append extra parameters with raw params provided", async () => {
+    const { getName } = (await runner.compile(`
+      @test op getName(id: string): string;
+    `)) as { getName: Operation };
+
+    const res = render(
+      <Output>
+        <SourceFile path="test.ts">
+          <FunctionExpression
+            type={getName}
+            parameters={[{ name: "additionalParam", type: "number" }]}
+          />
+        </SourceFile>
+      </Output>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+        function (additionalParam: number, id: string): string {}
+      `,
+    );
+  });
+});

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

@@ -0,0 +1,80 @@
+import { Output, render } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import { SourceFile } from "@alloy-js/typescript";
+import { Operation } from "@typespec/compiler";
+import { BasicTestRunner } from "@typespec/compiler/testing";
+import { beforeEach, describe, it } from "vitest";
+import { FunctionType } from "../../../src/typescript/index.js";
+import { assertFileContents } from "../../utils.js";
+import { createEmitterFrameworkTestRunner } from "../test-host.js";
+
+describe("function types with a `type` prop", () => {
+  let runner: BasicTestRunner;
+
+  beforeEach(async () => {
+    runner = await createEmitterFrameworkTestRunner();
+  });
+
+  it("creates a function type", async () => {
+    const { getName } = (await runner.compile(`
+      @test op getName(id: string): string;
+    `)) as { getName: Operation };
+
+    const res = render(
+      <Output>
+        <SourceFile path="test.ts">
+          <FunctionType type={getName} />
+        </SourceFile>
+      </Output>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+        (id: string) => string
+      `,
+    );
+  });
+
+  it("creates an async function type", async () => {
+    const { getName } = (await runner.compile(`
+      @test op getName(id: string): string;
+    `)) as { getName: Operation };
+
+    const res = render(
+      <Output>
+        <SourceFile path="test.ts">
+          <FunctionType async type={getName} />
+        </SourceFile>
+      </Output>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+        (id: string) => Promise<string>
+      `,
+    );
+  });
+
+  it("can append extra parameters with raw params provided", async () => {
+    const { getName } = (await runner.compile(`
+      @test op getName(id: string): string;
+    `)) as { getName: Operation };
+
+    const res = render(
+      <Output>
+        <SourceFile path="test.ts">
+          <FunctionType type={getName} parameters={[{ name: "additionalParam", type: "number" }]} />
+        </SourceFile>
+      </Output>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+        (additionalParam: number, id: string) => string
+      `,
+    );
+  });
+});

package/test/typescript/components/interface-declaration.test.tsx

@@ -564,7 +564,7 @@ describe("Typescript Interface", () => {
         const actualContent = await format(testFile.contents as string, { parser: "typescript" });
         const expectedContent = await format(
           `export interface WidgetOperations {
-          getName: (id: string) => string;
+          getName(id: string): string;
         }`,
           {
             parser: "typescript",
@@ -605,8 +605,8 @@ describe("Typescript Interface", () => {
         const actualContent = await format(testFile.contents as string, { parser: "typescript" });
         const expectedContent = await format(
           `export interface WidgetOperations {
-          getName: (foo: Foo) => string;
-          getOtherName: (name: string) => string
+          getName(foo: Foo): string;
+          getOtherName(name: string): string
         }
         export interface Foo {
           name: string;
@@ -654,7 +654,7 @@ describe("Typescript Interface", () => {
         const actualContent = await format(testFile.contents as string, { parser: "typescript" });
         const expectedContent = await format(
           `export interface WidgetOperations {
-          getName: (id: string) => Widget;
+          getName(id: string): Widget;
         }
         export interface Widget {
           id: string;
@@ -707,8 +707,8 @@ describe("Typescript Interface", () => {
         const actualContent = await format(testFile.contents as string, { parser: "typescript" });
         const expectedContent = await format(
           `export interface WidgetOperationsExtended {
-          getName: (id: string) => Widget;
-          delete: (id: string) => void;
+          getName(id: string): Widget;
+          delete(id: string): void;
         }
         export interface Widget {
           id: string;

package/test/typescript/components/interface-method.test.tsx

@@ -0,0 +1,69 @@
+import { Output, render } from "@alloy-js/core";
+import { d } from "@alloy-js/core/testing";
+import { InterfaceDeclaration, SourceFile } from "@alloy-js/typescript";
+import { Operation } from "@typespec/compiler";
+import { BasicTestRunner } from "@typespec/compiler/testing";
+import { beforeEach, describe, it } from "vitest";
+import { InterfaceMethod } from "../../../src/typescript/components/interface-method.jsx";
+import { assertFileContents } from "../../utils.js";
+import { createEmitterFrameworkTestRunner } from "../test-host.js";
+
+describe("interface methods with a `type` prop", () => {
+  let runner: BasicTestRunner;
+
+  beforeEach(async () => {
+    runner = await createEmitterFrameworkTestRunner();
+  });
+
+  it("creates a interface member", async () => {
+    const { getName } = (await runner.compile(`
+      @test op getName(id: string): string;
+    `)) as { getName: Operation };
+
+    const res = render(
+      <Output>
+        <SourceFile path="test.ts">
+          <InterfaceDeclaration name="basicInterface">
+            <InterfaceMethod type={getName} name={getName.name} />
+          </InterfaceDeclaration>
+        </SourceFile>
+      </Output>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+        interface basicInterface {
+          getName(id: string): string
+        }
+      `,
+    );
+  });
+
+  it("creates an async interface function", async () => {
+    const { getName } = (await runner.compile(`
+      @test op getName(id: string): string;
+    `)) as { getName: Operation };
+
+    const res = render(
+      <Output>
+        <SourceFile path="test.ts">
+          <InterfaceDeclaration name="basicInterface">
+            <InterfaceMethod async type={getName} />
+          </InterfaceDeclaration>
+        </SourceFile>
+      </Output>,
+    );
+
+    assertFileContents(
+      res,
+      d`
+        interface basicInterface {
+          getName(id: string): Promise<string>
+        }
+      `,
+    );
+  });
+
+  it.todo("can append extra parameters with raw params provided", async () => {});
+});

package/test/typescript/components/type-alias-declaration.test.tsx

@@ -1,10 +1,11 @@
 import { Output, render } from "@alloy-js/core";
 import { SourceFile } from "@alloy-js/typescript";
-import { Namespace } from "@typespec/compiler";
+import { Namespace, Operation } from "@typespec/compiler";
 import { format } from "prettier";
 import { assert, describe, expect, it } from "vitest";
 import { TypeAliasDeclaration } from "../../../src/typescript/components/type-alias-declaration.jsx";
-import { getProgram } from "../test-host.js";
+import { assertFileContents } from "../../utils.js";
+import { createEmitterFrameworkTestRunner, getProgram } from "../test-host.js";
 
 describe("Typescript Type Alias Declaration", () => {
   describe("Type Alias bound to Typespec Scalar", () => {
@@ -117,4 +118,21 @@ describe("Typescript Type Alias Declaration", () => {
       });
     });
   });
+
+  it("creates a type alias of a function", async () => {
+    const runner = await createEmitterFrameworkTestRunner();
+    const { getName } = (await runner.compile(`
+      @test op getName(id: string): string;
+    `)) as { getName: Operation };
+
+    const res = render(
+      <Output>
+        <SourceFile path="test.ts">
+          <TypeAliasDeclaration type={getName} />
+        </SourceFile>
+      </Output>,
+    );
+
+    assertFileContents(res, "type getName = (id: string) => string;");
+  });
 });

package/test/typescript/components/value-expression.test.tsx

@@ -0,0 +1,236 @@
+import { Output, render } from "@alloy-js/core";
+import { dedent } from "@alloy-js/core/testing";
+import { SourceFile } from "@alloy-js/typescript";
+import { EnumValue, Model, Namespace, Numeric, NumericValue, Value } from "@typespec/compiler";
+import { $ } from "@typespec/compiler/experimental/typekit";
+import { assert, beforeAll, describe, expect, it } from "vitest";
+import { ValueExpression } from "../../../src/typescript/components/value-expression.js";
+import { getProgram, initEmptyProgram } from "../test-host.js";
+
+beforeAll(async () => {
+  await initEmptyProgram();
+});
+
+it("renders strings", async () => {
+  const value = $.value.createString("test");
+
+  await testValueExpression(value, `"test"`);
+});
+
+describe("numeric values", () => {
+  it("renders integers", async () => {
+    const value = $.value.createNumeric(42);
+
+    await testValueExpression(value, `42`);
+  });
+
+  it("renders decimals", async () => {
+    const value = $.value.createNumeric(42.5);
+
+    await testValueExpression(value, `42.5`);
+  });
+
+  it("renders bigints", async () => {
+    const digits = "1234567890123456789012345678901234567890";
+    const value: NumericValue = {
+      entityKind: "Value",
+      valueKind: "NumericValue",
+      value: Numeric(digits),
+    } as NumericValue;
+
+    await testValueExpression(value, `${digits}n`);
+  });
+
+  it("throws on invalid numbers", async () => {
+    const digits = "123456789123456789.112233445566778899";
+    const value: NumericValue = {
+      entityKind: "Value",
+      valueKind: "NumericValue",
+      value: Numeric(digits),
+    } as NumericValue;
+
+    await expect(testValueExpression(value, ``)).rejects.toThrow("BigInt value must be an integer");
+  });
+});
+
+it("renders booleans", async () => {
+  const value = $.value.createBoolean(true);
+  await testValueExpression(value, `true`);
+});
+
+it("renders nulls", async () => {
+  const value = {
+    entityKind: "Value",
+    valueKind: "NullValue",
+    value: null,
+  } as Value;
+  await testValueExpression(value, `null`);
+});
+
+it("renders empty arrays", async () => {
+  // Can be replaced with with TypeKit once #6976 is implemented
+  const value = {
+    entityKind: "Value",
+    valueKind: "ArrayValue",
+    values: [],
+  } as unknown as Value;
+  await testValueExpression(value, `[]`);
+});
+
+it("renders arrays with mixed values", async () => {
+  // Can be replaced with with TypeKit once #6976 is implemented
+  const value = {
+    entityKind: "Value",
+    valueKind: "ArrayValue",
+    values: [$.value.createString("foo"), $.value.createNumeric(42), $.value.createBoolean(true)],
+  } as Value;
+  await testValueExpression(value, `["foo", 42, true]`);
+});
+
+it("renders scalars", async () => {
+  const program = await getProgram(`
+      namespace DemoService;
+      model DateRange {
+        @encode("rfc7231")
+        minDate: utcDateTime = utcDateTime.fromISO("2024-02-15T18:36:03Z");
+      }
+    `);
+  const [namespace] = program.resolveTypeReference("DemoService");
+  const dateRange = (namespace as Namespace).models.get("DateRange");
+  const minDate = dateRange?.properties.get("minDate")?.defaultValue;
+  assert.exists(minDate, "unable to find minDate property");
+  await testValueExpression(minDate, `"2024-02-15T18:36:03Z"`);
+});
+
+it("throws on unsupported scalar", async () => {
+  const program = await getProgram(`
+      namespace DemoService;
+
+      scalar ipv4 extends string {
+        init fromInt(value: uint32);
+      }
+
+      @example (#{ip: ipv4.fromInt(2130706433)})
+      model IpAddress {
+        ip: ipv4;
+      }
+    `);
+  const [namespace] = program.resolveTypeReference("DemoService");
+  const model = (namespace as Namespace).models.get("IpAddress");
+  assert.exists(model, "unable to find IpAddress model");
+
+  const value = getExampleValue(model);
+  await expect(testValueExpression(value, ``)).rejects.toThrow(
+    /Unsupported scalar constructor fromInt/,
+  );
+});
+
+it("renders empty objects", async () => {
+  // Can be replaced with with TypeKit once #6976 is implemented
+  const program = await getProgram(`
+      namespace DemoService;
+      @example(#{})
+      model ObjectValue {};
+    `);
+  const [namespace] = program.resolveTypeReference("DemoService");
+  const model = (namespace as Namespace).models.get("ObjectValue");
+  assert.exists(model, "unable to find ObjectValue model");
+
+  const value = getExampleValue(model);
+  await testValueExpression(value, `{}`);
+});
+
+it("renders objects with properties", async () => {
+  // Can be replaced with with TypeKit once #6976 is implemented
+  const program = await getProgram(`
+      namespace DemoService;
+      @example(#{a: 5, b: "foo", c: true})
+      model ObjectValue {
+        a: int32;
+        b: string;
+        c: boolean;
+      };
+    `);
+  const [namespace] = program.resolveTypeReference("DemoService");
+  const model = (namespace as Namespace).models.get("ObjectValue");
+  assert.exists(model, "unable to find ObjectValue model");
+
+  const value = getExampleValue(model);
+  await testValueExpression(
+    value,
+    dedent(`
+      {
+        a: 5,
+        b: "foo",
+        c: true,
+      }`),
+  );
+});
+
+it("renders enums", async () => {
+  // Can be replaced with with TypeKit once #6976 is implemented
+  const program = await getProgram(`
+      namespace DemoService;
+      enum Color {
+        Red,
+        Green: 3,
+        Blue
+      }
+    `);
+  const [namespace] = program.resolveTypeReference("DemoService");
+  const colors = (namespace as Namespace).enums.get("Color");
+  assert.exists(colors, "unable to find Color enum");
+
+  const red = colors?.members.get("Red");
+  assert.exists(red, "unable to find Red enum member");
+  await testValueExpression(
+    {
+      valueKind: "EnumValue",
+      value: red,
+    } as EnumValue,
+    `"Red"`,
+  );
+
+  const green = colors?.members.get("Green");
+  assert.exists(green, "unable to find Green enum member");
+  await testValueExpression(
+    {
+      valueKind: "EnumValue",
+      value: green,
+    } as EnumValue,
+    `3`,
+  );
+});
+
+/**
+ * Helper that renders a value expression and checks the output against the expected value.
+ */
+async function testValueExpression(value: Value, expected: string) {
+  const prefix = "const val = ";
+  const res = render(
+    <Output>
+      <SourceFile path="test.ts">
+        {prefix}
+        <ValueExpression value={value} />
+      </SourceFile>
+    </Output>,
+  );
+  const testFile = res.contents.find((file) => file.path === "test.ts");
+
+  assert.exists(testFile, "test.ts file not rendered");
+
+  assert.equal(
+    testFile.contents,
+    `${prefix}${expected}`,
+    "test.ts file contents do not match expected",
+  );
+}
+
+/**
+ * Extracts the value marked with the @example decorator from a model.
+ */
+function getExampleValue(model: Model): Value {
+  const decorator = model?.decorators.find((d) => d.definition?.name === "@example");
+  assert.exists(decorator?.args[0]?.value, "unable to find example decorator");
+  return decorator.args[0].value as Value;
+}

package/test/typescript/test-host.ts

@@ -39,3 +39,11 @@ export async function getProgram(
   expectDiagnosticEmpty(diagnostics);
   return wrapper.program;
 }
+
+/**
+ * Initializes an empty program in the compiler.
+ * This is useful when you want to initialize the default TypeKits without any code.
+ */
+export async function initEmptyProgram(): Promise<void> {
+  await getProgram("");
+}

package/test/utils.ts

@@ -1,7 +1,8 @@
-import { Children, render } from "@alloy-js/core";
+import { Children, OutputDirectory, render } from "@alloy-js/core";
 import { Output } from "@alloy-js/core/stc";
 import { SourceFile } from "@alloy-js/typescript/stc";
 import { Program } from "@typespec/compiler";
+import { assert } from "vitest";
 import { getProgram } from "./typescript/test-host.js";
 
 export async function getEmitOutput(tspCode: string, cb: (program: Program) => Children) {
@@ -12,3 +13,9 @@ export async function getEmitOutput(tspCode: string, cb: (program: Program) => C
 
   return testFile.contents;
 }
+
+export function assertFileContents(res: OutputDirectory, contents: string) {
+  const testFile = res.contents.find((file) => file.path === "test.ts")!;
+  assert(testFile, "test.ts file not rendered");
+  assert.equal(testFile.contents, contents);
+}