@azure-tools/typespec-ts 0.30.1 → 0.31.0-alpha.20240723.1

package/src/modular/serialization/serializeDateTime.ts

@@ -1,22 +0,0 @@
-import { SdkDatetimeType } from "@azure-tools/typespec-client-generator-core";
-import { UsageFlags } from "@typespec/compiler";
-import { SerializeTypeOptions } from "./serializers.js";
-
-export function serializeDatetime(
-  options: SerializeTypeOptions<SdkDatetimeType>
-): string {
-  const { functionType, type, valueExpr } = options;
-  if (functionType === UsageFlags.Input) {
-    switch (type.encode) {
-      case "rfc7231":
-        return `(${valueExpr}).toUTCString()`;
-      case "unixTimestamp":
-        return `(${valueExpr}).getTime()`;
-      case "rfc3339":
-      default:
-        return `(${valueExpr}).toISOString()`;
-    }
-  } else {
-    return `new Date(${valueExpr})`;
-  }
-}

package/src/modular/serialization/serializeHeaders.ts

@@ -1,64 +0,0 @@
-import {
-  SdkHeaderParameter,
-  UsageFlags
-} from "@azure-tools/typespec-client-generator-core";
-import { SerializeTypeOptions, serializeType } from "./serializers.js";
-import { SerializerOutput } from "./util.js";
-import { getCollectionSeparator } from "./collectionUtils.js";
-import { serializeArray } from "./serializeArray.js";
-import { isNumericTypeKind } from "../helpers/typeHelpers.js";
-
-export function serializeHeader(
-  options: SerializeTypeOptions<
-    SdkHeaderParameter & {
-      kind: "header";
-    }
-  >
-): SerializerOutput {
-  const { type, functionType, valueExpr } = options;
-
-  // We need to handle arrays differently than other types.
-  // For headers arrays are serialized as a single string with a separator.
-  if (type.type.kind === "array") {
-    const separator = JSON.stringify(
-      getCollectionSeparator(type.collectionFormat)
-    );
-
-    if (functionType === UsageFlags.Input) {
-      // Serialization
-      // Here we need to turn an array into a string with a separator.
-      // We can use the serializeArray function to do this.
-      const serializedArray = serializeArray({
-        ...options,
-        type: type.type
-      });
-
-      // Now that we have serialized the array, we can join the elements with the separator.
-      return `${serializedArray}.join(${separator})`;
-    } else {
-      // Deserialization
-      // Here we have a string that we need to split into an array.
-      const array = `${valueExpr}.split(${separator})`;
-
-      // No need to parse if the elements ar strings
-      if (type.type.valueType.kind === "string") {
-        return array;
-      }
-
-      if (
-        isNumericTypeKind(type.type.valueType.kind) ||
-        type.type.valueType.kind === "boolean"
-      ) {
-        return `${array}.map(e => JSON.parse(e))`;
-      }
-
-      return `${array}.map(e => ${serializeType({
-        ...options,
-        type: type.type.valueType,
-        valueExpr: "e"
-      })})`;
-    }
-  }
-
-  return serializeType({ ...options, type: type.type });
-}

package/src/modular/serialization/serializers.ts

