@seedprotocol/sdk 0.3.1 → 0.3.2

package/dist/src/fetchDataFromEas.ts

@@ -1,94 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,184 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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
-    //   },
-    // )
-  })
-}