@scalar/cli 2.0.1 → 2.5.1

package/chunks/chunk-XCSR4RIT.js

@@ -0,0 +1,210 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  RegistryAsset
+} from "./chunk-CISTON3A.js";
+import {
+  contentShaSchema
+} from "./chunk-Q7DOQHZN.js";
+import {
+  docVersionSchema,
+  external_exports,
+  namespaceSchema
+} from "./chunk-IKT5F47M.js";
+
+// ../../packages/urls/dist/registry/path-generators.js
+function versionFormat(version) {
+  if (!version || version === "latest")
+    return "latest";
+  return docVersionSchema.parse(version);
+}
+function filetypeFormat(filetype) {
+  return filetype ? external_exports.enum(["yaml", "json", "zip"]).parse(filetype) : "yaml";
+}
+function registryFormat(format) {
+  return external_exports.enum(["yaml", "json", "preview"]).parse(format);
+}
+var pagesSha = (sha) => contentShaSchema.parse(sha);
+var pageChunkFile = (entryId) => {
+  const id = external_exports.string().min(1, "Page chunk entry id must not be empty").parse(entryId);
+  return `${encodeURIComponent(id)}.json`;
+};
+var MAX_OBJECT_NAME_BYTES = 1024;
+var withinObjectNameLimit = (key, entryId) => {
+  const bytes = new TextEncoder().encode(key).length;
+  if (bytes > MAX_OBJECT_NAME_BYTES) {
+    throw new Error(`Page chunk key is ${bytes} bytes, over the ${MAX_OBJECT_NAME_BYTES}-byte object name limit, for entry id "${entryId}"`);
+  }
+  return key;
+};
+function buildAsset(namespace, asset, slug) {
+  return {
+    /**
+     * Get registry record path.
+     *
+     * Registry collection records have a base resource path
+     * with the primary registry item metadata: namespace,
+     * asset type and slug.
+     *
+     * @example scalar/apis/scalar-galaxy
+     */
+    path: () => {
+      return `${namespace}/${asset}/${slug}`;
+    },
+    /**
+     * Get registry GCS file storage path
+     *
+     * Unlike registry record paths, storage paths contain the version
+     * of a registry item, and the respective file type.
+     *
+     * @example scalar/apis/scalar-galaxy/1.0.0.json
+     */
+    file: (opts) => {
+      return `${namespace}/${asset}/${slug}/${opts?.build || versionFormat(opts?.version)}${opts?.upgraded ? "_upgraded" : ""}${opts?.variant === "processed" ? "_processed" : ""}.${filetypeFormat(opts?.type)}`;
+    },
+    /**
+     * Get registry GCS folder storage path
+     *
+     * @example scalar/apis/scalar-galaxy
+     */
+    folder: (opts) => {
+      return `${namespace}/${asset}/${slug}${opts?.version ? `/${opts.version}` : ""}`;
+    },
+    /**
+     * Content-addressed blob path for an immutable content instance. Blobs are
+     * write-once — the sha in the key is the SHA-256 of the exact bytes stored,
+     * so identical content dedupes to the same object and nothing at this path
+     * is ever overwritten.
+     *
+     * The optional `variant` keys derived artifacts next to the content they
+     * derive from: `_processed` (SDK overlay output) and `_upgraded`
+     * (normalized OpenAPI) share the source content's json sha, so a variant
+     * object is immutable for the same reason the content blob is.
+     *
+     * @example scalar/apis/scalar-galaxy/blobs/2f7a...c9.json
+     * @example scalar/apis/scalar-galaxy/blobs/2f7a...c9_processed.json
+     */
+    blob: (opts) => {
+      const sha = external_exports.string().regex(/^[a-f0-9]{64}$/, "Blob sha must be a sha-256 hex digest").parse(opts.sha);
+      const variant = opts.variant ? `_${opts.variant}` : "";
+      return `${namespace}/${asset}/${slug}/blobs/${sha}${variant}.${filetypeFormat(opts.type)}`;
+    },
+    /**
+     * Prefix holding the per-page sidecar derived from one content instance:
+     * a manifest, a models bundle and one chunk per navigation entry.
+     *
+     * Deliberately beside `blobs/`, not inside it. {@link copyBlobsFolder}
+     * copies the whole `blobs/` prefix on every resource rename, twice and with
+     * unbounded concurrency; a sidecar contributes roughly ten thousand objects
+     * per sha, which would turn a rename into tens of thousands of concurrent
+     * copies. `pages/` is instead deleted with the resource and regenerated
+     * lazily under the new path, where the cost is one rebuild rather than a
+     * rename that may not finish.
+     *
+     * @example scalar/apis/scalar-galaxy/pages/2f7a...c9/
+     */
+    pagesPrefix: (opts) => {
+      return `${namespace}/${asset}/${slug}/pages/${pagesSha(opts.sha)}/`;
+    },
+    /**
+     * The sidecar's index: the stripped base document, the navigation tree and
+     * the entry table. Written last, so its presence is what marks a sidecar
+     * complete.
+     *
+     * @example scalar/apis/scalar-galaxy/pages/2f7a...c9/manifest.json
+     */
+    pagesManifest: (opts) => {
+      return `${namespace}/${asset}/${slug}/pages/${pagesSha(opts.sha)}/manifest.json`;
+    },
+    /**
+     * Every component schema of the sidecar, in one object. Split out of the
+     * manifest because the sidebar only needs it once a reader opens Models.
+     *
+     * @example scalar/apis/scalar-galaxy/pages/2f7a...c9/models.json
+     */
+    pagesModels: (opts) => {
+      return `${namespace}/${asset}/${slug}/pages/${pagesSha(opts.sha)}/models.json`;
+    },
+    /**
+     * One navigation entry's chunk — the slice of the document that entry's
+     * page renders, merged onto the manifest's stripped base document.
+     *
+     * @example scalar/apis/scalar-galaxy/pages/2f7a...c9/chunks/tag%2Fplanets%2Fget%2Fplanets.json
+     */
+    pageChunk: (opts) => {
+      return withinObjectNameLimit(`${namespace}/${asset}/${slug}/pages/${pagesSha(opts.sha)}/chunks/${pageChunkFile(opts.entryId)}`, opts.entryId);
+    },
+    /**
+     * Claim marker for a sidecar being built. Created with
+     * `ifGenerationMatch: 0` so exactly one producer wins across the fleet, and
+     * deleted when the job settles.
+     *
+     * Mutable, unlike everything else under the prefix: it is written, read for
+     * its age and removed within one build. See {@link planPagesCacheControl}
+     * in `@scalar-org/entities/registry` for what that means for serving.
+     *
+     * @example scalar/apis/scalar-galaxy/pages/2f7a...c9/preparing.json
+     */
+    pagesPreparing: (opts) => {
+      return `${namespace}/${asset}/${slug}/pages/${pagesSha(opts.sha)}/preparing.json`;
+    },
+    /**
+     * Records that building this sha's sidecar failed, so a reader is told so
+     * instead of polling a job that will not finish. Cleared by a rebuild, so
+     * it is mutable in the same way the claim marker is.
+     *
+     * @example scalar/apis/scalar-galaxy/pages/2f7a...c9/failed.json
+     */
+    pagesFailed: (opts) => {
+      return `${namespace}/${asset}/${slug}/pages/${pagesSha(opts.sha)}/failed.json`;
+    },
+    /**
+     * Get a full standardized registry url path
+     *
+     * Our registry resolver understands a few path formats.
+     * However, this is our primary registry format to use across
+     * internal products.
+     *
+     * @example @scalar/apis/scalar-galaxy/1.0.0?format=preview
+     */
+    url: (opts) => {
+      const query = [
+        opts?.format ? `format=${registryFormat(opts.format)}` : "",
+        opts?.variant === "processed" ? "variant=processed" : "",
+        opts?.lang ? `lang=${opts.lang}` : ""
+      ].filter(Boolean).join("&");
+      return `@${namespace}/${asset}/${slug}@${versionFormat(opts?.version)}${query ? `?${query}` : ""}`;
+    }
+  };
+}
+function registry(teamNamespace) {
+  const namespace = namespaceSchema.parse(teamNamespace);
+  return {
+    apis: (slug) => buildAsset(namespace, RegistryAsset.Apis, slug),
+    rules: (slug) => buildAsset(namespace, RegistryAsset.Rules, slug),
+    sdks: (slug) => buildAsset(namespace, RegistryAsset.Sdks, slug),
+    schemas: (slug) => buildAsset(namespace, RegistryAsset.Schemas, slug),
+    workspaces: (slug) => buildAsset(namespace, RegistryAsset.Workspaces, slug)
+  };
+}
+
+// ../../packages/urls/dist/publish/full.js
+function getPublishUrl(domain, subpath) {
+  const url = `https://${domain}${subpath ?? ""}`;
+  return new URL(url).toString();
+}
+
+// ../../packages/urls/dist/publish/previews.js
+function getPublishPreviewUrl(publishUid, domain, subpath = "") {
+  const url = `https://${getPublishPreviewDomain(publishUid, domain)}${subpath ?? ""}`;
+  new URL(url);
+  return url;
+}
+function getPublishPreviewDomain(publishUid, domain) {
+  return `${publishUid}--${domain}`;
+}
+
+export {
+  getPublishUrl,
+  getPublishPreviewUrl,
+  registry
+};

