@sanity/cli 5.9.0-next.8 → 6.0.0-alpha.11

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

@@ -0,0 +1,6 @@
+import { subdebug } from '@sanity/cli-core';
+export const schemasDeployDebug = subdebug('schemas:deploy');
+export const schemasListDebug = subdebug('schemas:list');
+export const schemasExtractDebug = subdebug('schemas:extract');
+
+//# sourceMappingURL=debug.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/schema/utils/debug.ts"],"sourcesContent":["import {subdebug} from '@sanity/cli-core'\n\nexport const schemasDeployDebug = subdebug('schemas:deploy')\nexport const schemasListDebug = subdebug('schemas:list')\nexport const schemasExtractDebug = subdebug('schemas:extract')\n"],"names":["subdebug","schemasDeployDebug","schemasListDebug","schemasExtractDebug"],"mappings":"AAAA,SAAQA,QAAQ,QAAO,mBAAkB;AAEzC,OAAO,MAAMC,qBAAqBD,SAAS,kBAAiB;AAC5D,OAAO,MAAME,mBAAmBF,SAAS,gBAAe;AACxD,OAAO,MAAMG,sBAAsBH,SAAS,mBAAkB"}

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

@@ -0,0 +1,12 @@
+import { resolveLocalPackage } from '@sanity/cli-core';
+/**
+ * Extracts validation problem groups from a SchemaError.
+ */ export async function extractValidationFromSchemaError(error, workDir) {
+    const { SchemaError } = await resolveLocalPackage('sanity', workDir);
+    if (error instanceof SchemaError) {
+        return error.schema._validation;
+    }
+    return undefined;
+}
+
+//# sourceMappingURL=extractValidationFromSchemaError.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/schema/utils/extractValidationFromSchemaError.ts"],"sourcesContent":["import {resolveLocalPackage} from '@sanity/cli-core'\nimport {type SchemaValidationProblemGroup} from '@sanity/types'\n\n/**\n * Extracts validation problem groups from a SchemaError.\n */\nexport async function extractValidationFromSchemaError(\n  error: unknown,\n  workDir: string,\n): Promise<SchemaValidationProblemGroup[] | undefined> {\n  const {SchemaError} = await resolveLocalPackage<typeof import('sanity')>('sanity', workDir)\n\n  if (error instanceof SchemaError) {\n    return error.schema._validation\n  }\n\n  return undefined\n}\n"],"names":["resolveLocalPackage","extractValidationFromSchemaError","error","workDir","SchemaError","schema","_validation","undefined"],"mappings":"AAAA,SAAQA,mBAAmB,QAAO,mBAAkB;AAGpD;;CAEC,GACD,OAAO,eAAeC,iCACpBC,KAAc,EACdC,OAAe;IAEf,MAAM,EAACC,WAAW,EAAC,GAAG,MAAMJ,oBAA6C,UAAUG;IAEnF,IAAID,iBAAiBE,aAAa;QAChC,OAAOF,MAAMG,MAAM,CAACC,WAAW;IACjC;IAEA,OAAOC;AACT"}

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

@@ -0,0 +1,33 @@
+import { styleText } from 'node:util';
+import { extractManifestSafe } from '../../manifest/extractManifest.js';
+import { FlagValidationError } from './schemaStoreValidation.js';
+export async function ensureManifestExtractSatisfied(args) {
+    const { extractManifest, manifestDir, manifestSafe, output, schemaRequired, workDir } = args;
+    if (!extractManifest) {
+        return true;
+    }
+    try {
+        // a successful manifest extract will write a new manifest file, which manifestReader will then read from disk
+        const error = await extractManifestSafe({
+            flags: {
+                json: false,
+                path: manifestDir
+            },
+            output,
+            workDir
+        });
+        if (!manifestSafe && error) {
+            throw error;
+        }
+        return true;
+    } catch (err) {
+        if (schemaRequired || err instanceof FlagValidationError) {
+            throw err;
+        } else {
+            output.log(styleText('gray', `↳ Failed to extract manifest:\n  ${err.message}`));
+            return false;
+        }
+    }
+}
+
+//# 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 {styleText} from 'node:util'\n\nimport {type Output} from '@sanity/cli-core'\n\nimport {extractManifestSafe} from '../../manifest/extractManifest.js'\nimport {FlagValidationError} from './schemaStoreValidation.js'\n\nexport async function ensureManifestExtractSatisfied(args: {\n  extractManifest: boolean\n  manifestDir: string\n  manifestSafe?: boolean\n  output: Output\n  schemaRequired?: boolean\n  workDir: string\n}) {\n  const {extractManifest, manifestDir, manifestSafe, output, schemaRequired, workDir} = 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    const error = await extractManifestSafe({\n      flags: {json: false, path: manifestDir},\n      output,\n      workDir,\n    })\n\n    if (!manifestSafe && error) {\n      throw error\n    }\n\n    return true\n  } catch (err) {\n    if (schemaRequired || err instanceof FlagValidationError) {\n      throw err\n    } else {\n      output.log(styleText('gray', `↳ Failed to extract manifest:\\n  ${err.message}`))\n      return false\n    }\n  }\n}\n"],"names":["styleText","extractManifestSafe","FlagValidationError","ensureManifestExtractSatisfied","args","extractManifest","manifestDir","manifestSafe","output","schemaRequired","workDir","error","flags","json","path","err","log","message"],"mappings":"AAAA,SAAQA,SAAS,QAAO,YAAW;AAInC,SAAQC,mBAAmB,QAAO,oCAAmC;AACrE,SAAQC,mBAAmB,QAAO,6BAA4B;AAE9D,OAAO,eAAeC,+BAA+BC,IAOpD;IACC,MAAM,EAACC,eAAe,EAAEC,WAAW,EAAEC,YAAY,EAAEC,MAAM,EAAEC,cAAc,EAAEC,OAAO,EAAC,GAAGN;IACtF,IAAI,CAACC,iBAAiB;QACpB,OAAO;IACT;IACA,IAAI;QACF,8GAA8G;QAC9G,MAAMM,QAAQ,MAAMV,oBAAoB;YACtCW,OAAO;gBAACC,MAAM;gBAAOC,MAAMR;YAAW;YACtCE;YACAE;QACF;QAEA,IAAI,CAACH,gBAAgBI,OAAO;YAC1B,MAAMA;QACR;QAEA,OAAO;IACT,EAAE,OAAOI,KAAK;QACZ,IAAIN,kBAAkBM,eAAeb,qBAAqB;YACxD,MAAMa;QACR,OAAO;YACLP,OAAOQ,GAAG,CAAChB,UAAU,QAAQ,CAAC,iCAAiC,EAAEe,IAAIE,OAAO,EAAE;YAC9E,OAAO;QACT;IACF;AACF"}

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

