storybooker 0.0.1

package/src/utils/auth-utils.ts

@@ -0,0 +1,30 @@
+import type { Middleware } from "openapi-fetch";
+import type z from "zod";
+import type { sharedSchemas } from "./schema-utils";
+
+export function createAuthMiddleware(options: {
+  authType: z.infer<typeof sharedSchemas.authType>;
+  authValue: z.infer<typeof sharedSchemas.authValue>;
+}): Middleware {
+  const { authType, authValue } = options;
+  return {
+    onRequest: ({ request }) => {
+      if (!authValue) {
+        return request;
+      }
+      if (!authType) {
+        return request;
+      }
+
+      switch (authType) {
+        case "auth-header": {
+          request.headers.set("Authorization", authValue);
+          return request;
+        }
+        default: {
+          return request;
+        }
+      }
+    },
+  };
+}

package/src/utils/pkg-utils.ts

@@ -0,0 +1,34 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export type PkgManager = "npm" | "yarn" | "pnpm" | "bun";
+export function detectPackageManager(
+  startDir: string = process.cwd(),
+  maxDepth = 5,
+): PkgManager {
+  let currentDir = startDir;
+  let depth = 0;
+
+  while (depth < maxDepth) {
+    if (fs.existsSync(path.join(currentDir, `yarn.lock`))) {
+      return "yarn";
+    }
+    if (fs.existsSync(path.join(currentDir, `pnpm-lock.yaml`))) {
+      return "pnpm";
+    }
+    if (fs.existsSync(path.join(currentDir, `package-lock.json`))) {
+      return "npm";
+    }
+    if (fs.existsSync(path.join(currentDir, `bun.lock`))) {
+      return "bun";
+    }
+
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+
+  throw new Error("Package manager could not be determined.");
+}

package/src/utils/sb-build.ts

@@ -0,0 +1,51 @@
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { detectPackageManager } from "./pkg-utils";
+
+export function buildStoryBook({
+  build,
+  cwd,
+  silent,
+}: {
+  build?: string | boolean;
+  cwd: string;
+  silent?: boolean;
+}): string | undefined {
+  if (build === false) {
+    console.log("> Skipping StoryBook Build.");
+    return;
+  }
+
+  let output = "";
+  if (typeof build === "string" && build.trim() !== "") {
+    console.log("> Building StoryBook with script: %s", build);
+    const pkgManager = detectPackageManager(cwd);
+    output = spawnSync(pkgManager, ["run", build], {
+      cwd,
+      shell: true,
+      stdio: silent ? undefined : "inherit",
+      encoding: "utf8",
+    }).stdout;
+  } else {
+    console.log("> Building StoryBook with storybook CLI");
+    output = spawnSync("npx", ["-y", "storybook", "build"], {
+      cwd,
+      stdio: silent ? undefined : "inherit",
+      encoding: "utf8",
+    }).stdout;
+  }
+
+  const outputDirpath = output?.split("Output directory: ").at(1)?.trim();
+
+  if (!outputDirpath || !fs.existsSync(outputDirpath)) {
+    console.error(`Could not find build output at '${outputDirpath}'.`);
+    return undefined;
+  }
+
+  console.log(
+    "> Built StoryBook to dir: '%s'.",
+    path.relative(cwd, outputDirpath),
+  );
+  return outputDirpath;
+}

package/src/utils/sb-test.ts

@@ -0,0 +1,115 @@
+// oxlint-disable require-await
+// oxlint-disable max-lines-per-function
+
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { detectPackageManager } from "./pkg-utils";
+
+export function testStoryBook({
+  test,
+  cwd,
+  silent,
+  testReportDir = ".test/report",
+  testCoverageDir = ".test/coverage",
+}: {
+  test: string | boolean | undefined;
+  cwd: string;
+  silent?: boolean;
+  testReportDir?: string;
+  testCoverageDir?: string;
+}): {
+  testCoverageDirpath: string | undefined;
+  testReportDirpath: string | undefined;
+} {
+  if (test) {
+    try {
+      runTest(test, { cwd, silent, testCoverageDir, testReportDir });
+    } catch (error) {
+      console.error(error);
+    }
+  } else {
+    console.log("> Skipping tests");
+  }
+
+  const testReportDirpath = path.join(cwd, testReportDir);
+  const existsTestReportDirpath = fs.existsSync(testReportDirpath);
+
+  if (existsTestReportDirpath) {
+    console.log(
+      "> Test report saved at '%s'.",
+      path.relative(cwd, testReportDirpath),
+    );
+  } else {
+    console.warn("> Test report was not created'.");
+  }
+
+  const testCoverageDirpath = path.join(cwd, testCoverageDir);
+  const existsTestCoverageDirpath = fs.existsSync(testCoverageDirpath);
+  if (existsTestCoverageDirpath) {
+    console.log(
+      "> Test coverage saved at '%s'.",
+      path.relative(cwd, testCoverageDirpath),
+    );
+  } else {
+    console.warn("> Test coverage was not created'.");
+  }
+
+  return {
+    testCoverageDirpath: existsTestCoverageDirpath
+      ? testCoverageDirpath
+      : undefined,
+    testReportDirpath: existsTestReportDirpath ? testReportDirpath : undefined,
+  };
+}
+
+function runTest(
+  test: string | true,
+  options: {
+    cwd: string;
+    silent?: boolean;
+    testReportDir: string;
+    testCoverageDir: string;
+  },
+): void {
+  const { cwd, silent, testCoverageDir, testReportDir } = options;
+  if (typeof test === "string" && test.trim() !== "") {
+    console.log("> Testing StoryBook with script: %s", test);
+    const pkgManager = detectPackageManager(cwd);
+    spawnSync(pkgManager, ["run", test], {
+      cwd,
+      shell: true,
+      stdio: silent ? undefined : "inherit",
+    });
+    return;
+  }
+
+  console.log("> Testing StoryBook with Vitest");
+  spawnSync(
+    "npx",
+    [
+      "-y",
+      "vitest",
+      "run",
+      // "--silent=passed-only",
+      "--reporter=default",
+      "--reporter=html",
+      `--outputFile.html=${path.join(testReportDir, "index.html")}`,
+      "--reporter=json",
+      `--outputFile.json=${path.join(testReportDir, "report.json")}`,
+      "--coverage",
+      "--coverage.provider=v8",
+      "--coverage.reportOnFailure",
+      `--coverage.reportsDirectory=${testCoverageDir}`,
+      "--coverage.reporter=text",
+      "--coverage.reporter=html",
+      "--coverage.reporter=text-summary",
+      "--coverage.reporter=json-summary",
+    ],
+    {
+      cwd,
+      stdio: silent ? undefined : "inherit",
+    },
+  );
+  return;
+}

package/src/utils/schema-utils.ts

@@ -0,0 +1,123 @@
+// oxlint-disable no-useless-undefined
+
+import type { CommandBuilder, Options } from "yargs";
+import z from "zod";
+
+declare module "zod" {
+  interface GlobalMeta {
+    alias?: string[];
+    hidden?: boolean;
+    implies?: string;
+  }
+}
+
+export const sharedSchemas = {
+  project: z
+    .string({ error: "ProjectID is required to match with project." })
+    .meta({
+      alias: ["p"],
+      description: "Project ID associated with the StoryBook.",
+    }),
+  url: z.url({ error: "URL is required to connect to the service." }).meta({
+    alias: ["u"],
+    description: "URL of the StoryBooker service.",
+  }),
+  cwd: z
+    .string()
+    .optional()
+    .meta({ description: "Change the working directory for the command." }),
+
+  testReportDir: z.string().optional().meta({
+    description: "Relative path of the test report directory to upload.",
+  }),
+  testCoverageDir: z.string().optional().meta({
+    description: "Relative path of the test coverage directory to upload.",
+  }),
+
+  authType: z
+    .enum(["auth-header"])
+    .optional()
+    .meta({ description: "Enable auth for outgoing requests." }),
+  authValue: z.string().optional().meta({
+    description: "Auth value set for outgoing requests.",
+    implies: "authType",
+  }),
+};
+
+export function zodSchemaToCommandBuilder(
+  objectSchema: z.core.$ZodObject,
+): CommandBuilder {
+  const builder: CommandBuilder = {};
+  for (const [key, schema] of Object.entries(objectSchema._zod.def.shape)) {
+    const meta = schema instanceof z.ZodType ? schema.meta() : undefined;
+
+    let optional = false;
+    try {
+      // @ts-expect-error undefined
+      const valueOrPromise = schema["~standard"].validate(undefined, {});
+      if (valueOrPromise instanceof Promise) {
+        throw new TypeError("Cannot handle async schema");
+      }
+      optional = true;
+    } catch {
+      optional = false;
+    }
+
+    // @ts-expect-error undefined -> never
+    let errorMessage = schema._zod.def.error?.(undefined);
+    if (typeof errorMessage === "object") {
+      errorMessage = errorMessage?.message;
+    }
+
+    let defaultValue =
+      schema instanceof z.core.$ZodDefault
+        ? schema._zod.def.defaultValue
+        : undefined;
+    if (typeof defaultValue === "function") {
+      defaultValue = String(defaultValue());
+    }
+
+    const description =
+      // @ts-expect-error unknown schema
+      // oxlint-disable-next-line no-unsafe-assignment
+      String(schema._zod.def.description ?? schema.description);
+
+    builder[key] = {
+      alias: meta?.alias,
+      description,
+      demandOption: optional ? false : (errorMessage ?? true),
+      type: zodSchemaTypeToYargsBuilderType(schema),
+      default: defaultValue,
+      deprecated: meta?.deprecated,
+      hidden: meta?.hidden,
+      implies: meta?.implies,
+    };
+  }
+
+  return builder;
+}
+
+function zodSchemaTypeToYargsBuilderType(
+  schema: z.core.$ZodType,
+): Options["type"] {
+  if (schema instanceof z.core.$ZodArray) {
+    return "array";
+  }
+  if (schema instanceof z.core.$ZodBoolean) {
+    return "boolean";
+  }
+  if (schema instanceof z.core.$ZodNumber) {
+    return "number";
+  }
+  if (schema instanceof z.core.$ZodOptional) {
+    return zodSchemaTypeToYargsBuilderType(schema._zod.def.innerType);
+  }
+  if (schema instanceof z.core.$ZodDefault) {
+    return zodSchemaTypeToYargsBuilderType(schema._zod.def.innerType);
+  }
+  if (schema instanceof z.core.$ZodUnion) {
+    return undefined;
+  }
+
+  return "string";
+}

package/src/utils/stream-utils.ts

@@ -0,0 +1,72 @@
+// oxlint-disable no-useless-undefined
+// oxlint-disable no-nested-ternary
+
+import * as process from "node:process";
+import type { Readable } from "node:stream";
+import { styleText } from "node:util";
+
+export function toReadableStream(
+  readable: Readable,
+  filesize: number,
+  onProgress: (uploaded: number, total: number) => void = onUploadProgress,
+): ReadableStream {
+  let uploaded = 0;
+
+  return new ReadableStream({
+    start: (controller) => {
+      function onData(chunk: Buffer): void {
+        try {
+          uploaded += chunk.length;
+          controller.enqueue(chunk);
+          onProgress?.(uploaded, filesize);
+        } catch {
+          // If controller is closed, remove listeners and destroy stream
+          cleanup();
+          readable.destroy();
+        }
+      }
+
+      function onEnd(): void {
+        cleanup();
+        controller.close();
+      }
+
+      function onError(err: Error): void {
+        cleanup();
+        controller.error(err);
+      }
+
+      function cleanup(): void {
+        readable.off("data", onData);
+        readable.off("end", onEnd);
+        readable.off("error", onError);
+
+        console.log("");
+      }
+
+      readable.on("data", onData);
+      readable.on("end", onEnd);
+      readable.on("error", onError);
+    },
+
+    cancel: () => {
+      readable.destroy();
+    },
+  });
+}
+
+/** Function to handle upload progress */
+export function onUploadProgress(uploaded: number, total: number): void {
+  const percent = ((uploaded / total) * 100).toFixed(2);
+  const percentStr = percent.padStart(6, " ");
+  const totalStr = (total / 1000).toFixed(2);
+  const uploadedStr = (uploaded / 1000)
+    .toFixed(2)
+    .padStart(totalStr.length, " ");
+  process.stdout.write(
+    styleText(
+      "dim",
+      `\r  - Uploaded: ${uploadedStr} / ${totalStr} KB (${percentStr}%)`,
+    ),
+  );
+}

package/src/utils/types.ts

@@ -0,0 +1,4 @@
+import type { Client } from "openapi-fetch";
+import type { paths } from "../service-schema";
+
+export type ServiceClient = Client<paths>;

package/src/utils/zip.ts

@@ -0,0 +1,75 @@
+// @ts-check
+/*! cross-zip. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+
+import { ChildProcess, execSync } from "node:child_process";
+import fs from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+const isWindows = process.platform === "win32";
+
+/**
+ * Cross-platform sync zip utility that works on Windows and Unix-like systems.
+ * It uses the `zip` command on Unix-like systems and PowerShell on Windows.
+ * It throws an error if the `zip` command is not available on Unix-like systems.
+ */
+export function zip(inPath: string, outPath: fs.PathLike): void {
+  if (isWindows) {
+    if (fs.statSync(inPath).isFile()) {
+      const inFile = fs.readFileSync(inPath);
+      const tmpPath = path.join(tmpdir(), `cross-zip-${Date.now()}`);
+      fs.mkdirSync(tmpPath);
+      fs.writeFileSync(path.join(tmpPath, path.basename(inPath)), inFile);
+      inPath = tmpPath;
+    }
+    fs.rmdirSync(outPath, { recursive: true, maxRetries: 3 });
+  }
+
+  const cwd = path.dirname(inPath);
+  const zipCmd = getZipCommand();
+  const zipCmdArgs = getZipArgs(inPath, outPath);
+  try {
+    execSync([zipCmd, ...zipCmdArgs].join(" "), {
+      cwd,
+      maxBuffer: Infinity,
+      encoding: "utf8",
+    });
+  } catch (error) {
+    if (error instanceof ChildProcess) {
+      console.error("STDOUT:", error.stdout);
+      console.error("STDERR:", error.stderr);
+    }
+    throw error;
+  }
+}
+
+// Unzip function to extract files from a zip archive
+
+function getZipCommand(): string {
+  if (isWindows) {
+    return "powershell.exe";
+  }
+  return "zip";
+}
+
+function getZipArgs(inPath: fs.PathLike, outPath: fs.PathLike): string[] {
+  if (isWindows) {
+    return [
+      "-nologo",
+      "-noprofile",
+      "-command",
+      '& { param([String]$myInPath, [String]$myOutPath); Add-Type -A "System.IO.Compression.FileSystem"; [IO.Compression.ZipFile]::CreateFromDirectory($myInPath, $myOutPath); exit !$? }',
+      "-myInPath",
+      quotePath(inPath),
+      "-myOutPath",
+      quotePath(outPath),
+    ];
+  }
+
+  const dirname = path.basename(inPath.toString());
+  return ["-r", "-y", outPath.toString(), dirname];
+}
+
+function quotePath(pathToTransform: fs.PathLike): string {
+  return `"${pathToTransform.toString()}"`;
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"],
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "skipLibCheck": true
+  }
+}

package/tsdown.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+  banner: { js: "#!/usr/bin/env node" },
+  dts: false,
+  entry: ["./src/index.ts"],
+  platform: "node",
+  treeshake: true,
+});