@jayfong/x-server 2.12.1 → 2.12.3

package/lib/_cjs/cli/env_util.js

@@ -172,12 +172,11 @@ class EnvUtil {
           NODE_ENV: 'development' | 'production';
           ${envs.map(env => (0, _vtils.dedent)`
                 ${env.comment ? (0, _vtils.dedent)`
-                      /**
-                       ${env.comment.split(/[\r\n]+/g).map(line => `* ${line.trim()}`).join('\n*\n')}
-                       */
-                    ` : ''}
-                ${env.key}: ${// TODO: 优化类型推断
-    Array.isArray(env.value) ? `Array<${typeof env.value[0]}>` : typeof env.value};
+                        /**
+                         ${env.comment.split(/[\r\n]+/g).map(line => `* ${line.trim()}`).join('\n*\n')}
+                        */
+                      ` : ''}
+                ${env.key}: ${Array.isArray(env.value) ? `Array<${env.value[0] ? typeof env.value[0] : 'any'}>` : typeof env.value};
               `).join('\n')}
         }
       }

package/lib/_cjs/index.js

@@ -194,6 +194,14 @@ Object.keys(_dispose).forEach(function (key) {
   exports[key] = _dispose[key];
 });
 
+var _emoji = require("./services/emoji");
+
+Object.keys(_emoji).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _emoji[key]) return;
+  exports[key] = _emoji[key];
+});
+
 var _jwt = require("./services/jwt");
 
 Object.keys(_jwt).forEach(function (key) {
@@ -242,6 +250,14 @@ Object.keys(_redis).forEach(function (key) {
   exports[key] = _redis[key];
 });
 
+var _request = require("./services/request");
+
+Object.keys(_request).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _request[key]) return;
+  exports[key] = _request[key];
+});
+
 var _sensitive_words = require("./services/sensitive_words");
 
 Object.keys(_sensitive_words).forEach(function (key) {

package/lib/_cjs/services/request.js

@@ -0,0 +1,221 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+exports.__esModule = true;
+exports.RequestService = exports.RequestFormUrlencoded = exports.RequestFormStream = exports.RequestFormData = void 0;
+
+var _formData = _interopRequireDefault(require("form-data"));
+
+var _formstream = _interopRequireDefault(require("formstream"));
+
+var _got = _interopRequireDefault(require("got"));
+
+var _proxyAgent = require("proxy-agent");
+
+class RequestFormUrlencoded extends URLSearchParams {}
+
+exports.RequestFormUrlencoded = RequestFormUrlencoded;
+
+class RequestFormData extends _formData.default {
+  constructor(cb) {
+    super();
+
+    if (cb) {
+      cb(this);
+    }
+  }
+
+}
+
+exports.RequestFormData = RequestFormData;
+
+class RequestFormStream extends _formstream.default {
+  constructor(cb) {
+    super();
+
+    if (cb) {
+      cb(this);
+    }
+  }
+
+}
+
+exports.RequestFormStream = RequestFormStream;
+
+class RequestService {
+  constructor(options) {
+    this.options = options;
+    this.serviceName = 'request';
+  }
+
+  static getGotOptions(options, responseType) {
+    const gotOptions = {
+      responseType: responseType === 'stream' ? undefined : responseType,
+      rejectUnauthorized: false,
+      isStream: responseType === 'stream'
+    };
+
+    if (options.headers) {
+      gotOptions.headers = options.headers;
+    }
+
+    if (options.followRedirect != null) {
+      gotOptions.followRedirect = options.followRedirect;
+    }
+
+    if (options.timeoutMs) {
+      gotOptions.timeout = options.timeoutMs;
+    }
+
+    if (options.proxyUrl) {
+      const proxyAgent = new _proxyAgent.ProxyAgent({
+        getProxyForUrl: () => options.proxyUrl
+      });
+      gotOptions.agent = {
+        http: proxyAgent,
+        https: proxyAgent,
+        http2: proxyAgent
+      };
+    }
+
+    if (options.encoding) {
+      gotOptions.encoding = options.encoding;
+    }
+
+    if (options.cookieJar) {
+      gotOptions.cookieJar = options.cookieJar;
+    }
+
+    return gotOptions;
+  }
+
+  static getRaw(options, responseType) {
+    let url = options.url;
+
+    if (options.data) {
+      const _url = new URL(url);
+
+      Object.keys(options.data).forEach(key => {
+        _url.searchParams.set(key, options.data[key]);
+      });
+      url = _url.toString();
+    }
+
+    const res = (0, _got.default)({
+      url: url,
+      method: 'GET',
+      ...this.getGotOptions(options, responseType || 'buffer')
+    });
+
+    if (responseType === 'stream') {
+      return res;
+    }
+
+    return res.then(res => ({
+      status: res.statusCode,
+      headers: res.headers,
+      data: res.body
+    }));
+  }
+
+  static postRaw(options, responseType) {
+    const gotOptions = this.getGotOptions(options, responseType || 'buffer');
+
+    if (responseType === 'stream' && options.data instanceof _formstream.default) {
+      gotOptions.headers = options.data.headers(gotOptions.headers);
+    }
+
+    const res = (0, _got.default)({
+      url: options.url,
+      method: 'POST',
+      ...(options.data == null ? {
+        body: ''
+      } : options.data instanceof _formData.default ? {
+        body: options.data
+      } : options.data instanceof URLSearchParams ? {
+        form: options.data
+      } : options.data instanceof _formstream.default ? {} : {
+        json: options.data
+      }),
+      ...gotOptions
+    });
+
+    if (responseType === 'stream' && options.data instanceof _formstream.default) {
+      options.data.pipe(res);
+    }
+
+    if (responseType === 'stream') {
+      return res;
+    }
+
+    return res.then(res => ({
+      status: res.statusCode,
+      headers: res.headers,
+      data: res.body
+    }));
+  }
+
+  static async getText(options) {
+    return this.getRaw(options, 'text');
+  }
+
+  static async postText(options) {
+    return this.postRaw(options, 'text');
+  }
+
+  static async get(options) {
+    return this.getRaw(options, 'json');
+  }
+
+  static async post(options) {
+    return this.postRaw(options, 'json');
+  }
+
+  static getStream(options) {
+    return this.getRaw(options, 'stream');
+  }
+
+  static postStream(options) {
+    return this.postRaw(options, 'stream');
+  }
+
+  getRaw(options, responseType) {
+    return RequestService.getRaw({ ...this.options,
+      ...options
+    }, responseType);
+  }
+
+  postRaw(options, responseType) {
+    return RequestService.postRaw({ ...this.options,
+      ...options
+    }, responseType);
+  }
+
+  async getText(options) {
+    return this.getRaw(options, 'text');
+  }
+
+  async postText(options) {
+    return this.postRaw(options, 'text');
+  }
+
+  async get(options) {
+    return this.getRaw(options, 'json');
+  }
+
+  async post(options) {
+    return this.postRaw(options, 'json');
+  }
+
+  getStream(options) {
+    return this.getRaw(options, 'stream');
+  }
+
+  postStream(options) {
+    return this.postRaw(options, 'stream');
+  }
+
+}
+
+exports.RequestService = RequestService;

package/lib/_cjs/types/_formstream.js

@@ -0,0 +1 @@
+"use strict";

package/lib/_cjs/x.js

@@ -17,6 +17,8 @@ var _emoji = require("./services/emoji");
 
 var _log = require("./services/log");
 
+var _request = require("./services/request");
+
 const env = JSON.parse(process.env.X_SERVER_ENVS || '{}');
 const x = {
   appId: env.APP_ID,
@@ -35,4 +37,4 @@ _fsExtra.default.ensureDirSync(x.dataDir);
 
 x.register(new _dispose.DisposeService({
   disposeOnExit: true
-}), new _log.LogService(), new _emoji.EmojiService());
+}), new _log.LogService(), new _emoji.EmojiService(), new _request.RequestService());

package/lib/cli/env_util.js

@@ -158,12 +158,11 @@ export class EnvUtil {
           NODE_ENV: 'development' | 'production';
           ${envs.map(env => dedent`
                 ${env.comment ? dedent`
-                      /**
-                       ${env.comment.split(/[\r\n]+/g).map(line => `* ${line.trim()}`).join('\n*\n')}
-                       */
-                    ` : ''}
-                ${env.key}: ${// TODO: 优化类型推断
-    Array.isArray(env.value) ? `Array<${typeof env.value[0]}>` : typeof env.value};
+                        /**
+                         ${env.comment.split(/[\r\n]+/g).map(line => `* ${line.trim()}`).join('\n*\n')}
+                        */
+                      ` : ''}
+                ${env.key}: ${Array.isArray(env.value) ? `Array<${env.value[0] ? typeof env.value[0] : 'any'}>` : typeof env.value};
               `).join('\n')}
         }
       }

