@uploadista/server 0.0.3

package/dist/http-utils.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Shared HTTP utilities for server adapters
+ *
+ * This module provides routing and error handling utilities used across
+ * Hono, Express, and Fastify adapters for request parsing and response formatting.
+ */
+/**
+ * Parses URL segments from a pathname, filtering out empty segments.
+ * Useful for extracting route components from request paths.
+ *
+ * @param pathname - The URL pathname (e.g., "/uploadista/api/upload/abc123")
+ * @returns Array of non-empty path segments
+ *
+ * @example
+ * ```typescript
+ * const segments = parseUrlSegments("/uploadista/api/upload/abc123");
+ * // => ["uploadista", "api", "upload", "abc123"]
+ * ```
+ */
+export declare const parseUrlSegments: (pathname: string) => string[];
+/**
+ * Extracts the last segment from a URL pathname.
+ *
+ * @param pathname - The URL pathname to parse
+ * @returns The last non-empty segment, or undefined if none exists
+ *
+ * @example
+ * ```typescript
+ * const id = getLastSegment("/uploadista/api/upload/abc123");
+ * // => "abc123"
+ * ```
+ */
+export declare const getLastSegment: (pathname: string) => string | undefined;
+/**
+ * Checks if a pathname includes a specific base path and API prefix.
+ * Used to determine if a request should be handled by the Uploadista adapter.
+ *
+ * @param pathname - The request pathname
+ * @param basePath - The base path configured for the adapter (e.g., "uploadista")
+ * @returns true if the path includes `{basePath}/api/`
+ *
+ * @example
+ * ```typescript
+ * const isUploadistaPath = hasBasePath("/uploadista/api/upload", "uploadista");
+ * // => true
+ * ```
+ */
+export declare const hasBasePath: (pathname: string, basePath: string) => boolean;
+/**
+ * Removes the base path prefix and returns clean route segments.
+ * Transforms "/uploadista/api/upload/abc123" → ["upload", "abc123"]
+ *
+ * @param pathname - The full request pathname
+ * @param basePath - The base path to remove (e.g., "uploadista")
+ * @returns Array of route segments without base path prefix
+ *
+ * @example
+ * ```typescript
+ * const route = getRouteSegments("/uploadista/api/upload/abc123", "uploadista");
+ * // => ["upload", "abc123"]
+ * ```
+ */
+export declare const getRouteSegments: (pathname: string, basePath: string) => string[];
+/**
+ * Standard error handler for flow and job operations.
+ * Maps application errors to appropriate HTTP status codes and error formats.
+ *
+ * Supports errors with `code`, `message`, `status`, and `details` properties.
+ * Maps error codes to HTTP status codes (e.g., NOT_FOUND → 404, VALIDATION_ERROR → 400).
+ *
+ * @param error - The error object to handle (can be any type)
+ * @returns Standardized error response with status, code, message, and optional details
+ *
+ * @example
+ * ```typescript
+ * import { handleFlowError } from "@uploadista/server";
+ *
+ * const response = handleFlowError({
+ *   code: "FLOW_JOB_NOT_FOUND",
+ *   message: "Job not found",
+ * });
+ * // => { status: 404, code: "FLOW_JOB_NOT_FOUND", message: "Job not found" }
+ * ```
+ */
+export declare const handleFlowError: (error: unknown) => {
+    status: number;
+    code: string;
+    message: string;
+    details?: unknown;
+};
+/**
+ * Extracts job ID from URL segments for job status endpoint.
+ * Expected URL format: `/uploadista/api/jobs/:jobId/status`
+ *
+ * @param urlSegments - Parsed URL segments (without base path)
+ * @returns The job ID if found, or undefined
+ *
+ * @example
+ * ```typescript
+ * const jobId = extractJobIdFromStatus(["jobs", "job-123", "status"]);
+ * // => "job-123"
+ * ```
+ */
+export declare const extractJobIdFromStatus: (urlSegments: string[]) => string | undefined;
+/**
+ * Extracts job ID and node ID from URL segments for continue flow endpoint.
+ * Expected URL format: `/uploadista/api/jobs/:jobId/continue/:nodeId`
+ *
+ * @param urlSegments - Parsed URL segments (without base path)
+ * @returns Object with extracted jobId and nodeId (either can be undefined if not found)
+ *
+ * @example
+ * ```typescript
+ * const { jobId, nodeId } = extractJobAndNodeId([
+ *   "jobs",
+ *   "job-123",
+ *   "continue",
+ *   "node-456",
+ * ]);
+ * // => { jobId: "job-123", nodeId: "node-456" }
+ * ```
+ */
+export declare const extractJobAndNodeId: (urlSegments: string[]) => {
+    jobId: string | undefined;
+    nodeId: string | undefined;
+};
+/**
+ * Extracts flow ID and storage ID from URL segments.
+ * Expected URL format: `/uploadista/api/flow/:flowId/:storageId`
+ *
+ * Mutates the input array (removes last 2 elements).
+ *
+ * @param urlSegments - Parsed URL segments (will be mutated)
+ * @returns Object with extracted flowId and storageId
+ *
+ * @example
+ * ```typescript
+ * const segments = ["flow", "flow-123", "storage-456"];
+ * const { flowId, storageId } = extractFlowAndStorageId(segments);
+ * // => { flowId: "flow-123", storageId: "storage-456" }
+ * // segments is now ["flow"]
+ * ```
+ */
+export declare const extractFlowAndStorageId: (urlSegments: string[]) => {
+    flowId: string | undefined;
+    storageId: string | undefined;
+};
+//# sourceMappingURL=http-utils.d.ts.map

