@seedprotocol/sdk 0.1.67 → 0.1.70

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-nGDuz8NN.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-Cy1fke9s.js';
 import 'immer';
 import 'reflect-metadata';
 import './constants-BLctWkrn.js';
@@ -14,14 +14,14 @@ import 'nanoid-dictionary';
 import 'debug';
 import 'lodash-es';
 import 'drizzle-orm/sqlite-core';
+import 'react';
+import 'rxjs';
+import 'pluralize';
 import 'eventemitter3';
 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';

package/dist/{seed.schema.config-miFErQ6h.js → seed.schema.config-dylVDX7W.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-nGDuz8NN.js';
+import { T as Text, M as Model } from './index-Cy1fke9s.js';
 import 'react';
 import 'reflect-metadata';
 import 'xstate';
@@ -15,14 +15,14 @@ import 'nanoid-dictionary';
 import 'debug';
 import 'lodash-es';
 import 'drizzle-orm/sqlite-core';
+import 'rxjs';
+import 'immer';
+import 'pluralize';
 import 'eventemitter3';
 import '@tanstack/react-query';
 import 'graphql-request';
 import '@tanstack/query-sync-storage-persister';
 import '@tanstack/react-query-persist-client';
-import 'rxjs';
-import 'immer';
-import 'pluralize';
 import '@statelyai/inspect';
 import 'drizzle-orm/sqlite-proxy';
 import 'use-immer';
@@ -74,4 +74,4 @@ const models = {
 };
 
 export { models };
-//# sourceMappingURL=seed.schema.config-miFErQ6h.js.map
+//# sourceMappingURL=seed.schema.config-dylVDX7W.js.map

package/dist/{seed.schema.config-miFErQ6h.js.map → seed.schema.config-dylVDX7W.js.map}

@@ -1 +1 @@
-{"version":3,"file":"seed.schema.config-miFErQ6h.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-dylVDX7W.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

@@ -16,6 +16,10 @@ export const createMetadata: CreateMetadata = async (
 
   metadataValues.localId = generateId()
 
+  if (!metadataValues.modelType && metadataValues.modelName) {
+    metadataValues.modelType = metadataValues.modelName.toLowerCase()
+  }
+
   if (
     propertyRecordSchema &&
     propertyRecordSchema.localStorageDir &&

package/dist/src/getItems.ts

@@ -54,6 +54,8 @@ export const getItemsData: GetItemsData = async ({
       versionsCount: versionData.versionsCount,
       lastVersionPublishedAt: versionData.lastVersionPublishedAt,
       lastLocalUpdateAt: versionData.lastLocalUpdateAt,
+      latestVersionUid: versionData.latestVersionUid,
+      latestVersionLocalId: versionData.latestVersionLocalId,
       createdAt: seeds.createdAt,
     })
     .from(seeds)

package/dist/src/getVersionData.ts

@@ -3,7 +3,7 @@ import { versions, VersionsType } from '@/shared/seedSchema'
 import { and, eq } from 'drizzle-orm'
 
 type GetVersionDataProps = {
-  localId?: string
+  localId?: string | null
   uid?: string
   seedLocalId?: string
 }

package/dist/src/hydrateFromDb.ts

@@ -195,7 +195,15 @@ export const hydrateFromDb = fromCallback<EventObject, typeof propertyMachine>(
         }
 
         if (urlNeedsToBeRefreshed) {
-          const filePath = `/files/${localStorageDir}/${refResolvedValue}`
+          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)
@@ -214,6 +222,25 @@ export const hydrateFromDb = fromCallback<EventObject, typeof propertyMachine>(
         propertyValueProcessed = propertyValueFromDb.split(',')
       }
 
+      if (seedLocalIdFromDb === 'sAFXuO7Uez') {
+        console.log(`[hydrateFromDb] sending updateContext with:`, {
+          type: 'updateContext',
+          localId,
+          uid,
+          propertyValue: propertyValueProcessed,
+          seedLocalId: seedLocalIdFromDb,
+          seedUid: seedUidFromDb,
+          versionLocalId: versionLocalIdFromDb,
+          versionUid: versionUidFromDb,
+          schemaUid: schemaUidFromDb,
+          refValueType,
+          localStorageDir,
+          resolvedValue: refResolvedValue,
+          resolvedDisplayValue: refResolvedDisplayValue,
+          renderValue: refResolvedDisplayValue,
+        })
+      }
+
       sendBack({
         type: 'updateContext',
         localId,

package/dist/src/index.ts

@@ -1,21 +1,106 @@
-import { setup } from 'xstate'
+import { EventObject, fromCallback } from 'xstate'
+import { FromCallbackInput } from '@/types/machines'
 import {
-  uploadBinaryData,
-  uploadMetadata,
-} from '@/browser/schema/file/upload/actors'
-
-export const uploadMachine = setup({
-  actors: {
-    uploadBinaryData,
-    uploadMetadata,
-  },
-}).createMachine({
-  id: 'upload',
-  initial: 'idle',
-  context: {
-    file: '',
-  },
-  states: {
-    idle: {},
-  },
+  ItemPropertyValueType,
+  PropertyMachineContext,
+  SaveValueToDbEvent,
+} from '@/types/property'
+import { updateItemPropertyValue } from '@/browser/db/write/updateItemPropertyValue'
+
+export * from './saveImageSrc'
+export * from './saveRelation'
+export * from './saveItemStorage'
+
+export const analyzeInput = fromCallback<
+  EventObject,
+  FromCallbackInput<PropertyMachineContext, SaveValueToDbEvent>
+>(({ sendBack, input: { context, event } }) => {
+  const {
+    localId,
+    propertyName: propertyNameRaw,
+    seedLocalId,
+    versionLocalId,
+    versionUid,
+    propertyValue: existingValue,
+    propertyRecordSchema,
+    itemModelName,
+    schemaUid,
+  } = context
+
+  let newValue: ItemPropertyValueType
+
+  if (event) {
+    newValue = event.newValue
+  }
+
+  if (existingValue === newValue) {
+    sendBack({ type: 'saveValueToDbSuccess' })
+    return
+  }
+
+  if (!propertyRecordSchema) {
+    throw new Error('Missing propertyRecordSchema')
+  }
+
+  const _analyzeInput = async (): Promise<boolean> => {
+    let propertyName = propertyNameRaw
+
+    if (
+      propertyRecordSchema.refValueType &&
+      propertyRecordSchema.refValueType !== 'ImageSrc' &&
+      propertyRecordSchema.dataType === 'Relation'
+    ) {
+      sendBack({
+        type: 'saveRelation',
+        newValue,
+      })
+      return false
+    }
+
+    if (
+      propertyRecordSchema.refValueType === 'ImageSrc' ||
+      propertyRecordSchema.dataType === 'ImageSrc'
+    ) {
+      sendBack({
+        type: 'saveImageSrc',
+        newValue,
+      })
+      return false
+    }
+
+    if (
+      propertyRecordSchema.storageType &&
+      propertyRecordSchema.storageType === 'ItemStorage'
+    ) {
+      sendBack({
+        type: 'saveItemStorage',
+        newValue,
+      })
+      return false
+    }
+
+    await updateItemPropertyValue({
+      localId: localId,
+      propertyName,
+      newValue,
+      seedLocalId,
+      versionLocalId,
+      versionUid,
+      modelName: itemModelName,
+      schemaUid,
+    })
+
+    sendBack({
+      type: 'updateContext',
+      propertyValue: newValue,
+    })
+
+    return true
+  }
+
+  _analyzeInput().then((isDone) => {
+    if (isDone) {
+      sendBack({ type: 'saveValueToDbSuccess' })
+    }
+  })
 })

package/dist/src/propertyMachine.ts

@@ -64,6 +64,12 @@ 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') {
@@ -71,6 +77,12 @@ 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/saveImageSrc.ts

@@ -5,12 +5,13 @@ import {
   PropertyMachineContext,
   SaveValueToDbEvent,
 } from '@/types/property'
-import { createSeed, updateItemPropertyValue } from '@/browser/db/write'
+import { createSeed } 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'
+import { updateItemPropertyValue } from '@/browser/db/write/updateItemPropertyValue'
 
 const readFileAsDataUrl = async (file: File): Promise<string> => {
   return new Promise((resolve) => {
@@ -77,6 +78,10 @@ export const saveImageSrc = fromCallback<
     schemaUid,
   } = context
 
+  if (seedLocalId === 'qpIzW1e52r') {
+    console.log(`[saveImageSrc] versionLocaId is : ${versionLocalId}`)
+  }
+
   let newValue: ItemPropertyValueType
 
   if (event) {
@@ -173,6 +178,8 @@ export const saveImageSrc = fromCallback<
           refSeedType: 'image',
           refResolvedDisplayValue,
           refResolvedValue: fileName,
+          localStorageDir: '/images',
+          easDataType: 'bytes32',
         },
         propertyRecordSchema,
       )
@@ -180,7 +187,7 @@ export const saveImageSrc = fromCallback<
 
     if (localId) {
       await updateItemPropertyValue({
-        propertyLocalId: localId,
+        localId: localId,
         propertyName: propertyNameRaw,
         newValue: newImageSeedLocalId,
         seedLocalId,
@@ -190,6 +197,8 @@ export const saveImageSrc = fromCallback<
         refSeedType: 'image',
         refResolvedDisplayValue,
         refResolvedValue: fileName,
+        localStorageDir: '/images',
+        easDataType: 'bytes32',
       })
     }
 

package/dist/src/updateItemPropertyValue.ts

@@ -0,0 +1,230 @@
+import { escapeSqliteString } from '@/shared/helpers/db'
+import { getAppDb, runQueryForStatement } from '@/browser'
+import { metadata, MetadataType } from '@/shared/seedSchema'
+import { and, eq, sql } from 'drizzle-orm'
+import { getSeedData } from '@/browser/db/read/getSeedData'
+import { getVersionData } from '@/browser/db/read/getVersionData'
+import { generateId } from '@/shared/helpers'
+import debug from 'debug'
+import { eventEmitter } from '@/eventBus'
+
+const logger = debug('app:write:updateItemPropertyValue')
+
+const sendItemUpdateEvent = ({ modelName, seedLocalId, seedUid }) => {
+  if (!modelName || (!seedLocalId && !seedUid)) {
+    return
+  }
+  eventEmitter.emit(`item.${modelName}.${seedUid || seedLocalId}.update`)
+}
+
+type UpdateItemPropertyValue = (props: Partial<MetadataType>) => Promise<void>
+
+export const updateItemPropertyValue: UpdateItemPropertyValue = async ({
+  localId,
+  propertyName,
+  newValue,
+  seedUid,
+  seedLocalId,
+  modelName,
+  refSeedType,
+  refResolvedValue,
+  refResolvedDisplayValue,
+  versionLocalId,
+  versionUid,
+  schemaUid,
+  localStorageDir,
+}) => {
+  if (!localId && !seedLocalId) {
+    logger(
+      `[db/write] [updateItemPropertyValue] no propertyLocalId or seedLocalId for property: ${propertyName}`,
+    )
+    return
+  }
+
+  let safeNewValue = newValue
+
+  if (
+    typeof newValue === 'string' &&
+    !refResolvedDisplayValue &&
+    !refResolvedValue
+  ) {
+    safeNewValue = escapeSqliteString(newValue)
+  }
+
+  const appDb = getAppDb()
+
+  const rows = await appDb
+    .select()
+    .from(metadata)
+    .where(
+      and(
+        eq(metadata.propertyName, propertyName!),
+        eq(metadata.seedLocalId, seedLocalId!),
+      ),
+    )
+    .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC'))
+
+  // const mostRecentRecordStatement = `SELECT local_id,
+  //                                           uid,
+  //                                           property_name,
+  //                                           property_value,
+  //                                           model_type,
+  //                                           seed_uid,
+  //                                           seed_local_id,
+  //                                           version_local_id,
+  //                                           version_uid,
+  //                                           schema_uid,
+  //                                           eas_data_type
+  //                                    FROM metadata
+  //                                    WHERE property_name = '${propertyName}'
+  //                                      AND seed_local_id = '${seedLocalId}'
+  //                                    ORDER BY COALESCE(attestation_created_at, created_at) DESC;`
+  //
+  // const { rows } = await runQueryForStatement(mostRecentRecordStatement)
+
+  if (rows && rows.length > 0) {
+    const {
+      localId,
+      uid,
+      propertyName: propertyNameFromDb,
+      propertyValue: propertyValueFromDb,
+      modelType,
+      seedUid,
+      seedLocalId: seedLocalIdFromDb,
+      versionLocalId,
+      versionUid,
+      schemaUid,
+      easDataType,
+      localStorageDir: localStorageDirFromDb,
+      refSeedType: refSeedTypeFromDb,
+      refResolvedValue: refResolvedValueFromDb,
+      refResolvedDisplayValue: refResolvedDisplayValueFromDb,
+    } = rows[0]
+
+    if (
+      propertyValueFromDb === newValue &&
+      modelType === modelName?.toLowerCase() &&
+      refSeedTypeFromDb === refSeedType &&
+      refResolvedValueFromDb === refResolvedValue
+    ) {
+      logger(
+        `[db/write] [updateItemPropertyValue] value is the same as most recent record for property: ${propertyNameFromDb}`,
+      )
+      return
+    }
+
+    // This means we already have a local-only record so we should just update that one
+    if (!uid) {
+      const updatePropertyStatement = `UPDATE metadata
+                                       SET property_value             = '${safeNewValue}',
+                                           ref_seed_type              = ${refSeedType ? `'${refSeedType}'` : 'NULL'},
+                                           ref_resolved_value         = ${refResolvedValue ? `'${refResolvedValue}'` : 'NULL'},
+                                           ref_resolved_display_value = ${refResolvedDisplayValue ? `'${refResolvedDisplayValue}'` : 'NULL'},
+                                           updated_at                 = ${Date.now()}
+                                       WHERE local_id = '${localId}';`
+
+      await runQueryForStatement(updatePropertyStatement)
+
+      sendItemUpdateEvent({ modelName, seedLocalId, seedUid })
+
+      return
+    }
+
+    const seedDataFromDb = await getSeedData({ seedLocalId })
+    const versionDataFromDb = await getVersionData({ localId: versionLocalId })
+
+    // Here we don't have a local-only record so we need to create a new one
+    const newLocalId = generateId()
+
+    const newPropertyStatement = `INSERT INTO metadata (local_id,
+                                                        property_name,
+                                                        property_value,
+                                                        model_type,
+                                                        seed_uid,
+                                                        seed_local_id,
+                                                        version_local_id,
+                                                        version_uid,
+                                                        schema_uid,
+                                                        eas_data_type,
+                                                        ref_seed_type,
+                                                        ref_resolved_value,
+                                                        ref_resolved_display_value,
+                                                        local_storage_dir,
+                                                        created_at)
+                                  VALUES ('${newLocalId}',
+                                          '${propertyNameFromDb}',
+                                          '${safeNewValue}',
+                                          '${modelType || modelName?.toLowerCase()}',
+                                          ${seedDataFromDb?.uid ? `'${seedDataFromDb.uid}'` : 'NULL'},
+                                          '${seedLocalIdFromDb}',
+                                          '${versionLocalId}',
+                                          ${versionDataFromDb?.uid ? `'${versionDataFromDb.uid}'` : 'NULL'},
+                                          '${schemaUid}',
+                                          ${easDataType ? `'${easDataType}'` : 'NULL'},
+                                          ${refSeedType ? `'${refSeedType}'` : 'NULL'},
+                                          ${refResolvedValue ? `'${refResolvedValue}'` : 'NULL'},
+                                          ${refResolvedDisplayValue ? `'${refResolvedDisplayValue}'` : 'NULL'},
+                                          ${localStorageDir ? `'${localStorageDir}'` : 'NULL'},
+                                          ${Date.now()});`
+
+    await runQueryForStatement(newPropertyStatement)
+
+    sendItemUpdateEvent({ modelName, seedLocalId, seedUid })
+
+    return
+  }
+
+  // Here there are no records for this property on this seed so we should create one
+
+  const newLocalId = generateId()
+
+  if (!seedUid) {
+    const seedData = await getSeedData({ seedLocalId })
+    if (seedData) {
+      seedUid = seedData.uid
+    }
+  }
+
+  if (!versionUid) {
+    const versionData = await getVersionData({ localId: versionLocalId })
+    if (versionData) {
+      versionUid = versionData.uid
+    }
+  }
+
+  const newPropertyStatement = `INSERT INTO metadata (local_id,
+                                                      property_name,
+                                                      property_value,
+                                                      model_type,
+                                                      seed_uid,
+                                                      seed_local_id,
+                                                      version_local_id,
+                                                      version_uid,
+                                                      schema_uid,
+                                                      ref_seed_type,
+                                                      ref_resolved_value,
+                                                      ref_resolved_display_value,
+                                                      local_storage_dir,
+                                                      created_at)
+                                VALUES ('${newLocalId}',
+                                        '${propertyName}',
+                                        '${safeNewValue}',
+                                        '${modelName?.toLowerCase()}',
+                                        ${seedUid ? `'${seedUid}'` : 'NULL'},
+                                        '${seedLocalId}',
+                                        '${versionLocalId}',
+                                        ${versionUid ? `'${versionUid}'` : 'NULL'},
+                                        '${schemaUid}',
+                                        ${refSeedType ? `'${refSeedType}'` : 'NULL'},
+                                        ${refResolvedValue ? `'${refResolvedValue}'` : 'NULL'},
+                                        ${refResolvedDisplayValue ? `'${refResolvedDisplayValue}'` : 'NULL'},
+                                        ${Date.now()});`
+
+  await runQueryForStatement(newPropertyStatement)
+
+  sendItemUpdateEvent({ modelName, seedLocalId, seedUid })
+
+  if (!seedLocalId && propertyName && modelName && newValue) {
+    // TODO: Does this ever happen? If so, what should we do?
+  }
+}