fileserver: delete ZenFS

ZenFS integration often holds back @types/node upgrades.

Author: yoursunny

integ/browser-tests/package.json

@@ -25,8 +25,6 @@
   "devDependencies": {
     "@nodelib/fs.walk": "^3.0.1",
     "@types/webpack": "^5.28.5",
-    "@zenfs/core": "~2.5.6",
-    "@zenfs/dom": "~1.2.9",
     "fork-ts-checker-webpack-plugin": "^9.1.0",
     "html-webpack-plugin": "^5.6.7",
     "puppeteer": "^24.42.0",

integ/browser-tests/tests/segmented-object/api.ts

@@ -5,5 +5,4 @@ export interface FetchedInfo {
 
 declare global {
   function testBlobChunkSource(): Promise<FetchedInfo>;
-  function testZenFS(payloadHex: string): Promise<FetchedInfo>;
 }

integ/browser-tests/tests/segmented-object/browser.ts

@@ -1,7 +1,5 @@
-import { BlobChunkSource, fetch, FileChunkSource, serve, type Server } from "@ndn/segmented-object";
-import { asBufferSource, Closers, fromHex, toHex } from "@ndn/util";
-import { configure as zenfsConfigure } from "@zenfs/core";
-import { WebAccess } from "@zenfs/dom";
+import { BlobChunkSource, fetch, serve, type Server } from "@ndn/segmented-object";
+import { asBufferSource, Closers, toHex } from "@ndn/util";
 
 import type { FetchedInfo } from "./api";
 
@@ -31,22 +29,3 @@ globalThis.testBlobChunkSource = (): Promise<FetchedInfo> => {
   const server = serve("/R", new BlobChunkSource(file));
   return fetchAndReport(server);
 };
-
-globalThis.testZenFS = async (payloadHex): Promise<FetchedInfo> => {
-  const root = await navigator.storage.getDirectory();
-  const file = await root.getFileHandle("R.bin", { create: true });
-  const writable = await file.createWritable();
-  await writable.write(fromHex(payloadHex));
-  await writable.close();
-
-  await zenfsConfigure({
-    mounts: {
-      "/W": {
-        backend: WebAccess,
-        handle: root,
-      },
-    },
-  });
-  const server = serve("/R", new FileChunkSource("/W/R.bin"));
-  return fetchAndReport(server);
-};

integ/browser-tests/tests/segmented-object/test.t.ts

@@ -33,9 +33,3 @@ test("blob to buffer", async () => {
   expect(size).toBe(objectBody.byteLength);
   expect(digest).toBe(objectBodyDigest);
 });
-
-test("file to buffer", async () => {
-  const { size, digest } = await pageInvoke<typeof globalThis.testZenFS>("testZenFS", toHex(objectBody));
-  expect(size).toBe(objectBody.byteLength);
-  expect(digest).toBe(objectBodyDigest);
-});

pkg/fileserver/README.md

@@ -16,6 +16,5 @@ Client (consumer):
 
 * simple client
   * demonstrated in `@ndn/cat` package `file-client` subcommand
-* [ZenFS](https://zenfs.dev/core/) wrapper
 
 Server (producer): not yet.

pkg/fileserver/package.json

@@ -26,20 +26,18 @@
     "types": "lib/mod.d.ts"
   },
   "dependencies": {
-    "@miyauci/lru-map": "1.0.0-beta.1",
     "@ndn/naming-convention2": "workspace:*",
     "@ndn/packet": "workspace:*",
     "@ndn/rdr": "workspace:*",
     "@ndn/segmented-object": "workspace:*",
     "@ndn/tlv": "workspace:*",
     "@ndn/util": "workspace:*",
-    "@zenfs/core": "~2.5.6",
     "obliterator": "^2.0.5",
-    "streaming-iterables": "^8.0.1",
     "tslib": "^2.8.1"
   },
   "devDependencies": {
     "@ndn/endpoint": "workspace:*",
-    "@ndn/fw": "workspace:^"
+    "@ndn/fw": "workspace:^",
+    "streaming-iterables": "^8.0.1"
   }
 }

pkg/fileserver/src/mod.ts

@@ -2,4 +2,3 @@ export * from "./an";
 export * from "./client";
 export * from "./ls";
 export * from "./metadata";
-export * from "./zenfs";

pkg/fileserver/src/zenfs.ts

@@ -7,11 +7,10 @@ import { Data, Name } from "@ndn/packet";
 import { makeMetadataPacket, MetadataKeyword } from "@ndn/rdr";
 import { BufferChunkSource, DataProducer } from "@ndn/segmented-object";
 import { makeObjectBody } from "@ndn/segmented-object/test-fixture/object-body";
-import { configure as zenfsConfigure, fs as zenfs } from "@zenfs/core";
 import { collect } from "streaming-iterables";
-import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { afterAll, beforeAll, expect, test } from "vitest";
 
-import { buildDirectoryListing, Client, FileMetadata, lsKeyword, ModeDir, ModeFile, NDNZenFS } from "..";
+import { buildDirectoryListing, Client, FileMetadata, lsKeyword, ModeDir, ModeFile } from "..";
 
 // Directory hierarchy:
 //   /
@@ -83,15 +82,6 @@ beforeAll(async () => {
   );
 
   client = new Client(prefix);
-
-  await zenfsConfigure({
-    mounts: {
-      "/N": {
-        backend: NDNZenFS,
-        client,
-      },
-    },
-  });
 });
 afterAll(Forwarder.deleteDefault);
 
