@sanity/assist 1.0.0

package/src/types.ts

@@ -0,0 +1,167 @@
+import {SanityDocument, ValidationMarker} from 'sanity'
+import {PortableTextBlock, PortableTextMarkDefinition, PortableTextSpan} from '@portabletext/types'
+
+//id prefixes
+export const assistDocumentIdPrefix = 'sanity.assist.schemaType.'
+export const assistDocumentStatusIdPrefix = 'sanity.assist.status.'
+export const assistSchemaIdPrefix = 'sanity.assist.schema.'
+
+// type names
+export const assistDocumentTypeName = 'sanity.assist.schemaType.annotations' as const
+export const assistFieldTypeName = 'sanity.assist.schemaType.field' as const
+export const instructionTypeName = 'sanity.assist.instruction' as const
+export const promptTypeName = 'sanity.assist.instruction.prompt' as const
+
+export const userInputTypeName = 'sanity.assist.instruction.userInput' as const
+export const instructionContextTypeName = 'sanity.assist.instruction.context' as const
+export const fieldReferenceTypeName = 'sanity.assist.instruction.fieldRef' as const
+
+// user-facing type. Intentionally does not have sanity. prefix
+export const contextDocumentTypeName = 'assist.instruction.context' as const
+
+export const assistTasksStatusTypeName = 'sanity.assist.task.status' as const
+export const instructionTaskTypeName = 'sanity.assist.instructionTask' as const
+export const fieldPresenceTypeName = 'sanity.assist.instructionTask.presence' as const
+
+export const assistSerializedTypeName = 'sanity.assist.serialized.type' as const
+export const assistSerializedFieldTypeName = 'sanity.assist.serialized.field' as const
+
+//url params
+export const inspectParam = 'inspect' as const
+export const fieldPathParam = 'pathKey' as const
+export const instructionParam = 'instruction' as const
+
+// other constants
+export const documentRootKey = '<document>'
+
+export interface SerializedSchemaMember {
+  _type?: typeof assistSerializedFieldTypeName
+  type: string
+  name: string
+  title?: string
+  values?: string[]
+  of?: SerializedSchemaMember[]
+  to?: {type: string}[]
+}
+
+export interface SerializedSchemaType {
+  _type?: typeof assistSerializedTypeName
+  _id?: string
+  type: string
+  title?: string
+  name?: string
+  fields?: SerializedSchemaMember[]
+  of?: {type: string}[]
+  to?: {type: string}[]
+  options?: {
+    imagePromptField?: string
+  }
+}
+
+export interface AssistDocument extends SanityDocument {
+  fields?: AssistField[]
+  instructions?: StudioInstruction[]
+}
+
+export interface StudioAssistDocument {
+  _id: string
+  _type: typeof assistDocumentTypeName
+  fields?: StudioAssistField[]
+
+  // added
+  tasks?: InstructionTask[]
+}
+export interface AssistField {
+  _key: string
+  _type: typeof assistFieldTypeName
+  path?: string
+  instructions?: StudioInstruction[]
+}
+
+export interface StudioAssistField {
+  _key: string
+  path?: string
+  instructions?: StudioInstruction[]
+
+  // added
+  tasks?: InstructionTask[]
+}
+
+export interface FieldRef extends PortableTextMarkDefinition {
+  _type: typeof fieldReferenceTypeName
+  path?: string
+}
+
+export interface ContextBlock {
+  _type: typeof instructionContextTypeName
+  reference?: {
+    _type: 'reference'
+    _ref?: string
+  }
+}
+
+export interface UserInputBlock {
+  _type: typeof userInputTypeName
+  _key: string
+  message?: string
+  description?: string
+}
+
+export type InlinePromptBlock = PortableTextSpan | FieldRef | UserInputBlock | ContextBlock
+export type PromptTextBlock = PortableTextBlock<never, InlinePromptBlock, 'normal', never>
+
+export type PromptBlock = PromptTextBlock | FieldRef | ContextBlock | UserInputBlock
+
+export interface AiPresence {
+  _key: string
+  _type: typeof fieldPresenceTypeName
+  path?: string
+  started?: string
+}
+
+export type TaskEndedReason = 'success' | 'error' | 'aborted' | 'timeout'
+
+export interface InstructionTask {
+  _key: string
+  _type: typeof instructionTaskTypeName
+  instructionKey?: string
+  path?: string
+  started?: string
+  updated?: string
+  ended?: string
+  message?: string
+  reason?: TaskEndedReason
+  presence?: AiPresence[]
+  startedByUserId?: string
+
+  //added by studio
+  // eslint-disable-next-line no-use-before-define
+  instruction?: StudioInstruction
+}
+
+export interface StudioInstruction {
+  _key: string
+  _type: typeof instructionTypeName
+  prompt?: PromptBlock[]
+
+  icon?: string
+  userId?: string
+  title?: string
+  placeholder?: string
+
+  //added after query / synthetic fields
+  tasks?: InstructionTask[]
+  validation?: ValidationMarker[]
+}
+
+export interface AssistTasksStatus {
+  _id: string
+  _type: typeof assistTasksStatusTypeName
+  tasks?: InstructionTask[]
+}
+
+export interface AssistInspectorRouteParams {
+  [inspectParam]?: string
+  [fieldPathParam]?: string
+  [instructionParam]?: string
+}

