@sanity/assist 1.0.0

package/src/schemas/serialize/serializeSchema.test.ts

@@ -0,0 +1,382 @@
+import {describe, expect, test} from 'vitest'
+import {Schema} from '@sanity/schema'
+import {serializeSchema} from './serializeSchema'
+import {defineArrayMember, defineField, defineType} from 'sanity'
+import {AssistOptions} from '../typeDefExtensions'
+
+const mockStudioTypes = [
+  defineField({
+    type: 'object',
+    name: 'slug',
+    fields: [{type: 'string', name: '_ref'}],
+  }),
+  defineField({
+    type: 'object',
+    name: 'sanity.imageHotspot',
+    fields: [{type: 'string', name: 'whatever'}],
+  }),
+  defineField({
+    type: 'object',
+    name: 'sanity.imageCrop',
+    fields: [{type: 'string', name: 'whatever'}],
+  }),
+]
+
+describe('serializeSchema', () => {
+  test('should serialize simple schema', () => {
+    const schema = Schema.compile({
+      name: 'test',
+      types: [
+        {
+          type: 'document',
+          name: 'article',
+          fields: [
+            {type: 'string', name: 'title'},
+            {type: 'some', name: 'some'},
+            {
+              name: 'array',
+              of: [{type: 'some'}],
+              type: 'array',
+            },
+          ],
+        },
+        {
+          type: 'object',
+          name: 'some',
+          fields: [{type: 'string', name: 'title'}],
+        },
+      ],
+    })
+
+    const serializedTypes = serializeSchema(schema, {leanFormat: true})
+
+    expect(serializedTypes).toEqual([
+      {
+        fields: [
+          {name: 'title', title: 'Title', type: 'string'},
+          {name: 'some', title: 'Some', type: 'some'},
+          {
+            name: 'array',
+            of: [{name: 'some', title: 'Some', type: 'some'}],
+            title: 'Array',
+            type: 'array',
+          },
+        ],
+        name: 'article',
+        title: 'Article',
+        type: 'document',
+      },
+      {
+        fields: [{name: 'title', title: 'Title', type: 'string'}],
+        name: 'some',
+        title: 'Some',
+        type: 'object',
+      },
+    ])
+  })
+
+  test('should not serialize excluded fields or types or types with every member excluded', () => {
+    const options: AssistOptions = {aiWritingAssistance: {exclude: true}}
+
+    const schema = Schema.compile({
+      name: 'test',
+      types: [
+        {
+          type: 'document',
+          name: 'allFieldsExcluded',
+          fields: [
+            defineField({type: 'string', name: 'title', options}),
+            defineField({
+              type: 'object',
+              name: 'excludedObject',
+              // all fields excluded should exclude field
+              fields: [{type: 'string', name: 'title', options}],
+              options: {aiWritingAssistance: {exclude: true}},
+            }),
+            defineField({
+              type: 'array',
+              name: 'excludedArray',
+              // all items excluded should exclude field
+              of: [{type: 'object', name: 'remove', options}, {type: 'excluded'}],
+              options: {aiWritingAssistance: {exclude: true}},
+            }),
+            //image without extra fields should be excluded
+            defineField({type: 'image', name: 'image'}),
+            // unsupported types
+            defineField({type: 'number', name: 'number'}),
+            defineField({type: 'slug', name: 'slug'}),
+            defineField({type: 'url', name: 'url'}),
+            defineField({type: 'datetime', name: 'datetime'}),
+            defineField({type: 'file', name: 'file'}),
+            defineField({type: 'reference', name: 'reference', to: [{type: 'excluded'}]}),
+            defineField({
+              type: 'crossDatasetReference',
+              name: 'crossDatasetReference',
+              to: [{type: 'excluded'}],
+              dataset: 'x',
+              projectId: 'y',
+            }),
+          ],
+        },
+        defineField({
+          type: 'object',
+          name: 'excluded',
+          fields: [{type: 'string', name: 'title', options}],
+          options: {aiWritingAssistance: {exclude: true}},
+        }),
+        ...mockStudioTypes,
+      ],
+    })
+
+    const serializedTypes = serializeSchema(schema, {leanFormat: true})
+
+    //everything excluded directly or indirectly
+    expect(serializedTypes).toEqual([])
+  })
+
+  test('should serialize opt-in inline object using custom typeName', () => {
+    const schema = Schema.compile({
+      name: 'test',
+      types: [
+        {
+          type: 'document',
+          name: 'article',
+          fields: [
+            {type: 'string', name: 'title'},
+            defineField({
+              type: 'object',
+              name: 'some',
+              fields: [{type: 'string', name: 'title'}],
+            }),
+            defineField({
+              type: 'array',
+              name: 'array',
+              of: [
+                defineArrayMember({
+                  type: 'object',
+                  name: 'inlineArrayMember',
+                  fields: [{type: 'string', name: 'title'}],
+                }),
+              ],
+            }),
+          ],
+        },
+      ],
+    })
+
+    const serializedTypes = serializeSchema(schema, {leanFormat: true})
+
+    expect(serializedTypes).toEqual([
+      {
+        fields: [
+          {name: 'title', title: 'Title', type: 'string'},
+          {
+            name: 'some',
+            title: 'Some',
+            type: 'object',
+            fields: [{name: 'title', title: 'Title', type: 'string'}],
+          },
+          {
+            name: 'array',
+            of: [
+              {
+                type: 'object',
+                name: 'inlineArrayMember',
+                title: 'Inline Array Member',
+                fields: [{name: 'title', title: 'Title', type: 'string'}],
+              },
+            ],
+            title: 'Array',
+            type: 'array',
+          },
+        ],
+        name: 'article',
+        title: 'Article',
+        type: 'document',
+      },
+    ])
+  })
+
+  test('should serialize inline object', () => {
+    const schema = Schema.compile({
+      name: 'test',
+      types: [
+        {
+          type: 'document',
+          name: 'article',
+          fields: [
+            {type: 'string', name: 'title'},
+            defineField({
+              type: 'object',
+              name: 'someObject',
+              fields: [{type: 'string', name: 'title'}],
+            }),
+            defineField({
+              type: 'file',
+              name: 'someFile',
+              fields: [{type: 'string', name: 'title'}],
+            }),
+            defineField({
+              type: 'image',
+              name: 'someImage',
+              fields: [{type: 'string', name: 'title'}],
+            }),
+          ],
+        },
+        ...mockStudioTypes,
+      ],
+    })
+
+    const serializedTypes = serializeSchema(schema, {leanFormat: true})
+
+    expect(serializedTypes).toEqual([
+      {
+        fields: [
+          {name: 'title', title: 'Title', type: 'string'},
+          {
+            name: 'someObject',
+            title: 'Some Object',
+            type: 'object',
+            fields: [{name: 'title', title: 'Title', type: 'string'}],
+          },
+          {
+            name: 'someImage',
+            title: 'Some Image',
+            type: 'image',
+            fields: [{name: 'title', title: 'Title', type: 'string'}],
+          },
+        ],
+        name: 'article',
+        title: 'Article',
+        type: 'document',
+      },
+    ])
+  })
+
+  test('should serialize inline, anonymous array object type', () => {
+    const schema = Schema.compile({
+      name: 'test',
+      types: [
+        {
+          type: 'document',
+          name: 'article',
+          fields: [
+            {type: 'string', name: 'title'},
+            defineField({
+              type: 'array',
+              name: 'array',
+              of: [
+                defineArrayMember({
+                  type: 'object',
+                  title: 'Nameless item',
+                  fields: [{type: 'string', name: 'title'}],
+                }),
+              ],
+            }),
+          ],
+        },
+        {
+          fields: [{name: 'title', title: 'Title', type: 'string'}],
+          name: 'item',
+          title: 'Item',
+          type: 'object',
+        },
+      ],
+    })
+
+    const serializedTypes = serializeSchema(schema, {leanFormat: true})
+
+    expect(serializedTypes).toEqual([
+      {
+        fields: [
+          {name: 'title', title: 'Title', type: 'string'},
+          {
+            name: 'array',
+            of: [
+              {
+                name: 'object',
+                title: 'Nameless item',
+                type: 'object',
+                fields: [{name: 'title', title: 'Title', type: 'string'}],
+              },
+            ],
+            title: 'Array',
+            type: 'array',
+          },
+        ],
+        name: 'article',
+        title: 'Article',
+        type: 'document',
+      },
+      {
+        fields: [{name: 'title', title: 'Title', type: 'string'}],
+        name: 'item',
+        title: 'Item',
+        type: 'object',
+      },
+    ])
+  })
+
+  test('should serialize nested inline objects', () => {
+    const schema = Schema.compile({
+      name: 'test',
+      types: [
+        {
+          type: 'document',
+          name: 'article',
+          fields: [
+            defineField({
+              type: 'object',
+              name: 'outer',
+              fields: [
+                defineField({
+                  type: 'object',
+                  name: 'inner',
+                  fields: [{type: 'string', name: 'title'}],
+                }),
+              ],
+            }),
+          ],
+        },
+      ],
+    })
+
+    const serializedTypes = serializeSchema(schema, {leanFormat: true})
+
+    expect(serializedTypes).toEqual([
+      {
+        name: 'article',
+        title: 'Article',
+        type: 'document',
+        fields: [
+          {
+            fields: [
+              {
+                type: 'object',
+                name: 'inner',
+                title: 'Inner',
+                fields: [{name: 'title', title: 'Title', type: 'string'}],
+              },
+            ],
+            type: 'object',
+            name: 'outer',
+            title: 'Outer',
+          },
+        ],
+      },
+    ])
+  })
+
+  test('should serialize list values', () => {
+    const schema = Schema.compile({
+      name: 'test',
+      types: [defineType({type: 'string', name: 'list', options: {list: ['a', 'b']}})],
+    })
+
+    const serializedTypes = serializeSchema(schema, {leanFormat: true})
+
+    expect(serializedTypes).toEqual([
+      {name: 'list', title: 'String', type: 'string', values: ['a', 'b']},
+    ])
+  })
+})

