@lobehub/lobehub 2.0.0-next.26 → 2.0.0-next.27

package/src/store/session/slices/sessionGroup/action.test.ts

@@ -42,7 +42,7 @@ describe('createSessionGroupSlice', () => {
     it('should clear session groups and refresh sessions', async () => {
       const spyOn = vi
         .spyOn(sessionService, 'removeSessionGroups')
-        .mockResolvedValueOnce(undefined);
+        .mockResolvedValueOnce(undefined as any);
       const spyOnRefreshSessions = vi.spyOn(useSessionStore.getState(), 'refreshSessions');
 
       const { result } = renderHook(() => useSessionStore());
@@ -59,7 +59,7 @@ describe('createSessionGroupSlice', () => {
   describe('removeSessionGroup', () => {
     it('should remove a session group and refresh sessions', async () => {
       const mockId = 'mock-id';
-      vi.spyOn(sessionService, 'removeSessionGroup').mockResolvedValueOnce(undefined);
+      vi.spyOn(sessionService, 'removeSessionGroup').mockResolvedValueOnce(undefined as any);
       const spyOnRefreshSessions = vi.spyOn(useSessionStore.getState(), 'refreshSessions');
 
       const { result } = renderHook(() => useSessionStore());
@@ -77,7 +77,7 @@ describe('createSessionGroupSlice', () => {
     it('should update a session group id and refresh sessions', async () => {
       const mockSessionId = 'session-id';
       const mockGroupId = 'group-id';
-      vi.spyOn(sessionService, 'updateSession').mockResolvedValueOnce(undefined);
+      vi.spyOn(sessionService, 'updateSession').mockResolvedValueOnce(undefined as any);
       const spyOnRefreshSessions = vi.spyOn(useSessionStore.getState(), 'refreshSessions');
 
       const { result } = renderHook(() => useSessionStore());
@@ -98,7 +98,7 @@ describe('createSessionGroupSlice', () => {
       const mockId = 'mock-id';
       const mockName = 'New Name';
       const spyOnRefreshSessions = vi.spyOn(useSessionStore.getState(), 'refreshSessions');
-      vi.spyOn(sessionService, 'updateSessionGroup').mockResolvedValueOnce(undefined);
+      vi.spyOn(sessionService, 'updateSessionGroup').mockResolvedValueOnce(undefined as any);
 
       const { result } = renderHook(() => useSessionStore());
 
@@ -117,7 +117,7 @@ describe('createSessionGroupSlice', () => {
         { id: 'id1', sort: 0 },
         { id: 'id2', sort: 1 },
       ];
-      vi.spyOn(sessionService, 'updateSessionGroupOrder').mockResolvedValueOnce(undefined);
+      vi.spyOn(sessionService, 'updateSessionGroupOrder').mockResolvedValueOnce(undefined as any);
       const spyOnRefreshSessions = vi.spyOn(useSessionStore.getState(), 'refreshSessions');
 
       const { result } = renderHook(() => useSessionStore());

package/src/store/user/slices/common/action.test.ts

@@ -30,7 +30,7 @@ describe('createCommonSlice', () => {
       const avatar = 'data:image/png;base64,';
 
       const spyOn = vi.spyOn(result.current, 'refreshUserState');
-      const updateAvatarSpy = vi.spyOn(userService, 'updateAvatar').mockResolvedValue(undefined);
+      const updateAvatarSpy = vi.spyOn(userService, 'updateAvatar').mockResolvedValue({} as any);
 
       await act(async () => {
         await result.current.updateAvatar(avatar);

package/src/services/aiModel/server.test.ts

@@ -1,122 +0,0 @@
-import { AiProviderModelListItem } from 'model-bank';
-import { describe, expect, it, vi } from 'vitest';
-
-import { lambdaClient } from '@/libs/trpc/client';
-
-import { ServerService } from './server';
-
-vi.mock('@/libs/trpc/client', () => ({
-  lambdaClient: {
-    aiModel: {
-      createAiModel: { mutate: vi.fn() },
-      getAiProviderModelList: { query: vi.fn() },
-      getAiModelById: { query: vi.fn() },
-      toggleModelEnabled: { mutate: vi.fn() },
-      updateAiModel: { mutate: vi.fn() },
-      batchUpdateAiModels: { mutate: vi.fn() },
-      batchToggleAiModels: { mutate: vi.fn() },
-      clearModelsByProvider: { mutate: vi.fn() },
-      clearRemoteModels: { mutate: vi.fn() },
-      updateAiModelOrder: { mutate: vi.fn() },
-      removeAiModel: { mutate: vi.fn() },
-    },
-  },
-}));
-
-describe('ServerService', () => {
-  const service = new ServerService();
-
-  it('should create AI model', async () => {
-    const params = {
-      id: 'test-id',
-      providerId: 'test-provider',
-      displayName: 'Test Model',
-    };
-    await service.createAiModel(params);
-    expect(vi.mocked(lambdaClient.aiModel.createAiModel.mutate)).toHaveBeenCalledWith(params);
-  });
-
-  it('should get AI provider model list', async () => {
-    await service.getAiProviderModelList('123');
-    expect(vi.mocked(lambdaClient.aiModel.getAiProviderModelList.query)).toHaveBeenCalledWith({
-      id: '123',
-    });
-  });
-
-  it('should get AI model by id', async () => {
-    await service.getAiModelById('123');
-    expect(vi.mocked(lambdaClient.aiModel.getAiModelById.query)).toHaveBeenCalledWith({
-      id: '123',
-    });
-  });
-
-  it('should toggle model enabled', async () => {
-    const params = { id: '123', providerId: 'test', enabled: true };
-    await service.toggleModelEnabled(params);
-    expect(vi.mocked(lambdaClient.aiModel.toggleModelEnabled.mutate)).toHaveBeenCalledWith(params);
-  });
-
-  it('should update AI model', async () => {
-    const value = { contextWindowTokens: 4000, displayName: 'Updated Model' };
-    await service.updateAiModel('123', 'openai', value);
-    expect(vi.mocked(lambdaClient.aiModel.updateAiModel.mutate)).toHaveBeenCalledWith({
-      id: '123',
-      providerId: 'openai',
-      value,
-    });
-  });
-
-  it('should batch update AI models', async () => {
-    const models: AiProviderModelListItem[] = [
-      {
-        id: '123',
-        enabled: true,
-        type: 'chat',
-      },
-    ];
-    await service.batchUpdateAiModels('provider1', models);
-    expect(vi.mocked(lambdaClient.aiModel.batchUpdateAiModels.mutate)).toHaveBeenCalledWith({
-      id: 'provider1',
-      models,
-    });
-  });
-
-  it('should batch toggle AI models', async () => {
-    const models = ['123', '456'];
-    await service.batchToggleAiModels('provider1', models, true);
-    expect(vi.mocked(lambdaClient.aiModel.batchToggleAiModels.mutate)).toHaveBeenCalledWith({
-      id: 'provider1',
-      models,
-      enabled: true,
-    });
-  });
-
-  it('should clear models by provider', async () => {
-    await service.clearModelsByProvider('provider1');
-    expect(vi.mocked(lambdaClient.aiModel.clearModelsByProvider.mutate)).toHaveBeenCalledWith({
-      providerId: 'provider1',
-    });
-  });
-
-  it('should clear remote models', async () => {
-    await service.clearRemoteModels('provider1');
-    expect(vi.mocked(lambdaClient.aiModel.clearRemoteModels.mutate)).toHaveBeenCalledWith({
-      providerId: 'provider1',
-    });
-  });
-
-  it('should update AI model order', async () => {
-    const items = [{ id: '123', sort: 1 }];
-    await service.updateAiModelOrder('provider1', items);
-    expect(vi.mocked(lambdaClient.aiModel.updateAiModelOrder.mutate)).toHaveBeenCalledWith({
-      providerId: 'provider1',
-      sortMap: items,
-    });
-  });
-
-  it('should delete AI model', async () => {
-    const params = { id: '123', providerId: 'openai' };
-    await service.deleteAiModel(params);
-    expect(vi.mocked(lambdaClient.aiModel.removeAiModel.mutate)).toHaveBeenCalledWith(params);
-  });
-});

package/src/services/aiModel/server.ts

@@ -1,51 +0,0 @@
-import { lambdaClient } from '@/libs/trpc/client';
-import { IAiModelService } from '@/services/aiModel/type';
-
-export class ServerService implements IAiModelService {
-  createAiModel: IAiModelService['createAiModel'] = async (params) => {
-    return lambdaClient.aiModel.createAiModel.mutate(params);
-  };
-
-  getAiProviderModelList: IAiModelService['getAiProviderModelList'] = async (id) => {
-    return lambdaClient.aiModel.getAiProviderModelList.query({ id });
-  };
-
-  getAiModelById: IAiModelService['getAiModelById'] = async (id) => {
-    return lambdaClient.aiModel.getAiModelById.query({ id });
-  };
-
-  toggleModelEnabled: IAiModelService['toggleModelEnabled'] = async (params) => {
-    return lambdaClient.aiModel.toggleModelEnabled.mutate(params);
-  };
-
-  updateAiModel: IAiModelService['updateAiModel'] = async (id, providerId, value) => {
-    return lambdaClient.aiModel.updateAiModel.mutate({ id, providerId, value });
-  };
-
-  batchUpdateAiModels: IAiModelService['batchUpdateAiModels'] = async (id, models) => {
-    return lambdaClient.aiModel.batchUpdateAiModels.mutate({ id, models });
-  };
-
-  batchToggleAiModels: IAiModelService['batchToggleAiModels'] = async (id, models, enabled) => {
-    return lambdaClient.aiModel.batchToggleAiModels.mutate({ enabled, id, models });
-  };
-
-  clearModelsByProvider: IAiModelService['clearModelsByProvider'] = async (providerId) => {
-    return lambdaClient.aiModel.clearModelsByProvider.mutate({ providerId });
-  };
-
-  clearRemoteModels: IAiModelService['clearRemoteModels'] = async (providerId) => {
-    return lambdaClient.aiModel.clearRemoteModels.mutate({ providerId });
-  };
-
-  updateAiModelOrder: IAiModelService['updateAiModelOrder'] = async (providerId, items) => {
-    return lambdaClient.aiModel.updateAiModelOrder.mutate({ providerId, sortMap: items });
-  };
-
-  deleteAiModel: IAiModelService['deleteAiModel'] = async (params: {
-    id: string;
-    providerId: string;
-  }) => {
-    return lambdaClient.aiModel.removeAiModel.mutate(params);
-  };
-}

package/src/services/aiModel/type.ts

@@ -1,32 +0,0 @@
-/* eslint-disable typescript-sort-keys/interface */
-import {
-  AiModelSortMap,
-  AiProviderModelListItem,
-  CreateAiModelParams,
-  ToggleAiModelEnableParams,
-  UpdateAiModelParams,
-} from 'model-bank';
-
-export interface IAiModelService {
-  createAiModel: (params: CreateAiModelParams) => Promise<any>;
-
-  getAiProviderModelList: (id: string) => Promise<AiProviderModelListItem[]>;
-
-  getAiModelById: (id: string) => Promise<any>;
-
-  toggleModelEnabled: (params: ToggleAiModelEnableParams) => Promise<any>;
-
-  updateAiModel: (id: string, providerId: string, value: UpdateAiModelParams) => Promise<any>;
-
-  batchUpdateAiModels: (id: string, models: AiProviderModelListItem[]) => Promise<any>;
-
-  batchToggleAiModels: (id: string, models: string[], enabled: boolean) => Promise<any>;
-
-  clearRemoteModels: (providerId: string) => Promise<any>;
-
-  clearModelsByProvider: (providerId: string) => Promise<any>;
-
-  updateAiModelOrder: (providerId: string, items: AiModelSortMap[]) => Promise<any>;
-
-  deleteAiModel: (params: { id: string; providerId: string }) => Promise<any>;
-}

package/src/services/aiProvider/server.ts

@@ -1,43 +0,0 @@
-import { lambdaClient } from '@/libs/trpc/client';
-
-import { IAiProviderService } from './type';
-
-export class ServerService implements IAiProviderService {
-  createAiProvider: IAiProviderService['createAiProvider'] = async (params) => {
-    return lambdaClient.aiProvider.createAiProvider.mutate(params);
-  };
-
-  getAiProviderList: IAiProviderService['getAiProviderList'] = async () => {
-    return lambdaClient.aiProvider.getAiProviderList.query();
-  };
-
-  getAiProviderById: IAiProviderService['getAiProviderById'] = async (id) => {
-    return lambdaClient.aiProvider.getAiProviderById.query({ id });
-  };
-
-  toggleProviderEnabled: IAiProviderService['toggleProviderEnabled'] = async (id, enabled) => {
-    return lambdaClient.aiProvider.toggleProviderEnabled.mutate({ enabled, id });
-  };
-
-  updateAiProvider: IAiProviderService['updateAiProvider'] = async (id, value) => {
-    return lambdaClient.aiProvider.updateAiProvider.mutate({ id, value });
-  };
-
-  updateAiProviderConfig: IAiProviderService['updateAiProviderConfig'] = async (id, value) => {
-    return lambdaClient.aiProvider.updateAiProviderConfig.mutate({ id, value });
-  };
-
-  updateAiProviderOrder: IAiProviderService['updateAiProviderOrder'] = async (items) => {
-    return lambdaClient.aiProvider.updateAiProviderOrder.mutate({ sortMap: items });
-  };
-
-  deleteAiProvider: IAiProviderService['deleteAiProvider'] = async (id) => {
-    return lambdaClient.aiProvider.removeAiProvider.mutate({ id });
-  };
-
-  getAiProviderRuntimeState: IAiProviderService['getAiProviderRuntimeState'] = async (
-    isLogin?: boolean,
-  ) => {
-    return lambdaClient.aiProvider.getAiProviderRuntimeState.query({ isLogin });
-  };
-}

package/src/services/aiProvider/type.ts

@@ -1,27 +0,0 @@
-import {
-  AiProviderDetailItem,
-  AiProviderRuntimeState,
-  AiProviderSortMap,
-  CreateAiProviderParams,
-  UpdateAiProviderConfigParams,
-} from '@/types/aiProvider';
-
-export interface IAiProviderService {
-  createAiProvider: (params: CreateAiProviderParams) => Promise<any>;
-
-  deleteAiProvider: (id: string) => Promise<any>;
-
-  getAiProviderById: (id: string) => Promise<AiProviderDetailItem | undefined>;
-
-  getAiProviderList: () => Promise<any>;
-
-  getAiProviderRuntimeState: (isLogin?: boolean) => Promise<AiProviderRuntimeState>;
-
-  toggleProviderEnabled: (id: string, enabled: boolean) => Promise<any>;
-
-  updateAiProvider: (id: string, value: any) => Promise<any>;
-
-  updateAiProviderConfig: (id: string, value: UpdateAiProviderConfigParams) => Promise<any>;
-
-  updateAiProviderOrder: (items: AiProviderSortMap[]) => Promise<any>;
-}

package/src/services/chatGroup/server.ts

@@ -1,67 +0,0 @@
-import {
-  ChatGroupAgentItem,
-  ChatGroupItem,
-  NewChatGroup,
-  NewChatGroupAgent,
-} from '@/database/schemas';
-import { lambdaClient } from '@/libs/trpc/client';
-
-import { IChatGroupService } from './type';
-
-export class ServerService implements IChatGroupService {
-  createGroup(params: Omit<NewChatGroup, 'userId'>): Promise<ChatGroupItem> {
-    return lambdaClient.group.createGroup.mutate({
-      ...params,
-      config: params.config as any,
-    });
-  }
-
-  updateGroup(id: string, value: Partial<ChatGroupItem>): Promise<ChatGroupItem> {
-    return lambdaClient.group.updateGroup.mutate({
-      id,
-      value: {
-        ...value,
-        config: value.config as any,
-      },
-    });
-  }
-
-  deleteGroup(id: string): Promise<any> {
-    return lambdaClient.group.deleteGroup.mutate({ id });
-  }
-
-  getGroup(id: string): Promise<ChatGroupItem | undefined> {
-    return lambdaClient.group.getGroup.query({ id });
-  }
-
-  getGroups(): Promise<ChatGroupItem[]> {
-    return lambdaClient.group.getGroups.query();
-  }
-
-  addAgentsToGroup(groupId: string, agentIds: string[]): Promise<ChatGroupAgentItem[]> {
-    return lambdaClient.group.addAgentsToGroup.mutate({ agentIds, groupId });
-  }
-
-  removeAgentsFromGroup(groupId: string, agentIds: string[]): Promise<any> {
-    return lambdaClient.group.removeAgentsFromGroup.mutate({ agentIds, groupId });
-  }
-
-  updateAgentInGroup(
-    groupId: string,
-    agentId: string,
-    updates: Partial<Pick<NewChatGroupAgent, 'order' | 'role'>>,
-  ): Promise<ChatGroupAgentItem> {
-    return lambdaClient.group.updateAgentInGroup.mutate({
-      agentId,
-      groupId,
-      updates: {
-        order: updates.order === null ? undefined : updates.order,
-        role: updates.role === null ? undefined : updates.role,
-      },
-    });
-  }
-
-  getGroupAgents(groupId: string): Promise<ChatGroupAgentItem[]> {
-    return lambdaClient.group.getGroupAgents.query({ groupId });
-  }
-}

package/src/services/chatGroup/type.ts

@@ -1,22 +0,0 @@
-import {
-  ChatGroupAgentItem,
-  ChatGroupItem,
-  NewChatGroup,
-  NewChatGroupAgent,
-} from '@/database/schemas';
-
-export interface IChatGroupService {
-  addAgentsToGroup(groupId: string, agentIds: string[]): Promise<ChatGroupAgentItem[]>;
-  createGroup(params: Omit<NewChatGroup, 'userId'>): Promise<ChatGroupItem>;
-  deleteGroup(id: string): Promise<any>;
-  getGroup(id: string): Promise<ChatGroupItem | undefined>;
-  getGroupAgents(groupId: string): Promise<ChatGroupAgentItem[]>;
-  getGroups(): Promise<ChatGroupItem[]>;
-  removeAgentsFromGroup(groupId: string, agentIds: string[]): Promise<any>;
-  updateAgentInGroup(
-    groupId: string,
-    agentId: string,
-    updates: Partial<Pick<NewChatGroupAgent, 'order' | 'role'>>,
-  ): Promise<ChatGroupAgentItem>;
-  updateGroup(id: string, value: Partial<ChatGroupItem>): Promise<ChatGroupItem>;
-}

package/src/services/export/server.ts

@@ -1,9 +0,0 @@
-import { lambdaClient } from '@/libs/trpc/client';
-
-import { IExportService } from './type';
-
-export class ServerService implements IExportService {
-  exportData: IExportService['exportData'] = async () => {
-    return await lambdaClient.exporter.exportData.mutate();
-  };
-}

package/src/services/export/type.ts

@@ -1,5 +0,0 @@
-import { ExportDatabaseData } from '@/types/export';
-
-export interface IExportService {
-  exportData(): Promise<ExportDatabaseData>;
-}

package/src/services/file/server.ts

@@ -1,53 +0,0 @@
-import { lambdaClient } from '@/libs/trpc/client';
-import { QueryFileListParams, QueryFileListSchemaType, UploadFileParams } from '@/types/files';
-
-import { IFileService } from './type';
-
-interface CreateFileParams extends Omit<UploadFileParams, 'url'> {
-  knowledgeBaseId?: string;
-  url: string;
-}
-
-export class ServerService implements IFileService {
-  createFile: IFileService['createFile'] = async (params, knowledgeBaseId) => {
-    return lambdaClient.file.createFile.mutate({ ...params, knowledgeBaseId } as CreateFileParams);
-  };
-
-  getFile: IFileService['getFile'] = async (id) => {
-    const item = await lambdaClient.file.findById.query({ id });
-
-    if (!item) {
-      throw new Error('file not found');
-    }
-
-    return { ...item, type: item.fileType };
-  };
-
-  removeFile: IFileService['removeFile'] = async (id) => {
-    await lambdaClient.file.removeFile.mutate({ id });
-  };
-
-  removeFiles: IFileService['removeFiles'] = async (ids) => {
-    await lambdaClient.file.removeFiles.mutate({ ids });
-  };
-
-  removeAllFiles: IFileService['removeAllFiles'] = async () => {
-    await lambdaClient.file.removeAllFiles.mutate();
-  };
-
-  getFiles = async (params: QueryFileListParams) => {
-    return lambdaClient.file.getFiles.query(params as QueryFileListSchemaType);
-  };
-
-  getFileItem = async (id: string) => {
-    return lambdaClient.file.getFileItemById.query({ id });
-  };
-
-  checkFileHash: IFileService['checkFileHash'] = async (hash) => {
-    return lambdaClient.file.checkFileHash.mutate({ hash });
-  };
-
-  removeFileAsyncTask = async (id: string, type: 'embedding' | 'chunk') => {
-    return lambdaClient.file.removeFileAsyncTask.mutate({ id, type });
-  };
-}

package/src/services/file/type.ts

@@ -1,13 +0,0 @@
-import { CheckFileHashResult, FileItem, UploadFileParams } from '@/types/files';
-
-export interface IFileService {
-  checkFileHash(hash: string): Promise<CheckFileHashResult>;
-  createFile(
-    file: UploadFileParams,
-    knowledgeBaseId?: string,
-  ): Promise<{ id: string; url: string }>;
-  getFile(id: string): Promise<FileItem>;
-  removeAllFiles(): Promise<any>;
-  removeFile(id: string): Promise<void>;
-  removeFiles(ids: string[]): Promise<void>;
-}

package/src/services/import/server.ts

@@ -1,133 +0,0 @@
-import { DefaultErrorShape } from '@trpc/server/unstable-core-do-not-import';
-
-import { lambdaClient } from '@/libs/trpc/client';
-import { uploadService } from '@/services/upload';
-import { useUserStore } from '@/store/user';
-import { ImportPgDataStructure } from '@/types/export';
-import { ImportStage, OnImportCallbacks } from '@/types/importer';
-import { uuid } from '@/utils/uuid';
-
-import { IImportService } from './type';
-
-export class ServerService implements IImportService {
-  importSettings: IImportService['importSettings'] = async (settings) => {
-    await useUserStore.getState().importAppSettings(settings);
-  };
-
-  importData: IImportService['importData'] = async (data, callbacks) => {
-    const handleError = (e: unknown) => {
-      callbacks?.onStageChange?.(ImportStage.Error);
-      const error = e as DefaultErrorShape;
-
-      callbacks?.onError?.({
-        code: error.data.code,
-        httpStatus: error.data.httpStatus,
-        message: error.message,
-        path: error.data.path,
-      });
-    };
-
-    const totalLength =
-      (data.messages?.length || 0) +
-      (data.sessionGroups?.length || 0) +
-      (data.sessions?.length || 0) +
-      (data.topics?.length || 0);
-
-    if (totalLength < 500) {
-      callbacks?.onStageChange?.(ImportStage.Importing);
-      const time = Date.now();
-      try {
-        const result = await lambdaClient.importer.importByPost.mutate({ data });
-        const duration = Date.now() - time;
-
-        callbacks?.onStageChange?.(ImportStage.Success);
-        callbacks?.onSuccess?.(result.results, duration);
-      } catch (e) {
-        handleError(e);
-      }
-
-      return;
-    }
-
-    await this.uploadData(data, { callbacks, handleError });
-  };
-
-  importPgData: IImportService['importPgData'] = async (
-    data: ImportPgDataStructure,
-    {
-      callbacks,
-    }: {
-      callbacks?: OnImportCallbacks;
-      overwriteExisting?: boolean;
-    } = {},
-  ): Promise<void> => {
-    const handleError = (e: unknown) => {
-      callbacks?.onStageChange?.(ImportStage.Error);
-      const error = e as DefaultErrorShape;
-
-      callbacks?.onError?.({
-        code: error.data.code,
-        httpStatus: error.data.httpStatus,
-        message: error.message,
-        path: error.data.path,
-      });
-    };
-
-    const totalLength = Object.values(data.data)
-      .map((d) => d.length)
-      .reduce((a, b) => a + b, 0);
-
-    if (totalLength < 500) {
-      callbacks?.onStageChange?.(ImportStage.Importing);
-      const time = Date.now();
-      try {
-        const result = await lambdaClient.importer.importPgByPost.mutate(data);
-        const duration = Date.now() - time;
-
-        callbacks?.onStageChange?.(ImportStage.Success);
-        callbacks?.onSuccess?.(result.results, duration);
-      } catch (e) {
-        handleError(e);
-      }
-
-      return;
-    }
-
-    await this.uploadData(data, { callbacks, handleError });
-  };
-
-  private uploadData = async (
-    data: object,
-    { callbacks, handleError }: { callbacks?: OnImportCallbacks; handleError: (e: unknown) => any },
-  ) => {
-    // if the data is too large, upload it to S3 and upload by file
-    const filename = `${uuid()}.json`;
-
-    let pathname;
-    try {
-      callbacks?.onStageChange?.(ImportStage.Uploading);
-      const result = await uploadService.uploadDataToS3(data, {
-        filename,
-        onProgress: (status, state) => {
-          callbacks?.onFileUploading?.(state);
-        },
-        pathname: `import_config/${filename}`,
-      });
-      pathname = result.data.path;
-      console.log(pathname);
-    } catch {
-      throw new Error('Upload Error');
-    }
-
-    callbacks?.onStageChange?.(ImportStage.Importing);
-    const time = Date.now();
-    try {
-      const result = await lambdaClient.importer.importByFile.mutate({ pathname });
-      const duration = Date.now() - time;
-      callbacks?.onStageChange?.(ImportStage.Success);
-      callbacks?.onSuccess?.(result.results, duration);
-    } catch (e) {
-      handleError(e);
-    }
-  };
-}

package/src/services/import/type.ts

@@ -1,17 +0,0 @@
-import { ImportPgDataStructure } from '@/types/export';
-import { ImporterEntryData, OnImportCallbacks } from '@/types/importer';
-import { UserSettings } from '@/types/user/settings';
-
-export interface IImportService {
-  importData(data: ImporterEntryData, callbacks?: OnImportCallbacks): Promise<void>;
-
-  importPgData(
-    data: ImportPgDataStructure,
-    options?: {
-      callbacks?: OnImportCallbacks;
-      overwriteExisting?: boolean;
-    },
-  ): Promise<void>;
-
-  importSettings(settings: UserSettings): Promise<void>;
-}