@seedprotocol/sdk 0.2.43 → 0.2.45

package/dist/src/constants.ts

@@ -1,72 +1,79 @@
+const ENV = (typeof process !== 'undefined' && process.env) 
+            ? process.env 
+            : (typeof window !== 'undefined' && (window as any).env) 
+            ? (window as any).env 
+            : {};
+
+
 const MACHINE_ID_SCOPE = '@seedSdk'
 
 export enum MachineIds {
-  GLOBAL = `${MACHINE_ID_SCOPE}/global`,
-  INTERNAL = `${MACHINE_ID_SCOPE}/internal`,
-  DB = `${MACHINE_ID_SCOPE}/db`,
-  EAS = `${MACHINE_ID_SCOPE}/eas`,
-  ITEM = `${MACHINE_ID_SCOPE}/item`,
-  ALL_ITEMS = `${MACHINE_ID_SCOPE}/allItems`,
-  MODEL = `${MACHINE_ID_SCOPE}/model`,
+  GLOBAL      = `${MACHINE_ID_SCOPE}/global`,
+  INTERNAL    = `${MACHINE_ID_SCOPE}/internal`,
+  DB          = `${MACHINE_ID_SCOPE}/db`,
+  EAS         = `${MACHINE_ID_SCOPE}/eas`,
+  ITEM        = `${MACHINE_ID_SCOPE}/item`,
+  ALL_ITEMS   = `${MACHINE_ID_SCOPE}/allItems`,
+  MODEL       = `${MACHINE_ID_SCOPE}/model`,
   FILE_SYSTEM = `${MACHINE_ID_SCOPE}/fileSystem`,
 }
 
 const { INTERNAL, DB, GLOBAL, EAS, MODEL } = MachineIds
 
 export enum GlobalState {
-  UNINITIALIZED = 'uninitialized',
-  INITIALIZING = 'initializing',
-  INITIALIZED = 'initialized',
-  PUBLISHING_ITEM = 'publishingItem',
+  UNINITIALIZED       = 'uninitialized',
+  INITIALIZING        = 'initializing',
+  INITIALIZED         = 'initialized',
+  PUBLISHING_ITEM     = 'publishingItem',
   ADDING_MODELS_TO_DB = 'addingModelsToDb',
 }
 
 const {
-  UNINITIALIZED,
-  INITIALIZING,
-  INITIALIZED,
-  PUBLISHING_ITEM,
-  ADDING_MODELS_TO_DB,
-} = GlobalState
+        UNINITIALIZED,
+        INITIALIZING,
+        INITIALIZED,
+        PUBLISHING_ITEM,
+        ADDING_MODELS_TO_DB,
+      } = GlobalState
 
 export enum InternalState {
-  IDLE = 'idle',
-  INITIALIZING = 'initializing',
+  IDLE             = 'idle',
+  INITIALIZING     = 'initializing',
   VALIDATING_INPUT = 'validatingInput',
-  CONFIGURING_FS = 'configuringFs',
-  LOADING_SEED_DB = 'loadingSeedDb',
-  SAVING_CONFIG = 'savingConfig',
-  LOADING_APP_DB = 'loadingAppDb',
-  LOADING_SDK_DB = 'loadingSdkDb',
+  CONFIGURING_FS   = 'configuringFs',
+  LOADING_SEED_DB  = 'loadingSeedDb',
+  SAVING_CONFIG    = 'savingConfig',
+  LOADING_APP_DB   = 'loadingAppDb',
+  LOADING_SDK_DB   = 'loadingSdkDb',
 }
 
 const { VALIDATING_INPUT, CONFIGURING_FS, LOADING_SEED_DB, LOADING_APP_DB } =
-  InternalState
+        InternalState
 
 export enum DbState {
-  CHECKING_STATUS = 'checkingStatus',
+  CHECKING_STATUS   = 'checkingStatus',
   WAITING_FOR_FILES = 'waitingForFiles',
-  VALIDATING = 'validating',
-  CONNECTING_TO_DB = 'connectingToDb',
+  VALIDATING        = 'validating',
+  CONNECTING_TO_DB  = 'connectingToDb',
   // FETCHING_MIGRATIONS = 'fetchingMigrations',
-  MIGRATING = 'migrating',
+  MIGRATING         = 'migrating',
 }
 
 const {
-  CHECKING_STATUS,
-  VALIDATING,
-  CONNECTING_TO_DB,
-  WAITING_FOR_FILES,
-  MIGRATING,
-} = DbState
+        CHECKING_STATUS,
+        VALIDATING,
+        CONNECTING_TO_DB,
+        WAITING_FOR_FILES,
+        MIGRATING,
+      } = DbState
 
 export enum PublishMachineStates {
-  VALIDATING_ITEM_DATA = 'validatingItemData',
-  CREATING_PUBLISH_ATTEMPT = 'creatingPublishAttempt',
-  UPLOADING = 'uploading',
+  VALIDATING_ITEM_DATA           = 'validatingItemData',
+  CREATING_PUBLISH_ATTEMPT       = 'creatingPublishAttempt',
+  UPLOADING                      = 'uploading',
   PREPARING_PUBLISH_REQUEST_DATA = 'preparingPublishRequestData',
-  PUBLISHING = 'publishing',
-  IDLE = 'idle',
+  PUBLISHING                     = 'publishing',
+  IDLE                           = 'idle',
 }
 
 export const INTERNAL_VALIDATING_INPUT_SUCCESS = `${INTERNAL}.${VALIDATING_INPUT}.success`
