typespec-typescript-emitter 0.2.0 → 0.3.1

package/src/emit_types_typeguards.ts

@@ -0,0 +1,137 @@
+import { Model, Type } from "@typespec/compiler";
+import { resolveScalar } from "./emit_types_resolve.js";
+
+export const getTypeguardModel = (
+  m: Model,
+  accessor: string,
+  nestingLevel = 1,
+  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,
+          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,
+  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,
+          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 (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 && t.namespace?.models.has(t.name)) {
+        return [`is${t.name}(${accessor})`, []];
+      } else {
+        const guard = getTypeguardModel(t, accessor, nestingLevel, 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) !== "Date" &&
+        resolveScalar(t) !== "Uint8Array"
+      )
+        return [`typeof ${accessor} === '${resolveScalar(t)}'`, []];
+      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,
+              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,
+              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/src/emitter.ts

@@ -9,20 +9,46 @@ import emitRoutes from "./emit_routes.js";
 import emitTypes from "./emit_types.js";
 import { EmitterOptions } from "./lib.js";
 
+declare global {
+  interface String {
+    addLine(str: string, tabs?: number, continued?: boolean): string;
+  }
+}
+
+String.prototype.addLine = function (
+  this: string,
+  str: string,
+  tabs?: number,
+  continued?: boolean,
+): string {
+  return `${this}${"  ".repeat(tabs ?? 0)}${str}${continued ? "" : "\n"}`;
+};
+
 export async function $onEmit(context: EmitContext) {
   if (!context.program.compilerOptions.noEmit) {
     const options: EmitterOptions = {
       "root-namespace": context.options["root-namespace"],
       "out-dir": context.options["out-dir"] ?? context.emitterOutputDir,
       "enable-types": context.options["enable-types"] ?? true,
+      "enable-typeguards":
+        (context.options["enable-types"] ?? true) &&
+        (context.options["enable-typeguards"] ?? false),
       "enable-routes": context.options["enable-routes"] ?? false,
+      "typeguards-in-routes":
+        (context.options["enable-types"] ?? true) &&
+        (context.options["enable-typeguards"] ?? false) &&
+        (context.options["enable-routes"] ?? false) &&
+        (context.options["typeguards-in-routes"] ?? false),
     };
 
     console.log(`Writing routes to ${options["out-dir"]}`);
 
     let targetNamespaceFound = false;
     let routesObject = "";
-    let typeFiles: ReturnType<typeof emitTypes> = {};
+    let typeFiles: ReturnType<typeof emitTypes> = {
+      files: {},
+      typeguardedNames: [],
+    };
     navigateProgram(context.program, {
       namespace(n) {
         if (
@@ -30,15 +56,18 @@ export async function $onEmit(context: EmitContext) {
           n.name === context.options["root-namespace"]
         ) {
           targetNamespaceFound = true;
+          if (options["enable-types"] || options["enable-typeguards"])
+            typeFiles = emitTypes(context, n, options);
           if (options["enable-routes"]) {
             const servers = getServers(context.program, n);
             routesObject = emitRoutes(
               context,
               n,
               servers && servers[0] ? servers[0].url : "",
+              options,
+              typeFiles.typeguardedNames,
             );
           }
-          if (options["enable-types"]) typeFiles = emitTypes(context, n);
         }
       },
     });
@@ -59,13 +88,14 @@ export async function $onEmit(context: EmitContext) {
     }
 
     // type files
-    if (options["enable-types"]) {
-      const typeFileArr = Object.entries(typeFiles);
+    if (options["enable-types"] || options["enable-typeguards"]) {
+      const typeFileArr = Object.entries(typeFiles.files);
       for (let i = 0; i < typeFileArr.length; i++) {
-        await emitFile(context.program, {
-          path: resolvePath(options["out-dir"], `${typeFileArr[i][0]}.ts`),
-          content: typeFileArr[i][1],
-        });
+        if (typeFileArr[i][1])
+          await emitFile(context.program, {
+            path: resolvePath(options["out-dir"], `${typeFileArr[i][0]}.ts`),
+            content: typeFileArr[i][1],
+          });
       }
     }
   }

package/src/lib.ts

@@ -4,7 +4,9 @@ export interface EmitterOptions {
   "root-namespace": string;
   "out-dir": string;
   "enable-types": boolean;
+  "enable-typeguards": boolean;
   "enable-routes": boolean;
+  "typeguards-in-routes": boolean;
 }
 
 const EmitterOptionsSchema: JSONSchemaType<EmitterOptions> = {
@@ -14,7 +16,9 @@ const EmitterOptionsSchema: JSONSchemaType<EmitterOptions> = {
     "root-namespace": { type: "string" },
     "out-dir": { type: "string", format: "absolute-path" },
     "enable-types": { type: "boolean" },
+    "enable-typeguards": { type: "boolean" },
     "enable-routes": { type: "boolean" },
+    "typeguards-in-routes": { type: "boolean" },
   },
   required: ["root-namespace"],
 };