@hamak/ui-remote-fs-impl 0.4.3

package/dist/es2015/providers/http-workspace-client.js

@@ -0,0 +1,199 @@
+"use strict";
+/**
+ * HTTP Workspace Client
+ *
+ * HTTP-based implementation of IWorkspaceClient using Axios.
+ * Migrated from amk/libs/server/ws/ws-client/src/lib/server-ws-ws-client.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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHttpWorkspaceClient = exports.HttpWorkspaceClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+/**
+ * HTTP-based implementation of IWorkspaceClient
+ *
+ * This implementation uses Axios to communicate with a REST API backend.
+ * Supports configurable base URL, timeout, and custom axios instances.
+ *
+ * @example
+ * ```typescript
+ * const client = new HttpWorkspaceClient({
+ *   workspaceId: '0',
+ *   baseUrl: 'http://localhost:3000/api'
+ * });
+ *
+ * const files = await client.listFiles(['folder', 'subfolder']);
+ * ```
+ */
+class HttpWorkspaceClient {
+    constructor(config) {
+        this.workspaceId = config.workspaceId;
+        // Default base URL to current origin if not provided
+        this.baseUrl = config.baseUrl ||
+            (typeof globalThis !== 'undefined' && 'location' in globalThis
+                ? `${globalThis.location.protocol}//${globalThis.location.host}/api`
+                : '/api');
+        // Use provided axios instance or create new one
+        this.axios = config.axiosInstance || axios_1.default.create({
+            baseURL: this.baseUrl,
+            timeout: config.timeout || 30000,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+    }
+    /**
+     * Format path segments to URL path string
+     */
+    formatPath(path) {
+        return path.join('/');
+    }
+    /**
+     * Handle axios errors and convert to ErrorObject
+     */
+    handleError(error) {
+        var _a, _b, _c, _d;
+        if (axios_1.default.isAxiosError(error)) {
+            const axiosError = error;
+            // Try to extract error from response
+            if ((_b = (_a = axiosError.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.error) {
+                throw axiosError.response.data.error;
+            }
+            // Create error from axios error
+            const errorObj = {
+                code: axiosError.code || 'UNKNOWN',
+                message: axiosError.message || 'Unknown error occurred',
+                params: {
+                    status: (_c = axiosError.response) === null || _c === void 0 ? void 0 : _c.status,
+                    statusText: (_d = axiosError.response) === null || _d === void 0 ? void 0 : _d.statusText,
+                },
+            };
+            throw errorObj;
+        }
+        // Handle non-axios errors
+        const errorObj = {
+            code: 'UNKNOWN',
+            message: error instanceof Error ? error.message : 'Unknown error occurred',
+        };
+        throw errorObj;
+    }
+    /**
+     * Serialize content to string for transmission
+     */
+    serializeContent(content) {
+        if (typeof content === 'string') {
+            return content;
+        }
+        return JSON.stringify(content);
+    }
+    /**
+     * List files and directories at the specified path
+     */
+    listFiles(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const formattedPath = this.formatPath(path);
+                const response = yield this.axios.get(`/workspaces/${this.workspaceId}/files/${formattedPath}`);
+                return response.data;
+            }
+            catch (error) {
+                this.handleError(error);
+            }
+        });
+    }
+    /**
+     * Create a directory at the specified path
+     */
+    createDirectory(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const formattedPath = this.formatPath(path);
+                const response = yield this.axios.post(`/workspaces/${this.workspaceId}/mkdir/${formattedPath}`);
+                return response.data;
+            }
+            catch (error) {
+                this.handleError(error);
+            }
+        });
+    }
+    /**
+     * Read a file's metadata and content
+     */
+    readFile(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const formattedPath = this.formatPath(path);
+                const response = yield this.axios.get(`/workspaces/${this.workspaceId}/read/${formattedPath}`);
+                return response.data;
+            }
+            catch (error) {
+                this.handleError(error);
+            }
+        });
+    }
+    /**
+     * Write or update a file's content (uses PUT method)
+     */
+    putFile(path, content) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const formattedPath = this.formatPath(path);
+                const serializedContent = this.serializeContent(content);
+                const response = yield this.axios.put(`/workspaces/${this.workspaceId}/put/${formattedPath}`, { content: serializedContent });
+                return response.data;
+            }
+            catch (error) {
+                this.handleError(error);
+            }
+        });
+    }
+    /**
+     * Delete a file or directory
+     */
+    deleteFile(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const formattedPath = this.formatPath(path);
+                const response = yield this.axios.delete(`/workspaces/${this.workspaceId}/delete/${formattedPath}`);
+                return response.data;
+            }
+            catch (error) {
+                this.handleError(error);
+            }
+        });
+    }
+    /**
+     * Get the workspace ID
+     */
+    getWorkspaceId() {
+        return this.workspaceId;
+    }
+    /**
+     * Get the base URL
+     */
+    getBaseUrl() {
+        return this.baseUrl;
+    }
+}
+exports.HttpWorkspaceClient = HttpWorkspaceClient;
+/**
+ * Factory function to create HTTP workspace client with default configuration
+ */
+function createHttpWorkspaceClient(workspaceId, baseUrl) {
+    return new HttpWorkspaceClient({
+        workspaceId,
+        baseUrl,
+    });
+}
+exports.createHttpWorkspaceClient = createHttpWorkspaceClient;

