@kne/fastify-app-manager 0.1.1 → 0.1.2

package/libs/utils/dbIdentity.js

@@ -0,0 +1,118 @@
+const path = require('node:path');
+const { hasAppDbConfig } = require('./env');
+
+const SYSTEM_TABLES = new Set(['_fs_sql_migrations']);
+
+const fingerprintDbConfig = db => {
+  if (!db || typeof db !== 'object') {
+    return null;
+  }
+  const dialect = db.dialect || 'sqlite';
+  if (dialect === 'sqlite') {
+    const storage = db.storage || db.host || null;
+    if (!storage) {
+      return null;
+    }
+    return `sqlite:${path.resolve(String(storage))}`;
+  }
+  const host = db.host || '127.0.0.1';
+  const port = db.port != null ? String(db.port) : '';
+  const database = db.database || db.dbName || '';
+  if (!database) {
+    return null;
+  }
+  return `${dialect}:${host}:${port}:${database}`;
+};
+
+const fingerprintFromEnv = (env = {}) => {
+  const dialect = env.DB_DIALECT || 'sqlite';
+  if (dialect === 'sqlite') {
+    const storage = env.DB_STORAGE || env.DB_HOST;
+    if (!storage) {
+      return null;
+    }
+    return `sqlite:${path.resolve(String(storage))}`;
+  }
+  if (!env.DB_DATABASE) {
+    return null;
+  }
+  return `${dialect}:${env.DB_HOST || '127.0.0.1'}:${env.DB_PORT != null ? String(env.DB_PORT) : ''}:${env.DB_DATABASE}`;
+};
+
+const assertDefaultAppDbSeparated = (defaultAppDb, hostSequelize) => {
+  const defaultFp = fingerprintDbConfig(defaultAppDb);
+  if (!defaultFp || !hostSequelize) {
+    return;
+  }
+  let hostCfg = null;
+  try {
+    hostCfg = hostSequelize.config || hostSequelize.options || null;
+    if (hostSequelize.options?.dialect === 'sqlite' || hostCfg?.dialect === 'sqlite') {
+      hostCfg = {
+        dialect: 'sqlite',
+        storage: hostSequelize.options?.storage || hostCfg?.storage
+      };
+    } else if (hostCfg) {
+      hostCfg = {
+        dialect: hostCfg.dialect || hostSequelize.options?.dialect,
+        host: hostCfg.host,
+        port: hostCfg.port,
+        database: hostCfg.database
+      };
+    }
+  } catch (e) {
+    return;
+  }
+  const hostFp = fingerprintDbConfig(hostCfg);
+  if (hostFp && hostFp === defaultFp) {
+    throw new Error('defaultAppDb must be separated from the host sequelize database (same sqlite storage or host+database)');
+  }
+};
+
+const resolveDbScope = (appEnv = {}, options = {}) => {
+  if (options.dbScope === 'dedicated' || options.dbScope === 'shared') {
+    return options.dbScope;
+  }
+  return hasAppDbConfig(appEnv) ? 'dedicated' : 'shared';
+};
+
+const normalizeOwnedTables = tables => [...new Set((Array.isArray(tables) ? tables : []).map(t => String(t || '').trim()).filter(Boolean))];
+
+const isSystemTable = name => SYSTEM_TABLES.has(String(name || ''));
+
+/**
+ * Sanitize app slug for sequelize table prefix: `ai-talent-saas` → `ai_talent_saas`
+ */
+const sanitizeAppNameForTablePrefix = name =>
+  String(name || '')
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '_')
+    .replace(/^_+|_+$/g, '')
+    .replace(/_+/g, '_') || 'app';
+
+/**
+ * Shared-DB table prefix: `t_{app}_` (e.g. `t_ai_talent_saas_`)
+ */
+const buildTablePrefix = appName => `t_${sanitizeAppNameForTablePrefix(appName)}_`;
+
+const resolveTablePrefix = (appName, appEnv = {}) => {
+  const explicit = appEnv && appEnv.DB_TABLE_PREFIX != null ? String(appEnv.DB_TABLE_PREFIX).trim() : '';
+  if (explicit) {
+    return explicit;
+  }
+  return buildTablePrefix(appName);
+};
+
+module.exports = {
+  SYSTEM_TABLES,
+  fingerprintDbConfig,
+  fingerprintFromEnv,
+  assertDefaultAppDbSeparated,
+  resolveDbScope,
+  normalizeOwnedTables,
+  isSystemTable,
+  sanitizeAppNameForTablePrefix,
+  buildTablePrefix,
+  resolveTablePrefix
+};

