@hamak/ui-remote-resource 0.5.1

package/dist/impl/autosave/resource-autosave-provider.js

@@ -0,0 +1,112 @@
+/**
+ * Resource Autosave Provider
+ *
+ * Implements autosave for files managed by the remote resource plugin.
+ * Uses UPDATE_ENTITY or RESOURCE_CALL_REQUEST actions to save files.
+ */
+import { REMOTE_RESOURCE_EXTENSION_KEY, } from '../../api';
+import { EntityActionFactory } from '../../api';
+import { ResourceActionFactory } from '../../api';
+/**
+ * Autosave provider for remote resources
+ *
+ * This provider handles autosave for files that are managed via the
+ * remote resource plugin. It checks for the presence of resource/entity
+ * extension state and uses appropriate actions to save changes.
+ */
+export class ResourceAutosaveProvider {
+    constructor(config = {}) {
+        Object.defineProperty(this, "id", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'remote-resource'
+        });
+        Object.defineProperty(this, "priority", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 20
+        }); // Higher priority than remote-fs
+        Object.defineProperty(this, "entityActionFactory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "resourceActionFactory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.entityActionFactory = config.entityActionFactory ?? new EntityActionFactory();
+        this.resourceActionFactory = config.resourceActionFactory ?? new ResourceActionFactory();
+    }
+    /**
+     * Check if this provider supports a given path.
+     * Returns true if the node has remote resource extension state.
+     */
+    supports(_path, node) {
+        const extensionState = node.state?.extensionStates?.[REMOTE_RESOURCE_EXTENSION_KEY];
+        return extensionState !== undefined;
+    }
+    /**
+     * Save file content to remote server.
+     * Dispatches UPDATE_ENTITY (if entity) or RESOURCE_CALL_REQUEST (if resource).
+     */
+    async save(path, content, node, dispatch) {
+        try {
+            const resourceAttrs = node.state?.extensionStates?.[REMOTE_RESOURCE_EXTENSION_KEY];
+            if (!resourceAttrs) {
+                return {
+                    success: false,
+                    error: {
+                        code: 'NO_RESOURCE_STATE',
+                        message: 'Node has no remote resource extension state',
+                    },
+                };
+            }
+            // Check if this is an entity
+            if (resourceAttrs.entity?.entityId) {
+                // Use entity update action
+                dispatch(this.entityActionFactory.update(resourceAttrs.entity.entityId, path, content));
+            }
+            else if (resourceAttrs.endpointId) {
+                // Use resource call request with update operation
+                dispatch(this.resourceActionFactory.callRequest(resourceAttrs.endpointId, 'update', { body: content }, path));
+            }
+            else {
+                return {
+                    success: false,
+                    error: {
+                        code: 'NO_ENDPOINT',
+                        message: 'Node has no entity or endpoint information',
+                    },
+                };
+            }
+            // Note: The actual HTTP request is async and handled by resource middleware.
+            // Success/failure will be tracked by the middleware dispatching
+            // RESOURCE_CALL_SUCCESS or RESOURCE_CALL_FAILURE actions.
+            return {
+                success: true,
+                timestamp: Date.now(),
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: {
+                    code: error.code ?? 'SAVE_ERROR',
+                    message: error.message ?? 'Failed to dispatch save action',
+                },
+            };
+        }
+    }
+    /**
+     * Cancel is a no-op for resources since we don't track in-flight requests here.
+     */
+    cancel(_path) {
+        // No-op: resource middleware handles request lifecycle
+    }
+}

package/dist/impl/index.d.ts

