@jayfong/x-server 1.10.3 → 1.11.2

package/lib/_cjs/cli/deploy_util.js

@@ -0,0 +1,61 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+exports.__esModule = true;
+exports.DeployUtil = void 0;
+
+var _fsExtra = _interopRequireDefault(require("fs-extra"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _vtils = require("vtils");
+
+var _nodeSsh = require("node-ssh");
+
+class DeployUtil {
+  static async deploy(options) {
+    const pkgContent = await _fsExtra.default.readJson(_path.default.join(options.cwd, 'package.json'));
+
+    const appFile = _path.default.join(options.cwd, `temp/app.${pkgContent.version}.tgz`);
+
+    if (!(await _fsExtra.default.pathExists(appFile))) {
+      throw new Error('请先构建');
+    }
+
+    const ssh = new _nodeSsh.NodeSSH();
+    await ssh.connect({
+      host: options.host,
+      username: options.user,
+      privateKey: options.key
+    });
+    const appName = pkgContent.name;
+    const appDir = `./${appName}`;
+    await ssh.execCommand((0, _vtils.dedent)`
+        set -ex
+        mkdir -p app_files/${appName}
+        rm -rf ${appDir}
+        mkdir ${appDir}
+      `, {
+      cwd: options.dir,
+      onStdout: buf => console.log(buf.toString()),
+      onStderr: buf => console.log(buf.toString())
+    });
+    const remoteAppFile = `${options.dir}/app_files/${appName}/${_path.default.basename(appFile)}`;
+    await ssh.putFile(appFile, remoteAppFile);
+    await ssh.execCommand((0, _vtils.dedent)`
+        set -ex
+        tar -zxvf ${remoteAppFile} -C ${appDir}
+        cd ${appDir}/dist
+        pm2 startOrReload pm2.config.js
+      `, {
+      cwd: options.cwd,
+      onStdout: buf => console.log(buf.toString()),
+      onStderr: buf => console.log(buf.toString())
+    });
+    ssh.dispose();
+  }
+
+}
+
+exports.DeployUtil = DeployUtil;

package/lib/_cjs/cli/env_util.js

@@ -0,0 +1,145 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+exports.__esModule = true;
+exports.EnvUtil = void 0;
+
+var _fsExtra = _interopRequireDefault(require("fs-extra"));
+
+var _nodePath = _interopRequireDefault(require("node:path"));
+
+var _vtils = require("vtils");
+
+class EnvUtil {
+  static normalizeValue(value) {
+    if (value.includes(' || ')) {
+      const [devValue, prodValue] = value.split(/\s+\|\|\s+/);
+      return (0, _vtils.devOrProd)(() => EnvUtil.normalizeValue(devValue), () => EnvUtil.normalizeValue(prodValue));
+    }
+
+    return value === 'true' ? true : value === 'false' ? false : value.startsWith('[') && value.endsWith(']') || value.startsWith('{') && value.endsWith('}') ? JSON.parse(value) : (0, _vtils.isNumeric)(value) ? Number(value) : value;
+  }
+
+  static parseContent(src) {
+    const envs = []; // https://github.com/andreialecu/dotenv/blob/feat-multiline/lib/main.js
+
+    const multilineLineBreaks = true; // convert Buffers before splitting into lines and processing
+
+    const lines = src.toString().split(EnvUtil.NEWLINES_MATCH);
+    let lastComment = '';
+
+    for (let idx = 0; idx < lines.length; idx++) {
+      let line = lines[idx]; // matching "KEY' and 'VAL' in 'KEY=VAL'
+
+      const keyValueArr = line.match(EnvUtil.RE_INI_KEY_VAL); // matched?
+
+      if (keyValueArr != null) {
+        const key = keyValueArr[1]; // default undefined or missing values to empty string
+
+        let val = keyValueArr[2] || '';
+        let end = val.length - 1;
+        const isDoubleQuoted = val[0] === '"' && val[end] === '"';
+        const isSingleQuoted = val[0] === "'" && val[end] === "'";
+        const isMultilineDoubleQuoted = val[0] === '"' && (val.length === 1 || val[end] !== '"');
+        const isMultilineSingleQuoted = val[0] === "'" && (val.length === 1 || val[end] !== "'"); // if parsing line breaks and the value starts with a quote
+
+        if (multilineLineBreaks && (isMultilineDoubleQuoted || isMultilineSingleQuoted)) {
+          const quoteChar = isMultilineDoubleQuoted ? '"' : "'";
+          val = val.substring(1);
+
+          while (idx++ < lines.length - 1) {
+            line = lines[idx];
+            end = line.length - 1;
+
+            if (line[end] === quoteChar) {
+              val += EnvUtil.NEWLINE + line.substring(0, end);
+              break;
+            }
+
+            val += EnvUtil.NEWLINE + line;
+          }
+
+          val = (0, _vtils.dedent)(val); // if single or double quoted, remove quotes
+        } else if (isSingleQuoted || isDoubleQuoted) {
+          val = val.substring(1, end); // if double quoted, expand newlines
+
+          if (isDoubleQuoted) {
+            val = val.replace(EnvUtil.RE_NEWLINES, EnvUtil.NEWLINE);
+          }
+
+          val = (0, _vtils.dedent)(val);
+        } else {
+          // remove surrounding whitespace
+          val = (0, _vtils.dedent)(val).trim();
+        }
+
+        envs.push({
+          key: key,
+          value: EnvUtil.normalizeValue(val),
+          comment: lastComment
+        });
+        lastComment = '';
+      } else {
+        const commentArr = line.match(EnvUtil.COMMENT_MATCH);
+
+        if (commentArr) {
+          lastComment = commentArr[1];
+        }
+      }
+    }
+
+    return envs;
+  }
+
+  static async parseFile(options) {
+    const envFile = _nodePath.default.join(options.cwd, options.file);
+
+    if (await _fsExtra.default.pathExists(envFile)) {
+      const envContent = await _fsExtra.default.readFile(envFile, 'utf-8');
+      const envs = EnvUtil.parseContent(envContent);
+      return envs;
+    }
+
+    return [];
+  }
+
+  static async importFile(options) {
+    for (const env of await EnvUtil.parseFile(options)) {
+      process.env[env.key] = env.value;
+    }
+  }
+
+  static makeTypes(envs) {
+    return (0, _vtils.dedent)`
+      declare namespace NodeJS {
+        interface ProcessEnv {
+          /** 当前环境 */
+          NODE_ENV: 'development' | 'production';
+          ${envs.map(env => (0, _vtils.dedent)`
+                ${env.comment ? `/** ${env.comment} */` : ''}
+                ${env.key}: ${// TODO: 优化类型推断
+    Array.isArray(env.value) ? `Array<${typeof env.value[0]}>` : typeof env.value};
+              `).join('\n')}
+        }
+      }
+    `;
+  }
+
+  static async outputTypes(options) {
+    const envs = await EnvUtil.parseFile(options);
+
+    const outFile = _nodePath.default.join(options.cwd, options.outFile);
+
+    const types = EnvUtil.makeTypes(envs);
+    await _fsExtra.default.outputFile(outFile, types);
+  }
+
+}
+
+exports.EnvUtil = EnvUtil;
+EnvUtil.NEWLINE = '\n';
+EnvUtil.RE_INI_KEY_VAL = /^\s*([\w.-]+)\s*=\s*(.*)?\s*$/;
+EnvUtil.RE_NEWLINES = /\\n/g;
+EnvUtil.NEWLINES_MATCH = /\r\n|\n|\r/;
+EnvUtil.COMMENT_MATCH = /^#\s*(.+?)\s*$/;

package/lib/_cjs/cli/register.js

@@ -0,0 +1,8 @@
+"use strict";
+
+var _node = require("esbuild-register/dist/node");
+
+(0, _node.register)({
+  hookIgnoreNodeModules: false,
+  hookMatcher: filename => filename.includes('/.x/') || !filename.includes('/node_modules/')
+});

package/lib/_cjs/cli/template_util.js

@@ -0,0 +1,77 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+exports.__esModule = true;
+exports.TemplateUtil = void 0;
+
+var _fsExtra = _interopRequireDefault(require("fs-extra"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _vtils = require("vtils");
+
+var _vscodeGenerateIndexStandalone = require("vscode-generate-index-standalone");
+
+class TemplateUtil {
+  /**
+   * 初始化辅助包。
+   */
+  static async initHelperPackage(cwd) {
+    const fromDir = _path.default.join(__dirname, 'templates');
+
+    const toDir = _path.default.join(cwd, 'node_modules/.x');
+
+    await _fsExtra.default.copy(fromDir, toDir, {
+      overwrite: true
+    });
+  }
+  /**
+   * 初始化模型。
+   */
+
+
+  static async initModels(cwd) {
+    const modelsDir = _path.default.join(cwd, 'src/models');
+
+    const indexFile = _path.default.join(modelsDir, 'index.ts');
+
+    const indexFile2 = _path.default.join(cwd, 'node_modules/.x/models.ts');
+
+    const prismaClientFile = _path.default.join(cwd, 'node_modules/.prisma/client/index.d.ts');
+
+    const prismaClientFileContent = await _fsExtra.default.readFile(prismaClientFile, 'utf8');
+    const modelNames = [...prismaClientFileContent.match(/(?<=const ModelName:).+?(?=\})/s)[0].matchAll(/(\S+?):/g)].map(match => (0, _vtils.camelCase)(match[1]));
+    await Promise.all(modelNames.map(async modelName => {
+      const model_name = (0, _vtils.snakeCase)(modelName);
+      const ModelName = (0, _vtils.upperFirst)(modelName);
+
+      const modelFile = _path.default.join(modelsDir, `${model_name}.ts`);
+
+      if (!(await _fsExtra.default.pathExists(modelFile))) {
+        await _fsExtra.default.outputFile(modelFile, (0, _vtils.dedent)`
+              import { ${ModelName}BaseModel } from '@jayfong/x-server'
+
+              export class ${ModelName}Model extends ${ModelName}BaseModel {}
+              
+              export const ${modelName}Model = new ${ModelName}Model()
+            `);
+      }
+    }));
+
+    if (!(await _fsExtra.default.pathExists(indexFile))) {
+      await _fsExtra.default.outputFile(indexFile, (0, _vtils.dedent)`
+          // @index(['./**/*.ts', '!**/*.test.ts', '!**/_*'], f => \`export * from '\${f.path}'\`)
+          // @endindex
+        `);
+    }
+
+    await (0, _vscodeGenerateIndexStandalone.generateManyIndex)({
+      patterns: [indexFile, indexFile2],
+      replaceFile: true
+    });
+  }
+
+}
+
+exports.TemplateUtil = TemplateUtil;

package/lib/_cjs/cli/templates/handlers.ts

@@ -0,0 +1,3 @@
+// @index('../../src/handlers/**/*.ts', (f, _) => `export * as __${_.pascal(f.path.replace('/src/handlers/', ''))}__ from '${f.path}'`)
+
+// @endindex

package/lib/_cjs/cli/templates/hooks.ts

@@ -0,0 +1,2 @@
+// @index('../../src/hooks/**/*.ts', (f, _) => `import '${f.path}'`)
+// @endindex

package/lib/_cjs/cli/templates/models.ts

@@ -0,0 +1,22 @@
+import { x, HttpError } from '@jayfong/x-server'
+import { PrismaClient } from '@prisma/client'
+
+const prisma = new PrismaClient({
+  rejectOnNotFound: err => new HttpError.NotFound(err.message),
+})
+
+x.dispose.add(() => prisma.$disconnect())
+
+type ModelName =
+  // @index('../.prisma/client/index.d.ts', /(?<=const ModelName:).+?(?=\})/s, /(\S+?):/g, (m, _) => `| '${_.camel(m[1])}'`)
+  ''
+// @endindex
+
+function makeBaseModel<TModelName extends ModelName>(name: TModelName) {
+  return class BaseModel {
+    public query = prisma[name]
+  }
+}
+
+// @index('../.prisma/client/index.d.ts', /(?<=const ModelName:).+?(?=\})/s, /(\S+?):/g, (m, _) => `export const ${_.pascal(m[1])}BaseModel = makeBaseModel('${_.camel(m[1])}')`)
+// @endindex

package/lib/_cjs/cli/templates/package.json

@@ -0,0 +1,3 @@
+{
+  "name": ".x"
+}

package/lib/_cjs/cli/templates/routes.ts

@@ -0,0 +1,26 @@
+import * as handlers from './handlers'
+import { Handler, XServer } from '@jayfong/x-server'
+
+const basePathWithHandlers: Array<[string, Record<string, Handler>]> = [
+  // @index('../../src/handlers/**/*.ts', (f, _) => `['${('/'+_.snake(f.path.replace('/src/handlers/', '')).replace(/_/g, '/')+'/').replace(/\/{2,}/g, '/')}', handlers.__${_.pascal(f.path.replace('/src/handlers/', ''))}__ as any],`)
+  // @endindex
+]
+
+export const routes: XServer.Route[] = basePathWithHandlers.reduce<
+  XServer.Route[]
+>((res, item) => {
+  const validHandlerNames = Object.keys(item[1]).filter(
+    name => !name.startsWith('_') && name !== 'default',
+  )
+  for (const handlerName of validHandlerNames) {
+    const path = item[1][handlerName].options.requestPath || handlerName
+    const paths = Array.isArray(path) ? path : [path]
+    for (const path of paths) {
+      res.push({
+        path: `${item[0]}${path}`,
+        handler: item[1][handlerName],
+      })
+    }
+  }
+  return res
+}, [])

package/lib/_cjs/cli/templates/tasks.ts

@@ -0,0 +1,2 @@
+// @index('../../src/tasks/**/*.ts', (f, _) => `import '${f.path}'`)
+// @endindex

package/lib/_cjs/core/define_bus.js

@@ -0,0 +1,28 @@
+"use strict";
+
+exports.__esModule = true;
+exports.defineBus = defineBus;
+
+var _nodeEvents = require("node:events");
+
+class EventBus extends _nodeEvents.EventEmitter {
+  onReturnOff(event, listener) {
+    this.on(event, listener);
+    return () => this.off(event, listener);
+  }
+
+}
+
+function defineBus() {
+  const eventEmitter = new EventBus();
+  return eventEmitter;
+} // strict-event-emitter-types
+// https://github.com/bterlson/strict-event-emitter-types/blob/9ed45fc68a69f0b7f85ce4e5fe11ff53cc6a009e/src/index.ts
+// the overridden signatures need to be assignment compatible, but
+// due to how tuple types work[0] it's not possible to be assignment
+// compatible anymore. This hack fixes it with a unique symbol that
+// won't ever show up in parameter help etc.
+//
+// Unfortunately, this has the result of giving a poor error message when
+// you mix up types.
+// 0: https://github.com/Microsoft/TypeScript/issues/26013)

package/lib/_cjs/core/define_handler.js

@@ -0,0 +1,43 @@
+"use strict";
+
+exports.__esModule = true;
+exports.defineHandler = defineHandler;
+
+var _handler = require("./handler");
+
+function defineHandler(options) {
+  const handler = new _handler.Handler({ ...options,
+    requestMethod: 'POST'
+  });
+  return handler;
+}
+
+defineHandler.POST = defineHandler;
+
+defineHandler.GET = options => {
+  const handler = new _handler.Handler({ ...options,
+    requestMethod: 'GET'
+  });
+  return handler;
+};
+
+defineHandler.FILE = options => {
+  const handler = new _handler.Handler({ ...options,
+    requestMethod: 'FILE'
+  });
+  return handler;
+};
+
+defineHandler.WS = options => {
+  const handler = new _handler.Handler({ ...options,
+    requestMethod: 'WS'
+  });
+  return handler;
+};
+
+defineHandler.XML = options => {
+  const handler = new _handler.Handler({ ...options,
+    requestMethod: 'XML'
+  });
+  return handler;
+};

package/lib/_cjs/core/define_hook.js

@@ -0,0 +1,10 @@
+"use strict";
+
+exports.__esModule = true;
+exports.defineHook = defineHook;
+
+var _handler = require("./handler");
+
+function defineHook(hook) {
+  _handler.Handler.addHook(hook);
+}

package/lib/_cjs/core/define_server.js

@@ -0,0 +1,12 @@
+"use strict";
+
+exports.__esModule = true;
+exports.defineServer = defineServer;
+
+var _server = require("./server");
+
+async function defineServer(options) {
+  const server = new _server.Server(options);
+  await server.start();
+  return server;
+}

package/lib/_cjs/core/define_task.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+exports.__esModule = true;
+exports.defineTask = defineTask;
+
+var _bull = _interopRequireDefault(require("bull"));
+
+var _x = require("../x");
+
+async function defineTask(options) {
+  const queue = new _bull.default(options.name, {
+    redis: _x.x.redis.options,
+    prefix: `${_x.x.appName}_task`
+  });
+  queue.process(async job => {
+    return options.handle(job.data);
+  });
+
+  if (options.cron) {
+    queue.add({}, {
+      repeat: {
+        cron: options.cron
+      }
+    });
+  }
+
+  return queue;
+}

package/lib/_cjs/core/handler.js

@@ -0,0 +1,90 @@
+"use strict";
+
+exports.__esModule = true;
+exports.Handler = void 0;
+
+var _vtils = require("vtils");
+
+var _dispose = require("../services/dispose");
+
+var _http_error = require("../core/http_error");
+
+class Handler {
+  constructor(options) {
+    this.options = options;
+
+    this.handle = async (data, ctx) => {
+      // 前置 hook
+      if (Handler.hooks.length) {
+        await Promise.all(Handler.hooks.map(hook => hook(this.options, data, ctx)));
+      }
+
+      if (this.options.requestMethod === 'WS') {
+        return this.handleWs(data, ctx);
+      }
+
+      return this.handleHttp(data, ctx);
+    };
+
+    this.handleHttp = async (data, ctx) => {
+      let res = await this.options.handle(data, ctx); // 打包返回数据
+
+      if (this.options.responseDataPack) {
+        res = _vtils.DataPacker.packAsRawType(res);
+      }
+
+      return res;
+    };
+
+    this.handleWs = async (data, ctx) => {
+      const dispose = new _dispose.DisposeService();
+      ctx.ws.socket.on('message', async payload => {
+        try {
+          const _ = JSON.parse(payload.toString('utf8'));
+
+          const send = data => {
+            ctx.ws.socket.send(JSON.stringify({
+              id: _.id,
+              data: data
+            }));
+          };
+
+          const process = async (type, fn) => {
+            if (_.type === type) {
+              await fn({
+                data: _.data,
+                send: send,
+                dispose: dispose
+              });
+            }
+          };
+
+          if (_.type === 'ping') {
+            send();
+          } else {
+            await this.options.handle(process, ctx);
+          }
+        } catch (err) {
+          const _err = _http_error.HttpError.isHttpError(err) ? err : new _http_error.HttpError.InternalServerError();
+
+          ctx.ws.socket.send(JSON.stringify({
+            statusCode: _err.statusCode,
+            error: _err.name,
+            message: _err.message
+          }));
+        }
+      });
+      ctx.ws.socket.on('close', () => {
+        dispose.dispose();
+      });
+    };
+  }
+
+  static addHook(hook) {
+    this.hooks.push(hook);
+  }
+
+}
+
+exports.Handler = Handler;
+Handler.hooks = [];

package/lib/_cjs/core/http_error.js

@@ -0,0 +1,9 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+exports.__esModule = true;
+
+var _httpErrors = _interopRequireDefault(require("http-errors"));
+
+exports.HttpError = _httpErrors.default;

package/lib/_cjs/core/http_method.js

@@ -0,0 +1,12 @@
+"use strict";
+
+exports.__esModule = true;
+exports.HandlerMethodToHttpMethod = void 0;
+const HandlerMethodToHttpMethod = {
+  GET: 'GET',
+  POST: 'POST',
+  FILE: 'POST',
+  WS: 'GET',
+  XML: 'POST'
+};
+exports.HandlerMethodToHttpMethod = HandlerMethodToHttpMethod;