@hamak/ui-remote-fs-impl 0.4.3

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

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

package/dist/services/index.js

@@ -0,0 +1,4 @@
+/**
+ * Remote FS Services
+ */
+export * from './remote-fs-service';

package/dist/services/remote-fs-service.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Remote FS Service
+ *
+ * Service implementation for remote filesystem operations.
+ * Will be implemented in future phases.
+ */
+export declare class RemoteFsService {
+    constructor();
+}
+//# sourceMappingURL=remote-fs-service.d.ts.map

package/dist/services/remote-fs-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remote-fs-service.d.ts","sourceRoot":"","sources":["../../src/services/remote-fs-service.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,qBAAa,eAAe;;CAI3B"}

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

@@ -0,0 +1,12 @@
+/**
+ * Remote FS Service
+ *
+ * Service implementation for remote filesystem operations.
+ * Will be implemented in future phases.
+ */
+// Placeholder - will be implemented in future phases
+export class RemoteFsService {
+    constructor() {
+        throw new Error('Not yet implemented');
+    }
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@hamak/ui-remote-fs-impl",
+  "version": "0.4.3",
+  "private": false,
+  "type": "module",
+  "description": "Remote FS Implementation - HTTP-based remote filesystem",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/amah/app-framework.git",
+    "directory": "packages/ui-remote-fs/ui-remote-fs-impl"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && tsc -p tsconfig.es2015.json",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js",
+      "legacy": "./dist/es2015/index.js"
+    },
+    "./es2015": {
+      "import": "./dist/es2015/index.js",
+      "default": "./dist/es2015/index.js"
+    }
+  },
+  "dependencies": {
+    "@hamak/ui-remote-fs-api": "0.4.3",
+    "@hamak/ui-remote-fs-spi": "0.4.3",
+    "@hamak/ui-store-api": "0.4.1",
+    "@hamak/ui-store-impl": "0.4.1",
+    "@hamak/microkernel-api": "0.4.1",
+    "@hamak/microkernel-spi": "0.4.1",
+    "@reduxjs/toolkit": "^2.0.0",
+    "axios": "^1.6.0",
+    "redux": "^5.0.1"
+  },
+  "peerDependencies": {
+    "@hamak/shared-utils": "^0.4.2"
+  },
+  "devDependencies": {
+    "@hamak/shared-utils": "0.4.3",
+    "typescript": "~5.4.0",
+    "vitest": "^2.0.0",
+    "@types/node": "^20.0.0"
+  }
+}

package/project.json

@@ -0,0 +1,24 @@
+{
+  "name": "@hamak/ui-remote-fs-impl",
+  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "packages/ui-remote-fs/ui-remote-fs-impl/src",
+  "projectType": "library",
+  "targets": {
+    "build": {
+      "executor": "nx:run-commands",
+      "outputs": ["{projectRoot}/dist"],
+      "options": {
+        "command": "tsc -p tsconfig.json && tsc -p tsconfig.es2015.json",
+        "cwd": "{projectRoot}"
+      }
+    },
+    "clean": {
+      "executor": "nx:run-commands",
+      "options": {
+        "command": "rm -rf dist",
+        "cwd": "{projectRoot}"
+      }
+    }
+  },
+  "tags": ["type:library", "scope:ui-remote-fs"]
+}

package/src/actions/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Remote FS Actions
+ */
+
+export * from './remote-fs-actions';

package/src/actions/remote-fs-actions.ts