@@ -0,0 +1,20 @@
+export * from '../api';
+export * from '../spi';
+export { createResourcePlugin } from './plugin/resource-plugin-factory';
+export type { PluginModule } from './plugin/resource-plugin-factory';
+export { RESOURCE_REGISTRY_TOKEN, ENTITY_REGISTRY_TOKEN } from './plugin/resource-plugin-factory';
+export { STORE_MANAGER_TOKEN, MIDDLEWARE_REGISTRY_TOKEN, STORE_EXTENSIONS_TOKEN } from '@hamak/ui-store-api';
+export { RestResourceProvider } from './providers/rest-resource-provider';
+export type { RestProviderConfig } from './providers/rest-resource-provider';
+export { MockResourceProvider } from './providers/mock-resource-provider';
+export type { MockProviderConfig, EndpointMockConfig, MockConfigMap, MockCallHistoryEntry } from './providers/mock-resource-provider';
+export { ResourceRegistry } from './registry/resource-registry';
+export { EntityRegistry } from './registry/entity-registry';
+export { createResourceMiddleware } from './middleware/resource-middleware';
+export { createSyncMiddleware } from './middleware/sync-middleware';
+export { createEntityMiddleware } from './middleware/entity-middleware';
+export { createEntitySyncMiddleware } from './middleware/entity-sync-middleware';
+export type { FileSystemNodeActions } from '@hamak/ui-store-impl';
+export { ResourceAutosaveProvider } from './autosave/resource-autosave-provider';
+export type { ResourceAutosaveProviderConfig } from './autosave/resource-autosave-provider';
+//# sourceMappingURL=index.d.ts.map

package/dist/impl/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/impl/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AAGvB,OAAO,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AACxE,YAAY,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EACL,uBAAuB,EACvB,qBAAqB,EACtB,MAAM,kCAAkC,CAAC;AAG1C,OAAO,EACL,mBAAmB,EACnB,yBAAyB,EACzB,sBAAsB,EACvB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,YAAY,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAC7E,OAAO,EAAE,oBAAoB,EAAE,MAAM,oCAAoC,CAAC;AAC1E,YAAY,EACV,kBAAkB,EAClB,kBAAkB,EAClB,aAAa,EACb,oBAAoB,EACrB,MAAM,oCAAoC,CAAC;AAG5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAG5D,OAAO,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAC;AAC5E,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AACxE,OAAO,EAAE,0BAA0B,EAAE,MAAM,qCAAqC,CAAC;AAGjF,YAAY,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAGlE,OAAO,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACjF,YAAY,EAAE,8BAA8B,EAAE,MAAM,uCAAuC,CAAC"}

package/dist/impl/index.js

@@ -0,0 +1,20 @@
+export * from '../api';
+export * from '../spi';
+// Plugin factory (main export)
+export { createResourcePlugin } from './plugin/resource-plugin-factory';
+export { RESOURCE_REGISTRY_TOKEN, ENTITY_REGISTRY_TOKEN } from './plugin/resource-plugin-factory';
+// Re-export store tokens from ui-store-api for convenience
+export { STORE_MANAGER_TOKEN, MIDDLEWARE_REGISTRY_TOKEN, STORE_EXTENSIONS_TOKEN } from '@hamak/ui-store-api';
+// Built-in providers (exported for convenience and testing)
+export { RestResourceProvider } from './providers/rest-resource-provider';
+export { MockResourceProvider } from './providers/mock-resource-provider';
+// Registry implementations (internal, but exported for testing)
+export { ResourceRegistry } from './registry/resource-registry';
+export { EntityRegistry } from './registry/entity-registry';
+// Middleware factories (internal, but exported for advanced use cases)
+export { createResourceMiddleware } from './middleware/resource-middleware';
+export { createSyncMiddleware } from './middleware/sync-middleware';
+export { createEntityMiddleware } from './middleware/entity-middleware';
+export { createEntitySyncMiddleware } from './middleware/entity-sync-middleware';
+// Autosave provider
+export { ResourceAutosaveProvider } from './autosave/resource-autosave-provider';

package/dist/impl/middleware/entity-middleware.d.ts

@@ -0,0 +1,13 @@
+import type { Middleware } from 'redux';
+import { type EntityAction } from '../../api';
+export interface EntityMiddlewareConfig {
+    entityRegistry: any;
+    fsSliceName: string;
+    onError?: (error: any, action: EntityAction) => void;
+}
+/**
+ * Entity middleware
+ * Translates entity actions to resource actions
+ */
+export declare function createEntityMiddleware<S = any>(config: EntityMiddlewareConfig): Middleware<{}, S>;
+//# sourceMappingURL=entity-middleware.d.ts.map

