typespec-typescript-emitter 1.2.0 → 2.0.1

package/src/resolve/types/Model.Indexed.ts

@@ -0,0 +1,113 @@
+import { Model } from "@typespec/compiler";
+import { Resolvable } from "../Resolvable.js";
+import {
+  Resolver,
+  ResolverOptions,
+  ResolverResult,
+} from "../Resolvable_helpers.js";
+
+enum Type {
+  Array,
+  Record,
+}
+
+export class IndexedModel extends Resolvable<Model> {
+  constructor(t: Model, r: Resolver) {
+    super(t, r);
+    if (t.name === "Array") {
+      this._indexedModelKind = Type.Array;
+    } else if (t.name === "Record") {
+      this._indexedModelKind = Type.Record;
+    } else
+      throw new TypeError(
+        `Cannot create IndexedModel on type of name ${t.name}`,
+      );
+  }
+
+  private _indexedModelKind: Type;
+  protected expectedTypeKind: string = "Model";
+
+  public override async hasVisibility(
+    opts: ResolverOptions<Resolver>,
+    out: ResolverResult<Resolver>,
+  ): Promise<boolean> {
+    if (await super.hasVisibility(opts, out)) return true;
+    if (
+      await Resolvable.hasVisibility(this._t.indexer!.value, opts, out, this._t)
+    )
+      return true;
+    return false;
+  }
+
+  protected async type(
+    opts: ResolverOptions<Resolver.Type>,
+    out: ResolverResult<Resolver.Type>,
+  ): Promise<void> {
+    const resolved = await this.resolveNested(
+      this._t.indexer!.value,
+      opts,
+      out,
+      false,
+    );
+    switch (this._indexedModelKind) {
+      case Type.Array:
+        out.resolved.append(`(${resolved.resolved})[]`);
+        break;
+      case Type.Record:
+        out.resolved.append(`{[k: string]: ${resolved.resolved}}`);
+        break;
+    }
+    out.imports.push(...resolved.imports);
+  }
+
+  protected async typeguard(
+    opts: ResolverOptions<Resolver.Typeguard>,
+    out: ResolverResult<Resolver.Typeguard>,
+  ): Promise<void> {
+    const oldAccessor = opts.accessor;
+    opts.accessor = this._indexedModelKind === Type.Array ? "v" : "v[1]";
+    const resolved = await this.resolveNested(
+      this._t.indexer!.value,
+      opts,
+      out,
+    );
+    opts.accessor = oldAccessor;
+    if (resolved.resolved.value.endsWith("\n")) resolved.resolved.dropLast();
+
+    switch (this._indexedModelKind) {
+      case Type.Array:
+        out.resolved.append(
+          `Array.isArray(${opts.accessor}) && ${opts.accessor}.every((v) => ${resolved.resolved})`,
+        );
+        break;
+      case Type.Record:
+        out.resolved.append(
+          `typeof ${opts.accessor} === 'object' && Object.entries(${opts.accessor} as Record<string, any>).every((v) => ${resolved.resolved})`,
+        );
+        break;
+    }
+    out.imports.push(...resolved.imports);
+  }
+
+  protected validate(): void {
+    if (this._t.name !== "Array" && this._t.name !== "Record") {
+      this.diagnostic(
+        "typeclass-modeltype-mismatch",
+        "Tried creating IndexedModel for non-array and non-record model type",
+        "error",
+      );
+      throw new Error(
+        "Tried creating IndexedModel for non-array and non-record model type",
+      );
+    }
+    if (!this._t.indexer) {
+      this.diagnostic(
+        "no-indexer",
+        "Tried creating IndexedModel for type without indexer",
+        "error",
+      );
+      throw new Error("Tried creating IndexedModel for type without indexer");
+    }
+    super.validate();
+  }
+}

package/src/resolve/types/Model.Shaped.ts

