@scalar/cli 2.0.1 → 2.5.1

package/chunks/action-MSLBC2SO.js

@@ -0,0 +1,92 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  apiService
+} from "./chunk-AO3F5XWR.js";
+import {
+  BaseCollections
+} from "./chunk-F467BYYR.js";
+import {
+  getDatabaseClient
+} from "./chunk-Z2KMGFE6.js";
+import "./chunk-HCPN3KNF.js";
+import "./chunk-B2MHTD3R.js";
+import "./chunk-3L6DLIXJ.js";
+import "./chunk-P7H7GY5A.js";
+import "./chunk-HPL3ZZ2P.js";
+import {
+  getAuthData
+} from "./chunk-M37TP6U2.js";
+import "./chunk-4ZDQXWBT.js";
+import {
+  teamSchema
+} from "./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,
+  printTable
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import {
+  external_exports,
+  namespaceSchema
+} from "./chunk-IKT5F47M.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/registry/list/action.ts
+import as from "ansis";
+async function listAction(args) {
+  const { error, data } = external_exports.object({
+    namespace: namespaceSchema.optional()
+  }).safeParse({
+    namespace: args.namespace
+  });
+  if (error)
+    return output.error().title("Invalid input").message(error.issues[0].message).exit("error");
+  const auth = await getAuthData();
+  auth.addEventListener((state) => Object.assign(auth, state));
+  const client = await getDatabaseClient();
+  const team = await client.getOne({
+    collectionPath: BaseCollections.Teams,
+    query: {
+      uid: auth.teamUid
+    },
+    schema: teamSchema
+  });
+  if (team.error)
+    return output.error().title("An error occurred when fetching your team.").message(team.message).exit("error");
+  const namespace = data.namespace || team.data.namespaces.at(0);
+  if (!namespace) {
+    return output.error().title("Missing namespace").message(
+      "Could not find a valid namespace for your API. Please specify a namespace or contact support."
+    ).exit("error");
+  }
+  const apiClient = await apiService();
+  const listApisRes = await apiClient.managedDocs.getApiDocs(namespace);
+  if (listApisRes.error)
+    return output.error().title(listApisRes.message).exit("error");
+  if (listApisRes.data.length === 0) {
+    output.info().title(`No registry APIs found for namespace "${namespace}".`).print();
+    return;
+  }
+  printTable(
+    [
+      { name: "title", title: "Title", alignment: "left", maxLen: 40 },
+      { name: "name", title: "Name", alignment: "left", color: "blue" },
+      { name: "version", title: "Version", alignment: "left" },
+      { name: "access", title: "Access", alignment: "left" }
+    ],
+    listApisRes.data.map((api) => ({
+      title: api.title || as.dim("\u2014"),
+      name: `@${api.namespace}/${api.slug}`,
+      version: api.version,
+      access: api.isPrivate ? as.green("Private") : as.yellow("Public")
+    }))
+  );
+}
+export {
+  listAction
+};

package/chunks/action-NVSZT2ZD.js

@@ -0,0 +1,37 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  readAndParseConfig,
+  renderConfigError
+} from "./chunk-7AGLC7WV.js";
+import "./chunk-PBXZN65A.js";
+import "./chunk-OQKDBLOZ.js";
+import "./chunk-K74E42RV.js";
+import "./chunk-CISTON3A.js";
+import "./chunk-Q7DOQHZN.js";
+import {
+  output
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import "./chunk-IKT5F47M.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/project/check-config/action.ts
+import as from "ansis";
+async function checkConfigAction(inputArgument) {
+  const result = readAndParseConfig(inputArgument);
+  if (result.success) {
+    output.info().line(
+      `${as.green("[SUCCESS]")} ${as.green("The Scalar Configuration is valid:")} ${as.green(result.filePath)}`
+    ).line(
+      `${as.green("Scalar Configuration validated")} ${as.grey(
+        `in ${as.white.bold(`${result.validationTime} ms`)}`
+      )}
+`
+    ).print();
+  } else {
+    renderConfigError(result.error);
+  }
+}
+export {
+  checkConfigAction
+};

package/chunks/action-OGQSTRMX.js

@@ -0,0 +1,37 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  apiService
+} 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-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import "./chunk-IKT5F47M.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/registry/delete/action.ts
+async function deleteAction(namespace, slug) {
+  const client = await apiService();
+  const logger = output.info().line().loader("Deleting the api document");
+  const deleteDocument = await client.managedDocs.delete(namespace, slug);
+  if (deleteDocument.error) {
+    return output.error().title(deleteDocument.message).exit("error");
+  }
+  logger.update("loader", 0, { content: "Successfully deleted document." }).print();
+}
+export {
+  deleteAction
+};

