@seedprotocol/sdk 0.1.47 → 0.1.49

package/dist/src/helpers.ts

@@ -0,0 +1,150 @@
+import { fs } from '@zenfs/core'
+import path from 'path'
+import { Endpoints } from '@/types'
+import { BROWSER_FS_TOP_DIR } from '@/browser/services/internal/constants'
+import debug from 'debug'
+
+const logger = debug('app:services:internal:helpers')
+
+/**
+ * Recursively create directories if they don't exist.
+ * @param {string} dirPath - The directory path to create.
+ */
+export const createDirectories = async (dirPath: string) => {
+  const dirPathExists = await fs.promises.exists(dirPath)
+  if (dirPathExists) {
+    return
+  }
+
+  const parentDir = path.dirname(dirPath)
+  const parentDirExists = await fs.promises.exists(parentDir)
+  if (!parentDirExists) {
+    await createDirectories(parentDir)
+  }
+
+  await fs.promises.mkdir(dirPath, { recursive: true })
+}
+
+let busy = false
+
+export const downloadFile = async (url: string, localFilePath: string) => {
+  try {
+    const response = await fetch(url)
+    const fileData = await response.text().catch((error) => {
+      console.error(`Failed to parse text from ${url}:`, error)
+    })
+    if (!fileData) {
+      console.error(`No file data from ${url}`)
+      return
+    }
+    const localDirPath = path.dirname(localFilePath)
+
+    if (busy) {
+      return
+    }
+
+    busy = true
+
+    await createDirectories(localDirPath)
+
+    const filename = path.basename(localFilePath)
+
+    const regex = /(\d+)[\w_]+\.(sql|json)$/
+
+    const match = filename.match(regex)
+
+    let migrationNumber
+
+    if (match && match.length > 1) {
+      migrationNumber = match[1]
+    }
+
+    if (migrationNumber) {
+      const filesInDir = await fs.promises.readdir(localDirPath)
+      for (const file of filesInDir) {
+        if (file === filename) {
+          continue
+        }
+        const innerMatch = file.match(regex)
+        let existingFileMigrationNumber
+        if (innerMatch && innerMatch.length > 1) {
+          existingFileMigrationNumber = innerMatch[1]
+        }
+        if (
+          migrationNumber &&
+          existingFileMigrationNumber &&
+          existingFileMigrationNumber === migrationNumber
+        ) {
+          await fs.promises.unlink(path.join(localDirPath, file))
+        }
+      }
+    }
+
+    // if (filename === '_journal.json') {
+    //   const exists = await fs.promises.exists(localFilePath)
+    //   if (exists) {
+    //     await fs.promises.rm(localFilePath)
+    //   }
+    //   await fs.promises.writeFile(localFilePath, fileData)
+    // }
+    //
+    // if (filename !== '_journal.json') {
+    //   await fs.promises.writeFile(localFilePath, fileData)
+    // }
+    await fs.promises.writeFile(localFilePath, fileData)
+  } catch (error) {
+    if (JSON.stringify(error).includes('File exists')) {
+      const fileData = await fs.promises.readFile(localFilePath, 'utf-8')
+    }
+    logger(`[Error] Failed to download file from ${url}:`, error)
+  }
+
+  busy = false
+}
+
+export const fetchDirectory = async (url: string) => {
+  const response = await fetch(url)
+  return response.json()
+}
+
+export const fetchFilesRecursively = async (
+  url: string,
+  localPath: string,
+  fileList: string[],
+) => {
+  try {
+    for (const file of fileList) {
+      const fileUrl = `${url}/${file}`
+      const fileLocalPath = path.join(localPath, file)
+
+      // logger(`[fetchFilesRecursively] fileUrl: ${fileUrl}`)
+      // logger(`[fetchFilesRecursively] fileLocalPath: ${fileLocalPath}`)
+
+      await downloadFile(fileUrl, fileLocalPath)
+    }
+  } catch (error) {
+    console.error(`Failed to fetch files from ${url}:`, error)
+  }
+}
+
+export const confirmFilesExist = async (filePaths: string[]) => {
+  let everythingDownloaded = false
+
+  for (const filePath of filePaths) {
+    const fullPath = path.join(BROWSER_FS_TOP_DIR, filePath)
+    everythingDownloaded = await fs.promises.exists(fullPath)
+  }
+
+  if (!everythingDownloaded) {
+    setTimeout(async () => {
+      await confirmFilesExist(filePaths)
+    }, 500)
+  }
+}
+
+export const syncDbFiles = async ({ filePaths, files }: Endpoints) => {
+  const fileList = await fetchDirectory(filePaths)
+  await fetchFilesRecursively(files, BROWSER_FS_TOP_DIR, fileList)
+  await confirmFilesExist(fileList)
+  logger('[syncDbFiles] Files synced!')
+}

