@seedprotocol/sdk 0.1.47 → 0.1.49

package/dist/src/download.ts

@@ -0,0 +1,289 @@
+import { syncDbFiles } from '@/browser/services/internal/helpers'
+import { eventEmitter } from '@/eventBus'
+import { fs } from '@zenfs/core'
+import { ARWEAVE_HOST } from '@/browser/services/internal/constants'
+import { appState } from 'src/shared/seedSchema'
+import { eq } from 'drizzle-orm'
+import { getArweave } from '@/browser/schema/file'
+import { getAddressesFromDb } from '@/shared/helpers/db'
+import { getImageDataType, getMimeType, identifyString } from '@/shared/helpers'
+import { arweaveClient, easClient, queryClient } from '@/browser/helpers'
+import { GET_FILES_METADATA } from '@/browser/schema/file/queries'
+import debug from 'debug'
+import { getAppDb, isAppDbReady } from '@/browser/db/sqlWasmClient'
+import { getGlobalService } from '@/browser/services'
+import { waitFor } from 'xstate'
+import { writeAppState } from '@/browser/db/write'
+import { getMetadata } from '@/browser/db/read/getMetadata'
+import { saveMetadata } from '@/browser/db/write/saveMetadata'
+import { GET_TRANSACTION_TAGS } from '@/browser/arweave/queries'
+
+const logger = debug('app:files:download')
+
+export const downloadAllFilesRequestHandler = async ({
+  endpoints,
+  eventId,
+}) => {
+  await syncDbFiles(endpoints)
+
+  eventEmitter.emit('fs.downloadAll.success', { eventId })
+  eventEmitter.emit('fs.downloadAllBinary.request', { endpoints })
+}
+
+export const downloadAllFilesBinaryRequestHandler = async () => {
+  let addresses: string[] | undefined
+
+  if (isAppDbReady()) {
+    addresses = await getAddressesFromDb()
+  }
+
+  if (!isAppDbReady()) {
+    const globalService = getGlobalService()
+    const internalService = globalService.getSnapshot().context.internalService
+    if (internalService) {
+      await waitFor(internalService, (snapshot) => snapshot.value === 'ready')
+      addresses = await getAddressesFromDb()
+    }
+  }
+
+  if (!addresses || addresses.length === 0) {
+    return
+  }
+
+  const { filesMetadata } = await queryClient.fetchQuery({
+    queryKey: ['getFilesMetadata', ...addresses],
+    queryFn: async () =>
+      easClient.request(GET_FILES_METADATA, {
+        where: {
+          attester: {
+            in: addresses,
+          },
+          schema: {
+            is: {
+              id: {
+                equals:
+                  '0x55fdefb36fcbbaebeb7d6b41dc3a1a9666e4e42154267c889de064faa7ede517',
+              },
+            },
+          },
+        },
+      }),
+  })
+
+  if (!(await fs.promises.exists('/files'))) {
+    await fs.promises.mkdir('/files', { recursive: true })
+  }
+
+  if (!(await fs.promises.exists('/files/html'))) {
+    await fs.promises.mkdir('/files/html', { recursive: true })
+  }
+
+  if (!(await fs.promises.exists('/files/json'))) {
+    await fs.promises.mkdir('/files/json', { recursive: true })
+  }
+
+  if (!(await fs.promises.exists('/files/images'))) {
+    await fs.promises.mkdir('/files/images', { recursive: true })
+  }
+
+  const appDb = getAppDb()
+
+  if (!appDb) {
+    console.warn('[fetchAll/actors] [fetchAllBinaryData] seedDb not available')
+    return []
+  }
+
+  for (const fileMetadata of filesMetadata) {
+    const json = JSON.parse(fileMetadata.decodedDataJson)
+    const transactionId = json[0].value.value
+
+    const excludedTransactionsQuery = await appDb
+      .select()
+      .from(appState)
+      .where(eq(appState.key, 'excludedTransactions'))
+
+    let excludedTransactions = new Set<string>()
+
+    if (excludedTransactionsQuery && excludedTransactionsQuery.length === 1) {
+      const valueString = excludedTransactionsQuery[0].value
+      if (valueString) {
+        const excludedTransactionsArray = JSON.parse(valueString)
+        excludedTransactions = new Set(excludedTransactionsArray)
+      }
+    }
+
+    if (excludedTransactions.has(transactionId)) {
+      continue
+    }
+
+    const arweave = getArweave()
+
+    if (!arweave) {
+      console.warn(
+        '[fetchAll/actors] [fetchAllBinaryData] arweave not available',
+      )
+      return []
+    }
+
+    try {
+      const res = await fetch(
+        `https://${ARWEAVE_HOST}/tx/${transactionId}/status`,
+      )
+
+      if (res.status !== 200) {
+        logger(
+          `[fetchAll/actors] [fetchAllBinaryData] error fetching transaction data for ${transactionId}`,
+        )
+
+        excludedTransactions.add(transactionId)
+
+        await writeAppState(
+          'excludedTransactions',
+          JSON.stringify(Array.from(excludedTransactions)),
+        )
+
+        continue
+      }
+
+      const { tags } = await queryClient.fetchQuery({
+        queryKey: ['getTransactionTags', transactionId],
+        queryFn: async () =>
+          arweaveClient.request(GET_TRANSACTION_TAGS, {
+            transactionId,
+          }),
+      })
+
+      if (tags && tags.length === 0) {
+        for (const { name, value } of tags) {
+          if (name === 'Content-SHA-256') {
+            const metadataRecord = await getMetadata({
+              storageTransactionId: transactionId,
+            })
+
+            if (metadataRecord) {
+              await saveMetadata(metadataRecord, {
+                contentHash: value,
+              })
+            }
+          }
+        }
+      }
+
+      const fetchResponse = await queryClient.fetchQuery({
+        queryKey: ['fetchTransaction', transactionId],
+        queryFn: async () =>
+          fetch(`https://${ARWEAVE_HOST}/raw/${transactionId}`),
+      })
+
+      const dataString = await fetchResponse.text()
+
+      // const dataString = await arweave.transactions.getData(transactionId, {
+      //   decode: true,
+      //   string: true,
+      // })
+
+      if (!dataString) {
+        logger(
+          `[fetchAll/actors] [fetchAllBinaryData] transaction ${transactionId} data not found`,
+        )
+      }
+
+      let contentType = identifyString(dataString)
+      if (
+        contentType !== 'json' &&
+        contentType !== 'base64' &&
+        contentType !== 'html'
+      ) {
+        const possibleImageType = getImageDataType(dataString)
+        if (!possibleImageType) {
+          logger(
+            `[fetchAll/actors] [fetchAllBinaryData] transaction ${transactionId} data not in expected format: ${possibleImageType}`,
+          )
+          continue
+        }
+
+        contentType = possibleImageType
+      }
+
+      if (contentType === 'url') {
+        const url = dataString as string
+        const response = await fetch(url)
+        if (!response.ok) {
+          throw new Error(`Failed to fetch image: ${response.statusText}`)
+        }
+
+        // Get the image as a Blob
+        const blob = await response.blob()
+        const buffer = await blob.arrayBuffer()
+        const bufferUint8Array = new Uint8Array(buffer)
+
+        // Extract the file extension from the URL
+        const extensionMatch = url.match(/\.(jpg|jpeg|png|gif|bmp|webp|svg)$/i)
+        if (!extensionMatch) {
+          throw new Error(
+            'Unable to determine the file extension from the URL.',
+          )
+        }
+        const fileExtension = extensionMatch[0] // e.g., ".jpg"
+
+        // Set the file name (you can customize this)
+        // const fileNameFromUrl = `${transactionId}${fileExtension}`
+
+        await fs.promises.writeFile(
+          `/files/images/${transactionId}`,
+          bufferUint8Array,
+          {
+            encoding: 'binary',
+          },
+        )
+
+        continue
+      }
+
+      const mimeType = getMimeType(dataString as string)
+
+      let fileName = transactionId
+
+      if (contentType === 'base64') {
+        if (mimeType) {
+          fileName += `.${mimeType}`
+        }
+
+        // Remove the Base64 header if it exists (e.g., "data:image/png;base64,")
+        const base64Data = dataString.split(',').pop() || ''
+
+        // Decode the Base64 string to binary
+        const binaryString = atob(base64Data)
+        const length = binaryString.length
+        const binaryData = new Uint8Array(length)
+
+        for (let i = 0; i < length; i++) {
+          binaryData[i] = binaryString.charCodeAt(i)
+        }
+
+        await fs.promises.writeFile(`/files/images/${fileName}`, binaryData, {
+          encoding: 'binary',
+        })
+
+        // if (dataUint8Array && dataUint8Array instanceof Uint8Array) {
+        //   await fs.promises.writeFile(
+        //     `/files/images/${fileName}`,
+        //     dataUint8Array,
+        //   )
+        // }
+      }
+
+      if (contentType === 'html') {
+        fileName += '.html'
+        await fs.promises.writeFile(`/files/html/${fileName}`, dataString)
+      }
+
+      if (contentType === 'json') {
+        fileName += '.json'
+        await fs.promises.writeFile(`/files/json/${fileName}`, dataString)
+      }
+    } catch (error) {
+      logger(error)
+    }
+  }
+}

