@stonecrop/stonecrop 0.4.37 → 0.6.0

package/dist/src/plugins/index.js

@@ -0,0 +1,90 @@
+import { nextTick } from 'vue';
+import Registry from '../registry';
+import { Stonecrop } from '../stonecrop';
+import { useOperationLogStore } from '../stores/operation-log';
+/**
+ * Setup auto-initialization for user-defined initialization logic
+ * This function handles the post-mount initialization automatically
+ */
+async function setupAutoInitialization(registry, stonecrop, onRouterInitialized) {
+    // Wait for the next tick to ensure the app is mounted
+    await nextTick();
+    try {
+        await onRouterInitialized(registry, stonecrop);
+    }
+    catch {
+        // Silent error handling - application should handle initialization errors
+    }
+}
+/**
+ * Stonecrop Vue plugin
+ * @param app - The Vue app instance
+ * @param options - The plugin options
+ * @example
+ * ```ts
+ * import { createApp } from 'vue'
+ * import Stonecrop from '@stonecrop/stonecrop'
+ * import router from './router'
+ *
+ * const app = createApp(App)
+ * app.use(Stonecrop, {
+ *   router,
+ *   getMeta: async (routeContext) => {
+ *     // routeContext contains: { path, segments }
+ *     // fetch doctype meta from your API using the route context
+ *   },
+ *   autoInitializeRouter: true,
+ *   onRouterInitialized: async (registry, stonecrop) => {
+ *     // your custom initialization logic here
+ *   }
+ * })
+ * app.mount('#app')
+ * ```
+ * @public
+ */
+const plugin = {
+    install: (app, options) => {
+        // Check for existing router installation
+        const existingRouter = app.config.globalProperties.$router;
+        const providedRouter = options?.router;
+        const router = existingRouter || providedRouter;
+        if (!existingRouter && providedRouter) {
+            app.use(providedRouter);
+        }
+        // Create registry with available router
+        const registry = new Registry(router, options?.getMeta);
+        app.provide('$registry', registry);
+        app.config.globalProperties.$registry = registry;
+        // Create and provide a global Stonecrop instance
+        const stonecrop = new Stonecrop(registry);
+        app.provide('$stonecrop', stonecrop);
+        app.config.globalProperties.$stonecrop = stonecrop;
+        // Initialize operation log store if Pinia is available
+        // This ensures the store is created with the app's Pinia instance
+        try {
+            const pinia = app.config.globalProperties.$pinia;
+            if (pinia) {
+                // Initialize the operation log store with the app's Pinia instance
+                const operationLogStore = useOperationLogStore(pinia);
+                // Provide the store so components can access it
+                app.provide('$operationLogStore', operationLogStore);
+                app.config.globalProperties.$operationLogStore = operationLogStore;
+            }
+        }
+        catch (error) {
+            // Pinia not available - operation log won't work, but app should still function
+            console.warn('Pinia not available - operation log features will be disabled:', error);
+        }
+        // Register custom components
+        if (options?.components) {
+            for (const [tag, component] of Object.entries(options.components)) {
+                app.component(tag, component);
+            }
+        }
+        // Setup auto-initialization if requested
+        if (options?.autoInitializeRouter && options.onRouterInitialized) {
+            void setupAutoInitialization(registry, stonecrop, options.onRouterInitialized);
+        }
+    },
+};
+export default plugin;

package/dist/src/registry.d.ts

@@ -1,5 +1,6 @@
 import { Router } from 'vue-router';
 import DoctypeMeta from './doctype';
+import { RouteContext } from './types/registry';
 /**
  * Stonecrop Registry class
  * @public
@@ -25,12 +26,17 @@ export default class Registry {
      * @see {@link https://router.vuejs.org/}
      */
     readonly router?: Router;
-    constructor(router?: Router, getMeta?: (doctype: string) => DoctypeMeta | Promise<DoctypeMeta>);
     /**
-     * The getMeta function fetches doctype metadata from an API
+     * Creates a new Registry instance (singleton pattern)
+     * @param router - Optional Vue router instance for route management
+     * @param getMeta - Optional function to fetch doctype metadata from an API
+     */
+    constructor(router?: Router, getMeta?: (routeContext: RouteContext) => DoctypeMeta | Promise<DoctypeMeta>);
+    /**
+     * The getMeta function fetches doctype metadata from an API based on route context
      * @see {@link DoctypeMeta}
      */