@@ -1,304 +0,0 @@
-import { ImportType } from "@azure-tools/rlc-common";
-import {
-  SdkConstantType,
-  SdkContext,
-  SdkEnumType,
-  SdkModelPropertyType,
-  SdkModelType,
-  SdkType,
-  SdkUnionType
-} from "@azure-tools/typespec-client-generator-core";
-import { getDiscriminator, UsageFlags } from "@typespec/compiler";
-import _ from "lodash";
-import * as Reify from "../../reify/index.js";
-import {
-  getEncodingFormat,
-  getParameterTypePropertyName,
-  getReturnTypePropertyName,
-  isDefined,
-  SerializerMap,
-  SerializerOutput
-} from "./util.js";
-import { serializeHeader } from "./serializeHeaders.js";
-import { serializeArray } from "./serializeArray.js";
-import { serializeDatetime } from "./serializeDateTime.js";
-
-export interface SerializeTypeOptions<
-  TCGCType extends SdkType | SdkModelPropertyType
-> {
-  dpgContext: SdkContext;
-  functionType: UsageFlags;
-  serializerMap?: SerializerMap;
-  type: TCGCType;
-  valueExpr: string;
-  importCallback: (importType: ImportType, importedName: string) => void;
-}
-
-const placeholder = <T>(_?: T) => {
-  return '(()=>{throw Error("Not implemented.")})()';
-};
-
-export function serializeType<TCGCType extends SdkType | SdkModelPropertyType>(
-  options: SerializeTypeOptions<TCGCType>
-): SerializerOutput {
-  const { functionType, serializerMap, type, valueExpr } = options;
-  const modularTypeName = (type as { name?: string }).name;
-  const serializerMetadata =
-    isDefined(modularTypeName) && serializerMap?.[modularTypeName];
-
-  if (serializerMetadata) {
-    const functionName =
-      functionType === UsageFlags.Input
-        ? serializerMetadata?.serializerFunctionName
-        : serializerMetadata?.deserializerFunctionName;
-
-    return `${
-      functionName ??
-      (functionType === UsageFlags.Input
-        ? "MISSING_SERIALIZER"
-        : "MISSING_DESERIALIZER")
-    }((${valueExpr}))`;
-  }
-
-  return getSerializeHandler(type.kind)?.(options) ?? valueExpr;
-}
-
-function getSerializeHandler<TCGCType extends SdkType | SdkModelPropertyType>(
-  kind: TCGCType["kind"]
-): ((options: SerializeTypeOptions<TCGCType>) => SerializerOutput) | undefined {
-  type SimpleType =
-    | "any"
-    | "armId"
-    | "azureLocation"
-    | "boolean"
-    | "constant"
-    | "decimal"
-    | "decimal128"
-    | "enum"
-    | "eTag"
-    | "float"
-    | "float32"
-    | "float64"
-    | "guid"
-    | "int16"
-    | "int32"
-    | "int64"
-    | "int8"
-    | "integer"
-    | "ipAddress"
-    | "ipV4Address"
-    | "ipV6Address"
-    | "numeric"
-    | "password"
-    | "safeint"
-    | "string"
-    | "uint16"
-    | "uint32"
-    | "uint64"
-    | "uint8"
-    | "uri"
-    | "url"
-    | "uuid"
-    | "nullable";
-
-  type SerializeHandler<
-    TCGCTypeKind extends (SdkType | SdkModelPropertyType)["kind"]
-  > = {
-    [K in TCGCTypeKind]: (
-      options: SerializeTypeOptions<
-        (SdkType | SdkModelPropertyType) & { kind: K }
-      >
-    ) => SerializerOutput;
-  };
-  type SerializeHandlerMap = Partial<SerializeHandler<SimpleType>> &
-    SerializeHandler<
-      Exclude<(SdkType | SdkModelPropertyType)["kind"], SimpleType>
-    >;
-
-  const handlers: SerializeHandlerMap = {
-    array: serializeArray,
-    bytes: serializeByteArray,
-    enumvalue: (options) =>
-      serializeType({ ...options, type: options.type.valueType }),
-    model: serializeModelPropertiesInline,
-    offsetDateTime: serializeDatetime,
-    plainDate: ({ valueExpr }) => `(${valueExpr}).toDateString()`,
-    plainTime: ({ valueExpr }) => `(${valueExpr}).toTimeString()`,
-    property: serializeModelProperty,
-    // TODO: This is the function that emits the body of a function meant to serialize a type union.
-    // It's implemented as a switch statement. This is fine for a function body. However,
-    // `getSerializeHandler` is designed to always return something that can go in expression
-    // position. We may or may not decide to emit a function to serialize anonymous unions using the
-    // TCGC generated name as its identifier. If we don't, a copy of this function will need to be
-    // adapted to expression position (e.g. nested ternary statements). As it stands, this function
-    // should never actually be dispatched, and should be removed if we find it to be unnecessary.
-    union: serializeUnionInline,
-    utcDateTime: serializeDatetime,
-
-    duration: placeholder,
-    tuple: placeholder,
-    dict: placeholder,
-    credential: placeholder,
-
-    endpoint: placeholder,
-    method: placeholder,
-    query: placeholder,
-    path: placeholder,
-    body: placeholder,
-    header: serializeHeader
-  };
-  const handler = handlers[kind];
-  return handler as any;
-}
-
-function serializeByteArray(
-  options: SerializeTypeOptions<SdkType & { kind: "bytes" }>
-): string {
-  const { functionType, type, valueExpr, importCallback } = options;
-
-  if (type.encode === "binary") {
-    return valueExpr;
-  }
-
-  const format = getEncodingFormat(functionType, type);
-  const args = [valueExpr, `"${format}"`].join(", ");
-
-  if (functionType === UsageFlags.Input) {
-    importCallback("coreUtil", "uint8ArrayToString");
-    return `uint8ArrayToString(${args})`;
-  }
-  importCallback("coreUtil", "stringToUint8Array");
-  return `(typeof (${valueExpr}) === 'string')
-      ? (stringToUint8Array(${args}))
-      : (${valueExpr})`;
-}
-
-export function serializeModelPropertiesInline(
-  options: SerializeTypeOptions<SdkModelType>
-): string {
-  const { dpgContext, functionType, type, valueExpr } = options;
-  const props = type.properties.filter((p) => p.kind === "property");
-  const serializedParents = type.baseModel
-    ? `...(${serializeType({ ...options, type: type.baseModel })})`
-    : undefined;
-  const serializedProps = props.map((prop) => {
-    const id = getParameterTypePropertyName(dpgContext, functionType, prop);
-    return serializeModelProperty({
-      ...options,
-      type: prop,
-      valueExpr: `${valueExpr}["${id}"]`
-    });
-  });
-  const body = [`...(${valueExpr})`, serializedParents, ...serializedProps]
-    .filter(isDefined)
-    .join(",\n");
-  return `{${body}}`;
-}
-
-export function serializeUnionInline(
-  options: SerializeTypeOptions<SdkUnionType>
-): string {
-  const { dpgContext, type, valueExpr } = options;
-  const discriminator = getDiscriminator(dpgContext.program, type.__raw!)
-    ?.propertyName;
-  if (!discriminator) {
-    return placeholder();
-  }
-  const baseType = type.values.find((v) => v.kind !== "constant")!;
-  const variants = type.values.filter(
-    (v) => v !== baseType
-  ) as SdkConstantType[];
-  // TODO: Used to catch corner cases during testing. Remove this before shipping.
-  variants
-    .filter((v) => v.kind !== "constant")
-    .forEach((v) => {
-      throw Error(
-        `TODO: Handle non-constant non-base variant of union ${type.name} ` +
-          `with type name ${v.name} and kind ${v.kind}`
-      );
-    });
-  const cases = variants
-    .map((variant) => {
-      `${variant.value}: ${serializeType({
-        ...options,
-        type: variant
-      })}`;
-    })
-    .join(",\n");
-  // TODO: Non-discriminated unions have UB at the moment, as opposed to having good messaging that
-  // they're not supported
-  return `({${cases}})[(${valueExpr})["${discriminator}"]] ?? (${serializeType({
-    ...options,
-    type: baseType
-  })})`;
-}
-
-export function serializeEnumFunctionBody(
-  options: SerializeTypeOptions<SdkEnumType>
-): string {
-  const { type, valueExpr } = options;
-  const defaultBody: Reify.Statement[] = [{ kind: "return", value: valueExpr }];
-
-  const cases = _(type.values)
-    .map((value): [string | undefined, Reify.Statement[]] => {
-      const variantId = `${type.name}.${value.name}`;
-      const variantBody: Reify.ReturnStatement[] = [
-        {
-          kind: "return",
-          value: serializeType({ ...options, type: value.valueType })
-        }
-      ];
-      return [variantId, variantBody];
-    })
-    .concat([[undefined, defaultBody]])
-    .reduce((acc, [id, body]) => {
-      const ids = acc.get(body) ?? new Set();
-      ids.add(id);
-      acc.set(body, ids);
-      return acc;
-    }, new Map<Reify.Statement[], Set<string | undefined>>());
-
-  const functionBody: Reify.SwitchReturn = {
-    kind: "switch return",
-    expr: valueExpr,
-    cases
-  };
-
-  return Reify.reifySwitchReturn(functionBody);
-}
-
-function serializeModelProperty(
-  options: SerializeTypeOptions<SdkModelPropertyType>
-): string {
-  const { type, valueExpr } = options;
-
-  const propDecl = getPropertyDeclaration(options);
-
-  return type.optional
-    ? `...((${valueExpr}) === undefined ? {} : {${propDecl}})`
-    : `${propDecl}`;
-}
-
-function getPropertyDeclaration(
-  options: SerializeTypeOptions<SdkModelPropertyType>
-): string {
-  const { dpgContext, functionType, type } = options;
-
-  const id = getReturnTypePropertyName(dpgContext, functionType, type);
-  const propInitializer = getPropertyInitializer(options);
-
-  return `"${id}": (${propInitializer})`;
-}
-
-function getPropertyInitializer(
-  options: SerializeTypeOptions<SdkModelPropertyType>
-): string {
-  const { type } = options;
-
-  const propSerializer = serializeType({
-    ...options,
-    type: { ...type.type, nullable: false, optional: false }
-  });
-
-  return propSerializer;
-}