package/dist/http-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-utils.d.ts","sourceRoot":"","sources":["../src/http-utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,GAAI,UAAU,MAAM,KAAG,MAAM,EAEzD,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc,GAAI,UAAU,MAAM,KAAG,MAAM,GAAG,SAG1D,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,WAAW,GAAI,UAAU,MAAM,EAAE,UAAU,MAAM,KAAG,OAEhE,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB,GAC3B,UAAU,MAAM,EAChB,UAAU,MAAM,KACf,MAAM,EAER,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,eAAe,GAC1B,OAAO,OAAO,KACb;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAwFpE,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,sBAAsB,GACjC,aAAa,MAAM,EAAE,KACpB,MAAM,GAAG,SAEX,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,mBAAmB,GAC9B,aAAa,MAAM,EAAE,KACpB;IAAE,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAA;CAKzD,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,uBAAuB,GAClC,aAAa,MAAM,EAAE,KACpB;IAAE,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAA;CAK7D,CAAC"}

package/dist/http-utils.js

@@ -0,0 +1,233 @@
+/**
+ * Shared HTTP utilities for server adapters
+ *
+ * This module provides routing and error handling utilities used across
+ * Hono, Express, and Fastify adapters for request parsing and response formatting.
+ */
+/**
+ * Parses URL segments from a pathname, filtering out empty segments.
+ * Useful for extracting route components from request paths.
+ *
+ * @param pathname - The URL pathname (e.g., "/uploadista/api/upload/abc123")
+ * @returns Array of non-empty path segments
+ *
+ * @example
+ * ```typescript
+ * const segments = parseUrlSegments("/uploadista/api/upload/abc123");
+ * // => ["uploadista", "api", "upload", "abc123"]
+ * ```
+ */
+export const parseUrlSegments = (pathname) => {
+    return pathname.split("/").filter(Boolean);
+};
+/**
+ * Extracts the last segment from a URL pathname.
+ *
+ * @param pathname - The URL pathname to parse
+ * @returns The last non-empty segment, or undefined if none exists
+ *
+ * @example
+ * ```typescript
+ * const id = getLastSegment("/uploadista/api/upload/abc123");
+ * // => "abc123"
+ * ```
+ */
+export const getLastSegment = (pathname) => {
+    const segments = parseUrlSegments(pathname);
+    return segments[segments.length - 1];
+};
+/**
+ * Checks if a pathname includes a specific base path and API prefix.
+ * Used to determine if a request should be handled by the Uploadista adapter.
+ *
+ * @param pathname - The request pathname
+ * @param basePath - The base path configured for the adapter (e.g., "uploadista")
+ * @returns true if the path includes `{basePath}/api/`
+ *
+ * @example
+ * ```typescript
+ * const isUploadistaPath = hasBasePath("/uploadista/api/upload", "uploadista");
+ * // => true
+ * ```
+ */
+export const hasBasePath = (pathname, basePath) => {
+    return pathname.includes(`${basePath}/api/`);
+};
+/**
+ * Removes the base path prefix and returns clean route segments.
+ * Transforms "/uploadista/api/upload/abc123" → ["upload", "abc123"]
+ *
+ * @param pathname - The full request pathname
+ * @param basePath - The base path to remove (e.g., "uploadista")
+ * @returns Array of route segments without base path prefix
+ *
+ * @example
+ * ```typescript
+ * const route = getRouteSegments("/uploadista/api/upload/abc123", "uploadista");
+ * // => ["upload", "abc123"]
+ * ```
+ */
+export const getRouteSegments = (pathname, basePath) => {
+    return pathname.replace(`${basePath}/api/`, "").split("/").filter(Boolean);
+};
+/**
+ * Standard error handler for flow and job operations.
+ * Maps application errors to appropriate HTTP status codes and error formats.
+ *
+ * Supports errors with `code`, `message`, `status`, and `details` properties.
+ * Maps error codes to HTTP status codes (e.g., NOT_FOUND → 404, VALIDATION_ERROR → 400).
+ *
+ * @param error - The error object to handle (can be any type)
+ * @returns Standardized error response with status, code, message, and optional details
+ *
+ * @example
+ * ```typescript
+ * import { handleFlowError } from "@uploadista/server";
+ *
+ * const response = handleFlowError({
+ *   code: "FLOW_JOB_NOT_FOUND",
+ *   message: "Job not found",
+ * });
+ * // => { status: 404, code: "FLOW_JOB_NOT_FOUND", message: "Job not found" }
+ * ```
+ */
+export const handleFlowError = (error) => {
+    let status = 500;
+    let code = "UNKNOWN_ERROR";
+    let message = "Internal server error";
+    let details;
+    if (typeof error === "object" && error !== null) {
+        const errorObj = error;
+        // Extract error code
+        if ("code" in errorObj && typeof errorObj.code === "string") {
+            code = errorObj.code;
+        }
+        // Extract message
+        if ("message" in errorObj && typeof errorObj.message === "string") {
+            message = errorObj.message;
+        }
+        else if ("body" in errorObj && typeof errorObj.body === "string") {
+            // Support UploadistaError's body property
+            message = errorObj.body;
+        }
+        // Extract details if present
+        if ("details" in errorObj) {
+            details = errorObj.details;
+        }
+        // Map error codes to HTTP status codes
+        if ("status" in errorObj && typeof errorObj.status === "number") {
+            status = errorObj.status;
+        }
+        else if ("code" in errorObj) {
+            // Fallback: derive status from common error codes
+            switch (errorObj.code) {
+                case "FILE_NOT_FOUND":
+                case "FLOW_JOB_NOT_FOUND":
+                case "UPLOAD_ID_NOT_FOUND":
+                    status = 404;
+                    break;
+                case "FLOW_JOB_ERROR":
+                case "VALIDATION_ERROR":
+                case "INVALID_METADATA":
+                case "INVALID_LENGTH":
+                case "ABORTED":
+                case "INVALID_TERMINATION":
+                    status = 400;
+                    break;
+                case "INVALID_OFFSET":
+                    status = 409;
+                    break;
+                case "ERR_SIZE_EXCEEDED":
+                case "ERR_MAX_SIZE_EXCEEDED":
+                    status = 413;
+                    break;
+                case "FILE_NO_LONGER_EXISTS":
+                    status = 410;
+                    break;
+                case "MISSING_OFFSET":
+                case "INVALID_CONTENT_TYPE":
+                    status = 403;
+                    break;
+                default:
+                    status = 500;
+            }
+        }
+        // Special handling for specific error messages
+        if ("message" in errorObj && errorObj.message === "Invalid JSON body") {
+            status = 400;
+            code = "VALIDATION_ERROR";
+        }
+    }
+    const result = {
+        status,
+        code,
+        message,
+    };
+    if (details !== undefined) {
+        result.details = details;
+    }
+    return result;
+};
+/**
+ * Extracts job ID from URL segments for job status endpoint.
+ * Expected URL format: `/uploadista/api/jobs/:jobId/status`
+ *
+ * @param urlSegments - Parsed URL segments (without base path)
+ * @returns The job ID if found, or undefined
+ *
+ * @example
+ * ```typescript
+ * const jobId = extractJobIdFromStatus(["jobs", "job-123", "status"]);
+ * // => "job-123"
+ * ```
+ */
+export const extractJobIdFromStatus = (urlSegments) => {
+    return urlSegments[urlSegments.length - 2];
+};
+/**
+ * Extracts job ID and node ID from URL segments for continue flow endpoint.
+ * Expected URL format: `/uploadista/api/jobs/:jobId/continue/:nodeId`
+ *
+ * @param urlSegments - Parsed URL segments (without base path)
+ * @returns Object with extracted jobId and nodeId (either can be undefined if not found)
+ *
+ * @example
+ * ```typescript
+ * const { jobId, nodeId } = extractJobAndNodeId([
+ *   "jobs",
+ *   "job-123",
+ *   "continue",
+ *   "node-456",
+ * ]);
+ * // => { jobId: "job-123", nodeId: "node-456" }
+ * ```
+ */
+export const extractJobAndNodeId = (urlSegments) => {
+    return {
+        jobId: urlSegments[urlSegments.length - 3],
+        nodeId: urlSegments[urlSegments.length - 1],
+    };
+};
+/**
+ * Extracts flow ID and storage ID from URL segments.
+ * Expected URL format: `/uploadista/api/flow/:flowId/:storageId`
+ *
+ * Mutates the input array (removes last 2 elements).
+ *
+ * @param urlSegments - Parsed URL segments (will be mutated)
+ * @returns Object with extracted flowId and storageId
+ *
+ * @example
+ * ```typescript
+ * const segments = ["flow", "flow-123", "storage-456"];
+ * const { flowId, storageId } = extractFlowAndStorageId(segments);
+ * // => { flowId: "flow-123", storageId: "storage-456" }
+ * // segments is now ["flow"]
+ * ```
+ */
+export const extractFlowAndStorageId = (urlSegments) => {
+    return {
+        storageId: urlSegments.pop(),
+        flowId: urlSegments.pop(),
+    };
+};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./auth";
+export * from "./cache";
+export * from "./error-types";
+export * from "./http-utils";
+export * from "./layer-utils";
+export * from "./plugins-typing";
+export * from "./service";
+export * from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from "./auth";
+export * from "./cache";
+export * from "./error-types";
+export * from "./http-utils";
+export * from "./layer-utils";
+export * from "./plugins-typing";
+export * from "./service";
+export * from "./types";