@@ -83,36 +90,36 @@ export const INTERNAL_LOADING_APP_DB_FAILURE = `${INTERNAL}.${LOADING_APP_DB}.fa
 export const INTERNAL_SAVING_CONFIG_SUCCESS = `${INTERNAL}.savingConfig.success`
 export const INTERNAL_SAVING_CONFIG_FAILURE = `${INTERNAL}.savingConfig.failure`
 
-export const GLOBAL_GETTING_SEED_CLASS_SUCCESS = `${GLOBAL}.${PUBLISHING_ITEM}.success`
-export const GLOBAL_INITIALIZING_SEND_CONFIG = `${GLOBAL}.${INITIALIZING}.sendConfig`
-export const GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY = `${GLOBAL}.${INITIALIZING}.internalServiceReady`
+export const GLOBAL_GETTING_SEED_CLASS_SUCCESS             = `${GLOBAL}.${PUBLISHING_ITEM}.success`
+export const GLOBAL_INITIALIZING_SEND_CONFIG               = `${GLOBAL}.${INITIALIZING}.sendConfig`
+export const GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY    = `${GLOBAL}.${INITIALIZING}.internalServiceReady`
 export const GLOBAL_INITIALIZING_CREATE_ALL_ITEMS_SERVICES = `${GLOBAL}.${INITIALIZING}.createAllItemsServices`
-export const GLOBAL_ADDING_MODELS_TO_DB_SUCCESS = `${GLOBAL}.${ADDING_MODELS_TO_DB}.success`
+export const GLOBAL_ADDING_MODELS_TO_DB_SUCCESS            = `${GLOBAL}.${ADDING_MODELS_TO_DB}.success`
 
-export const DB_CHECK_STATUS_UPDATE_PATHS = `${DB}.${CHECKING_STATUS}.updatePaths`
-export const DB_CHECK_STATUS_EXISTS = `${DB}.${CHECKING_STATUS}.exists`
+export const DB_CHECK_STATUS_UPDATE_PATHS   = `${DB}.${CHECKING_STATUS}.updatePaths`
+export const DB_CHECK_STATUS_EXISTS         = `${DB}.${CHECKING_STATUS}.exists`
 export const DB_CHECK_STATUS_DOES_NOT_EXIST = `${DB}.${CHECKING_STATUS}.doesNotExist`
-export const DB_CHECK_STATUS_FAILURE = `${DB}.${CHECKING_STATUS}.failure`
+export const DB_CHECK_STATUS_FAILURE        = `${DB}.${CHECKING_STATUS}.failure`
 
-export const DB_VALIDATING_SUCCESS = `${DB}.${VALIDATING}.success`
-export const DB_VALIDATING_WAIT = `${DB}.${VALIDATING}.wait`
-export const DB_MIGRATING_WAIT = `${DB}.${MIGRATING}.wait`
-export const DB_MIGRATING_SUCCESS = `${DB}.${MIGRATING}.success`
-export const DB_CREATING_SUCCESS = `${DB}.${CONNECTING_TO_DB}.success`
+export const DB_VALIDATING_SUCCESS         = `${DB}.${VALIDATING}.success`
+export const DB_VALIDATING_WAIT            = `${DB}.${VALIDATING}.wait`
+export const DB_MIGRATING_WAIT             = `${DB}.${MIGRATING}.wait`
+export const DB_MIGRATING_SUCCESS          = `${DB}.${MIGRATING}.success`
+export const DB_CREATING_SUCCESS           = `${DB}.${CONNECTING_TO_DB}.success`
 export const DB_WAITING_FOR_FILES_RECEIVED = `${DB}.${WAITING_FOR_FILES}.filesReceived`
-export const DB_ON_SNAPSHOT = `${DB}.onSnapshot`
-export const CHILD_SNAPSHOT = 'childSnapshot'
+export const DB_ON_SNAPSHOT                = `${DB}.onSnapshot`
+export const CHILD_SNAPSHOT                = 'childSnapshot'
 
 export const INTERNAL_SERVICE_SNAPSHOT = 'internalServiceSnapshot'
 
-export const DB_NAME_APP = 'app_db'
+export const DB_NAME_APP        = 'app_db'
 export const BROWSER_FS_TOP_DIR = 'app-files'
 
 export const EAS_ENDPOINT =
-  process.env.NEXT_PUBLIC_EAS_ENDPOINT ||
-  process.env.EAS_ENDPOINT ||
-  'https://optimism-sepolia.easscan.org/graphql'
+               ENV.NEXT_PUBLIC_EAS_ENDPOINT ||
+               ENV.EAS_ENDPOINT ||
+               'https://optimism-sepolia.easscan.org/graphql'
 
-export const ARWEAVE_HOST =
-  process.env.NEXT_PUBLIC_ARWEAVE_HOST || 'arweave.net'
+export const ARWEAVE_HOST     =
+               ENV.NEXT_PUBLIC_ARWEAVE_HOST || 'arweave.net'
 export const ARWEAVE_ENDPOINT = `https://${ARWEAVE_HOST}/graphql`