package/dist/es2015/providers/index.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * Remote FS Providers
+ */
+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("./http-workspace-client"), exports);

package/dist/es2015/services/index.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * Remote FS Services
+ */
+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-service"), exports);

package/dist/es2015/services/remote-fs-service.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * Remote FS Service
+ *
+ * Service implementation for remote filesystem operations.
+ * Will be implemented in future phases.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoteFsService = void 0;
+// Placeholder - will be implemented in future phases
+class RemoteFsService {
+    constructor() {
+        throw new Error('Not yet implemented');
+    }
+}
+exports.RemoteFsService = RemoteFsService;

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * UI Remote FS Implementation
+ * HTTP-based remote filesystem implementation
+ */
+export * from './actions';
+export * from './middleware';
+export * from './providers';
+export * from './plugin';
+export * from './services';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,9 @@
+/**
+ * UI Remote FS Implementation
+ * HTTP-based remote filesystem implementation
+ */
+export * from './actions';
+export * from './middleware';
+export * from './providers';
+export * from './plugin';
+export * from './services';

package/dist/middleware/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Remote FS Middleware
+ */
+export * from './remote-fs-middleware';
+export * from './store-sync-middleware';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/middleware/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC"}

package/dist/middleware/index.js

@@ -0,0 +1,5 @@
+/**
+ * Remote FS Middleware
+ */
+export * from './remote-fs-middleware';
+export * from './store-sync-middleware';

package/dist/middleware/remote-fs-middleware.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 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
+ */
+import { AnyAction, Middleware } from '@reduxjs/toolkit';
+import { IWorkspaceClient, IPathTranslator } from '@hamak/ui-remote-fs-spi';
+import { ErrorObject } from '@hamak/ui-remote-fs-api';
+/**
+ * Configuration for remote FS middleware
+ */
+export interface RemoteFsMiddlewareConfig {
+    /**
+     * Workspace client for remote operations
+     */
+    client: IWorkspaceClient;
+    /**
+     * Path translator for mount point translation
+     */
+    pathTranslator: IPathTranslator;
+    /**
+     * Optional error handler
+     */
+    onError?: (error: ErrorObject, action: AnyAction) => void;
+    /**
+     * Optional success handler
+     */
+    onSuccess?: (result: any, action: AnyAction) => void;
+}
+/**
+ * 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'))
+ * });
+ * ```
+ */
+export declare function createRemoteFsMiddleware<S = any>(config: RemoteFsMiddlewareConfig): Middleware<{}, S>;
+export default createRemoteFsMiddleware;
+//# sourceMappingURL=remote-fs-middleware.d.ts.map

