@seedprotocol/sdk 0.1.47 → 0.1.48

package/dist/src/dbMachine.ts

@@ -0,0 +1,181 @@
+import { assign, emit, setup } from 'xstate'
+import {
+  DB_CHECK_STATUS_EXISTS,
+  DB_CHECK_STATUS_UPDATE_PATHS,
+  DB_CREATING_SUCCESS,
+  DB_MIGRATING_SUCCESS,
+  DB_MIGRATING_WAIT,
+  DB_VALIDATING_SUCCESS,
+  DB_VALIDATING_WAIT,
+  DB_WAITING_FOR_FILES_RECEIVED,
+  DbState,
+  MachineIds,
+} from '../internal/constants'
+import debug from 'debug'
+import { DbServiceContext } from '@/types'
+import { checkStatus } from '@/browser/services/db/actors/checkStatus'
+import { connectToDb } from '@/browser/services/db/actors/connectToDb'
+import { validate } from '@/browser/services/db/actors/validate'
+import { migrate } from '@/browser/services/db/actors/migrate'
+
+const logger = debug('app:services:db:machine')
+
+const {
+  CHECKING_STATUS,
+  VALIDATING,
+  WAITING_FOR_FILES,
+  CONNECTING_TO_DB,
+  MIGRATING,
+} = DbState
+
+const dbMachine = setup({
+  types: {
+    context: {} as Partial<DbServiceContext>,
+    input: {} as Partial<DbServiceContext> | undefined,
+  },
+  actors: {
+    checkStatus,
+    validate,
+    connectToDb,
+    migrate,
+  },
+}).createMachine({
+  id: MachineIds.DB,
+  initial: CHECKING_STATUS,
+  context: ({ input }) => input as DbServiceContext,
+  on: {
+    [DB_WAITING_FOR_FILES_RECEIVED]: {
+      actions: assign({
+        hasFiles: ({ event }) => {
+          logger('[db/machine] DB_WAITING_FOR_FILES_RECEIVED event:', event)
+          return true
+        },
+      }),
+    },
+    updateHasFiles: {
+      target: `.${CHECKING_STATUS}`,
+      actions: assign({
+        hasFiles: ({ context, event }) => {
+          logger('[db/machine] updateHasFiles event:', event)
+          logger('[db/machine] updateHasFiles context:', context)
+          return event.hasFiles
+        },
+      }),
+    },
+  },
+  // always: {
+  //   target: `.${CHECKING_STATUS}`,
+  //   guard: ({ context, event }) => context.hasFiles && event.type === 'updateHasFiles',
+  // },
+  states: {
+    idle: {
+      on: {
+        start: CHECKING_STATUS,
+      },
+      meta: {
+        displayText: 'DB starting ...',
+        percentComplete: 0,
+      },
+    },
+    [CHECKING_STATUS]: {
+      on: {
+        [DB_CHECK_STATUS_UPDATE_PATHS]: {
+          actions: assign({
+            pathToDb: ({ event }) => event.pathToDb,
+            pathToDir: ({ event }) => event.pathToDir,
+            pathToDbDir: ({ event }) => event.pathToDbDir,
+          }),
+        },
+        [DB_CHECK_STATUS_EXISTS]: CONNECTING_TO_DB,
+      },
+      invoke: {
+        src: 'checkStatus',
+        input: ({ context, event }) => ({ context, event }),
+      },
+      meta: {
+        displayText: 'Checking DB status',
+        percentComplete: 60,
+      },
+    },
+    [CONNECTING_TO_DB]: {
+      on: {
+        [DB_CREATING_SUCCESS]: {
+          target: VALIDATING,
+          actions: assign({
+            dbId: ({ event }) => event.dbId,
+          }),
+        },
+      },
+      invoke: {
+        src: 'connectToDb',
+        input: ({ context }) => ({ context }),
+      },
+      meta: {
+        displayText: 'Connecting to local DB',
+        percentComplete: 70,
+      },
+    },
+    [VALIDATING]: {
+      on: {
+        [DB_VALIDATING_SUCCESS]: {
+          target: MIGRATING,
+          // guard: ({ context }) => context.hasFiles,
+        },
+        [DB_VALIDATING_WAIT]: {
+          target: WAITING_FOR_FILES,
+          // guard: ({ context }) => !context.hasFiles,
+        },
+      },
+      invoke: {
+        src: 'validate',
+        input: ({ context }) => ({ context }),
+      },
+      meta: {
+        displayText: 'Validating DB',
+        percentComplete: 80,
+      },
+    },
+    // Here we're waiting for migration and schema files to be downloaded
+    [WAITING_FOR_FILES]: {
+      on: {
+        [DB_WAITING_FOR_FILES_RECEIVED]: {
+          target: MIGRATING,
+          actions: assign({
+            hasFiles: true,
+          }),
+        },
+        [DB_MIGRATING_SUCCESS]: 'ready',
+      },
+      entry: ({ context }) => {
+        if (context.hasFiles) {
+          emit({ type: DB_WAITING_FOR_FILES_RECEIVED })
+        }
+      },
+    },
+    [MIGRATING]: {
+      on: {
+        [DB_MIGRATING_WAIT]: WAITING_FOR_FILES,
+        [DB_MIGRATING_SUCCESS]: {
+          target: 'ready',
+        },
+      },
+      invoke: {
+        src: 'migrate',
+        input: ({ context }) => ({ context }),
+      },
+      meta: {
+        displayText: 'Migrating DB',
+        percentComplete: 90,
+      },
+    },
+    ready: {
+      target: 'idle',
+      meta: {
+        displayText: 'Wrapping up the db ...',
+        percentComplete: 100,
+      },
+    },
+  },
+})
+
+export { dbMachine }

package/dist/src/deleteItem.ts

@@ -0,0 +1,19 @@
+import { getAppDb } from '../sqlWasmClient'
+import { seeds } from '@/shared/seedSchema'
+import { eq, or } from 'drizzle-orm'
+
+type DeleteItemProps = {
+  seedLocalId?: string
+  seedUid?: string
+}
+type DeleteItem = (props: DeleteItemProps) => Promise<void>
+export const deleteItem: DeleteItem = async ({ seedLocalId, seedUid }) => {
+  const appDb = getAppDb()
+
+  await appDb
+    .update(seeds)
+    .set({
+      _markedForDeletion: 1,
+    })
+    .where(or(eq(seeds.localId, seedLocalId), eq(seeds.uid, seedUid)))
+}

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' })
+  })
+})