@seedprotocol/sdk 0.1.47 → 0.1.49

package/dist/src/request.ts

@@ -0,0 +1,54 @@
+import { getItem } from '@/browser/db/read/getItem'
+import { eventEmitter } from '@/eventBus'
+
+const activeItemRequests = new Set<string>()
+
+const queue = new Map<string, Record<string, unknown>>()
+
+export const itemRequestHandler = async (event) => {
+  const { seedLocalId, seedUid, modelName, eventId } = event
+
+  if (activeItemRequests.has(seedLocalId)) {
+    console.log(
+      '[item/events] [itemRequestHandler] already requesting item with queue size',
+      queue.size,
+    )
+    queue.set(seedLocalId, event)
+    return
+  }
+
+  const item = await getItem({
+    modelName,
+    seedLocalId,
+    seedUid,
+  })
+
+  if (!item) {
+    console.warn(
+      `[item/events] [itemRequestHandler] no item for seedLocalId ${seedLocalId} or versionUid ${seedUid}`,
+    )
+    if (eventId) {
+      eventEmitter.emit(`item.${modelName}.${seedLocalId}.response`, {
+        item,
+        eventId,
+      })
+    }
+    return
+  }
+
+  eventEmitter.emit(`item.${modelName}.${seedLocalId}.response`, {
+    item,
+    eventId,
+  })
+
+  queue.delete(seedLocalId)
+  if (queue.size > 0 && queue.has(seedLocalId)) {
+    const nextEvent = queue.get(seedLocalId)
+    console.log(
+      '[item/events] [itemRequestHandler] taking event from queue with queue size',
+      queue.size,
+      nextEvent,
+    )
+    await itemRequestHandler(nextEvent)
+  }
+}

package/dist/src/requestAll.ts

