@seedprotocol/sdk 0.1.47 → 0.1.48

package/dist/src/initialize.ts

@@ -0,0 +1,127 @@
+import { EventObject, fromCallback, Subscription } from 'xstate'
+import { isNode, isReactNative } from '@/shared'
+import {
+  GLOBAL_INITIALIZING_CREATE_ALL_ITEMS_SERVICES,
+  GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY,
+  GLOBAL_INITIALIZING_SEND_CONFIG,
+} from '@/browser/services/internal/constants'
+import debug from 'debug'
+import { FromCallbackInput, GlobalMachineContext } from '@/types'
+import { getAppDb } from '@/browser/db/sqlWasmClient'
+import { appState } from '@/shared/seedSchema'
+import { like } from 'drizzle-orm'
+
+const logger = debug('app:services:global:actors:initialize')
+
+export const initialize = fromCallback<
+  EventObject,
+  FromCallbackInput<GlobalMachineContext>
+>(({ sendBack, input: { event, context } }) => {
+  const { internalService, models, endpoints } = context
+
+  const { addresses } = event
+
+  let environment = 'browser'
+
+  if (isNode()) {
+    environment = 'node'
+  }
+
+  if (isReactNative()) {
+    environment = 'react-native'
+  }
+
+  let internalSubscription: Subscription | undefined
+  let easSubscription: Subscription | undefined
+
+  if (environment === 'browser' && models) {
+    const _initFileSystem = async (): Promise<void> => {
+      return
+      // return new Promise((resolve) => {
+      // })
+    }
+
+    const _initInternal = async (): Promise<void> => {
+      return new Promise((resolve) => {
+        internalSubscription = internalService.subscribe((snapshot) => {
+          logger('[sdk] [internal] snapshot', snapshot)
+          if (snapshot.value === 'ready') {
+            resolve()
+          }
+        })
+        internalService.send({ type: 'init', endpoints, addresses })
+      })
+    }
+
+    const _initAllItemsServices = async (): Promise<void> => {
+      const appDb = getAppDb()
+
+      const rows = await appDb
+        .select()
+        .from(appState)
+        .where(like(appState.key, 'snapshot__%'))
+
+      const payloadObj = {
+        create: {},
+        restore: {},
+      }
+
+      const modelNamesRestored: string[] = []
+
+      if (rows && rows.length > 0) {
+        for (const row of rows) {
+          const modelName = row.key.replace('snapshot__', '')
+          payloadObj.restore[modelName] = JSON.parse(row.value)
+          modelNamesRestored.push(modelName)
+        }
+      }
+      for (const [modelName, ModelClass] of Object.entries(models)) {
+        if (!modelNamesRestored.includes(modelName)) {
+          payloadObj.create[modelName] = ModelClass
+        }
+      }
+      sendBack({
+        type: GLOBAL_INITIALIZING_CREATE_ALL_ITEMS_SERVICES,
+        ...payloadObj,
+      })
+    }
+
+    const _initEas = async (): Promise<void> => {
+      // const { easService } = await import('@/browser/eas')
+      // easService.send({ type: 'init', endpoints, models })
+      // return new Promise((resolve) => {
+      //   easSubscription = easService.subscribe((snapshot) => {
+      //     if (snapshot.value === 'ready') {
+      //       resolve()
+      //     }
+      //   })
+      //   easService.send({ type: 'init', endpoints, models })
+      // })
+    }
+
+    _initFileSystem().then(() => {
+      logger('[global/actors] File system initialized')
+    })
+
+    _initInternal()
+      .then(() => {
+        return _initAllItemsServices()
+      })
+      .then(() => {
+        logger('[global/actors] Internal initialized')
+        sendBack({ type: GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY })
+        internalSubscription?.unsubscribe()
+      })
+
+    // _initEas().then(() => {
+    //   logger('EAS initialized')
+    // })
+  }
+
+  sendBack({ type: GLOBAL_INITIALIZING_SEND_CONFIG, environment })
+
+  return () => {
+    internalSubscription?.unsubscribe()
+    easSubscription?.unsubscribe()
+  }
+})

package/dist/src/internalMachine.ts

