@seedprotocol/sdk 0.1.47 → 0.1.49

package/dist/src/item.ts

@@ -0,0 +1,324 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+import { createNewItem } from '@/browser/db/write'
+import { Item } from '@/browser/item'
+import { eventEmitter } from '@/eventBus'
+import { useImmer } from 'use-immer'
+import { orderBy } from 'lodash-es'
+import { getAreItemEventHandlersReady } from '@/browser/events'
+import { Subscription } from 'xstate'
+import { useSelector } from '@xstate/react'
+import debug from 'debug'
+import { useGlobalServiceStatus, useIsDbReady } from '@/browser/react/services'
+import { ModelValues } from '@/types'
+
+const logger = debug('app:react:item')
+
+type UseItemProps = {
+  modelName: string
+  seedLocalId?: string
+  seedUid?: string
+}
+
+type UseItemReturn<T extends ModelValues<T>> = {
+  item: Item<T> | undefined
+  itemData: ItemData<T>
+  itemStatus: string | Record<string, unknown> | undefined
+}
+
+type UseItem<T> = (props: UseItemProps) => UseItemReturn<T>
+
+type ItemData<T> = Record<string, Partial<T>>
+
+export const useItem: UseItem<any> = ({ modelName, seedLocalId, seedUid }) => {
+  const [itemData, setItemData] = useImmer<ItemData<any>>({})
+  const [item, setItem] = useState<Item<any> | undefined>()
+  const [itemSubscription, setItemSubscription] = useState<
+    Subscription | undefined
+  >()
+
+  const { status, internalStatus } = useGlobalServiceStatus()
+
+  const isReadingDb = useRef(false)
+
+  const itemStatus = useSelector(
+    item?.getService(),
+    (snapshot) => snapshot?.value,
+  )
+
+  const updateItem = useCallback((newItem: Item<any>) => {
+    setItemData((draft) => {
+      Object.keys(newItem.properties).forEach((propertyName) => {
+        const value = newItem[propertyName]
+        draft[propertyName] = value
+      })
+    })
+  }, [])
+
+  const readFromDb = useCallback(async () => {
+    if (
+      isReadingDb.current ||
+      internalStatus !== 'ready' ||
+      (!seedUid && !seedLocalId)
+    ) {
+      return
+    }
+    isReadingDb.current = true
+    const foundItem = await Item.find({
+      modelName,
+      seedLocalId,
+      seedUid,
+    })
+    if (!foundItem) {
+      logger('[useItem] [getItemFromDb] no item found', modelName, seedLocalId)
+      return
+    }
+    setItem(foundItem)
+    updateItem(foundItem)
+    isReadingDb.current = false
+  }, [internalStatus])
+
+  const listenerRef = useRef(readFromDb)
+
+  useEffect(() => {
+    listenerRef.current = readFromDb
+  }, [readFromDb])
+
+  useEffect(() => {
+    if (internalStatus === 'ready') {
+      listenerRef.current()
+    }
+  }, [internalStatus, status])
+
+  useEffect(() => {
+    if (item && !itemSubscription) {
+      const subscription = item.subscribe(async (_) => {
+        const newItem = await Item.find({ modelName, seedLocalId, seedUid })
+        if (!newItem) {
+          logger(
+            '[useItem] [itemSubscription] no item found',
+            modelName,
+            seedLocalId,
+          )
+          return
+        }
+        updateItem(newItem)
+        setItem(newItem)
+      })
+      setItemSubscription(subscription)
+    }
+
+    return () => {
+      itemSubscription?.unsubscribe()
+    }
+  }, [item, itemSubscription])
+
+  useEffect(() => {
+    const seedId = seedUid || seedLocalId
+
+    eventEmitter.addListener(`item.${modelName}.${seedId}.update`, () => {
+      listenerRef.current()
+    })
+
+    return () => {
+      eventEmitter.removeListener(
+        `item.${modelName}.${seedId}.update`,
+        readFromDb,
+      )
+    }
+  }, [])
+
+  return {
+    item,
+    itemData,
+    itemStatus,
+  }
+}
+type UseItemsReturn = {
+  items: Item<any>[]
+  isReadingDb: boolean
+  isInitialized: boolean
+}
+type UseItemsProps = {
+  modelName?: string
+  deleted?: boolean
+}
+type UseItems = (props: UseItemsProps) => UseItemsReturn
+export const useItems: UseItems = ({ modelName, deleted }) => {
+  const [items, setItems] = useImmer<Item<any>[]>([])
+  const [isReadingDb, setIsReadingDb] = useState(false)
+  const [isInitialized, setIsInitialized] = useState(false)
+
+  const isDbReady = useIsDbReady()
+
+  const modelNameRef = useRef<string | undefined>(modelName)
+
+  const readFromDb = useCallback(
+    async (event) => {
+      if (
+        !event ||
+        !event.modelName ||
+        event.modelName !== modelNameRef.current ||
+        isReadingDb
+      ) {
+        return
+      }
+      setIsReadingDb(true)
+      const allItems = await Item.all(modelNameRef.current, deleted)
+      setItems(() => allItems)
+      setIsReadingDb(false)
+    },
+    [modelName, isReadingDb],
+  )
+
+  useEffect(() => {
+    if (isDbReady && !isInitialized) {
+      const _fetchItems = async (): Promise<void> => {
+        await readFromDb({ modelName })
+        setIsInitialized(true)
+      }
+
+      _fetchItems()
+    }
+  }, [isInitialized, isDbReady])
+
+  useEffect(() => {
+    eventEmitter.addListener('item.requestAll', readFromDb)
+
+    return () => {
+      eventEmitter.removeListener('item.requestAll')
+    }
+  }, [])
+
+  return {
+    items: orderBy(
+      items,
+      [
+        (item) =>
+          item.lastVersionPublishedAt ||
+          item.attestationCreatedAt ||
+          item.createdAt,
+      ],
+      ['desc'],
+    ).slice(0, 10),
+    isReadingDb,
+    isInitialized,
+  }
+}
+export const useItemIsReady = () => {
+  const [itemListenersReady, setItemListenersReady] = useState(false)
+
+  const itemEventListenersHandler = useCallback((_) => {
+    setItemListenersReady(true)
+  }, [])
+
+  useEffect(() => {
+    const areReady = getAreItemEventHandlersReady()
+
+    if (areReady) {
+      itemEventListenersHandler(true)
+    }
+
+    eventEmitter.addListener(
+      'item.events.setupAllItemsEventHandlers',
+      itemEventListenersHandler,
+    )
+
+    return () => {
+      eventEmitter.removeListener('item.events.setupAllItemsEventHandlers')
+    }
+  }, [])
+
+  return {
+    isReady: itemListenersReady,
+  }
+}
+export const useCreateItem = <T>(modelName: string) => {
+  const [isCreatingItem, setIsCreatingItem] = useState(false)
+
+  const { isReady } = useItemIsReady()
+
+  const createItem = useCallback(
+    async (itemData) => {
+      if (!isReady) {
+        console.error(
+          `[useCreateItem] [createItem] called before listeners are ready`,
+          itemData,
+        )
+        return
+      }
+      if (isCreatingItem) {
+        // TODO: should we setup a queue for this?
+        console.error(
+          `[useCreateItem] [createItem] already creating item`,
+          itemData,
+        )
+        return
+      }
+
+      setIsCreatingItem(true)
+
+      const { seedLocalId } = await createNewItem({ modelName, ...itemData })
+
+      const newItem = await Item.find({ modelName, seedLocalId })
+
+      eventEmitter.emit('item.requestAll', { modelName })
+
+      setIsCreatingItem(false)
+    },
+    [isCreatingItem, isReady],
+  )
+
+  return {
+    createItem,
+    isCreatingItem,
+  }
+}
+
+type PublishItemResult = Error | undefined | void
+
+type UsePublishItemReturn = {
+  publishItem: (
+    item: Item<any> | undefined,
+    callback: (result: PublishItemResult) => any,
+  ) => void
+  isPublishing: boolean
+}
+
+type PublishItemProps = [
+  item: Item<any> | undefined,
+  callback?: (result: PublishItemResult) => any | undefined,
+]
+
+type PublishItem = (...props: PublishItemProps) => Promise<any>
+
+export const usePublishItem = (): UsePublishItemReturn => {
+  const [isPublishing, setIsPublishing] = useState(false)
+
+  const isLocked = useRef(false)
+
+  const publishItem: PublishItem = useCallback(async (item, callback?) => {
+    if (!item || isLocked.current) {
+      return
+    }
+    isLocked.current = true
+    console.log('Publishing item', item)
+    setIsPublishing(true)
+    try {
+      await item.publish()
+      if (callback) {
+        callback()
+      }
+    } catch (e) {
+      if (callback) {
+        callback(e as Error)
+      }
+    }
+    setIsPublishing(false)
+    isLocked.current = false
+  }, [])
+
+  return {
+    publishItem,
+    isPublishing,
+  }
+}