@@ -0,0 +1,157 @@
+import { eventEmitter } from '@/eventBus'
+import { Item } from '@/browser/item'
+import { getItemsData } from '@/browser/db/read/getItems'
+import debug from 'debug'
+import { getModel } from '@/browser/stores/modelClass'
+
+const logger = debug('app:events:requestAll')
+
+const cache = new Map<string, Map<string, Item<any>>>()
+
+let modelCount = 0
+
+const handleRequestAll = async (event) => {
+  const { modelName, eventId } = event
+
+  let modelItemsCache
+
+  if (cache.has(modelName)) {
+    modelItemsCache = cache.get(modelName)
+  }
+
+  if (modelItemsCache && modelName === 'Identity' && modelCount <= 1) {
+    // Send what we have while we update the cache
+    eventEmitter.emit(`item.${modelName}.requestAll.response`, {
+      items: Array.from(modelItemsCache.values()),
+      eventId,
+    })
+    modelCount++
+  }
+
+  if (!modelItemsCache) {
+    modelItemsCache = new Map()
+  }
+
+  const itemsData = await getItemsData({ modelName })
+
+  const cacheKeys = Array.from(modelItemsCache.keys())
+
+  const keysInDb = []
+
+  const returnItems = []
+
+  const ModelClass = getModel(modelName)
+
+  for (const itemData of itemsData) {
+    returnItems.push(
+      await Item.create({
+        ...itemData,
+        modelName,
+      }),
+    )
+  }
+
+  if (modelName === 'Identity' && modelCount <= 1) {
+    logger(
+      `[XXXXXX] [handleRequestAll] ${ModelClass?.originalConstructor.name}:`,
+      returnItems.length,
+    )
+    eventEmitter.emit(`item.${modelName}.requestAll.response`, {
+      items: returnItems,
+      eventId,
+    })
+  }
+
+  for (const returnItem of returnItems) {
+    const itemCacheKey = `${returnItem.seedLocalId}_${returnItem.seedUid || ''}`
+    keysInDb.push(itemCacheKey)
+    const existingCacheKey = cacheKeys.find((ck) => ck.includes(itemCacheKey))
+
+    if (!existingCacheKey) {
+      modelItemsCache.set(itemCacheKey, returnItem)
+      continue
+    }
+
+    if (existingCacheKey) {
+      const existingItem = modelItemsCache.get(existingCacheKey)
+      if (!existingItem) {
+        console.error(
+          '[events/requestAll] [getItemsDataFromDb] no existingItem for cache key',
+          existingCacheKey,
+          modelItemsCache,
+        )
+        continue
+      }
+      for (const [key, value] of Object.entries(returnItem)) {
+        if (key === 'seedLocalId' || key === 'seedUid') {
+          continue
+        }
+        existingItem[key] = value
+      }
+      modelItemsCache.set(existingCacheKey, existingItem)
+    }
+  }
+
+  // Remove any stale items from the cache that were deleted from the DB
+  if (keysInDb.length !== cacheKeys.length) {
+    for (const cacheKey of cacheKeys) {
+      if (!keysInDb.includes(cacheKey)) {
+        modelItemsCache.delete(cacheKey)
+      }
+    }
+  }
+
+  cache.set(modelName, modelItemsCache)
+
+  if (modelName === 'Identity' && modelCount <= 1) {
+    logger(
+      `[XXXXXX] [getItemsDataFromDb] ${modelName} responding with`,
+      Array.from(modelItemsCache.values()),
+    )
+    eventEmitter.emit(`item.${modelName}.requestAll.response`, {
+      items: Array.from(modelItemsCache.values()),
+      eventId,
+    })
+  }
+}
+
+export const itemRequestAllHandler = async (event) => {
+  logger('[events/requestAll] Request all items', event)
+  await handleRequestAll(event)
+  // eventQueue.push(event, (err) => {
+  //   if (err) {
+  //     console.error(err)
+  //   }
+  //   if (!err) {
+  //     logger('[events/requestAll] Request all items done without error')
+  //   }
+  // })
+}
+
+// export const getItemCache = () => {
+//   return itemCache
+// }
+
+type CreateItemCacheKeyParams = {
+  seedLocalId?: string
+  seedUid?: string
+}
+
+type CreateItemCacheKey = (
+  itemData: CreateItemCacheKeyParams,
+) => string | undefined
+
+export const createItemCacheKey: CreateItemCacheKey = (itemData) => {
+  if (!itemData || (!itemData.seedLocalId && !itemData.seedUid)) {
+    return
+  }
+  return `${itemData.seedLocalId}_${itemData.seedUid || ''}`
+}
+
+// export const updateItemCache = (itemCacheKey: string, item: Item<any>) => {
+//   itemCache.set(itemCacheKey, item)
+// }
+//
+// export const deleteItemFromCache = (itemCacheKey: string) => {
+//   itemCache.delete(itemCacheKey)
+// }

package/dist/src/resolveRelatedValue.ts