package/dist/layer-utils.d.ts

@@ -0,0 +1,121 @@
+import type { FlowProvider } from "@uploadista/core/flow";
+import { type BaseEventEmitterService, type BaseKvStoreService, type UploadFileDataStore, type UploadFileDataStores, type UploadFileKVStore } from "@uploadista/core/types";
+import { type UploadServer } from "@uploadista/core/upload";
+import type { GenerateId } from "@uploadista/core/utils";
+import { Layer } from "effect";
+/**
+ * Configuration for creating upload server layers.
+ * Specifies all dependencies needed by the upload server Effect Layer.
+ *
+ * @property kvStore - Key-value store for upload metadata
+ * @property eventEmitter - Event emitter for upload progress events
+ * @property dataStore - File data storage implementation
+ * @property bufferedDataStore - Optional buffered storage for performance optimization
+ * @property generateId - Optional custom ID generator (uses default if omitted)
+ *
+ * @example
+ * ```typescript
+ * import { createUploadServerLayer } from "@uploadista/server";
+ *
+ * const uploadLayerConfig: UploadServerLayerConfig = {
+ *   kvStore: redisKvStore,
+ *   eventEmitter: webSocketEventEmitter,
+ *   dataStore: s3DataStore,
+ * };
+ * ```
+ */
+export interface UploadServerLayerConfig {
+    kvStore: Layer.Layer<BaseKvStoreService>;
+    eventEmitter: Layer.Layer<BaseEventEmitterService>;
+    dataStore: Layer.Layer<UploadFileDataStores, never, UploadFileKVStore>;
+    bufferedDataStore?: Layer.Layer<UploadFileDataStore, never, UploadFileKVStore>;
+    generateId?: Layer.Layer<GenerateId>;
+}
+/**
+ * Configuration for creating flow server layers.
+ * Specifies all dependencies needed by the flow processing server.
+ *
+ * @property kvStore - Key-value store for flow job metadata
+ * @property eventEmitter - Event emitter for flow progress events
+ * @property flowProvider - Factory function for creating flows
+ * @property uploadServer - Upload server layer (used by flows for uploads)
+ *
+ * @example
+ * ```typescript
+ * import { createFlowServerLayer } from "@uploadista/server";
+ *
+ * const flowLayerConfig: FlowServerLayerConfig = {
+ *   kvStore: redisKvStore,
+ *   eventEmitter: webSocketEventEmitter,
+ *   flowProvider: createFlowsEffect,
+ *   uploadServer: uploadServerLayer,
+ * };
+ * ```
+ */
+export interface FlowServerLayerConfig {
+    kvStore: Layer.Layer<BaseKvStoreService>;
+    eventEmitter: Layer.Layer<BaseEventEmitterService>;
+    flowProvider: Layer.Layer<FlowProvider>;
+    uploadServer: Layer.Layer<UploadServer>;
+}
+/**
+ * Creates the upload server layer with all dependencies composed.
+ * This layer handles file uploads with chunked transfer, resumption, and metadata tracking.
+ *
+ * The created layer includes:
+ * - Upload KV store (metadata tracking)
+ * - Data store (file storage)
+ * - Event emitter (progress notifications)
+ * - Optional buffered data store (performance optimization)
+ * - Optional custom ID generator
+ *
+ * @param config - Upload server layer configuration
+ * @returns Effect Layer providing UploadServer
+ *
+ * @example
+ * ```typescript
+ * import { createUploadServerLayer } from "@uploadista/server";
+ * import { Layer } from "effect";
+ *
+ * const uploadServerLayer = createUploadServerLayer({
+ *   kvStore: redisKvStore,
+ *   eventEmitter: webSocketEventEmitter,
+ *   dataStore: s3DataStore,
+ * });
+ *
+ * // Use in application
+ * const app = Layer.provide(appLogic, uploadServerLayer);
+ * ```
+ */
+export declare const createUploadServerLayer: ({ kvStore, eventEmitter, dataStore, bufferedDataStore, generateId, }: UploadServerLayerConfig) => Layer.Layer<UploadServer, never, never>;
+/**
+ * Creates the flow server layer with all dependencies composed.
+ * This layer handles file processing workflows with multi-stage pipelines.
+ *
+ * The created layer includes:
+ * - Flow job KV store (job metadata and state)
+ * - Event emitter (progress notifications)
+ * - Flow provider (flow definitions)
+ * - Upload server (for uploads within flows)
+ *
+ * @param config - Flow server layer configuration
+ * @returns Effect Layer providing FlowServer
+ *
+ * @example
+ * ```typescript
+ * import { createFlowServerLayer } from "@uploadista/server";
+ * import { Layer } from "effect";
+ *
+ * const flowServerLayer = createFlowServerLayer({
+ *   kvStore: redisKvStore,
+ *   eventEmitter: webSocketEventEmitter,
+ *   flowProvider: createFlowsEffect,
+ *   uploadServer: uploadServerLayer,
+ * });
+ *
+ * // Use in application
+ * const app = Layer.provide(appLogic, flowServerLayer);
+ * ```
+ */
+export declare const createFlowServerLayer: ({ kvStore, eventEmitter, flowProvider, uploadServer, }: FlowServerLayerConfig) => Layer.Layer<import("@uploadista/core").FlowServer, never, never>;
+//# sourceMappingURL=layer-utils.d.ts.map