package/dist/src/drizzle.ts

@@ -0,0 +1,82 @@
+import path from 'path'
+import fs from 'fs'
+import pluralize from 'pluralize'
+import { camelCase, snakeCase } from 'lodash-es'
+import * as nunjucks from 'nunjucks'
+import { ILoader } from 'nunjucks'
+import { ModelClassType } from '@/types'
+import { SCHEMA_NJK } from '@/shared/helpers/constants'
+import {
+  appGeneratedSchemaDir,
+  dotSeedDir,
+  templatePath,
+} from '@/node/constants'
+import { getTsImport } from '@/node/helpers'
+
+const TemplateLoader: ILoader = {
+  getSource: (name: string) => {
+    let templateFilePath
+    if (name.includes(templatePath)) {
+      templateFilePath = name
+    } else {
+      templateFilePath = path.join(templatePath, path.basename(name))
+    }
+    const src = fs.readFileSync(templateFilePath, 'utf-8')
+
+    return {
+      path: name,
+      src,
+      noCache: false,
+    }
+  },
+}
+
+// Configure Nunjucks
+const env = new nunjucks.Environment(TemplateLoader)
+
+env.addFilter('camelCase', camelCase)
+env.addFilter('snakeCase', snakeCase)
+env.addFilter('pluralize', pluralize)
+
+const generateDrizzleSchemaCode = (
+  modelName: string,
+  modelClass: ModelClassType,
+): string => {
+  const listProperties = Object.entries(modelClass.schema).filter(
+    ([key, propertyDef]) => propertyDef?.dataType === 'List',
+  )
+
+  const filePath = path.join(templatePath, SCHEMA_NJK)
+
+  const schemaCode = env.render(filePath, {
+    modelName,
+    modelClass,
+    listProperties,
+  })
+
+  return schemaCode
+}
+
+export const createDrizzleSchemaFilesFromConfig = async () => {
+  const schemaFilePath = path.join(dotSeedDir, 'schema.ts') // Developer created file with model definitions
+
+  console.log('schemaFilePath:', schemaFilePath)
+
+  const { models } = await getTsImport<{
+    models: Record<string, ModelClassType>
+  }>(schemaFilePath)
+
+  console.log('models:', models)
+
+  for (const [modelName, modelClass] of Object.entries(models)) {
+    const code = generateDrizzleSchemaCode(modelName, modelClass)
+
+    if (!fs.existsSync(appGeneratedSchemaDir)) {
+      fs.mkdirSync(appGeneratedSchemaDir)
+    }
+
+    const filePath = path.join(appGeneratedSchemaDir, `${modelName}Schema.ts`)
+
+    await fs.promises.writeFile(filePath, code).catch((e) => console.error(e))
+  }
+}

