@seedprotocol/sdk 0.1.105 → 0.1.107

package/dist/main.js

@@ -1,7 +1,7 @@
-export { j as ImageSrc, I as Item, k as ItemProperty, J as Json, L as List, M as Model, P as Property, R as Relation, T as Text, t as client, v as getCorrectId, s as getGlobalService, n as useCreateItem, p as useDeleteItem, q as useGlobalServiceStatus, l as useItem, m as useItemProperties, o as useItemProperty, u as useItems, r as useServices, w as withSeed } from './index--nvTinP_.js';
+export { j as ImageSrc, I as Item, k as ItemProperty, J as Json, L as List, M as Model, P as Property, R as Relation, T as Text, t as client, v as getCorrectId, s as getGlobalService, n as useCreateItem, p as useDeleteItem, q as useGlobalServiceStatus, l as useItem, m as useItemProperties, o as useItemProperty, u as useItems, r as useServices, w as withSeed } from './index-Dg23uBJg.js';
 import 'immer';
 import 'reflect-metadata';
-import './constants-rmQ8zg8_.js';
+import './constants-qIJt7998.js';
 import 'xstate';
 import 'arweave';
 import 'drizzle-orm';
@@ -12,7 +12,6 @@ import 'dayjs';
 import 'nanoid';
 import 'nanoid-dictionary';
 import 'debug';
-import 'lodash-es';
 import 'drizzle-orm/sqlite-core';
 import 'react';
 import '@tanstack/react-query';
@@ -22,6 +21,7 @@ import '@tanstack/react-query-persist-client';
 import 'use-immer';
 import '@xstate/react';
 import 'eventemitter3';
+import 'lodash-es';
 import 'pluralize';
 import '@statelyai/inspect';
 import 'rxjs';

package/dist/{seed.schema.config-wQXee2fb.js → seed.schema.config-C1zm5m77.js}

@@ -1,6 +1,6 @@
-import { _ as __decorate, a as __metadata } from './constants-rmQ8zg8_.js';
+import { _ as __decorate, a as __metadata } from './constants-qIJt7998.js';
 import 'drizzle-orm';
-import { T as Text, M as Model } from './index--nvTinP_.js';
+import { T as Text, M as Model } from './index-Dg23uBJg.js';
 import 'react';
 import 'reflect-metadata';
 import 'xstate';
@@ -15,7 +15,6 @@ import 'dayjs';
 import 'nanoid';
 import 'nanoid-dictionary';
 import 'debug';
-import 'lodash-es';
 import 'drizzle-orm/sqlite-core';
 import '@tanstack/react-query';
 import 'graphql-request';
@@ -24,6 +23,7 @@ import '@tanstack/react-query-persist-client';
 import 'use-immer';
 import '@xstate/react';
 import 'eventemitter3';
+import 'lodash-es';
 import 'immer';
 import 'pluralize';
 import '@statelyai/inspect';
@@ -76,4 +76,4 @@ const models = {
 };
 
 export { models };
-//# sourceMappingURL=seed.schema.config-wQXee2fb.js.map
+//# sourceMappingURL=seed.schema.config-C1zm5m77.js.map

package/dist/{seed.schema.config-wQXee2fb.js.map → seed.schema.config-C1zm5m77.js.map}

