@seedprotocol/sdk 0.2.51 → 0.2.53

package/dist/src/resolveRelatedValue.ts

@@ -1,367 +0,0 @@
-import { EventObject, fromCallback } from 'xstate'
-import { convertTxIdToImageSrc } from '@/helpers'
-import fs from '@zenfs/core'
-import debug from 'debug'
-import { FromCallbackInput } from '@/types/machines'
-import { PropertyMachineContext } from '@/types/property'
-import { getStorageTransactionIdForSeedUid } from '@/db/read/getStorageTransactionIdForSeedUid'
-import { getRelationValueData } from '@/db/read/getRelationValueData'
-
-const logger = debug('app:property:actors:resolveRelatedValue')
-
-const storageTransactionIdToContentUrl = new Map<string, string>()
-const refResolvedValueToContentUrl = new Map<string, string>()
-const seedUidToContentUrl = new Map<string, string>()
-
-export const resolveRelatedValue = fromCallback<
-  EventObject,
-  FromCallbackInput<PropertyMachineContext, EventObject>
->(({ sendBack, input: { context } }) => {
-  const {
-    isRelation,
-    propertyValue,
-    propertyName,
-    seedUid,
-    propertyRecordSchema,
-    populatedFromDb,
-    schemaUid,
-  } = context
-
-  const _resolveRelatedValue = async () => {
-    if (!propertyValue || !isRelation || populatedFromDb) {
-      return
-    }
-
-    let parsedValue
-
-    try {
-      parsedValue = JSON.parse(propertyValue)
-    } catch (error) {
-      logger(`${propertyName} value is not a JSON string.`)
-    }
-
-    if (!parsedValue && seedUidToContentUrl.has(propertyValue)) {
-      const contentUrl = seedUidToContentUrl.get(propertyValue)
-      sendBack({
-        type: 'updateContext',
-        renderValue: contentUrl,
-      })
-      sendBack({
-        type: 'resolvingRelatedValueSuccess',
-        refResolvedDisplayValue: contentUrl,
-      })
-      return true
-    }
-
-    if (Array.isArray(propertyValue)) {
-      // TODO: Handle array of seedUids
-      logger(`${propertyName} value is an array of seedUids`)
-      return
-    }
-
-    if (Array.isArray(parsedValue)) {
-      logger(`${propertyName} value is a stringified array of seedUids`)
-      return
-    }
-
-    const storageTransactionId =
-      await getStorageTransactionIdForSeedUid(propertyValue)
-
-    if (storageTransactionId) {
-      if (storageTransactionIdToContentUrl.has(storageTransactionId)) {
-        const contentUrl =
-          storageTransactionIdToContentUrl.get(storageTransactionId)
-        sendBack({
-          type: 'updateContext',
-          renderValue: contentUrl,
-        })
-        sendBack({
-          type: 'resolvingRelatedValueSuccess',
-          refResolvedDisplayValue: contentUrl,
-          refResolvedValue: storageTransactionId,
-        })
-        return true
-      }
-
-      const contentUrl = await convertTxIdToImageSrc(storageTransactionId)
-      if (contentUrl) {
-        seedUidToContentUrl.set(propertyValue, contentUrl)
-      }
-      sendBack({
-        type: 'updateContext',
-        renderValue: contentUrl,
-      })
-      sendBack({
-        type: 'resolvingRelatedValueSuccess',
-        refResolvedDisplayValue: contentUrl,
-        refResolvedValue: storageTransactionId,
-      })
-      return true
-    }
-
-    const relationValueData = await getRelationValueData(propertyValue)
-
-    if (relationValueData) {
-      const { refResolvedValue } = relationValueData
-      const propertyValueFromDb = relationValueData.propertyValue
-
-      // This handles a local-only relation value and resolves from the filesystem
-      if (
-        refResolvedValue &&
-        propertyRecordSchema.dataType === 'Relation' &&
-        propertyValueFromDb.length === 10 &&
-        propertyRecordSchema.ref
-      ) {
-        if (refResolvedValueToContentUrl.has(refResolvedValue)) {
-          const contentUrl = refResolvedValueToContentUrl.get(refResolvedValue)
-          sendBack({
-            type: 'updateContext',
-            renderValue: contentUrl,
-          })
-          sendBack({
-            type: 'resolvingRelatedValueSuccess',
-            refResolvedDisplayValue: contentUrl,
-          })
-          return true
-        }
-
-        const fileExists = await fs.promises.exists(
-          '/files/images/' + refResolvedValue,
-        )
-        if (fileExists) {
-          const fileContents = await fs.promises.readFile(
-            '/files/images/' + refResolvedValue,
-          )
-          const fileHandler = new File([fileContents], refResolvedValue)
-          const contentUrl = URL.createObjectURL(fileHandler)
-          refResolvedValueToContentUrl.set(refResolvedValue, contentUrl)
-          sendBack({
-            type: 'updateContext',
-            renderValue: contentUrl,
-          })
-          sendBack({
-            type: 'resolvingRelatedValueSuccess',
-            refResolvedDisplayValue: contentUrl,
-          })
-          return true
-        }
-      }
-
-      if (typeof propertyValueFromDb === 'string') {
-        // Check files for a filename that matches the propertyValue
-        if (
-          propertyRecordSchema &&
-          propertyRecordSchema.refValueType === 'ImageSrc'
-        ) {
-          let contentUrl
-
-          if (storageTransactionIdToContentUrl.has(propertyValueFromDb)) {
-            contentUrl =
-              storageTransactionIdToContentUrl.get(propertyValueFromDb)
-          }
-
-          if (!contentUrl) {
-            const imageFileExists = await fs.promises.exists(
-              `/images/${propertyValue}`,
-            )
-            if (imageFileExists) {
-              const fileContents = await fs.promises.readFile(
-                `/images/${propertyValue}`,
-              )
-              const fileHandler = new File([fileContents], propertyValue)
-              contentUrl = URL.createObjectURL(fileHandler)
-              storageTransactionIdToContentUrl.set(
-                propertyValueFromDb,
-                contentUrl,
-              )
-            }
-          }
-
-          if (contentUrl) {
-            sendBack({
-              type: 'updateContext',
-              renderValue: contentUrl,
-            })
-            sendBack({
-              type: 'resolvingRelatedValueSuccess',
-              refResolvedDisplayValue: contentUrl,
-            })
-            return true
-          }
-        }
-      }
-    }
-  }
-
-  _resolveRelatedValue().then((success) => {
-    // if (success) {
-    //   sendBack({
-    //     type: 'resolvingRelatedValueDone',
-    //   })
-    // }
-    // return
-    sendBack({
-      type: 'resolvingRelatedValueDone',
-    })
-  })
-})
-
-//   const eventKey = `storage.transaction.${initialValue}.contentUrl.response`
-//
-//   const contentUrlListener = async (event) => {
-//     console.log('[itemProperty] [constructor] contentUrlListener', event)
-//   }
-//
-//   eventEmitter.once(eventKey, contentUrlListener)
-//
-//   const ready = getArePropertyEventHandlersReady()
-//
-//   console.log('[itemProperty] [constructor] ready', ready)
-//
-//   eventEmitter.emit('storage.transaction.contentUrl.request', {
-//     storageTransactionId: initialValue,
-//   })
-
-// Related property values can either be seedUid or seedUid[]
-// let relatedSeedUid: string
-// let relatedSeedUids: string[]
-//
-// if (Array.isArray(propertyValue)) {
-//   relatedSeedUids = propertyValue
-// } else {
-//   relatedSeedUid = propertyValue
-// }
-//
-// if (relatedSeedUid) {
-//   console.log(
-//     `[property/actors] [resolveRelatedValue] seedUid: ${relatedSeedUid}`,
-//   )
-//   const latestVersionOfRelatedSeedQuery = await appDb.run(
-//     sql.raw(
-//       `
-//           SELECT local_id, uid, MAX(attestation_created_at)
-//           FROM versions
-//           WHERE seed_uid = '${relatedSeedUid}';
-//       `,
-//     ),
-//   )
-//   if (
-//     latestVersionOfRelatedSeedQuery &&
-//     latestVersionOfRelatedSeedQuery.rows &&
-//     latestVersionOfRelatedSeedQuery.rows.length > 0
-//   ) {
-//     const latestVersionOfRelatedSeed =
-//       latestVersionOfRelatedSeedQuery.rows[0]
-//     console.log(
-//       '[property/actors] [resolveRelatedValue] latestVersionOfRelatedSeed',
-//       latestVersionOfRelatedSeed,
-//     )
-//     const storageIdQuery = await appDb.run(
-//       sql.raw(
-//         `
-//             SELECT property_value, MAX(attestation_created_at), ref_resolved_display_value, ref_resolved_value
-//             FROM metadata
-//             WHERE seed_uid = '${relatedSeedUid}'
-//               AND property_name = 'storageTransactionId';
-//         `,
-//       ),
-//     )
-//
-//     if (
-//       storageIdQuery &&
-//       storageIdQuery.rows &&
-//       storageIdQuery.rows.length > 0
-//     ) {
-//       const storageId = storageIdQuery.rows[0][0]
-//
-//       if (!storageId) {
-//         console.error(
-//           `storageId not found for ${propertyName} with relatedSeedUid ${relatedSeedUid}`,
-//         )
-//       }
-//
-//       const refResolvedDisplayValue = storageIdQuery.rows[0][2]
-//       let resolvedValue = storageIdQuery.rows[0][3]
-//
-//       if (refResolvedDisplayValue && resolvedValue) {
-//         sendBack({
-//           type: 'resolvingRelatedValueSuccess',
-//           refResolvedDisplayValue,
-//           resolvedValue,
-//         })
-//         return
-//       }
-//
-//       console.log(
-//         '[property/actors] [resolveRelatedValue] storageId',
-//         storageId,
-//       )
-//
-//       const contentUrl = await convertTxIdToImageSrc(storageId)
-//
-//       if (!contentUrl) {
-//         throw new Error(
-//           `contentUrl not found for ${propertyName} with relatedSeedUid ${relatedSeedUid}`,
-//         )
-//       }
-//
-//       await appDb.run(
-//         sql.raw(
-//           `UPDATE metadata
-//            SET ref_resolved_display_value = '${contentUrl}',
-//                ref_resolved_value         = '${storageId}'
-//            WHERE seed_uid = '${relatedSeedUid}'
-//              AND property_name = 'storageTransactionId';
-//           `,
-//         ),
-//       )
-//
-//       sendBack({
-//         type: 'resolvingRelatedValueSuccess',
-//         refResolvedDisplayValue: contentUrl,
-//         resolvedValue: storageId,
-//       })
-//     }
-//   }
-//
-//   const versionUidQuery = await appDb.run(
-//     sql.raw(
-//       `
-//           SELECT uid
-//           FROM versions
-//           WHERE seed_uid = '${relatedSeedUid}';
-//       `,
-//     ),
-//   )
-//
-//   if (
-//     versionUidQuery &&
-//     versionUidQuery.rows &&
-//     versionUidQuery.rows.length > 0
-//   ) {
-//     const versionUids = versionUidQuery.rows.map((row) => row[0])
-//     console.log(
-//       '[property/actors] [resolveRelatedValue] versionUids',
-//       versionUids,
-//     )
-//     const { itemProperties } = await easClient.request(GET_PROPERTIES, {
-//       where: {
-//         refUID: {
-//           in: versionUids,
-//         },
-//         decodedDataJson: {
-//           contains: 'storage_transaction_id',
-//         },
-//       },
-//     })
-//
-//     console.log(
-//       '[property/actors] [resolveRelatedValue] itemProperties',
-//       itemProperties,
-//     )
-//
-//     if (itemProperties && itemProperties.length > 0) {
-//       await savePropertiesToDb(itemProperties)
-//     }
-//   }
-// }

