@kne/fastify-app-manager 0.1.1

package/libs/controllers/app.js

@@ -0,0 +1,274 @@
+const fp = require('fastify-plugin');
+const { createSseReply } = require('../utils/logStream');
+
+module.exports = fp(async (fastify, options) => {
+  const { services } = fastify[options.name];
+  const auth = () => options.createAuthenticate();
+
+  fastify.post(
+    `${options.prefix}/app/create`,
+    {
+      onRequest: auth(),
+      schema: {
+        summary: '创建应用',
+        body: {
+          type: 'object',
+          required: ['name', 'label'],
+          properties: {
+            name: { type: 'string' },
+            label: { type: 'string' },
+            domain: { type: 'string' },
+            icon: { type: 'string' },
+            description: { type: 'string' },
+            env: { type: 'object' },
+            pm2Config: { type: 'object' },
+            options: { type: 'object' }
+          }
+        }
+      }
+    },
+    async request => services.app.create(request.body)
+  );
+
+  fastify.post(
+    `${options.prefix}/app/save`,
+    {
+      onRequest: auth(),
+      schema: {
+        summary: '更新应用元信息',
+        body: {
+          type: 'object',
+          required: ['name'],
+          properties: {
+            name: { type: 'string' },
+            label: { type: 'string' },
+            domain: { type: 'string' },
+            icon: { type: 'string' },
+            description: { type: 'string' },
+            env: { type: 'object' },
+            pm2Config: { type: 'object' },
+            options: { type: 'object' }
+          }
+        }
+      }
+    },
+    async request => services.app.save(request.body)
+  );
+
+  fastify.post(
+    `${options.prefix}/app/save-env`,
+    {
+      onRequest: auth(),
+      schema: {
+        summary: '合并更新应用环境变量',
+        body: {
+          type: 'object',
+          required: ['name', 'env'],
+          properties: {
+            name: { type: 'string' },
+            env: { type: 'object' }
+          }
+        }
+      }
+    },
+    async request => services.app.saveEnv(request.body)
+  );
+
+  fastify.post(
+    `${options.prefix}/app/version/upload`,
+    {
+      onRequest: auth(),
+      schema: {
+        summary: '上传应用版本 zip'
+      }
+    },
+    async request => {
+      const parts = request.parts();
+      let name;
+      let version;
+      let label;
+      let zipBuffer;
+      for await (const part of parts) {
+        if (part.type === 'file') {
+          zipBuffer = await part.toBuffer();
+        } else {
+          const val = part.value;
+          if (part.fieldname === 'name') name = val;
+          if (part.fieldname === 'version') version = val;
+          if (part.fieldname === 'label') label = val;
+        }
+      }
+      if (!zipBuffer) {
+        throw fastify.httpErrors.badRequest('file is required');
+      }
+      return services.app.uploadVersion({ name, version, label, zipBuffer });
+    }
+  );
+
+  fastify.get(
+    `${options.prefix}/app/version/list`,
+    {
+      onRequest: auth(),
+      schema: {
+        summary: '应用版本列表',
+        query: {
+          type: 'object',
+          required: ['name'],
+          properties: {
+            name: { type: 'string' },
+            perPage: { type: 'number', default: 20 },
+            currentPage: { type: 'number', default: 1 }
+          }
+        }
+      }
+    },
+    async request => services.app.listVersions(request.query)
+  );
+
+  fastify.post(
+    `${options.prefix}/app/deploy`,
+    {
+      onRequest: auth(),
+      schema: {
+        summary: '部署指定版本',
+        body: {
+          type: 'object',
+          required: ['name'],
+          properties: {
+            name: { type: 'string' },
+            versionId: { type: 'string' },
+            version: { type: 'string' },
+            runMigration: { type: 'boolean', default: true }
+          }
+        }
+      }
+    },
+    async request => services.app.deploy(request.body)
+  );
+
+  fastify.get(
+    `${options.prefix}/app/list`,
+    {
+      onRequest: auth(),
+      schema: {
+        summary: '应用列表',
+        query: {
+          type: 'object',
+          properties: {
+            filter: { type: 'object', default: {} },
+            perPage: { type: 'number', default: 20 },
+            currentPage: { type: 'number', default: 1 }
+          }
+        }
+      }
+    },
+    async request => services.app.list(request.query)
+  );
+
+  fastify.get(
+    `${options.prefix}/app/detail`,
+    {
+      onRequest: auth(),
+      schema: {
+        summary: '应用详情',
+        query: {
+          type: 'object',
+          required: ['name'],
+          properties: {
+            name: { type: 'string' }
+          }
+        }
+      }
+    },
+    async request => services.app.detail(request.query)
+  );
+
+  for (const action of ['start', 'stop', 'restart', 'remove']) {
+    fastify.post(
+      `${options.prefix}/app/${action}`,
+      {
+        onRequest: auth(),
+        schema: {
+          summary: `${action} 应用`,
+          body: {
+            type: 'object',
+            required: ['name'],
+            properties: { name: { type: 'string' } }
+          }
+        }
+      },
+      async request => services.app[action](request.body)
+    );
+  }
+
+  fastify.get(
+    `${options.prefix}/app/logs`,
+    {
+      onRequest: auth(),
+      schema: {
+        summary: '读取应用日志文件',
+        query: {
+          type: 'object',
+          required: ['name'],
+          properties: {
+            name: { type: 'string' },
+            stream: { type: 'string', enum: ['out', 'err'], default: 'out' },
+            perPage: { type: 'number', default: 100 },
+            currentPage: { type: 'number', default: 1 }
+          }
+        }
+      }
+    },
+    async request => services.app.logs(request.query)
+  );
+
+  fastify.get(
+    `${options.prefix}/app/logs/stream`,
+    {
+      onRequest: auth(),
+      schema: {
+        summary: 'SSE 实时日志',
+        query: {
+          type: 'object',
+          required: ['name'],
+          properties: {
+            name: { type: 'string' },
+            stream: { type: 'string', enum: ['out', 'err'] }
+          }
+        }
+      }
+    },
+    async (request, reply) => {
+      const { name, stream } = request.query;
+      await services.app.detail({ name });
+      const sse = createSseReply(reply, { heartbeatMs: options.sseHeartbeatMs });
+      const hub = services.app.getLogHub();
+
+      const replay = await services.app.readLastLines(name, stream || 'out', options.sseReplayLines);
+      for (const line of replay) {
+        if (stream && line.stream && line.stream !== stream) {
+          continue;
+        }
+        sse.writeEvent('log', {
+          appName: name,
+          stream: stream || 'out',
+          content: line.content,
+          line: line.line
+        });
+      }
+
+      const onLog = payload => {
+        if (stream && payload.stream !== stream) {
+          return;
+        }
+        sse.writeEvent('log', payload);
+      };
+      const eventName = `log:${name}`;
+      hub?.on(eventName, onLog);
+      request.raw.on('close', () => {
+        hub?.off(eventName, onLog);
+        sse.close();
+      });
+    }
+  );
+});

