@sanity/cli 7.10.0 → 7.11.0

package/dist/actions/migration/resolveMigrationScript.js

@@ -0,0 +1,75 @@
+import path from 'node:path';
+import { importModule, subdebug } from '@sanity/cli-core';
+import { MIGRATION_SCRIPT_EXTENSIONS, MIGRATIONS_DIRECTORY } from './constants.js';
+import { fileExists } from './fileExists.js';
+const debug = subdebug('migration:resolveMigrationScript');
+/**
+ * Resolves the potential paths to a migration script.
+ * Considers the following paths (where `<ext>` is 'mjs', 'js', 'ts' or 'cjs'):
+ *
+ * - `<migrationsDir>/<migrationName>.<ext>`
+ * - `<migrationsDir>/<migrationName>/index.<ext>`
+ *
+ * Note that all possible paths are returned, even if the files do not exist.
+ * Check the `mod` property to see if a module could actually be loaded.
+ *
+ * @param workDir - Working directory of the studio
+ * @param migrationName - The name of the migration directory to resolve
+ * @returns An array of potential migration scripts
+ * @internal
+ */ export async function resolveMigrationScript(workDir, migrationName) {
+    const locations = [
+        migrationName,
+        path.join(migrationName, 'index')
+    ];
+    const results = [];
+    for (const location of locations){
+        for (const ext of MIGRATION_SCRIPT_EXTENSIONS){
+            const relativePath = path.join(MIGRATIONS_DIRECTORY, `${location}.${ext}`);
+            const absolutePath = path.resolve(workDir, relativePath);
+            let mod;
+            // Check if the file exists before trying to import it
+            const exists = await fileExists(absolutePath);
+            if (!exists) {
+                continue;
+            }
+            try {
+                debug(`importing migration from ${absolutePath}`);
+                const imported = await importModule(absolutePath, {
+                    default: false
+                });
+                // Handle both ESM and CJS default exports
+                mod = imported;
+            } catch (err) {
+                debug(`error importing migration from ${absolutePath}`, err);
+                // Ignore MODULE_NOT_FOUND errors, but throw others
+                if (err.code !== 'MODULE_NOT_FOUND' && err.code !== 'ERR_MODULE_NOT_FOUND') {
+                    throw new Error(`Error loading migration: ${err.message}`, {
+                        cause: err
+                    });
+                }
+            }
+            results.push({
+                absolutePath,
+                mod,
+                relativePath
+            });
+        }
+    }
+    return results;
+}
+/**
+ * Checks whether or not the passed resolved migration script is actually loadable (eg has a default export)
+ *
+ * @param script - The resolved migration script to check
+ * @returns `true` if the script is loadable, `false` otherwise
+ * @internal
+ */ export function isLoadableMigrationScript(script) {
+    if (script.mod === undefined || typeof script.mod.default !== 'object' || script.mod.default === null || Array.isArray(script.mod.default)) {
+        return false;
+    }
+    const mod = script.mod.default;
+    return typeof mod.title === 'string' && mod.migrate !== undefined;
+}
+
+//# sourceMappingURL=resolveMigrationScript.js.map

