@hamak/ui-remote-resource-impl 0.4.19

package/dist/es2015/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEntitySyncMiddleware = exports.createEntityMiddleware = exports.createSyncMiddleware = exports.createResourceMiddleware = exports.EntityRegistry = exports.ResourceRegistry = exports.MockResourceProvider = exports.RestResourceProvider = exports.STORE_EXTENSIONS_TOKEN = exports.MIDDLEWARE_REGISTRY_TOKEN = exports.STORE_MANAGER_TOKEN = exports.ENTITY_REGISTRY_TOKEN = exports.RESOURCE_REGISTRY_TOKEN = exports.createResourcePlugin = void 0;
+// Plugin factory (main export)
+var resource_plugin_factory_1 = require("./plugin/resource-plugin-factory");
+Object.defineProperty(exports, "createResourcePlugin", { enumerable: true, get: function () { return resource_plugin_factory_1.createResourcePlugin; } });
+var resource_plugin_factory_2 = require("./plugin/resource-plugin-factory");
+Object.defineProperty(exports, "RESOURCE_REGISTRY_TOKEN", { enumerable: true, get: function () { return resource_plugin_factory_2.RESOURCE_REGISTRY_TOKEN; } });
+Object.defineProperty(exports, "ENTITY_REGISTRY_TOKEN", { enumerable: true, get: function () { return resource_plugin_factory_2.ENTITY_REGISTRY_TOKEN; } });
+// Re-export store tokens from ui-store-api for convenience
+var ui_store_api_1 = require("@hamak/ui-store-api");
+Object.defineProperty(exports, "STORE_MANAGER_TOKEN", { enumerable: true, get: function () { return ui_store_api_1.STORE_MANAGER_TOKEN; } });
+Object.defineProperty(exports, "MIDDLEWARE_REGISTRY_TOKEN", { enumerable: true, get: function () { return ui_store_api_1.MIDDLEWARE_REGISTRY_TOKEN; } });
+Object.defineProperty(exports, "STORE_EXTENSIONS_TOKEN", { enumerable: true, get: function () { return ui_store_api_1.STORE_EXTENSIONS_TOKEN; } });
+// Built-in providers (exported for convenience and testing)
+var rest_resource_provider_1 = require("./providers/rest-resource-provider");
+Object.defineProperty(exports, "RestResourceProvider", { enumerable: true, get: function () { return rest_resource_provider_1.RestResourceProvider; } });
+var mock_resource_provider_1 = require("./providers/mock-resource-provider");
+Object.defineProperty(exports, "MockResourceProvider", { enumerable: true, get: function () { return mock_resource_provider_1.MockResourceProvider; } });
+// Registry implementations (internal, but exported for testing)
+var resource_registry_1 = require("./registry/resource-registry");
+Object.defineProperty(exports, "ResourceRegistry", { enumerable: true, get: function () { return resource_registry_1.ResourceRegistry; } });
+var entity_registry_1 = require("./registry/entity-registry");
+Object.defineProperty(exports, "EntityRegistry", { enumerable: true, get: function () { return entity_registry_1.EntityRegistry; } });
+// Middleware factories (internal, but exported for advanced use cases)
+var resource_middleware_1 = require("./middleware/resource-middleware");
+Object.defineProperty(exports, "createResourceMiddleware", { enumerable: true, get: function () { return resource_middleware_1.createResourceMiddleware; } });
+var sync_middleware_1 = require("./middleware/sync-middleware");
+Object.defineProperty(exports, "createSyncMiddleware", { enumerable: true, get: function () { return sync_middleware_1.createSyncMiddleware; } });
+var entity_middleware_1 = require("./middleware/entity-middleware");
+Object.defineProperty(exports, "createEntityMiddleware", { enumerable: true, get: function () { return entity_middleware_1.createEntityMiddleware; } });
+var entity_sync_middleware_1 = require("./middleware/entity-sync-middleware");
+Object.defineProperty(exports, "createEntitySyncMiddleware", { enumerable: true, get: function () { return entity_sync_middleware_1.createEntitySyncMiddleware; } });

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

