@transloadit/convex 0.0.3 → 0.0.5

package/src/debug/index.ts

@@ -0,0 +1,84 @@
+type ConsoleSink = Pick<Console, "log" | "info" | "warn" | "error">;
+
+export type DebugLogger = {
+  enabled: boolean;
+  log: (message: string, meta?: Record<string, unknown>) => void;
+  info: (message: string, meta?: Record<string, unknown>) => void;
+  warn: (message: string, meta?: Record<string, unknown>) => void;
+  error: (message: string, meta?: Record<string, unknown>) => void;
+  event: (name: string, meta?: Record<string, unknown>) => void;
+  child: (namespace: string) => DebugLogger;
+};
+
+export type DebugLoggerOptions = {
+  namespace?: string;
+  enabled?: boolean;
+  sink?: ConsoleSink;
+  clock?: () => Date;
+};
+
+const resolveEnv = (): Record<string, string | undefined> => {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env;
+  }
+  return {};
+};
+
+const parseEnabled = (value: string | undefined) => {
+  if (!value) return false;
+  const normalized = value.trim().toLowerCase();
+  return normalized === "1" || normalized === "true" || normalized === "yes";
+};
+
+const formatLine = (
+  timestamp: string,
+  prefix: string,
+  message: string,
+  meta?: Record<string, unknown>,
+) => {
+  if (!meta || Object.keys(meta).length === 0) {
+    return `${timestamp} ${prefix} ${message}`;
+  }
+  return `${timestamp} ${prefix} ${message} ${JSON.stringify(meta)}`;
+};
+
+export const createDebugLogger = (
+  options: DebugLoggerOptions = {},
+): DebugLogger => {
+  const env = resolveEnv();
+  const enabled =
+    options.enabled ??
+    (parseEnabled(env.TRANSLOADIT_DEBUG) ||
+      parseEnabled(env.CONVEX_TRANSLOADIT_DEBUG));
+  const namespace = options.namespace ?? "convex";
+  const prefix = `[transloadit:${namespace}]`;
+  const sink: ConsoleSink = options.sink ?? console;
+  const clock = options.clock ?? (() => new Date());
+
+  const emit = (
+    level: "log" | "info" | "warn" | "error",
+    message: string,
+    meta?: Record<string, unknown>,
+  ) => {
+    if (!enabled) return;
+    const line = formatLine(clock().toISOString(), prefix, message, meta);
+    sink[level](line);
+  };
+
+  const logger: DebugLogger = {
+    enabled,
+    log: (message, meta) => emit("log", message, meta),
+    info: (message, meta) => emit("info", message, meta),
+    warn: (message, meta) => emit("warn", message, meta),
+    error: (message, meta) => emit("error", message, meta),
+    event: (name, meta) => emit("info", `event:${name}`, meta),
+    child: (childNamespace) =>
+      createDebugLogger({
+        ...options,
+        namespace: `${namespace}:${childNamespace}`,
+        enabled,
+      }),
+  };
+
+  return logger;
+};

package/src/react/index.test.tsx