package/lib/index.d.ts

@@ -22,12 +22,14 @@ export * from './services/cache';
 export * from './services/captcha';
 export * from './services/dingtalk';
 export * from './services/dispose';
+export * from './services/emoji';
 export * from './services/jwt';
 export * from './services/log';
 export * from './services/mail';
 export * from './services/pay';
 export * from './services/rate_limit';
 export * from './services/redis';
+export * from './services/request';
 export * from './services/sensitive_words';
 export * from './types/index';
 export * from './x';

package/lib/index.js

@@ -1,4 +1,4 @@
-// @index(['./**/*.ts', '!**/*.test.ts', '!./cli/**', '!./client_helper.ts'], f => `export * from '${f.path}'`)
+// @index(['./**/*.ts', '!**/*.test.ts', '!./cli/**', '!./client_helper.ts', '!**/_*'], f => `export * from '${f.path}'`)
 export * from "./core/define_bus";
 export * from "./core/define_cron";
 export * from "./core/define_handler";
@@ -23,12 +23,14 @@ export * from "./services/cache";
 export * from "./services/captcha";
 export * from "./services/dingtalk";
 export * from "./services/dispose";
+export * from "./services/emoji";
 export * from "./services/jwt";
 export * from "./services/log";
 export * from "./services/mail";
 export * from "./services/pay";
 export * from "./services/rate_limit";
 export * from "./services/redis";
