@seedprotocol/sdk 0.3.1 → 0.3.3

package/dist/src/saveDataToDb.ts

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

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

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

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

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

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