package/dist/src/resolveRemoteStorage.ts

@@ -1,88 +0,0 @@
-import { EventObject, fromCallback } from 'xstate'
-import { FromCallbackInput } from '@/types/machines'
-import { PropertyMachineContext } from '@/types/property'
-import fs from '@zenfs/core'
-
-export const resolveRemoteStorage = fromCallback<
-  EventObject,
-  FromCallbackInput<PropertyMachineContext, EventObject>
->(({ sendBack, input: { context } }) => {
-  const { propertyInstances } = context
-
-  if (!propertyInstances) {
-    throw new Error(`propertyInstances not found for ${context.seedLocalId}`)
-  }
-
-  if (!propertyInstances.has('storageTransactionId')) {
-    return
-  }
-
-  const storageTransactionId = propertyInstances.get('storageTransactionId')
-
-  const _resolveRemoteStorage = async (): Promise<void> => {
-    const path = await import('path-browserify')
-
-    const filesDirExists = await fs.promises.exists('/files')
-
-    if (!filesDirExists) {
-      await fs.promises.mkdir('/files')
-    }
-
-    const htmlDir = path.join('/files', 'html')
-
-    const htmlExists = await fs.promises.exists(htmlDir)
-
-    if (htmlExists) {
-      const htmlFiles = await fs.promises.readdir(htmlDir)
-      const matchingHtmlFile = htmlFiles.find(
-        (file) => file === `${storageTransactionId}.html`,
-      )
-      if (matchingHtmlFile) {
-        const htmlString = await fs.promises.readFile(
-          path.join(htmlDir, matchingHtmlFile),
-          'utf8',
-        )
-        sendBack({
-          type: 'updateValue',
-          propertyName: 'html',
-          propertyValue: htmlString,
-        })
-      }
-    }
-
-    if (!htmlExists) {
-      await fs.promises.mkdir(htmlDir)
-    }
-
-    const jsonDir = path.join('/files', 'json')
-
-    const jsonExists = await fs.promises.exists(jsonDir)
-
-    if (jsonExists) {
-      const jsonFiles = await fs.promises.readdir(jsonDir)
-      const matchingJsonFile = jsonFiles.find(
-        (file) => file === `${storageTransactionId}.json`,
-      )
-      if (matchingJsonFile) {
-        const jsonString = await fs.promises.readFile(
-          path.join(jsonDir, matchingJsonFile),
-          'utf8',
-        )
-        sendBack({
-          type: 'updateValue',
-          propertyName: 'json',
-          propertyValue: jsonString,
-        })
-      }
-    }
-
-    if (!jsonExists) {
-      await fs.promises.mkdir(jsonDir)
-    }
-  }
-
-  _resolveRemoteStorage().then(() => {
-    sendBack({ type: 'resolveRemoteStorageSuccess' })
-    return
-  })
-})