+export * from "./services/request";
 export * from "./services/sensitive_words";
 export * from "./types/index";
 export * from "./x"; // @endindex

package/lib/services/request.d.ts

@@ -0,0 +1,92 @@
+/// <reference types="node" />
+import FormData from 'form-data';
+import FormStream from 'formstream';
+import Request from 'got/dist/source/core';
+import { BaseService } from './base';
+import { CookieJar } from 'tough-cookie';
+export interface RequestServiceOptions {
+    proxyUrl?: string;
+    timeoutMs?: number;
+    headers?: Record<string, any>;
+    /**
+     * @default true
+     */
+    followRedirect?: boolean;
+    /**
+     * @default "utf-8"
+     */
+    encoding?: BufferEncoding;
+    cookieJar?: CookieJar;
+}
+export interface RequestServiceResponse<T> {
+    status: number;
+    headers: Record<string, any>;
+    data: T;
+}
+export interface RequestServiceGetOptions extends RequestServiceOptions {
+    url: string;
+    data?: Record<string, any>;
+}
+export interface RequestServicePostOptions extends RequestServiceOptions {
+    url: string;
+    data?: Record<string, any> | FormData | URLSearchParams;
+}
+export interface RequestServiceGetStreamOptions extends RequestServiceOptions {
+    url: string;
+    data?: Record<string, any>;
+}
+export interface RequestServicePostStreamOptions extends RequestServiceOptions {
+    url: string;
+    data?: Record<string, any> | FormData | URLSearchParams | FormStream;
+}
+export declare class RequestFormUrlencoded extends URLSearchParams {
+}
+export declare class RequestFormData extends FormData {
+    constructor(cb?: (formData: FormData) => FormData);
+}
+export declare class RequestFormStream extends FormStream {
+    constructor(cb?: (formStream: FormStream) => FormStream);
+}
+export declare class RequestService implements BaseService {
+    private options?;
+    serviceName: string;
+    constructor(options?: RequestServiceOptions);
+    private static getGotOptions;
+    static getRaw(options: RequestServiceGetStreamOptions): Promise<RequestServiceResponse<Buffer>>;
+    static getRaw(options: RequestServiceGetStreamOptions, responseType: 'buffer'): Promise<RequestServiceResponse<Buffer>>;
+    static getRaw(options: RequestServiceGetStreamOptions, responseType: 'text'): Promise<RequestServiceResponse<string>>;
+    static getRaw<T>(options: RequestServiceGetStreamOptions, responseType: 'json'): Promise<RequestServiceResponse<T>>;
+    static getRaw(options: RequestServiceGetStreamOptions, responseType: 'stream'): Request;
+    static postRaw(options: RequestServicePostOptions): Promise<RequestServiceResponse<Buffer>>;
+    static postRaw(options: RequestServicePostOptions, responseType: 'buffer'): Promise<RequestServiceResponse<Buffer>>;
+    static postRaw(options: RequestServicePostOptions, responseType: 'text'): Promise<RequestServiceResponse<string>>;
+    static postRaw<T>(options: RequestServicePostOptions, responseType: 'json'): Promise<RequestServiceResponse<T>>;
+    static postRaw(options: RequestServicePostOptions, responseType: 'stream'): Request;
+    static getText(options: RequestServiceGetStreamOptions): Promise<RequestServiceResponse<string>>;
+    static postText(options: RequestServicePostOptions): Promise<RequestServiceResponse<string>>;
+    static get<T>(options: RequestServiceGetStreamOptions): Promise<RequestServiceResponse<T>>;
+    static post<T>(options: RequestServicePostOptions): Promise<RequestServiceResponse<T>>;
+    static getStream(options: RequestServiceGetOptions): Request;
+    static postStream(options: RequestServicePostStreamOptions): Request;
+    getRaw(options: RequestServiceGetStreamOptions): Promise<RequestServiceResponse<Buffer>>;
+    getRaw(options: RequestServiceGetStreamOptions, responseType: 'buffer'): Promise<RequestServiceResponse<Buffer>>;
+    getRaw(options: RequestServiceGetStreamOptions, responseType: 'text'): Promise<RequestServiceResponse<string>>;
+    getRaw<T>(options: RequestServiceGetStreamOptions, responseType: 'json'): Promise<RequestServiceResponse<T>>;
+    getRaw(options: RequestServiceGetStreamOptions, responseType: 'stream'): Request;
+    postRaw(options: RequestServicePostOptions): Promise<RequestServiceResponse<Buffer>>;
+    postRaw(options: RequestServicePostOptions, responseType: 'buffer'): Promise<RequestServiceResponse<Buffer>>;
+    postRaw(options: RequestServicePostOptions, responseType: 'text'): Promise<RequestServiceResponse<string>>;
+    postRaw<T>(options: RequestServicePostOptions, responseType: 'json'): Promise<RequestServiceResponse<T>>;
+    postRaw(options: RequestServicePostOptions, responseType: 'stream'): Request;
+    getText(options: RequestServiceGetStreamOptions): Promise<RequestServiceResponse<string>>;
+    postText(options: RequestServicePostOptions): Promise<RequestServiceResponse<string>>;
+    get<T>(options: RequestServiceGetStreamOptions): Promise<RequestServiceResponse<T>>;
+    post<T>(options: RequestServicePostOptions): Promise<RequestServiceResponse<T>>;
+    getStream(options: RequestServiceGetOptions): Request;
+    postStream(options: RequestServicePostStreamOptions): Request;
+}
+declare module '../x' {
+    interface X {
+        request: RequestService;
+    }
+}

