@seedprotocol/sdk 0.1.53 → 0.1.55

package/dist/src/hydrateFromDb.ts

@@ -81,19 +81,7 @@ export const hydrateFromDb = fromCallback<EventObject, typeof propertyMachine>(
         )
       }
 
-      const selectFromStatement = db
-        .select({
-          localId: metadata.localId,
-          uid: metadata.uid,
-          propertyName: metadata.propertyName,
-          propertyValue: metadata.propertyValue,
-          seedLocalId: metadata.seedLocalId,
-          seedUid: metadata.seedUid,
-          schemaUid: metadata.schemaUid,
-          refResolvedValue: metadata.refResolvedValue,
-          refResolvedDisplayValue: metadata.refResolvedDisplayValue,
-        })
-        .from(metadata)
+      const selectFromStatement = db.select().from(metadata)
 
       if (seedUid && !seedLocalId) {
         hydrateQuery = selectFromStatement.where(
@@ -139,8 +127,12 @@ export const hydrateFromDb = fromCallback<EventObject, typeof propertyMachine>(
         seedLocalId: seedLocalIdFromDb,
         seedUid: seedUidFromDb,
         schemaUid: schemaUidFromDb,
+        versionLocalId: versionLocalIdFromDb,
+        versionUid: versionUidFromDb,
+        refValueType,
         refResolvedValue,
         refResolvedDisplayValue,
+        localStorageDir,
       } = firstRow
 
       if (propertyName && !propertyNameFromDb) {
@@ -186,9 +178,13 @@ export const hydrateFromDb = fromCallback<EventObject, typeof propertyMachine>(
         propertyValue: propertyValueFromDb,
         seedLocalId: seedLocalIdFromDb,
         seedUid: seedUidFromDb,
+        versionLocalId: versionLocalIdFromDb,
+        versionUid: versionUidFromDb,
         schemaUid: schemaUidFromDb,
-        resolveValue: refResolvedValue,
-        resolveDisplayValue: refResolvedDisplayValue,
+        refValueType,
+        localStorageDir,
+        resolvedValue: refResolvedValue,
+        resolvedDisplayValue: refResolvedDisplayValue,
         renderValue: refResolvedDisplayValue,
       })
 

package/dist/src/propertyMachine.ts

@@ -6,20 +6,32 @@ import { waitForDb } from '@/browser/property/actors/waitForDb'
 import { initialize } from '@/browser/property/actors/initialize'
 import { resolveRelatedValue } from '@/browser/property/actors/resolveRelatedValue'
 import { hydrateFromDb } from '@/browser/property/actors/hydrateFromDb'
-import { saveValueToDb } from '@/browser/property/actors/saveValueToDb'
-import { updateMachineContext } from '@/browser/helpers'
+import {
+  analyzeInput,
+  saveImageSrc,
+  saveItemStorage,
+  saveRelation,
+} from '@/browser/property/actors/saveValueToDb' // import { updateMachineContext } from '@/browser/helpers'
+// import { updateMachineContext } from '@/browser/helpers'
 
 export const propertyMachine = setup({
   types: {
     context: {} as PropertyMachineContext,
+    input: {} as PropertyMachineContext,
   },
+  // actions: {
+  //   updateContext: updateMachineContext,
+  // },
   actors: {
     waitForDb,
     hydrateFromDb,
     initialize,
     resolveRelatedValue,
     resolveRemoteStorage,
-    saveValueToDb,
+    analyzeInput,
+    saveImageSrc,
+    saveRelation,
+    saveItemStorage,
   },
 }).createMachine({
   id: 'itemProperty',
@@ -48,7 +60,20 @@ export const propertyMachine = setup({
       }),
       target: '.saving',
     },
-    updateContext: updateMachineContext,
+    updateContext: {
+      actions: assign(({ context, event }) => {
+        const newContext = Object.assign({}, context)
+
+        for (let i = 0; i < Object.keys(event).length; i++) {
+          const key = Object.keys(event)[i]
+          if (key === 'type') {
+            continue
+          }
+          newContext[key] = event[key]
+        }
+        return newContext
+      }),
+    },
   },
   states: {
     idle: {},
@@ -120,23 +145,60 @@ export const propertyMachine = setup({
       },
     },
     saving: {
-      on: {
-        saveValueToDbSuccess: {
-          target: 'idle',
-          actions: assign({
-            isSaving: false,
-          }),
+      initial: 'analyzingInput',
+      states: {
+        analyzingInput: {
+          on: {
+            saveValueToDbSuccess: {
+              target: 'doneSaving',
+            },
+            saveImageSrc: 'savingImageSrc',
+            saveRelation: 'savingRelation',
+            saveItemStorage: 'savingItemStorage',
+          },
+          invoke: {
+            src: 'analyzeInput',
+            input: ({ context, event }) => ({ context, event }),
+          },
         },
-        saveValueToDbFailure: {
-          target: 'idle',
-          actions: assign({
-            isSaving: false,
-          }),
+        savingImageSrc: {
+          on: {
+            saveImageSrcSuccess: 'doneSaving',
+          },
+          invoke: {
+            src: 'saveImageSrc',
+            input: ({ context, event }) => ({ context, event }),
+          },
+        },
+        savingRelation: {
+          on: {
+            saveRelationSuccess: 'doneSaving',
+          },
+          invoke: {
+            src: 'saveRelation',
+            input: ({ context, event }) => ({ context, event }),
+          },
+        },
+        savingItemStorage: {
+          on: {
+            saveItemStorageSuccess: 'doneSaving',
+          },
+          invoke: {
+            src: 'saveItemStorage',
+            input: ({ context, event }) => ({ context, event }),
+          },
+        },
+        doneSaving: {
+          type: 'final',
         },
       },
-      invoke: {
-        src: 'saveValueToDb',
-        input: ({ context, event }) => ({ context, event }),
+      onDone: {
+        target: 'idle',
+        actions: assign(({ context }) => {
+          return {
+            isSaving: false,
+          }
+        }),
       },
     },
   },

package/dist/src/resolveRelatedValue.ts

@@ -25,6 +25,10 @@ export const resolveRelatedValue = fromCallback<
     schemaUid,
   } = context
 
+  if (seedLocalId === 'AhiILhtcVq') {
+    console.log('[resolveRelatedValue] seedLocalId', seedLocalId)
+  }
+
   const _resolveRelatedValue = async () => {
     if (!propertyValue || !isRelation) {
       return

package/dist/src/saveImageSrc.ts

@@ -0,0 +1,200 @@
+import { EventObject, fromCallback } from 'xstate'
+import { FromCallbackInput } from '@/types/machines'
+import {
+  ItemPropertyValueType,
+  PropertyMachineContext,
+  SaveValueToDbEvent,
+} from '@/types/property'
+import { createSeed, updateItemPropertyValue } from '@/browser/db/write'
+import { getDataTypeFromString, getMimeType } from '@/shared/helpers'
+import { createVersion } from '@/browser/db/write/createVersion'
+import { fs } from '@zenfs/core'
+import { getContentUrlFromPath } from '@/browser/helpers'
+import { createMetadata } from '@/browser/db/write/createMetadata'
+
+const readFileAsDataUrl = async (file: File): Promise<string> => {
+  return new Promise((resolve) => {
+    const reader = new FileReader()
+    reader.onload = async (e) => {
+      const base64 = e.target.result.split(',')[1] // Extract the base64 string
+      const mimeType = file.type // Get the file's MIME type
+      const base64WithMimeType = `data:${mimeType};base64,${base64}`
+
+      resolve(base64WithMimeType)
+    }
+
+    reader.readAsDataURL(file)
+  })
+}
+
+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
+}
+
+export const saveImageSrc = fromCallback<
+  EventObject,
+  FromCallbackInput<PropertyMachineContext, SaveValueToDbEvent>
+>(({ sendBack, input: { context, event } }) => {
+  const {
+    localId,
+    propertyName: propertyNameRaw,
+    propertyValue: existingValue,
+    propertyRecordSchema,
+    itemModelName,
+    seedLocalId,
+    seedUid,
+    versionLocalId,
+    versionUid,
+    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 (typeof newValue === 'string') {
+      newValueType = getDataTypeFromString(newValue)
+    }
+
+    if (newValueType === 'imageBase64') {
+      mimeType = getMimeType(newValue as string)
+    }
+
+    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) {
+      await fs.promises.writeFile(filePath, new Uint8Array(fileData))
+    }
+
+    if (typeof fileData === 'string') {
+      await fs.promises.writeFile(filePath, fileData)
+    }
+
+    const refResolvedDisplayValue = await getContentUrlFromPath(filePath)
+
+    if (!localId) {
+      await createMetadata(
+        {
+          propertyName,
+          propertyValue: newImageSeedLocalId,
+          seedLocalId,
+          seedUid,
+          versionLocalId,
+          versionUid,
+          modelName: itemModelName,
+          schemaUid,
+          refSeedType: 'image',
+          refResolvedDisplayValue,
+          refResolvedValue: fileName,
+        },
+        propertyRecordSchema,
+      )
+    }
+
+    if (localId) {
+      await updateItemPropertyValue({
+        propertyLocalId: localId,
+        propertyName: propertyNameRaw,
+        newValue: newImageSeedLocalId,
+        seedLocalId,
+        versionLocalId,
+        modelName: itemModelName,
+        schemaUid,
+        refSeedType: 'image',
+        refResolvedDisplayValue,
+        refResolvedValue: fileName,
+      })
+    }
+
+    sendBack({
+      type: 'updateContext',
+      propertyValue: newImageSeedLocalId,
+      refSeedType: 'image',
+      renderValue: refResolvedDisplayValue,
+      resolvedDisplayValue: refResolvedDisplayValue,
+      resolvedValue: fileName,
+    })
+  }
+
+  _saveImageSrc().then(() => {
+    sendBack({ type: 'saveImageSrcSuccess' })
+  })
+})

package/dist/src/saveItemStorage.ts

@@ -0,0 +1,145 @@
+import { EventObject, fromCallback } from 'xstate'
+import { FromCallbackInput } from '@/types/machines'
+import {
+  ItemPropertyValueType,
+  PropertyMachineContext,
+  SaveValueToDbEvent,
+} from '@/types/property'
+import { getAppDb } from '@/browser'
+import { getItemPropertyData } from '@/browser/db/read/getItemProperty'
+import { getItemDataFromDb } from '@/browser/db/read/getItem'
+import { and, eq } from 'drizzle-orm'
+import { metadata } from '@/shared/seedSchema'
+import { createMetadata } from '@/browser/db/write/createMetadata'
+import { fs } from '@zenfs/core'
+
+export const saveItemStorage = fromCallback<
+  EventObject,
+  FromCallbackInput<PropertyMachineContext, SaveValueToDbEvent>
+>(({ sendBack, input: { context, event } }) => {
+  const {
+    localId,
+    seedLocalId,
+    seedUid,
+    propertyName,
+    propertyRecordSchema,
+    itemModelName,
+    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 = getAppDb()
+    let propertyData
+
+    if (localId) {
+      propertyData = await getItemPropertyData({
+        localId,
+      })
+    }
+
+    if (!localId && seedLocalId) {
+      const itemData = await getItemDataFromDb({
+        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) {
+          const propertyDataRows = await createMetadata(
+            {
+              propertyName,
+              modelType: itemModelName.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.seedLocalId}${propertyRecordSchema.filenameSuffix}`
+
+    if (!localStorageDir || !fileName) {
+      throw new Error(
+        `Missing localStorageDir: ${localStorageDir} or fileName: ${fileName}`,
+      )
+    }
+
+    const filePath = `/files/${localStorageDir}/${fileName}`
+    await fs.promises.writeFile(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/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 '@/shared/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/syncDbWithEas.ts

@@ -358,7 +358,7 @@ const createMetadataRecordsForStorageTransactionId = async (
       versionLocalId,
       versionUid,
       refValueType: 'file',
-      refResolvedValue: `${propertyValue}.${propertyDef.filenameSuffix}`,
+      refResolvedValue: `${propertyValue}${propertyDef.filenameSuffix}`,
       modelType: seedUidToModelType.get(seedUid),
       createdAt: Date.now(),
       updatedAt: Date.now(),

package/dist/src/versionData.ts

@@ -0,0 +1,24 @@
+import { versions } from '@/shared/seedSchema'
+import { count, max } from 'drizzle-orm'
+import { getAppDb } from '@/browser/db/sqlWasmClient'
+
+export const getVersionData = () => {
+  const appDb = getAppDb()
+
+  return appDb.$with('versionData').as(
+    appDb
+      .select({
+        seedLocalId: versions.seedLocalId,
+        seedUid: versions.seedUid,
+        latestVersionUid: versions.uid,
+        latestVersionLocalId: versions.localId,
+        versionsCount: count(versions.localId).as('versionsCount'),
+        lastVersionPublishedAt: max(versions.attestationCreatedAt).as(
+          'lastVersionPublishedAt',
+        ),
+        lastLocalUpdateAt: max(versions.createdAt).as('lastLocalUpdateAt'),
+      })
+      .from(versions)
+      .groupBy(versions.seedLocalId),
+  )
+}