package/dist/src/createMetadata.ts

@@ -1,7 +1,9 @@
 import { metadata, MetadataType } from '@/seedSchema'
-import { generateId } from '@/helpers'
+import { BaseEasClient, BaseQueryClient, generateId } from '@/helpers'
 import { PropertyType } from '@/types'
 import { BaseDb } from '../Db/BaseDb'
+import { GET_SCHEMA_BY_NAME, GET_SCHEMAS } from '@/Item/queries'
+import { INTERNAL_DATA_TYPES } from '@/helpers/constants'
 
 type CreateMetadata = (
   metadataValues: Partial<MetadataType>,
@@ -20,15 +22,38 @@ export const createMetadata: CreateMetadata = async (
     metadataValues.modelType = metadataValues.modelName.toLowerCase()
   }
 
+  const isItemStorage = propertyRecordSchema && propertyRecordSchema.storageType === 'ItemStorage'
+
   if (
     propertyRecordSchema &&
     propertyRecordSchema.localStorageDir &&
-    propertyRecordSchema.storageType === 'ItemStorage'
+    isItemStorage
   ) {
     metadataValues.refResolvedValue = `${metadataValues.seedUid || metadataValues.seedLocalId}${propertyRecordSchema.filenameSuffix}`
     metadataValues.refValueType = 'file'
   }
 
+  if (!isItemStorage && !metadataValues.schemaUid && propertyRecordSchema) {
+    const queryClient = BaseQueryClient.getQueryClient()
+    const easClient = BaseEasClient.getEasClient()
+
+    const easDataType = INTERNAL_DATA_TYPES[propertyRecordSchema.dataType].eas
+  
+    const queryResult = await queryClient.fetchQuery({
+      queryKey: [`getSchemaByName${metadataValues.propertyName}`],
+      queryFn: async () =>
+        easClient.request(GET_SCHEMA_BY_NAME, {
+          where: {
+            schema: {
+              equals: `${easDataType} ${metadataValues.propertyName}`,
+            },
+          },
+        }),
+    })
+
+    metadataValues.schemaUid = queryResult.data[0].schema
+  }
+
   return appDb
     .insert(metadata)
     .values({

package/dist/src/dbMachine.ts

@@ -17,6 +17,7 @@ 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')
 
@@ -38,6 +39,7 @@ const dbMachine = setup({
     validate,
     connectToDb,
     migrate,
+    waitForFiles,
   },
 }).createMachine({
   id: MachineIds.DB,
@@ -146,6 +148,10 @@ const dbMachine = setup({
         },
         [DB_MIGRATING_SUCCESS]: 'ready',
       },
+      invoke: {
+        src: 'waitForFiles',
+        input: ({ context }) => ({ context }),
+      },
     },
     [MIGRATING]: {
       on: {

package/dist/src/download.ts

@@ -6,10 +6,7 @@ import { appState } from '@/seedSchema'
 import { eq } from 'drizzle-orm'
 import { getAddressesFromDb } from '@/helpers/db'
 import {
-  getDataTypeFromString,
-  getMimeType,
-  identifyString,
-  isBinary,
+  BaseFileManager,
 } from '@/helpers'
 import { GET_FILES_METADATA } from '@/schema/file/queries'
 import debug from 'debug'
@@ -47,7 +44,9 @@ export const downloadAllFilesBinaryRequestHandler = async () => {
     const globalService = getGlobalService()
     const internalService = globalService.getSnapshot().context.internalService
     if (internalService) {
-      await waitFor(internalService, (snapshot) => snapshot.value === 'ready')
+      await waitFor(internalService, (snapshot) => {
+        return snapshot.value === 'ready'
+      })
       addresses = await getAddressesFromDb()
     }
   }
@@ -102,37 +101,46 @@ export const downloadAllFilesBinaryRequestHandler = async () => {
     return []
   }
 
-  for (const fileMetadata of filesMetadata) {
-    const json = JSON.parse(fileMetadata.decodedDataJson)
-    const transactionId = json[0].value.value
-
-    const excludedTransactionsQuery = await appDb
+  const excludedTransactionsQuery = await appDb
       .select()
       .from(appState)
       .where(eq(appState.key, 'excludedTransactions'))
 
-    let excludedTransactions = new Set<string>()
+  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 (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()
+  const arweave = getArweave()
 
-    if (!arweave) {
-      console.warn(
-        '[fetchAll/actors] [fetchAllBinaryData] arweave not available',
-      )
-      return []
-    }
+  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(
@@ -153,9 +161,7 @@ export const downloadAllFilesBinaryRequestHandler = async () => {
 
         continue
       }
-
-      const arweaveClient = BaseArweaveClient.getArweaveClient()
-
+      
       const { tags: tagsResult } = await queryClient.fetchQuery({
         queryKey: ['getTransactionTags', transactionId],
         queryFn: async () =>
@@ -182,186 +188,25 @@ export const downloadAllFilesBinaryRequestHandler = async () => {
         }
       }
 
-      const data = await queryClient.fetchQuery({
-        queryKey: ['fetchTransaction', transactionId],
-        queryFn: async () => {
-          const response = await fetch(
-            `https://${ARWEAVE_HOST}/raw/${transactionId}`,
-          )
-
-          const arrayBuffer = await response.arrayBuffer()
-          if (isBinary(arrayBuffer)) {
-            return arrayBuffer
-          }
+      transactionIdsToDownload.push(transactionId)
 
-          const decoder = new TextDecoder('utf-8')
-          const text = decoder.decode(arrayBuffer)
+    
 
-          return text
-        },
-        networkMode: 'offlineFirst',
-      })
-
-      let dataString
-      let arrayBuffer
-
-      if (data instanceof ArrayBuffer) {
-        arrayBuffer = data
-      }
-
-      if (typeof data === 'string') {
-        dataString = data
-      }
-
-      // const dataString = await arweave.transactions.getData(transactionId, {
-      //   decode: true,
-      //   string: true,
-      // })
-
-      if (!dataString && !arrayBuffer) {
-        logger(
-          `[fetchAll/actors] [fetchAllBinaryData] transaction ${transactionId} data not found`,
-        )
-      }
-
-      if (dataString && dataString.startsWith('===FILE_SEPARATOR===')) {
-        const dataStringParts = dataString
-          .split('===FILE_SEPARATOR===')
-          .slice(1)
-
-        if (dataStringParts.length % 2 !== 0) {
-          throw new Error('Input array must have an even number of elements.')
-        }
-
-        for (let i = 0; i < dataStringParts.length; i += 2) {
-          const contentType = dataStringParts[i]
-          const content = dataStringParts[i + 1]
-          if (contentType === 'html') {
-            const fileName = `${transactionId}.html`
-            fs.writeFileSync(`/files/html/${fileName}`, content)
-          }
-          if (contentType === 'json') {
-            const fileName = `${transactionId}.json`
-            fs.writeFileSync(`/files/json/${fileName}`, content)
-          }
-        }
-
-        continue
-      }
-
-      if (!dataString && arrayBuffer) {
-        await fs.writeFileSync(
-          `/files/images/${transactionId}`,
-          new Uint8Array(arrayBuffer),
-        )
-        continue
-      }
-
-      if (!dataString) {
-        continue
-      }
-
-      let contentType = identifyString(dataString)
-      if (
-        contentType !== 'json' &&
-        contentType !== 'base64' &&
-        contentType !== 'html'
-      ) {
-        const possibleImageType = getDataTypeFromString(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 fileExtension = mimeType
-
-      if (fileExtension && fileExtension?.startsWith('image')) {
-        fileExtension = fileExtension.replace('image/', '')
-      }
-
-      let fileName = transactionId
-
-      if (contentType === 'base64') {
-        if (fileExtension) {
-          fileName += `.${fileExtension}`
-        }
-
-        // 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)
     }
   }
+
+  console.log('[download] Calling downloadAllFiles with transactionIdsToDownload', transactionIdsToDownload)
+
+  await BaseFileManager.downloadAllFiles({
+    transactionIds: transactionIdsToDownload,
+    arweaveHost: ARWEAVE_HOST,
+    excludedTransactions,
+  })
+
+  await BaseFileManager.resizeAllImages({
+    width: 480,
+    height: 480,
+  })
 }