@uploadista/server 0.0.3

package/dist/cloudflare-config.d.ts

@@ -0,0 +1,72 @@
+import type { EventEmitter, KvStore, UploadEvent, UploadFile } from "@uploadista/core/types";
+import type { UploadServerOptions } from "@uploadista/core/upload";
+import type { Database } from "@uploadista/orm";
+export type CloudflareWorkerEnv = {
+    DATABASE_URL: string;
+    UPLOADISTA_KV: KVNamespace;
+    STORAGE_ENCRYPTION_KEY: string;
+    STORAGE_ENCRYPTION_IV_LENGTH: string;
+    UPLOAD_EVENT_DURABLE_OBJECT: DurableObjectNamespace<any>;
+};
+export type CloudflareUploadServerConfig = {
+    env: CloudflareWorkerEnv;
+    db: Database;
+    kvStore: KvStore<UploadFile>;
+    eventEmitter: EventEmitter<UploadEvent>;
+    getDataStore: (storageId: string, options?: {
+        db?: Database;
+        kvStore?: KvStore<UploadFile>;
+        storageEncryptionKey?: string;
+        storageIvLength?: string;
+    }) => Promise<any>;
+};
+/**
+ * Create an upload server configuration for Cloudflare Workers
+ *
+ * This factory function helps configure the upload server with common
+ * Cloudflare Workers dependencies and environment variables.
+ *
+ * @example
+ * ```ts
+ * import { createCloudflareUploadServerConfig } from "@uploadista/server";
+ * import { createHonoUploadAdapter } from "@uploadista/server";
+ *
+ * const uploadConfig = createCloudflareUploadServerConfig({
+ *   env: c.env,
+ *   db,
+ *   kvStore,
+ *   eventEmitter,
+ *   getDataStore: myGetDataStore,
+ * });
+ *
+ * const uploadAdapter = createHonoUploadAdapter(uploadConfig);
+ * ```
+ */
+export declare const createCloudflareUploadServerConfig: (config: CloudflareUploadServerConfig) => UploadServerOptions;
+/**
+ * Simplified configuration builder for common Cloudflare Workers setups
+ *
+ * This provides a more opinionated configuration that works well for most
+ * standard Cloudflare Workers deployments.
+ *
+ * @example
+ * ```ts
+ * import { createSimpleCloudflareConfig } from "@uploadista/server";
+ *
+ * const uploadAdapter = createSimpleCloudflareConfig({
+ *   env: c.env,
+ *   db,
+ *   getDataStore: myGetDataStore,
+ *   createKvStore: () => myKvStore,
+ *   createEventEmitter: () => myEventEmitter,
+ * });
+ * ```
+ */
+export declare const createSimpleCloudflareConfig: (config: {
+    env: CloudflareWorkerEnv;
+    db: Database;
+    getDataStore: CloudflareUploadServerConfig["getDataStore"];
+    createKvStore: () => KvStore<UploadFile>;
+    createEventEmitter: () => EventEmitter<UploadEvent>;
+}) => UploadServerOptions;
+//# sourceMappingURL=cloudflare-config.d.ts.map

package/dist/cloudflare-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare-config.d.ts","sourceRoot":"","sources":["../src/cloudflare-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EACZ,OAAO,EACP,WAAW,EACX,UAAU,EACX,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhD,MAAM,MAAM,mBAAmB,GAAG;IAChC,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,WAAW,CAAC;IAC3B,sBAAsB,EAAE,MAAM,CAAC;IAC/B,4BAA4B,EAAE,MAAM,CAAC;IACrC,2BAA2B,EAAE,sBAAsB,CAAC,GAAG,CAAC,CAAC;CAC1D,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IACzC,GAAG,EAAE,mBAAmB,CAAC;IACzB,EAAE,EAAE,QAAQ,CAAC;IACb,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;IAC7B,YAAY,EAAE,YAAY,CAAC,WAAW,CAAC,CAAC;IACxC,YAAY,EAAE,CACZ,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE;QACR,EAAE,CAAC,EAAE,QAAQ,CAAC;QACd,OAAO,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;QAC9B,oBAAoB,CAAC,EAAE,MAAM,CAAC;QAC9B,eAAe,CAAC,EAAE,MAAM,CAAC;KAC1B,KACE,OAAO,CAAC,GAAG,CAAC,CAAC;CACnB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,kCAAkC,GAC7C,QAAQ,4BAA4B,KACnC,mBAeF,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,4BAA4B,GAAI,QAAQ;IACnD,GAAG,EAAE,mBAAmB,CAAC;IACzB,EAAE,EAAE,QAAQ,CAAC;IACb,YAAY,EAAE,4BAA4B,CAAC,cAAc,CAAC,CAAC;IAC3D,aAAa,EAAE,MAAM,OAAO,CAAC,UAAU,CAAC,CAAC;IACzC,kBAAkB,EAAE,MAAM,YAAY,CAAC,WAAW,CAAC,CAAC;CACrD,wBAYA,CAAC"}