package/dist/middleware/remote-fs-middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-fs-middleware.d.ts","sourceRoot":"","sources":["../../src/middleware/remote-fs-middleware.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEzD,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC5E,OAAO,EAAuB,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAW3E;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC;;OAEG;IACH,MAAM,EAAE,gBAAgB,CAAC;IAEzB;;OAEG;IACH,cAAc,EAAE,eAAe,CAAC;IAEhC;;OAEG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,KAAK,IAAI,CAAC;IAE1D;;OAEG;IACH,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,KAAK,IAAI,CAAC;CACtD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,GAAG,GAAG,EAC9C,MAAM,EAAE,wBAAwB,GAC/B,UAAU,CAAC,EAAE,EAAE,CAAC,CAAC,CAgLnB;AAED,eAAe,wBAAwB,CAAC"}

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

@@ -0,0 +1,192 @@
+/**
+ * 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
+ */
+import { Pathway } from '@hamak/shared-utils';
+import { RemoteFsActionTypes } from '@hamak/ui-remote-fs-api';
+import { rfsActions, } from '../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'))
+ * });
+ * ```
+ */
+export function createRemoteFsMiddleware(config) {
+    const { client, pathTranslator, onError, onSuccess } = config;
+    /**
+     * Translate local path to remote path
+     */
+    const toRemotePath = (path) => {
+        const pathway = Array.isArray(path) ? Pathway.of(path) : 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?.code || 'UNKNOWN',
+            message: error?.message || 'Unknown error',
+        };
+    };
+    const remoteFsMiddleware = (store) => (next) => (action) => {
+        const result = next(action);
+        const dispatch = store.dispatch;
+        const anyAction = action;
+        switch (anyAction.type) {
+            case RemoteFsActionTypes.LS_REQUEST: {
+                const requestAction = anyAction;
+                const remotePath = toRemotePath(requestAction.payload.path);
+                if (remotePath === undefined) {
+                    break;
+                }
+                void (async () => {
+                    try {
+                        const data = await client.listFiles(remotePath.getSegments());
+                        const completedAction = rfsActions.ofLsCompleted(data, requestAction);
+                        dispatch(completedAction);
+                        onSuccess?.(data, completedAction);
+                    }
+                    catch (error) {
+                        const errorObject = handleError(error);
+                        const failedAction = rfsActions.ofLsFailed(errorObject, requestAction);
+                        dispatch(failedAction);
+                        onError?.(errorObject, failedAction);
+                    }
+                })();
+                break;
+            }
+            case RemoteFsActionTypes.MKDIR_REQUEST: {
+                const requestAction = anyAction;
+                const remotePath = toRemotePath(requestAction.payload.path);
+                if (remotePath === undefined) {
+                    break;
+                }
+                void (async () => {
+                    try {
+                        const data = await client.createDirectory(remotePath.getSegments());
+                        const completedAction = rfsActions.ofMkdirCompleted(data, requestAction);
+                        dispatch(completedAction);
+                        onSuccess?.(data, completedAction);
+                    }
+                    catch (error) {
+                        const errorObject = handleError(error);
+                        const failedAction = rfsActions.ofMkdirFailed(errorObject, requestAction);
+                        dispatch(failedAction);
+                        onError?.(errorObject, failedAction);
+                    }
+                })();
+                break;
+            }
+            case RemoteFsActionTypes.GET_REQUEST: {
+                const requestAction = anyAction;
+                const remotePath = toRemotePath(requestAction.payload.path);
+                if (remotePath === undefined) {
+                    break;
+                }
+                void (async () => {
+                    try {
+                        const data = await client.readFile(remotePath.getSegments());
+                        const completedAction = rfsActions.ofGetCompleted(data, requestAction);
+                        dispatch(completedAction);
+                        onSuccess?.(data, completedAction);
+                    }
+                    catch (error) {
+                        const errorObject = handleError(error);
+                        const failedAction = rfsActions.ofGetFailed(errorObject, requestAction);
+                        dispatch(failedAction);
+                        onError?.(errorObject, failedAction);
+                    }
+                })();
+                break;
+            }
+            case RemoteFsActionTypes.POST_REQUEST: {
+                const requestAction = anyAction;
+                const remotePath = toRemotePath(requestAction.payload.path);
+                if (remotePath === undefined) {
+                    break;
+                }
+                void (async () => {
+                    try {
+                        const data = await client.putFile(remotePath.getSegments(), requestAction.payload.content);
+                        const completedAction = rfsActions.ofPostCompleted(data, requestAction);
+                        dispatch(completedAction);
+                        onSuccess?.(data, completedAction);
+                    }
+                    catch (error) {
+                        const errorObject = handleError(error);
+                        const failedAction = rfsActions.ofPostFailed(errorObject, requestAction);
+                        dispatch(failedAction);
+                        onError?.(errorObject, failedAction);
+                    }
+                })();
+                break;
+            }
+            case RemoteFsActionTypes.PUT_REQUEST: {
+                const requestAction = anyAction;
+                const remotePath = toRemotePath(requestAction.payload.path);
+                if (remotePath === undefined) {
+                    break;
+                }
+                void (async () => {
+                    try {
+                        const data = await client.putFile(remotePath.getSegments(), requestAction.payload.content);
+                        const completedAction = rfsActions.ofPutCompleted(data, requestAction);
+                        dispatch(completedAction);
+                        onSuccess?.(data, completedAction);
+                    }
+                    catch (error) {
+                        const errorObject = handleError(error);
+                        const failedAction = rfsActions.ofPutFailed(errorObject, requestAction);
+                        dispatch(failedAction);
+                        onError?.(errorObject, failedAction);
+                    }
+                })();
+                break;
+            }
+            case RemoteFsActionTypes.DELETE_REQUEST: {
+                const requestAction = anyAction;
+                const remotePath = toRemotePath(requestAction.payload.path);
+                if (remotePath === undefined) {
+                    break;
+                }
+                void (async () => {
+                    try {
+                        const data = await client.deleteFile(remotePath.getSegments());
+                        const completedAction = rfsActions.ofDeleteCompleted(data, requestAction);
+                        dispatch(completedAction);
+                        onSuccess?.(data, completedAction);
+                    }
+                    catch (error) {
+                        const errorObject = handleError(error);
+                        const failedAction = rfsActions.ofDeleteFailed(errorObject, requestAction);
+                        dispatch(failedAction);
+                        onError?.(errorObject, failedAction);
+                    }
+                })();
+                break;
+            }
+            default:
+                break;
+        }
+        return result;
+    };
+    return remoteFsMiddleware;
+}
+export default createRemoteFsMiddleware;

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

@@ -0,0 +1,35 @@
+/**
+ * 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
+ */
+import { Middleware } from '@reduxjs/toolkit';
+import { StoreSyncMiddlewareConfig } from '@hamak/ui-remote-fs-spi';
+/**
+ * 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
+ * });
+ * ```
+ */
+export declare function createStoreSyncMiddleware<S = any>(config: StoreSyncMiddlewareConfig): Middleware<{}, S>;
+export default createStoreSyncMiddleware;
+//# sourceMappingURL=store-sync-middleware.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"store-sync-middleware.d.ts","sourceRoot":"","sources":["../../src/middleware/store-sync-middleware.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAa,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAGzD,OAAO,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AAWpE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,GAAG,GAAG,EAC/C,MAAM,EAAE,yBAAyB,GAChC,UAAU,CAAC,EAAE,EAAE,CAAC,CAAC,CA6HnB;AAED,eAAe,yBAAyB,CAAC"}