@hamak/ui-remote-resource-impl 0.4.19

package/dist/middleware/entity-middleware.js

@@ -0,0 +1,221 @@
+import { EntityActionTypes, ResourceActionFactory, resourceAttributesUtil } from '@hamak/ui-remote-resource-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/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/middleware/entity-sync-middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-sync-middleware.d.ts","sourceRoot":"","sources":["../../src/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/middleware/entity-sync-middleware.js

@@ -0,0 +1,31 @@
+import { ResourceActionTypes, resourceAttributesUtil } from '@hamak/ui-remote-resource-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(store, action);
+        }
+        return result;
+    };
+}
+function handleEntityResourceSuccess(store, 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 } = action.payload;
+    // Create entity attributes
+    const entityAttrs = 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/middleware/resource-middleware.d.ts

@@ -0,0 +1,13 @@
+import type { Middleware } from 'redux';
+import { type ResourceAction } from '@hamak/ui-remote-resource-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/middleware/resource-middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource-middleware.d.ts","sourceRoot":"","sources":["../../src/middleware/resource-middleware.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AACxC,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,+BAA+B,CAAC;AAGvC,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/middleware/resource-middleware.js

@@ -0,0 +1,97 @@
+import { ResourceActionTypes, ResourceActionFactory } from '@hamak/ui-remote-resource-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/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/middleware/sync-middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-middleware.d.ts","sourceRoot":"","sources":["../../src/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/middleware/sync-middleware.js

@@ -0,0 +1,80 @@
+import { ResourceActionTypes } from '@hamak/ui-remote-resource-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 }));
+}

package/dist/plugin/resource-plugin-factory.d.ts

@@ -0,0 +1,31 @@
+import type { ResourcePluginConfig } from '@hamak/ui-remote-resource-spi';
+/**
+ * Microkernel plugin module interface
+ */
+export interface PluginModule {
+    initialize(ctx: InitializationContext): Promise<void>;
+    activate(ctx: ActivateContext): Promise<void>;
+    deactivate?(): Promise<void>;
+}
+interface InitializationContext {
+    provide(provider: any): void;
+    [key: string]: any;
+}
+interface ActivateContext {
+    resolve(token: any): any;
+    hooks: {
+        emit(event: string, data?: any): void;
+    };
+    [key: string]: any;
+}
+export declare const RESOURCE_REGISTRY_TOKEN = "RESOURCE_REGISTRY";
+export declare const ENTITY_REGISTRY_TOKEN = "ENTITY_REGISTRY";
+/**
+ * Create remote resource plugin
+ *
+ * @param config - Plugin configuration
+ * @returns Plugin module for microkernel registration
+ */
+export declare function createResourcePlugin(config?: ResourcePluginConfig): PluginModule;
+export {};
+//# sourceMappingURL=resource-plugin-factory.d.ts.map

package/dist/plugin/resource-plugin-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource-plugin-factory.d.ts","sourceRoot":"","sources":["../../src/plugin/resource-plugin-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAgB1E;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,UAAU,CAAC,GAAG,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtD,QAAQ,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9C,UAAU,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B;AAED,UAAU,qBAAqB;IAC7B,OAAO,CAAC,QAAQ,EAAE,GAAG,GAAG,IAAI,CAAC;IAC7B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,UAAU,eAAe;IACvB,OAAO,CAAC,KAAK,EAAE,GAAG,GAAG,GAAG,CAAC;IACzB,KAAK,EAAE;QACL,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC;KACvC,CAAC;IACF,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAGD,eAAO,MAAM,uBAAuB,sBAAsB,CAAC;AAC3D,eAAO,MAAM,qBAAqB,oBAAoB,CAAC;AAEvD;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,GAAE,oBAAyB,GAChC,YAAY,CAgId"}

package/dist/plugin/resource-plugin-factory.js

