@umituz/web-cloudflare 1.4.3 → 1.4.5

package/src/domains/analytics/index.ts

@@ -0,0 +1,13 @@
+/**
+ * Analytics Domain
+ * Complete Cloudflare Analytics integration
+ */
+
+// Entities
+export * from './entities';
+
+// Types
+export * from './types';
+
+// Services
+export * from './services';

package/src/{infrastructure/services/analytics → domains/analytics/services}/analytics.service.ts

@@ -3,7 +3,7 @@
  * @description Cloudflare Web Analytics operations
  */
 
-import type { AnalyticsEvent, AnalyticsPageviewEvent, AnalyticsCustomEvent, AnalyticsData } from "../../../domain/entities/analytics.entity";
+import type { AnalyticsEvent, AnalyticsPageviewEvent, AnalyticsCustomEvent, AnalyticsData } from "../entities";
 import type { IAnalyticsService } from "../../../domain/interfaces/services.interface";
 
 export interface AnalyticsClientOptions {

package/src/{infrastructure/services/analytics → domains/analytics/services}/index.ts

@@ -5,3 +5,4 @@
 
 export { AnalyticsService, analyticsService } from "./analytics.service";
 export type { AnalyticsClientOptions } from "./analytics.service";
+export type { IAnalyticsService } from '../types';

package/src/domains/analytics/types/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Analytics Domain Types
+ */
+
+export * from './service.interface';

package/src/domains/analytics/types/service.interface.ts

@@ -0,0 +1,12 @@
+/**
+ * Analytics Service Interface
+ * @description Abstract interface for Analytics operations
+ */
+
+import type { AnalyticsEvent, AnalyticsData } from '../entities';
+
+export interface IAnalyticsService {
+  trackEvent(event: AnalyticsEvent): Promise<void>;
+  trackPageview(url: string, title: string, referrer?: string): Promise<void>;
+  getAnalytics(): Promise<AnalyticsData>;
+}

package/src/domains/images/entities/index.ts

@@ -0,0 +1,48 @@
+/**
+ * Image Entity
+ * @description Cloudflare Images configuration and types
+ */
+
+export interface ImageConfig {
+  readonly account: string;
+  readonly customDomain?: string;
+}
+
+export interface ImageVariant {
+  readonly variant: string;
+  readonly width?: number;
+  readonly height?: number;
+  readonly fit?: "scale-down" | "contain" | "cover" | "crop" | "pad";
+  readonly format?: "jpeg" | "png" | "gif" | "webp" | "avif";
+  readonly quality?: number;
+}
+
+export interface ImageUploadResult {
+  readonly id: string;
+  readonly filename: string;
+  readonly uploaded: Date;
+  readonly variants: readonly string[];
+  readonly requireSignedURLs: boolean;
+}
+
+export interface ImageUploadOptions {
+  readonly metadata?: Record<string, string>;
+  readonly requireSignedURLs?: boolean;
+  readonly variants?: readonly ImageVariant[];
+}
+
+export interface ImageTransformation {
+  readonly width?: number;
+  readonly height?: number;
+  readonly fit?: "scale-down" | "contain" | "cover" | "crop" | "pad";
+  readonly format?: "jpeg" | "png" | "gif" | "webp" | "avif";
+  readonly quality?: number;
+  readonly rotate?: number;
+  readonly flip?: boolean;
+  readonly flop?: boolean;
+}
+
+export interface SignedURL {
+  readonly url: string;
+  readonly expiresAt: Date;
+}

package/src/domains/images/index.ts

@@ -0,0 +1,13 @@
+/**
+ * Images Domain
+ * Complete Cloudflare Images integration
+ */
+
+// Entities
+export * from './entities';
+
+// Types
+export * from './types';
+
+// Services
+export * from './services';

package/src/{infrastructure/services/images → domains/images/services}/images.service.ts

@@ -3,10 +3,10 @@
  * @description Cloudflare Images operations
  */
 
-import type { ImageUploadResult, ImageUploadOptions, ImageTransformation, SignedURL } from "../../../domain/entities/image.entity";
+import type { ImageUploadResult, ImageUploadOptions, ImageTransformation, SignedURL } from "../entities";
 import type { IImageService } from "../../../domain/interfaces/services.interface";
-import { validationUtils, transformUtils } from "../../utils";
-import { MAX_IMAGE_SIZE, ALLOWED_IMAGE_TYPES } from "../../constants";
+import { validationUtils, transformUtils } from "../../../infrastructure/utils";
+import { MAX_IMAGE_SIZE, ALLOWED_IMAGE_TYPES } from "../../../infrastructure/constants";
 
 export interface ImagesClientOptions {
   readonly accountId: string;

package/src/{infrastructure/services/images → domains/images/services}/index.ts

@@ -5,3 +5,4 @@
 
 export { ImagesService, imagesService } from "./images.service";
 export type { ImagesClientOptions } from "./images.service";
+export type { IImageService } from '../types';

package/src/domains/images/types/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Images Domain Types
+ */
+
+export * from './service.interface';

package/src/domains/images/types/service.interface.ts

@@ -0,0 +1,13 @@
+/**
+ * Images Service Interface
+ * @description Abstract interface for Images operations
+ */
+
+import type { ImageUploadResult, ImageUploadOptions, SignedURL, ImageTransformation } from '../entities';
+
+export interface IImageService {
+  upload(file: File | Blob, options?: ImageUploadOptions): Promise<ImageUploadResult>;
+  getSignedURL(imageId: string, expiresIn?: number): Promise<SignedURL>;
+  getTransformedURL(imageId: string, transform: ImageTransformation): Promise<string>;
+  delete(imageId: string): Promise<boolean>;
+}

package/src/domains/kv/entities/index.ts

@@ -0,0 +1,34 @@
+/**
+ * KV Entity
+ * @description Cloudflare KV configuration and types
+ */
+
+export interface KVNamespaceConfig {
+  readonly namespace: string;
+  readonly ttl?: number;
+}
+
+export interface KVEntry<T = unknown> {
+  readonly key: string;
+  readonly value: T;
+  readonly metadata?: Record<string, unknown>;
+  readonly expiration?: number;
+}
+
+export interface KVListOptions {
+  readonly limit?: number;
+  readonly cursor?: string;
+  readonly prefix?: string;
+}
+
+export interface KVListResult {
+  readonly keys: readonly KVKey[];
+  readonly list_complete: boolean;
+  readonly cursor?: string;
+}
+
+export interface KVKey {
+  readonly name: string;
+  readonly metadata?: Record<string, unknown>;
+  readonly expiration?: number;
+}

package/src/domains/kv/index.ts

@@ -0,0 +1,13 @@
+/**
+ * KV Domain
+ * Complete Cloudflare KV key-value storage integration
+ */
+
+// Entities
+export * from './entities';
+
+// Types
+export * from './types';
+
+// Services
+export * from './services';

package/src/{infrastructure/services/kv → domains/kv/services}/index.ts

@@ -5,3 +5,4 @@
 
 export { KVService, kvService } from "./kv.service";
 export type { KVCacheOptions } from "./kv.service";
+export type { IKVService } from '../types';

package/src/{infrastructure/services/kv → domains/kv/services}/kv.service.ts

@@ -3,9 +3,9 @@
  * @description Cloudflare KV key-value storage operations
  */
 
-import type { KVEntry, KVListOptions, KVListResult } from "../../../domain/entities/kv.entity";
+import type { KVEntry, KVListOptions, KVListResult } from "../entities";
 import type { IKVService } from "../../../domain/interfaces/services.interface";
-import { validationUtils, cacheUtils } from "../../utils";
+import { validationUtils, cacheUtils } from "../../../infrastructure/utils";
 
 export interface KVCacheOptions {
   readonly namespace: string;

package/src/domains/kv/types/index.ts

@@ -0,0 +1,5 @@
+/**
+ * KV Domain Types
+ */
+
+export * from './service.interface';

package/src/domains/kv/types/service.interface.ts

@@ -0,0 +1,13 @@
+/**
+ * KV Service Interface
+ * @description Abstract interface for KV storage operations
+ */
+
+import type { KVListOptions, KVListResult } from '../entities';
+
+export interface IKVService {
+  get<T>(key: string): Promise<T | null>;
+  put<T>(key: string, value: T, options?: { ttl?: number }): Promise<void>;
+  delete(key: string): Promise<boolean>;
+  list(options?: KVListOptions): Promise<KVListResult>;
+}

package/src/domains/workers/entities/index.ts

@@ -11,7 +11,7 @@ export interface WorkerResponse extends Response {
   waitUntil?: (promise: Promise<unknown>) => void;
 }
 
-export interface WorkerConfig {
+export interface CloudflareWorkerConfig {
   readonly name: string;
   readonly routes?: string[];
   readonly schedule?: string;

package/src/domains/workflows/entities/index.ts

@@ -0,0 +1,60 @@
+/**
+ * Workflows Domain Entities
+ * @description Workflow orchestration entities for Cloudflare Workers
+ */
+
+/**
+ * Workflow step definition
+ */
+export interface WorkflowStep {
+  id: string;
+  name: string;
+  handler: string;
+  timeout?: number;
+  retryPolicy?: {
+    maxAttempts: number;
+    backoffMultiplier: number;
+    initialDelay: number;
+    maxDelay: number;
+  };
+  dependencies?: string[];
+}
+
+/**
+ * Workflow definition
+ */
+export interface WorkflowDefinition {
+  id: string;
+  name: string;
+  description?: string;
+  steps: WorkflowStep[];
+}
+
+/**
+ * Workflow execution state
+ */
+export interface WorkflowExecution {
+  id: string;
+  workflowId: string;
+  status: 'pending' | 'running' | 'completed' | 'failed';
+  currentStep?: string;
+  startedAt: number;
+  completedAt?: number;
+  input: unknown;
+  output?: unknown;
+  error?: string;
+}
+
+/**
+ * Workflow config
+ */
+export interface CloudflareWorkflowConfig {
+  enabled: boolean;
+  maxExecutionTime: number;
+  defaultRetries: number;
+  workflows?: Record<string, WorkflowDefinition>;
+  storage?: 'kv' | 'd1';
+}
+
+// Type alias for compatibility
+export type WorkflowConfig = CloudflareWorkflowConfig;

package/src/domains/workflows/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Workflows Domain
+ * Complete workflow orchestration integration
+ */
+
+// Entities
+export * from './entities';
+
+// Services
+export * from './services';

package/src/domains/workflows/services/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Workflows Service
+ * Subpath: @umituz/web-cloudflare/workflows
+ */
+
+export * from './workflows.service';

package/src/{infrastructure/services/workflows/index.ts → domains/workflows/services/workflows.service.ts}

@@ -11,7 +11,7 @@ import type {
   MediaProcessingWorkflow,
   AIGenerationWorkflow,
   BatchOperationWorkflow,
-} from '../../domain/workflows.entity';
+} from '../entities';
 
 export interface WorkflowServiceConfig {
   KV?: KVNamespace;

package/src/domains/wrangler/entities/index.ts

@@ -132,9 +132,9 @@ export interface WorkerVersionInfo {
 }
 
 /**
- * Analytics data
+ * Wrangler analytics data
  */
-export interface AnalyticsData {
+export interface WranglerAnalyticsData {
   requests?: number;
   errors?: number;
   statusCodes?: Record<string, number>;

package/src/domains/wrangler/services/wrangler.service.ts

@@ -118,6 +118,14 @@ export class WranglerService implements IWranglerService {
     }
   }
 
+  /**
+   * Convert string result to void result
+   */
+  private asVoidResult(result: WranglerResult<string>): WranglerResult<void> {
+    const { data, ...rest } = result;
+    return rest;
+  }
+
   // ==================== Authentication ====================
 
   async login(options?: WranglerCommandOptions): Promise<WranglerResult<AuthInfo>> {
@@ -132,7 +140,7 @@ export class WranglerService implements IWranglerService {
   }
 
   async logout(options?: WranglerCommandOptions): Promise<WranglerResult<void>> {
-    return this.execute(['logout'], options);
+    return this.asVoidResult(await this.execute(['logout'], options));
   }
 
   async whoami(options?: WranglerCommandOptions): Promise<WranglerResult<AuthInfo>> {
@@ -158,7 +166,7 @@ export class WranglerService implements IWranglerService {
     if (template) {
       args.push('--template', template);
     }
-    return this.execute(args, options);
+    return this.asVoidResult(await this.execute(args, options));
   }
 
   async dev(
@@ -237,7 +245,7 @@ export class WranglerService implements IWranglerService {
     value: string,
     options?: WranglerCommandOptions
   ): Promise<WranglerResult<void>> {
-    return this.execute(['kv:key', 'put', '--namespace-id', namespaceId, key, value], options);
+    return this.asVoidResult(await this.execute(['kv:key', 'put', '--namespace-id', namespaceId, key, value], options));
   }
 
   async kvKeyGet(
@@ -253,7 +261,7 @@ export class WranglerService implements IWranglerService {
     key: string,
     options?: WranglerCommandOptions
   ): Promise<WranglerResult<void>> {
-    return this.execute(['kv:key', 'delete', '--namespace-id', namespaceId, key], options);
+    return this.asVoidResult(await this.execute(['kv:key', 'delete', '--namespace-id', namespaceId, key], options));
   }
 
   // ==================== R2 Operations ====================
@@ -289,7 +297,7 @@ export class WranglerService implements IWranglerService {
     bucketName: string,
     options?: WranglerCommandOptions
   ): Promise<WranglerResult<void>> {
-    return this.execute(['r2', 'bucket', 'delete', bucketName], options);
+    return this.asVoidResult(await this.execute(['r2', 'bucket', 'delete', bucketName], options));
   }
 
   async r2ObjectPut(
@@ -298,7 +306,7 @@ export class WranglerService implements IWranglerService {
     file: string,
     options?: WranglerCommandOptions
   ): Promise<WranglerResult<void>> {
-    return this.execute(['r2', 'object', 'put', bucketName, key, '--file', file], options);
+    return this.asVoidResult(await this.execute(['r2', 'object', 'put', bucketName, key, '--file', file], options));
   }
 
   // ==================== D1 Operations ====================
@@ -412,7 +420,7 @@ export class WranglerService implements IWranglerService {
     secretName: string,
     options?: WranglerCommandOptions
   ): Promise<WranglerResult<void>> {
-    return this.execute(['secret', 'delete', secretName], options);
+    return this.asVoidResult(await this.execute(['secret', 'delete', secretName], options));
   }
 
   // ==================== Monitoring ====================
@@ -446,7 +454,7 @@ export class WranglerService implements IWranglerService {
     versionId: string,
     options?: WranglerCommandOptions
   ): Promise<WranglerResult<void>> {
-    return this.execute(['versions', 'rollback', '--version-id', versionId], options);
+    return this.asVoidResult(await this.execute(['versions', 'rollback', '--version-id', versionId], options));
   }
 
   // ==================== Generic Command Execution ====================

package/src/domains/wrangler/types/service.interface.ts

@@ -12,8 +12,8 @@ import type {
   D1DatabaseInfo,
   SecretInfo,
   WorkerVersionInfo,
-  AnalyticsData,
-} from '../entities/wrangler.entity';
+  WranglerAnalyticsData,
+} from '../entities';
 
 export interface IWranglerService {
   // Authentication

package/src/index.ts

@@ -31,10 +31,10 @@ export * from "./domains/workers";
 export * from "./domains/ai-gateway";
 export * from "./domains/r2";
 export * from "./domains/d1";
-export * from "./infrastructure/services/kv";
-export * from "./infrastructure/services/images";
-export * from "./infrastructure/services/analytics";
-export * from "./infrastructure/services/workflows";
+export * from "./domains/kv";
+export * from "./domains/images";
+export * from "./domains/analytics";
+export * from "./domains/workflows";
 
 // Infrastructure - Router, Middleware, Utils
 export * from "./infrastructure/router";

package/src/infrastructure/middleware/auth.ts

@@ -0,0 +1,118 @@
+/**
+ * Auth Middleware
+ * @description Authentication middleware for Cloudflare Workers
+ */
+
+export interface AuthConfig {
+  enabled: boolean;
+  type: 'bearer' | 'apikey' | 'basic';
+  token?: string;
+  apiKeyHeader?: string;
+  apiKeyValue?: string;
+  username?: string;
+  password?: string;
+}
+
+/**
+ * Require authentication
+ */
+export async function requireAuth(
+  request: Request,
+  config: AuthConfig
+): Promise<Response | null> {
+  if (!config.enabled) {
+    return null;
+  }
+
+  const authHeader = request.headers.get('Authorization');
+
+  if (!authHeader) {
+    return new Response(
+      JSON.stringify({ error: 'Missing authorization header' }),
+      {
+        status: 401,
+        headers: { 'Content-Type': 'application/json' },
+      }
+    );
+  }
+
+  switch (config.type) {
+    case 'bearer':
+      if (!authHeader.startsWith('Bearer ')) {
+        return new Response(
+          JSON.stringify({ error: 'Invalid authorization type' }),
+          {
+            status: 401,
+            headers: { 'Content-Type': 'application/json' },
+          }
+        );
+      }
+      const token = authHeader.substring(7);
+      if (token !== config.token) {
+        return new Response(
+          JSON.stringify({ error: 'Invalid token' }),
+          {
+            status: 401,
+            headers: { 'Content-Type': 'application/json' },
+          }
+        );
+      }
+      break;
+
+    case 'apikey':
+      const apiKey = request.headers.get(config.apiKeyHeader || 'X-API-Key');
+      if (apiKey !== config.apiKeyValue) {
+        return new Response(
+          JSON.stringify({ error: 'Invalid API key' }),
+          {
+            status: 401,
+            headers: { 'Content-Type': 'application/json' },
+          }
+        );
+      }
+      break;
+
+    case 'basic':
+      if (!authHeader.startsWith('Basic ')) {
+        return new Response(
+          JSON.stringify({ error: 'Invalid authorization type' }),
+          {
+            status: 401,
+            headers: { 'Content-Type': 'application/json' },
+          }
+        );
+      }
+      const credentials = atob(authHeader.substring(6));
+      const [username, password] = credentials.split(':');
+      if (username !== config.username || password !== config.password) {
+        return new Response(
+          JSON.stringify({ error: 'Invalid credentials' }),
+          {
+            status: 401,
+            headers: { 'Content-Type': 'application/json' },
+          }
+        );
+      }
+      break;
+  }
+
+  return null;
+}
+
+/**
+ * Add user context to request
+ */
+export function addUserContext(request: Request, user: {
+  id: string;
+  [key: string]: unknown;
+}): Request {
+  const headers = new Headers(request.headers);
+  headers.set('X-User-ID', user.id);
+  headers.set('X-User-Context', JSON.stringify(user));
+
+  return new Request(request.url, {
+    method: request.method,
+    headers,
+    body: request.body,
+  });
+}