Use idiomatic Effect APIs in filesystem and telemetry

Cursor Agent committed 4 months ago

Commit 6241e151 parent c1ec1913 files · +183 −90Browse files

Showing the changes to apps/server/src/workspace/WorkspaceFileSystem.ts (1 of 3 files). Show all

Unified · Split

apps/server/src/workspace/WorkspaceFileSystem.ts+87−89

-// @effect-diagnostics nodeBuiltinImport:off
 /**
  * WorkspaceFileSystem - Effect service contract for workspace file mutations.
  *
  *
  * @module WorkspaceFileSystem
  */
-import * as NodeFSP from "node:fs/promises";
 import type {
   ProjectReadFileInput,
   ProjectReadFileResult,
 import * as Effect from "effect/Effect";
 import * as FileSystem from "effect/FileSystem";
 import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
 import * as Path from "effect/Path";
 import * as Schema from "effect/Schema";
       relativePath: input.relativePath,
     });
-    const realWorkspaceRoot = yield* Effect.tryPromise({
+    const realWorkspaceRoot = yield* fileSystem.realPath(input.cwd).pipe(
-      try: () => NodeFSP.realpath(input.cwd),
+      Effect.mapError(
-      catch: (cause) =>
+        (cause) =>
-        new WorkspaceFileSystemOperationError({
+          new WorkspaceFileSystemOperationError({
-          workspaceRoot: input.cwd,
+            workspaceRoot: input.cwd,
-          relativePath: input.relativePath,
+            relativePath: input.relativePath,
-          resolvedPath: target.absolutePath,
+            resolvedPath: target.absolutePath,
-          operationPath: input.cwd,
+            operationPath: input.cwd,
-          operation: "realpath-workspace-root",
+            operation: "realpath-workspace-root",
-          cause,
+            cause,
-        }),
+          }),
-    });
+      ),
-    const realTargetPath = yield* Effect.tryPromise({
+    );
-      try: () => NodeFSP.realpath(target.absolutePath),
+    const realTargetPath = yield* fileSystem.realPath(target.absolutePath).pipe(
-      catch: (cause) =>
+      Effect.mapError(
-        new WorkspaceFileSystemOperationError({
+        (cause) =>
-          workspaceRoot: input.cwd,
+          new WorkspaceFileSystemOperationError({
-          relativePath: input.relativePath,
+            workspaceRoot: input.cwd,
-          resolvedPath: target.absolutePath,
+            relativePath: input.relativePath,
-          operationPath: target.absolutePath,
+            resolvedPath: target.absolutePath,
-          operation: "realpath-target",
+            operationPath: target.absolutePath,
-          cause,
+            operation: "realpath-target",
-        }),
+            cause,
-    });
+          }),
+      ),
+    );
     const relativeRealPath = path.relative(realWorkspaceRoot, realTargetPath);
     if (
       relativeRealPath.startsWith(`..${path.sep}`) ||
       });
     }
-    return yield* Effect.acquireUseRelease(
+    return yield* Effect.scoped(
-      Effect.tryPromise({
+      Effect.gen(function* () {
-        try: () => NodeFSP.open(realTargetPath, "r"),
+        const file = yield* fileSystem.open(realTargetPath, { flag: "r" }).pipe(
-        catch: (cause) =>
+          Effect.mapError(
-          new WorkspaceFileSystemOperationError({
+            (cause) =>
-            workspaceRoot: input.cwd,
-            relativePath: input.relativePath,
-            resolvedPath: realTargetPath,
-            operationPath: realTargetPath,
-            operation: "open",
-            cause,
-          }),
-      }),
-      (handle) =>
-        Effect.gen(function* () {
-          const stat = yield* Effect.tryPromise({
-            try: () => handle.stat(),
-            catch: (cause) =>
               new WorkspaceFileSystemOperationError({
                 workspaceRoot: input.cwd,
                 relativePath: input.relativePath,
                 resolvedPath: realTargetPath,
                 operationPath: realTargetPath,
-                operation: "stat",
+                operation: "open",
                 cause,
               }),
-          });
+          ),
-          if (!stat.isFile()) {
+        );
-            return yield* new WorkspacePathNotFileError({
+        const stat = yield* file.stat.pipe(
-              workspaceRoot: input.cwd,
+          Effect.mapError(
-              relativePath: input.relativePath,
+            (cause) =>
-              resolvedPath: realTargetPath,
-            });
-          }
-          const bytesToRead = Math.min(stat.size, PROJECT_READ_FILE_MAX_BYTES);
-          const buffer = Buffer.alloc(bytesToRead);
-          const { bytesRead } = yield* Effect.tryPromise({
-            try: () => handle.read(buffer, 0, bytesToRead, 0),
-            catch: (cause) =>
               new WorkspaceFileSystemOperationError({
                 workspaceRoot: input.cwd,
                 relativePath: input.relativePath,
                 resolvedPath: realTargetPath,
                 operationPath: realTargetPath,
-                operation: "read",
+                operation: "stat",
                 cause,
               }),
+          ),
+        );
+        if (stat.type !== "File") {
+          return yield* new WorkspacePathNotFileError({
+            workspaceRoot: input.cwd,
+            relativePath: input.relativePath,
+            resolvedPath: realTargetPath,
           });
-          const fileBytes = buffer.subarray(0, bytesRead);
+        }
-          if (fileBytes.includes(0)) {
-            return yield* new WorkspaceBinaryFileError({
-              workspaceRoot: input.cwd,
-              relativePath: input.relativePath,
-              resolvedPath: realTargetPath,
-            });
-          }
-          return {
+        const truncated = stat.size > FileSystem.Size(PROJECT_READ_FILE_MAX_BYTES);
-            relativePath: target.relativePath,
+        const byteLength = Number(stat.size);
-            contents: new TextDecoder("utf-8").decode(fileBytes),
+        const bytesToRead = truncated ? PROJECT_READ_FILE_MAX_BYTES : byteLength;
-            byteLength: stat.size,
+        const fileBytes =
-            truncated: stat.size > PROJECT_READ_FILE_MAX_BYTES,
+          bytesToRead === 0
-          };
+            ? new Uint8Array()
-        }),
+            : yield* file.readAlloc(bytesToRead).pipe(
-      (handle) =>
+                Effect.map(
-        Effect.tryPromise({
+                  Option.match({
-          try: () => handle.close(),
+                    onNone: () => new Uint8Array(),
-          catch: (cause) =>
+                    onSome: (bytes) => bytes,
-            new WorkspaceFileSystemOperationError({
+                  }),
-              workspaceRoot: input.cwd,
+                ),
-              relativePath: input.relativePath,
+                Effect.mapError(
-              resolvedPath: realTargetPath,
+                  (cause) =>
-              operationPath: realTargetPath,
+                    new WorkspaceFileSystemOperationError({
-              operation: "close",
+                      workspaceRoot: input.cwd,
-              cause,
+                      relativePath: input.relativePath,
-            }),
+                      resolvedPath: realTargetPath,
-        }),
+                      operationPath: realTargetPath,
+                      operation: "read",
+                      cause,
+                    }),
+                ),
+              );
+        if (fileBytes.includes(0)) {
+          return yield* new WorkspaceBinaryFileError({
+            workspaceRoot: input.cwd,
+            relativePath: input.relativePath,
+            resolvedPath: realTargetPath,
+          });
+        }
+        return {
+          relativePath: target.relativePath,
+          contents: new TextDecoder("utf-8").decode(fileBytes),
+          byteLength,
+          truncated,
+        };
+      }),
     );
   });