@@ -0,0 +1,131 @@
+import { MIDDLEWARE_REGISTRY_TOKEN } from '@hamak/ui-store-api';
+import { FILESYSTEM_ADAPTER_TOKEN } from '@hamak/ui-store-impl';
+import { ResourceRegistry } from '../registry/resource-registry';
+import { EntityRegistry } from '../registry/entity-registry';
+import { RestResourceProvider } from '../providers/rest-resource-provider';
+import { MockResourceProvider } from '../providers/mock-resource-provider';
+import { createResourceMiddleware } from '../middleware/resource-middleware';
+import { createSyncMiddleware } from '../middleware/sync-middleware';
+import { createEntityMiddleware } from '../middleware/entity-middleware';
+import { createEntitySyncMiddleware } from '../middleware/entity-sync-middleware';
+// Dependency injection tokens (for local use)
+export const RESOURCE_REGISTRY_TOKEN = 'RESOURCE_REGISTRY';
+export const ENTITY_REGISTRY_TOKEN = 'ENTITY_REGISTRY';
+/**
+ * Create remote resource plugin
+ *
+ * @param config - Plugin configuration
+ * @returns Plugin module for microkernel registration
+ */
+export function createResourcePlugin(config = {}) {
+    const resourceRegistry = new ResourceRegistry();
+    const entityRegistry = new EntityRegistry();
+    return {
+        async initialize(ctx) {
+            // Register default providers
+            const restProvider = new RestResourceProvider();
+            const mockProvider = new MockResourceProvider();
+            resourceRegistry.registerProvider(restProvider);
+            resourceRegistry.registerProvider(mockProvider);
+            // Register custom providers
+            if (config.providers) {
+                config.providers.forEach((provider) => {
+                    resourceRegistry.registerProvider(provider);
+                });
+            }
+            // Register endpoints
+            if (config.endpoints) {
+                config.endpoints.forEach((endpoint) => {
+                    resourceRegistry.registerEndpoint(endpoint);
+                });
+            }
+            // Register entities
+            if (config.entities) {
+                config.entities.forEach((entity) => {
+                    entityRegistry.registerEntity(entity);
+                });
+            }
+            // Provide registries via DI
+            ctx.provide({
+                provide: RESOURCE_REGISTRY_TOKEN,
+                useValue: resourceRegistry
+            });
+            ctx.provide({
+                provide: ENTITY_REGISTRY_TOKEN,
+                useValue: entityRegistry
+            });
+            // Register middleware during initialization
+            try {
+                // Access resolve method if available on context
+                const resolve = ctx.resolve;
+                if (resolve) {
+                    // Resolve FileSystemAdapter from DI
+                    const fsAdapter = resolve(FILESYSTEM_ADAPTER_TOKEN);
+                    if (!fsAdapter) {
+                        console.warn('[ui-remote-resource] FileSystemAdapter not available in DI');
+                        return;
+                    }
+                    const fsActions = fsAdapter.getActions();
+                    const fsSliceName = fsAdapter.sliceName;
+                    // Create middleware with FileSystemAdapter actions
+                    const entityMiddleware = createEntityMiddleware({
+                        entityRegistry,
+                        fsSliceName,
+                        onError: config.onError
+                    });
+                    const resourceMiddleware = createResourceMiddleware({
+                        registry: resourceRegistry,
+                        onError: config.onError,
+                        onSuccess: config.onSuccess
+                    });
+                    const entitySyncMiddleware = createEntitySyncMiddleware();
+                    const resourceSyncMiddleware = createSyncMiddleware({
+                        fsActions
+                    });
+                    const middlewareRegistry = resolve(MIDDLEWARE_REGISTRY_TOKEN);
+                    middlewareRegistry.register({
+                        id: 'entity-middleware',
+                        middleware: entityMiddleware,
+                        priority: 110,
+                        plugin: 'ui-remote-resource'
+                    });
+                    middlewareRegistry.register({
+                        id: 'resource-middleware',
+                        middleware: resourceMiddleware,
+                        priority: 100,
+                        plugin: 'ui-remote-resource'
+                    });
+                    middlewareRegistry.register({
+                        id: 'entity-sync-middleware',
+                        middleware: entitySyncMiddleware,
+                        priority: 60,
+                        plugin: 'ui-remote-resource'
+                    });
+                    middlewareRegistry.register({
+                        id: 'resource-sync-middleware',
+                        middleware: resourceSyncMiddleware,
+                        priority: 50,
+                        plugin: 'ui-remote-resource'
+                    });
+                }
+                else {
+                    console.warn('Resolve method not available in initialization context');
+                }
+            }
+            catch (error) {
+                console.warn('Failed to register middleware during initialization:', error);
+            }
+        },
+        async activate(ctx) {
+            // Emit ready event
+            ctx.hooks?.emit('ui-remote-resource:ready', {
+                resourceRegistry,
+                entityRegistry
+            });
+        },
+        async deactivate() {
+            // Cleanup if needed
+            // For now, no cleanup required
+        }
+    };
+}