@sanity/cli 5.1.1-next.6 → 6.0.0-alpha.3

package/dist/actions/schema/metafile.js

@@ -0,0 +1,51 @@
+/** Converts serialized schema debug data to ESBuild metafile format */ export function generateMetafile(schema) {
+    const output = {
+        bytes: 0,
+        exports: [],
+        imports: [],
+        inputs: {}
+    };
+    // Generate a esbuild metafile
+    const inputs = {};
+    function processType(path, entry) {
+        let childSize = 0;
+        if (entry.fields) {
+            for (const [name, fieldEntry] of Object.entries(entry.fields)){
+                processType(`${path}/${name}`, fieldEntry);
+                childSize += fieldEntry.size;
+            }
+        }
+        if (entry.of) {
+            for (const [name, fieldEntry] of Object.entries(entry.of)){
+                processType(`${path}/${name}`, fieldEntry);
+                childSize += fieldEntry.size;
+            }
+        }
+        const selfSize = entry.size - childSize;
+        inputs[path] = {
+            bytes: selfSize,
+            format: 'esm',
+            imports: []
+        };
+        output.inputs[path] = {
+            bytesInOutput: selfSize
+        };
+        output.bytes += selfSize;
+    }
+    for (const [name, entry] of Object.entries(schema.types)){
+        const fakePath = `schema/${entry.extends}/${name}`;
+        processType(fakePath, entry);
+    }
+    for (const [name, entry] of Object.entries(schema.hoisted)){
+        const fakePath = `hoisted/${name}`;
+        processType(fakePath, entry);
+    }
+    return {
+        inputs,
+        outputs: {
+            root: output
+        }
+    };
+}
+
+//# sourceMappingURL=metafile.js.map

package/dist/actions/schema/metafile.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/schema/metafile.ts"],"sourcesContent":["import {type SerializedSchemaDebug, type SerializedTypeDebug} from '../../threads/validateSchema.js'\n\n// This implements the metafile format of ESBuild.\ntype Metafile = {\n  inputs: Record<string, MetafileInput>\n  outputs: Record<string, MetafileOutput>\n}\n\ntype MetafileOutput = {\n  bytes: number\n  exports: []\n  imports: []\n  inputs: Record<string, {bytesInOutput: number}>\n}\n\ntype MetafileInput = {\n  bytes: number\n  format: 'csj' | 'esm'\n  imports: []\n}\n\n/** Converts serialized schema debug data to ESBuild metafile format */\nexport function generateMetafile(schema: SerializedSchemaDebug): Metafile {\n  const output: MetafileOutput = {\n    bytes: 0,\n    exports: [],\n    imports: [],\n    inputs: {},\n  }\n\n  // Generate a esbuild metafile\n  const inputs: Record<string, MetafileInput> = {}\n\n  function processType(path: string, entry: SerializedTypeDebug) {\n    let childSize = 0\n\n    if (entry.fields) {\n      for (const [name, fieldEntry] of Object.entries(entry.fields)) {\n        processType(`${path}/${name}`, fieldEntry)\n        childSize += fieldEntry.size\n      }\n    }\n\n    if (entry.of) {\n      for (const [name, fieldEntry] of Object.entries(entry.of)) {\n        processType(`${path}/${name}`, fieldEntry)\n        childSize += fieldEntry.size\n      }\n    }\n\n    const selfSize = entry.size - childSize\n\n    inputs[path] = {\n      bytes: selfSize,\n      format: 'esm',\n      imports: [],\n    }\n\n    output.inputs[path] = {\n      bytesInOutput: selfSize,\n    }\n\n    output.bytes += selfSize\n  }\n\n  for (const [name, entry] of Object.entries(schema.types)) {\n    const fakePath = `schema/${entry.extends}/${name}`\n    processType(fakePath, entry)\n  }\n\n  for (const [name, entry] of Object.entries(schema.hoisted)) {\n    const fakePath = `hoisted/${name}`\n    processType(fakePath, entry)\n  }\n\n  return {inputs, outputs: {root: output}}\n}\n"],"names":["generateMetafile","schema","output","bytes","exports","imports","inputs","processType","path","entry","childSize","fields","name","fieldEntry","Object","entries","size","of","selfSize","format","bytesInOutput","types","fakePath","extends","hoisted","outputs","root"],"mappings":"AAqBA,qEAAqE,GACrE,OAAO,SAASA,iBAAiBC,MAA6B;IAC5D,MAAMC,SAAyB;QAC7BC,OAAO;QACPC,SAAS,EAAE;QACXC,SAAS,EAAE;QACXC,QAAQ,CAAC;IACX;IAEA,8BAA8B;IAC9B,MAAMA,SAAwC,CAAC;IAE/C,SAASC,YAAYC,IAAY,EAAEC,KAA0B;QAC3D,IAAIC,YAAY;QAEhB,IAAID,MAAME,MAAM,EAAE;YAChB,KAAK,MAAM,CAACC,MAAMC,WAAW,IAAIC,OAAOC,OAAO,CAACN,MAAME,MAAM,EAAG;gBAC7DJ,YAAY,GAAGC,KAAK,CAAC,EAAEI,MAAM,EAAEC;gBAC/BH,aAAaG,WAAWG,IAAI;YAC9B;QACF;QAEA,IAAIP,MAAMQ,EAAE,EAAE;YACZ,KAAK,MAAM,CAACL,MAAMC,WAAW,IAAIC,OAAOC,OAAO,CAACN,MAAMQ,EAAE,EAAG;gBACzDV,YAAY,GAAGC,KAAK,CAAC,EAAEI,MAAM,EAAEC;gBAC/BH,aAAaG,WAAWG,IAAI;YAC9B;QACF;QAEA,MAAME,WAAWT,MAAMO,IAAI,GAAGN;QAE9BJ,MAAM,CAACE,KAAK,GAAG;YACbL,OAAOe;YACPC,QAAQ;YACRd,SAAS,EAAE;QACb;QAEAH,OAAOI,MAAM,CAACE,KAAK,GAAG;YACpBY,eAAeF;QACjB;QAEAhB,OAAOC,KAAK,IAAIe;IAClB;IAEA,KAAK,MAAM,CAACN,MAAMH,MAAM,IAAIK,OAAOC,OAAO,CAACd,OAAOoB,KAAK,EAAG;QACxD,MAAMC,WAAW,CAAC,OAAO,EAAEb,MAAMc,OAAO,CAAC,CAAC,EAAEX,MAAM;QAClDL,YAAYe,UAAUb;IACxB;IAEA,KAAK,MAAM,CAACG,MAAMH,MAAM,IAAIK,OAAOC,OAAO,CAACd,OAAOuB,OAAO,EAAG;QAC1D,MAAMF,WAAW,CAAC,QAAQ,EAAEV,MAAM;QAClCL,YAAYe,UAAUb;IACxB;IAEA,OAAO;QAACH;QAAQmB,SAAS;YAACC,MAAMxB;QAAM;IAAC;AACzC"}

