@sanity/cross-dataset-duplicator 0.3.0

package/src/components/SelectButtons.tsx

@@ -0,0 +1,80 @@
+import React, {useState, useEffect} from 'react'
+import {Button, Card, Flex} from '@sanity/ui'
+import {typeIsAsset} from '../helpers'
+import {PayloadItem} from '../types'
+
+const buttons = [`All`, `None`, null, `New`, `Existing`, `Older`, null, `Documents`, `Assets`]
+
+type SelectButtonsProps = {
+  payload: PayloadItem[]
+  setPayload: Function
+}
+
+export default function SelectButtons(props: SelectButtonsProps) {
+  const {payload, setPayload} = props
+  const [disabledActions, setDisabledActions] = useState([])
+
+  // Set intiial disabled button
+  useEffect(() => {
+    if (!disabledActions?.length && payload.every((item) => item.include)) {
+      setDisabledActions([`ALL`])
+    }
+  }, [])
+
+  function handleSelectButton(action = ``) {
+    if (!action || !payload.length) return
+
+    const newPayload = [...payload]
+
+    switch (action) {
+      case 'ALL':
+        newPayload.map((item) => (item.include = true))
+        break
+      case 'NONE':
+        newPayload.map((item) => (item.include = false))
+        break
+      case 'NEW':
+        newPayload.map((item) => (item.include = Boolean(item.status === 'CREATE')))
+        break
+      case 'EXISTING':
+        newPayload.map((item) => (item.include = Boolean(item.status === 'EXISTS')))
+        break
+      case 'OLDER':
+        newPayload.map((item) => (item.include = Boolean(item.status === 'OVERWRITE')))
+        break
+      case 'ASSETS':
+        newPayload.map((item) => (item.include = typeIsAsset(item.doc._type)))
+        break
+      case 'DOCUMENTS':
+        newPayload.map((item) => (item.include = !typeIsAsset(item.doc._type)))
+        break
+      default:
+        break
+    }
+
+    setDisabledActions([action])
+    setPayload(newPayload)
+  }
+
+  return (
+    <Card padding={1} radius={3} shadow={1}>
+      <Flex gap={2}>
+        {buttons.map((action, actionIndex) =>
+          action ? (
+            <Button
+              key={action}
+              fontSize={1}
+              mode="bleed"
+              padding={2}
+              text={action}
+              disabled={disabledActions.includes(action.toUpperCase())}
+              onClick={() => handleSelectButton(action.toUpperCase())}
+            />
+          ) : (
+            <Card key={`divider-${actionIndex}`} borderLeft />
+          )
+        )}
+      </Flex>
+    </Card>
+  )
+}

package/src/components/StatusBadge.tsx

@@ -0,0 +1,97 @@
+import React from 'react'
+import {Box, Text, Badge, Tooltip} from '@sanity/ui'
+import type {BadgeTone} from '@sanity/ui'
+
+type StatusTones = {
+  EXISTS: BadgeTone
+  OVERWRITE: BadgeTone
+  UPDATE: BadgeTone
+  CREATE: BadgeTone
+}
+
+const documentTones: StatusTones = {
+  EXISTS: `primary`,
+  OVERWRITE: `critical`,
+  UPDATE: `caution`,
+  CREATE: `positive`,
+}
+
+const assetTones: StatusTones = {
+  EXISTS: `critical`,
+  OVERWRITE: `critical`,
+  UPDATE: `critical`,
+  CREATE: `positive`,
+}
+
+type messageTypes = {
+  EXISTS: string
+  OVERWRITE: string
+  UPDATE: string
+  CREATE: string
+}
+
+const documentMessages: messageTypes = {
+  // Only happens once document is copied the first time, and _updatedAt is the same
+  EXISTS: `This document already exists at the Destination with the same ID with the same Updated time.`,
+  // Is true immediately after transaction as _updatedAt is updated by API after mutation
+  // Is also true if the document at the destination has been manually modified
+  // Presently, the plugin doesn't actually compare the two documents
+  OVERWRITE: `A newer version of this document exists at the Destination, and it will be overwritten with this version.`,
+  // Document at destination is older
+  UPDATE: `An older version of this document exists at the Destination, and it will be overwritten with this version.`,
+  // Document at destination doesn't exist
+  CREATE: `This document will be created at the destination.`,
+}
+
+const assetMessages: messageTypes = {
+  EXISTS: `This Asset already exists at the Destination`,
+  OVERWRITE: `This Asset already exists at the Destination`,
+  UPDATE: `This Asset already exists at the Destination`,
+  CREATE: `This Asset does not yet exist at the Destination`,
+}
+
+const assetStatus: messageTypes = {
+  EXISTS: `RE-UPLOAD`,
+  OVERWRITE: `RE-UPLOAD`,
+  UPDATE: `RE-UPLOAD`,
+  CREATE: `UPLOAD`,
+}
+
+type StatusBadgeProps = {
+  status: 'EXISTS' | 'OVERWRITE' | 'UPDATE' | 'CREATE' | undefined
+  isAsset: boolean
+}
+
+export default function StatusBadge(props: StatusBadgeProps) {
+  const {status, isAsset} = props
+
+  const badgeTone = isAsset ? assetTones[status] : documentTones[status]
+  
+  if (!badgeTone) {
+    return (
+      <Badge muted padding={2} fontSize={1} mode="outline">
+        Checking...
+      </Badge>
+    )
+  }
+  
+  const badgeText = isAsset ? assetMessages[status] : documentMessages[status]
+  const badgeStatus = isAsset ? assetStatus[status] : status
+
+  return (
+    <Tooltip
+      content={
+        <Box padding={3} style={{maxWidth: 200}}>
+          <Text size={1}>{badgeText}</Text>
+        </Box>
+      }
+      fallbackPlacements={['right', 'left']}
+      placement="top"
+      portal
+    >
+      <Badge muted padding={2} fontSize={1} tone={badgeTone} mode="outline">
+        {badgeStatus}
+      </Badge>
+    </Tooltip>
+  )
+}