package/dist/src/hydrateExistingItem.ts

@@ -0,0 +1,137 @@
+import { EventObject, fromCallback } from 'xstate'
+import { waitForEvent } from '@/browser/events'
+import {
+  FromCallbackInput,
+  HydrateExistingItemEvent,
+  ItemMachineContext,
+} from '@/types'
+
+export const hydrateExistingItem = fromCallback<
+  EventObject,
+  FromCallbackInput<ItemMachineContext<any>, HydrateExistingItemEvent>
+>(({ sendBack, input: { event, context } }) => {
+  const { existingItem } = event!
+  const { seedUid, seedLocalId, ModelClass } = context
+
+  if (!ModelClass) {
+    throw new Error('ModelClass not found')
+  }
+
+  const modelName = ModelClass.originalConstructor.name
+
+  const _checkForItemOnAllItemsService = async (): Promise<boolean> => {
+    if (!existingItem.seedLocalId && !existingItem.seedUid) {
+      console.warn(
+        '[singleItemActors] [hydrateExistingItem] No seedLocalId or seedUid found on existingItem',
+      )
+      return false
+    }
+
+    if (!seedUid && !seedLocalId) {
+      return false
+    }
+
+    const results = await waitForEvent({
+      req: {
+        eventLabel: 'item.request',
+        data: {
+          modelName,
+          seedUid,
+          seedLocalId,
+          source: 'hydrateExistingItem',
+        },
+      },
+      res: {
+        eventLabel: `item.${modelName}.${seedLocalId}.response`,
+      },
+    })
+
+    return true
+
+    // return new Promise((resolve) => {
+    // const timeStart = Date.now()
+    //
+    // const interval = setInterval(() => {
+    //   const timeElapsed = Date.now() - timeStart
+    //   if (timeElapsed > 2000) {
+    //     eventEmitter.emit('item.request', {
+    //       modelName,
+    //       versionUid,
+    //       versionLocalId,
+    //       source: 'hydrateExistingItem',
+    //     })
+    //   }
+    //   if (timeElapsed > 30000) {
+    //     clearInterval(interval)
+    //     console.error(
+    //       `[singleItemActors] [hydrateExistingItem] ${timeElapsed / 1000}s elapsed for ${modelName} ${versionLocalId}`,
+    //       context,
+    //     )
+    //     eventEmitter.removeListener(
+    //       `item.${modelName}.response`,
+    //       handleItemRequestResponse,
+    //     )
+    //     resolve(false)
+    //   }
+    // }, 500)
+
+    // const handleItemRequestResponse = (event) => {
+    //   if (
+    //     event.item &&
+    //     ((event.item.versionLocalId &&
+    //       event.item.versionLocalId === versionLocalId) ||
+    //       (event.item.versionUid && event.item.versionUid === versionUid))
+    //   ) {
+    //     clearInterval(interval)
+    //     eventEmitter.removeListener(
+    //       `item.${modelName}.response`,
+    //       handleItemRequestResponse,
+    //     )
+    //     resolve(true)
+    //   }
+    // }
+    //
+    // eventEmitter.addListener(
+    //   `item.${modelName}.response`,
+    //   handleItemRequestResponse,
+    // )
+    //
+    // eventEmitter.emit('item.request', {
+    //   modelName,
+    //   versionUid,
+    //   versionLocalId,
+    //   source: 'hydrateExistingItem',
+    // })
+    // })
+
+    // if (existingItem.versionLocalId && !existingItem.versionLocalId) {
+    //   console.log(
+    //     `[singleItemActors] [hydrateExistingItem] versionLocalId: ${existingItem.versionLocalId} versionUid: ${existingItem.versionUid}`,
+    //   )
+    //
+    //   return true
+    // }
+    //
+    // console.log(
+    //   `[singleItemActors] [hydrateExistingItem] versionLocalId: ${existingItem.versionLocalId} versionUid: ${existingItem.versionUid}`,
+    // )
+    // return true
+  }
+
+  _checkForItemOnAllItemsService().then((shouldContinue) => {
+    if (!shouldContinue) {
+      sendBack({ type: 'hydrateExistingItemFailure' })
+      return
+    }
+    // for (const [key, value] of Object.entries(existingItem)) {
+    //   sendBack({
+    //     type: 'updateValue',
+    //     propertyName: key,
+    //     propertyValue: value,
+    //     source: 'db',
+    //   })
+    // }
+
+    sendBack({ type: 'hydrateExistingItemSuccess' })
+  })
+})