package/lib/services/request.js

@@ -0,0 +1,199 @@
+import FormData from 'form-data';
+import FormStream from 'formstream';
+import got from 'got';
+import { ProxyAgent } from 'proxy-agent';
+export class RequestFormUrlencoded extends URLSearchParams {}
+export class RequestFormData extends FormData {
+  constructor(cb) {
+    super();
+
+    if (cb) {
+      cb(this);
+    }
+  }
+
+}
+export class RequestFormStream extends FormStream {
+  constructor(cb) {
+    super();
+
+    if (cb) {
+      cb(this);
+    }
+  }
+
+}
+export class RequestService {
+  constructor(options) {
+    this.options = options;
+    this.serviceName = 'request';
+  }
+
+  static getGotOptions(options, responseType) {
+    const gotOptions = {
+      responseType: responseType === 'stream' ? undefined : responseType,
+      rejectUnauthorized: false,
+      isStream: responseType === 'stream'
+    };
+
+    if (options.headers) {
+      gotOptions.headers = options.headers;
+    }
+
+    if (options.followRedirect != null) {
+      gotOptions.followRedirect = options.followRedirect;
+    }
+
+    if (options.timeoutMs) {
+      gotOptions.timeout = options.timeoutMs;
+    }
+
+    if (options.proxyUrl) {
+      const proxyAgent = new ProxyAgent({
+        getProxyForUrl: () => options.proxyUrl
+      });
+      gotOptions.agent = {
+        http: proxyAgent,
+        https: proxyAgent,
+        http2: proxyAgent
+      };
+    }
+
+    if (options.encoding) {
+      gotOptions.encoding = options.encoding;
+    }
+
+    if (options.cookieJar) {
+      gotOptions.cookieJar = options.cookieJar;
+    }
+
+    return gotOptions;
+  }
+
+  static getRaw(options, responseType) {
+    let url = options.url;
+
+    if (options.data) {
+      const _url = new URL(url);
+
+      Object.keys(options.data).forEach(key => {
+        _url.searchParams.set(key, options.data[key]);
+      });
+      url = _url.toString();
+    }
+
+    const res = got({
+      url: url,
+      method: 'GET',
+      ...this.getGotOptions(options, responseType || 'buffer')
+    });
+
+    if (responseType === 'stream') {
+      return res;
+    }
+
+    return res.then(res => ({
+      status: res.statusCode,
+      headers: res.headers,
+      data: res.body
+    }));
+  }
+
+  static postRaw(options, responseType) {
+    const gotOptions = this.getGotOptions(options, responseType || 'buffer');
+
+    if (responseType === 'stream' && options.data instanceof FormStream) {
+      gotOptions.headers = options.data.headers(gotOptions.headers);
+    }
+
+    const res = got({
+      url: options.url,
+      method: 'POST',
+      ...(options.data == null ? {
+        body: ''
+      } : options.data instanceof FormData ? {
+        body: options.data
+      } : options.data instanceof URLSearchParams ? {
+        form: options.data
+      } : options.data instanceof FormStream ? {} : {
+        json: options.data
+      }),
+      ...gotOptions
+    });
+
+    if (responseType === 'stream' && options.data instanceof FormStream) {
+      options.data.pipe(res);
+    }
+
+    if (responseType === 'stream') {
+      return res;
+    }
+
+    return res.then(res => ({
+      status: res.statusCode,
+      headers: res.headers,
+      data: res.body
+    }));
+  }
+
+  static async getText(options) {
+    return this.getRaw(options, 'text');
+  }
+
+  static async postText(options) {
+    return this.postRaw(options, 'text');
+  }
+
+  static async get(options) {
+    return this.getRaw(options, 'json');
+  }
+
+  static async post(options) {
+    return this.postRaw(options, 'json');
+  }
+
+  static getStream(options) {
+    return this.getRaw(options, 'stream');
+  }
+
+  static postStream(options) {
+    return this.postRaw(options, 'stream');
+  }
+
+  getRaw(options, responseType) {
+    return RequestService.getRaw({ ...this.options,
+      ...options
+    }, responseType);
+  }
+
+  postRaw(options, responseType) {
+    return RequestService.postRaw({ ...this.options,
+      ...options
+    }, responseType);
+  }
+
+  async getText(options) {
+    return this.getRaw(options, 'text');
+  }
+
+  async postText(options) {
+    return this.postRaw(options, 'text');
+  }
+
+  async get(options) {
+    return this.getRaw(options, 'json');
+  }
+
+  async post(options) {
+    return this.postRaw(options, 'json');
+  }
+
+  getStream(options) {
+    return this.getRaw(options, 'stream');
+  }
+
+  postStream(options) {
+    return this.postRaw(options, 'stream');
+  }
+
+}

