@seedprotocol/sdk 0.3.0 → 0.3.1

package/dist/src/saveDataToDb.ts

@@ -0,0 +1,145 @@
+import { EventObject, fromCallback } from 'xstate'
+import { itemMachineSingle } from '@/Item/service/itemMachineSingle'
+import { sql } from 'drizzle-orm'
+import { escapeSqliteString } from '@/helpers/db'
+import { generateId } from '@/helpers'
+import { BaseDb } from '@/db/Db/BaseDb'
+
+const relatedSnakeCaseToCamelCase = (snakeCase: string): string => {
+  let camelCasePropertyName = snakeCase
+
+  camelCasePropertyName = camelCasePropertyName.replace(/_(id|ids)$/, '')
+
+  return camelCasePropertyName
+    .toLowerCase()
+    .replace(/[-_][a-z]/g, (group) => group.slice(-1).toUpperCase())
+}
+
+export const saveDataToDb = fromCallback<EventObject, typeof itemMachineSingle>(
+  ({ sendBack, input: { context } }) => {
+    const {
+      modelName,
+      modelTableName,
+      versionUid,
+      versionLocalId,
+      seedLocalId,
+      propertiesBySchemaUid,
+    } = context
+
+    const _saveDataToDb = async (): Promise<void> => {
+      const appDb = BaseDb.getAppDb()
+
+      // Write fetched data from EAS to the database
+      await appDb.run(
+        sql.raw(
+          `INSERT INTO ${modelTableName} (version_local_id, seed_local_id, version_uid, created_at)
+           VALUES ('${versionLocalId}', '${seedLocalId}', '${versionUid}', ${new Date().getTime()});`,
+        ),
+      )
+
+      const existingItemQuery = await appDb.run(
+        sql.raw(
+          `SELECT id, version_local_id, version_uid, seed_local_id, created_at
+           FROM ${modelTableName}
+           WHERE version_local_id = '${versionLocalId}';`,
+        ),
+      )
+
+      let itemDbId
+
+      if (
+        existingItemQuery &&
+        existingItemQuery.rows &&
+        existingItemQuery.rows.length > 0
+      ) {
+        itemDbId = existingItemQuery.rows[0][0]
+      }
+
+      if (typeof itemDbId === 'undefined') {
+        console.error(
+          '[singleItemActors] [saveDataToDb] itemDbId not found in rows: ',
+          existingItemQuery.rows,
+        )
+        return
+      }
+
+      for (const [schemaUid, properties] of Object.entries(
+        propertiesBySchemaUid,
+      )) {
+        for (const property of properties) {
+          const json = JSON.parse(property.decodedDataJson)
+          const attestationValue = json[0].value
+          let propertyValue = attestationValue.value
+
+          if (typeof propertyValue === 'string') {
+            propertyValue = escapeSqliteString(propertyValue)
+          }
+
+          const camelCasePropertyName = relatedSnakeCaseToCamelCase(
+            attestationValue.name,
+          )
+
+          let attestationCreatedAt = property.timeCreated * 1000
+
+          await appDb.run(
+            sql.raw(
+              `INSERT INTO metadata (uid,
+                                     local_id,
+                                     property_name,
+                                     property_value,
+                                     model_type,
+                                     schema_uid,
+                                     version_uid,
+                                     eas_data_type,
+                                     created_at,
+                                     attestation_created_at)
+               VALUES ('${property.id}', '${generateId()}', '${attestationValue.name}', '${propertyValue}',
+                       '${modelTableName}', '${schemaUid}',
+                       '${versionUid}',
+                       '${attestationValue.type}',
+                       ${new Date().getTime()}, ${attestationCreatedAt}, ${itemDbId})
+               ON CONFLICT DO NOTHING;`,
+            ),
+          )
+
+          // sendBack({
+          //   type: 'updateValue',
+          //   propertyName: camelCasePropertyName,
+          //   propertyValue,
+          //   source: 'eas',
+          // })
+        }
+      }
+      // const propertiesQuery = (await appDb.run(
+      //   sql.raw(
+      //     `SELECT property_name, property_value, schema_uid
+      //      FROM metadata
+      //      WHERE version_uid = '${versionUid}'
+      //      ORDER BY created_at DESC;`,
+      //   ),
+      // )) as { rows: Array<[string, string]> }
+
+      // propertiesQuery.rows?.forEach((row) => {
+      //   const propertyName = relatedSnakeCaseToCamelCase(row[0] as string)
+      //   let propertyValue = row[1] as string
+      //   const schemaUid = row[2] as string
+      //   if (isJSONString(propertyValue)) {
+      //     propertyValue = JSON.parse(propertyValue)
+      //   }
+      //   sendBack({
+      //     type: 'updateValue',
+      //     propertyName,
+      //     propertyValue,
+      //     schemaUid,
+      //     source: 'db',
+      //   })
+      // })
+
+      return
+    }
+
+    _saveDataToDb().then(() => {
+      sendBack({ type: 'saveDataToDbSuccess' })
+    })
+  },
+)

