@stonecrop/stonecrop 0.4.37 → 0.5.0

package/dist/src/stonecrop.js

@@ -0,0 +1,251 @@
+import { createHST } from './stores/hst';
+import { useOperationLogStore } from './stores/operation-log';
+/**
+ * Main Stonecrop class with HST integration and built-in Operation Log
+ * @public
+ */
+export class Stonecrop {
+    hstStore;
+    _operationLogStore;
+    _operationLogConfig;
+    /** The registry instance containing all doctype definitions */
+    registry;
+    /**
+     * Creates a new Stonecrop instance with HST integration
+     * @param registry - The Registry instance containing doctype definitions
+     * @param operationLogConfig - Optional configuration for the operation log
+     */
+    constructor(registry, operationLogConfig) {
+        this.registry = registry;
+        // Store config for lazy initialization
+        this._operationLogConfig = operationLogConfig;
+        // Initialize HST store with auto-sync to Registry
+        this.initializeHSTStore();
+        this.setupRegistrySync();
+    }
+    /**
+     * Get the operation log store (lazy initialization)
+     * @internal
+     */
+    getOperationLogStore() {
+        if (!this._operationLogStore) {
+            this._operationLogStore = useOperationLogStore();
+            if (this._operationLogConfig) {
+                this._operationLogStore.configure(this._operationLogConfig);
+            }
+        }
+        return this._operationLogStore;
+    }
+    /**
+     * Initialize the HST store structure
+     */
+    initializeHSTStore() {
+        const initialStoreStructure = {};
+        // Auto-populate from existing Registry doctypes
+        Object.keys(this.registry.registry).forEach(doctypeSlug => {
+            initialStoreStructure[doctypeSlug] = {};
+        });
+        this.hstStore = createHST(initialStoreStructure, 'StonecropStore');
+    }
+    /**
+     * Setup automatic sync with Registry when doctypes are added
+     */
+    setupRegistrySync() {
+        // Extend Registry.addDoctype to auto-create HST store sections
+        const originalAddDoctype = this.registry.addDoctype.bind(this.registry);
+        this.registry.addDoctype = (doctype) => {
+            // Call original method
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+            originalAddDoctype(doctype);
+            // Auto-create HST store section for new doctype
+            if (!this.hstStore.has(doctype.slug)) {
+                this.hstStore.set(doctype.slug, {});
+            }
+        };
+    }
+    /**
+     * Get records hash for a doctype
+     * @param doctype - The doctype to get records for
+     * @returns HST node containing records hash
+     */
+    records(doctype) {
+        const slug = typeof doctype === 'string' ? doctype : doctype.slug;
+        this.ensureDoctypeExists(slug);
+        return this.hstStore.getNode(slug);
+    }
+    /**
+     * Add a record to the store
+     * @param doctype - The doctype
+     * @param recordId - The record ID
+     * @param recordData - The record data
+     */
+    addRecord(doctype, recordId, recordData) {
+        const slug = typeof doctype === 'string' ? doctype : doctype.slug;
+        this.ensureDoctypeExists(slug);
+        // Store raw record data - let HST handle wrapping with proper hierarchy
+        this.hstStore.set(`${slug}.${recordId}`, recordData);
+    }
+    /**
+     * Get a specific record
+     * @param doctype - The doctype
+     * @param recordId - The record ID
+     * @returns HST node for the record or undefined
+     */
+    getRecordById(doctype, recordId) {
+        const slug = typeof doctype === 'string' ? doctype : doctype.slug;
+        this.ensureDoctypeExists(slug);
+        // First check if the record exists
+        const recordExists = this.hstStore.has(`${slug}.${recordId}`);
+        if (!recordExists) {
+            return undefined;
+        }
+        // Check if the actual value is undefined (i.e., record was removed)
+        const recordValue = this.hstStore.get(`${slug}.${recordId}`);
+        if (recordValue === undefined) {
+            return undefined;
+        }
+        // Use getNode to get the properly wrapped HST node with correct parent relationships
+        return this.hstStore.getNode(`${slug}.${recordId}`);
+    }
+    /**
+     * Remove a record from the store
+     * @param doctype - The doctype
+     * @param recordId - The record ID
+     */
+    removeRecord(doctype, recordId) {
+        const slug = typeof doctype === 'string' ? doctype : doctype.slug;
+        this.ensureDoctypeExists(slug);
+        // Remove the specific record directly by setting to undefined
+        if (this.hstStore.has(`${slug}.${recordId}`)) {
+            this.hstStore.set(`${slug}.${recordId}`, undefined);
+        }
+    }
+    /**
+     * Get all record IDs for a doctype
+     * @param doctype - The doctype
+     * @returns Array of record IDs
+     */
+    getRecordIds(doctype) {
+        const slug = typeof doctype === 'string' ? doctype : doctype.slug;
+        this.ensureDoctypeExists(slug);
+        const doctypeNode = this.hstStore.get(slug);
+        if (!doctypeNode || typeof doctypeNode !== 'object') {
+            return [];
+        }
+        return Object.keys(doctypeNode).filter(key => doctypeNode[key] !== undefined);
+    }
+    /**
+     * Clear all records for a doctype
+     * @param doctype - The doctype
+     */
+    clearRecords(doctype) {
+        const slug = typeof doctype === 'string' ? doctype : doctype.slug;
+        this.ensureDoctypeExists(slug);
+        // Get all record IDs and remove them
+        const recordIds = this.getRecordIds(slug);
+        recordIds.forEach(recordId => {
+            this.hstStore.set(`${slug}.${recordId}`, undefined);
+        });
+    }
+    /**
+     * Setup method for doctype initialization
+     * @param doctype - The doctype to setup
+     */
+    setup(doctype) {
+        // Ensure doctype exists in store
+        this.ensureDoctypeExists(doctype.slug);
+    }
+    /**
+     * Run action on doctype
+     * Executes the action and logs it to the operation log for audit tracking
+     * @param doctype - The doctype
+     * @param action - The action to run
+     * @param args - Action arguments (typically record IDs)
+     */
+    runAction(doctype, action, args) {
+        const registry = this.registry.registry[doctype.slug];
+        const actions = registry?.actions?.get(action);
+        const recordIds = Array.isArray(args) ? args.filter((arg) => typeof arg === 'string') : undefined;
+        // Log action execution start
+        const opLogStore = this.getOperationLogStore();
+        let actionResult = 'success';
+        let actionError;
+        try {
+            // Execute action functions
+            if (actions && actions.length > 0) {
+                actions.forEach(actionStr => {
+                    try {
+                        // eslint-disable-next-line @typescript-eslint/no-implied-eval
+                        const actionFn = new Function('args', actionStr);
+                        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+                        actionFn(args);
+                    }
+                    catch (error) {
+                        actionResult = 'failure';
+                        actionError = error instanceof Error ? error.message : 'Unknown error';
+                        throw error;
+                    }
+                });
+            }
+        }
+        catch {
+            // Error already set in inner catch
+        }
+        finally {
+            // Log the action execution to operation log
+            opLogStore.logAction(doctype.doctype, action, recordIds, actionResult, actionError);
+        }
+    }
+    /**
+     * Get records from server (maintains compatibility)
+     * @param doctype - The doctype
+     */
+    async getRecords(doctype) {
+        const response = await fetch(`/${doctype.slug}`);
+        const records = await response.json();
+        // Store each record in HST
+        records.forEach((record) => {
+            if (record.id) {
+                this.addRecord(doctype, record.id, record);
+            }
+        });
+    }
+    /**
+     * Get single record from server (maintains compatibility)
+     * @param doctype - The doctype
+     * @param recordId - The record ID
+     */
+    async getRecord(doctype, recordId) {
+        const response = await fetch(`/${doctype.slug}/${recordId}`);
+        const record = await response.json();
+        // Store record
+        this.addRecord(doctype, recordId, record);
+    }
+    /**
+     * Ensure doctype section exists in HST store
+     * @param slug - The doctype slug
+     */
+    ensureDoctypeExists(slug) {
+        if (!this.hstStore.has(slug)) {
+            this.hstStore.set(slug, {});
+        }
+    }
+    /**
+     * Get doctype metadata from the registry
+     * @param context - The route context
+     * @returns The doctype metadata
+     */
+    async getMeta(context) {
+        if (!this.registry.getMeta) {
+            throw new Error('No getMeta function provided to Registry');
+        }
+        return await this.registry.getMeta(context);
+    }
+    /**
+     * Get the root HST store node for advanced usage
+     * @returns Root HST node
+     */
+    getStore() {
+        return this.hstStore;
+    }
+}

