typespec-typescript-emitter 1.2.0 → 2.0.1

package/src/emit_mapped_types.ts

@@ -1,155 +0,0 @@
-import {
-  EmitContext,
-  isTemplateDeclaration,
-  Namespace,
-  Operation,
-  Type,
-} from "@typespec/compiler";
-import {
-  getHttpOperation,
-  resolveRequestVisibility,
-  Visibility,
-} from "@typespec/http";
-import { resolveType } from "./emit_types_resolve.js";
-
-export const emitRoutedTypemap = (
-  context: EmitContext,
-  namespace: Namespace,
-): string => {
-  const ops: {
-    [path: string]: {
-      [verb: string]: {
-        // "string" in these does not refer to the type "string"! It's the typescript code as string.
-        request: string;
-        response: Array<{ status: number | "unknown"; body: string }>;
-      };
-    };
-  } = {};
-
-  const traverseNamespace = (n: Namespace): void => {
-    // operations
-    const processOp = (op: Operation) => {
-      const httpOp = getHttpOperation(context.program, op);
-      const path = httpOp[0].path;
-      const verb = httpOp[0].verb.toUpperCase();
-      if (!ops[path]) ops[path] = {};
-      ops[path][verb] = {
-        request: "null",
-        response: [{ status: 200, body: "{}" }],
-      };
-
-      // request
-      let request = "null";
-      if (httpOp[0].parameters.body) {
-        request = resolveType(httpOp[0].parameters.body.type, {
-          nestlevel: 2,
-          currentNamespace: namespace,
-          context,
-          visibility: resolveRequestVisibility(
-            context.program,
-            op,
-            httpOp[0].verb,
-          ),
-          resolveEvenWithName: true,
-        }).replaceAll("\n", "\n  ");
-      }
-      ops[path][verb].request = request;
-
-      // response
-      if (op.returnType && op.returnType.kind) {
-        const getReturnType = (
-          t: Type,
-        ): (typeof ops)[string][string]["response"] => {
-          const ret: (typeof ops)[string][string]["response"] = [];
-          if (t.kind === "Model") {
-            // if the return type is a model, it may have a fully qualified body
-            const modelret: (typeof ret)[number] = {
-              status: 200,
-              body: "{}",
-            };
-            let wasQualifiedBody = false;
-            t.properties.forEach((prop) => {
-              prop.decorators.forEach((dec) => {
-                // one of the properties may be the status code
-                if (
-                  dec.definition?.name === "@statusCode" &&
-                  prop.type.kind === "Number"
-                )
-                  modelret.status = prop.type.value;
-                // one of the properties may be the body definition
-                if (dec.definition?.name === "@body") {
-                  modelret.body = resolveType(prop.type, {
-                    nestlevel: 2,
-                    currentNamespace: namespace,
-                    context,
-                    visibility: Visibility.Read,
-                    resolveEvenWithName: true,
-                  }).replaceAll("\n", "\n  ");
-                  wasQualifiedBody = true;
-                }
-              });
-            });
-            // ... if not, we assume status 200 and treat the model as the body
-            if (!wasQualifiedBody) {
-              modelret.body = resolveType(t, {
-                nestlevel: 2,
-                currentNamespace: namespace,
-                context,
-                visibility: Visibility.Read,
-                resolveEvenWithName: true,
-              }).replaceAll("\n", "\n  ");
-            }
-            ret.push(modelret);
-          } else if (t.kind === "Union") {
-            // if the return type is a union, we have to check and resolve all variants
-            // the union could either be a body-only definition or fully qualified (see above)
-            t.variants.forEach((variant) => {
-              ret.push(...getReturnType(variant.type));
-            });
-          } else
-            ret.push({
-              status: 200,
-              body: resolveType(t, {
-                nestlevel: 1,
-                currentNamespace: namespace,
-                context,
-                visibility: Visibility.Read,
-                resolveEvenWithName: true,
-              }),
-            });
-          return ret;
-        };
-        ops[path][verb].response = getReturnType(op.returnType);
-      }
-    }; // end operations
-
-    n.operations.forEach(processOp);
-    n.interfaces.forEach((itf) => {
-      if (!isTemplateDeclaration(itf)) itf.operations.forEach(processOp);
-    });
-
-    // get and traverse all namespaces
-    n.namespaces.forEach((ns) => traverseNamespace(ns));
-  };
-
-  traverseNamespace(namespace);
-  let out = `export type types_${context.options["root-namespace"]} = {\n`;
-  out += Object.entries(ops)
-    .map((path) => {
-      let pathret = `  ['${path[0]}']: {\n`;
-      pathret += Object.entries(path[1])
-        .map((verb) => {
-          let verbret = `    ['${verb[0]}']: {\n`;
-          verbret += `      request: ${verb[1].request}\n`;
-          verbret += `      response: ${verb[1].response.map((res) => `{status: ${res.status}, body: ${res.body}}`).join(" | ")}\n`;
-          verbret += "    }";
-          return verbret;
-        })
-        .join(",\n");
-      pathret += "\n  }";
-      return pathret;
-    })
-    .join(",\n");
-  out += "\n};\n";
-  return out;
-};