package/dist/impl/middleware/entity-middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-middleware.d.ts","sourceRoot":"","sources":["../../../src/impl/middleware/entity-middleware.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AACxC,OAAO,EAGL,KAAK,YAAY,EAMlB,MAAM,WAAW,CAAC;AAGnB,MAAM,WAAW,sBAAsB;IACrC,cAAc,EAAE,GAAG,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,YAAY,KAAK,IAAI,CAAC;CACtD;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,GAAG,GAAG,EAC5C,MAAM,EAAE,sBAAsB,GAC7B,UAAU,CAAC,EAAE,EAAE,CAAC,CAAC,CAgCnB"}

package/dist/impl/middleware/entity-middleware.js

@@ -0,0 +1,221 @@
+import { EntityActionTypes, ResourceActionFactory, resourceAttributesUtil } from '../../api';
+/**
+ * Entity middleware
+ * Translates entity actions to resource actions
+ */
+export function createEntityMiddleware(config) {
+    const { entityRegistry, fsSliceName, onError } = config;
+    const resourceActionFactory = new ResourceActionFactory();
+    return (store) => (next) => (action) => {
+        // Only handle entity actions
+        if (!isEntityAction(action)) {
+            return next(action);
+        }
+        // Pass through for tracking
+        next(action);
+        const entityAction = action;
+        try {
+            // Translate entity action to resource action
+            const resourceAction = translateEntityAction(entityAction, entityRegistry, resourceActionFactory, store.getState(), fsSliceName);
+            // Dispatch resource action
+            store.dispatch(resourceAction);
+        }
+        catch (error) {
+            onError?.(error, entityAction);
+            console.error('Entity middleware error:', error);
+        }
+    };
+}
+function isEntityAction(action) {
+    return [
+        EntityActionTypes.FETCH_ENTITY,
+        EntityActionTypes.UPDATE_ENTITY,
+        EntityActionTypes.DELETE_ENTITY,
+        EntityActionTypes.CREATE_ENTITY
+    ].includes(action.type);
+}
+function translateEntityAction(entityAction, entityRegistry, resourceActionFactory, state, fsSliceName) {
+    const { entityId } = entityAction.payload;
+    // Get entity definition
+    const entityDef = entityRegistry.getEntity(entityId);
+    if (!entityDef) {
+        throw new Error(`Entity not found: ${entityId}`);
+    }
+    switch (entityAction.type) {
+        case EntityActionTypes.FETCH_ENTITY:
+            return handleFetchEntity(entityAction, entityDef, resourceActionFactory);
+        case EntityActionTypes.UPDATE_ENTITY:
+            return handleUpdateEntity(entityAction, entityDef, resourceActionFactory, state, fsSliceName);
+        case EntityActionTypes.DELETE_ENTITY:
+            return handleDeleteEntity(entityAction, entityDef, resourceActionFactory, state, fsSliceName);
+        case EntityActionTypes.CREATE_ENTITY:
+            return handleCreateEntity(entityAction, entityDef, resourceActionFactory);
+        default:
+            throw new Error(`Unknown entity action type: ${entityAction.type}`);
+    }
+}
+/**
+ * Handle FETCH_ENTITY: keys provided, generate path and params
+ */
+function handleFetchEntity(action, entityDef, resourceActionFactory) {
+    const { keys, params, path } = action.payload;
+    // Validate keys
+    validateKeys(keys, entityDef.keySchema);
+    // Generate path from keys (if not explicitly provided)
+    const targetPath = path || generatePath(keys, entityDef);
+    // Map keys to resource params
+    const resourceParams = entityDef.keyMapper(keys, 'fetch');
+    // Merge with additional params
+    const mergedParams = {
+        ...resourceParams.params,
+        ...params,
+        // Store entity context for entity sync middleware
+        _entityContext: {
+            entityId: entityDef.id,
+            keys,
+            keyFields: entityDef.keySchema.fields
+        }
+    };
+    return resourceActionFactory.callRequest(entityDef.resourceEndpointId, 'fetch', mergedParams, targetPath, action.id);
+}
+/**
+ * Handle UPDATE_ENTITY: path provided, read keys from file attributes
+ */
+function handleUpdateEntity(action, entityDef, resourceActionFactory, state, fsSliceName) {
+    const { path, data, params } = action.payload;
+    // Read file node
+    const fileNode = selectFileNode(state, path, fsSliceName);
+    if (!fileNode) {
+        throw new Error(`Entity not found at path: ${JSON.stringify(path)}`);
+    }
+    // Get entity keys from extension state
+    const keys = resourceAttributesUtil.getEntityKeys(fileNode);
+    if (!keys) {
+        throw new Error(`Entity keys not found in file attributes at: ${JSON.stringify(path)}`);
+    }
+    // Validate keys
+    validateKeys(keys, entityDef.keySchema);
+    // Map keys to resource params
+    const resourceParams = entityDef.keyMapper(keys, 'update');
+    // Merge with body data and additional params
+    const mergedParams = {
+        ...resourceParams.params,
+        ...params,
+        body: data,
+        _entityContext: {
+            entityId: entityDef.id,
+            keys,
+            keyFields: entityDef.keySchema.fields
+        }
+    };
+    return resourceActionFactory.callRequest(entityDef.resourceEndpointId, 'update', mergedParams, path, action.id);
+}
+/**
+ * Handle DELETE_ENTITY: path provided, read keys from file attributes
+ */
+function handleDeleteEntity(action, entityDef, resourceActionFactory, state, fsSliceName) {
+    const { path, params } = action.payload;
+    // Read file node
+    const fileNode = selectFileNode(state, path, fsSliceName);
+    if (!fileNode) {
+        throw new Error(`Entity not found at path: ${JSON.stringify(path)}`);
+    }
+    // Get entity keys from extension state
+    const keys = resourceAttributesUtil.getEntityKeys(fileNode);
+    if (!keys) {
+        throw new Error(`Entity keys not found in file attributes at: ${JSON.stringify(path)}`);
+    }
+    // Validate keys
+    validateKeys(keys, entityDef.keySchema);
+    // Map keys to resource params
+    const resourceParams = entityDef.keyMapper(keys, 'delete');
+    // Merge with additional params
+    const mergedParams = {
+        ...resourceParams.params,
+        ...params,
+        _entityContext: {
+            entityId: entityDef.id,
+            keys,
+            keyFields: entityDef.keySchema.fields
+        }
+    };
+    return resourceActionFactory.callRequest(entityDef.resourceEndpointId, 'delete', mergedParams, path, action.id);
+}
+/**
+ * Handle CREATE_ENTITY: keys optional (may be generated by server)
+ */
+function handleCreateEntity(action, entityDef, resourceActionFactory) {
+    const { keys, data, path, params } = action.payload;
+    // Keys are optional for create (server may generate ID)
+    let targetPath = path;
+    let resourceParams;
+    if (keys) {
+        validateKeys(keys, entityDef.keySchema, true); // Partial validation
+        targetPath = path || generatePath(keys, entityDef);
+        resourceParams = entityDef.keyMapper(keys, 'create');
+    }
+    else {
+        resourceParams = { params: {} };
+    }
+    // Merge with body data and additional params
+    const mergedParams = {
+        ...resourceParams.params,
+        ...params,
+        body: data,
+        _entityContext: keys
+            ? {
+                entityId: entityDef.id,
+                keys,
+                keyFields: entityDef.keySchema.fields
+            }
+            : undefined
+    };
+    return resourceActionFactory.callRequest(entityDef.resourceEndpointId, 'create', mergedParams, targetPath, action.id);
+}
+/**
+ * Validate entity keys against schema
+ */
+function validateKeys(keys, schema, partial = false) {
+    if (!partial) {
+        for (const field of schema.fields) {
+            if (!(field in keys) || keys[field] === undefined || keys[field] === null) {
+                throw new Error(`Missing required key field: ${field}`);
+            }
+        }
+    }
+    if (schema.validate) {
+        const result = schema.validate(keys);
+        if (result !== true) {
+            throw new Error(typeof result === 'string' ? result : 'Invalid entity keys');
+        }
+    }
+}
+/**
+ * Generate file path from entity keys
+ */
+function generatePath(keys, entityDef) {
+    if (entityDef.pathGenerator) {
+        const result = entityDef.pathGenerator(keys, entityDef.id);
+        return Array.isArray(result) ? result : [result];
+    }
+    // Default path generator: ['entities', entityId, ...keyValues]
+    const keyValues = entityDef.keySchema.fields.map((field) => String(keys[field]));
+    return ['entities', entityDef.id, ...keyValues];
+}
+/**
+ * Select file node from state
+ */
+function selectFileNode(state, path, fsSliceName) {
+    const fsState = state[fsSliceName];
+    if (!fsState?.root)
+        return undefined;
+    const pathArray = Array.isArray(path) ? path : [path];
+    let currentNode = fsState.root;
+    for (const segment of pathArray) {
+        if (!currentNode || currentNode.type !== 'directory') {
+            return undefined;
+        }
+        currentNode = currentNode.children?.[segment];
+    }
+    return currentNode;
+}