@@ -0,0 +1,348 @@
+import { EventObject, fromCallback } from 'xstate'
+import { convertTxIdToImageSrc } from '@/shared/helpers'
+import { propertyMachine } from '../propertyMachine'
+import { fs } from '@zenfs/core'
+import {
+  getRelationValueData,
+  getStorageTransactionIdForSeedUid,
+} from '@/browser/db/read'
+
+const storageTransactionIdToContentUrl = new Map<string, string>()
+const refResolvedValueToContentUrl = new Map<string, string>()
+const seedUidToContentUrl = new Map<string, string>()
+
+export const resolveRelatedValue = fromCallback<
+  EventObject,
+  typeof propertyMachine
+>(({ sendBack, input: { context } }) => {
+  const {
+    isRelation,
+    propertyValue,
+    propertyName,
+    seedUid,
+    propertyRecordSchema,
+    seedLocalId,
+    schemaUid,
+  } = context
+
+  const _resolveRelatedValue = async () => {
+    if (!propertyValue || !isRelation) {
+      return
+    }
+
+    if (seedUidToContentUrl.has(propertyValue)) {
+      const contentUrl = seedUidToContentUrl.get(propertyValue)
+      sendBack({
+        type: 'updateRenderValue',
+        renderValue: contentUrl,
+      })
+      sendBack({
+        type: 'resolvingRelatedValueSuccess',
+        resolvedDisplayValue: contentUrl,
+      })
+      return true
+    }
+
+    if (Array.isArray(propertyValue)) {
+      // TODO: Handle array of seedUids
+      return
+    }
+
+    const storageTransactionId =
+      await getStorageTransactionIdForSeedUid(propertyValue)
+
+    if (storageTransactionId) {
+      if (storageTransactionIdToContentUrl.has(storageTransactionId)) {
+        const contentUrl =
+          storageTransactionIdToContentUrl.get(storageTransactionId)
+        sendBack({
+          type: 'updateRenderValue',
+          renderValue: contentUrl,
+        })
+        sendBack({
+          type: 'resolvingRelatedValueSuccess',
+          resolvedDisplayValue: contentUrl,
+          resolvedValue: storageTransactionId,
+        })
+        return true
+      }
+
+      const contentUrl = await convertTxIdToImageSrc(storageTransactionId)
+      if (contentUrl) {
+        seedUidToContentUrl.set(propertyValue, contentUrl)
+      }
+      sendBack({
+        type: 'updateRenderValue',
+        renderValue: contentUrl,
+      })
+      sendBack({
+        type: 'resolvingRelatedValueSuccess',
+        resolvedDisplayValue: contentUrl,
+        resolvedValue: storageTransactionId,
+      })
+      return true
+    }
+
+    const relationValueData = await getRelationValueData(propertyValue)
+
+    if (relationValueData) {
+      const { refResolvedValue } = relationValueData
+      const propertyValueFromDb = relationValueData.propertyValue
+
+      // This handles a local-only relation value and resolves from the filesystem
+      if (
+        refResolvedValue &&
+        propertyRecordSchema.dataType === 'Relation' &&
+        propertyValueFromDb.length === 10 &&
+        propertyRecordSchema.ref
+      ) {
+        if (refResolvedValueToContentUrl.has(refResolvedValue)) {
+          const contentUrl = refResolvedValueToContentUrl.get(refResolvedValue)
+          sendBack({
+            type: 'updateRenderValue',
+            renderValue: contentUrl,
+          })
+          sendBack({
+            type: 'resolvingRelatedValueSuccess',
+            resolvedDisplayValue: contentUrl,
+          })
+          return true
+        }
+
+        const fileExists = await fs.promises.exists(
+          '/files/images/' + refResolvedValue,
+        )
+        if (fileExists) {
+          const fileContents = await fs.promises.readFile(
+            '/files/images/' + refResolvedValue,
+          )
+          const fileHandler = new File([fileContents], refResolvedValue)
+          const contentUrl = URL.createObjectURL(fileHandler)
+          refResolvedValueToContentUrl.set(refResolvedValue, contentUrl)
+          sendBack({
+            type: 'updateRenderValue',
+            renderValue: contentUrl,
+          })
+          sendBack({
+            type: 'resolvingRelatedValueSuccess',
+            resolvedDisplayValue: contentUrl,
+          })
+          return true
+        }
+      }
+
+      if (typeof propertyValueFromDb === 'string') {
+        // Check files for a filename that matches the propertyValue
+        if (propertyRecordSchema.dataType === 'ImageSrc') {
+          let contentUrl
+
+          if (storageTransactionIdToContentUrl.has(propertyValueFromDb)) {
+            contentUrl =
+              storageTransactionIdToContentUrl.get(propertyValueFromDb)
+          }
+
+          if (!contentUrl) {
+            const imageFileExists = await fs.promises.exists(
+              `/images/${propertyValue}`,
+            )
+            if (imageFileExists) {
+              const fileContents = await fs.promises.readFile(
+                `/images/${propertyValue}`,
+              )
+              const fileHandler = new File([fileContents], propertyValue)
+              contentUrl = URL.createObjectURL(fileHandler)
+              storageTransactionIdToContentUrl.set(
+                propertyValueFromDb,
+                contentUrl,
+              )
+            }
+          }
+
+          if (contentUrl) {
+            sendBack({
+              type: 'updateRenderValue',
+              renderValue: contentUrl,
+            })
+            sendBack({
+              type: 'resolvingRelatedValueSuccess',
+              resolvedDisplayValue: contentUrl,
+            })
+            return true
+          }
+        }
+      }
+    }
+  }
+
+  _resolveRelatedValue().then((success) => {
+    // if (success) {
+    //   sendBack({
+    //     type: 'resolvingRelatedValueDone',
+    //   })
+    // }
+    // return
+    sendBack({
+      type: 'resolvingRelatedValueDone',
+    })
+  })
+})
+
+//   const eventKey = `storage.transaction.${initialValue}.contentUrl.response`
+//
+//   const contentUrlListener = async (event) => {
+//     console.log('[itemProperty] [constructor] contentUrlListener', event)
+//   }
+//
+//   eventEmitter.once(eventKey, contentUrlListener)
+//
+//   const ready = getArePropertyEventHandlersReady()
+//
+//   console.log('[itemProperty] [constructor] ready', ready)
+//
+//   eventEmitter.emit('storage.transaction.contentUrl.request', {
+//     storageTransactionId: initialValue,
+//   })
+
+// Related property values can either be seedUid or seedUid[]
+// let relatedSeedUid: string
+// let relatedSeedUids: string[]
+//
+// if (Array.isArray(propertyValue)) {
+//   relatedSeedUids = propertyValue
+// } else {
+//   relatedSeedUid = propertyValue
+// }
+//
+// if (relatedSeedUid) {
+//   console.log(
+//     `[property/actors] [resolveRelatedValue] seedUid: ${relatedSeedUid}`,
+//   )
+//   const latestVersionOfRelatedSeedQuery = await appDb.run(
+//     sql.raw(
+//       `
+//           SELECT local_id, uid, MAX(attestation_created_at)
+//           FROM versions
+//           WHERE seed_uid = '${relatedSeedUid}';
+//       `,
+//     ),
+//   )
+//   if (
+//     latestVersionOfRelatedSeedQuery &&
+//     latestVersionOfRelatedSeedQuery.rows &&
+//     latestVersionOfRelatedSeedQuery.rows.length > 0
+//   ) {
+//     const latestVersionOfRelatedSeed =
+//       latestVersionOfRelatedSeedQuery.rows[0]
+//     console.log(
+//       '[property/actors] [resolveRelatedValue] latestVersionOfRelatedSeed',
+//       latestVersionOfRelatedSeed,
+//     )
+//     const storageIdQuery = await appDb.run(
+//       sql.raw(
+//         `
+//             SELECT property_value, MAX(attestation_created_at), ref_resolved_display_value, ref_resolved_value
+//             FROM metadata
+//             WHERE seed_uid = '${relatedSeedUid}'
+//               AND property_name = 'storageTransactionId';
+//         `,
+//       ),
+//     )
+//
+//     if (
+//       storageIdQuery &&
+//       storageIdQuery.rows &&
+//       storageIdQuery.rows.length > 0
+//     ) {
+//       const storageId = storageIdQuery.rows[0][0]
+//
+//       if (!storageId) {
+//         console.error(
+//           `storageId not found for ${propertyName} with relatedSeedUid ${relatedSeedUid}`,
+//         )
+//       }
+//
+//       const resolvedDisplayValue = storageIdQuery.rows[0][2]
+//       let resolvedValue = storageIdQuery.rows[0][3]
+//
+//       if (resolvedDisplayValue && resolvedValue) {
+//         sendBack({
+//           type: 'resolvingRelatedValueSuccess',
+//           resolvedDisplayValue,
+//           resolvedValue,
+//         })
+//         return
+//       }
+//
+//       console.log(
+//         '[property/actors] [resolveRelatedValue] storageId',
+//         storageId,
+//       )
+//
+//       const contentUrl = await convertTxIdToImageSrc(storageId)
+//
+//       if (!contentUrl) {
+//         throw new Error(
+//           `contentUrl not found for ${propertyName} with relatedSeedUid ${relatedSeedUid}`,
+//         )
+//       }
+//
+//       await appDb.run(
+//         sql.raw(
+//           `UPDATE metadata
+//            SET ref_resolved_display_value = '${contentUrl}',
+//                ref_resolved_value         = '${storageId}'
+//            WHERE seed_uid = '${relatedSeedUid}'
+//              AND property_name = 'storageTransactionId';
+//           `,
+//         ),
+//       )
+//
+//       sendBack({
+//         type: 'resolvingRelatedValueSuccess',
+//         resolvedDisplayValue: contentUrl,
+//         resolvedValue: storageId,
+//       })
+//     }
+//   }
+//
+//   const versionUidQuery = await appDb.run(
+//     sql.raw(
+//       `
+//           SELECT uid
+//           FROM versions
+//           WHERE seed_uid = '${relatedSeedUid}';
+//       `,
+//     ),
+//   )
+//
+//   if (
+//     versionUidQuery &&
+//     versionUidQuery.rows &&
+//     versionUidQuery.rows.length > 0
+//   ) {
+//     const versionUids = versionUidQuery.rows.map((row) => row[0])
+//     console.log(
+//       '[property/actors] [resolveRelatedValue] versionUids',
+//       versionUids,
+//     )
+//     const { itemProperties } = await easClient.request(GET_PROPERTIES, {
+//       where: {
+//         refUID: {
+//           in: versionUids,
+//         },
+//         decodedDataJson: {
+//           contains: 'storage_transaction_id',
+//         },
+//       },
+//     })
+//
+//     console.log(
+//       '[property/actors] [resolveRelatedValue] itemProperties',
+//       itemProperties,
+//     )
+//
+//     if (itemProperties && itemProperties.length > 0) {
+//       await savePropertiesToDb(itemProperties)
+//     }
+//   }
+// }

