@seedprotocol/sdk 0.4.1 → 0.4.3

package/dist/ItemProperty/ItemProperty.js

@@ -1,613 +0,0 @@
-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