package/dist/impl/middleware/entity-sync-middleware.d.ts

@@ -0,0 +1,7 @@
+import type { Middleware } from 'redux';
+/**
+ * Entity sync middleware
+ * Stores entity keys in extension state when resource calls succeed
+ */
+export declare function createEntitySyncMiddleware<S = any>(): Middleware<{}, S>;
+//# sourceMappingURL=entity-sync-middleware.d.ts.map

package/dist/impl/middleware/entity-sync-middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-sync-middleware.d.ts","sourceRoot":"","sources":["../../../src/impl/middleware/entity-sync-middleware.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AAOxC;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,GAAG,GAAG,KAAK,UAAU,CAAC,EAAE,EAAE,CAAC,CAAC,CAWvE"}

package/dist/impl/middleware/entity-sync-middleware.js

@@ -0,0 +1,32 @@
+import { ResourceActionTypes, resourceAttributesUtil } from '../../api';
+/**
+ * Entity sync middleware
+ * Stores entity keys in extension state when resource calls succeed
+ */
+export function createEntitySyncMiddleware() {
+    return (_store) => (next) => (action) => {
+        const result = next(action);
+        // Listen for resource success actions that originated from entity actions
+        if (action.type === ResourceActionTypes.RESOURCE_CALL_SUCCESS) {
+            handleEntityResourceSuccess(action);
+        }
+        return result;
+    };
+}
+function handleEntityResourceSuccess(action) {
+    const { request } = action;
+    // Check if this resource action originated from an entity action
+    const entityContext = request.payload.params?._entityContext;
+    if (!entityContext) {
+        return; // Not an entity-originated action
+    }
+    const { entityId, keys, keyFields } = entityContext;
+    const { path: _path } = action.payload;
+    // Create entity attributes
+    // Entity attributes - reserved for future use when metadata support is added
+    void resourceAttributesUtil.createEntityAttributes(entityId, keys, keyFields);
+    // TODO: Entity attributes are no longer stored in file extension state
+    // The FileSystemAdapter doesn't support updating extension states directly
+    // Entity information is now tracked through the file content itself
+    // Future: Consider adding entity metadata support to FileSystemAdapter
+}

