@typespec/http-server-js 0.58.0-alpha.13-dev.4 → 0.58.0-alpha.13-dev.7

package/src/scripts/scaffold/data-mocks.ts

@@ -9,7 +9,11 @@ import {
   Union,
 } from "@typespec/compiler";
 import { $ } from "@typespec/compiler/experimental/typekit";
-import { parseCase } from "../../util/case.js";
+import { JsContext, Module } from "../../ctx.js";
+import { isUnspeakable, parseCase } from "../../util/case.js";
+
+import { module as dateTimeHelper } from "../../../generated-defs/helpers/datetime.js";
+import { KEYWORDS } from "../../util/keywords.js";
 
 /**
  * Generates a mock value for a TypeSpec Model.
@@ -19,13 +23,13 @@ import { parseCase } from "../../util/case.js";
  * @returns A JavaScript string representation of the mock data
  * @throws Error if a property cannot be mocked
  */
-function mockModel(type: Model): string {
+function mockModel(ctx: JsContext, module: Module, type: Model): string {
   if ($.array.is(type)) {
-    return mockArray(type);
+    return mockArray(ctx, module, type);
   }
 
   if ($.record.is(type)) {
-    return mockRecord(type);
+    return mockRecord(ctx, module, type);
   }
 
   const mock: string[][] = [];
@@ -37,18 +41,18 @@ function mockModel(type: Model): string {
   }
 
   for (const [name, prop] of properties) {
-    if (prop.optional) {
+    if (prop.optional || isUnspeakable(prop.name)) {
       continue;
     }
 
-    const propMock = mockType(prop.type);
+    const propMock = mockType(ctx, module, prop.type);
 
     if (!propMock) {
       throw new Error(`Could not mock property ${name} of type ${prop.type.kind}`);
     }
 
     const propName = parseCase(name).camelCase;
-    mock.push([propName, propMock]);
+    mock.push([KEYWORDS.has(propName) ? `_${propName}` : propName, propMock]);
   }
 
   // If all properties were optional, return an empty object
@@ -67,9 +71,9 @@ function mockModel(type: Model): string {
  * @param type - The TypeSpec array Model to mock
  * @returns A JavaScript string representation of the mock array
  */
-function mockArray(type: Model): string {
+function mockArray(ctx: JsContext, module: Module, type: Model): string {
   const elementType = $.array.getElementType(type);
-  const mockedType = mockType(elementType);
+  const mockedType = mockType(ctx, module, elementType);
 
   // If we can't mock the element type, return an empty array
   if (mockedType === undefined) {
@@ -85,9 +89,9 @@ function mockArray(type: Model): string {
  * @param type - The TypeSpec record Model to mock
  * @returns A JavaScript string representation of the mock record
  */
-function mockRecord(type: Model): string {
+function mockRecord(ctx: JsContext, module: Module, type: Model): string {
   const elementType = $.record.getElementType(type);
-  const mockedType = mockType(elementType);
+  const mockedType = mockType(ctx, module, elementType);
 
   if (mockedType === undefined) {
     return "{}";
@@ -104,8 +108,12 @@ function mockRecord(type: Model): string {
  * @param prop - The TypeSpec model property to mock
  * @returns A JavaScript string representation of the mocked property or undefined if it cannot be mocked
  */
-function mockModelProperty(prop: ModelProperty): string | undefined {
-  return mockType(prop.type);
+function mockModelProperty(
+  ctx: JsContext,
+  module: Module,
+  prop: ModelProperty,
+): string | undefined {
+  return mockType(ctx, module, prop.type);
 }
 
 /**
@@ -125,9 +133,9 @@ function mockLiteral(type: LiteralType): string {
  * @param type - The TypeSpec type to mock
  * @returns A JavaScript string representation of the mock data, or undefined if the type cannot be mocked
  */
-export function mockType(type: Type): string | undefined {
+export function mockType(ctx: JsContext, module: Module, type: Type): string | undefined {
   if ($.model.is(type)) {
-    return mockModel(type);
+    return mockModel(ctx, module, type);
   }
 
   if ($.literal.is(type)) {
@@ -135,15 +143,15 @@ export function mockType(type: Type): string | undefined {
   }
 
   if ($.modelProperty.is(type)) {
-    return mockModelProperty(type);
+    return mockModelProperty(ctx, module, type);
   }
 
   if ($.scalar.is(type)) {
-    return mockScalar(type);
+    return mockScalar(ctx, module, type);
   }
 
   if ($.union.is(type)) {
-    return mockUnion(type);
+    return mockUnion(ctx, module, type);
   }
 
   if (isVoidType(type)) {
@@ -159,12 +167,12 @@ export function mockType(type: Type): string | undefined {
  * @param union - The TypeSpec union to mock
  * @returns A JavaScript string representation of a mock for one variant, or undefined if no suitable variant is found
  */
-function mockUnion(union: Union): string | undefined {
+function mockUnion(ctx: JsContext, module: Module, union: Union): string | undefined {
   for (const variant of union.variants.values()) {
     if (isErrorType(variant.type)) {
       continue;
     }
-    return mockType(variant.type);
+    return mockType(ctx, module, variant.type);
   }
 
   return undefined;
@@ -177,12 +185,19 @@ function mockUnion(union: Union): string | undefined {
  * @param scalar - The TypeSpec scalar to mock
  * @returns A JavaScript string representation of a suitable mock value for the scalar type
  */
-function mockScalar(scalar: Scalar): string | undefined {
+function mockScalar(ctx: JsContext, module: Module, scalar: Scalar): string | undefined {
   if ($.scalar.isBoolean(scalar) || $.scalar.extendsBoolean(scalar)) {
     return JSON.stringify(true);
   }
   if ($.scalar.isNumeric(scalar) || $.scalar.extendsNumeric(scalar)) {
-    return JSON.stringify(42);
+    switch ((scalar as Scalar).name) {
+      case "integer":
+      case "int64":
+      case "uint64":
+        return "42n";
+      default:
+        return "42";
+    }
   }
 
   if ($.scalar.isUtcDateTime(scalar) || $.scalar.extendsUtcDateTime(scalar)) {
@@ -194,7 +209,12 @@ function mockScalar(scalar: Scalar): string | undefined {
   }
 
   if ($.scalar.isDuration(scalar) || $.scalar.extendsDuration(scalar)) {
-    return JSON.stringify("P1Y2M3DT4H5M6S");
+    module.imports.push({
+      from: dateTimeHelper,
+      binder: ["Duration"],
+    });
+
+    return 'Duration.parseISO8601("P1Y2M3DT4H5M6S")';
   }
 
   if ($.scalar.isOffsetDateTime(scalar) || $.scalar.extendsOffsetDateTime(scalar)) {