package/dist/src/itemMachineAll.ts

@@ -0,0 +1,158 @@
+import { assign, setup } from 'xstate'
+import { MachineIds } from '@/browser/services/internal/constants'
+import { AllItemsMachineContext } from '@/types'
+import { eventEmitter } from '@/eventBus'
+import { initialize } from '@/browser/item/all/actors/initialize'
+import { fetchDbData } from '@/browser/item/all/actors/fetchDbData'
+import { fetchSeeds } from '@/browser/item/all/actors/fetchSeeds'
+import { fetchVersions } from '@/browser/item/all/actors/fetchVersions'
+import { fetchRelatedItems } from '@/browser/item/all/actors/fetchRelatedItems'
+import { processItems } from '@/browser/item/all/actors/processItems'
+
+const excludedVersionUidValues = ['', 'undefined', 'null', '0', 0]
+
+export const itemMachineAll = setup({
+  types: {
+    context: {} as Partial<AllItemsMachineContext>,
+    input: {} as Partial<AllItemsMachineContext> | undefined,
+  },
+  actors: {
+    initialize,
+    fetchDbData,
+    fetchSeeds,
+    fetchVersions,
+    fetchRelatedItems,
+    processItems,
+  },
+}).createMachine({
+  id: MachineIds.ALL_ITEMS,
+  initial: 'uninitialized',
+  context: ({ input }) => input as AllItemsMachineContext,
+  on: {
+    updateTimes: {
+      actions: assign({
+        times: ({ event }) => event.times,
+      }),
+    },
+  },
+  states: {
+    idle: {
+      entry: ({ self, context }) => {
+        eventEmitter.emit('service.saveState.request', {
+          state: self.getPersistedSnapshot(),
+          serviceId: `${MachineIds.ALL_ITEMS}_${context.modelName}`,
+        })
+      },
+    },
+    uninitialized: {
+      on: {
+        modelsFound: {
+          target: 'initializing',
+          actions: assign({
+            modelAddedToDb: true,
+          }),
+        },
+      },
+    },
+    initializing: {
+      on: {
+        initializeSuccess: {
+          target: 'fetchingSeeds',
+          actions: assign({
+            modelName: ({ event }) => event.modelName,
+            modelNameLowercase: ({ event }) => event.modelNameLowercase,
+            modelNamePlural: ({ event }) => event.modelNamePlural,
+            queryVariables: ({ event }) => event.queryVariables,
+          }),
+        },
+        modelsNotFound: 'idle',
+      },
+      invoke: {
+        src: 'initialize',
+        input: ({ context }) => ({ context }),
+      },
+    },
+    fetchingSeeds: {
+      on: {
+        fetchSeedsSuccess: {
+          target: 'fetchingVersions',
+          actions: assign({
+            itemSeeds: ({ event }) => event.itemSeeds,
+          }),
+        },
+      },
+      invoke: {
+        src: 'fetchSeeds',
+        input: ({ context }) => ({ context }),
+      },
+    },
+    fetchingVersions: {
+      on: {
+        fetchVersionsSuccess: {
+          target: 'fetchingRelatedItems',
+          actions: assign({
+            itemVersions: ({ event }) => event.itemVersions,
+          }),
+        },
+      },
+      invoke: {
+        src: 'fetchVersions',
+        input: ({ context }) => ({ context }),
+      },
+    },
+    fetchingRelatedItems: {
+      on: {
+        fetchRelatedItemsSuccess: {
+          target: 'processingItems',
+          actions: assign({
+            relatedProperties: ({ event }) => event.relatedProperties,
+            relatedVersionsBySeedUid: ({ event }) =>
+              event.relatedVersionsBySeedUid,
+            relatedVersionsBySchemaUid: ({ event }) =>
+              event.relatedVersionsBySchemaUid,
+            schemaUidsByModelName: ({ event }) => event.schemaUidsByModelName,
+            mostRecentPropertiesBySeedUid: ({ event }) =>
+              event.mostRecentPropertiesBySeedUid,
+          }),
+        },
+      },
+      invoke: {
+        src: 'fetchRelatedItems',
+        input: ({ context }) => ({ context }),
+      },
+    },
+    processingItems: {
+      on: {
+        processItemsSuccess: 'idle',
+        itemCreated: {
+          actions: assign({
+            items: ({ context, event }) => {
+              if (context && context.items) {
+                const foundItem = context.items.find((item) => {
+                  if (!item.versionLocalId) {
+                    return false
+                  }
+                  return (
+                    item.versionLocalId === event.item.versionLocalId ||
+                    item.versionUid === event.item.versionUid
+                  )
+                })
+                if (foundItem) {
+                  return context.items
+                }
+                return [...context.items, event.item]
+              }
+              if (context && !context.items) {
+                return [event.item]
+              }
+            },
+          }),
+        },
+      },
+      invoke: {
+        src: 'processItems',
+        input: ({ context, self }) => ({ context, self }),
+      },
+    },
+  },
+})

