@lobehub/lobehub 2.0.0-next.239 → 2.0.0-next.240

package/src/server/routers/lambda/image/index.test.ts

@@ -0,0 +1,491 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { AsyncTaskStatus, AsyncTaskType } from '@/types/asyncTask';
+
+// Use vi.hoisted for variables used in vi.mock factory
+const {
+  mockServerDB,
+  mockGetKeyFromFullUrl,
+  mockGetFullFileUrl,
+  mockAsyncTaskModelUpdate,
+  mockChargeBeforeGenerate,
+  mockCreateAsyncCaller,
+} = vi.hoisted(() => ({
+  mockServerDB: {
+    transaction: vi.fn(),
+  },
+  mockGetKeyFromFullUrl: vi.fn(),
+  mockGetFullFileUrl: vi.fn(),
+  mockAsyncTaskModelUpdate: vi.fn(),
+  mockChargeBeforeGenerate: vi.fn(),
+  mockCreateAsyncCaller: vi.fn(),
+}));
+
+// Mock debug
+vi.mock('debug', () => ({
+  default: () => () => {},
+}));
+
+// Mock auth related
+vi.mock('@lobechat/utils/server', () => ({
+  getXorPayload: vi.fn(() => ({})),
+}));
+
+// Mock database adaptor
+vi.mock('@/database/core/db-adaptor', () => ({
+  getServerDB: vi.fn(async () => mockServerDB),
+}));
+
+// Mock FileService
+vi.mock('@/server/services/file', () => ({
+  FileService: vi.fn(() => ({
+    getKeyFromFullUrl: mockGetKeyFromFullUrl,
+    getFullFileUrl: mockGetFullFileUrl,
+  })),
+}));
+
+// Mock AsyncTaskModel
+vi.mock('@/database/models/asyncTask', () => ({
+  AsyncTaskModel: vi.fn(() => ({
+    update: mockAsyncTaskModelUpdate,
+  })),
+}));
+
+// Mock chargeBeforeGenerate
+vi.mock('@/business/server/image-generation/chargeBeforeGenerate', () => ({
+  chargeBeforeGenerate: (params: any) => mockChargeBeforeGenerate(params),
+}));
+
+// Mock async caller
+vi.mock('@/server/routers/async/caller', () => ({
+  createAsyncCaller: mockCreateAsyncCaller,
+}));
+
+// Mock drizzle-orm
+vi.mock('drizzle-orm', () => ({
+  and: vi.fn((...args) => args),
+  eq: vi.fn((a, b) => ({ a, b })),
+}));
+
+// Mock database schemas
+vi.mock('@/database/schemas', () => ({
+  asyncTasks: { id: 'asyncTasks.id', userId: 'asyncTasks.userId' },
+  generationBatches: { id: 'generationBatches.id' },
+  generations: { id: 'generations.id', userId: 'generations.userId' },
+}));
+
+// Mock seed generator
+vi.mock('@/utils/number', () => ({
+  generateUniqueSeeds: vi.fn((count: number) => Array.from({ length: count }, (_, i) => 1000 + i)),
+}));
+
+import { imageRouter } from './index';
+
+describe('imageRouter', () => {
+  const mockUserId = 'test-user-id';
+  const mockAsyncCallerCreateImage = vi.fn();
+
+  const createMockCtx = (overrides = {}) => ({
+    userId: mockUserId,
+    authorizationHeader: 'mock-auth-header',
+    ...overrides,
+  });
+
+  const createDefaultInput = (overrides = {}) => ({
+    generationTopicId: 'topic-1',
+    imageNum: 2,
+    model: 'stable-diffusion',
+    params: {
+      prompt: 'a beautiful sunset',
+      width: 512,
+      height: 512,
+    },
+    provider: 'test-provider',
+    ...overrides,
+  });
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+
+    // Default mock implementations
+    mockChargeBeforeGenerate.mockResolvedValue(undefined);
+    mockGetKeyFromFullUrl.mockResolvedValue(null);
+    mockGetFullFileUrl.mockResolvedValue(null);
+
+    // Setup default transaction mock
+    const mockBatch = {
+      id: 'batch-1',
+      generationTopicId: 'topic-1',
+      model: 'stable-diffusion',
+      provider: 'test-provider',
+      config: {},
+      userId: mockUserId,
+    };
+
+    const mockGenerations = [
+      { id: 'gen-1', generationBatchId: 'batch-1', seed: 1000, userId: mockUserId },
+      { id: 'gen-2', generationBatchId: 'batch-1', seed: 1001, userId: mockUserId },
+    ];
+
+    const mockAsyncTasks = [
+      { id: 'task-1', status: AsyncTaskStatus.Pending, type: AsyncTaskType.ImageGeneration },
+      { id: 'task-2', status: AsyncTaskStatus.Pending, type: AsyncTaskType.ImageGeneration },
+    ];
+
+    let insertCallCount = 0;
+    mockServerDB.transaction.mockImplementation(async (callback) => {
+      insertCallCount = 0;
+      const tx = {
+        insert: vi.fn().mockReturnValue({
+          values: vi.fn().mockReturnValue({
+            returning: vi.fn().mockImplementation(() => {
+              insertCallCount++;
+              if (insertCallCount === 1) return [mockBatch];
+              if (insertCallCount === 2) return mockGenerations;
+              // For async tasks, return one at a time
+              const taskIndex = insertCallCount - 3;
+              return [mockAsyncTasks[taskIndex] || mockAsyncTasks[0]];
+            }),
+          }),
+        }),
+        update: vi.fn().mockReturnValue({
+          set: vi.fn().mockReturnValue({
+            where: vi.fn().mockResolvedValue(undefined),
+          }),
+        }),
+      };
+
+      return callback(tx);
+    });
+
+    mockCreateAsyncCaller.mockResolvedValue({
+      image: {
+        createImage: mockAsyncCallerCreateImage,
+      },
+    });
+  });
+
+  describe('createImage', () => {
+    it('should create image generation batch and generations successfully', async () => {
+      const ctx = createMockCtx();
+      const input = createDefaultInput();
+
+      const caller = imageRouter.createCaller(ctx);
+      const result = await caller.createImage(input);
+
+      expect(result.success).toBe(true);
+      expect(result.data.batch).toBeDefined();
+      expect(result.data.batch.id).toBe('batch-1');
+      expect(result.data.generations).toHaveLength(2);
+      expect(mockServerDB.transaction).toHaveBeenCalled();
+    });
+
+    it('should convert imageUrls to S3 keys for database storage', async () => {
+      mockGetKeyFromFullUrl
+        .mockResolvedValueOnce('files/image1.jpg')
+        .mockResolvedValueOnce('files/image2.jpg');
+
+      const ctx = createMockCtx();
+      const input = createDefaultInput({
+        params: {
+          prompt: 'test prompt',
+          imageUrls: [
+            'https://s3.amazonaws.com/bucket/files/image1.jpg',
+            'https://s3.amazonaws.com/bucket/files/image2.jpg',
+          ],
+        },
+      });
+
+      const caller = imageRouter.createCaller(ctx);
+      await caller.createImage(input);
+
+      expect(mockGetKeyFromFullUrl).toHaveBeenCalledTimes(2);
+      expect(mockGetKeyFromFullUrl).toHaveBeenCalledWith(
+        'https://s3.amazonaws.com/bucket/files/image1.jpg',
+      );
+      expect(mockGetKeyFromFullUrl).toHaveBeenCalledWith(
+        'https://s3.amazonaws.com/bucket/files/image2.jpg',
+      );
+    });
+
+    it('should convert single imageUrl to S3 key for database storage', async () => {
+      mockGetKeyFromFullUrl.mockResolvedValue('files/single-image.jpg');
+
+      const ctx = createMockCtx();
+      const input = createDefaultInput({
+        params: {
+          prompt: 'test prompt',
+          imageUrl: 'https://s3.amazonaws.com/bucket/files/single-image.jpg',
+        },
+      });
+
+      const caller = imageRouter.createCaller(ctx);
+      await caller.createImage(input);
+
+      expect(mockGetKeyFromFullUrl).toHaveBeenCalledWith(
+        'https://s3.amazonaws.com/bucket/files/single-image.jpg',
+      );
+    });
+
+    it('should handle failed URL to key conversion gracefully for imageUrls', async () => {
+      mockGetKeyFromFullUrl.mockResolvedValue(null);
+
+      const ctx = createMockCtx();
+      const input = createDefaultInput({
+        params: {
+          prompt: 'test prompt',
+          imageUrls: ['https://example.com/image.jpg'],
+        },
+      });
+
+      const caller = imageRouter.createCaller(ctx);
+      const result = await caller.createImage(input);
+
+      // Should still succeed, just with empty imageUrls in config
+      expect(result.success).toBe(true);
+    });
+
+    it('should throw error when imageUrls conversion fails and URLs remain', async () => {
+      mockGetKeyFromFullUrl.mockRejectedValue(new Error('Conversion failed'));
+
+      const ctx = createMockCtx();
+      const input = createDefaultInput({
+        params: {
+          prompt: 'test prompt',
+          imageUrls: ['https://example.com/image.jpg'],
+        },
+      });
+
+      const caller = imageRouter.createCaller(ctx);
+
+      // When conversion fails, the original URL is kept but validateNoUrlsInConfig
+      // will detect it and throw an error to prevent storing URLs in database
+      await expect(caller.createImage(input)).rejects.toThrow(
+        'Invalid configuration: Found full URL instead of key',
+      );
+    });
+
+    it('should throw error when single imageUrl conversion fails and URL remains', async () => {
+      mockGetKeyFromFullUrl.mockRejectedValue(new Error('Conversion failed'));
+
+      const ctx = createMockCtx();
+      const input = createDefaultInput({
+        params: {
+          prompt: 'test prompt',
+          imageUrl: 'https://example.com/image.jpg',
+        },
+      });
+
+      const caller = imageRouter.createCaller(ctx);
+
+      // When conversion fails, the original URL is kept but validateNoUrlsInConfig
+      // will detect it and throw an error to prevent storing URLs in database
+      await expect(caller.createImage(input)).rejects.toThrow(
+        'Invalid configuration: Found full URL instead of key',
+      );
+    });
+
+    it('should return charge result when chargeBeforeGenerate returns a value', async () => {
+      const chargeResult = {
+        success: true as const,
+        data: {
+          batch: { id: 'charged-batch' },
+          generations: [{ id: 'charged-gen' }],
+        },
+      };
+      mockChargeBeforeGenerate.mockResolvedValue(chargeResult);
+
+      const ctx = createMockCtx();
+      const input = createDefaultInput();
+
+      const caller = imageRouter.createCaller(ctx);
+      const result = await caller.createImage(input);
+
+      expect(result).toEqual(chargeResult);
+      // Should not proceed with database transaction
+      expect(mockServerDB.transaction).not.toHaveBeenCalled();
+    });
+
+    it('should call chargeBeforeGenerate with correct parameters', async () => {
+      const ctx = createMockCtx();
+      const input = createDefaultInput();
+
+      const caller = imageRouter.createCaller(ctx);
+      await caller.createImage(input);
+
+      expect(mockChargeBeforeGenerate).toHaveBeenCalledWith(
+        expect.objectContaining({
+          generationTopicId: 'topic-1',
+          imageNum: 2,
+          model: 'stable-diffusion',
+          provider: 'test-provider',
+          userId: mockUserId,
+        }),
+      );
+    });
+
+    it('should trigger async image generation tasks', async () => {
+      const ctx = createMockCtx();
+      const input = createDefaultInput();
+
+      const caller = imageRouter.createCaller(ctx);
+      await caller.createImage(input);
+
+      expect(mockCreateAsyncCaller).toHaveBeenCalledWith({ userId: mockUserId });
+    });
+
+    it('should handle async caller creation failure', async () => {
+      mockCreateAsyncCaller.mockRejectedValue(new Error('Caller creation failed'));
+
+      const ctx = createMockCtx();
+      const input = createDefaultInput();
+
+      const caller = imageRouter.createCaller(ctx);
+      const result = await caller.createImage(input);
+
+      // Should still return success as the database records were created
+      expect(result.success).toBe(true);
+      // Should update async task status to error
+      expect(mockAsyncTaskModelUpdate).toHaveBeenCalled();
+    });
+
+    it('should update all task statuses to error when async processing fails', async () => {
+      mockCreateAsyncCaller.mockRejectedValue(new Error('Processing failed'));
+
+      const ctx = createMockCtx();
+      const input = createDefaultInput();
+
+      const caller = imageRouter.createCaller(ctx);
+      await caller.createImage(input);
+
+      // Should update both tasks to error status
+      expect(mockAsyncTaskModelUpdate).toHaveBeenCalledTimes(2);
+      expect(mockAsyncTaskModelUpdate).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.objectContaining({
+          status: AsyncTaskStatus.Error,
+        }),
+      );
+    });
+
+    it('should generate unique seeds when seed param is provided', async () => {
+      const ctx = createMockCtx();
+      const input = createDefaultInput({
+        params: {
+          prompt: 'test prompt',
+          seed: 42,
+        },
+      });
+
+      const caller = imageRouter.createCaller(ctx);
+      await caller.createImage(input);
+
+      expect(mockServerDB.transaction).toHaveBeenCalled();
+    });
+
+    it('should use null seeds when seed param is not provided', async () => {
+      const ctx = createMockCtx();
+      const input = createDefaultInput({
+        params: {
+          prompt: 'test prompt',
+          // No seed param
+        },
+      });
+
+      const caller = imageRouter.createCaller(ctx);
+      await caller.createImage(input);
+
+      expect(mockServerDB.transaction).toHaveBeenCalled();
+    });
+
+    it('should pass with valid key-based imageUrls', async () => {
+      mockGetKeyFromFullUrl.mockResolvedValue('files/valid-key.jpg');
+
+      const ctx = createMockCtx();
+      const input = createDefaultInput({
+        params: {
+          prompt: 'test prompt',
+          imageUrls: ['files/valid-key.jpg'],
+        },
+      });
+
+      const caller = imageRouter.createCaller(ctx);
+      const result = await caller.createImage(input);
+
+      expect(result.success).toBe(true);
+    });
+
+    describe('development environment URL conversion', () => {
+      beforeEach(() => {
+        vi.stubEnv('NODE_ENV', 'development');
+      });
+
+      afterEach(() => {
+        vi.unstubAllEnvs();
+      });
+
+      it('should convert single imageUrl to S3 URL in development mode', async () => {
+        mockGetKeyFromFullUrl.mockResolvedValue('files/image-key.jpg');
+        mockGetFullFileUrl.mockResolvedValue('https://s3.amazonaws.com/bucket/files/image-key.jpg');
+
+        const ctx = createMockCtx();
+        const input = createDefaultInput({
+          params: {
+            prompt: 'test prompt',
+            imageUrl: 'http://localhost:3000/f/file-id',
+          },
+        });
+
+        const caller = imageRouter.createCaller(ctx);
+        const result = await caller.createImage(input);
+
+        expect(result.success).toBe(true);
+        expect(mockGetFullFileUrl).toHaveBeenCalledWith('files/image-key.jpg');
+      });
+
+      it('should convert multiple imageUrls to S3 URLs in development mode', async () => {
+        mockGetKeyFromFullUrl
+          .mockResolvedValueOnce('files/image1.jpg')
+          .mockResolvedValueOnce('files/image2.jpg');
+        mockGetFullFileUrl
+          .mockResolvedValueOnce('https://s3.amazonaws.com/bucket/files/image1.jpg')
+          .mockResolvedValueOnce('https://s3.amazonaws.com/bucket/files/image2.jpg');
+
+        const ctx = createMockCtx();
+        const input = createDefaultInput({
+          params: {
+            prompt: 'test prompt',
+            imageUrls: ['http://localhost:3000/f/id1', 'http://localhost:3000/f/id2'],
+          },
+        });
+
+        const caller = imageRouter.createCaller(ctx);
+        const result = await caller.createImage(input);
+
+        expect(result.success).toBe(true);
+        expect(mockGetFullFileUrl).toHaveBeenCalledTimes(2);
+        expect(mockGetFullFileUrl).toHaveBeenCalledWith('files/image1.jpg');
+        expect(mockGetFullFileUrl).toHaveBeenCalledWith('files/image2.jpg');
+      });
+
+      it('should not convert URLs when getFullFileUrl returns null', async () => {
+        mockGetKeyFromFullUrl.mockResolvedValue('files/image-key.jpg');
+        mockGetFullFileUrl.mockResolvedValue(null);
+
+        const ctx = createMockCtx();
+        const input = createDefaultInput({
+          params: {
+            prompt: 'test prompt',
+            imageUrl: 'http://localhost:3000/f/file-id',
+          },
+        });
+
+        const caller = imageRouter.createCaller(ctx);
+        const result = await caller.createImage(input);
+
+        expect(result.success).toBe(true);
+        expect(mockGetFullFileUrl).toHaveBeenCalled();
+      });
+    });
+  });
+});