package/src/modular/serialization/util.ts

@@ -1,171 +0,0 @@
-import {
-  getLibraryName,
-  getWireName,
-  SdkEnumType,
-  SdkModelPropertyType,
-  SdkModelType,
-  SdkType,
-  SdkUnionType,
-  UsageFlags as TCGCUsageFlags
-} from "@azure-tools/typespec-client-generator-core";
-import { UsageFlags } from "@typespec/compiler";
-import { toPascalCase } from "../../utils/casingUtils.js";
-import { SdkContext } from "../../utils/interfaces.js";
-
-type ModularTypeName = string;
-export type SerializeFunctionType = SdkModelType | SdkUnionType | SdkEnumType;
-export type SerializerMap = Record<ModularTypeName, SerializerMetadata>;
-export type SerializerOutput = string;
-
-interface SerializerMetadata {
-  rlcTypeName?: string;
-  rlcTypeAlias?: string;
-  type: SerializeFunctionType;
-  serializerFunctionName?: string;
-  deserializerFunctionName?: string;
-}
-
-const supportedFormats = ["base64url", "base64", "byte"];
-export function getEncodingFormat(
-  functionType: UsageFlags,
-  type: SdkType & { kind: "bytes" }
-) {
-  if (functionType === UsageFlags.Output) {
-    return type.encode;
-  }
-
-  return supportedFormats.find((format) => format === type.encode) ?? "base64";
-}
-
-const dispatch: {
-  [Kind in SdkType["kind"]]: (
-    type: SdkType & { kind: Kind }
-  ) => string | undefined;
-} = {
-  string: (_) => "string",
-  boolean: (_) => "boolean",
-  bytes: (_) => "Uint8Array",
-  model: (type) => type.name,
-  union: (type) => type.name,
-  enum: (type) => type.name,
-  plainDate: (_) => "Date",
-  plainTime: (_) => "Date",
-  any: (_) => "any",
-  numeric: (_) => "number",
-  integer: (_) => "number",
-  safeint: (_) => "number",
-  int8: (_) => "number",
-  int16: (_) => "number",
-  int32: (_) => "number",
-  int64: (_) => "number",
-  uint8: (_) => "number",
-  uint16: (_) => "number",
-  uint32: (_) => "number",
-  uint64: (_) => "number",
-  float: (_) => "number",
-  float32: (_) => "number",
-  float64: (_) => "number",
-  decimal: (_) => "number",
-  decimal128: (_) => "number",
-  password: (_) => "string",
-  guid: (_) => "string",
-  url: (_) => "string",
-  uri: (_) => "string",
-  ipAddress: (_) => "string",
-  uuid: (_) => "string",
-  ipV4Address: (_) => "string",
-  ipV6Address: (_) => "string",
-  eTag: (_) => "string",
-  armId: (_) => "string",
-  azureLocation: (_) => "string",
-  utcDateTime: (_) => "Date",
-  offsetDateTime: (_) => "Date",
-  duration: (_) => "FIXME",
-  array: (type) => {
-    const valueTypeId = getModularTypeId(type.valueType);
-    return valueTypeId ? `Array<${valueTypeId}>` : undefined;
-  },
-  tuple: (type) => {
-    const elementIds = type.values.map(getModularTypeId);
-    if (!type.values.length || elementIds.some((id) => !id)) {
-      return;
-    }
-    return `[${elementIds.join(", ")}]`;
-  },
-  dict: (type) => {
-    const keyId = getModularTypeId(type.keyType);
-    const valueId = getModularTypeId(type.valueType);
-    if (!keyId || !valueId) {
-      return;
-    }
-    const valueType = valueId;
-    return `Record<${keyId}, ${valueType}>`;
-  },
-  enumvalue: (_) => "FIXME",
-  constant: (_) => "FIXME",
-  credential: (_) => "FIXME",
-  endpoint: (_) => "string",
-  nullable: (_) => "null"
-};
-
-export function getModularTypeId<T extends SdkType>(
-  type: T
-): string | undefined {
-  const callback = dispatch[type.kind] as (type: T) => string | undefined;
-  return callback(type);
-}
-
-export function getParameterTypePropertyName(
-  dpgContext: SdkContext,
-  functionType: UsageFlags,
-  p: SdkModelPropertyType
-): string {
-  return functionType === UsageFlags.Output
-    ? getWireName(dpgContext, p.__raw!)
-    : getLibraryName(dpgContext, p.__raw!);
-}
-
-export function getReturnTypePropertyName(
-  dpgContext: SdkContext,
-  functionType: UsageFlags,
-  p: SdkModelPropertyType
-): string {
-  return functionType === UsageFlags.Output
-    ? getLibraryName(dpgContext, p.__raw!)
-    : getWireName(dpgContext, p.__raw!);
-}
-
-export function getRLCTypeId(
-  dpgContext: SdkContext,
-  type: SdkType & { name?: string }
-) {
-  const modularTypeId = getModularTypeId(type);
-  const usage = getUsage(dpgContext, type);
-  const useOutputModel =
-    usage & UsageFlags.Output && !(usage & UsageFlags.Input);
-  return useOutputModel ? toPascalCase(`${modularTypeId} Rest`) : modularTypeId;
-}
-
-export function getUsage(
-  // @ts-expect-error: To be removed with the below TODO
-  dpgContext: SdkContext,
-  // @ts-expect-error: Ditto
-  type: SdkType
-): TCGCUsageFlags {
-  return toDpgUsageFlags(
-    //TODO: Currently disregards usage when calculating whether or not to emit the function. This
-    //doesn't affect client API surface.
-    TCGCUsageFlags.Input | TCGCUsageFlags.Output
-  );
-}
-
-function toDpgUsageFlags(usage: TCGCUsageFlags): UsageFlags {
-  return (
-    (usage & TCGCUsageFlags.Input ? UsageFlags.Input : 0) |
-    (usage & TCGCUsageFlags.Output ? UsageFlags.Output : 0)
-  );
-}
-
-export function isDefined<T>(thing: T | undefined | null): thing is T {
-  return typeof thing !== "undefined" && thing !== null;
-}