@@ -0,0 +1,302 @@
+/**
+ * Remote FS Actions
+ *
+ * Action creators for remote filesystem operations.
+ * Migrated from amk/libs/ui/core/remote-fs/src/lib/remote-fs-actions.ts
+ */
+
+import { RemoteFsActionTypes, ErrorObject } from '@hamak/ui-remote-fs-api';
+import { FileInfo } from '@hamak/shared-utils';
+
+// Interfaces for action payloads
+export interface LsRequestAction {
+  type: RemoteFsActionTypes.LS_REQUEST;
+  payload: { path: string | string[] };
+  [key: string]: any;
+}
+
+export interface LsCompletedAction {
+  type: RemoteFsActionTypes.LS_COMPLETED;
+  payload: { data: FileInfo[]; request: LsRequestAction };
+  [key: string]: any;
+}
+
+export interface LsFailedAction {
+  type: RemoteFsActionTypes.LS_FAILED;
+  payload: { error: ErrorObject; request: LsRequestAction };
+  [key: string]: any;
+}
+
+export interface MkdirRequestAction {
+  type: RemoteFsActionTypes.MKDIR_REQUEST;
+  payload: { path: string | string[] };
+  [key: string]: any;
+}
+
+export interface MkdirCompletedAction {
+  type: RemoteFsActionTypes.MKDIR_COMPLETED;
+  payload: { data: FileInfo; request: MkdirRequestAction };
+  [key: string]: any;
+}
+
+export interface MkdirFailedAction {
+  type: RemoteFsActionTypes.MKDIR_FAILED;
+  payload: { error: ErrorObject; request: MkdirRequestAction };
+  [key: string]: any;
+}
+
+export interface GetRequestAction {
+  type: RemoteFsActionTypes.GET_REQUEST;
+  payload: { path: string | string[] };
+  [key: string]: any;
+}
+
+export interface GetCompletedAction {
+  type: RemoteFsActionTypes.GET_COMPLETED;
+  payload: { data: FileInfo; request: GetRequestAction };
+  [key: string]: any;
+}
+
+export interface GetFailedAction {
+  type: RemoteFsActionTypes.GET_FAILED;
+  payload: { error: ErrorObject; request: GetRequestAction };
+  [key: string]: any;
+}
+
+export interface PostRequestAction {
+  type: RemoteFsActionTypes.POST_REQUEST;
+  payload: { path: string | string[]; content: any };
+  [key: string]: any;
+}
+
+export interface PostCompletedAction {
+  type: RemoteFsActionTypes.POST_COMPLETED;
+  payload: { data: FileInfo; request: PostRequestAction };
+  [key: string]: any;
+}
+
+export interface PostFailedAction {
+  type: RemoteFsActionTypes.POST_FAILED;
+  payload: { error: ErrorObject; request: PostRequestAction };
+  [key: string]: any;
+}
+
+export interface PutRequestAction {
+  type: RemoteFsActionTypes.PUT_REQUEST;
+  payload: { path: string | string[]; content: any };
+  [key: string]: any;
+}
+
+export interface PutCompletedAction {
+  type: RemoteFsActionTypes.PUT_COMPLETED;
+  payload: { data: FileInfo; request: PutRequestAction };
+  [key: string]: any;
+}
+
+export interface PutFailedAction {
+  type: RemoteFsActionTypes.PUT_FAILED;
+  payload: { error: ErrorObject; request: PutRequestAction };
+  [key: string]: any;
+}
+
+export interface DeleteRequestAction {
+  type: RemoteFsActionTypes.DELETE_REQUEST;
+  payload: { path: string | string[] };
+  [key: string]: any;
+}
+
+export interface DeleteCompletedAction {
+  type: RemoteFsActionTypes.DELETE_COMPLETED;
+  payload: { data: FileInfo; request: DeleteRequestAction };
+  [key: string]: any;
+}
+
+export interface DeleteFailedAction {
+  type: RemoteFsActionTypes.DELETE_FAILED;
+  payload: { error: ErrorObject; request: DeleteRequestAction };
+  [key: string]: any;
+}
+
+/**
+ * Union type for all remote FS actions
+ */
+export type RemoteFsAction =
+  | LsRequestAction
+  | LsCompletedAction
+  | LsFailedAction
+  | MkdirRequestAction
+  | MkdirCompletedAction
+  | MkdirFailedAction
+  | GetRequestAction
+  | GetCompletedAction
+  | GetFailedAction
+  | PostRequestAction
+  | PostCompletedAction
+  | PostFailedAction
+  | PutRequestAction
+  | PutCompletedAction
+  | PutFailedAction
+  | DeleteRequestAction
+  | DeleteCompletedAction
+  | DeleteFailedAction;
+
+/**
+ * Action factory class for creating remote filesystem actions
+ */
+export class RemoteFsActionFactory {
+  public types = RemoteFsActionTypes;
+
+  // LS (List) operations
+  ofLsRequest(path: string | string[]): LsRequestAction {
+    return {
+      type: this.types.LS_REQUEST,
+      payload: { path },
+    };
+  }
+
+  ofLsCompleted(data: FileInfo[], request: LsRequestAction): LsCompletedAction {
+    return {
+      type: this.types.LS_COMPLETED,
+      payload: { data, request },
+    };
+  }
+
+  ofLsFailed(error: ErrorObject, request: LsRequestAction): LsFailedAction {
+    return {
+      type: this.types.LS_FAILED,
+      payload: { error, request },
+    };
+  }
+
+  // MKDIR (Make Directory) operations
+  ofMkdirRequest(path: string | string[]): MkdirRequestAction {
+    return {
+      type: this.types.MKDIR_REQUEST,
+      payload: { path },
+    };
+  }
+
+  ofMkdirCompleted(data: FileInfo, request: MkdirRequestAction): MkdirCompletedAction {
+    return {
+      type: this.types.MKDIR_COMPLETED,
+      payload: { data, request },
+    };
+  }
+
+  ofMkdirFailed(error: ErrorObject, request: MkdirRequestAction): MkdirFailedAction {
+    return {
+      type: this.types.MKDIR_FAILED,
+      payload: { error, request },
+    };
+  }
+
+  // GET (Read File) operations
+  ofGetRequest(path: string | string[]): GetRequestAction {
+    return {
+      type: this.types.GET_REQUEST,
+      payload: { path },
+    };
+  }
+
+  ofGetCompleted(data: FileInfo, request: GetRequestAction): GetCompletedAction {
+    return {
+      type: this.types.GET_COMPLETED,
+      payload: { data, request },
+    };
+  }
+
+  ofGetFailed(error: ErrorObject, request: GetRequestAction): GetFailedAction {
+    return {
+      type: this.types.GET_FAILED,
+      payload: { error, request },
+    };
+  }
+
+  // POST (Create File) operations
+  ofPostRequest(path: string | string[], content: any): PostRequestAction {
+    return {
+      type: this.types.POST_REQUEST,
+      payload: { path, content },
+    };
+  }
+
+  ofPostCompleted(data: FileInfo, request: PostRequestAction): PostCompletedAction {
+    return {
+      type: this.types.POST_COMPLETED,
+      payload: { data, request },
+    };
+  }
+
+  ofPostFailed(error: ErrorObject, request: PostRequestAction): PostFailedAction {
+    return {
+      type: this.types.POST_FAILED,
+      payload: { error, request },
+    };
+  }
+
+  // PUT (Update File) operations
+  ofPutRequest(path: string | string[], content: any): PutRequestAction {
+    return {
+      type: this.types.PUT_REQUEST,
+      payload: { path, content },
+    };
+  }
+
+  ofPutCompleted(data: FileInfo, request: PutRequestAction): PutCompletedAction {
+    return {
+      type: this.types.PUT_COMPLETED,
+      payload: { data, request },
+    };
+  }
+
+  ofPutFailed(error: ErrorObject, request: PutRequestAction): PutFailedAction {
+    return {
+      type: this.types.PUT_FAILED,
+      payload: { error, request },
+    };
+  }
+
+  // DELETE operations
+  ofDeleteRequest(path: string | string[]): DeleteRequestAction {
+    return {
+      type: this.types.DELETE_REQUEST,
+      payload: { path },
+    };
+  }
+
+  ofDeleteCompleted(data: FileInfo, request: DeleteRequestAction): DeleteCompletedAction {
+    return {
+      type: this.types.DELETE_COMPLETED,
+      payload: { data, request },
+    };
+  }
+
+  ofDeleteFailed(error: ErrorObject, request: DeleteRequestAction): DeleteFailedAction {
+    return {
+      type: this.types.DELETE_FAILED,
+      payload: { error, request },
+    };
+  }
+
+  /**
+   * Type guard to check if an action is a remote FS action
+   */
+  isRemoteFsAction(action: any): action is RemoteFsAction {
+    return (
+      action &&
+      typeof action === 'object' &&
+      'type' in action &&
+      Object.values(RemoteFsActionTypes).includes(action.type)
+    );
+  }
+}
+
+/**
+ * Singleton instance of the action factory
+ */
+export const rfsActions = new RemoteFsActionFactory();
+
+/**
+ * Re-export the action types enum for convenience
+ */
+export { RemoteFsActionTypes };

