@seedprotocol/sdk 0.2.50 → 0.2.52

package/dist/src/fetchRelatedItems.ts

@@ -1,184 +0,0 @@
-import { EventObject, fromCallback } from 'xstate'
-import {
-  GET_ALL_PROPERTIES_FOR_ALL_VERSIONS,
-  GET_SEED_IDS,
-  GET_VERSIONS,
-} from '@/Item/queries'
-import {
-  models as modelsTable,
-  modelUids,
-  PropertyType,
-} from '@/seedSchema'
-import { Attestation } from '@/graphql/gql/graphql'
-import {
-  AllItemsMachineContext,
-  FromCallbackInput,
-  ModelClassType,
-} from '@/types'
-import { getAddressesFromDb } from '@/helpers/db'
-import { eq } from 'drizzle-orm'
-import { BaseDb } from '@/db/Db/BaseDb'
-import { BaseEasClient } from '@/helpers/EasClient/BaseEasClient'
-import { BaseQueryClient } from '@/helpers/QueryClient/BaseQueryClient'
-
-
-export const fetchRelatedItems = fromCallback<
-  EventObject,
-  FromCallbackInput<AllItemsMachineContext>
->(({ sendBack, input: { context } }) => {
-  const { ModelClass, modelName } = context
-
-  const appDb = BaseDb.getAppDb()
-
-  const relatedProperties = new Map<string, PropertyType>()
-  const relatedVersionsBySeedUid = new Map<string, Attestation[]>()
-  const schemaUidsByModelName = new Map<string, string>()
-  const mostRecentVersionsBySeedUid = new Map<string, Attestation>()
-  const mostRecentPropertiesBySeedUid = new Map<string, Attestation[]>()
-  const seedUidsByMostRecentVersionUid = new Map<string, string>()
-
-  const _fetchRelatedItems = async () => {
-    // Get related properties
-    for (const [propertyName, propertyDef] of Object.entries(
-      (ModelClass as ModelClassType).schema,
-    )) {
-      if (propertyDef && propertyDef.ref && propertyDef.refModelId) {
-        relatedProperties.set(propertyName, propertyDef)
-      }
-    }
-
-    const addresses = await getAddressesFromDb(appDb)
-
-    // Get the models they point to from sdkConfigDb
-    for (const [propertyName, propertyDef] of relatedProperties.entries()) {
-      const relatedModelQuery = await appDb
-        .select({
-          id: modelsTable.id,
-          name: modelsTable.name,
-          uid: modelUids.uid,
-        })
-        .from(modelsTable)
-        .leftJoin(modelUids, eq(modelsTable.id, modelUids.modelId))
-        .where(eq(modelsTable.id, propertyDef.refModelId))
-        .limit(1)
-
-      if (relatedModelQuery && relatedModelQuery.length > 0) {
-        const relatedModel = relatedModelQuery[0]
-        const relatedModelUid = relatedModel.uid
-        // Exclude the current model's schemaUid since we already have its versions
-        if (relatedModelUid && relatedModelUid !== ModelClass.schemaUid) {
-          schemaUidsByModelName.set(relatedModel.name, relatedModelUid)
-        }
-      }
-    }
-
-    const queryKey = [`getRelatedSeedIds${modelName}`]
-
-    const queryClient = BaseQueryClient.getQueryClient()
-    const easClient = BaseEasClient.getEasClient()
-
-    const { itemSeedIds: relatedSeedIdAttestations } =
-      await queryClient.fetchQuery({
-        queryKey,
-        queryFn: async () =>
-          easClient.request(GET_SEED_IDS, {
-            where: {
-              schema: {
-                is: {
-                  id: {
-                    in: Array.from(schemaUidsByModelName.values()),
-                  },
-                },
-              },
-              attester: {
-                in: addresses,
-              },
-            },
-          }),
-      })
-
-    const relatedSeedIds = relatedSeedIdAttestations.map((seed) => seed.id)
-
-    const { itemVersions: relatedVersions } = await queryClient.fetchQuery({
-      queryKey: [`getRelatedVersions${modelName}`],
-      queryFn: async () =>
-        easClient.request(GET_VERSIONS, {
-          where: {
-            refUID: {
-              in: relatedSeedIds,
-            },
-            attester: {
-              in: addresses,
-            },
-          },
-        }),
-    })
-
-    // Index versions by seedUid
-    for (const version of relatedVersions) {
-      const existingVersionsForSeedUid =
-        relatedVersionsBySeedUid.get(version.refUID) || []
-      existingVersionsForSeedUid.push(version)
-      relatedVersionsBySeedUid.set(version.refUID, existingVersionsForSeedUid)
-    }
-
-    // Sort the indexed versions by timeCreated and index the most recent
-    for (const [
-      seedUid,
-      versionsForSeed,
-    ] of relatedVersionsBySeedUid.entries()) {
-      const versionsForSeedSorted = versionsForSeed.sort(
-        (a: Attestation, b: Attestation) => {
-          return a.timeCreated - b.timeCreated
-        },
-      )
-      relatedVersionsBySeedUid.set(seedUid, versionsForSeedSorted)
-      mostRecentVersionsBySeedUid.set(seedUid, versionsForSeedSorted[0])
-      seedUidsByMostRecentVersionUid.set(versionsForSeedSorted[0].id, seedUid)
-    }
-
-    // Extract the ids of the most recent versions
-    const mostRecentVersionIds = Array.from(
-      mostRecentVersionsBySeedUid.values(),
-    ).map((version) => version.id)
-
-    const { allProperties } = await queryClient.fetchQuery({
-      queryKey: [`getAllProperties${modelName}`],
-      queryFn: async () =>
-        easClient.request(GET_ALL_PROPERTIES_FOR_ALL_VERSIONS, {
-          where: {
-            refUID: {
-              in: mostRecentVersionIds,
-            },
-            attester: {
-              in: addresses,
-            },
-          },
-        }),
-    })
-
-    for (const propertyAttestation of allProperties) {
-      const seedUidForProperty = seedUidsByMostRecentVersionUid.get(
-        propertyAttestation.refUID,
-      )
-      const existingPropertiesForSeedUid =
-        mostRecentPropertiesBySeedUid.get(seedUidForProperty!) || []
-      existingPropertiesForSeedUid.push(propertyAttestation)
-      mostRecentPropertiesBySeedUid.set(
-        seedUidForProperty!,
-        existingPropertiesForSeedUid,
-      )
-    }
-  }
-
-  _fetchRelatedItems().then(() => {
-    sendBack({
-      type: 'fetchRelatedItemsSuccess',
-      mostRecentPropertiesBySeedUid,
-      relatedVersionsBySeedUid,
-      relatedProperties,
-      schemaUidsByModelName,
-    })
-    return
-  })
-})

