@uploadista/server 0.0.7 → 0.0.9

package/src/core/http-handlers/flow-http-handlers.ts

@@ -0,0 +1,245 @@
+import { FlowServer } from "@uploadista/core/flow";
+import { Effect } from "effect";
+import { AuthCacheService } from "../../cache";
+import { AuthContextService } from "../../service";
+import type {
+  CancelFlowRequest,
+  CancelFlowResponse,
+  GetFlowRequest,
+  GetFlowResponse,
+  GetJobStatusRequest,
+  GetJobStatusResponse,
+  PauseFlowRequest,
+  PauseFlowResponse,
+  ResumeFlowRequest,
+  ResumeFlowResponse,
+  RunFlowRequest,
+  RunFlowResponse,
+} from "../routes";
+
+export const handleGetFlow = ({ flowId }: GetFlowRequest) => {
+  return Effect.gen(function* () {
+    const flowServer = yield* FlowServer;
+    // Access auth context if available
+    const authService = yield* AuthContextService;
+    const clientId = yield* authService.getClientId();
+
+    if (clientId) {
+      yield* Effect.logInfo(`[Flow] Getting flow data: ${flowId}, client: ${clientId}`);
+    }
+
+    const flowData = yield* flowServer.getFlowData(flowId, clientId);
+
+    return {
+      status: 200,
+      body: flowData,
+    } as GetFlowResponse;
+  });
+};
+
+export const handleRunFlow = <TRequirements>({
+  flowId,
+  storageId,
+  inputs,
+}: RunFlowRequest) => {
+  return Effect.gen(function* () {
+    const flowServer = yield* FlowServer;
+    // Access auth context if available
+    const authService = yield* AuthContextService;
+    const authCache = yield* AuthCacheService;
+    const clientId = yield* authService.getClientId();
+
+    if (clientId) {
+      yield* Effect.logInfo(
+        `[Flow] Executing flow: ${flowId}, storage: ${storageId}, client: ${clientId}`,
+      );
+      yield* Effect.logInfo(JSON.stringify(inputs, null, 2));
+    } else {
+      yield* Effect.logInfo(`[Flow] Executing flow: ${flowId}, storage: ${storageId}`);
+      yield* Effect.logInfo(`[Flow] Inputs: ${JSON.stringify(inputs, null, 2)}`);
+    }
+
+    // Run flow returns immediately with jobId
+    yield* Effect.logInfo(`[Flow] Calling flowServer.runFlow...`);
+    const result = yield* flowServer.runFlow<TRequirements>({
+      flowId,
+      storageId,
+      clientId,
+      inputs,
+    }).pipe(
+      Effect.tap(() => Effect.logInfo(`[Flow] runFlow completed successfully`)),
+      Effect.tapError((error) =>
+        Effect.logError(`[Flow] runFlow failed with error: ${error}`)
+      ),
+    );
+
+    // Cache auth context for subsequent flow operations (continue, status)
+    const authContext = yield* authService.getAuthContext();
+    if (authContext) {
+      yield* authCache.set(result.id, authContext);
+    }
+
+    yield* Effect.logInfo(`[Flow] Flow started with jobId: ${result.id}`);
+
+    return {
+      status: 200,
+      body: result,
+    } as RunFlowResponse;
+  });
+};
+
+export const handleJobStatus = ({ jobId }: GetJobStatusRequest) => {
+  return Effect.gen(function* () {
+    const flowServer = yield* FlowServer;
+    // Access auth context if available
+    const authService = yield* AuthContextService;
+    const authCache = yield* AuthCacheService;
+    const clientId = yield* authService.getClientId();
+
+    if (!jobId) {
+      throw new Error("No job id");
+    }
+
+    if (clientId) {
+      yield* Effect.logInfo(`[Flow] Getting job status: ${jobId}, client: ${clientId}`);
+    }
+
+    const result = yield* flowServer.getJobStatus(jobId);
+
+    // Clear cache if flow is completed or failed
+    if (result.status === "completed" || result.status === "failed") {
+      yield* authCache.delete(jobId);
+      if (clientId) {
+        yield* Effect.logInfo(
+          `[Flow] Flow ${result.status}, cleared auth cache: ${jobId}`,
+        );
+      }
+    }
+
+    return {
+      status: 200,
+      body: result,
+    } as GetJobStatusResponse;
+  });
+};
+
+export const handleResumeFlow = <TRequirements>({
+  jobId,
+  nodeId,
+  newData,
+}: ResumeFlowRequest) => {
+  return Effect.gen(function* () {
+    const flowServer = yield* FlowServer;
+    // Try to get auth from current request or cached auth
+    const authService = yield* AuthContextService;
+    const authCache = yield* AuthCacheService;
+
+    // Try current auth first, fallback to cached auth
+    let clientId = yield* authService.getClientId();
+    if (!clientId) {
+      const cachedAuth = yield* authCache.get(jobId);
+      clientId = cachedAuth?.clientId ?? null;
+    }
+
+    if (clientId) {
+      yield* Effect.logInfo(
+        `[Flow] Continuing flow: jobId=${jobId}, nodeId=${nodeId}, client: ${clientId}`,
+      );
+    }
+
+    if (newData === undefined) {
+      throw new Error("Missing newData");
+    }
+
+    const result = yield* flowServer.resumeFlow<TRequirements>({
+      jobId,
+      nodeId,
+      newData,
+      clientId,
+    });
+
+    // Clear cache if flow is completed or failed
+    if (result.status === "completed" || result.status === "failed") {
+      yield* authCache.delete(jobId);
+      if (clientId) {
+        yield* Effect.logInfo(
+          `[Flow] Flow ${result.status}, cleared auth cache: ${jobId}`,
+        );
+      }
+    }
+
+    return {
+      status: 200,
+      body: result,
+    } as ResumeFlowResponse;
+  });
+};
+export const handlePauseFlow = ({ jobId }: PauseFlowRequest) => {
+  return Effect.gen(function* () {
+    const flowServer = yield* FlowServer;
+    // Try to get auth from current request or cached auth
+    const authService = yield* AuthContextService;
+    const authCache = yield* AuthCacheService;
+
+    // Try current auth first, fallback to cached auth
+    let clientId = yield* authService.getClientId();
+    if (!clientId) {
+      const cachedAuth = yield* authCache.get(jobId);
+      clientId = cachedAuth?.clientId ?? null;
+    }
+
+    if (clientId) {
+      yield* Effect.logInfo(`[Flow] Pausing flow: jobId=${jobId}, client: ${clientId}`);
+    }
+
+    const result = yield* flowServer.pauseFlow(jobId, clientId);
+
+    if (clientId) {
+      yield* Effect.logInfo(`[Flow] Flow paused: ${jobId}, status: ${result.status}`);
+    }
+
+    return {
+      status: 200,
+      body: result,
+    } as PauseFlowResponse;
+  });
+};
+
+export const handleCancelFlow = ({ jobId }: CancelFlowRequest) => {
+  return Effect.gen(function* () {
+    const flowServer = yield* FlowServer;
+    // Try to get auth from current request or cached auth
+    const authService = yield* AuthContextService;
+    const authCache = yield* AuthCacheService;
+
+    if (!jobId) {
+      throw new Error("No job id");
+    }
+
+    // Try current auth first, fallback to cached auth
+    let clientId = yield* authService.getClientId();
+    if (!clientId) {
+      const cachedAuth = yield* authCache.get(jobId);
+      clientId = cachedAuth?.clientId ?? null;
+    }
+
+    if (clientId) {
+      yield* Effect.logInfo(
+        `[Flow] Cancelling flow: jobId=${jobId}, client: ${clientId}`,
+      );
+    }
+
+    const result = yield* flowServer.cancelFlow(jobId, clientId);
+
+    // Clear cache since flow is cancelled
+    yield* authCache.delete(jobId);
+    if (clientId) {
+      yield* Effect.logInfo(`[Flow] Flow cancelled, cleared auth cache: ${jobId}`);
+    }
+
+    return {
+      status: 200,
+      body: result,
+    } as CancelFlowResponse;
+  });
+};

