@hamak/ui-remote-fs-impl 0.4.3

package/dist/es2015/middleware/remote-fs-middleware.js

@@ -0,0 +1,205 @@
+"use strict";
+/**
+ * Remote FS Middleware
+ *
+ * Redux middleware for handling remote filesystem operations via HTTP client.
+ * Migrated from amk/libs/ui/core/remote-fs/src/lib/remote-fs-middleware.ts
+ */
+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.createRemoteFsMiddleware = void 0;
+const shared_utils_1 = require("@hamak/shared-utils");
+const ui_remote_fs_api_1 = require("@hamak/ui-remote-fs-api");
+const remote_fs_actions_1 = require("../actions/remote-fs-actions");
+/**
+ * Create remote filesystem middleware
+ *
+ * This middleware intercepts remote FS actions and executes them via the provided
+ * workspace client. It handles path translation from local mount point to remote paths.
+ *
+ * @param config Middleware configuration
+ * @returns Redux middleware
+ *
+ * @example
+ * ```typescript
+ * const middleware = createRemoteFsMiddleware({
+ *   client: new HttpWorkspaceClient({ workspaceId: '0' }),
+ *   pathTranslator: new PathTranslator(Pathway.ofRoot().resolve('remote'))
+ * });
+ * ```
+ */
+function createRemoteFsMiddleware(config) {
+    const { client, pathTranslator, onError, onSuccess } = config;
+    /**
+     * Translate local path to remote path
+     */
+    const toRemotePath = (path) => {
+        const pathway = Array.isArray(path) ? shared_utils_1.Pathway.of(path) : shared_utils_1.Pathway.of([path]);
+        return pathTranslator.toRemotePath(pathway);
+    };
+    /**
+     * Handle errors and convert to ErrorObject
+     */
+    const handleError = (error) => {
+        if (error && typeof error === 'object' && 'code' in error && 'message' in error) {
+            return error;
+        }
+        return {
+            code: (error === null || error === void 0 ? void 0 : error.code) || 'UNKNOWN',
+            message: (error === null || error === void 0 ? void 0 : error.message) || 'Unknown error',
+        };
+    };
+    const remoteFsMiddleware = (store) => (next) => (action) => {
+        const result = next(action);
+        const dispatch = store.dispatch;
+        const anyAction = action;
+        switch (anyAction.type) {
+            case ui_remote_fs_api_1.RemoteFsActionTypes.LS_REQUEST: {
+                const requestAction = anyAction;
+                const remotePath = toRemotePath(requestAction.payload.path);
+                if (remotePath === undefined) {
+                    break;
+                }
+                void (() => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        const data = yield client.listFiles(remotePath.getSegments());
+                        const completedAction = remote_fs_actions_1.rfsActions.ofLsCompleted(data, requestAction);
+                        dispatch(completedAction);
+                        onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(data, completedAction);
+                    }
+                    catch (error) {
+                        const errorObject = handleError(error);
+                        const failedAction = remote_fs_actions_1.rfsActions.ofLsFailed(errorObject, requestAction);
+                        dispatch(failedAction);
+                        onError === null || onError === void 0 ? void 0 : onError(errorObject, failedAction);
+                    }
+                }))();
+                break;
+            }
+            case ui_remote_fs_api_1.RemoteFsActionTypes.MKDIR_REQUEST: {
+                const requestAction = anyAction;
+                const remotePath = toRemotePath(requestAction.payload.path);
+                if (remotePath === undefined) {
+                    break;
+                }
+                void (() => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        const data = yield client.createDirectory(remotePath.getSegments());
+                        const completedAction = remote_fs_actions_1.rfsActions.ofMkdirCompleted(data, requestAction);
+                        dispatch(completedAction);
+                        onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(data, completedAction);
+                    }
+                    catch (error) {
+                        const errorObject = handleError(error);
+                        const failedAction = remote_fs_actions_1.rfsActions.ofMkdirFailed(errorObject, requestAction);
+                        dispatch(failedAction);
+                        onError === null || onError === void 0 ? void 0 : onError(errorObject, failedAction);
+                    }
+                }))();
+                break;
+            }
+            case ui_remote_fs_api_1.RemoteFsActionTypes.GET_REQUEST: {
+                const requestAction = anyAction;
+                const remotePath = toRemotePath(requestAction.payload.path);
+                if (remotePath === undefined) {
+                    break;
+                }
+                void (() => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        const data = yield client.readFile(remotePath.getSegments());
+                        const completedAction = remote_fs_actions_1.rfsActions.ofGetCompleted(data, requestAction);
+                        dispatch(completedAction);
+                        onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(data, completedAction);
+                    }
+                    catch (error) {
+                        const errorObject = handleError(error);
+                        const failedAction = remote_fs_actions_1.rfsActions.ofGetFailed(errorObject, requestAction);
+                        dispatch(failedAction);
+                        onError === null || onError === void 0 ? void 0 : onError(errorObject, failedAction);
+                    }
+                }))();
+                break;
+            }
+            case ui_remote_fs_api_1.RemoteFsActionTypes.POST_REQUEST: {
+                const requestAction = anyAction;
+                const remotePath = toRemotePath(requestAction.payload.path);
+                if (remotePath === undefined) {
+                    break;
+                }
+                void (() => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        const data = yield client.putFile(remotePath.getSegments(), requestAction.payload.content);
+                        const completedAction = remote_fs_actions_1.rfsActions.ofPostCompleted(data, requestAction);
+                        dispatch(completedAction);
+                        onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(data, completedAction);
+                    }
+                    catch (error) {
+                        const errorObject = handleError(error);
+                        const failedAction = remote_fs_actions_1.rfsActions.ofPostFailed(errorObject, requestAction);
+                        dispatch(failedAction);
+                        onError === null || onError === void 0 ? void 0 : onError(errorObject, failedAction);
+                    }
+                }))();
+                break;
+            }
+            case ui_remote_fs_api_1.RemoteFsActionTypes.PUT_REQUEST: {
+                const requestAction = anyAction;
+                const remotePath = toRemotePath(requestAction.payload.path);
+                if (remotePath === undefined) {
+                    break;
+                }
+                void (() => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        const data = yield client.putFile(remotePath.getSegments(), requestAction.payload.content);
+                        const completedAction = remote_fs_actions_1.rfsActions.ofPutCompleted(data, requestAction);
+                        dispatch(completedAction);
+                        onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(data, completedAction);
+                    }
+                    catch (error) {
+                        const errorObject = handleError(error);
+                        const failedAction = remote_fs_actions_1.rfsActions.ofPutFailed(errorObject, requestAction);
+                        dispatch(failedAction);
+                        onError === null || onError === void 0 ? void 0 : onError(errorObject, failedAction);
+                    }
+                }))();
+                break;
+            }
+            case ui_remote_fs_api_1.RemoteFsActionTypes.DELETE_REQUEST: {
+                const requestAction = anyAction;
+                const remotePath = toRemotePath(requestAction.payload.path);
+                if (remotePath === undefined) {
+                    break;
+                }
+                void (() => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        const data = yield client.deleteFile(remotePath.getSegments());
+                        const completedAction = remote_fs_actions_1.rfsActions.ofDeleteCompleted(data, requestAction);
+                        dispatch(completedAction);
+                        onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess(data, completedAction);
+                    }
+                    catch (error) {
+                        const errorObject = handleError(error);
+                        const failedAction = remote_fs_actions_1.rfsActions.ofDeleteFailed(errorObject, requestAction);
+                        dispatch(failedAction);
+                        onError === null || onError === void 0 ? void 0 : onError(errorObject, failedAction);
+                    }
+                }))();
+                break;
+            }
+            default:
+                break;
+        }
+        return result;
+    };
+    return remoteFsMiddleware;
+}
+exports.createRemoteFsMiddleware = createRemoteFsMiddleware;
+exports.default = createRemoteFsMiddleware;

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

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * Store Sync Middleware
+ *
+ * Redux middleware for synchronizing remote filesystem operations to Redux Store FS.
+ * This middleware listens to remote FS completion actions and updates the Store FS accordingly.
+ * Migrated from amk/libs/ui/core/remote-fs/src/lib/store-fs-adapter-middleware.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStoreSyncMiddleware = void 0;
+const shared_utils_1 = require("@hamak/shared-utils");
+const ui_remote_fs_api_1 = require("@hamak/ui-remote-fs-api");
+const remote_fs_actions_1 = require("../actions/remote-fs-actions");
+/**
+ * Create store sync middleware
+ *
+ * This middleware intercepts remote FS completion actions and synchronizes them
+ * to the Redux Store FileSystem. It handles:
+ * - LS_COMPLETED: Creates directories and file entries in Store FS
+ * - MKDIR_COMPLETED: Creates directory in Store FS
+ * - GET_COMPLETED: Creates/updates file content in Store FS
+ * - POST/PUT_COMPLETED: Reloads file content from remote
+ * - DELETE_COMPLETED: Removes node from Store FS
+ *
+ * @param config Middleware configuration
+ * @returns Redux middleware
+ *
+ * @example
+ * ```typescript
+ * const middleware = createStoreSyncMiddleware({
+ *   fileSystemAdapter: storeFs,
+ *   pathTranslator: new PathTranslator(Pathway.ofRoot().resolve('remote')),
+ *   autoReload: true
+ * });
+ * ```
+ */
+function createStoreSyncMiddleware(config) {
+    const { fileSystemAdapter, pathTranslator, autoReload = true, transformContent } = config;
+    const storeFsActions = fileSystemAdapter.getActions();
+    const storeSyncMiddleware = (store) => (next) => (action) => {
+        const result = next(action);
+        const anyAction = action;
+        // Only process remote FS actions
+        if (!remote_fs_actions_1.rfsActions.isRemoteFsAction(anyAction)) {
+            return result;
+        }
+        const dispatch = store.dispatch;
+        switch (anyAction.type) {
+            case ui_remote_fs_api_1.RemoteFsActionTypes.LS_COMPLETED: {
+                const completedAction = anyAction;
+                const { request, data } = completedAction.payload;
+                // Iterate through file list and create entries in Store FS
+                data === null || data === void 0 ? void 0 : data.forEach((fileInfo) => {
+                    // Build local path: request path + file name
+                    const localPath = shared_utils_1.Pathway.of(request.payload.path)
+                        .resolve(fileInfo.name)
+                        .getSegments();
+                    if (fileInfo.isDirectory) {
+                        // Create directory with parents flag
+                        dispatch(storeFsActions.mkdir(localPath, true));
+                    }
+                    else {
+                        // Create file entry without content (contentIsPresent: false)
+                        dispatch(storeFsActions.setFile(localPath, undefined, 'xs:any', {
+                            override: true,
+                            contentIsPresent: false,
+                        }));
+                    }
+                });
+                break;
+            }
+            case ui_remote_fs_api_1.RemoteFsActionTypes.MKDIR_COMPLETED: {
+                const completedAction = anyAction;
+                const { request } = completedAction.payload;
+                const localPath = shared_utils_1.Pathway.of(request.payload.path).getSegments();
+                // Create directory in Store FS
+                dispatch(storeFsActions.mkdir(localPath, true));
+                break;
+            }
+            case ui_remote_fs_api_1.RemoteFsActionTypes.GET_COMPLETED: {
+                const completedAction = anyAction;
+                const { request, data } = completedAction.payload;
+                const localPath = shared_utils_1.Pathway.of(request.payload.path).getSegments();
+                // Parse content
+                let content = data.content === undefined || data.content === null
+                    ? undefined
+                    : data.content === ''
+                        ? undefined
+                        : JSON.parse(data.content);
+                // Apply content transform if provided
+                if (content !== undefined && transformContent) {
+                    content = transformContent(content);
+                }
+                // Check if file exists in Store FS
+                const fileSystemNode = fileSystemAdapter.createSelector((state) => state.fileSystem, localPath)(store.getState());
+                if (fileSystemNode === undefined) {
+                    // File doesn't exist, create it with content
+                    dispatch(storeFsActions.setFile(localPath, content, 'xs:any', {
+                        override: true,
+                        contentIsPresent: true,
+                    }));
+                }
+                else {
+                    // File exists, update content only if it's a file
+                    if ((fileSystemNode === null || fileSystemNode === void 0 ? void 0 : fileSystemNode.type) === 'file') {
+                        dispatch(storeFsActions.setFileContent(localPath, content, true));
+                    }
+                }
+                break;
+            }
+            case ui_remote_fs_api_1.RemoteFsActionTypes.POST_COMPLETED:
+            case ui_remote_fs_api_1.RemoteFsActionTypes.PUT_COMPLETED: {
+                const completedAction = anyAction;
+                const { request } = completedAction.payload;
+                const localPath = shared_utils_1.Pathway.of(request.payload.path).getSegments();
+                // Reload file content from remote if autoReload is enabled
+                if (autoReload) {
+                    dispatch(remote_fs_actions_1.rfsActions.ofGetRequest(localPath));
+                }
+                break;
+            }
+            case ui_remote_fs_api_1.RemoteFsActionTypes.DELETE_COMPLETED: {
+                const completedAction = anyAction;
+                const { request } = completedAction.payload;
+                const localPath = shared_utils_1.Pathway.of(request.payload.path).getSegments();
+                // Remove node from Store FS
+                dispatch(storeFsActions.removeNode(localPath));
+                break;
+            }
+            default:
+                break;
+        }
+        return result;
+    };
+    return storeSyncMiddleware;
+}
+exports.createStoreSyncMiddleware = createStoreSyncMiddleware;
+exports.default = createStoreSyncMiddleware;