@@ -0,0 +1,71 @@
+import { readFile, stat } from 'node:fs/promises';
+import path, { join, resolve } from 'node:path';
+import { styleText } from 'node:util';
+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 = ({ manifestDir, output, workDir })=>{
+    let parsedManifest;
+    const parsedWorkspaces = {};
+    const getManifest = async ()=>{
+        if (parsedManifest) {
+            return parsedManifest?.parsedJson;
+        }
+        const staticPath = resolve(join(workDir, manifestDir));
+        const manifestFile = path.join(staticPath, MANIFEST_FILENAME);
+        const result = await parseJsonFile(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(styleText('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 parseJsonFile(workspaceSchemaFile);
+        if (!result) {
+            throw new Error(`Workspace schema file at "${workspaceSchemaFile}" does not exist.`);
+        }
+        parsedWorkspaces[workspaceName] = result;
+        return result.parsedJson;
+    };
+    return {
+        getManifest,
+        getWorkspaceSchema
+    };
+};
+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'\nimport {styleText} from 'node:util'\n\nimport {type Output} from '@sanity/cli-core'\n\nimport {MANIFEST_FILENAME} from '../../manifest/extractManifest.js'\nimport {type CreateManifest, type ManifestSchemaType} from '../../manifest/types.js'\n\ntype CreateManifestReaderFactory = (args: {\n  manifestDir: string\n  output: Output\n  workDir: string\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  manifestDir,\n  output,\n  workDir,\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 staticPath = resolve(join(workDir, manifestDir))\n    const manifestFile = path.join(staticPath, MANIFEST_FILENAME)\n\n    const result = await parseJsonFile<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 or run \"sanity manifest extract\" first.`,\n      )\n    }\n\n    output.log(\n      styleText(\n        'gray',\n        `↳ Read manifest from ${manifestFile} (last modified: ${result.lastModified})`,\n      ),\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 parseJsonFile<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\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","styleText","MANIFEST_FILENAME","createManifestReader","manifestDir","output","workDir","parsedManifest","parsedWorkspaces","getManifest","parsedJson","staticPath","manifestFile","result","parseJsonFile","Error","log","lastModified","getWorkspaceSchema","workspaceName","manifest","workspaceManifest","workspaces","find","workspace","name","workspaceSchemaFile","schema","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;AAC7C,SAAQC,SAAS,QAAO,YAAW;AAInC,SAAQC,iBAAiB,QAAO,oCAAmC;AAoBnE;;;CAGC,GACD,OAAO,MAAMC,uBAAoD,CAAC,EAChEC,WAAW,EACXC,MAAM,EACNC,OAAO,EACR;IACC,IAAIC;IACJ,MAAMC,mBACJ,CAAC;IAEH,MAAMC,cAAmD;QACvD,IAAIF,gBAAgB;YAClB,OAAOA,gBAAgBG;QACzB;QAEA,MAAMC,aAAaX,QAAQD,KAAKO,SAASF;QACzC,MAAMQ,eAAed,KAAKC,IAAI,CAACY,YAAYT;QAE3C,MAAMW,SAAS,MAAMC,cAA8BF;QACnD,IAAI,CAACC,QAAQ;YACX,MAAM,IAAIE,MACR,CAAC,2BAA2B,EAAEH,aAAa,iGAAiG,CAAC;QAEjJ;QAEAP,OAAOW,GAAG,CACRf,UACE,QACA,CAAC,qBAAqB,EAAEW,aAAa,iBAAiB,EAAEC,OAAOI,YAAY,CAAC,CAAC,CAAC;QAIlFV,iBAAiBM;QACjB,OAAOA,OAAOH,UAAU;IAC1B;IAEA,MAAMQ,qBAAiE,OAAOC;QAC5E,IAAIX,gBAAgB,CAACW,cAAc,EAAE;YACnC,OAAOX,gBAAgB,CAACW,cAAc,EAAET;QAC1C;QACA,MAAMU,WAAW,MAAMX;QACvB,IAAI,CAACW,UAAU;YACb,MAAM,IAAIL,MAAM;QAClB;QAEA,MAAMM,oBAAoBD,SAASE,UAAU,CAACC,IAAI,CAChD,CAACC,YAAcA,UAAUC,IAAI,KAAKN;QAGpC,IAAI,CAACE,mBAAmB;YACtB,MAAM,IAAIN,MAAM,CAAC,oBAAoB,EAAEI,cAAc,oBAAoB,CAAC;QAC5E;QAEA,MAAMO,sBAAsB5B,KAAKC,IAAI,CAACK,aAAaiB,kBAAkBM,MAAM;QAC3E,MAAMd,SAAS,MAAMC,cAAoCY;QACzD,IAAI,CAACb,QAAQ;YACX,MAAM,IAAIE,MAAM,CAAC,0BAA0B,EAAEW,oBAAoB,iBAAiB,CAAC;QACrF;QACAlB,gBAAgB,CAACW,cAAc,GAAGN;QAClC,OAAOA,OAAOH,UAAU;IAC1B;IACA,OAAO;QACLD;QACAS;IACF;AACF,EAAC;AAED,eAAeJ,cAAiBc,QAAgB;IAC9C,IAAIC;IACJ,IAAI;QACFA,QAAQ,MAAMhC,KAAK+B;IACrB,EAAE,OAAM;QACN,sBAAsB;QACtB,OAAOE;IACT;IACA,MAAMC,UAAU,MAAMnC,SAASgC,UAAU;IACzC,MAAMX,eAAeY,MAAMG,KAAK,CAACC,WAAW;IAC5C,MAAMC,OAAOC,KAAKC,KAAK,CAACL;IACxB,IAAI,CAACG,MAAM;QACT,MAAM,IAAInB,MAAM,CAAC,WAAW,EAAEa,SAAS,YAAY,CAAC;IACtD;IACA,OAAO;QACLX;QACAP,YAAYwB;QACZpC,MAAM8B;IACR;AACF"}

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)}`;
+}
+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\nfunction 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,SAASE,wBAAwBC,KAAe;IAC9C,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.js

@@ -0,0 +1,108 @@
+import { CLIError } from '@oclif/core/errors';
+import { uniqBy } from '../../../util/uniqBy.js';
+import { isDefined } from '../../manifest/schemaTypeHelpers.js';
+import { SANITY_WORKSPACE_SCHEMA_ID_PREFIX } from '../../manifest/types.js';
+const validForIdChars = 'a-zA-Z0-9._-';
+const validForIdPattern = new RegExp(`^[${validForIdChars}]+$`);
+//no periods allowed in workspaceName or tag in ids
+export const validForNamesChars = 'a-zA-Z0-9_-';
+export const validForNamesPattern = new RegExp(`^[${validForNamesChars}]+$`);
+const requiredInId = SANITY_WORKSPACE_SCHEMA_ID_PREFIX.replaceAll(/[.]/g, String.raw`\.`);
+const idIdPatternString = String.raw`^${requiredInId}\.([${validForNamesChars}]+)`;
+const baseIdPattern = new RegExp(`${idIdPatternString}$`);
+const taggedIdIdPattern = new RegExp(String.raw`${idIdPatternString}\.tag\.([${validForNamesChars}]+)$`);
+export class FlagValidationError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'FlagValidationError';
+    }
+}
+export function parseIds(ids) {
+    if (!ids) {
+        throw new CLIError('ids argument is empty');
+    }
+    const errors = [];
+    const parsedIds = ids.split(',').map((id)=>id.trim()).filter((id)=>!!id).map((id)=>parseWorkspaceSchemaId(errors, id)).filter((item)=>isDefined(item));
+    if (errors.length > 0) {
+        throw new CLIError(`Invalid arguments:\n${errors.map((error)=>`  - ${error}`).join('\n')}`);
+    }
+    if (parsedIds.length === 0) {
+        throw new CLIError(`ids contains no valid id strings`);
+    }
+    const uniqueIds = uniqBy(parsedIds, 'schemaId');
+    if (uniqueIds.length < parsedIds.length) {
+        throw new CLIError(`ids contains duplicates`);
+    }
+    return uniqueIds;
+}
+export function parseWorkspaceSchemaId(errors, id) {
+    if (id === undefined) {
+        return;
+    }
+    if (!id) {
+        errors.push('id argument is empty');
+        return;
+    }
+    const trimmedId = id.trim();
+    if (!validForIdPattern.test(trimmedId)) {
+        errors.push(`id can only contain characters in [${validForIdChars}] but found: "${trimmedId}"`);
+        return;
+    }
+    if (trimmedId.startsWith('-')) {
+        errors.push(`id cannot start with - (dash) but found: "${trimmedId}"`);
+        return;
+    }
+    if (/\.\./g.test(trimmedId)) {
+        errors.push(`id cannot have consecutive . (period) characters, but found: "${trimmedId}"`);
+        return;
+    }
+    const [, workspace] = trimmedId.match(taggedIdIdPattern) ?? trimmedId.match(baseIdPattern) ?? [];
+    if (!workspace) {
+        errors.push([
+            `id must either match ${SANITY_WORKSPACE_SCHEMA_ID_PREFIX}.<workspaceName> `,
+            `or ${SANITY_WORKSPACE_SCHEMA_ID_PREFIX}.<workspaceName>.tag.<tag> but found: "${trimmedId}". `,
+            `Note that workspace name characters not in [${validForNamesChars}] has to be replaced with _ for schema id.`
+        ].join(''));
+        return;
+    }
+    return {
+        schemaId: trimmedId,
+        workspace
+    };
+}
+/**
+ *
+ * @param tag - The tag to parse
+ * Throws an error if the tag is empty
+ * Throws an error if the tag contains a period
+ * Throws an error if the tag starts with a dash
+ * Returns the parsed tag
+ */ export async function parseTag(tag) {
+    if (tag === undefined) {
+        return tag;
+    }
+    if (!tag) {
+        throw new CLIError('tag argument is empty');
+    }
+    if (tag.includes('.')) {
+        throw new CLIError(`tag cannot contain . (period), but was: "${tag}"`);
+    }
+    if (!validForNamesPattern.test(tag)) {
+        throw new CLIError(`tag can only contain characters in [${validForNamesChars}], but was: "${tag}"`);
+    }
+    if (tag.startsWith('-')) {
+        throw new CLIError(`tag cannot start with - (dash) but was: "${tag}"`);
+    }
+    return tag;
+}
+function getProjectIdMismatchMessage(workspace, operation) {
+    return `No permissions to ${operation} schema for workspace "${workspace.name}" with projectId "${workspace.projectId}"`;
+}
+export function filterLogReadProjectIdMismatch(workspace, projectId, output) {
+    const canRead = workspace.projectId === projectId;
+    if (!canRead) output.warn(`${getProjectIdMismatchMessage(workspace, 'read')} – ignoring it.`);
+    return canRead;
+}
+export const SCHEMA_PERMISSION_HELP_TEXT = 'For multi-project workspaces, set SANITY_AUTH_TOKEN environment variable to a token with access to the workspace projects.';
+
+//# sourceMappingURL=schemaStoreValidation.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/schema/utils/schemaStoreValidation.ts"],"sourcesContent":["import {CLIError} from '@oclif/core/errors'\nimport {type Output} from '@sanity/cli-core'\n\nimport {uniqBy} from '../../../util/uniqBy.js'\nimport {isDefined} from '../../manifest/schemaTypeHelpers.js'\nimport {SANITY_WORKSPACE_SCHEMA_ID_PREFIX} from '../../manifest/types.js'\n\nconst validForIdChars = 'a-zA-Z0-9._-'\nconst validForIdPattern = new RegExp(`^[${validForIdChars}]+$`)\n\n//no periods allowed in workspaceName or tag in ids\nexport const validForNamesChars = 'a-zA-Z0-9_-'\nexport const validForNamesPattern = new RegExp(`^[${validForNamesChars}]+$`)\n\nconst requiredInId = SANITY_WORKSPACE_SCHEMA_ID_PREFIX.replaceAll(/[.]/g, String.raw`\\.`)\n\nconst idIdPatternString = String.raw`^${requiredInId}\\.([${validForNamesChars}]+)`\nconst baseIdPattern = new RegExp(`${idIdPatternString}$`)\nconst taggedIdIdPattern = new RegExp(\n  String.raw`${idIdPatternString}\\.tag\\.([${validForNamesChars}]+)$`,\n)\n\nexport class FlagValidationError extends Error {\n  constructor(message: string) {\n    super(message)\n    this.name = 'FlagValidationError'\n  }\n}\n\nexport interface WorkspaceSchemaId {\n  schemaId: string\n  workspace: string\n}\n\nexport function parseIds(ids?: string): WorkspaceSchemaId[] {\n  if (!ids) {\n    throw new CLIError('ids argument is empty')\n  }\n\n  const errors: string[] = []\n\n  const parsedIds = ids\n    .split(',')\n    .map((id) => id.trim())\n    .filter((id) => !!id)\n    .map((id) => parseWorkspaceSchemaId(errors, id))\n    .filter((item) => isDefined(item))\n\n  if (errors.length > 0) {\n    throw new CLIError(`Invalid arguments:\\n${errors.map((error) => `  - ${error}`).join('\\n')}`)\n  }\n\n  if (parsedIds.length === 0) {\n    throw new CLIError(`ids contains no valid id strings`)\n  }\n\n  const uniqueIds = uniqBy(parsedIds, 'schemaId' satisfies keyof (typeof parsedIds)[number])\n  if (uniqueIds.length < parsedIds.length) {\n    throw new CLIError(`ids contains duplicates`)\n  }\n\n  return uniqueIds\n}\n\nexport function parseWorkspaceSchemaId(errors: string[], id?: string) {\n  if (id === undefined) {\n    return\n  }\n\n  if (!id) {\n    errors.push('id argument is empty')\n    return\n  }\n\n  const trimmedId = id.trim()\n\n  if (!validForIdPattern.test(trimmedId)) {\n    errors.push(`id can only contain characters in [${validForIdChars}] but found: \"${trimmedId}\"`)\n    return\n  }\n\n  if (trimmedId.startsWith('-')) {\n    errors.push(`id cannot start with - (dash) but found: \"${trimmedId}\"`)\n    return\n  }\n\n  if (/\\.\\./g.test(trimmedId)) {\n    errors.push(`id cannot have consecutive . (period) characters, but found: \"${trimmedId}\"`)\n    return\n  }\n\n  const [, workspace] = trimmedId.match(taggedIdIdPattern) ?? trimmedId.match(baseIdPattern) ?? []\n  if (!workspace) {\n    errors.push(\n      [\n        `id must either match ${SANITY_WORKSPACE_SCHEMA_ID_PREFIX}.<workspaceName> `,\n        `or ${SANITY_WORKSPACE_SCHEMA_ID_PREFIX}.<workspaceName>.tag.<tag> but found: \"${trimmedId}\". `,\n        `Note that workspace name characters not in [${validForNamesChars}] has to be replaced with _ for schema id.`,\n      ].join(''),\n    )\n    return\n  }\n  return {\n    schemaId: trimmedId,\n    workspace,\n  }\n}\n\n/**\n *\n * @param tag - The tag to parse\n * Throws an error if the tag is empty\n * Throws an error if the tag contains a period\n * Throws an error if the tag starts with a dash\n * Returns the parsed tag\n */\nexport async function parseTag(tag?: string) {\n  if (tag === undefined) {\n    return tag\n  }\n\n  if (!tag) {\n    throw new CLIError('tag argument is empty')\n  }\n\n  if (tag.includes('.')) {\n    throw new CLIError(`tag cannot contain . (period), but was: \"${tag}\"`)\n  }\n\n  if (!validForNamesPattern.test(tag)) {\n    throw new CLIError(\n      `tag can only contain characters in [${validForNamesChars}], but was: \"${tag}\"`,\n    )\n  }\n\n  if (tag.startsWith('-')) {\n    throw new CLIError(`tag cannot start with - (dash) but was: \"${tag}\"`)\n  }\n\n  return tag\n}\n\nfunction getProjectIdMismatchMessage(\n  workspace: {name: string; projectId: string},\n  operation: 'read' | 'write',\n) {\n  return `No permissions to ${operation} schema for workspace \"${workspace.name}\" with projectId \"${workspace.projectId}\"`\n}\n\nexport function filterLogReadProjectIdMismatch(\n  workspace: {name: string; projectId: string},\n  projectId: string,\n  output: Output,\n) {\n  const canRead = workspace.projectId === projectId\n  if (!canRead) output.warn(`${getProjectIdMismatchMessage(workspace, 'read')} – ignoring it.`)\n  return canRead\n}\n\nexport const SCHEMA_PERMISSION_HELP_TEXT =\n  'For multi-project workspaces, set SANITY_AUTH_TOKEN environment variable to a token with access to the workspace projects.'\n"],"names":["CLIError","uniqBy","isDefined","SANITY_WORKSPACE_SCHEMA_ID_PREFIX","validForIdChars","validForIdPattern","RegExp","validForNamesChars","validForNamesPattern","requiredInId","replaceAll","String","raw","idIdPatternString","baseIdPattern","taggedIdIdPattern","FlagValidationError","Error","message","name","parseIds","ids","errors","parsedIds","split","map","id","trim","filter","parseWorkspaceSchemaId","item","length","error","join","uniqueIds","undefined","push","trimmedId","test","startsWith","workspace","match","schemaId","parseTag","tag","includes","getProjectIdMismatchMessage","operation","projectId","filterLogReadProjectIdMismatch","output","canRead","warn","SCHEMA_PERMISSION_HELP_TEXT"],"mappings":"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"}

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