package/dist/impl/middleware/resource-middleware.d.ts

@@ -0,0 +1,13 @@
+import type { Middleware } from 'redux';
+import { type ResourceAction } from '../../api';
+export interface ResourceMiddlewareConfig {
+    registry: any;
+    onError?: (error: any, action: ResourceAction) => void;
+    onSuccess?: (result: any, action: ResourceAction) => void;
+}
+/**
+ * Resource middleware
+ * Intercepts RESOURCE_CALL_REQUEST actions and executes API calls via providers
+ */
+export declare function createResourceMiddleware<S = any>(config: ResourceMiddlewareConfig): Middleware<{}, S>;
+//# sourceMappingURL=resource-middleware.d.ts.map

package/dist/impl/middleware/resource-middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource-middleware.d.ts","sourceRoot":"","sources":["../../../src/impl/middleware/resource-middleware.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AACxC,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,WAAW,CAAC;AAGnB,MAAM,WAAW,wBAAwB;IACvC,QAAQ,EAAE,GAAG,CAAC;IACd,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,cAAc,KAAK,IAAI,CAAC;IACvD,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,cAAc,KAAK,IAAI,CAAC;CAC3D;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,GAAG,GAAG,EAC9C,MAAM,EAAE,wBAAwB,GAC/B,UAAU,CAAC,EAAE,EAAE,CAAC,CAAC,CA6EnB"}

package/dist/impl/middleware/resource-middleware.js

