@scalar/cli 2.0.1 → 2.1.0

package/chunks/chunk-X4QLDBB5.js

@@ -0,0 +1,221 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+
+// src/helpers/std-out/print-table.ts
+import { Table } from "console-table-printer";
+var printTable = (columns, rows) => {
+  const table2 = new Table({ columns });
+  for (const row of rows) {
+    table2.addRow(row);
+  }
+  table2.printTable();
+};
+
+// src/helpers/std-out/output.ts
+import as from "ansis";
+import UpdateManager from "stdout-update";
+
+// ../../node_modules/.pnpm/ansi-regex@6.2.2/node_modules/ansi-regex/index.js
+function ansiRegex({ onlyFirst = false } = {}) {
+  const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
+  const osc = `(?:\\u001B\\][\\s\\S]*?${ST})`;
+  const csi = "[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]";
+  const pattern = `${osc}|${csi}`;
+  return new RegExp(pattern, onlyFirst ? void 0 : "g");
+}
+
+// ../../node_modules/.pnpm/strip-ansi@7.2.0/node_modules/strip-ansi/index.js
+var regex = ansiRegex();
+function stripAnsi(string) {
+  if (typeof string !== "string") {
+    throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
+  }
+  if (!string.includes("\x1B") && !string.includes("\x9B")) {
+    return string;
+  }
+  return string.replace(regex, "");
+}
+
+// src/helpers/std-out/table.ts
+var table = (data, options) => {
+  let maxCols = 0;
+  data.forEach((row) => {
+    if (row.length > maxCols) {
+      maxCols = row.length;
+    }
+  });
+  const maxLengths = new Array(maxCols).fill(0);
+  for (const i of data.keys()) {
+    for (const j of data[i].keys()) {
+      if (stripAnsi(data[i][j]).length > maxLengths[j]) {
+        maxLengths[j] = stripAnsi(data[i][j]).length;
+      }
+    }
+  }
+  for (const row of data) {
+    for (const [index, col] of row.entries()) {
+      const lengthDiff = col.length - stripAnsi(col).length;
+      row[index] = col.padEnd(
+        maxLengths[index] + (options?.padding ?? 1) + lengthDiff
+      );
+    }
+  }
+};
+
+// src/helpers/std-out/output.ts
+var levelColors = {
+  info: (s) => s,
+  warn: as.yellow,
+  error: as.red
+};
+var levelPrefixes = {
+  info: "",
+  warn: "[WARN]",
+  error: "[ERROR]"
+};
+var outputFactory = (level) => (options) => {
+  const titlePrefix = levelPrefixes[level];
+  const cl = levelColors[level];
+  const manager = UpdateManager.getInstance();
+  const state = [];
+  let i = 0;
+  const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  function update(complete) {
+    i += 1;
+    manager.update(
+      state.map((it) => {
+        if (it.type === "title") {
+          return cl(as.bold(`${titlePrefix} ${it.content}`));
+        }
+        if (it.type === "loader") {
+          return complete ? cl(`\u2714 ${it.content}`) : cl(`${frames[i % frames.length]} ${it.content}`);
+        }
+        if (it.type === "table") {
+          return it.content.map((it2) => cl(it2.join(""))).join("\n");
+        }
+        return cl(it.content);
+      })
+    );
+  }
+  manager.hook();
+  const interval = setInterval(() => {
+    update();
+  }, options?.frameRate ?? 100);
+  function end() {
+    update(true);
+    process.stdout.write("");
+    manager.unhook();
+    clearInterval(interval);
+    return { state };
+  }
+  return {
+    /** Current list of std-out state objects */
+    state,
+    /** Display a formatted title */
+    title: function(title) {
+      state.push({
+        type: "title",
+        content: title
+      });
+      return this;
+    },
+    /** Display a new line with the provided content */
+    line: function(content) {
+      state.push({
+        type: "line",
+        content: content ?? ""
+      });
+      return this;
+    },
+    /** Display a message with a line above and below */
+    message: function(content) {
+      state.push(
+        {
+          type: "line",
+          content: ""
+        },
+        {
+          type: "line",
+          content: content ?? ""
+        },
+        {
+          type: "line",
+          content: ""
+        }
+      );
+      return this;
+    },
+    /** Display a loader with a message alongside. */
+    loader: function(content) {
+      state.push({
+        type: "loader",
+        content: content ?? ""
+      });
+      return this;
+    },
+    /**
+     * Update a specific line of a specific type
+     * Only works when animate is set to true
+     */
+    update: function(type, index, values) {
+      const operation = state.filter((it) => it.type === type)[index];
+      if (operation) {
+        Object.assign(operation, values);
+      }
+      if (operation.type === "table") {
+        table(operation.content, operation.options);
+      }
+      return this;
+    },
+    /**
+     * Delete a specific line of a specific type
+     * Only works when the animate is set to true
+     */
+    delete: function(type, index) {
+      let count = 0;
+      for (let i2 = 0; i2 < state.length; i2++) {
+        if (state[i2].type === type) {
+          if (count === index) {
+            state.splice(i2, 1);
+            return;
+          }
+          count++;
+        }
+      }
+      return this;
+    },
+    /** Display a table that handles padding column widths automatically */
+    table: function(data, opt) {
+      table(data, opt);
+      state.push({
+        type: "table",
+        content: data,
+        options: opt
+      });
+      return this;
+    },
+    /** Print the current state to the console */
+    print: end,
+    /**
+     * Finish a log block and unhook from the std-out manager
+     * This closes out a running animation
+     */
+    finish: end,
+    /** Exit the process with a success code */
+    exit: (code) => {
+      end();
+      return process.exit(code === "error" ? 1 : 0);
+    }
+  };
+};
+
+// src/helpers/std-out/index.ts
+var output = {
+  error: outputFactory("error"),
+  warn: outputFactory("warn"),
+  info: outputFactory("info")
+};
+
+export {
+  printTable,
+  output
+};

