@umituz/web-cloudflare 1.4.6 → 1.4.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/web-cloudflare",
-  "version": "1.4.6",
+  "version": "1.4.7",
   "description": "Comprehensive Cloudflare Workers integration with config-based patterns, middleware, router, workflows, and AI (Patch-only versioning: only z in x.y.z increments)",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/config/patterns.ts

@@ -246,7 +246,7 @@ export const minimalConfig: Partial<WorkerConfig> = {
 export function mergeConfigs<T extends Record<string, any>>(
   base: T,
   ...overrides: Array<Partial<Record<string, any>>>
-): T {
+): Record<string, any> {
   return overrides.reduce((acc, override) => {
     return deepMerge(acc, override);
   }, base);
@@ -255,7 +255,7 @@ export function mergeConfigs<T extends Record<string, any>>(
 function deepMerge<T extends Record<string, any>>(
   target: T,
   source: Partial<Record<string, any>>
-): T {
+): Record<string, any> {
   const output = { ...target };
 
   if (isObject(target) && isObject(source)) {

package/src/domains/ai-gateway/services/index.ts

@@ -127,17 +127,27 @@ export class AIGatewayService {
       throw new Error(`Provider error: ${response.statusText}`);
     }
 
-    const data = await response.json();
+    const data = await response.json() as {
+      id?: string;
+      content?: string;
+      text?: string;
+      output?: string;
+      usage?: {
+        promptTokens?: number;
+        completionTokens?: number;
+        totalTokens?: number;
+      };
+    };
 
     return {
       id: data.id || this.generateId(),
       provider: provider.id,
       model: request.model,
-      content: data.content || data.text || data.output,
-      usage: data.usage || {
-        promptTokens: 0,
-        completionTokens: 0,
-        totalTokens: 0,
+      content: data.content || data.text || data.output || '',
+      usage: {
+        promptTokens: data.usage?.promptTokens || 0,
+        completionTokens: data.usage?.completionTokens || 0,
+        totalTokens: data.usage?.totalTokens || 0,
       },
       cached: false,
       timestamp: Date.now(),
@@ -215,9 +225,9 @@ import type {
 
 export class WorkersAIService {
   private env: {
-    AI?: AiTextGeneration;
+    AI?: any;
     bindings?: {
-      AI?: Ai;
+      AI?: any;
     };
   };
 

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

@@ -1,9 +1,10 @@
 /**
  * Analytics Service
- * @description Cloudflare Web Analytics operations
+ * @description Cloudflare Web Analytics operations for Workers runtime
  */
 
-import type { AnalyticsEvent, AnalyticsPageviewEvent, AnalyticsCustomEvent, AnalyticsData } from "../entities";
+import type { AnalyticsEvent, AnalyticsPageviewEvent, AnalyticsCustomEvent } from "../entities";
+import type { AnalyticsData } from "../../../domain/entities/analytics.entity";
 import type { IAnalyticsService } from "../../../domain/interfaces/services.interface";
 
 export interface AnalyticsClientOptions {
@@ -29,13 +30,9 @@ class AnalyticsService implements IAnalyticsService {
 
   async trackEvent(event: AnalyticsEvent): Promise<void> {
     this.ensureInitialized();
-
     this.eventQueue.push(event);
-
-    // In a browser environment, send to Cloudflare Analytics
-    if (typeof window !== "undefined" && (window as any)._cfAnalytics) {
-      (window as any)._cfAnalytics.track(event);
-    }
+    // In Workers runtime, events are queued for batch processing
+    // The actual sending would be done via Cloudflare Analytics API
   }
 
   async trackPageview(url: string, title: string, referrer?: string): Promise<void> {
@@ -50,12 +47,10 @@ class AnalyticsService implements IAnalyticsService {
     await this.trackEvent(event);
   }
 
-  async trackCustom(eventName: string, data?: Record<string, unknown>): Promise<void> {
-    if (typeof window === "undefined") return;
-
+  async trackCustom(eventName: string, data?: Record<string, unknown>, url?: string): Promise<void> {
     const event: AnalyticsCustomEvent = {
       timestamp: Date.now(),
-      url: window.location.href,
+      url: url || '/workers',
       eventType: "custom",
       eventName,
       eventData: data,
@@ -65,11 +60,9 @@ class AnalyticsService implements IAnalyticsService {
   }
 
   async trackOutboundLink(url: string, linkType?: string): Promise<void> {
-    if (typeof window === "undefined") return;
-
     const event: AnalyticsCustomEvent = {
       timestamp: Date.now(),
-      url: window.location.href,
+      url: '/workers',
       eventType: "custom",
       eventName: "outbound-link",
       eventData: {
@@ -82,11 +75,9 @@ class AnalyticsService implements IAnalyticsService {
   }
 
   async trackTiming(name: string, value: number, label?: string): Promise<void> {
-    if (typeof window === "undefined") return;
-
     const event: AnalyticsEvent = {
       timestamp: Date.now(),
-      url: window.location.href,
+      url: '/workers',
       eventType: "timing",
       eventData: {
         name,
@@ -101,89 +92,22 @@ class AnalyticsService implements IAnalyticsService {
   async getAnalytics(): Promise<AnalyticsData> {
     this.ensureInitialized();
 
-    // In a real implementation, this would fetch from Cloudflare Analytics API
-    // For now, return queued events
-
     return {
       siteId: this.siteId!,
-      events: this.eventQueue,
+      events: [...this.eventQueue],
       metrics: {
-        pageviews: this.eventQueue.filter((e) => e.eventType === "pageview").length,
-        uniqueVisitors: new Set(this.eventQueue.map((e) => e.url)).size,
+        pageviews: this.eventQueue.filter(e => e.eventType === "pageview").length,
+        uniqueVisitors: 0, // Would be calculated from stored data
       },
     };
   }
 
-  /**
-   * Get analytics script tag
-   */
-  getScriptTag(): string {
-    this.ensureInitialized();
-
-    const scriptUrl = this.scriptUrl || `https://static.cloudflareinsights.com/beacon.min.js`;
-
-    return `
-<script defer src='${scriptUrl}' data-cf-beacon='{"token": "${this.siteId}"}'></script>
-    `.trim();
-  }
-
-  /**
-   * Clear queued events
-   */
-  clearEvents(): void {
+  async flush(): Promise<void> {
+    // In Workers, this would send events to Cloudflare Analytics API
     this.eventQueue = [];
   }
-
-  /**
-   * Get queued events
-   */
-  getQueuedEvents(): readonly AnalyticsEvent[] {
-    return this.eventQueue;
-  }
-
-  /**
-   * E-commerce helpers
-   */
-  async trackPurchase(transactionId: string, revenue: number, items: readonly { id: string; name: string; price: number; quantity: number }[]): Promise<void> {
-    await this.trackCustom("purchase", {
-      transactionId,
-      revenue,
-      items,
-    });
-  }
-
-  async trackAddToCart(itemId: string, price: number, quantity: number): Promise<void> {
-    await this.trackCustom("add-to-cart", {
-      itemId,
-      price,
-      quantity,
-    });
-  }
-
-  async trackRemoveFromCart(itemId: string, quantity: number): Promise<void> {
-    await this.trackCustom("remove-from-cart", {
-      itemId,
-      quantity,
-    });
-  }
-
-  /**
-   * Engagement helpers
-   */
-  async trackScrollDepth(depth: number): Promise<void> {
-    await this.trackCustom("scroll-depth", { depth });
-  }
-
-  async trackTimeOnPage(seconds: number): Promise<void> {
-    await this.trackCustom("time-on-page", { seconds });
-  }
-
-  async trackEngagement(action: string, target?: string): Promise<void> {
-    await this.trackCustom("engagement", {
-      action,
-      target,
-    });
-  }
 }
 
+// Export class and singleton instance
+export { AnalyticsService };
 export const analyticsService = new AnalyticsService();

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

@@ -3,7 +3,7 @@
  * @description Abstract interface for Analytics operations
  */
 
-import type { AnalyticsEvent, AnalyticsData } from '../entities';
+import type { AnalyticsEvent, AnalyticsData } from '../../../domain/entities/analytics.entity';
 
 export interface IAnalyticsService {
   trackEvent(event: AnalyticsEvent): Promise<void>;

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

@@ -3,7 +3,7 @@
  * @description Cloudflare D1 database operations
  */
 
-import type { D1QueryResult, D1BatchResult } from "../entities";
+import type { D1QueryResult, D1BatchResult } from "../../../domain/entities/d1.entity";
 import type { ID1Service } from "../../../domain/interfaces/services.interface";
 
 export interface D1ExecOptions {
@@ -33,14 +33,10 @@ class D1Service implements ID1Service {
     const result = params ? await stmt.bind(...params).all() : await stmt.all();
 
     return {
-      results: result.results as T[],
-      success: result.success,
+      rows: result.results as T[],
       meta: result.meta
         ? {
             duration: result.meta.duration,
-            rows_read: result.meta.rows_read,
-            rows_written: result.meta.rows_written,
-            last_row_id: result.meta.last_row_id,
             changes: result.meta.changes,
           }
         : undefined,
@@ -48,20 +44,20 @@ class D1Service implements ID1Service {
   }
 
   async batch(
-    statements: readonly { sql: string; params?: readonly unknown[]; binding?: string }[]
+    sqlStatements: readonly { sql: string; params?: readonly unknown[]; binding?: string }[]
   ): Promise<D1BatchResult> {
     // Group by binding
     const grouped = new Map<string, D1PreparedStatement[]>();
 
-    for (const stmt of statements) {
-      const binding = stmt.binding || "default";
-      const database = this.getDatabase(binding);
+    for (const stmt of sqlStatements) {
+      const bindingName = stmt.binding || "default";
+      const database = this.getDatabase(bindingName);
 
-      if (!grouped.has(binding)) {
-        grouped.set(binding, []);
+      if (!grouped.has(bindingName)) {
+        grouped.set(bindingName, []);
       }
 
-      grouped.get(binding)!.push(database.prepare(stmt.sql));
+      grouped.get(bindingName)!.push(database.prepare(stmt.sql));
     }
 
     // Note: D1 batch requires all statements to be from the same database
@@ -69,18 +65,17 @@ class D1Service implements ID1Service {
       throw new Error("Batch operations must be from the same database binding");
     }
 
-    const [binding, statements] = Array.from(grouped.entries())[0];
-    const database = this.getDatabase(binding);
+    const [bindingName, preparedStatements] = Array.from(grouped.entries())[0];
+    const database = this.getDatabase(bindingName);
 
-    const results = await database.batch(statements as D1PreparedStatement[]);
+    const results = await database.batch(preparedStatements as D1PreparedStatement[]);
 
     return {
       success: results.every((r) => r.success),
       results: results.map((r) => ({
-        results: r.results,
-        success: r.success,
-        meta: r.meta,
-      })),
+        rows: r.results,
+        meta: r.meta ? { duration: r.meta.duration, changes: r.meta.changes } : undefined,
+      })) as D1QueryResult[],
     };
   }
 
@@ -94,7 +89,7 @@ class D1Service implements ID1Service {
   async findOne<T>(sql: string, params?: readonly unknown[], binding?: string): Promise<T | null> {
     const result = await this.query<T>(sql, params, binding);
 
-    return (result.results[0] as T) ?? null;
+    return (result.rows[0] as T) ?? null;
   }
 
   async insert<T>(
@@ -165,7 +160,7 @@ class D1Service implements ID1Service {
 
     const result = await this.query<{ name: string }>(sql, [table], binding);
 
-    return result.results.length > 0;
+    return result.rows.length > 0;
   }
 
   /**
@@ -188,4 +183,6 @@ interface D1Transaction {
   query<T>(sql: string, params?: readonly unknown[]): Promise<D1QueryResult<T>>;
 }
 
+// Export class and singleton instance
+export { D1Service };
 export const d1Service = new D1Service();

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

@@ -3,7 +3,7 @@
  * @description Cloudflare Images operations
  */
 
-import type { ImageUploadResult, ImageUploadOptions, ImageTransformation, SignedURL } from "../entities";
+import type { ImageUploadResult, ImageUploadOptions, ImageTransformation, SignedURL } from "../../../domain/entities/image.entity";
 import type { IImageService } from "../../../domain/interfaces/services.interface";
 import { validationUtils, transformUtils } from "../../../infrastructure/utils";
 import { MAX_IMAGE_SIZE, ALLOWED_IMAGE_TYPES } from "../../../infrastructure/constants";
@@ -59,14 +59,13 @@ class ImagesService implements IImageService {
     const formData = new FormData();
     formData.append("file", file);
 
-    if (options?.metadata) {
-      for (const [key, value] of Object.entries(options.metadata)) {
-        formData.append(`metadata[${key}]`, value);
-      }
-    }
-
-    if (options?.requireSignedURLs !== undefined) {
-      formData.append("requireSignedURLs", options.requireSignedURLs.toString());
+    // Apply transformations if specified in options
+    if (options?.width || options?.height || options?.format || options?.quality) {
+      const variants: Array<{ width?: number; height?: number; format?: string; quality?: number }> = [];
+      if (options.width) variants.push({ width: options.width });
+      if (options.height) variants.push({ height: options.height });
+      if (options.format) variants.push({ format: options.format });
+      if (options.quality) variants.push({ quality: options.quality });
     }
 
     // Upload
@@ -81,19 +80,31 @@ class ImagesService implements IImageService {
       throw new Error(`Upload failed: ${error}`);
     }
 
-    const data = await response.json();
+    const data = await response.json() as {
+      result: {
+        id: string;
+        filename: string;
+        uploaded: string;
+        variants: string[];
+        requireSignedURLs: boolean;
+      };
+    };
 
+    // Map API response to old entity type
     return {
       id: data.result.id,
-      filename: data.result.filename,
-      uploaded: new Date(data.result.uploaded),
-      variants: data.result.variants,
-      requireSignedURLs: data.result.requireSignedURLs,
+      url: data.result.variants[0] || '',
+      variants: data.result.variants.map((v) => ({
+        width: 0,
+        height: 0,
+        format: (options?.format || 'jpeg') as 'jpeg' | 'png' | 'webp' | 'avif',
+        url: v,
+      })),
     };
   }
 
   async getSignedURL(imageId: string, expiresIn = 3600): Promise<SignedURL> {
-    const expiresAt = new Date(Date.now() + expiresIn * 1000);
+    const expires = Date.now() + expiresIn * 1000;
 
     const response = await fetch(`${this.getAPIBaseURL()}/${imageId}`, {
       method: "POST",
@@ -102,7 +113,7 @@ class ImagesService implements IImageService {
         "Content-Type": "application/json",
       },
       body: JSON.stringify({
-        expiry: expiresAt.toISOString(),
+        expiry: new Date(expires).toISOString(),
       }),
     });
 
@@ -111,11 +122,16 @@ class ImagesService implements IImageService {
       throw new Error(`Failed to get signed URL: ${error}`);
     }
 
-    const data = await response.json();
+    const data = await response.json() as {
+      result: {
+        signedURLs?: string[];
+        variants?: string[];
+      };
+    };
 
     return {
-      url: data.result.signedURLs?.[0] || data.result.variants?.[0],
-      expiresAt,
+      url: data.result.signedURLs?.[0] || data.result.variants?.[0] || '',
+      expires,
     };
   }
 
@@ -164,10 +180,29 @@ class ImagesService implements IImageService {
       throw new Error(`List failed: ${error}`);
     }
 
-    const data = await response.json();
+    const data = await response.json() as {
+      result: {
+        images: Array<{
+          id: string;
+          filename: string;
+          uploaded: string;
+          variants: string[];
+        }>;
+        totalCount: number;
+      };
+    };
 
     return {
-      images: data.result.images,
+      images: data.result.images.map((img) => ({
+        id: img.id,
+        url: img.variants[0] || '',
+        variants: img.variants.map((v) => ({
+          width: 0,
+          height: 0,
+          format: 'jpeg' as const,
+          url: v,
+        })),
+      })),
       totalCount: data.result.totalCount,
     };
   }
@@ -224,4 +259,6 @@ class ImagesService implements IImageService {
   }
 }
 
+// Export class and singleton instance
+export { ImagesService };
 export const imagesService = new ImagesService();

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

@@ -3,7 +3,7 @@
  * @description Cloudflare KV key-value storage operations
  */
 
-import type { KVEntry, KVListOptions, KVListResult } from "../entities";
+import type { KVEntry, KVListOptions, KVListResult } from "../../../domain/entities/kv.entity";
 import type { IKVService } from "../../../domain/interfaces/services.interface";
 import { validationUtils, cacheUtils } from "../../../infrastructure/utils";
 
@@ -79,9 +79,12 @@ class KVService implements IKVService {
     });
 
     return {
-      keys: list.keys,
-      list_complete: list.list_complete,
-      cursor: list.cursor,
+      keys: list.keys.map((k) => ({
+        key: k.name,
+        value: '',
+        metadata: k.metadata as Record<string, unknown> | undefined,
+      })),
+      cursor: (list as any).cursor as string | undefined,
     };
   }
 
@@ -107,10 +110,12 @@ class KVService implements IKVService {
 
     await Promise.all(
       list.keys.map(async (key) => {
-        await this.delete(key.name, binding);
+        await this.delete(key.key, binding);
       })
     );
   }
 }
 
+// Export class and singleton instance
+export { KVService };
 export const kvService = new KVService();

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

@@ -6,7 +6,7 @@
 /**
  * CORS configuration
  */
-export interface CORSConfig {
+export interface MiddlewareCORSConfig {
   enabled: boolean;
   allowedOrigins: string[];
   allowedMethods: string[];
@@ -19,7 +19,7 @@ export interface CORSConfig {
 /**
  * Cache configuration
  */
-export interface CacheConfig {
+export interface MiddlewareCacheConfig {
   enabled: boolean;
   defaultTTL: number;
   paths?: Record<string, number>;
@@ -31,7 +31,7 @@ export interface CacheConfig {
 /**
  * Rate limit configuration
  */
-export interface RateLimitConfig {
+export interface MiddlewareRateLimitConfig {
   enabled: boolean;
   maxRequests: number;
   window: number;
@@ -48,7 +48,7 @@ export interface RateLimitConfig {
 /**
  * Authentication configuration
  */
-export interface AuthConfig {
+export interface MiddlewareAuthConfig {
   enabled: boolean;
   type: 'bearer' | 'apikey' | 'basic';
   token?: string;

package/src/domains/middleware/services/auth.service.ts

@@ -3,14 +3,18 @@
  * @description Authentication middleware for Cloudflare Workers
  */
 
-import type { AuthConfig } from '../entities';
+import type { MiddlewareAuthConfig } from '../entities';
+
+// Type aliases for backwards compatibility
+export type { MiddlewareAuthConfig };
+export type AuthConfig = MiddlewareAuthConfig;
 
 /**
  * Require authentication
  */
 export async function requireAuth(
   request: Request,
-  config: AuthConfig
+  config: MiddlewareAuthConfig
 ): Promise<Response | null> {
   if (!config.enabled) {
     return null;

package/src/domains/middleware/services/cache.service.ts

@@ -3,7 +3,11 @@
  * @description Caching middleware for Cloudflare Workers
  */
 
-import type { CacheConfig } from '../entities';
+import type { MiddlewareCacheConfig } from '../entities';
+
+// Type aliases for backwards compatibility
+export type { MiddlewareCacheConfig };
+export type CacheConfig = MiddlewareCacheConfig;
 
 interface CacheEntry {
   response: Response;
@@ -17,7 +21,7 @@ const cacheStore = new Map<string, CacheEntry>();
  */
 export async function cache(
   request: Request,
-  config: CacheConfig
+  config: MiddlewareCacheConfig
 ): Promise<Response | null> {
   if (!config.enabled) {
     return null;
@@ -46,7 +50,7 @@ export async function cache(
 export function setCache(
   request: Request,
   response: Response,
-  config: CacheConfig
+  config: MiddlewareCacheConfig
 ): void {
   if (!config.enabled) {
     return;

package/src/domains/middleware/services/cors.service.ts

@@ -3,7 +3,10 @@
  * @description Cross-Origin Resource Sharing middleware for Cloudflare Workers
  */
 
-import type { CORSConfig } from '../entities';
+import type { MiddlewareCORSConfig } from '../entities';
+
+// Type alias for backwards compatibility
+export type CORSConfig = MiddlewareCORSConfig;
 
 /**
  * Add CORS headers to response
@@ -11,7 +14,7 @@ import type { CORSConfig } from '../entities';
 export function addCorsHeaders(
   request: Request,
   response: Response,
-  config: CORSConfig
+  config: MiddlewareCORSConfig
 ): Response {
   if (!config.enabled) {
     return response;
@@ -23,7 +26,7 @@ export function addCorsHeaders(
   // Check if origin is allowed
   const allowedOrigin = config.allowedOrigins.includes('*')
     ? '*'
-    : config.allowedOrigins.includes(origin || '')
+    : origin && config.allowedOrigins.includes(origin)
     ? origin
     : config.allowedOrigins[0];
 
@@ -55,7 +58,7 @@ export function addCorsHeaders(
  */
 export async function cors(
   request: Request,
-  config: CORSConfig
+  config: MiddlewareCORSConfig
 ): Promise<Response | null> {
   if (!config.enabled) {
     return null;
@@ -68,7 +71,7 @@ export async function cors(
 
     const allowedOrigin = config.allowedOrigins.includes('*')
       ? '*'
-      : config.allowedOrigins.includes(origin || '')
+      : origin && config.allowedOrigins.includes(origin)
       ? origin
       : config.allowedOrigins[0];