@uploadista/core 0.0.2

package/dist/types/input-file.d.ts

@@ -0,0 +1,104 @@
+import { z } from "zod";
+/**
+ * Zod schema for validating InputFile objects.
+ *
+ * This schema defines the structure and validation rules for file upload requests.
+ * Use this schema to parse and validate input data when creating new uploads.
+ *
+ * @see {@link InputFile} for the TypeScript type
+ */
+export declare const inputFileSchema: z.ZodObject<{
+    uploadLengthDeferred: z.ZodOptional<z.ZodBoolean>;
+    storageId: z.ZodString;
+    size: z.ZodNumber;
+    type: z.ZodString;
+    fileName: z.ZodOptional<z.ZodString>;
+    lastModified: z.ZodOptional<z.ZodNumber>;
+    metadata: z.ZodOptional<z.ZodString>;
+    checksum: z.ZodOptional<z.ZodString>;
+    checksumAlgorithm: z.ZodOptional<z.ZodString>;
+    flow: z.ZodOptional<z.ZodObject<{
+        flowId: z.ZodString;
+        nodeId: z.ZodString;
+        jobId: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Represents the input data for creating a new file upload.
+ *
+ * This type defines the information required to initiate an upload.
+ * It's used by clients to provide upload metadata before sending file data.
+ *
+ * @property storageId - Target storage backend identifier (e.g., "s3-production", "azure-blob")
+ * @property size - File size in bytes
+ * @property type - MIME type of the file (e.g., "image/jpeg", "application/pdf")
+ * @property uploadLengthDeferred - If true, file size is not known upfront (streaming upload)
+ * @property fileName - Original filename from the client
+ * @property lastModified - File's last modified timestamp in milliseconds since epoch
+ * @property metadata - Base64-encoded metadata string (as per tus protocol)
+ * @property checksum - Expected file checksum for validation
+ * @property checksumAlgorithm - Algorithm used for checksum (e.g., "md5", "sha256")
+ * @property flow - Optional flow processing configuration
+ * @property flow.flowId - ID of the flow to execute on this file
+ * @property flow.nodeId - Starting node ID in the flow
+ * @property flow.jobId - Flow job execution ID
+ *
+ * @example
+ * ```typescript
+ * // Basic file upload
+ * const inputFile: InputFile = {
+ *   storageId: "s3-production",
+ *   size: 1024000,
+ *   type: "image/jpeg",
+ *   fileName: "photo.jpg",
+ *   lastModified: Date.now()
+ * };
+ *
+ * // Upload with metadata (base64 encoded as per tus protocol)
+ * const metadata = btoa(JSON.stringify({
+ *   userId: "user_123",
+ *   albumId: "album_456"
+ * }));
+ * const inputWithMetadata: InputFile = {
+ *   storageId: "s3-production",
+ *   size: 2048000,
+ *   type: "image/png",
+ *   fileName: "screenshot.png",
+ *   metadata
+ * };
+ *
+ * // Upload with checksum validation
+ * const inputWithChecksum: InputFile = {
+ *   storageId: "s3-production",
+ *   size: 512000,
+ *   type: "application/pdf",
+ *   fileName: "document.pdf",
+ *   checksum: "5d41402abc4b2a76b9719d911017c592",
+ *   checksumAlgorithm: "md5"
+ * };
+ *
+ * // Upload that triggers a flow
+ * const inputWithFlow: InputFile = {
+ *   storageId: "s3-temp",
+ *   size: 4096000,
+ *   type: "image/jpeg",
+ *   fileName: "large-image.jpg",
+ *   flow: {
+ *     flowId: "resize-and-optimize",
+ *     nodeId: "input_1",
+ *     jobId: "job_789"
+ *   }
+ * };
+ *
+ * // Streaming upload (size unknown)
+ * const streamingInput: InputFile = {
+ *   storageId: "s3-production",
+ *   size: 0, // Will be updated as data arrives
+ *   type: "video/mp4",
+ *   uploadLengthDeferred: true,
+ *   fileName: "live-stream.mp4"
+ * };
+ * ```
+ */
+export type InputFile = z.infer<typeof inputFileSchema>;
+//# sourceMappingURL=input-file.d.ts.map

package/dist/types/input-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input-file.d.ts","sourceRoot":"","sources":["../../src/types/input-file.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;iBAiB1B,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4EG;AACH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/dist/types/input-file.js

@@ -0,0 +1,27 @@
+import { z } from "zod";
+/**
+ * Zod schema for validating InputFile objects.
+ *
+ * This schema defines the structure and validation rules for file upload requests.
+ * Use this schema to parse and validate input data when creating new uploads.
+ *
+ * @see {@link InputFile} for the TypeScript type
+ */
+export const inputFileSchema = z.object({
+    uploadLengthDeferred: z.boolean().optional(),
+    storageId: z.string(),
+    size: z.number(),
+    type: z.string(),
+    fileName: z.string().optional(),
+    lastModified: z.number().optional(),
+    metadata: z.string().optional(),
+    checksum: z.string().optional(),
+    checksumAlgorithm: z.string().optional(),
+    flow: z
+        .object({
+        flowId: z.string(),
+        nodeId: z.string(),
+        jobId: z.string(),
+    })
+        .optional(),
+});

package/dist/types/kv-store.d.ts

@@ -0,0 +1,281 @@
+import { Context, Effect, Layer } from "effect";
+import { UploadistaError } from "../errors";
+import type { FlowJob } from "../flow";
+import type { UploadFile } from "./upload-file";
+/**
+ * Base key-value store interface for raw string storage.
+ *
+ * This is the low-level interface that storage adapters implement.
+ * It stores raw string values without type safety or serialization.
+ *
+ * @property get - Retrieves a value by key, returns null if not found
+ * @property set - Stores a value with the given key
+ * @property delete - Removes a value by key
+ * @property list - Optional operation to list all keys with a given prefix
+ *
+ * @example
+ * ```typescript
+ * // Implement a BaseKvStore with Redis
+ * const redisKvStore: BaseKvStore = {
+ *   get: (key) => Effect.tryPromise({
+ *     try: () => redis.get(key),
+ *     catch: (error) => UploadistaError.fromCode("UNKNOWN_ERROR", { cause: error })
+ *   }),
+ *
+ *   set: (key, value) => Effect.tryPromise({
+ *     try: () => redis.set(key, value),
+ *     catch: (error) => UploadistaError.fromCode("UNKNOWN_ERROR", { cause: error })
+ *   }),
+ *
+ *   delete: (key) => Effect.tryPromise({
+ *     try: () => redis.del(key),
+ *     catch: (error) => UploadistaError.fromCode("UNKNOWN_ERROR", { cause: error })
+ *   }),
+ *
+ *   list: (prefix) => Effect.tryPromise({
+ *     try: () => redis.keys(`${prefix}*`),
+ *     catch: (error) => UploadistaError.fromCode("UNKNOWN_ERROR", { cause: error })
+ *   })
+ * };
+ * ```
+ */
+export interface BaseKvStore {
+    readonly get: (key: string) => Effect.Effect<string | null, UploadistaError>;
+    readonly set: (key: string, value: string) => Effect.Effect<void, UploadistaError>;
+    readonly delete: (key: string) => Effect.Effect<void, UploadistaError>;
+    readonly list?: (keyPrefix: string) => Effect.Effect<Array<string>, UploadistaError>;
+}
+/**
+ * Type-safe key-value store interface with automatic serialization.
+ *
+ * This wraps a BaseKvStore and handles JSON serialization/deserialization
+ * for a specific data type, providing type safety and eliminating the need
+ * for manual JSON.stringify/parse calls.
+ *
+ * @template TData - The type of data stored in this KV store
+ *
+ * @property get - Retrieves and deserializes a value, fails if not found
+ * @property set - Serializes and stores a value
+ * @property delete - Removes a value by key
+ * @property list - Optional operation to list all keys (without prefix)
+ *
+ * @example
+ * ```typescript
+ * // Use a typed KV store
+ * const uploadStore: KvStore<UploadFile> = new TypedKvStore(
+ *   baseStore,
+ *   "uploads:",
+ *   jsonSerializer.serialize,
+ *   jsonSerializer.deserialize
+ * );
+ *
+ * // Store and retrieve typed data
+ * const program = Effect.gen(function* () {
+ *   const file: UploadFile = {
+ *     id: "file123",
+ *     offset: 0,
+ *     storage: { id: "s3", type: "s3" }
+ *   };
+ *
+ *   // Automatic serialization
+ *   yield* uploadStore.set("file123", file);
+ *
+ *   // Automatic deserialization with type safety
+ *   const retrieved = yield* uploadStore.get("file123");
+ *   console.log(retrieved.offset); // TypeScript knows this is a number
+ * });
+ * ```
+ */
+export type KvStore<TData> = {
+    readonly get: (key: string) => Effect.Effect<TData, UploadistaError>;
+    readonly set: (key: string, value: TData) => Effect.Effect<void, UploadistaError>;
+    readonly delete: (key: string) => Effect.Effect<void, UploadistaError>;
+    readonly list?: () => Effect.Effect<Array<string>, UploadistaError>;
+};
+/**
+ * Typed wrapper class that adds serialization to a BaseKvStore.
+ *
+ * This class implements the KvStore interface by wrapping a BaseKvStore
+ * and handling serialization/deserialization for a specific type. It also
+ * adds a key prefix to isolate different data types in the same store.
+ *
+ * @template TData - The type of data to store
+ *
+ * @example
+ * ```typescript
+ * // Create a typed store for UploadFile
+ * const uploadFileStore = new TypedKvStore<UploadFile>(
+ *   baseKvStore,
+ *   "uploadista:upload-file:", // All keys will be prefixed
+ *   (data) => JSON.stringify(data),
+ *   (str) => JSON.parse(str) as UploadFile
+ * );
+ *
+ * // Use the store
+ * const effect = Effect.gen(function* () {
+ *   const file: UploadFile = { ... };
+ *   yield* uploadFileStore.set("abc123", file);
+ *   // Internally stores at key "uploadista:upload-file:abc123"
+ *
+ *   const retrieved = yield* uploadFileStore.get("abc123");
+ *   return retrieved;
+ * });
+ *
+ * // Custom serialization for binary data
+ * const binaryStore = new TypedKvStore<Uint8Array>(
+ *   baseKvStore,
+ *   "binary:",
+ *   (data) => btoa(String.fromCharCode(...data)), // Base64 encode
+ *   (str) => Uint8Array.from(atob(str), c => c.charCodeAt(0)) // Base64 decode
+ * );
+ * ```
+ */
+export declare class TypedKvStore<TData> implements KvStore<TData> {
+    private baseStore;
+    private keyPrefix;
+    private serialize;
+    private deserialize;
+    constructor(baseStore: BaseKvStore, keyPrefix: string, serialize: (data: TData) => string, deserialize: (str: string) => TData);
+    get: (key: string) => Effect.Effect<TData, UploadistaError>;
+    set: (key: string, value: TData) => Effect.Effect<void, UploadistaError>;
+    delete: (key: string) => Effect.Effect<void, UploadistaError>;
+    list: () => Effect.Effect<Array<string>, UploadistaError>;
+}
+/**
+ * Default JSON serialization helpers.
+ *
+ * These functions provide standard JSON serialization for use with TypedKvStore.
+ * They work with any JSON-serializable type.
+ *
+ * @example
+ * ```typescript
+ * const store = new TypedKvStore<MyType>(
+ *   baseStore,
+ *   "mydata:",
+ *   jsonSerializer.serialize,
+ *   jsonSerializer.deserialize
+ * );
+ * ```
+ */
+export declare const jsonSerializer: {
+    serialize: <T>(data: T) => string;
+    deserialize: <T>(str: string) => T;
+};
+declare const BaseKvStoreService_base: Context.TagClass<BaseKvStoreService, "BaseKvStore", BaseKvStore>;
+/**
+ * Effect-TS context tag for the base untyped KV store.
+ *
+ * This is the low-level store that storage adapter implementations provide.
+ * Most application code should use typed stores like UploadFileKVStore instead.
+ *
+ * @example
+ * ```typescript
+ * // Provide a base store implementation
+ * const baseStoreLayer = Layer.succeed(BaseKvStoreService, redisKvStore);
+ *
+ * // Use in an Effect
+ * const effect = Effect.gen(function* () {
+ *   const baseStore = yield* BaseKvStoreService;
+ *   yield* baseStore.set("raw-key", "raw-value");
+ * });
+ * ```
+ */
+export declare class BaseKvStoreService extends BaseKvStoreService_base {
+}
+declare const UploadFileKVStore_base: Context.TagClass<UploadFileKVStore, "UploadFileKVStore", KvStore<UploadFile>>;
+/**
+ * Effect-TS context tag for the UploadFile typed KV store.
+ *
+ * This provides type-safe storage for UploadFile metadata. It's the primary
+ * way to store and retrieve upload metadata in the system.
+ *
+ * @example
+ * ```typescript
+ * const uploadEffect = Effect.gen(function* () {
+ *   const kvStore = yield* UploadFileKVStore;
+ *
+ *   // Store upload metadata
+ *   const file: UploadFile = {
+ *     id: "upload123",
+ *     offset: 0,
+ *     storage: { id: "s3", type: "s3" }
+ *   };
+ *   yield* kvStore.set("upload123", file);
+ *
+ *   // Retrieve with type safety
+ *   const retrieved = yield* kvStore.get("upload123");
+ *   return retrieved;
+ * });
+ * ```
+ */
+export declare class UploadFileKVStore extends UploadFileKVStore_base {
+}
+/**
+ * Effect Layer that creates the UploadFileKVStore from a BaseKvStore.
+ *
+ * This layer automatically wires up JSON serialization for UploadFile objects
+ * with the "uploadista:upload-file:" key prefix.
+ *
+ * @example
+ * ```typescript
+ * const program = Effect.gen(function* () {
+ *   const kvStore = yield* UploadFileKVStore;
+ *   // Use the store...
+ * }).pipe(
+ *   Effect.provide(uploadFileKvStore),
+ *   Effect.provide(baseStoreLayer)
+ * );
+ * ```
+ */
+export declare const uploadFileKvStore: Layer.Layer<UploadFileKVStore, never, BaseKvStoreService>;
+declare const FlowJobKVStore_base: Context.TagClass<FlowJobKVStore, "FlowJobKVStore", KvStore<FlowJob>>;
+/**
+ * Effect-TS context tag for the FlowJob typed KV store.
+ *
+ * This provides type-safe storage for FlowJob metadata, tracking the
+ * execution state of flow processing jobs.
+ *
+ * @example
+ * ```typescript
+ * const flowEffect = Effect.gen(function* () {
+ *   const jobStore = yield* FlowJobKVStore;
+ *
+ *   // Store job state
+ *   const job: FlowJob = {
+ *     id: "job123",
+ *     flowId: "flow_resize",
+ *     status: "running",
+ *     tasks: [],
+ *     createdAt: new Date(),
+ *     updatedAt: new Date()
+ *   };
+ *   yield* jobStore.set("job123", job);
+ *
+ *   // Retrieve and check status
+ *   const retrieved = yield* jobStore.get("job123");
+ *   return retrieved.status;
+ * });
+ * ```
+ */
+export declare class FlowJobKVStore extends FlowJobKVStore_base {
+}
+/**
+ * Effect Layer that creates the FlowJobKVStore from a BaseKvStore.
+ *
+ * This layer automatically wires up JSON serialization for FlowJob objects
+ * with the "uploadista:flow-job:" key prefix.
+ *
+ * @example
+ * ```typescript
+ * const program = Effect.gen(function* () {
+ *   const jobStore = yield* FlowJobKVStore;
+ *   // Use the store...
+ * }).pipe(
+ *   Effect.provide(flowJobKvStore),
+ *   Effect.provide(baseStoreLayer)
+ * );
+ * ```
+ */
+export declare const flowJobKvStore: Layer.Layer<FlowJobKVStore, never, BaseKvStoreService>;
+export {};
+//# sourceMappingURL=kv-store.d.ts.map

package/dist/types/kv-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kv-store.d.ts","sourceRoot":"","sources":["../../src/types/kv-store.ts"],"names":[],"mappings":"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"}

package/dist/types/kv-store.js

@@ -0,0 +1,234 @@
+import { Context, Effect, Layer } from "effect";
+import { UploadistaError } from "../errors";
+/**
+ * Typed wrapper class that adds serialization to a BaseKvStore.
+ *
+ * This class implements the KvStore interface by wrapping a BaseKvStore
+ * and handling serialization/deserialization for a specific type. It also
+ * adds a key prefix to isolate different data types in the same store.
+ *
+ * @template TData - The type of data to store
+ *
+ * @example
+ * ```typescript
+ * // Create a typed store for UploadFile
+ * const uploadFileStore = new TypedKvStore<UploadFile>(
+ *   baseKvStore,
+ *   "uploadista:upload-file:", // All keys will be prefixed
+ *   (data) => JSON.stringify(data),
+ *   (str) => JSON.parse(str) as UploadFile
+ * );
+ *
+ * // Use the store
+ * const effect = Effect.gen(function* () {
+ *   const file: UploadFile = { ... };
+ *   yield* uploadFileStore.set("abc123", file);
+ *   // Internally stores at key "uploadista:upload-file:abc123"
+ *
+ *   const retrieved = yield* uploadFileStore.get("abc123");
+ *   return retrieved;
+ * });
+ *
+ * // Custom serialization for binary data
+ * const binaryStore = new TypedKvStore<Uint8Array>(
+ *   baseKvStore,
+ *   "binary:",
+ *   (data) => btoa(String.fromCharCode(...data)), // Base64 encode
+ *   (str) => Uint8Array.from(atob(str), c => c.charCodeAt(0)) // Base64 decode
+ * );
+ * ```
+ */
+export class TypedKvStore {
+    baseStore;
+    keyPrefix;
+    serialize;
+    deserialize;
+    constructor(baseStore, keyPrefix, serialize, deserialize) {
+        this.baseStore = baseStore;
+        this.keyPrefix = keyPrefix;
+        this.serialize = serialize;
+        this.deserialize = deserialize;
+    }
+    get = (key) => this.baseStore.get(this.keyPrefix + key).pipe(Effect.flatMap((value) => {
+        if (value === null) {
+            return Effect.fail(UploadistaError.fromCode("FILE_NOT_FOUND", {
+                cause: `Key "${key}" not found`,
+            }));
+        }
+        try {
+            return Effect.succeed(this.deserialize(value));
+        }
+        catch (error) {
+            return Effect.fail(new UploadistaError({
+                code: "VALIDATION_ERROR",
+                status: 400,
+                body: `Failed to deserialize value for key "${key}"`,
+                cause: error,
+            }));
+        }
+    }));
+    set = (key, value) => {
+        try {
+            const serialized = this.serialize(value);
+            return this.baseStore.set(this.keyPrefix + key, serialized);
+        }
+        catch (error) {
+            return Effect.fail(new UploadistaError({
+                code: "VALIDATION_ERROR",
+                status: 400,
+                body: `Failed to serialize value for key "${key}"`,
+                cause: error,
+            }));
+        }
+    };
+    delete = (key) => this.baseStore.delete(this.keyPrefix + key);
+    list = () => {
+        if (this.baseStore.list) {
+            return this.baseStore.list(this.keyPrefix);
+        }
+        return Effect.fail(new UploadistaError({
+            code: "UNKNOWN_ERROR",
+            status: 501,
+            body: "List operation not supported by this store",
+        }));
+    };
+}
+/**
+ * Default JSON serialization helpers.
+ *
+ * These functions provide standard JSON serialization for use with TypedKvStore.
+ * They work with any JSON-serializable type.
+ *
+ * @example
+ * ```typescript
+ * const store = new TypedKvStore<MyType>(
+ *   baseStore,
+ *   "mydata:",
+ *   jsonSerializer.serialize,
+ *   jsonSerializer.deserialize
+ * );
+ * ```
+ */
+export const jsonSerializer = {
+    serialize: (data) => JSON.stringify(data),
+    deserialize: (str) => JSON.parse(str),
+};
+/**
+ * Effect-TS context tag for the base untyped KV store.
+ *
+ * This is the low-level store that storage adapter implementations provide.
+ * Most application code should use typed stores like UploadFileKVStore instead.
+ *
+ * @example
+ * ```typescript
+ * // Provide a base store implementation
+ * const baseStoreLayer = Layer.succeed(BaseKvStoreService, redisKvStore);
+ *
+ * // Use in an Effect
+ * const effect = Effect.gen(function* () {
+ *   const baseStore = yield* BaseKvStoreService;
+ *   yield* baseStore.set("raw-key", "raw-value");
+ * });
+ * ```
+ */
+export class BaseKvStoreService extends Context.Tag("BaseKvStore")() {
+}
+/**
+ * Effect-TS context tag for the UploadFile typed KV store.
+ *
+ * This provides type-safe storage for UploadFile metadata. It's the primary
+ * way to store and retrieve upload metadata in the system.
+ *
+ * @example
+ * ```typescript
+ * const uploadEffect = Effect.gen(function* () {
+ *   const kvStore = yield* UploadFileKVStore;
+ *
+ *   // Store upload metadata
+ *   const file: UploadFile = {
+ *     id: "upload123",
+ *     offset: 0,
+ *     storage: { id: "s3", type: "s3" }
+ *   };
+ *   yield* kvStore.set("upload123", file);
+ *
+ *   // Retrieve with type safety
+ *   const retrieved = yield* kvStore.get("upload123");
+ *   return retrieved;
+ * });
+ * ```
+ */
+export class UploadFileKVStore extends Context.Tag("UploadFileKVStore")() {
+}
+/**
+ * Effect Layer that creates the UploadFileKVStore from a BaseKvStore.
+ *
+ * This layer automatically wires up JSON serialization for UploadFile objects
+ * with the "uploadista:upload-file:" key prefix.
+ *
+ * @example
+ * ```typescript
+ * const program = Effect.gen(function* () {
+ *   const kvStore = yield* UploadFileKVStore;
+ *   // Use the store...
+ * }).pipe(
+ *   Effect.provide(uploadFileKvStore),
+ *   Effect.provide(baseStoreLayer)
+ * );
+ * ```
+ */
+export const uploadFileKvStore = Layer.effect(UploadFileKVStore, Effect.gen(function* () {
+    const baseStore = yield* BaseKvStoreService;
+    return new TypedKvStore(baseStore, "uploadista:upload-file:", jsonSerializer.serialize, jsonSerializer.deserialize);
+}));
+/**
+ * Effect-TS context tag for the FlowJob typed KV store.
+ *
+ * This provides type-safe storage for FlowJob metadata, tracking the
+ * execution state of flow processing jobs.
+ *
+ * @example
+ * ```typescript
+ * const flowEffect = Effect.gen(function* () {
+ *   const jobStore = yield* FlowJobKVStore;
+ *
+ *   // Store job state
+ *   const job: FlowJob = {
+ *     id: "job123",
+ *     flowId: "flow_resize",
+ *     status: "running",
+ *     tasks: [],
+ *     createdAt: new Date(),
+ *     updatedAt: new Date()
+ *   };
+ *   yield* jobStore.set("job123", job);
+ *
+ *   // Retrieve and check status
+ *   const retrieved = yield* jobStore.get("job123");
+ *   return retrieved.status;
+ * });
+ * ```
+ */
+export class FlowJobKVStore extends Context.Tag("FlowJobKVStore")() {
+}
+/**
+ * Effect Layer that creates the FlowJobKVStore from a BaseKvStore.
+ *
+ * This layer automatically wires up JSON serialization for FlowJob objects
+ * with the "uploadista:flow-job:" key prefix.
+ *
+ * @example
+ * ```typescript
+ * const program = Effect.gen(function* () {
+ *   const jobStore = yield* FlowJobKVStore;
+ *   // Use the store...
+ * }).pipe(
+ *   Effect.provide(flowJobKvStore),
+ *   Effect.provide(baseStoreLayer)
+ * );
+ * ```
+ */
+export const flowJobKvStore = Layer.effect(FlowJobKVStore, Effect.gen(function* () {
+    const baseStore = yield* BaseKvStoreService;
+    return new TypedKvStore(baseStore, "uploadista:flow-job:", jsonSerializer.serialize, jsonSerializer.deserialize);
+}));

package/dist/types/middleware.d.ts

@@ -0,0 +1,17 @@
+import { Context, Effect, Layer } from "effect";
+import type { UploadistaError } from "../errors";
+export type MiddlewareContext = {
+    request: Request;
+    uploadId?: string;
+    metadata?: Record<string, string>;
+};
+export type MiddlewareNext = () => Promise<Response>;
+export type Middleware = (context: MiddlewareContext, next: MiddlewareNext) => Promise<Response>;
+declare const MiddlewareService_base: Context.TagClass<MiddlewareService, "MiddlewareService", {
+    readonly execute: (middlewares: Middleware[], context: MiddlewareContext, handler: MiddlewareNext) => Effect.Effect<Response, UploadistaError>;
+}>;
+export declare class MiddlewareService extends MiddlewareService_base {
+}
+export declare const MiddlewareServiceLive: Layer.Layer<MiddlewareService, never, never>;
+export {};
+//# sourceMappingURL=middleware.d.ts.map

package/dist/types/middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../../src/types/middleware.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAChD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEjD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACnC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,MAAM,OAAO,CAAC,QAAQ,CAAC,CAAC;AAErD,MAAM,MAAM,UAAU,GAAG,CACvB,OAAO,EAAE,iBAAiB,EAC1B,IAAI,EAAE,cAAc,KACjB,OAAO,CAAC,QAAQ,CAAC,CAAC;;sBAMD,CAChB,WAAW,EAAE,UAAU,EAAE,EACzB,OAAO,EAAE,iBAAiB,EAC1B,OAAO,EAAE,cAAc,KACpB,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,eAAe,CAAC;;AAPjD,qBAAa,iBAAkB,SAAQ,sBASpC;CAAG;AAEN,eAAO,MAAM,qBAAqB,8CAyBjC,CAAC"}