refa provider

src/account-pool/account-pool.service.ts

@@ -64,7 +64,7 @@ export class AccountPoolService
     this.ChatGPTAPIBrowserConstructor = (
       await eval("import('chatgpt3')")
     ).ChatGPTAPIBrowser;
-    this.accountInfos = await this.accountProvider.getAccounts();
+    this.accountInfos = await this.accountProvider.get();
     this.accountInfos.forEach((a) => this.initAccount(a));
   }
 

src/account-provider/account-provider.service.ts

 import { Injectable } from '@nestjs/common';
-import { ConfigService } from '@nestjs/config';
 import { OpenAIAccount } from '../utility/config';
-import { fetchDatasource } from '../datasource/datasource';
+import { BaseProvider } from '../datasource/base-provider';
+import { ConfigService } from '@nestjs/config';
 
 @Injectable()
-export class AccountProviderService {
-  constructor(private config: ConfigService) {}
-  async getAccounts() {
-    return (
-      (await fetchDatasource<OpenAIAccount[]>(this.config.get('accounts'))) ||
-      []
-    );
+export class AccountProviderService extends BaseProvider<OpenAIAccount[]> {
+  constructor(config: ConfigService) {
+    super(config, 'accounts');
   }
-
   async writeBack(
     accounts: OpenAIAccount[],
     type: 'add' | 'remove',

src/datasource/base-provider.ts

+import { ConfigService } from '@nestjs/config';
+import { DatasourceConfig, Datasources } from './datasource';
+
+export class BaseProvider<T> {
+  constructor(protected config: ConfigService, protected key: string) {}
+
+  async get(): Promise<T> {
+    const config = this.config.get<DatasourceConfig<T>>(this.key);
+    if (!config) {
+      return;
+    }
+    if (Array.isArray(config)) {
+      // legacy config
+      return config as T;
+    }
+    const Datasource = Datasources.get(config.type);
+    if (!Datasource) {
+      throw new Error(`Unknown datasource type: ${config.type}`);
+    }
+    return new Datasource(config.config).getData();
+  }
+}

src/datasource/datasource.ts

@@ -6,7 +6,10 @@ export interface DatasourceConfigMap<T> {
   static: T;
   api: { endpoint: string; headers: Record<string, string | number> };
 }
-export interface DatasourceConfig<T, K extends keyof DatasourceConfigMap<T>> {
+export interface DatasourceConfig<
+  T,
+  K extends keyof DatasourceConfigMap<T> = keyof DatasourceConfigMap<T>,
+> {
   type: K;
   config: DatasourceConfigMap<T>[K];
 }
@@ -20,20 +23,3 @@ export const Datasources = new Map<
 
 Datasources.set('static', StaticDatasource as any);
 Datasources.set('api', ApiDatasource as any);
-
-export async function fetchDatasource<T>(
-  config: DatasourceConfig<T, keyof DatasourceConfigMap<any>>,
-): Promise<T> {
-  if (!config) {
-    return;
-  }
-  if (Array.isArray(config)) {
-    // legacy config
-    return config as any;
-  }
-  const Datasource = Datasources.get(config.type);
-  if (!Datasource) {
-    throw new Error(`Unknown datasource type: ${config.type}`);
-  }
-  return new Datasource(config.config).getData();
-}

src/davinci/davinci.service.ts

@@ -19,7 +19,7 @@ export class DavinciService extends ConsoleLogger implements OnModuleInit {
   private pointer = 0;
   private async getKey(exclude: string[] = []) {
     const excludeSet = new Set(exclude);
-    const keys = (await this.keyProvider.getKeys()).filter(
+    const keys = (await this.keyProvider.get()).filter(
       (key) => !excludeSet.has(key),
     );
     if (!keys.length) {
@@ -28,7 +28,10 @@ export class DavinciService extends ConsoleLogger implements OnModuleInit {
         'No available accounts.',
       ).toException();
     }
-    const index = this.pointer++ % keys.length;
+    if (this.pointer >= keys.length) {
+      this.pointer = 0;
+    }
+    const index = this.pointer++;
     return keys[index];
   }
 

src/key-provider/key-provider.service.ts

 import { Injectable } from '@nestjs/common';
+import { BaseProvider } from '../datasource/base-provider';
 import { ConfigService } from '@nestjs/config';
-import { fetchDatasource } from '../datasource/datasource';
 
 @Injectable()
-export class KeyProviderService {
-  constructor(private config: ConfigService) {}
-  async getKeys() {
-    return (await fetchDatasource<string[]>(this.config.get('apiKeys'))) || [];
+export class KeyProviderService extends BaseProvider<string[]> {
+  constructor(config: ConfigService) {
+    super(config, 'apiKeys');
   }
 }

src/proxy-pool/proxy-pool.service.ts

@@ -7,7 +7,7 @@ export class ProxyPoolService {
   constructor(private proxyProvider: ProxyProviderService) {}
 
   async getProxy() {
-    const proxies = await this.proxyProvider.getProxies();
+    const proxies = await this.proxyProvider.get();
     if (!proxies?.length) {
       return;
     }

src/proxy-provider/proxy-provider.service.ts

 import { Injectable } from '@nestjs/common';
+import { BaseProvider } from '../datasource/base-provider';
 import { ConfigService } from '@nestjs/config';
-import { fetchDatasource } from '../datasource/datasource';
 
 @Injectable()
-export class ProxyProviderService {
-  constructor(private config: ConfigService) {}
-  async getProxies() {
-    return (await fetchDatasource<string[]>(this.config.get('proxies'))) || [];
+export class ProxyProviderService extends BaseProvider<string[]> {
+  constructor(config: ConfigService) {
+    super(config, 'proxies');
   }
 }