package/chunks/chunk-ZTVWAKNJ.js

@@ -0,0 +1,21 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  getPublishPreviewUrl,
+  getPublishUrl
+} from "./chunk-DOVIWNKQ.js";
+
+// src/domains/project/publish/url.ts
+function getPublishDeploymentUrl(publish) {
+  try {
+    if (publish.preview) {
+      return getPublishPreviewUrl(publish.uid, publish.domain, publish.subpath);
+    }
+    return getPublishUrl(publish.domain, publish.subpath);
+  } catch {
+    return null;
+  }
+}
+
+export {
+  getPublishDeploymentUrl
+};

package/chunks/create.action-FFQLBSJH.js

@@ -0,0 +1,108 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  apiService
+} from "./chunk-SXYALPYK.js";
+import {
+  BaseCollections
+} from "./chunk-2BSG2QHO.js";
+import {
+  getDatabaseClient
+} from "./chunk-SHSHFGA7.js";
+import "./chunk-UPUTMFD4.js";
+import "./chunk-B6QZJWCQ.js";
+import {
+  SdkLanguage
+} from "./chunk-5BPPGTUU.js";
+import "./chunk-P646T2WH.js";
+import "./chunk-4QS7SJTG.js";
+import "./chunk-VTYTPSXO.js";
+import {
+  getAuthData
+} from "./chunk-5BISXQX4.js";
+import {
+  config
+} from "./chunk-OAXFCOJV.js";
+import "./chunk-TLFMATXR.js";
+import {
+  teamSchema
+} from "./chunk-4DGQIAJX.js";
+import {
+  namespaceSchema,
+  slugSchema
+} from "./chunk-ISGLWBXZ.js";
+import {
+  external_exports
+} from "./chunk-H2WRMLYY.js";
+import "./chunk-K74E42RV.js";
+import "./chunk-IX7LJ3AD.js";
+import {
+  output
+} from "./chunk-X4QLDBB5.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/sdk/create.action.ts
+import { select, text } from "@clack/prompts";
+import as from "ansis";
+async function createAction(opts) {
+  const { error, data } = external_exports.object({
+    namespace: namespaceSchema.optional(),
+    language: external_exports.enum(SdkLanguage).optional(),
+    api: slugSchema.optional()
+  }).safeParse(opts);
+  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 db = await getDatabaseClient();
+  const client = await apiService();
+  const language = opts.language || await text({
+    message: "Please choose a language for your SDK",
+    placeholder: "typescript",
+    validate: (v) => {
+      return external_exports.enum(SdkLanguage).safeParse(v)?.error ? "Please select a valid language" : void 0;
+    },
+    defaultValue: void 0
+  });
+  const team = await db.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 namespaceApisRes = await client.managedDocs.getApiDocs(namespace);
+  if (namespaceApisRes.error)
+    return output.error().title(namespaceApisRes.message).exit("error");
+  const apiUid = namespaceApisRes.data.find((api) => api.slug === data.api)?.uid || await select({
+    message: "Please select an API",
+    options: namespaceApisRes.data.map((api) => ({
+      value: api.uid,
+      label: api.slug
+    }))
+  });
+  if (!apiUid) {
+    return output.error().title("No API found").message("Please provide a valid API slug").exit("error");
+  }
+  const logger = output.info().loader("Creating the SDK");
+  const response = await client.sdks.create({
+    apiUid,
+    languages: [language]
+  });
+  if (response.error) {
+    return output.error().title("Something went wrong").message(response.message).exit("error");
+  }
+  logger.update("loader", 0, { content: "SDK created successfully!" });
+  const dashboardUrl = `${config.projects.dashboard}/sdk/${response.data}`;
+  logger.message(`View your SDK in the Scalar dashboard: ${as.cyan(dashboardUrl)}`).exit("success");
+}
+export {
+  createAction
+};