package/dist/actions/schema/schemaStoreConstants.d.ts

@@ -0,0 +1 @@
+export declare const SCHEMA_STORE_FEATURE_ENABLED: boolean;

package/dist/actions/schema/schemaStoreConstants.js

@@ -0,0 +1,4 @@
+const FEATURE_ENABLED_ENV_NAME = 'SANITY_CLI_SCHEMA_STORE_ENABLED';
+export const SCHEMA_STORE_FEATURE_ENABLED = process.env[FEATURE_ENABLED_ENV_NAME] === 'true';
+
+//# sourceMappingURL=schemaStoreConstants.js.map

package/dist/actions/schema/schemaStoreConstants.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/schema/schemaStoreConstants.ts"],"sourcesContent":["const FEATURE_ENABLED_ENV_NAME = 'SANITY_CLI_SCHEMA_STORE_ENABLED'\n\nexport const SCHEMA_STORE_FEATURE_ENABLED = process.env[FEATURE_ENABLED_ENV_NAME] === 'true'\n"],"names":["FEATURE_ENABLED_ENV_NAME","SCHEMA_STORE_FEATURE_ENABLED","process","env"],"mappings":"AAAA,MAAMA,2BAA2B;AAEjC,OAAO,MAAMC,+BAA+BC,QAAQC,GAAG,CAACH,yBAAyB,KAAK,OAAM"}

package/dist/actions/schema/schemaStoreTypes.d.ts

@@ -0,0 +1,29 @@
+import { type Output } from '@sanity/cli-core';
+import { type SanityClient } from '@sanity/client';
+import { type ManifestExtractor } from './utils/manifestExtractor';
+import { type ManifestJsonReader } from './utils/manifestReader';
+export interface SchemaStoreContext {
+    apiClient: () => Promise<SanityClient>;
+    manifestExtractor: ManifestExtractor;
+    output: Output;
+    workDir: string;
+    jsonReader?: ManifestJsonReader;
+}
+/**
+ * There is more context locally to decide how and when to log, depending on flags;
+ * we therefore let actions log as soon as possible, possibly stopping stack unwinding.
+ * This gives us more control over the color and detail of the error message, as well as ensuring
+ * we dont double-log errors up the chain.
+ *
+ * Depending on flags, store actions can fail without throwing; to allow control flow to continue,
+ * even in the face of failure (--schema-required ture/false for store)
+ *
+ * It is up to action to make this distinction based on flags.
+ *
+ * However, we _do_ want to ensure correct exit code on commands (0 vs 1), so
+ * CLI command chains are stopped if a store command fails.
+ *
+ * Invalid flags will always throw.
+ *
+ */
+export type SchemaStoreActionResult = 'failure' | 'success';

package/dist/actions/schema/schemaStoreTypes.js

@@ -0,0 +1,19 @@
+/**
+ * There is more context locally to decide how and when to log, depending on flags;
+ * we therefore let actions log as soon as possible, possibly stopping stack unwinding.
+ * This gives us more control over the color and detail of the error message, as well as ensuring
+ * we dont double-log errors up the chain.
+ *
+ * Depending on flags, store actions can fail without throwing; to allow control flow to continue,
+ * even in the face of failure (--schema-required ture/false for store)
+ *
+ * It is up to action to make this distinction based on flags.
+ *
+ * However, we _do_ want to ensure correct exit code on commands (0 vs 1), so
+ * CLI command chains are stopped if a store command fails.
+ *
+ * Invalid flags will always throw.
+ *
+ */ export { };
+
+//# sourceMappingURL=schemaStoreTypes.js.map

