sanity 3.77.3-server-side-schemas.15 → 3.77.3-server-side-schemas.16

package/src/_internal/cli/actions/manifest/extractManifestAction.ts

@@ -33,7 +33,7 @@ const EXTRACT_FAILURE_MESSAGE =
   "↳ Couldn't extract manifest file. Sanity Create will not be available for the studio.\n" +
   `  Disable this message with ${FEATURE_ENABLED_ENV_NAME}=false`
 
-interface ExtractFlags {
+export interface ExtractManifestFlags {
   path?: string
 }
 
@@ -42,7 +42,7 @@ interface ExtractFlags {
  * @returns `undefined` if extract succeeded - caught error if it failed
  */
 export async function extractManifestSafe(
-  args: CliCommandArguments<ExtractFlags>,
+  args: CliCommandArguments<ExtractManifestFlags>,
   context: CliCommandContext,
 ): Promise<Error | undefined> {
   if (!EXTRACT_MANIFEST_ENABLED) {
@@ -61,7 +61,7 @@ export async function extractManifestSafe(
 }
 
 async function extractManifest(
-  args: CliCommandArguments<ExtractFlags>,
+  args: CliCommandArguments<ExtractManifestFlags>,
   context: CliCommandContext,
 ): Promise<void> {
   const {output, workDir} = context

package/src/_internal/cli/actions/schema/deleteSchemaAction.ts

@@ -2,22 +2,30 @@ import {type CliCommandArguments, type CliCommandContext} from '@sanity/cli'
 import chalk from 'chalk'
 
 import {type ManifestWorkspaceFile} from '../../../manifest/manifestTypes'
-import {getManifestPath, readManifest, throwIfProjectIdMismatch} from './storeSchemasAction'
+import {
+  getManifestPath,
+  readManifest,
+  SCHEMA_STORE_ENABLED,
+  throwIfProjectIdMismatch,
+} from './storeSchemasAction'
 
 export interface DeleteSchemaFlags {
-  ids: string
-  path: string
-  dataset: string
+  'ids': string
+  'manifest-dir': string
+  'dataset': string
 }
 
 export default async function deleteSchemaAction(
   args: CliCommandArguments<DeleteSchemaFlags>,
   context: CliCommandContext,
 ): Promise<void> {
+  if (!SCHEMA_STORE_ENABLED) {
+    return
+  }
   const flags = args.extOptions
   if (typeof flags.dataset === 'boolean') throw new Error('Dataset is empty')
   if (typeof flags.ids === 'boolean') throw new Error('Ids are empty')
-  if (typeof flags.path === 'boolean') throw new Error('Path is empty')
+  if (typeof flags['manifest-dir'] === 'boolean') throw new Error('Manifest directory is empty')
 
   const {apiClient, output} = context
 
@@ -36,8 +44,9 @@ export default async function deleteSchemaAction(
     return
   }
 
-  const manifestPath = getManifestPath(context, flags.path)
-  const manifest = readManifest(manifestPath, output)
+  const manifestDir = flags['manifest-dir']
+  const manifestPath = getManifestPath(context, manifestDir)
+  const manifest = await readManifest(manifestPath, context)
 
   const results = await Promise.allSettled(
     manifest.workspaces.flatMap((workspace: ManifestWorkspaceFile) => {

package/src/_internal/cli/actions/schema/schemaListAction.ts

@@ -4,12 +4,17 @@ import chalk from 'chalk'
 import {size, sortBy, uniqBy} from 'lodash'
 
 import {type ManifestWorkspaceFile} from '../../../manifest/manifestTypes'
-import {getManifestPath, readManifest, throwIfProjectIdMismatch} from './storeSchemasAction'
+import {
+  getManifestPath,
+  readManifest,
+  SCHEMA_STORE_ENABLED,
+  throwIfProjectIdMismatch,
+} from './storeSchemasAction'
 
 export interface SchemaListFlags {
-  json: boolean
-  id: string
-  path: string
+  'json': boolean
+  'id': string
+  'manifest-dir': string
 }
 
 type PrintSchemaListArgs = {
@@ -46,11 +51,18 @@ const printSchemaList = ({
   rows.forEach((row) => output.print(printRow(row)))
 }
 
-export default async function fetchSchemaAction(
+export default async function schemaListAction(
   args: CliCommandArguments<SchemaListFlags>,
   context: CliCommandContext,
 ): Promise<void> {
+  if (!SCHEMA_STORE_ENABLED) {
+    return
+  }
+
   const flags = args.extOptions
+  if (typeof flags.id === 'boolean') throw new Error('Schema ID is empty')
+  if (typeof flags['manifest-dir'] === 'boolean') throw new Error('Manifest directory is empty')
+
   const {apiClient, output} = context
   const client = apiClient({
     requireUser: true,
@@ -58,14 +70,16 @@ export default async function fetchSchemaAction(
   }).withConfig({apiVersion: 'v2024-08-01'})
 
   const projectId = client.config().projectId
+  const dataset = client.config().dataset
 
-  if (!projectId) {
-    output.error('Project ID must be defined.')
+  if (!projectId || !dataset) {
+    output.error('Project ID and dataset must be defined.')
     return
   }
 
-  const manifestPath = getManifestPath(context, flags.path)
-  const manifest = readManifest(manifestPath, output)
+  const manifestDir = flags['manifest-dir']
+  const manifestPath = getManifestPath(context, manifestDir)
+  const manifest = await readManifest(manifestPath, context)
 
   // Gather all schemas
   const results = await Promise.allSettled(

package/src/_internal/cli/actions/schema/storeSchemasAction.ts

@@ -1,16 +1,23 @@
-import {readFileSync} from 'node:fs'
+import {readFileSync, statSync} from 'node:fs'
 import path, {join, resolve} from 'node:path'
 
-import {type CliCommandArguments, type CliCommandContext, type CliOutputter} from '@sanity/cli'
+import {type CliCommandArguments, type CliCommandContext} from '@sanity/cli'
 import chalk from 'chalk'
 import {type Ora} from 'ora'
 
 import {type ManifestSchemaType, type ManifestWorkspaceFile} from '../../../manifest/manifestTypes'
-import {MANIFEST_FILENAME} from '../manifest/extractManifestAction'
+import {
+  type ExtractManifestFlags,
+  extractManifestSafe,
+  MANIFEST_FILENAME,
+} from '../manifest/extractManifestAction'
 import {SANITY_WORKSPACE_SCHEMA_TYPE} from './schemaListAction'
 
+const FEATURE_ENABLED_ENV_NAME = 'SANITY_CLI_SCHEMA_STORE_ENABLED'
+export const SCHEMA_STORE_ENABLED = process.env[FEATURE_ENABLED_ENV_NAME] === 'true'
+
 export interface StoreManifestSchemasFlags {
-  'path'?: string
+  'manifest-dir'?: string
   'workspace'?: string
   'id-prefix'?: string
   'schema-required'?: boolean
@@ -28,14 +35,49 @@ export const getManifestPath = (context: CliCommandContext, customPath?: string)
   return manifestPath
 }
 
-export const readManifest = (readPath: string, output?: CliOutputter, spinner?: Ora) => {
+/**
+ * Helper function to read and parse a manifest file with logging
+ */
+const readAndParseManifest = (manifestPath: string, context: CliCommandContext) => {
+  const content = readFileSync(manifestPath, 'utf-8')
+  const stats = statSync(manifestPath)
+  const lastModified = stats.mtime.toISOString()
+  context.output.print(
+    chalk.gray(`\n↳ Read manifest from ${manifestPath} (last modified: ${lastModified})`),
+  )
+  return JSON.parse(content)
+}
+
+export const readManifest = async (readPath: string, context: CliCommandContext, spinner?: Ora) => {
+  const manifestPath = `${readPath}/${MANIFEST_FILENAME}`
+
   try {
-    return JSON.parse(readFileSync(`${readPath}/${MANIFEST_FILENAME}`, 'utf-8'))
+    return readAndParseManifest(manifestPath, context)
   } catch (error) {
-    const errorMessage = `Manifest not found at ${readPath}/${MANIFEST_FILENAME}`
-    if (spinner) spinner.fail(errorMessage)
-    if (output) output.error(errorMessage)
-    throw error
+    // Still log that we're attempting extraction
+    spinner!.text = 'Manifest not found, attempting to extract it...'
+
+    await extractManifestSafe(
+      {
+        extOptions: {path: readPath},
+        groupOrCommand: 'extract',
+        argv: [],
+        argsWithoutOptions: [],
+        extraArguments: [],
+      } as CliCommandArguments<ExtractManifestFlags>,
+      context,
+    )
+
+    // Try reading the manifest again after extraction
+    try {
+      return readAndParseManifest(manifestPath, context)
+    } catch (retryError) {
+      const errorMessage = `Failed to read manifest at ${manifestPath}`
+      spinner?.fail(errorMessage)
+      // We should log the error too for consistency
+      context.output.error(errorMessage)
+      throw retryError
+    }
   }
 }
 
@@ -55,14 +97,19 @@ export default async function storeSchemasAction(
   args: CliCommandArguments<StoreManifestSchemasFlags>,
   context: CliCommandContext,
 ): Promise<Error | undefined> {
+  if (!SCHEMA_STORE_ENABLED) {
+    return undefined
+  }
+
   const flags = args.extOptions
 
   const schemaRequired = flags['schema-required']
   const workspaceName = flags.workspace
   const idPrefix = flags['id-prefix']
   const verbose = flags.verbose
+  const manifestDir = flags['manifest-dir']
 
-  if (typeof flags.path === 'boolean') throw new Error('Path is empty')
+  if (typeof manifestDir === 'boolean') throw new Error('Manifest directory is empty')
   if (typeof idPrefix === 'boolean') throw new Error('Id prefix is empty')
   if (typeof workspaceName === 'boolean') throw new Error('Workspace is empty')
 
@@ -70,7 +117,7 @@ export default async function storeSchemasAction(
 
   const spinner = output.spinner({}).start('Storing schemas')
 
-  const manifestPath = getManifestPath(context, flags.path)
+  const manifestPath = getManifestPath(context, manifestDir)
 
   try {
     const client = apiClient({
@@ -81,7 +128,7 @@ export default async function storeSchemasAction(
     const projectId = client.config().projectId
     if (!projectId) throw new Error('Project ID is not defined')
 
-    const manifest = readManifest(manifestPath, output, spinner)
+    const manifest = await readManifest(manifestPath, context, spinner)
 
     let storedCount = 0
 

package/src/_internal/cli/commands/app/deployCommand.ts

@@ -5,12 +5,14 @@ import {
 } from '@sanity/cli'
 
 import {type DeployStudioActionFlags} from '../../actions/deploy/deployAction'
+import {SCHEMA_STORE_ENABLED} from '../../actions/schema/storeSchemasAction'
 
 const helpText = `
 Options
   --source-maps Enable source maps for built bundles (increases size of bundle)
   --no-minify Skip minifying built JavaScript (speeds up build, increases size of bundle)
   --no-build Don't build the application prior to deploy, instead deploying the version currently in \`dist/\`
+  ${SCHEMA_STORE_ENABLED ? '--verbose Enable verbose logging for the schema store' : ''}
   -y, --yes Unattended mode, answers "yes" to any "yes/no" prompt and otherwise uses defaults
 
 Examples

package/src/_internal/cli/commands/index.ts

@@ -1,5 +1,6 @@
 import {type CliCommandDefinition, type CliCommandGroupDefinition} from '@sanity/cli'
 
+import {SCHEMA_STORE_ENABLED} from '../actions/schema/storeSchemasAction'
 import appGroup from './app/appGroup'
 import appBuildCommand from './app/buildCommand'
 import appDeployCommand from './app/deployCommand'
@@ -62,7 +63,8 @@ import inviteUserCommand from './users/inviteUserCommand'
 import listUsersCommand from './users/listUsersCommand'
 import usersGroup from './users/usersGroup'
 
-const commands: (CliCommandDefinition | CliCommandGroupDefinition)[] = [
+// Base commands that are always included
+const baseCommands: (CliCommandDefinition | CliCommandGroupDefinition)[] = [
   appGroup,
   appDeployCommand,
   appDevCommand,
@@ -118,12 +120,18 @@ const commands: (CliCommandDefinition | CliCommandGroupDefinition)[] = [
   validateSchemaCommand,
   extractSchemaCommand,
   previewCommand,
-  fetchSchemaCommand,
-  storeSchemaCommand,
   execCommand,
   manifestGroup,
   extractManifestCommand,
-  deleteSchemaCommand,
+]
+
+// Internal schema commands that are only included when enabled
+const internalSchemaCommands = [fetchSchemaCommand, storeSchemaCommand, deleteSchemaCommand]
+
+// Include experimental commands only when the feature flag is enabled
+const commands: (CliCommandDefinition | CliCommandGroupDefinition)[] = [
+  ...baseCommands,
+  ...(SCHEMA_STORE_ENABLED ? internalSchemaCommands : []),
 ]
 
 /**

package/src/_internal/cli/commands/schema/deleteSchemaCommand.ts

@@ -10,7 +10,7 @@ const helpText = `
 Options
   --ids <schema_id_1,schema_id_2,...> comma-separated list of schema IDs to delete
   --dataset <dataset_name> delete schemas from a specific dataset
-  --path <path> path to the manifest file if it is not in the default location
+  --manifest-dir <directory> directory containing your manifest file if it's not in the default location
 
 Examples
   # Delete single schema

package/src/_internal/cli/commands/schema/schemaListCommand.ts

@@ -10,7 +10,7 @@ const helpText = `
 Options
   --json get schemas as json
   --id <schema_id> fetch a specific schema by its ID
-  --path <path> path to your manifest file if it's not in the default location
+  --manifest-dir <directory> directory containing your manifest file if it's not in the default location
 
 Examples
   # Get full json schemas

package/src/_internal/cli/commands/schema/storeSchemaCommand.ts

@@ -2,16 +2,17 @@ import {type CliCommandArguments, type CliCommandDefinition} from '@sanity/cli'
 
 import {type StoreManifestSchemasFlags} from '../../actions/schema/storeSchemasAction'
 
-const description = 'Store schemas into the current dataset.'
+const description = 'Store schemas into workspace datasets.'
 
 const helpText = `
 **Note**: This command is experimental and subject to change.
 
 Options:
-  --workspace The name of the workspace to fetch the stored schema for
-  --path If you are not using the default static file path, you can specify it here.
-  --id-prefix you can specify a custom id prefix for the stored schemas. Useful if you want to store the schema in a different path than the default one.
-  --verbose Enable verbose logging
+  --workspace <workspace_name> store schema for a specific workspace
+  --manifest-dir <directory> directory containing your manifest file if it's not in the default location
+  --id-prefix <prefix> add a prefix to the schema ID
+  --schema-required fail if schema file is not found
+  --verbose print detailed information during store
 
 Examples
   # if no options are provided all workspace schemas will be stored

package/lib/_chunks-cjs/extractManifestAction.js

@@ -1,99 +0,0 @@
-"use strict";
-var node_crypto = require("node:crypto"), fs = require("node:fs/promises"), path = require("node:path"), node_worker_threads = require("node:worker_threads"), chalk = require("chalk"), dateFns = require("date-fns"), readPkgUp = require("read-pkg-up"), timing = require("./timing.js");
-function _interopDefaultCompat(e) {
-  return e && typeof e == "object" && "default" in e ? e : { default: e };
-}
-var chalk__default = /* @__PURE__ */ _interopDefaultCompat(chalk), readPkgUp__default = /* @__PURE__ */ _interopDefaultCompat(readPkgUp);
-const MANIFEST_FILENAME = "create-manifest.json", SCHEMA_FILENAME_SUFFIX = ".create-schema.json", TOOLS_FILENAME_SUFFIX = ".create-tools.json", FEATURE_ENABLED_ENV_NAME = "SANITY_CLI_EXTRACT_MANIFEST_ENABLED", EXTRACT_MANIFEST_ENABLED = process.env[FEATURE_ENABLED_ENV_NAME] !== "false", EXTRACT_MANIFEST_LOG_ERRORS = process.env.SANITY_CLI_EXTRACT_MANIFEST_LOG_ERRORS === "true", CREATE_TIMER = "create-manifest", EXTRACT_TASK_TIMEOUT_MS = dateFns.minutesToMilliseconds(2), EXTRACT_FAILURE_MESSAGE = `\u21B3 Couldn't extract manifest file. Sanity Create will not be available for the studio.
-  Disable this message with ${FEATURE_ENABLED_ENV_NAME}=false`;
-async function extractManifestSafe(args, context) {
-  if (EXTRACT_MANIFEST_ENABLED)
-    try {
-      await extractManifest(args, context);
-      return;
-    } catch (err) {
-      return EXTRACT_MANIFEST_LOG_ERRORS && context.output.error(err), err;
-    }
-}
-async function extractManifest(args, context) {
-  const {
-    output,
-    workDir
-  } = context, flags = args.extOptions, defaultOutputDir = path.resolve(path.join(workDir, "dist")), outputDir = path.resolve(defaultOutputDir), defaultStaticPath = path.join(outputDir, "static"), staticPath = flags.path ?? defaultStaticPath, path$1 = path.join(staticPath, MANIFEST_FILENAME), rootPkgPath = readPkgUp__default.default.sync({
-    cwd: __dirname
-  })?.path;
-  if (!rootPkgPath)
-    throw new Error("Could not find root directory for `sanity` package");
-  const timer = timing.getTimer();
-  timer.start(CREATE_TIMER);
-  const spinner = output.spinner({}).start("Extracting manifest");
-  try {
-    const workspaceManifests = await getWorkspaceManifests({
-      rootPkgPath,
-      workDir
-    });
-    await fs.mkdir(staticPath, {
-      recursive: !0
-    });
-    const workspaceFiles = await writeWorkspaceFiles(workspaceManifests, staticPath), manifest = {
-      /**
-       * Version history:
-       * 1: Initial release.
-       * 2: Added tools file.
-       */
-      version: 2,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      workspaces: workspaceFiles
-    };
-    await fs.writeFile(path$1, JSON.stringify(manifest, null, 2));
-    const manifestDuration = timer.end(CREATE_TIMER);
-    spinner.succeed(`Extracted manifest (${manifestDuration.toFixed()}ms)`);
-  } catch (err) {
-    throw spinner.fail(err.message), output.print(chalk__default.default.gray(EXTRACT_FAILURE_MESSAGE)), err;
-  }
-}
-async function getWorkspaceManifests({
-  rootPkgPath,
-  workDir
-}) {
-  const workerPath = path.join(path.dirname(rootPkgPath), "lib", "_internal", "cli", "threads", "extractManifest.js"), worker = new node_worker_threads.Worker(workerPath, {
-    workerData: {
-      workDir
-    },
-    // eslint-disable-next-line no-process-env
-    env: process.env
-  });
-  let timeout = !1;
-  const timeoutId = setTimeout(() => {
-    timeout = !0, worker.terminate();
-  }, EXTRACT_TASK_TIMEOUT_MS);
-  try {
-    return await new Promise((resolveWorkspaces, reject) => {
-      const buffer = [];
-      worker.addListener("message", (message) => buffer.push(message)), worker.addListener("exit", (exitCode) => {
-        exitCode === 0 ? resolveWorkspaces(buffer) : timeout && reject(new Error(`Extract manifest was aborted after ${EXTRACT_TASK_TIMEOUT_MS}ms`));
-      }), worker.addListener("error", reject);
-    });
-  } finally {
-    clearTimeout(timeoutId);
-  }
-}
-function writeWorkspaceFiles(manifestWorkspaces, staticPath) {
-  const output = manifestWorkspaces.reduce((workspaces, workspace) => [...workspaces, writeWorkspaceFile(workspace, staticPath)], []);
-  return Promise.all(output);
-}
-async function writeWorkspaceFile(workspace, staticPath) {
-  const [schemaFilename, toolsFilename] = await Promise.all([createFile(staticPath, workspace.schema, SCHEMA_FILENAME_SUFFIX), createFile(staticPath, workspace.tools, TOOLS_FILENAME_SUFFIX)]);
-  return {
-    ...workspace,
-    schema: schemaFilename,
-    tools: toolsFilename
-  };
-}
-const createFile = async (path$1, content, filenameSuffix) => {
-  const stringifiedContent = JSON.stringify(content, null, 2), filename = `${node_crypto.createHash("sha1").update(stringifiedContent).digest("hex").slice(0, 8)}${filenameSuffix}`;
-  return await fs.writeFile(path.join(path$1, filename), stringifiedContent), filename;
-};
-exports.MANIFEST_FILENAME = MANIFEST_FILENAME;
-exports.extractManifestSafe = extractManifestSafe;
-//# sourceMappingURL=extractManifestAction.js.map

package/lib/_chunks-cjs/extractManifestAction.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"extractManifestAction.js","sources":["../../src/_internal/cli/actions/manifest/extractManifestAction.ts"],"sourcesContent":["import {createHash} from 'node:crypto'\nimport {mkdir, writeFile} from 'node:fs/promises'\nimport {dirname, join, resolve} from 'node:path'\nimport {Worker} from 'node:worker_threads'\n\nimport {type CliCommandArguments, type CliCommandContext} from '@sanity/cli'\nimport chalk from 'chalk'\nimport {minutesToMilliseconds} from 'date-fns'\nimport readPkgUp from 'read-pkg-up'\n\nimport {\n  type CreateManifest,\n  type CreateWorkspaceManifest,\n  type ManifestWorkspaceFile,\n} from '../../../manifest/manifestTypes'\nimport {type ExtractManifestWorkerData} from '../../threads/extractManifest'\nimport {getTimer} from '../../util/timing'\n\nexport const MANIFEST_FILENAME = 'create-manifest.json'\nconst SCHEMA_FILENAME_SUFFIX = '.create-schema.json'\nconst TOOLS_FILENAME_SUFFIX = '.create-tools.json'\n\n/** Escape-hatch env flags to change action behavior */\nconst FEATURE_ENABLED_ENV_NAME = 'SANITY_CLI_EXTRACT_MANIFEST_ENABLED'\nconst EXTRACT_MANIFEST_ENABLED = process.env[FEATURE_ENABLED_ENV_NAME] !== 'false'\nconst EXTRACT_MANIFEST_LOG_ERRORS = process.env.SANITY_CLI_EXTRACT_MANIFEST_LOG_ERRORS === 'true'\n\nconst CREATE_TIMER = 'create-manifest'\n\nconst EXTRACT_TASK_TIMEOUT_MS = minutesToMilliseconds(2)\n\nconst EXTRACT_FAILURE_MESSAGE =\n  \"↳ Couldn't extract manifest file. Sanity Create will not be available for the studio.\\n\" +\n  `  Disable this message with ${FEATURE_ENABLED_ENV_NAME}=false`\n\ninterface ExtractFlags {\n  path?: string\n}\n\n/**\n * This function will never throw.\n * @returns `undefined` if extract succeeded - caught error if it failed\n */\nexport async function extractManifestSafe(\n  args: CliCommandArguments<ExtractFlags>,\n  context: CliCommandContext,\n): Promise<Error | undefined> {\n  if (!EXTRACT_MANIFEST_ENABLED) {\n    return undefined\n  }\n\n  try {\n    await extractManifest(args, context)\n    return undefined\n  } catch (err) {\n    if (EXTRACT_MANIFEST_LOG_ERRORS) {\n      context.output.error(err)\n    }\n    return err\n  }\n}\n\nasync function extractManifest(\n  args: CliCommandArguments<ExtractFlags>,\n  context: CliCommandContext,\n): Promise<void> {\n  const {output, workDir} = context\n\n  const flags = args.extOptions\n  const defaultOutputDir = resolve(join(workDir, 'dist'))\n\n  const outputDir = resolve(defaultOutputDir)\n  const defaultStaticPath = join(outputDir, 'static')\n\n  const staticPath = flags.path ?? defaultStaticPath\n\n  const path = join(staticPath, MANIFEST_FILENAME)\n\n  const rootPkgPath = readPkgUp.sync({cwd: __dirname})?.path\n  if (!rootPkgPath) {\n    throw new Error('Could not find root directory for `sanity` package')\n  }\n\n  const timer = getTimer()\n  timer.start(CREATE_TIMER)\n  const spinner = output.spinner({}).start('Extracting manifest')\n\n  try {\n    const workspaceManifests = await getWorkspaceManifests({rootPkgPath, workDir})\n    await mkdir(staticPath, {recursive: true})\n\n    const workspaceFiles = await writeWorkspaceFiles(workspaceManifests, staticPath)\n\n    const manifest: CreateManifest = {\n      /**\n       * Version history:\n       * 1: Initial release.\n       * 2: Added tools file.\n       */\n      version: 2,\n      createdAt: new Date().toISOString(),\n      workspaces: workspaceFiles,\n    }\n\n    await writeFile(path, JSON.stringify(manifest, null, 2))\n    const manifestDuration = timer.end(CREATE_TIMER)\n\n    spinner.succeed(`Extracted manifest (${manifestDuration.toFixed()}ms)`)\n  } catch (err) {\n    spinner.fail(err.message)\n    output.print(chalk.gray(EXTRACT_FAILURE_MESSAGE))\n    throw err\n  }\n}\n\nasync function getWorkspaceManifests({\n  rootPkgPath,\n  workDir,\n}: {\n  rootPkgPath: string\n  workDir: string\n}): Promise<CreateWorkspaceManifest[]> {\n  const workerPath = join(\n    dirname(rootPkgPath),\n    'lib',\n    '_internal',\n    'cli',\n    'threads',\n    'extractManifest.js',\n  )\n\n  const worker = new Worker(workerPath, {\n    workerData: {workDir} satisfies ExtractManifestWorkerData,\n    // eslint-disable-next-line no-process-env\n    env: process.env,\n  })\n\n  let timeout = false\n  const timeoutId = setTimeout(() => {\n    timeout = true\n    worker.terminate()\n  }, EXTRACT_TASK_TIMEOUT_MS)\n\n  try {\n    return await new Promise<CreateWorkspaceManifest[]>((resolveWorkspaces, reject) => {\n      const buffer: CreateWorkspaceManifest[] = []\n      worker.addListener('message', (message) => buffer.push(message))\n      worker.addListener('exit', (exitCode) => {\n        if (exitCode === 0) {\n          resolveWorkspaces(buffer)\n        } else if (timeout) {\n          reject(new Error(`Extract manifest was aborted after ${EXTRACT_TASK_TIMEOUT_MS}ms`))\n        }\n      })\n      worker.addListener('error', reject)\n    })\n  } finally {\n    clearTimeout(timeoutId)\n  }\n}\n\nfunction writeWorkspaceFiles(\n  manifestWorkspaces: CreateWorkspaceManifest[],\n  staticPath: string,\n): Promise<ManifestWorkspaceFile[]> {\n  const output = manifestWorkspaces.reduce<Promise<ManifestWorkspaceFile>[]>(\n    (workspaces, workspace) => {\n      return [...workspaces, writeWorkspaceFile(workspace, staticPath)]\n    },\n    [],\n  )\n  return Promise.all(output)\n}\n\nasync function writeWorkspaceFile(\n  workspace: CreateWorkspaceManifest,\n  staticPath: string,\n): Promise<ManifestWorkspaceFile> {\n  const [schemaFilename, toolsFilename] = await Promise.all([\n    createFile(staticPath, workspace.schema, SCHEMA_FILENAME_SUFFIX),\n    createFile(staticPath, workspace.tools, TOOLS_FILENAME_SUFFIX),\n  ])\n\n  return {\n    ...workspace,\n    schema: schemaFilename,\n    tools: toolsFilename,\n  }\n}\n\nconst createFile = async (path: string, content: any, filenameSuffix: string) => {\n  const stringifiedContent = JSON.stringify(content, null, 2)\n  const hash = createHash('sha1').update(stringifiedContent).digest('hex')\n  const filename = `${hash.slice(0, 8)}${filenameSuffix}`\n\n  // workspaces with identical data will overwrite each others file. This is ok, since they are identical and can be shared\n  await writeFile(join(path, filename), stringifiedContent)\n\n  return filename\n}\n"],"names":["MANIFEST_FILENAME","SCHEMA_FILENAME_SUFFIX","TOOLS_FILENAME_SUFFIX","FEATURE_ENABLED_ENV_NAME","EXTRACT_MANIFEST_ENABLED","process","env","EXTRACT_MANIFEST_LOG_ERRORS","SANITY_CLI_EXTRACT_MANIFEST_LOG_ERRORS","CREATE_TIMER","EXTRACT_TASK_TIMEOUT_MS","minutesToMilliseconds","EXTRACT_FAILURE_MESSAGE","extractManifestSafe","args","context","extractManifest","err","output","error","workDir","flags","extOptions","defaultOutputDir","resolve","join","outputDir","defaultStaticPath","staticPath","path","rootPkgPath","readPkgUp","sync","cwd","__dirname","Error","timer","getTimer","start","spinner","workspaceManifests","getWorkspaceManifests","mkdir","recursive","workspaceFiles","writeWorkspaceFiles","manifest","version","createdAt","Date","toISOString","workspaces","writeFile","JSON","stringify","manifestDuration","end","succeed","toFixed","fail","message","print","chalk","gray","workerPath","dirname","worker","Worker","workerData","timeout","timeoutId","setTimeout","terminate","Promise","resolveWorkspaces","reject","buffer","addListener","push","exitCode","clearTimeout","manifestWorkspaces","reduce","workspace","writeWorkspaceFile","all","schemaFilename","toolsFilename","createFile","schema","tools","content","filenameSuffix","stringifiedContent","filename","createHash","update","digest","slice"],"mappings":"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"}

package/lib/_chunks-cjs/storeSchemasAction.js

@@ -1,147 +0,0 @@
-"use strict";
-var fs = require("node:fs"), path = require("node:path"), chalk = require("chalk"), extractManifestAction = require("./extractManifestAction.js"), size = require("lodash/size.js"), sortBy = require("lodash/sortBy.js"), uniqBy = require("lodash/uniqBy.js");
-function _interopDefaultCompat(e) {
-  return e && typeof e == "object" && "default" in e ? e : { default: e };
-}
-var path__default = /* @__PURE__ */ _interopDefaultCompat(path), chalk__default = /* @__PURE__ */ _interopDefaultCompat(chalk), size__default = /* @__PURE__ */ _interopDefaultCompat(size), sortBy__default = /* @__PURE__ */ _interopDefaultCompat(sortBy), uniqBy__default = /* @__PURE__ */ _interopDefaultCompat(uniqBy);
-const SANITY_WORKSPACE_SCHEMA_TYPE = "sanity.workspace.schema", printSchemaList = ({
-  schemas,
-  output
-}) => {
-  const ordered = sortBy__default.default(schemas.map(({
-    _createdAt: createdAt,
-    _id: id,
-    workspace
-  }) => [id, workspace.name, workspace.dataset, workspace.projectId, createdAt].map(String)), ["createdAt"]), headings = ["Id", "Workspace", "Dataset", "ProjectId", "CreatedAt"], rows = ordered.reverse(), maxWidths = rows.reduce((max, row) => row.map((current, index) => Math.max(size__default.default(current), max[index])), headings.map((str) => size__default.default(str))), printRow = (row) => row.map((col, i) => `${col}`.padEnd(maxWidths[i])).join("   ");
-  output.print(chalk__default.default.cyan(printRow(headings))), rows.forEach((row) => output.print(printRow(row)));
-};
-async function fetchSchemaAction(args, context) {
-  const flags = args.extOptions, {
-    apiClient,
-    output
-  } = context, client = apiClient({
-    requireUser: !0,
-    requireProject: !0
-  }).withConfig({
-    apiVersion: "v2024-08-01"
-  }), projectId = client.config().projectId;
-  if (!projectId) {
-    output.error("Project ID must be defined.");
-    return;
-  }
-  const manifestPath = getManifestPath(context, flags.path), manifest = readManifest(manifestPath, output), schemas = (await Promise.allSettled(uniqBy__default.default(manifest.workspaces, "dataset").map(async (workspace) => (throwIfProjectIdMismatch(workspace, projectId), flags.id ? await client.withConfig({
-    dataset: workspace.dataset,
-    projectId: workspace.projectId
-  }).getDocument(flags.id) : await client.withConfig({
-    dataset: workspace.dataset,
-    projectId: workspace.projectId,
-    useCdn: !1
-  }).fetch("*[_type == $type]", {
-    type: SANITY_WORKSPACE_SCHEMA_TYPE
-  }))))).map((result, index) => {
-    if (result.status === "rejected") {
-      const workspace = manifest.workspaces[index];
-      return output.error(chalk__default.default.red(`Failed to fetch schemas for workspace '${workspace.name}': ${result.reason.message}`)), [];
-    }
-    return result.value;
-  }).flat();
-  if (schemas.length === 0) {
-    output.error("No schemas found");
-    return;
-  }
-  flags.json ? output.print(`${JSON.stringify(flags.id ? schemas[0] : schemas, null, 2)}`) : printSchemaList({
-    schemas,
-    output
-  });
-}
-var schemaListAction = /* @__PURE__ */ Object.freeze({
-  __proto__: null,
-  SANITY_WORKSPACE_SCHEMA_TYPE,
-  default: fetchSchemaAction
-});
-const getManifestPath = (context, customPath) => {
-  const defaultOutputDir = path.resolve(path.join(context.workDir, "dist")), outputDir = path.resolve(defaultOutputDir), defaultStaticPath = path.join(outputDir, "static"), staticPath = customPath ?? defaultStaticPath;
-  return path__default.default.resolve(process.cwd(), staticPath);
-}, readManifest = (readPath, output, spinner) => {
-  try {
-    return JSON.parse(fs.readFileSync(`${readPath}/${extractManifestAction.MANIFEST_FILENAME}`, "utf-8"));
-  } catch (error) {
-    const errorMessage = `Manifest not found at ${readPath}/${extractManifestAction.MANIFEST_FILENAME}`;
-    throw spinner && spinner.fail(errorMessage), output && output.error(errorMessage), error;
-  }
-}, throwIfProjectIdMismatch = (workspace, projectId) => {
-  if (workspace.projectId !== projectId)
-    throw new Error(`\u21B3 No permissions to store schema for workspace ${workspace.name} with projectId: ${workspace.projectId}`);
-};
-async function storeSchemasAction(args, context) {
-  const flags = args.extOptions, schemaRequired = flags["schema-required"], workspaceName = flags.workspace, idPrefix = flags["id-prefix"], verbose = flags.verbose;
-  if (typeof flags.path == "boolean") throw new Error("Path is empty");
-  if (typeof idPrefix == "boolean") throw new Error("Id prefix is empty");
-  if (typeof workspaceName == "boolean") throw new Error("Workspace is empty");
-  const {
-    output,
-    apiClient
-  } = context, spinner = output.spinner({}).start("Storing schemas"), manifestPath = getManifestPath(context, flags.path);
-  try {
-    const client = apiClient({
-      requireUser: !0,
-      requireProject: !0
-    }).withConfig({
-      apiVersion: "v2024-08-01"
-    }), projectId = client.config().projectId;
-    if (!projectId) throw new Error("Project ID is not defined");
-    const manifest = readManifest(manifestPath, output, spinner);
-    let storedCount = 0, error;
-    const saveSchema = async (workspace) => {
-      const id = `${idPrefix ? `${idPrefix}.` : ""}${SANITY_WORKSPACE_SCHEMA_TYPE}.${workspace.name}`;
-      try {
-        throwIfProjectIdMismatch(workspace, projectId);
-        const schema = JSON.parse(fs.readFileSync(`${manifestPath}/${workspace.schema}`, "utf-8"));
-        await client.withConfig({
-          dataset: workspace.dataset,
-          projectId: workspace.projectId
-        }).transaction().createOrReplace({
-          _type: SANITY_WORKSPACE_SCHEMA_TYPE,
-          _id: id,
-          workspace,
-          schema
-        }).commit(), storedCount++, spinner.text = `Stored ${storedCount} schemas so far...`, verbose && spinner.succeed(`Schema stored for workspace '${workspace.name}'`);
-      } catch (err) {
-        if (error = err, spinner.fail(`Error storing schema for workspace '${workspace.name}':
-${chalk__default.default.red(`${err.message}`)}`), schemaRequired) throw err;
-      } finally {
-        verbose && output.print(chalk__default.default.gray(`\u21B3 schemaId: ${id}, projectId: ${projectId}, dataset: ${workspace.dataset}`));
-      }
-    };
-    if (workspaceName) {
-      const workspaceToSave = manifest.workspaces.find((workspace) => workspace.name === workspaceName);
-      if (!workspaceToSave)
-        throw spinner.fail(`Workspace ${workspaceName} not found in manifest`), new Error(`Workspace ${workspaceName} not found in manifest: projectID: ${projectId}`);
-      await saveSchema(workspaceToSave), spinner.succeed("Stored 1 schemas");
-    } else
-      await Promise.all(manifest.workspaces.map(async (workspace) => {
-        await saveSchema(workspace);
-      })), spinner.succeed(`Stored ${storedCount}/${manifest.workspaces.length} schemas`);
-    if (error) throw error;
-    return;
-  } catch (err) {
-    if (schemaRequired) throw err;
-    return err;
-  } finally {
-    output.print(`${chalk__default.default.gray("\u21B3 List stored schemas with:")} ${chalk__default.default.cyan("sanity schema list")}`);
-  }
-}
-var storeSchemasAction$1 = /* @__PURE__ */ Object.freeze({
-  __proto__: null,
-  default: storeSchemasAction,
-  getManifestPath,
-  readManifest,
-  throwIfProjectIdMismatch
-});
-exports.getManifestPath = getManifestPath;
-exports.readManifest = readManifest;
-exports.schemaListAction = schemaListAction;
-exports.storeSchemasAction = storeSchemasAction;
-exports.storeSchemasAction$1 = storeSchemasAction$1;
-exports.throwIfProjectIdMismatch = throwIfProjectIdMismatch;
-//# sourceMappingURL=storeSchemasAction.js.map