package/dist/src/saveImageSrc.ts

@@ -0,0 +1,242 @@
+import { EventObject, fromCallback } from 'xstate'
+import { FromCallbackInput } from '@/types/machines'
+import {
+  ItemPropertyValueType,
+  PropertyMachineContext,
+  SaveValueToDbEvent,
+} from '@/types/property'
+import { createSeed } from '@/db/write/createSeed'
+import { getDataTypeFromString, getMimeType } from '@/helpers'
+import { createVersion } from '@/db/write/createVersion'
+import fs from '@zenfs/core'
+import { createMetadata } from '@/db/write/createMetadata'
+import { updateItemPropertyValue } from '@/db/write/updateItemPropertyValue'
+import { getSchemaUidForSchemaDefinition } from '@/stores/eas'
+import { getSchemaUidForModel } from '@/db/read/getSchemaUidForModel'
+import { BaseFileManager } from '@/helpers/FileManager/BaseFileManager'
+import { eventEmitter } from '@/eventBus'
+import { ImageSize } from '@/helpers/constants'
+
+
+
+const readFileAsArrayBuffer = async (file: File): Promise<ArrayBuffer> => {
+  return new Promise((resolve) => {
+    const reader = new FileReader()
+    reader.onload = async (e) => {
+      const arrayBuffer = e.target.result as ArrayBuffer
+
+      resolve(arrayBuffer)
+    }
+
+    reader.readAsArrayBuffer(file)
+  })
+}
+
+const fetchImage = async (url: string) => {
+  const response = await fetch(url)
+  const mimeType = response.headers.get('Content-Type')
+  const imageBuffer = await response.arrayBuffer()
+  const bytes = new Uint8Array(imageBuffer)
+
+  const binaryString = bytes.reduce(
+    (acc, byte) => acc + String.fromCharCode(byte),
+    '',
+  )
+
+  let base64 = btoa(binaryString)
+
+  if (mimeType) {
+    base64 = `data:${mimeType};base64,${base64}`
+  }
+
+  return base64
+}
+
+let imageSchemaUid: string | undefined
+
+export const saveImageSrc = fromCallback<
+  EventObject,
+  FromCallbackInput<PropertyMachineContext, SaveValueToDbEvent>
+>(({ sendBack, input: { context, event } }) => {
+  const {
+    localId,
+    propertyName: propertyNameRaw,
+    propertyValue: existingValue,
+    propertyRecordSchema,
+    modelName,
+    seedLocalId,
+    seedUid,
+    versionLocalId,
+    versionUid,
+  } = context
+
+  let { schemaUid } = context
+
+  let newValue: ItemPropertyValueType
+
+  if (event) {
+    newValue = event.newValue
+  }
+
+  if (existingValue === newValue) {
+    sendBack({ type: 'saveValueToDbSuccess' })
+    return
+  }
+
+  const _saveImageSrc = async (): Promise<void> => {
+    let propertyName = propertyNameRaw
+
+    if (!propertyNameRaw.endsWith('Id')) {
+      propertyName = `${propertyName}Id`
+    }
+
+    let newValueType
+    let fileData: string | ArrayBuffer | undefined
+    let mimeType
+    let fileName
+
+    if (!imageSchemaUid) {
+      imageSchemaUid = await getSchemaUidForModel('Image')
+    }
+
+    if (typeof newValue === 'string') {
+      newValueType = getDataTypeFromString(newValue)
+    }
+
+    if (newValueType === 'imageBase64') {
+      mimeType = getMimeType(newValue as string)
+      const base64Data = (newValue as string).split(',')[1] // Strip the Base64 prefix
+      const binaryString = atob(base64Data)
+
+      const binaryLength = binaryString.length
+      const binaryArray = new Uint8Array(binaryLength)
+      for (let i = 0; i < binaryLength; i++) {
+        binaryArray[i] = binaryString.charCodeAt(i)
+      }
+      fileData = binaryArray.buffer
+    }
+
+    if (newValueType === 'url') {
+      fileData = await fetchImage(newValue as string)
+    }
+
+    if (newValue instanceof File) {
+      fileName = newValue.name
+      mimeType = newValue.type
+      fileData = await readFileAsArrayBuffer(newValue)
+    }
+
+    if (!fileData) {
+      throw new Error('No file data found')
+    }
+
+    const newImageSeedLocalId = await createSeed({
+      type: 'image',
+    })
+
+    if (!fileName) {
+      fileName = newImageSeedLocalId
+      if (mimeType) {
+        fileName += `.${mimeType.split('/')[1]}`
+      }
+    }
+
+    const filePath = `/files/images/${fileName}`
+
+    const imageVersionLocalId = await createVersion({
+      seedLocalId: newImageSeedLocalId,
+      seedType: 'image',
+    })
+
+    if (fileData instanceof ArrayBuffer) {
+      try {
+        await BaseFileManager.saveFile(filePath, new Uint8Array(fileData))
+      } catch (e) {
+        fs.writeFileSync(filePath, new Uint8Array(fileData))
+        eventEmitter.emit('file-saved', filePath)
+      }
+    }
+
+    if (typeof fileData === 'string') {
+      try {
+        await BaseFileManager.saveFile(filePath, fileData)
+      } catch (e) {
+        fs.writeFileSync(filePath, fileData)
+        eventEmitter.emit('file-saved', filePath)
+      }
+    }
+
+
+    await BaseFileManager.resizeImage({filePath, width: ImageSize.EXTRA_SMALL, height: ImageSize.EXTRA_SMALL})
+    await BaseFileManager.resizeImage({filePath, width: ImageSize.SMALL, height: ImageSize.SMALL})
+    await BaseFileManager.resizeImage({filePath, width: ImageSize.MEDIUM, height: ImageSize.MEDIUM})
+    await BaseFileManager.resizeImage({filePath, width: ImageSize.LARGE, height: ImageSize.LARGE})
+    await BaseFileManager.resizeImage({filePath, width: ImageSize.EXTRA_LARGE, height: ImageSize.EXTRA_LARGE})
+
+    const refResolvedDisplayValue = await BaseFileManager.getContentUrlFromPath(filePath)
+
+    let newLocalId
+
+    if (!localId) {
+      const result = await createMetadata(
+        {
+          propertyName,
+          propertyValue: newImageSeedLocalId,
+          seedLocalId,
+          seedUid,
+          versionLocalId,
+          versionUid,
+          modelName,
+          schemaUid,
+          refSeedType: 'image',
+          refModelUid: imageSchemaUid,
+          refSchemaUid: imageSchemaUid,
+          refResolvedDisplayValue,
+          refResolvedValue: fileName,
+          localStorageDir: '/images',
+          easDataType: 'bytes32',
+        },
+        propertyRecordSchema,
+      )
+
+      newLocalId = result[0].localId
+    }
+
+    if (localId) {
+      await updateItemPropertyValue({
+        localId: localId,
+        propertyName: propertyNameRaw,
+        newValue: newImageSeedLocalId,
+        seedLocalId,
+        versionLocalId,
+        modelName,
+        schemaUid,
+        refSeedType: 'image',
+        refResolvedDisplayValue,
+        refResolvedValue: fileName,
+        refModelUid: imageSchemaUid,
+        refSchemaUid: imageSchemaUid,
+        localStorageDir: '/images',
+        easDataType: 'bytes32',
+      })
+    }
+
+    sendBack({
+      type: 'updateContext',
+      localId: newLocalId || localId,
+      propertyValue: newImageSeedLocalId,
+      refSeedType: 'image',
+      refSchemaUid: imageSchemaUid,
+      renderValue: refResolvedDisplayValue,
+      refResolvedDisplayValue,
+      refResolvedValue: fileName,
+      localStorageDir: '/images',
+      easDataType: 'bytes32',
+      schemaUid,
+    })
+  }
+
+  _saveImageSrc().then(() => {
+    sendBack({ type: 'saveImageSrcSuccess' })
+  })
+})