package/dist/src/hydrateFromDb.ts

@@ -0,0 +1,254 @@
+import { EventObject, fromCallback } from 'xstate'
+import { propertyMachine } from '../propertyMachine'
+import { and, eq, or, sql } from 'drizzle-orm'
+import { escapeSqliteString } from '@/shared/helpers/db'
+import debug from 'debug'
+import { fs } from '@zenfs/core'
+import { metadata } from 'src/shared/seedSchema'
+import { getAppDb } from '@/browser/db/sqlWasmClient'
+
+const logger = debug('app:property:actors:hydrateFromDb')
+
+export const hydrateFromDb = fromCallback<EventObject, typeof propertyMachine>(
+  ({ sendBack, input: { context } }) => {
+    const {
+      seedUid,
+      seedLocalId,
+      propertyName: propertyNameRaw,
+      propertyValue,
+      propertyRecordSchema,
+      itemModelName,
+    } = context
+
+    let propertyName = propertyNameRaw
+
+    if (
+      propertyRecordSchema &&
+      propertyRecordSchema.ref &&
+      propertyRecordSchema.dataType === 'Relation' &&
+      !propertyNameRaw.endsWith('Id')
+    ) {
+      propertyName = propertyNameRaw + 'Id'
+    }
+
+    if (
+      propertyRecordSchema &&
+      propertyRecordSchema.ref &&
+      propertyRecordSchema.dataType === 'List' &&
+      !propertyNameRaw.endsWith('Ids')
+    ) {
+      propertyName = propertyNameRaw + 'Ids'
+    }
+
+    const _hydrateFromDb = async () => {
+      const db = getAppDb()
+
+      let hydrateQuery
+      let safeValue = propertyValue
+      let propertyValueQueryString = `property_value `
+      let propertyNameQueryString = `property_name = '${propertyName}'`
+      let propertyNameQuery = eq(metadata.propertyName, propertyName)
+
+      if (safeValue && typeof propertyValue === 'string') {
+        safeValue = escapeSqliteString(propertyValue)
+        propertyValueQueryString += `= '${safeValue}'`
+      }
+
+      if (!safeValue) {
+        propertyValueQueryString += 'IS NULL'
+      }
+
+      if (typeof propertyValue === 'number') {
+        propertyValueQueryString += `= ${propertyValue}`
+      }
+
+      if (
+        propertyRecordSchema &&
+        propertyRecordSchema.ref &&
+        propertyRecordSchema.dataType === 'Relation'
+      ) {
+        let missingPropertyNameVariant
+        if (propertyName.endsWith('Id')) {
+          missingPropertyNameVariant = propertyName.slice(0, -2)
+        }
+        if (!propertyName.endsWith('Id')) {
+          missingPropertyNameVariant = propertyName + 'Id'
+        }
+        propertyNameQueryString += ` OR property_name = '${missingPropertyNameVariant}'`
+        propertyNameQuery = or(
+          eq(metadata.propertyName, propertyName),
+          eq(metadata.propertyName, missingPropertyNameVariant),
+        )
+      }
+
+      const selectFromStatement = db
+        .select({
+          localId: metadata.localId,
+          uid: metadata.uid,
+          propertyName: metadata.propertyName,
+          propertyValue: metadata.propertyValue,
+          seedLocalId: metadata.seedLocalId,
+          seedUid: metadata.seedUid,
+          schemaUid: metadata.schemaUid,
+          refResolvedValue: metadata.refResolvedValue,
+          refResolvedDisplayValue: metadata.refResolvedDisplayValue,
+        })
+        .from(metadata)
+
+      if (seedUid && !seedLocalId) {
+        hydrateQuery = selectFromStatement.where(
+          and(eq(metadata.seedUid, seedUid), propertyNameQuery),
+        )
+      }
+
+      if (seedUid && seedLocalId) {
+        hydrateQuery = selectFromStatement.where(
+          and(
+            eq(metadata.seedLocalId, seedLocalId),
+            eq(metadata.seedUid, seedUid),
+            propertyNameQuery,
+          ),
+        )
+      }
+
+      if (!seedUid && seedLocalId) {
+        hydrateQuery = selectFromStatement.where(
+          and(eq(metadata.seedLocalId, seedLocalId), propertyNameQuery),
+        )
+      }
+
+      if (!hydrateQuery) {
+        return
+      }
+
+      const rows = await hydrateQuery.orderBy(
+        sql.raw('COALESCE(attestation_created_at, created_at) DESC'),
+      )
+
+      if (!rows || !rows.length) {
+        return
+      }
+
+      const firstRow = rows[0]
+
+      const {
+        localId,
+        uid,
+        propertyName: propertyNameFromDb,
+        propertyValue: propertyValueFromDb,
+        seedLocalId: seedLocalIdFromDb,
+        seedUid: seedUidFromDb,
+        schemaUid: schemaUidFromDb,
+        refResolvedValue,
+        refResolvedDisplayValue,
+      } = firstRow
+
+      if (propertyName && !propertyNameFromDb) {
+        logger(
+          `Property name from code is ${propertyName} but has not value in db ${propertyNameFromDb} for Property.${localId}`,
+        )
+      }
+
+      if (
+        propertyName &&
+        propertyNameFromDb &&
+        !propertyNameFromDb.includes(propertyName) &&
+        !propertyName.includes(propertyNameFromDb) &&
+        propertyNameFromDb !== propertyName
+      ) {
+        logger(
+          `Property name from db ${propertyNameFromDb} does not match property name ${propertyName} for Property.${localId}`,
+        )
+      }
+
+      if (propertyValue && propertyValueFromDb !== propertyValue) {
+        logger(
+          `Property value from db ${propertyValueFromDb} does not match property value ${propertyValue} for Property.${localId}`,
+        )
+      }
+
+      if (seedLocalIdFromDb !== seedLocalId) {
+        logger(
+          `Seed local id from db ${seedLocalIdFromDb} does not match seed local id ${seedLocalId} for Property.${localId}`,
+        )
+      }
+
+      if (seedUidFromDb !== seedUid) {
+        logger(
+          `Seed uid from db ${seedUidFromDb} does not match seed uid ${seedUid} for Property.${localId}`,
+        )
+      }
+
+      sendBack({
+        type: 'updateContext',
+        localId,
+        uid,
+        propertyValue: propertyValueFromDb,
+        seedLocalId: seedLocalIdFromDb,
+        seedUid: seedUidFromDb,
+        schemaUid: schemaUidFromDb,
+        resolveValue: refResolvedValue,
+        resolveDisplayValue: refResolvedDisplayValue,
+        renderValue: refResolvedDisplayValue,
+      })
+
+      if (propertyNameFromDb === 'storageTransactionId') {
+        const { Item } = await import(`@/browser/item`)
+        const item = await Item.find({
+          seedLocalId,
+          modelName: itemModelName,
+        })
+        if (item) {
+          for (const [propertyName, property] of Object.entries(
+            item.properties,
+          )) {
+            if (
+              propertyName === 'html' &&
+              propertyValueFromDb &&
+              propertyValueFromDb.length === 43
+            ) {
+              const htmlFilePath = `/files/html/${propertyValueFromDb}.html`
+              const exists = await fs.promises.exists(htmlFilePath)
+              if (!exists) {
+                return
+              }
+              const renderValue = await fs.promises
+                .readFile(htmlFilePath, 'utf8')
+                .catch((error) => {
+                  logger('Error reading html file', error)
+                })
+              property
+                .getService()
+                .send({ type: 'updateRenderValue', renderValue })
+              return
+            }
+            if (
+              propertyName === 'json' &&
+              propertyValueFromDb &&
+              propertyValueFromDb.length === 43
+            ) {
+              const jsonFilePath = `/files/json/${propertyValueFromDb}.json`
+              const exists = await fs.promises.exists(jsonFilePath)
+              if (!exists) {
+                return
+              }
+              const renderValue = await fs.promises
+                .readFile(jsonFilePath, 'utf8')
+                .catch((error) => {
+                  logger('Error reading json file', error)
+                })
+              property
+                .getService()
+                .send({ type: 'updateRenderValue', renderValue })
+              return
+            }
+          }
+        }
+      }
+    }
+
+    _hydrateFromDb().then(() => {
+      sendBack({ type: 'hydrateFromDbSuccess' })
+    })
+  },
+)

