@seedprotocol/sdk 0.2.51 → 0.2.53

package/dist/src/dbMachine.ts

@@ -1,182 +0,0 @@
-import { assign, 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 '@/services/db/actors/checkStatus'
-import { connectToDb } from '@/services/db/actors/connectToDb'
-import { validate } from '@/services/db/actors/validate'
-import { migrate } from '@/services/db/actors/migrate'
-import { waitForFiles } from './actors/waitForFiles'
-
-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,
-    waitForFiles,
-  },
-}).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',
-      },
-      invoke: {
-        src: 'waitForFiles',
-        input: ({ context }) => ({ context }),
-      },
-    },
-    [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

@@ -1,19 +0,0 @@
-import { BaseDb } from '@/db/Db/BaseDb'
-import { seeds } from '@/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 = BaseDb.getAppDb()
-
-  await appDb
-    .update(seeds)
-    .set({
-      _markedForDeletion: 1,
-    })
-    .where(or(eq(seeds.localId, seedLocalId), eq(seeds.uid, seedUid)))
-}

package/dist/src/download.ts

@@ -1,202 +0,0 @@
-import { syncDbFiles } from '@/services/internal/helpers'
-import { eventEmitter } from '@/eventBus'
-import fs from '@zenfs/core'
-import { ARWEAVE_HOST } from '@/services/internal/constants'
-import { appState } from '@/seedSchema'
-import { eq } from 'drizzle-orm'
-import { getAddressesFromDb } from '@/helpers/db'
-import {
-  BaseFileManager,
-} from '@/helpers'
-import { GET_FILES_METADATA } from '@/schema/file/queries'
-import debug from 'debug'
-import { getGlobalService } from '@/services'
-import { waitFor } from 'xstate'
-import { getMetadata } from '@/db/read/getMetadata'
-import { saveMetadata } from '@/db/write/saveMetadata'
-import { GET_TRANSACTION_TAGS } from '@/helpers/ArweaveClient/queries'
-import { saveAppState } from '@/db/write/saveAppState'
-import { BaseDb } from '@/db/Db/BaseDb'
-import { BaseEasClient, BaseQueryClient, BaseArweaveClient } from '@/helpers'
-import { getArweave } from '@/helpers/ArweaveClient'
-
-
-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 (BaseDb.isAppDbReady()) {
-    addresses = await getAddressesFromDb()
-  }
-
-  if (!BaseDb.isAppDbReady()) {
-    const globalService = getGlobalService()
-    const internalService = globalService.getSnapshot().context.internalService
-    if (internalService) {
-      await waitFor(internalService, (snapshot) => {
-        return snapshot.value === 'ready'
-      })
-      addresses = await getAddressesFromDb()
-    }
-  }
-
-  if (!addresses || addresses.length === 0) {
-    return
-  }
-
-  const queryClient = BaseQueryClient.getQueryClient()
-  const easClient = BaseEasClient.getEasClient()
-
-  const { filesMetadata } = await queryClient.fetchQuery({
-    queryKey: ['getFilesMetadata', ...addresses],
-    queryFn: async () =>
-      easClient.request(GET_FILES_METADATA, {
-        where: {
-          attester: {
-            in: addresses,
-          },
-          schema: {
-            is: {
-              id: {
-                equals:
-                  '0x55fdefb36fcbbaebeb7d6b41dc3a1a9666e4e42154267c889de064faa7ede517',
-              },
-            },
-          },
-        },
-      }),
-  })
-
-  await BaseFileManager.createDirIfNotExists('/files')
-  await BaseFileManager.createDirIfNotExists('/files/html')
-  await BaseFileManager.createDirIfNotExists('/files/json')
-  await BaseFileManager.createDirIfNotExists('/files/images')
-
-  const appDb = BaseDb.getAppDb()
-
-  if (!appDb) {
-    console.warn('[fetchAll/actors] [fetchAllBinaryData] seedDb not available')
-    return []
-  }
-
-  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)
-    }
-  }
-
-  const transactionIds = []
-
-  for (const fileMetadata of filesMetadata) {
-    const json = JSON.parse(fileMetadata.decodedDataJson)
-    const transactionId = json[0].value.value
-    if (excludedTransactions.has(transactionId)) {
-      continue
-    }
-    transactionIds.push(transactionId)
-  }
-
-  const arweave = getArweave()
-
-  if (!arweave) {
-    console.warn(
-      '[fetchAll/actors] [fetchAllBinaryData] arweave not available',
-    )
-    return []
-  }
-
-  const arweaveClient = BaseArweaveClient.getArweaveClient()
-
-  const transactionIdsToDownload = []
-
-  for (const transactionId of transactionIds) {
-
-    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 saveAppState(
-          'excludedTransactions',
-          JSON.stringify(Array.from(excludedTransactions)),
-        )
-
-        continue
-      }
-      
-      const { tags: tagsResult } = await queryClient.fetchQuery({
-        queryKey: ['getTransactionTags', transactionId],
-        queryFn: async () =>
-          arweaveClient.request(GET_TRANSACTION_TAGS, {
-            transactionId,
-          }),
-      })
-
-      const tags = tagsResult.tags || []
-
-      if (tagsResult.tags && tagsResult.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,
-              })
-            }
-          }
-        }
-      }
-
-      transactionIdsToDownload.push(transactionId)
-
-    
-
-    } catch (error) {
-      logger(error)
-    }
-  }
-
-  console.log('[download] Calling downloadAllFiles with transactionIdsToDownload', transactionIdsToDownload)
-
-  await BaseFileManager.downloadAllFiles({
-    transactionIds: transactionIdsToDownload,
-    arweaveHost: ARWEAVE_HOST,
-    excludedTransactions,
-  })
-
-  await BaseFileManager.resizeAllImages({
-    width: 480,
-    height: 480,
-  })
-}

