sanity-plugin-workflow 1.0.6 → 2.0.0

package/src/hooks/useWorkflowDocuments.tsx

@@ -1,167 +0,0 @@
-import {DraggableLocation} from '@hello-pangea/dnd'
-import {useToast} from '@sanity/ui'
-import groq from 'groq'
-import React from 'react'
-import {useClient} from 'sanity'
-import {useListeningQuery} from 'sanity-plugin-utils'
-
-import {API_VERSION} from '../constants'
-import {SanityDocumentWithMetadata, State} from '../types'
-
-const QUERY = groq`*[_type == "workflow.metadata"]|order(orderRank){
-  "_metadata": {
-    _rev,
-    assignees,
-    documentId,
-    state,
-    orderRank,
-    "draftDocumentId": "drafts." + documentId,
-  }
-}{
-  ...,
-  ...(
-    *[_id == ^._metadata.documentId || _id == ^._metadata.draftDocumentId]|order(_updatedAt)[0]{ 
-      _id, 
-      _type, 
-      _rev, 
-      _updatedAt 
-    }
-  )
-}`
-
-type WorkflowDocuments = {
-  workflowData: {
-    data: SanityDocumentWithMetadata[]
-    loading: boolean
-    error: boolean | unknown | ProgressEvent
-  }
-  operations: {
-    move: (
-      draggedId: string,
-      destination: DraggableLocation,
-      states: State[],
-      newOrder: string
-    ) => void
-  }
-}
-
-export function useWorkflowDocuments(schemaTypes: string[]): WorkflowDocuments {
-  const toast = useToast()
-  const client = useClient({apiVersion: API_VERSION})
-
-  // Get and listen to changes on documents + workflow metadata documents
-  const {data, loading, error} = useListeningQuery<
-    SanityDocumentWithMetadata[]
-  >(QUERY, {
-    params: {schemaTypes},
-    initialValue: [],
-  })
-
-  const [localDocuments, setLocalDocuments] = React.useState<
-    SanityDocumentWithMetadata[]
-  >([])
-
-  React.useEffect(() => {
-    if (data) {
-      setLocalDocuments(data)
-    }
-  }, [data])
-
-  const move = React.useCallback(
-    async (
-      draggedId: string,
-      destination: DraggableLocation,
-      states: State[],
-      newOrder: string
-    ) => {
-      // Optimistic update
-      const currentLocalData = localDocuments
-      const newLocalDocuments = localDocuments.map((item) => {
-        if (item?._metadata?.documentId === draggedId) {
-          return {
-            ...item,
-            _metadata: {
-              ...item._metadata,
-              state: destination.droppableId,
-              orderRank: newOrder,
-              // This value won't be written to the document
-              // It's done so that un/publish operations don't happen twice
-              // Because a moved document's card will update once optimistically
-              // and then again when the document is updated
-              optimistic: true,
-            },
-          }
-        }
-
-        return item
-      })
-
-      setLocalDocuments(newLocalDocuments)
-
-      // Now client-side update
-      const newStateId = destination.droppableId
-      const newState = states.find((s) => s.id === newStateId)
-      const document = localDocuments.find(
-        (d) => d?._metadata?.documentId === draggedId
-      )
-
-      if (!newState?.id) {
-        toast.push({
-          title: `Could not find target state ${newStateId}`,
-          status: 'error',
-        })
-        return null
-      }
-
-      if (!document) {
-        toast.push({
-          title: `Could not find dragged document in data`,
-          status: 'error',
-        })
-        return null
-      }
-
-      // We need to know if it's a draft or not
-      const {_id, _type} = document
-
-      // Metadata + useDocumentOperation always uses Published id
-      const {documentId, _rev} = document._metadata || {}
-
-      await client
-        .patch(`workflow-metadata.${documentId}`)
-        .ifRevisionId(_rev)
-        .set({state: newStateId, orderRank: newOrder})
-        .commit()
-        .then((res) => {
-          toast.push({
-            title:
-              newState.id === document._metadata.state
-                ? `Reordered in "${newState?.title ?? newStateId}"`
-                : `Moved to "${newState?.title ?? newStateId}"`,
-            status: 'success',
-          })
-          return res
-        })
-        .catch((err) => {
-          // Revert optimistic update
-          setLocalDocuments(currentLocalData)
-
-          toast.push({
-            title: `Failed to move to "${newState?.title ?? newStateId}"`,
-            description: err.message,
-            status: 'error',
-          })
-          return null
-        })
-
-      // Send back to the workflow board so a document update can happen
-      return {_id, _type, documentId, state: newState as State}
-    },
-    [client, toast, localDocuments]
-  )
-
-  return {
-    workflowData: {data: localDocuments, loading, error},
-    operations: {move},
-  }
-}