package/src/emit_types_resolve.ts

@@ -1,280 +0,0 @@
-import {
-  ArrayModelType,
-  EmitContext,
-  Enum,
-  getDoc,
-  Model,
-  Namespace,
-  RecordModelType,
-  Scalar,
-  Tuple,
-  Type,
-  Union,
-} from "@typespec/compiler";
-import { isVisible, Visibility } from "@typespec/http";
-
-type CommonOptions = {
-  nestlevel: number;
-  currentNamespace: Namespace;
-  context: EmitContext;
-  visibility?: Visibility;
-  resolveEvenWithName?: boolean;
-  isNamespaceRoot?: boolean;
-};
-
-export const resolveType = (t: Type, opts: CommonOptions): string => {
-  let typeStr = "unknown";
-  switch (t.kind) {
-    case "Model":
-      if (t.name === "Array") {
-        typeStr = resolveArray(t as ArrayModelType, opts);
-      } else if (t.name === "Record") {
-        typeStr = resolveRecord(t as RecordModelType, opts);
-      } else typeStr = resolveModel(t, opts);
-      break;
-    case "Boolean":
-      typeStr = "boolean";
-      break;
-    case "Enum":
-      typeStr = resolveEnum(t, opts);
-      break;
-    case "Intrinsic":
-      typeStr = t.name;
-      break;
-    case "Number":
-      typeStr = t.valueAsString;
-      break;
-    case "Scalar":
-      typeStr = resolveScalar(
-        t,
-        !!opts.context.options["serializable-date-types"],
-      );
-      break;
-    case "String":
-      typeStr = `'${t.value}'`;
-      break;
-    case "Tuple":
-      typeStr = resolveTuple(t, opts);
-      break;
-    case "Union":
-      typeStr = resolveUnion(t, opts);
-      break;
-    case "EnumMember":
-      if (opts.resolveEvenWithName) {
-        // If we're at routed typemap we will emit enum either value or index / name (as string if configured)
-        const value = resolveEnumMemberValue(t.enum, t.name);
-        if (value) {
-          typeStr = typeof value === "string" ? `'${value}'` : value.toString();
-        } else if (opts.context.options["string-nominal-enums"]) {
-          typeStr = `'${t.name}'`;
-        } else {
-          const index = resolveEnumMemberIndex(t.enum, t.name);
-          if (index !== undefined) {
-            typeStr = index.toString();
-          }
-        }
-        break;
-      }
-      typeStr = `${t.enum.name}.${t.name}`;
-      break;
-    default:
-      console.warn("Could not resolve type:", t.kind);
-  }
-  return typeStr;
-};
-
-export const resolveArray = (
-  a: ArrayModelType,
-  opts: CommonOptions,
-): string => {
-  if (a.name !== "Array")
-    throw new Error(`Trying to parse model ${a.name} as Array`);
-  return `(${resolveType(a.indexer.value, { ...opts, isNamespaceRoot: false })})[]`;
-};
-
-export const resolveRecord = (
-  a: RecordModelType,
-  opts: CommonOptions,
-): string => {
-  if (a.name !== "Record")
-    throw new Error(`Trying to parse model ${a.name} as Record`);
-  return `{[k: string]: ${resolveType(a.indexer.value, opts)}}`;
-};
-
-export const resolveEnum = (e: Enum, opts: CommonOptions): string => {
-  if (
-    e.name &&
-    !opts.isNamespaceRoot &&
-    opts.currentNamespace.enums.has(e.name) &&
-    !opts.resolveEvenWithName
-  ) {
-    return e.name;
-  }
-
-  if (opts.resolveEvenWithName) {
-    return resolveEnumAsUnion(e, opts);
-  }
-
-  let ret = "{\n";
-  let i = 1;
-  e.members.forEach((p) => {
-    const val =
-      p.value === undefined
-        ? ""
-        : " = " +
-          (typeof p.value === "string" ? `'${p.value}'` : p.value.toString());
-    ret = ret.addLine(
-      `${p.name.includes("-") ? `'${p.name}'` : p.name}${val}${i < e.members.size ? "," : ""}`,
-      opts.nestlevel + 1,
-    );
-    i++;
-  });
-  ret = ret.addLine("}", opts.nestlevel, true);
-  return ret;
-};
-
-export const resolveTuple = (t: Tuple, opts: CommonOptions): string => {
-  return `[${t.values.map((v) => resolveType(v, opts)).join(", ")}]`;
-};
-
-export const resolveUnion = (u: Union, opts: CommonOptions): string => {
-  if (
-    u.name &&
-    !opts.isNamespaceRoot &&
-    u.namespace?.unions.has(u.name) &&
-    !opts.resolveEvenWithName
-  )
-    return u.name;
-  return Array.from(u.variants)
-    .map((v) => {
-      const variantType = v[1].type;
-      // If variant is a named model in the current namespace
-      // and it's not in routed typemap, reference it by name:
-      if (
-        !opts.resolveEvenWithName &&
-        variantType.kind === "Model" &&
-        variantType.name &&
-        opts.currentNamespace.models.has(variantType.name)
-      ) {
-        return variantType.name;
-      }
-      // Otherwise resolve type inline
-      return resolveType(variantType, { ...opts, isNamespaceRoot: false });
-    })
-    .join(" | ");
-};
-export const resolveScalar = (
-  s: Scalar,
-  serializableDates: boolean,
-): string => {
-  let ret = "unknown";
-  switch (s.name) {
-    case "boolean":
-      ret = "boolean";
-      break;
-    case "bytes":
-      ret = "Uint8Array";
-      break;
-    case "duration":
-    case "numeric":
-      ret = "number";
-      break;
-    case "plainTime":
-    case "string":
-    case "url":
-      ret = "string";
-      break;
-    case "offsetDateTime":
-    case "plainDate":
-    case "utcDateTime":
-      ret = serializableDates ? "string" : "Date";
-      break;
-    case "unixTimestamp32":
-      ret = serializableDates ? "number" : "Date";
-      break;
-    default:
-      console.warn("Could not resolve scalar:", s.name);
-  }
-
-  if (serializableDates && s.name === "unixTimestamp32") {
-    // If we want to use serializable date types baseScalar should be skipped
-    // for unixTimestamp32 (since it is utcDateTime and would emit a string)
-    return ret;
-  }
-
-  return s.baseScalar ? resolveScalar(s.baseScalar, serializableDates) : ret;
-};
-
-export const resolveModel = (m: Model, opts: CommonOptions): string => {
-  if (
-    m.name &&
-    !opts.isNamespaceRoot &&
-    opts.currentNamespace.models.has(m.name) &&
-    !opts.resolveEvenWithName
-  )
-    return m.name;
-  let ret = "{\n";
-  let i = 1;
-  m.properties.forEach((p) => {
-    if (
-      opts.visibility === undefined ||
-      isVisible(opts.context.program, p, opts.visibility)
-    ) {
-      if (opts.context) {
-        const doc = getDoc(opts.context.program, p);
-        if (doc) ret = ret.addLine(`/** ${doc} */`, opts.nestlevel! + 1);
-      }
-      const typeStr = resolveType(p.type, {
-        ...opts,
-        nestlevel: opts.nestlevel + 1,
-        isNamespaceRoot: false,
-      });
-      if (typeStr.includes("unknown"))
-        console.warn(`Could not resolve property ${p.name} on ${m.name}`);
-      ret = ret.addLine(
-        `${p.name}${p.optional ? "?" : ""}: ${typeStr}${i < m.properties.size ? "," : ""}`,
-        opts.nestlevel + 1,
-      );
-    }
-    i++;
-  });
-  ret = ret.addLine("}", opts.nestlevel, true);
-  return ret;
-};
-
-export const resolveEnumMemberValue = (
-  e: Enum,
-  name: string,
-): string | number | undefined => {
-  const member = e.members.get(name);
-  if (!member) {
-    console.warn("Missing enum member under name:", name);
-    return;
-  }
-  return member?.value;
-};
-
-export const resolveEnumAsUnion = (e: Enum, opts: CommonOptions): string => {
-  return Array.from(e.members.values())
-    .map((member, index) => {
-      const fallback = opts.context.options["string-nominal-enums"]
-        ? member.name
-        : index;
-      const value = resolveEnumMemberValue(e, member.name) ?? fallback;
-      return typeof value === "string" ? `'${value}'` : value.toString();
-    })
-    .join(" | ");
-};
-
-export const resolveEnumMemberIndex = (
-  e: Enum,
-  name: string,
-): number | undefined => {
-  const index = Array.from(e.members.values()).findIndex((member) => {
-    return member.name === name;
-  });
-  if (index === -1) {
-    return;
-  }
-  return index;
-};