package/src/server/routers/lambda/{image.ts → image/index.ts}

@@ -23,32 +23,9 @@ import {
 } from '@/types/asyncTask';
 import { generateUniqueSeeds } from '@/utils/number';
 
-const log = debug('lobe-image:lambda');
+import { validateNoUrlsInConfig } from './utils';
 
-/**
- * Recursively validate that no full URLs are present in the config
- * This is a defensive check to ensure only keys are stored in database
- */
-function validateNoUrlsInConfig(obj: any, path: string = ''): void {
-  if (typeof obj === 'string') {
-    if (obj.startsWith('http://') || obj.startsWith('https://')) {
-      throw new Error(
-        `Invalid configuration: Found full URL instead of key at ${path || 'root'}. ` +
-          `URL: "${obj.slice(0, 100)}${obj.length > 100 ? '...' : ''}". ` +
-          `All URLs must be converted to storage keys before database insertion.`,
-      );
-    }
-  } else if (Array.isArray(obj)) {
-    obj.forEach((item, index) => {
-      validateNoUrlsInConfig(item, `${path}[${index}]`);
-    });
-  } else if (obj && typeof obj === 'object') {
-    Object.entries(obj).forEach(([key, value]) => {
-      const currentPath = path ? `${path}.${key}` : key;
-      validateNoUrlsInConfig(value, currentPath);
-    });
-  }
-}
+const log = debug('lobe-image:lambda');
 
 const imageProcedure = authedProcedure
   .use(keyVaults)