package/dist/cloudflare-config.js

@@ -0,0 +1,67 @@
+/**
+ * Create an upload server configuration for Cloudflare Workers
+ *
+ * This factory function helps configure the upload server with common
+ * Cloudflare Workers dependencies and environment variables.
+ *
+ * @example
+ * ```ts
+ * import { createCloudflareUploadServerConfig } from "@uploadista/server";
+ * import { createHonoUploadAdapter } from "@uploadista/server";
+ *
+ * const uploadConfig = createCloudflareUploadServerConfig({
+ *   env: c.env,
+ *   db,
+ *   kvStore,
+ *   eventEmitter,
+ *   getDataStore: myGetDataStore,
+ * });
+ *
+ * const uploadAdapter = createHonoUploadAdapter(uploadConfig);
+ * ```
+ */
+export const createCloudflareUploadServerConfig = (config) => {
+    const { env, db, kvStore, eventEmitter, getDataStore } = config;
+    return {
+        dataStore: (storageId) => {
+            return getDataStore(storageId, {
+                db,
+                kvStore,
+                storageEncryptionKey: env.STORAGE_ENCRYPTION_KEY,
+                storageIvLength: env.STORAGE_ENCRYPTION_IV_LENGTH,
+            });
+        },
+        kvStore,
+        eventEmitter,
+    };
+};
+/**
+ * Simplified configuration builder for common Cloudflare Workers setups
+ *
+ * This provides a more opinionated configuration that works well for most
+ * standard Cloudflare Workers deployments.
+ *
+ * @example
+ * ```ts
+ * import { createSimpleCloudflareConfig } from "@uploadista/server";
+ *
+ * const uploadAdapter = createSimpleCloudflareConfig({
+ *   env: c.env,
+ *   db,
+ *   getDataStore: myGetDataStore,
+ *   createKvStore: () => myKvStore,
+ *   createEventEmitter: () => myEventEmitter,
+ * });
+ * ```
+ */
+export const createSimpleCloudflareConfig = (config) => {
+    const { env, db, getDataStore, createKvStore, createEventEmitter } = config;
+    const uploadServerConfig = createCloudflareUploadServerConfig({
+        env,
+        db,
+        kvStore: createKvStore(),
+        eventEmitter: createEventEmitter(),
+        getDataStore,
+    });
+    return uploadServerConfig;
+};

package/dist/error-types.d.ts