package/dist/src/stores/hst.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Core HST Interface - enhanced with tree navigation
+ * Provides a hierarchical state tree interface for navigating and manipulating nested data structures.
+ *
+ * @public
+ */
+interface HSTNode {
+    /**
+     * Gets a value at the specified path
+     * @param path - The dot-separated path to the value
+     * @returns The value at the specified path
+     */
+    get(path: string): any;
+    /**
+     * Sets a value at the specified path
+     * @param path - The dot-separated path where to set the value
+     * @param value - The value to set
+     * @param source - Optional source of the operation (user, system, sync, undo, redo)
+     */
+    set(path: string, value: any, source?: 'user' | 'system' | 'sync' | 'undo' | 'redo'): void;
+    /**
+     * Checks if a value exists at the specified path
+     * @param path - The dot-separated path to check
+     * @returns True if the path exists, false otherwise
+     */
+    has(path: string): boolean;
+    /**
+     * Gets the parent node in the tree hierarchy
+     * @returns The parent HSTNode or null if this is the root
+     */
+    getParent(): HSTNode | null;
+    /**
+     * Gets the root node of the tree
+     * @returns The root HSTNode
+     */
+    getRoot(): HSTNode;
+    /**
+     * Gets the full path from root to this node
+     * @returns The dot-separated path string
+     */
+    getPath(): string;
+    /**
+     * Gets the depth level of this node in the tree
+     * @returns The depth as a number (0 for root)
+     */
+    getDepth(): number;
+    /**
+     * Gets an array of path segments from root to this node
+     * @returns Array of path segments representing breadcrumbs
+     */
+    getBreadcrumbs(): string[];
+    /**
+     * Gets a child node at the specified relative path
+     * @param path - The relative path to the child node
+     * @returns The child HSTNode
+     */
+    getNode(path: string): HSTNode;
+    /**
+     * Trigger an XState transition with optional context data
+     * @param transition - The transition name (should be uppercase per convention)
+     * @param context - Optional additional FSM context data
+     * @returns Promise resolving to the transition execution results
+     */
+    triggerTransition(transition: string, context?: {
+        currentState?: string;
+        targetState?: string;
+        fsmContext?: Record<string, any>;
+    }): Promise<any>;
+}
+interface RegistryGlobal {
+    Registry?: {
+        _root?: {
+            registry: Record<string, any>;
+        };
+    };
+}
+declare global {
+    interface Window extends RegistryGlobal {
+    }
+    const global: RegistryGlobal | undefined;
+}
+/**
+ * Global HST Manager (Singleton)
+ * Manages hierarchical state trees and provides access to the global registry.
+ *
+ * @public
+ */
+declare class HST {
+    private static instance;
+    /**
+     * Gets the singleton instance of HST
+     * @returns The HST singleton instance
+     */
+    static getInstance(): HST;
+    /**
+     * Gets the global registry instance
+     * @returns The global registry object or undefined if not found
+     */
+    getRegistry(): any;
+    /**
+     * Helper method to get doctype metadata from the registry
+     * @param doctype - The name of the doctype to retrieve metadata for
+     * @returns The doctype metadata object or undefined if not found
+     */
+    getDoctypeMeta(doctype: string): any;
+}
+declare class HSTProxy implements HSTNode {
+    private target;
+    private parentPath;
+    private rootNode;
+    private doctype;
+    private parentDoctype?;
+    private hst;
+    constructor(target: any, doctype: string, parentPath?: string, rootNode?: HSTNode | null, parentDoctype?: string);
+    get(path: string): any;
+    getNode(path: string): HSTNode;
+    set(path: string, value: any, source?: 'user' | 'system' | 'sync' | 'undo' | 'redo'): void;
+    has(path: string): boolean;
+    getParent(): HSTNode | null;
+    getRoot(): HSTNode;
+    getPath(): string;
+    getDepth(): number;
+    getBreadcrumbs(): string[];
+    /**
+     * Trigger an XState transition with optional context data
+     */
+    triggerTransition(transition: string, context?: {
+        currentState?: string;
+        targetState?: string;
+        fsmContext?: Record<string, any>;
+    }): Promise<any>;
+    private resolvePath;
+    private resolveValue;
+    private updateValue;
+    private getProperty;
+    private setProperty;
+    private triggerFieldActions;
+    private isVueReactive;
+    private isPiniaStore;
+    private isImmutable;
+    private isPrimitive;
+    private parsePath;
+}
+/**
+ * Factory function for HST creation
+ * Creates a new HSTNode proxy for hierarchical state tree navigation.
+ *
+ * @param target - The target object to wrap with HST functionality
+ * @param doctype - The document type identifier
+ * @param parentDoctype - Optional parent document type identifier
+ * @returns A new HSTNode proxy instance
+ *
+ * @public
+ */
+declare function createHST(target: any, doctype: string, parentDoctype?: string): HSTNode;
+export { HSTProxy, HST, createHST, type HSTNode };
+//# sourceMappingURL=hst.d.ts.map

package/dist/src/stores/hst.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hst.d.ts","sourceRoot":"","sources":["../../../src/stores/hst.ts"],"names":[],"mappings":"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"}