@@ -103,11 +80,18 @@ export const imageRouter = router({
     if (Array.isArray(params.imageUrls) && params.imageUrls.length > 0) {
       log('Converting imageUrls to S3 keys for database storage: %O', params.imageUrls);
       try {
-        const imageKeys = params.imageUrls.map((url) => {
-          const key = fileService.getKeyFromFullUrl(url);
-          log('Converted URL %s to key %s', url, key);
-          return key;
-        });
+        const imageKeysWithNull = await Promise.all(
+          params.imageUrls.map(async (url) => {
+            const key = await fileService.getKeyFromFullUrl(url);
+            if (key) {
+              log('Converted URL %s to key %s', url, key);
+            } else {
+              log('Failed to extract key from URL: %s', url);
+            }
+            return key;
+          }),
+        );
+        const imageKeys = imageKeysWithNull.filter((key): key is string => key !== null);
 
         configForDatabase = {
           ...configForDatabase,
@@ -115,29 +99,61 @@ export const imageRouter = router({
         };
         log('Successfully converted imageUrls to keys for database: %O', imageKeys);
       } catch (error) {
-        log('Error converting imageUrls to keys: %O', error);
-        log('Keeping original imageUrls due to conversion error');
+        console.error('Error converting imageUrls to keys: %O', error);
+        console.error('Keeping original imageUrls due to conversion error');
       }
     }
     // 2) Process single image in imageUrl
     if (typeof params.imageUrl === 'string' && params.imageUrl) {
       try {
-        const key = fileService.getKeyFromFullUrl(params.imageUrl);
-        log('Converted single imageUrl to key: %s -> %s', params.imageUrl, key);
-        configForDatabase = { ...configForDatabase, imageUrl: key };
+        const key = await fileService.getKeyFromFullUrl(params.imageUrl);
+        if (key) {
+          log('Converted single imageUrl to key: %s -> %s', params.imageUrl, key);
+          configForDatabase = { ...configForDatabase, imageUrl: key };
+        } else {
+          log('Failed to extract key from single imageUrl: %s', params.imageUrl);
+        }
       } catch (error) {
-        log('Error converting imageUrl to key: %O', error);
+        console.error('Error converting imageUrl to key: %O', error);
         // Keep original value if conversion fails
       }
     }
 
+    // In development, convert localhost proxy URLs to S3 URLs for async task access
+    let generationParams = params;
+    if (process.env.NODE_ENV === 'development') {
+      const updates: Record<string, unknown> = {};
+
+      // Handle single imageUrl: localhost/f/{id} -> S3 URL
+      if (typeof params.imageUrl === 'string' && params.imageUrl) {
+        const s3Url = await fileService.getFullFileUrl(configForDatabase.imageUrl as string);
+        if (s3Url) {
+          log('Dev: converted proxy URL to S3 URL: %s -> %s', params.imageUrl, s3Url);
+          updates.imageUrl = s3Url;
+        }
+      }
+
+      // Handle multiple imageUrls
+      if (Array.isArray(params.imageUrls) && params.imageUrls.length > 0) {
+        const s3Urls = await Promise.all(
+          (configForDatabase.imageUrls as string[]).map((key) => fileService.getFullFileUrl(key)),
+        );
+        log('Dev: converted proxy URLs to S3 URLs: %O', s3Urls);
+        updates.imageUrls = s3Urls;
+      }
+
+      if (Object.keys(updates).length > 0) {
+        generationParams = { ...params, ...updates };
+      }
+    }
+
     // Defensive check: ensure no full URLs enter the database
     validateNoUrlsInConfig(configForDatabase, 'configForDatabase');
 
     const chargeResult = await chargeBeforeGenerate({
       clientIp: ctx.clientIp,
       configForDatabase,
-      generationParams: params,
+      generationParams,
       generationTopicId,
       imageNum,
       model,
@@ -167,7 +183,7 @@ export const imageRouter = router({
       const [batch] = await tx.insert(generationBatches).values(newBatch).returning();
       log('Generation batch created successfully: %s', batch.id);
 
-      // 2. Create 4 generations (fixed at 4 images for phase one)
+      // 2. Create generations
       const seeds =
         'seed' in params
           ? generateUniqueSeeds(imageNum)
@@ -248,7 +264,7 @@ export const imageRouter = router({
           generationId: generation.id,
           generationTopicId,
           model,
-          params,
+          params: generationParams,
           provider,
           taskId: asyncTaskId,
         });
@@ -256,8 +272,8 @@ export const imageRouter = router({
 
       log('All %d background async image generation tasks started', generationsWithTasks.length);
     } catch (e) {
-      console.error('[createImage] Failed to process async tasks:', e);
-      log('Failed to process async tasks: %O', e);
+      console.error('Failed to process async tasks:', e);
+      console.error('Failed to process async tasks: %O', e);
 
       // If overall failure occurs, update all task statuses to failed
       try {

package/src/server/routers/lambda/{__tests__/image.test.ts → image/utils.test.ts}

@@ -1,26 +1,6 @@
 import { describe, expect, it } from 'vitest';
 
-// Copy of the validation function from image.ts for testing
-function validateNoUrlsInConfig(obj: any, path: string = ''): void {
-  if (typeof obj === 'string') {
-    if (obj.startsWith('http://') || obj.startsWith('https://')) {
-      throw new Error(
-        `Invalid configuration: Found full URL instead of key at ${path || 'root'}. ` +
-          `URL: "${obj.slice(0, 100)}${obj.length > 100 ? '...' : ''}". ` +
-          `All URLs must be converted to storage keys before database insertion.`,
-      );
-    }
-  } else if (Array.isArray(obj)) {
-    obj.forEach((item, index) => {
-      validateNoUrlsInConfig(item, `${path}[${index}]`);
-    });
-  } else if (obj && typeof obj === 'object') {
-    Object.entries(obj).forEach(([key, value]) => {
-      const currentPath = path ? `${path}.${key}` : key;
-      validateNoUrlsInConfig(value, currentPath);
-    });
-  }
-}
+import { validateNoUrlsInConfig } from './utils';
 
 describe('imageRouter', () => {
   describe('validateNoUrlsInConfig utility', () => {

package/src/server/routers/lambda/image/utils.ts

@@ -0,0 +1,24 @@
+/**
+ * Recursively validate that no full URLs are present in the config
+ * This is a defensive check to ensure only keys are stored in database
+ */
+export function validateNoUrlsInConfig(obj: any, path: string = ''): void {
+  if (typeof obj === 'string') {
+    if (obj.startsWith('http://') || obj.startsWith('https://')) {
+      throw new Error(
+        `Invalid configuration: Found full URL instead of key at ${path || 'root'}. ` +
+          `URL: "${obj.slice(0, 100)}${obj.length > 100 ? '...' : ''}". ` +
+          `All URLs must be converted to storage keys before database insertion.`,
+      );
+    }
+  } else if (Array.isArray(obj)) {
+    obj.forEach((item, index) => {
+      validateNoUrlsInConfig(item, `${path}[${index}]`);
+    });
+  } else if (obj && typeof obj === 'object') {
+    Object.entries(obj).forEach(([key, value]) => {
+      const currentPath = path ? `${path}.${key}` : key;
+      validateNoUrlsInConfig(value, currentPath);
+    });
+  }
+}