sanity 3.72.2-coreui.15 → 3.72.2-server-side-schemas-1.19

package/src/_internal/cli/actions/deploy/deployAction.ts

@@ -8,6 +8,7 @@ import tar from 'tar-fs'
 import {shouldAutoUpdate} from '../../util/shouldAutoUpdate'
 import buildSanityStudio, {type BuildSanityStudioCommandFlags} from '../build/buildAction'
 import {extractManifestSafe} from '../manifest/extractManifestAction'
+import storeManifestSchemas from '../schema/storeSchemasAction'
 import {
   checkDir,
   createDeployment,
@@ -113,7 +114,7 @@ export default async function deployStudioAction(
       return
     }
 
-    await extractManifestSafe(
+    const extractManifestError = await extractManifestSafe(
       {
         ...buildArgs,
         extOptions: {},
@@ -121,6 +122,16 @@ export default async function deployStudioAction(
       },
       context,
     )
+
+    const storeManifestSchemasArgs = {
+      ...args,
+      extOptions: {
+        path: `${sourceDir}/static`,
+      },
+      extraArguments: [],
+    }
+
+    if (!extractManifestError) await storeManifestSchemas(storeManifestSchemasArgs, context)
   }
 
   // Ensure that the directory exists, is a directory and seems to have valid content

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

@@ -0,0 +1,35 @@
+import {type CliCommandArguments, type CliCommandContext} from '@sanity/cli'
+
+import {type ManifestSchemaType} from '../../../manifest/manifestTypes'
+
+export interface FetchSchemaFlags {
+  id: string
+}
+
+export default async function fetchSchemaAction(
+  args: CliCommandArguments<FetchSchemaFlags>,
+  context: CliCommandContext,
+): Promise<void> {
+  const {apiClient, output} = context
+  const flags = args.extOptions
+  const schemaId = flags.id
+  const spinner = output.spinner({}).start('Fetching schema')
+  const client = apiClient({
+    requireUser: true,
+    requireProject: true,
+  }).withConfig({apiVersion: 'v2024-08-01'})
+
+  const projectId = client.config().projectId
+  const dataset = client.config().dataset
+
+  const schema = await client
+    .withConfig({
+      dataset: dataset,
+      projectId: projectId,
+    })
+    .fetch<ManifestSchemaType>(`*[_type == "sanity.workspace.schema" && _id == "${schemaId}"]`)
+
+  spinner.succeed('Schema fetched')
+  // print schema as json
+  output.success(JSON.stringify(schema, null, 2))
+}

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

@@ -0,0 +1,93 @@
+import {readFileSync} from 'node:fs'
+import path, {join, resolve} from 'node:path'
+
+import {type CliCommandArguments, type CliCommandContext} from '@sanity/cli'
+
+import {
+  type CreateManifest,
+  type ManifestSchemaType,
+  type ManifestWorkspaceFile,
+} from '../../../manifest/manifestTypes'
+
+export interface StoreManifestSchemasFlags {
+  'path'?: string
+  'workspace'?: string
+  'custom-id'?: string
+}
+
+export default async function storeManifestSchemas(
+  args: CliCommandArguments<StoreManifestSchemasFlags>,
+  context: CliCommandContext,
+): Promise<void> {
+  const flags = args.extOptions
+  const workspaceName = flags.workspace
+  const customId = flags['custom-id']
+  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
+
+  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
+
+    const manifest: CreateManifest = JSON.parse(
+      readFileSync(`${manifestPath}/create-manifest.json`, 'utf-8'),
+    )
+
+    const saveSchema = async (workspace: ManifestWorkspaceFile) => {
+      const spinner = output.spinner({}).start('Storing schemas')
+      const id = customId || `sanity.workspace.schema.${workspace.name}`
+      try {
+        if (workspace.projectId !== projectId && workspaceName !== workspace.name) {
+          spinner.fail(
+            `Cannot store schema for ${workspace.name} because manifest projectId does not match: ${projectId} !== ${workspace.projectId}`,
+          )
+          return
+        }
+        const schema = JSON.parse(
+          readFileSync(`${manifestPath}/${workspace.schema}`, 'utf-8'),
+        ) as ManifestSchemaType
+        await client
+          .withConfig({
+            dataset: workspace.dataset,
+            projectId: workspace.projectId,
+          })
+          .transaction()
+          .createOrReplace({_type: 'sanity.workspace.schema', _id: id, workspace, schema})
+          .commit()
+        spinner.succeed(
+          `Schema stored for workspace ${workspace.name} (shcemaId: ${id}, projectId: ${projectId}, dataset: ${workspace.dataset})`,
+        )
+      } catch (error) {
+        spinner.fail(`Error storing schema for workspace ${workspace.name}: ${error}`)
+      }
+    }
+
+    if (workspaceName) {
+      const schemaToSave = manifest.workspaces.find((workspace) => workspace.name === workspaceName)
+      if (schemaToSave) {
+        await saveSchema(schemaToSave)
+      } else {
+        output.error(`Workspace ${workspaceName} not found in manifest: projectID: ${projectId}`)
+      }
+    } else {
+      await Promise.all(
+        manifest.workspaces.map(async (workspace): Promise<void> => {
+          await saveSchema(workspace)
+        }),
+      )
+    }
+  } catch (err) {
+    output.error(err)
+  }
+}

package/src/_internal/cli/commands/build/buildCommand.ts

@@ -6,7 +6,9 @@ Options
   --source-maps Enable source maps for built bundles (increases size of bundle)
   --auto-updates / --no-auto-updates Enable/disable auto updates of studio versions
   --no-minify Skip minifying built JavaScript (speeds up build, increases size of bundle)
+  --work
   -y, --yes Unattended mode, answers "yes" to any "yes/no" prompt and otherwise uses defaults
+  --schema-path If you are storing your schemas in a different path than the default one, you need to specify it here.
 
 Examples
   sanity build

package/src/_internal/cli/commands/deploy/deployCommand.ts

@@ -10,6 +10,7 @@ const helpText = `
 Options
   --source-maps Enable source maps for built bundles (increases size of bundle)
   --auto-updates / --no-auto-updates Enable/disable auto updates of studio versions
+  --schema-path / path to schema folder if custom schema folder is used
   --no-minify Skip minifying built JavaScript (speeds up build, increases size of bundle)
   --no-build Don't build the studio prior to deploy, instead deploying the version currently in \`dist/\`
   -y, --yes Unattended mode, answers "yes" to any "yes/no" prompt and otherwise uses defaults

package/src/_internal/cli/commands/index.ts

@@ -47,7 +47,9 @@ import migrationGroup from './migration/migrationGroup'
 import runMigrationCommand from './migration/runMigrationCommand'
 import previewCommand from './preview/previewCommand'
 import extractSchemaCommand from './schema/extractSchemaCommand'
+import fetchSchemaCommand from './schema/fetchSchemaCommand'
 import schemaGroup from './schema/schemaGroup'
+import storeSchemaCommand from './schema/storeSchemaCommand'
 import validateSchemaCommand from './schema/validateSchemaCommand'
 import startCommand from './start/startCommand'
 import inviteUserCommand from './users/inviteUserCommand'
@@ -105,6 +107,8 @@ const commands: (CliCommandDefinition | CliCommandGroupDefinition)[] = [
   validateSchemaCommand,
   extractSchemaCommand,
   previewCommand,
+  fetchSchemaCommand,
+  storeSchemaCommand,
   execCommand,
   manifestGroup,
   extractManifestCommand,

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

@@ -0,0 +1,31 @@
+import {type CliCommandArguments, type CliCommandDefinition} from '@sanity/cli'
+
+import {type FetchSchemaFlags} from '../../actions/schema/fetchSchemaAction'
+
+const description = 'Extracts a JSON representation of a Sanity schema within a Studio context.'
+
+const helpText = `
+**Note**: This command is experimental and subject to change.
+
+Options
+  --id id of the schema to fetch
+
+Examples
+  # Fetch the stored schema for the workspace 'default' in the dataset 'sanity-test'
+  sanity schema fetch --id sanity.workspace.schema.default
+`
+
+const fetchSchemaCommand = {
+  name: 'fetch',
+  group: 'schema',
+  signature: '',
+  description,
+  helpText,
+  action: async (args, context) => {
+    const mod = await import('../../actions/schema/fetchSchemaAction')
+
+    return mod.default(args as unknown as CliCommandArguments<FetchSchemaFlags>, context)
+  },
+} satisfies CliCommandDefinition
+
+export default fetchSchemaCommand

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

@@ -0,0 +1,35 @@
+import {type CliCommandArguments, type CliCommandDefinition} from '@sanity/cli'
+
+import {type StoreManifestSchemasFlags} from '../../actions/schema/storeSchemasAction'
+
+const description = ''
+
+const helpText = `
+**Note**: This command is experimental and subject to change.
+
+Options:
+  --workspace The name of the workspace to fetch the stored schema for
+  --path If you are not using the default static file path, you can specify it here.
+  --custom-id you can specify a custom id for the schema. Useful if you want to store the schema in a different path than the default one.
+
+Examples
+  # if no options are provided all workspace schemas will be stored
+  sanity schema store
+  # Store the schema for only the workspace 'default'
+  sanity schema store --workspace default
+`
+
+const storeSchemaCommand = {
+  name: 'store',
+  group: 'schema',
+  signature: '',
+  description,
+  helpText,
+  action: async (args, context) => {
+    const mod = await import('../../actions/schema/storeSchemasAction')
+
+    return mod.default(args as unknown as CliCommandArguments<StoreManifestSchemasFlags>, context)
+  },
+} satisfies CliCommandDefinition
+
+export default storeSchemaCommand

package/src/_internal/cli/server/renderDocument.tsx

@@ -111,18 +111,6 @@ export function decorateIndexWithAutoGeneratedWarning(template: string): string
   return template.replace(/<head/, `\n<!--\n${autoGeneratedWarning}\n-->\n<head`)
 }
 
-/**
- * Decorates the given HTML template with a script
- * tag that loads the bridge component to communicate
- * with core-ui.
- */
-export function decorateIndexWithBridgeScript(template: string): string {
-  return template.replace(
-    '</head>',
-    '<script src="https://core.sanity-cdn.com/bridge.js" async type="module"></script>\n</head>',
-  )
-}
-
 export function getPossibleDocumentComponentLocations(studioRootPath: string): string[] {
   return [path.join(studioRootPath, '_document.js'), path.join(studioRootPath, '_document.tsx')]
 }

package/src/_internal/cli/server/runtime.ts

@@ -7,7 +7,6 @@ import {debug as serverDebug} from './debug'
 import {getEntryModule} from './getEntryModule'
 import {
   decorateIndexWithAutoGeneratedWarning,
-  decorateIndexWithBridgeScript,
   getPossibleDocumentComponentLocations,
   renderDocument,
 } from './renderDocument'
@@ -45,17 +44,15 @@ export async function writeSanityRuntime({
 
   async function renderAndWriteDocument() {
     debug('Rendering document template')
-    const indexHtml = decorateIndexWithBridgeScript(
-      decorateIndexWithAutoGeneratedWarning(
-        await renderDocument({
-          studioRootPath: cwd,
-          monorepo,
-          props: {
-            entryPath: `/${path.relative(cwd, path.join(runtimeDir, 'app.js'))}`,
-            basePath: basePath || '/',
-          },
-        }),
-      ),
+    const indexHtml = decorateIndexWithAutoGeneratedWarning(
+      await renderDocument({
+        studioRootPath: cwd,
+        monorepo,
+        props: {
+          entryPath: `/${path.relative(cwd, path.join(runtimeDir, 'app.js'))}`,
+          basePath: basePath || '/',
+        },
+      }),
     )
 
     debug('Writing index.html to runtime directory')