@seedprotocol/sdk 0.1.54 → 0.1.55

package/dist/main.js

@@ -1,4 +1,4 @@
-export { h as ImageSrc, I as Item, j as ItemProperty, J as Json, L as List, M as Model, P as Property, R as Relation, T as Text, s as client, t as getCorrectId, r as getGlobalService, m as useCreateItem, o as useDeleteItem, p as useGlobalServiceStatus, k as useItem, l as useItemProperties, n as useItemProperty, u as useItems, q as useServices, w as withSeed } from './index-DQKd-s2Q.js';
+export { h as ImageSrc, I as Item, j as ItemProperty, J as Json, L as List, M as Model, P as Property, R as Relation, T as Text, s as client, t as getCorrectId, r as getGlobalService, m as useCreateItem, o as useDeleteItem, p as useGlobalServiceStatus, k as useItem, l as useItemProperties, n as useItemProperty, u as useItems, q as useServices, w as withSeed } from './index-D4my8yy8.js';
 import 'immer';
 import 'reflect-metadata';
 import './constants-BLctWkrn.js';
@@ -19,12 +19,12 @@ import '@tanstack/react-query';
 import 'graphql-request';
 import '@tanstack/query-sync-storage-persister';
 import '@tanstack/react-query-persist-client';
+import 'react';
 import 'rxjs';
 import 'pluralize';
 import '@statelyai/inspect';
 import 'drizzle-orm/sqlite-proxy';
 import '@zenfs/dom';
-import 'react';
 import 'use-immer';
 import '@xstate/react';
 //# sourceMappingURL=main.js.map

package/dist/{seed.schema.config-OyHsE0Zl.js → seed.schema.config-BHZSMMmL.js}

@@ -1,6 +1,6 @@
 import { _ as __decorate, a as __metadata } from './constants-BLctWkrn.js';
 import 'drizzle-orm';
-import { T as Text, M as Model } from './index-DQKd-s2Q.js';
+import { T as Text, M as Model } from './index-D4my8yy8.js';
 import 'react';
 import 'reflect-metadata';
 import 'xstate';
@@ -74,4 +74,4 @@ const models = {
 };
 
 export { models };
-//# sourceMappingURL=seed.schema.config-OyHsE0Zl.js.map
+//# sourceMappingURL=seed.schema.config-BHZSMMmL.js.map

package/dist/{seed.schema.config-OyHsE0Zl.js.map → seed.schema.config-BHZSMMmL.js.map}