package/libs/controllers/gateway.js

@@ -0,0 +1,88 @@
+const fp = require('fastify-plugin');
+const { rewriteLocation, rewriteSetCookiePath, shouldRewriteBody, rewriteBody } = require('../utils/pathRewrite');
+
+module.exports = fp(async (fastify, options) => {
+  const ns = options.name;
+  const pathPrefix = options.pathPrefix.replace(/\/$/, '') || '/app';
+
+  const proxyToApp = async (request, reply, app, { stripPrefix } = {}) => {
+    let targetPath = request.raw.url || '/';
+    if (stripPrefix) {
+      const mount = `${pathPrefix}/${app.name}`;
+      if (targetPath === mount || targetPath.startsWith(mount + '/') || targetPath.startsWith(mount + '?')) {
+        targetPath = targetPath.slice(mount.length) || '/';
+        if (!targetPath.startsWith('/')) {
+          targetPath = `/${targetPath}`;
+        }
+      }
+    }
+
+    const dest = `http://127.0.0.1:${app.port}${targetPath}`;
+    const mountPrefix = `${pathPrefix}/${app.name}`;
+
+    return reply.from(dest, {
+      rewriteRequestHeaders: (req, headers) => {
+        const next = { ...headers };
+        delete next['content-length'];
+        return next;
+      },
+      rewriteHeaders: headers => {
+        const next = { ...headers };
+        if (stripPrefix) {
+          if (next.location) {
+            next.location = rewriteLocation(next.location, mountPrefix);
+          }
+          if (next['set-cookie']) {
+            next['set-cookie'] = rewriteSetCookiePath(next['set-cookie'], mountPrefix);
+          }
+        }
+        // body rewrite changes length
+        if (stripPrefix && shouldRewriteBody(next['content-type'] || '') && !next['content-encoding']) {
+          delete next['content-length'];
+        }
+        return next;
+      },
+      onResponse: async (request, reply, res) => {
+        const contentType = res.headers['content-type'] || '';
+        if (stripPrefix && shouldRewriteBody(contentType) && !res.headers['content-encoding']) {
+          const chunks = [];
+          for await (const chunk of res.stream) {
+            chunks.push(chunk);
+          }
+          const buf = Buffer.concat(chunks.map(c => (Buffer.isBuffer(c) ? c : Buffer.from(c))));
+          const text = rewriteBody(buf.toString('utf8'), mountPrefix);
+          return reply.send(text);
+        }
+        return reply.send(res.stream);
+      }
+    });
+  };
+
+  // Domain + path gateway: run early, but skip management API and let other routes try first for non-matches.
+  fastify.addHook('onRequest', async (request, reply) => {
+    const url = request.raw.url || '';
+    if (url.startsWith(options.prefix)) {
+      return;
+    }
+
+    const { services } = fastify[ns];
+    if (!services?.app) {
+      return;
+    }
+
+    const host = request.headers.host;
+    const byHost = await services.app.findByHost(host);
+    if (byHost) {
+      return proxyToApp(request, reply, byHost, { stripPrefix: false });
+    }
+
+    const match = url.match(new RegExp(`^${pathPrefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}/([^/?#]+)`));
+    if (match) {
+      const appName = match[1];
+      const app = await services.app.findByPathName(appName);
+      if (app) {
+        return proxyToApp(request, reply, app, { stripPrefix: true });
+      }
+    }
+  });
+});

