@seedprotocol/sdk 0.2.50 → 0.2.52

package/dist/src/helpers.ts

@@ -1,273 +0,0 @@
-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 fs.promises.exists(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

@@ -1,137 +0,0 @@
-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

@@ -1,270 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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' })
-  })
-})