@@ -0,0 +1,209 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEntityMiddleware = void 0;
+const ui_remote_resource_api_1 = require("@hamak/ui-remote-resource-api");
+/**
+ * Entity middleware
+ * Translates entity actions to resource actions
+ */
+function createEntityMiddleware(config) {
+    const { entityRegistry, fsSliceName, onError } = config;
+    const resourceActionFactory = new ui_remote_resource_api_1.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 === null || onError === void 0 ? void 0 : onError(error, entityAction);
+            console.error('Entity middleware error:', error);
+        }
+    };
+}
+exports.createEntityMiddleware = createEntityMiddleware;
+function isEntityAction(action) {
+    return [
+        ui_remote_resource_api_1.EntityActionTypes.FETCH_ENTITY,
+        ui_remote_resource_api_1.EntityActionTypes.UPDATE_ENTITY,
+        ui_remote_resource_api_1.EntityActionTypes.DELETE_ENTITY,
+        ui_remote_resource_api_1.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 ui_remote_resource_api_1.EntityActionTypes.FETCH_ENTITY:
+            return handleFetchEntity(entityAction, entityDef, resourceActionFactory);
+        case ui_remote_resource_api_1.EntityActionTypes.UPDATE_ENTITY:
+            return handleUpdateEntity(entityAction, entityDef, resourceActionFactory, state, fsSliceName);
+        case ui_remote_resource_api_1.EntityActionTypes.DELETE_ENTITY:
+            return handleDeleteEntity(entityAction, entityDef, resourceActionFactory, state, fsSliceName);
+        case ui_remote_resource_api_1.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 = Object.assign(Object.assign(Object.assign({}, 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 = ui_remote_resource_api_1.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 = Object.assign(Object.assign(Object.assign({}, 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 = ui_remote_resource_api_1.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 = Object.assign(Object.assign(Object.assign({}, 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 = Object.assign(Object.assign(Object.assign({}, 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) {
+    var _a;
+    const fsState = state[fsSliceName];
+    if (!(fsState === null || fsState === void 0 ? void 0 : 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 = (_a = currentNode.children) === null || _a === void 0 ? void 0 : _a[segment];
+    }
+    return currentNode;
+}

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEntitySyncMiddleware = void 0;
+const ui_remote_resource_api_1 = require("@hamak/ui-remote-resource-api");
+/**
+ * Entity sync middleware
+ * Stores entity keys in extension state when resource calls succeed
+ */
+function createEntitySyncMiddleware() {
+    return (store) => (next) => (action) => {
+        const result = next(action);
+        // Listen for resource success actions that originated from entity actions
+        if (action.type === ui_remote_resource_api_1.ResourceActionTypes.RESOURCE_CALL_SUCCESS) {
+            handleEntityResourceSuccess(store, action);
+        }
+        return result;
+    };
+}
+exports.createEntitySyncMiddleware = createEntitySyncMiddleware;
+function handleEntityResourceSuccess(store, action) {
+    var _a;
+    const { request } = action;
+    // Check if this resource action originated from an entity action
+    const entityContext = (_a = request.payload.params) === null || _a === void 0 ? void 0 : _a._entityContext;
+    if (!entityContext) {
+        return; // Not an entity-originated action
+    }
+    const { entityId, keys, keyFields } = entityContext;
+    const { path } = action.payload;
+    // Create entity attributes
+    const entityAttrs = ui_remote_resource_api_1.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/es2015/middleware/resource-middleware.js

@@ -0,0 +1,111 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createResourceMiddleware = void 0;
+const ui_remote_resource_api_1 = require("@hamak/ui-remote-resource-api");
+/**
+ * Resource middleware
+ * Intercepts RESOURCE_CALL_REQUEST actions and executes API calls via providers
+ */
+function createResourceMiddleware(config) {
+    const { registry, onError, onSuccess } = config;
+    const actionFactory = new ui_remote_resource_api_1.ResourceActionFactory();
+    return (store) => (next) => (action) => __awaiter(this, void 0, void 0, function* () {
+        // Only handle RESOURCE_CALL_REQUEST actions
+        if (action.type !== ui_remote_resource_api_1.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 = yield 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 === null || onSuccess === void 0 ? void 0 : 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 === null || onError === void 0 ? void 0 : onError(error, requestAction);
+        }
+    });
+}
+exports.createResourceMiddleware = createResourceMiddleware;
+/**
+ * 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 === null || endpointDef === void 0 ? void 0 : 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 === null || params === void 0 ? void 0 : params.id) {
+        return String(params.id);
+    }
+    // Otherwise generate based on operation + timestamp
+    return `${operation}-${Date.now()}`;
+}
+/**
+ * Normalize error to consistent format
+ */
+function normalizeError(error) {
+    var _a, _b, _c;
+    return {
+        message: error.message || 'Unknown error',
+        code: error.code || ((_b = (_a = error.response) === null || _a === void 0 ? void 0 : _a.status) === null || _b === void 0 ? void 0 : _b.toString()),
+        details: ((_c = error.response) === null || _c === void 0 ? void 0 : _c.data) || error
+    };
+}

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

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSyncMiddleware = void 0;
+const ui_remote_resource_api_1 = require("@hamak/ui-remote-resource-api");
+const navigation_utils_1 = require("@hamak/navigation-utils");
+/**
+ * Sync middleware
+ * Updates file system state when resource actions complete
+ */
+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 === ui_remote_resource_api_1.ResourceActionTypes.RESOURCE_CALL_REQUEST) {
+            handleRequestAction(store, action, fsActions);
+        }
+        // Handle success action (update content)
+        if (action.type === ui_remote_resource_api_1.ResourceActionTypes.RESOURCE_CALL_SUCCESS) {
+            handleSuccessAction(store, action, fsActions);
+        }
+        // Handle failure action (set error state)
+        if (action.type === ui_remote_resource_api_1.ResourceActionTypes.RESOURCE_CALL_FAILURE) {
+            handleFailureAction(store, action, fsActions);
+        }
+        return result;
+    };
+}
+exports.createSyncMiddleware = createSyncMiddleware;
+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 = navigation_utils_1.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) {
+    var _a;
+    const { path, data } = action.payload;
+    const { request } = action;
+    // Normalize path using Pathway utility
+    const pathway = navigation_utils_1.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 = ((_a = request.meta) === null || _a === void 0 ? void 0 : _a.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 = navigation_utils_1.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/es2015/plugin/resource-plugin-factory.js

@@ -0,0 +1,151 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createResourcePlugin = exports.ENTITY_REGISTRY_TOKEN = exports.RESOURCE_REGISTRY_TOKEN = void 0;
+const ui_store_api_1 = require("@hamak/ui-store-api");
+const ui_store_impl_1 = require("@hamak/ui-store-impl");
+const resource_registry_1 = require("../registry/resource-registry");
+const entity_registry_1 = require("../registry/entity-registry");
+const rest_resource_provider_1 = require("../providers/rest-resource-provider");
+const mock_resource_provider_1 = require("../providers/mock-resource-provider");
+const resource_middleware_1 = require("../middleware/resource-middleware");
+const sync_middleware_1 = require("../middleware/sync-middleware");
+const entity_middleware_1 = require("../middleware/entity-middleware");
+const entity_sync_middleware_1 = require("../middleware/entity-sync-middleware");
+// Dependency injection tokens (for local use)
+exports.RESOURCE_REGISTRY_TOKEN = 'RESOURCE_REGISTRY';
+exports.ENTITY_REGISTRY_TOKEN = 'ENTITY_REGISTRY';
+/**
+ * Create remote resource plugin
+ *
+ * @param config - Plugin configuration
+ * @returns Plugin module for microkernel registration
+ */
+function createResourcePlugin(config = {}) {
+    const resourceRegistry = new resource_registry_1.ResourceRegistry();
+    const entityRegistry = new entity_registry_1.EntityRegistry();
+    return {
+        initialize(ctx) {
+            return __awaiter(this, void 0, void 0, function* () {
+                // Register default providers
+                const restProvider = new rest_resource_provider_1.RestResourceProvider();
+                const mockProvider = new mock_resource_provider_1.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: exports.RESOURCE_REGISTRY_TOKEN,
+                    useValue: resourceRegistry
+                });
+                ctx.provide({
+                    provide: exports.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(ui_store_impl_1.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 = (0, entity_middleware_1.createEntityMiddleware)({
+                            entityRegistry,
+                            fsSliceName,
+                            onError: config.onError
+                        });
+                        const resourceMiddleware = (0, resource_middleware_1.createResourceMiddleware)({
+                            registry: resourceRegistry,
+                            onError: config.onError,
+                            onSuccess: config.onSuccess
+                        });
+                        const entitySyncMiddleware = (0, entity_sync_middleware_1.createEntitySyncMiddleware)();
+                        const resourceSyncMiddleware = (0, sync_middleware_1.createSyncMiddleware)({
+                            fsActions
+                        });
+                        const middlewareRegistry = resolve(ui_store_api_1.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);
+                }
+            });
+        },
+        activate(ctx) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                // Emit ready event
+                (_a = ctx.hooks) === null || _a === void 0 ? void 0 : _a.emit('ui-remote-resource:ready', {
+                    resourceRegistry,
+                    entityRegistry
+                });
+            });
+        },
+        deactivate() {
+            return __awaiter(this, void 0, void 0, function* () {
+                // Cleanup if needed
+                // For now, no cleanup required
+            });
+        }
+    };
+}
+exports.createResourcePlugin = createResourcePlugin;