@seedprotocol/sdk 0.1.67 → 0.1.70

package/dist/{index-nGDuz8NN.js → index-Cy1fke9s.js}

@@ -11,15 +11,15 @@ import * as nanoIdDictionary from 'nanoid-dictionary';
 import debug from 'debug';
 import { startCase, debounce, camelCase, orderBy } from 'lodash-es';
 import { sqliteTable, text, int, blob, check, unique } from 'drizzle-orm/sqlite-core';
+import { useState, useEffect, useRef, useCallback } from 'react';
+import { BehaviorSubject } from 'rxjs';
+import { immerable, produce, enableMapSet } from 'immer';
+import pluralize from 'pluralize';
 import EventEmitter from 'eventemitter3';
 import { QueryClient } from '@tanstack/react-query';
 import { GraphQLClient } from 'graphql-request';
 import { createSyncStoragePersister } from '@tanstack/query-sync-storage-persister';
 import { persistQueryClient } from '@tanstack/react-query-persist-client';
-import { useState, useEffect, useRef, useCallback } from 'react';
-import { BehaviorSubject } from 'rxjs';
-import { immerable, produce, enableMapSet } from 'immer';
-import pluralize from 'pluralize';
 import { createBrowserInspector } from '@statelyai/inspect';
 import { drizzle } from 'drizzle-orm/sqlite-proxy';
 import { WebAccess } from '@zenfs/dom';