-    getMeta?: (doctype: string) => DoctypeMeta | Promise<DoctypeMeta>;
+    getMeta?: (routeContext: RouteContext) => DoctypeMeta | Promise<DoctypeMeta>;
     /**
      * Get doctype metadata
      * @param doctype - The doctype to fetch metadata for

package/dist/src/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAEnC,OAAO,WAAW,MAAM,WAAW,CAAA;AAEnC;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,QAAQ;IAC5B;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAA;IAEtB;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IAErB;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;IAE9C;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;gBAEZ,MAAM,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IAW9F;;;OAGG;IACH,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAAA;IAEjE;;;;;OAKG;IACH,UAAU,CAAC,OAAO,EAAE,WAAW;CA0B/B"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAEnC,OAAO,WAAW,MAAM,WAAW,CAAA;AAEnC,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAE/C;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,QAAQ;IAC5B;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAA;IAEtB;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IAErB;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;IAE9C;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IAExB;;;;OAIG;gBACS,MAAM,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,YAAY,EAAE,YAAY,KAAK,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;IAWzG;;;OAGG;IACH,OAAO,CAAC,EAAE,CAAC,YAAY,EAAE,YAAY,KAAK,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAAA;IAE5E;;;;;OAKG;IACH,UAAU,CAAC,OAAO,EAAE,WAAW;CAkC/B"}

package/dist/{registry.js → src/registry.js}

@@ -1,3 +1,4 @@
+import { getGlobalTriggerEngine } from './field-triggers';
 /**
  * Stonecrop Registry class
  * @public
@@ -23,6 +24,11 @@ export default class Registry {
      * @see {@link https://router.vuejs.org/}
      */
     router;