@@ -148,52 +138,3 @@ test.each(readFileIntoCases)("readFileInto [%d,%d)", async (...tc) => {
     await client.readFileInto(statB, ...args);
   }, ...tc);
 });
-
-test("zenfs rejects", async () => {
-  expect(() => zenfs.statSync("/N/A")).toThrow(/async/);
-  expect(() => zenfs.readdirSync("/N/A")).toThrow(/async/);
-  await expect(zenfs.promises.appendFile("/N/A/B.bin", "tail")).rejects.toThrow(/read-only/);
-  expect(() => zenfs.readFileSync("/N/A/B.bin")).toThrow(/async/);
-  expect(() => zenfs.openSync("/N/A/B.bin", "r")).toThrow(/async/);
-});
-
-test("zenfs stat", async () => {
-  const statRoot = await zenfs.promises.stat("/N");
-  expect(statRoot.isDirectory()).toBeTruthy();
-
-  const statA = await zenfs.promises.stat("/N/A");
-  expect(statA.isDirectory()).toBeTruthy();
-
-  const statB = await zenfs.promises.stat("/N/A/B.bin");
-  expect(statB.isFile()).toBeTruthy();
-  expect(statB.size).toBe(bodyB.length);
-});
-
-describe("zenfs open", () => {
-  let fh: zenfs.promises.FileHandle;
-  beforeAll(async () => {
-    fh = await zenfs.promises.open("/N/A/B.bin", "r");
-  });
-  afterAll(async () => {
-    await fh.close();
-  });
-
-  test("stat", async () => {
-    expect((await fh.stat()).size).toBe(bodyB.length);
-  });
-
-  test.each(readFileIntoCases)("read [%d,%d)", async (...tc) => {
-    await testReadFileInto(async (...args) => {
-      await fh.read(...args);
-    }, ...tc);
-  });
-});
-
-test("zenfs readdir", async () => {
-  await expect(zenfs.promises.readdir("/N")).resolves.toEqual(["A"]);
-  await expect(zenfs.promises.readdir("/N/A")).resolves.toEqual(["B.bin"]);
-});
-
-test("zenfs readFile", async () => {
-  await expect(zenfs.promises.readFile("/N/A/B.bin")).resolves.toEqualUint8Array(bodyB);
-});

pkg/fileserver/tests/client.t.ts

@@ -31,7 +31,6 @@
     "@ndn/naming-convention2": "workspace:*",
     "@ndn/packet": "workspace:*",
     "@ndn/util": "workspace:*",
-    "@zenfs/core": "~2.5.6",
     "it-keepalive": "^1.2.0",
     "obliterator": "^2.0.5",
     "p-lazy": "^5.0.0",