sanity 3.77.3-server-side-schemas.36 → 3.77.3-server-side-schemas.37

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

@@ -3,18 +3,16 @@ import chalk from 'chalk'
 import uniq from 'lodash/uniq'
 
 import {isDefined} from '../../../manifest/manifestTypeHelpers'
-import {type ManifestWorkspaceFile} from '../../../manifest/manifestTypes'
 import {type SchemaStoreContext} from './schemaStoreTypes'
 import {createManifestExtractor, isManifestExtractSatisfied} from './utils/mainfestExtractor'
 import {createManifestReader} from './utils/manifestReader'
 import {createSchemaApiClient} from './utils/schemaApiClient'
 import {
-  assetIdsMatchesWorkspaces,
   filterLogReadProjectIdMismatch,
   parseDeleteSchemasConfig,
   type StoreSchemaCommonFlags,
 } from './utils/schemaStoreValidation'
-import {getDatasetsOutString, getStringArrayOutString} from './utils/storeSchemaOutStrings'
+import {getDatasetsOutString, getStringList} from './utils/storeSchemaOutStrings'
 
 export interface DeleteSchemaFlags extends StoreSchemaCommonFlags {
   ids?: string
@@ -22,19 +20,19 @@ export interface DeleteSchemaFlags extends StoreSchemaCommonFlags {
 }
 
 interface DeleteResult {
-  workspace: ManifestWorkspaceFile
+  dataset: string
   schemaId: string
   deleted: boolean
 }
 
 class DeleteIdError extends Error {
   public id: string
-  public workspace: ManifestWorkspaceFile
-  constructor(id: string, workspace: ManifestWorkspaceFile, options?: ErrorOptions) {
+  public dataset: string
+  constructor(id: string, dataset: string, options?: ErrorOptions) {
     super((options?.cause as {message?: string})?.message, options)
     this.name = 'DeleteIdError'
     this.id = id
-    this.workspace = workspace
+    this.dataset = dataset
   }
 }
 
@@ -76,76 +74,73 @@ export async function deleteSchemaAction(
     .filter((workspace) => !dataset || workspace.dataset === dataset)
     .filter((workspace) => filterLogReadProjectIdMismatch(workspace, projectId, output))
 
-  assetIdsMatchesWorkspaces(
-    ids.map((id) => id.schemaId),
-    workspaces,
-  )
+  const datasets = uniq(workspaces.map((w) => w.dataset))
 
   const results = await Promise.allSettled(
-    workspaces.flatMap((workspace: ManifestWorkspaceFile) => {
-      return ids
-        .filter(({workspace: idWorkspace}) => idWorkspace === workspace.name)
-        .map(async ({schemaId}): Promise<DeleteResult> => {
-          try {
-            const deletedSchema = await client
-              .withConfig({dataset: workspace.dataset})
-              .delete(schemaId)
-            return {workspace, schemaId, deleted: deletedSchema.results.length}
-          } catch (err) {
-            throw new DeleteIdError(schemaId, workspace, {cause: err})
-          }
-        })
+    datasets.flatMap((targetDataset: string) => {
+      return ids.map(async ({schemaId}): Promise<DeleteResult> => {
+        try {
+          const deletedSchema = await client.withConfig({dataset: targetDataset}).delete(schemaId)
+          return {dataset: targetDataset, schemaId, deleted: deletedSchema.results.length}
+        } catch (err) {
+          throw new DeleteIdError(schemaId, targetDataset, {cause: err})
+        }
+      })
     }),
   )
 
   const deletedIds = results
     .filter((r): r is PromiseFulfilledResult<DeleteResult> => r.status === 'fulfilled')
     .filter((r) => r.value.deleted)
-    .map((r) => r.value.schemaId)
+    .map((r) => r.value)
 
   const notFound = uniq(
     results
       .filter((r): r is PromiseFulfilledResult<DeleteResult> => r.status === 'fulfilled')
       .filter((r) => !r.value.deleted)
+      .filter((r) => !deletedIds.map(({schemaId}) => schemaId).includes(r.value.schemaId))
       .map((r) => r.value.schemaId),
   )
 
-  const deleteFailureIds = results
-    .filter((r) => r.status === 'rejected')
-    .map((result) => {
-      const error = result.reason
-      if (error instanceof DeleteIdError) {
-        output.error(
-          chalk.red(
-            `Failed to delete schema "${error.id}" in dataset "${error.workspace.dataset}":\n${error.message}`,
-          ),
-        )
-        if (verbose) output.error(error)
-        return error.id
-      }
-      //hubris inc: given the try-catch wrapping the full promise "this should never happen"
-      throw error
-    })
+  const deleteFailureIds = uniq(
+    results
+      .filter((r) => r.status === 'rejected')
+      .map((result) => {
+        const error = result.reason
+        if (error instanceof DeleteIdError) {
+          output.error(
+            chalk.red(
+              `Failed to delete schema "${error.id}" in dataset "${error.dataset}":\n${error.message}`,
+            ),
+          )
+          if (verbose) output.error(error)
+          return error.id
+        }
+        //hubris inc: given the try-catch wrapping the full promise "this should never happen"
+        throw error
+      }),
+  )
 
   const success = deletedIds.length === ids.length
   if (success) {
     output.success(`Successfully deleted ${deletedIds.length}/${ids.length} schemas`)
   } else {
-    const datasets = uniq(workspaces.map((w) => w.dataset))
     output.error(
       [
         `Deleted ${deletedIds.length}/${ids.length} schemas.`,
         deletedIds.length
-          ? `Successfully deleted ids:\n  ${getStringArrayOutString(deletedIds)}`
+          ? `Successfully deleted ids:\n${deletedIds
+              .map(
+                ({schemaId, dataset: targetDataset}) =>
+                  `- "${schemaId}" (in ${getDatasetsOutString([targetDataset])})`,
+              )
+              .join('\n')}`
           : undefined,
         notFound.length
-          ? `Ids not found in ${getDatasetsOutString(datasets)}:\n  ${getStringArrayOutString(notFound)}`
+          ? `Ids not found in ${getDatasetsOutString(datasets)}:\n${getStringList(notFound)}`
           : undefined,
         ...(deleteFailureIds.length
-          ? [
-              `Failed to delete ids:\n  ${getStringArrayOutString(deleteFailureIds)}`,
-              'Check logs for errors.',
-            ]
+          ? [`Failed to delete ids:\n${getStringList(deleteFailureIds)}`, 'Check logs for errors.']
           : []),
       ]
         .filter(isDefined)

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

@@ -13,7 +13,6 @@ import {createManifestExtractor, isManifestExtractSatisfied} from './utils/mainf
 import {createManifestReader} from './utils/manifestReader'
 import {createSchemaApiClient} from './utils/schemaApiClient'
 import {
-  assetIdsMatchesWorkspaces,
   filterLogReadProjectIdMismatch,
   parseListSchemasConfig,
   type StoreSchemaCommonFlags,
@@ -68,8 +67,6 @@ export async function listSchemasAction(
     filterLogReadProjectIdMismatch(workspace, projectId, output),
   )
 
-  if (id) assetIdsMatchesWorkspaces([id], workspaces)
-
   const datasets = uniq(workspaces.map((w) => w.dataset))
 
   const schemaResults = await Promise.allSettled(

package/src/_internal/cli/actions/schema/utils/schemaStoreValidation.ts

@@ -94,13 +94,13 @@ function assertNoErrors(errors: string[]) {
   }
 }
 
-export function assetIdsMatchesWorkspaces(ids: string[], workspaces: {name: string}[]) {
+export function assertIdsMatchesWorkspaces(ids: string[], workspaces: {name: string}[]) {
   const invalidIds = ids
     .map((id) => ({
       id,
       parsedId: parseWorkspaceSchemaId(id, []),
     }))
-    .filter(({id, parsedId}) => !parsedId || !workspaces.some((w) => w.name === parsedId.workspace))
+    .filter(({parsedId}) => !parsedId || !workspaces.some((w) => w.name === parsedId.workspace))
 
   if (invalidIds.length)
     throw new FlagValidationError(

package/src/_internal/cli/actions/schema/utils/storeSchemaOutStrings.ts

@@ -7,3 +7,7 @@ export function getDatasetsOutString(datasets: string[]) {
 export function getStringArrayOutString(array: string[]) {
   return `[${array.map((d) => `"${d}"`).join(',')}]`
 }
+
+export function getStringList(array: string[]) {
+  return array.map((s) => `- "${s}"`).join('\n')
+}

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

@@ -1,6 +1,6 @@
 import {type CliCommandDefinition} from '@sanity/cli'
 
-const description = 'Delete schema documents by id'
+const description = 'Delete schema documents by id.'
 
 const helpText = `
 **Note**: This command is experimental and subject to change.