@typespec/http-server-js 0.58.0-alpha.12-dev.0 → 0.58.0-alpha.12-dev.1

package/test/datetime.test.ts

@@ -0,0 +1,226 @@
+import { deepStrictEqual, strictEqual, throws } from "assert";
+import { describe, it } from "vitest";
+import { Duration } from "../src/helpers/datetime.js";
+
+describe("datetime", () => {
+  describe("duration", () => {
+    it("parses an ISO8601 duration string", () => {
+      deepStrictEqual(Duration.parseISO8601("P1Y2M3D"), {
+        sign: "+",
+        years: 1,
+        months: 2,
+        weeks: 0,
+        days: 3,
+        hours: 0,
+        minutes: 0,
+        seconds: 0,
+      });
+    });
+
+    it("parses a negative ISO8601 duration string", () => {
+      deepStrictEqual(Duration.parseISO8601("-P1Y2M3D"), {
+        sign: "-",
+        years: 1,
+        months: 2,
+        weeks: 0,
+        days: 3,
+        hours: 0,
+        minutes: 0,
+        seconds: 0,
+      });
+    });
+
+    it("parses a duration string with hours and minutes", () => {
+      deepStrictEqual(Duration.parseISO8601("PT1H2M"), {
+        sign: "+",
+        years: 0,
+        months: 0,
+        weeks: 0,
+        days: 0,
+        hours: 1,
+        minutes: 2,
+        seconds: 0,
+      });
+    });
+
+    it("parses a duration string with fractional years", () => {
+      deepStrictEqual(Duration.parseISO8601("P1.5Y"), {
+        sign: "+",
+        years: 1.5,
+        months: 0,
+        weeks: 0,
+        days: 0,
+        hours: 0,
+        minutes: 0,
+        seconds: 0,
+      });
+    });
+
+    it("does not parse an invalid duration string", () => {
+      throws(() => Duration.parseISO8601("1Y2M3D4H"), {
+        message: "Invalid ISO8601 duration: 1Y2M3D4H",
+      });
+    });
+
+    it("does not parse a duration string with too many digits in a component", () => {
+      throws(
+        () =>
+          Duration.parseISO8601(
+            "P123429384502934875023948572039485720394857230948572309485723094857203948572309456789.19821374652345232304958273049582730495827340958720349857452345234529223450928347592834387456928374659238476Y",
+          ),
+        {
+          message:
+            "ISO8601 duration string is too long: P123429384502934875023948572039485720394857230948572309485723094857203948572309456789.19821374652345232304958273049582730495827340958720349857452345234529223450928347592834387456928374659238476Y",
+        },
+      );
+    });
+
+    it("does not parse a duration string with an invalid group", () => {
+      throws(() => Duration.parseISO8601("P1Y2M3D4H5X"), {
+        message: "Invalid ISO8601 duration: P1Y2M3D4H5X",
+      });
+    });
+
+    it("does not parse a duration string with missing group", () => {
+      throws(() => Duration.parseISO8601("P1Y2M3D4H5.5"), {
+        message: "Invalid ISO8601 duration: P1Y2M3D4H5.5",
+      });
+    });
+
+    it("does not parse a duration string with multiple points", () => {
+      throws(() => Duration.parseISO8601("P1.2.3Y"), {
+        message: "Invalid ISO8601 duration: P1.2.3Y",
+      });
+    });
+
+    it("allows comma as decimal separator", () => {
+      deepStrictEqual(Duration.parseISO8601("P1,5Y4.2DT1,005S"), {
+        sign: "+",
+        years: 1.5,
+        months: 0,
+        weeks: 0,
+        days: 4.2,
+        hours: 0,
+        minutes: 0,
+        seconds: 1.005,
+      });
+    });
+
+    it("writes an ISO8601 duration string", () => {
+      const duration: Duration = {
+        sign: "+",
+        years: 1,
+        months: 2,
+        weeks: 3,
+        days: 4,
+        hours: 5,
+        minutes: 6,
+        seconds: 7,
+      };
+
+      strictEqual(Duration.toISO8601(duration), "P1Y2M3W4DT5H6M7S");
+    });
+
+    it("writes a negative ISO8601 duration string", () => {
+      const duration: Duration = {
+        sign: "-",
+        years: 1,
+        months: 2,
+        weeks: 3,
+        days: 4,
+        hours: 5,
+        minutes: 6,
+        seconds: 7,
+      };
+
+      strictEqual(Duration.toISO8601(duration), "-P1Y2M3W4DT5H6M7S");
+    });
+
+    it("writes a duration string with only years", () => {
+      const duration: Duration = {
+        sign: "+",
+        years: 1,
+        months: 0,
+        weeks: 0,
+        days: 0,
+        hours: 0,
+        minutes: 0,
+        seconds: 0,
+      };
+
+      strictEqual(Duration.toISO8601(duration), "P1Y");
+    });
+
+    it("writes a duration string with only hours", () => {
+      const duration: Duration = {
+        sign: "+",
+        years: 0,
+        months: 0,
+        weeks: 0,
+        days: 0,
+        hours: 36,
+        minutes: 0,
+        seconds: 0,
+      };
+
+      strictEqual(Duration.toISO8601(duration), "PT36H");
+    });
+
+    it("writes a duration string with fractional amounts", () => {
+      const duration: Duration = {
+        sign: "+",
+        years: 1.5,
+        months: 0,
+        weeks: 0,
+        days: 0,
+        hours: 0,
+        minutes: 0,
+        seconds: 1.005,
+      };
+
+      strictEqual(Duration.toISO8601(duration), "P1.5YT1.005S");
+    });
+
+    it("computes total seconds in durations", () => {
+      const duration = Duration.parseISO8601("PT22H96M60S");
+
+      strictEqual(Duration.totalSeconds(duration), 22 * 60 * 60 + 96 * 60 + 60);
+      strictEqual(Duration.totalSecondsBigInt(duration), 22n * 60n * 60n + 96n * 60n + 60n);
+    });
+
+    it("computes total seconds in durations with fractional amounts", () => {
+      const duration = Duration.parseISO8601("PT1.5H22.005S");
+
+      strictEqual(Duration.totalSeconds(duration), 1.5 * 60 * 60 + 22 + 0.005);
+    });
+
+    it("does not allow total seconds for durations with years, months, weeks, or days", () => {
+      const durations = ["P1Y", "P1M", "P1W", "P1D"].map((iso) => Duration.parseISO8601(iso));
+
+      for (const duration of durations) {
+        throws(() => Duration.totalSeconds(duration), {
+          message:
+            "Cannot calculate total seconds for a duration with years, months, weeks, or days.",
+        });
+
+        throws(() => Duration.totalSecondsBigInt(duration), {
+          message:
+            "Cannot calculate total seconds for a duration with years, months, weeks, or days.",
+        });
+      }
+    });
+
+    it("does not allow total seconds as bigint for durations with fractional amounts", () => {
+      const durations = ["PT1.5H", "PT1.5M", "PT1.5S", "PT1H1.5M", "PT1H1.5S", "PT1M1.5S"].map(
+        (iso) => Duration.parseISO8601(iso),
+      );
+
+      for (const duration of durations) {
+        throws(() => Duration.totalSecondsBigInt(duration), {
+          message:
+            "Cannot calculate total seconds as a BigInt for a duration with non-integer components.",
+        });
+      }
+    });
+  });
+});

