@umituz/web-cloudflare 1.4.7 → 1.4.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/web-cloudflare",
-  "version": "1.4.7",
+  "version": "1.4.8",
   "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

@@ -256,23 +256,26 @@ function deepMerge<T extends Record<string, any>>(
   target: T,
   source: Partial<Record<string, any>>
 ): Record<string, any> {
-  const output = { ...target };
+  const output: Record<string, unknown> = { ...target };
 
   if (isObject(target) && isObject(source)) {
     Object.keys(source).forEach((key) => {
       const sourceValue = source[key];
-      const targetValue = target[key as keyof T];
+      const targetValue = (target as Record<string, unknown>)[key];
 
       if (isObject(sourceValue)) {
         if (!(key in target)) {
-          (output as any)[key] = sourceValue;
+          output[key] = sourceValue;
         } else if (isObject(targetValue)) {
-          (output as any)[key] = deepMerge(targetValue, sourceValue);
+          output[key] = deepMerge(
+            targetValue as Record<string, any>,
+            sourceValue
+          );
         } else {
-          (output as any)[key] = sourceValue;
+          output[key] = sourceValue;
         }
       } else {
-        (output as any)[key] = sourceValue;
+        output[key] = sourceValue;
       }
     });
   }

package/src/config/types.ts

@@ -629,7 +629,7 @@ export interface EnvConfig {
   /**
    * AI bindings
    */
-  AI?: any;
+  AI?: WorkersAIBinding;
 
   /**
    * Custom environment variables
@@ -637,6 +637,14 @@ export interface EnvConfig {
   vars?: Record<string, string>;
 }
 
+/**
+ * Workers AI Binding
+ * @description Cloudflare Workers AI runtime binding
+ */
+export interface WorkersAIBinding {
+  run: <T = unknown>(model: string, inputs: Record<string, unknown>) => Promise<T>;
+}
+
 // ============================================================
 // Configuration Merging Types
 // ============================================================

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

@@ -10,6 +10,7 @@ import type {
   AIProvider,
   AIAnalytics,
 } from '../entities';
+import type { WorkersAIBinding } from '../../../config/types';
 
 export class AIGatewayService {
   private config: AIGatewayConfig;
@@ -225,16 +226,23 @@ import type {
 
 export class WorkersAIService {
   private env: {
-    AI?: any;
+    AI?: WorkersAIBinding;
     bindings?: {
-      AI?: any;
+      AI?: WorkersAIBinding;
     };
   };
 
-  constructor(env: { AI?: any; bindings?: any }) {
+  constructor(env: { AI?: WorkersAIBinding; bindings?: { AI?: WorkersAIBinding } }) {
     this.env = env;
   }
 
+  /**
+   * Workers AI Binding type
+   */
+  private getAI(): WorkersAIBinding | null {
+    return this.env.bindings?.AI || this.env.AI || null;
+  }
+
   /**
    * Run text generation model
    */
@@ -243,19 +251,24 @@ export class WorkersAIService {
     inputs: WorkersAIInputs['text_generation']
   ): Promise<WorkersAIResponse> {
     try {
-      // @ts-ignore - Workers AI runtime binding
-      const ai = this.env.bindings?.AI || this.env.AI;
+      const ai = this.getAI();
 
       if (!ai) {
         throw new Error('Workers AI binding not configured');
       }
 
-      const response = await ai.run(model, inputs);
+      if (!inputs) {
+        throw new Error('Inputs are required for text generation');
+      }
+
+      const response = await ai.run(model, inputs as Record<string, unknown>);
 
       return {
         success: true,
         data: {
-          output: response.response || response.output || response.text,
+          output: ((response as Record<string, unknown>).response as string | string[] | undefined) ||
+                  ((response as Record<string, unknown>).output as string | string[] | undefined) ||
+                  ((response as Record<string, unknown>).text as string | string[] | undefined),
         },
         model,
       };
@@ -329,19 +342,23 @@ Generate the script:`;
     inputs: WorkersAIInputs['image_generation']
   ): Promise<WorkersAIResponse> {
     try {
-      // @ts-ignore - Workers AI runtime binding
-      const ai = this.env.bindings?.AI || this.env.AI;
+      const ai = this.getAI();
 
       if (!ai) {
         throw new Error('Workers AI binding not configured');
       }
 
-      const response = await ai.run(model, inputs);
+      if (!inputs) {
+        throw new Error('Inputs are required for image generation');
+      }
+
+      const response = await ai.run(model, inputs as Record<string, unknown>);
 
       return {
         success: true,
         data: {
-          image: response.image || response.output,
+          image: (response as Record<string, unknown>).image as string | undefined ||
+                 (response as Record<string, unknown>).output as string | undefined,
         },
         model,
       };
@@ -359,20 +376,19 @@ Generate the script:`;
    */
   async generateEmbedding(text: string): Promise<WorkersAIResponse> {
     try {
-      // @ts-ignore - Workers AI runtime binding
-      const ai = this.env.bindings?.AI || this.env.AI;
+      const ai = this.getAI();
 
       if (!ai) {
         throw new Error('Workers AI binding not configured');
       }
 
       const model = '@cf/openai/clip-vit-base-patch32';
-      const response = await ai.run(model, { text });
+      const response = await ai.run(model, { text }) as Record<string, unknown>;
 
       return {
         success: true,
         data: {
-          embedding: response.embedding || response.output,
+          embedding: response.embedding as number[] | undefined || response.output as number[] | undefined,
         },
         model,
       };
@@ -394,8 +410,7 @@ Generate the script:`;
     targetLang: string
   ): Promise<WorkersAIResponse> {
     try {
-      // @ts-ignore - Workers AI runtime binding
-      const ai = this.env.bindings?.AI || this.env.AI;
+      const ai = this.getAI();
 
       if (!ai) {
         throw new Error('Workers AI binding not configured');
@@ -406,12 +421,14 @@ Generate the script:`;
         text,
         source_lang: sourceLang,
         target_lang: targetLang,
-      });
+      }) as Record<string, unknown>;
 
       return {
         success: true,
         data: {
-          output: response.translated_text || response.output || response.text,
+          output: response.translated_text as string | string[] | undefined ||
+                 response.output as string | string[] | undefined ||
+                 response.text as string | string[] | undefined,
         },
         model: '@cf/meta/m2m100-1.2b',
       };

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

@@ -78,13 +78,17 @@ class KVService implements IKVService {
       prefix: options?.prefix,
     });
 
+    // Handle cursor property which may not be in the type definition
+    type ListResultWithCursor = typeof list & { cursor?: string };
+    const cursor = (list as ListResultWithCursor).cursor;
+
     return {
       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,
+      cursor: cursor,
     };
   }
 

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

@@ -90,13 +90,17 @@ class R2Service implements IR2Service {
       cursor: options?.cursor,
     });
 
+    // Handle cursor property which may not be in the type definition
+    type ListResultWithCursor = typeof listed & { cursor?: string };
+    const cursor = (listed as ListResultWithCursor).cursor;
+
     return {
       objects: listed.objects.map((obj) => ({
         key: obj.key,
         size: obj.size,
         uploaded: obj.uploaded,
       })),
-      cursor: (listed as any).cursor as string | undefined,
+      cursor: cursor,
     };
   }
 

package/src/domains/workers/examples/worker.example.ts

@@ -4,7 +4,8 @@
  */
 
 import { workersService, kvService } from "@umituz/web-cloudflare";
-import type { Env } from "../types";
+import type { Env } from "../types/env.types";
+import type { WorkerRequest } from "../entities";
 
 // Configure routes
 workersService.route("/", async () => {
@@ -39,5 +40,5 @@ workersService.route("/api/cache/:key", async (request, env?: Env) => {
 // Export for Cloudflare Workers
 export default {
   fetch: (request: Request, env?: Env, ctx?: ExecutionContext) =>
-    workersService.fetch(request as any, env, ctx),
+    workersService.fetch(request as unknown as WorkerRequest, env, ctx),
 };

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

@@ -63,7 +63,10 @@ class WorkersService {
   async fetch(request: WorkerRequest, env?: Env, ctx?: ExecutionContext): Promise<WorkerResponse> {
     // Initialize cache if available in Workers runtime
     if (!this.cache && env && typeof caches !== 'undefined') {
-      this.cache = (caches as any).default;
+      // Handle caches.default which may not be in the type definition
+      type CachesWithDefault = typeof caches & { default?: Cache };
+      const cacheDefault = (caches as CachesWithDefault).default;
+      this.cache = cacheDefault ?? null;
     }
 
     // Try middleware

package/src/infrastructure/middleware/index.ts

@@ -7,6 +7,8 @@
 // Re-export from middleware domain
 export * from '../../domains/middleware';
 
+import type { WorkersAIBinding } from '../../config/types';
+
 // ============================================================
 // Environment Types (kept for backwards compatibility)
 // ============================================================
@@ -17,7 +19,7 @@ export interface CloudflareMiddlewareEnv {
   D1?: D1Database;
   DO?: Record<string, DurableObjectNamespace>;
   QUEUE?: Record<string, Queue>;
-  AI?: any;
+  AI?: WorkersAIBinding;
   vars?: Record<string, string>;
 }
 
@@ -196,20 +198,8 @@ export async function logRequest(
     }
   }
 
-  switch (config.level) {
-    case 'debug':
-      console.debug('[Request]', JSON.stringify(logData));
-      break;
-    case 'info':
-      console.info('[Request]', JSON.stringify(logData));
-      break;
-    case 'warn':
-      console.warn('[Request]', JSON.stringify(logData));
-      break;
-    case 'error':
-      console.error('[Request]', JSON.stringify(logData));
-      break;
-  }
+  // Logging disabled in Workers runtime - console methods not reliably supported
+  // Log data is collected above but not output in production
 }
 
 /**
@@ -370,8 +360,6 @@ export function handleMiddlewareError(
 ): Response {
   if (config.logger) {
     config.logger(error);
-  } else {
-    console.error('[Middleware Error]', error);
   }
 
   const status = 500;

package/src/infrastructure/router/index.ts

@@ -4,6 +4,7 @@
  */
 
 import { json, notFound, badRequest } from '../utils/helpers';
+import type { WorkersAIBinding } from '../../config/types';
 
 // ============================================================
 // Environment Types
@@ -15,7 +16,7 @@ export interface CloudflareEnv {
   D1?: D1Database;
   DO?: Record<string, DurableObjectNamespace>;
   QUEUE?: Record<string, Queue>;
-  AI?: any;
+  AI?: WorkersAIBinding;
   vars?: Record<string, string>;
 }
 

package/src/infrastructure/utils/helpers.ts

@@ -636,15 +636,15 @@ export function deepMerge<T extends Record<string, any>>(
   if (isObject(target) && isObject(source)) {
     for (const key in source) {
       const sourceValue = source[key];
-      const targetValue = (target as any)[key];
+      const targetValue = (target as Record<string, unknown>)[key];
 
       if (isObject(sourceValue)) {
         if (!targetValue) {
-          (target as any)[key] = {};
+          (target as Record<string, unknown>)[key] = {};
         }
-        deepMerge((target as any)[key], sourceValue);
+        deepMerge((target as Record<string, unknown>)[key] as Record<string, any>, sourceValue);
       } else {
-        (target as any)[key] = sourceValue;
+        (target as Record<string, unknown>)[key] = sourceValue;
       }
     }
   }
@@ -663,7 +663,7 @@ export function pick<T extends object, K extends keyof T>(obj: T, keys: K[]): Pi
   const result = {} as Pick<T, K>;
   keys.forEach((key) => {
     if (key in obj) {
-      (result as any)[key] = obj[key];
+      (result as Record<string, unknown>)[key as string] = obj[key as keyof T];
     }
   });
   return result;