@scalar/cli 2.0.1 → 2.5.1

package/chunks/chunk-F467BYYR.js

@@ -0,0 +1,568 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  accessGroupSchema,
+  identityProviderRecordSchema,
+  loginPortalSchema,
+  managedSchema,
+  workspaceSchema
+} from "./chunk-HCPN3KNF.js";
+import {
+  userSchema
+} from "./chunk-B2MHTD3R.js";
+import {
+  sdkSchema
+} from "./chunk-3L6DLIXJ.js";
+import {
+  teamSchema
+} from "./chunk-VNYE4R7N.js";
+import {
+  activeDeploymentSchema,
+  publishRecordSchema,
+  themeSchema
+} from "./chunk-OQKDBLOZ.js";
+import {
+  managedDocSchema,
+  ruleSchema
+} from "./chunk-CISTON3A.js";
+import {
+  docVersionRecordSchema
+} from "./chunk-Q7DOQHZN.js";
+import {
+  emailSchema,
+  entitySchema,
+  external_exports,
+  nanoidSchema,
+  zod_default
+} from "./chunk-IKT5F47M.js";
+
+// ../../packages/entities/dist/admins/index.js
+var scalarAdminSchema = entitySchema.extend({
+  email: zod_default.string().email(),
+  name: zod_default.string().min(2).max(100),
+  role: zod_default.enum(["admin", "super-admin"])
+}).meta({ id: "scalar-admin" });
+
+// ../../packages/entities/dist/publish/publish.js
+var headingRecordSchema = external_exports.object({
+  slug: external_exports.string(),
+  name: external_exports.string(),
+  level: external_exports.coerce.number().int(),
+  uid: nanoidSchema,
+  parent: external_exports.string().optional(),
+  isPageTitle: external_exports.boolean().optional()
+}).meta({ id: "heading-record" });
+var publishAssetSchema = external_exports.object({
+  path: external_exports.string(),
+  data: external_exports.string()
+}).meta({ id: "publish-asset" });
+var typesenseConfigSchema = external_exports.object({
+  keyId: external_exports.number(),
+  keyValue: external_exports.string(),
+  collectionName: external_exports.string()
+}).meta({ id: "typesense-config" });
+
+// ../../packages/entities/dist/deploys/deploy.js
+var subpathSchema = external_exports.object({
+  subpath: external_exports.string(),
+  projectUid: external_exports.string(),
+  /**
+   * The project's own title, for labelling it in cross-project search.
+   * Written on publish, so it is absent until the project next publishes.
+   */
+  name: external_exports.string().optional(),
+  /**
+   * The project's active publish, used to cache-bust its search index the
+   * way a project already busts its own. Absent until it next publishes.
+   */
+  publishUid: external_exports.string().optional(),
+  /**
+   * Present only for sites still served by Typesense. Builds on the jsonl
+   * search backend omit it; federated search fetches `${subpath}/search-entries.jsonl`.
+   */
+  typesenseConfig: typesenseConfigSchema.optional().nullable()
+}).meta({ id: "subpath" });
+var cloudflareHttpTokenSchema = external_exports.object({
+  /** URL path, e.g. `/.well-known/pki-validation/ca3-<id>.txt` */
+  path: external_exports.string(),
+  /** Plain-text response body the token path must answer with */
+  body: external_exports.string()
+}).meta({ id: "cloudflare-http-token" });
+var cloudflareHostnameStateSchema = external_exports.object({
+  /** Custom hostname id in the Cloudflare zone */
+  hostnameId: external_exports.string(),
+  /** Hostname ownership status reported by Cloudflare (pending, active, …) */
+  status: external_exports.string(),
+  /** Certificate status reported by Cloudflare (pending_validation, active, …) */
+  sslStatus: external_exports.string(),
+  httpTokens: cloudflareHttpTokenSchema.array().default([]),
+  /** Unix seconds of the reconciler run that last wrote this state */
+  syncedAt: external_exports.number()
+}).meta({ id: "cloudflare-hostname-state" });
+var siteDeploySchema = entitySchema.extend({
+  domain: external_exports.string(),
+  teamUid: nanoidSchema,
+  projectUid: nanoidSchema,
+  /**
+   * Title of the project mounted at the domain root.
+   *
+   * The root project is deliberately not one of `subpaths` — both request
+   * matchers resolve by longest path prefix, so a '/' entry would become a
+   * catch-all that every request matched. It is denormalized here instead so
+   * search can name and scope it without a second lookup.
+   */
+  rootName: external_exports.string().optional(),
+  subpaths: subpathSchema.array().default([]),
+  cloudflare: cloudflareHostnameStateSchema.optional().nullable()
+}).meta({ id: "site-deploy" });
+var searchConfigRootSchema = external_exports.object({
+  projectUid: external_exports.string(),
+  name: external_exports.string().optional()
+}).meta({ id: "search-config-root" });
+var searchConfigResponseSchema = external_exports.object({
+  subpaths: subpathSchema.array(),
+  root: searchConfigRootSchema.optional()
+}).meta({ id: "search-config-response" });
+
+// ../../packages/entities/dist/user/ban.js
+var bannedUserSchema = entitySchema.extend({
+  email: emailSchema,
+  reason: zod_default.string(),
+  bannedBy: emailSchema
+}).meta({ id: "banned-user" });
+
+// ../../packages/entities/dist/database/collections.js
+var BaseCollections = {
+  Users: "users",
+  ScalarAdmins: "admin-users",
+  SignupMeta: "signup-meta",
+  ExchangeTokens: "exchange-tokens",
+  HostingExchange: "hosting-exchange",
+  HostingLoginTokens: "hosting-login-tokens",
+  HostingOauthStates: "hosting-oauth-states",
+  Passwords: "passwords",
+  SignupOtp: "signup-otp",
+  GithubUsers: "github-users",
+  BitbucketUsers: "bitbucket-users",
+  RefreshTokens: "refresh-tokens",
+  LoginAttempts: "login-attempts",
+  Teams: "team",
+  Deploys: "deploys",
+  SamlStates: "saml-states",
+  SignupData: "signup-data",
+  Projects: (teamUid) => `team/${teamUid}/projects`,
+  GithubProjects: (teamUid) => `team/${teamUid}/projects-github`,
+  DocsProjects: (teamUid) => `team/${teamUid}/docs`,
+  Themes: (teamUid) => `team/${teamUid}/themes`,
+  PublishRecords: (teamUid) => `team/${teamUid}/publish`,
+  ManagedDocs: (teamUid) => `team/${teamUid}/managed-docs`,
+  ManagedDocInstances: (teamUid, docUid) => `team/${teamUid}/managed-docs/${docUid}/instances`,
+  ManagedDocVersions: (teamUid, docUid) => `team/${teamUid}/managed-docs/${docUid}/versions`,
+  ManagedSchemas: (teamUid) => `team/${teamUid}/managed-schemas`,
+  ManagedSchemaInstances: (teamUid, schemaUid) => `team/${teamUid}/managed-schemas/${schemaUid}/instances`,
+  ManagedSchemaVersions: (teamUid, schemaUid) => `team/${teamUid}/managed-schemas/${schemaUid}/versions`,
+  Rules: (teamUid) => `team/${teamUid}/rules`,
+  RuleInstances: (teamUid, ruleUid) => `team/${teamUid}/rules/${ruleUid}/instances`,
+  RegistryPublishes: (teamUid) => `team/${teamUid}/registry-publishes`,
+  LinkedRepositories: (teamUid) => `team/${teamUid}/repositories`,
+  RegistryGitMigrations: "registry-git-migrations",
+  AccessGroups: (teamUid) => `team/${teamUid}/access-groups`,
+  LoginPortals: (teamUid) => `team/${teamUid}/login-portals`,
+  Sdks: (teamUid) => `team/${teamUid}/sdks`,
+  SdkBuilds: (teamUid) => `team/${teamUid}/sdk-builds`,
+  SdkBuildLogs: (teamUid) => `team/${teamUid}/sdk-build-logs`,
+  PersonalTokens: (userUid) => `user/${userUid}/personal-tokens`,
+  IdentityProviders: (teamUid) => `team/${teamUid}/identity-providers`,
+  Workspaces: (teamUid) => `team/${teamUid}/workspaces`,
+  WebhookSubscriptions: (teamUid) => `team/${teamUid}/webhook-subscriptions`,
+  WebhookDeliveries: (teamUid) => `team/${teamUid}/webhook-deliveries`,
+  WebhookSecrets: (teamUid) => `team/${teamUid}/webhook-secrets`,
+  WebhookEventClaims: "webhook-event-claims",
+  OauthStates: "oauth-states",
+  Waitlist: "waitlist",
+  BannedUsers: "banned-users"
+};
+
+// ../../packages/entities/dist/database/edge-cache.js
+var requiredUid = { uid: nanoidSchema };
+var entityExtension = {
+  ...requiredUid,
+  _path: external_exports.string(),
+  _registryPath: external_exports.string().default("")
+};
+var registryRequiredFields = {
+  uid: true,
+  title: true,
+  slug: true,
+  namespace: true,
+  loginPortalUid: true,
+  isPrivate: true,
+  accessGroups: true
+};
+function generateRegistryPath(entity) {
+  entity._registryPath = `${entity.namespace}/${entity.slug}`;
+  return entity;
+}
+function teamUidFromPath(path) {
+  return path.split("/").at(1) ?? "";
+}
+var edgeCacheDeploySchema = siteDeploySchema.omit({ cloudflare: true }).extend(requiredUid);
+var edgeCacheProjectSchema = external_exports.object({
+  ...requiredUid,
+  loginPortalUid: external_exports.string().default(""),
+  accessGroups: external_exports.array(external_exports.string()).default([]),
+  identityProviders: external_exports.string().array().default([]),
+  isPrivate: external_exports.boolean().default(false),
+  /**
+   * The customer's docs-analytics opt-out. It defaults to true, so a cache
+   * that omits the field silently opts an opted-out customer back in — the
+   * hosting proxy projects it on every project collection for this reason.
+   */
+  analyticsEnabled: external_exports.boolean().default(true),
+  activeDeployment: activeDeploymentSchema.nullable().optional(),
+  _path: external_exports.string()
+});
+var edgeCacheGithubProjectSchema = edgeCacheProjectSchema;
+var edgeCacheDocsProjectSchema = edgeCacheProjectSchema;
+var PROJECT_TABLE = "project";
+var edgeCachePublishRecordSchema = publishRecordSchema.pick({ uid: true, projectUid: true, agentToken: true }).extend(requiredUid).transform(({ uid, projectUid, agentToken }) => ({
+  uid,
+  projectUid,
+  agentToken,
+  _publishPath: `${uid.toLowerCase()}/${projectUid}`
+}));
+var edgeCacheApiSchema = managedDocSchema.pick({
+  ...registryRequiredFields,
+  theme: true,
+  version: true,
+  latestVersion: true,
+  agentEnabled: true
+}).extend(entityExtension).transform(generateRegistryPath);
+var edgeCacheSchemaSchema = managedSchema.pick({ ...registryRequiredFields, version: true }).extend(entityExtension).transform(generateRegistryPath);
+var edgeCacheDocVersionSchema = docVersionRecordSchema.pick({
+  uid: true,
+  version: true,
+  upgraded: true
+}).extend({ ...requiredUid, _path: external_exports.string() });
+var edgeCacheRuleSchema = ruleSchema.pick(registryRequiredFields).extend(entityExtension).transform(generateRegistryPath);
+var edgeCacheSdkSchema = sdkSchema.pick({ ...registryRequiredFields, versions: true, targets: true }).extend(entityExtension).transform(generateRegistryPath);
+var edgeCacheWorkspaceSchema = workspaceSchema.pick({ ...registryRequiredFields, version: true, versions: true }).extend(entityExtension).transform(generateRegistryPath);
+var edgeCacheTeamSchema = teamSchema.pick({
+  uid: true,
+  users: true,
+  externalAccess: true
+}).extend(requiredUid);
+var edgeCacheUserSchema = userSchema.pick({
+  uid: true,
+  email: true
+}).extend(requiredUid);
+var edgeCacheLoginPortalSchema = loginPortalSchema.extend(requiredUid);
+var edgeCacheAccessGroupSchema = accessGroupSchema.extend(requiredUid);
+var edgeCacheThemeSchema = themeSchema.pick({ uid: true, theme: true, slug: true }).extend({ ...requiredUid, _path: external_exports.string() });
+var edgeCacheIdentityProviderSchema = identityProviderRecordSchema.extend({ _path: external_exports.string() }).pick({
+  uid: true,
+  name: true,
+  provider: true,
+  consumerOnly: true,
+  _path: true
+}).extend(requiredUid).transform(({ uid, name, provider, consumerOnly, _path }) => ({
+  uid,
+  name,
+  provider,
+  consumerOnly,
+  teamUid: teamUidFromPath(_path),
+  _path
+}));
+var SAFE_SQL_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function assertSafeIdentifier(value, context) {
+  if (!SAFE_SQL_IDENTIFIER.test(value)) {
+    throw new Error(`Unsafe SQL identifier for edge-cache ${context}: ${JSON.stringify(value)}`);
+  }
+}
+function defineCollection(config) {
+  assertSafeIdentifier(config.tableName, `tableName "${config.tableName}"`);
+  for (const field of config.indexFields) {
+    assertSafeIdentifier(field, `indexField "${field}" on "${config.tableName}"`);
+  }
+  if (config.source !== void 0) {
+    assertSafeIdentifier(config.source, `source "${config.source}" on "${config.tableName}"`);
+  }
+  return config;
+}
+var edgeCacheCollections = {
+  deploy: defineCollection({
+    schema: edgeCacheDeploySchema,
+    indexFields: ["domain"],
+    tableName: "deploy",
+    mongoCollection: BaseCollections.Deploys
+  }),
+  project: defineCollection({
+    schema: edgeCacheProjectSchema,
+    indexFields: [],
+    tableName: PROJECT_TABLE,
+    mongoCollection: BaseCollections.Projects,
+    source: "project",
+    priority: 2,
+    projection: {
+      uid: 1,
+      loginPortalUid: 1,
+      accessGroups: 1,
+      identityProviders: 1,
+      isPrivate: 1,
+      analyticsEnabled: 1,
+      activeDeployment: 1,
+      _path: 1
+    }
+  }),
+  githubProject: defineCollection({
+    schema: edgeCacheGithubProjectSchema,
+    indexFields: [],
+    tableName: PROJECT_TABLE,
+    mongoCollection: BaseCollections.GithubProjects,
+    source: "github",
+    priority: 1,
+    projection: {
+      uid: 1,
+      loginPortalUid: 1,
+      accessGroups: 1,
+      identityProviders: 1,
+      isPrivate: 1,
+      analyticsEnabled: 1,
+      activeDeployment: 1,
+      _path: 1
+    }
+  }),
+  docsProject: defineCollection({
+    schema: edgeCacheDocsProjectSchema,
+    indexFields: [],
+    tableName: PROJECT_TABLE,
+    mongoCollection: BaseCollections.DocsProjects,
+    source: "docs",
+    priority: 3,
+    projection: {
+      uid: 1,
+      loginPortalUid: 1,
+      accessGroups: 1,
+      identityProviders: 1,
+      isPrivate: 1,
+      analyticsEnabled: 1,
+      activeDeployment: 1,
+      _path: 1
+    }
+  }),
+  publishRecord: defineCollection({
+    schema: edgeCachePublishRecordSchema,
+    indexFields: ["_publishPath"],
+    tableName: "publishRecord",
+    mongoCollection: BaseCollections.PublishRecords,
+    projection: { uid: 1, projectUid: 1, agentToken: 1 }
+  }),
+  api: defineCollection({
+    schema: edgeCacheApiSchema,
+    indexFields: ["_registryPath"],
+    tableName: "api",
+    mongoCollection: BaseCollections.ManagedDocs,
+    projection: {
+      uid: 1,
+      title: 1,
+      slug: 1,
+      namespace: 1,
+      loginPortalUid: 1,
+      isPrivate: 1,
+      accessGroups: 1,
+      theme: 1,
+      _path: 1,
+      _registryPath: 1,
+      version: 1,
+      latestVersion: 1,
+      agentEnabled: 1
+    }
+  }),
+  schema: defineCollection({
+    schema: edgeCacheSchemaSchema,
+    indexFields: ["_registryPath"],
+    tableName: "schema",
+    mongoCollection: BaseCollections.ManagedSchemas,
+    projection: {
+      uid: 1,
+      title: 1,
+      slug: 1,
+      namespace: 1,
+      loginPortalUid: 1,
+      isPrivate: 1,
+      accessGroups: 1,
+      version: 1,
+      _path: 1,
+      _registryPath: 1
+    }
+  }),
+  // The versions collections are pseudo-nested under each document, so their
+  // physical Mongo collection names carry two uid placeholders (see
+  // collectionNameFromPath in mongobase) — written as static patterns here
+  // because the config's function form substitutes only the first uid.
+  apiVersion: defineCollection({
+    schema: edgeCacheDocVersionSchema,
+    indexFields: ["_path", "version"],
+    tableName: "docVersion",
+    mongoCollection: "team/<uid-0>/managed-docs/<uid-1>/versions",
+    source: "api",
+    priority: 2,
+    projection: {
+      uid: 1,
+      version: 1,
+      upgraded: 1,
+      _path: 1
+    }
+  }),
+  schemaVersion: defineCollection({
+    schema: edgeCacheDocVersionSchema,
+    indexFields: ["_path", "version"],
+    tableName: "docVersion",
+    mongoCollection: "team/<uid-0>/managed-schemas/<uid-1>/versions",
+    source: "schema",
+    priority: 1,
+    projection: {
+      uid: 1,
+      version: 1,
+      upgraded: 1,
+      _path: 1
+    }
+  }),
+  rule: defineCollection({
+    schema: edgeCacheRuleSchema,
+    indexFields: ["_registryPath"],
+    tableName: "rule",
+    mongoCollection: BaseCollections.Rules,
+    projection: {
+      uid: 1,
+      title: 1,
+      slug: 1,
+      namespace: 1,
+      loginPortalUid: 1,
+      isPrivate: 1,
+      accessGroups: 1,
+      _path: 1,
+      _registryPath: 1
+    }
+  }),
+  sdk: defineCollection({
+    schema: edgeCacheSdkSchema,
+    indexFields: ["_registryPath"],
+    tableName: "sdk",
+    mongoCollection: BaseCollections.Sdks,
+    projection: {
+      uid: 1,
+      title: 1,
+      slug: 1,
+      namespace: 1,
+      loginPortalUid: 1,
+      isPrivate: 1,
+      accessGroups: 1,
+      versions: 1,
+      targets: 1,
+      _path: 1,
+      _registryPath: 1
+    }
+  }),
+  workspace: defineCollection({
+    schema: edgeCacheWorkspaceSchema,
+    indexFields: ["_registryPath"],
+    tableName: "workspace",
+    mongoCollection: BaseCollections.Workspaces,
+    projection: {
+      uid: 1,
+      title: 1,
+      slug: 1,
+      namespace: 1,
+      loginPortalUid: 1,
+      isPrivate: 1,
+      accessGroups: 1,
+      version: 1,
+      versions: 1,
+      _registryPath: 1,
+      _path: 1
+    }
+  }),
+  team: defineCollection({
+    schema: edgeCacheTeamSchema,
+    indexFields: [],
+    tableName: "team",
+    mongoCollection: BaseCollections.Teams,
+    projection: { uid: 1, users: 1, externalAccess: 1 }
+  }),
+  user: defineCollection({
+    schema: edgeCacheUserSchema,
+    indexFields: ["email"],
+    tableName: "user",
+    mongoCollection: BaseCollections.Users,
+    projection: { uid: 1, email: 1 }
+  }),
+  loginPortal: defineCollection({
+    schema: edgeCacheLoginPortalSchema,
+    indexFields: [],
+    tableName: "loginPortal",
+    mongoCollection: BaseCollections.LoginPortals
+  }),
+  accessGroup: defineCollection({
+    schema: edgeCacheAccessGroupSchema,
+    indexFields: [],
+    tableName: "accessGroup",
+    mongoCollection: BaseCollections.AccessGroups
+  }),
+  theme: defineCollection({
+    schema: edgeCacheThemeSchema,
+    indexFields: [],
+    tableName: "theme",
+    mongoCollection: BaseCollections.Themes,
+    projection: { uid: 1, theme: 1, slug: 1, _path: 1 }
+  }),
+  identityProvider: defineCollection({
+    schema: edgeCacheIdentityProviderSchema,
+    indexFields: ["teamUid"],
+    tableName: "identityProvider",
+    mongoCollection: BaseCollections.IdentityProviders,
+    projection: { uid: 1, name: 1, provider: 1, consumerOnly: 1, _path: 1 }
+  })
+};
+var sharedTables = new Set(Object.values(edgeCacheCollections).map((config) => config.tableName).filter((table, index, all) => all.indexOf(table) !== index));
+for (const [key, config] of Object.entries(edgeCacheCollections)) {
+  const shared = sharedTables.has(config.tableName);
+  if (shared && !config.source) {
+    throw new Error(`Edge-cache collection "${key}" shares table "${config.tableName}" but declares no source.`);
+  }
+  if (!shared && config.source) {
+    throw new Error(`Edge-cache collection "${key}" declares source "${config.source}" but no other collection uses table "${config.tableName}".`);
+  }
+}
+var sourcesByTable = /* @__PURE__ */ new Map();
+for (const [key, config] of Object.entries(edgeCacheCollections)) {
+  if (!config.source)
+    continue;
+  const seen = sourcesByTable.get(`${config.tableName}:${config.source}`);
+  if (seen) {
+    throw new Error(`Edge-cache collections "${seen}" and "${key}" both use source "${config.source}" on table "${config.tableName}".`);
+  }
+  sourcesByTable.set(`${config.tableName}:${config.source}`, key);
+}
+var prioritiesByTable = /* @__PURE__ */ new Map();
+for (const [key, config] of Object.entries(edgeCacheCollections)) {
+  const shared = sharedTables.has(config.tableName);
+  if (shared && config.priority === void 0) {
+    throw new Error(`Edge-cache collection "${key}" shares table "${config.tableName}" but declares no priority.`);
+  }
+  if (!shared && config.priority !== void 0) {
+    throw new Error(`Edge-cache collection "${key}" declares a priority but does not share table "${config.tableName}".`);
+  }
+  if (config.priority === void 0)
+    continue;
+  const taken = prioritiesByTable.get(config.tableName) ?? /* @__PURE__ */ new Map();
+  const holder = taken.get(config.priority);
+  if (holder) {
+    throw new Error(`Edge-cache collections "${holder}" and "${key}" both use priority ${config.priority} on table "${config.tableName}".`);
+  }
+  taken.set(config.priority, key);
+  prioritiesByTable.set(config.tableName, taken);
+}
+
+export {
+  BaseCollections
+};