@seedprotocol/sdk 0.2.54 → 0.3.1

package/dist/src/fetchDataFromEas.ts

@@ -0,0 +1,94 @@
+import { EventObject, fromCallback } from 'xstate'
+import { GET_PROPERTIES } from '@/Item/queries'
+import { itemMachineSingle } from '@/Item/service/itemMachineSingle'
+import { PropertyType } from '@/seedSchema'
+import { Attestation } from '@/graphql/gql/graphql'
+import { ModelClassType } from '@/types'
+import { BaseEasClient, BaseQueryClient } from '@/helpers'
+
+
+export const fetchDataFromEas = fromCallback<
+  EventObject,
+  typeof itemMachineSingle
+>(({ sendBack, input: { context } }) => {
+  const { ModelClass, modelTableName, versionUid } = context
+
+  const propertiesMetadata = new Map<string, PropertyType>()
+
+  // EAS is the final source of truth, so we need to see if our Item is
+  // already represented there. Then we need to intelligently sync/merge
+  // with whatever new data has been created on the device before the sync.
+  for (const [propertyName, propertyMetadata] of Object.entries(
+    (ModelClass as ModelClassType).schema,
+  )) {
+    if (propertyMetadata) {
+      propertiesMetadata.set(propertyName, propertyMetadata)
+    }
+  }
+
+  sendBack({ type: 'updatePropertiesMetadata', propertiesMetadata })
+
+  if (!versionUid) {
+    // In this case this is a local only item, so we don't need to fetch anything
+    return
+  }
+
+  const _fetchDataFromEas = async (): Promise<void> => {
+    const queryClient = BaseQueryClient.getQueryClient()
+    const easClient = BaseEasClient.getEasClient()
+
+    // Fetch Properties by versionUid
+    const { itemProperties } = await queryClient.fetchQuery({
+      queryKey: ['getProperties', versionUid],
+      queryFn: async () =>
+        easClient.request(GET_PROPERTIES, {
+          where: {
+            refUID: {
+              in: [versionUid],
+            },
+            decodedDataJson: {
+              not: {
+                // The first of many filters to keep bad data out
+                contains:
+                  '"value":"0x0000000000000000000000000000000000000000000000000000000000000020"',
+              },
+            },
+          },
+        }),
+    })
+
+    // Filter properties by schemaId
+    const selectedPropertiesMap: {
+      [schemaId: string]: Attestation[]
+    } = {}
+    itemProperties.forEach((property) => {
+      const existingProperties = selectedPropertiesMap[property.schemaId] || []
+      existingProperties.push(property)
+      selectedPropertiesMap[property.schemaId] = existingProperties
+    })
+
+    // For each schemaId, sort property Attestations by timeCreated DESC
+    Object.keys(selectedPropertiesMap).forEach((schemaId) => {
+      const sorted = selectedPropertiesMap[schemaId].sort((a, b) => {
+        return a.timeCreated - b.timeCreated
+      })
+      selectedPropertiesMap[schemaId] = sorted
+    })
+
+    Object.keys(selectedPropertiesMap).forEach((schemaId) => {
+      // TODO: Finish this logic
+      // console.log('[singleItemActors] [fetchDataFromEas] schemaId', schemaId)
+      // sendBack({ type: 'addPropertyAttestation', schemaId })
+    })
+
+    // Attach processed properties to the itemService/itemMachine context
+    sendBack({
+      type: 'updatedPropertiesBySchemaUid',
+      propertiesBySchemaUid: selectedPropertiesMap,
+    })
+  }
+
+  _fetchDataFromEas().then(() => {
+    sendBack({ type: 'fetchDataFromEasSuccess' })
+  })
+})

package/dist/src/fetchDbData.ts

@@ -0,0 +1,19 @@
+import { EventObject, fromCallback } from 'xstate'
+import { AllItemsMachineContext, FromCallbackInput } from '@/types'
+
+export const fetchDbData = fromCallback<
+  EventObject,
+  FromCallbackInput<AllItemsMachineContext>
+>(
+  ({ sendBack, input: { context } }) => {
+    const { modelNamePlural, times } = context
+
+    const _fetchDbData = async (): Promise<void> => { }
+
+    _fetchDbData().then(() => {
+      sendBack({ type: 'fetchDbDataSuccess' })
+    })
+
+    return () => { }
+  },
+)

