@seedprotocol/sdk 0.1.73 → 0.1.75

package/dist/src/hydrateFromDb.ts

@@ -1,277 +1,293 @@
 import { EventObject, fromCallback } from 'xstate'
-import { propertyMachine } from '../propertyMachine'
 import { and, eq, or, sql } from 'drizzle-orm'
-import { escapeSqliteString } from '@/shared/helpers/db'
 import debug from 'debug'
 import { fs } from '@zenfs/core'
 import { metadata } from 'src/shared/seedSchema'
 import { getAppDb } from '@/browser/db/sqlWasmClient'
 import { updateMetadata } from '@/browser/db/write/updateMetadata'
+import { FromCallbackInput } from '@/types/machines'
+import { PropertyMachineContext } from '@/types/property'
 
 const logger = debug('app:property:actors:hydrateFromDb')
 
-export const hydrateFromDb = fromCallback<EventObject, typeof propertyMachine>(
-  ({ sendBack, input: { context } }) => {
-    const {
-      seedUid,
-      seedLocalId,
-      propertyName: propertyNameRaw,
-      propertyValue,
-      propertyRecordSchema,
-      itemModelName,
-    } = context
-
-    let propertyName = propertyNameRaw
+export const hydrateFromDb = fromCallback<
+  EventObject,
+  FromCallbackInput<PropertyMachineContext, EventObject>
+>(({ sendBack, input: { context } }) => {
+  const {
+    seedUid,
+    seedLocalId,
+    propertyName: propertyNameRaw,
+    propertyValue,
+    propertyRecordSchema,
+    itemModelName,
+  } = context
+
+  let propertyName = propertyNameRaw
+
+  if (
+    propertyRecordSchema &&
+    propertyRecordSchema.ref &&
+    propertyRecordSchema.dataType === 'Relation' &&
+    !propertyNameRaw.endsWith('Id')
+  ) {
+    propertyName = propertyNameRaw + 'Id'
+  }
+
+  if (
+    propertyRecordSchema &&
+    propertyRecordSchema.ref &&
+    propertyRecordSchema.dataType === 'List' &&
+    !propertyNameRaw.endsWith('Ids')
+  ) {
+    propertyName = propertyNameRaw + 'Ids'
+  }
+
+  const _hydrateFromDb = async () => {
+    const appDb = getAppDb()
+
+    const whereClauses = []
+
+    let hydrateQuery
+    // let safeValue = propertyValue
+    // let propertyValueQueryString = `property_value `
+    // let propertyNameQueryString = `property_name = '${propertyName}'`
+    let propertyNameQuery = eq(metadata.propertyName, propertyName)
+
+    // if (safeValue && typeof propertyValue === 'string') {
+    //   safeValue = escapeSqliteString(propertyValue)
+    //   propertyValueQueryString += `= '${safeValue}'`
+    // }
+
+    // if (!safeValue) {
+    //   propertyValueQueryString += 'IS NULL'
+    // }
+
+    // if (typeof propertyValue === 'number') {
+    //   propertyValueQueryString += `= ${propertyValue}`
+    // }
 
     if (
       propertyRecordSchema &&
       propertyRecordSchema.ref &&
-      propertyRecordSchema.dataType === 'Relation' &&
-      !propertyNameRaw.endsWith('Id')
+      propertyRecordSchema.dataType === 'Relation'
     ) {
-      propertyName = propertyNameRaw + 'Id'
-    }
-
-    if (
-      propertyRecordSchema &&
-      propertyRecordSchema.ref &&
-      propertyRecordSchema.dataType === 'List' &&
-      !propertyNameRaw.endsWith('Ids')
-    ) {
-      propertyName = propertyNameRaw + 'Ids'
-    }
-
-    const _hydrateFromDb = async () => {
-      const db = getAppDb()
-
-      let hydrateQuery
-      let safeValue = propertyValue
-      let propertyValueQueryString = `property_value `
-      let propertyNameQueryString = `property_name = '${propertyName}'`
-      let propertyNameQuery = eq(metadata.propertyName, propertyName)
-
-      if (safeValue && typeof propertyValue === 'string') {
-        safeValue = escapeSqliteString(propertyValue)
-        propertyValueQueryString += `= '${safeValue}'`
-      }
-
-      if (!safeValue) {
-        propertyValueQueryString += 'IS NULL'
+      let missingPropertyNameVariant
+      if (propertyName.endsWith('Id')) {
+        missingPropertyNameVariant = propertyName.slice(0, -2)
       }
-
-      if (typeof propertyValue === 'number') {
-        propertyValueQueryString += `= ${propertyValue}`
+      if (!propertyName.endsWith('Id')) {
+        missingPropertyNameVariant = propertyName + 'Id'
       }
-
-      if (
-        propertyRecordSchema &&
-        propertyRecordSchema.ref &&
-        propertyRecordSchema.dataType === 'Relation'
-      ) {
-        let missingPropertyNameVariant
-        if (propertyName.endsWith('Id')) {
-          missingPropertyNameVariant = propertyName.slice(0, -2)
-        }
-        if (!propertyName.endsWith('Id')) {
-          missingPropertyNameVariant = propertyName + 'Id'
-        }
-        propertyNameQuery = or(
-          eq(metadata.propertyName, propertyName),
-          eq(metadata.propertyName, missingPropertyNameVariant),
+      if (missingPropertyNameVariant) {
+        whereClauses.push(
+          or(
+            eq(metadata.propertyName, propertyName),
+            eq(metadata.propertyName, missingPropertyNameVariant),
+          ),
         )
+        // propertyNameQuery = or(
+        //   eq(metadata.propertyName, propertyName),
+        //   eq(metadata.propertyName, missingPropertyNameVariant),
+        // )
       }
-
-      const selectFromStatement = db.select().from(metadata)
-
-      if (seedUid && !seedLocalId) {
-        hydrateQuery = selectFromStatement.where(
-          and(eq(metadata.seedUid, seedUid), propertyNameQuery),
-        )
+      if (!missingPropertyNameVariant) {
+        whereClauses.push(eq(metadata.propertyName, propertyName))
       }
+    }
 
-      if (seedUid && seedLocalId) {
-        hydrateQuery = selectFromStatement.where(
-          and(
-            eq(metadata.seedLocalId, seedLocalId),
-            eq(metadata.seedUid, seedUid),
-            propertyNameQuery,
-          ),
-        )
-      }
+    // if (seedUid && !seedLocalId) {
+    //   hydrateQuery = selectFromStatement.where(
+    //     and(eq(metadata.seedUid, seedUid), propertyNameQuery),
+    //   )
+    // }
+
+    if (seedUid) {
+      // hydrateQuery = selectFromStatement.where(
+      //   and(
+      //     eq(metadata.seedLocalId, seedLocalId),
+      //     eq(metadata.seedUid, seedUid),
+      //     propertyNameQuery,
+      //   ),
+      // )
+      whereClauses.push(eq(metadata.seedUid, seedUid))
+    }
 
-      if (!seedUid && seedLocalId) {
-        hydrateQuery = selectFromStatement.where(
-          and(eq(metadata.seedLocalId, seedLocalId), propertyNameQuery),
-        )
-      }
+    if (seedLocalId) {
+      // hydrateQuery = selectFromStatement.where(
+      //   and(eq(metadata.seedLocalId, seedLocalId), propertyNameQuery),
+      // )
+      whereClauses.push(eq(metadata.seedLocalId, seedLocalId))
+    }
 
-      if (!hydrateQuery) {
-        return
-      }
+    if (!hydrateQuery) {
+      return
+    }
 
-      const rows = await hydrateQuery.orderBy(
-        sql.raw('COALESCE(attestation_created_at, created_at) DESC'),
-      )
+    const rows = await appDb
+      .select()
+      .from(metadata)
+      .where(and(...whereClauses))
+      .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC'))
 
-      if (!rows || !rows.length) {
-        return
-      }
+    if (!rows || !rows.length) {
+      return
+    }
 
-      const firstRow = rows[0]
-
-      const {
-        localId,
-        uid,
-        propertyName: propertyNameFromDb,
-        propertyValue: propertyValueFromDb,
-        seedLocalId: seedLocalIdFromDb,
-        seedUid: seedUidFromDb,
-        schemaUid: schemaUidFromDb,
-        versionLocalId: versionLocalIdFromDb,
-        versionUid: versionUidFromDb,
-        refValueType,
-        refResolvedValue,
-        localStorageDir,
-      } = firstRow
-
-      let { refResolvedDisplayValue } = firstRow
-
-      let propertyValueProcessed: string | string[] | undefined | null =
-        propertyValueFromDb
-
-      if (propertyName && !propertyNameFromDb) {
-        logger(
-          `Property name from code is ${propertyName} but has not value in db ${propertyNameFromDb} for Property.${localId}`,
-        )
-      }
+    const firstRow = rows[0]
 
-      if (
-        propertyName &&
-        propertyNameFromDb &&
-        !propertyNameFromDb.includes(propertyName) &&
-        !propertyName.includes(propertyNameFromDb) &&
-        propertyNameFromDb !== propertyName
-      ) {
-        logger(
-          `Property name from db ${propertyNameFromDb} does not match property name ${propertyName} for Property.${localId}`,
-        )
-      }
+    const {
+      localId,
+      uid,
+      propertyName: propertyNameFromDb,
+      propertyValue: propertyValueFromDb,
+      seedLocalId: seedLocalIdFromDb,
+      seedUid: seedUidFromDb,
+      schemaUid: schemaUidFromDb,
+      versionLocalId: versionLocalIdFromDb,
+      versionUid: versionUidFromDb,
+      refValueType,
+      refResolvedValue,
+      localStorageDir,
+    } = firstRow
+
+    let { refResolvedDisplayValue } = firstRow
+
+    let propertyValueProcessed: string | string[] | undefined | null =
+      propertyValueFromDb
+
+    if (propertyName && !propertyNameFromDb) {
+      logger(
+        `Property name from code is ${propertyName} but has not value in db ${propertyNameFromDb} for Property.${localId}`,
+      )
+    }
 
-      if (propertyValue && propertyValueFromDb !== propertyValue) {
-        logger(
-          `Property value from db ${propertyValueFromDb} does not match property value ${propertyValue} for Property.${localId}`,
-        )
-      }
+    if (
+      propertyName &&
+      propertyNameFromDb &&
+      !propertyNameFromDb.includes(propertyName) &&
+      !propertyName.includes(propertyNameFromDb) &&
+      propertyNameFromDb !== propertyName
+    ) {
+      logger(
+        `Property name from db ${propertyNameFromDb} does not match property name ${propertyName} for Property.${localId}`,
+      )
+    }
 
-      if (seedLocalIdFromDb !== seedLocalId) {
-        logger(
-          `Seed local id from db ${seedLocalIdFromDb} does not match seed local id ${seedLocalId} for Property.${localId}`,
-        )
-      }
+    if (propertyValue && propertyValueFromDb !== propertyValue) {
+      logger(
+        `Property value from db ${propertyValueFromDb} does not match property value ${propertyValue} for Property.${localId}`,
+      )
+    }
 
-      if (seedUidFromDb !== seedUid) {
-        logger(
-          `Seed uid from db ${seedUidFromDb} does not match seed uid ${seedUid} for Property.${localId}`,
-        )
-      }
+    if (seedLocalIdFromDb !== seedLocalId) {
+      logger(
+        `Seed local id from db ${seedLocalIdFromDb} does not match seed local id ${seedLocalId} for Property.${localId}`,
+      )
+    }
 
-      if (
-        refResolvedValue &&
-        refResolvedDisplayValue &&
-        refResolvedDisplayValue.includes('http')
-      ) {
-        let urlNeedsToBeRefreshed = false
+    if (seedUidFromDb !== seedUid) {
+      logger(
+        `Seed uid from db ${seedUidFromDb} does not match seed uid ${seedUid} for Property.${localId}`,
+      )
+    }
 
-        try {
-          const response = await fetch(refResolvedDisplayValue, {
-            method: 'HEAD',
-          })
+    if (
+      refResolvedValue &&
+      refResolvedDisplayValue &&
+      refResolvedDisplayValue.includes('http')
+    ) {
+      let urlNeedsToBeRefreshed = false
 
-          // Check if the status is in the 200-299 range
-          if (!response.ok) {
-            urlNeedsToBeRefreshed = true
-          }
-        } catch (error) {
-          urlNeedsToBeRefreshed = true
-        }
+      try {
+        const response = await fetch(refResolvedDisplayValue, {
+          method: 'HEAD',
+        })
 
-        if (urlNeedsToBeRefreshed) {
-          let dir = localStorageDir
-          if (
-            !dir &&
-            propertyRecordSchema &&
-            propertyRecordSchema.refValueType === 'ImageSrc'
-          ) {
-            dir = 'images'
-          }
-          const filePath = `/files/${dir}/${refResolvedValue}`
-          const fileExists = await fs.promises.exists(filePath)
-          if (fileExists) {
-            const fileContents = await fs.promises.readFile(filePath)
-            const fileHandler = new File([fileContents], refResolvedValue)
-            refResolvedDisplayValue = URL.createObjectURL(fileHandler)
-            await updateMetadata({
-              localId,
-              refResolvedDisplayValue,
-            })
-          }
+        // Check if the status is in the 200-299 range
+        if (!response.ok) {
+          urlNeedsToBeRefreshed = true
         }
+      } catch (error) {
+        urlNeedsToBeRefreshed = true
       }
 
-      if (
-        propertyRecordSchema &&
-        propertyRecordSchema.dataType === 'List' &&
-        propertyRecordSchema.ref &&
-        typeof propertyValueFromDb === 'string'
-      ) {
-        propertyValueProcessed = propertyValueFromDb.split(',')
+      if (urlNeedsToBeRefreshed) {
+        let dir = localStorageDir
+        if (
+          !dir &&
+          propertyRecordSchema &&
+          propertyRecordSchema.refValueType === 'ImageSrc'
+        ) {
+          dir = 'images'
+        }
+        const filePath = `/files/${dir}/${refResolvedValue}`
+        const fileExists = await fs.promises.exists(filePath)
+        if (fileExists) {
+          const fileContents = await fs.promises.readFile(filePath)
+          const fileHandler = new File([fileContents], refResolvedValue)
+          refResolvedDisplayValue = URL.createObjectURL(fileHandler)
+          await updateMetadata({
+            localId,
+            refResolvedDisplayValue,
+          })
+        }
       }
+    }
 
-      sendBack({
-        type: 'updateContext',
-        localId,
-        uid,
-        propertyValue: propertyValueProcessed,
-        seedLocalId: seedLocalIdFromDb,
-        seedUid: seedUidFromDb,
-        versionLocalId: versionLocalIdFromDb,
-        versionUid: versionUidFromDb,
-        schemaUid: schemaUidFromDb,
-        refValueType,
-        localStorageDir,
-        resolvedValue: refResolvedValue,
-        resolvedDisplayValue: refResolvedDisplayValue,
-        renderValue: refResolvedDisplayValue,
-      })
+    if (
+      propertyRecordSchema &&
+      propertyRecordSchema.dataType === 'List' &&
+      propertyRecordSchema.ref &&
+      typeof propertyValueFromDb === 'string'
+    ) {
+      propertyValueProcessed = propertyValueFromDb.split(',')
+    }
 
-      if (
-        propertyRecordSchema &&
-        propertyRecordSchema.storageType &&
-        propertyRecordSchema.storageType === 'ItemStorage'
-      ) {
-        const { Item } = await import(`@/browser/item`)
-        const item = await Item.find({
-          seedLocalId,
-          modelName: itemModelName,
-        })
-        if (item) {
-          const filePath = `/files/${localStorageDir}/${refResolvedValue}`
-          const exists = await fs.promises.exists(filePath)
+    sendBack({
+      type: 'updateContext',
+      localId,
+      uid,
+      propertyValue: propertyValueProcessed,
+      seedLocalId: seedLocalIdFromDb,
+      seedUid: seedUidFromDb,
+      versionLocalId: versionLocalIdFromDb,
+      versionUid: versionUidFromDb,
+      schemaUid: schemaUidFromDb,
+      refValueType,
+      localStorageDir,
+      resolvedValue: refResolvedValue,
+      resolvedDisplayValue: refResolvedDisplayValue,
+      renderValue: refResolvedDisplayValue,
+    })
 
-          if (!exists) {
-            return
-          }
+    if (
+      propertyRecordSchema &&
+      propertyRecordSchema.storageType &&
+      propertyRecordSchema.storageType === 'ItemStorage'
+    ) {
+      const { Item } = await import(`@/browser/item`)
+      const item = await Item.find({
+        seedLocalId,
+        modelName: itemModelName,
+      })
+      if (item) {
+        const filePath = `/files/${localStorageDir}/${refResolvedValue}`
+        const exists = await fs.promises.exists(filePath)
 
-          const renderValue = await fs.promises.readFile(filePath, 'utf8')
-          const property = item.properties[propertyName]
-          property.getService().send({ type: 'updateRenderValue', renderValue })
+        if (!exists) {
           return
         }
+
+        const renderValue = await fs.promises.readFile(filePath, 'utf8')
+        const property = item.properties[propertyName]
+        property.getService().send({ type: 'updateRenderValue', renderValue })
+        return
       }
     }
+  }
 
-    _hydrateFromDb().then(() => {
-      sendBack({ type: 'hydrateFromDbSuccess' })
-    })
-  },
-)
+  _hydrateFromDb().then(() => {
+    sendBack({ type: 'hydrateFromDbSuccess' })
+  })
+})

package/dist/src/item.ts

@@ -351,7 +351,6 @@ export const usePublishItem = (): UsePublishItemReturn => {
       return
     }
     isLocked.current = true
-    console.log('Publishing item', item)
     setIsPublishing(true)
     try {
       // await item.publish()

package/dist/src/propertyMachine.ts

@@ -7,11 +7,11 @@ import { initialize } from '@/browser/property/actors/initialize'
 import { resolveRelatedValue } from '@/browser/property/actors/resolveRelatedValue'
 import { hydrateFromDb } from '@/browser/property/actors/hydrateFromDb'
 import {
-  analyzeInput,
   saveImageSrc,
   saveItemStorage,
   saveRelation,
-} from '@/browser/property/actors/saveValueToDb' // import { updateMachineContext } from '@/browser/helpers'
+} from '@/browser/property/actors/saveValueToDb'
+import { analyzeInput } from '@/browser/property/actors/saveValueToDb/analyzeInput' // import { updateMachineContext } from '@/browser/helpers'
 // import { updateMachineContext } from '@/browser/helpers'
 
 export const propertyMachine = setup({
@@ -54,6 +54,7 @@ export const propertyMachine = setup({
         }
       }),
     },
+    reload: '.hydratingFromDb',
     save: {
       actions: assign({
         isSaving: true,
@@ -64,12 +65,6 @@ export const propertyMachine = setup({
       actions: assign(({ context, event }) => {
         const newContext = Object.assign({}, context)
 
-        if (context.seedLocalId === 'qpIzW1e52r') {
-          console.log(
-            `[updateContext] before update versionLocalId is ${context.versionLocalId}`,
-          )
-        }
-
         for (let i = 0; i < Object.keys(event).length; i++) {
           const key = Object.keys(event)[i]
           if (key === 'type') {
@@ -77,12 +72,6 @@ export const propertyMachine = setup({
           }
           newContext[key] = event[key]
         }
-
-        if (context.seedLocalId === 'qpIzW1e52r') {
-          console.log(
-            `[updateContext] after update versionLocalId is ${newContext.versionLocalId}`,
-          )
-        }
         return newContext
       }),
     },

package/dist/src/request.ts

@@ -9,10 +9,6 @@ export const itemRequestHandler = async (event) => {
   const { seedLocalId, seedUid, modelName, eventId } = event
 
   if (activeItemRequests.has(seedLocalId)) {
-    console.log(
-      '[item/events] [itemRequestHandler] already requesting item with queue size',
-      queue.size,
-    )
     queue.set(seedLocalId, event)
     return
   }
@@ -44,11 +40,6 @@ export const itemRequestHandler = async (event) => {
   queue.delete(seedLocalId)
   if (queue.size > 0 && queue.has(seedLocalId)) {
     const nextEvent = queue.get(seedLocalId)
-    console.log(
-      '[item/events] [itemRequestHandler] taking event from queue with queue size',
-      queue.size,
-      nextEvent,
-    )
     await itemRequestHandler(nextEvent)
   }
 }

package/dist/src/saveImageSrc.ts

@@ -78,10 +78,6 @@ export const saveImageSrc = fromCallback<
     schemaUid,
   } = context
 
-  if (seedLocalId === 'qpIzW1e52r') {
-    console.log(`[saveImageSrc] versionLocaId is : ${versionLocalId}`)
-  }
-
   let newValue: ItemPropertyValueType
 
   if (event) {

package/dist/src/services.ts

@@ -114,9 +114,6 @@ export const useService = (service: ActorRef<any, any>) => {
   const updateTime = useCallback(
     (interval) => {
       const context = service.getSnapshot().context
-      if (context && context.times) {
-        console.log('[ActorItem] [useEffect] context.times', context.times)
-      }
       const status = service.getSnapshot().value
       if (
         status === 'done' ||

package/dist/src/updateItemPropertyValue.ts

@@ -218,6 +218,7 @@ export const updateItemPropertyValue: UpdateItemPropertyValue = async ({
                                         ${refSeedType ? `'${refSeedType}'` : 'NULL'},
                                         ${refResolvedValue ? `'${refResolvedValue}'` : 'NULL'},
                                         ${refResolvedDisplayValue ? `'${refResolvedDisplayValue}'` : 'NULL'},
+                                        ${localStorageDir ? `'${localStorageDir}'` : 'NULL'},
                                         ${Date.now()});`
 
   await runQueryForStatement(newPropertyStatement)

package/dist/src/waitForFiles.ts

@@ -0,0 +1,33 @@
+import { EventObject, fromCallback } from 'xstate'
+import { DbServiceContext, FromCallbackInput } from '@/types'
+import { DB_WAITING_FOR_FILES_RECEIVED } from '@/browser/services/internal/constants'
+import debug from 'debug'
+import fs from '@zenfs/core'
+
+const logger = debug('app:services:db:actors:waitForFiles')
+
+export const waitForFiles = fromCallback<
+  EventObject,
+  FromCallbackInput<DbServiceContext>
+>(({ sendBack, input: { context } }) => {
+  const { pathToDbDir } = context
+
+  const _waitForFiles = async (): Promise<void> => {
+    return new Promise((resolve) => {
+      const interval = setInterval(async () => {
+        const journalExists = await fs.promises.exists(
+          `${pathToDbDir}/meta/_journaljson`,
+        )
+        if (journalExists) {
+          clearInterval(interval)
+          resolve()
+        }
+      })
+    })
+  }
+
+  _waitForFiles().then(() => {
+    sendBack({ type: DB_WAITING_FOR_FILES_RECEIVED })
+    return
+  })
+})