@sanity/cli 6.0.0-alpha.9 → 6.1.0

package/dist/actions/manifest/extractAppManifest.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/actions/manifest/extractAppManifest.ts"],"sourcesContent":["import {getCliConfig} from '@sanity/cli-core'\nimport {spinner} from '@sanity/cli-core/ux'\n\nimport {getErrorMessage} from '../../util/getErrorMessage.js'\nimport {type DeployFlags} from '../deploy/types.js'\nimport {type AppManifest} from './types.js'\n\ninterface ExtractAppManifestOptions {\n  flags: DeployFlags\n  workDir: string\n}\n\n/**\n *\n * This functions slightly differently from the studio manifest extraction function.\n * We don't need to parse very complicated information like schemas and tools,\n * and we submit the manifest as a multipart form field instead of writing a file.\n */\nexport async function extractAppManifest(options: ExtractAppManifestOptions): Promise<AppManifest | undefined> {\n  const {workDir} = options\n\n  const spin = spinner('Extracting manifest').start()\n\n  try {\n    const {app} = await getCliConfig(workDir)\n    if (!app) {\n      // this is probably a problem for deployment, but not an issue for manifest extraction\n      spin.succeed('No app configuration found')\n      return undefined\n    }\n    const manifest: AppManifest = {\n      version: '1',\n      ...(app.icon ? {icon: app.icon} : {}),\n      ...(app.title ? {title: app.title} : {}),\n    }\n\n    spin.succeed(`Extracted manifest`)\n\n    return manifest\n  } catch (err) {\n    const message = getErrorMessage(err)\n    spin.fail(message)\n    throw err\n  }\n}\n\n/**\n * App manifests aren't required right now.\n * This function just ensures we're not uploading empty manifests\n * (so we can reduce noise in user-applications)\n */\nexport function appManifestHasData(manifest?: AppManifest | null): boolean {\n  if (!manifest || typeof manifest !== 'object' || Object.keys(manifest).length === 0) {\n    return false\n  }\n  const validAppManifestKeys = ['icon', 'title']\n  return validAppManifestKeys.some((key) => !!manifest[key as keyof AppManifest])\n}\n"],"names":["getCliConfig","spinner","getErrorMessage","extractAppManifest","options","workDir","spin","start","app","succeed","undefined","manifest","version","icon","title","err","message","fail","appManifestHasData","Object","keys","length","validAppManifestKeys","some","key"],"mappings":"AAAA,SAAQA,YAAY,QAAO,mBAAkB;AAC7C,SAAQC,OAAO,QAAO,sBAAqB;AAE3C,SAAQC,eAAe,QAAO,gCAA+B;AAS7D;;;;;CAKC,GACD,OAAO,eAAeC,mBAAmBC,OAAkC;IACzE,MAAM,EAACC,OAAO,EAAC,GAAGD;IAElB,MAAME,OAAOL,QAAQ,uBAAuBM,KAAK;IAEjD,IAAI;QACF,MAAM,EAACC,GAAG,EAAC,GAAG,MAAMR,aAAaK;QACjC,IAAI,CAACG,KAAK;YACR,sFAAsF;YACtFF,KAAKG,OAAO,CAAC;YACb,OAAOC;QACT;QACA,MAAMC,WAAwB;YAC5BC,SAAS;YACT,GAAIJ,IAAIK,IAAI,GAAG;gBAACA,MAAML,IAAIK,IAAI;YAAA,IAAI,CAAC,CAAC;YACpC,GAAIL,IAAIM,KAAK,GAAG;gBAACA,OAAON,IAAIM,KAAK;YAAA,IAAI,CAAC,CAAC;QACzC;QAEAR,KAAKG,OAAO,CAAC,CAAC,kBAAkB,CAAC;QAEjC,OAAOE;IACT,EAAE,OAAOI,KAAK;QACZ,MAAMC,UAAUd,gBAAgBa;QAChCT,KAAKW,IAAI,CAACD;QACV,MAAMD;IACR;AACF;AAEA;;;;CAIC,GACD,OAAO,SAASG,mBAAmBP,QAA6B;IAC9D,IAAI,CAACA,YAAY,OAAOA,aAAa,YAAYQ,OAAOC,IAAI,CAACT,UAAUU,MAAM,KAAK,GAAG;QACnF,OAAO;IACT;IACA,MAAMC,uBAAuB;QAAC;QAAQ;KAAQ;IAC9C,OAAOA,qBAAqBC,IAAI,CAAC,CAACC,MAAQ,CAAC,CAACb,QAAQ,CAACa,IAAyB;AAChF"}
+{"version":3,"sources":["../../../src/actions/manifest/extractAppManifest.ts"],"sourcesContent":["import {readFile} from 'node:fs/promises'\nimport {relative, resolve} from 'node:path'\n\nimport {getCliConfig} from '@sanity/cli-core'\nimport {spinner} from '@sanity/cli-core/ux'\n\nimport {getErrorMessage} from '../../util/getErrorMessage.js'\nimport {type AppManifest} from './types.js'\n\ninterface ExtractAppManifestOptions {\n  workDir: string\n}\n\n/**\n * Resolves app.icon from config (a file path) to an SVG string for the manifest.\n * The manifest expects the SVG string inline, not a path.\n * Brett sanitizes SVGs so it's skipped here.\n */\nasync function readIconFromPath(workDir: string, iconPath: string): Promise<string> {\n  const resolvedPath = resolve(workDir, iconPath)\n  const pathRelativeToWorkDir = relative(workDir, resolvedPath)\n  if (pathRelativeToWorkDir.startsWith('..')) {\n    throw new Error(\n      `Icon path \"${iconPath}\" resolves outside the project directory and is not allowed.`,\n    )\n  }\n\n  let content: string\n  try {\n    content = await readFile(resolvedPath, 'utf8')\n  } catch (err) {\n    const message = err instanceof Error ? err.message : String(err)\n    throw new Error(\n      `Could not read icon file at \"${iconPath}\" (resolved: ${resolvedPath}): ${message}`,\n    )\n  }\n\n  const trimmed = content.trim()\n  if (!/<svg[\\s>]/i.test(trimmed)) {\n    throw new Error(\n      `Icon file at \"${iconPath}\" does not contain an SVG element. App manifest icons must be SVG files.`,\n    )\n  }\n\n  return trimmed\n}\n\n/**\n *\n * This functions slightly differently from the studio manifest extraction function.\n * We don't need to parse very complicated information like schemas and tools.\n * The app icon in config is a file path (e.g. relative to project root); its content is read and inlined in the manifest.\n */\nexport async function extractAppManifest(\n  options: ExtractAppManifestOptions,\n): Promise<AppManifest | undefined> {\n  const {workDir} = options\n  const {app} = await getCliConfig(workDir)\n  if (!app) {\n    return undefined\n  }\n\n  const spin = spinner('Extracting manifest').start()\n\n  try {\n    let icon: string | undefined\n    if (app.icon) {\n      icon = await readIconFromPath(workDir, app.icon)\n    }\n\n    if (!icon && !app.title) {\n      spin.succeed('Manifest creation skipped: no icon or title found in app configuration')\n      return undefined\n    }\n\n    const manifest: AppManifest = {\n      version: '1',\n      ...(icon ? {icon} : {}),\n      ...(app.title ? {title: app.title} : {}),\n    }\n\n    spin.succeed(`Extracted manifest`)\n\n    return manifest\n  } catch (err) {\n    const message = getErrorMessage(err)\n    spin.fail(message)\n    throw err\n  }\n}\n"],"names":["readFile","relative","resolve","getCliConfig","spinner","getErrorMessage","readIconFromPath","workDir","iconPath","resolvedPath","pathRelativeToWorkDir","startsWith","Error","content","err","message","String","trimmed","trim","test","extractAppManifest","options","app","undefined","spin","start","icon","title","succeed","manifest","version","fail"],"mappings":"AAAA,SAAQA,QAAQ,QAAO,mBAAkB;AACzC,SAAQC,QAAQ,EAAEC,OAAO,QAAO,YAAW;AAE3C,SAAQC,YAAY,QAAO,mBAAkB;AAC7C,SAAQC,OAAO,QAAO,sBAAqB;AAE3C,SAAQC,eAAe,QAAO,gCAA+B;AAO7D;;;;CAIC,GACD,eAAeC,iBAAiBC,OAAe,EAAEC,QAAgB;IAC/D,MAAMC,eAAeP,QAAQK,SAASC;IACtC,MAAME,wBAAwBT,SAASM,SAASE;IAChD,IAAIC,sBAAsBC,UAAU,CAAC,OAAO;QAC1C,MAAM,IAAIC,MACR,CAAC,WAAW,EAAEJ,SAAS,4DAA4D,CAAC;IAExF;IAEA,IAAIK;IACJ,IAAI;QACFA,UAAU,MAAMb,SAASS,cAAc;IACzC,EAAE,OAAOK,KAAK;QACZ,MAAMC,UAAUD,eAAeF,QAAQE,IAAIC,OAAO,GAAGC,OAAOF;QAC5D,MAAM,IAAIF,MACR,CAAC,6BAA6B,EAAEJ,SAAS,aAAa,EAAEC,aAAa,GAAG,EAAEM,SAAS;IAEvF;IAEA,MAAME,UAAUJ,QAAQK,IAAI;IAC5B,IAAI,CAAC,aAAaC,IAAI,CAACF,UAAU;QAC/B,MAAM,IAAIL,MACR,CAAC,cAAc,EAAEJ,SAAS,wEAAwE,CAAC;IAEvG;IAEA,OAAOS;AACT;AAEA;;;;;CAKC,GACD,OAAO,eAAeG,mBACpBC,OAAkC;IAElC,MAAM,EAACd,OAAO,EAAC,GAAGc;IAClB,MAAM,EAACC,GAAG,EAAC,GAAG,MAAMnB,aAAaI;IACjC,IAAI,CAACe,KAAK;QACR,OAAOC;IACT;IAEA,MAAMC,OAAOpB,QAAQ,uBAAuBqB,KAAK;IAEjD,IAAI;QACF,IAAIC;QACJ,IAAIJ,IAAII,IAAI,EAAE;YACZA,OAAO,MAAMpB,iBAAiBC,SAASe,IAAII,IAAI;QACjD;QAEA,IAAI,CAACA,QAAQ,CAACJ,IAAIK,KAAK,EAAE;YACvBH,KAAKI,OAAO,CAAC;YACb,OAAOL;QACT;QAEA,MAAMM,WAAwB;YAC5BC,SAAS;YACT,GAAIJ,OAAO;gBAACA;YAAI,IAAI,CAAC,CAAC;YACtB,GAAIJ,IAAIK,KAAK,GAAG;gBAACA,OAAOL,IAAIK,KAAK;YAAA,IAAI,CAAC,CAAC;QACzC;QAEAH,KAAKI,OAAO,CAAC,CAAC,kBAAkB,CAAC;QAEjC,OAAOC;IACT,EAAE,OAAOf,KAAK;QACZ,MAAMC,UAAUV,gBAAgBS;QAChCU,KAAKO,IAAI,CAAChB;QACV,MAAMD;IACR;AACF"}

package/dist/actions/manifest/extractManifest.js

@@ -1,93 +1,42 @@
-import { createHash } from 'node:crypto';
-import { mkdir, writeFile } from 'node:fs/promises';
-import { join, resolve } from 'node:path';
-import { getTimer } from '@sanity/cli-core';
+import { findProjectRoot, getTimer, studioWorkerTask } from '@sanity/cli-core';
 import { spinner } from '@sanity/cli-core/ux';
-import { importStudioConfig } from '../../util/importStudioConfig.js';
-import { readModuleVersion } from '../../util/readModuleVersion.js';
-import { extractWorkspaceManifest } from './extractWorkspaceManifest.js';
-export const MANIFEST_FILENAME = 'create-manifest.json';
-const SCHEMA_FILENAME_SUFFIX = '.create-schema.json';
-const TOOLS_FILENAME_SUFFIX = '.create-tools.json';
-/** Escape-hatch env flags to change action behavior */ const FEATURE_ENABLED_ENV_NAME = 'SANITY_CLI_EXTRACT_MANIFEST_ENABLED';
-const EXTRACT_MANIFEST_ENABLED = process.env[FEATURE_ENABLED_ENV_NAME] !== 'false';
-const EXTRACT_MANIFEST_LOG_ERRORS = process.env.SANITY_CLI_EXTRACT_MANIFEST_LOG_ERRORS === 'true';
+import { SchemaExtractionError } from '../schema/utils/SchemaExtractionError.js';
+import { manifestDebug } from './debug.js';
+import { writeManifestFile } from './writeManifestFile.js';
 const CREATE_TIMER = 'create-manifest';
-/**
- * This function will never throw.
- * @returns `undefined` if extract succeeded - caught error if it failed
- */ export async function extractManifestSafe(options) {
-    if (!EXTRACT_MANIFEST_ENABLED) {
-        return undefined;
-    }
-    try {
-        await extractManifest(options);
-        return undefined;
-    } catch (err) {
-        if (EXTRACT_MANIFEST_LOG_ERRORS) {
-            options.output.error(err);
-        }
-        return err;
-    }
-}
-async function extractManifest(options) {
-    const { flags, workDir } = options;
-    const staticPath = resolve(join(workDir, flags.path));
-    const path = join(staticPath, MANIFEST_FILENAME);
+export async function extractManifest(outPath) {
+    const projectRoot = await findProjectRoot(process.cwd());
+    manifestDebug('Project root %o', projectRoot);
+    const workDir = projectRoot.directory;
+    const configPath = projectRoot.path;
     const timer = getTimer();
     timer.start(CREATE_TIMER);
     const spin = spinner('Extracting manifest').start();
     try {
-        const workspaceManifests = await getWorkspaceManifests(workDir);
-        await mkdir(staticPath, {
-            recursive: true
+        const result = await studioWorkerTask(new URL('extractManifest.worker.js', import.meta.url), {
+            name: 'extractManifest',
+            studioRootPath: workDir,
+            workerData: {
+                configPath,
+                workDir
+            }
+        });
+        manifestDebug('Result %o', result);
+        if (result.type === 'error') {
+            throw new SchemaExtractionError(result.error, result.validation);
+        }
+        await writeManifestFile({
+            outPath,
+            workDir,
+            workspaceManifests: result.workspaceManifests
         });
-        const workspaceFiles = await writeWorkspaceFiles(workspaceManifests, staticPath);
-        const manifest = {
-            /**
-       * Version history:
-       * 1: Initial release.
-       * 2: Added tools file.
-       * 3. Added studioVersion field.
-       */ createdAt: new Date().toISOString(),
-            studioVersion: await readModuleVersion(workDir, 'sanity'),
-            version: 3,
-            workspaces: workspaceFiles
-        };
-        await writeFile(path, JSON.stringify(manifest, null, 2));
         const manifestDuration = timer.end(CREATE_TIMER);
         spin.succeed(`Extracted manifest (${manifestDuration.toFixed(0)}ms)`);
     } catch (err) {
-        spin.fail(err.message);
+        manifestDebug('Error extracting manifest', err);
+        spin.fail();
         throw err;
     }
 }
-async function getWorkspaceManifests(workDir) {
-    const workspaces = await importStudioConfig(workDir);
-    return await extractWorkspaceManifest(workspaces);
-}
-function writeWorkspaceFiles(manifestWorkspaces, staticPath) {
-    const output = manifestWorkspaces.map((workspace)=>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, content, filenameSuffix)=>{
-    const stringifiedContent = JSON.stringify(content, null, 2);
-    const hash = createHash('sha1').update(stringifiedContent).digest('hex');
-    const filename = `${hash.slice(0, 8)}${filenameSuffix}`;
-    // workspaces with identical data will overwrite each others file. This is ok, since they are identical and can be shared
-    await writeFile(join(path, filename), stringifiedContent);
-    return filename;
-};
 
 //# sourceMappingURL=extractManifest.js.map

package/dist/actions/manifest/extractManifest.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/actions/manifest/extractManifest.ts"],"sourcesContent":["import {createHash} from 'node:crypto'\nimport {mkdir, writeFile} from 'node:fs/promises'\nimport {join, resolve} from 'node:path'\n\nimport {getTimer, Output} from '@sanity/cli-core'\nimport {spinner} from '@sanity/cli-core/ux'\nimport {type Workspace} from 'sanity'\n\nimport {type ExtractManifestCommand} from '../../commands/manifest/extract'\nimport {importStudioConfig} from '../../util/importStudioConfig.js'\nimport {readModuleVersion} from '../../util/readModuleVersion.js'\nimport {extractWorkspaceManifest} from './extractWorkspaceManifest.js'\nimport {\n  type CreateManifest,\n  type CreateWorkspaceManifest,\n  type ManifestWorkspaceFile,\n} from './types'\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\ninterface ExtractManifestOptions {\n  flags: ExtractManifestCommand['flags']\n  output: Output\n  workDir: 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  options: ExtractManifestOptions,\n): Promise<Error | undefined> {\n  if (!EXTRACT_MANIFEST_ENABLED) {\n    return undefined\n  }\n\n  try {\n    await extractManifest(options)\n    return undefined\n  } catch (err) {\n    if (EXTRACT_MANIFEST_LOG_ERRORS) {\n      options.output.error(err)\n    }\n    return err\n  }\n}\n\nasync function extractManifest(options: ExtractManifestOptions): Promise<void> {\n  const {flags, workDir} = options\n  const staticPath = resolve(join(workDir, flags.path))\n  const path = join(staticPath, MANIFEST_FILENAME)\n\n  const timer = getTimer()\n  timer.start(CREATE_TIMER)\n  const spin = spinner('Extracting manifest').start()\n\n  try {\n    const workspaceManifests = await getWorkspaceManifests(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       * 3. Added studioVersion field.\n       */\n      createdAt: new Date().toISOString(),\n      studioVersion: await readModuleVersion(workDir, 'sanity'),\n      version: 3,\n      workspaces: workspaceFiles,\n    }\n\n    await writeFile(path, JSON.stringify(manifest, null, 2))\n    const manifestDuration = timer.end(CREATE_TIMER)\n\n    spin.succeed(`Extracted manifest (${manifestDuration.toFixed(0)}ms)`)\n  } catch (err) {\n    spin.fail(err.message)\n    throw err\n  }\n}\n\nasync function getWorkspaceManifests(workDir: string): Promise<CreateWorkspaceManifest[]> {\n  const workspaces = await importStudioConfig(workDir)\n  return await extractWorkspaceManifest(workspaces as unknown as Workspace[])\n}\n\nfunction writeWorkspaceFiles(\n  manifestWorkspaces: CreateWorkspaceManifest[],\n  staticPath: string,\n): Promise<ManifestWorkspaceFile[]> {\n  const output = manifestWorkspaces.map((workspace) => writeWorkspaceFile(workspace, staticPath))\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: unknown, 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":["createHash","mkdir","writeFile","join","resolve","getTimer","spinner","importStudioConfig","readModuleVersion","extractWorkspaceManifest","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","extractManifestSafe","options","undefined","extractManifest","err","output","error","flags","workDir","staticPath","path","timer","start","spin","workspaceManifests","getWorkspaceManifests","recursive","workspaceFiles","writeWorkspaceFiles","manifest","createdAt","Date","toISOString","studioVersion","version","workspaces","JSON","stringify","manifestDuration","end","succeed","toFixed","fail","message","manifestWorkspaces","map","workspace","writeWorkspaceFile","Promise","all","schemaFilename","toolsFilename","createFile","schema","tools","content","filenameSuffix","stringifiedContent","hash","update","digest","filename","slice"],"mappings":"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"}
+{"version":3,"sources":["../../../src/actions/manifest/extractManifest.ts"],"sourcesContent":["import {findProjectRoot, getTimer, studioWorkerTask} from '@sanity/cli-core'\nimport {spinner} from '@sanity/cli-core/ux'\n\nimport {type ExtractSchemaWorkerError} from '../schema/types.js'\nimport {SchemaExtractionError} from '../schema/utils/SchemaExtractionError.js'\nimport {manifestDebug} from './debug.js'\nimport {type CreateWorkspaceManifest, type ExtractManifestWorkerData} from './types'\nimport {writeManifestFile} from './writeManifestFile.js'\n\nconst CREATE_TIMER = 'create-manifest'\n\ninterface ExtractManifestWorkerResult {\n  type: 'success'\n  workspaceManifests: CreateWorkspaceManifest[]\n}\n\ntype ExtractManifestWorkerMessage = ExtractManifestWorkerResult | ExtractSchemaWorkerError\n\nexport async function extractManifest(outPath: string): Promise<void> {\n  const projectRoot = await findProjectRoot(process.cwd())\n\n  manifestDebug('Project root %o', projectRoot)\n\n  const workDir = projectRoot.directory\n  const configPath = projectRoot.path\n\n  const timer = getTimer()\n  timer.start(CREATE_TIMER)\n  const spin = spinner('Extracting manifest').start()\n\n  try {\n    const result = await studioWorkerTask<ExtractManifestWorkerMessage>(\n      new URL('extractManifest.worker.js', import.meta.url),\n      {\n        name: 'extractManifest',\n        studioRootPath: workDir,\n        workerData: {configPath, workDir} satisfies ExtractManifestWorkerData,\n      },\n    )\n\n    manifestDebug('Result %o', result)\n\n    if (result.type === 'error') {\n      throw new SchemaExtractionError(result.error, result.validation)\n    }\n\n    await writeManifestFile({\n      outPath,\n      workDir,\n      workspaceManifests: result.workspaceManifests,\n    })\n\n    const manifestDuration = timer.end(CREATE_TIMER)\n\n    spin.succeed(`Extracted manifest (${manifestDuration.toFixed(0)}ms)`)\n  } catch (err) {\n    manifestDebug('Error extracting manifest', err)\n    spin.fail()\n\n    throw err\n  }\n}\n"],"names":["findProjectRoot","getTimer","studioWorkerTask","spinner","SchemaExtractionError","manifestDebug","writeManifestFile","CREATE_TIMER","extractManifest","outPath","projectRoot","process","cwd","workDir","directory","configPath","path","timer","start","spin","result","URL","url","name","studioRootPath","workerData","type","error","validation","workspaceManifests","manifestDuration","end","succeed","toFixed","err","fail"],"mappings":"AAAA,SAAQA,eAAe,EAAEC,QAAQ,EAAEC,gBAAgB,QAAO,mBAAkB;AAC5E,SAAQC,OAAO,QAAO,sBAAqB;AAG3C,SAAQC,qBAAqB,QAAO,2CAA0C;AAC9E,SAAQC,aAAa,QAAO,aAAY;AAExC,SAAQC,iBAAiB,QAAO,yBAAwB;AAExD,MAAMC,eAAe;AASrB,OAAO,eAAeC,gBAAgBC,OAAe;IACnD,MAAMC,cAAc,MAAMV,gBAAgBW,QAAQC,GAAG;IAErDP,cAAc,mBAAmBK;IAEjC,MAAMG,UAAUH,YAAYI,SAAS;IACrC,MAAMC,aAAaL,YAAYM,IAAI;IAEnC,MAAMC,QAAQhB;IACdgB,MAAMC,KAAK,CAACX;IACZ,MAAMY,OAAOhB,QAAQ,uBAAuBe,KAAK;IAEjD,IAAI;QACF,MAAME,SAAS,MAAMlB,iBACnB,IAAImB,IAAI,6BAA6B,YAAYC,GAAG,GACpD;YACEC,MAAM;YACNC,gBAAgBX;YAChBY,YAAY;gBAACV;gBAAYF;YAAO;QAClC;QAGFR,cAAc,aAAae;QAE3B,IAAIA,OAAOM,IAAI,KAAK,SAAS;YAC3B,MAAM,IAAItB,sBAAsBgB,OAAOO,KAAK,EAAEP,OAAOQ,UAAU;QACjE;QAEA,MAAMtB,kBAAkB;YACtBG;YACAI;YACAgB,oBAAoBT,OAAOS,kBAAkB;QAC/C;QAEA,MAAMC,mBAAmBb,MAAMc,GAAG,CAACxB;QAEnCY,KAAKa,OAAO,CAAC,CAAC,oBAAoB,EAAEF,iBAAiBG,OAAO,CAAC,GAAG,GAAG,CAAC;IACtE,EAAE,OAAOC,KAAK;QACZ7B,cAAc,6BAA6B6B;QAC3Cf,KAAKgB,IAAI;QAET,MAAMD;IACR;AACF"}

package/dist/actions/manifest/extractManifest.worker.js

@@ -0,0 +1,30 @@
+import { isMainThread, parentPort, workerData } from 'node:worker_threads';
+import { getStudioWorkspaces, subdebug } from '@sanity/cli-core';
+import { extractValidationFromSchemaError } from '../schema/utils/extractValidationFromSchemaError.js';
+import { extractWorkspaceManifest } from './extractWorkspaceManifest.js';
+import { extractManifestWorkerData } from './types.js';
+if (isMainThread || !parentPort) {
+    throw new Error('Should only be run in a worker!');
+}
+const debug = subdebug('extractManifest.worker');
+const { configPath, workDir } = extractManifestWorkerData.parse(workerData);
+try {
+    debug('Extracting workspace manifests from config path %s', configPath);
+    const workspaces = await getStudioWorkspaces(configPath);
+    debug('Workspaces %o', workspaces);
+    const workspaceManifests = await extractWorkspaceManifest(workspaces, workDir);
+    parentPort.postMessage({
+        type: 'success',
+        workspaceManifests
+    });
+} catch (error) {
+    debug('Error extracting workspace manifests', error);
+    const validation = await extractValidationFromSchemaError(error, workDir);
+    parentPort.postMessage({
+        error: error instanceof Error ? error.message : String(error),
+        type: 'error',
+        validation
+    });
+}
+
+//# sourceMappingURL=extractManifest.worker.js.map

package/dist/actions/manifest/extractManifest.worker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/manifest/extractManifest.worker.ts"],"sourcesContent":["import {isMainThread, parentPort, workerData} from 'node:worker_threads'\n\nimport {getStudioWorkspaces, subdebug} from '@sanity/cli-core'\n\nimport {extractValidationFromSchemaError} from '../schema/utils/extractValidationFromSchemaError.js'\nimport {extractWorkspaceManifest} from './extractWorkspaceManifest.js'\nimport {extractManifestWorkerData} from './types.js'\n\nif (isMainThread || !parentPort) {\n  throw new Error('Should only be run in a worker!')\n}\n\nconst debug = subdebug('extractManifest.worker')\n\nconst {configPath, workDir} = extractManifestWorkerData.parse(workerData)\n\ntry {\n  debug('Extracting workspace manifests from config path %s', configPath)\n  const workspaces = await getStudioWorkspaces(configPath)\n  debug('Workspaces %o', workspaces)\n  const workspaceManifests = await extractWorkspaceManifest(workspaces, workDir)\n\n  parentPort.postMessage({\n    type: 'success',\n    workspaceManifests,\n  })\n} catch (error) {\n  debug('Error extracting workspace manifests', error)\n  const validation = await extractValidationFromSchemaError(error, workDir)\n  parentPort.postMessage({\n    error: error instanceof Error ? error.message : String(error),\n    type: 'error',\n    validation,\n  })\n}\n"],"names":["isMainThread","parentPort","workerData","getStudioWorkspaces","subdebug","extractValidationFromSchemaError","extractWorkspaceManifest","extractManifestWorkerData","Error","debug","configPath","workDir","parse","workspaces","workspaceManifests","postMessage","type","error","validation","message","String"],"mappings":"AAAA,SAAQA,YAAY,EAAEC,UAAU,EAAEC,UAAU,QAAO,sBAAqB;AAExE,SAAQC,mBAAmB,EAAEC,QAAQ,QAAO,mBAAkB;AAE9D,SAAQC,gCAAgC,QAAO,sDAAqD;AACpG,SAAQC,wBAAwB,QAAO,gCAA+B;AACtE,SAAQC,yBAAyB,QAAO,aAAY;AAEpD,IAAIP,gBAAgB,CAACC,YAAY;IAC/B,MAAM,IAAIO,MAAM;AAClB;AAEA,MAAMC,QAAQL,SAAS;AAEvB,MAAM,EAACM,UAAU,EAAEC,OAAO,EAAC,GAAGJ,0BAA0BK,KAAK,CAACV;AAE9D,IAAI;IACFO,MAAM,sDAAsDC;IAC5D,MAAMG,aAAa,MAAMV,oBAAoBO;IAC7CD,MAAM,iBAAiBI;IACvB,MAAMC,qBAAqB,MAAMR,yBAAyBO,YAAYF;IAEtEV,WAAWc,WAAW,CAAC;QACrBC,MAAM;QACNF;IACF;AACF,EAAE,OAAOG,OAAO;IACdR,MAAM,wCAAwCQ;IAC9C,MAAMC,aAAa,MAAMb,iCAAiCY,OAAON;IACjEV,WAAWc,WAAW,CAAC;QACrBE,OAAOA,iBAAiBT,QAAQS,MAAME,OAAO,GAAGC,OAAOH;QACvDD,MAAM;QACNE;IACF;AACF"}

package/dist/actions/manifest/extractWorkspaceManifest.js

@@ -1,25 +1,24 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import DOMPurify from 'isomorphic-dompurify';
-import startCase from 'lodash-es/startCase.js';
-import { renderToString } from 'react-dom/server';
-import { ConcreteRuleClass, createSchema } from 'sanity';
-import { ServerStyleSheet } from 'styled-components';
-import { config } from './purifyConfig.js';
-import { SchemaIcon } from './SchemaIcon.js';
-import { getCustomFields, getDefinedTypeName, isCrossDatasetReference, isCustomized, isDefined, isGlobalDocumentReference, isPrimitive, isRecord, isReference, isString, isType } from './schemaTypeHelpers.js';
-const MAX_CUSTOM_PROPERTY_DEPTH = 5;
-export function extractWorkspaceManifest(workspaces) {
-    return workspaces.map((workspace)=>{
-        const serializedSchema = extractManifestSchemaTypes(workspace.schema);
-        const serializedTools = extractManifestTools(workspace.tools);
-        return {
-            basePath: workspace.basePath,
-            dataset: workspace.dataset,
-            icon: resolveIcon({
+import { resolveLocalPackage } from '@sanity/cli-core';
+import { resolveIcon } from './iconResolver.js';
+import { transformType } from './schemaTypeTransformer.js';
+/**
+ * Extracts manifest data from an array of workspaces
+ */ export function extractWorkspaceManifest(workspaces, workDir) {
+    return Promise.all(workspaces.map(async (workspace)=>{
+        const [icon, serializedSchema, serializedTools] = await Promise.all([
+            resolveIcon({
                 icon: workspace.icon,
                 subtitle: workspace.subtitle,
-                title: workspace.title
+                title: workspace.title,
+                workDir
             }),
+            extractManifestSchemaTypes(workspace.schema, workDir),
+            extractManifestTools(workspace.tools, workDir)
+        ]);
+        return {
+            basePath: workspace.basePath,
+            dataset: workspace.dataset,
+            icon,
             mediaLibrary: workspace.mediaLibrary,
             name: workspace.name,
             projectId: workspace.projectId,
@@ -28,379 +27,39 @@ export function extractWorkspaceManifest(workspaces) {
             title: workspace.title,
             tools: serializedTools
         };
-    });
+    }));
 }
 /**
  * Extracts all serializable properties from userland schema types,
- * so they best-effort can be used as definitions for Schema.compile
-. */ function extractManifestSchemaTypes(schema) {
+ * so they best-effort can be used as definitions for Schema.compile.
+ *
+ * @internal
+ */ export async function extractManifestSchemaTypes(schema, workDir) {
     const typeNames = schema.getTypeNames();
     const context = {
         schema
     };
+    const { createSchema } = await resolveLocalPackage('sanity', workDir);
     const studioDefaultTypeNames = createSchema({
         name: 'default',
         types: []
     }).getTypeNames();
     return typeNames.filter((typeName)=>!studioDefaultTypeNames.includes(typeName)).map((typeName)=>schema.get(typeName)).filter((type)=>type !== undefined).map((type)=>transformType(type, context));
 }
-function transformCommonTypeFields(type, typeName, context) {
-    const arrayProps = typeName === 'array' && type.jsonType === 'array' ? transformArrayMember(type, context) : {};
-    const referenceProps = isReference(type) ? transformReference(type) : {};
-    const crossDatasetRefProps = isCrossDatasetReference(type) ? transformCrossDatasetReference(type) : {};
-    const globalRefProps = isGlobalDocumentReference(type) ? transformGlobalDocumentReference(type) : {};
-    const objectFields = type.jsonType === 'object' && type.type && isCustomized(type) ? {
-        fields: getCustomFields(type).map((objectField)=>transformField(objectField, context))
-    } : {};
-    return {
-        ...retainCustomTypeProps(type),
-        ...transformValidation(type.validation),
-        ...ensureString('description', type.description),
-        ...objectFields,
-        ...arrayProps,
-        ...referenceProps,
-        ...crossDatasetRefProps,
-        ...globalRefProps,
-        ...ensureConditional('readOnly', type.readOnly),
-        ...ensureConditional('hidden', type.hidden),
-        ...transformFieldsets(type),
-        // fieldset prop gets instrumented via getCustomFields
-        ...ensureString('fieldset', type.fieldset),
-        ...transformBlockType(type, context)
-    };
-}
-function transformFieldsets(type) {
-    if (type.jsonType !== 'object') {
-        return {};
-    }
-    const fieldsets = type.fieldsets?.filter((fs)=>!fs.single).map((fs)=>{
-        const options = isRecord(fs.options) ? {
-            options: retainSerializableProps(fs.options)
-        } : {};
-        return {
-            name: fs.name,
-            ...ensureCustomTitle(fs.name, fs.title),
-            ...ensureString('description', fs.description),
-            ...ensureConditional('readOnly', fs.readOnly),
-            ...ensureConditional('hidden', fs.hidden),
-            ...options
-        };
-    });
-    return fieldsets?.length ? {
-        fieldsets
-    } : {};
-}
-function transformType(type, context) {
-    const typeName = type.type ? type.type.name : type.jsonType;
-    return {
-        ...transformCommonTypeFields(type, typeName, context),
-        name: type.name,
-        type: typeName,
-        ...ensureCustomTitle(type.name, type.title)
-    };
-}
-function retainCustomTypeProps(type) {
-    const manuallySerializedFields = new Set([
-        '__experimental_actions',
-        '__experimental_formPreviewTitle',
-        '__experimental_omnisearch_visibility',
-        '__experimental_search',
-        'components',
-        'description',
-        'fields',
-        'fieldsets',
-        //only exists on fields
-        'group',
-        'groups',
-        'hidden',
-        'icon',
-        'jsonType',
-        //explicitly added
-        'name',
-        'of',
-        'orderings',
-        'preview',
-        'readOnly',
-        'title',
-        'to',
-        // not serialized
-        'type',
-        'validation'
-    ]);
-    const typeWithoutManuallyHandledFields = Object.fromEntries(Object.entries(type).filter(([key])=>!manuallySerializedFields.has(key)));
-    return retainSerializableProps(typeWithoutManuallyHandledFields);
-}
-function retainSerializableProps(maybeSerializable, depth = 0) {
-    if (depth > MAX_CUSTOM_PROPERTY_DEPTH) {
-        return undefined;
-    }
-    if (!isDefined(maybeSerializable)) {
-        return undefined;
-    }
-    if (isPrimitive(maybeSerializable)) {
-        // cull empty strings
-        if (maybeSerializable === '') {
-            return undefined;
-        }
-        return maybeSerializable;
-    }
-    // url-schemes ect..
-    if (maybeSerializable instanceof RegExp) {
-        return maybeSerializable.toString();
-    }
-    if (Array.isArray(maybeSerializable)) {
-        const arrayItems = maybeSerializable.map((item)=>retainSerializableProps(item, depth + 1)).filter((item)=>isDefined(item));
-        return arrayItems.length > 0 ? arrayItems : undefined;
-    }
-    if (isRecord(maybeSerializable)) {
-        const serializableEntries = Object.entries(maybeSerializable).map(([key, value])=>{
-            return [
-                key,
-                retainSerializableProps(value, depth + 1)
-            ];
-        }).filter(([, value])=>isDefined(value));
-        return serializableEntries.length > 0 ? Object.fromEntries(serializableEntries) : undefined;
-    }
-    return undefined;
-}
-function transformField(field, context) {
-    const fieldType = field.type;
-    const typeName = getDefinedTypeName(fieldType) ?? fieldType.name;
-    return {
-        ...transformCommonTypeFields(fieldType, typeName, context),
-        name: field.name,
-        type: typeName,
-        ...ensureCustomTitle(field.name, fieldType.title),
-        // this prop gets added synthetically via getCustomFields
-        ...ensureString('fieldset', field.fieldset)
-    };
-}
-function transformArrayMember(arrayMember, context) {
-    return {
-        of: arrayMember.of.map((type)=>{
-            const typeName = getDefinedTypeName(type) ?? type.name;
-            return {
-                ...transformCommonTypeFields(type, typeName, context),
-                type: typeName,
-                ...typeName === type.name ? {} : {
-                    name: type.name
-                },
-                ...ensureCustomTitle(type.name, type.title)
-            };
-        })
-    };
-}
-function transformReference(reference) {
-    return {
-        to: (reference.to ?? []).map((type)=>{
-            return {
-                ...retainCustomTypeProps(type),
-                type: type.name
-            };
-        })
-    };
-}
-function transformCrossDatasetReference(reference) {
-    return {
-        to: (reference.to ?? []).map((crossDataset)=>{
-            const preview = crossDataset.preview?.select ? {
-                preview: {
-                    select: crossDataset.preview.select
-                }
-            } : {};
-            return {
-                type: crossDataset.type,
-                ...ensureCustomTitle(crossDataset.type, crossDataset.title),
-                ...preview
-            };
-        })
-    };
-}
-function transformGlobalDocumentReference(reference) {
-    return {
-        to: (reference.to ?? []).map((crossDataset)=>{
-            const preview = crossDataset.preview?.select ? {
-                preview: {
-                    select: crossDataset.preview.select
-                }
-            } : {};
-            return {
-                type: crossDataset.type,
-                ...ensureCustomTitle(crossDataset.type, crossDataset.title),
-                ...preview
-            };
-        })
-    };
-}
-const transformTypeValidationRule = (rule)=>{
-    return {
-        ...rule,
-        constraint: 'constraint' in rule && (typeof rule.constraint === 'string' ? rule.constraint.toLowerCase() : retainSerializableProps(rule.constraint))
-    };
-};
-const validationRuleTransformers = {
-    type: transformTypeValidationRule
-};
-function transformValidation(validation) {
-    const validationArray = (Array.isArray(validation) ? validation : [
-        validation
-    ]).filter((value)=>typeof value === 'object' && '_type' in value);
-    // we dont want type in the output as that is implicitly given by the typedef itself an will only bloat the payload
-    const disallowedFlags = new Set([
-        'type'
-    ]);
-    // Validation rules that refer to other fields use symbols, which cannot be serialized. It would
-    // be possible to transform these to a serializable type, but we haven't implemented that for now.
-    const disallowedConstraintTypes = new Set([
-        ConcreteRuleClass.FIELD_REF
-    ]);
-    const serializedValidation = validationArray.map(({ _level, _message, _rules })=>{
-        const message = typeof _message === 'string' ? {
-            message: _message
-        } : {};
-        const serializedRules = _rules.filter((rule)=>{
-            if (!('constraint' in rule)) {
-                return false;
-            }
-            const { constraint, flag } = rule;
-            if (disallowedFlags.has(flag)) {
-                return false;
-            }
-            return !(typeof constraint === 'object' && 'type' in constraint && disallowedConstraintTypes.has(constraint.type));
-        }).map((rule)=>{
-            const transformer = validationRuleTransformers[rule.flag] ?? ((spec)=>retainSerializableProps(spec));
-            const transformedRule = transformer(rule);
-            if (!transformedRule) {
-                return;
-            }
-            return transformedRule;
-        }).filter((rule)=>rule !== undefined);
-        return {
-            level: _level,
-            rules: serializedRules,
-            ...message
-        };
-    }).filter((group)=>group.rules.length > 0);
-    return serializedValidation.length > 0 ? {
-        validation: serializedValidation
-    } : {};
-}
-function ensureCustomTitle(typeName, value) {
-    const titleObject = ensureString('title', value);
-    const defaultTitle = startCase(typeName);
-    // omit title if its the same as default, to reduce payload
-    if (titleObject.title === defaultTitle) {
-        return {};
-    }
-    return titleObject;
-}
-function ensureString(key, value) {
-    if (typeof value === 'string') {
-        return {
-            [key]: value
-        };
-    }
-    return {};
-}
-function ensureConditional(key, value) {
-    if (typeof value === 'boolean') {
-        return {
-            [key]: value
-        };
-    }
-    if (typeof value === 'function') {
-        return {
-            [key]: 'conditional'
-        };
-    }
-    return {};
-}
-function transformBlockType(blockType, context) {
-    if (blockType.jsonType !== 'object' || !isType(blockType, 'block')) {
-        return {};
-    }
-    const childrenField = blockType.fields?.find((field)=>field.name === 'children');
-    if (!childrenField) {
-        return {};
-    }
-    const ofType = childrenField.type.of;
-    if (!ofType) {
-        return {};
-    }
-    const spanType = ofType.find((memberType)=>memberType.name === 'span');
-    if (!spanType) {
-        return {};
-    }
-    const inlineObjectTypes = ofType.filter((memberType)=>memberType.name !== 'span') || [];
-    return {
-        lists: resolveEnabledListItems(blockType),
-        marks: {
-            annotations: spanType.annotations.map((t)=>transformType(t, context)),
-            decorators: resolveEnabledDecorators(spanType)
-        },
-        of: inlineObjectTypes.map((t)=>transformType(t, context)),
-        styles: resolveEnabledStyles(blockType)
-    };
-}
-function resolveEnabledStyles(blockType) {
-    const styleField = blockType.fields?.find((btField)=>btField.name === 'style');
-    return resolveTitleValueArray(styleField?.type?.options?.list);
-}
-function resolveEnabledDecorators(spanType) {
-    return 'decorators' in spanType ? resolveTitleValueArray(spanType.decorators) : undefined;
-}
-function resolveEnabledListItems(blockType) {
-    const listField = blockType.fields?.find((btField)=>btField.name === 'listItem');
-    return resolveTitleValueArray(listField?.type?.options?.list);
-}
-function resolveTitleValueArray(possibleArray) {
-    if (!possibleArray || !Array.isArray(possibleArray)) {
-        return undefined;
-    }
-    const titledValues = possibleArray.filter((d)=>isRecord(d) && !!d.value && isString(d.value)).map((item)=>{
-        return {
-            value: item.value,
-            ...ensureString('title', item.title)
-        };
-    });
-    if (!titledValues?.length) {
-        return undefined;
-    }
-    return titledValues;
-}
-const extractManifestTools = (tools)=>tools.map((tool)=>{
+/**
+ * Extracts tool information from workspace tools
+ */ const extractManifestTools = async (tools, workDir)=>Promise.all(tools.map(async (tool)=>{
         const { __internalApplicationType: type, icon, name, title } = tool;
         return {
-            icon: resolveIcon({
+            icon: await resolveIcon({
                 icon: icon,
-                title
+                title,
+                workDir
             }),
             name,
             title,
             type: type || null
         };
-    });
-const resolveIcon = (props)=>{
-    const sheet = new ServerStyleSheet();
-    try {
-        /**
-     * You must render the element first so
-     * the style-sheet above can be populated
-     */ const element = renderToString(sheet.collectStyles(/*#__PURE__*/ _jsx(SchemaIcon, {
-            ...props
-        })));
-        const styleTags = sheet.getStyleTags();
-        /**
-     * We can then create a single string
-     * of HTML combining our styles and element
-     * before purifying below.
-     */ const html = `${styleTags}${element}`.trim();
-        return DOMPurify.sanitize(html, config);
-    } catch  {
-        return null;
-    } finally{
-        sheet.seal();
-    }
-};
+    }));
 
 //# sourceMappingURL=extractWorkspaceManifest.js.map