@seedprotocol/sdk 0.1.52 → 0.1.54

package/dist/{index-DMIKRod-.js → index-DQKd-s2Q.js}

@@ -2,8 +2,8 @@ import { b as __awaiter, d as __rest, i as internalPropertyNames, I as INTERNAL_
 import path, { basename } from 'path';
 import 'reflect-metadata';
 import { Type } from '@sinclair/typebox';
-import { fromCallback, assign, setup, createActor, waitFor, emit, raise } from 'xstate';
-import { sql, relations, and, eq, max, or, inArray, like, isNotNull, isNull, count, desc, getTableColumns } from 'drizzle-orm';
+import { fromCallback, assign, createActor, waitFor, setup, emit, raise } from 'xstate';
+import { sql, relations, and, eq, max, or, inArray, like, count, isNotNull, isNull, getTableColumns, gt } from 'drizzle-orm';
 import { fs, configureSingle } from '@zenfs/core';
 import 'dayjs';
 import { customAlphabet } from 'nanoid';
@@ -930,19 +930,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
             }
             propertyNameQuery = or(eq(metadata.propertyName, propertyName), eq(metadata.propertyName, missingPropertyNameVariant));
         }
-        const selectFromStatement = db
-            .select({
-            localId: metadata.localId,
-            uid: metadata.uid,
-            propertyName: metadata.propertyName,
-            propertyValue: metadata.propertyValue,
-            seedLocalId: metadata.seedLocalId,
-            seedUid: metadata.seedUid,
-            schemaUid: metadata.schemaUid,
-            refResolvedValue: metadata.refResolvedValue,
-            refResolvedDisplayValue: metadata.refResolvedDisplayValue,
-        })
-            .from(metadata);
+        const selectFromStatement = db.select().from(metadata);
         if (seedUid && !seedLocalId) {
             hydrateQuery = selectFromStatement.where(and(eq(metadata.seedUid, seedUid), propertyNameQuery));
         }
@@ -960,7 +948,7 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
             return;
         }
         const firstRow = rows[0];
-        const { localId, uid, propertyName: propertyNameFromDb, propertyValue: propertyValueFromDb, seedLocalId: seedLocalIdFromDb, seedUid: seedUidFromDb, schemaUid: schemaUidFromDb, refResolvedValue, refResolvedDisplayValue, } = firstRow;
+        const { localId, uid, propertyName: propertyNameFromDb, propertyValue: propertyValueFromDb, seedLocalId: seedLocalIdFromDb, seedUid: seedUidFromDb, schemaUid: schemaUidFromDb, versionLocalId: versionLocalIdFromDb, versionUid: versionUidFromDb, refValueType, refResolvedValue, refResolvedDisplayValue, localStorageDir, } = firstRow;
         if (propertyName && !propertyNameFromDb) {
             logger$m(`Property name from code is ${propertyName} but has not value in db ${propertyNameFromDb} for Property.${localId}`);
         }