package/dist/src/itemMachineSingle.ts

@@ -0,0 +1,175 @@
+import { assign, setup } from 'xstate'
+import { MachineIds } from '@/browser/services/internal/constants'
+import { ItemMachineContext } from '@/types'
+import { ItemProperty } from '../../property'
+import { waitForDb } from './actors/waitForDb'
+import { initialize } from './actors/initialize'
+import { hydrateExistingItem } from './actors/hydrateExistingItem'
+import { hydrateNewItem } from './actors/hydrateNewItem'
+import { fetchDataFromEas } from './actors/fetchDataFromEas'
+
+export const itemMachineSingle = setup({
+  types: {
+    context: {} as ItemMachineContext<any>,
+    input: {},
+  },
+  actors: {
+    waitForDb,
+    initialize,
+    hydrateExistingItem,
+    hydrateNewItem,
+    fetchDataFromEas,
+  },
+}).createMachine({
+  id: MachineIds.ITEM,
+  initial: 'waitingForDb',
+  context: ({ input }) => input as ItemMachineContext<any>,
+  on: {
+    updatedPropertiesBySchemaUid: {
+      actions: assign({
+        propertiesBySchemaUid: ({ event }) => event.propertiesBySchemaUid,
+      }),
+    },
+    updatePropertiesMetadata: {
+      actions: assign({
+        propertiesMetadata: ({ event }) => event.propertiesMetadata,
+      }),
+    },
+    updateProperties: {
+      actions: assign({
+        propertiesUpdatedAt: Date.now(),
+      }),
+    },
+    updateValue: {
+      actions: assign(({ event, context }) => {
+        let { propertyInstances } = context
+        if (!propertyInstances) {
+          propertyInstances = new Map<string, ItemProperty<any>>()
+        }
+        const { propertyName, propertyValue } = event
+
+        if (!propertyInstances.has(propertyName)) {
+          return {
+            [propertyName]: propertyValue,
+          }
+        }
+        const propertyInstance = propertyInstances.get(
+          propertyName,
+        ) as ItemProperty<any>
+
+        propertyInstance.value = propertyValue
+        propertyInstances.set(propertyName, propertyInstance)
+        // TODO: use immer here
+        return {
+          propertyInstances,
+        }
+      }),
+    },
+    addPropertyInstance: {
+      actions: assign(({ context, event }) => {
+        const propertyInstances =
+          context.propertyInstances || new Map<string, typeof ItemProperty>()
+        propertyInstances.set(event.propertyName, event.propertyInstance)
+        return {
+          propertyInstances,
+        }
+      }),
+    },
+    // addPropertyAttestation: {
+    //   actions: assign(({ context, event }) => {
+    //     console.log('[singleItemMachine] [addPropertyAttestation] event', event)
+    //     const propertyInstances =
+    //       context.propertyInstances || new Map<string, typeof ItemProperty>()
+    //     propertyInstances.set(event.propertyName, event.propertyInstances)
+    //     return {
+    //       propertyInstances,
+    //     }
+    //   }),
+    // },
+  },
+  states: {
+    idle: {},
+    waitingForDb: {
+      on: {
+        waitForDbSuccess: 'initializing',
+      },
+      invoke: {
+        src: 'waitForDb',
+      },
+    },
+    initializing: {
+      on: {
+        hasExistingItem: {
+          target: 'idle',
+          actions: assign({
+            modelTableName: ({ event }) => event.modelTableName,
+            modelNamePlural: ({ event }) => event.modelNamePlural,
+            modelName: ({ event }) => event.modelName,
+            existingItem: ({ event }) => event.existingItem,
+          }),
+        },
+        isNewItem: {
+          target: 'idle',
+          actions: assign({
+            modelTableName: ({ event }) => event.modelTableName,
+            modelNamePlural: ({ event }) => event.modelNamePlural,
+            modelName: ({ event }) => event.modelName,
+          }),
+        },
+      },
+      invoke: {
+        src: 'initialize',
+        input: ({ context, event }) => ({ context, event }),
+      },
+    },
+    hydratingExistingItem: {
+      on: {
+        hydrateExistingItemSuccess: 'idle',
+        hydrateExistingItemFailure: 'destroying',
+      },
+      invoke: {
+        src: 'hydrateExistingItem',
+        input: ({ event, context }) => ({ event, context }),
+      },
+    },
+    hydratingNewItem: {
+      on: {
+        hydrateNewItemSuccess: 'idle',
+      },
+      invoke: {
+        src: 'hydrateNewItem',
+        input: ({ context }) => ({ context }),
+      },
+    },
+    fetchingRemoteData: {
+      on: {
+        fetchRemoteDataSuccess: 'idle',
+      },
+      invoke: {
+        src: 'fetchRemoteData',
+        input: ({ context }) => ({ context }),
+      },
+    },
+    // fetchingDataFromEas: {
+    //   on: {
+    //     fetchDataFromEasSuccess: 'savingDataToDb',
+    //   },
+    //   invoke: {
+    //     src: 'fetchDataFromEas',
+    //     input: ({ context }) => ({ context }),
+    //   },
+    // },
+    // savingDataToDb: {
+    //   on: {
+    //     saveDataToDbSuccess: 'idle',
+    //   },
+    //   invoke: {
+    //     src: 'saveDataToDb',
+    //     input: ({ context }) => ({ context }),
+    //   },
+    // },
+    destroying: {
+      type: 'final',
+    },
+  },
+})

