@typespec/spector 0.1.0-alpha.0

package/src/spec-utils/import-spec.ts

@@ -0,0 +1,49 @@
+import { type ResolveModuleHost, resolveModule } from "@typespec/compiler/module-resolver";
+import { readFile, realpath, stat } from "fs/promises";
+import { pathToFileURL } from "url";
+
+export async function importTypeSpec(
+  baseDir: string,
+): Promise<typeof import("@typespec/compiler")> {
+  return importTypeSpecLibrary("@typespec/compiler", baseDir);
+}
+export async function importSpecExpect(
+  baseDir: string,
+): Promise<typeof import("@typespec/spector")> {
+  return importTypeSpecLibrary("@typespec/spector", baseDir);
+}
+export async function importTypeSpecRest(
+  baseDir: string,
+): Promise<typeof import("@typespec/rest")> {
+  return importTypeSpecLibrary("@typespec/rest", baseDir);
+}
+
+export async function importTypeSpecHttp(
+  baseDir: string,
+): Promise<typeof import("@typespec/http")> {
+  return importTypeSpecLibrary("@typespec/http", baseDir);
+}
+
+export async function importTypeSpecLibrary(name: string, baseDir: string): Promise<any> {
+  try {
+    const host: ResolveModuleHost = {
+      realpath,
+      readFile: async (path: string) => await readFile(path, "utf-8"),
+      stat,
+    };
+    const resolved = await resolveModule(host, name, {
+      baseDir,
+      conditions: ["import"],
+    });
+    return import(
+      pathToFileURL(resolved.type === "module" ? resolved.mainFile : resolved.path).toString()
+    );
+  } catch (err: any) {
+    if (err.code === "MODULE_NOT_FOUND") {
+      // Resolution from cwd failed: use current package.
+      return import(name);
+    } else {
+      throw err;
+    }
+  }
+}

package/src/spec-utils/index.ts

@@ -0,0 +1 @@
+export * from "./import-spec.js";

package/src/utils/body-utils.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest";
+import { cleanupBody } from "./body-utils.js";
+
+describe("BodyUtils", () => {
+  describe("cleanupBody()", () => {
+    it("remove trailing whitespaces", () => {
+      expect(cleanupBody("  foo     ")).toEqual("foo");
+    });
+
+    it("remove trailing new lines", () => {
+      expect(cleanupBody("\nfoo\nbar\n")).toEqual("foo\nbar");
+    });
+
+    it("replace windows line endings", () => {
+      expect(cleanupBody("foo\r\nbar")).toEqual("foo\nbar");
+    });
+  });
+});

package/src/utils/body-utils.ts

@@ -0,0 +1,8 @@
+/**
+ * Cleanup the raw content:
+ *  - trim whitespaces
+ *  - replace \r\n with \n
+ * @param rawContent: raw content to clean.
+ */
+export const cleanupBody = (rawContent: string): string =>
+  rawContent.trim().replace(/\r?\n|\r/g, "\n");

package/src/utils/diagnostic-reporter.ts

@@ -0,0 +1,49 @@
+import { getSourceLocation, SourceLocation, Type } from "@typespec/compiler";
+import pc from "picocolors";
+import { logger } from "../logger.js";
+
+export interface Diagnostic {
+  message: string;
+  target?: Type | string;
+}
+
+export interface DiagnosticReporter {
+  readonly diagnostics: Diagnostic[];
+  reportDiagnostic(diagnostic: Diagnostic): void;
+  reportDiagnostics(diagnostic: readonly Diagnostic[]): void;
+}
+
+export function createDiagnosticReporter(): DiagnosticReporter {
+  const diagnostics: Diagnostic[] = [];
+  function reportDiagnostic(diagnostic: Diagnostic) {
+    const target = diagnostic.target ? `\n  ${resolveSourceLocation(diagnostic.target)}` : "";
+    logger.error(`${pc.red("✘")} ${diagnostic.message}${target}`);
+    diagnostics.push(diagnostic);
+  }
+  return {
+    diagnostics,
+    reportDiagnostic,
+    reportDiagnostics(diagnostics: readonly Diagnostic[]) {
+      for (const diagnostic of diagnostics) {
+        reportDiagnostic(diagnostic);
+      }
+    },
+  };
+}
+
+function resolveSourceLocation(target: Type | string) {
+  if (typeof target === "string") {
+    return pc.cyan(target);
+  }
+
+  const location = getSourceLocation(target);
+  return getSourceLocationStr(location);
+}
+
+export function getSourceLocationStr(location: SourceLocation) {
+  const position = location.file.getLineAndCharacterOfPosition(location.pos);
+  const path = pc.cyan(location.file.path);
+  const line = pc.yellow(position.line + 1);
+  const column = pc.yellow(position.character + 1);
+  return `${path}:${line}:${column}`;
+}