package/dist/src/saveItemStorage.ts

@@ -0,0 +1,156 @@
+import { EventObject, fromCallback } from 'xstate'
+import { FromCallbackInput } from '@/types/machines'
+import {
+  ItemPropertyValueType,
+  PropertyMachineContext,
+  SaveValueToDbEvent,
+} from '@/types/property'
+import { BaseDb } from '@/db/Db/BaseDb'
+import { getItemPropertyData } from '@/db/read/getItemProperty'
+import { getItemData } from '@/db/read/getItemData'
+import { and, eq } from 'drizzle-orm'
+import { metadata } from '@/seedSchema'
+import { createMetadata } from '@/db/write/createMetadata'
+import fs from '@zenfs/core'
+import { BaseFileManager } from '@/helpers/FileManager/BaseFileManager'
+
+export const saveItemStorage = fromCallback<
+  EventObject,
+  FromCallbackInput<PropertyMachineContext, SaveValueToDbEvent>
+>(({ sendBack, input: { context, event } }) => {
+  const {
+    localId,
+    seedLocalId,
+    seedUid,
+    propertyName,
+    propertyRecordSchema,
+    modelName,
+    propertyValue: existingValue,
+  } = context
+
+  if (!propertyRecordSchema) {
+    throw new Error('Missing propertyRecordSchema')
+  }
+
+  let newValue: ItemPropertyValueType
+
+  if (event) {
+    newValue = event.newValue
+  }
+
+  if (existingValue === newValue) {
+    sendBack({ type: 'saveValueToDbSuccess' })
+    return
+  }
+
+  const _saveItemStorage = async (): Promise<boolean> => {
+    // Save value to file
+    const appDb = BaseDb.getAppDb()
+    let propertyData
+
+    if (localId) {
+      propertyData = await getItemPropertyData({
+        localId,
+      })
+    }
+
+    if (!localId && seedLocalId) {
+      const itemData = await getItemData({
+        seedLocalId,
+      })
+      if (itemData) {
+        const whereClauses = [
+          eq(metadata.propertyName, propertyName),
+          eq(metadata.seedLocalId, seedLocalId),
+        ]
+
+        if (itemData.latestVersionLocalId) {
+          whereClauses.push(
+            eq(metadata.versionLocalId, itemData.latestVersionLocalId),
+          )
+        }
+
+        const queryRows = await appDb
+          .select()
+          .from(metadata)
+          .where(and(...whereClauses))
+
+        if (queryRows && queryRows.length) {
+          propertyData = queryRows[0]
+        }
+
+        if (!propertyData && newValue) {
+
+          const filename = `${seedUid || seedLocalId}${propertyRecordSchema.filenameSuffix}`
+          const writeToPath = `/files/${propertyRecordSchema.localStorageDir}/${filename}`
+          await BaseFileManager.saveFile(writeToPath, newValue as string | Blob | ArrayBuffer)
+
+          const propertyDataRows = await createMetadata(
+            {
+              propertyName,
+              propertyValue: filename,
+              modelType: modelName.toLowerCase(),
+              seedLocalId,
+              seedUid,
+              versionLocalId: itemData.latestVersionLocalId,
+              versionUid: itemData.latestVersionUid,
+              localStorageDir: propertyRecordSchema.localStorageDir,
+              refValueType: 'file',
+            },
+            propertyRecordSchema,
+          )
+
+          propertyData = propertyDataRows[0]
+        }
+
+        // propertyData = {
+        //   propertyName,
+        //   seedLocalId,
+        //   seedUid,
+        //   versionLocalId: itemData.latestVersionLocalId,
+        //   versionUid: itemData.latestVersionUid,
+        //   schemaUid: itemData.schemaUid,
+        // }
+      }
+    }
+
+    const localStorageDir =
+      propertyRecordSchema.localStorageDir || propertyData.localStorageDir
+    const fileName =
+      propertyData.refResolvedValue ||
+      `${propertyData.seedUid || propertyData.seedLocalId}${propertyRecordSchema.filenameSuffix}`
+
+    if (!localStorageDir || !fileName) {
+      throw new Error(
+        `Missing localStorageDir: ${localStorageDir} or fileName: ${fileName}`,
+      )
+    }
+
+    const filePath = `/files/${localStorageDir}/${fileName}`
+    try {
+      await BaseFileManager.saveFile(filePath, newValue as string | Blob | ArrayBuffer)
+    } catch (error) {
+      fs.writeFileSync(filePath, newValue)
+    }
+
+    await appDb
+      .update(metadata)
+      .set({
+        refResolvedValue: fileName,
+      })
+      .where(eq(metadata.localId, propertyData.localId))
+
+    sendBack({
+      type: 'updateContext',
+      renderValue: newValue,
+    })
+
+    return true
+  }
+
+  _saveItemStorage().then((success) => {
+    if (success) {
+      sendBack({ type: 'saveItemStorageSuccess' })
+    }
+  })
+})

