@scalar/cli 2.1.0 → 2.5.1

package/chunks/action-QE2ZQQX7.js

@@ -0,0 +1,250 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  measureTime
+} from "./chunk-KHDYYVYF.js";
+import {
+  isAsyncApiDocument,
+  isDocument,
+  safeNormalize
+} from "./chunk-24WAOKGG.js";
+import {
+  require_dist
+} from "./chunk-K74E42RV.js";
+import "./chunk-CISTON3A.js";
+import "./chunk-Q7DOQHZN.js";
+import {
+  isYamlFileName
+} from "./chunk-4ORL4MST.js";
+import {
+  output
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import {
+  external_exports
+} from "./chunk-IKT5F47M.js";
+import {
+  __toESM
+} from "./chunk-3MZYUBJ6.js";
+
+// src/domains/document/join/action.ts
+var import_yaml = __toESM(require_dist(), 1);
+import fs from "node:fs/promises";
+import path from "node:path";
+import as from "ansis";
+import { bundle } from "@scalar/json-magic/bundle";
+import { fetchUrls, readFiles } from "@scalar/json-magic/bundle/plugins/node";
+import { join } from "@scalar/openapi-parser";
+
+// src/domains/document/join/helpers.ts
+import { getValueByPath as getValueByPathWithContext } from "@scalar/json-magic/helpers/get-value-by-path";
+var getValueByPath = (input, path2) => {
+  return getValueByPathWithContext(input, path2).value;
+};
+var getPrefixes = (documents, path2) => {
+  const segments = path2.split(".");
+  return documents.map((doc) => {
+    const value = getValueByPath(doc, segments);
+    if (value === void 0) {
+      return "";
+    }
+    return String(value);
+  });
+};
+
+// src/domains/document/join/asyncapi.ts
+import { isDeepStrictEqual } from "node:util";
+import { upgrade } from "@scalar/asyncapi-upgrader";
+import { validate } from "@scalar/asyncapi-validator";
+var escapePointer = (value) => value.replaceAll("~", "~0").replaceAll("/", "~1");
+var unescapePointer = (value) => value.replaceAll("~1", "/").replaceAll("~0", "~");
+var prefixReferences = (value, prefix, section = "components") => {
+  if (Array.isArray(value))
+    return value.map((item) => prefixReferences(item, prefix, section));
+  if (!isDocument(value)) return value;
+  return Object.fromEntries(
+    Object.entries(value).map(([key, child]) => {
+      if (key === "$ref" && typeof child === "string" && child.startsWith(`#/${section}/`)) {
+        const segments = child.split("/");
+        const offset = section === "components" ? 3 : 2;
+        if (segments[offset])
+          segments[offset] = escapePointer(
+            prefix + unescapePointer(segments[offset])
+          );
+        return [key, segments.join("/")];
+      }
+      return [key, prefixReferences(child, prefix, section)];
+    })
+  );
+};
+var joinAsyncApi = (inputs, prefixes) => {
+  const conflicts = [];
+  const documents = inputs.map((input, index) => {
+    if (!validate(input).valid)
+      conflicts.push({
+        type: "asyncapi",
+        path: `input ${index + 1} is invalid`
+      });
+    const externalPrefix = `document${index}-`;
+    const document = prefixReferences(
+      upgrade(structuredClone(input)),
+      externalPrefix,
+      "x-ext"
+    );
+    if (isDocument(document["x-ext"])) {
+      document["x-ext"] = Object.fromEntries(
+        Object.entries(document["x-ext"]).map(([key, value]) => [
+          externalPrefix + key,
+          value
+        ])
+      );
+    }
+    const prefix = prefixes[index] ?? "";
+    if (!prefix) return document;
+    const renamed = prefixReferences(document, prefix);
+    if (isDocument(renamed.components)) {
+      renamed.components = Object.fromEntries(
+        Object.entries(renamed.components).map(([kind, entries]) => [
+          kind,
+          isDocument(entries) ? Object.fromEntries(
+            Object.entries(entries).map(([name, value]) => [
+              prefix + name,
+              value
+            ])
+          ) : entries
+        ])
+      );
+    }
+    return renamed;
+  });
+  const mergeNamed = (values, pointer) => {
+    const merged = /* @__PURE__ */ new Map();
+    for (const value of values) {
+      if (!isDocument(value)) continue;
+      for (const [name, entry] of Object.entries(value)) {
+        if (merged.has(name) && !isDeepStrictEqual(merged.get(name), entry)) {
+          conflicts.push({
+            type: "asyncapi",
+            path: `${pointer}/${escapePointer(name)}`
+          });
+        }
+        merged.set(name, entry);
+      }
+    }
+    return Object.fromEntries(merged);
+  };
+  const namedSections = ["channels", "operations", "servers", "x-ext"];
+  const separatelyMerged = /* @__PURE__ */ new Set(["info", "components", ...namedSections]);
+  const result = mergeNamed(
+    documents.map(
+      (document) => Object.fromEntries(
+        Object.entries(document).filter(([key]) => !separatelyMerged.has(key))
+      )
+    ),
+    "#"
+  );
+  result.info = Object.assign(
+    {},
+    ...[...documents].reverse().map((document) => document.info)
+  );
+  for (const section of namedSections) {
+    result[section] = mergeNamed(
+      documents.map((document) => document[section]),
+      `#/${section}`
+    );
+  }
+  const componentKinds = new Set(
+    documents.flatMap(
+      (document) => isDocument(document.components) ? Object.keys(document.components) : []
+    )
+  );
+  result.components = Object.fromEntries(
+    [...componentKinds].map((kind) => [
+      kind,
+      mergeNamed(
+        documents.map(
+          (document) => isDocument(document.components) ? document.components[kind] : void 0
+        ),
+        `#/components/${escapePointer(kind)}`
+      )
+    ])
+  );
+  return conflicts.length ? { ok: false, conflicts } : { ok: true, document: result };
+};
+
+// src/domains/document/join/action.ts
+var formatErrorMessage = (conflicts) => {
+  return conflicts.map((conflict) => {
+    if (conflict.type === "asyncapi")
+      return `AsyncAPI conflict at ${conflict.path}`;
+    if (conflict.type === "component") {
+      return `Component '/${conflict.componentType}/${conflict.name}' has conflicts`;
+    }
+    if (conflict.type === "path") {
+      return `Path '${conflict.path} ${conflict.method}' has conflicts`;
+    }
+    return `Webhook '${conflict.path} ${conflict.method}' has conflicts`;
+  });
+};
+async function joinAction(rawInput, rawOpt) {
+  const { error, data: input } = external_exports.array(external_exports.string()).safeParse(rawInput);
+  if (error) {
+    return output.error().title("Invalid input").message(error.issues[0].message).exit("error");
+  }
+  const { error: optsError, data: opts } = external_exports.object({
+    output: external_exports.string(),
+    prefixComponentsWithPathValue: external_exports.string().optional()
+  }).safeParse(rawOpt);
+  if (optsError) {
+    return output.error().title("Invalid options").line("").line(
+      optsError.issues.map((e) => `${e.message} property: '${e.path}'`).join("\n")
+    ).line("").exit("error");
+  }
+  const files = (await Promise.all(input.map((file) => fs.readFile(file, "utf-8")))).map((it) => {
+    const document = safeNormalize(it);
+    if (!isDocument(document)) {
+      return output.error().title("Invalid input").message(
+        "Could not read an API document from one of the input files. Please provide valid JSON or YAML files."
+      ).exit("error");
+    }
+    return document;
+  });
+  const asyncApiCount = files.filter(isAsyncApiDocument).length;
+  if (asyncApiCount > 0 && asyncApiCount !== files.length) {
+    return output.error().title("Cannot join OpenAPI and AsyncAPI documents together").exit("error");
+  }
+  const specification = asyncApiCount ? "AsyncAPI" : "OpenAPI";
+  const documents = asyncApiCount ? await Promise.all(
+    input.map(async (file) => {
+      const document = await bundle(path.resolve(file), {
+        plugins: [readFiles(), fetchUrls()],
+        treeShake: false
+      });
+      if (!isDocument(document)) {
+        return output.error().title("Invalid input").message(
+          "Could not read an API document from one of the input files. Please provide valid JSON or YAML files."
+        ).exit("error");
+      }
+      return document;
+    })
+  ) : files;
+  const prefixes = opts.prefixComponentsWithPathValue ? getPrefixes(files, opts.prefixComponentsWithPathValue) : [];
+  const { executionTimeMs, result } = await measureTime(
+    async () => asyncApiCount ? joinAsyncApi(documents, prefixes) : await join(files, { prefixComponents: prefixes })
+  );
+  if (!result.ok) {
+    return output.error().title(`Failed to join ${specification} documents`).line().line(`Conflicts:
+${formatErrorMessage(result.conflicts).join("\n")}`).line().exit("error");
+  }
+  const isYaml = isYamlFileName(opts.output);
+  await fs.writeFile(
+    opts.output,
+    isYaml ? import_yaml.default.stringify(result.document) : JSON.stringify(result.document, null, 2),
+    "utf8"
+  );
+  output.info().message(
+    `${as.green(`\u{1F91D} ${specification} Documents joined`)} in ${as.white(`${as.bold(`${Math.round(executionTimeMs)}`)} ms`)}`
+  ).print();
+}
+export {
+  joinAction
+};

package/chunks/{action-HD2T6BFJ.js → action-QPUSPD5M.js}

@@ -1,23 +1,23 @@
 import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
 import {
   getUserTeams
-} from "./chunk-ASMHW5AY.js";
+} from "./chunk-6ZMT63IV.js";
 import {
   getDatabaseClient
-} from "./chunk-SHSHFGA7.js";
-import "./chunk-B6QZJWCQ.js";
+} from "./chunk-Z2KMGFE6.js";
+import "./chunk-B2MHTD3R.js";
 import {
   getAuthData
-} from "./chunk-5BISXQX4.js";
-import "./chunk-OAXFCOJV.js";
-import "./chunk-4DGQIAJX.js";
-import "./chunk-ISGLWBXZ.js";
-import "./chunk-H2WRMLYY.js";
-import "./chunk-IX7LJ3AD.js";
+} from "./chunk-M37TP6U2.js";
+import "./chunk-4ZDQXWBT.js";
+import "./chunk-VNYE4R7N.js";
+import "./chunk-OQKDBLOZ.js";
+import "./chunk-4ORL4MST.js";
 import {
   output,
   printTable
-} from "./chunk-X4QLDBB5.js";
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-IKT5F47M.js";
 import "./chunk-3MZYUBJ6.js";
 
 // src/domains/team/list/action.ts