package/src/core/http-handlers/http-handlers.ts

@@ -0,0 +1,72 @@
+import { Effect } from "effect";
+import type { UploadistaRequest, UploadistaResponse } from "../routes";
+import {
+  handleCancelFlow,
+  handleGetFlow,
+  handleJobStatus,
+  handlePauseFlow,
+  handleResumeFlow,
+  handleRunFlow,
+} from "./flow-http-handlers";
+import {
+  handleCreateUpload,
+  handleGetCapabilities,
+  handleGetUpload,
+  handleUploadChunk,
+} from "./upload-http-handlers";
+
+export type { UploadistaRequest, UploadistaResponse } from "../routes";
+
+export const handleUploadistaRequest = <TRequirements>(
+  req: UploadistaRequest,
+) => {
+  return Effect.gen(function* () {
+    switch (req.type) {
+      case "create-upload":
+        return (yield* handleCreateUpload(req)) as UploadistaResponse;
+      case "get-capabilities":
+        return (yield* handleGetCapabilities(req)) as UploadistaResponse;
+      case "get-upload":
+        return (yield* handleGetUpload(req)) as UploadistaResponse;
+      case "upload-chunk":
+        return (yield* handleUploadChunk(req)) as UploadistaResponse;
+      case "get-flow":
+        return (yield* handleGetFlow(req)) as UploadistaResponse;
+      case "run-flow":
+        return (yield* handleRunFlow<TRequirements>(req)) as UploadistaResponse;
+      case "job-status":
+        return (yield* handleJobStatus(req)) as UploadistaResponse;
+      case "resume-flow":
+        return (yield* handleResumeFlow<TRequirements>(
+          req,
+        )) as UploadistaResponse;
+      case "pause-flow":
+        return (yield* handlePauseFlow(req)) as UploadistaResponse;
+      case "cancel-flow":
+        return (yield* handleCancelFlow(req)) as UploadistaResponse;
+      case "not-found":
+        return {
+          status: 404,
+          headers: { "Content-Type": "application/json" },
+          body: { error: "Not found" },
+        } as UploadistaResponse;
+      case "bad-request":
+        return {
+          status: 400,
+          body: { error: "Bad request", message: req.message },
+        } as UploadistaResponse;
+      case "method-not-allowed":
+        return {
+          status: 405,
+          headers: { "Content-Type": "application/json" },
+          body: { error: "Method not allowed" },
+        } as UploadistaResponse;
+      case "unsupported-content-type":
+        return {
+          status: 415,
+          headers: { "Content-Type": "application/json" },
+          body: { error: "Unsupported content type" },
+        } as UploadistaResponse;
+    }
+  });
+};