@@ -1 +1 @@
-{"version":3,"file":"seed.schema.config-wQXee2fb.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-C1zm5m77.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/eas.ts

@@ -0,0 +1,40 @@
+import { toSnakeCase } from '@/shared/helpers'
+import { getSchemaForItemProperty } from '@/browser/helpers/getSchemaForItemProperty'
+
+const schemaUidForSchemaDefinition = new Map<string, string>()
+
+export const setSchemaUidForSchemaDefinition = ({ text, schemaUid }) => {
+  const propertySnakeCase = toSnakeCase(text)
+  schemaUidForSchemaDefinition.set(propertySnakeCase, schemaUid)
+}
+
+export const getSchemaUidForSchemaDefinition = (schemaText: string) => {
+  const textSnakeCase = toSnakeCase(schemaText)
+  if (!schemaUidForSchemaDefinition.has(textSnakeCase)) {
+    return
+  }
+  return schemaUidForSchemaDefinition.get(textSnakeCase)
+}
+
+export const fetchSchemaUids = async () => {
+  const versionSchemaUid = await getSchemaForItemProperty({
+    propertyName: 'version',
+    easDataType: 'bytes32',
+  })
+  if (versionSchemaUid) {
+    setSchemaUidForSchemaDefinition({
+      text: 'version',
+      schemaUid: versionSchemaUid,
+    })
+  }
+  const imageSchemaUid = await getSchemaForItemProperty({
+    propertyName: 'image',
+    easDataType: 'bytes32',
+  })
+  if (imageSchemaUid) {
+    setSchemaUidForSchemaDefinition({
+      text: 'image',
+      schemaUid: imageSchemaUid,
+    })
+  }
+}

package/dist/src/getPublishPayload.ts

@@ -8,114 +8,132 @@ import {
   AttestationRequest,
   SchemaEncoder,
   ZERO_ADDRESS,
+  ZERO_BYTES32,
 } from '@ethereum-attestation-service/eas-sdk'
 
 import { getSchemaForItemProperty } from '@/browser/helpers/getSchemaForItemProperty'
 import { toSnakeCase } from '@/shared/helpers'
 import pluralize from 'pluralize'
+import { getSchemaUidForModel } from '@/browser/db/read/getSchemaUidForModel'
+import { getSchemaUidForSchemaDefinition } from '@/browser/stores/eas'
+import { ItemProperty } from '@/browser/property/ItemProperty'
+import { getCorrectId } from '@/browser/helpers'
+import { Item } from '@/browser/item/Item'
 
-type PublishPayload = {
-  localId: string
-  seedIsRevocable: boolean
-  seedSchemaUid: string
-  seedUid: string
-  versionSchemaUid: string
-  versionUid: string
-  listOfAttestations: AttestationRequest[]
-  propertiesToUpdate: any[]
+const getVersionUid = (item: Item<any>) => {
+  let versionUid
+
+  if (
+    item.latestVersionUid &&
+    item.latestVersionUid !== 'NULL' &&
+    item.latestVersionUid !== 'undefined'
+  ) {
+    versionUid = item.latestVersionUid
+  }
+  return versionUid || ZERO_ADDRESS
 }
 
-type MultiPublishPayload = PublishPayload[]
+const getPropertyData = async (itemProperty: ItemProperty<any>) => {
+  const easDataType =
+    INTERNAL_DATA_TYPES[itemProperty.propertyDef!.dataType].eas
 
-export const getPublishPayload = async (
-  seedLocalId: string,
-): Promise<MultiPublishPayload> => {
-  const item = await getItem({ seedLocalId })
+  let schemaUid = itemProperty.schemaUid
 
-  if (!item) {
-    throw new Error('Item not found')
-  }
+  const propertyNameForSchema = toSnakeCase(itemProperty.propertyName)
 
-  const localId = item.seedLocalId
-  const seedIsRevocable = true
-  const seedSchemaUid = item.schemaUid
-  const seedUid = item.seedUid
-  const versionSchemaUid = VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA
-  const listOfAttestations = []
-  const propertiesToUpdate = []
+  const schemaDef = `${easDataType} ${propertyNameForSchema}`
 
-  for (const [propertyName, itemProperty] of Object.entries(item.properties)) {
-    if (!itemProperty.value || !itemProperty.propertyDef) {
-      continue
+  if (!schemaUid) {
+    schemaUid = getSchemaUidForSchemaDefinition(schemaDef)
+    if (!schemaUid) {
+      const schema = await getSchemaForItemProperty({
+        propertyName: 'version',
+        easDataType: 'bytes32',
+      })
+      if (schema) {
+        schemaUid = schema.id
+      }
     }
+  }
+
+  return {
+    schemaUid,
+    easDataType,
+    schemaDef,
+    propertyNameForSchema,
+  }
+}
 
-    const easDataType =
-      INTERNAL_DATA_TYPES[itemProperty.propertyDef.dataType].eas
+const getSegmentedItemProperties = (item: Item<any>) => {
+  const itemBasicProperties = []
+  const itemRelationProperties = []
+  const itemListProperties = []
+  const itemStorageProperties = []
 
-    let schemaUid = itemProperty.schemaUid
-    let propertyNameForSchema = propertyName
-    let propertyValue = itemProperty.getService().getSnapshot()
-      .context.propertyValue
+  for (const itemProperty of Object.values(item.properties)) {
+    if (!itemProperty.propertyDef) {
+      continue
+    }
 
     if (itemProperty.propertyDef.dataType === 'Relation') {
-      propertyNameForSchema = `${propertyName}Id`
+      itemRelationProperties.push(itemProperty)
+      continue
     }
 
-    if (
-      itemProperty.propertyDef.dataType === 'List' &&
-      itemProperty.propertyDef.ref
-    ) {
-      const singularPropertyName = pluralize.singular(propertyName)
-      propertyNameForSchema = `${singularPropertyName}${itemProperty.propertyDef.ref}Ids`
-      if (typeof propertyValue === 'string' && propertyValue.length === 66) {
-        propertyValue = [propertyValue]
-      }
-      if (typeof propertyValue === 'string' && propertyValue.length > 66) {
-        try {
-          propertyValue = JSON.parse(propertyValue)
-        } catch (error) {
-          console.log('No-op due to error: ', error)
-        }
-      }
+    if (itemProperty.propertyDef.dataType === 'List') {
+      itemListProperties.push(itemProperty)
+      continue
     }
 
     if (
       itemProperty.propertyDef.storageType &&
       itemProperty.propertyDef.storageType === 'ItemStorage'
     ) {
+      itemStorageProperties.push(itemProperty)
       continue
     }
 
-    const foundPropertySchema = await getSchemaForItemProperty({
-      schemaUid,
-      propertyName: propertyNameForSchema,
-      easDataType,
-    })
+    itemBasicProperties.push(itemProperty)
+  }
 
-    if (!foundPropertySchema) {
-      throw new Error(
-        `No schema found for property ${itemProperty.propertyName} ${itemProperty.localId}`,
-      )
+  return {
+    itemBasicProperties,
+    itemRelationProperties,
+    itemListProperties,
+    itemStorageProperties,
+  }
+}
+
+const processBasicProperties = async (
+  itemBasicProperties: ItemProperty<any>[],
+  itemPublishData: PublishPayload,
+): Promise<PublishPayload> => {
+  for (const basicProperty of itemBasicProperties) {
+    const value = basicProperty.getService().getSnapshot().context.propertyValue
+
+    if (!value || basicProperty.uid) {
+      continue
     }
 
-    schemaUid = foundPropertySchema.id
+    const { schemaUid, easDataType, schemaDef } =
+      await getPropertyData(basicProperty)
+
+    const propertyNameForSchema = toSnakeCase(basicProperty.propertyName)
 
     const data = [
       {
-        name: toSnakeCase(propertyNameForSchema),
+        name: propertyNameForSchema,
         type: easDataType,
-        value: propertyValue,
+        value,
       },
     ]
 
-    const easSchemaDefinition = foundPropertySchema.schema
-
-    const dataEncoder = new SchemaEncoder(easSchemaDefinition)
+    const dataEncoder = new SchemaEncoder(schemaDef)
 
     const encodedData = dataEncoder.encodeData(data)
 
-    listOfAttestations.push({
-      schema: schemaUid,
+    itemPublishData.listOfAttestations.push({
+      schema: schemaUid!,
       data: [
         {
           ...defaultAttestationData,
@@ -125,16 +143,211 @@ export const getPublishPayload = async (
     })
   }
 
-  return [
-    {
-      localId,
-      seedIsRevocable,
-      seedSchemaUid,
+  return itemPublishData
+}
+
+const processRelationProperty = async (
+  relationProperty: ItemProperty<any>,
+  multiPublishPayload: MultiPublishPayload,
+): Promise<MultiPublishPayload> => {
+  const value = relationProperty.getService().getSnapshot()
+    .context.propertyValue
+  if (!value || relationProperty.uid) {
+    return multiPublishPayload
+  }
+
+  const { localId: seedLocalId, uid: seedUid } = getCorrectId(value)
+
+  const relatedItem = await getItem({
+    seedLocalId,
+    seedUid,
+  })
+
+  if (!relatedItem) {
+    throw new Error(
+      `No related item found for relation property: ${relationProperty.propertyName}`,
+    )
+  }
+
+  const versionUid = getVersionUid(relatedItem)
+
+  const seedSchemaUid = await getSchemaUidForModel(
+    relationProperty.propertyDef!.ref as string,
+  )
+
+  let publishPayload: PublishPayload = {
+    localId: relationProperty.localId,
+    seedIsRevocable: true,
+    versionSchemaUid: VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA,
+    seedUid: seedUid || ZERO_ADDRESS,
+    seedSchemaUid,
+    versionUid,
+    listOfAttestations: [],
+    propertiesToUpdate: [],
+  }
+
+  const { itemBasicProperties } = getSegmentedItemProperties(relatedItem)
+
+  publishPayload = await processBasicProperties(
+    itemBasicProperties,
+    publishPayload,
+  )
+
+  multiPublishPayload.push(publishPayload)
+
+  return multiPublishPayload
+}
+
+const processListProperty = async (
+  listProperty: ItemProperty<any>,
+  multiPublishPayload: MultiPublishPayload,
+): Promise<MultiPublishPayload> => {
+  let value = listProperty.getService().getSnapshot().context.propertyValue
+  if (!value || listProperty.uid) {
+    return multiPublishPayload
+  }
+
+  const singularPropertyName = pluralize.singular(listProperty.propertyName)
+  const propertyNameForSchema = `${singularPropertyName}${listProperty.propertyDef!.ref}Ids`
+  if (typeof value === 'string' && value.length === 66) {
+    value = [value]
+  }
+  if (typeof value === 'string' && value.length > 66) {
+    try {
+      value = JSON.parse(value)
+    } catch (error) {
+      value = value.split(',')
+    }
+  }
+
+  for (const seedId of value) {
+    const { localId: seedLocalId, uid: seedUid } = getCorrectId(seedId)
+
+    const relatedItem = await getItem({
+      seedLocalId,
+      seedUid,
+    })
+
+    if (!relatedItem) {
+      throw new Error(
+        `No related item found for list property: ${listProperty.propertyName}`,
+      )
+    }
+
+    if (relatedItem.seedUid) {
+      return multiPublishPayload
+    }
+
+    const versionUid = getVersionUid(relatedItem)
+
+    const seedSchemaUid = await getSchemaUidForModel(
+      listProperty.propertyDef!.ref as string,
+    )
+
+    let publishPayload: PublishPayload = {
+      localId: relatedItem.seedLocalId,
+      seedIsRevocable: true,
+      versionSchemaUid: VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA,
       seedUid: seedUid || ZERO_ADDRESS,
-      versionUid: item.latestVersionUid || ZERO_ADDRESS,
-      versionSchemaUid,
-      listOfAttestations,
-      propertiesToUpdate,
-    },
-  ]
+      seedSchemaUid,
+      versionUid,
+      listOfAttestations: [],
+      propertiesToUpdate: [
+        {
+          publishLocalId: listProperty.localId,
+          propertySchemaUid: listProperty.schemaUid,
+        },
+      ],
+    }
+
+    const { itemBasicProperties } = getSegmentedItemProperties(relatedItem)
+
+    publishPayload = await processBasicProperties(
+      itemBasicProperties,
+      publishPayload,
+    )
+
+    multiPublishPayload.push(publishPayload)
+  }
+
+  return multiPublishPayload
+}
+
+type PublishPayload = {
+  localId: string
+  seedIsRevocable: boolean
+  seedSchemaUid: string
+  seedUid: string
+  versionSchemaUid: string
+  versionUid: string
+  listOfAttestations: AttestationRequest[]
+  propertiesToUpdate: any[]
+}
+
+type MultiPublishPayload = PublishPayload[]
+
+export const getPublishPayload = async (
+  seedLocalId: string,
+): Promise<MultiPublishPayload> => {
+  const item = await getItem({ seedLocalId })
+
+  if (!item) {
+    throw new Error('Item not found')
+  }
+
+  // if (item.modelName === 'Post') {
+  //   item.authors = [
+  //     'Sr0bIx9Fwj',
+  //     '0xc2879650e9503a303ceb46f966e55baab480b267dc20cede23ef503622eee6d7',
+  //   ]
+  // }
+
+  let multiPublishPayload: MultiPublishPayload = []
+
+  // Each PublishPayload is generated from a Seed that needs publishing
+
+  // First we need to determine all Seeds to publish
+
+  // That means the Seed of the Item, plus any Seeds pointed to by Relations
+
+  let itemPublishData: PublishPayload = {
+    localId: item.seedLocalId,
+    seedUid: item.seedUid || ZERO_BYTES32,
+    seedIsRevocable: true,
+    seedSchemaUid: item.schemaUid,
+    versionSchemaUid: VERSION_SCHEMA_UID_OPTIMISM_SEPOLIA,
+    versionUid: item.latestVersionUid || ZERO_BYTES32,
+    listOfAttestations: [],
+    propertiesToUpdate: [],
+  }
+
+  const {
+    itemBasicProperties,
+    itemRelationProperties,
+    itemListProperties,
+    itemStorageProperties,
+  } = getSegmentedItemProperties(item)
+
+  itemPublishData = await processBasicProperties(
+    itemBasicProperties,
+    itemPublishData,
+  )
+
+  multiPublishPayload.push(itemPublishData)
+
+  for (const relationProperty of itemRelationProperties) {
+    multiPublishPayload = await processRelationProperty(
+      relationProperty,
+      multiPublishPayload,
+    )
+  }
+
+  for (const listProperty of itemListProperties) {
+    multiPublishPayload = await processListProperty(
+      listProperty,
+      multiPublishPayload,
+    )
+  }
+
+  return multiPublishPayload
 }

package/dist/src/initialize.ts

@@ -10,12 +10,13 @@ import { FromCallbackInput, GlobalMachineContext } from '@/types'
 import { getAppDb } from '@/browser/db/sqlWasmClient'
 import { appState } from '@/shared/seedSchema'
 import { like } from 'drizzle-orm'
+import { fetchSchemaUids } from '@/browser/stores/eas'
 
 const logger = debug('app:services:global:actors:initialize')
 
 export const initialize = fromCallback<
   EventObject,
-  FromCallbackInput<GlobalMachineContext>
+  FromCallbackInput<GlobalMachineContext, EventObject>
 >(({ sendBack, input: { event, context } }) => {
   const { internalService, models, endpoints } = context
 
@@ -87,16 +88,7 @@ export const initialize = fromCallback<
     }
 
     const _initEas = async (): Promise<void> => {
-      // const { easService } = await import('@/browser/eas')
-      // easService.send({ type: 'init', endpoints, models })
-      // return new Promise((resolve) => {
-      //   easSubscription = easService.subscribe((snapshot) => {
-      //     if (snapshot.value === 'ready') {
-      //       resolve()
-      //     }
-      //   })
-      //   easService.send({ type: 'init', endpoints, models })
-      // })
+      await fetchSchemaUids()
     }
 
     _initFileSystem().then(() => {
@@ -107,6 +99,9 @@ export const initialize = fromCallback<
       .then(() => {
         return _initAllItemsServices()
       })
+      .then(() => {
+        return _initEas()
+      })
       .then(() => {
         logger('[global/actors] Internal initialized')
         sendBack({ type: GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY })

package/dist/src/saveImageSrc.ts

@@ -12,6 +12,8 @@ import { fs } from '@zenfs/core'
 import { getContentUrlFromPath } from '@/browser/helpers'
 import { createMetadata } from '@/browser/db/write/createMetadata'
 import { updateItemPropertyValue } from '@/browser/db/write/updateItemPropertyValue'
+import { getSchemaUidForSchemaDefinition } from '@/browser/stores/eas'
+import { getSchemaUidForModel } from '@/browser/db/read/getSchemaUidForModel'
 
 const readFileAsDataUrl = async (file: File): Promise<string> => {
   return new Promise((resolve) => {
@@ -61,6 +63,8 @@ const fetchImage = async (url: string) => {
   return base64
 }
 
+let imageSchemaUid: string | undefined
+
 export const saveImageSrc = fromCallback<
   EventObject,
   FromCallbackInput<PropertyMachineContext, SaveValueToDbEvent>
@@ -75,9 +79,10 @@ export const saveImageSrc = fromCallback<
     seedUid,
     versionLocalId,
     versionUid,
-    schemaUid,
   } = context
 
+  let { schemaUid } = context
+
   let newValue: ItemPropertyValueType
 
   if (event) {
@@ -101,6 +106,10 @@ export const saveImageSrc = fromCallback<
     let mimeType
     let fileName
 
+    if (!imageSchemaUid) {
+      imageSchemaUid = await getSchemaUidForModel('Image')
+    }
+
     if (typeof newValue === 'string') {
       newValueType = getDataTypeFromString(newValue)
     }
@@ -160,6 +169,10 @@ export const saveImageSrc = fromCallback<
 
     const refResolvedDisplayValue = await getContentUrlFromPath(filePath)
 
+    if (!schemaUid) {
+      schemaUid = getSchemaUidForSchemaDefinition(propertyName)
+    }
+
     if (!localId) {
       await createMetadata(
         {
@@ -172,6 +185,8 @@ export const saveImageSrc = fromCallback<
           modelName: itemModelName,
           schemaUid,
           refSeedType: 'image',
+          refModelUid: imageSchemaUid,
+          refSchemaUid: imageSchemaUid,
           refResolvedDisplayValue,
           refResolvedValue: fileName,
           localStorageDir: '/images',
@@ -193,6 +208,8 @@ export const saveImageSrc = fromCallback<
         refSeedType: 'image',
         refResolvedDisplayValue,
         refResolvedValue: fileName,
+        refModelUid: imageSchemaUid,
+        refSchemaUid: imageSchemaUid,
         localStorageDir: '/images',
         easDataType: 'bytes32',
       })
@@ -202,9 +219,12 @@ export const saveImageSrc = fromCallback<
       type: 'updateContext',
       propertyValue: newImageSeedLocalId,
       refSeedType: 'image',
+      refSchemaUid: imageSchemaUid,
       renderValue: refResolvedDisplayValue,
       resolvedDisplayValue: refResolvedDisplayValue,
       resolvedValue: fileName,
+      localStorageDir: '/images',
+      easDataType: 'bytes32',
     })
   }