@seedprotocol/sdk 0.3.1 → 0.3.2

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,50 +0,0 @@
-import { FromCallbackInput } from "@/types";
-import { fromCallback } from "xstate";
-import { ClientManagerContext } from "@/types";
-import { EventObject } from "xstate";
-import debug from "debug";
-import { appState } from "@/seedSchema";
-
-const logger = debug('app:client:writeToDb')
-
-export const saveAppState = fromCallback<
-EventObject, 
-FromCallbackInput<ClientManagerContext>
->(
-  ({sendBack, input: {key, value}}) => {
-
-    const _saveAppState = async () => {
-      const { BaseDb } = await import('@/db/Db/BaseDb')
-      if (!BaseDb) {
-        throw new Error('BaseDb not found')
-      }
-      const appDb = BaseDb.getAppDb()
-      if (!appDb) {
-        throw new Error('App DB not found')
-      }
-
-      console.log(`key: ${key} value: ${value}`)
-
-      appDb.insert(appState)
-        .values({
-          key: key,
-          value: JSON.stringify(value),
-        })
-        .onConflictDoUpdate({
-          target: appState.key,
-          set: {
-            value: JSON.stringify(value),
-          },
-        })
-      
-    }
-
-    _saveAppState().then(() => {
-      sendBack({
-        type: 'saveAppStateSuccess',
-        key,
-        value,
-      })
-    })
-    
-  })

package/dist/src/saveConfig.ts

@@ -1,106 +0,0 @@
-import { EventObject, fromCallback } from 'xstate'
-import { INTERNAL_SAVING_CONFIG_SUCCESS } from '@/services/internal/constants'
-import { BaseDb } from '@/db/Db/BaseDb'
-import { FromCallbackInput, InternalMachineContext } from '@/types'
-import { appState } from '@/seedSchema'
-import debug                    from 'debug'
-import { getTableColumns, sql } from 'drizzle-orm'
-import { getTableConfig } from 'drizzle-orm/sqlite-core'
-
-const logger = debug('app:services:internal:actors:saveConfig')
-
-export const saveConfig = fromCallback<
-  EventObject,
-  FromCallbackInput<InternalMachineContext>
->(({ sendBack, input: { 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)
-
-    const tableColumns = getTableColumns(appState)
-
-    logger('tableColumns', tableColumns)
-
-    const {
-      columns,
-      indexes,
-      foreignKeys,
-      checks,
-      primaryKeys,
-      name,
-    } = getTableConfig(appState);
-
-    logger('columns', columns)
-    logger('indexes', indexes)
-    logger('foreignKeys', foreignKeys)
-    logger('checks', checks)
-    logger('primaryKeys', primaryKeys)
-    logger('name', name)
-
-    logger('calling select on db')
-
-    const queryResult = await appDb.select().from(appState)
-
-    logger('queryResult', queryResult)
-
-    // TODO: Figure out how to define on conflict with multiple rows added
-    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')
-    }
-
-  _saveConfig().then(() => {
-    logger('[sdk] [internal/actors] Successfully saved config')
-    return sendBack({ type: INTERNAL_SAVING_CONFIG_SUCCESS })
-  })
-
-  return () => { }
-})