package/src/index.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';

package/src/middleware/index.ts

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

package/src/middleware/remote-fs-middleware.ts

@@ -0,0 +1,244 @@
+/**
+ * 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 { Pathway } from '@hamak/shared-utils';
+import { IWorkspaceClient, IPathTranslator } from '@hamak/ui-remote-fs-spi';
+import { RemoteFsActionTypes, ErrorObject } from '@hamak/ui-remote-fs-api';
+import {
+  rfsActions,
+  LsRequestAction,
+  MkdirRequestAction,
+  GetRequestAction,
+  PostRequestAction,
+  PutRequestAction,
+  DeleteRequestAction,
+} from '../actions/remote-fs-actions';
+
+/**
+ * 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 function createRemoteFsMiddleware<S = any>(
+  config: RemoteFsMiddlewareConfig
+): Middleware<{}, S> {
+  const { client, pathTranslator, onError, onSuccess } = config;
+
+  /**
+   * Translate local path to remote path
+   */
+  const toRemotePath = (path: string | string[]): Pathway | undefined => {
+    const pathway = Array.isArray(path) ? Pathway.of(path) : Pathway.of([path]);
+    return pathTranslator.toRemotePath(pathway);
+  };
+
+  /**
+   * Handle errors and convert to ErrorObject
+   */
+  const handleError = (error: any): ErrorObject => {
+    if (error && typeof error === 'object' && 'code' in error && 'message' in error) {
+      return error as ErrorObject;
+    }
+    return {
+      code: error?.code || 'UNKNOWN',
+      message: error?.message || 'Unknown error',
+    };
+  };
+
+  const remoteFsMiddleware: Middleware<{}, S> = (store) => (next) => (action) => {
+    const result = next(action);
+    const dispatch = store.dispatch;
+    const anyAction = action as AnyAction;
+
+    switch (anyAction.type) {
+      case RemoteFsActionTypes.LS_REQUEST: {
+        const requestAction = anyAction as LsRequestAction;
+        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 as MkdirRequestAction;
+        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 as GetRequestAction;
+        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 as PostRequestAction;
+        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 as PutRequestAction;
+        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 as DeleteRequestAction;
+        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;