package/dist/src/saveAppState.ts

@@ -1,19 +0,0 @@
-import { BaseDb } from '@/db/Db/BaseDb'
-import { appState } from '@/seedSchema'
-
-export const saveAppState = async (key: string, value: string) => {
-  const appDb = BaseDb.getAppDb()
-
-  await appDb
-    .insert(appState)
-    .values({
-      key,
-      value,
-    })
-    .onConflictDoUpdate({
-      target: appState.key,
-      set: {
-        value,
-      },
-    })
-}

package/dist/src/saveConfig.ts

@@ -1,88 +0,0 @@
-import { EventObject, fromCallback } from 'xstate'
-import { INTERNAL_SAVING_CONFIG_SUCCESS } from '@/services/internal/constants'
-import { BaseDb } from '@/db/Db/BaseDb'
-import debug from 'debug'
-import { FromCallbackInput, InternalMachineContext } from '@/types'
-import { appState } from '@/seedSchema'
-
-const logger = debug('app:services:internal:actors:saveConfig')
-
-export const saveConfig = fromCallback<
-  EventObject,
-  FromCallbackInput<InternalMachineContext>
->(({ sendBack, input: { context } }) => {
-  if (typeof window === 'undefined') {
-    console.error('seedInitBrowser called from non-browser context')
-    sendBack({
-      type: 'error',
-      error: 'Browser method called from non-browser context',
-    })
-  }
-
-  const { endpoints, addresses, arweaveDomain } = context
-
-  if (!endpoints) {
-    throw new Error('saveConfig called with invalid endpoints')
-  }
-
-  const _saveConfig = async (): Promise<void> => {
-    // logger('[sdk] [internal/actors] starting _saveConfig')
-    const appDb = BaseDb.getAppDb()
-    if (!appDb) {
-      throw new Error('App DB not found')
-    }
-    const endpointsValueString = JSON.stringify(endpoints)
-    const addressesValueString = JSON.stringify(addresses)
-    // TODO: Figure out how to define on conflict with multiple rows added
-    try {
-      // logger('[sdk] [internal/actors] Saving endpoints to db')
-      await appDb
-        .insert(appState)
-        .values({
-          key: 'endpoints',
-          value: endpointsValueString,
-        })
-        .onConflictDoUpdate({
-          target: appState.key,
-          set: {
-            value: endpointsValueString,
-          },
-        })
-      // logger('[sdk] [internal/actors] Saving addresses to db')
-      await appDb
-        .insert(appState)
-        .values({
-          key: 'addresses',
-          value: addressesValueString,
-        })
-        .onConflictDoUpdate({
-          target: appState.key,
-          set: {
-            value: addressesValueString,
-          },
-        })
-      await appDb
-        .insert(appState)
-        .values({
-          key: 'arweaveDomain',
-          value: arweaveDomain || 'arweave.net',
-        })
-        .onConflictDoUpdate({
-          target: appState.key,
-          set: {
-            value: arweaveDomain || 'arweave.net',
-          },
-        })
-      logger('[sdk] [internal/actors] Should be done saving')
-    } catch (error) {
-      console.error('Error saving config:', error)
-    }
-  }
-
-  _saveConfig().then(() => {
-    logger('[sdk] [internal/actors] Successfully saved config')
-    return sendBack({ type: INTERNAL_SAVING_CONFIG_SUCCESS })
-  })
-
-  return () => { }
-})