@@ -0,0 +1,9 @@
+import { uniqBy } from '../../../util/uniqBy.js';
+export function uniqByProjectIdDataset(workspaces) {
+    return uniqBy(workspaces.map((w)=>({
+            ...w,
+            key: `${w.projectId}-${w.dataset}`
+        })), 'key');
+}
+
+//# sourceMappingURL=uniqByProjectIdDataset.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/schema/utils/uniqByProjectIdDataset.ts"],"sourcesContent":["import {uniqBy} from '../../../util/uniqBy.js'\nimport {type ManifestWorkspaceFile} from '../../manifest/types'\n\nexport function uniqByProjectIdDataset(workspaces: ManifestWorkspaceFile[]) {\n  return uniqBy(\n    workspaces.map((w) => ({\n      ...w,\n      key: `${w.projectId}-${w.dataset}`,\n    })),\n    'key',\n  )\n}\n"],"names":["uniqBy","uniqByProjectIdDataset","workspaces","map","w","key","projectId","dataset"],"mappings":"AAAA,SAAQA,MAAM,QAAO,0BAAyB;AAG9C,OAAO,SAASC,uBAAuBC,UAAmC;IACxE,OAAOF,OACLE,WAAWC,GAAG,CAAC,CAACC,IAAO,CAAA;YACrB,GAAGA,CAAC;YACJC,KAAK,GAAGD,EAAEE,SAAS,CAAC,CAAC,EAAEF,EAAEG,OAAO,EAAE;QACpC,CAAA,IACA;AAEJ"}

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

