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

package/src/http/server/index.ts

@@ -12,7 +12,6 @@ import {
 } from "@typespec/http";
 import { createOrGetModuleForNamespace } from "../../common/namespace.js";
 import { emitTypeReference, isValueLiteralType } from "../../common/reference.js";
-import { parseTemplateForScalar } from "../../common/scalar.js";
 import {
   SerializableType,
   isSerializationRequired,
@@ -33,6 +32,7 @@ import { emitMultipart, emitMultipartLegacy } from "./multipart.js";
 
 import { module as headerHelpers } from "../../../generated-defs/helpers/header.js";
 import { module as httpHelpers } from "../../../generated-defs/helpers/http.js";
+import { getJsScalar } from "../../common/scalar.js";
 import { requiresJsonSerialization } from "../../common/serialization/json.js";
 
 const DEFAULT_CONTENT_TYPE = "application/json";
@@ -127,7 +127,7 @@ function* emitRawServerOperation(
 
   const queryParams: Extract<HttpOperationParameter, { type: "query" }>[] = [];
 
-  const parsedParams = new Set<ModelProperty>();
+  const parsedParams = new Map<ModelProperty, HttpOperationParameter>();
 
   for (const parameter of operation.parameters.parameters) {
     const resolvedParameter =
@@ -140,11 +140,11 @@ function* emitRawServerOperation(
         throw new UnimplementedError("cookie parameters");
       case "query":
         queryParams.push(parameter);
-        parsedParams.add(resolvedParameter);
+        parsedParams.set(resolvedParameter, parameter);
         break;
       case "path":
         // Already handled above.
-        parsedParams.add(resolvedParameter);
+        parsedParams.set(resolvedParameter, parameter);
         break;
       default:
         throw new Error(
@@ -228,7 +228,7 @@ function* emitRawServerOperation(
 
         let value: string;
 
-        if (requiresJsonSerialization(ctx, body.type)) {
+        if (requiresJsonSerialization(ctx, module, body.type)) {
           value = `${bodyTypeName}.fromJsonObject(JSON.parse(body))`;
         } else {
           value = `JSON.parse(body)`;
@@ -283,13 +283,17 @@ function* emitRawServerOperation(
     } else {
       const resolvedParameter = param.type.kind === "ModelProperty" ? param.type : param;
 
-      paramBaseExpression =
-        resolvedParameter.type.kind === "Scalar" && parsedParams.has(resolvedParameter)
-          ? parseTemplateForScalar(ctx, resolvedParameter.type).replace(
-              "{}",
-              paramNameCase.camelCase,
-            )
-          : paramNameCase.camelCase;
+      const httpOperationParam = parsedParams.get(resolvedParameter);
+
+      if (resolvedParameter.type.kind === "Scalar" && httpOperationParam) {
+        const jsScalar = getJsScalar(ctx, module, resolvedParameter.type, resolvedParameter);
+
+        const encoder = jsScalar.http[httpOperationParam.type];
+
+        paramBaseExpression = encoder.decode(paramNameCase.camelCase);
+      } else {
+        paramBaseExpression = paramNameCase.camelCase;
+      }
     }
 
     if (param.optional) {
@@ -360,7 +364,7 @@ function* emitResultProcessing(
     // Single target type
     yield* emitResultProcessingForType(ctx, names, t, module);
   } else {
-    const codeTree = differentiateUnion(ctx, t);
+    const codeTree = differentiateUnion(ctx, module, t);
 
     yield* writeCodeTree(ctx, codeTree, {
       subject: names.result,
@@ -452,7 +456,12 @@ function* emitResultProcessingForType(
 
   if (body) {
     const bodyCase = parseCase(body.name);
-    const serializationRequired = isSerializationRequired(ctx, body.type, "application/json");
+    const serializationRequired = isSerializationRequired(
+      ctx,
+      module,
+      body.type,
+      "application/json",
+    );
     requireSerialization(ctx, body.type, "application/json");
 
     yield `${names.ctx}.response.setHeader("content-type", "application/json");`;
@@ -469,7 +478,12 @@ function* emitResultProcessingForType(
     if (allMetadataIsRemoved) {
       yield `${names.ctx}.response.end();`;
     } else {
-      const serializationRequired = isSerializationRequired(ctx, target, "application/json");
+      const serializationRequired = isSerializationRequired(
+        ctx,
+        module,
+        target,
+        "application/json",
+      );
       requireSerialization(ctx, target, "application/json");
 
       yield `${names.ctx}.response.setHeader("content-type", "application/json");`;

package/src/http/server/multipart.ts

@@ -167,7 +167,7 @@ export function* emitMultipart(
       yield `        const __object = JSON.parse(Buffer.concat(__chunks).toString("utf-8"));`;
       yield "";
 
-      if (requiresJsonSerialization(ctx, namedPart.body.type)) {
+      if (requiresJsonSerialization(ctx, module, namedPart.body.type)) {
         const bodyTypeReference = emitTypeReference(
           ctx,
           namedPart.body.type,

package/src/lib.ts

@@ -125,6 +125,12 @@ export const $lib = createTypeSpecLibrary({
           "An OpenAPI3 document could not be generated for this service because versioned services are not yet supported by the HTTP server emitter for JavaScript.",
       },
     },
+    "unknown-encoding": {
+      severity: "error",
+      messages: {
+        default: paramMessage`Unknown encoding '${"encoding"}' to type '${"target"}' for type '${"type"}'.`,
+      },
+    },
   },
 });
 

package/src/util/case.ts

@@ -28,6 +28,25 @@ export function isUnspeakable(name: string): boolean {
   return true;
 }
 
+const JS_IDENTIFIER = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+
+/**
+ * Returns an access expression for a given subject and key.
+ *
+ * If the access can be performed using dot notation, it will. Otherwise, bracket notation will be used.
+ *
+ * @param subject - the expression to access
+ * @param key - the key to access within the subject, must be an index value literal, not an expression
+ */
+export function access(subject: string, key: string | number): string {
+  subject = JS_IDENTIFIER.test(subject) ? subject : `(${subject})`;
+  if (typeof key === "string" && JS_IDENTIFIER.test(key)) {
+    return `${subject}.${key}`;
+  } else {
+    return `${subject}[${JSON.stringify(key)}]`;
+  }
+}
+
 /**
  * Destructures a name into its components.
  *

package/src/util/differentiate.ts

@@ -21,7 +21,7 @@ import {
   isUnknownType,
 } from "@typespec/compiler";
 import { getJsScalar } from "../common/scalar.js";
-import { JsContext } from "../ctx.js";
+import { JsContext, Module } from "../ctx.js";
 import { reportDiagnostic } from "../lib.js";
 import { isUnspeakable, parseCase } from "./case.js";
 import { UnimplementedError, UnreachableError } from "./error.js";
@@ -287,6 +287,7 @@ const PROPERTY_ID = (prop: ModelProperty) => parseCase(prop.name).camelCase;
  */
 export function differentiateUnion(
   ctx: JsContext,
+  module: Module,
   union: Union,
   renderPropertyName: (prop: ModelProperty) => string = PROPERTY_ID,
 ): CodeTree {
@@ -313,7 +314,7 @@ export function differentiateUnion(
       }
     }
 
-    return differentiateTypes(ctx, cases, renderPropertyName);
+    return differentiateTypes(ctx, module, cases, renderPropertyName);
   } else {
     const property = (variants[0].type as Model).properties.get(discriminator)!;
 
@@ -353,6 +354,7 @@ export function differentiateUnion(
  */
 export function differentiateTypes(
   ctx: JsContext,
+  module: Module,
   cases: Set<PreciseType>,
   renderPropertyName: (prop: ModelProperty) => string = PROPERTY_ID,
 ): CodeTree {
@@ -378,7 +380,7 @@ export function differentiateTypes(
   const intrinsics = (categories.Intrinsic as (VoidType | NullType)[]) ?? [];
 
   if (literals.length + scalars.length + intrinsics.length === 0) {
-    return differentiateModelTypes(ctx, select(models, cases), renderPropertyName);
+    return differentiateModelTypes(ctx, module, select(models, cases), renderPropertyName);
   } else {
     const branches: IfBranch[] = [];
 
@@ -419,7 +421,7 @@ export function differentiateTypes(
     const scalarRepresentations = new Map<string, Scalar>();
 
     for (const scalar of scalars) {
-      const jsScalar = getJsScalar(ctx.program, scalar, scalar);
+      const jsScalar = getJsScalar(ctx, module, scalar, scalar).type;
 
       if (scalarRepresentations.has(jsScalar)) {
         reportDiagnostic(ctx.program, {
@@ -503,7 +505,7 @@ export function differentiateTypes(
       branches,
       else:
         models.length > 0
-          ? differentiateModelTypes(ctx, select(models, cases), renderPropertyName)
+          ? differentiateModelTypes(ctx, module, select(models, cases), renderPropertyName)
           : undefined,
     };
   }
@@ -563,10 +565,14 @@ function getJsValue(ctx: JsContext, literal: JsLiteralType | EnumMember): Litera
  */
 type IntegerRange = [number, number];
 
-function getIntegerRange(ctx: JsContext, property: ModelProperty): IntegerRange | false {
+function getIntegerRange(
+  ctx: JsContext,
+  module: Module,
+  property: ModelProperty,
+): IntegerRange | false {
   if (
     property.type.kind === "Scalar" &&
-    getJsScalar(ctx.program, property.type, property) === "number"
+    getJsScalar(ctx, module, property.type, property).type === "number"
   ) {
     const minValue = getMinValue(ctx.program, property);
     const maxValue = getMaxValue(ctx.program, property);
@@ -594,6 +600,7 @@ function overlaps(range: IntegerRange, other: IntegerRange): boolean {
  */
 export function differentiateModelTypes(
   ctx: JsContext,
+  module: Module,
   models: Set<Model>,
   renderPropertyName: (prop: ModelProperty) => string = PROPERTY_ID,
 ): CodeTree {
@@ -656,7 +663,7 @@ export function differentiateModelTypes(
 
       // CASE - unique range
 
-      const range = getIntegerRange(ctx, prop);
+      const range = getIntegerRange(ctx, module, prop);
       if (range) {
         let ranges = propertyRanges.get(renderedPropName);
         if (!ranges) {