@@ -0,0 +1,138 @@
+import type { UploadistaError } from "@uploadista/core/errors";
+/**
+ * Base adapter error class for HTTP adapters.
+ * All adapter-specific errors should extend this class or one of its subclasses.
+ *
+ * @example
+ * ```typescript
+ * throw new AdapterError("Something went wrong", 500, "INTERNAL_ERROR");
+ * ```
+ */
+export declare class AdapterError extends Error {
+    readonly statusCode: number;
+    readonly errorCode: string;
+    constructor(message: string, statusCode?: number, errorCode?: string);
+}
+/**
+ * Validation error - indicates invalid request data or parameters.
+ * Returns HTTP 400 Bad Request status.
+ *
+ * @example
+ * ```typescript
+ * if (!isValidUploadId(id)) {
+ *   throw new ValidationError("Invalid upload ID format");
+ * }
+ * ```
+ */
+export declare class ValidationError extends AdapterError {
+    constructor(message: string);
+}
+/**
+ * Not found error - indicates a requested resource does not exist.
+ * Returns HTTP 404 Not Found status.
+ *
+ * @example
+ * ```typescript
+ * if (!upload) {
+ *   throw new NotFoundError("Upload");
+ * }
+ * ```
+ */
+export declare class NotFoundError extends AdapterError {
+    constructor(resource: string);
+}
+/**
+ * Bad request error - indicates a malformed request.
+ * Returns HTTP 400 Bad Request status.
+ * Similar to ValidationError but for request structure issues.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const data = JSON.parse(body);
+ * } catch {
+ *   throw new BadRequestError("Invalid JSON body");
+ * }
+ * ```
+ */
+export declare class BadRequestError extends AdapterError {
+    constructor(message: string);
+}
+/**
+ * Creates a standardized error response object for AdapterError.
+ * Includes error message, error code, and ISO timestamp.
+ *
+ * @param error - The AdapterError to format
+ * @returns Standardized error response body
+ *
+ * @example
+ * ```typescript
+ * import { createErrorResponseBody } from "@uploadista/server";
+ *
+ * try {
+ *   // ... operation
+ * } catch (err) {
+ *   const errorResponse = createErrorResponseBody(err);
+ *   res.status(err.statusCode).json(errorResponse);
+ * }
+ * ```
+ */
+export declare const createErrorResponseBody: (error: AdapterError) => {
+    error: string;
+    code: string;
+    timestamp: string;
+};
+/**
+ * Creates a standardized error response body from UploadistaError.
+ * Formats core library errors for HTTP responses with optional details.
+ *
+ * @param error - The UploadistaError to format
+ * @returns Standardized error response body with error, code, timestamp, and optional details
+ *
+ * @example
+ * ```typescript
+ * import { createUploadistaErrorResponseBody } from "@uploadista/server";
+ *
+ * try {
+ *   const result = yield* uploadServer.handleUpload(input);
+ * } catch (err) {
+ *   if (err instanceof UploadistaError) {
+ *     const errorResponse = createUploadistaErrorResponseBody(err);
+ *     res.status(400).json(errorResponse);
+ *   }
+ * }
+ * ```
+ */
+export declare const createUploadistaErrorResponseBody: (error: UploadistaError) => {
+    error: string;
+    code: string;
+    timestamp: string;
+    details?: unknown;
+};
+/**
+ * Creates a generic error response body for unknown/unexpected errors.
+ * Used as a fallback when error type cannot be determined.
+ *
+ * @param message - Error message to include in response (defaults to "Internal server error")
+ * @returns Standardized error response body with generic INTERNAL_ERROR code
+ *
+ * @example
+ * ```typescript
+ * import { createGenericErrorResponseBody } from "@uploadista/server";
+ *
+ * try {
+ *   // ... operation
+ * } catch (err) {
+ *   const errorResponse = createGenericErrorResponseBody(
+ *     err instanceof Error ? err.message : "Unknown error"
+ *   );
+ *   res.status(500).json(errorResponse);
+ * }
+ * ```
+ */
+export declare const createGenericErrorResponseBody: (message?: string) => {
+    error: string;
+    code: string;
+    timestamp: string;
+};
+//# sourceMappingURL=error-types.d.ts.map

package/dist/error-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-types.d.ts","sourceRoot":"","sources":["../src/error-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE/D;;;;;;;;GAQG;AACH,qBAAa,YAAa,SAAQ,KAAK;aAGnB,UAAU,EAAE,MAAM;aAClB,SAAS,EAAE,MAAM;gBAFjC,OAAO,EAAE,MAAM,EACC,UAAU,GAAE,MAAY,EACxB,SAAS,GAAE,MAAyB;CAKvD;AAED;;;;;;;;;;GAUG;AACH,qBAAa,eAAgB,SAAQ,YAAY;gBACnC,OAAO,EAAE,MAAM;CAI5B;AAED;;;;;;;;;;GAUG;AACH,qBAAa,aAAc,SAAQ,YAAY;gBACjC,QAAQ,EAAE,MAAM;CAI7B;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,eAAgB,SAAQ,YAAY;gBACnC,OAAO,EAAE,MAAM;CAI5B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,uBAAuB,GAAI,OAAO,YAAY;;;;CAIzD,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,iCAAiC,GAAI,OAAO,eAAe;WAE7D,MAAM;UACP,MAAM;eACD,MAAM;cACP,OAAO;CAYpB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,8BAA8B,GACzC,gBAAiC;;;;CAKjC,CAAC"}

package/dist/error-types.js