package/src/hooks/useWorkflowMetadata.tsx

@@ -1,49 +0,0 @@
-import {useMemo} from 'react'
-import {useListeningQuery} from 'sanity-plugin-utils'
-
-import {API_VERSION} from '../constants'
-import {KeyedMetadata, Metadata} from '../types'
-
-/**
- * Takes the published ID of documents and return the metadata for those documents.
- *
- * @param ids Source document published IDs
- */
-export function useWorkflowMetadata(ids: string[]): {
-  data: KeyedMetadata
-  loading: boolean
-  error: boolean | unknown | ProgressEvent
-} {
-  const {
-    data: rawData,
-    loading,
-    error,
-  } = useListeningQuery<Metadata[]>(
-    `*[_type == "workflow.metadata" && documentId in $ids]{
-      _id,
-      _type,
-      _rev,
-      assignees,
-      documentId,
-      state,
-      orderRank
-    }`,
-    {
-      params: {ids},
-      options: {apiVersion: API_VERSION},
-    }
-  )
-
-  const keyedMetadata = useMemo(() => {
-    if (!rawData || rawData.length === 0) return {}
-
-    return rawData.reduce<KeyedMetadata>((acc, cur) => {
-      return {
-        ...acc,
-        [cur.documentId]: cur,
-      }
-    }, {})
-  }, [rawData])
-
-  return {data: keyedMetadata, loading, error}
-}

package/src/index.ts

@@ -1,97 +0,0 @@
-import {definePlugin, DocumentActionProps, isObjectInputProps} from 'sanity'
-
-import {AssignWorkflow} from './actions/AssignWorkflow'
-import {BeginWorkflow} from './actions/BeginWorkflow'
-import {CompleteWorkflow} from './actions/CompleteWorkflow'
-import {UpdateWorkflow} from './actions/UpdateWorkflow'
-import {AssigneesBadge} from './badges/AssigneesBadge'
-import {StateBadge} from './badges/StateBadge'
-import {WorkflowProvider} from './components/WorkflowContext'
-import WorkflowSignal from './components/WorkflowSignal'
-import {DEFAULT_CONFIG} from './constants'
-import metadata from './schema/workflow/workflow.metadata'
-import {workflowTool} from './tools'
-import {WorkflowConfig} from './types'
-
-export const workflow = definePlugin<WorkflowConfig>(
-  (config = DEFAULT_CONFIG) => {
-    const {schemaTypes, states} = {...DEFAULT_CONFIG, ...config}
-
-    if (!states?.length) {
-      throw new Error(`Workflow plugin: Missing "states" in config`)
-    }
-
-    if (!schemaTypes?.length) {
-      throw new Error(`Workflow plugin: Missing "schemaTypes" in config`)
-    }
-
-    return {
-      name: 'sanity-plugin-workflow',
-      schema: {
-        types: [metadata(states)],
-      },
-      // TODO: Remove 'workflow.metadata' from list of new document types
-      // ...
-      studio: {
-        components: {
-          layout: (props) =>
-            WorkflowProvider({...props, workflow: {schemaTypes, states}}),
-        },
-      },
-      form: {
-        components: {
-          input: (props) => {
-            if (
-              props.id === `root` &&
-              isObjectInputProps(props) &&
-              schemaTypes.includes(props.schemaType.name)
-            ) {
-              return WorkflowSignal(props)
-            }
-
-            return props.renderDefault(props)
-          },
-        },
-      },
-      document: {
-        actions: (prev, context) => {
-          if (!schemaTypes.includes(context.schemaType)) {
-            return prev
-          }
-
-          return [
-            (props) => BeginWorkflow(props),
-            (props) => AssignWorkflow(props),
-            ...states.map(
-              (state) => (props: DocumentActionProps) =>
-                UpdateWorkflow(props, state)
-            ),
-            (props) => CompleteWorkflow(props),
-            ...prev,
-          ]
-        },
-        badges: (prev, context) => {
-          if (!schemaTypes.includes(context.schemaType)) {
-            return prev
-          }
-
-          const {documentId, currentUser} = context
-
-          if (!documentId) {
-            return prev
-          }
-
-          return [
-            () => StateBadge(documentId),
-            () => AssigneesBadge(documentId, currentUser),
-            ...prev,
-          ]
-        },
-      },
-      tools: [
-        // TODO: These configs could be read from Context
-        workflowTool({schemaTypes, states}),
-      ],
-    }
-  }
-)