package/chunks/chunk-Z2KMGFE6.js

@@ -0,0 +1,295 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  getAuthData
+} from "./chunk-M37TP6U2.js";
+import {
+  config
+} from "./chunk-4ZDQXWBT.js";
+import {
+  external_exports,
+  objectSchema,
+  schemaModel
+} from "./chunk-IKT5F47M.js";
+
+// ../../packages/mongobase-client/dist/auth/tokens.js
+var tokenResponseSchema = external_exports.object({
+  accessToken: external_exports.string(),
+  refreshToken: external_exports.string()
+});
+
+// ../../packages/mongobase-client/dist/auth/utility.js
+var ErrorCode;
+(function(ErrorCode2) {
+  ErrorCode2["AuthFail"] = "auth-fail";
+})(ErrorCode || (ErrorCode = {}));
+
+// ../../packages/mongobase-client/dist/database/access.js
+var primitiveSchema = external_exports.union([
+  external_exports.string(),
+  external_exports.number(),
+  external_exports.boolean(),
+  external_exports.null()
+]);
+var $filterSchema = external_exports.object({
+  $in: external_exports.string().array().optional(),
+  $nin: external_exports.string().array().optional(),
+  $eq: primitiveSchema.optional(),
+  $ne: primitiveSchema.optional(),
+  $lt: external_exports.number().optional(),
+  $gt: external_exports.number().optional(),
+  $gte: external_exports.number().optional(),
+  $lte: external_exports.number().optional(),
+  $or: external_exports.lazy(() => $filterSchema.array()).optional()
+});
+var querySchema = external_exports.record(external_exports.string(), external_exports.union([primitiveSchema, $filterSchema]));
+var getRecordRequestSchema = external_exports.object({
+  collectionPath: external_exports.string(),
+  query: querySchema
+});
+var addRecordRequestSchema = external_exports.object({
+  collectionPath: external_exports.string(),
+  data: objectSchema
+});
+var addMultipleRecordsRequestSchema = external_exports.object({
+  collectionPath: external_exports.string(),
+  data: objectSchema.array()
+});
+var updateRecordRequestSchema = external_exports.object({
+  collectionPath: external_exports.string(),
+  data: objectSchema,
+  query: querySchema
+});
+var deleteRecordRequestSchema = external_exports.object({
+  collectionPath: external_exports.string(),
+  query: querySchema
+});
+var dropCollectionRequestSchema = external_exports.object({
+  collectionPath: external_exports.string()
+});
+function formatResponse(response, schema) {
+  return {
+    status: response.status,
+    data: schemaModel(response.data, schema),
+    error: false
+  };
+}
+var statusMessages = {
+  401: "Unauthorized. Please check that an access token was provided to the instance. "
+};
+function formatError(error, message) {
+  return {
+    status: error.status ?? 500,
+    message: statusMessages[error.response?.status] ?? error.message ?? message,
+    error: true,
+    originalError: error
+  };
+}
+var addResponseSchema = external_exports.object({
+  insertedId: external_exports.string()
+});
+var addMultiResponseSchema = external_exports.object({
+  insertedCount: external_exports.number(),
+  insertedIds: external_exports.preprocess((s) => Array.isArray(s) ? s : Object.values(s), external_exports.string().array())
+});
+var updateResponseSchema = external_exports.object({
+  matchedCount: external_exports.number(),
+  modifiedCount: external_exports.number(),
+  upsertedCount: external_exports.number(),
+  upsertedId: external_exports.string().nullable()
+});
+var deletedResponseSchema = external_exports.object({
+  deletedCount: external_exports.number()
+});
+function createAccess(baseURL) {
+  const state = {
+    accessToken: ""
+  };
+  function makeRequest(options) {
+    return fetch(`${baseURL}${options.url}`, {
+      method: options.method,
+      headers: {
+        ...options.headers,
+        // An empty bearer token is always rejected — omit the header so the
+        // server returns a clean 401 instead of parsing a malformed value
+        ...state.accessToken ? { Authorization: `Bearer ${state.accessToken}` } : {},
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(options.data)
+    }).then(async (res) => {
+      if (!res.ok) {
+        return formatError({ status: res.status, message: await res.text() }, "Unknown Error");
+      }
+      return formatResponse({ data: await res.json(), status: res.status }, options.schema);
+    }).catch((err) => formatError(err));
+  }
+  function get({ collectionPath, query, schema, type }) {
+    const data = schemaModel({ collectionPath, query }, getRecordRequestSchema);
+    return makeRequest({
+      url: `/database/get-${type}`,
+      method: "POST",
+      data,
+      schema
+    });
+  }
+  function addOne({ collectionPath, data, schema, responseSchema }) {
+    const sanitizedData = schemaModel({ collectionPath, data: schemaModel(data, schema) }, addRecordRequestSchema);
+    return makeRequest({
+      url: "/database/add-one",
+      method: "POST",
+      data: sanitizedData,
+      schema: responseSchema
+    });
+  }
+  function addMultiple({ collectionPath, data, schema, responseSchema }) {
+    const sanitizedData = schemaModel({ collectionPath, data: schemaModel(data, schema) }, addMultipleRecordsRequestSchema);
+    return makeRequest({
+      url: "/database/add-many",
+      method: "POST",
+      data: sanitizedData,
+      schema: responseSchema
+    });
+  }
+  function remove({ collectionPath, query, type }) {
+    const data = schemaModel({ collectionPath, query }, deleteRecordRequestSchema);
+    return makeRequest({
+      url: `/database/delete-${type}`,
+      method: "POST",
+      data,
+      schema: deletedResponseSchema
+    });
+  }
+  function update({ collectionPath, data, query, schema }) {
+    const updateData = schemaModel({
+      collectionPath,
+      query,
+      data: schemaModel(data, schema)
+    }, updateRecordRequestSchema);
+    return makeRequest({
+      url: "/database/update-one",
+      method: "POST",
+      data: updateData,
+      schema: updateResponseSchema
+    });
+  }
+  function dropCollection({ collectionPath }) {
+    const data = schemaModel({ collectionPath }, dropCollectionRequestSchema);
+    return makeRequest({
+      url: "/database/drop-collection",
+      method: "POST",
+      data,
+      schema: external_exports.any()
+    });
+  }
+  return {
+    /** Update the access token */
+    updateAccessToken(accessToken) {
+      state.accessToken = accessToken;
+    },
+    async checkHealth(url) {
+      if (!state.accessToken) {
+        return {
+          status: 511,
+          message: "No Access Token",
+          error: true,
+          originalError: null
+        };
+      }
+      return await makeRequest({
+        url,
+        method: "GET",
+        schema: external_exports.any()
+      });
+    },
+    /** Get a single record */
+    getOne(options) {
+      return get({ ...options, type: "one" });
+    },
+    /** Get multiple records */
+    getMany(options) {
+      return get({ ...options, type: "many" });
+    },
+    /** Add a single record */
+    addOne(options) {
+      return addOne({ ...options, responseSchema: addResponseSchema });
+    },
+    /** Add multiple records */
+    addMany(options) {
+      return addMultiple({ ...options, responseSchema: addMultiResponseSchema });
+    },
+    updateOne(options) {
+      return update({ ...options });
+    },
+    /** Delete a single record */
+    deleteOne(options) {
+      return remove({ ...options, type: "one" });
+    },
+    /** Delete multiple records */
+    deleteMany(options) {
+      return remove({ ...options, type: "many" });
+    },
+    dropCollection
+  };
+}
+
+// ../../packages/mongobase-client/dist/database/offline.js
+var DiffOp;
+(function(DiffOp2) {
+  DiffOp2["Remove"] = "remove";
+  DiffOp2["Replace"] = "replace";
+  DiffOp2["Add"] = "add";
+})(DiffOp || (DiffOp = {}));
+var diffRecordSchema = external_exports.object({
+  op: external_exports.enum(DiffOp),
+  path: external_exports.union([external_exports.string(), external_exports.number()]).array(),
+  value: external_exports.any()
+});
+var MutationOp;
+(function(MutationOp2) {
+  MutationOp2["Add"] = "add";
+  MutationOp2["Update"] = "update";
+  MutationOp2["Delete"] = "delete";
+})(MutationOp || (MutationOp = {}));
+var collectionChangeRecordSchema = external_exports.record(external_exports.string(), external_exports.object({
+  action: external_exports.enum(MutationOp),
+  value: external_exports.any()
+}));
+var changelogSchema = external_exports.record(external_exports.string(), collectionChangeRecordSchema);
+
+// ../../packages/mongobase-client/dist/database/socket.js
+var SubscriptionTypes;
+(function(SubscriptionTypes2) {
+  SubscriptionTypes2["Collection"] = "collection";
+  SubscriptionTypes2["Document"] = "document";
+})(SubscriptionTypes || (SubscriptionTypes = {}));
+var MAX_RECONNECT_INTERVAL = 60 * 1e3;
+
+// ../../packages/mongobase-client/dist/database/subscribe.js
+var SubscriptionAction;
+(function(SubscriptionAction2) {
+  SubscriptionAction2["Add"] = "insert";
+  SubscriptionAction2["Update"] = "update";
+  SubscriptionAction2["Remove"] = "delete";
+})(SubscriptionAction || (SubscriptionAction = {}));
+
+// ../../packages/mongobase-client/dist/database/index.js
+function initDatabase(baseUrl) {
+  if (!baseUrl)
+    throw new Error("Invalid URL provided to initDatabase");
+  return createAccess(baseUrl);
+}
+
+// src/helpers/database.ts
+var getDatabaseClient = async () => {
+  const client = initDatabase(`${config.services.api}/rtdb`);
+  const auth = await getAuthData();
+  auth.addEventListener((state) => {
+    Object.assign(auth, state);
+    client.updateAccessToken(state.accessToken);
+  });
+  client.updateAccessToken(auth.accessToken);
+  return client;
+};
+
+export {
+  getDatabaseClient
+};

package/chunks/create.action-HDD2WUON.js

@@ -0,0 +1,108 @@
+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 {
+  SdkLanguage
+} from "./chunk-3L6DLIXJ.js";
+import "./chunk-P7H7GY5A.js";
+import "./chunk-HPL3ZZ2P.js";
+import {
+  getAuthData
+} from "./chunk-M37TP6U2.js";
+import {
+  config
+} from "./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
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import {
+  external_exports,
+  namespaceSchema,
+  slugSchema
+} from "./chunk-IKT5F47M.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-7GOZY7ID.js

@@ -0,0 +1,88 @@
+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
+} from "./chunk-T5HJUAWB.js";
+import "./chunk-GSGZHE26.js";
+import {
+  external_exports,
+  namespaceSchema,
+  slugSchema
+} from "./chunk-IKT5F47M.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
+};