package/dist/src/saveMetadata.ts

@@ -0,0 +1,18 @@
+import { metadata, MetadataType } from '@/seedSchema'
+import { BaseDb } from '@/db/Db/BaseDb'
+import { eq } from 'drizzle-orm'
+
+export const saveMetadata = async (
+  metadataRecord: Partial<MetadataType>,
+  metadataValues: Partial<MetadataType>,
+) => {
+  const appDb = BaseDb.getAppDb()
+
+  await appDb
+    .update(metadata)
+    .set({
+      ...metadataValues,
+      updatedAt: Date.now(),
+    })
+    .where(eq(metadata.localId, metadataRecord.localId))
+}

package/dist/src/savePublishService.ts

@@ -0,0 +1,30 @@
+import { EventObject, fromCallback } from 'xstate'
+import { FromCallbackInput, GlobalMachineContext } from '@/types/machines'
+import { saveAppState } from '@/db/write/saveAppState'
+
+export const savePublishService = fromCallback<
+  EventObject,
+  FromCallbackInput<GlobalMachineContext>
+>(({ sendBack, input: { event, context } }) => {
+  const { publishItemService } = context
+
+  if (!publishItemService) {
+    sendBack({ type: 'savePublishServiceError' })
+    return
+  }
+
+  const _savePublishService = async (): Promise<boolean> => {
+    await saveAppState(
+      `snapshot__publishItemService`,
+      JSON.stringify(publishItemService.getPersistedSnapshot()),
+    )
+
+    return true
+  }
+
+  _savePublishService().then((success) => {
+    if (success) {
+      sendBack({ type: 'savePublishServiceSuccess' })
+    }
+  })
+})