package/dist/src/resolveRemoteStorage.ts

@@ -0,0 +1,87 @@
+import { EventObject, fromCallback } from 'xstate'
+import { itemMachineSingle } from '@/browser/item/single/itemMachineSingle'
+
+export const resolveRemoteStorage = fromCallback<
+  EventObject,
+  typeof itemMachineSingle
+>(({ sendBack, input: { context } }) => {
+  const { propertyInstances } = context
+
+  if (!propertyInstances) {
+    throw new Error(`propertyInstances not found for ${context.seedLocalId}`)
+  }
+
+  if (!propertyInstances.has('storageTransactionId')) {
+    return
+  }
+
+  const storageTransactionId = propertyInstances.get('storageTransactionId')
+
+  const _resolveRemoteStorage = async (): Promise<void> => {
+    const path = await import('path-browserify')
+    const { fs } = await import('@zenfs/core')
+
+    const filesDirExists = await fs.promises.exists('/files')
+
+    if (!filesDirExists) {
+      await fs.promises.mkdir('/files')
+    }
+
+    const htmlDir = path.join('/files', 'html')
+
+    const htmlExists = await fs.promises.exists(htmlDir)
+
+    if (htmlExists) {
+      const htmlFiles = await fs.promises.readdir(htmlDir)
+      const matchingHtmlFile = htmlFiles.find(
+        (file) => file === `${storageTransactionId}.html`,
+      )
+      if (matchingHtmlFile) {
+        const htmlString = await fs.promises.readFile(
+          path.join(htmlDir, matchingHtmlFile),
+          'utf8',
+        )
+        sendBack({
+          type: 'updateValue',
+          propertyName: 'html',
+          propertyValue: htmlString,
+        })
+      }
+    }
+
+    if (!htmlExists) {
+      await fs.promises.mkdir(htmlDir)
+    }
+
+    const jsonDir = path.join('/files', 'json')
+
+    const jsonExists = await fs.promises.exists(jsonDir)
+
+    if (jsonExists) {
+      const jsonFiles = await fs.promises.readdir(jsonDir)
+      const matchingJsonFile = jsonFiles.find(
+        (file) => file === `${storageTransactionId}.json`,
+      )
+      if (matchingJsonFile) {
+        const jsonString = await fs.promises.readFile(
+          path.join(jsonDir, matchingJsonFile),
+          'utf8',
+        )
+        sendBack({
+          type: 'updateValue',
+          propertyName: 'json',
+          propertyValue: jsonString,
+        })
+      }
+    }
+
+    if (!jsonExists) {
+      await fs.promises.mkdir(jsonDir)
+    }
+  }
+
+  _resolveRemoteStorage().then(() => {
+    sendBack({ type: 'resolveRemoteStorageSuccess' })
+    return
+  })
+})