package/dist/src/fetchRelatedItems.ts

@@ -0,0 +1,184 @@
+import { EventObject, fromCallback } from 'xstate'
+import {
+  GET_ALL_PROPERTIES_FOR_ALL_VERSIONS,
+  GET_SEED_IDS,
+  GET_VERSIONS,
+} from '@/Item/queries'
+import {
+  models as modelsTable,
+  modelUids,
+  PropertyType,
+} from '@/seedSchema'
+import { Attestation } from '@/graphql/gql/graphql'
+import {
+  AllItemsMachineContext,
+  FromCallbackInput,
+  ModelClassType,
+} from '@/types'
+import { getAddressesFromDb } from '@/helpers/db'
+import { eq } from 'drizzle-orm'
+import { BaseDb } from '@/db/Db/BaseDb'
+import { BaseEasClient } from '@/helpers/EasClient/BaseEasClient'
+import { BaseQueryClient } from '@/helpers/QueryClient/BaseQueryClient'
+
+
+export const fetchRelatedItems = fromCallback<
+  EventObject,
+  FromCallbackInput<AllItemsMachineContext>
+>(({ sendBack, input: { context } }) => {
+  const { ModelClass, modelName } = context
+
+  const appDb = BaseDb.getAppDb()
+
+  const relatedProperties = new Map<string, PropertyType>()
+  const relatedVersionsBySeedUid = new Map<string, Attestation[]>()
+  const schemaUidsByModelName = new Map<string, string>()
+  const mostRecentVersionsBySeedUid = new Map<string, Attestation>()
+  const mostRecentPropertiesBySeedUid = new Map<string, Attestation[]>()
+  const seedUidsByMostRecentVersionUid = new Map<string, string>()
+
+  const _fetchRelatedItems = async () => {
+    // Get related properties
+    for (const [propertyName, propertyDef] of Object.entries(
+      (ModelClass as ModelClassType).schema,
+    )) {
+      if (propertyDef && propertyDef.ref && propertyDef.refModelId) {
+        relatedProperties.set(propertyName, propertyDef)
+      }
+    }
+
+    const addresses = await getAddressesFromDb(appDb)
+
+    // Get the models they point to from sdkConfigDb
+    for (const [propertyName, propertyDef] of relatedProperties.entries()) {
+      const relatedModelQuery = await appDb
+        .select({
+          id: modelsTable.id,
+          name: modelsTable.name,
+          uid: modelUids.uid,
+        })
+        .from(modelsTable)
+        .leftJoin(modelUids, eq(modelsTable.id, modelUids.modelId))
+        .where(eq(modelsTable.id, propertyDef.refModelId))
+        .limit(1)
+
+      if (relatedModelQuery && relatedModelQuery.length > 0) {
+        const relatedModel = relatedModelQuery[0]
+        const relatedModelUid = relatedModel.uid
+        // Exclude the current model's schemaUid since we already have its versions
+        if (relatedModelUid && relatedModelUid !== ModelClass.schemaUid) {
+          schemaUidsByModelName.set(relatedModel.name, relatedModelUid)
+        }
+      }
+    }
+
+    const queryKey = [`getRelatedSeedIds${modelName}`]
+
+    const queryClient = BaseQueryClient.getQueryClient()
+    const easClient = BaseEasClient.getEasClient()
+
+    const { itemSeedIds: relatedSeedIdAttestations } =
+      await queryClient.fetchQuery({
+        queryKey,
+        queryFn: async () =>
+          easClient.request(GET_SEED_IDS, {
+            where: {
+              schema: {
+                is: {
+                  id: {
+                    in: Array.from(schemaUidsByModelName.values()),
+                  },
+                },
+              },
+              attester: {
+                in: addresses,
+              },
+            },
+          }),
+      })
+
+    const relatedSeedIds = relatedSeedIdAttestations.map((seed) => seed.id)
+
+    const { itemVersions: relatedVersions } = await queryClient.fetchQuery({
+      queryKey: [`getRelatedVersions${modelName}`],
+      queryFn: async () =>
+        easClient.request(GET_VERSIONS, {
+          where: {
+            refUID: {
+              in: relatedSeedIds,
+            },
+            attester: {
+              in: addresses,
+            },
+          },
+        }),
+    })
+
+    // Index versions by seedUid
+    for (const version of relatedVersions) {
+      const existingVersionsForSeedUid =
+        relatedVersionsBySeedUid.get(version.refUID) || []
+      existingVersionsForSeedUid.push(version)
+      relatedVersionsBySeedUid.set(version.refUID, existingVersionsForSeedUid)
+    }
+
+    // Sort the indexed versions by timeCreated and index the most recent
+    for (const [
+      seedUid,
+      versionsForSeed,
+    ] of relatedVersionsBySeedUid.entries()) {
+      const versionsForSeedSorted = versionsForSeed.sort(
+        (a: Attestation, b: Attestation) => {
+          return a.timeCreated - b.timeCreated
+        },
+      )
+      relatedVersionsBySeedUid.set(seedUid, versionsForSeedSorted)
+      mostRecentVersionsBySeedUid.set(seedUid, versionsForSeedSorted[0])
+      seedUidsByMostRecentVersionUid.set(versionsForSeedSorted[0].id, seedUid)
+    }
+
+    // Extract the ids of the most recent versions
+    const mostRecentVersionIds = Array.from(
+      mostRecentVersionsBySeedUid.values(),
+    ).map((version) => version.id)
+
+    const { allProperties } = await queryClient.fetchQuery({
+      queryKey: [`getAllProperties${modelName}`],
+      queryFn: async () =>
+        easClient.request(GET_ALL_PROPERTIES_FOR_ALL_VERSIONS, {
+          where: {
+            refUID: {
+              in: mostRecentVersionIds,
+            },
+            attester: {
+              in: addresses,
+            },
+          },
+        }),
+    })
+
+    for (const propertyAttestation of allProperties) {
+      const seedUidForProperty = seedUidsByMostRecentVersionUid.get(
+        propertyAttestation.refUID,
+      )
+      const existingPropertiesForSeedUid =
+        mostRecentPropertiesBySeedUid.get(seedUidForProperty!) || []
+      existingPropertiesForSeedUid.push(propertyAttestation)
+      mostRecentPropertiesBySeedUid.set(
+        seedUidForProperty!,
+        existingPropertiesForSeedUid,
+      )
+    }
+  }
+
+  _fetchRelatedItems().then(() => {
+    sendBack({
+      type: 'fetchRelatedItemsSuccess',
+      mostRecentPropertiesBySeedUid,
+      relatedVersionsBySeedUid,
+      relatedProperties,
+      schemaUidsByModelName,
+    })
+    return
+  })
+})