package/dist/es2015/plugin/index.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * Remote FS Plugin Factory
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./remote-fs-plugin-factory"), exports);

package/dist/es2015/plugin/remote-fs-plugin-factory.js

@@ -0,0 +1,169 @@
+"use strict";
+/**
+ * Remote FS Plugin Factory
+ *
+ * Creates a microkernel plugin for remote filesystem operations.
+ * Integrates HTTP-based remote filesystem with Redux Store FS.
+ */
+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.createRemoteFsPlugin = void 0;
+const ui_remote_fs_api_1 = require("@hamak/ui-remote-fs-api");
+const ui_remote_fs_spi_1 = require("@hamak/ui-remote-fs-spi");
+const http_workspace_client_1 = require("../providers/http-workspace-client");
+const remote_fs_middleware_1 = require("../middleware/remote-fs-middleware");
+const store_sync_middleware_1 = require("../middleware/store-sync-middleware");
+const ui_store_api_1 = require("@hamak/ui-store-api");
+/**
+ * Create Remote FS plugin
+ *
+ * This plugin provides remote filesystem capabilities through HTTP API.
+ * It registers two middleware:
+ * - Remote FS Middleware: Handles remote operations via HTTP client
+ * - Store Sync Middleware: Synchronizes remote data to Redux Store FS
+ *
+ * @param config Plugin configuration
+ * @returns PluginModule for microkernel integration
+ *
+ * @example
+ * ```typescript
+ * import { Pathway } from '@hamak/shared-utils';
+ * import { createRemoteFsPlugin } from '@hamak/ui-remote-fs-impl';
+ *
+ * const plugin = createRemoteFsPlugin({
+ *   workspaceId: '0',
+ *   mountPoint: Pathway.ofRoot().resolve('remote'),
+ *   baseUrl: 'http://localhost:3000/api',
+ *   autoReload: true
+ * });
+ * ```
+ */
+function createRemoteFsPlugin(config) {
+    let workspaceClient;
+    let pathTranslator;
+    let storeManager;
+    const log = (message, ...args) => {
+        if (config.debug) {
+            console.log(`[ui-remote-fs] ${message}`, ...args);
+        }
+    };
+    return {
+        initialize(ctx) {
+            return __awaiter(this, void 0, void 0, function* () {
+                log('Initializing plugin...');
+                // Create or use custom workspace client
+                if (config.customClient) {
+                    workspaceClient = config.customClient;
+                    log('Using custom workspace client');
+                }
+                else {
+                    const clientConfig = {
+                        workspaceId: config.workspaceId,
+                        baseUrl: config.baseUrl,
+                        timeout: config.timeout,
+                    };
+                    workspaceClient = new http_workspace_client_1.HttpWorkspaceClient(clientConfig);
+                    log('Created HTTP workspace client', { baseUrl: config.baseUrl, workspaceId: config.workspaceId });
+                }
+                // Create or use custom path translator
+                if (config.customPathTranslator) {
+                    pathTranslator = config.customPathTranslator;
+                    log('Using custom path translator');
+                }
+                else {
+                    pathTranslator = new ui_remote_fs_spi_1.PathTranslator(config.mountPoint);
+                    log('Created path translator', { mountPoint: config.mountPoint.getSegments() });
+                }
+                // Register services via DI
+                ctx.provide({ provide: ui_remote_fs_api_1.WORKSPACE_CLIENT_TOKEN, useValue: workspaceClient });
+                ctx.provide({ provide: ui_remote_fs_api_1.PATH_TRANSLATOR_TOKEN, useValue: pathTranslator });
+                // Note: IRemoteFsService implementation will be added in future phases
+                // ctx.provide({ provide: REMOTE_FS_SERVICE_TOKEN, useValue: remoteFsService });
+                log('Plugin initialized');
+            });
+        },
+        activate(ctx) {
+            return __awaiter(this, void 0, void 0, function* () {
+                log('Activating plugin...');
+                // Resolve store manager from DI
+                try {
+                    storeManager = ctx.resolve(ui_store_api_1.STORE_MANAGER_TOKEN);
+                }
+                catch (error) {
+                    throw new Error('[ui-remote-fs] Store manager not found. Ensure @hamak/ui-store plugin is loaded before ui-remote-fs.');
+                }
+                // Get file system adapter from store
+                const fileSystemAdapter = storeManager.getFileSystemAdapter();
+                if (!fileSystemAdapter) {
+                    throw new Error('[ui-remote-fs] File system adapter not found in store manager.');
+                }
+                // Get store extensions collector
+                const extensionsCollector = ctx.resolve(ui_store_api_1.STORE_EXTENSIONS_TOKEN);
+                // Create and register remote FS middleware
+                const remoteFsMiddleware = (0, remote_fs_middleware_1.createRemoteFsMiddleware)({
+                    client: workspaceClient,
+                    pathTranslator,
+                    onError: (error, action) => {
+                        log('Remote FS error:', error, action);
+                        ctx.hooks.emit('ui-remote-fs:error', { error, action });
+                    },
+                    onSuccess: (result, action) => {
+                        log('Remote FS success:', action.type);
+                        ctx.hooks.emit('ui-remote-fs:success', { result, action });
+                    },
+                });
+                // Create and register store sync middleware
+                const storeSyncMiddleware = (0, store_sync_middleware_1.createStoreSyncMiddleware)({
+                    fileSystemAdapter,
+                    pathTranslator,
+                    autoReload: config.autoReload,
+                    transformContent: config.transformContent,
+                });
+                // Register middleware with store extensions
+                const middlewareExtensions = [
+                    {
+                        id: 'remote-fs',
+                        middleware: remoteFsMiddleware,
+                        priority: 100,
+                        plugin: 'ui-remote-fs',
+                        description: 'Handles remote filesystem operations via HTTP',
+                    },
+                    {
+                        id: 'store-sync',
+                        middleware: storeSyncMiddleware,
+                        priority: 50,
+                        plugin: 'ui-remote-fs',
+                        description: 'Synchronizes remote FS to Redux Store FS',
+                    },
+                ];
+                extensionsCollector.register('ui-remote-fs:middleware', {
+                    middleware: middlewareExtensions,
+                });
+                log('Middleware registered');
+                // Emit ready event
+                ctx.hooks.emit('ui-remote-fs:ready', {
+                    workspaceClient,
+                    pathTranslator,
+                    mountPoint: config.mountPoint,
+                });
+                log('Plugin activated');
+            });
+        },
+        deactivate() {
+            return __awaiter(this, void 0, void 0, function* () {
+                log('Plugin deactivated');
+                // Cleanup if needed
+            });
+        },
+    };
+}
+exports.createRemoteFsPlugin = createRemoteFsPlugin;
+exports.default = createRemoteFsPlugin;