package/dist/src/loadAppDb.ts

@@ -0,0 +1,47 @@
+import { EventObject, fromCallback, Subscription } from 'xstate'
+import {
+  DB_NAME_APP,
+  DB_ON_SNAPSHOT,
+  INTERNAL_LOADING_APP_DB_SUCCESS,
+} from '@/browser/services/internal/constants'
+import debug from 'debug'
+import { FromCallbackInput, InternalMachineContext } from '@/types'
+
+const logger = debug('app:services:internal:actors:loadAppDb')
+
+export const loadAppDb = fromCallback<
+  EventObject,
+  FromCallbackInput<InternalMachineContext>
+>(({ sendBack, input: { context } }) => {
+  const { appDbService } = context
+
+  let subscription: Subscription | undefined
+
+  const _loadAppDb = async (): Promise<void> => {
+    return new Promise((resolve) => {
+      if (appDbService.getSnapshot().value === 'ready') {
+        return resolve()
+      }
+      subscription = appDbService.subscribe({
+        next: (snapshot) => {
+          if (snapshot.value === 'ready') {
+            return resolve()
+          }
+
+          sendBack({ type: DB_ON_SNAPSHOT, dbName: DB_NAME_APP, snapshot })
+        },
+      })
+    })
+  }
+
+  _loadAppDb().then(() => {
+    sendBack({ type: INTERNAL_LOADING_APP_DB_SUCCESS })
+    logger('[sdk] [internal/actors] Successfully loaded app DB')
+  })
+
+  return () => {
+    if (subscription) {
+      subscription.unsubscribe()
+    }
+  }
+})