@seedprotocol/sdk 0.2.54 → 0.3.1

package/dist/src/helpers.ts

@@ -0,0 +1,273 @@
+import fs from '@zenfs/core'
+import path from 'path'
+import { Endpoints } from '@/types'
+import { BROWSER_FS_TOP_DIR } from '@/services/internal/constants'
+import debug from 'debug'
+import { BaseFileManager } from '@/helpers/FileManager/BaseFileManager'
+
+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 BaseFileManager.pathExists(dirPath)
+  if (dirPathExists) {
+    return
+  }
+
+  const parentDir = path.dirname(dirPath)
+  let parentDirExists = await BaseFileManager.pathExists(parentDir)
+  if (!parentDirExists) {
+    await createDirectories(parentDir)
+  }
+
+  parentDirExists = await BaseFileManager.pathExists(parentDir)
+  if (parentDirExists) {
+    await BaseFileManager.createDirIfNotExists(dirPath)
+  }
+}
+
+// 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))
+//         }
+//       }
+//     }
+
+//     try {
+
+//       await fs.promises.writeFile(localFilePath, fileData)
+//       logger(`[downloadFile] Wrote file async to ${localFilePath}`)
+//     } catch (error) {
+//       fs.writeFileSync(localFilePath, fileData)
+//       logger(`[downloadFile] Wrote file sync to ${localFilePath}`)
+//     }
+//   } catch (error) {
+//     logger(`[Error] Failed to download file from ${url}:`, error)
+//   }
+
+//   busy = false
+// }
+
+type DownloadFunction = (fileUrl: string) => Promise<void>;
+
+class FileDownloadManager {
+    private filesToDownload: Map<string, number>;
+    private maxRetries: number;
+    private isDownloading: boolean = false;
+
+    constructor(fileUrls: string[], maxRetries: number) {
+        this.filesToDownload = new Map(fileUrls.map(url => [url, 0]));
+        this.maxRetries = maxRetries;
+    }
+
+    async downloadFile(url: string, localFilePath: string): Promise<void> {
+      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)
+  
+      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))
+          }
+        }
+      }
+  
+      try {
+  
+        await fs.promises.writeFile(localFilePath, fileData)
+        logger(`[downloadFile] Wrote file async to ${localFilePath}`)
+      } catch (error) {
+        fs.writeFileSync(localFilePath, fileData)
+        logger(`[downloadFile] Wrote file sync to ${localFilePath}`)
+      }
+     
+    }
+
+    async start(): Promise<void> {
+        if (this.isDownloading) {
+            console.warn("Download process is already running.");
+            return;
+        }
+
+        this.isDownloading = true;
+
+        for (const [fileUrl, attempts] of this.filesToDownload.entries()) {
+            let success = false;
+
+            while (attempts < this.maxRetries) {
+                try {
+                    console.log(`Starting download: ${fileUrl}`);
+                    await this.downloadFile(fileUrl, fileUrl);
+                    console.log(`Download successful: ${fileUrl}`);
+                    this.filesToDownload.delete(fileUrl);
+                    success = true;
+                    break; // Move to next file
+                } catch (error) {
+                    console.error(`Error downloading ${fileUrl}:`, error);
+                    this.filesToDownload.set(fileUrl, attempts + 1);
+                }
+            }
+
+            if (!success) {
+                console.error(`Failed to download after ${this.maxRetries} attempts: ${fileUrl}`);
+            }
+        }
+
+        this.isDownloading = false;
+        console.log("All downloads completed.");
+    }
+
+    addFile(fileUrl: string): void {
+        if (!this.filesToDownload.has(fileUrl)) {
+            this.filesToDownload.set(fileUrl, 0);
+            console.log(`Added file to download queue: ${fileUrl}`);
+        } else {
+            console.warn(`File already in queue: ${fileUrl}`);
+        }
+    }
+
+    getPendingFiles(): string[] {
+        return Array.from(this.filesToDownload.keys());
+    }
+
+    clear(): void {
+        this.filesToDownload.clear();
+        console.log("Cleared all files from the download queue.");
+    }
+}
+
+
+export const fetchDirectory = async (url: string) => {
+  const response = await fetch(url)
+  return response.json()
+}
+
+// export const fetchFilesRecursively = async (
+//   url: string,
+//   localPath: string,
+//   fileList: string[],
+// ) => {
+//   for (const file of fileList) {
+//     try {
+//       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) {
+    everythingDownloaded = await fs.promises.exists(filePath)
+  }
+
+  if (!everythingDownloaded) {
+    setTimeout(async () => {
+      await confirmFilesExist(filePaths)
+    }, 500)
+  }
+}
+
+const filesToExclude = ['.DS_Store']
+
+export const syncDbFiles = async ({ filePaths, files }: Endpoints) => {
+  let fileList = await fetchDirectory(filePaths)
+  fileList = fileList.filter((file: string) => !filesToExclude.includes(file))
+  fileList = fileList.map((file: string) => `${files}/${file}`)
+  const downloadManager = new FileDownloadManager(fileList, 5)
+  await downloadManager.start()
+  // 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 '@/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,270 @@
+import { EventObject, fromCallback } from 'xstate'
+import { and, eq, or, sql } from 'drizzle-orm'
+import debug from 'debug'
+import fs from '@zenfs/core'
+import { metadata } from '@/seedSchema'
+import { BaseDb } from '@/db/Db/BaseDb'
+import { updateMetadata } from '@/db/write/updateMetadata'
+import { FromCallbackInput } from '@/types/machines'
+import { PropertyMachineContext } from '@/types/property'
+import path from 'path'
+
+const logger = debug('app:property:actors:hydrateFromDb')
+
+export const hydrateFromDb = fromCallback<
+  EventObject,
+  FromCallbackInput<PropertyMachineContext, EventObject>
+>(({ sendBack, input: { context } }) => {
+  const {
+    seedUid,
+    seedLocalId,
+    propertyName: propertyNameRaw,
+    propertyRecordSchema,
+    modelName,
+  } = 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 appDb = BaseDb.getAppDb()
+
+    const isRelation =
+      propertyRecordSchema &&
+      propertyRecordSchema.ref &&
+      propertyRecordSchema.dataType === 'Relation'
+
+    const whereClauses = []
+
+    if (isRelation) {
+      let missingPropertyNameVariant
+      if (propertyName.endsWith('Id')) {
+        missingPropertyNameVariant = propertyName.slice(0, -2)
+      }
+      if (!propertyName.endsWith('Id')) {
+        missingPropertyNameVariant = propertyName + 'Id'
+      }
+      if (missingPropertyNameVariant) {
+        whereClauses.push(
+          or(
+            eq(metadata.propertyName, propertyName),
+            eq(metadata.propertyName, missingPropertyNameVariant),
+          ),
+        )
+      }
+      if (!missingPropertyNameVariant) {
+        whereClauses.push(eq(metadata.propertyName, propertyName))
+      }
+    } else {
+      whereClauses.push(eq(metadata.propertyName, propertyName))
+    }
+
+    if (seedUid) {
+      whereClauses.push(eq(metadata.seedUid, seedUid))
+    }
+
+    if (seedLocalId) {
+      whereClauses.push(eq(metadata.seedLocalId, seedLocalId))
+    }
+
+    const rows = await appDb
+      .select()
+      .from(metadata)
+      .where(and(...whereClauses))
+      .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,
+      versionLocalId: versionLocalIdFromDb,
+      versionUid: versionUidFromDb,
+      refValueType,
+      localStorageDir,
+    } = firstRow
+
+    let { refResolvedDisplayValue, refResolvedValue } = firstRow
+
+    let propertyValueProcessed: string | string[] | undefined | null =
+      propertyValueFromDb
+
+
+    if (
+      propertyRecordSchema &&
+      propertyRecordSchema.refValueType === 'ImageSrc'
+    ) {
+      let shouldReadFromFile = true
+
+      if (
+        refResolvedValue &&
+        refResolvedDisplayValue &&
+        refResolvedDisplayValue.includes('http')
+      ) {
+        try {
+          const response = await fetch(refResolvedDisplayValue, {
+            method: 'HEAD',
+          })
+
+          // Check if the status is in the 200-299 range
+          if (response.ok) {
+            shouldReadFromFile = false
+          }
+        } catch (error) {
+          shouldReadFromFile = true
+        }
+      }
+
+      if (shouldReadFromFile) {
+        let dir = localStorageDir
+        if (
+          !dir &&
+          propertyRecordSchema &&
+          propertyRecordSchema.refValueType === 'ImageSrc'
+        ) {
+          dir = 'images'
+        }
+
+        dir = dir!.replace(/^\//, '')
+
+        if (
+          !refResolvedValue &&
+          propertyValueFromDb &&
+          propertyValueFromDb.length === 66
+        ) {
+          // Here the storageTransactionId is stored on a different record and
+          // we want to add it as the refResolvedValue
+          const storageTransactionQuery = await appDb
+            .select({
+              propertyValue: metadata.propertyValue,
+            })
+            .from(metadata)
+            .where(
+              and(
+                eq(metadata.seedUid, propertyValueFromDb),
+                or(
+                  eq(metadata.propertyName, 'storageTransactionId'),
+                  eq(metadata.propertyName, 'transactionId'),
+                ),
+              ),
+            )
+
+          if (storageTransactionQuery && storageTransactionQuery.length > 0) {
+            const row = storageTransactionQuery[0]
+            refResolvedValue = row.propertyValue
+            await updateMetadata({
+              localId,
+              refResolvedValue,
+              localStorageDir: '/images',
+            })
+          }
+        }
+
+        const dirPath = `/files/${dir}`
+        const files = await fs.promises.readdir(dirPath)
+        const matchingFiles = files.filter((file) => {
+          return path.basename(file).includes(refResolvedValue!)
+        })
+        let fileExists = false
+        let filename
+        let filePath
+        if (matchingFiles && matchingFiles.length > 0) {
+          fileExists = true
+          filename = matchingFiles[0]
+          filePath = `/files/${dir}/${filename}`
+        }
+        if (fileExists && filename && filePath) {
+          const fileContents = await fs.promises.readFile(filePath)
+          const fileHandler = new File([fileContents], filename)
+          refResolvedDisplayValue = URL.createObjectURL(fileHandler)
+          await updateMetadata({
+            localId,
+            refResolvedValue: filename,
+          })
+        }
+      }
+    }
+
+    if (
+      propertyRecordSchema &&
+      propertyRecordSchema.dataType === 'List' &&
+      propertyRecordSchema.ref &&
+      typeof propertyValueFromDb === 'string'
+    ) {
+      propertyValueProcessed = propertyValueFromDb.split(',')
+    }
+
+    sendBack({
+      type: 'updateContext',
+      localId,
+      uid,
+      propertyValue: propertyValueProcessed,
+      seedLocalId: seedLocalIdFromDb,
+      seedUid: seedUidFromDb,
+      versionLocalId: versionLocalIdFromDb,
+      versionUid: versionUidFromDb,
+      schemaUid: schemaUidFromDb,
+      refValueType,
+      localStorageDir,
+      refResolvedValue,
+      refResolvedDisplayValue,
+      renderValue: refResolvedDisplayValue,
+      populatedFromDb: true,
+    })
+
+    if (
+      propertyRecordSchema &&
+      propertyRecordSchema.storageType &&
+      propertyRecordSchema.storageType === 'ItemStorage'
+    ) {
+      const { Item } = await import(`@/browser/Item`)
+      const item = await Item.find({
+        seedLocalId,
+        modelName,
+      })
+      if (item) {
+        const filePath = `/files/${localStorageDir}/${refResolvedValue}`
+        const exists = await fs.promises.exists(filePath)
+
+        if (!exists) {
+          return
+        }
+
+        const renderValue = await fs.promises.readFile(filePath, 'utf8')
+        const property = item.properties[propertyName]
+        property.getService().send({ type: 'updateContext', renderValue })
+        return
+      }
+    }
+  }
+
+  _hydrateFromDb().then(() => {
+    sendBack({ type: 'hydrateFromDbSuccess' })
+  })
+})

package/dist/src/hydrateNewItem.ts

@@ -0,0 +1,34 @@
+import { EventObject, fromCallback } from 'xstate'
+import { createSeed } from '@/db/write/createSeed'
+import { FromCallbackInput, ItemMachineContext } from '@/types'
+import { createVersion } from '@/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' })
+  })
+})