@@ -0,0 +1,340 @@
+/// <reference types="vite/client" />
+// @vitest-environment jsdom
+
+import { renderHook } from "@testing-library/react";
+import type { FunctionReference } from "convex/server";
+import { act } from "react";
+import { afterEach, describe, expect, test, vi } from "vitest";
+import type {
+  CreateAssemblyFn,
+  GetAssemblyStatusFn,
+  ListResultsFn,
+  RefreshAssemblyFn,
+  UppyLike,
+} from "./index.tsx";
+import {
+  useAssemblyStatusWithPolling,
+  useTransloaditUpload,
+  useTransloaditUppy,
+} from "./index.tsx";
+
+(
+  globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }
+).IS_REACT_ACT_ENVIRONMENT = true;
+
+let currentStatus: unknown = null;
+let currentResults: unknown = null;
+let queryHandler: (fn: unknown, args: unknown) => unknown = () => currentStatus;
+const refreshMock = vi.hoisted(() => vi.fn(() => Promise.resolve()));
+const actionMock = vi.hoisted(() => vi.fn((fn: unknown) => fn));
+const queryMock = vi.hoisted(() => vi.fn());
+
+vi.mock("convex/react", () => ({
+  useQuery: queryMock,
+  useAction: actionMock,
+}));
+
+vi.mock("tus-js-client", () => {
+  type UploadOptions = {
+    endpoint?: string;
+    onUploadUrlAvailable?: () => void;
+    onProgress?: (bytesUploaded: number, bytesTotal: number) => void;
+    onSuccess?: () => void;
+  };
+
+  return {
+    Upload: class MockUpload {
+      url?: string;
+      private options: UploadOptions;
+      constructor(_file: File, options: UploadOptions) {
+        this.options = options;
+        this.url = options?.endpoint
+          ? `${options.endpoint}/upload`
+          : "https://tus.mock/upload";
+      }
+      start() {
+        this.options?.onUploadUrlAvailable?.();
+        this.options?.onProgress?.(1, 1);
+        this.options?.onSuccess?.();
+      }
+      abort() {
+        // no-op for tests
+      }
+    },
+  };
+});
+
+const noopGetStatus = (() => null) as unknown as Parameters<
+  typeof useAssemblyStatusWithPolling
+>[0];
+const noopRefresh = refreshMock as unknown as RefreshAssemblyFn;
+
+queryMock.mockImplementation((fn, args) => queryHandler(fn, args));
+
+describe("useAssemblyStatusWithPolling", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+    refreshMock.mockClear();
+    actionMock.mockClear();
+    queryMock.mockClear();
+    currentResults = null;
+    currentStatus = null;
+    queryHandler = () => currentStatus;
+    queryMock.mockImplementation((fn, args) => queryHandler(fn, args));
+  });
+
+  test("does not trigger immediate refresh on status change", async () => {
+    vi.useFakeTimers();
+    currentStatus = { ok: "ASSEMBLY_UPLOADING" };
+
+    const { rerender, unmount } = renderHook(
+      ({ assemblyId }: { assemblyId: string }) =>
+        useAssemblyStatusWithPolling(noopGetStatus, noopRefresh, assemblyId, {
+          pollIntervalMs: 1000,
+        }),
+      { initialProps: { assemblyId: "asm_1" } },
+    );
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    expect(refreshMock).toHaveBeenCalledTimes(1);
+
+    await act(async () => {
+      vi.advanceTimersByTime(1000);
+      await Promise.resolve();
+    });
+
+    expect(refreshMock).toHaveBeenCalledTimes(2);
+
+    currentStatus = { ok: "ASSEMBLY_COMPLETED" };
+    rerender({ assemblyId: "asm_1" });
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    expect(refreshMock).toHaveBeenCalledTimes(2);
+
+    unmount();
+  });
+
+  test("does not overlap refresh calls", async () => {
+    vi.useFakeTimers();
+    currentStatus = { ok: "ASSEMBLY_UPLOADING" };
+    let resolveRefresh: (() => void) | null = null;
+    refreshMock.mockImplementation(
+      () =>
+        new Promise<void>((resolve) => {
+          resolveRefresh = resolve;
+        }),
+    );
+
+    const { unmount } = renderHook(() =>
+      useAssemblyStatusWithPolling(noopGetStatus, noopRefresh, "asm_overlap", {
+        pollIntervalMs: 1000,
+      }),
+    );
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    expect(refreshMock).toHaveBeenCalledTimes(1);
+
+    await act(async () => {
+      vi.advanceTimersByTime(3000);
+      await Promise.resolve();
+    });
+
+    expect(refreshMock).toHaveBeenCalledTimes(1);
+
+    await act(async () => {
+      resolveRefresh?.();
+      await Promise.resolve();
+    });
+
+    await act(async () => {
+      vi.advanceTimersByTime(1000);
+      await Promise.resolve();
+    });
+
+    expect(refreshMock).toHaveBeenCalledTimes(2);
+
+    unmount();
+  });
+});
+
+describe("useTransloaditUpload", () => {
+  afterEach(() => {
+    actionMock.mockClear();
+    queryMock.mockClear();
+    currentResults = null;
+    currentStatus = null;
+    queryHandler = () => currentStatus;
+  });
+
+  test("uploads files and exposes status/results", async () => {
+    const createAssembly = vi.fn(async () => ({
+      assemblyId: "asm_123",
+      data: {
+        tus_url: "https://tus.example.com",
+        assembly_ssl_url: "https://api2.transloadit.com/assemblies/asm_123",
+      },
+    }));
+
+    const getStatus = {} as GetAssemblyStatusFn;
+    const listResults = {} as ListResultsFn;
+    const refreshAssembly = refreshMock as unknown as RefreshAssemblyFn;
+    currentStatus = { raw: { ok: "ASSEMBLY_UPLOADING" } };
+    currentResults = [{ stepName: "resize", raw: { ssl_url: "https://file" } }];
+    queryHandler = (fn) => {
+      if (fn === getStatus) return currentStatus;
+      if (fn === listResults) return currentResults;
+      return null;
+    };
+    queryMock.mockImplementation((fn, args) => queryHandler(fn, args));
+
+    const { result } = renderHook(() =>
+      useTransloaditUpload({
+        createAssembly: createAssembly as unknown as CreateAssemblyFn,
+        getStatus,
+        listResults,
+        refreshAssembly,
+      }),
+    );
+
+    const file = new File(["hello"], "hello.txt", { type: "text/plain" });
+
+    await act(async () => {
+      await result.current.upload([file], {
+        steps: { resize: { robot: "/image/resize" } },
+      });
+    });
+
+    expect(createAssembly).toHaveBeenCalled();
+    expect(result.current.assemblyId).toBe("asm_123");
+    expect(result.current.results).toEqual(currentResults);
+    expect(result.current.status?.ok).toBe("ASSEMBLY_UPLOADING");
+  });
+
+  test("reset clears upload state", async () => {
+    const createAssembly = vi.fn(async () => ({
+      assemblyId: "asm_reset",
+      data: {
+        tus_url: "https://tus.example.com",
+        assembly_ssl_url: "https://api2.transloadit.com/assemblies/asm_reset",
+      },
+    }));
+
+    const getStatus = {} as GetAssemblyStatusFn;
+    const listResults = {} as ListResultsFn;
+    const refreshAssembly = refreshMock as unknown as RefreshAssemblyFn;
+    currentStatus = { raw: { ok: "ASSEMBLY_UPLOADING" } };
+    currentResults = [{ stepName: "resize", raw: { ssl_url: "https://file" } }];
+    queryHandler = (fn) => {
+      if (fn === getStatus) return currentStatus;
+      if (fn === listResults) return currentResults;
+      return null;
+    };
+    queryMock.mockImplementation((fn, args) => queryHandler(fn, args));
+
+    const { result } = renderHook(() =>
+      useTransloaditUpload({
+        createAssembly: createAssembly as unknown as CreateAssemblyFn,
+        getStatus,
+        listResults,
+        refreshAssembly,
+      }),
+    );
+
+    const file = new File(["hello"], "hello.txt", { type: "text/plain" });
+
+    await act(async () => {
+      await result.current.upload([file], {
+        steps: { resize: { robot: "/image/resize" } },
+      });
+    });
+
+    expect(result.current.assemblyId).toBe("asm_reset");
+
+    act(() => {
+      result.current.reset();
+    });
+
+    expect(result.current.assemblyId).toBeNull();
+    expect(result.current.error).toBeNull();
+  });
+});
+
+describe("useTransloaditUppy", () => {
+  afterEach(() => {
+    actionMock.mockClear();
+    queryMock.mockClear();
+    currentResults = null;
+    currentStatus = null;
+    queryHandler = () => currentStatus;
+    queryMock.mockImplementation((fn, args) => queryHandler(fn, args));
+  });
+
+  test("uploads via uppy and exposes status/results", async () => {
+    const createAssembly = vi.fn(async () => ({
+      assemblyId: "asm_uppy",
+      data: {
+        tus_url: "https://tus.example.com",
+        assembly_ssl_url: "https://api2.transloadit.com/assemblies/asm_uppy",
+      },
+    }));
+
+    const uppy = {
+      getFiles: () => [
+        {
+          id: "file-1",
+          data: new File(["hello"], "hello.jpg", { type: "image/jpeg" }),
+        },
+      ],
+      setFileMeta: vi.fn(),
+      setFileState: vi.fn(),
+      getPlugin: vi.fn(() => ({ setOptions: vi.fn() })),
+      upload: vi.fn(async () => ({ successful: [{ id: "file-1" }] })),
+    } as unknown as UppyLike;
+
+    const getStatus = {} as GetAssemblyStatusFn;
+    const listResults = {} as ListResultsFn;
+    const refreshAssembly = refreshMock as unknown as RefreshAssemblyFn;
+    currentStatus = { raw: { ok: "ASSEMBLY_UPLOADING" } };
+    currentResults = [{ stepName: "resize", raw: { ssl_url: "https://file" } }];
+    queryHandler = (fn) => {
+      if (fn === getStatus) return currentStatus;
+      if (fn === listResults) return currentResults;
+      return null;
+    };
+    queryMock.mockImplementation((fn, args) => queryHandler(fn, args));
+
+    const { result } = renderHook(() =>
+      useTransloaditUppy({
+        uppy,
+        createAssembly: createAssembly as unknown as FunctionReference<
+          "action",
+          "public",
+          { fileCount: number },
+          { assemblyId: string; data: Record<string, unknown> }
+        >,
+        getStatus,
+        listResults,
+        refreshAssembly,
+      }),
+    );
+
+    await act(async () => {
+      await result.current.startUpload();
+    });
+
+    expect(createAssembly).toHaveBeenCalled();
+    expect(uppy.upload).toHaveBeenCalled();
+    expect(result.current.assemblyId).toBe("asm_uppy");
+    expect(result.current.results).toEqual(currentResults);
+    expect(result.current.status?.ok).toBe("ASSEMBLY_UPLOADING");
+  });
+});