@seedprotocol/sdk 0.3.30 → 0.4.0

package/dist/ItemProperty/ItemProperty.js

@@ -0,0 +1,613 @@
+import { createActor, waitFor } from 'xstate';
+import { BehaviorSubject } from 'rxjs';
+import { propertyMachine } from './service/propertyMachine.js';
+import { INTERNAL_PROPERTY_NAMES } from '../helpers/constants.js';
+import debug from 'debug';
+import pluralize from 'pluralize';
+import { getPropertyData } from '../db/read/getPropertyData.js';
+import { getCorrectId } from '../helpers/index.js';
+import { createReactiveProxy } from '../helpers/reactiveProxy.js';
+import { BaseFileManager } from '../helpers/FileManager/BaseFileManager.js';
+
+// Start loading Model at module load time (non-blocking)
+import('../Model/Model.js').then(module => {
+    module.Model;
+    return module;
+}).catch(() => {
+    // If import fails, ModelClass remains null
+});
+const logger = debug('seedSdk:property:class');
+// Define tracked properties for the Proxy
+// These properties will be read from/written to the actor context
+const TRACKED_PROPERTIES = [
+    'propertyName',
+    'propertyValue',
+    'renderValue',
+    'seedLocalId',
+    'seedUid',
+    'modelName',
+    'dataType',
+    'refResolvedValue',
+    'versionLocalId',
+    'versionUid',
+    'schemaUid',
+    'localId',
+    'uid',
+];
+// WeakMap to store mutable state per ItemProperty instance
+// This avoids issues with read-only properties when instances are frozen by Immer
+const itemPropertyInstanceState = new WeakMap();
+class ItemProperty {
+    constructor(initialValues) {
+        this._isRelation = false;
+        this._isList = false;
+        const { modelName, propertyName, propertyValue, seedLocalId, seedUid, versionLocalId, versionUid, storageTransactionId, schemaUid } = initialValues;
+        if (!modelName) {
+            throw new Error('Model name is required');
+        }
+        if (!propertyName) {
+            throw new Error(`Property name not provided`);
+        }
+        // ItemProperty no longer depends on Model - property schema will be loaded from database
+        // via loadOrCreateProperty actor or can be provided in initialValues
+        const serviceInput = {
+            propertyValue,
+            propertyName,
+            seedLocalId,
+            seedUid,
+            versionLocalId,
+            versionUid,
+            modelName,
+            storageTransactionId,
+            // propertyRecordSchema will be loaded from database via loadOrCreateProperty actor
+            // or can be provided in initialValues if available
+            propertyRecordSchema: initialValues.propertyRecordSchema,
+            schemaUid,
+            isSaving: false,
+            isRelation: false,
+            isDbReady: false,
+        };
+        // Property schema will be loaded from database via loadOrCreateProperty actor
+        // For now, use propertyRecordSchema from initialValues if provided
+        const propertyRecordSchema = initialValues.propertyRecordSchema;
+        if (propertyRecordSchema) {
+            this._dataType = propertyRecordSchema.dataType;
+            serviceInput.propertyRecordSchema = propertyRecordSchema;
+            // Use string literals to avoid circular dependency in constructor
+            // ModelPropertyDataTypes values are stable string constants
+            if (propertyRecordSchema.dataType === 'Relation') {
+                this._isRelation = true;
+            }
+            if (propertyRecordSchema.dataType === 'List' &&
+                propertyRecordSchema.ref) {
+                this._isList = true;
+                this._isRelation = true;
+                if (propertyValue) {
+                    try {
+                        serviceInput.propertyValue = JSON.parse(propertyValue);
+                    }
+                    catch (e) {
+                        logger('List property value is not JSON', e);
+                    }
+                }
+                const propertyNameSingular = pluralize(propertyName, 1);
+                this._alias = propertyName;
+                serviceInput.propertyName = `${propertyNameSingular}${propertyRecordSchema.ref}Ids`;
+            }
+            if (!this._alias && propertyName.endsWith('Id')) {
+                this._alias = propertyName.slice(0, -2);
+            }
+            else if (!this._alias && propertyName.endsWith('Ids')) {
+                this._alias = pluralize(propertyName.slice(0, -3));
+            }
+        }
+        serviceInput.isRelation = this._isRelation;
+        this._subject = new BehaviorSubject(propertyValue);
+        this._service = createActor(propertyMachine, {
+            input: serviceInput,
+        });
+        this._subscription = this._service.subscribe(async (snapshot) => {
+            if (!snapshot || !snapshot.context) {
+                return;
+            }
+            // Use dynamic import to break circular dependency
+            const { ModelPropertyDataTypes } = await import('../Schema/index.js');
+            const { context } = snapshot;
+            const { propertyRecordSchema } = context;
+            if (context.seedLocalId && context.propertyName) {
+                const cacheKey = ItemProperty.cacheKey(context.seedLocalId, context.propertyName);
+                if (!ItemProperty.instanceCache.has(cacheKey)) {
+                    ItemProperty.instanceCache.set(cacheKey, {
+                        instance: this,
+                        refCount: 1,
+                    });
+                }
+            }
+            let renderValue;
+            const isImage = propertyRecordSchema &&
+                propertyRecordSchema.dataType === ModelPropertyDataTypes.Image;
+            const isFile = propertyRecordSchema &&
+                propertyRecordSchema.dataType === ModelPropertyDataTypes.File;
+            const isItemStorage = propertyRecordSchema &&
+                propertyRecordSchema.storageType &&
+                propertyRecordSchema.storageType === 'ItemStorage' &&
+                context.refResolvedValue &&
+                context.localStorageDir;
+            if (!this._schemaUid && context.schemaUid) {
+                this._schemaUid = context.schemaUid;
+            }
+            if (isImage ||
+                isFile ||
+                isItemStorage) {
+                const filePath = `/files/${context.localStorageDir}/${context.refResolvedValue}`;
+                try {
+                    const exists = await BaseFileManager.pathExists(filePath);
+                    if (exists && isItemStorage) {
+                        renderValue = await BaseFileManager.readFileAsString(filePath);
+                    }
+                    if (exists && isImage) {
+                        if (context.refResolvedDisplayValue) {
+                            renderValue = context.refResolvedDisplayValue;
+                        }
+                        if (!context.refResolvedDisplayValue) {
+                            renderValue = await BaseFileManager.getContentUrlFromPath(filePath);
+                        }
+                    }
+                    if (exists && isFile) {
+                        renderValue = await BaseFileManager.readFileAsString(filePath);
+                    }
+                    if (!exists) {
+                        renderValue = 'No file found';
+                    }
+                }
+                catch (e) {
+                    logger(`[ItemProperty] [${context.seedLocalId}] [${context.propertyName}] [storageType] error`, e);
+                    renderValue = 'No file found';
+                }
+            }
+            if (!renderValue) {
+                renderValue = context.renderValue || context.propertyValue;
+            }
+            let transformedPropertyName = propertyName;
+            const skipTransform = INTERNAL_PROPERTY_NAMES.includes(propertyName) || !!this._alias;
+            if (!skipTransform && transformedPropertyName.endsWith('Id')) {
+                transformedPropertyName = transformedPropertyName.slice(0, -2);
+            }
+            if (!skipTransform && transformedPropertyName.endsWith('Ids')) {
+                transformedPropertyName = transformedPropertyName.slice(0, -3);
+            }
+            if (skipTransform && this._alias) {
+                transformedPropertyName = this._alias;
+            }
+            if (skipTransform && !this._alias) ;
+            // Update context with renderValue instead of BehaviorSubject
+            // The reactive proxy will handle reactivity
+            const currentRenderValue = context.renderValue || context.propertyValue;
+            if (currentRenderValue === renderValue) {
+                return;
+            }
+            // Update context with new renderValue
+            this._service.send({
+                type: 'updateContext',
+                renderValue,
+            });
+        });
+        this._service.start();
+        // Initialize instance state in WeakMap
+        itemPropertyInstanceState.set(this, {
+            liveQuerySubscription: null,
+        });
+        // Set up liveQuery subscription for cross-instance updates
+        this._setupLiveQuerySubscription();
+    }
+    /**
+     * Set up liveQuery subscription to watch for metadata changes in the database
+     * This enables cross-instance synchronization (e.g., changes in other tabs/windows)
+     */
+    _setupLiveQuerySubscription() {
+        const isBrowser = typeof window !== 'undefined';
+        const logger = debug('seedSdk:itemProperty:liveQuery');
+        // Use a closure variable to track setup state per instance
+        const setupState = { subscriptionSetUp: false };
+        const setupLiveQuery = async (seedLocalId, seedUid, propertyName, versionLocalId) => {
+            if (setupState.subscriptionSetUp) {
+                return;
+            }
+            if (!seedLocalId && !seedUid) {
+                logger('[ItemProperty._setupLiveQuerySubscription] No seedLocalId or seedUid');
+                return;
+            }
+            if (!propertyName) {
+                logger('[ItemProperty._setupLiveQuerySubscription] No propertyName');
+                return;
+            }
+            setupState.subscriptionSetUp = true;
+            logger(`[ItemProperty._setupLiveQuerySubscription] Setting up liveQuery for propertyName: ${propertyName}, seedLocalId: ${seedLocalId}`);
+            try {
+                const { BaseDb } = await import('../db/Db/BaseDb.js');
+                const { metadata } = await import('../seedSchema/index.js');
+                const { eq, and, isNotNull } = await import('drizzle-orm');
+                const { getMetadataLatest } = await import('../db/read/subqueries/metadataLatest.js');
+                const db = BaseDb.getAppDb();
+                if (!db) {
+                    logger('[ItemProperty._setupLiveQuerySubscription] Database not available');
+                    return;
+                }
+                // Query initial metadata using getMetadataLatest subquery pattern
+                const metadataLatest = getMetadataLatest({ seedLocalId, seedUid });
+                const initialMetadata = await db
+                    .with(metadataLatest)
+                    .select()
+                    .from(metadataLatest)
+                    .where(and(eq(metadataLatest.propertyName, propertyName), eq(metadataLatest.rowNum, 1)))
+                    .limit(1);
+                if (initialMetadata.length > 0) {
+                    const metaRow = initialMetadata[0];
+                    logger(`[ItemProperty._setupLiveQuerySubscription] Initial query returned metadata record`);
+                    // Update context with initial metadata
+                    this._service.send({
+                        type: 'updateContext',
+                        propertyValue: metaRow.propertyValue,
+                        renderValue: metaRow.propertyValue,
+                        localId: metaRow.localId || undefined,
+                        uid: metaRow.uid || undefined,
+                        versionLocalId: metaRow.versionLocalId || undefined,
+                        versionUid: metaRow.versionUid || undefined,
+                        schemaUid: metaRow.schemaUid || undefined,
+                    });
+                }
+                // Only set up liveQuery subscription in browser environment
+                if (isBrowser) {
+                    // Set up liveQuery to watch metadata table for this property
+                    // Use proper SQL parameter binding - ensure values are strings, not objects
+                    const resolvedSeedUid = seedUid || null;
+                    const resolvedSeedLocalId = seedLocalId || null;
+                    const metadata$ = BaseDb.liveQuery((sql) => {
+                        if (resolvedSeedUid) {
+                            return sql `
+                  SELECT local_id as localId, uid, property_name as propertyName, property_value as propertyValue, 
+                         version_local_id as versionLocalId, version_uid as versionUid, schema_uid as schemaUid
+                  FROM metadata
+                  WHERE seed_uid = ${resolvedSeedUid}
+                    AND property_name = ${propertyName}
+                    AND property_name IS NOT NULL
+                  ORDER BY COALESCE(created_at, attestation_created_at) DESC
+                  LIMIT 1
+                `;
+                        }
+                        else if (resolvedSeedLocalId) {
+                            return sql `
+                  SELECT local_id as localId, uid, property_name as propertyName, property_value as propertyValue, 
+                         version_local_id as versionLocalId, version_uid as versionUid, schema_uid as schemaUid
+                  FROM metadata
+                  WHERE seed_local_id = ${resolvedSeedLocalId}
+                    AND property_name = ${propertyName}
+                    AND property_name IS NOT NULL
+                  ORDER BY COALESCE(created_at, attestation_created_at) DESC
+                  LIMIT 1
+                `;
+                        }
+                        else {
+                            // Fallback - should not happen, but handle gracefully
+                            return sql `
+                  SELECT local_id as localId, uid, property_name as propertyName, property_value as propertyValue, 
+                         version_local_id as versionLocalId, version_uid as versionUid, schema_uid as schemaUid
+                  FROM metadata
+                  WHERE 1 = 0
+                `;
+                        }
+                    });
+                    const instanceState = itemPropertyInstanceState.get(this);
+                    if (!instanceState) {
+                        logger('[ItemProperty._setupLiveQuerySubscription] Instance state not found');
+                        return;
+                    }
+                    // Subscribe to liveQuery updates
+                    const subscription = metadata$.subscribe({
+                        next: async (metadataRows) => {
+                            if (metadataRows.length === 0)
+                                return;
+                            const metaRow = metadataRows[0];
+                            logger(`[ItemProperty._setupLiveQuerySubscription] Metadata updated in database for propertyName: ${propertyName}`);
+                            // Update context with metadata changes
+                            this._service.send({
+                                type: 'updateContext',
+                                propertyValue: metaRow.propertyValue,
+                                renderValue: metaRow.propertyValue,
+                                localId: metaRow.localId || undefined,
+                                uid: metaRow.uid || undefined,
+                                versionLocalId: metaRow.versionLocalId || undefined,
+                                versionUid: metaRow.versionUid || undefined,
+                                schemaUid: metaRow.schemaUid || undefined,
+                            });
+                        },
+                        error: (error) => {
+                            logger(`[ItemProperty._setupLiveQuerySubscription] LiveQuery error: ${error}`);
+                        },
+                    });
+                    instanceState.liveQuerySubscription = subscription;
+                    logger(`[ItemProperty._setupLiveQuerySubscription] LiveQuery subscription set up for propertyName: ${propertyName}`);
+                }
+                else {
+                    logger(`[ItemProperty._setupLiveQuerySubscription] Skipping liveQuery subscription in Node.js environment`);
+                }
+            }
+            catch (error) {
+                logger(`[ItemProperty._setupLiveQuerySubscription] Error setting up subscription: ${error}`);
+                setupState.subscriptionSetUp = false; // Reset on error so we can retry
+            }
+        };
+        // Set up liveQuery subscription as soon as we have required context
+        const setupSubscription = this._service.subscribe(async (snapshot) => {
+            const seedLocalId = snapshot.context.seedLocalId;
+            const seedUid = snapshot.context.seedUid;
+            const propertyName = snapshot.context.propertyName;
+            snapshot.context.versionLocalId;
+            if ((!seedLocalId && !seedUid) || !propertyName) {
+                return; // Need seed ID and propertyName to proceed
+            }
+            // Once we have required context, set up the liveQuery subscription (only once)
+            if ((seedLocalId || seedUid) && propertyName && !setupState.subscriptionSetUp) {
+                await setupLiveQuery(seedLocalId || '', seedUid, propertyName);
+                if (setupState.subscriptionSetUp) {
+                    setupSubscription.unsubscribe();
+                }
+            }
+        });
+        // Also check current state immediately in case context is already available
+        const currentSnapshot = this._service.getSnapshot();
+        const seedLocalId = currentSnapshot.context.seedLocalId;
+        const seedUid = currentSnapshot.context.seedUid;
+        const propertyName = currentSnapshot.context.propertyName;
+        currentSnapshot.context.versionLocalId;
+        if ((seedLocalId || seedUid) && propertyName && !setupState.subscriptionSetUp) {
+            setupLiveQuery(seedLocalId || '', seedUid, propertyName).catch((error) => {
+                logger(`[ItemProperty._setupLiveQuerySubscription] Error in immediate setup: ${error}`);
+            });
+        }
+    }
+    static create(props) {
+        const { propertyName, seedLocalId, seedUid, versionLocalId, versionUid } = props;
+        if (!propertyName || (!seedLocalId && !seedUid)) {
+            return;
+        }
+        const cacheKey = this.cacheKey((seedUid || seedLocalId), propertyName);
+        if (seedLocalId && propertyName) {
+            if (this.instanceCache.has(cacheKey)) {
+                const { instance, refCount } = this.instanceCache.get(cacheKey);
+                this.instanceCache.set(cacheKey, {
+                    instance,
+                    refCount: refCount + 1,
+                });
+                return instance;
+            }
+            if (!this.instanceCache.has(cacheKey)) {
+                const newInstance = new ItemProperty(props);
+                // Wrap instance in Proxy for reactive property access
+                const proxiedInstance = createReactiveProxy({
+                    instance: newInstance,
+                    service: newInstance._service,
+                    trackedProperties: TRACKED_PROPERTIES,
+                    getContext: (instance) => {
+                        return instance._getSnapshotContext();
+                    },
+                    sendUpdate: (instance, prop, value) => {
+                        instance._service.send({
+                            type: 'updateContext',
+                            [prop]: value,
+                        });
+                    },
+                });
+                this.instanceCache.set(cacheKey, {
+                    instance: proxiedInstance,
+                    refCount: 1,
+                });
+                return proxiedInstance;
+            }
+        }
+        if (seedUid && propertyName) {
+            if (this.instanceCache.has(cacheKey)) {
+                const { instance, refCount } = this.instanceCache.get(cacheKey);
+                this.instanceCache.set(cacheKey, { instance, refCount: refCount + 1 });
+                return instance;
+            }
+            if (!this.instanceCache.has(cacheKey)) {
+                const newInstance = new ItemProperty(props);
+                // Wrap instance in Proxy for reactive property access
+                const proxiedInstance = createReactiveProxy({
+                    instance: newInstance,
+                    service: newInstance._service,
+                    trackedProperties: TRACKED_PROPERTIES,
+                    getContext: (instance) => {
+                        return instance._getSnapshotContext();
+                    },
+                    sendUpdate: (instance, prop, value) => {
+                        instance._service.send({
+                            type: 'updateContext',
+                            [prop]: value,
+                        });
+                    },
+                });
+                this.instanceCache.set(cacheKey, { instance: proxiedInstance, refCount: 1 });
+                return proxiedInstance;
+            }
+        }
+        const newInstance = new ItemProperty(props);
+        // Wrap instance in Proxy for reactive property access
+        return createReactiveProxy({
+            instance: newInstance,
+            service: newInstance._service,
+            trackedProperties: TRACKED_PROPERTIES,
+            getContext: (instance) => {
+                return instance._getSnapshotContext();
+            },
+            sendUpdate: (instance, prop, value) => {
+                instance._service.send({
+                    type: 'updateContext',
+                    [prop]: value,
+                });
+            },
+        });
+    }
+    static async find({ propertyName, seedLocalId, seedUid, }) {
+        if ((!seedLocalId && !seedUid) || !propertyName) {
+            return;
+        }
+        const cacheKeyId = seedUid || seedLocalId;
+        const cacheKey = ItemProperty.cacheKey(cacheKeyId, propertyName);
+        if (this.instanceCache.has(cacheKey)) {
+            const { instance, refCount } = this.instanceCache.get(cacheKey);
+            this.instanceCache.set(cacheKey, {
+                instance,
+                refCount: refCount + 1,
+            });
+            return instance;
+        }
+        const propertyData = await getPropertyData({
+            propertyName,
+            seedLocalId,
+            seedUid,
+        });
+        if (!propertyData) {
+            return;
+        }
+        return ItemProperty.create(propertyData);
+    }
+    static cacheKey(seedLocalIdOrUid, propertyName) {
+        const { uid, localId } = getCorrectId(seedLocalIdOrUid);
+        return `Item_${uid || localId}_${propertyName}`;
+    }
+    getService() {
+        return this._service;
+    }
+    _getSnapshot() {
+        return this._service.getSnapshot();
+    }
+    _getSnapshotContext() {
+        return this._getSnapshot().context;
+    }
+    get localId() {
+        return this._getSnapshotContext().localId ?? '';
+    }
+    get uid() {
+        return this._getSnapshotContext().uid ?? '';
+    }
+    get seedLocalId() {
+        return this._getSnapshotContext().seedLocalId ?? '';
+    }
+    get seedUid() {
+        return this._getSnapshotContext().seedUid ?? '';
+    }
+    get schemaUid() {
+        return this._getSnapshotContext().schemaUid;
+    }
+    get propertyName() {
+        if (this._alias) {
+            return this._alias;
+        }
+        return this._getSnapshotContext().propertyName;
+    }
+    get modelName() {
+        return this._getSnapshotContext().modelName;
+    }
+    get propertyDef() {
+        return this._getSnapshotContext().propertyRecordSchema;
+    }
+    get localStorageDir() {
+        const propertyDef = this.propertyDef;
+        if (propertyDef && propertyDef.localStorageDir) {
+            return this.propertyDef.localStorageDir;
+        }
+        if (this._getSnapshot().context.localStorageDir) {
+            return this._getSnapshot().context.localStorageDir;
+        }
+    }
+    get refResolvedValue() {
+        return this._getSnapshotContext().refResolvedValue;
+    }
+    get localStoragePath() {
+        if (this.localStorageDir) {
+            return `/files${this.localStorageDir}/${this.refResolvedValue}`;
+        }
+    }
+    get versionLocalId() {
+        return this._getSnapshotContext().versionLocalId;
+    }
+    get status() {
+        return this._getSnapshot().value;
+    }
+    get alias() {
+        return this._alias;
+    }
+    get value() {
+        // Use string literal to avoid circular dependency
+        const context = this._getSnapshotContext();
+        if (this._dataType === 'Image') {
+            return context.refResolvedValue;
+        }
+        // Read from context via proxy (renderValue or propertyValue)
+        return context.renderValue || context.propertyValue;
+    }
+    set value(value) {
+        const context = this._getSnapshotContext();
+        const currentValue = context.renderValue || context.propertyValue;
+        if (currentValue === value) {
+            return;
+        }
+        // If no propertyRecordSchema, just update context directly
+        if (!context.propertyRecordSchema) {
+            this._service.send({
+                type: 'updateContext',
+                propertyValue: value,
+                renderValue: value,
+            });
+        }
+        else {
+            // Otherwise trigger save
+            this._service.send({
+                type: 'save',
+                newValue: value,
+            });
+        }
+    }
+    get published() {
+        return !!this._getSnapshot().context.uid;
+    }
+    subscribe(callback) {
+        // Subscribe to service instead of BehaviorSubject for reactivity
+        return this._service.subscribe((snapshot) => {
+            const context = snapshot.context;
+            const value = context.renderValue || context.propertyValue;
+            if (callback.next) {
+                callback.next(value);
+            }
+        });
+    }
+    async save() {
+        await waitFor(this._service, (snapshot) => !snapshot.context.isSaving && snapshot.value === 'idle', {
+            timeout: 10000,
+        });
+        // return new Promise((resolve) => {
+        //   const saveSub = this._service.subscribe((snapshot) => {
+        //     if (!snapshot.context.isSaving) {
+        //       saveSub.unsubscribe()
+        //       resolve()
+        //     }
+        //   })
+        // })
+    }
+    unload() {
+        // Clean up liveQuery subscription
+        const instanceState = itemPropertyInstanceState.get(this);
+        if (instanceState?.liveQuerySubscription) {
+            instanceState.liveQuerySubscription.unsubscribe();
+            instanceState.liveQuerySubscription = null;
+        }
+        this._subscription?.unsubscribe();
+        this._service.stop();
+    }
+}
+ItemProperty.instanceCache = new Map();
+
+export { ItemProperty };
+//# sourceMappingURL=ItemProperty.js.map