@sanity/assist 5.0.4 → 6.0.0

package/src/schemas/serialize/serializeSchema.ts

@@ -1,224 +0,0 @@
-import {
-  ArraySchemaType,
-  ImageOptions,
-  isArraySchemaType,
-  ObjectSchemaType,
-  ReferenceOptions,
-  ReferenceSchemaType,
-  Schema,
-  SchemaType,
-  typed,
-} from 'sanity'
-
-import {isAssistSupported} from '../../helpers/assistSupported'
-import {isType} from '../../helpers/typeUtils'
-import {
-  assistSchemaIdPrefix,
-  assistSerializedFieldTypeName,
-  assistSerializedTypeName,
-  SerializedSchemaMember,
-  SerializedSchemaType,
-} from '../../types'
-import {hiddenTypes} from './schemaUtils'
-
-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)
-    // because a field can override exclude at the type level, we have to also serialize excluded types
-    // so don't do this: .filter((t) => isAssistSupported(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) {
-    // eslint-disable-next-line no-console -- log error
-    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 schemaOptions: SerializedSchemaType['options'] = removeUndef({
-    imagePromptField: (type.options as ImageOptions)?.aiAssist?.imageInstructionField,
-    embeddingsIndex: (type.options as ReferenceOptions)?.aiAssist?.embeddingsIndex,
-  })
-  return removeUndef({
-    options: Object.keys(schemaOptions).length ? schemaOptions : undefined,
-    values: Array.isArray(type?.options?.list)
-      ? type?.options?.list.map((v: string | {value: string; title: string}) =>
-          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,
-    annotations:
-      typeName === 'block' && 'fields' in type
-        ? serializeAnnotations(type, schema, options)
-        : undefined,
-    inlineOf:
-      typeName === 'block' && 'fields' in type
-        ? serializeInlineOf(type, schema, options)
-        : undefined,
-    hidden:
-      typeof type.hidden === 'function' ? ('function' as const) : type.hidden ? true : undefined,
-    readOnly:
-      typeof type.readOnly === 'function'
-        ? ('function' as const)
-        : type.readOnly
-          ? true
-          : undefined,
-  })
-}
-
-function serializeFields(
-  schema: Schema,
-  schemaType: ObjectSchemaType,
-  options: Options | undefined,
-) {
-  const fields = schemaType.fieldsets
-    ? schemaType.fieldsets.flatMap((fs) =>
-        fs.single
-          ? fs.field
-          : fs.fields.map((f) => ({
-              ...f,
-              type: {
-                ...f.type,
-                // if fieldset is (conditionally) hidden, the field must be considered the same way
-                // ie, if the field does not show up in conditionalMembers, it is hidden
-                // regardless of weather or not it is the field function or the fieldset function that hides it
-                hidden:
-                  typeof fs.hidden === 'function' ? fs.hidden : fs.hidden ? true : f.type.hidden,
-              },
-            })),
-      )
-    : schemaType.fields
-
-  return 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,
-    ...getBaseFields(schema, type, typeName, options),
-  })
-}
-
-function serializeInlineOf(
-  blockSchemaType: ObjectSchemaType,
-  schema: Schema,
-  options: Options | undefined,
-): SerializedSchemaMember[] | undefined {
-  const childrenField = blockSchemaType.fields.find((f) => f.name === 'children')
-  const childrenType = childrenField?.type
-  if (!childrenType || !isArraySchemaType(childrenType)) {
-    return undefined
-  }
-  return arrayOf(
-    {
-      ...childrenType,
-      of: childrenType.of.filter((t) => !isType(t, 'span')),
-    },
-    schema,
-    options,
-  )
-}
-
-function serializeAnnotations(
-  blockSchemaType: ObjectSchemaType,
-  schema: Schema,
-  options: Options | undefined,
-): SerializedSchemaMember[] | undefined {
-  const markDefs = blockSchemaType.fields.find((f) => f.name === 'markDefs')
-  const marksType = markDefs?.type
-  if (!marksType || !isArraySchemaType(marksType)) {
-    return undefined
-  }
-  return arrayOf(marksType, schema, options)
-}
-
-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

@@ -1,60 +0,0 @@
-import {CodeIcon, StarIcon} from '@sanity/icons'
-import {defineField, defineType} from 'sanity'
-
-import {assistSerializedFieldTypeName, assistSerializedTypeName} from '../types'
-
-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

@@ -1,127 +0,0 @@
-import 'sanity'
-/* eslint-disable no-unused-vars */
-export interface AssistOptions {
-  aiAssist?: {
-    /** Set to true to disable assistance for this field or type */
-    exclude?: boolean
-
-    /**
-     * Set to true to add translation field-action to the field.
-     * Only has an effect in document types configured for document or field level translations.
-     */
-    translateAction?: 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 {
-    aiAssist?: AssistOptions['aiAssist'] & {
-      /**
-       * When set, an image will be created whenever the `imageInstructionField` is written to by
-       * an AI Assist instruction.
-       *
-       * The value output by AI Assist will be use as an image prompt for an generative image AI.
-       *
-       * This means that instructions directly for the field or instructions that visit the field when running,
-       * will result in the image being changed.
-       *
-       * `imageInstructionField` must be a child-path relative to the image field, ie:
-       * * field
-       * * path.to.field
-       *
-       * ### Example
-       * ```ts
-       * defineType({
-       *   type: 'image',
-       *   name: 'articleImage',
-       *   fields: [
-       *     defineField({
-       *       type: 'text',
-       *       name: 'imagePrompt',
-       *       title: 'Image prompt',
-       *       rows: 2,
-       *     }),
-       *   ],
-       *   options: {
-       *      aiAssist: {
-       *        imageInstructionField: 'imagePrompt',
-       *     }
-       *   },
-       * })
-       * ```
-       */
-      imageInstructionField?: string
-
-      /**
-       * When set, an image description will be automatically created for the image.
-       *
-       * `imageDescriptionField` must be a child-path relative to the image field, ie:
-       * * field
-       * * path.to.field
-       *
-       * Whenever the image asset for the field is changed in the Studio,
-       * an image description is generated and set into the `imageDescriptionField`.
-       *
-       * ### Example
-       * ```ts
-       * defineType({
-       *   type: 'image',
-       *   name: 'articleImage',
-       *   fields: [
-       *     defineField({
-       *       type: 'string',
-       *       name: 'altText',
-       *       title: 'Alt text',
-       *     }),
-       *   ],
-       *   options: {
-       *      aiAssist: {
-       *        imageDescriptionField: 'altText',
-       *     }
-       *   },
-       * })
-       * ```
-       */
-      imageDescriptionField?:
-        | string
-        | {
-            path: string
-            /**
-             * When updateOnImageChange is true (or undefined), whenever the
-             * image asset changes, imageDescriptionField will be regenerated.
-             *
-             * default:  true
-             * */
-            updateOnImageChange?: boolean
-          }
-    }
-  }
-  interface NumberOptions extends AssistOptions {}
-  interface ObjectOptions extends AssistOptions {}
-  interface ReferenceBaseOptions {
-    aiAssist?: {
-      /** Set to true to disable assistance for this field or type */
-      exclude?: boolean
-
-      /**
-       * When set, the reference field will allow instructions to be added to it.
-       * Should be the name of the embeddings-index where assist will look for contextually relevant documents
-       * */
-      embeddingsIndex?: string
-    }
-  }
-  interface SlugOptions extends AssistOptions {}
-  interface StringOptions extends AssistOptions {}
-  interface TextOptions extends AssistOptions {}
-  interface UrlOptions extends AssistOptions {}
-  interface EmailOptions extends AssistOptions {}
-}