package/chunks/action-PAGJ5PWC.js

@@ -0,0 +1,60 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  getUserTeams
+} from "./chunk-6ZMT63IV.js";
+import {
+  getDatabaseClient
+} from "./chunk-Z2KMGFE6.js";
+import "./chunk-B2MHTD3R.js";
+import {
+  getAuthData,
+  refreshToken
+} from "./chunk-M37TP6U2.js";
+import "./chunk-4ZDQXWBT.js";
+import "./chunk-VNYE4R7N.js";
+import "./chunk-OQKDBLOZ.js";
+import "./chunk-4ORL4MST.js";
+import {
+  output
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-IKT5F47M.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/team/set/action.ts
+import { select } from "@clack/prompts";
+import as from "ansis";
+async function setAction({ team }) {
+  const auth = await getAuthData();
+  auth.addEventListener((state) => Object.assign(auth, state));
+  if (!("refreshToken" in auth)) {
+    return output.error().title("Unsupported operation").message(
+      "You can not change the selected team because you are using a personal token, which is related to a specific team. \nTo be able to perform actions on other teams you need to generate a new personal token and login with the new token."
+    ).exit("error");
+  }
+  const client = await getDatabaseClient();
+  const userTeams = await getUserTeams(client, auth.email ?? "");
+  if (userTeams.error) {
+    return output.error().title("An error occurred while getting list of teams.").exit("error");
+  }
+  let teamValue = team;
+  if (!teamValue) {
+    teamValue = await select({
+      message: "Please select one of the teams",
+      options: userTeams.data.map((it) => ({
+        value: it.teamUid,
+        label: it.teamName
+      }))
+    });
+  }
+  const selectedTeam = userTeams.data.find((it) => it.teamUid === teamValue);
+  if (!selectedTeam) {
+    return output.error().title("Invalid team").message("Please choose a valid team id").exit("error");
+  }
+  await refreshToken(auth.refreshToken, teamValue);
+  output.info().message(
+    `Operation ${as.green("successful")}. Selected team: ${as.cyan(selectedTeam.teamName)}`
+  ).print();
+}
+export {
+  setAction
+};

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-QPUSPD5M.js

@@ -0,0 +1,54 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  getUserTeams
+} from "./chunk-6ZMT63IV.js";
+import {
+  getDatabaseClient
+} from "./chunk-Z2KMGFE6.js";
+import "./chunk-B2MHTD3R.js";
+import {
+  getAuthData
+} 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-T5HJUAWB.js";
+import "./chunk-IKT5F47M.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/team/list/action.ts
+import as from "ansis";
+async function listAction() {
+  const auth = await getAuthData();
+  auth.addEventListener((state) => Object.assign(auth, state));
+  const client = await getDatabaseClient();
+  const teams = await getUserTeams(client, auth.email ?? "default email");
+  if (teams.error) {
+    return output.error().title("An error occurred while getting list of teams.").exit("error");
+  }
+  if (teams.data.length === 0) {
+    output.info().title("You are not part of any teams.").print();
+    return;
+  }
+  printTable(
+    [
+      { name: "current", title: " ", alignment: "center" },
+      { name: "team", title: "Team", alignment: "left" }
+    ],
+    teams.data.map((it) => {
+      const isCurrentTeam = it.teamUid === auth.teamUid;
+      const color = isCurrentTeam ? as.green : as.blue;
+      return {
+        current: isCurrentTeam ? color("\u279C") : " ",
+        team: isCurrentTeam ? color(`${it.teamName} (default)`) : color(it.teamName)
+      };
+    })
+  );
+}
+export {
+  listAction
+};