package/dist/src/saveDataToDb.ts

@@ -1,145 +0,0 @@
-import { EventObject, fromCallback } from 'xstate'
-import { itemMachineSingle } from '@/Item/service/itemMachineSingle'
-import { sql } from 'drizzle-orm'
-import { escapeSqliteString } from '@/helpers/db'
-import { generateId } from '@/helpers'
-import { BaseDb } from '@/db/Db/BaseDb'
-
-const relatedSnakeCaseToCamelCase = (snakeCase: string): string => {
-  let camelCasePropertyName = snakeCase
-
-  camelCasePropertyName = camelCasePropertyName.replace(/_(id|ids)$/, '')
-
-  return camelCasePropertyName
-    .toLowerCase()
-    .replace(/[-_][a-z]/g, (group) => group.slice(-1).toUpperCase())
-}
-
-export const saveDataToDb = fromCallback<EventObject, typeof itemMachineSingle>(
-  ({ sendBack, input: { context } }) => {
-    const {
-      modelName,
-      modelTableName,
-      versionUid,
-      versionLocalId,
-      seedLocalId,
-      propertiesBySchemaUid,
-    } = context
-
-    const _saveDataToDb = async (): Promise<void> => {
-      const appDb = BaseDb.getAppDb()
-
-      // Write fetched data from EAS to the database
-      await appDb.run(
-        sql.raw(
-          `INSERT INTO ${modelTableName} (version_local_id, seed_local_id, version_uid, created_at)
-           VALUES ('${versionLocalId}', '${seedLocalId}', '${versionUid}', ${new Date().getTime()});`,
-        ),
-      )
-
-      const existingItemQuery = await appDb.run(
-        sql.raw(
-          `SELECT id, version_local_id, version_uid, seed_local_id, created_at
-           FROM ${modelTableName}
-           WHERE version_local_id = '${versionLocalId}';`,
-        ),
-      )
-
-      let itemDbId
-
-      if (
-        existingItemQuery &&
-        existingItemQuery.rows &&
-        existingItemQuery.rows.length > 0
-      ) {
-        itemDbId = existingItemQuery.rows[0][0]
-      }
-
-      if (typeof itemDbId === 'undefined') {
-        console.error(
-          '[singleItemActors] [saveDataToDb] itemDbId not found in rows: ',
-          existingItemQuery.rows,
-        )
-        return
-      }
-
-      for (const [schemaUid, properties] of Object.entries(
-        propertiesBySchemaUid,
-      )) {
-        for (const property of properties) {
-          const json = JSON.parse(property.decodedDataJson)
-          const attestationValue = json[0].value
-          let propertyValue = attestationValue.value
-
-          if (typeof propertyValue === 'string') {
-            propertyValue = escapeSqliteString(propertyValue)
-          }
-
-          const camelCasePropertyName = relatedSnakeCaseToCamelCase(
-            attestationValue.name,
-          )
-
-          let attestationCreatedAt = property.timeCreated * 1000
-
-          await appDb.run(
-            sql.raw(
-              `INSERT INTO metadata (uid,
-                                     local_id,
-                                     property_name,
-                                     property_value,
-                                     model_type,
-                                     schema_uid,
-                                     version_uid,
-                                     eas_data_type,
-                                     created_at,
-                                     attestation_created_at)
-               VALUES ('${property.id}', '${generateId()}', '${attestationValue.name}', '${propertyValue}',
-                       '${modelTableName}', '${schemaUid}',
-                       '${versionUid}',
-                       '${attestationValue.type}',
-                       ${new Date().getTime()}, ${attestationCreatedAt}, ${itemDbId})
-               ON CONFLICT DO NOTHING;`,
-            ),
-          )
-
-          // sendBack({
-          //   type: 'updateValue',
-          //   propertyName: camelCasePropertyName,
-          //   propertyValue,
-          //   source: 'eas',
-          // })
-        }
-      }
-      // const propertiesQuery = (await appDb.run(
-      //   sql.raw(
-      //     `SELECT property_name, property_value, schema_uid
-      //      FROM metadata
-      //      WHERE version_uid = '${versionUid}'
-      //      ORDER BY created_at DESC;`,
-      //   ),
-      // )) as { rows: Array<[string, string]> }
-
-      // propertiesQuery.rows?.forEach((row) => {
-      //   const propertyName = relatedSnakeCaseToCamelCase(row[0] as string)
-      //   let propertyValue = row[1] as string
-      //   const schemaUid = row[2] as string
-      //   if (isJSONString(propertyValue)) {
-      //     propertyValue = JSON.parse(propertyValue)
-      //   }
-      //   sendBack({
-      //     type: 'updateValue',
-      //     propertyName,
-      //     propertyValue,
-      //     schemaUid,
-      //     source: 'db',
-      //   })
-      // })
-
-      return
-    }
-
-    _saveDataToDb().then(() => {
-      sendBack({ type: 'saveDataToDbSuccess' })
-    })
-  },
-)