@@ -0,0 +1,155 @@
+/**
+ * Base adapter error class for HTTP adapters.
+ * All adapter-specific errors should extend this class or one of its subclasses.
+ *
+ * @example
+ * ```typescript
+ * throw new AdapterError("Something went wrong", 500, "INTERNAL_ERROR");
+ * ```
+ */
+export class AdapterError extends Error {
+    statusCode;
+    errorCode;
+    constructor(message, statusCode = 500, errorCode = "INTERNAL_ERROR") {
+        super(message);
+        this.statusCode = statusCode;
+        this.errorCode = errorCode;
+        this.name = "AdapterError";
+    }
+}
+/**
+ * Validation error - indicates invalid request data or parameters.
+ * Returns HTTP 400 Bad Request status.
+ *
+ * @example
+ * ```typescript
+ * if (!isValidUploadId(id)) {
+ *   throw new ValidationError("Invalid upload ID format");
+ * }
+ * ```
+ */
+export class ValidationError extends AdapterError {
+    constructor(message) {
+        super(message, 400, "VALIDATION_ERROR");
+        this.name = "ValidationError";
+    }
+}
+/**
+ * Not found error - indicates a requested resource does not exist.
+ * Returns HTTP 404 Not Found status.
+ *
+ * @example
+ * ```typescript
+ * if (!upload) {
+ *   throw new NotFoundError("Upload");
+ * }
+ * ```
+ */
+export class NotFoundError extends AdapterError {
+    constructor(resource) {
+        super(`${resource} not found`, 404, "NOT_FOUND");
+        this.name = "NotFoundError";
+    }
+}
+/**
+ * Bad request error - indicates a malformed request.
+ * Returns HTTP 400 Bad Request status.
+ * Similar to ValidationError but for request structure issues.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const data = JSON.parse(body);
+ * } catch {
+ *   throw new BadRequestError("Invalid JSON body");
+ * }
+ * ```
+ */
+export class BadRequestError extends AdapterError {
+    constructor(message) {
+        super(message, 400, "BAD_REQUEST");
+        this.name = "BadRequestError";
+    }
+}
+/**
+ * Creates a standardized error response object for AdapterError.
+ * Includes error message, error code, and ISO timestamp.
+ *
+ * @param error - The AdapterError to format
+ * @returns Standardized error response body
+ *
+ * @example
+ * ```typescript
+ * import { createErrorResponseBody } from "@uploadista/server";
+ *
+ * try {
+ *   // ... operation
+ * } catch (err) {
+ *   const errorResponse = createErrorResponseBody(err);
+ *   res.status(err.statusCode).json(errorResponse);
+ * }
+ * ```
+ */
+export const createErrorResponseBody = (error) => ({
+    error: error.message,
+    code: error.errorCode,
+    timestamp: new Date().toISOString(),
+});
+/**
+ * Creates a standardized error response body from UploadistaError.
+ * Formats core library errors for HTTP responses with optional details.
+ *
+ * @param error - The UploadistaError to format
+ * @returns Standardized error response body with error, code, timestamp, and optional details
+ *
+ * @example
+ * ```typescript
+ * import { createUploadistaErrorResponseBody } from "@uploadista/server";
+ *
+ * try {
+ *   const result = yield* uploadServer.handleUpload(input);
+ * } catch (err) {
+ *   if (err instanceof UploadistaError) {
+ *     const errorResponse = createUploadistaErrorResponseBody(err);
+ *     res.status(400).json(errorResponse);
+ *   }
+ * }
+ * ```
+ */
+export const createUploadistaErrorResponseBody = (error) => {
+    const response = {
+        error: error.body,
+        code: error.code,
+        timestamp: new Date().toISOString(),
+    };
+    if (error.details !== undefined) {
+        response.details = error.details;
+    }
+    return response;
+};
+/**
+ * Creates a generic error response body for unknown/unexpected errors.
+ * Used as a fallback when error type cannot be determined.
+ *
+ * @param message - Error message to include in response (defaults to "Internal server error")
+ * @returns Standardized error response body with generic INTERNAL_ERROR code
+ *
+ * @example
+ * ```typescript
+ * import { createGenericErrorResponseBody } from "@uploadista/server";
+ *
+ * try {
+ *   // ... operation
+ * } catch (err) {
+ *   const errorResponse = createGenericErrorResponseBody(
+ *     err instanceof Error ? err.message : "Unknown error"
+ *   );
+ *   res.status(500).json(errorResponse);
+ * }
+ * ```
+ */
+export const createGenericErrorResponseBody = (message = "Internal server error") => ({
+    error: message,
+    code: "INTERNAL_ERROR",
+    timestamp: new Date().toISOString(),
+});

package/dist/hono-adapter.d.ts