@@ -0,0 +1,291 @@
+import { getDoc, Model, ModelProperty, Program } from "@typespec/compiler";
+import { isVisible, Visibility } from "@typespec/http";
+import { AppendableString } from "../../helpers/appendableString.js";
+import { compareArrays } from "../../helpers/arrays.js";
+import { namespaceListFromNamespace } from "../../helpers/namespaces.js";
+import { Resolvable } from "../Resolvable.js";
+import {
+  Resolver,
+  ResolverOptions,
+  ResolverResult,
+} from "../Resolvable_helpers.js";
+
+type VisibilityType = "Read" | "Create" | "Update" | "Delete" | "Query";
+
+export class ShapedModel extends Resolvable<Model> {
+  protected expectedTypeKind: string = "Model";
+
+  private getProps(): ModelProperty[] {
+    return Array.from(this._t.properties).map((p) => p[1]);
+  }
+
+  private getPropVisibilityType(
+    program: Program,
+    prop: ModelProperty,
+  ): VisibilityType[] | null {
+    if (
+      !prop.decorators.some(
+        (decorator) => decorator.definition?.name === "@visibility",
+      )
+    )
+      return null;
+    const ret: VisibilityType[] = [];
+    if (isVisible(program, prop, Visibility.Read)) ret.push("Read");
+    if (isVisible(program, prop, Visibility.Create)) ret.push("Create");
+    if (isVisible(program, prop, Visibility.Update)) ret.push("Update");
+    if (isVisible(program, prop, Visibility.Delete)) ret.push("Delete");
+    if (isVisible(program, prop, Visibility.Query)) ret.push("Query");
+    return ret;
+  }
+
+  /**
+   * Checks whether or not any of the model's properties has @visibility modifier.
+   * Also returns true if any base model (in the entire chain) has a visibility OR if
+   * any nested type (in the model's properties) has a visibility.
+   */
+  public override async hasVisibility(
+    opts: ResolverOptions<Resolver>,
+    out: ResolverResult<Resolver>,
+  ): Promise<boolean> {
+    if (await super.hasVisibility(opts, out)) return true;
+    // resolve base
+    if (
+      this._t.baseModel &&
+      (await Resolvable.hasVisibility(this._t.baseModel, opts, out, this._t))
+    )
+      return true;
+    // resolve props: check for decorators
+    const props = this.getProps();
+    if (
+      props.some((prop) =>
+        prop.decorators.some(
+          (decorator) => decorator.definition?.name === "@visibility",
+        ),
+      )
+    )
+      return true;
+    // resolve props: check if any resolves to visibility
+    for (const prop of props) {
+      // check if this prop is somewhere up the resolution chain -> recursion -> skip (defaults to false)
+      const propNamespaces = namespaceListFromNamespace(
+        (prop.type as any).namespace,
+      );
+      if (
+        opts.parents &&
+        opts.parents.some((parent) => {
+          const parentNamespaces = namespaceListFromNamespace(
+            (parent as any).namespace,
+          );
+          return (
+            parent.kind === prop.type.kind &&
+            (prop.type as any).name &&
+            (parent as any).name === (prop.type as any).name &&
+            propNamespaces &&
+            parentNamespaces &&
+            compareArrays(propNamespaces, parentNamespaces)
+          );
+        })
+      )
+        continue;
+      // not recursion, resolve
+      if (await Resolvable.hasVisibility(prop.type, opts, out, this._t))
+        return true;
+    }
+    // nothing true
+    return false;
+  }
+
+  protected async type(
+    opts: ResolverOptions<Resolver.Type>,
+    out: ResolverResult<Resolver.Type>,
+  ): Promise<void> {
+    if (opts.emitDocs) {
+      out.doc = getDoc(opts.program, this._t);
+    }
+    const resolution = new AppendableString();
+    // check for base model (extended)
+    if (this._t.baseModel) {
+      const resolvedBase = await this.resolveNested(
+        this._t.baseModel,
+        opts,
+        out,
+      );
+      out.imports.push(...resolvedBase.imports);
+      resolution.append(`${resolvedBase.resolved} & `);
+    }
+
+    const props = this.getProps();
+
+    const propVisibilityTypes: Record<
+      string,
+      { type: VisibilityType[] | null; nested: string }
+    > = {};
+
+    if (props.length === 0) {
+      out.resolved.append("{}");
+    } else {
+      resolution.append("{\n");
+      for (let i = 0; i < props.length; i++) {
+        const prop = props[i];
+        // add doc strings
+        if (opts.emitDocs) {
+          const doc = getDoc(opts.program, prop);
+          if (doc) resolution.addLine(`/** ${doc} */`, opts.nestlevel + 1);
+        }
+        // resolve prop
+        const resolved = await this.resolveNested(prop.type, opts, out);
+        resolution.addLine(
+          `${prop.name}${prop.optional ? "?" : ""}: ${resolved.resolved}${i + 1 < this._t.properties.size ? "," : ""}`,
+          opts.nestlevel + 1,
+        );
+        out.imports.push(...resolved.imports);
+        // if prop has visibility, save to vismap
+        const propVis = this.getPropVisibilityType(opts.program, prop);
+        if (propVis !== null || resolved.hasVisibility) {
+          propVisibilityTypes[prop.name] = { type: null, nested: "" };
+          propVisibilityTypes[prop.name].type = propVis;
+          propVisibilityTypes[prop.name].nested = resolved.visibilityMap;
+        }
+      }
+
+      // build prop visibility map
+      const visMap = new AppendableString();
+      const propVisibilityTypesArr = Object.entries(propVisibilityTypes).filter(
+        (p) => p[1].type !== null || p[1].nested,
+      );
+      if (propVisibilityTypesArr.length > 0) {
+        visMap.addLine("{");
+        let i = 1;
+        for (const [prop, propvis] of propVisibilityTypesArr) {
+          const visLine = `vis: [${(propvis.type ?? []).map((t) => `Lifecycle.${t}`).join(", ")}]`;
+          if (propvis.type !== null && !propvis.nested) {
+            visMap.addLine(
+              `'${prop}': {${visLine}}`,
+              opts.nestlevel + 1,
+              "continued",
+            );
+          }
+          if (propvis.nested) {
+            visMap.addLine(`'${prop}': {`, opts.nestlevel + 1);
+            if (propvis.type) visMap.addLine(`${visLine},`, opts.nestlevel + 2);
+            visMap.addLine(
+              `nested: ${propvis.nested
+                .split("\n")
+                .map((l) => `  ${l}`)
+                .join("\n")
+                .trim()}`,
+              opts.nestlevel + 2,
+            );
+            visMap.addLine("}", opts.nestlevel + 1, "continued");
+          }
+          visMap.addLine(i < propVisibilityTypesArr.length ? "," : "");
+          i++;
+        }
+        visMap.addLine("}", opts.nestlevel, "continued");
+      }
+
+      resolution.addLine("}", opts.nestlevel, "continued");
+
+      out.visibilityMap = visMap.value;
+
+      if (
+        opts.parents &&
+        opts.parents.every(
+          (p) =>
+            p.kind !== "Model" || p.name === "Array" || p.name === "Record",
+        ) &&
+        visMap.value
+      ) {
+        // this model is nested in something that's not a model and has visibility; inline filters
+        out.resolved.append(`FilterLifecycle<${resolution}, ${visMap}, V>`);
+        // this model is the root type or nested in a model; do not inline visibility filter
+      } else {
+        out.resolved.append(resolution);
+      }
+    }
+  }
+
+  protected async typeguard(
+    opts: ResolverOptions<Resolver.Typeguard>,
+    out: ResolverResult<Resolver.Typeguard>,
+  ): Promise<void> {
+    out.resolved.append("\n");
+
+    if (this._t.baseModel) {
+      const resolvedBase = await this.resolveNested(
+        this._t.baseModel,
+        opts,
+        out,
+      );
+      out.resolved.append(
+        `${"  ".repeat(opts.nestlevel)}${resolvedBase.resolved} &&`,
+      );
+      out.imports.push(...resolvedBase.imports);
+      // derived type does not have extended properties; fix by casting
+      opts.accessor = `(${opts.accessor} as any)`;
+    }
+
+    const props = this.getProps();
+    const propGuards: string[] = [];
+    for (const prop of props) {
+      const oldAccessor = opts.accessor;
+      opts.accessor = `${opts.accessor}['${prop.name}']`;
+      const resolved = await this.resolveNested(prop.type, opts, out);
+      opts.accessor = oldAccessor;
+      out.imports.push(...resolved.imports);
+
+      const visibility = this.getPropVisibilityType(opts.program, prop);
+
+      let guard = " ".repeat(
+        out.resolved.value.endsWith("&") ? 1 : opts.nestlevel * 2,
+      );
+      if (visibility !== null) {
+        guard += `((vis as any) !== Lifecycle.All && ![${(visibility ?? []).map((t) => `Lifecycle.${t}`).join(", ")}].includes(vis) ? !('${prop.name}' in ${opts.accessor}) : (`;
+      }
+      if (
+        prop.type.kind === "Intrinsic" &&
+        ["never", "void"].includes(prop.type.name)
+      ) {
+        // some special intrinsic types need special treatment
+        switch (prop.type.name) {
+          case "never":
+            guard += `!('${prop.name}' in ${opts.accessor})`;
+            break;
+          case "void":
+            guard += `${opts.accessor}['${prop.name}'] === undefined`;
+            break;
+        }
+      } else {
+        guard += prop.optional
+          ? `${opts.accessor}['${prop.name}'] === undefined || `
+          : `${opts.accessor}['${prop.name}'] !== undefined && `;
+        guard += `(${resolved.resolved}`;
+        guard += resolved.resolved.value.endsWith("\n")
+          ? "  ".repeat(opts.nestlevel)
+          : "";
+        guard += ")";
+      }
+      if (visibility !== null) guard += "))";
+      propGuards.push(guard);
+    }
+    out.resolved.append(propGuards.join(" &&\n"));
+    out.resolved.addLine("", opts.nestlevel);
+  }
+
+  protected transformKnownType(
+    opts: ResolverOptions<Resolver>,
+    out: ResolverResult<Resolver>,
+  ): void {
+    // If this is a known type, it can't be the root of this resolution tree,
+    // because of the "originalTypeReady" flag.
+    // If it also has visibility, it must have its own visibility map,
+    // which is baked into the type definition, so it shouldn't be returned now.
+
+    if (this._r === Resolver.Type && out.hasVisibility) {
+      out.visibilityMap = "";
+      const newResolved = `${out.resolved}<V>`;
+      out.resolved.clear().append(newResolved);
+      // ret.visibilityMap = `${(t as any).name}_VisMap`;
+    }
+  }
+}