@@ -987,13 +975,17 @@ const hydrateFromDb = fromCallback(({ sendBack, input: { context } }) => {
             propertyValue: propertyValueFromDb,
             seedLocalId: seedLocalIdFromDb,
             seedUid: seedUidFromDb,
+            versionLocalId: versionLocalIdFromDb,
+            versionUid: versionUidFromDb,
             schemaUid: schemaUidFromDb,
-            resolveValue: refResolvedValue,
-            resolveDisplayValue: refResolvedDisplayValue,
+            refValueType,
+            localStorageDir,
+            resolvedValue: refResolvedValue,
+            resolvedDisplayValue: refResolvedDisplayValue,
             renderValue: refResolvedDisplayValue,
         });
         if (propertyNameFromDb === 'storageTransactionId') {
-            const { Item } = yield import('./index-wKss7188.js');
+            const { Item } = yield import('./index-NmD9sjcJ.js');
             const item = yield Item.find({
                 seedLocalId,
                 modelName: itemModelName,
@@ -1062,36 +1054,26 @@ const getSeedData = (_a) => __awaiter(void 0, [_a], void 0, function* ({ seedLoc
     return rows[0];
 });
 
-const getVersionData = (_a) => __awaiter(void 0, [_a], void 0, function* ({ seedLocalId }) {
-    const getVersionStatement = `SELECT local_id,
-                                      uid,
-                                      seed_local_id,
-                                      seed_uid,
-                                      seed_type,
-                                      note,
-                                      attestation_created_at,
-                                      attestation_raw,
-                                      created_at,
-                                      updated_at
-                               FROM versions
-                               WHERE local_id = '${seedLocalId}';`;
-    const { rows } = yield runQueryForStatement(getVersionStatement);
-    if (!rows || !rows.length) {
+const getVersionData$1 = (_a) => __awaiter(void 0, [_a], void 0, function* ({ localId, seedLocalId, uid, }) {
+    const appDb = getAppDb();
+    const whereClauses = [];
+    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(versions)
+        .where(and(...whereClauses));
+    if (!queryRows || !queryRows.length) {
         return;
     }
-    const seedValues = rows[0];
-    return {
-        localId: seedValues[0],
-        uid: seedValues[1],
-        seedLocalId: seedValues[2],
-        seedUid: seedValues[3],
-        seedType: seedValues[4],
-        note: seedValues[5],
-        attestationCreatedAt: seedValues[6],
-        attestationRaw: seedValues[7],
-        createdAt: seedValues[8],
-        updatedAt: seedValues[9],
-    };
+    return queryRows[0];
 });
 
 const eventEmitter = new EventEmitter();
@@ -1208,7 +1190,7 @@ const updateItemPropertyValue = (_a) => __awaiter(void 0, [_a], void 0, function
             return;
         }
         const seedDataFromDb = yield getSeedData({ seedLocalId });
-        const versionDataFromDb = yield getVersionData({ versionLocalId });
+        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,
@@ -1252,7 +1234,7 @@ const updateItemPropertyValue = (_a) => __awaiter(void 0, [_a], void 0, function
         }
     }
     if (!versionUid) {
-        const versionData = yield getVersionData({ versionLocalId });
+        const versionData = yield getVersionData$1({ versionLocalId });
         if (versionData) {
             versionUid = versionData.uid;
         }
@@ -1435,213 +1417,6 @@ const updateMachineContext = {
     }),
 };
 
-const saveValueToDb = fromCallback(({ sendBack, input: { context, event } }) => {
-    const { localId, propertyName: propertyNameRaw, seedLocalId, propertyValue: existingValue, propertyRecordSchema, itemModelName, schemaUid, } = context;
-    let { newValue } = event;
-    if (existingValue === newValue) {
-        sendBack({ type: 'saveValueToDbSuccess' });
-        return;
-    }
-    const _saveValueToDb = () => __awaiter(void 0, void 0, void 0, function* () {
-        let refResolvedValue;
-        let refResolvedDisplayValue;
-        let refSeedType;
-        let propertyName = propertyNameRaw;
-        let versionLocalId;
-        if (propertyRecordSchema &&
-            propertyRecordSchema.dataType === 'Relation') {
-            refResolvedValue = newValue;
-            if (!propertyName.endsWith('Id')) {
-                propertyName = `${propertyName}Id`;
-            }
-            let fileType;
-            const dirs = yield fs.promises.readdir('/files');
-            for (const dir of dirs) {
-                const files = yield fs.promises.readdir(`/files/${dir}`);
-                if (files.includes(newValue)) {
-                    fileType = dir;
-                    break;
-                }
-            }
-            if (fileType === 'images') {
-                const filePath = `/files/images/${newValue}`;
-                refResolvedDisplayValue = yield getContentUrlFromPath(filePath);
-                refSeedType = 'image';
-                newValue = yield createSeed({
-                    type: refSeedType,
-                });
-                versionLocalId = yield createVersion({
-                    seedLocalId: newValue,
-                    seedType: refSeedType,
-                });
-            }
-        }
-        yield updateItemPropertyValue({
-            propertyLocalId: localId,
-            propertyName,
-            newValue,
-            seedLocalId,
-            refSeedType,
-            refResolvedValue,
-            refResolvedDisplayValue,
-            versionLocalId,
-            modelName: itemModelName,
-            schemaUid,
-        });
-        sendBack({
-            type: 'updateContext',
-            propertyValue: newValue,
-            renderValue: refResolvedDisplayValue,
-        });
-    });
-    _saveValueToDb().then(() => {
-        sendBack({ type: 'saveValueToDbSuccess' });
-    });
-});
-
-const propertyMachine = setup({
-    types: {
-        context: {},
-    },
-    actors: {
-        waitForDb: waitForDb$1,
-        hydrateFromDb,
-        initialize: initialize$3,
-        resolveRelatedValue,
-        resolveRemoteStorage,
-        saveValueToDb,
-    },
-}).createMachine({
-    id: 'itemProperty',
-    initial: 'waitingForDb',
-    context: ({ input }) => input,
-    on: {
-        updatePropertyValue: {
-            target: '.resolvingRelatedValue',
-            guard: ({ context }) => !context.isDbReady,
-            actions: assign(({ event }) => {
-                return {
-                    propertyValue: event.propertyValue,
-                };
-            }),
-        },
-        updateRenderValue: {
-            actions: assign(({ event, context }) => {
-                return {
-                    renderValue: event.renderValue,
-                };
-            }),
-        },
-        save: {
-            actions: assign({
-                isSaving: true,
-            }),
-            target: '.saving',
-        },
-        updateContext: updateMachineContext,
-    },
-    states: {
-        idle: {},
-        waitingForDb: {
-            on: {
-                waitForDbSuccess: {
-                    target: 'hydratingFromDb',
-                    actions: assign({
-                        isDbReady: true,
-                    }),
-                },
-            },
-            invoke: {
-                src: 'waitForDb',
-                input: ({ context }) => ({ context }),
-            },
-        },
-        hydratingFromDb: {
-            on: {
-                hydrateFromDbSuccess: 'initializing',
-            },
-            invoke: {
-                src: 'hydrateFromDb',
-                input: ({ context }) => ({ context }),
-            },
-        },
-        initializing: {
-            on: {
-                initializeSuccess: 'idle',
-                isRelatedProperty: {
-                    target: 'resolvingRelatedValue',
-                },
-                hasRemoteBackup: {
-                    target: 'resolvingRemoteStorage',
-                },
-            },
-            invoke: {
-                src: 'initialize',
-                input: ({ context, event }) => ({ context, event }),
-            },
-        },
-        resolvingRelatedValue: {
-            on: {
-                resolvingRelatedValueSuccess: {
-                    target: 'idle',
-                    actions: assign({
-                        resolvedDisplayValue: ({ event }) => event.resolvedDisplayValue,
-                        resolvedValue: ({ event }) => event.resolvedValue,
-                    }),
-                },
-                resolvingRelatedValueDone: {
-                    target: 'idle',
-                },
-            },
-            invoke: {
-                src: 'resolveRelatedValue',
-                input: ({ context }) => ({ context }),
-            },
-        },
-        resolvingRemoteStorage: {
-            on: {
-                resolveRemoteStorageSuccess: {
-                    target: 'idle',
-                },
-            },
-            invoke: {
-                src: 'resolveRemoteStorage',
-                input: ({ context }) => ({ context }),
-            },
-        },
-        saving: {
-            on: {
-                saveValueToDbSuccess: {
-                    target: 'idle',
-                    actions: assign({
-                        isSaving: false,
-                    }),
-                },
-                saveValueToDbFailure: {
-                    target: 'idle',
-                    actions: assign({
-                        isSaving: false,
-                    }),
-                },
-            },
-            invoke: {
-                src: 'saveValueToDb',
-                input: ({ context, event }) => ({ context, event }),
-            },
-        },
-    },
-    // conflict: {
-    //   on: {
-    //     resolveConflict: {
-    //       target: 'saving',
-    //       actions: assign({
-    //         data: ({ context, event }) => event.output,
-    //       }),
-    //     },
-    //   },
-    // },
-});
-
 const modelStore = new Map();
 const getModels = () => {
     return Object.fromEntries(modelStore);
@@ -1662,7 +1437,7 @@ const namesThatEndWithId = [];
 class ItemProperty {
     // private constructor(localIdOrUid) {
     // }
-    constructor({ propertyValue, seedUid, seedLocalId, itemModelName, propertyName, storageTransactionId, schemaUid, }) {
+    constructor({ propertyValue, seedUid, seedLocalId, versionLocalId, versionUid, itemModelName, propertyName, storageTransactionId, schemaUid, }) {
         this._isRelation = false;
         this._isList = false;
         this[_a$2] = true;
@@ -1673,12 +1448,13 @@ class ItemProperty {
         if (!propertyName) {
             throw new Error(`Property name not provided`);
         }
-        this._lastRenderedValue = propertyValue;
         const serviceInput = {
             propertyValue,
-            seedUid,
             propertyName,
             seedLocalId,
+            seedUid,
+            versionLocalId,
+            versionUid,
             itemModelName,
             storageTransactionId,
             propertyRecordSchema: ModelClass.schema[propertyName],
@@ -1723,8 +1499,12 @@ class ItemProperty {
         this._service = createActor(propertyMachine, {
             input: serviceInput,
         });
-        this._subscription = this._service.subscribe((snapshot) => {
+        this._subscription = this._service.subscribe((snapshot) => __awaiter(this, void 0, void 0, function* () {
+            if (!snapshot || !snapshot.context) {
+                return;
+            }
             const { context } = snapshot;
+            const { propertyRecordSchema } = context;
             // if (this.uid && !cacheHasProperty(this.uid)) {
             //   addPropertyToCache(this)
             // }
@@ -1746,7 +1526,21 @@ class ItemProperty {
                 //   this._updateResponseListener,
                 // )
             }
-            const renderValue = context.renderValue || context.propertyValue;
+            let renderValue;
+            if (propertyRecordSchema &&
+                propertyRecordSchema.storageType &&
+                propertyRecordSchema.storageType === 'ItemStorage' &&
+                context.resolvedValue &&
+                context.localStorageDir) {
+                const filePath = `/files/${context.localStorageDir}/${context.resolvedValue}`;
+                const exists = yield fs.promises.exists(filePath);
+                if (exists) {
+                    renderValue = yield fs.promises.readFile(filePath, 'utf-8');
+                }
+            }
+            if (!renderValue) {
+                renderValue = context.renderValue || context.propertyValue;
+            }
             let transformedPropertyName = propertyName;
             const skipTransform = internalPropertyNames.includes(propertyName) || !!this._alias;
             if (!skipTransform && transformedPropertyName.endsWith('Id')) {
@@ -1766,14 +1560,14 @@ class ItemProperty {
             if (context.seedUid) {
                 eventEmitter.emit(`item.${itemModelName}.${context.seedUid}.update`);
             }
-        });
+        }));
         this._service.start();
     }
     _updateResponseListener(event) {
         logger$k(`[ItemProperty] [_updateResponseListener] [${this.itemModelName}.${this.seedLocalId}] ${this.propertyName} event`, event);
     }
     static create(props) {
-        const { propertyName, seedLocalId, seedUid } = props;
+        const { propertyName, seedLocalId, seedUid, versionLocalId, versionUid } = props;
         if (!propertyName || (!seedLocalId && !seedUid)) {
             return;
         }
@@ -1842,32 +1636,35 @@ class ItemProperty {
     getService() {
         return this._service;
     }
+    _getSnapshot() {
+        return this._service.getSnapshot();
+    }
     get localId() {
-        return this._service.getSnapshot().context.localId;
+        return this._getSnapshot().context.localId;
     }
     get uid() {
-        return this._service.getSnapshot().context.uid;
+        return this._getSnapshot().context.uid;
     }
     get seedLocalId() {
-        return this._service.getSnapshot().context.seedLocalId;
+        return this._getSnapshot().context.seedLocalId;
     }
     get seedUid() {
-        return this._service.getSnapshot().context.seedUid;
+        return this._getSnapshot().context.seedUid;
     }
     get propertyName() {
         if (this._alias) {
             return this._alias;
         }
-        return this._service.getSnapshot().context.propertyName;
+        return this._getSnapshot().context.propertyName;
     }
     get itemModelName() {
-        return this._service.getSnapshot().context.itemModelName;
+        return this._getSnapshot().context.itemModelName;
     }
     get propertyDef() {
-        return this._service.getSnapshot().context.propertyRecordSchema;
+        return this._getSnapshot().context.propertyRecordSchema;
     }
     get status() {
-        return this._service.getSnapshot().value;
+        return this._getSnapshot().value;
     }
     get alias() {
         return this._alias;
@@ -1892,7 +1689,7 @@ class ItemProperty {
         });
     }
     get published() {
-        return !!this._service.getSnapshot().context.uid;
+        return !!this._getSnapshot().context.uid;
     }
     subscribe(callback) {
         return this._subject.subscribe(callback);
@@ -1921,84 +1718,6 @@ class ItemProperty {
 _a$2 = immerable;
 ItemProperty.instanceCache = new Map();
 
-const TPropertyDataType = Type.Union([
-    Type.Literal('Text'),
-    Type.Literal('Number'),
-    Type.Literal('List'),
-    Type.Literal('Relation'),
-    Type.Literal('ImageSrc'),
-    Type.Literal('FileSrc'),
-    Type.Literal('Json'),
-    Type.Literal('Blob'),
-]);
-const TStorageType = Type.Union([
-    Type.Literal('ItemStorage'), // Looks for a storageTransactionId property on the item
-    Type.Literal('PropertyStorage'), // Looks for a storageTransactionId value on the property
-]);
-const TProperty = Type.Object({
-    id: Type.Optional(Type.Number()),
-    name: Type.Optional(Type.String()),
-    dataType: TPropertyDataType,
-    ref: Type.Optional(Type.String()),
-    modelId: Type.Optional(Type.Number()),
-    refModelId: Type.Optional(Type.Number()),
-    refValueType: Type.Optional(TPropertyDataType),
-    storageType: Type.Optional(TStorageType),
-    localStorageDir: Type.Optional(Type.String()),
-    filenameSuffix: Type.Optional(Type.String()),
-});
-const TPropertyConstructor = Type.Function([
-    Type.Optional(Type.Union([Type.String(), TStorageType])),
-    Type.Optional(Type.Union([Type.String(), TPropertyDataType])),
-    Type.Optional(Type.String()),
-], TProperty);
-Type.Record(TPropertyDataType, TPropertyConstructor);
-const Property = {
-    Text: (storageType, localStorageDir, filenameSuffix) => ({
-        dataType: 'Text',
-        storageType,
-        localStorageDir,
-        filenameSuffix,
-        TObject: Type.String(),
-    }),
-    Json: () => ({ dataType: 'Json' }),
-    Blob: () => ({ dataType: 'Blob' }),
-    Number: () => ({ dataType: 'Number' }),
-    List: (ref, refValueType) => ({
-        dataType: 'List',
-        ref,
-        refValueType,
-    }),
-    Relation: (ref, refValueType) => ({
-        dataType: 'Relation',
-        ref,
-        refValueType,
-    }),
-    ImageSrc: () => ({ dataType: 'ImageSrc' }),
-};
-const PropertyMetadataKey = Symbol('property');
-const PropertyConstructor = (propertyType) => {
-    return function (parentClassPrototype, propertyKey) {
-        const existingProperties = Reflect.getMetadata(PropertyMetadataKey, parentClassPrototype) || [];
-        existingProperties.push({ propertyKey, propertyType });
-        // console.log('existingProperties', existingProperties)
-        // console.log('propertyKey', propertyKey)
-        // console.log('propertyType', propertyType)
-        // console.log('PropertyMetadataKey', PropertyMetadataKey)
-        // console.log('typeof target', typeof target)
-        Reflect.defineMetadata(PropertyMetadataKey, existingProperties, parentClassPrototype);
-        // console.log(
-        //   `After adding ${propertyKey}:`,
-        //   Reflect.getMetadata(PropertyMetadataKey, parentClassPrototype),
-        // )
-    };
-};
-const Text = (storageType, srcDir, filenameSuffix) => PropertyConstructor(Property.Text(storageType, srcDir, filenameSuffix));
-const Json = () => PropertyConstructor(Property.Json());
-const ImageSrc = () => PropertyConstructor(Property.ImageSrc());
-const Relation = (ref, refValueType) => PropertyConstructor(Property.Relation(ref, refValueType)); // Adjust for actual relation type
-const List = (ref, reValueType) => PropertyConstructor(Property.List(ref, reValueType)); // Adjust for actual list type
-
 const waitForDb = fromCallback(({ sendBack }) => {
     const _waitForDb = new Promise((resolve) => {
         const interval = setInterval(() => {
@@ -2553,7 +2272,7 @@ const createMetadataRecordsForStorageTransactionId = (storageTransactionIdProper
             versionLocalId,
             versionUid,
             refValueType: 'file',
-            refResolvedValue: `${propertyValue}.${propertyDef.filenameSuffix}`,
+            refResolvedValue: `${propertyValue}${propertyDef.filenameSuffix}`,
             modelType: seedUidToModelType.get(seedUid),
             createdAt: Date.now(),
             updatedAt: Date.now(),
@@ -2894,7 +2613,7 @@ const addModelsToDb = fromCallback(({ sendBack, input: { context } }) => {
         if (!models$1) {
             return;
         }
-        const { models: SeedModels } = yield import('./seed.schema.config-C0M8Rcti.js');
+        const { models: SeedModels } = yield import('./seed.schema.config-OyHsE0Zl.js');
         const allModels = Object.assign(Object.assign({}, SeedModels), models$1);
         let hasModelsInDb = false;
         const schemaDefsByModelName = new Map();
@@ -3866,6 +3585,22 @@ const getArweave = () => {
     });
 };
 
+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 = [];
@@ -3878,22 +3613,24 @@ const getItemsData = (_a) => __awaiter(void 0, [_a], void 0, function* ({ modelN
     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: count(versions.localId),
-        lastVersionPublishedAt: max(versions.attestationCreatedAt),
-        lastLocalUpdateAt: max(versions.createdAt),
+        versionsCount: versionData.versionsCount,
+        lastVersionPublishedAt: versionData.lastVersionPublishedAt,
+        lastLocalUpdateAt: versionData.lastLocalUpdateAt,
         createdAt: seeds.createdAt,
     })
         .from(seeds)
-        .leftJoin(versions, eq(seeds.localId, versions.seedLocalId))
+        .leftJoin(versionData, eq(seeds.localId, versionData.seedLocalId))
         .where(and(...conditions))
-        .orderBy(desc(seeds.createdAt))
+        .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC'))
         .groupBy(seeds.localId);
     const itemsData = (yield query);
     return itemsData;
@@ -5559,11 +5296,12 @@ const setupServicesEventHandlers = () => {
 
 const saveServiceHandler = (event) => __awaiter(void 0, void 0, void 0, function* () {
     const globalService = getGlobalService();
-    if (!globalService) {
+    if (!globalService || !globalService.getSnapshot().context) {
         return;
     }
     const { modelName } = event;
-    const service = globalService.getSnapshot().context[`${modelName}Service`];
+    const nameOfService = `${modelName}Service`;
+    const service = globalService.getSnapshot().context[nameOfService];
     yield writeAppState(`snapshot__${modelName}`, JSON.stringify(service.getPersistedSnapshot()));
 });
 
@@ -5588,7 +5326,7 @@ const client = {
             console.error('fs listeners not ready during init');
         }
         globalService.send({ type: 'init', endpoints, models, addresses });
-        import('./seed.schema.config-C0M8Rcti.js').then(({ models }) => {
+        import('./seed.schema.config-OyHsE0Zl.js').then(({ models }) => {
             for (const [key, value] of Object.entries(models)) {
                 setModel(key, value);
             }
@@ -6561,92 +6299,6 @@ const getItemProperties = (_a) => __awaiter(void 0, [_a], void 0, function* ({ s
 //   })
 // }
 
-const logger = 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');
-    }
-    if (seedUid && !seedLocalId) {
-        const seedData = yield getSeedData({ seedUid });
-        if (!seedData) {
-            logger('[db/queries] [getItem] no seedData seedUid', seedUid);
-            return;
-        }
-        seedLocalId = seedData.localId;
-    }
-    const appDb = getAppDb();
-    const _b = getTableColumns(seeds), rest = __rest(_b, ["localId", "uid"]);
-    const whereClauses = [];
-    if (modelName) {
-        whereClauses.push(eq(seeds.type, modelName.toLowerCase()));
-    }
-    const uidWhereClause = seedUid
-        ? eq(seeds.uid, seedUid)
-        : isNull(seeds.uid);
-    const localWhereClause = seedLocalId
-        ? eq(seeds.localId, seedLocalId)
-        : isNull(seeds.localId);
-    whereClauses.push(or(localWhereClause, uidWhereClause));
-    const latestVersions = appDb.$with('latestVersions').as(appDb
-        .select({
-        localId: versions.localId,
-        uid: versions.uid,
-        seedLocalId: versions.seedLocalId,
-        seedUid: versions.seedUid,
-    })
-        .from(versions)
-        .groupBy(versions.seedLocalId));
-    const itemDataRows = yield appDb
-        .with(latestVersions)
-        .select(Object.assign(Object.assign({}, rest), { seedLocalId: seeds.localId, seedUid: seeds.uid, versionsCount: count(versions.localId), lastVersionPublishedAt: max(versions.attestationCreatedAt), latestVersionUid: latestVersions.uid }))
-        .from(seeds)
-        .leftJoin(versions, eq(versions.seedLocalId, seeds.localId))
-        .leftJoin(latestVersions, eq(versions.seedLocalId, latestVersions.seedLocalId))
-        .where(and(...whereClauses))
-        .groupBy(seeds.localId);
-    if (!itemDataRows || itemDataRows.length === 0) {
-        logger('[db/queries] [getItemDataFromDb] no itemDataRows');
-        return;
-    }
-    let itemData = itemDataRows[0];
-    const propertiesData = yield getItemProperties({ seedLocalId, seedUid });
-    // const initObj: ItemData = {
-    //   seedLocalId,
-    //   seedUid,
-    //   modelName,
-    // }
-    if (!propertiesData || propertiesData.length === 0) {
-        return itemData;
-    }
-    propertiesData[0];
-    for (const propertyData of propertiesData) {
-        const propertyName = propertyData.propertyName;
-        const propertyValue = propertyData.propertyValue;
-        // TODO: Find a better place for the property data below
-        // Since initObj is used to initialize an Item, the following values
-        // just overwrite each other for each property since they are Property
-        // specific.
-        // const refSeedType = propertyDbValues[11]
-        // if (refSeedType) {
-        //   initObj.refSeedType = refSeedType
-        // }
-        // const refValueType = propertyDbValues[12]
-        // if (refValueType) {
-        //   initObj.refValueType = refValueType
-        // }
-        //
-        // if (
-        //   refSeedType &&
-        //   refValueType === 'list' &&
-        //   propertyName.endsWith('Ids')
-        // ) {
-        //   logger('[db/queries] [getItemDataFromDb] propertyName', propertyName)
-        // }
-        itemData[propertyName] = propertyValue;
-    }
-    return itemData;
-});
-
 var _a$1;
 class Item {
     constructor(initialValues) {
@@ -6679,7 +6331,7 @@ class Item {
                 },
             });
         });
-        const { modelName, seedUid, schemaUid, seedLocalId } = initialValues;
+        const { modelName, seedUid, schemaUid, seedLocalId, latestVersionLocalId, latestVersionUid, } = initialValues;
         const ModelClass = getModel(modelName);
         if (ModelClass &&
             Object.keys(ModelClass === null || ModelClass === void 0 ? void 0 : ModelClass.schema).includes('storageTransactionId') &&
@@ -6692,15 +6344,14 @@ class Item {
                 seedUid,
                 schemaUid,
                 ModelClass,
+                latestVersionLocalId,
+                latestVersionUid,
                 storageTransactionId: this._storageTransactionId,
             },
         });
         this._subscription = this._service.subscribe((snapshot) => {
             const { context } = snapshot;
-            if (
-            // snapshot.value === 'waitingForDb' ||
-            // snapshot.value === 'initializing' ||
-            !context ||
+            if (!context ||
                 !context.propertyInstances ||
                 context.propertyInstances.size === 0) {
                 return;
@@ -6732,6 +6383,8 @@ class Item {
         const itemPropertyBase = {
             seedLocalId,
             seedUid,
+            versionLocalId: latestVersionLocalId,
+            versionUid: latestVersionUid,
             itemModelName: modelName,
             schemaUid,
         };
@@ -6755,6 +6408,9 @@ class Item {
     }
     static create(props) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (!props.seedUid) {
+                console.log('Creating new item without seedUid');
+            }
             if (props.seedUid || props.seedLocalId) {
                 const seedId = (props.seedUid || props.seedLocalId);
                 if (Item.instanceCache.has(seedId)) {
@@ -6799,6 +6455,13 @@ class Item {
                 seedLocalId,
                 seedUid,
             });
+            if (!itemData) {
+                console.error('No item data found', { modelName, seedLocalId, seedUid });
+                return;
+            }
+            if (!(itemData === null || itemData === void 0 ? void 0 : itemData.seedUid)) {
+                console.log('Item not found', { modelName, seedLocalId, seedUid });
+            }
             return Item.create(Object.assign(Object.assign({}, itemData), { modelName }));
         });
     }
@@ -6875,6 +6538,491 @@ class Item {
 _a$1 = immerable;
 Item.instanceCache = new Map();
 
+const logger = 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');
+    }
+    if (seedUid && !seedLocalId) {
+        const seedData = yield getSeedData({ seedUid });
+        if (!seedData) {
+            logger('[db/queries] [getItem] no seedData seedUid', seedUid);
+            return;
+        }
+        seedLocalId = seedData.localId;
+    }
+    const appDb = getAppDb();
+    const _b = getTableColumns(seeds), rest = __rest(_b, ["localId", "uid"]);
+    const whereClauses = [];
+    if (modelName) {
+        whereClauses.push(eq(seeds.type, modelName.toLowerCase()));
+    }
+    if (seedUid) {
+        whereClauses.push(eq(seeds.uid, seedUid));
+    }
+    if (seedLocalId && !seedUid) {
+        whereClauses.push(eq(seeds.localId, seedLocalId));
+    }
+    const versionData = getVersionData();
+    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 }))
+        .from(seeds)
+        .leftJoin(versionData, eq(seeds.localId, versionData.seedLocalId))
+        .where(and(...whereClauses, gt(versionData.versionsCount, 0)))
+        .orderBy(sql.raw('COALESCE(attestation_created_at, created_at) DESC'))
+        .groupBy(seeds.localId);
+    if (!itemDataRows || itemDataRows.length === 0) {
+        logger('[db/queries] [getItemDataFromDb] no itemDataRows');
+        return;
+    }
+    let itemData = itemDataRows[0];
+    const propertiesData = yield getItemProperties({ seedLocalId, seedUid });
+    // const initObj: ItemData = {
+    //   seedLocalId,
+    //   seedUid,
+    //   modelName,
+    // }
+    if (!propertiesData || propertiesData.length === 0) {
+        return itemData;
+    }
+    propertiesData[0];
+    for (const propertyData of propertiesData) {
+        const propertyName = propertyData.propertyName;
+        const propertyValue = propertyData.propertyValue;
+        // TODO: Find a better place for the property data below
+        // Since initObj is used to initialize an Item, the following values
+        // just overwrite each other for each property since they are Property
+        // specific.
+        // const refSeedType = propertyDbValues[11]
+        // if (refSeedType) {
+        //   initObj.refSeedType = refSeedType
+        // }
+        // const refValueType = propertyDbValues[12]
+        // if (refValueType) {
+        //   initObj.refValueType = refValueType
+        // }
+        //
+        // if (
+        //   refSeedType &&
+        //   refValueType === 'list' &&
+        //   propertyName.endsWith('Ids')
+        // ) {
+        //   logger('[db/queries] [getItemDataFromDb] propertyName', propertyName)
+        // }
+        itemData[propertyName] = propertyValue;
+    }
+    return itemData;
+});
+
+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)) {
+            tableColumns[propertyName];
+            whereClauses.push(eq(tableColumns[propertyName], propertyValue));
+        }
+    }
+    const queryRows = yield appDb
+        .select()
+        .from(metadata)
+        .where(and(...whereClauses));
+    if (!queryRows || queryRows.length === 0) {
+        return;
+    }
+    return queryRows[0];
+});
+
+const createMetadata = (metadataValues, propertyRecordSchema) => __awaiter(void 0, void 0, void 0, function* () {
+    const appDb = getAppDb();
+    metadataValues.localId = generateId();
+    if (propertyRecordSchema &&
+        propertyRecordSchema.localStorageDir &&
+        propertyRecordSchema.storageType === 'ItemStorage') {
+        metadataValues.refResolvedValue = `${metadataValues.localId}${propertyRecordSchema.filenameSuffix}`;
+        metadataValues.refValueType = 'file';
+    }
+    return appDb
+        .insert(metadata)
+        .values(Object.assign(Object.assign({}, metadataValues), { createdAt: Date.now(), updatedAt: Date.now() }))
+        .returning();
+});
+
+const saveValueToDb = fromCallback(({ sendBack, input: { context, event } }) => {
+    const { localId, propertyName: propertyNameRaw, seedLocalId, seedUid, versionLocalId, versionUid, propertyValue: existingValue, propertyRecordSchema, itemModelName, schemaUid, } = context;
+    let { newValue } = event;
+    if (existingValue === newValue) {
+        sendBack({ type: 'saveValueToDbSuccess' });
+        return;
+    }
+    const _saveValueToDb = () => __awaiter(void 0, void 0, void 0, function* () {
+        let refResolvedValue;
+        let refResolvedDisplayValue;
+        let refSeedType;
+        let propertyName = propertyNameRaw;
+        if (propertyRecordSchema && propertyRecordSchema.dataType === 'Relation') {
+            refResolvedValue = newValue;
+            if (!propertyName.endsWith('Id')) {
+                propertyName = `${propertyName}Id`;
+            }
+            let fileType;
+            const dirs = yield fs.promises.readdir('/files');
+            for (const dir of dirs) {
+                const files = yield fs.promises.readdir(`/files/${dir}`);
+                if (files.includes(newValue)) {
+                    fileType = dir;
+                    break;
+                }
+            }
+            if (fileType === 'images') {
+                const filePath = `/files/images/${newValue}`;
+                refResolvedDisplayValue = yield getContentUrlFromPath(filePath);
+                refSeedType = 'image';
+                newValue = yield createSeed({
+                    type: refSeedType,
+                });
+                yield createVersion({
+                    seedLocalId,
+                    seedUid,
+                    seedType: refSeedType,
+                });
+            }
+        }
+        if (propertyRecordSchema &&
+            propertyRecordSchema.storageType &&
+            propertyRecordSchema.storageType === 'ItemStorage') {
+            // Save value to file
+            const appDb = getAppDb();
+            let propertyData;
+            if (localId) {
+                propertyData = yield getItemPropertyData({
+                    localId,
+                });
+            }
+            if (!localId && seedLocalId) {
+                const itemData = yield getItemDataFromDb({
+                    seedLocalId,
+                });
+                if (itemData) {
+                    const whereClauses = [
+                        eq(metadata.propertyName, propertyName),
+                        eq(metadata.seedLocalId, seedLocalId),
+                    ];
+                    if (itemData.latestVersionLocalId) {
+                        whereClauses.push(eq(metadata.versionLocalId, itemData.latestVersionLocalId));
+                    }
+                    const queryRows = yield appDb
+                        .select()
+                        .from(metadata)
+                        .where(and(...whereClauses));
+                    if (queryRows && queryRows.length) {
+                        propertyData = queryRows[0];
+                    }
+                    if (!propertyData) {
+                        const propertyDataRows = yield createMetadata({
+                            propertyName,
+                            modelType: itemModelName.toLowerCase(),
+                            seedLocalId,
+                            seedUid,
+                            versionLocalId: itemData.latestVersionLocalId,
+                            versionUid: itemData.latestVersionUid,
+                            localStorageDir: propertyRecordSchema.localStorageDir,
+                            refValueType: 'file',
+                        }, propertyRecordSchema);
+                        propertyData = propertyDataRows[0];
+                    }
+                    // propertyData = {
+                    //   propertyName,
+                    //   seedLocalId,
+                    //   seedUid,
+                    //   versionLocalId: itemData.latestVersionLocalId,
+                    //   versionUid: itemData.latestVersionUid,
+                    //   schemaUid: itemData.schemaUid,
+                    // }
+                }
+            }
+            const localStorageDir = propertyRecordSchema.localStorageDir || propertyData.localStorageDir;
+            const fileName = propertyData.refResolvedValue ||
+                `${propertyData.localId}${propertyRecordSchema.filenameSuffix}`;
+            if (!localStorageDir || !fileName) {
+                throw new Error(`Missing localStorageDir: ${localStorageDir} or fileName: ${fileName}`);
+            }
+            const filePath = `/files/${localStorageDir}/${fileName}`;
+            yield fs.promises.writeFile(filePath, newValue);
+            yield appDb
+                .update(metadata)
+                .set({
+                refResolvedValue: fileName,
+            })
+                .where(eq(metadata.localId, propertyData.localId));
+            sendBack({
+                type: 'updateContext',
+                renderValue: newValue,
+            });
+            return;
+        }
+        yield updateItemPropertyValue({
+            propertyLocalId: localId,
+            propertyName,
+            newValue,
+            seedLocalId,
+            refSeedType,
+            refResolvedValue,
+            refResolvedDisplayValue,
+            versionLocalId,
+            modelName: itemModelName,
+            schemaUid,
+        });
+        sendBack({
+            type: 'updateContext',
+            propertyValue: newValue,
+            renderValue: refResolvedDisplayValue,
+        });
+    });
+    _saveValueToDb().then(() => {
+        sendBack({ type: 'saveValueToDbSuccess' });
+    });
+});
+
+// import { updateMachineContext } from '@/browser/helpers'
+const propertyMachine = setup({
+    types: {
+        context: {},
+    },
+    // actions: {
+    //   updateContext: updateMachineContext,
+    // },
+    actors: {
+        waitForDb: waitForDb$1,
+        hydrateFromDb,
+        initialize: initialize$3,
+        resolveRelatedValue,
+        resolveRemoteStorage,
+        saveValueToDb,
+    },
+}).createMachine({
+    id: 'itemProperty',
+    initial: 'waitingForDb',
+    context: ({ input }) => input,
+    on: {
+        updatePropertyValue: {
+            target: '.resolvingRelatedValue',
+            guard: ({ context }) => !context.isDbReady,
+            actions: assign(({ event }) => {
+                return {
+                    propertyValue: event.propertyValue,
+                };
+            }),
+        },
+        updateRenderValue: {
+            actions: assign(({ event, context }) => {
+                return {
+                    renderValue: event.renderValue,
+                };
+            }),
+        },
+        save: {
+            actions: assign({
+                isSaving: true,
+            }),
+            target: '.saving',
+        },
+        updateContext: {
+            actions: assign(({ context, event }) => {
+                const newContext = Object.assign({}, context);
+                for (let i = 0; i < Object.keys(event).length; i++) {
+                    const key = Object.keys(event)[i];
+                    if (key === 'type') {
+                        continue;
+                    }
+                    newContext[key] = event[key];
+                }
+                return newContext;
+            }),
+        },
+    },
+    states: {
+        idle: {},
+        waitingForDb: {
+            on: {
+                waitForDbSuccess: {
+                    target: 'hydratingFromDb',
+                    actions: assign({
+                        isDbReady: true,
+                    }),
+                },
+            },
+            invoke: {
+                src: 'waitForDb',
+                input: ({ context }) => ({ context }),
+            },
+        },
+        hydratingFromDb: {
+            on: {
+                hydrateFromDbSuccess: 'initializing',
+            },
+            invoke: {
+                src: 'hydrateFromDb',
+                input: ({ context }) => ({ context }),
+            },
+        },
+        initializing: {
+            on: {
+                initializeSuccess: 'idle',
+                isRelatedProperty: {
+                    target: 'resolvingRelatedValue',
+                },
+                hasRemoteBackup: {
+                    target: 'resolvingRemoteStorage',
+                },
+            },
+            invoke: {
+                src: 'initialize',
+                input: ({ context, event }) => ({ context, event }),
+            },
+        },
+        resolvingRelatedValue: {
+            on: {
+                resolvingRelatedValueSuccess: {
+                    target: 'idle',
+                    actions: assign({
+                        resolvedDisplayValue: ({ event }) => event.resolvedDisplayValue,
+                        resolvedValue: ({ event }) => event.resolvedValue,
+                    }),
+                },
+                resolvingRelatedValueDone: {
+                    target: 'idle',
+                },
+            },
+            invoke: {
+                src: 'resolveRelatedValue',
+                input: ({ context }) => ({ context }),
+            },
+        },
+        resolvingRemoteStorage: {
+            on: {
+                resolveRemoteStorageSuccess: {
+                    target: 'idle',
+                },
+            },
+            invoke: {
+                src: 'resolveRemoteStorage',
+                input: ({ context }) => ({ context }),
+            },
+        },
+        saving: {
+            on: {
+                saveValueToDbSuccess: {
+                    target: 'idle',
+                    actions: assign({
+                        isSaving: false,
+                    }),
+                },
+                saveValueToDbFailure: {
+                    target: 'idle',
+                    actions: assign({
+                        isSaving: false,
+                    }),
+                },
+            },
+            invoke: {
+                src: 'saveValueToDb',
+                input: ({ context, event }) => ({ context, event }),
+            },
+        },
+    },
+    // conflict: {
+    //   on: {
+    //     resolveConflict: {
+    //       target: 'saving',
+    //       actions: assign({
+    //         data: ({ context, event }) => event.output,
+    //       }),
+    //     },
+    //   },
+    // },
+});
+
+const TPropertyDataType = Type.Union([
+    Type.Literal('Text'),
+    Type.Literal('Number'),
+    Type.Literal('List'),
+    Type.Literal('Relation'),
+    Type.Literal('ImageSrc'),
+    Type.Literal('FileSrc'),
+    Type.Literal('Json'),
+    Type.Literal('Blob'),
+]);
+const TStorageType = Type.Union([
+    Type.Literal('ItemStorage'), // Looks for a storageTransactionId property on the item
+    Type.Literal('PropertyStorage'), // Looks for a storageTransactionId value on the property
+]);
+const TProperty = Type.Object({
+    id: Type.Optional(Type.Number()),
+    name: Type.Optional(Type.String()),
+    dataType: TPropertyDataType,
+    ref: Type.Optional(Type.String()),
+    modelId: Type.Optional(Type.Number()),
+    refModelId: Type.Optional(Type.Number()),
+    refValueType: Type.Optional(TPropertyDataType),
+    storageType: Type.Optional(TStorageType),
+    localStorageDir: Type.Optional(Type.String()),
+    filenameSuffix: Type.Optional(Type.String()),
+});
+const TPropertyConstructor = Type.Function([
+    Type.Optional(Type.Union([Type.String(), TStorageType, Type.Undefined()])),
+    Type.Optional(Type.Union([Type.String(), TPropertyDataType])),
+    Type.Optional(Type.String()),
+], TProperty);
+Type.Record(TPropertyDataType, TPropertyConstructor);
+const Property = {
+    Text: (storageType, localStorageDir, filenameSuffix) => ({
+        dataType: 'Text',
+        storageType,
+        localStorageDir,
+        filenameSuffix,
+        TObject: Type.String(),
+    }),
+    Json: () => ({ dataType: 'Json' }),
+    Blob: () => ({ dataType: 'Blob' }),
+    Number: () => ({ dataType: 'Number' }),
+    List: (ref, refValueType) => ({
+        dataType: 'List',
+        ref,
+        refValueType,
+    }),
+    Relation: (ref, refValueType) => ({
+        dataType: 'Relation',
+        ref,
+        refValueType,
+    }),
+    ImageSrc: () => ({ dataType: 'ImageSrc' }),
+};
+const PropertyMetadataKey = Symbol('property');
+const PropertyConstructor = (propertyType) => {
+    return function (parentClassPrototype, propertyKey) {
+        const existingProperties = Reflect.getMetadata(PropertyMetadataKey, parentClassPrototype) || [];
+        existingProperties.push({ propertyKey, propertyType });
+        // console.log('existingProperties', existingProperties)
+        // console.log('propertyKey', propertyKey)
+        // console.log('propertyType', propertyType)
+        // console.log('PropertyMetadataKey', PropertyMetadataKey)
+        // console.log('typeof target', typeof target)
+        Reflect.defineMetadata(PropertyMetadataKey, existingProperties, parentClassPrototype);
+        // console.log(
+        //   `After adding ${propertyKey}:`,
+        //   Reflect.getMetadata(PropertyMetadataKey, parentClassPrototype),
+        // )
+    };
+};
+const Text = (storageType, srcDir, filenameSuffix) => PropertyConstructor(Property.Text(storageType, srcDir, filenameSuffix));
+const Json = () => PropertyConstructor(Property.Json());
+const ImageSrc = () => PropertyConstructor(Property.ImageSrc());
+const Relation = (ref, refValueType) => PropertyConstructor(Property.Relation(ref, refValueType)); // Adjust for actual relation type
+const List = (ref, reValueType) => PropertyConstructor(Property.List(ref, reValueType)); // Adjust for actual list type
+
 const TModelValues = Type.Record(Type.String(), Type.Any());
 const TModelSchema = Type.Record(Type.String(), TProperty);
 const TModelClass = Type.Object({
@@ -6949,4 +7097,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-DMIKRod-.js.map
+//# sourceMappingURL=index-DQKd-s2Q.js.map