package/dist/actions/schema/schemaStoreTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/schema/schemaStoreTypes.ts"],"sourcesContent":["import {type Output} from '@sanity/cli-core'\nimport {type SanityClient} from '@sanity/client'\n\nimport {type ManifestExtractor} from './utils/manifestExtractor'\nimport {type ManifestJsonReader} from './utils/manifestReader'\n\nexport interface SchemaStoreContext {\n  apiClient: () => Promise<SanityClient>\n  manifestExtractor: ManifestExtractor\n  output: Output\n  workDir: string\n\n  jsonReader?: ManifestJsonReader\n}\n\n/**\n * There is more context locally to decide how and when to log, depending on flags;\n * we therefore let actions log as soon as possible, possibly stopping stack unwinding.\n * This gives us more control over the color and detail of the error message, as well as ensuring\n * we dont double-log errors up the chain.\n *\n * Depending on flags, store actions can fail without throwing; to allow control flow to continue,\n * even in the face of failure (--schema-required ture/false for store)\n *\n * It is up to action to make this distinction based on flags.\n *\n * However, we _do_ want to ensure correct exit code on commands (0 vs 1), so\n * CLI command chains are stopped if a store command fails.\n *\n * Invalid flags will always throw.\n *\n */\nexport type SchemaStoreActionResult = 'failure' | 'success'\n"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;CAgBC,GACD,WAA2D"}

package/dist/actions/schema/utils/manifestExtractor.d.ts

@@ -0,0 +1,14 @@
+import { type Output } from '@sanity/cli-core';
+export type ManifestExtractor = (manifestDir: string) => Promise<void>;
+export declare function ensureManifestExtractSatisfied(args: {
+    extractManifest: boolean;
+    manifestDir: string;
+    manifestExtractor: (manifestDir: string) => Promise<void>;
+    output: Output;
+    schemaRequired: boolean;
+}): Promise<boolean>;
+export declare function createManifestExtractor(context: {
+    output: Output;
+    safe?: boolean;
+    workDir: string;
+}): (manifestDir: string) => Promise<void>;

package/dist/actions/schema/utils/manifestExtractor.js

@@ -0,0 +1,38 @@
+import { chalk } from '@sanity/cli-core/ux';
+import { extractManifestSafe } from '../../manifest/extractManifest.js';
+import { FlagValidationError } from './schemaStoreValidation.js';
+export async function ensureManifestExtractSatisfied(args) {
+    const { extractManifest, manifestDir, manifestExtractor, output, schemaRequired } = args;
+    if (!extractManifest) {
+        return true;
+    }
+    try {
+        // a successful manifest extract will write a new manifest file, which manifestReader will then read from disk
+        await manifestExtractor(manifestDir);
+        return true;
+    } catch (err) {
+        if (schemaRequired || err instanceof FlagValidationError) {
+            throw err;
+        } else {
+            output.log(chalk.gray(`↳ Failed to extract manifest:\n  ${err.message}`));
+            return false;
+        }
+    }
+}
+export function createManifestExtractor(context) {
+    return async (manifestDir)=>{
+        const error = await extractManifestSafe({
+            flags: {
+                json: false,
+                path: manifestDir
+            },
+            output: context.output,
+            workDir: context.workDir
+        });
+        if (!context.safe && error) {
+            throw error;
+        }
+    };
+}
+
+//# sourceMappingURL=manifestExtractor.js.map