package/dist/src/fetchSeeds.ts

@@ -0,0 +1,45 @@
+import { EventObject, fromCallback } from 'xstate'
+import { GET_SEEDS } from '@/Item/queries'
+import { AllItemsMachineContext, FromCallbackInput } from '@/types'
+import { Attestation } from '@/graphql/gql/graphql'
+import { BaseEasClient } from '@/helpers/EasClient/BaseEasClient'
+import { BaseQueryClient } from '@/helpers/QueryClient/BaseQueryClient'
+import debug from 'debug'
+
+
+const logger = debug('app:allItemsActors:fetchSeeds')
+
+export const fetchSeeds = fromCallback<
+  EventObject,
+  FromCallbackInput<AllItemsMachineContext>
+>(
+  ({ sendBack, input: { context } }) => {
+    const { queryVariables, modelName } = context
+
+    if (!queryVariables) {
+      throw new Error('No queryVariables found')
+    }
+
+    let itemSeeds: Attestation[] | undefined
+
+    const _fetchSeeds = async () => {
+      const queryKey = [`getSeeds${modelName}`]
+
+      const queryClient = BaseQueryClient.getQueryClient()
+      const easClient = BaseEasClient.getEasClient()
+
+      const results = await queryClient.fetchQuery({
+        queryKey,
+        queryFn: async () => easClient.request(GET_SEEDS, queryVariables),
+      })
+
+      itemSeeds = results.itemSeeds
+    }
+
+    _fetchSeeds().then(() => {
+      sendBack({ type: 'fetchSeedsSuccess', itemSeeds })
+    })
+
+    return () => { }
+  },
+)

package/dist/src/fetchVersions.ts