package/dist/src/drizzle.ts

@@ -1,78 +0,0 @@
-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 '@/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
-
-  const { models } = await getTsImport<{
-    models: Record<string, ModelClassType>
-  }>(schemaFilePath)
-
-  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/eas.ts

@@ -1,40 +0,0 @@
-import { toSnakeCase } from '@/helpers'
-import { getSchemaForItemProperty } from '@/helpers/getSchemaForItemProperty'
-
-const schemaUidForSchemaDefinition = new Map<string, string>()
-
-export const setSchemaUidForSchemaDefinition = ({ text, schemaUid }) => {
-  const propertySnakeCase = toSnakeCase(text)
-  schemaUidForSchemaDefinition.set(propertySnakeCase, schemaUid)
-}
-
-export const getSchemaUidForSchemaDefinition = (schemaText: string) => {
-  const textSnakeCase = toSnakeCase(schemaText)
-  if (!schemaUidForSchemaDefinition.has(textSnakeCase)) {
-    return
-  }
-  return schemaUidForSchemaDefinition.get(textSnakeCase)
-}
-
-export const fetchSchemaUids = async () => {
-  const versionSchemaUid = await getSchemaForItemProperty({
-    propertyName: 'version',
-    easDataType: 'bytes32',
-  })
-  if (versionSchemaUid) {
-    setSchemaUidForSchemaDefinition({
-      text: 'version',
-      schemaUid: versionSchemaUid,
-    })
-  }
-  const imageSchemaUid = await getSchemaForItemProperty({
-    propertyName: 'image',
-    easDataType: 'bytes32',
-  })
-  if (imageSchemaUid) {
-    setSchemaUidForSchemaDefinition({
-      text: 'image',
-      schemaUid: imageSchemaUid,
-    })
-  }
-}

package/dist/src/environment.ts

@@ -1,35 +0,0 @@
-export const isNode = (): boolean => {
-  return (
-    typeof process !== 'undefined' &&
-    process.versions != null &&
-    process.versions.node != null
-  )
-}
-
-export const isBrowser = (): boolean => {
-  return !isElectron() && typeof window !== 'undefined' && typeof window.document !== 'undefined'
-}
-
-export const isReactNative = (): boolean => {
-  return typeof navigator !== 'undefined' && navigator.product === 'ReactNative'
-}
-
-export const isElectron = (): boolean => {
-  return typeof process !== 'undefined' && process.versions != null && process.versions.electron != null;
-}
-
-export const getEnvironment = (): string => {
-  if (isBrowser()) {
-    return 'browser'
-  }
-
-  if (isElectron()) {
-    return 'electron'
-  }
-
-  if (isReactNative()) {
-    return 'react-native'
-  }
-
-  return 'node'
-}

package/dist/src/eventBus.ts

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

package/dist/src/events.ts

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

@@ -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 () => { }
-  },
-)