package/src/schemas/serialize/serializeSchema.ts

@@ -0,0 +1,162 @@
+import {
+  ArraySchemaType,
+  ImageOptions,
+  ObjectSchemaType,
+  ReferenceSchemaType,
+  Schema,
+  SchemaType,
+  typed,
+} from 'sanity'
+import {
+  assistSerializedFieldTypeName,
+  assistSerializedTypeName,
+  SerializedSchemaMember,
+  SerializedSchemaType,
+  assistSchemaIdPrefix,
+} from '../../types'
+import {hiddenTypes} from './schemaUtils'
+import {isAssistSupported} from '../../helpers/assistSupported'
+
+interface Options {
+  leanFormat?: boolean
+}
+
+const inlineTypes = ['document', 'object', 'image', 'file']
+
+export function serializeSchema(schema: Schema, options?: Options): SerializedSchemaType[] {
+  const list = schema
+    .getTypeNames()
+    .filter((t) => !(hiddenTypes.includes(t) || t.startsWith('sanity.')))
+    .map((t) => schema.get(t))
+    .filter((t): t is SchemaType => !!t)
+    .map((t) => getSchemaStub(t, schema, options))
+    .filter((t) => {
+      if ('to' in t && t.to && !t.to.length) {
+        return false
+      }
+      if ('of' in t && t.of && !t.of.length) {
+        return false
+      }
+      if ('fields' in t && t.fields && !t.fields.length) {
+        return false
+      }
+      return true
+    })
+  list.sort((a, b) => (a?.name ?? '').localeCompare(b?.name ?? ''))
+  return list
+}
+
+function getSchemaStub(
+  schemaType: SchemaType,
+  schema: Schema,
+  options?: Options
+): SerializedSchemaType {
+  if (!schemaType.type?.name) {
+    console.error('Missing type name', schemaType.type)
+    throw new Error('Type is missing name!')
+  }
+  const baseSchema: SerializedSchemaType = {
+    // we dont need type or id when we send using POST, so leave these out to save bandwidth
+    ...(options?.leanFormat
+      ? {}
+      : {_id: `${assistSchemaIdPrefix}${schemaType.name}`, _type: assistSerializedTypeName}),
+    name: schemaType.name,
+    title: schemaType.title,
+    type: schemaType.type.name,
+    ...getBaseFields(schema, schemaType, schemaType.type.name, options),
+  }
+
+  return removeUndef(baseSchema)
+}
+
+function getBaseFields(
+  schema: Schema,
+  type: SchemaType,
+  typeName: string,
+  options: Options | undefined
+) {
+  const imagePromptField = (type.options as ImageOptions)?.imagePromptField
+  return removeUndef({
+    options: imagePromptField
+      ? {
+          imagePromptField: imagePromptField,
+        }
+      : undefined,
+    values:
+      type.jsonType === 'string' && type?.options?.list
+        ? type?.options?.list.map((v) => (typeof v === 'string' ? v : v.value ?? `${v.title}`))
+        : undefined,
+    of: 'of' in type && typeName === 'array' ? arrayOf(type, schema, options) : undefined,
+    to:
+      'to' in type && typeName === 'reference'
+        ? refToTypeNames(type as ReferenceSchemaType)
+        : undefined,
+    fields:
+      'fields' in type && inlineTypes.includes(typeName)
+        ? serializeFields(schema, type, options)
+        : undefined,
+  })
+}
+
+function serializeFields(
+  schema: Schema,
+  schemaType: ObjectSchemaType,
+  options: Options | undefined
+) {
+  return schemaType.fields
+    .filter((f) => !['sanity.imageHotspot', 'sanity.imageCrop'].includes(f.type?.name ?? ''))
+    .filter((f) => isAssistSupported(f.type))
+    .map((field) => serializeMember(schema, field.type, field.name, options))
+}
+
+function serializeMember(
+  schema: Schema,
+  type: SchemaType,
+  name: string,
+  options: Options | undefined
+): SerializedSchemaMember {
+  const typeNameExists = !!schema.get(type?.name)
+  const typeName = typeNameExists ? type.name : type.type?.name ?? ''
+  return removeUndef({
+    ...(options?.leanFormat ? {} : {_type: assistSerializedFieldTypeName}),
+    name: name,
+    type: typeName,
+    title: type.title,
+    values:
+      type.jsonType === 'string' && type?.options?.list
+        ? type?.options?.list.map((v) => (typeof v === 'string' ? v : v.value ?? `${v.title}`))
+        : undefined,
+    of: 'of' in type && type.name === 'array' ? arrayOf(type, schema, options) : undefined,
+    to:
+      'to' in type && type.name === 'reference'
+        ? refToTypeNames(type as ReferenceSchemaType)
+        : undefined,
+    fields:
+      'fields' in type && inlineTypes.includes(typeName)
+        ? serializeFields(schema, type, options)
+        : undefined,
+  })
+}
+
+function arrayOf(
+  arrayType: ArraySchemaType,
+  schema: Schema,
+  options: Options | undefined
+): SerializedSchemaMember[] {
+  return arrayType.of
+    .filter((type) => isAssistSupported(type))
+    .map((t) => {
+      return serializeMember(schema, t, t.name, options)
+    })
+}
+
+function refToTypeNames(type: ReferenceSchemaType) {
+  return type.to.map((t) => ({
+    type: typed<string>(t.name),
+  }))
+}
+
+function removeUndef<T extends Record<string, any>>(obj: T): T {
+  Object.keys(obj).forEach((key) => (obj[key] === undefined ? delete obj[key] : {}))
+  return obj
+}