package/dist/actions/migration/resolveMigrationScript.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/migration/resolveMigrationScript.ts"],"sourcesContent":["import path from 'node:path'\n\nimport {importModule, subdebug} from '@sanity/cli-core'\nimport {type Migration} from '@sanity/migrate'\n\nimport {MIGRATION_SCRIPT_EXTENSIONS, MIGRATIONS_DIRECTORY} from './constants.js'\nimport {fileExists} from './fileExists.js'\n\ninterface ResolvedMigrationScript {\n  /**\n   * Absolute path to the migration script\n   */\n  absolutePath: string\n  /**\n   * Relative path from the working directory to the migration script\n   */\n  relativePath: string\n\n  /**\n   * The migration module, if it could be resolved - otherwise `undefined`\n   */\n  mod?: {default: Migration; down?: unknown; up?: unknown}\n}\n\nconst debug = subdebug('migration:resolveMigrationScript')\n\n/**\n * Resolves the potential paths to a migration script.\n * Considers the following paths (where `<ext>` is 'mjs', 'js', 'ts' or 'cjs'):\n *\n * - `<migrationsDir>/<migrationName>.<ext>`\n * - `<migrationsDir>/<migrationName>/index.<ext>`\n *\n * Note that all possible paths are returned, even if the files do not exist.\n * Check the `mod` property to see if a module could actually be loaded.\n *\n * @param workDir - Working directory of the studio\n * @param migrationName - The name of the migration directory to resolve\n * @returns An array of potential migration scripts\n * @internal\n */\nexport async function resolveMigrationScript(\n  workDir: string,\n  migrationName: string,\n): Promise<ResolvedMigrationScript[]> {\n  const locations = [migrationName, path.join(migrationName, 'index')]\n  const results: ResolvedMigrationScript[] = []\n\n  for (const location of locations) {\n    for (const ext of MIGRATION_SCRIPT_EXTENSIONS) {\n      const relativePath = path.join(MIGRATIONS_DIRECTORY, `${location}.${ext}`)\n      const absolutePath = path.resolve(workDir, relativePath)\n      let mod: {default: Migration; down?: unknown; up?: unknown} | undefined\n\n      // Check if the file exists before trying to import it\n      const exists = await fileExists(absolutePath)\n      if (!exists) {\n        continue\n      }\n\n      try {\n        debug(`importing migration from ${absolutePath}`)\n        const imported = await importModule<{default: Migration; down?: unknown; up?: unknown}>(\n          absolutePath,\n          {\n            default: false,\n          },\n        )\n        // Handle both ESM and CJS default exports\n        mod = imported\n      } catch (err) {\n        debug(`error importing migration from ${absolutePath}`, err)\n        // Ignore MODULE_NOT_FOUND errors, but throw others\n        if (\n          (err as NodeJS.ErrnoException).code !== 'MODULE_NOT_FOUND' &&\n          (err as NodeJS.ErrnoException).code !== 'ERR_MODULE_NOT_FOUND'\n        ) {\n          throw new Error(`Error loading migration: ${(err as Error).message}`, {cause: err})\n        }\n      }\n\n      results.push({absolutePath, mod, relativePath})\n    }\n  }\n\n  return results\n}\n\n/**\n * Checks whether or not the passed resolved migration script is actually loadable (eg has a default export)\n *\n * @param script - The resolved migration script to check\n * @returns `true` if the script is loadable, `false` otherwise\n * @internal\n */\nexport function isLoadableMigrationScript(\n  script: ResolvedMigrationScript,\n): script is Required<ResolvedMigrationScript> {\n  if (\n    script.mod === undefined ||\n    typeof script.mod.default !== 'object' ||\n    script.mod.default === null ||\n    Array.isArray(script.mod.default)\n  ) {\n    return false\n  }\n\n  const mod = script.mod.default\n  return typeof mod.title === 'string' && mod.migrate !== undefined\n}\n"],"names":["path","importModule","subdebug","MIGRATION_SCRIPT_EXTENSIONS","MIGRATIONS_DIRECTORY","fileExists","debug","resolveMigrationScript","workDir","migrationName","locations","join","results","location","ext","relativePath","absolutePath","resolve","mod","exists","imported","default","err","code","Error","message","cause","push","isLoadableMigrationScript","script","undefined","Array","isArray","title","migrate"],"mappings":"AAAA,OAAOA,UAAU,YAAW;AAE5B,SAAQC,YAAY,EAAEC,QAAQ,QAAO,mBAAkB;AAGvD,SAAQC,2BAA2B,EAAEC,oBAAoB,QAAO,iBAAgB;AAChF,SAAQC,UAAU,QAAO,kBAAiB;AAkB1C,MAAMC,QAAQJ,SAAS;AAEvB;;;;;;;;;;;;;;CAcC,GACD,OAAO,eAAeK,uBACpBC,OAAe,EACfC,aAAqB;IAErB,MAAMC,YAAY;QAACD;QAAeT,KAAKW,IAAI,CAACF,eAAe;KAAS;IACpE,MAAMG,UAAqC,EAAE;IAE7C,KAAK,MAAMC,YAAYH,UAAW;QAChC,KAAK,MAAMI,OAAOX,4BAA6B;YAC7C,MAAMY,eAAef,KAAKW,IAAI,CAACP,sBAAsB,GAAGS,SAAS,CAAC,EAAEC,KAAK;YACzE,MAAME,eAAehB,KAAKiB,OAAO,CAACT,SAASO;YAC3C,IAAIG;YAEJ,sDAAsD;YACtD,MAAMC,SAAS,MAAMd,WAAWW;YAChC,IAAI,CAACG,QAAQ;gBACX;YACF;YAEA,IAAI;gBACFb,MAAM,CAAC,yBAAyB,EAAEU,cAAc;gBAChD,MAAMI,WAAW,MAAMnB,aACrBe,cACA;oBACEK,SAAS;gBACX;gBAEF,0CAA0C;gBAC1CH,MAAME;YACR,EAAE,OAAOE,KAAK;gBACZhB,MAAM,CAAC,+BAA+B,EAAEU,cAAc,EAAEM;gBACxD,mDAAmD;gBACnD,IACE,AAACA,IAA8BC,IAAI,KAAK,sBACxC,AAACD,IAA8BC,IAAI,KAAK,wBACxC;oBACA,MAAM,IAAIC,MAAM,CAAC,yBAAyB,EAAE,AAACF,IAAcG,OAAO,EAAE,EAAE;wBAACC,OAAOJ;oBAAG;gBACnF;YACF;YAEAV,QAAQe,IAAI,CAAC;gBAACX;gBAAcE;gBAAKH;YAAY;QAC/C;IACF;IAEA,OAAOH;AACT;AAEA;;;;;;CAMC,GACD,OAAO,SAASgB,0BACdC,MAA+B;IAE/B,IACEA,OAAOX,GAAG,KAAKY,aACf,OAAOD,OAAOX,GAAG,CAACG,OAAO,KAAK,YAC9BQ,OAAOX,GAAG,CAACG,OAAO,KAAK,QACvBU,MAAMC,OAAO,CAACH,OAAOX,GAAG,CAACG,OAAO,GAChC;QACA,OAAO;IACT;IAEA,MAAMH,MAAMW,OAAOX,GAAG,CAACG,OAAO;IAC9B,OAAO,OAAOH,IAAIe,KAAK,KAAK,YAAYf,IAAIgB,OAAO,KAAKJ;AAC1D"}

package/dist/actions/migration/resolveMigrations.js

@@ -0,0 +1,50 @@
+import { readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { MIGRATION_SCRIPT_EXTENSIONS, MIGRATIONS_DIRECTORY } from './constants.js';
+import { isLoadableMigrationScript, resolveMigrationScript } from './resolveMigrationScript.js';
+/**
+ * Removes migration script extensions from a filename
+ *
+ * @param fileName - The filename to process
+ * @returns The filename without the extension
+ * @internal
+ */ function removeMigrationScriptExtension(fileName) {
+    // Remove `.ts`, `.js` etc from the end of a filename
+    const ext = MIGRATION_SCRIPT_EXTENSIONS.find((e)=>fileName.endsWith(`.${e}`));
+    return ext ? path.basename(fileName, `.${ext}`) : fileName;
+}
+/**
+ * Resolves all migrations in the studio working directory
+ *
+ * @param workDir - The studio working directory
+ * @returns Array of migrations and their respective paths
+ * @internal
+ */ export async function resolveMigrations(workDir) {
+    const migrationsDir = path.join(workDir, MIGRATIONS_DIRECTORY);
+    const migrationEntries = await readdir(migrationsDir, {
+        withFileTypes: true
+    });
+    const migrations = [];
+    const seen = new Set();
+    for (const entry of migrationEntries){
+        const entryName = entry.isDirectory() ? entry.name : removeMigrationScriptExtension(entry.name);
+        // A file (e.g. `foo.ts`) and a directory (e.g. `foo/`) can both map to the
+        // same id; only resolve each id once.
+        if (seen.has(entryName)) {
+            continue;
+        }
+        // `resolveMigrationScript` may return several loadable candidates for a
+        // single id (e.g. both `foo.ts` and `foo/index.ts`). List it just once.
+        const candidate = (await resolveMigrationScript(workDir, entryName)).find((script)=>isLoadableMigrationScript(script));
+        if (candidate) {
+            seen.add(entryName);
+            migrations.push({
+                id: entryName,
+                migration: candidate.mod.default
+            });
+        }
+    }
+    return migrations;
+}
+
+//# sourceMappingURL=resolveMigrations.js.map

package/dist/actions/migration/resolveMigrations.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/migration/resolveMigrations.ts"],"sourcesContent":["import {readdir} from 'node:fs/promises'\nimport path from 'node:path'\n\nimport {type Migration} from '@sanity/migrate'\n\nimport {MIGRATION_SCRIPT_EXTENSIONS, MIGRATIONS_DIRECTORY} from './constants.js'\nimport {isLoadableMigrationScript, resolveMigrationScript} from './resolveMigrationScript.js'\n\n/**\n * A resolved migration, where you are guaranteed that the migration file exists\n *\n * @internal\n */\ninterface ResolvedMigration {\n  id: string\n  migration: Migration\n}\n\n/**\n * Removes migration script extensions from a filename\n *\n * @param fileName - The filename to process\n * @returns The filename without the extension\n * @internal\n */\nfunction removeMigrationScriptExtension(fileName: string): string {\n  // Remove `.ts`, `.js` etc from the end of a filename\n  const ext = MIGRATION_SCRIPT_EXTENSIONS.find((e) => fileName.endsWith(`.${e}`))\n  return ext ? path.basename(fileName, `.${ext}`) : fileName\n}\n\n/**\n * Resolves all migrations in the studio working directory\n *\n * @param workDir - The studio working directory\n * @returns Array of migrations and their respective paths\n * @internal\n */\nexport async function resolveMigrations(workDir: string): Promise<ResolvedMigration[]> {\n  const migrationsDir = path.join(workDir, MIGRATIONS_DIRECTORY)\n  const migrationEntries = await readdir(migrationsDir, {withFileTypes: true})\n\n  const migrations: ResolvedMigration[] = []\n  const seen = new Set<string>()\n  for (const entry of migrationEntries) {\n    const entryName = entry.isDirectory() ? entry.name : removeMigrationScriptExtension(entry.name)\n    // A file (e.g. `foo.ts`) and a directory (e.g. `foo/`) can both map to the\n    // same id; only resolve each id once.\n    if (seen.has(entryName)) {\n      continue\n    }\n\n    // `resolveMigrationScript` may return several loadable candidates for a\n    // single id (e.g. both `foo.ts` and `foo/index.ts`). List it just once.\n    const candidate = (await resolveMigrationScript(workDir, entryName)).find((script) =>\n      isLoadableMigrationScript(script),\n    )\n    if (candidate) {\n      seen.add(entryName)\n      migrations.push({id: entryName, migration: candidate.mod.default})\n    }\n  }\n\n  return migrations\n}\n"],"names":["readdir","path","MIGRATION_SCRIPT_EXTENSIONS","MIGRATIONS_DIRECTORY","isLoadableMigrationScript","resolveMigrationScript","removeMigrationScriptExtension","fileName","ext","find","e","endsWith","basename","resolveMigrations","workDir","migrationsDir","join","migrationEntries","withFileTypes","migrations","seen","Set","entry","entryName","isDirectory","name","has","candidate","script","add","push","id","migration","mod","default"],"mappings":"AAAA,SAAQA,OAAO,QAAO,mBAAkB;AACxC,OAAOC,UAAU,YAAW;AAI5B,SAAQC,2BAA2B,EAAEC,oBAAoB,QAAO,iBAAgB;AAChF,SAAQC,yBAAyB,EAAEC,sBAAsB,QAAO,8BAA6B;AAY7F;;;;;;CAMC,GACD,SAASC,+BAA+BC,QAAgB;IACtD,qDAAqD;IACrD,MAAMC,MAAMN,4BAA4BO,IAAI,CAAC,CAACC,IAAMH,SAASI,QAAQ,CAAC,CAAC,CAAC,EAAED,GAAG;IAC7E,OAAOF,MAAMP,KAAKW,QAAQ,CAACL,UAAU,CAAC,CAAC,EAAEC,KAAK,IAAID;AACpD;AAEA;;;;;;CAMC,GACD,OAAO,eAAeM,kBAAkBC,OAAe;IACrD,MAAMC,gBAAgBd,KAAKe,IAAI,CAACF,SAASX;IACzC,MAAMc,mBAAmB,MAAMjB,QAAQe,eAAe;QAACG,eAAe;IAAI;IAE1E,MAAMC,aAAkC,EAAE;IAC1C,MAAMC,OAAO,IAAIC;IACjB,KAAK,MAAMC,SAASL,iBAAkB;QACpC,MAAMM,YAAYD,MAAME,WAAW,KAAKF,MAAMG,IAAI,GAAGnB,+BAA+BgB,MAAMG,IAAI;QAC9F,2EAA2E;QAC3E,sCAAsC;QACtC,IAAIL,KAAKM,GAAG,CAACH,YAAY;YACvB;QACF;QAEA,wEAAwE;QACxE,wEAAwE;QACxE,MAAMI,YAAY,AAAC,CAAA,MAAMtB,uBAAuBS,SAASS,UAAS,EAAGd,IAAI,CAAC,CAACmB,SACzExB,0BAA0BwB;QAE5B,IAAID,WAAW;YACbP,KAAKS,GAAG,CAACN;YACTJ,WAAWW,IAAI,CAAC;gBAACC,IAAIR;gBAAWS,WAAWL,UAAUM,GAAG,CAACC,OAAO;YAAA;QAClE;IACF;IAEA,OAAOf;AACT"}

package/dist/actions/migration/templates/index.js

@@ -0,0 +1,7 @@
+export { minimalAdvanced } from './minimalAdvanced.js';
+export { minimalSimple } from './minimalSimple.js';
+export { renameField } from './renameField.js';
+export { renameType } from './renameType.js';
+export { stringToPTE } from './stringToPTE.js';
+
+//# sourceMappingURL=index.js.map

package/dist/actions/migration/templates/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/migration/templates/index.ts"],"sourcesContent":["export {minimalAdvanced} from './minimalAdvanced.js'\nexport {minimalSimple} from './minimalSimple.js'\nexport {renameField} from './renameField.js'\nexport {renameType} from './renameType.js'\nexport {stringToPTE} from './stringToPTE.js'\n"],"names":["minimalAdvanced","minimalSimple","renameField","renameType","stringToPTE"],"mappings":"AAAA,SAAQA,eAAe,QAAO,uBAAsB;AACpD,SAAQC,aAAa,QAAO,qBAAoB;AAChD,SAAQC,WAAW,QAAO,mBAAkB;AAC5C,SAAQC,UAAU,QAAO,kBAAiB;AAC1C,SAAQC,WAAW,QAAO,mBAAkB"}

package/dist/actions/migration/templates/minimalAdvanced.js

@@ -0,0 +1,21 @@
+export const minimalAdvanced = ({ documentTypes, migrationName })=>`import {defineMigration, patch, at, setIfMissing} from 'sanity/migrate'
+
+/**
+ * this migration will set \`Default title\` on all documents that are missing a title
+ * and make \`true\` the default value for the \`enabled\` field
+ */
+export default defineMigration({
+  title: ${JSON.stringify(migrationName)},
+${documentTypes.length > 0 ? `  documentTypes: [${documentTypes.map((t)=>JSON.stringify(t)).join(', ')}],\n` : ''}
+  async *migrate(documents, context) {
+    for await (const document of documents()) {
+      yield patch(document._id, [
+        at('title', setIfMissing('Default title')),
+        at('enabled', setIfMissing(true)),
+      ])
+    }
+  }
+})
+`;
+
+//# sourceMappingURL=minimalAdvanced.js.map

package/dist/actions/migration/templates/minimalAdvanced.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/migration/templates/minimalAdvanced.ts"],"sourcesContent":["export const minimalAdvanced = ({\n  documentTypes,\n  migrationName,\n}: {\n  documentTypes: string[]\n  migrationName: string\n}) => `import {defineMigration, patch, at, setIfMissing} from 'sanity/migrate'\n\n/**\n * this migration will set \\`Default title\\` on all documents that are missing a title\n * and make \\`true\\` the default value for the \\`enabled\\` field\n */\nexport default defineMigration({\n  title: ${JSON.stringify(migrationName)},\n${\n  documentTypes.length > 0\n    ? `  documentTypes: [${documentTypes.map((t) => JSON.stringify(t)).join(', ')}],\\n`\n    : ''\n}\n  async *migrate(documents, context) {\n    for await (const document of documents()) {\n      yield patch(document._id, [\n        at('title', setIfMissing('Default title')),\n        at('enabled', setIfMissing(true)),\n      ])\n    }\n  }\n})\n`\n"],"names":["minimalAdvanced","documentTypes","migrationName","JSON","stringify","length","map","t","join"],"mappings":"AAAA,OAAO,MAAMA,kBAAkB,CAAC,EAC9BC,aAAa,EACbC,aAAa,EAId,GAAK,CAAC;;;;;;;SAOE,EAAEC,KAAKC,SAAS,CAACF,eAAe;AACzC,EACED,cAAcI,MAAM,GAAG,IACnB,CAAC,kBAAkB,EAAEJ,cAAcK,GAAG,CAAC,CAACC,IAAMJ,KAAKC,SAAS,CAACG,IAAIC,IAAI,CAAC,MAAM,IAAI,CAAC,GACjF,GACL;;;;;;;;;;AAUD,CAAC,CAAA"}

package/dist/actions/migration/templates/minimalSimple.js

@@ -0,0 +1,61 @@
+export const minimalSimple = ({ documentTypes, migrationName })=>`import {at, defineMigration, setIfMissing, unset} from 'sanity/migrate'
+
+export default defineMigration({
+  title: ${JSON.stringify(migrationName)},
+${documentTypes.length > 0 ? `  documentTypes: [${documentTypes.map((t)=>JSON.stringify(t)).join(', ')}],\n` : ''}
+  migrate: {
+    document(doc, context) {
+      // this will be called for every document of the matching type
+      // any patch returned will be applied to the document
+      // you can also return mutations that touches other documents
+
+      return at('title', setIfMissing('Default title'))
+    },
+    node(node, path, context) {
+      // this will be called for every node in every document of the matching type
+      // any patch returned will be applied to the document
+      // you can also return mutations that touches other documents
+
+      if (typeof node === 'string' && node === 'deleteme') {
+        return unset()
+      }
+    },
+    object(node, path, context) {
+      // this will be called for every object node in every document of the matching type
+      // any patch returned will be applied to the document
+      // you can also return mutations that touches other documents
+      if (node._type === 'author') {
+        // make sure all authors objects have a books array
+        return at('books', setIfMissing([]))
+      }
+    },
+    array(node, path, context) {
+      // this will be called for every array node in every document of the matching type
+      // any patch returned will be applied to the document
+      // you can also return mutations that touches other documents
+    },
+    string(node, path, context) {
+      // this will be called for every string node in every document of the matching type
+      // any patch returned will be applied to the document
+      // you can also return mutations that touches other documents
+    },
+    number(node, path, context) {
+      // this will be called for every number node in every document of the matching type
+      // any patch returned will be applied to the document
+      // you can also return mutations that touches other documents
+    },
+    boolean(node, path, context) {
+      // this will be called for every boolean node in every document of the matching type
+      // any patch returned will be applied to the document
+      // you can also return mutations that touches other documents
+    },
+    null(node, path, context) {
+      // this will be called for every null node in every document of the matching type
+      // any patch returned will be applied to the document
+      // you can also return mutations that touches other documents
+    },
+  },
+})
+`;
+
+//# sourceMappingURL=minimalSimple.js.map

package/dist/actions/migration/templates/minimalSimple.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/migration/templates/minimalSimple.ts"],"sourcesContent":["export const minimalSimple = ({\n  documentTypes,\n  migrationName,\n}: {\n  documentTypes: string[]\n  migrationName: string\n}) => `import {at, defineMigration, setIfMissing, unset} from 'sanity/migrate'\n\nexport default defineMigration({\n  title: ${JSON.stringify(migrationName)},\n${\n  documentTypes.length > 0\n    ? `  documentTypes: [${documentTypes.map((t) => JSON.stringify(t)).join(', ')}],\\n`\n    : ''\n}\n  migrate: {\n    document(doc, context) {\n      // this will be called for every document of the matching type\n      // any patch returned will be applied to the document\n      // you can also return mutations that touches other documents\n\n      return at('title', setIfMissing('Default title'))\n    },\n    node(node, path, context) {\n      // this will be called for every node in every document of the matching type\n      // any patch returned will be applied to the document\n      // you can also return mutations that touches other documents\n\n      if (typeof node === 'string' && node === 'deleteme') {\n        return unset()\n      }\n    },\n    object(node, path, context) {\n      // this will be called for every object node in every document of the matching type\n      // any patch returned will be applied to the document\n      // you can also return mutations that touches other documents\n      if (node._type === 'author') {\n        // make sure all authors objects have a books array\n        return at('books', setIfMissing([]))\n      }\n    },\n    array(node, path, context) {\n      // this will be called for every array node in every document of the matching type\n      // any patch returned will be applied to the document\n      // you can also return mutations that touches other documents\n    },\n    string(node, path, context) {\n      // this will be called for every string node in every document of the matching type\n      // any patch returned will be applied to the document\n      // you can also return mutations that touches other documents\n    },\n    number(node, path, context) {\n      // this will be called for every number node in every document of the matching type\n      // any patch returned will be applied to the document\n      // you can also return mutations that touches other documents\n    },\n    boolean(node, path, context) {\n      // this will be called for every boolean node in every document of the matching type\n      // any patch returned will be applied to the document\n      // you can also return mutations that touches other documents\n    },\n    null(node, path, context) {\n      // this will be called for every null node in every document of the matching type\n      // any patch returned will be applied to the document\n      // you can also return mutations that touches other documents\n    },\n  },\n})\n`\n"],"names":["minimalSimple","documentTypes","migrationName","JSON","stringify","length","map","t","join"],"mappings":"AAAA,OAAO,MAAMA,gBAAgB,CAAC,EAC5BC,aAAa,EACbC,aAAa,EAId,GAAK,CAAC;;;SAGE,EAAEC,KAAKC,SAAS,CAACF,eAAe;AACzC,EACED,cAAcI,MAAM,GAAG,IACnB,CAAC,kBAAkB,EAAEJ,cAAcK,GAAG,CAAC,CAACC,IAAMJ,KAAKC,SAAS,CAACG,IAAIC,IAAI,CAAC,MAAM,IAAI,CAAC,GACjF,GACL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDD,CAAC,CAAA"}

package/dist/actions/migration/templates/renameField.js

@@ -0,0 +1,20 @@
+export const renameField = ({ documentTypes, migrationName })=>`import {defineMigration, at, setIfMissing, unset} from 'sanity/migrate'
+
+const from = 'oldFieldName'
+const to = 'newFieldName'
+
+export default defineMigration({
+  title: ${JSON.stringify(migrationName)},
+${documentTypes.length > 0 ? `  documentTypes: [${documentTypes.map((t)=>JSON.stringify(t)).join(', ')}],\n` : ''}
+  migrate: {
+    document(doc, context) {
+      return [
+        at(to, setIfMissing(doc[from])),
+        at(from, unset())
+      ]
+    }
+  }
+})
+`;
+
+//# sourceMappingURL=renameField.js.map

package/dist/actions/migration/templates/renameField.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/migration/templates/renameField.ts"],"sourcesContent":["export const renameField = ({\n  documentTypes,\n  migrationName,\n}: {\n  documentTypes: string[]\n  migrationName: string\n}) => `import {defineMigration, at, setIfMissing, unset} from 'sanity/migrate'\n\nconst from = 'oldFieldName'\nconst to = 'newFieldName'\n\nexport default defineMigration({\n  title: ${JSON.stringify(migrationName)},\n${\n  documentTypes.length > 0\n    ? `  documentTypes: [${documentTypes.map((t) => JSON.stringify(t)).join(', ')}],\\n`\n    : ''\n}\n  migrate: {\n    document(doc, context) {\n      return [\n        at(to, setIfMissing(doc[from])),\n        at(from, unset())\n      ]\n    }\n  }\n})\n`\n"],"names":["renameField","documentTypes","migrationName","JSON","stringify","length","map","t","join"],"mappings":"AAAA,OAAO,MAAMA,cAAc,CAAC,EAC1BC,aAAa,EACbC,aAAa,EAId,GAAK,CAAC;;;;;;SAME,EAAEC,KAAKC,SAAS,CAACF,eAAe;AACzC,EACED,cAAcI,MAAM,GAAG,IACnB,CAAC,kBAAkB,EAAEJ,cAAcK,GAAG,CAAC,CAACC,IAAMJ,KAAKC,SAAS,CAACG,IAAIC,IAAI,CAAC,MAAM,IAAI,CAAC,GACjF,GACL;;;;;;;;;;AAUD,CAAC,CAAA"}

package/dist/actions/migration/templates/renameType.js

@@ -0,0 +1,19 @@
+export const renameType = ({ documentTypes, migrationName })=>`import {defineMigration, at, set} from 'sanity/migrate'
+
+const oldType = 'old'
+const newType = 'new'
+
+export default defineMigration({
+  title: ${JSON.stringify(migrationName)},
+${documentTypes.length > 0 ? `  documentTypes: [${documentTypes.map((t)=>JSON.stringify(t)).join(', ')}],\n` : ''}
+  migrate: {
+    object(object, path, context) {
+      if (object._type === oldType) {
+        return at('_type', set(newType))
+      }
+    }
+  }
+})
+`;
+
+//# sourceMappingURL=renameType.js.map

package/dist/actions/migration/templates/renameType.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/migration/templates/renameType.ts"],"sourcesContent":["export const renameType = ({\n  documentTypes,\n  migrationName,\n}: {\n  documentTypes: string[]\n  migrationName: string\n}) => `import {defineMigration, at, set} from 'sanity/migrate'\n\nconst oldType = 'old'\nconst newType = 'new'\n\nexport default defineMigration({\n  title: ${JSON.stringify(migrationName)},\n${\n  documentTypes.length > 0\n    ? `  documentTypes: [${documentTypes.map((t) => JSON.stringify(t)).join(', ')}],\\n`\n    : ''\n}\n  migrate: {\n    object(object, path, context) {\n      if (object._type === oldType) {\n        return at('_type', set(newType))\n      }\n    }\n  }\n})\n`\n"],"names":["renameType","documentTypes","migrationName","JSON","stringify","length","map","t","join"],"mappings":"AAAA,OAAO,MAAMA,aAAa,CAAC,EACzBC,aAAa,EACbC,aAAa,EAId,GAAK,CAAC;;;;;;SAME,EAAEC,KAAKC,SAAS,CAACF,eAAe;AACzC,EACED,cAAcI,MAAM,GAAG,IACnB,CAAC,kBAAkB,EAAEJ,cAAcK,GAAG,CAAC,CAACC,IAAMJ,KAAKC,SAAS,CAACG,IAAIC,IAAI,CAAC,MAAM,IAAI,CAAC,GACjF,GACL;;;;;;;;;AASD,CAAC,CAAA"}

package/dist/actions/migration/templates/stringToPTE.js

@@ -0,0 +1,32 @@
+export const stringToPTE = ({ documentTypes, migrationName })=>`import {pathsAreEqual, stringToPath} from 'sanity'
+import {defineMigration, set} from 'sanity/migrate'
+
+const targetPath = stringToPath('some.path')
+
+export default defineMigration({
+  title: ${JSON.stringify(migrationName)},
+${documentTypes.length > 0 ? `  documentTypes: [${documentTypes.map((t)=>JSON.stringify(t)).join(', ')}],\n` : ''}
+  migrate: {
+    string(node, path, ctx) {
+      if (pathsAreEqual(path, targetPath)) {
+        return set([
+          {
+            style: 'normal',
+            _type: 'block',
+            children: [
+              {
+                _type: 'span',
+                marks: [],
+                text: node,
+              },
+            ],
+            markDefs: [],
+          },
+        ])
+      }
+    },
+  },
+})
+`;
+
+//# sourceMappingURL=stringToPTE.js.map

package/dist/actions/migration/templates/stringToPTE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/actions/migration/templates/stringToPTE.ts"],"sourcesContent":["export const stringToPTE = ({\n  documentTypes,\n  migrationName,\n}: {\n  documentTypes: string[]\n  migrationName: string\n}) => `import {pathsAreEqual, stringToPath} from 'sanity'\nimport {defineMigration, set} from 'sanity/migrate'\n\nconst targetPath = stringToPath('some.path')\n\nexport default defineMigration({\n  title: ${JSON.stringify(migrationName)},\n${\n  documentTypes.length > 0\n    ? `  documentTypes: [${documentTypes.map((t) => JSON.stringify(t)).join(', ')}],\\n`\n    : ''\n}\n  migrate: {\n    string(node, path, ctx) {\n      if (pathsAreEqual(path, targetPath)) {\n        return set([\n          {\n            style: 'normal',\n            _type: 'block',\n            children: [\n              {\n                _type: 'span',\n                marks: [],\n                text: node,\n              },\n            ],\n            markDefs: [],\n          },\n        ])\n      }\n    },\n  },\n})\n`\n"],"names":["stringToPTE","documentTypes","migrationName","JSON","stringify","length","map","t","join"],"mappings":"AAAA,OAAO,MAAMA,cAAc,CAAC,EAC1BC,aAAa,EACbC,aAAa,EAId,GAAK,CAAC;;;;;;SAME,EAAEC,KAAKC,SAAS,CAACF,eAAe;AACzC,EACED,cAAcI,MAAM,GAAG,IACnB,CAAC,kBAAkB,EAAEJ,cAAcK,GAAG,CAAC,CAACC,IAAMJ,KAAKC,SAAS,CAACG,IAAIC,IAAI,CAAC,MAAM,IAAI,CAAC,GACjF,GACL;;;;;;;;;;;;;;;;;;;;;;AAsBD,CAAC,CAAA"}

package/dist/actions/migration/tree.js

@@ -0,0 +1,111 @@
+import { isIndexSegment, isIndexTuple, isKeySegment } from '@sanity/types';
+// copy/paste of `pathToString` from 'sanity' to prevent circular imports
+function pathToString(path) {
+    if (!Array.isArray(path)) {
+        throw new TypeError('Path is not an array');
+    }
+    let target = '';
+    let i = 0;
+    for (const segment of path){
+        if (isIndexSegment(segment)) {
+            target = `${target}[${segment}]`;
+        } else if (isKeySegment(segment) && segment._key) {
+            target = `${target}[_key=="${segment._key}"]`;
+        } else if (isIndexTuple(segment)) {
+            const [from, to] = segment;
+            target = `${target}[${from}:${to}]`;
+        } else if (typeof segment === 'string') {
+            const separator = i === 0 ? '' : '.';
+            target = `${target}${separator}${segment}`;
+        } else {
+            throw new TypeError(`Unsupported path segment \`${JSON.stringify(segment)}\``);
+        }
+        i++;
+    }
+    return target;
+}
+/**
+ * Recursively calculates the max length of all the keys in the given validation
+ * tree respecting extra length due to indentation depth. Used to calculate the
+ * padding for the rest of the tree.
+ */ export const maxKeyLength = (children = {}, depth = 0)=>{
+    let max = 0;
+    for (const [key, child] of Object.entries(children)){
+        const currentMax = Math.max(key.length + depth * 2, maxKeyLength(child.children, depth + 1));
+        max = Math.max(max, currentMax);
+    }
+    return max;
+};
+/**
+ * Recursively formats a given tree into a printed user-friendly tree structure
+ */ export const formatTree = ({ getMessage, getNodes: getLeaves = ({ nodes })=>nodes, indent = '', node = {}, paddingLength })=>{
+    const entries = Object.entries(node);
+    return entries.map(([key, child], index)=>{
+        const isLast = index === entries.length - 1;
+        const nextIndent = `${indent}${isLast ? '  ' : '│ '}`;
+        const leaves = getLeaves(child);
+        const nested = formatTree({
+            getMessage,
+            getNodes: getLeaves,
+            indent: nextIndent,
+            node: child.children,
+            paddingLength
+        });
+        if (!leaves?.length) {
+            const current = `${indent}${isLast ? '└' : '├'}─ ${key}`;
+            return [
+                current,
+                nested
+            ].filter(Boolean).join('\n');
+        }
+        const first = leaves[0];
+        const rest = leaves.slice(1);
+        if (!first) return '';
+        const firstPadding = '.'.repeat(paddingLength - indent.length - key.length);
+        const elbow = isLast ? '└' : '├';
+        const subsequentPadding = ' '.repeat(paddingLength - indent.length + 2);
+        const firstMessage = `${indent}${elbow}─ ${key} ${firstPadding} ${getMessage(first)}`;
+        const subsequentMessages = rest.map((marker)=>`${nextIndent}${subsequentPadding} ${getMessage(marker)}`).join('\n');
+        const current = [
+            firstMessage,
+            subsequentMessages
+        ].filter(Boolean).join('\n');
+        return [
+            current,
+            nested
+        ].filter(Boolean).join('\n');
+    }).join('\n');
+};
+/**
+ * Converts a set of markers with paths into a tree of markers where the paths
+ * are embedded in the tree
+ */ export function convertToTree(nodes) {
+    const root = {};
+    // add the markers to the tree
+    function addNode(node, tree = root) {
+        // if we've traversed the whole path
+        if (node.path.length === 0) {
+            if (!tree.nodes) tree.nodes = []; // ensure markers is defined
+            // then add the marker to the front
+            tree.nodes.push(node);
+            return;
+        }
+        const current = node.path[0];
+        const rest = node.path.slice(1);
+        if (!current) return;
+        const key = pathToString([
+            current
+        ]);
+        // ensure the current node has children and the next node
+        if (!tree.children) tree.children = {};
+        if (!(key in tree.children)) tree.children[key] = {};
+        addNode({
+            ...node,
+            path: rest
+        }, tree.children[key]);
+    }
+    for (const node of nodes)addNode(node);
+    return root;
+}
+
+//# sourceMappingURL=tree.js.map

package/dist/actions/migration/tree.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/actions/migration/tree.ts"],"sourcesContent":["import {isIndexSegment, isIndexTuple, isKeySegment, type Path} from '@sanity/types'\n\n// copy/paste of `pathToString` from 'sanity' to prevent circular imports\nfunction pathToString(path: Path): string {\n  if (!Array.isArray(path)) {\n    throw new TypeError('Path is not an array')\n  }\n\n  let target = ''\n  let i = 0\n  for (const segment of path) {\n    if (isIndexSegment(segment)) {\n      target = `${target}[${segment}]`\n    } else if (isKeySegment(segment) && segment._key) {\n      target = `${target}[_key==\"${segment._key}\"]`\n    } else if (isIndexTuple(segment)) {\n      const [from, to] = segment\n      target = `${target}[${from}:${to}]`\n    } else if (typeof segment === 'string') {\n      const separator = i === 0 ? '' : '.'\n      target = `${target}${separator}${segment}`\n    } else {\n      throw new TypeError(`Unsupported path segment \\`${JSON.stringify(segment)}\\``)\n    }\n    i++\n  }\n  return target\n}\n\ninterface BaseNode {\n  path: Path\n}\n\ninterface Tree<Node extends BaseNode> {\n  children?: Record<string, Tree<Node>>\n  nodes?: Node[]\n}\n\n/**\n * Recursively calculates the max length of all the keys in the given validation\n * tree respecting extra length due to indentation depth. Used to calculate the\n * padding for the rest of the tree.\n */\nexport const maxKeyLength = (children: Record<string, Tree<BaseNode>> = {}, depth = 0): number => {\n  let max = 0\n  for (const [key, child] of Object.entries(children)) {\n    const currentMax = Math.max(key.length + depth * 2, maxKeyLength(child.children, depth + 1))\n    max = Math.max(max, currentMax)\n  }\n  return max\n}\n\ninterface Options<Node extends BaseNode> {\n  getMessage: (node: Node) => string\n  paddingLength: number\n\n  getNodes?: (node: Tree<Node>) => Node[] | undefined\n  indent?: string\n  node?: Record<string, Tree<Node>>\n}\n\n/**\n * Recursively formats a given tree into a printed user-friendly tree structure\n */\nexport const formatTree = <Node extends BaseNode>({\n  getMessage,\n  getNodes: getLeaves = ({nodes}) => nodes,\n  indent = '',\n  node = {},\n  paddingLength,\n}: Options<Node>): string => {\n  const entries = Object.entries(node)\n\n  return entries\n    .map(([key, child], index) => {\n      const isLast = index === entries.length - 1\n      const nextIndent = `${indent}${isLast ? '  ' : '│ '}`\n      const leaves = getLeaves(child)\n\n      const nested = formatTree({\n        getMessage,\n        getNodes: getLeaves,\n        indent: nextIndent,\n        node: child.children,\n        paddingLength,\n      })\n\n      if (!leaves?.length) {\n        const current = `${indent}${isLast ? '└' : '├'}─ ${key}`\n        return [current, nested].filter(Boolean).join('\\n')\n      }\n\n      const first = leaves[0]\n      const rest = leaves.slice(1)\n      if (!first) return ''\n      const firstPadding = '.'.repeat(paddingLength - indent.length - key.length)\n      const elbow = isLast ? '└' : '├'\n      const subsequentPadding = ' '.repeat(paddingLength - indent.length + 2)\n\n      const firstMessage = `${indent}${elbow}─ ${key} ${firstPadding} ${getMessage(first)}`\n      const subsequentMessages = rest\n        .map((marker) => `${nextIndent}${subsequentPadding} ${getMessage(marker)}`)\n        .join('\\n')\n\n      const current = [firstMessage, subsequentMessages].filter(Boolean).join('\\n')\n      return [current, nested].filter(Boolean).join('\\n')\n    })\n    .join('\\n')\n}\n\n/**\n * Converts a set of markers with paths into a tree of markers where the paths\n * are embedded in the tree\n */\nexport function convertToTree<const Node extends BaseNode>(nodes: Node[]): Tree<Node> {\n  const root: Tree<Node> = {}\n\n  // add the markers to the tree\n  function addNode(node: Node, tree: Tree<Node> = root) {\n    // if we've traversed the whole path\n    if (node.path.length === 0) {\n      if (!tree.nodes) tree.nodes = [] // ensure markers is defined\n\n      // then add the marker to the front\n      tree.nodes.push(node)\n      return\n    }\n\n    const current = node.path[0]\n    const rest = node.path.slice(1)\n    if (!current) return\n    const key = pathToString([current])\n\n    // ensure the current node has children and the next node\n    if (!tree.children) tree.children = {}\n    if (!(key in tree.children)) tree.children[key] = {}\n\n    addNode({...node, path: rest}, tree.children[key])\n  }\n\n  for (const node of nodes) addNode(node)\n  return root\n}\n"],"names":["isIndexSegment","isIndexTuple","isKeySegment","pathToString","path","Array","isArray","TypeError","target","i","segment","_key","from","to","separator","JSON","stringify","maxKeyLength","children","depth","max","key","child","Object","entries","currentMax","Math","length","formatTree","getMessage","getNodes","getLeaves","nodes","indent","node","paddingLength","map","index","isLast","nextIndent","leaves","nested","current","filter","Boolean","join","first","rest","slice","firstPadding","repeat","elbow","subsequentPadding","firstMessage","subsequentMessages","marker","convertToTree","root","addNode","tree","push"],"mappings":"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"}

package/dist/actions/preview/previewAction.js

@@ -1,14 +1,46 @@
+import { SANITY_CACHE_DIR } from '@sanity/cli-build/_internal/build';
+import { isWorkbenchApp } from '@sanity/workbench-cli';
 import { gracefulServerDeath } from '../../server/gracefulServerDeath.js';
 import { startPreviewServer } from '../../server/previewServer.js';
+import { checkForDeprecatedAppId } from '../../util/appId.js';
+import { determineIsApp } from '../../util/determineIsApp.js';
+import { resolveReactStrictMode } from '../../util/resolveReactStrictMode.js';
+import { extractCoreAppManifest } from '../manifest/extractCoreAppManifest.js';
+import { extractStudioManifest } from '../manifest/extractStudioManifest.js';
 import { getPreviewServerConfig } from './getPreviewServerConfig.js';
 export async function previewAction(options) {
-    const { cliConfig, flags, outDir, workDir } = options;
+    const { cliConfig, flags, outDir, output, workDir } = options;
     const config = getPreviewServerConfig({
         cliConfig,
         flags,
         rootDir: outDir,
         workDir
     });
+    if (isWorkbenchApp(cliConfig?.app)) {
+        const isApp = determineIsApp(cliConfig);
+        // Lazy so a non-workbench `sanity start` never loads the package. `doImport`
+        // is path-based and doesn't apply to a bare specifier.
+        // eslint-disable-next-line no-restricted-syntax
+        const { startWorkbenchPreview } = await import('@sanity/workbench-cli/preview');
+        return startWorkbenchPreview({
+            cacheDir: `${SANITY_CACHE_DIR}/vite`,
+            checkForDeprecatedAppId: ()=>checkForDeprecatedAppId({
+                    cliConfig,
+                    output
+                }),
+            cliConfig,
+            extractManifest: isApp ? ({ workDir: wd })=>extractCoreAppManifest({
+                    workDir: wd
+                }) : (params)=>extractStudioManifest(params),
+            httpHost: config.httpHost,
+            httpPort: config.httpPort,
+            isApp,
+            outDir,
+            output,
+            reactStrictMode: resolveReactStrictMode(cliConfig) ?? false,
+            workDir
+        });
+    }
     try {
         const server = await startPreviewServer(config);
         return server;

package/dist/actions/preview/previewAction.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/actions/preview/previewAction.ts"],"sourcesContent":["import {type CliConfig} from '@sanity/cli-core'\n\nimport {gracefulServerDeath} from '../../server/gracefulServerDeath.js'\nimport {startPreviewServer} from '../../server/previewServer.js'\nimport {getPreviewServerConfig} from './getPreviewServerConfig.js'\nimport {type PreviewFlags} from './types.js'\n\ninterface PreviewActionOptions {\n  cliConfig: CliConfig\n  flags: PreviewFlags\n  outDir: string\n  workDir: string\n}\n\nexport async function previewAction(options: PreviewActionOptions) {\n  const {cliConfig, flags, outDir, workDir} = options\n\n  const config = getPreviewServerConfig({cliConfig, flags, rootDir: outDir, workDir})\n\n  try {\n    const server = await startPreviewServer(config)\n    return server\n  } catch (err) {\n    throw gracefulServerDeath('preview', config.httpHost, config.httpPort, err)\n  }\n}\n"],"names":["gracefulServerDeath","startPreviewServer","getPreviewServerConfig","previewAction","options","cliConfig","flags","outDir","workDir","config","rootDir","server","err","httpHost","httpPort"],"mappings":"AAEA,SAAQA,mBAAmB,QAAO,sCAAqC;AACvE,SAAQC,kBAAkB,QAAO,gCAA+B;AAChE,SAAQC,sBAAsB,QAAO,8BAA6B;AAUlE,OAAO,eAAeC,cAAcC,OAA6B;IAC/D,MAAM,EAACC,SAAS,EAAEC,KAAK,EAAEC,MAAM,EAAEC,OAAO,EAAC,GAAGJ;IAE5C,MAAMK,SAASP,uBAAuB;QAACG;QAAWC;QAAOI,SAASH;QAAQC;IAAO;IAEjF,IAAI;QACF,MAAMG,SAAS,MAAMV,mBAAmBQ;QACxC,OAAOE;IACT,EAAE,OAAOC,KAAK;QACZ,MAAMZ,oBAAoB,WAAWS,OAAOI,QAAQ,EAAEJ,OAAOK,QAAQ,EAAEF;IACzE;AACF"}
+{"version":3,"sources":["../../../src/actions/preview/previewAction.ts"],"sourcesContent":["import {SANITY_CACHE_DIR} from '@sanity/cli-build/_internal/build'\nimport {type CliConfig, type Output} from '@sanity/cli-core'\nimport {isWorkbenchApp} from '@sanity/workbench-cli'\n\nimport {gracefulServerDeath} from '../../server/gracefulServerDeath.js'\nimport {type PreviewServer, startPreviewServer} from '../../server/previewServer.js'\nimport {checkForDeprecatedAppId} from '../../util/appId.js'\nimport {determineIsApp} from '../../util/determineIsApp.js'\nimport {resolveReactStrictMode} from '../../util/resolveReactStrictMode.js'\nimport {extractCoreAppManifest} from '../manifest/extractCoreAppManifest.js'\nimport {extractStudioManifest} from '../manifest/extractStudioManifest.js'\nimport {getPreviewServerConfig} from './getPreviewServerConfig.js'\nimport {type PreviewFlags} from './types.js'\n\ninterface PreviewActionOptions {\n  cliConfig: CliConfig\n  flags: PreviewFlags\n  outDir: string\n  output: Output\n  workDir: string\n}\n\nexport async function previewAction(\n  options: PreviewActionOptions,\n): Promise<PreviewServer | {close: () => Promise<void>}> {\n  const {cliConfig, flags, outDir, output, workDir} = options\n\n  const config = getPreviewServerConfig({cliConfig, flags, rootDir: outDir, workDir})\n\n  if (isWorkbenchApp(cliConfig?.app)) {\n    const isApp = determineIsApp(cliConfig)\n    // Lazy so a non-workbench `sanity start` never loads the package. `doImport`\n    // is path-based and doesn't apply to a bare specifier.\n    // eslint-disable-next-line no-restricted-syntax\n    const {startWorkbenchPreview} = await import('@sanity/workbench-cli/preview')\n    return startWorkbenchPreview({\n      cacheDir: `${SANITY_CACHE_DIR}/vite`,\n      checkForDeprecatedAppId: () => checkForDeprecatedAppId({cliConfig, output}),\n      cliConfig,\n      extractManifest: isApp\n        ? ({workDir: wd}) => extractCoreAppManifest({workDir: wd})\n        : (params) => extractStudioManifest(params),\n      httpHost: config.httpHost,\n      httpPort: config.httpPort,\n      isApp,\n      outDir,\n      output,\n      reactStrictMode: resolveReactStrictMode(cliConfig) ?? false,\n      workDir,\n    })\n  }\n\n  try {\n    const server = await startPreviewServer(config)\n    return server\n  } catch (err) {\n    throw gracefulServerDeath('preview', config.httpHost, config.httpPort, err)\n  }\n}\n"],"names":["SANITY_CACHE_DIR","isWorkbenchApp","gracefulServerDeath","startPreviewServer","checkForDeprecatedAppId","determineIsApp","resolveReactStrictMode","extractCoreAppManifest","extractStudioManifest","getPreviewServerConfig","previewAction","options","cliConfig","flags","outDir","output","workDir","config","rootDir","app","isApp","startWorkbenchPreview","cacheDir","extractManifest","wd","params","httpHost","httpPort","reactStrictMode","server","err"],"mappings":"AAAA,SAAQA,gBAAgB,QAAO,oCAAmC;AAElE,SAAQC,cAAc,QAAO,wBAAuB;AAEpD,SAAQC,mBAAmB,QAAO,sCAAqC;AACvE,SAA4BC,kBAAkB,QAAO,gCAA+B;AACpF,SAAQC,uBAAuB,QAAO,sBAAqB;AAC3D,SAAQC,cAAc,QAAO,+BAA8B;AAC3D,SAAQC,sBAAsB,QAAO,uCAAsC;AAC3E,SAAQC,sBAAsB,QAAO,wCAAuC;AAC5E,SAAQC,qBAAqB,QAAO,uCAAsC;AAC1E,SAAQC,sBAAsB,QAAO,8BAA6B;AAWlE,OAAO,eAAeC,cACpBC,OAA6B;IAE7B,MAAM,EAACC,SAAS,EAAEC,KAAK,EAAEC,MAAM,EAAEC,MAAM,EAAEC,OAAO,EAAC,GAAGL;IAEpD,MAAMM,SAASR,uBAAuB;QAACG;QAAWC;QAAOK,SAASJ;QAAQE;IAAO;IAEjF,IAAIf,eAAeW,WAAWO,MAAM;QAClC,MAAMC,QAAQf,eAAeO;QAC7B,6EAA6E;QAC7E,uDAAuD;QACvD,gDAAgD;QAChD,MAAM,EAACS,qBAAqB,EAAC,GAAG,MAAM,MAAM,CAAC;QAC7C,OAAOA,sBAAsB;YAC3BC,UAAU,GAAGtB,iBAAiB,KAAK,CAAC;YACpCI,yBAAyB,IAAMA,wBAAwB;oBAACQ;oBAAWG;gBAAM;YACzEH;YACAW,iBAAiBH,QACb,CAAC,EAACJ,SAASQ,EAAE,EAAC,GAAKjB,uBAAuB;oBAACS,SAASQ;gBAAE,KACtD,CAACC,SAAWjB,sBAAsBiB;YACtCC,UAAUT,OAAOS,QAAQ;YACzBC,UAAUV,OAAOU,QAAQ;YACzBP;YACAN;YACAC;YACAa,iBAAiBtB,uBAAuBM,cAAc;YACtDI;QACF;IACF;IAEA,IAAI;QACF,MAAMa,SAAS,MAAM1B,mBAAmBc;QACxC,OAAOY;IACT,EAAE,OAAOC,KAAK;QACZ,MAAM5B,oBAAoB,WAAWe,OAAOS,QAAQ,EAAET,OAAOU,QAAQ,EAAEG;IACzE;AACF"}

package/dist/actions/schema/listSchemas.js

@@ -26,7 +26,7 @@ export async function listSchemas(options) {
         }
     });
     const schemas = await getDatasetSchemas(projectDatasets, id);
-    const parsedSchemas = parseSchemas(schemas, output);
+    const parsedSchemas = parseSchemas(schemas, output, json);
     if (parsedSchemas.length === 0) {
         const datasetString = getDatasetsOutString(projectDatasets.map((dataset)=>dataset.dataset));
         throw new Error(id ? `Schema for id "${id}" not found in ${datasetString}` : `No schemas found in ${datasetString}`);
@@ -56,16 +56,18 @@ async function getDatasetSchemas(projectDatasets, id) {
         }
     }));
 }
-function parseSchemas(schemas, output) {
+function parseSchemas(schemas, output, json) {
     return schemas.map((schema)=>{
         if (schema.status === 'fulfilled') return schema.value;
         const error = schema.reason;
         if (error instanceof DatasetError) {
             if ('cause' in error && error.cause && typeof error.cause === 'object' && 'statusCode' in error.cause && error.cause.statusCode === 401) {
-                output.log(styleText('yellow', `${logSymbols.warning} ↳ No permissions to read schema from "${error.dataset}". ${SCHEMA_PERMISSION_HELP_TEXT}:\n  ${styleText('red', `${error.message}`)}`));
+                const logDiagnostic = json ? output.warn.bind(output) : output.log.bind(output);
+                logDiagnostic(styleText('yellow', `${logSymbols.warning} ↳ No permissions to read schema from "${error.dataset}". ${SCHEMA_PERMISSION_HELP_TEXT}:\n  ${styleText('red', `${error.message}`)}`));
                 return [];
             }
-            output.log(styleText('red', `↳ Failed to fetch schema from "${error.dataset}":\n  ${error.message}`));
+            const logDiagnostic = json ? output.warn.bind(output) : output.log.bind(output);
+            logDiagnostic(styleText('red', `↳ Failed to fetch schema from "${error.dataset}":\n  ${error.message}`));
             return [];
         } else {
             //hubris inc: given the try-catch wrapping all the full promise "this should never happen"