package/src/resolve/types/Scalar.ts

@@ -0,0 +1,140 @@
+import { Scalar } from "@typespec/compiler";
+import { Resolvable } from "../Resolvable.js";
+import {
+  Resolver,
+  ResolverOptions,
+  ResolverResult,
+} from "../Resolvable_helpers.js";
+
+export class ResolvableScalar extends Resolvable<Scalar> {
+  protected expectedTypeKind = "Scalar";
+  private dateTypes = [
+    "offsetDateTime",
+    "plainDate",
+    "utcDateTime",
+    "unixTimestamp32",
+  ];
+
+  protected async type(
+    opts: ResolverOptions<Resolver.Type>,
+    out: ResolverResult<Resolver.Type>,
+  ): Promise<void> {
+    if (this.dateTypes.includes(this._t.name)) {
+      switch (this._t.name) {
+        case "offsetDateTime":
+        case "plainDate":
+        case "utcDateTime":
+          out.resolved.append(
+            opts.options["serializable-date-types"] ? "string" : "Date",
+          );
+          break;
+        case "unixTimestamp32":
+          out.resolved.append(
+            opts.options["serializable-date-types"] ? "number" : "Date",
+          );
+          break;
+      }
+    } else if (this._t.baseScalar) {
+      out.resolved.append(
+        (await this.resolveNested(this._t.baseScalar, opts, out)).resolved,
+      );
+    } else {
+      switch (this._t.name) {
+        case "boolean":
+          out.resolved.append("boolean");
+          break;
+        case "bytes":
+          out.resolved.append("Uint8Array");
+          break;
+        case "duration":
+          out.resolved.append("number");
+          break;
+        case "numeric":
+          out.resolved.append("number");
+          break;
+        case "plainTime":
+          out.resolved.append("string");
+          break;
+        case "string":
+          out.resolved.append("string");
+          break;
+        case "url":
+          out.resolved.append("string");
+          break;
+
+        default:
+          this.diagnostic(
+            "resolve-unresolved-scalar",
+            `Could not resolve scalar ${this._t.name}`,
+            "error",
+          );
+          out.resolved.append("unknown");
+          break;
+      }
+    }
+  }
+
+  protected async typeguard(
+    opts: ResolverOptions<Resolver.Typeguard>,
+    out: ResolverResult<Resolver.Typeguard>,
+  ): Promise<void> {
+    if (this.dateTypes.includes(this._t.name)) {
+      switch (this._t.name) {
+        case "offsetDateTime":
+        case "plainDate":
+        case "utcDateTime":
+          out.resolved.append(
+            opts.options["serializable-date-types"]
+              ? `typeof ${opts.accessor} === 'string'`
+              : `${opts.accessor} instanceof Date`,
+          );
+          break;
+        case "unixTimestamp32":
+          out.resolved.append(
+            opts.options["serializable-date-types"]
+              ? `typeof ${opts.accessor} === 'number'`
+              : `${opts.accessor} instanceof Date`,
+          );
+          break;
+      }
+    } else if (this._t.baseScalar) {
+      out.resolved.append(
+        (await this.resolveNested(this._t.baseScalar, opts, out)).resolved,
+      );
+    } else if (this._t.name === "bytes") {
+      out.resolved.append(`${opts.accessor} instanceof Uint8Array`);
+    } else {
+      out.resolved.append(`typeof ${opts.accessor} === '`);
+      switch (this._t.name) {
+        case "boolean":
+          out.resolved.append("boolean");
+          break;
+        case "duration":
+          out.resolved.append("number");
+          break;
+        case "numeric":
+          out.resolved.append("number");
+          break;
+        case "plainTime":
+          out.resolved.append("string");
+          break;
+        case "string":
+          out.resolved.append("string");
+          break;
+        case "url":
+          out.resolved.append("string");
+          break;
+
+        default:
+          this.diagnostic(
+            "resolve-unresolved-scalar",
+            `Could not create typeguard for scalar ${this._t.name}`,
+            "error",
+          );
+          out.resolved.append("unknown");
+          break;
+      }
+      out.resolved.append("'");
+    }
+  }
+}

