Initial Commit

packages/persistence/storage/storage-uri/tests/integration/cross-scheme.test.ts

@@ -0,0 +1,108 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createNodeFsStorage } from "@suaveplan/storage-file";
+import { createHttpStorage } from "@suaveplan/storage-http";
+import {
+    afterEach,
+    beforeEach,
+    describe,
+    expect,
+    it,
+} from "@suaveplan/testing/runner";
+import type { StorageLike } from "@suaveplan/types";
+import { createStorageUriResolver } from "../../src/index.js";
+import type { UriPlugin } from "../../src/types/plugin.types.js";
+
+function fileUriPlugin(adapter: StorageLike, rootDir: string): UriPlugin {
+    return {
+        scheme: "file",
+        adapter,
+        parse(uri) {
+            // file:///abs/path → key relative to rootDir.
+            const prefix = "file://";
+            const rest = uri.startsWith(prefix)
+                ? uri.slice(prefix.length)
+                : uri;
+            const abs = rest.startsWith("/") ? rest : `/${rest}`;
+            const root = rootDir.endsWith("/") ? rootDir : `${rootDir}/`;
+            const key = abs.startsWith(root)
+                ? abs.slice(root.length)
+                : abs.replace(/^\//, "");
+            return { key };
+        },
+        build(key) {
+            const root = rootDir.endsWith("/") ? rootDir : `${rootDir}/`;
+            return `file://${root}${key}`;
+        },
+    };
+}
+
+function httpsUriPlugin(adapter: StorageLike): UriPlugin {
+    return {
+        scheme: "https",
+        adapter,
+        parse(uri) {
+            const url = new URL(uri);
+            return {
+                key: url.pathname.replace(/^\//, ""),
+                meta: { host: url.host },
+            };
+        },
+    };
+}
+
+describe("cross-scheme integration", () => {
+    let root: string;
+
+    beforeEach(async () => {
+        root = await mkdtemp(join(tmpdir(), "storage-uri-int-"));
+    });
+
+    afterEach(async () => {
+        await rm(root, { recursive: true, force: true });
+    });
+
+    it("composes a resolver with real storage-file and storage-http adapters", {
+        timeout: 15000,
+    }, async () => {
+        const fileAdapter = createNodeFsStorage({ rootDir: root });
+
+        // In-process fetch stub serving a single payload at a known URL.
+        const payload = new TextEncoder().encode("from-http");
+        const httpAdapter = createHttpStorage({
+            baseUrl: "https://origin.test/",
+            fetch: async (input: unknown) => {
+                const url =
+                    typeof input === "string"
+                        ? input
+                        : input instanceof URL
+                          ? input.toString()
+                          : input instanceof Request
+                            ? input.url
+                            : String((input as { url?: string }).url ?? input);
+                if (url.endsWith("/poster.bin")) {
+                    return new Response(payload, { status: 200 });
+                }
+                return new Response("not found", { status: 404 });
+            },
+        });
+
+        const resolver = createStorageUriResolver([
+            fileUriPlugin(fileAdapter, root),
+            httpsUriPlugin(httpAdapter),
+        ]);
+
+        // HTTP read.
+        const httpBytes = await resolver.read("https://origin.test/poster.bin");
+        expect(new TextDecoder().decode(httpBytes)).toBe("from-http");
+
+        // File round-trip via resolver.
+        const fileUri = `file://${root}/cache/copy.bin`;
+        await resolver.write(fileUri, httpBytes);
+        const back = await resolver.read(fileUri);
+        expect(new TextDecoder().decode(back)).toBe("from-http");
+
+        expect(await resolver.exists(fileUri)).toBe(true);
+    });
+});