package/dist/src/hydrateNewItem.ts

@@ -0,0 +1,34 @@
+import { EventObject, fromCallback } from 'xstate'
+import { createSeed } from '@/browser/db/write'
+import { FromCallbackInput, ItemMachineContext } from '@/types'
+import { createVersion } from '@/browser/db/write/createVersion'
+
+export const hydrateNewItem = fromCallback<
+  EventObject,
+  FromCallbackInput<ItemMachineContext<any>>
+>(({ sendBack, input: { context } }) => {
+  const { seedUid, versionUid, modelName } = context
+
+  let newSeedLocalId: string
+
+  const _hydrateNewItem = async (): Promise<void> => {
+    if (!modelName) {
+      throw new Error('modelName is required')
+    }
+
+    newSeedLocalId = await createSeed({
+      type: modelName.toLowerCase(),
+      seedUid: seedUid ?? 'NULL',
+    })
+
+    await createVersion({
+      seedLocalId: newSeedLocalId,
+      seedType: modelName.toLowerCase(),
+      uid: versionUid ?? 'NULL',
+    })
+  }
+
+  _hydrateNewItem().then(() => {
+    sendBack({ type: 'hydrateNewItemSuccess' })
+  })
+})

package/dist/src/index.d.ts

@@ -0,0 +1,5 @@
+export * from './wasm.d.ts'
+
+declare module '@seedprotocol/sdk' {
+  export * from '@/'
+}