package/src/modular/static/karma.conf.cjs

@@ -1,120 +0,0 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
-// Licensed under the MIT License.
-
-// https://github.com/karma-runner/karma-chrome-launcher
-process.env.CHROME_BIN = require("puppeteer").executablePath();
-require("dotenv").config();
-
-module.exports = function (config) {
-  config.set({
-    // base path that will be used to resolve all patterns (eg. files, exclude)
-    basePath: "./",
-
-    // frameworks to use
-    // available frameworks: https://npmjs.org/browse/keyword/karma-adapter
-    frameworks: ["mocha"],
-
-    plugins: [
-      "karma-mocha",
-      "karma-mocha-reporter",
-      "karma-chrome-launcher",
-      "karma-firefox-launcher",
-      "karma-env-preprocessor",
-      "karma-coverage",
-      "karma-sourcemap-loader",
-      "karma-junit-reporter"
-    ],
-
-    // list of files / patterns to load in the browser
-    files: [
-      "dist-test/index.browser.js",
-      {
-        pattern: "dist-test/index.browser.js.map",
-        type: "html",
-        included: false,
-        served: true
-      }
-    ],
-
-    // list of files / patterns to exclude
-    exclude: [],
-
-    // preprocess matching files before serving them to the browser
-    // available preprocessors: https://npmjs.org/browse/keyword/karma-preprocessor
-    preprocessors: {
-      "**/*.js": ["sourcemap", "env"]
-      // IMPORTANT: COMMENT following line if you want to debug in your browsers!!
-      // Preprocess source file to calculate code coverage, however this will make source file unreadable
-      //"dist-test/index.browser.js": ["coverage"]
-    },
-
-    // inject following environment values into browser testing with window.__env__
-    // environment values MUST be exported or set with same console running "karma start"
-    // https://www.npmjs.com/package/karma-env-preprocessor
-    envPreprocessor: ["TEST_MODE"],
-
-    // test results reporter to use
-    // possible values: 'dots', 'progress'
-    // available reporters: https://npmjs.org/browse/keyword/karma-reporter
-    reporters: ["mocha", "coverage", "junit"],
-
-    coverageReporter: {
-      // specify a common output directory
-      dir: "coverage-browser/",
-      reporters: [
-        { type: "json", subdir: ".", file: "coverage.json" },
-        { type: "lcovonly", subdir: ".", file: "lcov.info" },
-        { type: "html", subdir: "html" },
-        { type: "cobertura", subdir: ".", file: "cobertura-coverage.xml" }
-      ]
-    },
-
-    junitReporter: {
-      outputDir: "", // results will be saved as $outputDir/$browserName.xml
-      outputFile: "test-results.browser.xml", // if included, results will be saved as $outputDir/$browserName/$outputFile
-      suite: "", // suite will become the package name attribute in xml testsuite element
-      useBrowserName: false, // add browser name to report and classes names
-      nameFormatter: undefined, // function (browser, result) to customize the name attribute in xml testcase element
-      classNameFormatter: undefined, // function (browser, result) to customize the classname attribute in xml testcase element
-      properties: {} // key value pair of properties to add to the <properties> section of the report
-    },
-
-    // web server port
-    port: 9876,
-
-    // enable / disable colors in the output (reporters and logs)
-    colors: true,
-
-    // level of logging
-    // possible values: config.LOG_DISABLE || config.LOG_ERROR || config.LOG_WARN || config.LOG_INFO || config.LOG_DEBUG
-    logLevel: config.LOG_INFO,
-
-    // enable / disable watching file and executing tests whenever any file changes
-    autoWatch: false,
-
-    // start these browsers
-    // available browser launchers: https://npmjs.org/browse/keyword/karma-launcher
-    // 'ChromeHeadless', 'Chrome', 'Firefox', 'Edge', 'IE'
-    browsers: ["ChromeHeadless"],
-
-    // Continuous Integration mode
-    // if true, Karma captures browsers, runs the tests and exits
-    singleRun: true,
-
-    // Concurrency level
-    // how many browser should be started simultaneous
-    concurrency: 1,
-
-    browserNoActivityTimeout: 600000,
-    browserDisconnectTimeout: 10000,
-    browserDisconnectTolerance: 3,
-
-    client: {
-      mocha: {
-        // change Karma's debug.html to the mocha web reporter
-        reporter: "html",
-        timeout: "600000"
-      }
-    }
-  });
-};