package/src/core/http-handlers/upload-http-handlers.ts

@@ -0,0 +1,168 @@
+import { inputFileSchema } from "@uploadista/core/types";
+import { UploadServer } from "@uploadista/core/upload";
+import { isSupportedAlgorithm } from "@uploadista/core/utils";
+import { MetricsService } from "@uploadista/observability";
+import { Effect } from "effect";
+import { AuthCacheService } from "../../cache";
+import { ValidationError } from "../../error-types";
+import { AuthContextService } from "../../service";
+import type {
+  CreateUploadRequest,
+  CreateUploadResponse,
+  GetCapabilitiesRequest,
+  GetCapabilitiesResponse,
+  GetUploadRequest,
+  GetUploadResponse,
+  UploadChunkRequest,
+  UploadChunkResponse,
+} from "../routes";
+
+export const handleCreateUpload = (req: CreateUploadRequest) =>
+  Effect.gen(function* () {
+    const server = yield* UploadServer;
+    // Access auth context if available
+    const authService = yield* AuthContextService;
+    const authCache = yield* AuthCacheService;
+    const clientId = yield* authService.getClientId();
+
+    if (clientId) {
+      yield* Effect.logInfo(`[Upload] Creating upload for client: ${clientId}`);
+    }
+
+    const parsedInputFile = yield* Effect.sync(() =>
+      inputFileSchema.safeParse(req.data),
+    );
+
+    if (!parsedInputFile.success) {
+      return yield* Effect.fail(
+        new ValidationError("Invalid input file schema"),
+      );
+    }
+
+    // Validate checksum algorithm if provided
+    if (
+      parsedInputFile.data.checksumAlgorithm &&
+      !isSupportedAlgorithm(parsedInputFile.data.checksumAlgorithm)
+    ) {
+      return yield* Effect.fail(
+        new ValidationError(
+          `Unsupported checksum algorithm: ${parsedInputFile.data.checksumAlgorithm}. Supported algorithms: sha256`,
+        ),
+      );
+    }
+
+    const fileCreated = yield* server.createUpload(
+      parsedInputFile.data,
+      clientId,
+    );
+
+    // Cache auth context for subsequent chunk uploads
+    const authContext = yield* authService.getAuthContext();
+    if (authContext) {
+      yield* authCache.set(fileCreated.id, authContext);
+    }
+
+    if (clientId) {
+      yield* Effect.logInfo(
+        `[Upload] Upload created: ${fileCreated.id} for client: ${clientId}`,
+      );
+    }
+
+    return {
+      status: 200,
+      body: fileCreated,
+    } as CreateUploadResponse;
+  });
+
+export const handleGetCapabilities = ({ storageId }: GetCapabilitiesRequest) =>
+  Effect.gen(function* () {
+    const server = yield* UploadServer;
+    const authService = yield* AuthContextService;
+    const clientId = yield* authService.getClientId();
+
+    const capabilities = yield* server.getCapabilities(storageId, clientId);
+
+    return {
+      status: 200,
+      body: {
+        storageId,
+        capabilities,
+        timestamp: new Date().toISOString(),
+      },
+    } as GetCapabilitiesResponse;
+  });
+
+export const handleGetUpload = ({ uploadId }: GetUploadRequest) =>
+  Effect.gen(function* () {
+    const server = yield* UploadServer;
+    const fileResult = yield* server.getUpload(uploadId);
+
+    return {
+      status: 200,
+      body: fileResult,
+    } as GetUploadResponse;
+  });
+
+export const handleUploadChunk = (req: UploadChunkRequest) =>
+  Effect.gen(function* () {
+    const server = yield* UploadServer;
+    // Try to get auth from current request or cached auth
+    const authService = yield* AuthContextService;
+    const authCache = yield* AuthCacheService;
+    const metricsService = yield* MetricsService;
+
+    const { uploadId, data } = req;
+
+    // Try current auth first, fallback to cached auth
+    let clientId = yield* authService.getClientId();
+    let authMetadata = yield* authService.getMetadata();
+    if (!clientId) {
+      const cachedAuth = yield* authCache.get(uploadId);
+      clientId = cachedAuth?.clientId ?? null;
+      authMetadata = cachedAuth?.metadata ?? {};
+    }
+
+    if (clientId) {
+      yield* Effect.logInfo(
+        `[Upload] Uploading chunk for upload: ${uploadId}, client: ${clientId}`,
+      );
+    }
+
+    const fileResult = yield* server.uploadChunk(uploadId, clientId, data);
+
+    // Clear cache and record metrics if upload is complete
+    if (fileResult.size && fileResult.offset >= fileResult.size) {
+      yield* authCache.delete(uploadId);
+      if (clientId) {
+        yield* Effect.logInfo(
+          `[Upload] Upload completed, cleared auth cache: ${uploadId}`,
+        );
+      }
+
+      // Record upload metrics if we have organization ID
+
+      if (clientId && fileResult.size) {
+        yield* Effect.logInfo(
+          `[Upload] Recording metrics for org: ${clientId}, size: ${fileResult.size}`,
+        );
+        yield* Effect.forkDaemon(
+          metricsService.recordUpload(clientId, fileResult.size, authMetadata),
+        );
+      } else {
+        yield* Effect.logWarning(
+          `[Upload] Cannot record metrics - missing organizationId or size`,
+        );
+      }
+    }
+
+    if (clientId) {
+      yield* Effect.logInfo(
+        `[Upload] Chunk uploaded for upload: ${uploadId}, client: ${clientId}`,
+      );
+    }
+
+    return {
+      status: 200,
+      body: fileResult,
+    } as UploadChunkResponse;
+  });