package/lib/types/_formstream.d.ts

@@ -0,0 +1,49 @@
+/// <reference types="node" />
+/// <reference types="node" />
+declare module 'formstream' {
+    import { Stream, Readable } from 'stream';
+    class FormStream extends Stream {
+        /**
+         * Add a normal field to the form.
+         *
+         * @param name Name of field
+         * @param value Value of field
+         */
+        field(name: string, value: string): this;
+        /**
+         * Add a local file to be uploaded to the form.
+         *
+         * @param name Name of file field
+         * @param filepath Local path of the file to be uploaded
+         * @param filename Name of the file (will be the base name of filepath if empty)
+         * @param filesize Size of the file (will not generate Content-Length header if not specified)
+         */
+        file(name: string, filepath: string, filename?: string, filesize?: number): this;
+        /**
+         * Add a buffer as a file to upload.
+         *
+         * @param name Name of field
+         * @param buffer The buffer to be uploaded
+         * @param filename The file name that tells the remote server
+         * @param contentType Content-Type (aka. MIME Type) of content (will be infered with filename if empty)
+         */
+        buffer(name: string, buffer: Buffer, filename: string, contentType?: string): this;
+        /**
+         * Add a readable stream as a file to upload. Event 'error' will be emitted if an error occured.
+         *
+         * @param name Name of field
+         * @param stream A readable stream to be piped
+         * @param filename The file name that tells the remote server
+         * @param contentType Content-Type (aka. MIME Type) of content (will be infered with filename if empty)
+         * @param size Size of the stream (will not generate Content-Length header if not specified)
+         */
+        stream(name: string, stream: Readable, filename: string, contentType?: string, size?: number): this;
+        /**
+         * Get headers for the request.
+         *
+         * @param additionalHeaders Additional headers
+         */
+        headers(additionalHeaders?: Record<string, any>): Record<string, any>;
+    }
+    export = FormStream;
+}