@@ -0,0 +1,23 @@
+import { SANITY_WORKSPACE_SCHEMA_ID_PREFIX } from '../../manifest/types.js';
+import { validForNamesChars, validForNamesPattern } from './schemaStoreValidation.js';
+export function getWorkspaceSchemaId(args) {
+    const { tag, workspaceName: rawWorkspaceName } = args;
+    let workspaceName = rawWorkspaceName;
+    let idWarning;
+    // The HTTP API replaces periods with _ in the workspace name, so the CLI should too
+    if (!validForNamesPattern.test(workspaceName)) {
+        workspaceName = workspaceName.replaceAll(new RegExp(`[^${validForNamesChars}]`, 'g'), '_');
+        idWarning = [
+            `Workspace "${rawWorkspaceName}" contains characters unsupported by schema _id [${validForNamesChars}], they will be replaced with _.`,
+            'This could lead duplicate schema ids: consider renaming your workspace.'
+        ].join('\n');
+    }
+    const safeBaseId = `${SANITY_WORKSPACE_SCHEMA_ID_PREFIX}.${workspaceName}`;
+    return {
+        idWarning,
+        safeBaseId,
+        safeTaggedId: `${safeBaseId}${tag ? `.${tag}` : ''}`
+    };
+}
+
+//# sourceMappingURL=workspaceSchemaId.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/schema/utils/workspaceSchemaId.ts"],"sourcesContent":["import {\n  type DefaultWorkspaceSchemaId,\n  SANITY_WORKSPACE_SCHEMA_ID_PREFIX,\n  type WorkspaceSchemaId,\n} from '../../manifest/types.js'\nimport {validForNamesChars, validForNamesPattern} from './schemaStoreValidation.js'\n\nexport function getWorkspaceSchemaId(args: {tag?: string; workspaceName: string}) {\n  const {tag, workspaceName: rawWorkspaceName} = args\n\n  let workspaceName = rawWorkspaceName\n  let idWarning: string | undefined\n\n  // The HTTP API replaces periods with _ in the workspace name, so the CLI should too\n  if (!validForNamesPattern.test(workspaceName)) {\n    workspaceName = workspaceName.replaceAll(new RegExp(`[^${validForNamesChars}]`, 'g'), '_')\n    idWarning = [\n      `Workspace \"${rawWorkspaceName}\" contains characters unsupported by schema _id [${validForNamesChars}], they will be replaced with _.`,\n      'This could lead duplicate schema ids: consider renaming your workspace.',\n    ].join('\\n')\n  }\n\n  const safeBaseId: DefaultWorkspaceSchemaId = `${SANITY_WORKSPACE_SCHEMA_ID_PREFIX}.${workspaceName}`\n  return {\n    idWarning,\n    safeBaseId,\n    safeTaggedId: `${safeBaseId}${tag ? `.${tag}` : ''}` satisfies WorkspaceSchemaId,\n  }\n}\n"],"names":["SANITY_WORKSPACE_SCHEMA_ID_PREFIX","validForNamesChars","validForNamesPattern","getWorkspaceSchemaId","args","tag","workspaceName","rawWorkspaceName","idWarning","test","replaceAll","RegExp","join","safeBaseId","safeTaggedId"],"mappings":"AAAA,SAEEA,iCAAiC,QAE5B,0BAAyB;AAChC,SAAQC,kBAAkB,EAAEC,oBAAoB,QAAO,6BAA4B;AAEnF,OAAO,SAASC,qBAAqBC,IAA2C;IAC9E,MAAM,EAACC,GAAG,EAAEC,eAAeC,gBAAgB,EAAC,GAAGH;IAE/C,IAAIE,gBAAgBC;IACpB,IAAIC;IAEJ,oFAAoF;IACpF,IAAI,CAACN,qBAAqBO,IAAI,CAACH,gBAAgB;QAC7CA,gBAAgBA,cAAcI,UAAU,CAAC,IAAIC,OAAO,CAAC,EAAE,EAAEV,mBAAmB,CAAC,CAAC,EAAE,MAAM;QACtFO,YAAY;YACV,CAAC,WAAW,EAAED,iBAAiB,iDAAiD,EAAEN,mBAAmB,gCAAgC,CAAC;YACtI;SACD,CAACW,IAAI,CAAC;IACT;IAEA,MAAMC,aAAuC,GAAGb,kCAAkC,CAAC,EAAEM,eAAe;IACpG,OAAO;QACLE;QACAK;QACAC,cAAc,GAAGD,aAAaR,MAAM,CAAC,CAAC,EAAEA,KAAK,GAAG,IAAI;IACtD;AACF"}