package/chunks/delete.action-QNN3LC2F.js

@@ -0,0 +1,96 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  apiService
+} from "./chunk-SXYALPYK.js";
+import {
+  BaseCollections
+} from "./chunk-2BSG2QHO.js";
+import {
+  getDatabaseClient
+} from "./chunk-SHSHFGA7.js";
+import "./chunk-UPUTMFD4.js";
+import "./chunk-B6QZJWCQ.js";
+import {
+  sdkSchema
+} from "./chunk-5BPPGTUU.js";
+import "./chunk-P646T2WH.js";
+import "./chunk-4QS7SJTG.js";
+import "./chunk-VTYTPSXO.js";
+import {
+  getAuthData
+} from "./chunk-5BISXQX4.js";
+import "./chunk-OAXFCOJV.js";
+import "./chunk-TLFMATXR.js";
+import {
+  teamSchema
+} from "./chunk-4DGQIAJX.js";
+import {
+  namespaceSchema,
+  slugSchema
+} from "./chunk-ISGLWBXZ.js";
+import {
+  external_exports
+} from "./chunk-H2WRMLYY.js";
+import "./chunk-K74E42RV.js";
+import "./chunk-IX7LJ3AD.js";
+import {
+  output
+} from "./chunk-X4QLDBB5.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/sdk/delete.action.ts
+import { select } from "@clack/prompts";
+async function deleteAction(opts) {
+  const { error, data } = external_exports.object({
+    slug: slugSchema.optional(),
+    namespace: namespaceSchema.optional()
+  }).safeParse(opts);
+  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 db = await getDatabaseClient();
+  const client = await apiService();
+  const team = await db.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 SDK. Please specify a namespace or contact support."
+    ).exit("error");
+  }
+  const sdks = await db.getMany({
+    collectionPath: BaseCollections.Sdks(team.data.uid),
+    query: {
+      namespace
+    },
+    schema: sdkSchema.array()
+  });
+  if (sdks.error) return output.error().title(sdks.message).exit("error");
+  const sdkUid = sdks.data.find((sdk) => sdk.slug === data.slug)?.uid || await select({
+    message: "Please select an SDK to delete",
+    options: sdks.data.map((sdk) => ({
+      value: sdk.uid,
+      label: sdk.slug
+    }))
+  });
+  if (!sdkUid) {
+    return output.error().title("No SDK found").message("Please provide a valid SDK slug").exit("error");
+  }
+  const logger = output.info().loader("Deleting the SDK");
+  const response = await client.sdks.delete(sdkUid);
+  if (response.error) {
+    return output.error().title("Something went wrong").message(response.message).exit("error");
+  }
+  logger.update("loader", 0, { content: "SDK deleted successfully!" }).exit("success");
+}
+export {
+  deleteAction
+};

package/chunks/delete.action-STHQHP4F.js