@@ -0,0 +1,220 @@
+import { assign, setup } from 'xstate'
+import { createBrowserInspector } from '@statelyai/inspect'
+import {
+  DB_NAME_APP,
+  INTERNAL_CONFIGURING_FS_SUCCESS,
+  INTERNAL_LOADING_APP_DB_SUCCESS,
+  INTERNAL_SAVING_CONFIG_SUCCESS,
+  INTERNAL_VALIDATING_INPUT_SUCCESS,
+  InternalState,
+  MachineIds,
+} from './constants'
+import { dbMachine } from '@/browser/services/db/dbMachine'
+import debug from 'debug'
+import { validateInput } from '@/browser/services/internal/actors/validateInput'
+import { prepareDb } from '@/browser/services/internal/actors/prepareDb'
+import { configureFs } from '@/browser/services/internal/actors/configureFs'
+import { saveConfig } from '@/browser/services/internal/actors/saveConfig'
+import { loadAppDb } from '@/browser/services/internal/actors/loadAppDb'
+import { InternalMachineContext } from '@/types'
+
+const logger = debug('app:services:internal:machine')
+
+const { inspect } = createBrowserInspector({
+  autoStart: false,
+})
+
+const {
+  IDLE,
+  VALIDATING_INPUT,
+  SAVING_CONFIG,
+  CONFIGURING_FS,
+  LOADING_APP_DB,
+} = InternalState
+
+// Create the state machine
+export const internalMachine = setup({
+  types: {
+    context: {} as Partial<InternalMachineContext>,
+    input: {} as Partial<InternalMachineContext> | undefined,
+  },
+  actors: {
+    prepareDb,
+    validateInput,
+    configureFs,
+    loadAppDb,
+    saveConfig,
+  },
+}).createMachine({
+  id: MachineIds.INTERNAL,
+  initial: IDLE,
+  context: ({ input }) => {
+    return {
+      ...input,
+      error: undefined,
+      hasFiles: false,
+    }
+  },
+  states: {
+    [IDLE]: {
+      on: {
+        reValidate: VALIDATING_INPUT,
+        init: {
+          target: VALIDATING_INPUT,
+          actions: [
+            assign({
+              appDbService: ({ spawn }) =>
+                spawn(dbMachine, {
+                  input: {
+                    dbName: DB_NAME_APP,
+                  },
+                }),
+            }),
+          ],
+        },
+      },
+      meta: {
+        displayText: 'Waiting for something to happen ...',
+        percentComplete: 0,
+      },
+    },
+    [VALIDATING_INPUT]: {
+      on: {
+        [INTERNAL_VALIDATING_INPUT_SUCCESS]: {
+          target: 'preparingDb',
+          actions: assign({
+            endpoints: ({ event }) => event.endpoints,
+            addresses: ({ event }) => event.addresses,
+          }),
+        },
+      },
+      invoke: {
+        src: 'validateInput',
+        input: ({ context, event }) => ({ context, event }),
+      },
+      meta: {
+        displayText: 'Validating input',
+        percentComplete: 20,
+      },
+      tags: ['loading'],
+    },
+    preparingDb: {
+      on: {
+        prepareDbSuccess: {
+          target: CONFIGURING_FS,
+        },
+      },
+      invoke: {
+        src: 'prepareDb',
+        input: ({ context, event }) => ({ context, event }),
+      },
+    },
+    [CONFIGURING_FS]: {
+      on: {
+        [INTERNAL_CONFIGURING_FS_SUCCESS]: {
+          target: LOADING_APP_DB,
+          actions: assign({ hasFiles: true }),
+        },
+      },
+      invoke: {
+        src: 'configureFs',
+        input: ({ context, event }) => ({ context, event }),
+      },
+      meta: {
+        displayText: 'Downloading app files',
+        percentComplete: 30,
+      },
+      tags: ['loading'],
+    },
+    [LOADING_APP_DB]: {
+      on: {
+        [INTERNAL_LOADING_APP_DB_SUCCESS]: {
+          target: SAVING_CONFIG,
+          actions: () => {
+            logger('[sdk] [internal/index] App DB loaded!')
+          },
+        },
+      },
+      invoke: {
+        src: 'loadAppDb',
+        input: ({ context, event }) => ({ context, event }),
+      },
+    },
+    // Save developer's config to DB
+    [SAVING_CONFIG]: {
+      on: {
+        [INTERNAL_SAVING_CONFIG_SUCCESS]: 'ready',
+      },
+      invoke: {
+        src: 'saveConfig',
+        input: ({ context, event }) => ({ context, event }),
+      },
+      meta: {
+        displayText: 'Saving configuration',
+        percentComplete: 80,
+      },
+      tags: ['loading'],
+    },
+    ready: {
+      entry: () => {
+        logger('[sdk] [internal/index] Ready!')
+      },
+      meta: {
+        displayText: "Crossing the t's ...",
+        percentComplete: 90,
+      },
+    },
+    error: {
+      on: {
+        retry: {
+          target: CONFIGURING_FS,
+          actions: assign({ error: undefined }),
+        },
+      },
+      entry: () => {
+        logger('[sdk] [internal/index] Error!')
+      },
+      meta: {
+        displayText: 'Whoops! Something went wrong.',
+        percentComplete: null,
+      },
+      tags: ['error'],
+    },
+  },
+})
+
+// const internalService = createActor(internalMachine, {
+//   input: {},
+//   inspect: (inspEvent) => {
+//     if (inspEvent.type === '@xstate.snapshot') {
+//       if (
+//         inspEvent.event &&
+//         inspEvent.event.snapshot &&
+//         inspEvent.event.snapshot.value
+//       ) {
+//         logger(
+//           `[internalService] ${inspEvent.event.snapshot.value}`,
+//           inspEvent,
+//         )
+//         return
+//       }
+//
+//       if (inspEvent.snapshot && inspEvent.snapshot.value) {
+//         logger(`[internalService] ${inspEvent.snapshot.value}`, inspEvent)
+//         return
+//       }
+//
+//       // logger(`[internalService] Uncaught event`, inspEvent)
+//     }
+//   },
+// })
+
+// internalService.subscribe((snapshot) => {
+//   globalService.send({ type: INTERNAL_SERVICE_SNAPSHOT, snapshot })
+// })
+//
+// internalService.on(CHILD_SNAPSHOT, (emitted) => {
+//   globalService.send({ ...emitted })
+// })
+
+// internalService.start()

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,
+  }
+}