package/dist/actions/schema/validateAction.js

@@ -0,0 +1,71 @@
+import { writeFileSync } from 'node:fs';
+import { studioWorkerTask } from '@sanity/cli-core';
+import { logSymbols, spinner } from '@sanity/cli-core/ux';
+import { formatSchemaValidation, getAggregatedSeverity } from './formatSchemaValidation.js';
+import { generateMetafile } from './metafile.js';
+export async function validateAction(options) {
+    const { debugMetafilePath, format, level, output, workDir, workspace } = options;
+    let spin;
+    if (format === 'pretty') {
+        spin = spinner(workspace ? `Validating schema from workspace '${workspace}'…` : 'Validating schema…').start();
+    }
+    const { serializedDebug, validation } = await studioWorkerTask(new URL('validateSchema.worker.js', import.meta.url), {
+        name: 'validateSchema',
+        studioRootPath: workDir,
+        workerData: {
+            debugSerialize: Boolean(debugMetafilePath),
+            level,
+            workDir,
+            workspace: workspace
+        }
+    });
+    const problems = validation.flatMap((group)=>group.problems);
+    const errorCount = problems.filter((problem)=>problem.severity === 'error').length;
+    const warningCount = problems.filter((problem)=>problem.severity === 'warning').length;
+    const overallSeverity = getAggregatedSeverity(validation);
+    const didFail = overallSeverity === 'error';
+    if (debugMetafilePath && !didFail) {
+        if (!serializedDebug) throw new Error('serializedDebug should always be produced');
+        const metafile = generateMetafile(serializedDebug);
+        writeFileSync(debugMetafilePath, JSON.stringify(metafile), 'utf8');
+    }
+    switch(format){
+        case 'json':
+            {
+                output.log(JSON.stringify(validation));
+                break;
+            }
+        case 'ndjson':
+            {
+                for (const group of validation){
+                    output.log(JSON.stringify(group));
+                }
+                break;
+            }
+        default:
+            {
+                spin?.succeed('Validated schema');
+                output.log(`\nValidation results:`);
+                output.log(`${logSymbols.error} Errors:   ${errorCount.toLocaleString('en-US')} error${errorCount === 1 ? '' : 's'}`);
+                if (level !== 'error') {
+                    output.log(`${logSymbols.warning} Warnings: ${warningCount.toLocaleString('en-US')} warning${warningCount === 1 ? '' : 's'}`);
+                }
+                output.log();
+                output.log(formatSchemaValidation(validation));
+                if (debugMetafilePath) {
+                    output.log();
+                    if (didFail) {
+                        output.log(`${logSymbols.info} Metafile not written due to validation errors`);
+                    } else {
+                        output.log(`${logSymbols.info} Metafile written to: ${debugMetafilePath}`);
+                        output.log(`  This can be analyzed at https://esbuild.github.io/analyze/`);
+                    }
+                }
+            }
+    }
+    if (didFail) {
+        throw new Error('Schema validation failed');
+    }
+}
+
+//# sourceMappingURL=validateAction.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/schema/validateAction.ts"],"sourcesContent":["import {writeFileSync} from 'node:fs'\n\nimport {Output, studioWorkerTask} from '@sanity/cli-core'\nimport {logSymbols, spinner} from '@sanity/cli-core/ux'\n\nimport {formatSchemaValidation, getAggregatedSeverity} from './formatSchemaValidation.js'\nimport {generateMetafile} from './metafile.js'\nimport {\n  type ValidateSchemaWorkerData,\n  type ValidateSchemaWorkerResult,\n} from './validateSchema.worker.js'\n\ninterface Options {\n  output: Output\n  workDir: string\n\n  debugMetafilePath?: string\n  format?: string\n  level?: 'error' | 'warning'\n  workspace?: string\n}\n\nexport async function validateAction(options: Options): Promise<void> {\n  const {debugMetafilePath, format, level, output, workDir, workspace} = options\n\n  let spin\n\n  if (format === 'pretty') {\n    spin = spinner(\n      workspace ? `Validating schema from workspace '${workspace}'…` : 'Validating schema…',\n    ).start()\n  }\n\n  const {serializedDebug, validation} = await studioWorkerTask<ValidateSchemaWorkerResult>(\n    new URL('validateSchema.worker.js', import.meta.url),\n    {\n      name: 'validateSchema',\n      studioRootPath: workDir,\n      workerData: {\n        debugSerialize: Boolean(debugMetafilePath),\n        level,\n        workDir,\n        workspace: workspace,\n      } satisfies ValidateSchemaWorkerData,\n    },\n  )\n\n  const problems = validation.flatMap((group) => group.problems)\n  const errorCount = problems.filter((problem) => problem.severity === 'error').length\n  const warningCount = problems.filter((problem) => problem.severity === 'warning').length\n\n  const overallSeverity = getAggregatedSeverity(validation)\n  const didFail = overallSeverity === 'error'\n\n  if (debugMetafilePath && !didFail) {\n    if (!serializedDebug) throw new Error('serializedDebug should always be produced')\n    const metafile = generateMetafile(serializedDebug)\n    writeFileSync(debugMetafilePath, JSON.stringify(metafile), 'utf8')\n  }\n\n  switch (format) {\n    case 'json': {\n      output.log(JSON.stringify(validation))\n      break\n    }\n    case 'ndjson': {\n      for (const group of validation) {\n        output.log(JSON.stringify(group))\n      }\n      break\n    }\n    default: {\n      spin?.succeed('Validated schema')\n      output.log(`\\nValidation results:`)\n      output.log(\n        `${logSymbols.error} Errors:   ${errorCount.toLocaleString('en-US')} error${\n          errorCount === 1 ? '' : 's'\n        }`,\n      )\n      if (level !== 'error') {\n        output.log(\n          `${logSymbols.warning} Warnings: ${warningCount.toLocaleString('en-US')} warning${\n            warningCount === 1 ? '' : 's'\n          }`,\n        )\n      }\n      output.log()\n\n      output.log(formatSchemaValidation(validation))\n\n      if (debugMetafilePath) {\n        output.log()\n        if (didFail) {\n          output.log(`${logSymbols.info} Metafile not written due to validation errors`)\n        } else {\n          output.log(`${logSymbols.info} Metafile written to: ${debugMetafilePath}`)\n          output.log(`  This can be analyzed at https://esbuild.github.io/analyze/`)\n        }\n      }\n    }\n  }\n\n  if (didFail) {\n    throw new Error('Schema validation failed')\n  }\n}\n"],"names":["writeFileSync","studioWorkerTask","logSymbols","spinner","formatSchemaValidation","getAggregatedSeverity","generateMetafile","validateAction","options","debugMetafilePath","format","level","output","workDir","workspace","spin","start","serializedDebug","validation","URL","url","name","studioRootPath","workerData","debugSerialize","Boolean","problems","flatMap","group","errorCount","filter","problem","severity","length","warningCount","overallSeverity","didFail","Error","metafile","JSON","stringify","log","succeed","error","toLocaleString","warning","info"],"mappings":"AAAA,SAAQA,aAAa,QAAO,UAAS;AAErC,SAAgBC,gBAAgB,QAAO,mBAAkB;AACzD,SAAQC,UAAU,EAAEC,OAAO,QAAO,sBAAqB;AAEvD,SAAQC,sBAAsB,EAAEC,qBAAqB,QAAO,8BAA6B;AACzF,SAAQC,gBAAgB,QAAO,gBAAe;AAgB9C,OAAO,eAAeC,eAAeC,OAAgB;IACnD,MAAM,EAACC,iBAAiB,EAAEC,MAAM,EAAEC,KAAK,EAAEC,MAAM,EAAEC,OAAO,EAAEC,SAAS,EAAC,GAAGN;IAEvE,IAAIO;IAEJ,IAAIL,WAAW,UAAU;QACvBK,OAAOZ,QACLW,YAAY,CAAC,kCAAkC,EAAEA,UAAU,EAAE,CAAC,GAAG,sBACjEE,KAAK;IACT;IAEA,MAAM,EAACC,eAAe,EAAEC,UAAU,EAAC,GAAG,MAAMjB,iBAC1C,IAAIkB,IAAI,4BAA4B,YAAYC,GAAG,GACnD;QACEC,MAAM;QACNC,gBAAgBT;QAChBU,YAAY;YACVC,gBAAgBC,QAAQhB;YACxBE;YACAE;YACAC,WAAWA;QACb;IACF;IAGF,MAAMY,WAAWR,WAAWS,OAAO,CAAC,CAACC,QAAUA,MAAMF,QAAQ;IAC7D,MAAMG,aAAaH,SAASI,MAAM,CAAC,CAACC,UAAYA,QAAQC,QAAQ,KAAK,SAASC,MAAM;IACpF,MAAMC,eAAeR,SAASI,MAAM,CAAC,CAACC,UAAYA,QAAQC,QAAQ,KAAK,WAAWC,MAAM;IAExF,MAAME,kBAAkB9B,sBAAsBa;IAC9C,MAAMkB,UAAUD,oBAAoB;IAEpC,IAAI1B,qBAAqB,CAAC2B,SAAS;QACjC,IAAI,CAACnB,iBAAiB,MAAM,IAAIoB,MAAM;QACtC,MAAMC,WAAWhC,iBAAiBW;QAClCjB,cAAcS,mBAAmB8B,KAAKC,SAAS,CAACF,WAAW;IAC7D;IAEA,OAAQ5B;QACN,KAAK;YAAQ;gBACXE,OAAO6B,GAAG,CAACF,KAAKC,SAAS,CAACtB;gBAC1B;YACF;QACA,KAAK;YAAU;gBACb,KAAK,MAAMU,SAASV,WAAY;oBAC9BN,OAAO6B,GAAG,CAACF,KAAKC,SAAS,CAACZ;gBAC5B;gBACA;YACF;QACA;YAAS;gBACPb,MAAM2B,QAAQ;gBACd9B,OAAO6B,GAAG,CAAC,CAAC,qBAAqB,CAAC;gBAClC7B,OAAO6B,GAAG,CACR,GAAGvC,WAAWyC,KAAK,CAAC,WAAW,EAAEd,WAAWe,cAAc,CAAC,SAAS,MAAM,EACxEf,eAAe,IAAI,KAAK,KACxB;gBAEJ,IAAIlB,UAAU,SAAS;oBACrBC,OAAO6B,GAAG,CACR,GAAGvC,WAAW2C,OAAO,CAAC,WAAW,EAAEX,aAAaU,cAAc,CAAC,SAAS,QAAQ,EAC9EV,iBAAiB,IAAI,KAAK,KAC1B;gBAEN;gBACAtB,OAAO6B,GAAG;gBAEV7B,OAAO6B,GAAG,CAACrC,uBAAuBc;gBAElC,IAAIT,mBAAmB;oBACrBG,OAAO6B,GAAG;oBACV,IAAIL,SAAS;wBACXxB,OAAO6B,GAAG,CAAC,GAAGvC,WAAW4C,IAAI,CAAC,8CAA8C,CAAC;oBAC/E,OAAO;wBACLlC,OAAO6B,GAAG,CAAC,GAAGvC,WAAW4C,IAAI,CAAC,sBAAsB,EAAErC,mBAAmB;wBACzEG,OAAO6B,GAAG,CAAC,CAAC,4DAA4D,CAAC;oBAC3E;gBACF;YACF;IACF;IAEA,IAAIL,SAAS;QACX,MAAM,IAAIC,MAAM;IAClB;AACF"}