@@ -0,0 +1,88 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  apiService
+} from "./chunk-SXYALPYK.js";
+import {
+  BaseCollections
+} from "./chunk-2BSG2QHO.js";
+import {
+  getDatabaseClient
+} from "./chunk-SHSHFGA7.js";
+import "./chunk-UPUTMFD4.js";
+import "./chunk-B6QZJWCQ.js";
+import "./chunk-5BPPGTUU.js";
+import "./chunk-P646T2WH.js";
+import "./chunk-4QS7SJTG.js";
+import "./chunk-VTYTPSXO.js";
+import {
+  getAuthData
+} from "./chunk-5BISXQX4.js";
+import "./chunk-OAXFCOJV.js";
+import "./chunk-TLFMATXR.js";
+import {
+  teamSchema
+} from "./chunk-4DGQIAJX.js";
+import {
+  namespaceSchema,
+  slugSchema
+} from "./chunk-ISGLWBXZ.js";
+import {
+  external_exports
+} from "./chunk-H2WRMLYY.js";
+import "./chunk-K74E42RV.js";
+import "./chunk-IX7LJ3AD.js";
+import {
+  output
+} from "./chunk-X4QLDBB5.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/schema/delete.action.ts
+import { select } from "@clack/prompts";
+async function deleteAction(opts) {
+  const { error, data } = external_exports.object({
+    slug: slugSchema.optional(),
+    namespace: namespaceSchema.optional()
+  }).safeParse(opts);
+  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 db = await getDatabaseClient();
+  const client = await apiService();
+  const team = await db.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 schema. Please specify a namespace or contact support."
+    ).exit("error");
+  }
+  const schemas = await client.managedSchemas.getSchemas(namespace);
+  if (schemas.error) return output.error().title(schemas.message).exit("error");
+  const schemaSlug = schemas.data.find((schema) => schema.slug === data.slug)?.slug || await select({
+    message: "Please select a schema to delete",
+    options: schemas.data.map((schema) => ({
+      value: schema.slug,
+      label: schema.slug
+    }))
+  });
+  if (!schemaSlug) {
+    return output.error().title("No schema found").message("Please provide a valid schema slug").exit("error");
+  }
+  const logger = output.info().loader("Deleting the schema");
+  const response = await client.managedSchemas.delete(namespace, schemaSlug);
+  if (response.error) {
+    return output.error().title("Something went wrong").message(response.message).exit("error");
+  }
+  logger.update("loader", 0, { content: "Schema deleted successfully!" }).exit("success");
+}
+export {
+  deleteAction
+};

package/chunks/get.action-OTKYOP3Z.js

@@ -0,0 +1,87 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  fetchFromRegistry
+} from "./chunk-NUXPNUSS.js";
+import "./chunk-T7MDADON.js";
+import {
+  registry
+} from "./chunk-DOVIWNKQ.js";
+import "./chunk-4QS7SJTG.js";
+import "./chunk-VTYTPSXO.js";
+import {
+  getAuthData
+} from "./chunk-5BISXQX4.js";
+import "./chunk-OAXFCOJV.js";
+import "./chunk-TLFMATXR.js";
+import "./chunk-4DGQIAJX.js";
+import {
+  docVersionSchema
+} from "./chunk-ISGLWBXZ.js";
+import {
+  external_exports
+} from "./chunk-H2WRMLYY.js";
+import "./chunk-IX7LJ3AD.js";
+import {
+  output
+} from "./chunk-X4QLDBB5.js";
+import "./chunk-3MZYUBJ6.js";
+
+// src/domains/schema/get.action.ts
+import fs from "node:fs/promises";
+var versionSchema = external_exports.union([docVersionSchema, external_exports.literal("latest")]);
+async function getAction(namespace, slug, args) {
+  if (!namespace) {
+    output.error().title("Invalid input").message("Please provide namespace of the schema").exit("error");
+    return;
+  }
+  if (!slug) {
+    output.error().title("Invalid input").message("Please provide slug of the schema").exit("error");
+    return;
+  }
+  const result = external_exports.object({
+    version: versionSchema,
+    format: external_exports.enum(["json", "yaml"]),
+    output: external_exports.string().min(1).optional()
+  }).safeParse({
+    version: args.version ?? "latest",
+    format: args.format,
+    output: args.output
+  });
+  if (result.error) {
+    output.error().title("Invalid input").message(result.error.issues[0].message).exit("error");
+    return;
+  }
+  const auth = await getAuthData();
+  auth.addEventListener((state) => Object.assign(auth, state));
+  const fetchResult = await fetchFromRegistry(
+    registry(namespace).schemas(slug).url({
+      version: result.data.version,
+      format: result.data.format
+    }),
+    auth.accessToken
+  );
+  if (fetchResult.error) {
+    output.error().title("Unable to download schema").message(fetchResult.message).exit("error");
+    return;
+  }
+  const document = fetchResult.data;
+  const withTrailingNewline = document.endsWith("\n") ? document : `${document}
+`;
+  if (result.data.output) {
+    try {
+      await fs.writeFile(result.data.output, withTrailingNewline, "utf8");
+    } catch (error) {
+      const message = error instanceof Error && error.message.length > 0 ? error.message : `Could not write to ${result.data.output}.`;
+      output.error().title("Unable to write schema to file").message(message).exit("error");
+      return;
+    }
+    output.info().line(
+      `Downloaded ${namespace}/${slug}@${result.data.version} (${result.data.format})`
+    ).line(`Written to ${result.data.output}`).print();
+    return;
+  }
+  process.stdout.write(withTrailingNewline);
+}
+export {
+  getAction
+};