package/dist/src/saveRelation.ts

@@ -0,0 +1,112 @@
+import { EventObject, fromCallback } from 'xstate'
+import { FromCallbackInput } from '@/types/machines'
+import {
+  ItemPropertyValueType,
+  PropertyMachineContext,
+  SaveValueToDbEvent,
+} from '@/types/property'
+import { getDataTypeFromString } from '@/helpers'
+
+export const saveRelation = fromCallback<
+  EventObject,
+  FromCallbackInput<PropertyMachineContext, SaveValueToDbEvent>
+>(({ sendBack, input: { context, event } }) => {
+  const {
+    localId,
+    propertyName: propertyNameRaw,
+    versionLocalId,
+    seedUid,
+    seedLocalId,
+    propertyValue: existingValue,
+    propertyRecordSchema,
+  } = context
+
+  if (!propertyRecordSchema) {
+    throw new Error('Missing propertyRecordSchema')
+  }
+
+  let newValue: ItemPropertyValueType
+
+  if (event) {
+    newValue = event.newValue
+  }
+
+  const _saveRelation = async (): Promise<boolean> => {
+    let refResolvedDisplayValue
+    let refSeedType
+    let propertyName = propertyNameRaw
+    let versionLocalIdToSave = versionLocalId
+
+    const refResolvedValue = newValue
+
+    if (!propertyName.endsWith('Id')) {
+      propertyName = `${propertyName}Id`
+    }
+
+    let newValueType
+
+    if (typeof newValue === 'string') {
+      newValueType = getDataTypeFromString(newValue)
+    }
+
+    if (newValue instanceof File) {
+      newValueType = 'file'
+    }
+
+    if (propertyRecordSchema.dataType === 'ImageSrc') {
+      sendBack({
+        type: 'saveImageSrc',
+        newValue,
+        newValueType,
+      })
+      return false
+    }
+
+    return true
+
+    // let fileType
+    //
+    // const dirs = await fs.promises.readdir('/files')
+    //
+    // for (const dir of dirs) {
+    //   const files = await fs.promises.readdir(`/files/${dir}`)
+    //   if (newValue && files.includes(newValue as string)) {
+    //     fileType = dir
+    //     break
+    //   }
+    // }
+    //
+    // if (newValue && fileType === 'images') {
+    //   const filePath = `/files/images/${newValue}`
+    //   refResolvedDisplayValue = await getContentUrlFromPath(filePath)
+    //   refSeedType = 'image'
+    //   newValue = await createSeed({
+    //     type: refSeedType,
+    //   })
+    //   await createVersion({
+    //     seedLocalId,
+    //     seedUid,
+    //     seedType: refSeedType,
+    //   })
+    // }
+    //
+    // await updateItemPropertyValue({
+    //   propertyLocalId: localId,
+    //   propertyName,
+    //   newValue,
+    //   seedLocalId,
+    //   refSeedType,
+    //   refResolvedValue,
+    //   refResolvedDisplayValue,
+    //   versionLocalId,
+    //   modelName: itemModelName,
+    //   schemaUid,
+    // })
+  }
+
+  _saveRelation().then((isDone) => {
+    if (isDone) {
+      sendBack({ type: 'saveRelationSuccess' })
+    }
+  })
+})