package/dist/src/fetchSeeds.ts

@@ -1,52 +0,0 @@
-import { EventObject, fromCallback } from 'xstate'
-import { GET_SEEDS } from '@/Item/queries'
-import { AllItemsMachineContext, FromCallbackInput } from '@/types'
-import { Attestation } from '@/graphql/gql/graphql'
-import { BaseEasClient } from '@/helpers/EasClient/BaseEasClient'
-import { BaseQueryClient } from '@/helpers/QueryClient/BaseQueryClient'
-import debug from 'debug'
-
-
-const logger = debug('app:allItemsActors:fetchSeeds')
-
-export const fetchSeeds = fromCallback<
-  EventObject,
-  FromCallbackInput<AllItemsMachineContext>
->(
-  ({ sendBack, input: { context } }) => {
-    const { queryVariables, modelName } = context
-
-    if (!queryVariables) {
-      throw new Error('No queryVariables found')
-    }
-
-    let itemSeeds: Attestation[] | undefined
-
-    const _fetchSeeds = async () => {
-      const queryKey = [`getSeeds${modelName}`]
-
-      const queryClient = BaseQueryClient.getQueryClient()
-      const easClient = BaseEasClient.getEasClient()
-
-      const cachedResults = queryClient.getQueryData(queryKey)
-
-      logger(
-        `[allItemsActors] [fetchSeeds] cachedResults ${Date.now()}`,
-        cachedResults,
-      )
-
-      const results = await queryClient.fetchQuery({
-        queryKey,
-        queryFn: async () => easClient.request(GET_SEEDS, queryVariables),
-      })
-
-      itemSeeds = results.itemSeeds
-    }
-
-    _fetchSeeds().then(() => {
-      sendBack({ type: 'fetchSeedsSuccess', itemSeeds })
-    })
-
-    return () => { }
-  },
-)

package/dist/src/fetchVersions.ts