package/dist/layer-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layer-utils.d.ts","sourceRoot":"","sources":["../src/layer-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,EACL,KAAK,uBAAuB,EAC5B,KAAK,kBAAkB,EAGvB,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,iBAAiB,EAGvB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,KAAK,YAAY,EAAgB,MAAM,yBAAyB,CAAC;AAC1E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAE/B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC;IACzC,YAAY,EAAE,KAAK,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;IACnD,SAAS,EAAE,KAAK,CAAC,KAAK,CAAC,oBAAoB,EAAE,KAAK,EAAE,iBAAiB,CAAC,CAAC;IACvE,iBAAiB,CAAC,EAAE,KAAK,CAAC,KAAK,CAC7B,mBAAmB,EACnB,KAAK,EACL,iBAAiB,CAClB,CAAC;IACF,UAAU,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;CACtC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC;IACzC,YAAY,EAAE,KAAK,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;IACnD,YAAY,EAAE,KAAK,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;IACxC,YAAY,EAAE,KAAK,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;CACzC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,uBAAuB,GAAI,sEAMrC,uBAAuB,4CAqBzB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,qBAAqB,GAAI,wDAKnC,qBAAqB,qEAavB,CAAC"}

package/dist/layer-utils.js

@@ -0,0 +1,80 @@
+import { flowServer } from "@uploadista/core/flow";
+import { flowEventEmitter, flowJobKvStore, uploadEventEmitter, uploadFileKvStore, } from "@uploadista/core/types";
+import { uploadServer } from "@uploadista/core/upload";
+import { Layer } from "effect";
+/**
+ * Creates the upload server layer with all dependencies composed.
+ * This layer handles file uploads with chunked transfer, resumption, and metadata tracking.
+ *
+ * The created layer includes:
+ * - Upload KV store (metadata tracking)
+ * - Data store (file storage)
+ * - Event emitter (progress notifications)
+ * - Optional buffered data store (performance optimization)
+ * - Optional custom ID generator
+ *
+ * @param config - Upload server layer configuration
+ * @returns Effect Layer providing UploadServer
+ *
+ * @example
+ * ```typescript
+ * import { createUploadServerLayer } from "@uploadista/server";
+ * import { Layer } from "effect";
+ *
+ * const uploadServerLayer = createUploadServerLayer({
+ *   kvStore: redisKvStore,
+ *   eventEmitter: webSocketEventEmitter,
+ *   dataStore: s3DataStore,
+ * });
+ *
+ * // Use in application
+ * const app = Layer.provide(appLogic, uploadServerLayer);
+ * ```
+ */
+export const createUploadServerLayer = ({ kvStore, eventEmitter, dataStore, bufferedDataStore, generateId, }) => {
+    // Set up upload server dependencies
+    const uploadFileKVStoreLayer = Layer.provide(uploadFileKvStore, kvStore);
+    const uploadDataStoreLayer = Layer.provide(dataStore, uploadFileKVStoreLayer);
+    const uploadBufferedDataStoreLayer = bufferedDataStore
+        ? Layer.provide(bufferedDataStore, uploadFileKVStoreLayer)
+        : Layer.empty;
+    const uploadEventEmitterLayer = Layer.provide(uploadEventEmitter, eventEmitter);
+    const uploadServerLayers = Layer.mergeAll(uploadDataStoreLayer, uploadFileKVStoreLayer, uploadEventEmitterLayer, ...(generateId ? [generateId] : []), uploadBufferedDataStoreLayer);
+    return Layer.provide(uploadServer, uploadServerLayers);
+};
+/**
+ * Creates the flow server layer with all dependencies composed.
+ * This layer handles file processing workflows with multi-stage pipelines.
+ *
+ * The created layer includes:
+ * - Flow job KV store (job metadata and state)
+ * - Event emitter (progress notifications)
+ * - Flow provider (flow definitions)
+ * - Upload server (for uploads within flows)
+ *
+ * @param config - Flow server layer configuration
+ * @returns Effect Layer providing FlowServer
+ *
+ * @example
+ * ```typescript
+ * import { createFlowServerLayer } from "@uploadista/server";
+ * import { Layer } from "effect";
+ *
+ * const flowServerLayer = createFlowServerLayer({
+ *   kvStore: redisKvStore,
+ *   eventEmitter: webSocketEventEmitter,
+ *   flowProvider: createFlowsEffect,
+ *   uploadServer: uploadServerLayer,
+ * });
+ *
+ * // Use in application
+ * const app = Layer.provide(appLogic, flowServerLayer);
+ * ```
+ */
+export const createFlowServerLayer = ({ kvStore, eventEmitter, flowProvider, uploadServer, }) => {
+    // Set up flow server dependencies
+    const flowJobKVStoreLayer = Layer.provide(flowJobKvStore, kvStore);
+    const flowEventEmitterLayer = Layer.provide(flowEventEmitter, eventEmitter);
+    const flowServerLayers = Layer.mergeAll(flowProvider, flowEventEmitterLayer, flowJobKVStoreLayer, uploadServer);
+    return Layer.provide(flowServer, flowServerLayers);
+};