@@ -0,0 +1,48 @@
+import type { InputFile } from "@uploadista/core/types";
+import type { UploadServerOptions } from "@uploadista/core/upload";
+import type { Context } from "hono";
+export type HonoUploadAdapterOptions = UploadServerOptions;
+export type HonoUploadAdapter = {
+    handler: (c: Context) => Promise<Response>;
+    upload: (c: Context, file: InputFile, stream: ReadableStream) => Promise<unknown>;
+    destroy?: () => Promise<void>;
+};
+/**
+ * Create a Hono adapter for the upload server
+ *
+ * @example
+ * ```ts
+ * const uploadAdapter = createHonoUploadAdapter({
+ *   dataStore: (storageId) => getDataStore(storageId),
+ *   kvStore: myKvStore,
+ *   eventEmitter: myEventEmitter,
+ * });
+ *
+ * const uploadAdapter = { handler: uploadServer.handler };
+ *
+ * app.on(['POST', 'GET', 'PATCH'], '/api/upload/**', (c) =>
+ *   uploadAdapter.handler(c)
+ * );
+ * ```
+ */
+export declare const createHonoUploadAdapter: (options: HonoUploadAdapterOptions) => HonoUploadAdapter;
+/**
+ * Middleware factory for Hono that handles upload server integration
+ *
+ * @example
+ * ```ts
+ * const uploadServerMiddleware = createHonoUploadServerMiddleware({
+ *   dataStore: (storageId) => getDataStore(storageId),
+ *   kvStore: myKvStore,
+ *   eventEmitter: myEventEmitter,
+ * });
+ *
+ * app.use(uploadServerMiddleware);
+ *
+ * app.on(['POST', 'GET', 'PATCH'], '/api/upload/**', (c) =>
+ *   c.get('uploadServer').handler(c.req.raw)
+ * );
+ * ```
+ */
+export declare const createHonoUploadServerMiddleware: (options: HonoUploadAdapterOptions) => (c: Context, next: () => Promise<void>) => Promise<void>;
+//# sourceMappingURL=hono-adapter.d.ts.map

package/dist/hono-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hono-adapter.d.ts","sourceRoot":"","sources":["../src/hono-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,KAAK,EAEV,mBAAmB,EACpB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAEpC,MAAM,MAAM,wBAAwB,GAAG,mBAAmB,CAAC;AAE3D,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC3C,MAAM,EAAE,CACN,CAAC,EAAE,OAAO,EACV,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,cAAc,KACnB,OAAO,CAAC,OAAO,CAAC,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/B,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,uBAAuB,GAClC,SAAS,wBAAwB,KAChC,iBAqBF,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,gCAAgC,GAC3C,SAAS,wBAAwB,MAInB,GAAG,OAAO,EAAE,MAAM,MAAM,OAAO,CAAC,IAAI,CAAC,kBAIpD,CAAC"}

package/dist/hono-adapter.js

@@ -0,0 +1,58 @@
+import { createFrameworkAgnosticUploadServer } from "@uploadista/core/upload";
+/**
+ * Create a Hono adapter for the upload server
+ *
+ * @example
+ * ```ts
+ * const uploadAdapter = createHonoUploadAdapter({
+ *   dataStore: (storageId) => getDataStore(storageId),
+ *   kvStore: myKvStore,
+ *   eventEmitter: myEventEmitter,
+ * });
+ *
+ * const uploadAdapter = { handler: uploadServer.handler };
+ *
+ * app.on(['POST', 'GET', 'PATCH'], '/api/upload/**', (c) =>
+ *   uploadAdapter.handler(c)
+ * );
+ * ```
+ */
+export const createHonoUploadAdapter = (options) => {
+    const server = createFrameworkAgnosticUploadServer(options);
+    return {
+        handler: async (c) => {
+            return server.handler(c.req.raw);
+        },
+        upload: async (_c, file, stream) => {
+            return server.upload(file, stream);
+        },
+        destroy: async () => {
+            await server.destroy?.();
+        },
+    };
+};
+/**
+ * Middleware factory for Hono that handles upload server integration
+ *
+ * @example
+ * ```ts
+ * const uploadServerMiddleware = createHonoUploadServerMiddleware({
+ *   dataStore: (storageId) => getDataStore(storageId),
+ *   kvStore: myKvStore,
+ *   eventEmitter: myEventEmitter,
+ * });
+ *
+ * app.use(uploadServerMiddleware);
+ *
+ * app.on(['POST', 'GET', 'PATCH'], '/api/upload/**', (c) =>
+ *   c.get('uploadServer').handler(c.req.raw)
+ * );
+ * ```
+ */
+export const createHonoUploadServerMiddleware = (options) => {
+    const server = createFrameworkAgnosticUploadServer(options);
+    return async (c, next) => {
+        c.set("uploadServer", server);
+        await next();
+    };
+};