@@ -0,0 +1,49 @@
+import { EventObject, fromCallback } from 'xstate'
+import { GET_VERSIONS } from '@/Item/queries'
+import { AllItemsMachineContext, FromCallbackInput } from '@/types'
+import { Attestation } from '@/graphql/gql/graphql'
+import { BaseEasClient } from '@/helpers/EasClient/BaseEasClient'
+import { BaseQueryClient } from '@/helpers/QueryClient/BaseQueryClient'
+
+
+export const fetchVersions = fromCallback<
+  EventObject,
+  FromCallbackInput<AllItemsMachineContext>
+>(
+  ({ sendBack, input: { context } }) => {
+    const { itemSeeds, modelName } = context
+
+    if (!itemSeeds) {
+      throw new Error('No queryVariables found')
+    }
+
+    let itemVersions: Attestation[] | undefined
+
+    const _fetchVersions = async () => {
+      const queryClient = BaseQueryClient.getQueryClient()
+      const easClient = BaseEasClient.getEasClient()
+
+      const seedIds = itemSeeds.map((seed) => seed.id)
+
+      const results = await queryClient.fetchQuery({
+        queryKey: [`getVersions${modelName}`],
+        queryFn: async () =>
+          easClient.request(GET_VERSIONS, {
+            where: {
+              refUID: {
+                in: seedIds,
+              },
+            },
+          }),
+      })
+
+      itemVersions = results.itemVersions
+    }
+
+    _fetchVersions().then(() => {
+      sendBack({ type: 'fetchVersionsSuccess', itemVersions })
+    })
+
+    return () => { }
+  },
+)

package/dist/src/files.ts

@@ -0,0 +1,81 @@
+import fs from '@zenfs/core'
+import * as fsNode from 'node:fs'
+import debug from 'debug'
+
+const logger = debug('app:helpers:files')
+// import * as retry from 'async-es/retry'
+
+export const listFilesInOPFSRoot = async () => {
+  // Get the root directory handle
+  const rootDirHandle = await navigator.storage.getDirectory()
+
+  // Initialize an array to hold the file names
+  let fileNames = []
+
+  // Create an async iterator to loop through directory entries
+  for await (const entry of rootDirHandle.values()) {
+    if (entry.kind === 'file') {
+      fileNames.push(entry.name)
+    }
+  }
+
+  return fileNames
+}
+
+/**
+ * Waits for a file to exist at the specified path.
+ * @param {string} filePath - The path of the file to check.
+ * @param {number} interval - The interval in milliseconds between checks (default: 500ms).
+ * @param {number} timeout - The timeout in milliseconds to wait for the file to exist (default: 10s).
+ * @returns {Promise<boolean>} - Resolves to true if the file exists within the timeout period, otherwise false.
+ */
+export const waitForFile = (
+  filePath: string,
+  interval: number = 1000,
+  timeout: number = 60000,
+): Promise<boolean> => {
+  return new Promise((resolve, reject) => {
+    const startTime = Date.now()
+
+    let isBusy = false
+
+    const _interval = setInterval(async () => {
+      logger('waitForFile', filePath)
+      if (isBusy) {
+        return
+      }
+      isBusy = true
+      if (fs.existsSync(filePath) && fsNode.existsSync(filePath)) {
+        clearInterval(_interval)
+        resolve(true)
+      }
+      if (Date.now() - startTime >= timeout) {
+        clearInterval(_interval)
+        reject(new Error('Timeout exceeded while waiting for file'))
+      }
+      isBusy = false
+    }, interval)
+
+    // retry(
+    //   {
+    //     times: Math.ceil(timeout / interval),
+    //     interval: interval,
+    //   },
+    //   (callback: Function) => {
+    //     if (fs.existsSync(filePath) && fsNode.existsSync(filePath)) {
+    //       return callback(null, true) // File exists, finish with success
+    //     }
+    //     if (Date.now() - startTime >= timeout) {
+    //       return callback(new Error('Timeout exceeded while waiting for file'))
+    //     }
+    //     callback(new Error('File does not exist yet')) // Retry with this error
+    //   },
+    //   (err: Error, result: boolean) => {
+    //     if (err) {
+    //       return resolve(false) // Resolve as false if timeout or error occurs
+    //     }
+    //     resolve(result) // Resolve as true if file exists
+    //   },
+    // )
+  })
+}