package/lib/x.d.ts

@@ -3,6 +3,7 @@ import { BaseService } from './services/base';
 import './services/dispose';
 import './services/emoji';
 import './services/log';
+import './services/request';
 export interface X {
     readonly appId: string;
     readonly env: NodeJS.ProcessEnv;

package/lib/x.js

@@ -4,6 +4,7 @@ import path from 'path';
 import { DisposeService } from "./services/dispose";
 import { EmojiService } from "./services/emoji";
 import { LogService } from "./services/log";
+import { RequestService } from "./services/request";
 const env = JSON.parse(process.env.X_SERVER_ENVS || '{}');
 export const x = {
   appId: env.APP_ID,
@@ -19,4 +20,4 @@ export const x = {
 fs.ensureDirSync(x.dataDir);
 x.register(new DisposeService({
   disposeOnExit: true
-}), new LogService(), new EmojiService());
+}), new LogService(), new EmojiService(), new RequestService());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jayfong/x-server",
-  "version": "2.12.1",
+  "version": "2.12.3",
   "license": "ISC",
   "sideEffects": false,
   "main": "lib/_cjs/index.js",
@@ -54,7 +54,10 @@
     "exit-hook": "^2.2.1",
     "fast-xml-parser": "^4.2.5",
     "fastify": "^4.19.2",
+    "form-data": "^4.0.0",
+    "formstream": "^1.2.0",
     "fs-extra": "^10.0.1",
+    "get-port": "^7.0.0",
     "globby": "^11",
     "got": "^11.8.2",
     "http-errors": "^2.0.0",
@@ -68,9 +71,11 @@
     "nodemailer": "^6.7.3",
     "pino-pretty": "^10.0.1",
     "prisma": "^4.8.0",
+    "proxy-agent": "^6.2.2",
     "select-run": "^1.1.2",
     "supports-color": "^8",
     "svg-captcha": "^1.4.0",
+    "tough-cookie": "^4.1.3",
     "ts-morph": "^12.2.0",
     "utf-8-validate": "^5.0.9",
     "vscode-generate-index-standalone": "^1.7.1",
@@ -95,6 +100,7 @@
     "node-fetch": "^3.3.1",
     "npm-check-updates": "^12.5.9",
     "prettier": "^2.8.8",
+    "proxy": "^2.1.1",
     "standard-version": "^9.3.2",
     "typescript": "^5.1.6",
     "typescript-snapshots-plugin": "^1.7.0"