@donkeylabs/server 2.0.19 → 2.0.21

package/src/core/process-adapter-kysely.ts

@@ -43,6 +43,7 @@ export class KyselyProcessAdapter implements ProcessAdapter {
   private db: Kysely<Database>;
   private cleanupTimer?: ReturnType<typeof setInterval>;
   private cleanupDays: number;
+  private stopped = false;
 
   constructor(db: Kysely<any>, config: KyselyProcessAdapterConfig = {}) {
     this.db = db as Kysely<Database>;
@@ -57,7 +58,16 @@ export class KyselyProcessAdapter implements ProcessAdapter {
     }
   }
 
+  /** Check if adapter is stopped (for safe database access) */
+  private checkStopped(): boolean {
+    return this.stopped;
+  }
+
   async create(process: Omit<ManagedProcess, "id">): Promise<ManagedProcess> {
+    if (this.checkStopped()) {
+      throw new Error("ProcessAdapter has been stopped");
+    }
+
     const id = `proc_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
 
     await this.db
@@ -85,17 +95,27 @@ export class KyselyProcessAdapter implements ProcessAdapter {
   }
 
   async get(processId: string): Promise<ManagedProcess | null> {
-    const row = await this.db
-      .selectFrom("__donkeylabs_processes__")
-      .selectAll()
-      .where("id", "=", processId)
-      .executeTakeFirst();
+    if (this.checkStopped()) return null;
 
-    if (!row) return null;
-    return this.rowToProcess(row);
+    try {
+      const row = await this.db
+        .selectFrom("__donkeylabs_processes__")
+        .selectAll()
+        .where("id", "=", processId)
+        .executeTakeFirst();
+
+      if (!row) return null;
+      return this.rowToProcess(row);
+    } catch (err: any) {
+      // Silently ignore errors if adapter was stopped during query
+      if (this.stopped && err?.message?.includes("destroyed")) return null;
+      throw err;
+    }
   }
 
   async update(processId: string, updates: Partial<ManagedProcess>): Promise<void> {
+    if (this.checkStopped()) return;
+
     const updateData: Partial<ProcessesTable> = {};
 
     if (updates.pid !== undefined) {
@@ -137,14 +157,22 @@ export class KyselyProcessAdapter implements ProcessAdapter {
 
     if (Object.keys(updateData).length === 0) return;
 
-    await this.db
-      .updateTable("__donkeylabs_processes__")
-      .set(updateData)
-      .where("id", "=", processId)
-      .execute();
+    try {
+      await this.db
+        .updateTable("__donkeylabs_processes__")
+        .set(updateData)
+        .where("id", "=", processId)
+        .execute();
+    } catch (err: any) {
+      // Silently ignore errors if adapter was stopped during query
+      if (this.stopped && err?.message?.includes("destroyed")) return;
+      throw err;
+    }
   }
 
   async delete(processId: string): Promise<boolean> {
+    if (this.checkStopped()) return false;
+
     // Check if exists first since BunSqliteDialect doesn't report numDeletedRows properly
     const exists = await this.db
       .selectFrom("__donkeylabs_processes__")
@@ -163,6 +191,8 @@ export class KyselyProcessAdapter implements ProcessAdapter {
   }
 
   async getByName(name: string): Promise<ManagedProcess[]> {
+    if (this.checkStopped()) return [];
+
     const rows = await this.db
       .selectFrom("__donkeylabs_processes__")
       .selectAll()
@@ -174,18 +204,28 @@ export class KyselyProcessAdapter implements ProcessAdapter {
   }
 
   async getRunning(): Promise<ManagedProcess[]> {
-    const rows = await this.db
-      .selectFrom("__donkeylabs_processes__")
-      .selectAll()
-      .where((eb) =>
-        eb.or([eb("status", "=", "running"), eb("status", "=", "spawning")])
-      )
-      .execute();
+    if (this.checkStopped()) return [];
 
-    return rows.map((r) => this.rowToProcess(r));
+    try {
+      const rows = await this.db
+        .selectFrom("__donkeylabs_processes__")
+        .selectAll()
+        .where((eb) =>
+          eb.or([eb("status", "=", "running"), eb("status", "=", "spawning")])
+        )
+        .execute();
+
+      return rows.map((r) => this.rowToProcess(r));
+    } catch (err: any) {
+      // Silently ignore errors if adapter was stopped during query
+      if (this.stopped && err?.message?.includes("destroyed")) return [];
+      throw err;
+    }
   }
 
   async getOrphaned(): Promise<ManagedProcess[]> {
+    if (this.checkStopped()) return [];
+
     const rows = await this.db
       .selectFrom("__donkeylabs_processes__")
       .selectAll()
@@ -223,7 +263,7 @@ export class KyselyProcessAdapter implements ProcessAdapter {
 
   /** Clean up old stopped/crashed processes */
   private async cleanup(): Promise<void> {
-    if (this.cleanupDays <= 0) return;
+    if (this.cleanupDays <= 0 || this.checkStopped()) return;
 
     try {
       const cutoff = new Date();
@@ -252,6 +292,7 @@ export class KyselyProcessAdapter implements ProcessAdapter {
 
   /** Stop the adapter and cleanup timer */
   stop(): void {
+    this.stopped = true;
     if (this.cleanupTimer) {
       clearInterval(this.cleanupTimer);
       this.cleanupTimer = undefined;

package/src/core/storage-adapter-local.test.ts

@@ -0,0 +1,199 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { rm, mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { createStorage } from "./storage";
+
+const TEST_DIR = "/tmp/donkeylabs-storage-test";
+
+describe("LocalStorageAdapter", () => {
+  beforeEach(async () => {
+    // Clean up test directory
+    if (existsSync(TEST_DIR)) {
+      await rm(TEST_DIR, { recursive: true });
+    }
+    await mkdir(TEST_DIR, { recursive: true });
+  });
+
+  afterEach(async () => {
+    // Clean up test directory
+    if (existsSync(TEST_DIR)) {
+      await rm(TEST_DIR, { recursive: true });
+    }
+  });
+
+  it("should upload and download a file", async () => {
+    const storage = createStorage({
+      provider: "local",
+      directory: TEST_DIR,
+      baseUrl: "/files",
+    });
+
+    const result = await storage.upload({
+      key: "test/hello.txt",
+      body: "Hello, Local Storage!",
+      contentType: "text/plain",
+      visibility: "public",
+    });
+
+    expect(result.key).toBe("test/hello.txt");
+    expect(result.size).toBe(21);
+    expect(result.url).toBe("/files/test/hello.txt");
+
+    // Verify file exists on disk
+    const filePath = join(TEST_DIR, "test/hello.txt");
+    expect(existsSync(filePath)).toBe(true);
+    const content = await readFile(filePath, "utf-8");
+    expect(content).toBe("Hello, Local Storage!");
+
+    // Download the file
+    const downloaded = await storage.download("test/hello.txt");
+    expect(downloaded).not.toBeNull();
+
+    const reader = downloaded!.body.getReader();
+    const chunks: Uint8Array[] = [];
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+    }
+    const text = new TextDecoder().decode(Buffer.concat(chunks));
+    expect(text).toBe("Hello, Local Storage!");
+  });
+
+  it("should store and retrieve metadata", async () => {
+    const storage = createStorage({
+      provider: "local",
+      directory: TEST_DIR,
+    });
+
+    await storage.upload({
+      key: "with-meta.txt",
+      body: "test",
+      contentType: "text/plain",
+      metadata: { author: "tester", version: "1.0" },
+      visibility: "private",
+    });
+
+    const head = await storage.head("with-meta.txt");
+    expect(head).not.toBeNull();
+    expect(head!.contentType).toBe("text/plain");
+    expect(head!.metadata).toEqual({ author: "tester", version: "1.0" });
+    expect(head!.visibility).toBe("private");
+
+    // Verify metadata file exists
+    const metaPath = join(TEST_DIR, ".with-meta.txt.meta.json");
+    expect(existsSync(metaPath)).toBe(true);
+  });
+
+  it("should delete files and metadata", async () => {
+    const storage = createStorage({
+      provider: "local",
+      directory: TEST_DIR,
+    });
+
+    await storage.upload({
+      key: "to-delete.txt",
+      body: "delete me",
+      metadata: { temp: "true" },
+    });
+
+    const filePath = join(TEST_DIR, "to-delete.txt");
+    const metaPath = join(TEST_DIR, ".to-delete.txt.meta.json");
+
+    expect(existsSync(filePath)).toBe(true);
+    expect(existsSync(metaPath)).toBe(true);
+
+    await storage.delete("to-delete.txt");
+
+    expect(existsSync(filePath)).toBe(false);
+    expect(existsSync(metaPath)).toBe(false);
+  });
+
+  it("should list files", async () => {
+    const storage = createStorage({
+      provider: "local",
+      directory: TEST_DIR,
+    });
+
+    await storage.upload({ key: "a/1.txt", body: "a1" });
+    await storage.upload({ key: "a/2.txt", body: "a2" });
+    await storage.upload({ key: "b/1.txt", body: "b1" });
+    await storage.upload({ key: "root.txt", body: "root" });
+
+    const allFiles = await storage.list();
+    // Filter out metadata files from count
+    const dataFiles = allFiles.files.filter((f) => !f.key.includes(".meta.json"));
+    expect(dataFiles.length).toBe(4);
+  });
+
+  it("should copy files", async () => {
+    const storage = createStorage({
+      provider: "local",
+      directory: TEST_DIR,
+    });
+
+    await storage.upload({
+      key: "original.txt",
+      body: "Original",
+      contentType: "text/plain",
+    });
+
+    await storage.copy({
+      source: "original.txt",
+      destination: "copy.txt",
+    });
+
+    expect(existsSync(join(TEST_DIR, "original.txt"))).toBe(true);
+    expect(existsSync(join(TEST_DIR, "copy.txt"))).toBe(true);
+
+    const copyContent = await readFile(join(TEST_DIR, "copy.txt"), "utf-8");
+    expect(copyContent).toBe("Original");
+  });
+
+  it("should move files", async () => {
+    const storage = createStorage({
+      provider: "local",
+      directory: TEST_DIR,
+    });
+
+    await storage.upload({
+      key: "to-move.txt",
+      body: "Moving",
+    });
+
+    await storage.move("to-move.txt", "moved.txt");
+
+    expect(existsSync(join(TEST_DIR, "to-move.txt"))).toBe(false);
+    expect(existsSync(join(TEST_DIR, "moved.txt"))).toBe(true);
+  });
+
+  it("should handle various body types", async () => {
+    const storage = createStorage({
+      provider: "local",
+      directory: TEST_DIR,
+    });
+
+    // String body
+    await storage.upload({
+      key: "string.txt",
+      body: "string content",
+    });
+
+    // Buffer body
+    await storage.upload({
+      key: "buffer.txt",
+      body: Buffer.from("buffer content"),
+    });
+
+    // Uint8Array body
+    await storage.upload({
+      key: "uint8.txt",
+      body: new TextEncoder().encode("uint8 content"),
+    });
+
+    expect(await readFile(join(TEST_DIR, "string.txt"), "utf-8")).toBe("string content");
+    expect(await readFile(join(TEST_DIR, "buffer.txt"), "utf-8")).toBe("buffer content");
+    expect(await readFile(join(TEST_DIR, "uint8.txt"), "utf-8")).toBe("uint8 content");
+  });
+});

package/src/core/storage.test.ts

@@ -0,0 +1,197 @@
+import { describe, it, expect } from "bun:test";
+import { createStorage, MemoryStorageAdapter } from "./storage";
+
+describe("Storage Service", () => {
+  describe("MemoryStorageAdapter", () => {
+    it("should upload and download a file", async () => {
+      const storage = createStorage({ provider: "memory" });
+
+      const result = await storage.upload({
+        key: "test/hello.txt",
+        body: "Hello, World!",
+        contentType: "text/plain",
+        visibility: "public",
+      });
+
+      expect(result.key).toBe("test/hello.txt");
+      expect(result.size).toBe(13);
+      expect(result.url).toBe("memory://test/hello.txt");
+
+      const downloaded = await storage.download("test/hello.txt");
+      expect(downloaded).not.toBeNull();
+      expect(downloaded!.contentType).toBe("text/plain");
+
+      // Read stream content
+      const reader = downloaded!.body.getReader();
+      const { value } = await reader.read();
+      const text = new TextDecoder().decode(value);
+      expect(text).toBe("Hello, World!");
+    });
+
+    it("should return null for non-existent file", async () => {
+      const storage = createStorage({ provider: "memory" });
+      const result = await storage.download("nonexistent.txt");
+      expect(result).toBeNull();
+    });
+
+    it("should check file existence", async () => {
+      const storage = createStorage({ provider: "memory" });
+
+      await storage.upload({
+        key: "exists.txt",
+        body: "test",
+      });
+
+      expect(await storage.exists("exists.txt")).toBe(true);
+      expect(await storage.exists("doesnt-exist.txt")).toBe(false);
+    });
+
+    it("should delete a file", async () => {
+      const storage = createStorage({ provider: "memory" });
+
+      await storage.upload({
+        key: "to-delete.txt",
+        body: "delete me",
+      });
+
+      expect(await storage.delete("to-delete.txt")).toBe(true);
+      expect(await storage.exists("to-delete.txt")).toBe(false);
+      expect(await storage.delete("to-delete.txt")).toBe(false); // Already deleted
+    });
+
+    it("should list files with prefix", async () => {
+      const storage = createStorage({ provider: "memory" });
+
+      await storage.upload({ key: "users/1/avatar.png", body: "img" });
+      await storage.upload({ key: "users/1/banner.png", body: "img" });
+      await storage.upload({ key: "users/2/avatar.png", body: "img" });
+      await storage.upload({ key: "products/1.jpg", body: "img" });
+
+      const usersResult = await storage.list({ prefix: "users/" });
+      expect(usersResult.files.length).toBe(3);
+
+      const user1Result = await storage.list({ prefix: "users/1/" });
+      expect(user1Result.files.length).toBe(2);
+
+      const allResult = await storage.list();
+      expect(allResult.files.length).toBe(4);
+    });
+
+    it("should list with delimiter for directory-like listing", async () => {
+      const storage = createStorage({ provider: "memory" });
+
+      await storage.upload({ key: "a/1.txt", body: "a" });
+      await storage.upload({ key: "a/2.txt", body: "a" });
+      await storage.upload({ key: "b/1.txt", body: "b" });
+      await storage.upload({ key: "root.txt", body: "root" });
+
+      const result = await storage.list({ delimiter: "/" });
+      expect(result.files.length).toBe(1); // root.txt only
+      expect(result.files[0].key).toBe("root.txt");
+      expect(result.prefixes).toContain("a/");
+      expect(result.prefixes).toContain("b/");
+    });
+
+    it("should get file metadata with head", async () => {
+      const storage = createStorage({ provider: "memory" });
+
+      await storage.upload({
+        key: "meta-test.txt",
+        body: "Hello",
+        contentType: "text/plain",
+        metadata: { author: "test" },
+        visibility: "private",
+      });
+
+      const head = await storage.head("meta-test.txt");
+      expect(head).not.toBeNull();
+      expect(head!.key).toBe("meta-test.txt");
+      expect(head!.size).toBe(5);
+      expect(head!.contentType).toBe("text/plain");
+      expect(head!.metadata).toEqual({ author: "test" });
+      expect(head!.visibility).toBe("private");
+    });
+
+    it("should copy a file", async () => {
+      const storage = createStorage({ provider: "memory" });
+
+      await storage.upload({
+        key: "original.txt",
+        body: "Original content",
+        contentType: "text/plain",
+      });
+
+      const result = await storage.copy({
+        source: "original.txt",
+        destination: "copy.txt",
+      });
+
+      expect(result.key).toBe("copy.txt");
+      expect(await storage.exists("original.txt")).toBe(true);
+      expect(await storage.exists("copy.txt")).toBe(true);
+    });
+
+    it("should move a file", async () => {
+      const storage = createStorage({ provider: "memory" });
+
+      await storage.upload({
+        key: "to-move.txt",
+        body: "Moving",
+      });
+
+      const result = await storage.move("to-move.txt", "moved.txt");
+
+      expect(result.key).toBe("moved.txt");
+      expect(await storage.exists("to-move.txt")).toBe(false);
+      expect(await storage.exists("moved.txt")).toBe(true);
+    });
+
+    it("should delete multiple files", async () => {
+      const storage = createStorage({ provider: "memory" });
+
+      await storage.upload({ key: "batch/1.txt", body: "1" });
+      await storage.upload({ key: "batch/2.txt", body: "2" });
+      await storage.upload({ key: "batch/3.txt", body: "3" });
+
+      const result = await storage.deleteMany([
+        "batch/1.txt",
+        "batch/2.txt",
+        "batch/nonexistent.txt",
+      ]);
+
+      expect(result.deleted).toContain("batch/1.txt");
+      expect(result.deleted).toContain("batch/2.txt");
+      expect(result.errors).toContain("batch/nonexistent.txt");
+      expect(await storage.exists("batch/3.txt")).toBe(true);
+    });
+
+    it("should handle pagination", async () => {
+      const storage = createStorage({ provider: "memory" });
+
+      // Create 10 files
+      for (let i = 0; i < 10; i++) {
+        await storage.upload({ key: `page/${i}.txt`, body: String(i) });
+      }
+
+      // Get first page
+      const page1 = await storage.list({ prefix: "page/", limit: 3 });
+      expect(page1.files.length).toBe(3);
+      expect(page1.hasMore).toBe(true);
+      expect(page1.cursor).not.toBeNull();
+
+      // Get second page
+      const page2 = await storage.list({
+        prefix: "page/",
+        limit: 3,
+        cursor: page1.cursor!,
+      });
+      expect(page2.files.length).toBe(3);
+      expect(page2.hasMore).toBe(true);
+
+      // Ensure no duplicates
+      const page1Keys = page1.files.map((f) => f.key);
+      const page2Keys = page2.files.map((f) => f.key);
+      expect(page1Keys.some((k) => page2Keys.includes(k))).toBe(false);
+    });
+  });
+});