sanity 3.77.2-server-side-schemas.18 → 3.77.2-server-side-schemas.24

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

@@ -1,11 +1,15 @@
 import {type CliCommandArguments, type CliCommandContext, type CliOutputter} from '@sanity/cli'
 import {type SanityDocument} from '@sanity/client'
 import chalk from 'chalk'
-import {size, sortBy} from 'lodash'
+import {size, sortBy, uniqBy} from 'lodash'
+
+import {type ManifestWorkspaceFile} from '../../../manifest/manifestTypes'
+import {getManifestPath, readManifest, throwIfProjectIdMismatch} from './storeSchemasAction'
 
 export interface SchemaListFlags {
   json: boolean
   id: string
+  path: string
 }
 
 type PrintSchemaListArgs = {
@@ -13,14 +17,18 @@ type PrintSchemaListArgs = {
   output: CliOutputter
   dataset: string
   projectId: string
+  path: string
 }
 
 export const SANITY_WORKSPACE_SCHEMA_ID = 'sanity.workspace.schema'
 
-const printSchemaList = ({schemas, output, dataset, projectId}: PrintSchemaListArgs) => {
+const printSchemaList = ({
+  schemas,
+  output,
+}: Omit<PrintSchemaListArgs, 'path' | 'dataset' | 'projectId'>) => {
   const ordered = sortBy(
     schemas.map(({_createdAt: createdAt, _id: id, workspace}) => {
-      return [id, workspace.title, dataset, projectId, createdAt].map(String)
+      return [id, workspace.title, workspace.dataset, workspace.projectId, createdAt].map(String)
     }),
     ['createdAt'],
   )
@@ -38,7 +46,7 @@ const printSchemaList = ({schemas, output, dataset, projectId}: PrintSchemaListA
   rows.forEach((row) => output.print(printRow(row)))
 }
 
-export default async function storeSchemaAction(
+export default async function fetchSchemaAction(
   args: CliCommandArguments<SchemaListFlags>,
   context: CliCommandContext,
 ): Promise<void> {
@@ -50,50 +58,67 @@ export default async function storeSchemaAction(
   }).withConfig({apiVersion: 'v2024-08-01'})
 
   const projectId = client.config().projectId
-  const dataset = client.config().dataset
 
-  if (!projectId || !dataset) {
-    output.error('Project ID and Dataset must be defined.')
+  if (!projectId) {
+    output.error('Project ID must be defined.')
     return
   }
 
-  let schemas: SanityDocument[]
-
-  if (flags.id) {
-    // Fetch a specific schema by id
-    schemas = await client
-      .withConfig({
-        dataset: dataset,
-        projectId: projectId,
-      })
-      .fetch<SanityDocument[]>(`*[_type == $type && _id == $id]`, {
-        id: flags.id,
-        type: SANITY_WORKSPACE_SCHEMA_ID,
-      })
-  } else {
-    // Fetch all schemas
-    schemas = await client
-      .withConfig({
-        dataset: dataset,
-        projectId: projectId,
-      })
-      .fetch<SanityDocument[]>(`*[_type == $type]`, {
-        type: SANITY_WORKSPACE_SCHEMA_ID,
-      })
-  }
+  const manifestPath = getManifestPath(context, flags.path)
+  const manifest = readManifest(manifestPath, output)
+
+  // Gather all schemas
+  const results = await Promise.allSettled(
+    uniqBy<ManifestWorkspaceFile>(manifest.workspaces, 'dataset').map(async (workspace) => {
+      throwIfProjectIdMismatch(workspace, projectId)
+      if (flags.id) {
+        // Fetch a specific schema by id
+        return await client
+          .withConfig({
+            dataset: workspace.dataset,
+            projectId: workspace.projectId,
+          })
+          .fetch<SanityDocument[]>(`*[_type == $type && _id == $id]`, {
+            id: flags.id,
+            type: SANITY_WORKSPACE_SCHEMA_ID,
+          })
+      }
+      // Fetch all schemas
+      return await client
+        .withConfig({
+          dataset: workspace.dataset,
+          projectId: workspace.projectId,
+        })
+        .fetch<SanityDocument[]>(`*[_type == $type]`, {
+          type: SANITY_WORKSPACE_SCHEMA_ID,
+        })
+    }),
+  )
+
+  // Log errors and collect successful results
+  const schemas = results
+    .map((result, index) => {
+      if (result.status === 'rejected') {
+        const workspace = manifest.workspaces[index]
+        output.error(
+          chalk.red(
+            `Failed to fetch schemas for workspace '${workspace.name}': ${result.reason.message}`,
+          ),
+        )
+        return []
+      }
+      return result.value
+    })
+    .flat()
 
   if (schemas.length === 0) {
-    if (flags.id) {
-      output.error(`No schema found with id: ${flags.id}`)
-    } else {
-      output.error(`No schemas found`)
-    }
+    output.error(`No schemas found`)
     return
   }
 
   if (flags.json) {
-    output.print(`${JSON.stringify(flags.id ? schemas[0] : schemas, null, 2)}`)
+    output.print(`${JSON.stringify(schemas, null, 2)}`)
   } else {
-    printSchemaList({schemas, output, dataset, projectId})
+    printSchemaList({schemas, output})
   }
 }

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

@@ -1,14 +1,11 @@
 import {readFileSync} from 'node:fs'
 import path, {join, resolve} from 'node:path'
 
-import {type CliCommandArguments, type CliCommandContext} from '@sanity/cli'
+import {type CliCommandArguments, type CliCommandContext, type CliOutputter} from '@sanity/cli'
 import chalk from 'chalk'
+import {type Ora} from 'ora'
 
-import {
-  type CreateManifest,
-  type ManifestSchemaType,
-  type ManifestWorkspaceFile,
-} from '../../../manifest/manifestTypes'
+import {type ManifestSchemaType, type ManifestWorkspaceFile} from '../../../manifest/manifestTypes'
 import {MANIFEST_FILENAME} from '../manifest/extractManifestAction'
 import {SANITY_WORKSPACE_SCHEMA_ID} from './schemaListAction'
 
@@ -20,57 +17,74 @@ export interface StoreManifestSchemasFlags {
   'verbose'?: boolean
 }
 
+export const getManifestPath = (context: CliCommandContext, customPath?: string) => {
+  const defaultOutputDir = resolve(join(context.workDir, 'dist'))
+
+  const outputDir = resolve(defaultOutputDir)
+  const defaultStaticPath = join(outputDir, 'static')
+
+  const staticPath = customPath ?? defaultStaticPath
+  const manifestPath = path.resolve(process.cwd(), staticPath)
+  return manifestPath
+}
+
+export const readManifest = (readPath: string, output?: CliOutputter, spinner?: Ora) => {
+  try {
+    return JSON.parse(readFileSync(`${readPath}/${MANIFEST_FILENAME}`, 'utf-8'))
+  } catch (error) {
+    const errorMessage = `Manifest not found at ${readPath}/${MANIFEST_FILENAME}`
+    if (spinner) spinner.fail(errorMessage)
+    if (output) output.error(errorMessage)
+    throw error
+  }
+}
+
+export const throwIfProjectIdMismatch = (workspace: ManifestWorkspaceFile, projectId: string) => {
+  if (workspace.projectId !== projectId) {
+    throw new Error(
+      `↳ No permissions to store schema for workspace ${workspace.name} with projectId: ${workspace.projectId}`,
+    )
+  }
+}
+
 export default async function storeSchemasAction(
   args: CliCommandArguments<StoreManifestSchemasFlags>,
   context: CliCommandContext,
 ): Promise<Error | undefined> {
   const flags = args.extOptions
+  if (typeof flags.path === 'boolean') throw new Error('Path is empty')
+  if (typeof flags['id-prefix'] === 'boolean') throw new Error('Id prefix is empty')
+  if (typeof flags.workspace === 'boolean') throw new Error('Workspace is empty')
+
   const schemaRequired = flags['schema-required']
   const workspaceName = flags.workspace
   const idPrefix = flags['id-prefix']
   const verbose = flags.verbose
-  const {output, workDir, apiClient} = context
-
-  const defaultOutputDir = resolve(join(workDir, 'dist'))
-
-  const outputDir = resolve(defaultOutputDir)
-  const defaultStaticPath = join(outputDir, 'static')
-
-  const staticPath = flags.path ?? defaultStaticPath
+  const {output, apiClient} = context
 
   const spinner = output.spinner({}).start('Storing schemas')
 
+  const manifestPath = getManifestPath(context, flags.path)
+
   try {
-    const manifestPath = path.resolve(process.cwd(), staticPath)
     const client = apiClient({
       requireUser: true,
       requireProject: true,
     }).withConfig({apiVersion: 'v2024-08-01'})
 
     const projectId = client.config().projectId
+    if (!projectId) throw new Error('Project ID is not defined')
 
-    let manifest: CreateManifest
-
-    try {
-      manifest = JSON.parse(readFileSync(`${manifestPath}/${MANIFEST_FILENAME}`, 'utf-8'))
-    } catch (error) {
-      spinner.fail(`Manifest not found at ${manifestPath}/${MANIFEST_FILENAME}`)
-      output.error(error)
-      throw error
-    }
+    const manifest = readManifest(manifestPath, output, spinner)
 
     let storedCount = 0
 
     let error: Error | undefined
 
     const saveSchema = async (workspace: ManifestWorkspaceFile) => {
-      const id = `${idPrefix || SANITY_WORKSPACE_SCHEMA_ID}.${workspace.name}`
+      const id = `${idPrefix ? `${idPrefix}.` : ''}${SANITY_WORKSPACE_SCHEMA_ID}.${workspace.name}`
       try {
-        if (workspace.projectId !== projectId) {
-          throw new Error(
-            `↳ No permissions to store schema for workspace ${workspace.name} with projectId: ${workspace.projectId}`,
-          )
-        }
+        throwIfProjectIdMismatch(workspace, projectId)
         const schema = JSON.parse(
           readFileSync(`${manifestPath}/${workspace.schema}`, 'utf-8'),
         ) as ManifestSchemaType
@@ -88,15 +102,13 @@ export default async function storeSchemasAction(
       } catch (err) {
         error = err
         spinner.fail(
-          `Error storing schema for workspace '${workspace.name}':\n${chalk.red(`- ${err.message}`)}`,
+          `Error storing schema for workspace '${workspace.name}':\n${chalk.red(`${err.message}`)}`,
         )
         if (schemaRequired) throw err
       } finally {
         if (verbose) {
           output.print(
-            chalk.gray(
-              `↳ schemaId: ${id}, projectId: ${projectId}, dataset: ${workspace.dataset}, workspace: ${workspace.name}\n`,
-            ),
+            chalk.gray(`↳ schemaId: ${id}, projectId: ${projectId}, dataset: ${workspace.dataset}`),
           )
         }
       }
@@ -105,7 +117,7 @@ export default async function storeSchemasAction(
     // If a workspace name is provided, only save the schema for that workspace
     if (workspaceName) {
       const workspaceToSave = manifest.workspaces.find(
-        (workspace) => workspace.name === workspaceName,
+        (workspace: ManifestWorkspaceFile) => workspace.name === workspaceName,
       )
       if (!workspaceToSave) {
         spinner.fail(`Workspace ${workspaceName} not found in manifest`)
@@ -115,7 +127,7 @@ export default async function storeSchemasAction(
       spinner.succeed(`Stored 1 schemas`)
     } else {
       await Promise.all(
-        manifest.workspaces.map(async (workspace): Promise<void> => {
+        manifest.workspaces.map(async (workspace: ManifestWorkspaceFile): Promise<void> => {
           await saveSchema(workspace)
         }),
       )
@@ -129,6 +141,6 @@ export default async function storeSchemasAction(
     if (schemaRequired) throw err
     return err
   } finally {
-    output.print(`List stored schemas with: ${chalk.cyan('sanity schema list')}`)
+    output.print(`${chalk.gray('↳ List stored schemas with:')} ${chalk.cyan('sanity schema list')}`)
   }
 }

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

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

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

@@ -29,7 +29,18 @@ const storeSchemaCommand = {
   action: async (args, context) => {
     const mod = await import('../../actions/schema/storeSchemasAction')
 
-    return mod.default(args as unknown as CliCommandArguments<StoreManifestSchemasFlags>, context)
+    const extendedArgs = {
+      ...args,
+      extOptions: {
+        ...args.extOptions,
+        'schema-required': true,
+      },
+    }
+
+    return mod.default(
+      extendedArgs as unknown as CliCommandArguments<StoreManifestSchemasFlags>,
+      context,
+    )
   },
 } satisfies CliCommandDefinition
 

package/lib/_chunks-cjs/schemaListAction.js

@@ -1,59 +0,0 @@
-"use strict";
-var chalk = require("chalk"), size = require("lodash/size.js"), sortBy = require("lodash/sortBy.js");
-function _interopDefaultCompat(e) {
-  return e && typeof e == "object" && "default" in e ? e : { default: e };
-}
-var chalk__default = /* @__PURE__ */ _interopDefaultCompat(chalk), size__default = /* @__PURE__ */ _interopDefaultCompat(size), sortBy__default = /* @__PURE__ */ _interopDefaultCompat(sortBy);
-const SANITY_WORKSPACE_SCHEMA_ID = "sanity.workspace.schema", printSchemaList = ({
-  schemas,
-  output,
-  dataset,
-  projectId
-}) => {
-  const ordered = sortBy__default.default(schemas.map(({
-    _createdAt: createdAt,
-    _id: id,
-    workspace
-  }) => [id, workspace.title, dataset, projectId, createdAt].map(String)), ["createdAt"]), headings = ["Id", "Title", "Dataset", "ProjectId", "CreatedAt"], rows = ordered.reverse(), maxWidths = rows.reduce((max, row) => row.map((current, index) => Math.max(size__default.default(current), max[index])), headings.map((str) => size__default.default(str))), printRow = (row) => row.map((col, i) => `${col}`.padEnd(maxWidths[i])).join("   ");
-  output.print(chalk__default.default.cyan(printRow(headings))), rows.forEach((row) => output.print(printRow(row)));
-};
-async function storeSchemaAction(args, context) {
-  const flags = args.extOptions, {
-    apiClient,
-    output
-  } = context, client = apiClient({
-    requireUser: !0,
-    requireProject: !0
-  }).withConfig({
-    apiVersion: "v2024-08-01"
-  }), projectId = client.config().projectId, dataset = client.config().dataset;
-  if (!projectId || !dataset) {
-    output.error("Project ID and Dataset must be defined.");
-    return;
-  }
-  let schemas;
-  if (flags.id ? schemas = await client.withConfig({
-    dataset,
-    projectId
-  }).fetch("*[_type == $type && _id == $id]", {
-    id: flags.id,
-    type: SANITY_WORKSPACE_SCHEMA_ID
-  }) : schemas = await client.withConfig({
-    dataset,
-    projectId
-  }).fetch("*[_type == $type]", {
-    type: SANITY_WORKSPACE_SCHEMA_ID
-  }), schemas.length === 0) {
-    flags.id ? output.error(`No schema found with id: ${flags.id}`) : output.error("No schemas found");
-    return;
-  }
-  flags.json ? output.print(`${JSON.stringify(flags.id ? schemas[0] : schemas, null, 2)}`) : printSchemaList({
-    schemas,
-    output,
-    dataset,
-    projectId
-  });
-}
-exports.SANITY_WORKSPACE_SCHEMA_ID = SANITY_WORKSPACE_SCHEMA_ID;
-exports.default = storeSchemaAction;
-//# sourceMappingURL=schemaListAction.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"schemaListAction.js","sources":["../../src/_internal/cli/actions/schema/schemaListAction.ts"],"sourcesContent":["import {type CliCommandArguments, type CliCommandContext, type CliOutputter} from '@sanity/cli'\nimport {type SanityDocument} from '@sanity/client'\nimport chalk from 'chalk'\nimport {size, sortBy} from 'lodash'\n\nexport interface SchemaListFlags {\n  json: boolean\n  id: string\n}\n\ntype PrintSchemaListArgs = {\n  schemas: SanityDocument[]\n  output: CliOutputter\n  dataset: string\n  projectId: string\n}\n\nexport const SANITY_WORKSPACE_SCHEMA_ID = 'sanity.workspace.schema'\n\nconst printSchemaList = ({schemas, output, dataset, projectId}: PrintSchemaListArgs) => {\n  const ordered = sortBy(\n    schemas.map(({_createdAt: createdAt, _id: id, workspace}) => {\n      return [id, workspace.title, dataset, projectId, createdAt].map(String)\n    }),\n    ['createdAt'],\n  )\n  const headings = ['Id', 'Title', 'Dataset', 'ProjectId', 'CreatedAt']\n  const rows = ordered.reverse()\n\n  const maxWidths = rows.reduce(\n    (max, row) => row.map((current, index) => Math.max(size(current), max[index])),\n    headings.map((str) => size(str)),\n  )\n\n  const printRow = (row: string[]) => row.map((col, i) => `${col}`.padEnd(maxWidths[i])).join('   ')\n\n  output.print(chalk.cyan(printRow(headings)))\n  rows.forEach((row) => output.print(printRow(row)))\n}\n\nexport default async function storeSchemaAction(\n  args: CliCommandArguments<SchemaListFlags>,\n  context: CliCommandContext,\n): Promise<void> {\n  const flags = args.extOptions\n  const {apiClient, output} = context\n  const client = apiClient({\n    requireUser: true,\n    requireProject: true,\n  }).withConfig({apiVersion: 'v2024-08-01'})\n\n  const projectId = client.config().projectId\n  const dataset = client.config().dataset\n\n  if (!projectId || !dataset) {\n    output.error('Project ID and Dataset must be defined.')\n    return\n  }\n\n  let schemas: SanityDocument[]\n\n  if (flags.id) {\n    // Fetch a specific schema by id\n    schemas = await client\n      .withConfig({\n        dataset: dataset,\n        projectId: projectId,\n      })\n      .fetch<SanityDocument[]>(`*[_type == $type && _id == $id]`, {\n        id: flags.id,\n        type: SANITY_WORKSPACE_SCHEMA_ID,\n      })\n  } else {\n    // Fetch all schemas\n    schemas = await client\n      .withConfig({\n        dataset: dataset,\n        projectId: projectId,\n      })\n      .fetch<SanityDocument[]>(`*[_type == $type]`, {\n        type: SANITY_WORKSPACE_SCHEMA_ID,\n      })\n  }\n\n  if (schemas.length === 0) {\n    if (flags.id) {\n      output.error(`No schema found with id: ${flags.id}`)\n    } else {\n      output.error(`No schemas found`)\n    }\n    return\n  }\n\n  if (flags.json) {\n    output.print(`${JSON.stringify(flags.id ? schemas[0] : schemas, null, 2)}`)\n  } else {\n    printSchemaList({schemas, output, dataset, projectId})\n  }\n}\n"],"names":["SANITY_WORKSPACE_SCHEMA_ID","printSchemaList","schemas","output","dataset","projectId","ordered","sortBy","map","_createdAt","createdAt","_id","id","workspace","title","String","headings","rows","reverse","maxWidths","reduce","max","row","current","index","Math","size","str","printRow","col","i","padEnd","join","print","chalk","cyan","forEach","storeSchemaAction","args","context","flags","extOptions","apiClient","client","requireUser","requireProject","withConfig","apiVersion","config","error","fetch","type","length","json","JSON","stringify"],"mappings":";;;;;;AAiBO,MAAMA,6BAA6B,2BAEpCC,kBAAkBA,CAAC;AAAA,EAACC;AAAAA,EAASC;AAAAA,EAAQC;AAAAA,EAASC;AAA8B,MAAM;AACtF,QAAMC,UAAUC,gBAAAA,QACdL,QAAQM,IAAI,CAAC;AAAA,IAACC,YAAYC;AAAAA,IAAWC,KAAKC;AAAAA,IAAIC;AAAAA,EAAAA,MACrC,CAACD,IAAIC,UAAUC,OAAOV,SAASC,WAAWK,SAAS,EAAEF,IAAIO,MAAM,CACvE,GACD,CAAC,WAAW,CACd,GACMC,WAAW,CAAC,MAAM,SAAS,WAAW,aAAa,WAAW,GAC9DC,OAAOX,QAAQY,QAAQ,GAEvBC,YAAYF,KAAKG,OACrB,CAACC,KAAKC,QAAQA,IAAId,IAAI,CAACe,SAASC,UAAUC,KAAKJ,IAAIK,cAAAA,QAAKH,OAAO,GAAGF,IAAIG,KAAK,CAAC,CAAC,GAC7ER,SAASR,IAAKmB,CAAQD,QAAAA,cAAAA,QAAKC,GAAG,CAAC,CACjC,GAEMC,WAAYN,SAAkBA,IAAId,IAAI,CAACqB,KAAKC,MAAM,GAAGD,GAAG,GAAGE,OAAOZ,UAAUW,CAAC,CAAC,CAAC,EAAEE,KAAK,KAAK;AAEjG7B,SAAO8B,MAAMC,eAAMC,QAAAA,KAAKP,SAASZ,QAAQ,CAAC,CAAC,GAC3CC,KAAKmB,QAASd,SAAQnB,OAAO8B,MAAML,SAASN,GAAG,CAAC,CAAC;AACnD;AAE8Be,eAAAA,kBAC5BC,MACAC,SACe;AACTC,QAAAA,QAAQF,KAAKG,YACb;AAAA,IAACC;AAAAA,IAAWvC;AAAAA,EAAAA,IAAUoC,SACtBI,SAASD,UAAU;AAAA,IACvBE,aAAa;AAAA,IACbC,gBAAgB;AAAA,EACjB,CAAA,EAAEC,WAAW;AAAA,IAACC,YAAY;AAAA,EAAA,CAAc,GAEnC1C,YAAYsC,OAAOK,SAAS3C,WAC5BD,UAAUuC,OAAOK,OAAAA,EAAS5C;AAE5B,MAAA,CAACC,aAAa,CAACD,SAAS;AAC1BD,WAAO8C,MAAM,yCAAyC;AACtD;AAAA,EAAA;AAGE/C,MAAAA;AAyBJ,MAvBIsC,MAAM5B,KAERV,UAAU,MAAMyC,OACbG,WAAW;AAAA,IACV1C;AAAAA,IACAC;AAAAA,EAAAA,CACD,EACA6C,MAAwB,mCAAmC;AAAA,IAC1DtC,IAAI4B,MAAM5B;AAAAA,IACVuC,MAAMnD;AAAAA,EACP,CAAA,IAGHE,UAAU,MAAMyC,OACbG,WAAW;AAAA,IACV1C;AAAAA,IACAC;AAAAA,EAAAA,CACD,EACA6C,MAAwB,qBAAqB;AAAA,IAC5CC,MAAMnD;AAAAA,EAAAA,CACP,GAGDE,QAAQkD,WAAW,GAAG;AACpBZ,UAAM5B,KACRT,OAAO8C,MAAM,4BAA4BT,MAAM5B,EAAE,EAAE,IAEnDT,OAAO8C,MAAM,kBAAkB;AAEjC;AAAA,EAAA;AAGET,QAAMa,OACRlD,OAAO8B,MAAM,GAAGqB,KAAKC,UAAUf,MAAM5B,KAAKV,QAAQ,CAAC,IAAIA,SAAS,MAAM,CAAC,CAAC,EAAE,IAE1ED,gBAAgB;AAAA,IAACC;AAAAA,IAASC;AAAAA,IAAQC;AAAAA,IAASC;AAAAA,EAAAA,CAAU;AAEzD;;;"}