typespec-typescript-emitter 1.2.0 → 2.0.1

package/src/emit_routedTypemap.ts

@@ -0,0 +1,128 @@
+import {
+  emitFile,
+  Namespace,
+  navigateProgram,
+  Operation,
+  Program,
+  resolvePath,
+} from "@typespec/compiler";
+import { getHttpOperation } from "@typespec/http";
+import { unique2D } from "./helpers/arrays.js";
+import autogenerateWarning from "./helpers/autogenerateWarning.js";
+import { TTypeMap } from "./helpers/buildTypeMap.js";
+import { getImports } from "./helpers/getImports.js";
+import { visibilityHelperFileName } from "./helpers/visibilityHelperFile.js";
+import { EmitterOptions } from "./lib.js";
+import {
+  resolveOperationTypemap,
+  TOperationTypemap,
+} from "./resolve/operationTypemap.js";
+
+export const emitRoutedTypemap = async (
+  program: Program,
+  options: EmitterOptions,
+  typemap: TTypeMap,
+): Promise<void> => {
+  // save original targeted namespaces array because it's mutated here
+  const targetedNamespaces = structuredClone(options["root-namespaces"]);
+  const namespaceImports: {
+    [namespace: string]: TTypeMap[number]["namespaces"][];
+  } = {};
+  const namespaceOps: {
+    [namespace: string]: {
+      ops: {
+        [path: string]: {
+          [verb: string]: TOperationTypemap;
+        };
+      };
+      hasVisibility: boolean;
+    };
+  } = {};
+
+  // finding all operations
+  const foundOps: { [namespace: string]: Operation[] } = {};
+  const traverseNamespace = (n: Namespace, rootName: string) => {
+    if (!foundOps[rootName]) foundOps[rootName] = [];
+    foundOps[rootName].push(...Array.from(n.operations).map((op) => op[1]));
+    n.namespaces.forEach((ns) => traverseNamespace(ns, rootName));
+  };
+  navigateProgram(program, {
+    namespace(n) {
+      const nsIndex = options["root-namespaces"].findIndex(
+        (ns) => n.name === ns,
+      );
+      if (nsIndex === -1) return;
+      // for some reason, navigateProgram visits each namespace multiple times; this prevents that
+      delete options["root-namespaces"][nsIndex];
+
+      traverseNamespace(n, n.name);
+    },
+  });
+
+  // resolving operations
+  for (const ns of Object.entries(foundOps)) {
+    for (const op of ns[1]) {
+      const resolved = await resolveOperationTypemap(
+        program,
+        options,
+        typemap,
+        op,
+      );
+      const httpOp = getHttpOperation(program, op)[0];
+
+      if (!namespaceImports[ns[0]]) namespaceImports[ns[0]] = [];
+      namespaceImports[ns[0]].push(...resolved.imports);
+
+      if (!namespaceOps[ns[0]])
+        namespaceOps[ns[0]] = { ops: {}, hasVisibility: false };
+      if (!namespaceOps[ns[0]].ops[httpOp.path])
+        namespaceOps[ns[0]].ops[httpOp.path] = {};
+      namespaceOps[ns[0]].ops[httpOp.path][httpOp.verb.toUpperCase()] =
+        resolved.types;
+
+      if (
+        resolved.types.request.hasVisibility ||
+        resolved.types.response.content.some((v) => v.hasVisibility)
+      )
+        namespaceOps[ns[0]].hasVisibility = true;
+    }
+  }
+
+  // emitting
+  for (const ns of Object.entries(namespaceOps)) {
+    const importStrings = getImports(unique2D(namespaceImports[ns[0]]));
+
+    if (ns[1].hasVisibility) {
+      importStrings.push(
+        `import {Lifecycle, FilterLifecycle} from './${visibilityHelperFileName}';`,
+      );
+    }
+
+    let out = `export type types_${ns[0]}${ns[1].hasVisibility ? "<V extends Lifecycle = Lifecycle.All>" : ""} = {\n`;
+    out += Object.entries(ns[1].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.content}\n`;
+            verbret += `      response: ${verb[1].response.content.map((res) => `{status: ${res.status}, body: ${res.body}}`).join(" | ")}\n`;
+            verbret += "    }";
+            return verbret;
+          })
+          .join(",\n");
+        pathret += "\n  }";
+        return pathret;
+      })
+      .join(",\n");
+    out += "\n};\n";
+    const content = `/* eslint-disable */\n\n${autogenerateWarning}\n${importStrings.join("\n")}\n\n${out}`;
+    await emitFile(program, {
+      path: resolvePath(options["out-dir"], `routedTypemap_${ns[0]}.ts`),
+      content: content,
+    });
+  }
+
+  // restore un-mutated version
+  options["root-namespaces"] = targetedNamespaces;
+};

package/src/emit_routes.ts

@@ -1,63 +1,80 @@
 import {
-  EmitContext,
+  emitFile,
   getDoc,
+  Interface,
   isTemplateDeclaration,
   Namespace,
-  Operation,
+  navigateProgram,
+  Program,
+  resolvePath,
 } from "@typespec/compiler";
 import { getAuthentication, getHttpOperation } from "@typespec/http";
+import { AppendableString } from "./helpers/appendableString.js";
+import autogenerateWarning from "./helpers/autogenerateWarning.js";
+import { EmitterOptions } from "./lib.js";
 
-export const emitRoutes = (
-  context: EmitContext,
-  namespace: Namespace,
-): string => {
-  let out = `export const routes_${context.options["root-namespace"]} = {\n`;
+export const emitRoutes = async (
+  program: Program,
+  options: EmitterOptions,
+): Promise<void> => {
+  // save original targeted namespaces array because it's mutated here
+  const targetedNamespaces = structuredClone(options["root-namespaces"]);
 
-  const traverseNamespace = (n: Namespace, nestLevel: number): void => {
-    // operations
-    const processOp = (op: Operation) => {
-      const httpOp = getHttpOperation(context.program, op);
+  const files: Record<string, AppendableString> = {};
 
-      // jsdoc comment
-      const doc = getDoc(context.program, op);
-      if (doc) out = out.addLine(`/** ${doc} */`, nestLevel + 1);
-
-      // start op body
-      out = out.addLine(`${op.name}: {`, nestLevel + 1);
-
-      // HTTP method
-      out = out.addLine(
-        `method: '${httpOp[0].verb.toUpperCase()}',`,
-        nestLevel + 2,
+  const traverseNamespace = (
+    n: Namespace | Interface,
+    nestlevel: number,
+    rootName: string,
+  ) => {
+    if (files[rootName] === undefined)
+      files[rootName] = new AppendableString(
+        `export const routes_${rootName} = {\n`,
       );
 
-      // path
-      out = out.addLine(`path: '${httpOp[0].path}',`, nestLevel + 2);
+    const numCollections =
+      Array.from((n as any).interfaces ?? []).length +
+      Array.from(((n as any).namespaces ?? []) as any[]).length;
 
-      // getUrl
-      const pathParams = httpOp[0].parameters.parameters.filter(
+    let i = 1;
+    for (const op of n.operations) {
+      const httpOp = getHttpOperation(program, op[1])[0];
+
+      const pathParams = httpOp.parameters.parameters.filter(
         (p) => p.type === "path",
       );
-      const pathParamsArgsString = pathParams
+      const urlParams = `params: {${pathParams
         .map((p) => `${p.name}: string`)
-        .join(", ");
-      const pathParamsArg = `params: {${pathParamsArgsString}}`;
-      const pathParamsOutString = pathParams.reduce(
+        .join(", ")}}`;
+      const urlReturn = pathParams.reduce(
         (sum, cur) =>
           sum.replaceAll(`{${cur.name}}`, `${"$"}{params.${cur.name}}`),
-        `\`${httpOp[0].path}\``,
+        `\`${httpOp.path}\``,
       );
 
-      out = out.addLine(
-        `getUrl: (${pathParams.length > 0 ? pathParamsArg : ""}): string => ${pathParamsOutString},`,
-        nestLevel + 2,
-      );
+      const doc = getDoc(program, op[1]);
+      if (doc)
+        files[rootName].addLine(
+          `/** ${doc} */`
+            .split("\n")
+            .map((l) => `${"  ".repeat(nestlevel)}${l}`)
+            .join("\n"),
+          0,
+        );
+      files[rootName]
+        .addLine(`${op[1].name}: {`, nestlevel)
+        .addLine(`verb: '${httpOp.verb.toUpperCase()}',`, nestlevel + 1)
+        .addLine(`path: '${httpOp.path}',`, nestlevel + 1)
+        .addLine(
+          `getUrl: (${pathParams.length > 0 ? urlParams : ""}): string => ${urlReturn},`,
+          nestlevel + 1,
+        );
 
       // auth
       let auth: Array<
         null | string | { apiKeyLocation: string; apiKeyName: string }
       > = [];
-      const opAuth = getAuthentication(context.program, op);
+      const opAuth = getAuthentication(program, op[1]);
       if (opAuth) {
         opAuth.options.forEach((authOption) =>
           authOption.schemes.forEach((authScheme) => {
@@ -77,8 +94,7 @@ export const emitRoutes = (
           }),
         );
       } else auth = [null];
-
-      out = out.addLine(
+      files[rootName].addLine(
         `auth: [${auth
           .map((authEntry) =>
             !authEntry
@@ -90,34 +106,65 @@ export const emitRoutes = (
                     .join(", ")}}`,
           )
           .join(", ")}]`,
-        nestLevel + 2,
+        nestlevel + 1,
       );
 
-      // finalize route entry
-      out = out.addLine("},", nestLevel + 1);
-    }; // end operations
-
-    n.operations.forEach(processOp);
-    n.interfaces.forEach((itf) => {
-      if (!isTemplateDeclaration(itf)) itf.operations.forEach(processOp);
-    });
+      files[rootName].addLine(
+        i < n.operations.size || numCollections > 0 ? "}," : "}",
+        nestlevel,
+      );
+      i++;
+    }
 
-    // get and traverse all namespaces
-    let nsnum = 0;
-    n.namespaces.forEach((ns) => {
-      nsnum++;
-      const doc = getDoc(context.program, ns);
-      if (doc) out = out.addLine(`/** ${doc} */`, nestLevel + 1);
-      out = out.addLine(`${ns.name}: {`, nestLevel + 1);
-      traverseNamespace(ns, nestLevel + 1);
-      out = out.addLine(
-        `}${nsnum < n.namespaces.size ? "," : ""}`,
-        nestLevel + 1,
+    let collectionNum = 1;
+    const printCollection = (n: Namespace | Interface): void => {
+      const doc = getDoc(program, n);
+      if (doc)
+        files[rootName].addLine(
+          `/** ${doc} */`
+            .split("\n")
+            .map((l) => `${"  ".repeat(nestlevel)}${l}`)
+            .join("\n"),
+        );
+      files[rootName].addLine(`${n.name}: {`, nestlevel);
+      traverseNamespace(n, nestlevel + 1, rootName);
+      files[rootName].addLine(
+        collectionNum < numCollections ? "}," : "}",
+        nestlevel,
       );
+      collectionNum++;
+    };
+
+    (((n as any).interfaces ?? []) as Interface[]).forEach((i) => {
+      if (!isTemplateDeclaration(i)) printCollection(i);
     });
+    (((n as any).namespaces ?? []) as Namespace[]).forEach((ns) =>
+      printCollection(ns),
+    );
+    if (n.name === rootName && nestlevel === 1)
+      files[rootName].addLine("} as const;");
   };
+  navigateProgram(program, {
+    namespace(n) {
+      const nsIndex = options["root-namespaces"].findIndex(
+        (ns) => n.name === ns,
+      );
+      if (nsIndex === -1) return;
+      // for some reason, navigateProgram visits each namespace multiple times; this prevents that
+      delete options["root-namespaces"][nsIndex];
+
+      traverseNamespace(n, 1, n.name);
+    },
+  });
+
+  // emitting
+  for (const file of Object.entries(files)) {
+    await emitFile(program, {
+      path: resolvePath(options["out-dir"], `routes_${file[0]}.ts`),
+      content: `/* eslint-disable */\n\n${autogenerateWarning}\n${file[1].value}`,
+    });
+  }
 
-  traverseNamespace(namespace, 0);
-  out += "} as const;\n";
-  return out;
+  // restore un-mutated version
+  options["root-namespaces"] = targetedNamespaces;
 };

package/src/emit_types.ts

@@ -1,103 +1,148 @@
-import { EmitContext, getDoc, Namespace } from "@typespec/compiler";
-import {
-  resolveEnum,
-  resolveModel,
-  resolveUnion,
-} from "./emit_types_resolve.js";
-import { getTypeguardModel } from "./emit_types_typeguards.js";
+import { emitFile, Program, resolvePath, Type } from "@typespec/compiler";
+import { AppendableString } from "./helpers/appendableString.js";
+import { unique2D } from "./helpers/arrays.js";
+import autogenerateWarning from "./helpers/autogenerateWarning.js";
+import { TTypeMap } from "./helpers/buildTypeMap.js";
+import { getImports } from "./helpers/getImports.js";
+import { filenameFromNamespaces } from "./helpers/namespaces.js";
+import { visibilityHelperFileName } from "./helpers/visibilityHelperFile.js";
 import { EmitterOptions } from "./lib.js";
+import { Resolvable } from "./resolve/Resolvable.js";
+import { Resolver } from "./resolve/Resolvable_helpers.js";
 
-const emitTypes = (
-  context: EmitContext,
-  namespace: Namespace,
+export const emitTypes = async (
+  program: Program,
   options: EmitterOptions,
-): {
-  files: Record<string, string>;
-  typeguardedNames: Array<{ filename: string; name: string }>;
-} => {
-  const out: ReturnType<typeof emitTypes> = { files: {}, typeguardedNames: [] };
+  typemap: TTypeMap,
+): Promise<void> => {
+  // maps file names to file contents
+  const files: Record<string, AppendableString> = {};
+  // maps file names to list of required imports
+  const imports: Record<
+    string,
+    {
+      namespaces: TTypeMap[number]["namespaces"][];
+      lifecycleTypes: string[];
+    }
+  > = {};
 
-  const traverseNamespace = (n: Namespace): void => {
-    let file = "";
+  // generate files
+  typemap.forEach((t) => {
+    files[filenameFromNamespaces(t.namespaces)] = new AppendableString();
+    imports[filenameFromNamespaces(t.namespaces)] = {
+      namespaces: [],
+      lifecycleTypes: [],
+    };
+  });
 
-    n.enums.forEach((e) => {
-      if (options["enable-types"]) {
-        const resolved = resolveEnum(e, {
-          context: context,
-          currentNamespace: n,
-          nestlevel: 0,
-          isNamespaceRoot: true,
-        });
-        if (resolved) {
-          const doc = getDoc(context.program, e);
-          if (doc) file = file.addLine(`/** ${doc} */`);
-          file = file.addLine(`export enum ${e.name} ${resolved};\n`);
-        }
-      }
-    });
-    n.unions.forEach((u) => {
-      if (options["enable-types"]) {
-        const resolved = resolveUnion(u, {
-          currentNamespace: n,
-          context,
-          nestlevel: 0,
-          isNamespaceRoot: true,
-        });
-        if (resolved) {
-          const doc = getDoc(context.program, u);
-          if (doc) file = file.addLine(`/** ${doc} */`);
-          file = file.addLine(`export type ${u.name} = ${resolved};\n`);
-        }
-      }
+  const typeOrder: Type["kind"][] = ["Enum", "Scalar", "Model", "Union"];
+  typemap.sort(
+    (a, b) => typeOrder.indexOf(a.type.kind) - typeOrder.indexOf(b.type.kind),
+  );
+
+  // resolve all types
+  for (let i = 0; i < typemap.length; i++) {
+    const t = typemap[i];
+    const filename = filenameFromNamespaces(t.namespaces);
+    const resolved = await Resolvable.resolve(Resolver.Type, t.type, {
+      program,
+      options,
+      emitDocs: true,
+      nestlevel: 0,
+      rootType: t,
+      typemap: typemap,
     });
-    n.models.forEach((m) => {
-      if (options["enable-types"]) {
-        const resolved = resolveModel(m, {
-          nestlevel: 0,
-          currentNamespace: n,
-          context,
-          isNamespaceRoot: true,
-        });
-        if (resolved) {
-          const doc = getDoc(context.program, m);
-          if (doc) file = file.addLine(`/** ${doc} */`);
-          file = file.addLine(`export interface ${m.name} ${resolved};`);
+
+    imports[filename].namespaces.push(...resolved.imports);
+    let declaration = "export ";
+    switch (t.type.kind) {
+      case "Enum":
+        declaration += `enum ${t.type.name}`;
+        break;
+      case "Scalar":
+        declaration += `type ${t.type.name} =`;
+        break;
+      case "Model":
+        declaration += `type ${t.type.name}${resolved.hasVisibility ? "<V extends Lifecycle = Lifecycle.All>" : ""} =`;
+        // Making ALL types generic (regardless of whether they need it) improves ease-of-use,
+        // both for the user as well for the dev when accessing known types.
+        // declaration += `type ${t.type.name}${resolved.hasVisibility ? "<V extends Lifecycle = Lifecycle.All>" : ""} =`;
+        break;
+      case "Union":
+        declaration += `type ${t.type.name}${resolved.hasVisibility ? "<V extends Lifecycle = Lifecycle.All>" : ""} =`;
+        // declaration += `type ${t.type.name}${resolved.hasVisibility ? "<V extends Lifecycle = Lifecycle.All>" : ""} =`;
+        break;
+    }
+    if (resolved.doc) files[filename].addLine(`/** ${resolved.doc} */`);
+
+    if (resolved.hasVisibility) {
+      imports[filename].lifecycleTypes.push("FilterLifecycle", "Lifecycle");
+    }
+    if (
+      (t.type as any).kind === "Model" &&
+      t.type.name !== "Array" &&
+      t.type.name !== "Record" &&
+      resolved.visibilityMap.replaceAll("{", "").replaceAll("}", "").trim()
+    ) {
+      files[filename].addLine(`${declaration} ${resolved.resolved.value}`);
+      // files[filename].addLine(
+      //   `${declaration} FilterLifecycle<${resolved.resolved.value}, typeof ${t.type.name}_VisMap, V>`,
+      // );
+      // files[filename].addLine(
+      //   `export const ${t.type.name}_VisMap = ${resolved.visibilityMap} as const`,
+      // );
+    } else {
+      files[filename].addLine(`${declaration} ${resolved.resolved.value}`);
+    }
+
+    if (options["enable-typeguards"]) {
+      const typeguard = await Resolvable.resolve(Resolver.Typeguard, t.type, {
+        program,
+        options,
+        nestlevel: 1,
+        rootType: t,
+        typemap: typemap,
+        accessor: "t",
+      });
+      if (typeguard.resolved.value) {
+        if (typeguard.hasVisibility) {
+          imports[filename].lifecycleTypes.push("Lifecycle");
+          files[filename].addLine(
+            `export function is${t.type.name}(t: any, vis: Lifecycle = Lifecycle.All): t is ${t.type.name}<typeof vis> {return (${typeguard.resolved})}`,
+          );
+        } else {
+          files[filename].addLine(
+            `export function is${t.type.name}(t: any): t is ${t.type.name} {return (${typeguard.resolved})}`,
+          );
         }
+        imports[filename].namespaces.push(...typeguard.imports);
       }
+    }
 
-      if (options["enable-typeguards"]) {
-        file = file.addLine(
-          `export function is${m.name}(arg: any): arg is ${m.name} {`,
-        );
-        file = file.addLine("return (", 1);
-        getTypeguardModel(
-          m,
-          "arg",
-          undefined,
-          n,
-          !!options["serializable-date-types"],
-        )[0]
-          .split("\n")
-          .forEach((line) => {
-            file = file.addLine(line, 1);
-          });
-        file = file.addLine(");", 1);
-        file = file.addLine("};");
-        out.typeguardedNames.push({
-          filename: n.name.charAt(0).toUpperCase() + n.name.slice(1),
-          name: m.name,
-        });
-      }
-      file += "\n";
-    });
-    // set output for this namespace
-    out.files[n.name.charAt(0).toUpperCase() + n.name.slice(1)] = file;
-    // recursively iterate child namespaces
-    n.namespaces.forEach((ns) => traverseNamespace(ns));
-  };
-  traverseNamespace(namespace);
+    files[filename].append("\n");
+  }
 
-  return out;
-};
+  const filesArr = Object.entries(files).filter((f) => !!f[1].value);
+  for (let i = 0; i < filesArr.length; i++) {
+    if (!filesArr[i][1].value) continue;
+    const filename = filesArr[i][0];
 
-export default emitTypes;
+    imports[filename].namespaces = unique2D(imports[filename].namespaces);
+    const importStrings = getImports(
+      imports[filename].namespaces.filter(
+        (i) => filenameFromNamespaces(i) !== filename,
+      ),
+    );
+    if (imports[filename].lifecycleTypes.length > 0) {
+      importStrings.push(
+        `import {${[...new Set(imports[filename].lifecycleTypes)].join(", ")}} from './${visibilityHelperFileName}';`,
+      ); // unique-ify
+    }
+
+    const content = `/* eslint-disable */\n\n${autogenerateWarning}${importStrings.join("\n")}${importStrings.length > 0 ? "\n\n" : ""}${filesArr[i][1].value}`;
+    await emitFile(program, {
+      path: resolvePath(options["out-dir"], filename),
+      content: content,
+    });
+  }
+};