package/dist/actions/schema/validateSchema.worker.js

@@ -0,0 +1,124 @@
+import { isMainThread, parentPort, workerData } from 'node:worker_threads';
+import { findStudioConfigPath, getStudioWorkspaces } from '@sanity/cli-core';
+import { DescriptorConverter } from '@sanity/schema/_internal';
+import { getWorkspace } from '../../util/getWorkspace.js';
+const { debugSerialize, level = 'warning', workDir, workspace: workspaceName } = workerData;
+async function main() {
+    if (isMainThread || !parentPort) {
+        throw new Error('This module must be run as a worker thread');
+    }
+    try {
+        const configPath = await findStudioConfigPath(workDir);
+        const workspaces = await getStudioWorkspaces(configPath);
+        const workspace = getWorkspace(workspaces, workspaceName);
+        const schema = workspace.schema;
+        parentPort?.postMessage(await resultFromSchema(schema));
+    } catch (err) {
+        if (isSchemaError(err)) {
+            parentPort?.postMessage(await resultFromSchema(err.schema));
+            return;
+        }
+        throw err;
+    }
+}
+async function resultFromSchema(schema) {
+    let serializedDebug;
+    if (debugSerialize) {
+        const conv = new DescriptorConverter();
+        const set = await conv.get(schema);
+        serializedDebug = getSerializedSchemaDebug(set);
+    }
+    const validation = schema._validation ?? [];
+    const result = {
+        serializedDebug,
+        validation: validation.map((group)=>({
+                ...group,
+                problems: group.problems.filter((problem)=>level === 'error' ? problem.severity === 'error' : true)
+            })).filter((group)=>group.problems.length)
+    };
+    return result;
+}
+function getSerializedSchemaDebug(set) {
+    let size = 0;
+    const types = {};
+    const hoisted = {};
+    for (const [id, value] of Object.entries(set.objectValues)){
+        const descType = typeof value.type === 'string' ? value.type : '<unknown>';
+        switch(descType){
+            case 'sanity.schema.hoisted':
+                {
+                    const key = typeof value.key === 'string' ? value.key : id;
+                    // The `hoisted` can technically  hoist _anything_,
+                    // but we detect the common case of field + array element.
+                    if (isEncodableObject(value.value) && isEncodableObject(value.value.typeDef)) {
+                        const debug = getSerializedTypeDebug(value.value.typeDef);
+                        hoisted[key] = debug;
+                        size += debug.size;
+                    }
+                    break;
+                }
+            case 'sanity.schema.namedType':
+                {
+                    const typeName = typeof value.name === 'string' ? value.name : id;
+                    if (isEncodableObject(value.typeDef)) {
+                        const debug = getSerializedTypeDebug(value.typeDef);
+                        types[typeName] = debug;
+                        size += debug.size;
+                    }
+                    break;
+                }
+            default:
+        }
+        size += JSON.stringify(value).length;
+    }
+    return {
+        hoisted,
+        size,
+        types
+    };
+}
+function isEncodableObject(val) {
+    return typeof val === 'object' && val !== null && !Array.isArray(val);
+}
+function isSchemaError(err) {
+    return err !== null && typeof err === 'object' && 'schema' in err && err.schema !== null && typeof err.schema === 'object' && '_validation' in err.schema;
+}
+function getSerializedTypeDebug(typeDef) {
+    const ext = typeof typeDef.extends === 'string' ? typeDef.extends : '<unknown>';
+    let fields;
+    let of;
+    if (Array.isArray(typeDef.fields)) {
+        fields = {};
+        for (const field of typeDef.fields){
+            if (!isEncodableObject(field)) continue;
+            const name = field.name;
+            const fieldTypeDef = field.typeDef;
+            if (typeof name !== 'string' || !isEncodableObject(fieldTypeDef)) continue;
+            fields[name] = getSerializedTypeDebug(fieldTypeDef);
+        }
+    }
+    if (Array.isArray(typeDef.of)) {
+        of = {};
+        for (const field of typeDef.of){
+            if (!isEncodableObject(field)) continue;
+            const name = field.name;
+            const arrayTypeDef = field.typeDef;
+            if (typeof name !== 'string' || !isEncodableObject(arrayTypeDef)) continue;
+            of[name] = getSerializedTypeDebug(arrayTypeDef);
+        }
+    }
+    return {
+        extends: ext,
+        fields,
+        of,
+        size: JSON.stringify(typeDef).length
+    };
+}
+await main();
+// Explicitly exit the process to avoid any dangling references from keeping
+// the process alive after resolving it's main task
+setImmediate(()=>{
+    process.exit(1);
+});
+
+//# sourceMappingURL=validateSchema.worker.js.map