package/dist/metrics/service.d.ts

@@ -0,0 +1,26 @@
+import type { Database } from "@uploadista/orm";
+import { Context, Effect, Layer } from "effect";
+declare const MetricsService_base: Context.TagClass<MetricsService, "MetricsService", {
+    /**
+     * Record upload metrics for an organization
+     */
+    readonly recordUpload: (organizationId: string, bytes: number) => Effect.Effect<void, never>;
+}>;
+/**
+ * Metrics Recording Service
+ *
+ * Provides access to metrics recording functionality throughout
+ * the upload and flow processing pipeline. The service is provided
+ * via Effect Layer and can be accessed using Effect.service().
+ */
+export declare class MetricsService extends MetricsService_base {
+}
+/**
+ * Creates a MetricsService Layer from a Database.
+ *
+ * @param db - The database instance
+ * @returns Effect Layer providing MetricsService
+ */
+export declare const MetricsServiceLive: (db: Database) => Layer.Layer<MetricsService>;
+export {};
+//# sourceMappingURL=service.d.ts.map

package/dist/metrics/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/metrics/service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhD,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;;IAY5C;;OAEG;2BACoB,CACrB,cAAc,EAAE,MAAM,EACtB,KAAK,EAAE,MAAM,KACV,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC;;AAhBnC;;;;;;GAMG;AACH,qBAAa,cAAe,SAAQ,mBAWjC;CAAG;AAEN;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAAI,IAAI,QAAQ,KAAG,KAAK,CAAC,KAAK,CAAC,cAAc,CAMxE,CAAC"}