package/src/utils/exec.ts

@@ -0,0 +1,36 @@
+import { ChildProcess, spawn, SpawnOptions } from "child_process";
+
+export async function execAsync(
+  command: string,
+  args: string[],
+  options: SpawnOptions = {},
+): Promise<{ exitCode: number; stdout: string; stderr: string; out: string; proc: ChildProcess }> {
+  const child = spawn(command, args, options);
+
+  return new Promise((resolve, reject) => {
+    child.on("error", (error) => {
+      reject(error);
+    });
+    const stdout: Buffer[] = [];
+    const stderr: Buffer[] = [];
+    const out: Buffer[] = [];
+    child.stdout?.on("data", (data) => {
+      stdout.push(data);
+      out.push(data);
+    });
+    child.stderr?.on("data", (data) => {
+      stderr.push(data);
+      out.push(data);
+    });
+
+    child.on("exit", (exitCode) => {
+      resolve({
+        exitCode: exitCode ?? -1,
+        stdout: Buffer.concat(stdout).toString(),
+        stderr: Buffer.concat(stderr).toString(),
+        out: Buffer.concat(out).toString(),
+        proc: child,
+      });
+    });
+  });
+}

package/src/utils/file-utils.ts

@@ -0,0 +1,14 @@
+import { mkdir } from "fs/promises";
+import { globby } from "globby";
+
+export async function findFilesFromPattern(pattern: string | string[]): Promise<string[]> {
+  return await globby(pattern);
+}
+
+/**
+ * Ensure the given dir exists.
+ * @param path Path to the dir.
+ */
+export async function ensureDir(path: string): Promise<void> {
+  await mkdir(path, { recursive: true });
+}

package/src/utils/index.ts

@@ -0,0 +1,5 @@
+export * from "./body-utils.js";
+export * from "./diagnostic-reporter.js";
+export * from "./file-utils.js";
+export * from "./misc-utils.js";
+export * from "./request-utils.js";

package/src/utils/misc-utils.ts

@@ -0,0 +1,54 @@
+import { execSync } from "child_process";
+import { readFile, stat } from "fs/promises";
+import { dirname, join } from "path";
+import { logger } from "../logger.js";
+
+export async function ensureScenariosPathExists(scenariosPath: string) {
+  try {
+    const stats = await stat(scenariosPath);
+    if (!stats.isDirectory()) {
+      throw new Error(`Scenarios path ${scenariosPath} is not a directory.`);
+    }
+  } catch (e) {
+    throw new Error(`Scenarios path ${scenariosPath} doesn't exists.`);
+  }
+}
+
+export function getCommit(path: string): string {
+  return execSync("git rev-parse HEAD", { cwd: path }).toString().trim();
+}
+
+export interface PackageJson {
+  name: string;
+  version: string;
+}
+
+export async function getPackageJson(path: string): Promise<PackageJson | undefined> {
+  logger.debug(`Loading package json for path "${path}"`);
+  const projectRoot = await findProjectRoot(path);
+  if (projectRoot === undefined) {
+    return undefined;
+  }
+  logger.debug(`Found project root "${projectRoot}"`);
+  const packageJsonPath = join(projectRoot, "package.json");
+  return JSON.parse((await readFile(packageJsonPath, "utf-8")).toString());
+}
+
+async function findProjectRoot(path: string): Promise<string | undefined> {
+  let current = path;
+  while (true) {
+    const pkgPath = join(current, "package.json");
+    try {
+      const stats = await stat(pkgPath);
+      if (stats?.isFile()) {
+        return current;
+      }
+    } catch {}
+
+    const parent = dirname(current);
+    if (parent === current) {
+      return undefined;
+    }
+    current = parent;
+  }
+}

package/src/utils/path-utils.ts

@@ -0,0 +1,3 @@
+export function normalizePath(path: string): string {
+  return path.replace(/\\/g, "/");
+}

package/src/utils/request-utils.ts

@@ -0,0 +1,4 @@
+import { Request } from "express";
+
+export const getRequestBaseUrl = (request: Request): string =>
+  `${request.protocol}://${request.get("host")}`;