package/src/emit_types_typeguards.ts

@@ -1,178 +0,0 @@
-import { Model, Namespace, Type } from "@typespec/compiler";
-import { resolveScalar } from "./emit_types_resolve.js";
-
-export const getTypeguardModel = (
-  m: Model,
-  accessor: string,
-  nestingLevel = 1,
-  currentNamespace: Namespace,
-  serializableDates: boolean,
-  knownGuards?: Array<{ filename: string; name: string }>,
-): [string, string[]] => {
-  const imports: string[] = [];
-  return [
-    Array.from(m.properties)
-      .map((property) => {
-        const guard = getTypeguard(
-          property[1].type,
-          `${accessor}['${property[1].name}']`,
-          nestingLevel + 1,
-          currentNamespace,
-          serializableDates,
-          knownGuards,
-        );
-        imports.push(...guard[1]);
-        let ret = "  ".repeat(nestingLevel);
-        ret += property[1].optional
-          ? `${accessor}['${property[1].name}'] === undefined || `
-          : `${accessor}['${property[1].name}'] !== undefined && `;
-        ret += `(${guard[0]})`;
-        return ret;
-      })
-      .filter((x) => !!x)
-      .join(" &&\n"),
-    imports,
-  ];
-};
-
-/**
- * Creates the function body for a typeguard
- * @param t Type to create guards for
- * @param accessor String by which the type-to-test can be accessed by the code
- * @param nestingLevel
- * @param knownGuards Array of names of known typeguards; if type is found in those, no new typeguard will be created and instead a reference to the existing one is produced
- * @returns Tuple: [function body of the typeguard, array of import filenames (not unique!)]
- */
-export const getTypeguard = (
-  t: Type,
-  accessor: string,
-  nestingLevel = 1,
-  currentNamespace: Namespace,
-  serializableDates: boolean,
-  knownGuards?: Array<{ filename: string; name: string }>,
-): [string, string[]] => {
-  switch (t.kind) {
-    case "Model":
-      if (t.name === "Array") {
-        const guard = getTypeguard(
-          t.indexer!.value,
-          "v",
-          nestingLevel,
-          currentNamespace,
-          serializableDates,
-          knownGuards,
-        );
-        if (guard[0].endsWith("\n"))
-          guard[0] = guard[0].substring(0, guard[0].length - 1);
-        return [
-          `Array.isArray(${accessor}) && ${accessor}.every((v) => ${guard[0]})`,
-          guard[1],
-        ];
-      } else if (t.name === "Record") {
-        const guard = getTypeguard(
-          t.indexer!.value,
-          "v",
-          nestingLevel,
-          currentNamespace,
-          serializableDates,
-          knownGuards,
-        );
-        if (guard[0].endsWith("\n"))
-          guard[0] = guard[0].substring(0, guard[0].length - 1);
-        return [
-          `typeof ${accessor} === 'object' && (Object.entries(${accessor}).length > 0 ? Object.values(${accessor} as Record<string, any>).every((v) => ${guard[0]}) : true)`,
-          guard[1],
-        ];
-      } else if (knownGuards && knownGuards.some((x) => x.name === t.name)) {
-        return [
-          `is${t.name}(${accessor})`,
-          [
-            `import {is${t.name}} from './${knownGuards.find((x) => x.name === t.name)!.filename}';`,
-          ],
-        ];
-      } else if (
-        t.name &&
-        !knownGuards &&
-        currentNamespace.name === t.namespace!.name
-      ) {
-        return [`is${t.name}(${accessor})`, []];
-      } else {
-        const guard = getTypeguardModel(
-          t,
-          accessor,
-          nestingLevel,
-          currentNamespace,
-          serializableDates,
-          knownGuards,
-        );
-        return [
-          `(\n${guard[0]}\n${"  ".repeat(Math.max(nestingLevel - 1, 0))})`,
-          guard[1],
-        ];
-      }
-    case "Boolean":
-      return [`typeof ${accessor} === 'boolean'`, []];
-    case "Intrinsic":
-      return [`${accessor} === ${t.name}`, []];
-    case "Number":
-      return [`typeof ${accessor} === 'number'`, []];
-    case "Scalar":
-      if (
-        // TODO: figure out how to support all the varieties of dates
-        // TODO: support byte arrays
-        resolveScalar(t, serializableDates) !== "Date" &&
-        resolveScalar(t, serializableDates) !== "Uint8Array"
-      )
-        return [
-          `typeof ${accessor} === '${resolveScalar(t, serializableDates)}'`,
-          [],
-        ];
-      break;
-    case "String":
-      return [`typeof ${accessor} === 'string'`, []];
-    case "Tuple": {
-      // TODO: ['string1', 'string2'] gets resolved as [string, string] instead of literals. Why?
-      const imports: string[] = [];
-      return [
-        t.values
-          .map((v, i) => {
-            const guard = getTypeguard(
-              v,
-              `${accessor}[${i}]`,
-              nestingLevel,
-              currentNamespace,
-              serializableDates,
-              knownGuards,
-            );
-            imports.push(...guard[1]);
-            return `(${guard[0]})`;
-          })
-          .join(" && "),
-        imports,
-      ];
-    }
-    case "Union": {
-      const imports: string[] = [];
-      return [
-        Array.from(t.variants)
-          .map((v) => {
-            const guard = getTypeguard(
-              v[1].type,
-              `${accessor}`,
-              nestingLevel,
-              currentNamespace,
-              serializableDates,
-              knownGuards,
-            );
-            imports.push(...guard[1]);
-            return `(${guard[0]})`;
-          })
-          .join(" || "),
-        imports,
-      ];
-    }
-    default:
-      console.warn("Could not resolve type:", t.kind);
-  }
-  return ["true", []]; // fallback to not break everything in case of errors
-};

