@uploadista/server 0.0.13-beta.4 → 0.0.13

package/{src/__tests__ → tests}/backward-compatibility.test.ts

@@ -14,7 +14,7 @@ import { describe, expect, it } from "vitest";
 describe("Deprecated plugins-typing module", () => {
   it("should still be importable", async () => {
     // Import from deprecated module - should not throw
-    const pluginsTyping = await import("../plugins-typing");
+    const pluginsTyping = await import("../src/plugins-typing");
 
     // Module should exist
     expect(pluginsTyping).toBeDefined();
@@ -40,21 +40,21 @@ describe("Deprecated plugins-typing module", () => {
 
 describe("Deprecated createTypeSafeServer", () => {
   it("should still be exported from core module", async () => {
-    const coreModule = await import("../core");
+    const coreModule = await import("../src/core");
 
     expect(coreModule).toHaveProperty("createTypeSafeServer");
     expect(typeof coreModule.createTypeSafeServer).toBe("function");
   });
 
   it("should be exported from create-type-safe-server module", async () => {
-    const module = await import("../core/create-type-safe-server");
+    const module = await import("../src/core/create-type-safe-server");
 
     expect(module).toHaveProperty("createTypeSafeServer");
     expect(typeof module.createTypeSafeServer).toBe("function");
   });
 
   it("should export helper functions", async () => {
-    const module = await import("../core/create-type-safe-server");
+    const module = await import("../src/core/create-type-safe-server");
 
     expect(module).toHaveProperty("defineFlow");
     expect(module).toHaveProperty("defineSimpleFlow");
@@ -69,7 +69,7 @@ describe("Deprecated createTypeSafeServer", () => {
 
 describe("New module exports", () => {
   it("should export runtime utilities from core module", async () => {
-    const coreModule = await import("../core");
+    const coreModule = await import("../src/core");
 
     // Runtime validation (these are actual runtime functions)
     expect(coreModule).toHaveProperty("validatePluginRequirements");
@@ -86,7 +86,7 @@ describe("New module exports", () => {
   });
 
   it("should export plugin validation utilities", async () => {
-    const validationModule = await import("../core/plugin-validation");
+    const validationModule = await import("../src/core/plugin-validation");
 
     expect(validationModule).toHaveProperty("validatePluginRequirements");
     expect(validationModule).toHaveProperty("formatPluginValidationError");
@@ -107,7 +107,7 @@ describe("New module exports", () => {
   });
 
   it("should export plugin types module", async () => {
-    const pluginTypesModule = await import("../core/plugin-types");
+    const pluginTypesModule = await import("../src/core/plugin-types");
 
     // Module should exist and be importable
     expect(pluginTypesModule).toBeDefined();
@@ -129,7 +129,7 @@ describe("New module exports", () => {
 
 describe("Import path compatibility", () => {
   it("should support importing from main core module", async () => {
-    const exports = await import("../core");
+    const exports = await import("../src/core");
 
     // Old APIs
     expect(exports.createTypeSafeServer).toBeDefined();
@@ -144,7 +144,7 @@ describe("Import path compatibility", () => {
   });
 
   it("should support importing deprecated module directly", async () => {
-    const exports = await import("../plugins-typing");
+    const exports = await import("../src/plugins-typing");
 
     // Module should be importable
     expect(exports).toBeDefined();
@@ -152,9 +152,9 @@ describe("Import path compatibility", () => {
   });
 
   it("should support importing new modules directly", async () => {
-    const pluginTypes = await import("../core/plugin-types");
-    const pluginValidation = await import("../core/plugin-validation");
-    const server = await import("../core/server");
+    const pluginTypes = await import("../src/core/plugin-types");
+    const pluginValidation = await import("../src/core/plugin-validation");
+    const server = await import("../src/core/server");
 
     // Modules should be importable
     expect(pluginTypes).toBeDefined();
@@ -169,7 +169,7 @@ describe("Import path compatibility", () => {
 
 describe("Helper functions compatibility", () => {
   it("should support defineFlow helper", async () => {
-    const { defineFlow } = await import("../core/create-type-safe-server");
+    const { defineFlow } = await import("../src/core/create-type-safe-server");
     const { Effect } = await import("effect");
 
     // Should be able to use defineFlow
@@ -180,7 +180,7 @@ describe("Helper functions compatibility", () => {
 
   it("should support defineSimpleFlow helper", async () => {
     const { defineSimpleFlow } = await import(
-      "../core/create-type-safe-server"
+      "../src/core/create-type-safe-server"
     );
     const { Effect } = await import("effect");
 
@@ -213,21 +213,21 @@ describe("Type availability", () => {
   it("should have TypeSafeServerConfig type available", async () => {
     // This is a compile-time check that the type exists
     // At runtime, we just verify the module exports
-    const module = await import("../core/create-type-safe-server");
+    const module = await import("../src/core/create-type-safe-server");
 
     expect(module).toBeDefined();
     // Type would be checked at compile time
   });
 
   it("should have plugin validation types available", async () => {
-    const module = await import("../core/plugin-validation");
+    const module = await import("../src/core/plugin-validation");
 
     expect(module).toBeDefined();
     // Types like PluginValidationResult would be checked at compile time
   });
 
   it("should have plugin types available", async () => {
-    const module = await import("../core/plugin-types");
+    const module = await import("../src/core/plugin-types");
 
     expect(module).toBeDefined();
     // Types like ValidatePlugins, PluginServices would be checked at compile time
@@ -242,7 +242,7 @@ describe("Migration scenarios", () => {
   it("should support old createTypeSafeServer imports", async () => {
     // Old code pattern
     const { createTypeSafeServer } = await import(
-      "../core/create-type-safe-server"
+      "../src/core/create-type-safe-server"
     );
 
     expect(createTypeSafeServer).toBeDefined();
@@ -251,7 +251,7 @@ describe("Migration scenarios", () => {
 
   it("should support new createUploadistaServer imports", async () => {
     // New code pattern
-    const { createUploadistaServer } = await import("../core/server");
+    const { createUploadistaServer } = await import("../src/core/server");
 
     expect(createUploadistaServer).toBeDefined();
     expect(typeof createUploadistaServer).toBe("function");
@@ -259,7 +259,7 @@ describe("Migration scenarios", () => {
 
   it("should support old plugin typing imports", async () => {
     // Old code pattern - module should be importable
-    const oldModule = await import("../plugins-typing");
+    const oldModule = await import("../src/plugins-typing");
 
     expect(oldModule).toBeDefined();
     // All exports are type-only (LayerSuccessUnion, FlowRequirementsOf, etc.)
@@ -267,7 +267,7 @@ describe("Migration scenarios", () => {
 
   it("should support new plugin typing imports", async () => {
     // New code pattern - module should be importable
-    const newModule = await import("../core/plugin-types");
+    const newModule = await import("../src/core/plugin-types");
 
     expect(newModule).toBeDefined();
     // All exports are type-only (ExtractFlowPluginRequirements, ValidatePlugins, etc.)
@@ -275,8 +275,8 @@ describe("Migration scenarios", () => {
 
   it("should support importing both old and new modules", async () => {
     // Both modules should be importable without conflicts
-    const oldModule = await import("../plugins-typing");
-    const newModule = await import("../core/plugin-types");
+    const oldModule = await import("../src/plugins-typing");
+    const newModule = await import("../src/core/plugin-types");
 
     expect(oldModule).toBeDefined();
     expect(newModule).toBeDefined();

package/{src → tests}/cache.test.ts

@@ -4,8 +4,8 @@ import {
   AuthCacheService,
   AuthCacheServiceLive,
   NoAuthCacheServiceLive,
-} from "./cache";
-import type { AuthContext } from "./types";
+} from "../src/cache";
+import type { AuthContext } from "../src/types";
 
 describe("AuthCacheService", () => {
   describe("AuthCacheServiceLive", () => {

package/tests/core/http-handlers/flow-handlers.test.ts

@@ -0,0 +1,495 @@
+/**
+ * Tests for HTTP Flow Handlers
+ *
+ * Covers:
+ * - Flow data retrieval
+ * - Flow execution and job management
+ * - Job status tracking
+ * - Flow control (pause, resume, cancel)
+ * - Auth context handling and caching
+ * - HTTP request/response handling
+ * - Error handling and status codes
+ */
+
+import { it } from "@effect/vitest";
+import type { FlowData, FlowJob } from "@uploadista/core";
+import { FlowServer } from "@uploadista/core/flow";
+import { Effect, Layer } from "effect";
+import { describe, expect } from "vitest";
+import { AuthCacheServiceLive, AuthContextServiceLive } from "../../../src";
+import {
+  handleCancelFlow,
+  handleGetFlow,
+  handleJobStatus,
+  handlePauseFlow,
+  handleResumeFlow,
+  handleRunFlow,
+} from "../../../src/core/http-handlers/flow-http-handlers";
+
+// Mock FlowServer implementation for testing
+const mockFlowServerMethods = {
+  getFlowData: (flowId: string, _clientId: string | null) =>
+    Effect.succeed<FlowData>({
+      id: flowId,
+      name: `Flow ${flowId}`,
+      nodes: [],
+      edges: [],
+    }),
+
+  runFlow: ({
+    flowId,
+    storageId,
+    clientId,
+  }: {
+    flowId: string;
+    storageId: string;
+    clientId: string | null;
+    inputs: Record<string, unknown>;
+  }) =>
+    Effect.succeed<FlowJob>({
+      id: `job-${flowId}-${Date.now()}`,
+      flowId,
+      storageId,
+      clientId,
+      status: "running",
+      tasks: [],
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    }),
+
+  getJobStatus: (jobId: string) =>
+    Effect.succeed<FlowJob>({
+      id: jobId,
+      flowId: "flow-123",
+      status: "running",
+      clientId: null,
+      storageId: "storage-1",
+      tasks: [],
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    }),
+
+  resumeFlow: ({
+    jobId,
+    clientId,
+  }: {
+    jobId: string;
+    nodeId: string;
+    newData: unknown;
+    clientId: string | null;
+  }) =>
+    Effect.succeed<FlowJob>({
+      id: jobId,
+      flowId: "flow-123",
+      status: "running",
+      clientId,
+      storageId: "storage-1",
+      tasks: [],
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    }),
+
+  pauseFlow: (jobId: string, clientId: string | null) =>
+    Effect.succeed<FlowJob>({
+      id: jobId,
+      flowId: "flow-123",
+      status: "paused",
+      clientId,
+      storageId: "storage-1",
+      tasks: [],
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    }),
+
+  cancelFlow: (jobId: string, clientId: string | null) =>
+    Effect.succeed<FlowJob>({
+      id: jobId,
+      flowId: "flow-123",
+      status: "cancelled",
+      clientId,
+      storageId: "storage-1",
+      tasks: [],
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    }),
+
+  // Mock methods required by FlowServerShape but not used in tests
+  getFlow: () => Effect.die("getFlow not implemented in test"),
+  subscribeToFlowEvents: () => Effect.void,
+  unsubscribeFromFlowEvents: () => Effect.void,
+};
+
+const FlowServerTest = Layer.succeed(FlowServer, mockFlowServerMethods);
+
+describe("HTTP Flow Handlers", () => {
+  describe("handleGetFlow", () => {
+    it.effect("should retrieve flow data without auth", () =>
+      Effect.gen(function* () {
+        const result = yield* handleGetFlow({
+          type: "get-flow",
+          flowId: "flow-123",
+        });
+
+        expect(result.status).toBe(200);
+        expect(result.body.id).toBe("flow-123");
+        expect(result.body.name).toBe("Flow flow-123");
+      }).pipe(
+        Effect.provide(FlowServerTest),
+        Effect.provide(AuthCacheServiceLive()),
+        Effect.provide(AuthContextServiceLive(null)),
+      ),
+    );
+
+    it.effect("should retrieve flow data with auth context", () =>
+      Effect.gen(function* () {
+        const result = yield* handleGetFlow({
+          type: "get-flow",
+          flowId: "flow-456",
+        });
+
+        expect(result.status).toBe(200);
+        expect(result.body.id).toBe("flow-456");
+      }).pipe(
+        Effect.provide(FlowServerTest),
+        Effect.provide(AuthCacheServiceLive()),
+        Effect.provide(
+          AuthContextServiceLive({
+            clientId: "user-123",
+            metadata: { role: "admin" },
+          }),
+        ),
+      ),
+    );
+
+    it.effect("should include flow metadata in response", () =>
+      Effect.gen(function* () {
+        const result = yield* handleGetFlow({
+          type: "get-flow",
+          flowId: "flow-789",
+        });
+
+        expect(result.status).toBe(200);
+        expect(result.body).toHaveProperty("id");
+        expect(result.body).toHaveProperty("name");
+        expect(result.body).toHaveProperty("nodes");
+        expect(result.body).toHaveProperty("edges");
+        expect(result.body.id).toBe("flow-789");
+      }).pipe(
+        Effect.provide(FlowServerTest),
+        Effect.provide(AuthCacheServiceLive()),
+        Effect.provide(AuthContextServiceLive(null)),
+      ),
+    );
+  });
+
+  describe("handleRunFlow", () => {
+    it.effect("should execute flow without auth", () =>
+      Effect.gen(function* () {
+        const result = yield* handleRunFlow<never>({
+          type: "run-flow",
+          flowId: "flow-123",
+          storageId: "storage-1",
+          inputs: { key: "value" },
+        });
+
+        expect(result.status).toBe(200);
+        expect(result.body).toHaveProperty("id");
+        expect(result.body.flowId).toBe("flow-123");
+        expect(result.body.storageId).toBe("storage-1");
+        expect(result.body.status).toBe("running");
+      }).pipe(
+        Effect.provide(FlowServerTest),
+        Effect.provide(AuthCacheServiceLive()),
+        Effect.provide(AuthContextServiceLive(null)),
+      ),
+    );
+
+    it.effect("should execute flow with auth context", () =>
+      Effect.gen(function* () {
+        const result = yield* handleRunFlow<never>({
+          type: "run-flow",
+          flowId: "flow-456",
+          storageId: "storage-2",
+          inputs: { data: "test" },
+        });
+
+        expect(result.status).toBe(200);
+        expect(result.body.clientId).toBe("user-123");
+        // Auth context is cached internally by the handler
+      }).pipe(
+        Effect.provide(FlowServerTest),
+        Effect.provide(AuthCacheServiceLive()),
+        Effect.provide(
+          AuthContextServiceLive({
+            clientId: "user-123",
+            metadata: { plan: "premium" },
+          }),
+        ),
+      ),
+    );
+
+    it.effect("should not cache auth context when no auth present", () =>
+      Effect.gen(function* () {
+        const result = yield* handleRunFlow<never>({
+          type: "run-flow",
+          flowId: "flow-789",
+          storageId: "storage-3",
+          inputs: {},
+        });
+
+        expect(result.status).toBe(200);
+        expect(result.body.clientId).toBeNull();
+      }).pipe(
+        Effect.provide(FlowServerTest),
+        Effect.provide(AuthCacheServiceLive()),
+        Effect.provide(AuthContextServiceLive(null)),
+      ),
+    );
+
+    it.effect("should return job ID immediately", () =>
+      Effect.gen(function* () {
+        const result = yield* handleRunFlow<never>({
+          type: "run-flow",
+          flowId: "flow-async",
+          storageId: "storage-4",
+          inputs: { async: true },
+        });
+
+        expect(result.status).toBe(200);
+        expect(result.body.id).toContain("job-");
+        expect(result.body.status).toBe("running");
+      }).pipe(
+        Effect.provide(FlowServerTest),
+        Effect.provide(AuthCacheServiceLive()),
+        Effect.provide(AuthContextServiceLive(null)),
+      ),
+    );
+  });
+
+  describe("handleJobStatus", () => {
+    it.effect("should get job status", () =>
+      Effect.gen(function* () {
+        const result = yield* handleJobStatus({
+          type: "job-status",
+          jobId: "job-123",
+        });
+
+        expect(result.status).toBe(200);
+        expect(result.body.id).toBe("job-123");
+        expect(result.body.flowId).toBe("flow-123");
+        expect(result.body).toHaveProperty("status");
+      }).pipe(
+        Effect.provide(FlowServerTest),
+        Effect.provide(AuthCacheServiceLive()),
+        Effect.provide(AuthContextServiceLive(null)),
+      ),
+    );
+
+    it.effect("should clear cache when flow completes", () =>
+      Effect.gen(function* () {
+        // Create FlowServer that returns completed status
+        const completedMethods = {
+          ...mockFlowServerMethods,
+          getJobStatus: (jobId: string) =>
+            Effect.succeed<FlowJob>({
+              id: jobId,
+              flowId: "flow-123",
+              status: "completed",
+              clientId: null,
+              storageId: "storage-1",
+              tasks: [],
+              createdAt: new Date(),
+              updatedAt: new Date(),
+            }),
+        };
+
+        const result = yield* handleJobStatus({
+          type: "job-status",
+          jobId: "job-completed",
+        }).pipe(
+          Effect.provide(Layer.succeed(FlowServer, completedMethods)),
+          Effect.provide(AuthCacheServiceLive()),
+          Effect.provide(AuthContextServiceLive(null)),
+        );
+
+        expect(result.status).toBe(200);
+        expect(result.body.status).toBe("completed");
+      }),
+    );
+
+    it.effect("should not clear cache for running jobs", () =>
+      Effect.gen(function* () {
+        const result = yield* handleJobStatus({
+          type: "job-status",
+          jobId: "job-running",
+        });
+
+        expect(result.status).toBe(200);
+        expect(result.body.status).toBe("running");
+      }).pipe(
+        Effect.provide(FlowServerTest),
+        Effect.provide(AuthCacheServiceLive()),
+        Effect.provide(AuthContextServiceLive(null)),
+      ),
+    );
+  });
+
+  describe("handleResumeFlow", () => {
+    it.effect("should resume flow with current auth", () =>
+      Effect.gen(function* () {
+        const result = yield* handleResumeFlow<never>({
+          type: "resume-flow",
+          jobId: "job-cached",
+          nodeId: "node-2",
+          newData: { selection: "yes" },
+        });
+
+        expect(result.status).toBe(200);
+        expect(result.body.id).toBe("job-cached");
+      }).pipe(
+        Effect.provide(FlowServerTest),
+        Effect.provide(AuthCacheServiceLive()),
+        Effect.provide(AuthContextServiceLive(null)),
+      ),
+    );
+  });
+
+  describe("handlePauseFlow", () => {
+    it.effect("should pause flow", () =>
+      Effect.gen(function* () {
+        const result = yield* handlePauseFlow({
+          type: "pause-flow",
+          jobId: "job-pause",
+        });
+
+        expect(result.status).toBe(200);
+        expect(result.body.id).toBe("job-pause");
+        expect(result.body.status).toBe("paused");
+      }).pipe(
+        Effect.provide(FlowServerTest),
+        Effect.provide(AuthCacheServiceLive()),
+        Effect.provide(AuthContextServiceLive(null)),
+      ),
+    );
+
+    it.effect("should pause flow with auth context", () =>
+      Effect.gen(function* () {
+        const result = yield* handlePauseFlow({
+          type: "pause-flow",
+          jobId: "job-pause-auth",
+        });
+
+        expect(result.status).toBe(200);
+        expect(result.body.status).toBe("paused");
+        expect(result.body.clientId).toBe("user-pause");
+      }).pipe(
+        Effect.provide(FlowServerTest),
+        Effect.provide(AuthCacheServiceLive()),
+        Effect.provide(AuthContextServiceLive({ clientId: "user-pause" })),
+      ),
+    );
+  });
+
+  describe("handleCancelFlow", () => {
+    it.effect("should cancel flow", () =>
+      Effect.gen(function* () {
+        const result = yield* handleCancelFlow({
+          type: "cancel-flow",
+          jobId: "job-cancel",
+        });
+
+        expect(result.status).toBe(200);
+        expect(result.body.id).toBe("job-cancel");
+        expect(result.body.status).toBe("cancelled");
+      }).pipe(
+        Effect.provide(FlowServerTest),
+        Effect.provide(AuthCacheServiceLive()),
+        Effect.provide(AuthContextServiceLive(null)),
+      ),
+    );
+
+    it.effect("should cancel flow with current auth", () =>
+      Effect.gen(function* () {
+        const result = yield* handleCancelFlow({
+          type: "cancel-flow",
+          jobId: "job-cancel-auth",
+        });
+
+        expect(result.status).toBe(200);
+        expect(result.body.status).toBe("cancelled");
+        expect(result.body.clientId).toBe("user-cancel-auth");
+      }).pipe(
+        Effect.provide(FlowServerTest),
+        Effect.provide(AuthCacheServiceLive()),
+        Effect.provide(
+          AuthContextServiceLive({
+            clientId: "user-cancel-auth",
+            metadata: { reason: "manual" },
+          }),
+        ),
+      ),
+    );
+  });
+
+  describe("HTTP Status Codes", () => {
+    it.effect("should return 200 OK for successful operations", () =>
+      Effect.gen(function* () {
+        const getFlowResult = yield* handleGetFlow({
+          type: "get-flow",
+          flowId: "flow-200",
+        });
+        expect(getFlowResult.status).toBe(200);
+
+        const runFlowResult = yield* handleRunFlow<never>({
+          type: "run-flow",
+          flowId: "flow-200",
+          storageId: "storage-1",
+          inputs: {},
+        });
+        expect(runFlowResult.status).toBe(200);
+
+        const statusResult = yield* handleJobStatus({
+          type: "job-status",
+          jobId: "job-200",
+        });
+        expect(statusResult.status).toBe(200);
+      }).pipe(
+        Effect.provide(FlowServerTest),
+        Effect.provide(AuthCacheServiceLive()),
+        Effect.provide(AuthContextServiceLive(null)),
+      ),
+    );
+  });
+
+  describe("Auth Context Integration", () => {
+    it.effect("should handle unauthenticated flow operations", () =>
+      Effect.gen(function* () {
+        // All operations should work without auth
+        const getResult = yield* handleGetFlow({
+          type: "get-flow",
+          flowId: "flow-unauth",
+        });
+        expect(getResult.status).toBe(200);
+
+        const runResult = yield* handleRunFlow<never>({
+          type: "run-flow",
+          flowId: "flow-unauth",
+          storageId: "storage-1",
+          inputs: {},
+        });
+        expect(runResult.status).toBe(200);
+        expect(runResult.body.clientId).toBeNull();
+
+        const statusResult = yield* handleJobStatus({
+          type: "job-status",
+          jobId: "job-unauth",
+        });
+        expect(statusResult.status).toBe(200);
+      }).pipe(
+        Effect.provide(FlowServerTest),
+        Effect.provide(AuthCacheServiceLive()),
+        Effect.provide(AuthContextServiceLive(null)),
+      ),
+    );
+  });
+});