package/src/schema/workflow/workflow.metadata.ts

@@ -1,68 +0,0 @@
-import {defineField, defineType} from 'sanity'
-
-import Field from '../../components/DocumentCard/Field'
-import UserAssignmentInput from '../../components/UserAssignmentInput'
-import {API_VERSION} from '../../constants'
-import initialRank from '../../helpers/initialRank'
-import {State} from '../../types'
-
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
-export default (states: State[]) =>
-  defineType({
-    type: 'document',
-    name: 'workflow.metadata',
-    title: 'Workflow metadata',
-    liveEdit: true,
-    fields: [
-      defineField({
-        name: 'state',
-        description: `The current "State" of the document. Field is read only as changing it would not fire the state's "operation" setting. These are fired in the Document Actions and in the custom Tool.`,
-        readOnly: true,
-        type: 'string',
-        options: {
-          list: states.length
-            ? states.map((state) => ({
-                value: state.id,
-                title: state.title,
-              }))
-            : [],
-          layout: 'radio',
-        },
-      }),
-      defineField({
-        name: 'documentId',
-        title: 'Document ID',
-        description:
-          'Used to help identify the target document that this metadata is tracking state for.',
-        type: 'string',
-        readOnly: true,
-        components: {
-          input: Field,
-        },
-      }),
-      defineField({
-        name: 'orderRank',
-        description: 'Used to maintain order position of cards in the Tool.',
-        type: 'string',
-        readOnly: true,
-        initialValue: async (p, {getClient}) => {
-          const lastDocOrderRank = await getClient({
-            apiVersion: API_VERSION,
-          }).fetch(`*[_type == $type]|order(@[$order] desc)[0][$order]`, {
-            order: `orderRank`,
-            type: `workflow.metadata`,
-          })
-
-          return initialRank(lastDocOrderRank)
-        },
-      }),
-      defineField({
-        type: 'array',
-        name: 'assignees',
-        of: [{type: 'string'}],
-        components: {
-          input: UserAssignmentInput,
-        },
-      }),
-    ],
-  })

package/src/tools/index.ts

@@ -1,15 +0,0 @@
-import {SplitVerticalIcon} from '@sanity/icons'
-import {Tool} from 'sanity'
-
-import WorkflowTool from '../components/WorkflowTool'
-import {WorkflowConfig} from '../types'
-
-export type WorkflowToolConfig = (options: WorkflowConfig) => Tool
-
-export const workflowTool: WorkflowToolConfig = (options: WorkflowConfig) => ({
-  name: 'workflow',
-  title: 'Workflow',
-  component: WorkflowTool,
-  icon: SplitVerticalIcon,
-  options,
-})

package/src/types/index.ts

@@ -1,71 +0,0 @@
-import {SanityDocumentLike} from 'sanity'
-
-export type State = {
-  id: string
-  transitions: string[]
-  title: string
-  roles?: string[]
-  requireAssignment?: boolean
-  requireValidation?: boolean
-  // From document badges
-  color?: 'primary' | 'success' | 'warning' | 'danger'
-}
-
-export type StateCheck<Id, States> = {
-  id: Id
-  // Transitions is an array of State ids
-  transitions?: States extends {id: infer Id2}[] ? Id2[] : never
-} & State
-
-export type WorkflowConfig = {
-  schemaTypes: string[]
-  states?: State[]
-}
-
-export function defineStates<
-  Id extends string,
-  States extends StateCheck<Id, States>[]
->(states: States): States {
-  return states
-}
-
-export type User = {
-  createdAt: string
-  displayName: string
-  email: string
-  familyName: string
-  givenName: string
-  id: string
-  imageUrl: string
-  isCurrentUser: boolean
-  middleName: string
-  projectId: string
-  provider: string
-  sanityUserId: string
-  updatedAt: string
-}
-
-export type DragData = {
-  documentId?: string
-  x?: number
-  y?: number
-  state?: string
-}
-
-export type Metadata = SanityDocumentLike & {
-  _rev: string
-  assignees: string[]
-  documentId: string
-  state: string
-  orderRank: string
-}
-
-export type KeyedMetadata = {[key: string]: Metadata}
-
-export type SanityDocumentWithMetadata = {
-  _metadata: Metadata
-  _id: string
-  _type: string
-  _rev: string
-  _updatedAt: string
-}

package/v2-incompatible.js

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