@@ -989,7 +989,13 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
                 urlNeedsToBeRefreshed = true;
             }
             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 = yield fs.promises.exists(filePath);
                 if (fileExists) {
                     const fileContents = yield fs.promises.readFile(filePath);
@@ -1004,6 +1010,24 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
             typeof propertyValueFromDb === 'string') {
             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,
@@ -1023,7 +1047,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
         if (propertyRecordSchema &&
             propertyRecordSchema.storageType &&
             propertyRecordSchema.storageType === 'ItemStorage') {
-            const { Item } = yield import('./index-BJn9UAOX.js');
+            const { Item } = yield import('./index-B6WilINl.js');
             const item = yield Item.find({
                 seedLocalId,
                 modelName: itemModelName,
@@ -1046,47 +1070,59 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const getSeedData = (_a) => __awaiter(void 0, [_a], void 0, function* ({ seedLocalId, seedUid }) {
+const getVersionData$1 = () => {
     const appDb = getAppDb();
-    let query;
-    const queryBase = appDb.select().from(seeds);
-    if (seedLocalId) {
-        query = queryBase.where(eq(seeds.localId, seedLocalId));
-    }
-    if (seedUid) {
-        query = queryBase.where(eq(seeds.uid, seedUid));
-    }
-    const rows = yield query;
-    if (!rows || !rows.length) {
-        return;
-    }
-    return rows[0];
-});
+    return appDb.$with('versionData').as(appDb
+        .select({
+        seedLocalId: versions.seedLocalId,
+        seedUid: versions.seedUid,
+        latestVersionUid: versions.uid,
+        latestVersionLocalId: versions.localId,
+        versionsCount: count(versions.localId).as('versionsCount'),
+        lastVersionPublishedAt: max(versions.attestationCreatedAt).as('lastVersionPublishedAt'),
+        lastLocalUpdateAt: max(versions.createdAt).as('lastLocalUpdateAt'),
+    })
+        .from(versions)
+        .groupBy(versions.seedLocalId));
+};
 
-const getVersionData$1 = (_a) => __awaiter(void 0, [_a], void 0, function* ({ localId, seedLocalId, uid, }) {
+const getItemsData = (_a) => __awaiter(void 0, [_a], void 0, function* ({ modelName, deleted, }) {
     const appDb = getAppDb();
-    const whereClauses = [];
-    if (seedLocalId) {
-        whereClauses.push(eq(versions.localId, seedLocalId));
-    }
-    if (localId) {
-        whereClauses.push(eq(versions.localId, localId));
+    const conditions = [];
+    if (modelName) {
+        conditions.push(eq(seeds.type, modelName.toLowerCase()));
     }
-    if (uid) {
-        whereClauses.push(eq(versions.uid, uid));
+    if (deleted) {
+        conditions.push(or(isNotNull(seeds._markedForDeletion), eq(seeds._markedForDeletion, 1)));
     }
-    const queryRows = yield appDb
-        .select()
-        .from(versions)
-        .where(and(...whereClauses));
-    if (!queryRows || !queryRows.length) {
-        return;
+    if (!deleted) {
+        conditions.push(or(isNull(seeds._markedForDeletion), eq(seeds._markedForDeletion, 0)));
     }
-    return queryRows[0];
+    const versionData = getVersionData$1();
+    let query = appDb
+        .with(versionData)
+        .select({
+        seedLocalId: seeds.localId,
+        seedUid: seeds.uid,
+        schemaUid: seeds.schemaUid,
+        modelName: sql `${modelName}`,
+        attestationCreatedAt: seeds.attestationCreatedAt,
+        versionsCount: versionData.versionsCount,
+        lastVersionPublishedAt: versionData.lastVersionPublishedAt,
+        lastLocalUpdateAt: versionData.lastLocalUpdateAt,
+        latestVersionUid: versionData.latestVersionUid,
+        latestVersionLocalId: versionData.latestVersionLocalId,
+        createdAt: seeds.createdAt,
+    })
+        .from(seeds)
+        .leftJoin(versionData, eq(seeds.localId, versionData.seedLocalId))
+        .where(and(gt(versionData.versionsCount, 0), ...conditions))
+        .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC'))
+        .groupBy(seeds.localId);
+    const itemsData = (yield query);
+    return itemsData;
 });
 
-const eventEmitter = new EventEmitter();
-
 const createVersion = (_a) => __awaiter(void 0, [_a], void 0, function* ({ seedLocalId, seedUid, seedType, uid, }) {
     const appDb = getAppDb();
     const newVersionLocalId = generateId();
@@ -1104,6 +1140,9 @@ const createVersion = (_a) => __awaiter(void 0, [_a], void 0, function* ({ seedL
 const createMetadata = (metadataValues, propertyRecordSchema) => __awaiter(void 0, void 0, void 0, function* () {
     const appDb = getAppDb();
     metadataValues.localId = generateId();
+    if (!metadataValues.modelType && metadataValues.modelName) {
+        metadataValues.modelType = metadataValues.modelName.toLowerCase();
+    }
     if (propertyRecordSchema &&
         propertyRecordSchema.localStorageDir &&
         propertyRecordSchema.storageType === 'ItemStorage') {
@@ -1130,13 +1169,7 @@ const setModel = (modelName, model) => {
     modelStore.set(modelName, model);
 };
 
-const logger$l = debug('app:write');
-const sendItemUpdateEvent = ({ modelName, seedLocalId, seedUid }) => {
-    if (!modelName || (!seedLocalId && !seedUid)) {
-        return;
-    }
-    eventEmitter.emit(`item.${modelName}.${seedUid || seedLocalId}.update`);
-};
+debug('app:write');
 const createSeed = (_a) => __awaiter(void 0, [_a], void 0, function* ({ type, seedUid }) {
     const appDb = getAppDb();
     const newSeedLocalId = generateId();
@@ -1186,148 +1219,6 @@ const createNewItem = (_a) => __awaiter(void 0, void 0, void 0, function* () {
         versionLocalId: newVersionId,
     };
 });
-const updateItemPropertyValue = (_a) => __awaiter(void 0, [_a], void 0, function* ({ propertyLocalId, propertyName, newValue, seedUid, seedLocalId, modelName, refSeedType, refResolvedValue, refResolvedDisplayValue, versionLocalId, versionUid, schemaUid, }) {
-    if (!propertyLocalId && !seedLocalId) {
-        logger$l(`[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();
-    yield 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 } = yield runQueryForStatement(mostRecentRecordStatement);
-    if (rows && rows.length > 0) {
-        const mostRecentRecord = rows[0];
-        const localId = mostRecentRecord[0];
-        const uid = mostRecentRecord[1];
-        const propertyNameFromDb = mostRecentRecord[2];
-        const propertyValueFromDb = mostRecentRecord[3];
-        const modelType = mostRecentRecord[4];
-        const seedUid = mostRecentRecord[5];
-        const seedLocalIdFromDb = mostRecentRecord[6];
-        const versionLocalId = mostRecentRecord[7];
-        mostRecentRecord[8];
-        const schemaUid = mostRecentRecord[9];
-        const easDataType = mostRecentRecord[10];
-        if (propertyValueFromDb === newValue) {
-            logger$l(`[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}';`;
-            yield runQueryForStatement(updatePropertyStatement);
-            sendItemUpdateEvent({ modelName, seedLocalId, seedUid });
-            return;
-        }
-        const seedDataFromDb = yield getSeedData({ seedLocalId });
-        const versionDataFromDb = yield getVersionData$1({ 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,
-                                                        created_at)
-                                  VALUES ('${newLocalId}',
-                                          '${propertyNameFromDb}',
-                                          '${safeNewValue}',
-                                          '${modelType}',
-                                          ${(seedDataFromDb === null || seedDataFromDb === void 0 ? void 0 : seedDataFromDb.uid) ? `'${seedDataFromDb.uid}'` : 'NULL'},
-                                          '${seedLocalIdFromDb}',
-                                          '${versionLocalId}',
-                                          ${(versionDataFromDb === null || versionDataFromDb === void 0 ? void 0 : versionDataFromDb.uid) ? `'${versionDataFromDb.uid}'` : 'NULL'},
-                                          '${schemaUid}',
-                                          ${easDataType ? `'${easDataType}'` : 'NULL'},
-                                          ${refSeedType ? `'${refSeedType}'` : 'NULL'},
-                                          ${refResolvedValue ? `'${refResolvedValue}'` : 'NULL'},
-                                          ${refResolvedDisplayValue ? `'${refResolvedDisplayValue}'` : 'NULL'},
-                                          ${Date.now()});`;
-        yield 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 = yield getSeedData({ seedLocalId });
-        if (seedData) {
-            seedUid = seedData.uid;
-        }
-    }
-    if (!versionUid) {
-        const versionData = yield getVersionData$1({ 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,
-                                                      created_at)
-                                VALUES ('${newLocalId}',
-                                        '${propertyName}',
-                                        '${safeNewValue}',
-                                        '${modelName === null || modelName === void 0 ? void 0 : modelName.toLowerCase()}',
-                                        ${seedUid ? `'${seedUid}'` : 'NULL'},
-                                        '${seedLocalId}',
-                                        '${versionLocalId}',
-                                        ${versionUid ? `'${versionUid}'` : 'NULL'},
-                                        '${schemaUid}',
-                                        ${refSeedType ? `'${refSeedType}'` : 'NULL'},
-                                        ${refResolvedValue ? `'${refResolvedValue}'` : 'NULL'},
-                                        ${refResolvedDisplayValue ? `'${refResolvedDisplayValue}'` : 'NULL'},
-                                        ${Date.now()});`;
-    yield runQueryForStatement(newPropertyStatement);
-    sendItemUpdateEvent({ modelName, seedLocalId, seedUid });
-});
 const writeAppState = (key, value) => __awaiter(void 0, void 0, void 0, function* () {
     const appDb = getAppDb();
     yield appDb
@@ -1344,6 +1235,8 @@ const writeAppState = (key, value) => __awaiter(void 0, void 0, void 0, function
     });
 });
 
+const eventEmitter = new EventEmitter();
+
 var MachineIds;
 (function (MachineIds) {
     MachineIds["GLOBAL"] = "@seedSdk/global";
@@ -1477,276 +1370,19 @@ const updateMachineContext = {
     }),
 };
 
-const readFileAsArrayBuffer = (file) => __awaiter(void 0, void 0, void 0, function* () {
-    return new Promise((resolve) => {
-        const reader = new FileReader();
-        reader.onload = (e) => __awaiter(void 0, void 0, void 0, function* () {
-            const arrayBuffer = e.target.result;
-            resolve(arrayBuffer);
-        });
-        reader.readAsArrayBuffer(file);
-    });
-});
-const fetchImage = (url) => __awaiter(void 0, void 0, void 0, function* () {
-    const response = yield fetch(url);
-    const mimeType = response.headers.get('Content-Type');
-    const imageBuffer = yield 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;
-});
-const saveImageSrc = fromCallback(({ sendBack, input: { context, event } }) => {
-    const { localId, propertyName: propertyNameRaw, propertyValue: existingValue, propertyRecordSchema, itemModelName, seedLocalId, seedUid, versionLocalId, versionUid, schemaUid, } = context;
-    let newValue;
-    if (event) {
-        newValue = event.newValue;
-    }
-    if (existingValue === newValue) {
-        sendBack({ type: 'saveValueToDbSuccess' });
-        return;
-    }
-    const _saveImageSrc = () => __awaiter(void 0, void 0, void 0, function* () {
-        let propertyName = propertyNameRaw;
-        if (!propertyNameRaw.endsWith('Id')) {
-            propertyName = `${propertyName}Id`;
-        }
-        let newValueType;
-        let fileData;
-        let mimeType;
-        let fileName;
-        if (typeof newValue === 'string') {
-            newValueType = getDataTypeFromString(newValue);
-        }
-        if (newValueType === 'imageBase64') {
-            mimeType = getMimeType(newValue);
-            const base64Data = newValue.split(',')[1]; // Strip the Base64 prefix
-            const binaryString = atob(base64Data);
-            const binaryLength = binaryString.length;
-            const binaryArray = new Uint8Array(binaryLength);
-            for (let i = 0; i < binaryLength; i++) {
-                binaryArray[i] = binaryString.charCodeAt(i);
-            }
-            fileData = binaryArray.buffer;
-        }
-        if (newValueType === 'url') {
-            fileData = yield fetchImage(newValue);
-        }
-        if (newValue instanceof File) {
-            fileName = newValue.name;
-            mimeType = newValue.type;
-            fileData = yield readFileAsArrayBuffer(newValue);
-        }
-        if (!fileData) {
-            throw new Error('No file data found');
-        }
-        const newImageSeedLocalId = yield createSeed({
-            type: 'image',
-        });
-        if (!fileName) {
-            fileName = newImageSeedLocalId;
-            if (mimeType) {
-                fileName += `.${mimeType.split('/')[1]}`;
-            }
-        }
-        const filePath = `/files/images/${fileName}`;
-        yield createVersion({
-            seedLocalId: newImageSeedLocalId,
-            seedType: 'image',
-        });
-        if (fileData instanceof ArrayBuffer) {
-            yield fs.promises.writeFile(filePath, new Uint8Array(fileData));
-        }
-        if (typeof fileData === 'string') {
-            yield fs.promises.writeFile(filePath, fileData);
-        }
-        const refResolvedDisplayValue = yield getContentUrlFromPath(filePath);
-        if (!localId) {
-            yield createMetadata({
-                propertyName,
-                propertyValue: newImageSeedLocalId,
-                seedLocalId,
-                seedUid,
-                versionLocalId,
-                versionUid,
-                modelName: itemModelName,
-                schemaUid,
-                refSeedType: 'image',
-                refResolvedDisplayValue,
-                refResolvedValue: fileName,
-            }, propertyRecordSchema);
-        }
-        if (localId) {
-            yield 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' });
-    });
-});
-
-const saveRelation = fromCallback(({ sendBack, input: { context, event } }) => {
-    const { localId, propertyName: propertyNameRaw, versionLocalId, seedUid, seedLocalId, propertyValue: existingValue, propertyRecordSchema, } = context;
-    if (!propertyRecordSchema) {
-        throw new Error('Missing propertyRecordSchema');
-    }
-    let newValue;
-    if (event) {
-        newValue = event.newValue;
-    }
-    const _saveRelation = () => __awaiter(void 0, void 0, void 0, function* () {
-        let propertyName = propertyNameRaw;
-        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' });
-        }
-    });
-});
-
-const getVersionData = () => {
-    const appDb = getAppDb();
-    return appDb.$with('versionData').as(appDb
-        .select({
-        seedLocalId: versions.seedLocalId,
-        seedUid: versions.seedUid,
-        latestVersionUid: versions.uid,
-        latestVersionLocalId: versions.localId,
-        versionsCount: count(versions.localId).as('versionsCount'),
-        lastVersionPublishedAt: max(versions.attestationCreatedAt).as('lastVersionPublishedAt'),
-        lastLocalUpdateAt: max(versions.createdAt).as('lastLocalUpdateAt'),
-    })
-        .from(versions)
-        .groupBy(versions.seedLocalId));
-};
-
-const getItemsData = (_a) => __awaiter(void 0, [_a], void 0, function* ({ modelName, deleted, }) {
-    const appDb = getAppDb();
-    const conditions = [];
-    if (modelName) {
-        conditions.push(eq(seeds.type, modelName.toLowerCase()));
-    }
-    if (deleted) {
-        conditions.push(or(isNotNull(seeds._markedForDeletion), eq(seeds._markedForDeletion, 1)));
-    }
-    if (!deleted) {
-        conditions.push(or(isNull(seeds._markedForDeletion), eq(seeds._markedForDeletion, 0)));
-    }
-    const versionData = getVersionData();
-    let query = appDb
-        .with(versionData)
-        .select({
-        seedLocalId: seeds.localId,
-        seedUid: seeds.uid,
-        schemaUid: seeds.schemaUid,
-        modelName: sql `${modelName}`,
-        attestationCreatedAt: seeds.attestationCreatedAt,
-        versionsCount: versionData.versionsCount,
-        lastVersionPublishedAt: versionData.lastVersionPublishedAt,
-        lastLocalUpdateAt: versionData.lastLocalUpdateAt,
-        createdAt: seeds.createdAt,
-    })
-        .from(seeds)
-        .leftJoin(versionData, eq(seeds.localId, versionData.seedLocalId))
-        .where(and(gt(versionData.versionsCount, 0), ...conditions))
-        .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC'))
-        .groupBy(seeds.localId);
-    const itemsData = (yield query);
-    return itemsData;
-});
-
-var _a$2;
-const logger$k = debug('app:property:class');
-const namesThatEndWithId = [];
-class ItemProperty {
-    // private constructor(localIdOrUid) {
-    // }
-    constructor({ propertyValue, seedUid, seedLocalId, versionLocalId, versionUid, itemModelName, propertyName, storageTransactionId, schemaUid, }) {
-        this._isRelation = false;
-        this._isList = false;
-        this[_a$2] = true;
-        const ModelClass = getModel(itemModelName);
-        if (!ModelClass) {
-            throw new Error(`Model ${itemModelName} not found`);
+var _a$2;
+const logger$l = debug('app:property:class');
+const namesThatEndWithId = [];
+class ItemProperty {
+    // private constructor(localIdOrUid) {
+    // }
+    constructor({ propertyValue, seedUid, seedLocalId, versionLocalId, versionUid, itemModelName, propertyName, storageTransactionId, schemaUid, }) {
+        this._isRelation = false;
+        this._isList = false;
+        this[_a$2] = true;
+        const ModelClass = getModel(itemModelName);
+        if (!ModelClass) {
+            throw new Error(`Model ${itemModelName} not found`);
         }
         if (!propertyName) {
             throw new Error(`Property name not provided`);
@@ -1785,7 +1421,7 @@ class ItemProperty {
                             serviceInput.propertyValue = JSON.parse(propertyValue);
                         }
                         catch (e) {
-                            logger$k('List property value is not JSON', e);
+                            logger$l('List property value is not JSON', e);
                         }
                     }
                     const propertyNameSingular = pluralize(propertyName, 1);
@@ -1867,7 +1503,7 @@ class ItemProperty {
         this._service.start();
     }
     _updateResponseListener(event) {
-        logger$k(`[ItemProperty] [_updateResponseListener] [${this.itemModelName}.${this.seedLocalId}] ${this.propertyName} event`, event);
+        logger$l(`[ItemProperty] [_updateResponseListener] [${this.itemModelName}.${this.seedLocalId}] ${this.propertyName} event`, event);
     }
     static create(props) {
         const { propertyName, seedLocalId, seedUid, versionLocalId, versionUid } = props;
@@ -2014,7 +1650,7 @@ class ItemProperty {
     }
     unload() {
         this._service.stop();
-        logger$k(`[XXXXXX] [ItemProperty] [${this.seedLocalId}] [unload] removing listener`, this._updateResponseEvent);
+        logger$l(`[XXXXXX] [ItemProperty] [${this.seedLocalId}] [unload] removing listener`, this._updateResponseEvent);
         eventEmitter.removeListener(this._updateResponseEvent, this._updateResponseListener);
     }
 }
@@ -2810,7 +2446,7 @@ const syncDbWithEasHandler = debounce((_) => __awaiter(void 0, void 0, void 0, f
     trailing: false,
 });
 
-const logger$j = debug('app:services:global:actors:initialize');
+const logger$k = debug('app:services:global:actors:initialize');
 const initialize$1 = fromCallback(({ sendBack, input: { event, context } }) => {
     const { internalService, models, endpoints } = context;
     const { addresses } = event;
@@ -2831,7 +2467,7 @@ const initialize$1 = fromCallback(({ sendBack, input: { event, context } }) => {
         const _initInternal = () => __awaiter(void 0, void 0, void 0, function* () {
             return new Promise((resolve) => {
                 internalSubscription = internalService.subscribe((snapshot) => {
-                    logger$j('[sdk] [internal] snapshot', snapshot);
+                    logger$k('[sdk] [internal] snapshot', snapshot);
                     if (snapshot.value === 'ready') {
                         resolve();
                     }
@@ -2865,14 +2501,14 @@ const initialize$1 = fromCallback(({ sendBack, input: { event, context } }) => {
             sendBack(Object.assign({ type: GLOBAL_INITIALIZING_CREATE_ALL_ITEMS_SERVICES }, payloadObj));
         });
         _initFileSystem().then(() => {
-            logger$j('[global/actors] File system initialized');
+            logger$k('[global/actors] File system initialized');
         });
         _initInternal()
             .then(() => {
             return _initAllItemsServices();
         })
             .then(() => {
-            logger$j('[global/actors] Internal initialized');
+            logger$k('[global/actors] Internal initialized');
             sendBack({ type: GLOBAL_INITIALIZING_INTERNAL_SERVICE_READY });
             internalSubscription === null || internalSubscription === void 0 ? void 0 : internalSubscription.unsubscribe();
         });
@@ -2886,7 +2522,7 @@ const initialize$1 = fromCallback(({ sendBack, input: { event, context } }) => {
     };
 });
 
-const logger$i = debug('app:services:global:actors:getSchemaForModel');
+const logger$j = debug('app:services:global:actors:getSchemaForModel');
 const getSchemaForModel = fromCallback(({ sendBack, input: { context, event } }) => {
     const { modelName } = event;
     if (!modelName) {
@@ -2902,12 +2538,12 @@ const getSchemaForModel = fromCallback(({ sendBack, input: { context, event } })
     if (!model) {
         throw new Error(`Model ${modelName} not found`);
     }
-    logger$i('[service/actor] [getSchemaForModel] model:', model);
+    logger$j('[service/actor] [getSchemaForModel] model:', model);
     sendBack({ type: 'schemaForModel', schema: model.schema });
     return () => { };
 });
 
-const logger$h = debug('app:services:global:actors:addModelsToDb');
+const logger$i = debug('app:services:global:actors:addModelsToDb');
 const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
     const { models: models$1 } = context;
     const _addModelsToDb = () => __awaiter(void 0, void 0, void 0, function* () {
@@ -2916,12 +2552,12 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
         if (!models$1) {
             return;
         }
-        const { models: SeedModels } = yield import('./seed.schema.config-miFErQ6h.js');
+        const { models: SeedModels } = yield import('./seed.schema.config-dylVDX7W.js');
         const allModels = Object.assign(Object.assign({}, SeedModels), models$1);
         let hasModelsInDb = false;
         const schemaDefsByModelName = new Map();
         for (const [modelName, _] of Object.entries(allModels)) {
-            logger$h('[helpers/db] [addModelsToInternalDb] starting modelName:', modelName);
+            logger$i('[helpers/db] [addModelsToInternalDb] starting modelName:', modelName);
             let foundModel;
             const foundModelsQuery = yield appDb
                 .select()
@@ -2931,7 +2567,7 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
                 yield appDb.insert(models).values({
                     name: modelName,
                 });
-                logger$h('[global/actors] [addModelsToDb] inserted model:', modelName);
+                logger$i('[global/actors] [addModelsToDb] inserted model:', modelName);
                 const foundModels = yield appDb
                     .select({
                     id: models.id,
@@ -3001,10 +2637,10 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-const logger$g = debug('app:services:db:actors:checkStatus');
+const logger$h = debug('app:services:db:actors:checkStatus');
 const checkStatus = fromCallback(({ sendBack, input: { context } }) => {
     const { dbName } = context;
-    logger$g('[db/actors] checkStatus context', context);
+    logger$h('[db/actors] checkStatus context', context);
     const pathToDir = `${BROWSER_FS_TOP_DIR}`;
     const pathToDbDir = `${pathToDir}/db`;
     const pathToDb = `${pathToDbDir}/${dbName}.sqlite3`;
@@ -3035,9 +2671,9 @@ const checkStatus = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const logger$f = debug('app:services:db:actors:connectToDb');
+const logger$g = debug('app:services:db:actors:connectToDb');
 const connectToDb = fromCallback(({ sendBack, input: { context } }) => {
-    logger$f('[db/actors] connectToDb context', context);
+    logger$g('[db/actors] connectToDb context', context);
     const { dbName, pathToDir } = context;
     let isConnecting = false;
     let dbId;
@@ -3050,16 +2686,16 @@ const connectToDb = fromCallback(({ sendBack, input: { context } }) => {
         const sqliteWasmClient = yield getSqliteWasmClient();
         //@ts-ignore
         response = yield sqliteWasmClient('config-get', {});
-        logger$f(response);
-        logger$f('Running SQLite3 version', response.result.version.libVersion);
+        logger$g(response);
+        logger$g('Running SQLite3 version', response.result.version.libVersion);
         //@ts-ignore
         response = yield sqliteWasmClient('open', {
             filename: `file:${pathToDir}/db/${dbName}.sqlite3?vfs=opfs`,
         });
-        logger$f(response);
+        logger$g(response);
         dbId = response.dbId;
         // logger(`dbId: ${dbId}`)
-        logger$f('OPFS is available, created persisted database at', response.result.filename.replace(/^file:(.*?)\?vfs=opfs$/, '$1'));
+        logger$g('OPFS is available, created persisted database at', response.result.filename.replace(/^file:(.*?)\?vfs=opfs$/, '$1'));
     });
     const interval = setInterval(() => {
         // TODO: Add a timeout
@@ -3116,7 +2752,7 @@ const validate = fromCallback(({ sendBack, input: { context } }) => {
     });
 });
 
-const logger$e = debug('app:services:db:actors:migrate');
+const logger$f = debug('app:services:db:actors:migrate');
 const dbExec = (dbId_1, params_1, sql_1, dbName_1, ...args_1) => __awaiter(void 0, [dbId_1, params_1, sql_1, dbName_1, ...args_1], void 0, function* (dbId, params, sql, dbName, retries = 2) {
     const rowsToReturnRaw = [];
     const sqliteWasmClient = yield getSqliteWasmClient();
@@ -3182,7 +2818,7 @@ const dbExec = (dbId_1, params_1, sql_1, dbName_1, ...args_1) => __awaiter(void
 });
 const migrate = fromCallback(({ sendBack, input: { context } }) => {
     const { pathToDbDir, dbId, dbName } = context;
-    logger$e('[db/actors] migrate context', context);
+    logger$f('[db/actors] migrate context', context);
     const schemaGlobString = `${BROWSER_FS_TOP_DIR}/schema/*`;
     let journalExists = false;
     // const _initFs = async (): Promise<void> => {
@@ -3346,7 +2982,7 @@ const migrate = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-const logger$d = debug('app:services:db:machine');
+const logger$e = debug('app:services:db:machine');
 const { CHECKING_STATUS, VALIDATING, WAITING_FOR_FILES, CONNECTING_TO_DB, MIGRATING, } = DbState;
 const dbMachine = setup({
     types: {
@@ -3367,7 +3003,7 @@ const dbMachine = setup({
         [DB_WAITING_FOR_FILES_RECEIVED]: {
             actions: assign({
                 hasFiles: ({ event }) => {
-                    logger$d('[db/machine] DB_WAITING_FOR_FILES_RECEIVED event:', event);
+                    logger$e('[db/machine] DB_WAITING_FOR_FILES_RECEIVED event:', event);
                     return true;
                 },
             }),
@@ -3376,8 +3012,8 @@ const dbMachine = setup({
             target: `.${CHECKING_STATUS}`,
             actions: assign({
                 hasFiles: ({ context, event }) => {
-                    logger$d('[db/machine] updateHasFiles event:', event);
-                    logger$d('[db/machine] updateHasFiles context:', context);
+                    logger$e('[db/machine] updateHasFiles event:', event);
+                    logger$e('[db/machine] updateHasFiles context:', context);
                     return event.hasFiles;
                 },
             }),
@@ -3598,7 +3234,7 @@ const prepareDb = fromCallback(({ sendBack }) => {
     };
 });
 
-const logger$c = debug('app:services:internal:helpers');
+const logger$d = debug('app:services:internal:helpers');
 /**
  * Recursively create directories if they don't exist.
  * @param {string} dirPath - The directory path to create.
@@ -3674,7 +3310,7 @@ const downloadFile = (url, localFilePath) => __awaiter(void 0, void 0, void 0, f
         if (JSON.stringify(error).includes('File exists')) {
             yield fs.promises.readFile(localFilePath, 'utf-8');
         }
-        logger$c(`[Error] Failed to download file from ${url}:`, error);
+        logger$d(`[Error] Failed to download file from ${url}:`, error);
     }
     busy = false;
 });
@@ -3712,7 +3348,7 @@ const syncDbFiles = (_a) => __awaiter(void 0, [_a], void 0, function* ({ filePat
     const fileList = yield fetchDirectory(filePaths);
     yield fetchFilesRecursively(files, BROWSER_FS_TOP_DIR, fileList);
     yield confirmFilesExist(fileList);
-    logger$c('[syncDbFiles] Files synced!');
+    logger$d('[syncDbFiles] Files synced!');
 });
 
 const uploadBinaryData = fromCallback(({ sendBack, receive, input }) => { });
@@ -3935,7 +3571,7 @@ const GET_TRANSACTION_TAGS = graphql(/* GraphQL */ `
   }
 `);
 
-const logger$b = debug('app:files:download');
+const logger$c = debug('app:files:download');
 const downloadAllFilesRequestHandler = (_a) => __awaiter(void 0, [_a], void 0, function* ({ endpoints, eventId, }) {
     yield syncDbFiles(endpoints);
     eventEmitter.emit('fs.downloadAll.success', { eventId });
@@ -4019,7 +3655,7 @@ const downloadAllFilesBinaryRequestHandler = () => __awaiter(void 0, void 0, voi
         try {
             const res = yield fetch(`https://${ARWEAVE_HOST}/tx/${transactionId}/status`);
             if (res.status !== 200) {
-                logger$b(`[fetchAll/actors] [fetchAllBinaryData] error fetching transaction data for ${transactionId}`);
+                logger$c(`[fetchAll/actors] [fetchAllBinaryData] error fetching transaction data for ${transactionId}`);
                 excludedTransactions.add(transactionId);
                 yield writeAppState('excludedTransactions', JSON.stringify(Array.from(excludedTransactions)));
                 continue;
@@ -4056,7 +3692,7 @@ const downloadAllFilesBinaryRequestHandler = () => __awaiter(void 0, void 0, voi
             //   string: true,
             // })
             if (!dataString) {
-                logger$b(`[fetchAll/actors] [fetchAllBinaryData] transaction ${transactionId} data not found`);
+                logger$c(`[fetchAll/actors] [fetchAllBinaryData] transaction ${transactionId} data not found`);
             }
             let contentType = identifyString(dataString);
             if (contentType !== 'json' &&
@@ -4064,7 +3700,7 @@ const downloadAllFilesBinaryRequestHandler = () => __awaiter(void 0, void 0, voi
                 contentType !== 'html') {
                 const possibleImageType = getDataTypeFromString(dataString);
                 if (!possibleImageType) {
-                    logger$b(`[fetchAll/actors] [fetchAllBinaryData] transaction ${transactionId} data not in expected format: ${possibleImageType}`);
+                    logger$c(`[fetchAll/actors] [fetchAllBinaryData] transaction ${transactionId} data not in expected format: ${possibleImageType}`);
                     continue;
                 }
                 contentType = possibleImageType;
@@ -4127,7 +3763,7 @@ const downloadAllFilesBinaryRequestHandler = () => __awaiter(void 0, void 0, voi
             }
         }
         catch (error) {
-            logger$b(error);
+            logger$c(error);
         }
     }
 });
@@ -4173,14 +3809,14 @@ const isFsInitialized = () => {
     return isInitialized;
 };
 
-const logger$a = debug('app:internal:actors:configureFs');
+const logger$b = debug('app:internal:actors:configureFs');
 const configureFs = fromCallback(({ sendBack, input: { context } }) => {
     const { endpoints, appDbService } = context;
-    logger$a('[internal/actors] [configureFs] Configuring FS');
+    logger$b('[internal/actors] [configureFs] Configuring FS');
     const _configureFs = () => __awaiter(void 0, void 0, void 0, function* () {
-        logger$a('[internal/actors] [configureFs] calling _configureFs');
-        logger$a('[internal/actors] [configureFs] areFsListenersReady:', areFsListenersReady());
-        logger$a('[internal/actors] [configureFs] isFsInitialized:', isFsInitialized());
+        logger$b('[internal/actors] [configureFs] calling _configureFs');
+        logger$b('[internal/actors] [configureFs] areFsListenersReady:', areFsListenersReady());
+        logger$b('[internal/actors] [configureFs] isFsInitialized:', isFsInitialized());
         yield waitForEvent({
             req: {
                 eventLabel: 'fs.downloadAll.request',
@@ -4209,7 +3845,7 @@ const configureFs = fromCallback(({ sendBack, input: { context } }) => {
         //     }
         //   }, 200)
         // })
-        logger$a('[internal/actors] [configureFs] fs configured!');
+        logger$b('[internal/actors] [configureFs] fs configured!');
     });
     // Some of our dependencies use fs sync functions, which don't work with
     // OPFS. ZenFS creates an async cache of all files so that the sync functions
@@ -4222,7 +3858,7 @@ const configureFs = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-const logger$9 = debug('app:services:internal:actors:saveConfig');
+const logger$a = debug('app:services:internal:actors:saveConfig');
 const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
     if (typeof window === 'undefined') {
         console.error('seedInitBrowser called from non-browser context');
@@ -4273,20 +3909,20 @@ const saveConfig = fromCallback(({ sendBack, input: { context } }) => {
                 },
                 setWhere: sql `key = 'addresses'`,
             });
-            logger$9('[sdk] [internal/actors] Should be done saving');
+            logger$a('[sdk] [internal/actors] Should be done saving');
         }
         catch (error) {
             console.error('Error saving config:', error);
         }
     });
     _saveConfig().then(() => {
-        logger$9('[sdk] [internal/actors] Successfully saved config');
+        logger$a('[sdk] [internal/actors] Successfully saved config');
         return sendBack({ type: INTERNAL_SAVING_CONFIG_SUCCESS });
     });
     return () => { };
 });
 
-const logger$8 = debug('app:services:internal:actors:loadAppDb');
+const logger$9 = debug('app:services:internal:actors:loadAppDb');
 const loadAppDb = fromCallback(({ sendBack, input: { context } }) => {
     const { appDbService } = context;
     let subscription;
@@ -4307,7 +3943,7 @@ const loadAppDb = fromCallback(({ sendBack, input: { context } }) => {
     });
     _loadAppDb().then(() => {
         sendBack({ type: INTERNAL_LOADING_APP_DB_SUCCESS });
-        logger$8('[sdk] [internal/actors] Successfully loaded app DB');
+        logger$9('[sdk] [internal/actors] Successfully loaded app DB');
     });
     return () => {
         if (subscription) {
@@ -4316,7 +3952,7 @@ const loadAppDb = fromCallback(({ sendBack, input: { context } }) => {
     };
 });
 
-const logger$7 = debug('app:services:internal:machine');
+const logger$8 = debug('app:services:internal:machine');
 createBrowserInspector({
     autoStart: false,
 });
@@ -4415,7 +4051,7 @@ const internalMachine = setup({
                 [INTERNAL_LOADING_APP_DB_SUCCESS]: {
                     target: SAVING_CONFIG,
                     actions: () => {
-                        logger$7('[sdk] [internal/index] App DB loaded!');
+                        logger$8('[sdk] [internal/index] App DB loaded!');
                     },
                 },
             },
@@ -4441,7 +4077,7 @@ const internalMachine = setup({
         },
         ready: {
             entry: () => {
-                logger$7('[sdk] [internal/index] Ready!');
+                logger$8('[sdk] [internal/index] Ready!');
             },
             meta: {
                 displayText: "Crossing the t's ...",
@@ -4456,7 +4092,7 @@ const internalMachine = setup({
                 },
             },
             entry: () => {
-                logger$7('[sdk] [internal/index] Error!');
+                logger$8('[sdk] [internal/index] Error!');
             },
             meta: {
                 displayText: 'Whoops! Something went wrong.',
@@ -4692,7 +4328,7 @@ const fetchDbData = fromCallback(({ sendBack, input: { context } }) => {
     return () => { };
 });
 
-const logger$6 = debug('app:allItemsActors:fetchSeeds');
+const logger$7 = debug('app:allItemsActors:fetchSeeds');
 const fetchSeeds = fromCallback(({ sendBack, input: { context } }) => {
     const { queryVariables, modelName } = context;
     if (!queryVariables) {
@@ -4702,7 +4338,7 @@ const fetchSeeds = fromCallback(({ sendBack, input: { context } }) => {
     const _fetchSeeds = () => __awaiter(void 0, void 0, void 0, function* () {
         const queryKey = [`getSeeds${modelName}`];
         const cachedResults = queryClient.getQueryData(queryKey);
-        logger$6(`[allItemsActors] [fetchSeeds] cachedResults ${Date.now()}`, cachedResults);
+        logger$7(`[allItemsActors] [fetchSeeds] cachedResults ${Date.now()}`, cachedResults);
         const results = yield queryClient.fetchQuery({
             queryKey,
             queryFn: () => __awaiter(void 0, void 0, void 0, function* () { return easClient.request(GET_SEEDS, queryVariables); }),
@@ -5133,13 +4769,13 @@ const preparePublishRequestData = fromCallback(({ sendBack, input: { context } }
     });
 });
 
-const logger$5 = debug('app:services:publish:actors:upload');
+const logger$6 = debug('app:services:publish:actors:upload');
 const upload = fromCallback(({ sendBack, input: { context } }) => {
     const { localId } = context;
     const _upload = () => __awaiter(void 0, void 0, void 0, function* () {
         const item = yield Item.find({ seedLocalId: localId });
         if (!item) {
-            logger$5('no item with localId', localId);
+            logger$6('no item with localId', localId);
             return false;
         }
         const editedProperties = yield item.getEditedProperties();
@@ -6004,7 +5640,24 @@ const getItemProperties = (_a) => __awaiter(void 0, [_a], void 0, function* ({ s
 //   })
 // }
 
-const logger$4 = debug('app:db:queries:getItem');
+const getSeedData = (_a) => __awaiter(void 0, [_a], void 0, function* ({ seedLocalId, seedUid }) {
+    const appDb = getAppDb();
+    let query;
+    const queryBase = appDb.select().from(seeds);
+    if (seedLocalId) {
+        query = queryBase.where(eq(seeds.localId, seedLocalId));
+    }
+    if (seedUid) {
+        query = queryBase.where(eq(seeds.uid, seedUid));
+    }
+    const rows = yield query;
+    if (!rows || !rows.length) {
+        return;
+    }
+    return rows[0];
+});
+
+const logger$5 = debug('app:db:queries:getItem');
 const getItemDataFromDb = (_a) => __awaiter(void 0, [_a], void 0, function* ({ modelName, seedLocalId, seedUid, }) {
     if (!seedLocalId && !seedUid) {
         throw new Error('[db/queries] [getItem] no seedLocalId or seedUid');
@@ -6012,7 +5665,7 @@ const getItemDataFromDb = (_a) => __awaiter(void 0, [_a], void 0, function* ({ m
     if (seedUid && !seedLocalId) {
         const seedData = yield getSeedData({ seedUid });
         if (!seedData) {
-            logger$4('[db/queries] [getItem] no seedData seedUid', seedUid);
+            logger$5('[db/queries] [getItem] no seedData seedUid', seedUid);
             return;
         }
         seedLocalId = seedData.localId;
@@ -6029,7 +5682,7 @@ const getItemDataFromDb = (_a) => __awaiter(void 0, [_a], void 0, function* ({ m
     if (seedLocalId && !seedUid) {
         whereClauses.push(eq(seeds.localId, seedLocalId));
     }
-    const versionData = getVersionData();
+    const versionData = getVersionData$1();
     const itemDataRows = yield appDb
         .with(versionData)
         .select(Object.assign(Object.assign({}, rest), { seedLocalId: seeds.localId, seedUid: seeds.uid, versionsCount: versionData.versionsCount, lastVersionPublishedAt: versionData.lastVersionPublishedAt, latestVersionUid: versionData.latestVersionUid, latestVersionLocalId: versionData.latestVersionLocalId }))
@@ -6039,7 +5692,7 @@ const getItemDataFromDb = (_a) => __awaiter(void 0, [_a], void 0, function* ({ m
         .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC'))
         .groupBy(seeds.localId);
     if (!itemDataRows || itemDataRows.length === 0) {
-        logger$4('[db/queries] [getItemDataFromDb] no itemDataRows');
+        logger$5('[db/queries] [getItemDataFromDb] no itemDataRows');
         return;
     }
     let itemData = itemDataRows[0];
@@ -6315,7 +5968,7 @@ class Item {
 _a$1 = immerable;
 Item.instanceCache = new Map();
 
-const logger$3 = debug('app:react:services');
+const logger$4 = debug('app:react:services');
 const finalStrings = ['idle', 'ready', 'done', 'success'];
 const getServiceName = (service) => {
     let name = 'actor';
@@ -6362,7 +6015,7 @@ const getServiceUniqueKey = (service) => {
         snapshot = service.getSnapshot();
     }
     catch (error) {
-        logger$3('Error:', error);
+        logger$4('Error:', error);
         return uniqueKey;
     }
     if (snapshot) {
@@ -6466,7 +6119,7 @@ const useGlobalServiceStatus = () => {
     };
 };
 
-const logger$2 = debug('app:react:item');
+const logger$3 = debug('app:react:item');
 const useItem = ({ modelName, seedLocalId, seedUid }) => {
     // const [itemSubscription, setItemSubscription] = useState<
     //   Subscription | undefined
@@ -6543,7 +6196,7 @@ const useItem = ({ modelName, seedLocalId, seedUid }) => {
             seedUid,
         });
         if (!foundItem) {
-            logger$2('[useItem] [getItemFromDb] no item found', modelName, seedLocalId);
+            logger$3('[useItem] [getItemFromDb] no item found', modelName, seedLocalId);
             isReadingDb.current = false;
             return;
         }
@@ -6565,7 +6218,7 @@ const useItem = ({ modelName, seedLocalId, seedUid }) => {
             const subscription = item.subscribe((_) => __awaiter(void 0, void 0, void 0, function* () {
                 const newItem = yield Item.find({ modelName, seedLocalId, seedUid });
                 if (!newItem) {
-                    logger$2('[useItem] [itemSubscription] no item found', modelName, seedLocalId);
+                    logger$3('[useItem] [itemSubscription] no item found', modelName, seedLocalId);
                     return;
                 }
                 updateItem(newItem);
@@ -6682,7 +6335,7 @@ const useCreateItem = (modelName) => {
     };
 };
 
-const logger$1 = debug('app:react:property');
+const logger$2 = debug('app:react:property');
 const useItemProperty = ({ propertyName, seedLocalId, seedUid, }) => {
     const [property, setProperty] = useState();
     const [isInitialized, setIsInitialized] = useState(false);
@@ -6708,7 +6361,7 @@ const useItemProperty = ({ propertyName, seedLocalId, seedUid, }) => {
             seedUid,
         });
         if (!foundProperty) {
-            logger$1(`[useItemPropertyTest] [readFromDb] no property found for Item.${seedLocalId}.${propertyName}`);
+            logger$2(`[useItemPropertyTest] [readFromDb] no property found for Item.${seedLocalId}.${propertyName}`);
             isReadingDb.current = false;
             return;
         }
@@ -6805,10 +6458,10 @@ const useDeleteItem = () => {
     };
 };
 
-const logger = debug('app:services:events');
+const logger$1 = debug('app:services:events');
 const handleServiceSaveState = (event) => {
     const { state, serviceId } = event;
-    logger(`[browser] [service.saveState.request] serviceId: ${serviceId}`);
+    logger$1(`[browser] [service.saveState.request] serviceId: ${serviceId}`);
     localStorage.setItem(`seed_sdk_service_${serviceId}`, JSON.stringify(state));
 };
 const setupServicesEventHandlers = () => {
@@ -6851,7 +6504,7 @@ const client = {
             console.error('fs listeners not ready during init');
         }
         globalService.send({ type: 'init', endpoints, models, addresses });
-        import('./seed.schema.config-miFErQ6h.js').then(({ models }) => {
+        import('./seed.schema.config-dylVDX7W.js').then(({ models }) => {
             for (const [key, value] of Object.entries(models)) {
                 setModel(key, value);
             }
@@ -6900,18 +6553,399 @@ const client = {
     },
 };
 
-const getItemPropertyData = (props) => __awaiter(void 0, void 0, void 0, function* () {
+const getVersionData = (_a) => __awaiter(void 0, [_a], void 0, function* ({ localId, seedLocalId, uid, }) {
     const appDb = getAppDb();
     const whereClauses = [];
-    const tableColumns = getTableColumns(metadata);
-    for (const [propertyName, propertyValue] of Object.entries(props)) {
-        if (Object.keys(tableColumns).includes(propertyName)) {
-            whereClauses.push(eq(tableColumns[propertyName], propertyValue));
-        }
+    if (seedLocalId) {
+        whereClauses.push(eq(versions.localId, seedLocalId));
+    }
+    if (localId) {
+        whereClauses.push(eq(versions.localId, localId));
+    }
+    if (uid) {
+        whereClauses.push(eq(versions.uid, uid));
     }
     const queryRows = yield appDb
         .select()
-        .from(metadata)
+        .from(versions)
+        .where(and(...whereClauses));
+    if (!queryRows || !queryRows.length) {
+        return;
+    }
+    return queryRows[0];
+});
+
+const logger = debug('app:write:updateItemPropertyValue');
+const sendItemUpdateEvent = ({ modelName, seedLocalId, seedUid }) => {
+    if (!modelName || (!seedLocalId && !seedUid)) {
+        return;
+    }
+    eventEmitter.emit(`item.${modelName}.${seedUid || seedLocalId}.update`);
+};
+const updateItemPropertyValue = (_a) => __awaiter(void 0, [_a], void 0, function* ({ 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 = yield 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 === null || modelName === void 0 ? void 0 : 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}';`;
+            yield runQueryForStatement(updatePropertyStatement);
+            sendItemUpdateEvent({ modelName, seedLocalId, seedUid });
+            return;
+        }
+        const seedDataFromDb = yield getSeedData({ seedLocalId });
+        const versionDataFromDb = yield 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 === null || modelName === void 0 ? void 0 : modelName.toLowerCase())}',
+                                          ${(seedDataFromDb === null || seedDataFromDb === void 0 ? void 0 : seedDataFromDb.uid) ? `'${seedDataFromDb.uid}'` : 'NULL'},
+                                          '${seedLocalIdFromDb}',
+                                          '${versionLocalId}',
+                                          ${(versionDataFromDb === null || versionDataFromDb === void 0 ? void 0 : versionDataFromDb.uid) ? `'${versionDataFromDb.uid}'` : 'NULL'},
+                                          '${schemaUid}',
+                                          ${easDataType ? `'${easDataType}'` : 'NULL'},
+                                          ${refSeedType ? `'${refSeedType}'` : 'NULL'},
+                                          ${refResolvedValue ? `'${refResolvedValue}'` : 'NULL'},
+                                          ${refResolvedDisplayValue ? `'${refResolvedDisplayValue}'` : 'NULL'},
+                                          ${localStorageDir ? `'${localStorageDir}'` : 'NULL'},
+                                          ${Date.now()});`;
+        yield 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 = yield getSeedData({ seedLocalId });
+        if (seedData) {
+            seedUid = seedData.uid;
+        }
+    }
+    if (!versionUid) {
+        const versionData = yield 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 === null || modelName === void 0 ? void 0 : modelName.toLowerCase()}',
+                                        ${seedUid ? `'${seedUid}'` : 'NULL'},
+                                        '${seedLocalId}',
+                                        '${versionLocalId}',
+                                        ${versionUid ? `'${versionUid}'` : 'NULL'},
+                                        '${schemaUid}',
+                                        ${refSeedType ? `'${refSeedType}'` : 'NULL'},
+                                        ${refResolvedValue ? `'${refResolvedValue}'` : 'NULL'},
+                                        ${refResolvedDisplayValue ? `'${refResolvedDisplayValue}'` : 'NULL'},
+                                        ${Date.now()});`;
+    yield runQueryForStatement(newPropertyStatement);
+    sendItemUpdateEvent({ modelName, seedLocalId, seedUid });
+});
+
+const readFileAsArrayBuffer = (file) => __awaiter(void 0, void 0, void 0, function* () {
+    return new Promise((resolve) => {
+        const reader = new FileReader();
+        reader.onload = (e) => __awaiter(void 0, void 0, void 0, function* () {
+            const arrayBuffer = e.target.result;
+            resolve(arrayBuffer);
+        });
+        reader.readAsArrayBuffer(file);
+    });
+});
+const fetchImage = (url) => __awaiter(void 0, void 0, void 0, function* () {
+    const response = yield fetch(url);
+    const mimeType = response.headers.get('Content-Type');
+    const imageBuffer = yield 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;
+});
+const saveImageSrc = fromCallback(({ sendBack, input: { context, event } }) => {
+    const { localId, propertyName: propertyNameRaw, propertyValue: existingValue, propertyRecordSchema, itemModelName, seedLocalId, seedUid, versionLocalId, versionUid, schemaUid, } = context;
+    if (seedLocalId === 'qpIzW1e52r') {
+        console.log(`[saveImageSrc] versionLocaId is : ${versionLocalId}`);
+    }
+    let newValue;
+    if (event) {
+        newValue = event.newValue;
+    }
+    if (existingValue === newValue) {
+        sendBack({ type: 'saveValueToDbSuccess' });
+        return;
+    }
+    const _saveImageSrc = () => __awaiter(void 0, void 0, void 0, function* () {
+        let propertyName = propertyNameRaw;
+        if (!propertyNameRaw.endsWith('Id')) {
+            propertyName = `${propertyName}Id`;
+        }
+        let newValueType;
+        let fileData;
+        let mimeType;
+        let fileName;
+        if (typeof newValue === 'string') {
+            newValueType = getDataTypeFromString(newValue);
+        }
+        if (newValueType === 'imageBase64') {
+            mimeType = getMimeType(newValue);
+            const base64Data = newValue.split(',')[1]; // Strip the Base64 prefix
+            const binaryString = atob(base64Data);
+            const binaryLength = binaryString.length;
+            const binaryArray = new Uint8Array(binaryLength);
+            for (let i = 0; i < binaryLength; i++) {
+                binaryArray[i] = binaryString.charCodeAt(i);
+            }
+            fileData = binaryArray.buffer;
+        }
+        if (newValueType === 'url') {
+            fileData = yield fetchImage(newValue);
+        }
+        if (newValue instanceof File) {
+            fileName = newValue.name;
+            mimeType = newValue.type;
+            fileData = yield readFileAsArrayBuffer(newValue);
+        }
+        if (!fileData) {
+            throw new Error('No file data found');
+        }
+        const newImageSeedLocalId = yield createSeed({
+            type: 'image',
+        });
+        if (!fileName) {
+            fileName = newImageSeedLocalId;
+            if (mimeType) {
+                fileName += `.${mimeType.split('/')[1]}`;
+            }
+        }
+        const filePath = `/files/images/${fileName}`;
+        yield createVersion({
+            seedLocalId: newImageSeedLocalId,
+            seedType: 'image',
+        });
+        if (fileData instanceof ArrayBuffer) {
+            yield fs.promises.writeFile(filePath, new Uint8Array(fileData));
+        }
+        if (typeof fileData === 'string') {
+            yield fs.promises.writeFile(filePath, fileData);
+        }
+        const refResolvedDisplayValue = yield getContentUrlFromPath(filePath);
+        if (!localId) {
+            yield createMetadata({
+                propertyName,
+                propertyValue: newImageSeedLocalId,
+                seedLocalId,
+                seedUid,
+                versionLocalId,
+                versionUid,
+                modelName: itemModelName,
+                schemaUid,
+                refSeedType: 'image',
+                refResolvedDisplayValue,
+                refResolvedValue: fileName,
+                localStorageDir: '/images',
+                easDataType: 'bytes32',
+            }, propertyRecordSchema);
+        }
+        if (localId) {
+            yield updateItemPropertyValue({
+                localId: localId,
+                propertyName: propertyNameRaw,
+                newValue: newImageSeedLocalId,
+                seedLocalId,
+                versionLocalId,
+                modelName: itemModelName,
+                schemaUid,
+                refSeedType: 'image',
+                refResolvedDisplayValue,
+                refResolvedValue: fileName,
+                localStorageDir: '/images',
+                easDataType: 'bytes32',
+            });
+        }
+        sendBack({
+            type: 'updateContext',
+            propertyValue: newImageSeedLocalId,
+            refSeedType: 'image',
+            renderValue: refResolvedDisplayValue,
+            resolvedDisplayValue: refResolvedDisplayValue,
+            resolvedValue: fileName,
+        });
+    });
+    _saveImageSrc().then(() => {
+        sendBack({ type: 'saveImageSrcSuccess' });
+    });
+});
+
+const saveRelation = fromCallback(({ sendBack, input: { context, event } }) => {
+    const { localId, propertyName: propertyNameRaw, versionLocalId, seedUid, seedLocalId, propertyValue: existingValue, propertyRecordSchema, } = context;
+    if (!propertyRecordSchema) {
+        throw new Error('Missing propertyRecordSchema');
+    }
+    let newValue;
+    if (event) {
+        newValue = event.newValue;
+    }
+    const _saveRelation = () => __awaiter(void 0, void 0, void 0, function* () {
+        let propertyName = propertyNameRaw;
+        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' });
+        }
+    });
+});
+
+const getItemPropertyData = (props) => __awaiter(void 0, void 0, void 0, function* () {
+    const appDb = getAppDb();
+    const whereClauses = [];
+    const tableColumns = getTableColumns(metadata);
+    for (const [propertyName, propertyValue] of Object.entries(props)) {
+        if (Object.keys(tableColumns).includes(propertyName)) {
+            whereClauses.push(eq(tableColumns[propertyName], propertyValue));
+        }
+    }
+    const queryRows = yield appDb
+        .select()
+        .from(metadata)
         .where(and(...whereClauses));
     if (!queryRows || queryRows.length === 0) {
         return;
@@ -7051,7 +7085,7 @@ const analyzeInput = fromCallback(({ sendBack, input: { context, event } }) => {
             return false;
         }
         yield updateItemPropertyValue({
-            propertyLocalId: localId,
+            localId: localId,
             propertyName,
             newValue,
             seedLocalId,
@@ -7123,6 +7157,9 @@ const propertyMachine = setup({
         updateContext: {
             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') {
@@ -7130,6 +7167,9 @@ const propertyMachine = setup({
                     }
                     newContext[key] = event[key];
                 }
+                if (context.seedLocalId === 'qpIzW1e52r') {
+                    console.log(`[updateContext] after update versionLocalId is ${newContext.versionLocalId}`);
+                }
                 return newContext;
             }),
         },
@@ -7425,4 +7465,4 @@ if (isNode()) {
 }
 
 export { GET_SCHEMAS as G, Item as I, Json as J, List as L, Model as M, Property as P, Relation as R, Text as T, GET_SEEDS as a, GET_SEED_IDS as b, GET_STORAGE_TRANSACTION_ID as c, GET_VERSIONS as d, GET_PROPERTIES as e, GET_ALL_PROPERTIES_FOR_ALL_VERSIONS as f, itemMachineAll as g, ImageSrc as h, itemMachineSingle as i, ItemProperty as j, useItem as k, useItemProperties as l, useCreateItem as m, useItemProperty as n, useDeleteItem as o, useGlobalServiceStatus as p, useServices as q, getGlobalService as r, client as s, getCorrectId as t, useItems as u, withSeed as w };
-//# sourceMappingURL=index-nGDuz8NN.js.map
+//# sourceMappingURL=index-Cy1fke9s.js.map