package/src/schemas/serializedSchemaTypeSchema.ts

@@ -0,0 +1,59 @@
+import {defineField, defineType} from 'sanity'
+import {assistSerializedFieldTypeName, assistSerializedTypeName} from '../types'
+import {CodeIcon, StarIcon} from '@sanity/icons'
+
+export const serializedSchemaField = defineType({
+  type: 'object',
+  name: assistSerializedFieldTypeName,
+  title: 'Field',
+  icon: CodeIcon,
+  fields: [
+    defineField({
+      name: 'name',
+      title: 'Name',
+      type: 'string',
+    }),
+    defineField({
+      name: 'type',
+      title: 'Type',
+      type: 'string',
+    }),
+  ],
+  preview: {
+    select: {
+      title: 'title',
+      subtitle: 'type',
+    },
+    prepare: ({title, subtitle}) => {
+      return {
+        title,
+        subtitle,
+        media: CodeIcon,
+      }
+    },
+  },
+})
+
+export const serializedSchemaType = defineType({
+  name: assistSerializedTypeName,
+  type: 'document',
+  title: 'Meta schema',
+  icon: StarIcon,
+  fields: [
+    defineField({
+      name: 'name',
+      title: 'Name',
+      type: 'string',
+    }),
+    defineField({
+      name: 'type',
+      title: 'Type',
+      type: 'string',
+    }),
+    defineField({
+      name: 'fields',
+      type: 'array',
+      of: [{type: serializedSchemaField.name}],
+    }),
+  ],
+})