package/src/core/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Core server module for framework-agnostic Uploadista server implementation.
+ *
+ * This module contains the unified server implementation that works across
+ * all framework adapters (Hono, Express, Fastify, etc.).
+ */
+
+export * from "./routes";
+export * from "./server";
+export * from "./types";
+export * from "./websocket-handlers/websocket-handlers";
+export * from "./websocket-routes";

package/src/core/routes.ts

@@ -0,0 +1,188 @@
+import type {
+  DataStoreCapabilities,
+  FlowData,
+  FlowJob,
+  UploadFile,
+} from "@uploadista/core";
+import type { StandardResponse } from "../adapter/types";
+
+export type UploadistaRouteType =
+  | "create-upload"
+  | "get-capabilities"
+  | "get-upload"
+  | "upload-chunk"
+  | "get-flow"
+  | "run-flow"
+  | "job-status"
+  | "resume-flow"
+  | "pause-flow"
+  | "cancel-flow"
+  | "not-found"
+  | "bad-request"
+  | "method-not-allowed"
+  | "unsupported-content-type";
+
+export type UploadistaRoute<T extends UploadistaRouteType> = {
+  type: T;
+};
+
+export type UploadistaStandardResponse<
+  T extends UploadistaRouteType,
+  ResponseBody,
+  Status extends number = 200,
+> = UploadistaRoute<T> & {
+  status: Status;
+  headers: { "Content-Type": "application/json" };
+  body: ResponseBody;
+};
+
+export type NotFoundRequest = UploadistaRoute<"not-found">;
+
+export type NotFoundResponse = UploadistaStandardResponse<
+  "not-found",
+  { error: "Not found" },
+  404
+>;
+
+export type MethodNotAllowedRequest = UploadistaRoute<"method-not-allowed">;
+
+export type MethodNotAllowedResponse = UploadistaStandardResponse<
+  "method-not-allowed",
+  { error: "Method not allowed" },
+  405
+>;
+
+export type BadRequestRequest = UploadistaRoute<"bad-request"> & {
+  message: string;
+};
+
+export type BadRequestResponse = UploadistaStandardResponse<
+  "bad-request",
+  { error: "Bad request"; message: string },
+  400
+>;
+
+export type UnsupportedContentTypeRequest =
+  UploadistaRoute<"unsupported-content-type">;
+
+export type UnsupportedContentTypeResponse = UploadistaStandardResponse<
+  "unsupported-content-type",
+  { error: "Unsupported content type" },
+  415
+>;
+export type CreateUploadRequest = UploadistaRoute<"create-upload"> & {
+  data: unknown;
+};
+export type CreateUploadResponse = UploadistaStandardResponse<
+  "create-upload",
+  UploadFile
+>;
+export type GetCapabilitiesRequest = UploadistaRoute<"get-capabilities"> & {
+  storageId: string;
+};
+export type GetCapabilitiesResponse = UploadistaStandardResponse<
+  "get-capabilities",
+  {
+    storageId: string;
+    capabilities: DataStoreCapabilities;
+    timestamp: string;
+  }
+>;
+
+export type GetUploadRequest = UploadistaRoute<"get-upload"> & {
+  uploadId: string;
+};
+
+export type GetUploadResponse = UploadistaStandardResponse<
+  "get-upload",
+  UploadFile
+>;
+
+export type UploadChunkRequest = UploadistaRoute<"upload-chunk"> & {
+  uploadId: string;
+  data: ReadableStream;
+};
+
+export type UploadChunkResponse = UploadistaStandardResponse<
+  "upload-chunk",
+  UploadFile
+>;
+
+export type GetFlowRequest = UploadistaRoute<"get-flow"> & {
+  flowId: string;
+};
+export type GetFlowResponse = UploadistaStandardResponse<"get-flow", FlowData>;
+
+export type RunFlowRequest = UploadistaRoute<"run-flow"> & {
+  flowId: string;
+  storageId: string;
+  inputs: Record<string, unknown>;
+};
+export type RunFlowResponse = UploadistaStandardResponse<"run-flow", FlowJob>;
+
+export type GetJobStatusRequest = UploadistaRoute<"job-status"> & {
+  jobId: string;
+};
+export type GetJobStatusResponse = UploadistaStandardResponse<
+  "job-status",
+  FlowJob
+>;
+
+export type ResumeFlowRequest = UploadistaRoute<"resume-flow"> & {
+  jobId: string;
+  nodeId: string;
+  newData: unknown;
+};
+export type ResumeFlowResponse = UploadistaStandardResponse<
+  "resume-flow",
+  FlowJob
+>;
+
+export type PauseFlowRequest = UploadistaRoute<"pause-flow"> & {
+  jobId: string;
+};
+export type PauseFlowResponse = UploadistaStandardResponse<
+  "pause-flow",
+  FlowJob
+>;
+
+export type CancelFlowRequest = UploadistaRoute<"cancel-flow"> & {
+  jobId: string;
+};
+export type CancelFlowResponse = UploadistaStandardResponse<
+  "cancel-flow",
+  FlowJob
+>;
+
+export type UploadistaRequest =
+  | CreateUploadRequest
+  | GetCapabilitiesRequest
+  | GetUploadRequest
+  | UploadChunkRequest
+  | GetFlowRequest
+  | RunFlowRequest
+  | GetJobStatusRequest
+  | ResumeFlowRequest
+  | PauseFlowRequest
+  | CancelFlowRequest
+  | NotFoundRequest
+  | BadRequestRequest
+  | MethodNotAllowedRequest
+  | UnsupportedContentTypeRequest;
+
+export type UploadistaResponse =
+  | CreateUploadResponse
+  | GetCapabilitiesResponse
+  | GetUploadResponse
+  | UploadChunkResponse
+  | GetFlowResponse
+  | RunFlowResponse
+  | GetJobStatusResponse
+  | ResumeFlowResponse
+  | PauseFlowResponse
+  | CancelFlowResponse
+  | NotFoundResponse
+  | BadRequestResponse
+  | MethodNotAllowedResponse
+  | UnsupportedContentTypeResponse
+  | StandardResponse;