package/libs/models/app.js

@@ -0,0 +1,88 @@
+module.exports = ({ DataTypes }) => {
+  return {
+    name: 'app',
+    model: {
+      name: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        unique: true,
+        comment: '应用 slug / appId'
+      },
+      label: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: '用户可见应用名'
+      },
+      domain: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        unique: true,
+        comment: '绑定域名 Host'
+      },
+      icon: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: '应用图标'
+      },
+      description: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        comment: '应用描述'
+      },
+      env: {
+        type: DataTypes.JSON,
+        allowNull: false,
+        defaultValue: {},
+        comment: '应用自有环境变量'
+      },
+      pm2Config: {
+        type: DataTypes.JSON,
+        allowNull: false,
+        defaultValue: {},
+        comment: 'PM2 覆盖配置'
+      },
+      options: {
+        type: DataTypes.JSON,
+        allowNull: false,
+        defaultValue: {},
+        comment: '扩展字段'
+      },
+      port: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        comment: '分配端口'
+      },
+      status: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        defaultValue: 'idle',
+        comment: 'idle|deploying|running|stopped|error'
+      },
+      currentVersionId: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: '当前部署版本 id'
+      },
+      rootPath: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: '应用根目录'
+      },
+      pm2Name: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        unique: true,
+        comment: 'PM2 进程名'
+      },
+      message: {
+        type: DataTypes.TEXT,
+        allowNull: true,
+        comment: '最近状态说明'
+      }
+    },
+    options: {
+      comment: '托管应用',
+      indexes: [{ fields: ['status'] }, { fields: ['domain'] }]
+    }
+  };
+};

package/libs/models/appVersion.js

@@ -0,0 +1,43 @@
+module.exports = ({ DataTypes }) => {
+  return {
+    name: 'appVersion',
+    model: {
+      appName: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: '所属应用 name'
+      },
+      version: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: '版本号'
+      },
+      label: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        comment: '版本说明'
+      },
+      artifactPath: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        comment: '版本解压目录'
+      },
+      hasMigration: {
+        type: DataTypes.BOOLEAN,
+        allowNull: false,
+        defaultValue: false,
+        comment: '是否存在 server/sql/*.sql'
+      },
+      migrationPath: {
+        type: DataTypes.STRING,
+        allowNull: true,
+        defaultValue: 'sql',
+        comment: '相对 server 的 sql 目录'
+      }
+    },
+    options: {
+      comment: '应用版本',
+      indexes: [{ fields: ['app_name'] }, { unique: true, fields: ['app_name', 'version'] }]
+    }
+  };
+};