@@ -1,49 +0,0 @@
-import { EventObject, fromCallback } from 'xstate'
-import { GET_VERSIONS } from '@/Item/queries'
-import { AllItemsMachineContext, FromCallbackInput } from '@/types'
-import { Attestation } from '@/graphql/gql/graphql'
-import { BaseEasClient } from '@/helpers/EasClient/BaseEasClient'
-import { BaseQueryClient } from '@/helpers/QueryClient/BaseQueryClient'
-
-
-export const fetchVersions = fromCallback<
-  EventObject,
-  FromCallbackInput<AllItemsMachineContext>
->(
-  ({ sendBack, input: { context } }) => {
-    const { itemSeeds, modelName } = context
-
-    if (!itemSeeds) {
-      throw new Error('No queryVariables found')
-    }
-
-    let itemVersions: Attestation[] | undefined
-
-    const _fetchVersions = async () => {
-      const queryClient = BaseQueryClient.getQueryClient()
-      const easClient = BaseEasClient.getEasClient()
-
-      const seedIds = itemSeeds.map((seed) => seed.id)
-
-      const results = await queryClient.fetchQuery({
-        queryKey: [`getVersions${modelName}`],
-        queryFn: async () =>
-          easClient.request(GET_VERSIONS, {
-            where: {
-              refUID: {
-                in: seedIds,
-              },
-            },
-          }),
-      })
-
-      itemVersions = results.itemVersions
-    }
-
-    _fetchVersions().then(() => {
-      sendBack({ type: 'fetchVersionsSuccess', itemVersions })
-    })
-
-    return () => { }
-  },
-)

package/dist/src/files.ts

@@ -1,81 +0,0 @@
-import fs from '@zenfs/core'
-import * as fsNode from 'node:fs'
-import debug from 'debug'
-
-const logger = debug('app:helpers:files')
-// import * as retry from 'async-es/retry'
-
-export const listFilesInOPFSRoot = async () => {
-  // Get the root directory handle
-  const rootDirHandle = await navigator.storage.getDirectory()
-
-  // Initialize an array to hold the file names
-  let fileNames = []
-
-  // Create an async iterator to loop through directory entries
-  for await (const entry of rootDirHandle.values()) {
-    if (entry.kind === 'file') {
-      fileNames.push(entry.name)
-    }
-  }
-
-  return fileNames
-}
-
-/**
- * Waits for a file to exist at the specified path.
- * @param {string} filePath - The path of the file to check.
- * @param {number} interval - The interval in milliseconds between checks (default: 500ms).
- * @param {number} timeout - The timeout in milliseconds to wait for the file to exist (default: 10s).
- * @returns {Promise<boolean>} - Resolves to true if the file exists within the timeout period, otherwise false.
- */
-export const waitForFile = (
-  filePath: string,
-  interval: number = 1000,
-  timeout: number = 60000,
-): Promise<boolean> => {
-  return new Promise((resolve, reject) => {
-    const startTime = Date.now()
-
-    let isBusy = false
-
-    const _interval = setInterval(async () => {
-      logger('waitForFile', filePath)
-      if (isBusy) {
-        return
-      }
-      isBusy = true
-      if (fs.existsSync(filePath) && fsNode.existsSync(filePath)) {
-        clearInterval(_interval)
-        resolve(true)
-      }
-      if (Date.now() - startTime >= timeout) {
-        clearInterval(_interval)
-        reject(new Error('Timeout exceeded while waiting for file'))
-      }
-      isBusy = false
-    }, interval)
-
-    // retry(
-    //   {
-    //     times: Math.ceil(timeout / interval),
-    //     interval: interval,
-    //   },
-    //   (callback: Function) => {
-    //     if (fs.existsSync(filePath) && fsNode.existsSync(filePath)) {
-    //       return callback(null, true) // File exists, finish with success
-    //     }
-    //     if (Date.now() - startTime >= timeout) {
-    //       return callback(new Error('Timeout exceeded while waiting for file'))
-    //     }
-    //     callback(new Error('File does not exist yet')) // Retry with this error
-    //   },
-    //   (err: Error, result: boolean) => {
-    //     if (err) {
-    //       return resolve(false) // Resolve as false if timeout or error occurs
-    //     }
-    //     resolve(result) // Resolve as true if file exists
-    //   },
-    // )
-  })
-}

package/dist/src/filesDownload.ts