package/dist/metrics/service.js

@@ -0,0 +1,20 @@
+import { recordUploadMetrics } from "@uploadista/server-metrics";
+import { Context, Effect, Layer } from "effect";
+/**
+ * Metrics Recording Service
+ *
+ * Provides access to metrics recording functionality throughout
+ * the upload and flow processing pipeline. The service is provided
+ * via Effect Layer and can be accessed using Effect.service().
+ */
+export class MetricsService extends Context.Tag("MetricsService")() {
+}
+/**
+ * Creates a MetricsService Layer from a Database.
+ *
+ * @param db - The database instance
+ * @returns Effect Layer providing MetricsService
+ */
+export const MetricsServiceLive = (db) => Layer.succeed(MetricsService, {
+    recordUpload: (organizationId, bytes) => recordUploadMetrics(db, organizationId, bytes).pipe(Effect.catchAll(() => Effect.void)),
+});

package/dist/plugins-typing.d.ts

@@ -0,0 +1,11 @@
+import type { Flow, UploadServer } from "@uploadista/core";
+import type { Effect, Layer } from "effect";
+import type z from "zod";
+export type LayerSuccessUnion<Layers extends readonly Layer.Layer<any, never, never>[]> = Layers[number] extends Layer.Layer<infer Success, never, never> ? Success : never;
+export type FlowSuccess<TFlows extends (flowId: string, clientId: string | null) => Effect.Effect<unknown, unknown, unknown>> = ReturnType<TFlows> extends Effect.Effect<infer Success, unknown, unknown> ? Success : never;
+export type FlowRequirementsOf<TFlows extends (flowId: string, clientId: string | null) => Effect.Effect<unknown, unknown, unknown>> = FlowSuccess<TFlows> extends Flow<z.ZodSchema<unknown>, z.ZodSchema<unknown>, infer R> ? Exclude<R, UploadServer> : never;
+export type RequiredPluginsOf<TFlows extends (flowId: string, clientId: string | null) => Effect.Effect<unknown, unknown, unknown>> = Exclude<FlowRequirementsOf<TFlows>, UploadServer>;
+export type PluginAssertion<TFlows extends (flowId: string, clientId: string | null) => Effect.Effect<unknown, unknown, unknown>, TPlugins extends readonly Layer.Layer<any, never, never>[]> = Exclude<RequiredPluginsOf<TFlows>, LayerSuccessUnion<TPlugins>> extends never ? unknown : {
+    __missingPlugins: Exclude<RequiredPluginsOf<TFlows>, LayerSuccessUnion<TPlugins>>;
+};
+//# sourceMappingURL=plugins-typing.d.ts.map