package/src/resolve/types/Simple.ts

@@ -0,0 +1,88 @@
+import {
+  IntrinsicType,
+  NumericLiteral,
+  StringLiteral,
+  Type,
+} from "@typespec/compiler";
+import { Resolvable } from "../Resolvable.js";
+import {
+  Resolver,
+  ResolverOptions,
+  ResolverResult,
+} from "../Resolvable_helpers.js";
+
+const allowedTypeKinds = [
+  "Boolean",
+  "Intrinsic",
+  "Number",
+  "String",
+  "TemplateParameter",
+] as const;
+
+export class ResolvableSimple extends Resolvable<Type> {
+  protected expectedTypeKind = ""; // placeholder as required; validate is overridden
+  public static AllowedTypeKinds = allowedTypeKinds;
+
+  private static typeMap: Record<
+    (typeof allowedTypeKinds)[number],
+    (t: Type) => string
+  > = {
+    Boolean: (t) => ((t as any).value ? "true" : "false"),
+    Intrinsic: (t) => (t as IntrinsicType).name,
+    Number: (t) => (t as NumericLiteral).valueAsString,
+    String: (t) => `'${(t as StringLiteral).value}'`,
+    TemplateParameter: () => "unknown",
+  };
+
+  protected async type(
+    opts: ResolverOptions<Resolver.Type>,
+    out: ResolverResult<Resolver.Type>,
+  ): Promise<void> {
+    const mapped =
+      ResolvableSimple.typeMap[
+        this._t.kind as (typeof allowedTypeKinds)[number]
+      ]; // check is in validate()
+    out.resolved.append(mapped(this._t));
+  }
+
+  protected async typeguard(
+    opts: ResolverOptions<Resolver.Typeguard>,
+    out: ResolverResult<Resolver.Typeguard>,
+  ): Promise<void> {
+    const mapped =
+      ResolvableSimple.typeMap[
+        this._t.kind as (typeof allowedTypeKinds)[number]
+      ]; // check is in validate()
+    const v = mapped(this._t);
+
+    // some special intrinsic types are handled directly in the model property
+    switch (v) {
+      case "unknown":
+        out.resolved.append("true");
+        break;
+      case "never":
+        out.resolved.append("false");
+        break; // instantly fails all type checks
+      case "void":
+        out.resolved.append(`${opts.accessor} === undefined`);
+        break;
+
+      default:
+        out.resolved.append(`${opts.accessor} === ${v}`);
+        break;
+    }
+  }
+
+  protected validate(): void {
+    if (!ResolvableSimple.AllowedTypeKinds.includes(this._t.kind as any)) {
+      this.diagnostic(
+        "typeclass-mismatch",
+        `Tried resolving type ${this._t.kind} as primitive`,
+        "error",
+      );
+      throw new TypeError(
+        `Type-kind/class mismatch: tried resolving type ${this._t.kind} as primitive`,
+      );
+    }
+  }
+}

