@seedprotocol/sdk 0.2.51 → 0.2.53

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' })
-    }
-  })
-})

package/dist/src/seed.schema.config.ts

@@ -1,25 +0,0 @@
-import { Model, Text } from '@/schema'
-
-@Model
-class Seed {
-  @Text() uid!: string
-  @Text() type!: string
-}
-
-@Model
-class Version {
-  @Text() seedUid!: string
-  @Text() note!: string
-}
-
-@Model
-class Metadata {
-  @Text() key!: string
-  @Text() value!: string
-}
-
-export const models = {
-  Seed,
-  Version,
-  Metadata,
-}

package/dist/src/seed.ts

@@ -1,10 +0,0 @@
-import { SeedConstructorOptions } from '@/types/types'
-import { SeedBase } from '@/shared/seed'
-
-class SeedNode extends SeedBase {
-  constructor(props: SeedConstructorOptions) {
-    super(props)
-  }
-}
-
-export { SeedNode }

package/dist/src/seedProtocol.ts

@@ -1,17 +0,0 @@
-import { Attestation } from '@/graphql/gql/graphql'
-
-export type PropertyToUpdateWithSeed = {
-  publishLocalId: string
-  propertySchemaUid: string
-}
-
-export type PublishRequestData = {
-  localId: string
-  seedIsRevocable: boolean
-  seedSchemaUid: string
-  seedUid?: string
-  versionSchemaUid: string
-  versionUid?: string
-  propertiesToUpdate: PropertyToUpdateWithSeed[]
-  listOfAttestations: Attestation[]
-}