package/dist/src/index.ts

@@ -0,0 +1,73 @@
+import { assign, setup } from 'xstate'
+import {
+  fetchAllBinaryData,
+  fetchAllMetadataRecords,
+} from '@/browser/schema/file/fetchAll/actors'
+import { Attestation } from '@/browser/gql/graphql'
+
+type FetchAllFilesMachineContext = {
+  addresses: string[]
+  dbsLoaded: boolean
+  filesMetadata?: Attestation[]
+  filesBlobData?: any[]
+}
+
+export const fetchAllFilesMachine = setup({
+  types: {
+    context: {} as FetchAllFilesMachineContext,
+  },
+  actors: {
+    fetchAllMetadataRecords,
+    fetchAllBinaryData,
+  },
+}).createMachine({
+  id: 'fetchAllFiles',
+  initial: 'idle',
+  context: ({ input }) =>
+    ({
+      ...input,
+      dbsLoaded: false,
+    }) as FetchAllFilesMachineContext,
+  on: {
+    allDbsLoaded: {
+      target: '.fetchingAllMetadataRecords',
+      actions: assign({
+        dbsLoaded: true,
+      }),
+    },
+  },
+  states: {
+    idle: {},
+    fetchingAllMetadataRecords: {
+      on: {
+        fetchingAllMetadataRecordsSuccess: {
+          target: 'fetchingAllBinaryData',
+          actions: assign({
+            filesMetadata: ({ event }) => event.filesMetadata,
+          }),
+        },
+      },
+      invoke: {
+        src: 'fetchAllMetadataRecords',
+        input: ({ context, event }) => ({ context, event }),
+      },
+    },
+    fetchingAllBinaryData: {
+      on: {
+        fetchingAllBinaryDataSuccess: {
+          target: 'success',
+          actions: assign({
+            filesBlobData: ({ event }) => event.filesBlobData,
+          }),
+        },
+      },
+      invoke: {
+        src: 'fetchAllBinaryData',
+        input: ({ context }) => ({ context }),
+      },
+    },
+    success: {
+      type: 'final',
+    },
+  },
+})