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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sanity",
-  "version": "3.72.2-coreui.15+190795cd18",
+  "version": "3.72.2-server-side-schemas.17+260ef73ae7",
   "description": "Sanity is a real-time content infrastructure with a scalable, hosted backend featuring a Graph Oriented Query Language (GROQ), asset pipelines and fast edge caches",
   "keywords": [
     "sanity",
@@ -160,11 +160,11 @@
     "@rexxars/react-json-inspector": "^9.0.1",
     "@sanity/asset-utils": "^2.0.6",
     "@sanity/bifur-client": "^0.4.1",
-    "@sanity/cli": "3.72.2-coreui.15+190795cd18",
+    "@sanity/cli": "3.72.2-server-side-schemas.17+260ef73ae7",
     "@sanity/client": "^6.27.2",
     "@sanity/color": "^3.0.0",
     "@sanity/comlink": "^3.0.1",
-    "@sanity/diff": "3.72.2-coreui.15+190795cd18",
+    "@sanity/diff": "3.72.2-server-side-schemas.17+260ef73ae7",
     "@sanity/diff-match-patch": "^3.1.1",
     "@sanity/eventsource": "^5.0.0",
     "@sanity/export": "^3.42.2",
@@ -173,15 +173,15 @@
     "@sanity/import": "^3.37.9",
     "@sanity/insert-menu": "1.0.20",
     "@sanity/logos": "^2.1.13",
-    "@sanity/migrate": "3.72.2-coreui.15+190795cd18",
-    "@sanity/mutator": "3.72.2-coreui.15+190795cd18",
+    "@sanity/migrate": "3.72.2-server-side-schemas.17+260ef73ae7",
+    "@sanity/mutator": "3.72.2-server-side-schemas.17+260ef73ae7",
     "@sanity/presentation-comlink": "^1.0.4",
     "@sanity/preview-url-secret": "^2.1.4",
-    "@sanity/schema": "3.72.2-coreui.15+190795cd18",
+    "@sanity/schema": "3.72.2-server-side-schemas.17+260ef73ae7",
     "@sanity/telemetry": "^0.7.7",
-    "@sanity/types": "3.72.2-coreui.15+190795cd18",
+    "@sanity/types": "3.72.2-server-side-schemas.17+260ef73ae7",
     "@sanity/ui": "^2.11.7",
-    "@sanity/util": "3.72.2-coreui.15+190795cd18",
+    "@sanity/util": "3.72.2-server-side-schemas.17+260ef73ae7",
     "@sanity/uuid": "^3.0.2",
     "@sentry/react": "^8.33.0",
     "@tanstack/react-table": "^8.16.0",
@@ -280,7 +280,7 @@
     "@repo/dev-aliases": "3.72.1",
     "@repo/package.config": "3.72.1",
     "@repo/test-config": "3.72.1",
-    "@sanity/codegen": "3.72.2-coreui.15+190795cd18",
+    "@sanity/codegen": "3.72.2-server-side-schemas.17+260ef73ae7",
     "@sanity/generate-help-url": "^3.0.0",
     "@sanity/pkg-utils": "6.13.4",
     "@sanity/tsdoc": "1.0.169",
@@ -324,5 +324,5 @@
   "engines": {
     "node": ">=18"
   },
-  "gitHead": "190795cd18175908cb9ce6412209ed707ab27a41"
+  "gitHead": "260ef73ae74e1382911170da3f285ef90607faa5"
 }

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 '../manifest/storeManifestSchemasAction'
 import {
   checkDir,
   createDeployment,
@@ -20,7 +21,8 @@ import {
 } from './helpers'
 
 export interface DeployStudioActionFlags extends BuildSanityStudioCommandFlags {
-  build?: boolean
+  'schema-path'?: string
+  'build'?: boolean
 }
 
 export default async function deployStudioAction(
@@ -113,7 +115,7 @@ export default async function deployStudioAction(
       return
     }
 
-    await extractManifestSafe(
+    const extractManifestError = await extractManifestSafe(
       {
         ...buildArgs,
         extOptions: {},
@@ -121,6 +123,16 @@ export default async function deployStudioAction(
       },
       context,
     )
+
+    const storeManifestSchemasArgs = {
+      ...args,
+      extOptions: {
+        'schema-path': flags['schema-path'],
+      },
+      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/manifest/storeManifestSchemasAction.ts

@@ -0,0 +1,88 @@
+import {readFileSync} from 'node:fs'
+import path from 'node:path'
+
+import {type CliCommandArguments, type CliCommandContext} from '@sanity/cli'
+
+import {
+  type CreateManifest,
+  type ManifestSchemaType,
+  type ManifestWorkspaceFile,
+} from '../../../manifest/manifestTypes'
+
+export interface StoreManifestSchemasFlags {
+  'schema-path'?: string
+  'workspace-name'?: string
+}
+
+export async function storeManifestSchemas(
+  args: CliCommandArguments<StoreManifestSchemasFlags>,
+  context: CliCommandContext,
+): Promise<void> {
+  const flags = args.extOptions
+  const schemaPath = flags['schema-path']
+  const workspaceName = flags['workspace-name']
+  const {output, workDir, apiClient} = context
+
+  try {
+    const manifestPath = path.resolve(
+      process.cwd(),
+      schemaPath || path.join(workDir, 'dist/static'),
+    )
+    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 = `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/actions/schema/fetchSchemaAction.ts

@@ -0,0 +1,36 @@
+import {type CliCommandArguments, type CliCommandContext} from '@sanity/cli'
+
+import {type ManifestSchemaType} from '../../../manifest/manifestTypes'
+
+export interface FetchSchemaFlags {
+  'schema-id': string
+  'dataset': string
+}
+
+export default async function fetchSchemaAction(
+  args: CliCommandArguments<FetchSchemaFlags>,
+  context: CliCommandContext,
+): Promise<void> {
+  const {apiClient, output} = context
+  const flags = args.extOptions
+  const schemaId = flags['schema-id']
+  const dataset = flags.dataset
+  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 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/storeSchemaAction.ts

@@ -0,0 +1,17 @@
+import {type CliCommandArguments, type CliCommandContext} from '@sanity/cli'
+
+import {
+  storeManifestSchemas,
+  type StoreManifestSchemasFlags,
+} from '../manifest/storeManifestSchemasAction'
+
+export interface StoreSchemaFlags extends StoreManifestSchemasFlags {
+  'workspace-name': string
+}
+
+export default async function storeSchemaAction(
+  args: CliCommandArguments<StoreSchemaFlags>,
+  context: CliCommandContext,
+): Promise<void> {
+  storeManifestSchemas(args, context)
+}

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,32 @@
+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
+  --workspace-name The name of the workspace to fetch the stored schema for
+  --dataset The dataset to fetch the schema from
+
+Examples
+  # Fetch the stored schema for the workspace 'default' in the dataset 'sanity-test'
+  sanity schema fetch --workspaceName default --dataset sanity-test
+`
+
+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,33 @@
+import {type CliCommandArguments, type CliCommandDefinition} from '@sanity/cli'
+
+import {type StoreSchemaFlags} from '../../actions/schema/storeSchemaAction'
+
+const description = ''
+
+const helpText = `
+**Note**: This command is experimental and subject to change.
+
+Required options:
+  --workspace-name The name of the workspace to fetch the stored schema for
+Optional options:
+  --schema-path If you want to store the schema in a different path than the default one, you can specify it here.
+
+Examples
+  # Store the schema for the workspace 'default'
+  sanity schema store --workspace-name default
+`
+
+const storeSchemaCommand = {
+  name: 'store',
+  group: 'schema',
+  signature: '',
+  description,
+  helpText,
+  action: async (args, context) => {
+    const mod = await import('../../actions/schema/storeSchemaAction')
+
+    return mod.default(args as unknown as CliCommandArguments<StoreSchemaFlags>, 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')