@@ -0,0 +1,97 @@
+import { ResourceActionTypes, ResourceActionFactory } from '../../api';
+/**
+ * Resource middleware
+ * Intercepts RESOURCE_CALL_REQUEST actions and executes API calls via providers
+ */
+export function createResourceMiddleware(config) {
+    const { registry, onError, onSuccess } = config;
+    const actionFactory = new ResourceActionFactory();
+    return (store) => (next) => async (action) => {
+        // Only handle RESOURCE_CALL_REQUEST actions
+        if (action.type !== ResourceActionTypes.RESOURCE_CALL_REQUEST) {
+            return next(action);
+        }
+        // Continue action flow (for sync middleware to set loading state)
+        next(action);
+        const requestAction = action;
+        const { endpointId, operation, params, path } = requestAction.payload;
+        try {
+            // Lookup endpoint
+            const endpointDef = registry.getEndpoint(endpointId);
+            if (!endpointDef) {
+                throw new Error(`Endpoint not found: ${endpointId}`);
+            }
+            // Get provider
+            const provider = registry.getProvider(endpointDef.providerType);
+            if (!provider) {
+                throw new Error(`Provider not found: ${endpointDef.providerType}`);
+            }
+            // Map action to call params (mapper receives entire action)
+            const callParams = endpointDef.payloadMapper
+                ? endpointDef.payloadMapper(requestAction)
+                : { params }; // Default: just use params
+            // Execute provider call
+            const result = await provider.call(endpointDef.endpoint, callParams, operation);
+            // Transform response (transformer receives entire action)
+            const transformedData = endpointDef.responseTransformer
+                ? endpointDef.responseTransformer(result.data, result.metadata, requestAction)
+                : result.data;
+            // Determine storage path
+            const storagePath = determinePath(path, endpointDef, params, operation);
+            // Dispatch success action
+            const successAction = actionFactory.callSuccess(endpointId, storagePath, transformedData, result.metadata, requestAction);
+            store.dispatch(successAction);
+            onSuccess?.(result, requestAction);
+        }
+        catch (error) {
+            // Determine storage path for error state
+            const endpointDef = registry.getEndpoint(endpointId);
+            const storagePath = determinePath(path, endpointDef, params, operation);
+            // Dispatch failure action
+            const failureAction = actionFactory.callFailure(endpointId, storagePath, normalizeError(error), requestAction);
+            store.dispatch(failureAction);
+            onError?.(error, requestAction);
+        }
+    };
+}
+/**
+ * Determine the file path where resource should be stored
+ */
+function determinePath(explicitPath, endpointDef, params, operation) {
+    // 1. Use explicit path from action if provided
+    if (explicitPath) {
+        return explicitPath;
+    }
+    // 2. Use endpoint's default folder + generate filename
+    if (endpointDef?.defaultFolder) {
+        const folder = Array.isArray(endpointDef.defaultFolder)
+            ? endpointDef.defaultFolder
+            : [endpointDef.defaultFolder];
+        // Generate filename from params or operation
+        const filename = generateFilename(params, operation);
+        return [...folder, filename];
+    }
+    // 3. Fallback to root with generated filename
+    return [generateFilename(params, operation)];
+}
+/**
+ * Generate filename from params or operation
+ */
+function generateFilename(params, operation) {
+    // If params has an id field, use it
+    if (params?.id) {
+        return String(params.id);
+    }
+    // Otherwise generate based on operation + timestamp
+    return `${operation}-${Date.now()}`;
+}
+/**
+ * Normalize error to consistent format
+ */
+function normalizeError(error) {
+    return {
+        message: error.message || 'Unknown error',
+        code: error.code || error.response?.status?.toString(),
+        details: error.response?.data || error
+    };
+}

package/dist/impl/middleware/sync-middleware.d.ts

@@ -0,0 +1,12 @@
+import type { Middleware } from 'redux';
+import type { FileSystemNodeActions } from '@hamak/ui-store-impl';
+export interface SyncMiddlewareConfig {
+    /** FileSystem actions from FileSystemAdapter */
+    fsActions: FileSystemNodeActions;
+}
+/**
+ * Sync middleware
+ * Updates file system state when resource actions complete
+ */
+export declare function createSyncMiddleware<S = any>(config: SyncMiddlewareConfig): Middleware<{}, S>;
+//# sourceMappingURL=sync-middleware.d.ts.map

