@seedprotocol/sdk 0.3.0 → 0.3.1

package/dist/src/createSeed.ts

@@ -0,0 +1,31 @@
+import { generateId } from '@/helpers'
+import { seeds } from '@/seedSchema'
+import { BaseDb } from '@/db/Db/BaseDb'
+import { getSchemaUidForModel } from '@/db/read/getSchemaUidForModel'
+
+type CreateSeedProps = {
+  type: string
+  seedUid?: string
+}
+
+export const createSeed = async ({ type, seedUid }: CreateSeedProps): Promise<string> => {
+  const schemaUid = await getSchemaUidForModel(type)
+
+  if (!schemaUid) {
+    throw new Error(`No schema found for model type: ${type}`)
+  }
+
+  const appDb = BaseDb.getAppDb()
+
+  const newSeedLocalId = generateId()
+
+  await appDb.insert(seeds).values({
+    localId: newSeedLocalId,
+    type,
+    uid: seedUid,
+    createdAt: Date.now(),
+    schemaUid,
+  })
+
+  return newSeedLocalId
+} 

package/dist/src/createSeeds.ts

@@ -0,0 +1,24 @@
+import { seeds, SeedType } from '@/seedSchema'
+import { BaseDb } from '@/db/Db/BaseDb'
+
+type CreateSeeds = (newSeeds: Partial<SeedType>[]) => Promise<string[]>
+
+export const createSeeds: CreateSeeds = async (
+  newSeeds: Partial<SeedType>[],
+) => {
+  const appDb = BaseDb.getAppDb()
+
+  const results = await appDb
+    .insert(seeds)
+    .values(newSeeds)
+    .returning({ uid: seeds.uid })
+
+  const newUids = results.reduce((acc, result) => {
+    if (result.uid) {
+      acc.push(result.uid)
+    }
+    return acc
+  }, [] as string[])
+
+  return newUids
+}

package/dist/src/createVersion.ts

@@ -0,0 +1,33 @@
+import { generateId } from '@/helpers'
+import { versions } from '@/seedSchema'
+import { BaseDb } from '../Db/BaseDb'
+
+type CreateVersionProps = {
+  seedLocalId?: string
+  seedUid?: string
+  seedType?: string
+  uid?: string
+}
+type CreateVersion = (props: CreateVersionProps) => Promise<string>
+
+export const createVersion: CreateVersion = async ({
+  seedLocalId,
+  seedUid,
+  seedType,
+  uid,
+}) => {
+  const appDb = BaseDb.getAppDb()
+
+  const newVersionLocalId = generateId()
+
+  await appDb.insert(versions).values({
+    localId: newVersionLocalId,
+    createdAt: Date.now(),
+    seedLocalId,
+    seedUid: seedUid ?? 'NULL',
+    seedType,
+    uid: uid || 'NULL',
+  })
+
+  return newVersionLocalId
+}

package/dist/src/dbMachine.ts

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

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

@@ -0,0 +1,208 @@
+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'
+import { isBrowser } from '@/helpers/environment'
+
+
+const logger = debug('app:files:download')
+
+
+export const downloadAllFilesRequestHandler = async ({
+  endpoints,
+  eventId,
+}) => {
+
+  if (!isBrowser()) {
+    return
+  }
+
+  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

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

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

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

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