@@ -1,326 +0,0 @@
-
-export default `(
-  ${
-    function () {
-
-const identifyString = (str: string) => {
-  try {
-    JSON.parse(str)
-    return 'json'
-  } catch (e) {
-    // Not JSON
-  }
-
-  if (!str) {
-    return
-  }
-
-  if (str.trim().startsWith('<') && str.trim().endsWith('>')) {
-    return 'html'
-  }
-
-  // Simple markdown checks (very naive)
-  if (/^#{1,6}\s|^-{3,}|\*{3,}|^-{1,2}\s|\*\s/.test(str)) {
-    return 'markdown'
-  }
-
-  if (/^data:image\/[a-zA-Z]+;base64,[A-Za-z0-9+/]+={0,2}$/.test(str)) {
-    return 'base64'
-  }
-
-  // Default to plain text if unsure
-  return 'text'
-}
-
-const getMimeType = (base64: string) => {
-  if (!base64) {
-    return null
-  }
-  const result = base64.match(/^data:([a-zA-Z0-9]+\/[a-zA-Z0-9-.+]+).*,/)
-
-  if (result && result.length > 1) {
-    return result[1]
-  } else {
-    return null // MIME type could not be determined
-  }
-}
-
-const getDataTypeFromString = (
-  data: string,
-): 'imageBase64' | 'base64' | 'url' | null => {
-  const nonImageBase64Regex =
-    /^(?!data:image\/(?:jpeg|png|gif|bmp|webp);base64,)[A-Za-z0-9+/=]+$/
-
-  if (nonImageBase64Regex.test(data)) {
-    return 'base64'
-  }
-
-  // Regular expression for base64 (simple version, checking for base64 format)
-  const imageBase64Regex = /^data:image\/[a-zA-Z]+;base64,[A-Za-z0-9+/]+={0,2}$/
-
-  if (imageBase64Regex.test(data)) {
-    return 'imageBase64'
-  }
-
-  // Regular expression for URL (simple version, checking for common URL format)
-  const urlRegex =
-    /^(http:\/\/www\.|https:\/\/www\.|http:\/\/|https:\/\/)?[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$/
-
-  if (urlRegex.test(data)) {
-    return 'url'
-  }
-
-  return null
-}
-
-const isBinary = (arrayBuffer: ArrayBuffer): boolean => {
-  const view = new Uint8Array(arrayBuffer);
-
-  let nonTextCount = 0;
-  const threshold = 0.2; // Adjust as needed (e.g., 20% non-text implies binary)
-
-  for (let i = 0; i < view.length; i++) {
-      const byte = view[i];
-
-      // ASCII printable characters (32-126) and common whitespace (9, 10, 13)
-      if (
-          (byte >= 32 && byte <= 126) || // Printable ASCII
-          byte === 9 || byte === 10 || byte === 13 // Tab, LF, CR
-      ) {
-          continue;
-      }
-
-      nonTextCount++;
-      if (nonTextCount / view.length > threshold) {
-          return true; // More than threshold are non-text bytes
-      }
-  }
-
-  return false; // Fewer than threshold are non-text bytes
-}
-
-const saveBufferToOPFS = async (filePath: string, buffer: Uint8Array): Promise<void> => {
-  // Access the OPFS root directory
-  const rootHandle = await navigator.storage.getDirectory();
-
-  // Split the filePath into directory segments and file name
-  const segments = filePath.split('/').filter(Boolean);
-  const fileName = segments.pop(); // Extract the file name
-  if (!fileName) {
-      throw new Error('Invalid file path: No file name provided.');
-  }
-
-  // Traverse or create directories as needed
-  let currentDirHandle = rootHandle;
-  for (const segment of segments) {
-      currentDirHandle = await currentDirHandle.getDirectoryHandle(segment, { create: true });
-  }
-
-  // Create or open the file in OPFS
-  const fileHandleAsync = await currentDirHandle.getFileHandle(fileName, { create: true });
-  const fileHandle = await fileHandleAsync.createSyncAccessHandle();
-  // Write the buffer to the file
-  fileHandle.write(buffer);
-  fileHandle.flush();
-  fileHandle.close();
-}
-
-const downloadFiles = async ({
-  transactionIds,
-  arweaveHost,
-}: {
-  transactionIds: string[],
-  arweaveHost: string,
-}) => {
-
-  let arrayBuffer: ArrayBuffer | undefined
-
-  for (const transactionId of transactionIds) {
-    try {
-      const response = await fetch(`https://${arweaveHost}/raw/${transactionId}`);
-
-      arrayBuffer = await response.arrayBuffer();
-    } catch(error) {
-      console.log(`[filesDownload] transaction ${transactionId} data not found`, error)
-      globalThis.postMessage({
-        message: 'excludeTransaction',
-        transactionId,
-      })
-      continue
-    }
-
-    let dataString
-    const isBinaryData = isBinary(arrayBuffer)
-
-    if (!isBinaryData) {
-      const decoder = new TextDecoder('utf-8')
-      const text = decoder.decode(arrayBuffer)
-      dataString = text
-    }
-
-    if (!dataString && !arrayBuffer) {
-      console.log(
-        `[filesDownload] transaction ${transactionId} data not found`,
-      )
-    }
-
-    if (dataString && dataString.startsWith('===FILE_SEPARATOR===')) {
-      const dataStringParts = dataString
-        .split('===FILE_SEPARATOR===')
-        .slice(1)
-
-      if (dataStringParts.length % 2 !== 0) {
-        throw new Error('Input array must have an even number of elements.')
-      }
-
-      for (let i = 0; i < dataStringParts.length; i += 2) {
-        const contentType = dataStringParts[i]
-        const content = dataStringParts[i + 1]
-        const encoder = new TextEncoder()
-        if (contentType === 'html') {
-          const fileName = `${transactionId}.html`
-          const buffer = encoder.encode(content)
-          saveBufferToOPFS(`/files/html/${fileName}`, buffer)
-        }
-        if (contentType === 'json') {
-          const fileName = `${transactionId}.json`
-          const buffer = encoder.encode(content)
-          saveBufferToOPFS(`/files/json/${fileName}`, buffer)
-        }
-      }
-
-      continue
-    }
-
-    if (!dataString && arrayBuffer) {
-      saveBufferToOPFS(
-        `/files/images/${transactionId}`,
-        new Uint8Array(arrayBuffer),
-      )
-      continue
-    }
-
-    if (!dataString) {
-      continue
-    }
-
-    let contentType = identifyString(dataString)
-
-    if (
-      contentType !== 'json' &&
-      contentType !== 'base64' &&
-      contentType !== 'html'
-    ) {
-      const possibleImageType = getDataTypeFromString(dataString)
-      if (!possibleImageType) {
-        console.log(
-          `[filesDownload] transaction ${transactionId} data not in expected format: ${possibleImageType}`,
-        )
-        continue
-      }
-
-      contentType = possibleImageType
-    }
-
-    if (contentType === 'url') {
-      const url = dataString as string
-
-      let buffer: ArrayBuffer | undefined
-
-      try {
-        const response = await fetch(url)
-  
-        buffer = await response.arrayBuffer()
-
-      } catch(error) {
-        console.log(`[filesDownload] transaction ${transactionId} value was url: ${dataString} but failed to fetch`, error)
-        globalThis.postMessage({
-          message: 'excludeTransaction',
-          transactionId,
-        })
-        continue
-      }
-
-      const bufferUint8Array = new Uint8Array(buffer)
-
-      // Extract the file extension from the URL
-      const extensionMatch = url.match(/\.(jpg|jpeg|png|gif|bmp|webp|svg)$/i)
-      if (!extensionMatch) {
-        throw new Error(
-          'Unable to determine the file extension from the URL.',
-        )
-      }
-      const fileExtension = extensionMatch[0] // e.g., ".jpg"
-
-      // Set the file name (you can customize this)
-      // const fileNameFromUrl = `${transactionId}${fileExtension}`
-
-      await saveBufferToOPFS(
-        `/files/images/${transactionId}`,
-        bufferUint8Array,
-      )
-
-      continue
-    }
-
-    const mimeType = getMimeType(dataString as string)
-    let fileExtension = mimeType
-
-    if (fileExtension && fileExtension?.startsWith('image')) {
-      fileExtension = fileExtension.replace('image/', '')
-    }
-
-    let fileName = transactionId
-
-    if (contentType === 'base64') {
-      if (fileExtension) {
-        fileName += `.${fileExtension}`
-      }
-
-      // Remove the Base64 header if it exists (e.g., "data:image/png;base64,")
-      const base64Data = dataString.split(',').pop() || ''
-
-      // Decode the Base64 string to binary
-      const binaryString = atob(base64Data)
-      const length = binaryString.length
-      const binaryData = new Uint8Array(length)
-
-      for (let i = 0; i < length; i++) {
-        binaryData[i] = binaryString.charCodeAt(i)
-      }
-
-      await saveBufferToOPFS(`/files/images/${fileName}`, binaryData)
-
-    }
-
-    if (contentType === 'html') {
-      fileName += '.html'
-      const encoder = new TextEncoder()
-      const buffer = encoder.encode(dataString)
-      await saveBufferToOPFS(`/files/html/${fileName}`, buffer)
-    }
-
-    if (contentType === 'json') {
-      fileName += '.json'
-      const encoder = new TextEncoder()
-      const buffer = encoder.encode(dataString)
-      await saveBufferToOPFS(`/files/json/${fileName}`, buffer)
-    }
-  }
-}
-
-onmessage = async (e) => {
-  console.log({
-    message: 'filesDownload onmessage',
-    data: e.data,
-  })
-  await downloadFiles(e.data);
-  globalThis.postMessage({
-    message: 'filesDownload onmessage done',
-    done: true,
-  })
-  
-}
-}.toString()
-}
-)()`