package/chunks/{action-45OGQB2M.js → action-R7IMFHQ5.js}

@@ -1,19 +1,24 @@
 import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
 import {
+  getFileOrUrl,
+  isAsyncApiContent,
   loadOpenApiFile,
   printSpecificationBanner
-} from "./chunk-23I5PKZZ.js";
+} from "./chunk-24WAOKGG.js";
 import {
   watchFile
-} from "./chunk-5BISXQX4.js";
-import "./chunk-OAXFCOJV.js";
-import "./chunk-4DGQIAJX.js";
-import "./chunk-ISGLWBXZ.js";
-import "./chunk-H2WRMLYY.js";
-import "./chunk-IX7LJ3AD.js";
+} from "./chunk-M37TP6U2.js";
+import "./chunk-4ZDQXWBT.js";
+import "./chunk-VNYE4R7N.js";
+import "./chunk-OQKDBLOZ.js";
+import "./chunk-CISTON3A.js";
+import "./chunk-Q7DOQHZN.js";
+import "./chunk-4ORL4MST.js";
 import {
   output
-} from "./chunk-X4QLDBB5.js";
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import "./chunk-IKT5F47M.js";
 import "./chunk-3MZYUBJ6.js";
 
 // src/domains/document/mock/action.ts
@@ -87,6 +92,10 @@ function getMethodColor(method) {
 
 // src/domains/document/mock/action.ts
 async function mockAction(fileArgument, { watch, once, port }) {
+  if (isAsyncApiContent(await getFileOrUrl(fileArgument))) {
+    const { mockAsyncApi } = await import("./asyncapi-QM76O55R.js");
+    return mockAsyncApi(fileArgument, { watch, once, port });
+  }
   let server;
   const result = await loadOpenApiFile(fileArgument);
   if (!result.valid) {

package/chunks/{action-UDZUUJSI.js → action-SH4UUXPL.js}

@@ -1,17 +1,23 @@
 import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
 import {
-  getFileOrUrl
-} from "./chunk-23I5PKZZ.js";
+  getFileOrUrl,
+  isDocument,
+  safeNormalize
+} from "./chunk-24WAOKGG.js";
 import {
   require_dist
 } from "./chunk-K74E42RV.js";
+import "./chunk-CISTON3A.js";
+import "./chunk-Q7DOQHZN.js";
 import {
   isUrl,
   isYamlFileName
-} from "./chunk-IX7LJ3AD.js";
+} from "./chunk-4ORL4MST.js";
 import {
   output
-} from "./chunk-X4QLDBB5.js";
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import "./chunk-IKT5F47M.js";
 import {
   __toESM
 } from "./chunk-3MZYUBJ6.js";
@@ -20,14 +26,19 @@ import {
 var import_yaml = __toESM(require_dist(), 1);
 import fs from "node:fs";
 import as from "ansis";
-import { normalize, toJson } from "@scalar/openapi-parser";
 async function formatAction(inputArgument, { output: outputPath }) {
   const startTime = performance.now();
   if (!inputArgument) {
     return output.error().title("Invalid argument").message("Please provide a file path").exit("error");
   }
-  const specification = await getFileOrUrl(inputArgument);
-  const newContent = isYamlFileName(outputPath || inputArgument) ? (0, import_yaml.stringify)(normalize(specification)) : toJson(normalize(specification));
+  const content = await getFileOrUrl(inputArgument);
+  const document = safeNormalize(content);
+  if (!isDocument(document)) {
+    return output.error().title("Invalid input").message(
+      "Could not read a document from the input. Please provide a valid JSON or YAML file."
+    ).exit("error");
+  }
+  const newContent = isYamlFileName(outputPath || inputArgument) ? (0, import_yaml.stringify)(document) : JSON.stringify(document, null, 2);
   if (outputPath) {
     fs.writeFileSync(outputPath, newContent, "utf8");
   } else if (!isUrl(inputArgument)) {

package/chunks/action-SNLCIBQC.js

@@ -0,0 +1,84 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  getFileOrUrl,
+  isAsyncApiContent
+} from "./chunk-24WAOKGG.js";
+import {
+  config
+} from "./chunk-4ZDQXWBT.js";
+import "./chunk-CISTON3A.js";
+import "./chunk-Q7DOQHZN.js";
+import "./chunk-4ORL4MST.js";
+import {
+  output
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import "./chunk-IKT5F47M.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/document/share/action.ts
+import as from "ansis";
+async function shareAction(fileArgument, { token }) {
+  if (!fileArgument) {
+    return output.error().title("Invalid argument").message("Please provide a file path").exit("error");
+  }
+  const content = await getFileOrUrl(fileArgument);
+  const specification = isAsyncApiContent(content) ? "AsyncAPI" : "OpenAPI";
+  const sandboxUrl = new URL(config.projects.sandbox);
+  const url = new URL("/api/share", sandboxUrl);
+  url.pathname = "/api/share";
+  if (token) {
+    url.searchParams.append("token", token);
+  }
+  return fetch(url.toString(), {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      content
+    })
+  }).then(async (response) => {
+    if (!response.ok)
+      throw new Error(`Sandbox returned HTTP ${response.status}`);
+    return response.json();
+  }).then((data) => {
+    if (data === null || typeof data !== "object" || Array.isArray(data)) {
+      throw new Error("Invalid sandbox response");
+    }
+    if (data.error || typeof data.id !== "string" || typeof data.token !== "string") {
+      throw new Error(data.message || "Invalid sandbox response");
+    }
+    const { id, token: newToken } = data;
+    const link = (pathname) => new URL(pathname, sandboxUrl).toString();
+    output.info().line(as.green.bold(`Your ${specification} file is public.`)).line().table(
+      [
+        [
+          `${as.green("\u279C")} ${as.white.bold("API Reference:")}`,
+          as.cyan(link(`/p/${id}`))
+        ],
+        [
+          `${as.grey("\u279C")} ${as.grey.bold("Editor:")}`,
+          as.cyan(link(`/e/${id}`))
+        ],
+        [],
+        [
+          `${as.grey("\u279C")} ${as.grey.bold(`${specification} JSON:`)}`,
+          as.cyan(link(`/files/${id}/openapi.json`))
+        ],
+        [
+          `${as.grey("\u279C")} ${as.grey.bold(`${specification} YAML:`)}`,
+          as.cyan(link(`/files/${id}/openapi.yaml`))
+        ]
+      ],
+      { padding: 1 }
+    ).line().line("Use the token to update the existing sandbox:").line().line(
+      `${as.grey("$")} ${as.white.bold("scalar document share --token=")}${as.cyan.bold(`${newToken}`)} `
+    ).line().print();
+  }).catch((error) => {
+    output.error().title("Failed to share the file.").message(`Details: ${error}`).exit("error");
+  });
+}
+export {
+  shareAction
+};

package/chunks/{action-C5VB4ITT.js → action-SQG3JAII.js}

@@ -1,38 +1,38 @@
 import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
 import {
   downloadIsolate
-} from "./chunk-TQ5XC2E3.js";
+} from "./chunk-LFU5ZUAP.js";
+import "./chunk-3ZJYGGAA.js";
 import {
   readAndParseConfig,
   renderConfigError
-} from "./chunk-P2VH7DOC.js";
+} from "./chunk-7AGLC7WV.js";
 import {
   CONFIG_FILE_DEFAULT,
   findConfig
-} from "./chunk-47Y4L5IT.js";
+} from "./chunk-PBXZN65A.js";
 import {
   ISOLATE_DIR
-} from "./chunk-KWOL7A6J.js";
-import "./chunk-5BPPGTUU.js";
-import "./chunk-4QS7SJTG.js";
-import "./chunk-VTYTPSXO.js";
+} from "./chunk-X5T526CE.js";
 import {
   getAuthData
-} from "./chunk-5BISXQX4.js";
+} from "./chunk-M37TP6U2.js";
 import {
   config
-} from "./chunk-OAXFCOJV.js";
-import "./chunk-TLFMATXR.js";
-import "./chunk-4DGQIAJX.js";
+} from "./chunk-4ZDQXWBT.js";
+import "./chunk-VNYE4R7N.js";
 import {
   ConfigVersion
-} from "./chunk-ISGLWBXZ.js";
-import "./chunk-H2WRMLYY.js";
+} from "./chunk-OQKDBLOZ.js";
 import "./chunk-K74E42RV.js";