package/src/helpers/clientConfig.ts

@@ -0,0 +1 @@
+export const clientConfig = {apiVersion: `2021-05-19`}

package/src/helpers/constants.ts

@@ -0,0 +1 @@
+export const SECRET_NAMESPACE = `CrossDatasetDuplicator`

package/src/helpers/getDocumentsInArray.ts

@@ -0,0 +1,74 @@
+import {extract} from '@sanity/mutator'
+import {SanityDocument} from '../types'
+
+// Recursively fetch Documents from an array of _id's and their references
+// Heavy use of Set is to avoid recursively querying for id's already in the payload
+export async function getDocumentsInArray(
+  fetchIds: string[],
+  client: any,
+  currentIds?: Set<string>
+) {
+  const collection = []
+
+  // Find initial docs
+  const data: SanityDocument[] = await client.fetch(`*[_id in $fetchIds]`, {
+    fetchIds: fetchIds ?? [],
+  })
+
+  if (!data?.length) {
+    return []
+  }
+
+  const localCurrentIds = currentIds ?? new Set()
+  
+  // Find new ids in the returned data
+  // Unless we started with an empty set, get the _ids from the data
+  const newDataIds: Set<string> = new Set(
+    data
+      .map((dataDoc) => dataDoc._id)
+      .filter((id) => (currentIds?.size ? !localCurrentIds.has(id) : Boolean(id)))
+  )
+
+  if (newDataIds.size) {
+    collection.push(...data)
+    localCurrentIds.add(...newDataIds)
+
+    // Check new data for more references
+    await Promise.all(
+      data.map(async (doc) => {
+        const expr = `.._ref`
+        const references = extract(expr, doc)
+
+        if (references.length) {
+          // Find references not already in the Collection
+          const newReferenceIds = new Set(references.filter((refId) => !localCurrentIds.has(refId)))
+
+          if (newReferenceIds.size) {
+            // Recusive query for new documents
+            const referenceDocs = await getDocumentsInArray(
+              Array.from(newReferenceIds),
+              client,
+              localCurrentIds
+            )
+
+            if (referenceDocs?.length) {
+              collection.push(...referenceDocs)
+            }
+          }
+        }
+      })
+    )
+  }
+
+  // Create a unique array of objects from collection
+  // Set() wasn't working for unique id's ¯\_(ツ)_/¯
+  const uniqueCollection = collection.filter(Boolean).reduce((acc, cur) => {
+    if (acc.some((doc) => doc._id === cur._id)) {
+      return acc
+    }
+
+    return [...acc, cur]
+  }, []) 
+
+  return uniqueCollection
+}

package/src/helpers/index.ts

@@ -0,0 +1,23 @@
+export function typeIsAsset(type = ``) {
+  if (!type) return false
+
+  return ['sanity.imageAsset', 'sanity.fileAsset'].includes(type)
+}
+
+export function createInitialMessage(docCount = 0, refsCount = 0) {
+  const message = [
+    docCount === 1 ? `This Document contains` : `These ${docCount} Documents contain`,
+    refsCount === 1 ? `1 Reference.` : `${refsCount} References.`,
+    refsCount === 1 ? `That Document` : `Those Documents`,
+    `may have References too. If referenced Documents do not exist at the target Destination, this transaction will fail.`
+  ]
+
+  return message.join(` `)
+}
+
+export const stickyStyles = {
+  position: 'sticky',
+  top: 0,
+  zIndex: 100,
+  backgroundColor: `rgba(255,255,255,0.95)`,
+}

package/src/index.js

@@ -0,0 +1,7 @@
+import DuplicateToAction from "./actions/DuplicateToAction";
+import CrossDatasetDuplicator from "./components/CrossDatasetDuplicator";
+
+export {
+  DuplicateToAction,
+  CrossDatasetDuplicator
+}

package/src/tool/index.ts

@@ -0,0 +1,13 @@
+import {LaunchIcon} from '@sanity/icons'
+import config from 'config:@sanity/cross-dataset-duplicator'
+
+import CrossDatasetDuplicator from '../components/CrossDatasetDuplicator'
+
+export default config?.tool
+  ? {
+      title: 'Duplicator',
+      name: 'duplicator',
+      icon: LaunchIcon,
+      component: CrossDatasetDuplicator,
+    }
+  : null

package/src/types/index.ts

@@ -0,0 +1,10 @@
+export type SanityDocument = {
+  _id: string
+  _type: string
+}
+
+export type PayloadItem = {
+  include: boolean
+  status: 'EXISTS' | 'OVERWRITE' | 'UPDATE' | 'CREATE'
+  doc: SanityDocument
+}