@seedprotocol/sdk 0.1.74 → 0.1.76

package/dist/src/getItemProperties.ts

@@ -1,15 +1,7 @@
 import { PropertyData } from '@/types'
 import { getAppDb } from '@/browser/db/sqlWasmClient'
 import { metadata, seeds, versions } from '@/shared/seedSchema'
-import {
-  and,
-  eq,
-  getTableColumns,
-  isNotNull,
-  isNull,
-  or,
-  SQL,
-} from 'drizzle-orm'
+import { and, eq, getTableColumns, isNotNull, isNull, SQL } from 'drizzle-orm'
 
 type GetPropertiesForSeedProps = {
   seedLocalId?: string
@@ -30,16 +22,24 @@ export const getItemProperties: GetItemProperties = async ({
 
   const whereClauses: SQL[] = [isNotNull(metadata.propertyName)]
 
-  const uidWhereClause: SQL = seedUid
-    ? eq(seeds.uid, seedUid)
-    : isNull(seeds.uid)
-  const localWhereClause: SQL = seedLocalId
-    ? eq(seeds.localId, seedLocalId)
-    : isNull(seeds.localId)
+  if (seedUid) {
+    whereClauses.push(eq(seeds.uid, seedUid))
+  }
+
+  if (seedLocalId) {
+    whereClauses.push(eq(seeds.localId, seedLocalId))
+  }
 
-  whereClauses.push(or(localWhereClause, uidWhereClause) as SQL)
+  // const uidWhereClause: SQL = seedUid
+  //   ? eq(seeds.uid, seedUid)
+  //   : isNull(seeds.uid)
+  // const localWhereClause: SQL = seedLocalId
+  //   ? eq(seeds.localId, seedLocalId)
+  //   : isNull(seeds.localId)
+
+  // whereClauses.push(or(localWhereClause, uidWhereClause) as SQL)
   whereClauses.push(isNotNull(metadata.propertyName))
-  whereClauses.push(isNotNull(metadata.easDataType))
+  // whereClauses.push(isNotNull(metadata.easDataType))
 
   if (typeof edited !== 'undefined') {
     if (edited) {
@@ -50,21 +50,6 @@ export const getItemProperties: GetItemProperties = async ({
     }
   }
 
-  // if (!seedLocalId || !seedUid) {
-  //   const seedRows = await appDb
-  //     .select({
-  //       localId: seeds.localId,
-  //       uid: seeds.uid,
-  //     })
-  //     .from(seeds)
-  //     .where(or(localWhereClause, uidWhereClause))
-  //
-  //   if (seedRows && seedRows.length > 0) {
-  //     seedUid = seedRows[0].uid as string
-  //     seedLocalId = seedRows[0].localId as string
-  //   }
-  // }
-
   const metadataColumns = getTableColumns(metadata)
 
   const propertiesData = await appDb
@@ -79,84 +64,3 @@ export const getItemProperties: GetItemProperties = async ({
 
   return propertiesData
 }
-
-// const localIdWhere = seedLocalId
-//   ? `s.local_id = '${seedLocalId}'`
-//   : 's.local_id IS NULL'
-// const uidWhere = seedUid ? `s.uid = '${seedUid}'` : 's.uid IS NULL'
-//
-// const queryStatement = `WITH LatestMetadata as (SELECT m.property_name,
-//                                                        m.property_value,
-//                                                        m.version_local_id,
-//                                                        MAX(m.attestation_created_at),
-//                                                        m.uid,
-//                                                        m.seed_local_id,
-//                                                        seed_uid
-//                                                 FROM metadata m
-//                                                          JOIN seeds s ON s.local_id = m.seed_local_id
-//                                                 GROUP BY m.property_name),
-//
-//                              LatestVersion as (SELECT v.local_id,
-//                                                       MAX(v.attestation_created_at) as attestation_created_at,
-//                                                       v.uid,
-//                                                       v.seed_local_id,
-//                                                       v.seed_uid
-//                                                FROM versions v
-//                                                         JOIN seeds s ON s.local_id = v.seed_local_id
-//                                                GROUP BY s.local_id)
-//
-//
-//                         SELECT s.local_id,
-//                                s.uid,
-//                                s.schema_uid,
-//                                m.property_name,
-//                                m.property_value,
-//                                COUNT(v.local_id) as versions_count,
-//                                m.model_type,
-//                                lv.attestation_created_at,
-//                                m.local_id,
-//                                m.uid,
-//                                MAX(m.attestation_created_at),
-//                                m.ref_seed_type,
-//                                m.ref_value_type,
-//                                m.seed_local_id,
-//                                m.seed_uid,
-//                                m.created_at,
-//                                m.updated_at,
-//                                m.version_uid
-//                         FROM seeds s
-//                                  JOIN LatestMetadata lm ON s.local_id = m.seed_local_id
-//                                  JOIN LatestVersion lv ON lv.seed_local_id = m.seed_local_id
-//                                  JOIN metadata m ON m.property_name = lm.property_name OR lm.property_value = s.uid
-//                                  JOIN versions v ON s.local_id = v.seed_local_id
-//                         WHERE ${localIdWhere}
-//                            OR ${uidWhere}
-//                         GROUP BY m.property_name;
-// `
-//
-// const { rows } = await runQueryForStatement(queryStatement)
-//
-// const propertiesDataOld: PropertyData[] = []
-//
-// for (const row of rows) {
-//   propertiesDataOld.push({
-//     localId: row[0],
-//     uid: row[1],
-//     schemaUid: row[2],
-//     propertyName: row[3],
-//     propertyValue: row[4],
-//     versionsCount: row[5],
-//     itemModelName: row[6],
-//     attestationCreatedAt: row[7],
-//     metadataLocalId: row[8],
-//     metadataUid: row[9],
-//     metadataAttestationCreatedAt: row[10],
-//     refSeedType: row[11],
-//     refValueType: row[12],
-//     seedLocalId: row[13],
-//     seedUid: row[14],
-//     createdAt: row[15],
-//     updatedAt: row[16],
-//     versionUid: row[17],
-//   })
-// }

package/dist/src/hydrateFromDb.ts

@@ -1,277 +1,257 @@
 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 = []
 
     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}'`
+      let missingPropertyNameVariant
+      if (propertyName.endsWith('Id')) {
+        missingPropertyNameVariant = propertyName.slice(0, -2)
       }
-
-      if (!safeValue) {
-        propertyValueQueryString += 'IS NULL'
-      }
-
-      if (typeof propertyValue === 'number') {
-        propertyValueQueryString += `= ${propertyValue}`
-      }
-
-      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 (!propertyName.endsWith('Id')) {
+        missingPropertyNameVariant = propertyName + 'Id'
       }
-
-      const selectFromStatement = db.select().from(metadata)
-
-      if (seedUid && !seedLocalId) {
-        hydrateQuery = selectFromStatement.where(
-          and(eq(metadata.seedUid, seedUid), propertyNameQuery),
-        )
-      }
-
-      if (seedUid && seedLocalId) {
-        hydrateQuery = selectFromStatement.where(
-          and(
-            eq(metadata.seedLocalId, seedLocalId),
-            eq(metadata.seedUid, seedUid),
-            propertyNameQuery,
+      if (missingPropertyNameVariant) {
+        whereClauses.push(
+          or(
+            eq(metadata.propertyName, propertyName),
+            eq(metadata.propertyName, missingPropertyNameVariant),
           ),
         )
       }
-
-      if (!seedUid && seedLocalId) {
-        hydrateQuery = selectFromStatement.where(
-          and(eq(metadata.seedLocalId, seedLocalId), propertyNameQuery),
-        )
-      }
-
-      if (!hydrateQuery) {
-        return
+      if (!missingPropertyNameVariant) {
+        whereClauses.push(eq(metadata.propertyName, propertyName))
       }
+    } else {
+      whereClauses.push(eq(metadata.propertyName, propertyName))
+    }
 
-      const rows = await hydrateQuery.orderBy(
-        sql.raw('COALESCE(attestation_created_at, created_at) DESC'),
-      )
+    if (seedUid) {
+      whereClauses.push(eq(metadata.seedUid, seedUid))
+    }
 
-      if (!rows || !rows.length) {
-        return
-      }
+    if (seedLocalId) {
+      whereClauses.push(eq(metadata.seedLocalId, seedLocalId))
+    }
 
-      const firstRow = rows[0]
+    const rows = await appDb
+      .select()
+      .from(metadata)
+      .where(and(...whereClauses))
+      .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC'))
 
-      const {
-        localId,
-        uid,
-        propertyName: propertyNameFromDb,
-        propertyValue: propertyValueFromDb,
-        seedLocalId: seedLocalIdFromDb,
-        seedUid: seedUidFromDb,
-        schemaUid: schemaUidFromDb,
-        versionLocalId: versionLocalIdFromDb,
-        versionUid: versionUidFromDb,
-        refValueType,
-        refResolvedValue,
-        localStorageDir,
-      } = firstRow
+    if (!rows || !rows.length) {
+      return
+    }
 
-      let { refResolvedDisplayValue } = firstRow
+    const firstRow = rows[0]
 
-      let propertyValueProcessed: string | string[] | undefined | null =
-        propertyValueFromDb
+    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 (propertyName && !propertyNameFromDb) {
-        logger(
-          `Property name from code is ${propertyName} but has not value in db ${propertyNameFromDb} 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 (
-        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 (propertyValue && propertyValueFromDb !== propertyValue) {
+      logger(
+        `Property value from db ${propertyValueFromDb} does not match property value ${propertyValue} for Property.${localId}`,
+      )
+    }
 
-      if (propertyValue && propertyValueFromDb !== propertyValue) {
-        logger(
-          `Property value from db ${propertyValueFromDb} does not match property value ${propertyValue} for Property.${localId}`,
-        )
-      }
+    if (seedLocalIdFromDb !== seedLocalId) {
+      logger(
+        `Seed local id from db ${seedLocalIdFromDb} does not match seed local id ${seedLocalId} for Property.${localId}`,
+      )
+    }
 
-      if (seedLocalIdFromDb !== seedLocalId) {
-        logger(
-          `Seed local id from db ${seedLocalIdFromDb} does not match seed local id ${seedLocalId} for Property.${localId}`,
-        )
-      }
+    if (seedUidFromDb !== seedUid) {
+      logger(
+        `Seed uid from db ${seedUidFromDb} does not match seed uid ${seedUid} for Property.${localId}`,
+      )
+    }
 
-      if (seedUidFromDb !== seedUid) {
-        logger(
-          `Seed uid from db ${seedUidFromDb} does not match seed uid ${seedUid} for Property.${localId}`,
-        )
-      }
+    if (
+      propertyRecordSchema &&
+      propertyRecordSchema.refValueType === 'ImageSrc'
+    ) {
+      let shouldReadFromFile = true
 
       if (
         refResolvedValue &&
         refResolvedDisplayValue &&
         refResolvedDisplayValue.includes('http')
       ) {
-        let urlNeedsToBeRefreshed = false
-
         try {
           const response = await fetch(refResolvedDisplayValue, {
             method: 'HEAD',
           })
 
           // Check if the status is in the 200-299 range
-          if (!response.ok) {
-            urlNeedsToBeRefreshed = true
+          if (response.ok) {
+            shouldReadFromFile = false
           }
         } catch (error) {
-          urlNeedsToBeRefreshed = true
-        }
-
-        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,
-            })
-          }
+          shouldReadFromFile = true
         }
       }
 
-      if (
-        propertyRecordSchema &&
-        propertyRecordSchema.dataType === 'List' &&
-        propertyRecordSchema.ref &&
-        typeof propertyValueFromDb === 'string'
-      ) {
-        propertyValueProcessed = propertyValueFromDb.split(',')
+      if (shouldReadFromFile) {
+        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' })
+  })
+})