package/src/useApiClient.ts

@@ -0,0 +1,140 @@
+import {useClient, useCurrentUser, useSchema} from 'sanity'
+import {useCallback, useMemo, useState} from 'react'
+import {serializeSchema} from './schemas/serialize/serializeSchema'
+import {useToast} from '@sanity/ui'
+import {SanityClient} from '@sanity/client'
+
+export interface UserTextInstance {
+  blockKey: string
+  userInput: string
+}
+
+export interface RunInstructionRequest {
+  documentId: string
+  assistDocumentId: string
+  path: string
+  instructionKey: string
+  userId?: string
+  userTexts?: UserTextInstance[]
+}
+
+export interface InstructStatus {
+  enabled: boolean
+  initialized: boolean
+  validToken: boolean
+}
+
+const basePath = '/assist/tasks/instruction'
+const editorialAiFieldActionFeature = 'editorialAiFieldActions'
+
+export function useApiClient(customApiClient?: (defaultClient: SanityClient) => SanityClient) {
+  const client = useClient({apiVersion: '2023-06-05'})
+  return useMemo(
+    () => (customApiClient ? customApiClient(client) : client),
+    [client, customApiClient]
+  )
+}
+
+export function useGetInstructStatus(apiClient: SanityClient) {
+  const [loading, setLoading] = useState(true)
+  const projectClient = useClient({apiVersion: '2023-06-05'})
+
+  const getInstructStatus = useCallback(async () => {
+    setLoading(true)
+
+    const projectId = apiClient.config().projectId
+    try {
+      const features = await projectClient.request<string[]>({
+        method: 'GET',
+        url: `/projects/${projectId}/features`,
+      })
+
+      const enabled = features.some((f) => f === editorialAiFieldActionFeature)
+
+      const status = await apiClient.request<Omit<InstructStatus, 'enabled'>>({
+        method: 'GET',
+        url: `${basePath}/${apiClient.config().dataset}/status?projectId=${projectId}`,
+      })
+
+      return {
+        ...status,
+        enabled,
+      }
+    } finally {
+      setLoading(false)
+    }
+  }, [setLoading, apiClient, projectClient])
+
+  return {
+    loading,
+    getInstructStatus,
+  }
+}
+
+export function useInitInstruct(apiClient: SanityClient) {
+  const [loading, setLoading] = useState(false)
+  const initInstruct = useCallback(() => {
+    setLoading(true)
+    return apiClient
+      .request({
+        method: 'GET',
+        url: `${basePath}/${apiClient.config().dataset}/init?projectId=${
+          apiClient.config().projectId
+        }`,
+      })
+      .finally(() => {
+        setLoading(false)
+      })
+  }, [setLoading, apiClient])
+
+  return {
+    loading,
+    initInstruct,
+  }
+}
+
+export function useRunInstructionApi(apiClient: SanityClient) {
+  const toast = useToast()
+  const [loading, setLoading] = useState(false)
+  const user = useCurrentUser()
+  const schema = useSchema()
+  const types = useMemo(() => serializeSchema(schema, {leanFormat: true}), [schema])
+
+  const runInstruction = useCallback(
+    (request: RunInstructionRequest) => {
+      setLoading(true)
+      return apiClient
+        .request({
+          method: 'POST',
+          url: `${basePath}/${apiClient.config().dataset}?projectId=${
+            apiClient.config().projectId
+          }`,
+          body: {
+            ...request,
+            types,
+            userId: user?.id,
+          },
+        })
+        .catch((e) => {
+          toast.push({
+            status: 'error',
+            title: 'Instruction failed',
+            description: e.message,
+          })
+          throw e
+        })
+        .finally(() => {
+          setLoading(false)
+        })
+    },
+    [apiClient, types, user, toast]
+  )
+
+  return useMemo(
+    () => ({
+      runInstruction,
+      loading,
+    }),
+    [runInstruction, loading]
+  )
+}

package/src/vite.config.ts

@@ -0,0 +1,9 @@
+import {defineConfig} from 'vitest/config'
+
+export default defineConfig({
+  test: {},
+
+  optimizeDeps: {
+    disabled: false,
+  },
+})

package/v2-incompatible.js

@@ -0,0 +1,11 @@
+const {showIncompatiblePluginDialog} = require('@sanity/incompatible-plugin')
+const {name, version, sanityExchangeUrl} = require('./package.json')
+
+export default showIncompatiblePluginDialog({
+  name: name,
+  versions: {
+    v3: version,
+    v2: undefined,
+  },
+  sanityExchangeUrl,
+})