package/dist/impl/middleware/sync-middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-middleware.d.ts","sourceRoot":"","sources":["../../../src/impl/middleware/sync-middleware.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AAOxC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAGlE,MAAM,WAAW,oBAAoB;IACnC,gDAAgD;IAChD,SAAS,EAAE,qBAAqB,CAAC;CAClC;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,GAAG,GAAG,EAC1C,MAAM,EAAE,oBAAoB,GAC3B,UAAU,CAAC,EAAE,EAAE,CAAC,CAAC,CAwBnB"}

package/dist/impl/middleware/sync-middleware.js

@@ -0,0 +1,80 @@
+import { ResourceActionTypes } from '../../api';
+import { Pathway } from '@hamak/navigation-utils';
+/**
+ * Sync middleware
+ * Updates file system state when resource actions complete
+ */
+export function createSyncMiddleware(config) {
+    const { fsActions } = config;
+    return (store) => (next) => (action) => {
+        // Pass through all actions first
+        const result = next(action);
+        // Handle request action (set loading state)
+        if (action.type === ResourceActionTypes.RESOURCE_CALL_REQUEST) {
+            handleRequestAction(store, action, fsActions);
+        }
+        // Handle success action (update content)
+        if (action.type === ResourceActionTypes.RESOURCE_CALL_SUCCESS) {
+            handleSuccessAction(store, action, fsActions);
+        }
+        // Handle failure action (set error state)
+        if (action.type === ResourceActionTypes.RESOURCE_CALL_FAILURE) {
+            handleFailureAction(store, action, fsActions);
+        }
+        return result;
+    };
+}
+function handleRequestAction(store, action, fsActions) {
+    const { path } = action.payload;
+    if (!path) {
+        // Loading state will be set when success/failure with resolved path
+        return;
+    }
+    // Normalize path using Pathway utility
+    const pathway = Pathway.of(path);
+    const parentPathway = pathway.getParent();
+    const parentSegments = parentPathway.getSegments();
+    // Ensure parent directory exists
+    if (parentSegments.length > 0) {
+        store.dispatch(fsActions.mkdir(parentSegments, true));
+    }
+    // Set loading state by creating file node with contentIsPresent=false
+    store.dispatch(fsActions.setFile(path, null, 'xs:any', { override: false, contentIsPresent: false }));
+}
+function handleSuccessAction(store, action, fsActions) {
+    const { path, data } = action.payload;
+    const { request } = action;
+    // Normalize path using Pathway utility
+    const pathway = Pathway.of(path);
+    const parentPathway = pathway.getParent();
+    const parentSegments = parentPathway.getSegments();
+    // Ensure parent directory exists
+    if (parentSegments.length > 0) {
+        store.dispatch(fsActions.mkdir(parentSegments, true));
+    }
+    // Set file content from remote (automatically sets contentLoaded=true and clears loading)
+    // Schema should come from endpoint definition if available
+    const schema = request.meta?.schema || 'xs:any';
+    // First ensure file exists with proper schema
+    store.dispatch(fsActions.setFile(path, data, schema, { override: true, contentIsPresent: true }));
+    // Then set content from remote to mark it as loaded from remote source
+    store.dispatch(fsActions.setFileContent(path, data, true));
+}
+function handleFailureAction(store, action, fsActions) {
+    const { path, error } = action.payload;
+    if (!path) {
+        return;
+    }
+    // Normalize path using Pathway utility
+    const pathway = Pathway.of(path);
+    const parentPathway = pathway.getParent();
+    const parentSegments = parentPathway.getSegments();
+    // Ensure parent directory exists
+    if (parentSegments.length > 0) {
+        store.dispatch(fsActions.mkdir(parentSegments, true));
+    }
+    // For now, just ensure the file exists and set content to null/error placeholder
+    // TODO: FileSystemAdapter doesn't currently support setting error state directly
+    // We might need to extend it or handle errors differently
+    store.dispatch(fsActions.setFile(path, { error }, 'xs:any', { override: true, contentIsPresent: true }));
+}