@@ -1 +1 @@
-{"version":3,"file":"seed.schema.config-OyHsE0Zl.js","sources":["../../src/shared/configs/seed.schema.config.ts"],"sourcesContent":["import { Model, Text } from '@/browser'\n\n@Model\nclass Seed {\n  @Text() uid!: string\n  @Text() type!: string\n}\n\n@Model\nclass Version {\n  @Text() seedUid!: string\n  @Text() note!: string\n}\n\n@Model\nclass Metadata {\n  @Text() key!: string\n  @Text() value!: string\n}\n\nexport const models = {\n  Seed,\n  Version,\n  Metadata,\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,IAAM,IAAI,GAAV,MAAM,IAAI,CAAA;CAGT;AAFS,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAa,CAAA,EAAA,IAAA,CAAA,SAAA,EAAA,KAAA,EAAA,KAAA,CAAA,CAAA;AACZ,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAc,CAAA,EAAA,IAAA,CAAA,SAAA,EAAA,MAAA,EAAA,KAAA,CAAA,CAAA;AAFjB,IAAI,GAAA,UAAA,CAAA;IADT;AACK,CAAA,EAAA,IAAI,CAGT;AAGD,IAAM,OAAO,GAAb,MAAM,OAAO,CAAA;CAGZ;AAFS,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAiB,CAAA,EAAA,OAAA,CAAA,SAAA,EAAA,SAAA,EAAA,KAAA,CAAA,CAAA;AAChB,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAc,CAAA,EAAA,OAAA,CAAA,SAAA,EAAA,MAAA,EAAA,KAAA,CAAA,CAAA;AAFjB,OAAO,GAAA,UAAA,CAAA;IADZ;AACK,CAAA,EAAA,OAAO,CAGZ;AAGD,IAAM,QAAQ,GAAd,MAAM,QAAQ,CAAA;CAGb;AAFS,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAa,CAAA,EAAA,QAAA,CAAA,SAAA,EAAA,KAAA,EAAA,KAAA,CAAA,CAAA;AACZ,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAe,CAAA,EAAA,QAAA,CAAA,SAAA,EAAA,OAAA,EAAA,KAAA,CAAA,CAAA;AAFlB,QAAQ,GAAA,UAAA,CAAA;IADb;AACK,CAAA,EAAA,QAAQ,CAGb;AAEY,MAAA,MAAM,GAAG;IACpB,IAAI;IACJ,OAAO;IACP,QAAQ;;;;;"}
+{"version":3,"file":"seed.schema.config-BHZSMMmL.js","sources":["../../src/shared/configs/seed.schema.config.ts"],"sourcesContent":["import { Model, Text } from '@/browser'\n\n@Model\nclass Seed {\n  @Text() uid!: string\n  @Text() type!: string\n}\n\n@Model\nclass Version {\n  @Text() seedUid!: string\n  @Text() note!: string\n}\n\n@Model\nclass Metadata {\n  @Text() key!: string\n  @Text() value!: string\n}\n\nexport const models = {\n  Seed,\n  Version,\n  Metadata,\n}\n"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,IAAM,IAAI,GAAV,MAAM,IAAI,CAAA;CAGT;AAFS,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAa,CAAA,EAAA,IAAA,CAAA,SAAA,EAAA,KAAA,EAAA,KAAA,CAAA,CAAA;AACZ,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAc,CAAA,EAAA,IAAA,CAAA,SAAA,EAAA,MAAA,EAAA,KAAA,CAAA,CAAA;AAFjB,IAAI,GAAA,UAAA,CAAA;IADT;AACK,CAAA,EAAA,IAAI,CAGT;AAGD,IAAM,OAAO,GAAb,MAAM,OAAO,CAAA;CAGZ;AAFS,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAiB,CAAA,EAAA,OAAA,CAAA,SAAA,EAAA,SAAA,EAAA,KAAA,CAAA,CAAA;AAChB,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAc,CAAA,EAAA,OAAA,CAAA,SAAA,EAAA,MAAA,EAAA,KAAA,CAAA,CAAA;AAFjB,OAAO,GAAA,UAAA,CAAA;IADZ;AACK,CAAA,EAAA,OAAO,CAGZ;AAGD,IAAM,QAAQ,GAAd,MAAM,QAAQ,CAAA;CAGb;AAFS,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAa,CAAA,EAAA,QAAA,CAAA,SAAA,EAAA,KAAA,EAAA,KAAA,CAAA,CAAA;AACZ,UAAA,CAAA;AAAP,IAAA,IAAI,EAAE;;AAAe,CAAA,EAAA,QAAA,CAAA,SAAA,EAAA,OAAA,EAAA,KAAA,CAAA,CAAA;AAFlB,QAAQ,GAAA,UAAA,CAAA;IADb;AACK,CAAA,EAAA,QAAQ,CAGb;AAEY,MAAA,MAAM,GAAG;IACpB,IAAI;IACJ,OAAO;IACP,QAAQ;;;;;"}

package/dist/src/createMetadata.ts

@@ -21,7 +21,7 @@ export const createMetadata: CreateMetadata = async (
     propertyRecordSchema.localStorageDir &&
     propertyRecordSchema.storageType === 'ItemStorage'
   ) {
-    metadataValues.refResolvedValue = `${metadataValues.localId}${propertyRecordSchema.filenameSuffix}`
+    metadataValues.refResolvedValue = `${metadataValues.seedLocalId}${propertyRecordSchema.filenameSuffix}`
     metadataValues.refValueType = 'file'
   }
 

package/dist/src/download.ts

@@ -6,7 +6,11 @@ import { appState } from 'src/shared/seedSchema'
 import { eq } from 'drizzle-orm'
 import { getArweave } from '@/browser/schema/file'
 import { getAddressesFromDb } from '@/shared/helpers/db'
-import { getImageDataType, getMimeType, identifyString } from '@/shared/helpers'
+import {
+  getDataTypeFromString,
+  getMimeType,
+  identifyString,
+} from '@/shared/helpers'
 import { arweaveClient, easClient, queryClient } from '@/browser/helpers'
 import { GET_FILES_METADATA } from '@/browser/schema/file/queries'
 import debug from 'debug'
@@ -194,7 +198,7 @@ export const downloadAllFilesBinaryRequestHandler = async () => {
         contentType !== 'base64' &&
         contentType !== 'html'
       ) {
-        const possibleImageType = getImageDataType(dataString)
+        const possibleImageType = getDataTypeFromString(dataString)
         if (!possibleImageType) {
           logger(
             `[fetchAll/actors] [fetchAllBinaryData] transaction ${transactionId} data not in expected format: ${possibleImageType}`,

package/dist/src/getItemProperty.ts

@@ -17,7 +17,6 @@ export const getItemPropertyData: GetItemPropertyData = async (props) => {
 
   for (const [propertyName, propertyValue] of Object.entries(props)) {
     if (Object.keys(tableColumns).includes(propertyName)) {
-      const column = tableColumns[propertyName]
       whereClauses.push(eq(tableColumns[propertyName], propertyValue))
     }
   }

package/dist/src/propertyMachine.ts

@@ -6,12 +6,18 @@ 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 {
+  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,
@@ -22,7 +28,10 @@ export const propertyMachine = setup({
     initialize,
     resolveRelatedValue,
     resolveRemoteStorage,
-    saveValueToDb,
+    analyzeInput,
+    saveImageSrc,
+    saveRelation,
+    saveItemStorage,
   },
 }).createMachine({
   id: 'itemProperty',
@@ -136,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' })
+    }
+  })
+})