+    /**
+     * Creates a new Registry instance (singleton pattern)
+     * @param router - Optional Vue router instance for route management
+     * @param getMeta - Optional function to fetch doctype metadata from an API
+     */
     constructor(router, getMeta) {
         if (Registry._root) {
             return Registry._root;
@@ -34,7 +40,7 @@ export default class Registry {
         this.getMeta = getMeta;
     }
     /**
-     * The getMeta function fetches doctype metadata from an API
+     * The getMeta function fetches doctype metadata from an API based on route context
      * @see {@link DoctypeMeta}
      */
     getMeta;
@@ -48,6 +54,13 @@ export default class Registry {
         if (!(doctype.doctype in Object.keys(this.registry))) {
             this.registry[doctype.slug] = doctype;
         }
+        // Register actions (including field triggers) with the field trigger engine
+        const triggerEngine = getGlobalTriggerEngine();
+        // Register under both doctype name and slug to handle different lookup patterns
+        triggerEngine.registerDoctypeActions(doctype.doctype, doctype.actions);
+        if (doctype.slug !== doctype.doctype) {
+            triggerEngine.registerDoctypeActions(doctype.slug, doctype.actions);
+        }
         if (doctype.component && this.router && !this.router.hasRoute(doctype.doctype)) {
             this.router.addRoute({
                 path: `/${doctype.slug}`,

package/dist/src/stonecrop.d.ts

@@ -1,135 +1,371 @@
 import DoctypeMeta from './doctype';
 import Registry from './registry';
-import { useDataStore } from './stores/data';
+import { type HSTNode } from './stores/hst';
+import type { OperationLogConfig } from './types/operation-log';
+import type { RouteContext } from './types/registry';
 /**
- * Stonecrop class
+ * Main Stonecrop class with HST integration and built-in Operation Log
  * @public
  */
 export declare class Stonecrop {
+    private hstStore;
+    private _operationLogStore?;
+    private _operationLogConfig?;
+    /** The registry instance containing all doctype definitions */
+    readonly registry: Registry;
     /**
-     * The root Stonecrop instance
-     */
-    static _root: Stonecrop;
-    /**
-     * The name of the Stonecrop instance
-     * @readonly
-     *
-     * @defaultValue 'Stonecrop'
-     */
-    readonly name = "Stonecrop";
-    /**
-     * The registry is an immutable collection of doctypes
-     * @example
-     * ```ts
-     * {
-     * 	'task': {
-     * 		doctype: 'Task',
-     * 		schema: {
-     * 			title: 'string',
-     * 			description: 'string',
-     * 			...
-     * 		}
-     * 	},
-     * 	...
-     * }
-     * ```
-     * @see {@link Registry}
-     * @see {@link DoctypeMeta}
+     * Creates a new Stonecrop instance with HST integration
+     * @param registry - The Registry instance containing doctype definitions
+     * @param operationLogConfig - Optional configuration for the operation log
      */
-    readonly registry: Registry;
+    constructor(registry: Registry, operationLogConfig?: Partial<OperationLogConfig>);
+    /**
+     * Get the operation log store (lazy initialization)
+     * @internal
+     */
+    getOperationLogStore(): import("pinia").Store<"hst-operation-log", Pick<{
+        operations: import("vue").Ref<{
+            id: string;
+            type: import("./types").HSTOperationType;
+            path: string;
+            fieldname: string;
+            beforeValue: any;
+            afterValue: any;
+            doctype: string;
+            recordId?: string | undefined;
+            timestamp: Date;
+            source?: import("./types").OperationSource | undefined;
+            reversible: boolean;
+            irreversibleReason?: string | undefined;
+            transition?: string | undefined;
+            currentState?: string | undefined;
+            targetState?: string | undefined;
+            actionName?: string | undefined;
+            actionRecordIds?: string[] | undefined;
+            actionResult?: "success" | "failure" | "pending" | undefined;
+            actionError?: string | undefined;
+            userId?: string | undefined;
+            metadata?: Record<string, any> | undefined;
+            parentOperationId?: string | undefined;
+            childOperationIds?: string[] | undefined;
+        }[], import("./types").HSTOperation[] | {
+            id: string;
+            type: import("./types").HSTOperationType;
+            path: string;
+            fieldname: string;
+            beforeValue: any;
+            afterValue: any;
+            doctype: string;
+            recordId?: string | undefined;
+            timestamp: Date;
+            source?: import("./types").OperationSource | undefined;
+            reversible: boolean;
+            irreversibleReason?: string | undefined;
+            transition?: string | undefined;
+            currentState?: string | undefined;
+            targetState?: string | undefined;
+            actionName?: string | undefined;
+            actionRecordIds?: string[] | undefined;
+            actionResult?: "success" | "failure" | "pending" | undefined;
+            actionError?: string | undefined;
+            userId?: string | undefined;
+            metadata?: Record<string, any> | undefined;
+            parentOperationId?: string | undefined;
+            childOperationIds?: string[] | undefined;
+        }[]>;
+        currentIndex: import("vue").Ref<number, number>;
+        config: import("vue").Ref<{
+            maxOperations?: number | undefined;
+            enableCrossTabSync?: boolean | undefined;
+            autoSyncInterval?: number | undefined;
+            enablePersistence?: boolean | undefined;
+            persistenceKeyPrefix?: string | undefined;
+            userId?: string | undefined;
+            operationFilter?: ((operation: import("./types").HSTOperation) => boolean) | undefined;
+        }, OperationLogConfig | {
+            maxOperations?: number | undefined;
+            enableCrossTabSync?: boolean | undefined;
+            autoSyncInterval?: number | undefined;
+            enablePersistence?: boolean | undefined;
+            persistenceKeyPrefix?: string | undefined;
+            userId?: string | undefined;
+            operationFilter?: ((operation: import("./types").HSTOperation) => boolean) | undefined;
+        }>;
+        clientId: import("vue").Ref<string, string>;
+        undoRedoState: import("vue").ComputedRef<import("./types").UndoRedoState>;
+        canUndo: import("vue").ComputedRef<boolean>;
+        canRedo: import("vue").ComputedRef<boolean>;
+        undoCount: import("vue").ComputedRef<number>;
+        redoCount: import("vue").ComputedRef<number>;
+        configure: (options: Partial<OperationLogConfig>) => void;
+        addOperation: (operation: import("./types").HSTOperationInput, source?: import("./types").OperationSource) => string;
+        startBatch: () => void;
+        commitBatch: (description?: string) => string | null;
+        cancelBatch: () => void;
+        undo: (store: HSTNode) => boolean;
+        redo: (store: HSTNode) => boolean;
+        clear: () => void;
+        getOperationsFor: (doctype: string, recordId?: string) => import("./types").HSTOperation[];
+        getSnapshot: () => import("./types").OperationLogSnapshot;
+        markIrreversible: (operationId: string, reason: string) => void;
+        logAction: (doctype: string, actionName: string, recordIds?: string[], result?: "success" | "failure" | "pending", error?: string) => string;
+    }, "operations" | "clientId" | "currentIndex" | "config">, Pick<{
+        operations: import("vue").Ref<{
+            id: string;
+            type: import("./types").HSTOperationType;
+            path: string;
+            fieldname: string;
+            beforeValue: any;
+            afterValue: any;
+            doctype: string;
+            recordId?: string | undefined;
+            timestamp: Date;
+            source?: import("./types").OperationSource | undefined;
+            reversible: boolean;
+            irreversibleReason?: string | undefined;
+            transition?: string | undefined;
+            currentState?: string | undefined;
+            targetState?: string | undefined;
+            actionName?: string | undefined;
+            actionRecordIds?: string[] | undefined;
+            actionResult?: "success" | "failure" | "pending" | undefined;
+            actionError?: string | undefined;
+            userId?: string | undefined;
+            metadata?: Record<string, any> | undefined;
+            parentOperationId?: string | undefined;
+            childOperationIds?: string[] | undefined;
+        }[], import("./types").HSTOperation[] | {
+            id: string;
+            type: import("./types").HSTOperationType;
+            path: string;
+            fieldname: string;
+            beforeValue: any;
+            afterValue: any;
+            doctype: string;
+            recordId?: string | undefined;
+            timestamp: Date;
+            source?: import("./types").OperationSource | undefined;
+            reversible: boolean;
+            irreversibleReason?: string | undefined;
+            transition?: string | undefined;
+            currentState?: string | undefined;
+            targetState?: string | undefined;
+            actionName?: string | undefined;
+            actionRecordIds?: string[] | undefined;
+            actionResult?: "success" | "failure" | "pending" | undefined;
+            actionError?: string | undefined;
+            userId?: string | undefined;
+            metadata?: Record<string, any> | undefined;
+            parentOperationId?: string | undefined;
+            childOperationIds?: string[] | undefined;
+        }[]>;
+        currentIndex: import("vue").Ref<number, number>;
+        config: import("vue").Ref<{
+            maxOperations?: number | undefined;
+            enableCrossTabSync?: boolean | undefined;
+            autoSyncInterval?: number | undefined;
+            enablePersistence?: boolean | undefined;
+            persistenceKeyPrefix?: string | undefined;
+            userId?: string | undefined;
+            operationFilter?: ((operation: import("./types").HSTOperation) => boolean) | undefined;
+        }, OperationLogConfig | {
+            maxOperations?: number | undefined;
+            enableCrossTabSync?: boolean | undefined;
+            autoSyncInterval?: number | undefined;
+            enablePersistence?: boolean | undefined;
+            persistenceKeyPrefix?: string | undefined;
+            userId?: string | undefined;
+            operationFilter?: ((operation: import("./types").HSTOperation) => boolean) | undefined;
+        }>;
+        clientId: import("vue").Ref<string, string>;
+        undoRedoState: import("vue").ComputedRef<import("./types").UndoRedoState>;
+        canUndo: import("vue").ComputedRef<boolean>;
+        canRedo: import("vue").ComputedRef<boolean>;
+        undoCount: import("vue").ComputedRef<number>;
+        redoCount: import("vue").ComputedRef<number>;
+        configure: (options: Partial<OperationLogConfig>) => void;
+        addOperation: (operation: import("./types").HSTOperationInput, source?: import("./types").OperationSource) => string;
+        startBatch: () => void;
+        commitBatch: (description?: string) => string | null;
+        cancelBatch: () => void;
+        undo: (store: HSTNode) => boolean;
+        redo: (store: HSTNode) => boolean;
+        clear: () => void;
+        getOperationsFor: (doctype: string, recordId?: string) => import("./types").HSTOperation[];
+        getSnapshot: () => import("./types").OperationLogSnapshot;
+        markIrreversible: (operationId: string, reason: string) => void;
+        logAction: (doctype: string, actionName: string, recordIds?: string[], result?: "success" | "failure" | "pending", error?: string) => string;
+    }, "undoRedoState" | "canUndo" | "canRedo" | "undoCount" | "redoCount">, Pick<{
+        operations: import("vue").Ref<{
+            id: string;
+            type: import("./types").HSTOperationType;
+            path: string;
+            fieldname: string;
+            beforeValue: any;
+            afterValue: any;
+            doctype: string;
+            recordId?: string | undefined;
+            timestamp: Date;
+            source?: import("./types").OperationSource | undefined;
+            reversible: boolean;
+            irreversibleReason?: string | undefined;
+            transition?: string | undefined;
+            currentState?: string | undefined;
+            targetState?: string | undefined;
+            actionName?: string | undefined;
+            actionRecordIds?: string[] | undefined;
+            actionResult?: "success" | "failure" | "pending" | undefined;
+            actionError?: string | undefined;
+            userId?: string | undefined;
+            metadata?: Record<string, any> | undefined;
+            parentOperationId?: string | undefined;
+            childOperationIds?: string[] | undefined;
+        }[], import("./types").HSTOperation[] | {
+            id: string;
+            type: import("./types").HSTOperationType;
+            path: string;
+            fieldname: string;
+            beforeValue: any;
+            afterValue: any;
+            doctype: string;
+            recordId?: string | undefined;
+            timestamp: Date;
+            source?: import("./types").OperationSource | undefined;
+            reversible: boolean;
+            irreversibleReason?: string | undefined;
+            transition?: string | undefined;
+            currentState?: string | undefined;
+            targetState?: string | undefined;
+            actionName?: string | undefined;
+            actionRecordIds?: string[] | undefined;
+            actionResult?: "success" | "failure" | "pending" | undefined;
+            actionError?: string | undefined;
+            userId?: string | undefined;
+            metadata?: Record<string, any> | undefined;
+            parentOperationId?: string | undefined;
+            childOperationIds?: string[] | undefined;
+        }[]>;
+        currentIndex: import("vue").Ref<number, number>;
+        config: import("vue").Ref<{
+            maxOperations?: number | undefined;
+            enableCrossTabSync?: boolean | undefined;
+            autoSyncInterval?: number | undefined;
+            enablePersistence?: boolean | undefined;
+            persistenceKeyPrefix?: string | undefined;
+            userId?: string | undefined;
+            operationFilter?: ((operation: import("./types").HSTOperation) => boolean) | undefined;
+        }, OperationLogConfig | {
+            maxOperations?: number | undefined;
+            enableCrossTabSync?: boolean | undefined;
+            autoSyncInterval?: number | undefined;
+            enablePersistence?: boolean | undefined;
+            persistenceKeyPrefix?: string | undefined;
+            userId?: string | undefined;
+            operationFilter?: ((operation: import("./types").HSTOperation) => boolean) | undefined;
+        }>;
+        clientId: import("vue").Ref<string, string>;
+        undoRedoState: import("vue").ComputedRef<import("./types").UndoRedoState>;
+        canUndo: import("vue").ComputedRef<boolean>;
+        canRedo: import("vue").ComputedRef<boolean>;
+        undoCount: import("vue").ComputedRef<number>;
+        redoCount: import("vue").ComputedRef<number>;
+        configure: (options: Partial<OperationLogConfig>) => void;
+        addOperation: (operation: import("./types").HSTOperationInput, source?: import("./types").OperationSource) => string;
+        startBatch: () => void;
+        commitBatch: (description?: string) => string | null;
+        cancelBatch: () => void;
+        undo: (store: HSTNode) => boolean;
+        redo: (store: HSTNode) => boolean;
+        clear: () => void;
+        getOperationsFor: (doctype: string, recordId?: string) => import("./types").HSTOperation[];
+        getSnapshot: () => import("./types").OperationLogSnapshot;
+        markIrreversible: (operationId: string, reason: string) => void;
+        logAction: (doctype: string, actionName: string, recordIds?: string[], result?: "success" | "failure" | "pending", error?: string) => string;
+    }, "undo" | "redo" | "configure" | "addOperation" | "startBatch" | "commitBatch" | "cancelBatch" | "clear" | "getOperationsFor" | "getSnapshot" | "markIrreversible" | "logAction">>;
+    /**
+     * Initialize the HST store structure
+     */
+    private initializeHSTStore;
+    /**
+     * Setup automatic sync with Registry when doctypes are added
+     */
+    private setupRegistrySync;
+    /**
+     * Get records hash for a doctype
+     * @param doctype - The doctype to get records for
+     * @returns HST node containing records hash
+     */
+    records(doctype: string | DoctypeMeta): HSTNode;
+    /**
+     * Add a record to the store
+     * @param doctype - The doctype
+     * @param recordId - The record ID
+     * @param recordData - The record data
+     */
+    addRecord(doctype: string | DoctypeMeta, recordId: string, recordData: any): void;
+    /**
+     * Get a specific record
+     * @param doctype - The doctype
+     * @param recordId - The record ID
+     * @returns HST node for the record or undefined
+     */
+    getRecordById(doctype: string | DoctypeMeta, recordId: string): HSTNode | undefined;
     /**
-     * The Pinia store that manages the mutable records
+     * Remove a record from the store
+     * @param doctype - The doctype
+     * @param recordId - The record ID
      */
-    store: ReturnType<typeof useDataStore>;
+    removeRecord(doctype: string | DoctypeMeta, recordId: string): void;
     /**
-     * @param registry - The immutable registry
-     * @param store - The mutable Pinia store
-     * @returns The Stonecrop instance with the given registry and store. If a Stonecrop instance has already been created, it returns the existing instance instead of creating a new one.
-     * @example
-     * ```ts
-     * const registry = new Registry()
-     * const store = useDataStore()
-     * const stonecrop = new Stonecrop(registry, store)
-     * ```
+     * Get all record IDs for a doctype
+     * @param doctype - The doctype
+     * @returns Array of record IDs
      */
-    constructor(registry: Registry, store: ReturnType<typeof useDataStore>);
+    getRecordIds(doctype: string | DoctypeMeta): string[];
     /**
-     * Sets up the Stonecrop instance with the given doctype
+     * Clear all records for a doctype
+     * @param doctype - The doctype
+     */
+    clearRecords(doctype: string | DoctypeMeta): void;
+    /**
+     * Setup method for doctype initialization
      * @param doctype - The doctype to setup
-     * @example
-     * ```ts
-     * const doctype = await registry.getMeta('Task')
-     * stonecrop.setup(doctype)
-     * ```
      */
     setup(doctype: DoctypeMeta): void;
     /**
-     * Gets the meta for the given doctype
-     * @param doctype - The doctype to get meta for
-     * @returns The meta for the given doctype
-     * @throws `NotImplementedError` if the `getMeta` function is not implemented for the doctype in the registry
-     * @example
-     * ```ts
-     * const doctype = await registry.getMeta('Task')
-     * const meta = stonecrop.getMeta(doctype)
-     * ```
-     * @see {@link DoctypeMeta}
+     * 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)
      */
-    getMeta(doctype: string): Promise<DoctypeMeta> | never;
+    runAction(doctype: DoctypeMeta, action: string, args?: any[]): void;
     /**
-     * Gets the records for the given doctype
-     * @param doctype - The doctype to get records for
-     * @param filters - The filters to apply to the records
-     * @example
-     * ```ts
-     * const doctype = await registry.getMeta('Task')
-     * await stonecrop.getRecords(doctype)
-     * ```
-     * @example
-     * ```ts
-     * const doctype = await registry.getMeta('Task')
-     * const filters = JSON.stringify({ status: 'Open' })
-     * await stonecrop.getRecords(doctype, { body: filters })
-     * ```
-     */
-    getRecords(doctype: DoctypeMeta, filters?: RequestInit): Promise<void>;
-    /**
-     * Gets the record for the given doctype and id
-     * @param doctype - The doctype to get record for
-     * @param id - The id of the record to get
-     * @example
-     * ```ts
-     * const doctype = await registry.getMeta('Task')
-     * await stonecrop.getRecord(doctype, 'TASK-00001')
-     * ```
-     */
-    getRecord(doctype: DoctypeMeta, id: string): Promise<void>;
-    /**
-     * Runs the action for the given doctype and id
-     * @param doctype - The doctype to run action for
-     * @param action - The action to run
-     * @param id - The id(s) of the record(s) to run action on
-     * @example
-     * ```ts
-     * const doctype = await registry.getMeta('Task')
-     * stonecrop.runAction(doctype, 'create')
-     * ```
-     * @example
-     * ```ts
-     * const doctype = await registry.getMeta('Task')
-     * stonecrop.runAction(doctype, 'update', ['TASK-00001'])
-     * ```
-     * @example
-     * ```ts
-     * const doctype = await registry.getMeta('Task')
-     * stonecrop.runAction(doctype, 'delete', ['TASK-00001'])
-     * ```
-     * @example
-     * ```ts
-     * const doctype = await registry.getMeta('Task')
-     * stonecrop.runAction(doctype, 'merge', ['TASK-00001', 'TASK-00002'])
-     * ```
-     */
-    runAction(doctype: DoctypeMeta, action: string, id?: string[]): void;
+     * Get records from server (maintains compatibility)
+     * @param doctype - The doctype
+     */
+    getRecords(doctype: DoctypeMeta): Promise<void>;
+    /**
+     * Get single record from server (maintains compatibility)
+     * @param doctype - The doctype
+     * @param recordId - The record ID
+     */
+    getRecord(doctype: DoctypeMeta, recordId: string): Promise<void>;
+    /**
+     * Ensure doctype section exists in HST store
+     * @param slug - The doctype slug
+     */
+    private ensureDoctypeExists;
+    /**
+     * Get doctype metadata from the registry
+     * @param context - The route context
+     * @returns The doctype metadata
+     */
+    getMeta(context: RouteContext): Promise<any>;
+    /**
+     * Get the root HST store node for advanced usage
+     * @returns Root HST node
+     */
+    getStore(): HSTNode;
 }
 //# sourceMappingURL=stonecrop.d.ts.map

package/dist/src/stonecrop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stonecrop.d.ts","sourceRoot":"","sources":["../../src/stonecrop.ts"],"names":[],"mappings":"AAEA,OAAO,WAAW,MAAM,WAAW,CAAA;AAEnC,OAAO,QAAQ,MAAM,YAAY,CAAA;AACjC,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AAE5C;;;GAGG;AACH,qBAAa,SAAS;IACrB;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,SAAS,CAAA;IAEvB;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,eAAc;IAE3B;;;;;;;;;;;;;;;;;;OAkBG;IACH,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;IAE3B;;OAEG;IACH,KAAK,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,CAAA;IAEtC;;;;;;;;;;OAUG;gBACS,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC;IAStE;;;;;;;;OAQG;IACH,KAAK,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IAIjC;;;;;;;;;;;OAWG;IACG,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,GAAG,KAAK;IAO5D;;;;;;;;;;;;;;;OAeG;IACG,UAAU,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAO5E;;;;;;;;;OASG;IACG,SAAS,CAAC,OAAO,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAOhE;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,SAAS,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI;CA6BpE"}
+{"version":3,"file":"stonecrop.d.ts","sourceRoot":"","sources":["../../src/stonecrop.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,WAAW,CAAA;AACnC,OAAO,QAAQ,MAAM,YAAY,CAAA;AACjC,OAAO,EAAa,KAAK,OAAO,EAAE,MAAM,cAAc,CAAA;AAEtD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAA;AAC/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAEpD;;;GAGG;AACH,qBAAa,SAAS;IACrB,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,kBAAkB,CAAC,CAAyC;IACpE,OAAO,CAAC,mBAAmB,CAAC,CAA6B;IAEzD,+DAA+D;IAC/D,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;IAE3B;;;;OAIG;gBACS,QAAQ,EAAE,QAAQ,EAAE,kBAAkB,CAAC,EAAE,OAAO,CAAC,kBAAkB,CAAC;IAWhF;;;OAGG;IACH,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAUpB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAW1B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAgBzB;;;;OAIG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,GAAG,OAAO;IAM/C;;;;;OAKG;IACH,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,GAAG,IAAI;IASjF;;;;;OAKG;IACH,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAoBnF;;;;OAIG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAUnE;;;;OAIG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,GAAG,MAAM,EAAE;IAYrD;;;OAGG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI;IAWjD;;;OAGG;IACH,KAAK,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IAKjC;;;;;;OAMG;IACH,SAAS,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,EAAE,GAAG,IAAI;IAkCnE;;;OAGG;IACG,UAAU,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAYrD;;;;OAIG;IACG,SAAS,CAAC,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAQtE;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAM3B;;;;OAIG;IACG,OAAO,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,GAAG,CAAC;IAOlD;;;OAGG;IACH,QAAQ,IAAI,OAAO;CAGnB"}