package/src/schemas/typeDefExtensions.ts

@@ -0,0 +1,30 @@
+/* eslint-disable no-unused-vars */
+export interface AssistOptions {
+  aiWritingAssistance?: {
+    /** Set to true to disable assistance for this field or type */
+    exclude?: boolean
+  }
+}
+
+declare module 'sanity' {
+  interface ArrayOptions extends AssistOptions {}
+  interface BlockOptions extends AssistOptions {}
+  interface BooleanOptions extends AssistOptions {}
+  interface CrossDatasetReferenceOptions extends AssistOptions {}
+  interface DateOptions extends AssistOptions {}
+  interface DatetimeOptions extends AssistOptions {}
+  interface DocumentOptions extends AssistOptions {}
+  interface FileOptions extends AssistOptions {}
+  interface GeopointOptions extends AssistOptions {}
+  interface ImageOptions extends AssistOptions {
+    imagePromptField?: string
+  }
+  interface NumberOptions extends AssistOptions {}
+  interface ObjectOptions extends AssistOptions {}
+  interface ReferenceBaseOptions extends AssistOptions {}
+  interface SlugOptions extends AssistOptions {}
+  interface StringOptions extends AssistOptions {}
+  interface TextOptions extends AssistOptions {}
+  interface UrlOptions extends AssistOptions {}
+  interface EmailOptions extends AssistOptions {}
+}