-import "./chunk-IX7LJ3AD.js";
+import "./chunk-CISTON3A.js";
+import "./chunk-Q7DOQHZN.js";
+import "./chunk-4ORL4MST.js";
 import {
   output
-} from "./chunk-X4QLDBB5.js";
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import "./chunk-IKT5F47M.js";
 import "./chunk-3MZYUBJ6.js";
 
 // src/domains/project/preview/action.ts
@@ -43,13 +43,31 @@ import as from "ansis";
 import { spawn } from "node:child_process";
 import path from "node:path";
 async function runIsolate(isolateOptions) {
-  const child = spawn("node", ["dist/isolate-entry.js"], { cwd: ISOLATE_DIR });
+  const executable = process.env.SCALAR_CLI_DISTRIBUTION === "portable" ? path.join(
+    path.dirname(process.execPath),
+    "runtime",
+    process.platform === "win32" ? "node.exe" : "node"
+  ) : process.execPath;
+  const child = spawn(executable, ["dist/isolate-entry.js"], {
+    cwd: ISOLATE_DIR,
+    env: {
+      ...process.env,
+      PATH: `${path.dirname(executable)}${path.delimiter}${process.env.PATH ?? ""}`
+    }
+  });
   child.stdin.write(JSON.stringify(isolateOptions));
   child.stdin.end();
   child.stdout.pipe(process.stdout);
   child.stderr.pipe(process.stderr);
-  child.on("close", (code) => {
-    console.log(`Process exited with code ${code}.`);
+  child.on("error", (error) => {
+    console.error(`Could not start docs preview: ${error.message}`);
+    process.exitCode = 1;
+  });
+  child.on("close", (code, signal) => {
+    console.log(
+      `Process exited with code ${code}${signal ? ` (signal ${signal})` : ""}.`
+    );
+    process.exitCode = code ?? 1;
   });
 }
 async function getAccessToken() {

package/chunks/action-UZQJNYK4.js

@@ -0,0 +1,18 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  IsolateDownloadError,
+  downloadIsolate,
+  isDiskWriteError,
+  updateIsolate
+} from "./chunk-LFU5ZUAP.js";
+import "./chunk-3ZJYGGAA.js";
+import "./chunk-X5T526CE.js";
+import "./chunk-4ZDQXWBT.js";
+import "./chunk-T5HJUAWB.js";
+import "./chunk-3MZYUBJ6.js";
+export {
+  IsolateDownloadError,
+  downloadIsolate,
+  isDiskWriteError,
+  updateIsolate
+};

package/chunks/{action-HNKM3Q65.js → action-VC4DCVST.js}

@@ -1,22 +1,25 @@
 import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
 import {
   apiService
-} from "./chunk-SXYALPYK.js";
-import "./chunk-UPUTMFD4.js";
-import "./chunk-B6QZJWCQ.js";
-import "./chunk-P646T2WH.js";
-import "./chunk-4QS7SJTG.js";
-import "./chunk-VTYTPSXO.js";
-import "./chunk-5BISXQX4.js";
-import "./chunk-OAXFCOJV.js";
-import "./chunk-TLFMATXR.js";
-import "./chunk-4DGQIAJX.js";
-import "./chunk-ISGLWBXZ.js";
-import "./chunk-H2WRMLYY.js";
-import "./chunk-IX7LJ3AD.js";
+} from "./chunk-AO3F5XWR.js";
+import "./chunk-HCPN3KNF.js";
+import "./chunk-B2MHTD3R.js";
+import "./chunk-3L6DLIXJ.js";
+import "./chunk-P7H7GY5A.js";
+import "./chunk-HPL3ZZ2P.js";
+import "./chunk-M37TP6U2.js";
+import "./chunk-4ZDQXWBT.js";
+import "./chunk-VNYE4R7N.js";
+import "./chunk-OQKDBLOZ.js";
+import "./chunk-K74E42RV.js";
+import "./chunk-CISTON3A.js";
+import "./chunk-Q7DOQHZN.js";
+import "./chunk-4ORL4MST.js";
 import {
   output
-} from "./chunk-X4QLDBB5.js";
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import "./chunk-IKT5F47M.js";
 import "./chunk-3MZYUBJ6.js";
 
 // src/domains/project/create/action.ts