package/test/main.test.ts

@@ -1,83 +0,0 @@
-import { readFileSync, writeFileSync } from "fs";
-import { join } from "path";
-import { expect, it } from "vitest";
-import { runner } from "./runner.js";
-
-const tests = ["simple-routes", "enum", "pr8", "union", "visibility"];
-
-const getTestData = (
-  testName: (typeof tests)[number],
-): {
-  input: string;
-  output: {
-    ts: string;
-    routes: string;
-    routedTypes: string;
-  };
-} => {
-  const targetsFolder = "targets";
-  return {
-    input: readFileSync(join(__dirname, `${targetsFolder}/${testName}.tsp`), {
-      encoding: "utf8",
-    }),
-    output: {
-      ts: readFileSync(
-        join(__dirname, `${targetsFolder}/${testName}.target.ts`),
-        { encoding: "utf8" },
-      )
-        .trim()
-        .replaceAll("\r\n", "\n"),
-      routes: readFileSync(
-        join(__dirname, `${targetsFolder}/${testName}.routes.ts`),
-        { encoding: "utf8" },
-      )
-        .trim()
-        .replaceAll("\r\n", "\n"),
-      routedTypes: readFileSync(
-        join(__dirname, `${targetsFolder}/${testName}.routed-types.ts`),
-        { encoding: "utf8" },
-      )
-        .trim()
-        .replaceAll("\r\n", "\n"),
-    },
-  };
-};
-
-const emitterOptions = {
-  "root-namespace": "test",
-  "enable-routes": true,
-  "enable-types": true,
-  "enable-typeguards": true,
-  "enable-routed-typemap": true,
-};
-
-tests.forEach((test) => {
-  it(`works for ${test}`, async () => {
-    const data = getTestData(test);
-    const emitter = await runner.emit(
-      "typespec-typescript-emitter",
-      emitterOptions,
-    );
-    const result = await emitter.compileAndDiagnose(data.input);
-
-    writeFileSync(
-      join(__dirname, `out/${test}.target.ts`),
-      result[0].outputs["Test.ts"],
-    );
-    writeFileSync(
-      join(__dirname, `out/${test}.routes.ts`),
-      result[0].outputs["routes_test.ts"],
-    );
-    writeFileSync(
-      join(__dirname, `out/${test}.routed-types.ts`),
-      result[0].outputs["routedTypemap_test.ts"],
-    );
-
-    expect(result[1].length).toBe(0);
-    expect(result[0].outputs["Test.ts"].trim()).toBe(data.output.ts);
-    expect(result[0].outputs["routes_test.ts"].trim()).toBe(data.output.routes);
-    expect(result[0].outputs["routedTypemap_test.ts"].trim()).toBe(
-      data.output.routedTypes,
-    );
-  });
-});