package/chunks/action-R7IMFHQ5.js

@@ -0,0 +1,147 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  getFileOrUrl,
+  isAsyncApiContent,
+  loadOpenApiFile,
+  printSpecificationBanner
+} from "./chunk-24WAOKGG.js";
+import {
+  watchFile
+} 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-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import "./chunk-IKT5F47M.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/document/mock/action.ts
+import as2 from "ansis";
+
+// src/domains/document/mock/helpers.ts
+import { serve } from "@hono/node-server";
+import as from "ansis";
+import { createMockServer } from "@scalar/mock-server";
+var bootServer = async ({
+  specification,
+  port
+}) => {
+  const app = await createMockServer({
+    specification,
+    onRequest
+  });
+  return serve(
+    {
+      fetch: app.fetch,
+      port: port ?? 3e3
+    },
+    (info) => {
+      output.info().message(
+        `${as.green.bold("\u279C Mock Server")} ${as.white(
+          "listening on"
+        )} ${as.cyan(`http://localhost:${info.port}`)}`
+      ).print();
+    }
+  );
+};
+var printAvailablePaths = (specification) => {
+  output.info().message(as.white.bold("Available Paths")).print();
+  if (specification?.paths === void 0 || Object.keys(specification?.paths).length === 0) {
+    output.warn().title(as.grey("Could not find any paths in the OpenAPI file.")).print();
+  }
+  for (const path in specification?.paths ?? []) {
+    if (specification?.paths?.[path] === void 0) {
+      continue;
+    }
+    for (const method in specification.paths[path]) {
+      if (specification.paths[path][method] === void 0) {
+        continue;
+      }
+      output.info().line(
+        `${as[getMethodColor(method)].bold(method.toUpperCase().padEnd(6))} ${as.grey(`${path}`)}`
+      ).print();
+    }
+  }
+  output.info().line().print();
+};
+var onRequest = ({
+  context,
+  operation
+}) => {
+  const { method } = context.req;
+  output.info().line(
+    `${as[getMethodColor(method)].bold(method.toUpperCase().padEnd(6))} ${as.grey(`${context.req.path}`)} ${as.grey("\u2192")} ${operation?.operationId ? as.white(operation.operationId) : as.red("[ERROR] 404 Not Found")}`
+  ).print();
+};
+function getMethodColor(method) {
+  const colors = {
+    get: "green",
+    post: "cyan",
+    put: "yellow",
+    delete: "red",
+    patch: "magenta"
+  };
+  return colors[method.toLowerCase()] ?? "grey";
+}
+
+// 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) {
+    return output.error().title("Invalid OpenAPI document").exit("error");
+  }
+  printSpecificationBanner({
+    version: result.version,
+    schema: result.schema
+  });
+  let { specification } = result;
+  if (watch) {
+    await watchFile(fileArgument, async () => {
+      const newResult = await loadOpenApiFile(fileArgument);
+      const specificationHasChanged = newResult?.specification && JSON.stringify(specification) !== JSON.stringify(newResult.specification);
+      if (specificationHasChanged && newResult.valid) {
+        output.info().title(as2.grey("OpenAPI file modified")).print();
+        printSpecificationBanner({
+          version: newResult.version,
+          schema: newResult.schema
+        });
+        specification = newResult.specification;
+        if (specification) {
+          server.close();
+          server = await bootServer({
+            specification,
+            port
+          });
+        }
+      }
+    });
+  }
+  if (!specification) {
+    output.warn().title("Could not find any paths in the OpenAPI file.").print();
+    return;
+  }
+  printAvailablePaths(specification);
+  server = await bootServer({
+    specification,
+    port
+  });
+  if (once) {
+    setTimeout(() => {
+      server.close();
+    }, 2e3);
+  }
+}
+export {
+  mockAction
+};