package/libs/utils/env.js

@@ -1,5 +1,7 @@
 const SECRET_MASK = '********';
 
+const normalizeSecretKeys = keys => [...new Set((Array.isArray(keys) ? keys : []).map(key => String(key || '').trim()).filter(Boolean))];
+
 const pickHostEnv = (passthroughEnvKeys = []) => {
   const result = {};
   for (const key of passthroughEnvKeys) {
@@ -10,22 +12,104 @@ const pickHostEnv = (passthroughEnvKeys = []) => {
   return result;
 };
 
-const mergeEnv = ({ passthroughEnvKeys = [], appEnv = {}, port }) => {
-  const merged = Object.assign({}, pickHostEnv(passthroughEnvKeys), appEnv || {}, {
-    PORT: String(port)
+const hasAppDbConfig = (appEnv = {}) => {
+  const dialect = appEnv.DB_DIALECT;
+  if (!dialect) {
+    return false;
+  }
+  if (dialect === 'sqlite') {
+    return !!(appEnv.DB_STORAGE || appEnv.DB_HOST);
+  }
+  return !!appEnv.DB_DATABASE;
+};
+
+const buildDefaultAppDbEnv = (defaultAppDb = {}) => {
+  const dialect = defaultAppDb.dialect || 'sqlite';
+  const env = { DB_DIALECT: dialect };
+  if (dialect === 'sqlite') {
+    const storage = defaultAppDb.storage || defaultAppDb.host || null;
+    if (storage) {
+      env.DB_STORAGE = String(storage);
+      env.DB_HOST = String(storage);
+    }
+    return env;
+  }
+  if (defaultAppDb.host != null) {
+    env.DB_HOST = String(defaultAppDb.host);
+  }
+  if (defaultAppDb.port != null) {
+    env.DB_PORT = String(defaultAppDb.port);
+  }
+  if (defaultAppDb.database != null) {
+    env.DB_DATABASE = String(defaultAppDb.database);
+  }
+  if (defaultAppDb.username != null) {
+    env.DB_USERNAME = String(defaultAppDb.username);
+  }
+  if (defaultAppDb.password != null) {
+    env.DB_PASSWORD = String(defaultAppDb.password);
+  }
+  return env;
+};
+
+/**
+ * Resolve env for an app DB connection (optional PORT).
+ * Order: host passthrough → defaultAppDb (if app has no DB_*) → appEnv → PORT
+ * → shared-scope DB_TABLE_PREFIX (from appName unless already set).
+ */
+const resolveAppDbEnv = ({ passthroughEnvKeys = [], appEnv = {}, defaultAppDb = null, port = null, includePort = false, appName = null, injectTablePrefix = true } = {}) => {
+  const base = Object.assign({}, pickHostEnv(passthroughEnvKeys));
+  if (defaultAppDb && !hasAppDbConfig(appEnv)) {
+    Object.assign(base, buildDefaultAppDbEnv(defaultAppDb));
+  }
+  Object.assign(base, appEnv || {});
+  if (includePort && port != null) {
+    base.PORT = String(port);
+  }
+  if (injectTablePrefix && appName) {
+    // lazy require avoids env ↔ dbIdentity cycle
+    const { resolveDbScope, resolveTablePrefix } = require('./dbIdentity');
+    if (resolveDbScope(appEnv || {}, {}) === 'shared' && (base.DB_TABLE_PREFIX == null || String(base.DB_TABLE_PREFIX).trim() === '')) {
+      base.DB_TABLE_PREFIX = resolveTablePrefix(appName, appEnv || {});
+    }
+  }
+  return base;
+};
+
+const mergeEnv = ({ passthroughEnvKeys = [], appEnv = {}, port, defaultAppDb = null, appName = null, injectTablePrefix = true } = {}) => {
+  return resolveAppDbEnv({
+    passthroughEnvKeys,
+    appEnv,
+    defaultAppDb,
+    port,
+    includePort: true,
+    appName,
+    injectTablePrefix
   });
-  return merged;
 };
 
-const isSecretKey = (key, pattern) => {
+const isPatternSecretKey = (key, pattern) => {
   const re = pattern instanceof RegExp ? pattern : new RegExp(pattern || '(SECRET|PASSWORD|TOKEN|KEY|PRIVATE)', 'i');
   return re.test(key);
 };
 
-const maskEnvForResponse = (appEnv = {}, { secretEnvKeyPattern } = {}) => {
+/**
+ * @param {string} key
+ * @param {RegExp|string} [pattern]
+ * @param {string[]} [secretKeys] 显式密钥键名（存于 app.options.secretEnvKeys）
+ */
+const isSecretKey = (key, pattern, secretKeys = []) => {
+  if ((secretKeys || []).includes(key)) {
+    return true;
+  }
+  return isPatternSecretKey(key, pattern);
+};
+
+const maskEnvForResponse = (appEnv = {}, { secretEnvKeyPattern, secretEnvKeys = [] } = {}) => {
   const masked = {};
+  const explicit = normalizeSecretKeys(secretEnvKeys);
   for (const [key, value] of Object.entries(appEnv || {})) {
-    if (isSecretKey(key, secretEnvKeyPattern)) {
+    if (isSecretKey(key, secretEnvKeyPattern, explicit)) {
       masked[key] = value == null || value === '' ? null : SECRET_MASK;
     } else {
       masked[key] = value;
@@ -37,17 +121,18 @@ const maskEnvForResponse = (appEnv = {}, { secretEnvKeyPattern } = {}) => {
 /**
  * merge patch into current env.
  * null => delete key
- * SECRET_MASK => keep existing
+ * SECRET_MASK => keep existing (when key is secret by pattern or explicit list)
  * other => set
  */
-const applyEnvPatch = (current = {}, patch = {}, { secretEnvKeyPattern } = {}) => {
+const applyEnvPatch = (current = {}, patch = {}, { secretEnvKeyPattern, secretEnvKeys = [] } = {}) => {
   const next = Object.assign({}, current);
+  const explicit = normalizeSecretKeys(secretEnvKeys);
   for (const [key, value] of Object.entries(patch || {})) {
     if (value === null) {
       delete next[key];
       continue;
     }
-    if (value === SECRET_MASK && isSecretKey(key, secretEnvKeyPattern)) {
+    if (value === SECRET_MASK && isSecretKey(key, secretEnvKeyPattern, explicit)) {
       continue;
     }
     next[key] = value;
@@ -55,6 +140,15 @@ const applyEnvPatch = (current = {}, patch = {}, { secretEnvKeyPattern } = {}) =
   return next;
 };
 
+/**
+ * 响应中的密钥键列表 = 显式列表 ∪ 当前 env 中匹配 pattern 的键
+ */
+const collectSecretKeys = (appEnv = {}, { secretEnvKeyPattern, secretEnvKeys = [] } = {}) => {
+  const explicit = normalizeSecretKeys(secretEnvKeys);
+  const fromPattern = Object.keys(appEnv || {}).filter(key => isPatternSecretKey(key, secretEnvKeyPattern));
+  return normalizeSecretKeys([...explicit, ...fromPattern]);
+};
+
 const PM2_CONFIG_KEYS = ['exec_mode', 'instances', 'autorestart', 'max_memory_restart', 'max_restarts', 'min_uptime', 'kill_timeout', 'merge_logs'];
 
 const mergePm2Config = (defaults = {}, appConfig = {}) => {
@@ -69,11 +163,17 @@ const mergePm2Config = (defaults = {}, appConfig = {}) => {
 
 module.exports = {
   SECRET_MASK,
+  normalizeSecretKeys,
   pickHostEnv,
+  hasAppDbConfig,
+  buildDefaultAppDbEnv,
+  resolveAppDbEnv,
   mergeEnv,
+  isPatternSecretKey,
   isSecretKey,
   maskEnvForResponse,
   applyEnvPatch,
+  collectSecretKeys,
   PM2_CONFIG_KEYS,
   mergePm2Config
 };

package/libs/utils/logFiles.js

@@ -22,20 +22,34 @@ const appendLog = async (filePath, content) => {
   await fs.appendFile(filePath, content.endsWith('\n') ? content : `${content}\n`);
 };
 
-const readLogTail = async (filePath, { perPage = 100, currentPage = 1 } = {}) => {
+const readLogTail = async (filePath, { perPage = 100, currentPage = 1, beforeLine } = {}) => {
+  const size = Math.min(100, Math.max(1, Number(perPage) || 100));
+  const page = Math.max(1, Number(currentPage) || 1);
   if (!(await fs.pathExists(filePath))) {
-    return { pageData: [], totalCount: 0 };
+    return { pageData: [], totalCount: 0, hasMore: false };
   }
   const text = await fs.readFile(filePath, 'utf8');
   const lines = text.split(/\r?\n/).filter((line, idx, arr) => !(idx === arr.length - 1 && line === ''));
   const totalCount = lines.length;
-  const start = Math.max(0, totalCount - perPage * currentPage);
-  const end = Math.max(0, totalCount - perPage * (currentPage - 1));
+  let start;
+  let end;
+  if (beforeLine != null && beforeLine !== '' && Number(beforeLine) > 0) {
+    // 取 line < beforeLine 的尾部 size 行（0-based slice end = beforeLine-1）
+    end = Math.min(Math.max(0, Number(beforeLine) - 1), totalCount);
+    start = Math.max(0, end - size);
+  } else {
+    start = Math.max(0, totalCount - size * page);
+    end = Math.max(0, totalCount - size * (page - 1));
+  }
   const pageData = lines.slice(start, end).map((content, i) => ({
     line: start + i + 1,
     content
   }));
-  return { pageData: pageData.reverse(), totalCount };
+  return {
+    pageData: pageData.reverse(),
+    totalCount,
+    hasMore: start > 0
+  };
 };
 
 const readLastLines = async (filePath, n = 100) => {

package/libs/utils/migrate.js

@@ -1,6 +1,5 @@
 const path = require('node:path');
 const fs = require('fs-extra');
-const { Sequelize } = require('sequelize');
 const { listSqlFiles } = require('./validatePackage');
 
 const SQL_MIGRATIONS_TABLE = '_fs_sql_migrations';
@@ -8,20 +7,21 @@ const SQL_MIGRATIONS_TABLE = '_fs_sql_migrations';
 /**
  * Run .sql files under server/{sqlPath} with the same tracking semantics as @kne/fastify-sequelize.
  */
-const runSqlMigrations = async ({ serverDir, sqlPath = 'sql', env = {} }) => {
+const runSqlMigrations = async ({ serverDir, sqlPath = 'sql', env = {}, Sequelize: SequelizeCtor } = {}) => {
   const sqlDir = path.join(serverDir, sqlPath);
   const files = await listSqlFiles(sqlDir);
   if (!files.length) {
     return { executed: [], skipped: true };
   }
 
-  const sequelize = createSequelizeFromEnv(env);
+  const sequelize = createSequelizeFromEnv(env, SequelizeCtor);
   try {
     await sequelize.authenticate();
+    // TIMESTAMP is portable across sqlite / postgres / mysql (avoid DATETIME — missing on PG)
     await sequelize.query(
       `CREATE TABLE IF NOT EXISTS ${SQL_MIGRATIONS_TABLE} (
         name VARCHAR(255) PRIMARY KEY,
-        executed_at DATETIME
+        executed_at TIMESTAMP
       )`
     );
 
@@ -46,7 +46,12 @@ const runSqlMigrations = async ({ serverDir, sqlPath = 'sql', env = {} }) => {
   }
 };
 
-const createSequelizeFromEnv = env => {
+const createSequelizeFromEnv = (env, SequelizeCtor) => {
+  let Sequelize = SequelizeCtor;
+  if (typeof Sequelize !== 'function') {
+    const mod = require('sequelize');
+    Sequelize = typeof mod === 'function' ? mod : mod.Sequelize;
+  }
   const dialect = env.DB_DIALECT || 'sqlite';
   if (dialect === 'sqlite') {
     return new Sequelize({

package/libs/utils/sqlQueryGuard.js

@@ -0,0 +1,72 @@
+const WRITE_OR_DDL = /\b(INSERT|UPDATE|DELETE|REPLACE|MERGE|DROP|ALTER|CREATE|TRUNCATE|GRANT|REVOKE|ATTACH|DETACH|VACUUM|REINDEX|INTO)\b/i;
+
+const ALLOWED_START = /^(WITH|SELECT|EXPLAIN|SHOW|DESCRIBE|DESC|PRAGMA)\b/i;
+
+const stripSqlComments = sql =>
+  String(sql || '')
+    .replace(/\/\*[\s\S]*?\*\//g, ' ')
+    .replace(/--[^\n]*/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+
+/**
+ * Validate read-only query SQL. Throws Error with message on reject.
+ * @returns {{ sql: string, tables: string[] }}
+ */
+const assertReadOnlyQuerySql = rawSql => {
+  const sql = stripSqlComments(rawSql);
+  if (!sql) {
+    throw new Error('sql is required');
+  }
+  if (sql.includes(';')) {
+    throw new Error('multiple statements are not allowed');
+  }
+  if (!ALLOWED_START.test(sql)) {
+    throw new Error('only read-only queries are allowed (SELECT / WITH / EXPLAIN / SHOW / DESCRIBE / PRAGMA)');
+  }
+  if (WRITE_OR_DDL.test(sql) && !/^EXPLAIN\b/i.test(sql)) {
+    // EXPLAIN may contain plan text; for normal SELECT/WITH still block DML keywords
+    if (!/^(SELECT|WITH|SHOW|DESCRIBE|DESC|PRAGMA)\b/i.test(sql)) {
+      throw new Error('write or DDL statements are not allowed');
+    }
+    // SELECT ... INTO is blocked by INTO in WRITE_OR_DDL
+    if (/\b(INSERT|UPDATE|DELETE|REPLACE|MERGE|DROP|ALTER|CREATE|TRUNCATE|GRANT|REVOKE)\b/i.test(sql)) {
+      throw new Error('write or DDL statements are not allowed');
+    }
+    if (/\bINTO\b/i.test(sql) && !/\bINSERT\b/i.test(sql)) {
+      // SELECT INTO
+      throw new Error('SELECT INTO is not allowed');
+    }
+  }
+  if (/^PRAGMA\b/i.test(sql) && /\b(writable_schema|journal_mode\s*=|user_version\s*=)/i.test(sql)) {
+    throw new Error('mutating PRAGMA is not allowed');
+  }
+
+  const tables = extractTableNames(sql);
+  return { sql, tables };
+};
+
+/**
+ * Best-effort table name extraction from FROM / JOIN clauses.
+ */
+const extractTableNames = sql => {
+  const names = new Set();
+  const re = /\b(?:FROM|JOIN)\s+([`"[\w.]+)/gi;
+  let match;
+  while ((match = re.exec(sql))) {
+    let raw = match[1];
+    raw = raw.replace(/^[`"[]|[`\]"]$/g, '');
+    const parts = raw.split('.');
+    const table = parts[parts.length - 1];
+    if (table && !/^\d+$/.test(table) && table.toLowerCase() !== 'select') {
+      names.add(table);
+    }
+  }
+  return [...names];
+};
+
+module.exports = {
+  assertReadOnlyQuerySql,
+  extractTableNames,
+  stripSqlComments
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kne/fastify-app-manager",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Fastify 单机应用市场插件：版本上传、PM2 托管、路径/域名反代与日志 SSE",
   "main": "index.js",
   "scripts": {
@@ -52,7 +52,7 @@
     "@fastify/env": "^5.0.2",
     "@fastify/sensible": "^6.0.5",
     "@kne/fastify-namespace": "^1.2.1",
-    "@kne/fastify-sequelize": "^3.0.6",
+    "@kne/fastify-sequelize": "^4.0.3",
     "chai": "^6.2.2",
     "fastify": "^5.4.0",
     "fastify-plugin": "^5.0.1",