// 设计一个全局的modle 然后别的地方再饮用 里面的service 的时候就不需要在自己的module 去导入了
// 官方文档有写
 
// 由于 node-zk 是异步 所以我也使用 异步 模块来实现
 
@Global()
@Module({
  providers: [
    ZKService,
    {
      provide: ZOOKEEPER_CLIENT,
      useFactory: async (optionsProvider: ConfigService) => {
        const zookeeperClient = await getZKClient({
          url: optionsProvider.get(EnumInterInitConfigKey.zkHost),
        });
        return zookeeperClient;
      },
      inject: [ConfigService],
    },
  ],
  exports: [ZKService],
})
//.....
 const getClient = async (options: any) => {
        const {url, ...opt} = options;
 
        const client = zookeeper.createClient(url, opt);
 
        client.once('connected', () => {
          Logger.log('zk connected success...');
        });
 
        client.on('state', (state: string) => {
          const sessionId = client.getSessionId().toString('hex');
        });
 
        client.connect();
        return client;
      };
 
// 这样写的话，用的时候直接丢就好啦
@Global()
@Module({
  imports: [
    ConfigModule.forRoot({
      isGlobal: true,
      expandVariables: true,
      load: [configuration],
    }),
    FaqModule,
    ZKModule.forRootAsync(),
  ],
  exports: [FaqModule],
})
export class CoreModule {}
 
// 只需要在用的地方 直接用ZkServic 就ok ，但是这样不够优雅，于是进化成啦🧬 这样 把它内聚一下
 
@Global()
@Module({
  providers: [ZKService],
  exports: [ZKService],
})
export class ZKModule implements OnModuleDestroy {
  static forRootAsync(): DynamicModule {
    return {
      module: ZKModule,
      imports: [],
      providers: [ZKService, this.createClient()],
    };
  }
  constructor(
    @Inject(ZOOKEEPER_CLIENT)
    private readonly zkCk: any,
  ) {}
 
  onModuleDestroy() {
    this.zkCk.close();
  }
 
  private static createClient = (): Provider => ({
    provide: ZOOKEEPER_CLIENT,
    useFactory: async (optionsProvider: ConfigService) => {
      const getClient = async (options: any) => {
        const {url, ...opt} = options;
 
        const client = zookeeper.createClient(url, opt);
 
        client.once('connected', () => {
          Logger.log('zk connected success...');
        });
 
        client.on('state', (state: string) => {
          const sessionId = client.getSessionId().toString('hex');
        });
 
        client.connect();
        return client;
      };
 
      const zookeeperClient = await getClient({
        url: optionsProvider.get(EnumInterInitConfigKey.zkHost),
      });
 
      return zookeeperClient;
    },
    inject: [ConfigService],
  });
}
 
// 用的地方就变成啦 forootAsync 
 ZKModule.forRootAsync(),
 
// 其他的redis 还是mq 都可以这样用 都是这样用的
   

import { ClusterModule, ClusterModuleOptions } from '@liaoliaots/nestjs-redis';
.....
  ClusterModule.forRootAsync({
      imports: [ConfigModule, ZooKeeperModule],
      inject: [MpsConfigService, MpsZKService],
      useFactory: async (
        configService: MpsConfigService,
        zkService: MpsZKService,
      ): Promise<ClusterModuleOptions> => {
        const data = JSON.parse(
          (await zkService.getData(configService.zooKeeperRedisNode)) as string,
        ) as ZooKeeperRedisResponse[];
        const cluster =
          process.env.K0S_CLUSTER_LOCATION ||
          configService.redisClusterLocationDefault;
        const { Host, Password } = data.find((_) => _.Name === cluster)!;
        const nodes = Host.split(',').map((_) => ({
          host: _.split(':')[0],
          port: Number(_.split(':')[1]),
        }));
 
        return {
          readyLog: true,
          config: {
            nodes,
            redisOptions: { password: Password },
            onClientCreated(client) {
              client.on('error', (err) => {
                Logger.error(err, 'CoreModule');
              });
              client.on('ready', () => {
                Logger.log('Connected to Redis.', 'CoreModule');
              });
            },
          },
        };
      },
    }),
  // 用的时候直接引入 第三方写的 
  import { ClusterService } from '@liaoliaots/nestjs-redis'; 就ok ，它会自动租册
 
// 比如说mq是没有的，怎么办？也很简单，使用动态模块 的特性 自己搞一个就好了
    MessageQueueModule.forRootAsync(), 具体代码就不写啦
      

const express = require('express')
const axios = require('axios')
const bodyParser = require('body-parser')
const { createProxyMiddleware } = require('http-proxy-middleware')
 
 
const app = express();
const port = 3000;    //端口号
app.use(bodyParser.urlencoded({ extended: false }))
app.use(bodyParser.json())
 
// cors
// 允许跨域
app.all('*', function(req, res, next) {
  res.header("Access-Control-Allow-Origin", '*');
  res.header("Access-Control-Allow-Headers", "Content-Type,Content-Length, Authorization, Accept,X-Requested-With");
  res.header("Access-Control-Allow-Methods","PUT,POST,GET,DELETE,OPTIONS");
  res.header("Access-Control-Allow-Credentials","true");
  if(req.method === "OPTIONS") res.send(200);
  else  next();
});
 
// `http://localhost:3000${initialState.Config.Technique?.ChatBotConnection?.HubUrl}` 直链线上
 
// proxy init API
app.post('*',  async (req, res) => {
  try {
    const v = await axios.post('https://chat.newegg.com' + req.url, req.body, {
      headers: {
        "cookie": "NID=725z2Q2Q0M72721j9D; NVTC=248326808.0001.febfd2a17.1672812596.1673491265.1673493057.6; NV_NVTCTIMESTAMP=1673493330"
      }
   })
 
   res.send(v.data)
  } catch (error) {
   console.log('error => ', error);
    res.send(error.info)
  }
})
 
// proxy ws 
app.use("/onlinechatservice/connection/chatwithbot",
    createProxyMiddleware({
      target: 'https://chat.newegg.com',
      changeOrigin: true,
      ws:true,
    })
);
 
 
app.listen(port, () => {
  console.log(`Example app listening at http://localhost:${port}`)
})