package/dist/actions/schema/utils/manifestExtractor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/schema/utils/manifestExtractor.ts"],"sourcesContent":["import {type Output} from '@sanity/cli-core'\nimport {chalk} from '@sanity/cli-core/ux'\n\nimport {extractManifestSafe} from '../../manifest/extractManifest.js'\nimport {FlagValidationError} from './schemaStoreValidation.js'\n\nexport type ManifestExtractor = (manifestDir: string) => Promise<void>\n\nexport async function ensureManifestExtractSatisfied(args: {\n  extractManifest: boolean\n  manifestDir: string\n  manifestExtractor: (manifestDir: string) => Promise<void>\n  output: Output\n  schemaRequired: boolean\n}) {\n  const {extractManifest, manifestDir, manifestExtractor, output, schemaRequired} = args\n  if (!extractManifest) {\n    return true\n  }\n  try {\n    // a successful manifest extract will write a new manifest file, which manifestReader will then read from disk\n    await manifestExtractor(manifestDir)\n    return true\n  } catch (err) {\n    if (schemaRequired || err instanceof FlagValidationError) {\n      throw err\n    } else {\n      output.log(chalk.gray(`↳ Failed to extract manifest:\\n  ${err.message}`))\n      return false\n    }\n  }\n}\n\nexport function createManifestExtractor(context: {\n  output: Output\n  safe?: boolean\n  workDir: string\n}) {\n  return async (manifestDir: string) => {\n    const error = await extractManifestSafe({\n      flags: {json: false, path: manifestDir},\n      output: context.output,\n      workDir: context.workDir,\n    })\n    if (!context.safe && error) {\n      throw error\n    }\n  }\n}\n"],"names":["chalk","extractManifestSafe","FlagValidationError","ensureManifestExtractSatisfied","args","extractManifest","manifestDir","manifestExtractor","output","schemaRequired","err","log","gray","message","createManifestExtractor","context","error","flags","json","path","workDir","safe"],"mappings":"AACA,SAAQA,KAAK,QAAO,sBAAqB;AAEzC,SAAQC,mBAAmB,QAAO,oCAAmC;AACrE,SAAQC,mBAAmB,QAAO,6BAA4B;AAI9D,OAAO,eAAeC,+BAA+BC,IAMpD;IACC,MAAM,EAACC,eAAe,EAAEC,WAAW,EAAEC,iBAAiB,EAAEC,MAAM,EAAEC,cAAc,EAAC,GAAGL;IAClF,IAAI,CAACC,iBAAiB;QACpB,OAAO;IACT;IACA,IAAI;QACF,8GAA8G;QAC9G,MAAME,kBAAkBD;QACxB,OAAO;IACT,EAAE,OAAOI,KAAK;QACZ,IAAID,kBAAkBC,eAAeR,qBAAqB;YACxD,MAAMQ;QACR,OAAO;YACLF,OAAOG,GAAG,CAACX,MAAMY,IAAI,CAAC,CAAC,iCAAiC,EAAEF,IAAIG,OAAO,EAAE;YACvE,OAAO;QACT;IACF;AACF;AAEA,OAAO,SAASC,wBAAwBC,OAIvC;IACC,OAAO,OAAOT;QACZ,MAAMU,QAAQ,MAAMf,oBAAoB;YACtCgB,OAAO;gBAACC,MAAM;gBAAOC,MAAMb;YAAW;YACtCE,QAAQO,QAAQP,MAAM;YACtBY,SAASL,QAAQK,OAAO;QAC1B;QACA,IAAI,CAACL,QAAQM,IAAI,IAAIL,OAAO;YAC1B,MAAMA;QACR;IACF;AACF"}

package/dist/actions/schema/utils/manifestReader.d.ts

@@ -0,0 +1,24 @@
+import { type Output } from '@sanity/cli-core';
+import { type CreateManifest, type ManifestSchemaType } from '../../manifest/types.js';
+export type ManifestJsonReader = <T>(filePath: string) => Promise<JsonFileParseSuccess<T> | undefined>;
+export type CreateManifestReaderFactory = (args: {
+    jsonReader?: <T>(filePath: string) => Promise<JsonFileParseSuccess<T> | undefined>;
+    manifestDir: string;
+    output: Output;
+}) => CreateManifestReader;
+export interface CreateManifestReader {
+    getManifest: () => Promise<CreateManifest>;
+    getWorkspaceSchema: (workspaceName: string) => Promise<ManifestSchemaType[]>;
+}
+interface JsonFileParseSuccess<T> {
+    lastModified: string;
+    parsedJson: T;
+    path: string;
+}
+/**
+ * The manifest reader will try to read manifest and workspace schema files _once_ and cache a successful result.
+ * If you need to re-read the manifest from disk, create a new instance.
+ */
+export declare const createManifestReader: CreateManifestReaderFactory;
+export declare function resolveManifestDirectory(workDir: string, customPath?: string): string;
+export {};

package/dist/actions/schema/utils/manifestReader.js

@@ -0,0 +1,77 @@
+import { readFile, stat } from 'node:fs/promises';
+import path, { join, resolve } from 'node:path';
+import { chalk } from '@sanity/cli-core/ux';
+import { MANIFEST_FILENAME } from '../../manifest/extractManifest.js';
+/**
+ * The manifest reader will try to read manifest and workspace schema files _once_ and cache a successful result.
+ * If you need to re-read the manifest from disk, create a new instance.
+ */ export const createManifestReader = ({ jsonReader = parseJsonFile, manifestDir, output })=>{
+    let parsedManifest;
+    const parsedWorkspaces = {};
+    const getManifest = async ()=>{
+        if (parsedManifest) {
+            return parsedManifest?.parsedJson;
+        }
+        const manifestFile = path.join(manifestDir, MANIFEST_FILENAME);
+        const result = await jsonReader(manifestFile);
+        if (!result) {
+            throw new Error(`Manifest does not exist at ${manifestFile}. To create the manifest file, omit --no-${'extract-manifest'} or run "sanity manifest extract" first.`);
+        }
+        output.log(chalk.gray(`↳ Read manifest from ${manifestFile} (last modified: ${result.lastModified})`));
+        parsedManifest = result;
+        return result.parsedJson;
+    };
+    const getWorkspaceSchema = async (workspaceName)=>{
+        if (parsedWorkspaces[workspaceName]) {
+            return parsedWorkspaces[workspaceName]?.parsedJson;
+        }
+        const manifest = await getManifest();
+        if (!manifest) {
+            throw new Error('Manifest is required to read workspace schema.');
+        }
+        const workspaceManifest = manifest.workspaces.find((workspace)=>workspace.name === workspaceName);
+        if (!workspaceManifest) {
+            throw new Error(`No workspace named "${workspaceName}" found in manifest.`);
+        }
+        const workspaceSchemaFile = path.join(manifestDir, workspaceManifest.schema);
+        const result = await jsonReader(workspaceSchemaFile);
+        if (!result) {
+            throw new Error(`Workspace schema file at "${workspaceSchemaFile}" does not exist.`);
+        }
+        parsedWorkspaces[workspaceName] = result;
+        return result.parsedJson;
+    };
+    return {
+        getManifest,
+        getWorkspaceSchema
+    };
+};
+export function resolveManifestDirectory(workDir, customPath) {
+    const defaultOutputDir = resolve(join(workDir, 'dist'));
+    const outputDir = resolve(defaultOutputDir);
+    const defaultStaticPath = join(outputDir, 'static');
+    const staticPath = customPath ?? defaultStaticPath;
+    return path.resolve(process.cwd(), staticPath);
+}
+async function parseJsonFile(filePath) {
+    let stats;
+    try {
+        stats = await stat(filePath);
+    } catch  {
+        // file does not exist
+        return undefined;
+    }
+    const content = await readFile(filePath, 'utf8');
+    const lastModified = stats.mtime.toISOString();
+    const json = JSON.parse(content);
+    if (!json) {
+        throw new Error(`JSON file "${filePath}" was empty.`);
+    }
+    return {
+        lastModified,
+        parsedJson: json,
+        path: filePath
+    };
+}
+
+//# sourceMappingURL=manifestReader.js.map

package/dist/actions/schema/utils/manifestReader.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/schema/utils/manifestReader.ts"],"sourcesContent":["import {type Stats} from 'node:fs'\nimport {readFile, stat} from 'node:fs/promises'\nimport path, {join, resolve} from 'node:path'\n\nimport {type Output} from '@sanity/cli-core'\nimport {chalk} from '@sanity/cli-core/ux'\n\nimport {MANIFEST_FILENAME} from '../../manifest/extractManifest.js'\nimport {type CreateManifest, type ManifestSchemaType} from '../../manifest/types.js'\nimport {type DeploySchemasFlags} from './schemaStoreValidation.js'\n\nexport type ManifestJsonReader = <T>(\n  filePath: string,\n) => Promise<JsonFileParseSuccess<T> | undefined>\n\nexport type CreateManifestReaderFactory = (args: {\n  jsonReader?: <T>(filePath: string) => Promise<JsonFileParseSuccess<T> | undefined>\n  manifestDir: string\n  output: Output\n}) => CreateManifestReader\n\nexport interface CreateManifestReader {\n  getManifest: () => Promise<CreateManifest>\n  getWorkspaceSchema: (workspaceName: string) => Promise<ManifestSchemaType[]>\n}\n\ninterface JsonFileParseSuccess<T> {\n  lastModified: string\n  parsedJson: T\n  path: string\n}\n\n/**\n * The manifest reader will try to read manifest and workspace schema files _once_ and cache a successful result.\n * If you need to re-read the manifest from disk, create a new instance.\n */\nexport const createManifestReader: CreateManifestReaderFactory = ({\n  jsonReader = parseJsonFile,\n  manifestDir,\n  output,\n}) => {\n  let parsedManifest: JsonFileParseSuccess<CreateManifest>\n  const parsedWorkspaces: Record<string, JsonFileParseSuccess<ManifestSchemaType[]> | undefined> =\n    {}\n\n  const getManifest: CreateManifestReader['getManifest'] = async () => {\n    if (parsedManifest) {\n      return parsedManifest?.parsedJson\n    }\n\n    const manifestFile = path.join(manifestDir, MANIFEST_FILENAME)\n\n    const result = await jsonReader<CreateManifest>(manifestFile)\n    if (!result) {\n      throw new Error(\n        `Manifest does not exist at ${manifestFile}. To create the manifest file, omit --no-${'extract-manifest' satisfies keyof DeploySchemasFlags} or run \"sanity manifest extract\" first.`,\n      )\n    }\n\n    output.log(\n      chalk.gray(`↳ Read manifest from ${manifestFile} (last modified: ${result.lastModified})`),\n    )\n\n    parsedManifest = result\n    return result.parsedJson\n  }\n\n  const getWorkspaceSchema: CreateManifestReader['getWorkspaceSchema'] = async (workspaceName) => {\n    if (parsedWorkspaces[workspaceName]) {\n      return parsedWorkspaces[workspaceName]?.parsedJson\n    }\n    const manifest = await getManifest()\n    if (!manifest) {\n      throw new Error('Manifest is required to read workspace schema.')\n    }\n\n    const workspaceManifest = manifest.workspaces.find(\n      (workspace) => workspace.name === workspaceName,\n    )\n\n    if (!workspaceManifest) {\n      throw new Error(`No workspace named \"${workspaceName}\" found in manifest.`)\n    }\n\n    const workspaceSchemaFile = path.join(manifestDir, workspaceManifest.schema)\n    const result = await jsonReader<ManifestSchemaType[]>(workspaceSchemaFile)\n    if (!result) {\n      throw new Error(`Workspace schema file at \"${workspaceSchemaFile}\" does not exist.`)\n    }\n    parsedWorkspaces[workspaceName] = result\n    return result.parsedJson\n  }\n  return {\n    getManifest,\n    getWorkspaceSchema,\n  }\n}\n\nexport function resolveManifestDirectory(workDir: string, customPath?: string): string {\n  const defaultOutputDir = resolve(join(workDir, 'dist'))\n\n  const outputDir = resolve(defaultOutputDir)\n  const defaultStaticPath = join(outputDir, 'static')\n\n  const staticPath = customPath ?? defaultStaticPath\n  return path.resolve(process.cwd(), staticPath)\n}\n\nasync function parseJsonFile<T>(filePath: string): Promise<JsonFileParseSuccess<T> | undefined> {\n  let stats: Stats\n  try {\n    stats = await stat(filePath)\n  } catch {\n    // file does not exist\n    return undefined\n  }\n  const content = await readFile(filePath, 'utf8')\n  const lastModified = stats.mtime.toISOString()\n  const json = JSON.parse(content) as T\n  if (!json) {\n    throw new Error(`JSON file \"${filePath}\" was empty.`)\n  }\n  return {\n    lastModified,\n    parsedJson: json,\n    path: filePath,\n  }\n}\n"],"names":["readFile","stat","path","join","resolve","chalk","MANIFEST_FILENAME","createManifestReader","jsonReader","parseJsonFile","manifestDir","output","parsedManifest","parsedWorkspaces","getManifest","parsedJson","manifestFile","result","Error","log","gray","lastModified","getWorkspaceSchema","workspaceName","manifest","workspaceManifest","workspaces","find","workspace","name","workspaceSchemaFile","schema","resolveManifestDirectory","workDir","customPath","defaultOutputDir","outputDir","defaultStaticPath","staticPath","process","cwd","filePath","stats","undefined","content","mtime","toISOString","json","JSON","parse"],"mappings":"AACA,SAAQA,QAAQ,EAAEC,IAAI,QAAO,mBAAkB;AAC/C,OAAOC,QAAOC,IAAI,EAAEC,OAAO,QAAO,YAAW;AAG7C,SAAQC,KAAK,QAAO,sBAAqB;AAEzC,SAAQC,iBAAiB,QAAO,oCAAmC;AAyBnE;;;CAGC,GACD,OAAO,MAAMC,uBAAoD,CAAC,EAChEC,aAAaC,aAAa,EAC1BC,WAAW,EACXC,MAAM,EACP;IACC,IAAIC;IACJ,MAAMC,mBACJ,CAAC;IAEH,MAAMC,cAAmD;QACvD,IAAIF,gBAAgB;YAClB,OAAOA,gBAAgBG;QACzB;QAEA,MAAMC,eAAed,KAAKC,IAAI,CAACO,aAAaJ;QAE5C,MAAMW,SAAS,MAAMT,WAA2BQ;QAChD,IAAI,CAACC,QAAQ;YACX,MAAM,IAAIC,MACR,CAAC,2BAA2B,EAAEF,aAAa,yCAAyC,EAAE,mBAAsD,wCAAwC,CAAC;QAEzL;QAEAL,OAAOQ,GAAG,CACRd,MAAMe,IAAI,CAAC,CAAC,qBAAqB,EAAEJ,aAAa,iBAAiB,EAAEC,OAAOI,YAAY,CAAC,CAAC,CAAC;QAG3FT,iBAAiBK;QACjB,OAAOA,OAAOF,UAAU;IAC1B;IAEA,MAAMO,qBAAiE,OAAOC;QAC5E,IAAIV,gBAAgB,CAACU,cAAc,EAAE;YACnC,OAAOV,gBAAgB,CAACU,cAAc,EAAER;QAC1C;QACA,MAAMS,WAAW,MAAMV;QACvB,IAAI,CAACU,UAAU;YACb,MAAM,IAAIN,MAAM;QAClB;QAEA,MAAMO,oBAAoBD,SAASE,UAAU,CAACC,IAAI,CAChD,CAACC,YAAcA,UAAUC,IAAI,KAAKN;QAGpC,IAAI,CAACE,mBAAmB;YACtB,MAAM,IAAIP,MAAM,CAAC,oBAAoB,EAAEK,cAAc,oBAAoB,CAAC;QAC5E;QAEA,MAAMO,sBAAsB5B,KAAKC,IAAI,CAACO,aAAae,kBAAkBM,MAAM;QAC3E,MAAMd,SAAS,MAAMT,WAAiCsB;QACtD,IAAI,CAACb,QAAQ;YACX,MAAM,IAAIC,MAAM,CAAC,0BAA0B,EAAEY,oBAAoB,iBAAiB,CAAC;QACrF;QACAjB,gBAAgB,CAACU,cAAc,GAAGN;QAClC,OAAOA,OAAOF,UAAU;IAC1B;IACA,OAAO;QACLD;QACAQ;IACF;AACF,EAAC;AAED,OAAO,SAASU,yBAAyBC,OAAe,EAAEC,UAAmB;IAC3E,MAAMC,mBAAmB/B,QAAQD,KAAK8B,SAAS;IAE/C,MAAMG,YAAYhC,QAAQ+B;IAC1B,MAAME,oBAAoBlC,KAAKiC,WAAW;IAE1C,MAAME,aAAaJ,cAAcG;IACjC,OAAOnC,KAAKE,OAAO,CAACmC,QAAQC,GAAG,IAAIF;AACrC;AAEA,eAAe7B,cAAiBgC,QAAgB;IAC9C,IAAIC;IACJ,IAAI;QACFA,QAAQ,MAAMzC,KAAKwC;IACrB,EAAE,OAAM;QACN,sBAAsB;QACtB,OAAOE;IACT;IACA,MAAMC,UAAU,MAAM5C,SAASyC,UAAU;IACzC,MAAMpB,eAAeqB,MAAMG,KAAK,CAACC,WAAW;IAC5C,MAAMC,OAAOC,KAAKC,KAAK,CAACL;IACxB,IAAI,CAACG,MAAM;QACT,MAAM,IAAI7B,MAAM,CAAC,WAAW,EAAEuB,SAAS,YAAY,CAAC;IACtD;IACA,OAAO;QACLpB;QACAN,YAAYgC;QACZ7C,MAAMuC;IACR;AACF"}

package/dist/actions/schema/utils/schemaActionHelpers.d.ts

@@ -0,0 +1 @@
+export declare function pluralize(word: string, count: number): string;

package/dist/actions/schema/utils/schemaActionHelpers.js

@@ -0,0 +1,5 @@
+export function pluralize(word, count) {
+    return `${count} ${word}${count === 1 ? '' : 's'}`;
+}
+
+//# sourceMappingURL=schemaActionHelpers.js.map

package/dist/actions/schema/utils/schemaActionHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/schema/utils/schemaActionHelpers.ts"],"sourcesContent":["export function pluralize(word: string, count: number) {\n  return `${count} ${word}${count === 1 ? '' : 's'}`\n}\n"],"names":["pluralize","word","count"],"mappings":"AAAA,OAAO,SAASA,UAAUC,IAAY,EAAEC,KAAa;IACnD,OAAO,GAAGA,MAAM,CAAC,EAAED,OAAOC,UAAU,IAAI,KAAK,KAAK;AACpD"}

package/dist/actions/schema/utils/schemaApiClient.d.ts

@@ -0,0 +1,6 @@
+import { type SanityClient } from '@sanity/client';
+export declare function createSchemaApiClient(apiClient: () => Promise<SanityClient>): Promise<{
+    client: SanityClient;
+    dataset: string;
+    projectId: string;
+}>;

package/dist/actions/schema/utils/schemaApiClient.js

@@ -0,0 +1,17 @@
+export async function createSchemaApiClient(apiClient) {
+    const client = (await apiClient()).withConfig({
+        apiVersion: 'v2025-03-01',
+        useCdn: false
+    });
+    const projectId = client.config().projectId;
+    const dataset = client.config().dataset;
+    if (!projectId) throw new Error('Project ID is not defined');
+    if (!dataset) throw new Error('Dataset is not defined');
+    return {
+        client,
+        dataset,
+        projectId
+    };
+}
+
+//# sourceMappingURL=schemaApiClient.js.map

package/dist/actions/schema/utils/schemaApiClient.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/schema/utils/schemaApiClient.ts"],"sourcesContent":["import {type SanityClient} from '@sanity/client'\n\nexport async function createSchemaApiClient(apiClient: () => Promise<SanityClient>) {\n  const client = (await apiClient()).withConfig({apiVersion: 'v2025-03-01', useCdn: false})\n\n  const projectId = client.config().projectId\n  const dataset = client.config().dataset\n  if (!projectId) throw new Error('Project ID is not defined')\n  if (!dataset) throw new Error('Dataset is not defined')\n\n  return {\n    client,\n    dataset,\n    projectId,\n  }\n}\n"],"names":["createSchemaApiClient","apiClient","client","withConfig","apiVersion","useCdn","projectId","config","dataset","Error"],"mappings":"AAEA,OAAO,eAAeA,sBAAsBC,SAAsC;IAChF,MAAMC,SAAS,AAAC,CAAA,MAAMD,WAAU,EAAGE,UAAU,CAAC;QAACC,YAAY;QAAeC,QAAQ;IAAK;IAEvF,MAAMC,YAAYJ,OAAOK,MAAM,GAAGD,SAAS;IAC3C,MAAME,UAAUN,OAAOK,MAAM,GAAGC,OAAO;IACvC,IAAI,CAACF,WAAW,MAAM,IAAIG,MAAM;IAChC,IAAI,CAACD,SAAS,MAAM,IAAIC,MAAM;IAE9B,OAAO;QACLP;QACAM;QACAF;IACF;AACF"}

package/dist/actions/schema/utils/schemaStoreOutStrings.d.ts

@@ -0,0 +1,3 @@
+export declare function getDatasetsOutString(datasets: string[]): string;
+export declare function getStringArrayOutString(array: string[]): string;
+export declare function getStringList(array: string[]): string;

package/dist/actions/schema/utils/schemaStoreOutStrings.js

@@ -0,0 +1,11 @@
+export function getDatasetsOutString(datasets) {
+    return datasets.length === 1 ? `dataset "${datasets[0]}"` : `datasets ${getStringArrayOutString(datasets)}`;
+}
+export function getStringArrayOutString(array) {
+    return `[${array.map((d)=>`"${d}"`).join(',')}]`;
+}
+export function getStringList(array) {
+    return array.map((s)=>`- "${s}"`).join('\n');
+}
+
+//# sourceMappingURL=schemaStoreOutStrings.js.map

package/dist/actions/schema/utils/schemaStoreOutStrings.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/schema/utils/schemaStoreOutStrings.ts"],"sourcesContent":["export function getDatasetsOutString(datasets: string[]) {\n  return datasets.length === 1\n    ? `dataset \"${datasets[0]}\"`\n    : `datasets ${getStringArrayOutString(datasets)}`\n}\n\nexport function getStringArrayOutString(array: string[]) {\n  return `[${array.map((d) => `\"${d}\"`).join(',')}]`\n}\n\nexport function getStringList(array: string[]) {\n  return array.map((s) => `- \"${s}\"`).join('\\n')\n}\n"],"names":["getDatasetsOutString","datasets","length","getStringArrayOutString","array","map","d","join","getStringList","s"],"mappings":"AAAA,OAAO,SAASA,qBAAqBC,QAAkB;IACrD,OAAOA,SAASC,MAAM,KAAK,IACvB,CAAC,SAAS,EAAED,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,GAC1B,CAAC,SAAS,EAAEE,wBAAwBF,WAAW;AACrD;AAEA,OAAO,SAASE,wBAAwBC,KAAe;IACrD,OAAO,CAAC,CAAC,EAAEA,MAAMC,GAAG,CAAC,CAACC,IAAM,CAAC,CAAC,EAAEA,EAAE,CAAC,CAAC,EAAEC,IAAI,CAAC,KAAK,CAAC,CAAC;AACpD;AAEA,OAAO,SAASC,cAAcJ,KAAe;IAC3C,OAAOA,MAAMC,GAAG,CAAC,CAACI,IAAM,CAAC,GAAG,EAAEA,EAAE,CAAC,CAAC,EAAEF,IAAI,CAAC;AAC3C"}

package/dist/actions/schema/utils/schemaStoreValidation.d.ts

@@ -0,0 +1,81 @@
+import { type Output } from '@sanity/cli-core';
+import { type DeleteSchemaFlags } from '../deleteSchemaAction.js';
+export interface DeploySchemasFlags extends SchemaStoreCommonFlags {
+    'schema-required'?: boolean;
+    tag?: string;
+    workspace?: string;
+}
+export interface SchemaListFlags extends SchemaStoreCommonFlags {
+    id?: string;
+    json?: boolean;
+}
+export declare const validForIdChars = "a-zA-Z0-9._-";
+export declare const validForIdPattern: RegExp;
+export declare const validForNamesChars = "a-zA-Z0-9_-";
+export declare const validForNamesPattern: RegExp;
+export declare class FlagValidationError extends Error {
+    constructor(message: string);
+}
+interface WorkspaceSchemaId {
+    schemaId: string;
+    workspace: string;
+}
+export interface SchemaStoreCommonFlags {
+    'extract-manifest'?: boolean;
+    'manifest-dir'?: string;
+    verbose?: boolean;
+}
+export declare function parseDeploySchemasConfig(flags: DeploySchemasFlags, context: {
+    workDir: string;
+}): {
+    schemaRequired: boolean;
+    tag: string | undefined;
+    workspaceName: string | undefined;
+    extractManifest: boolean;
+    manifestDir: string;
+    verbose: boolean;
+};
+export declare function parseListSchemasConfig(flags: SchemaListFlags, context: {
+    workDir: string;
+}): {
+    id: string | undefined;
+    json: boolean;
+    extractManifest: boolean;
+    manifestDir: string;
+    verbose: boolean;
+};
+export declare function parseDeleteSchemasConfig(flags: DeleteSchemaFlags, context: {
+    workDir: string;
+}): {
+    dataset: string | undefined;
+    ids: WorkspaceSchemaId[];
+    extractManifest: boolean;
+    manifestDir: string;
+    verbose: boolean;
+};
+export declare function parseIds(flags: {
+    ids?: unknown;
+}, errors: string[]): WorkspaceSchemaId[];
+export declare function parseId(flags: {
+    id?: unknown;
+}, errors: string[]): string | undefined;
+export declare function parseWorkspaceSchemaId(id: string, errors: string[]): {
+    schemaId: string;
+    workspace: string;
+} | undefined;
+export declare function parseTag(flags: {
+    tag?: unknown;
+}, errors: string[]): string | undefined;
+/**
+ * At the moment schema store commands does not support studios where workspaces have multiple projects
+ */
+export declare function throwWriteProjectIdMismatch(workspace: {
+    name: string;
+    projectId: string;
+}, projectId: string): void;
+export declare function filterLogReadProjectIdMismatch(workspace: {
+    name: string;
+    projectId: string;
+}, projectId: string, output: Output): boolean;
+export declare const SCHEMA_PERMISSION_HELP_TEXT = "For multi-project workspaces, set SANITY_AUTH_TOKEN environment variable to a token with access to the workspace projects.";
+export {};