package/test/scalar.test.ts

@@ -0,0 +1,345 @@
+import { ModelProperty, NoTarget, Scalar } from "@typespec/compiler";
+import { BasicTestRunner, createTestRunner } from "@typespec/compiler/testing";
+import { deepStrictEqual, strictEqual } from "assert";
+import { beforeEach, describe, it } from "vitest";
+import { getJsScalar } from "../src/common/scalar.js";
+import { createPathCursor, JsContext, Module } from "../src/ctx.js";
+
+import { module as dateTimeModule } from "../generated-defs/helpers/datetime.js";
+
+describe("scalar", () => {
+  let runner: BasicTestRunner;
+
+  beforeEach(async () => {
+    runner = await createTestRunner();
+  });
+
+  function createFakeModule(): [JsContext, Module] {
+    const module: Module = {
+      name: "example",
+      cursor: createPathCursor(),
+
+      imports: [],
+      declarations: [],
+    };
+
+    // Min context
+    const ctx: JsContext = {
+      program: runner.program,
+      rootModule: module,
+    } as JsContext;
+
+    return [ctx, module];
+  }
+
+  async function getScalar(...names: string[]): Promise<Scalar[]> {
+    const { test } = (await runner.compile(`
+      model Example {
+        @test test: [${names.join(", ")}];
+      }
+    `)) as { test: ModelProperty };
+
+    if (test.type.kind !== "Tuple") {
+      throw new Error("Expected tuple type");
+    }
+
+    if (!test.type.values.every((t) => t.kind === "Scalar")) {
+      throw new Error("Expected scalar types only");
+    }
+
+    return test.type.values as Scalar[];
+  }
+
+  it("has no-op encoding for string", async () => {
+    const [string] = await getScalar("TypeSpec.string");
+
+    const [ctx, mod] = createFakeModule();
+
+    const jsScalar = getJsScalar(ctx, mod, string, NoTarget);
+
+    strictEqual(jsScalar.type, "string");
+    strictEqual(jsScalar.getEncoding("default", string)?.encode("asdf"), "(asdf)");
+    strictEqual(mod.imports.length, 0);
+  });
+
+  it("correctly encodes and decodes all numbers using default string encoding", async () => {
+    const [string, ...numbers] = await getScalar(
+      "string",
+      "float32",
+      "float64",
+      "int8",
+      "int16",
+      "int32",
+      "uint8",
+      "uint16",
+      "uint32",
+      "safeint",
+    );
+
+    const [ctx, mod] = createFakeModule();
+
+    for (const number of numbers) {
+      const jsScalar = getJsScalar(ctx, mod, number, NoTarget);
+
+      strictEqual(jsScalar.type, "number");
+
+      const encoding = jsScalar.getEncoding("default", string);
+
+      if (!encoding) {
+        throw new Error("Expected default encoding");
+      }
+
+      const encoded = encoding.encode("asdf");
+
+      strictEqual(encoded, "globalThis.String((asdf))");
+
+      const decoded = encoding.decode("asdf");
+
+      strictEqual(decoded, "globalThis.Number((asdf))");
+    }
+  });
+
+  it("encodes and decodes types that coerce to bigint using default string encoding", async () => {
+    const [string, ...bigints] = await getScalar("string", "uint64", "int64", "integer");
+
+    const [ctx, mod] = createFakeModule();
+
+    for (const bigint of bigints) {
+      const jsScalar = getJsScalar(ctx, mod, bigint, NoTarget);
+
+      strictEqual(jsScalar.type, "bigint");
+
+      const encoding = jsScalar.getEncoding("default", string);
+
+      if (!encoding) {
+        throw new Error("Expected default encoding");
+      }
+
+      const encoded = encoding.encode("asdf");
+
+      strictEqual(encoded, "globalThis.String((asdf))");
+
+      const decoded = encoding.decode("asdf");
+
+      strictEqual(decoded, "globalThis.BigInt((asdf))");
+    }
+  });
+
+  it("bytes base64 encoding", async () => {
+    const [string, bytes] = await getScalar("TypeSpec.string", "TypeSpec.bytes");
+
+    const [ctx, mod] = createFakeModule();
+
+    const jsScalar = getJsScalar(ctx, mod, bytes, NoTarget);
+
+    strictEqual(jsScalar.type, "Uint8Array");
+
+    const encoding = jsScalar.getEncoding("base64", string);
+
+    if (!encoding) {
+      throw new Error("Expected base64 encoding");
+    }
+
+    const encoded = encoding.encode("asdf");
+
+    strictEqual(
+      encoded,
+      "((asdf) instanceof globalThis.Buffer ? (asdf) : globalThis.Buffer.from((asdf))).toString('base64')",
+    );
+
+    const decoded = encoding.decode("asdf");
+
+    strictEqual(decoded, "globalThis.Buffer.from((asdf), 'base64')");
+  });
+
+  it("bytes base64url encoding", async () => {
+    const [string, bytes] = await getScalar("TypeSpec.string", "TypeSpec.bytes");
+
+    const [ctx, mod] = createFakeModule();
+
+    const jsScalar = getJsScalar(ctx, mod, bytes, NoTarget);
+
+    strictEqual(jsScalar.type, "Uint8Array");
+
+    const encoding = jsScalar.getEncoding("base64url", string);
+
+    if (!encoding) {
+      throw new Error("Expected base64url encoding");
+    }
+
+    const encoded = encoding.encode("asdf");
+
+    strictEqual(
+      encoded,
+      "globalThis.encodeURIComponent((((asdf)) instanceof globalThis.Buffer ? ((asdf)) : globalThis.Buffer.from(((asdf)))).toString('base64'))",
+    );
+
+    const decoded = encoding.decode("asdf");
+
+    strictEqual(
+      decoded,
+      "globalThis.Buffer.from((globalThis.decodeURIComponent((asdf))), 'base64')",
+    );
+  });
+
+  describe("duration", () => {
+    it("produces correct parse template for ISO8601 duration", async () => {
+      const [Duration, string] = await getScalar("TypeSpec.duration", "TypeSpec.string");
+
+      const [ctx, mod] = createFakeModule();
+
+      const jsScalar = getJsScalar(ctx, mod, Duration, NoTarget);
+
+      strictEqual(jsScalar.type, "Duration");
+      strictEqual(
+        jsScalar.getEncoding("ISO8601", string)?.decode("asdf"),
+        "Duration.parseISO8601((asdf))",
+      );
+      strictEqual(mod.imports[0].from, dateTimeModule);
+      deepStrictEqual(mod.imports[0].binder, ["Duration"]);
+    });
+
+    it("produces correct write template for ISO8601 duration", async () => {
+      const [Duration, string] = await getScalar("TypeSpec.duration", "TypeSpec.string");
+
+      const [ctx, mod] = createFakeModule();
+
+      const jsScalar = getJsScalar(ctx, mod, Duration, NoTarget);
+
+      strictEqual(jsScalar.type, "Duration");
+      strictEqual(
+        jsScalar.getEncoding("ISO8601", string)?.encode("asdf"),
+        "Duration.toISO8601((asdf))",
+      );
+      strictEqual(mod.imports[0].from, dateTimeModule);
+      deepStrictEqual(mod.imports[0].binder, ["Duration"]);
+    });
+
+    it("can parse and write ISO8601 duration", async () => {
+      const [Duration, string] = await getScalar("TypeSpec.duration", "TypeSpec.string");
+
+      const [ctx, mod] = createFakeModule();
+
+      const jsScalar = getJsScalar(ctx, mod, Duration, NoTarget);
+
+      strictEqual(jsScalar.type, "Duration");
+
+      const encoding = jsScalar.getEncoding("ISO8601", string);
+
+      if (!encoding) {
+        throw new Error("Expected ISO8601 encoding");
+      }
+
+      const encoded = encoding.encode("duration");
+
+      strictEqual(encoded, "Duration.toISO8601((duration))");
+
+      const decoded = encoding.decode('"P1Y2M3DT4H5M6S"');
+
+      strictEqual(decoded, 'Duration.parseISO8601(("P1Y2M3DT4H5M6S"))');
+
+      strictEqual(mod.imports[0].from, dateTimeModule);
+      deepStrictEqual(mod.imports[0].binder, ["Duration"]);
+    });
+
+    it("allows default string encoding through via", async () => {
+      const [Duration, string] = await getScalar("duration", "string");
+
+      const [ctx, mod] = createFakeModule();
+
+      const jsScalar = getJsScalar(ctx, mod, Duration, NoTarget);
+
+      strictEqual(jsScalar.type, "Duration");
+
+      const encoding = jsScalar.getEncoding("default", string);
+
+      if (!encoding) {
+        throw new Error("Expected default encoding");
+      }
+
+      const encoded = encoding.encode("duration");
+
+      strictEqual(encoded, "Duration.toISO8601(((duration)))");
+
+      const decoded = encoding.decode("duration");
+
+      strictEqual(decoded, "Duration.parseISO8601(((duration)))");
+    });
+
+    it("allows encoding seconds to number types", async () => {
+      const [Duration, int32, uint32] = await getScalar("duration", "int32", "uint32");
+
+      const [ctx, mod] = createFakeModule();
+
+      const jsScalar = getJsScalar(ctx, mod, Duration, NoTarget);
+
+      strictEqual(jsScalar.type, "Duration");
+
+      const encodingInt32 = jsScalar.getEncoding("seconds", int32);
+
+      if (!encodingInt32) {
+        throw new Error("Expected seconds encoding int32");
+      }
+
+      const encodedInt32 = encodingInt32.encode("duration");
+
+      strictEqual(encodedInt32, "Duration.totalSeconds((duration))");
+
+      const decodedInt32 = encodingInt32.decode("duration");
+
+      strictEqual(decodedInt32, "Duration.fromSeconds((duration))");
+
+      const encodingUint32 = jsScalar.getEncoding("seconds", uint32);
+
+      if (!encodingUint32) {
+        throw new Error("Expected seconds encoding uint32");
+      }
+
+      const encodedUint32 = encodingUint32.encode("duration");
+
+      strictEqual(encodedUint32, "Duration.totalSeconds((duration))");
+
+      const decodedUint32 = encodingUint32.decode("duration");
+
+      strictEqual(decodedUint32, "Duration.fromSeconds((duration))");
+    });
+
+    it("allows encoding seconds to bigint types", async () => {
+      const [Duration, int64, uint64] = await getScalar("duration", "int64", "uint64");
+
+      const [ctx, mod] = createFakeModule();
+
+      const jsScalar = getJsScalar(ctx, mod, Duration, NoTarget);
+
+      strictEqual(jsScalar.type, "Duration");
+
+      const encodingInt64 = jsScalar.getEncoding("seconds", int64);
+
+      if (!encodingInt64) {
+        throw new Error("Expected seconds encoding int64");
+      }
+
+      const encodedInt64 = encodingInt64.encode("duration");
+
+      strictEqual(encodedInt64, "Duration.totalSecondsBigInt((duration))");
+
+      const decodedInt64 = encodingInt64.decode("duration");
+
+      strictEqual(decodedInt64, "Duration.fromSeconds(globalThis.Number((duration)))");
+
+      const encodingUint64 = jsScalar.getEncoding("seconds", uint64);
+
+      if (!encodingUint64) {
+        throw new Error("Expected seconds encoding uint64");
+      }
+
+      const encodedUint64 = encodingUint64.encode("duration");
+
+      strictEqual(encodedUint64, "Duration.totalSecondsBigInt((duration))");
+
+      const decodedUint64 = encodingUint64.decode("duration");
+
+      strictEqual(decodedUint64, "Duration.fromSeconds(globalThis.Number((duration)))");
+    });
+  });
+});