package/dist/src/environment.ts

@@ -0,0 +1,15 @@
+export const isNode = (): boolean => {
+  return (
+    typeof process !== 'undefined' &&
+    process.versions != null &&
+    process.versions.node != null
+  )
+}
+
+export const isBrowser = (): boolean => {
+  return typeof window !== 'undefined' && typeof window.document !== 'undefined'
+}
+
+export const isReactNative = (): boolean => {
+  return typeof navigator !== 'undefined' && navigator.product === 'ReactNative'
+}

package/dist/src/eventBus.ts

@@ -0,0 +1,5 @@
+import EventEmitter from 'eventemitter3'
+
+const eventEmitter = new EventEmitter()
+
+export { eventEmitter }

package/dist/src/events.ts

@@ -0,0 +1,14 @@
+import { eventEmitter } from '@/eventBus'
+import debug from 'debug'
+
+const logger = debug('app:services:events')
+
+const handleServiceSaveState = (event: any) => {
+  const { state, serviceId } = event
+  logger(`[browser] [service.saveState.request] serviceId: ${serviceId}`)
+  localStorage.setItem(`seed_sdk_service_${serviceId}`, JSON.stringify(state))
+}
+
+export const setupServicesEventHandlers = () => {
+  eventEmitter.addListener('service.saveState.request', handleServiceSaveState)
+}

package/dist/src/fetchDataFromEas.ts

@@ -0,0 +1,90 @@
+import { EventObject, fromCallback } from 'xstate'
+import { GET_PROPERTIES } from '@/browser/item/queries'
+import { itemMachineSingle } from '@/browser/item/single/itemMachineSingle'
+import { PropertyType } from '@/shared/seedSchema'
+import { easClient, queryClient } from '@/browser/helpers'
+import { Attestation } from '@/browser/gql/graphql'
+import { ModelClassType } from '@/types'
+
+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> => {
+    // 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,16 @@
+import { EventObject, fromCallback } from 'xstate'
+import { itemMachineAll } from '@/browser/item/all/itemMachineAll'
+
+export const fetchDbData = fromCallback<EventObject, typeof itemMachineAll>(
+  ({ 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,179 @@
+import { EventObject, fromCallback } from 'xstate'
+import {
+  GET_ALL_PROPERTIES_FOR_ALL_VERSIONS,
+  GET_SEED_IDS,
+  GET_VERSIONS,
+} from '@/browser/item/queries'
+import {
+  models as modelsTable,
+  modelUids,
+  PropertyType,
+} from '@/shared/seedSchema'
+import { Attestation } from '@/browser/gql/graphql'
+import {
+  AllItemsMachineContext,
+  FromCallbackInput,
+  ModelClassType,
+} from '@/types'
+import { getAddressesFromDb } from '@/shared/helpers/db'
+import { eq } from 'drizzle-orm'
+import { easClient, queryClient } from '@/browser/helpers'
+import { getAppDb } from '@/browser/db/sqlWasmClient'
+
+export const fetchRelatedItems = fromCallback<
+  EventObject,
+  FromCallbackInput<AllItemsMachineContext>
+>(({ sendBack, input: { context } }) => {
+  const { ModelClass, modelName } = context
+
+  const appDb = 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 { 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
+  })
+})