package/dist/actions/schema/validateSchema.worker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/schema/validateSchema.worker.ts"],"sourcesContent":["import {isMainThread, parentPort, workerData} from 'node:worker_threads'\n\nimport {findStudioConfigPath, getStudioWorkspaces} from '@sanity/cli-core'\nimport {\n  type EncodableObject,\n  type EncodableValue,\n  type SetSynchronization,\n} from '@sanity/descriptors'\nimport {DescriptorConverter} from '@sanity/schema/_internal'\nimport {\n  type Schema,\n  type SchemaValidationProblem,\n  type SchemaValidationProblemGroup,\n} from '@sanity/types'\n\nimport {getWorkspace} from '../../util/getWorkspace.js'\nimport {type SerializedSchemaDebug, type SerializedTypeDebug} from './types.js'\n\n/** @internal */\nexport interface ValidateSchemaWorkerData {\n  workDir: string\n\n  debugSerialize?: boolean\n  level?: SchemaValidationProblem['severity']\n  workspace?: string\n}\n\n/** @internal */\nexport interface ValidateSchemaWorkerResult {\n  validation: SchemaValidationProblemGroup[]\n\n  serializedDebug?: SerializedSchemaDebug\n}\n\nconst {\n  debugSerialize,\n  level = 'warning',\n  workDir,\n  workspace: workspaceName,\n} = workerData as ValidateSchemaWorkerData\n\nasync function main() {\n  if (isMainThread || !parentPort) {\n    throw new Error('This module must be run as a worker thread')\n  }\n\n  try {\n    const configPath = await findStudioConfigPath(workDir)\n    const workspaces = await getStudioWorkspaces(configPath)\n    const workspace = getWorkspace(workspaces, workspaceName)\n    const schema = workspace.schema\n    parentPort?.postMessage(await resultFromSchema(schema))\n  } catch (err: unknown) {\n    if (isSchemaError(err)) {\n      parentPort?.postMessage(await resultFromSchema(err.schema))\n      return\n    }\n\n    throw err\n  }\n}\n\nasync function resultFromSchema(schema: Schema): Promise<ValidateSchemaWorkerResult> {\n  let serializedDebug: ValidateSchemaWorkerResult['serializedDebug']\n\n  if (debugSerialize) {\n    const conv = new DescriptorConverter()\n    const set = await conv.get(schema)\n    serializedDebug = getSerializedSchemaDebug(set)\n  }\n\n  const validation = schema._validation ?? []\n\n  const result: ValidateSchemaWorkerResult = {\n    serializedDebug,\n    validation: validation\n      .map((group) => ({\n        ...group,\n        problems: group.problems.filter((problem) =>\n          level === 'error' ? problem.severity === 'error' : true,\n        ),\n      }))\n      .filter((group) => group.problems.length),\n  }\n\n  return result\n}\n\nfunction getSerializedSchemaDebug(set: SetSynchronization<string>): SerializedSchemaDebug {\n  let size = 0\n  const types: Record<string, SerializedTypeDebug> = {}\n  const hoisted: Record<string, SerializedTypeDebug> = {}\n\n  for (const [id, value] of Object.entries(set.objectValues)) {\n    const descType = typeof value.type === 'string' ? value.type : '<unknown>'\n    switch (descType) {\n      case 'sanity.schema.hoisted': {\n        const key = typeof value.key === 'string' ? value.key : id\n        // The `hoisted` can technically  hoist _anything_,\n        // but we detect the common case of field + array element.\n        if (isEncodableObject(value.value) && isEncodableObject(value.value.typeDef)) {\n          const debug = getSerializedTypeDebug(value.value.typeDef)\n          hoisted[key] = debug\n          size += debug.size\n        }\n        break\n      }\n      case 'sanity.schema.namedType': {\n        const typeName = typeof value.name === 'string' ? value.name : id\n        if (isEncodableObject(value.typeDef)) {\n          const debug = getSerializedTypeDebug(value.typeDef)\n          types[typeName] = debug\n          size += debug.size\n        }\n        break\n      }\n      default:\n    }\n    size += JSON.stringify(value).length\n  }\n\n  return {\n    hoisted,\n    size,\n    types,\n  }\n}\n\nfunction isEncodableObject(val: EncodableValue | undefined): val is EncodableObject {\n  return typeof val === 'object' && val !== null && !Array.isArray(val)\n}\n\nfunction isSchemaError(err: unknown): err is {schema: Schema} {\n  return (\n    err !== null &&\n    typeof err === 'object' &&\n    'schema' in err &&\n    err.schema !== null &&\n    typeof err.schema === 'object' &&\n    '_validation' in err.schema\n  )\n}\n\nfunction getSerializedTypeDebug(typeDef: EncodableObject): SerializedTypeDebug {\n  const ext = typeof typeDef.extends === 'string' ? typeDef.extends : '<unknown>'\n  let fields: SerializedTypeDebug['fields']\n  let of: SerializedTypeDebug['of']\n\n  if (Array.isArray(typeDef.fields)) {\n    fields = {}\n\n    for (const field of typeDef.fields) {\n      if (!isEncodableObject(field)) continue\n      const name = field.name\n      const fieldTypeDef = field.typeDef\n      if (typeof name !== 'string' || !isEncodableObject(fieldTypeDef)) continue\n\n      fields[name] = getSerializedTypeDebug(fieldTypeDef)\n    }\n  }\n\n  if (Array.isArray(typeDef.of)) {\n    of = {}\n\n    for (const field of typeDef.of) {\n      if (!isEncodableObject(field)) continue\n      const name = field.name\n      const arrayTypeDef = field.typeDef\n      if (typeof name !== 'string' || !isEncodableObject(arrayTypeDef)) continue\n\n      of[name] = getSerializedTypeDebug(arrayTypeDef)\n    }\n  }\n\n  return {\n    extends: ext,\n    fields,\n    of,\n    size: JSON.stringify(typeDef).length,\n  }\n}\n\nawait main()\n\n// Explicitly exit the process to avoid any dangling references from keeping\n// the process alive after resolving it's main task\nsetImmediate(() => {\n  process.exit(1)\n})\n"],"names":["isMainThread","parentPort","workerData","findStudioConfigPath","getStudioWorkspaces","DescriptorConverter","getWorkspace","debugSerialize","level","workDir","workspace","workspaceName","main","Error","configPath","workspaces","schema","postMessage","resultFromSchema","err","isSchemaError","serializedDebug","conv","set","get","getSerializedSchemaDebug","validation","_validation","result","map","group","problems","filter","problem","severity","length","size","types","hoisted","id","value","Object","entries","objectValues","descType","type","key","isEncodableObject","typeDef","debug","getSerializedTypeDebug","typeName","name","JSON","stringify","val","Array","isArray","ext","extends","fields","of","field","fieldTypeDef","arrayTypeDef","setImmediate","process","exit"],"mappings":"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"}

package/dist/actions/telemetry/getLearnMoreMessage.js

@@ -0,0 +1,15 @@
+export function getLearnMoreMessage(status) {
+    const url = 'https://www.sanity.io/telemetry';
+    switch(status){
+        case 'granted':
+            {
+                return `Learn more about the data being collected here:\n${url}`;
+            }
+        default:
+            {
+                return `Learn more here:\n${url}`;
+            }
+    }
+}
+
+//# sourceMappingURL=getLearnMoreMessage.js.map

package/dist/actions/telemetry/getLearnMoreMessage.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/telemetry/getLearnMoreMessage.ts"],"sourcesContent":["import {type ConsentInformation} from '@sanity/cli-core'\n\nexport function getLearnMoreMessage(status: ConsentInformation['status']): string {\n  const url = 'https://www.sanity.io/telemetry'\n\n  switch (status) {\n    case 'granted': {\n      return `Learn more about the data being collected here:\\n${url}`\n    }\n    default: {\n      return `Learn more here:\\n${url}`\n    }\n  }\n}\n"],"names":["getLearnMoreMessage","status","url"],"mappings":"AAEA,OAAO,SAASA,oBAAoBC,MAAoC;IACtE,MAAMC,MAAM;IAEZ,OAAQD;QACN,KAAK;YAAW;gBACd,OAAO,CAAC,iDAAiD,EAAEC,KAAK;YAClE;QACA;YAAS;gBACP,OAAO,CAAC,kBAAkB,EAAEA,KAAK;YACnC;IACF;AACF"}