package/src/resolve/types/Tuple.ts

@@ -0,0 +1,56 @@
+import { Tuple } from "@typespec/compiler";
+import { Resolvable } from "../Resolvable.js";
+import {
+  Resolver,
+  ResolverOptions,
+  ResolverResult,
+} from "../Resolvable_helpers.js";
+
+export class ResolvableTuple extends Resolvable<Tuple> {
+  protected expectedTypeKind = "Tuple";
+
+  public override async hasVisibility(
+    opts: ResolverOptions<Resolver>,
+    out: ResolverResult<Resolver>,
+  ): Promise<boolean> {
+    if (await super.hasVisibility(opts, out)) return true;
+    for (const v of this._t.values) {
+      if (await Resolvable.hasVisibility(v, opts, out, this._t)) return true;
+    }
+    return false;
+  }
+
+  protected async type(
+    opts: ResolverOptions<Resolver.Type>,
+    out: ResolverResult<Resolver.Type>,
+  ): Promise<void> {
+    const results: string[] = [];
+    for (const v of this._t.values) {
+      const resolved = await this.resolveNested(v, opts, out);
+      out.imports.push(...resolved.imports);
+      results.push(resolved.resolved.value);
+    }
+    out.resolved.append(`[${results.join(", ")}]`);
+  }
+
+  protected async typeguard(
+    opts: ResolverOptions<Resolver.Typeguard>,
+    out: ResolverResult<Resolver.Typeguard>,
+  ): Promise<void> {
+    const results: string[] = [];
+    const oldAccessor = opts.accessor;
+    let i = 0;
+    for (const v of this._t.values) {
+      opts.accessor = `${opts.accessor}[${i}]`;
+      const resolved = await this.resolveNested(v, opts, out);
+      opts.accessor = oldAccessor;
+      out.imports.push(...resolved.imports);
+      results.push(resolved.resolved.value);
+      i++;
+    }
+    opts.accessor = oldAccessor;
+    out.resolved.append(
+      `Array.isArray(${opts.accessor}) && ${results.map((g) => `(${g})`).join(" && ")}`,
+    );
+  }
+}