@waline/vercel 1.26.3 → 1.26.4

package/dist/package.json

@@ -0,0 +1,54 @@
+{
+	"name": "@waline/vercel",
+	"version": "1.26.3-deta-alpha.0",
+	"description": "vercel server for waline comment system",
+	"keywords": [
+		"waline",
+		"vercel",
+		"comment",
+		"blog"
+	],
+	"repository": {
+		"url": "https://github.com/walinejs/waline",
+		"directory": "packages/server"
+	},
+	"license": "MIT",
+	"author": "lizheming <i@imnerd.org>",
+	"dependencies": {
+		"@cloudbase/node-sdk": "2.9.1",
+		"@koa/cors": "4.0.0",
+		"akismet": "2.0.7",
+		"deta": "1.1.0",
+		"dompurify": "3.0.0",
+		"dy-node-ip2region": "1.0.1",
+		"fast-csv": "4.3.6",
+		"form-data": "4.0.0",
+		"jsdom": "21.1.0",
+		"jsonwebtoken": "9.0.0",
+		"katex": "0.16.4",
+		"leancloud-storage": "4.14.0",
+		"markdown-it": "13.0.1",
+		"markdown-it-emoji": "2.0.2",
+		"markdown-it-sub": "1.0.0",
+		"markdown-it-sup": "1.0.0",
+		"mathjax-full": "3.2.2",
+		"node-fetch": "2.6.9",
+		"nodemailer": "6.9.1",
+		"nunjucks": "3.2.3",
+		"phpass": "0.1.1",
+		"prismjs": "1.29.0",
+		"speakeasy": "2.0.0",
+		"think-helper": "1.1.4",
+		"think-logger3": "1.3.1",
+		"think-model": "1.5.4",
+		"think-model-mysql": "1.1.7",
+		"think-model-mysql2": "^2.0.0",
+		"think-model-postgresql": "1.1.7",
+		"think-mongo": "2.2.1",
+		"think-router-rest": "1.0.5",
+		"ua-parser-js": "1.0.33"
+	},
+	"engines": {
+		"node": ">=14"
+	}
+}

package/dist/src/config/adapter.js

@@ -0,0 +1,170 @@
+const { Console } = require('think-logger3');
+const Mysql = require('think-model-mysql');
+const Mysql2 = require('think-model-mysql2');
+const Postgresql = require('think-model-postgresql');
+
+let Sqlite = class {};
+
+try {
+  Sqlite = require('think-model-sqlite');
+} catch (err) {
+  console.log(err);
+}
+
+const {
+  MYSQL_HOST,
+  MYSQL_PORT,
+  MYSQL_DB,
+  MYSQL_USER,
+  MYSQL_PASSWORD,
+  MYSQL_PREFIX,
+  MYSQL_CHARSET,
+  MYSQL_SSL,
+  TIDB_HOST,
+  TIDB_PORT,
+  TIDB_DB,
+  TIDB_USER,
+  TIDB_PASSWORD,
+  TIDB_PREFIX,
+  TIDB_CHARSET,
+  SQLITE_PATH,
+  SQLITE_DB,
+  SQLITE_PREFIX,
+  PG_DB,
+  PG_HOST,
+  PG_PASSWORD,
+  PG_PORT,
+  PG_PREFIX,
+  PG_USER,
+  PG_SSL,
+  MONGO_AUTHSOURCE,
+  MONGO_DB,
+  MONGO_HOST,
+  MONGO_PASSWORD,
+  MONGO_PORT,
+  MONGO_REPLICASET,
+  MONGO_USER,
+} = process.env;
+
+let type = 'common';
+const mongoOpt = {};
+
+if (MONGO_REPLICASET) mongoOpt.replicaSet = MONGO_REPLICASET;
+if (MONGO_AUTHSOURCE) mongoOpt.authSource = MONGO_AUTHSOURCE;
+
+if (MONGO_DB) {
+  type = 'mongo';
+  for (const envKeys in process.env) {
+    if (/MONGO_OPT_/.test(envKeys)) {
+      const key = envKeys
+        .slice(10)
+        .toLocaleLowerCase()
+        .replace(/_([a-z])/g, (_, b) => b.toUpperCase());
+
+      mongoOpt[key] = process.env[envKeys];
+    }
+  }
+} else if (PG_DB) {
+  type = 'postgresql';
+} else if (SQLITE_PATH) {
+  type = 'sqlite';
+} else if (MYSQL_DB) {
+  type = 'mysql';
+} else if (TIDB_DB) {
+  type = 'tidb';
+}
+
+exports.model = {
+  type,
+  common: {
+    logSql: true,
+    logger: (msg) => think.logger.info(msg),
+  },
+
+  mongo: {
+    host: MONGO_HOST
+      ? MONGO_HOST.startsWith('[')
+        ? JSON.parse(MONGO_HOST)
+        : MONGO_HOST
+      : '127.0.0.1',
+    port: MONGO_PORT
+      ? MONGO_PORT.startsWith('[')
+        ? JSON.parse(MONGO_PORT)
+        : MONGO_PORT
+      : 27017,
+    user: MONGO_USER,
+    password: MONGO_PASSWORD,
+    database: MONGO_DB,
+    options: mongoOpt,
+  },
+
+  postgresql: {
+    handle: Postgresql,
+    user: PG_USER,
+    password: PG_PASSWORD,
+    database: PG_DB,
+    host: PG_HOST || '127.0.0.1',
+    port: PG_PORT || '3211',
+    connectionLimit: 1,
+    prefix: PG_PREFIX || 'wl_',
+    ssl:
+      PG_SSL == 'true'
+        ? {
+            rejectUnauthorized: false,
+          }
+        : null,
+  },
+
+  sqlite: {
+    handle: Sqlite,
+    path: SQLITE_PATH,
+    database: SQLITE_DB || 'waline',
+    connectionLimit: 1,
+    prefix: SQLITE_PREFIX || 'wl_',
+  },
+
+  mysql: {
+    handle: Mysql,
+    dateStrings: true,
+    host: MYSQL_HOST || '127.0.0.1',
+    port: MYSQL_PORT || '3306',
+    database: MYSQL_DB,
+    user: MYSQL_USER,
+    password: MYSQL_PASSWORD,
+    prefix: MYSQL_PREFIX || 'wl_',
+    charset: MYSQL_CHARSET || 'utf8mb4',
+    ssl:
+      MYSQL_SSL === 'true'
+        ? {
+            rejectUnauthorized: false,
+          }
+        : null,
+  },
+
+  tidb: {
+    handle: Mysql2,
+    dateStrings: true,
+    host: TIDB_HOST || '127.0.0.1',
+    port: TIDB_PORT || '4000',
+    database: TIDB_DB,
+    user: TIDB_USER,
+    password: TIDB_PASSWORD,
+    prefix: TIDB_PREFIX || 'wl_',
+    charset: TIDB_CHARSET || 'utf8mb4',
+    ssl: {
+      minVersion: 'TLSv1.2',
+      rejectUnauthorized: true,
+    },
+  },
+};
+
+/**
+ * logger adapter config
+ * @type {Object}
+ */
+exports.logger = {
+  type: 'console',
+  console: {
+    handle: Console,
+  },
+};

package/dist/src/config/config.js

@@ -0,0 +1,134 @@
+const {
+  JWT_TOKEN,
+  LEAN_KEY,
+  MYSQL_DB,
+  MYSQL_PASSWORD,
+  TIDB_DB,
+  TIDB_PASSWORD,
+  SQLITE_PATH,
+  PG_DB,
+  PG_PASSWORD,
+  MONGO_DB,
+  MONGO_PASSWORD,
+  FORBIDDEN_WORDS,
+  TCB_ENV,
+  TENCENTCLOUD_SECRETKEY,
+  TCB_KEY,
+  SECURE_DOMAINS,
+  DISABLE_USERAGENT,
+  DISABLE_REGION,
+  AVATAR_PROXY,
+  GITHUB_TOKEN,
+  DETA_PROJECT_KEY,
+  OAUTH_URL,
+
+  MARKDOWN_CONFIG = '{}',
+  MARKDOWN_HIGHLIGHT,
+  MARKDOWN_EMOJI,
+  MARKDOWN_SUB,
+  MARKDOWN_SUP,
+  // mathjax will be the default option for tex
+  MARKDOWN_TEX = 'mathjax',
+  MARKDOWN_MATHJAX = '{}',
+  MARKDOWN_KATEX = '{}',
+
+  MAIL_SUBJECT,
+  MAIL_TEMPLATE,
+  MAIL_SUBJECT_ADMIN,
+  MAIL_TEMPLATE_ADMIN,
+  QQ_TEMPLATE,
+  TG_TEMPLATE,
+  WX_TEMPLATE,
+  DISCORD_TEMPLATE,
+  LARK_TEMPLATE,
+
+  LEVELS,
+} = process.env;
+
+let storage = 'leancloud';
+let jwtKey = JWT_TOKEN || LEAN_KEY;
+
+if (LEAN_KEY) {
+  storage = 'leancloud';
+} else if (MONGO_DB) {
+  storage = 'mongodb';
+  jwtKey = jwtKey || MONGO_PASSWORD;
+} else if (PG_DB) {
+  storage = 'postgresql';
+  jwtKey = jwtKey || PG_PASSWORD;
+} else if (SQLITE_PATH) {
+  storage = 'sqlite';
+} else if (MYSQL_DB) {
+  storage = 'mysql';
+  jwtKey = jwtKey || MYSQL_PASSWORD;
+} else if (TIDB_DB) {
+  storage = 'tidb';
+  jwtKey = jwtKey || TIDB_PASSWORD;
+} else if (GITHUB_TOKEN) {
+  storage = 'github';
+  jwtKey = jwtKey || GITHUB_TOKEN;
+} else if (think.env === 'cloudbase' || TCB_ENV) {
+  storage = 'cloudbase';
+  jwtKey = jwtKey || TENCENTCLOUD_SECRETKEY || TCB_KEY || TCB_ENV;
+} else if (DETA_PROJECT_KEY) {
+  storage = 'deta';
+  jwtKey = jwtKey || DETA_PROJECT_KEY;
+}
+
+if (think.env === 'cloudbase' && storage === 'sqlite') {
+  throw new Error("You can't use SQLite in CloudBase platform.");
+}
+
+const forbiddenWords = FORBIDDEN_WORDS ? FORBIDDEN_WORDS.split(/\s*,\s*/) : [];
+
+const isFalse = (content) =>
+  content && ['0', 'false'].includes(content.toLowerCase());
+
+const markdown = {
+  config: JSON.parse(MARKDOWN_CONFIG),
+  plugin: {
+    emoji: !isFalse(MARKDOWN_EMOJI),
+    sub: !isFalse(MARKDOWN_SUB),
+    sup: !isFalse(MARKDOWN_SUP),
+    tex: isFalse(MARKDOWN_TEX) ? false : MARKDOWN_TEX,
+    mathjax: JSON.parse(MARKDOWN_MATHJAX),
+    katex: JSON.parse(MARKDOWN_KATEX),
+  },
+};
+
+if (isFalse(MARKDOWN_HIGHLIGHT)) markdown.config.highlight = false;
+
+let avatarProxy = '';
+
+if (AVATAR_PROXY) {
+  avatarProxy = !isFalse(AVATAR_PROXY) ? AVATAR_PROXY : '';
+}
+
+const oauthUrl = OAUTH_URL || 'https://oauth.lithub.cc';
+
+module.exports = {
+  workers: 1,
+  storage,
+  jwtKey,
+  forbiddenWords,
+  disallowIPList: [],
+  secureDomains: SECURE_DOMAINS ? SECURE_DOMAINS.split(/\s*,\s*/) : undefined,
+  disableUserAgent: DISABLE_USERAGENT && !isFalse(DISABLE_USERAGENT),
+  disableRegion: DISABLE_REGION && !isFalse(DISABLE_REGION),
+  levels:
+    !LEVELS || isFalse(LEVELS)
+      ? false
+      : LEVELS.split(/\s*,\s*/).map((v) => Number(v)),
+  avatarProxy,
+  oauthUrl,
+  markdown,
+  mailSubject: MAIL_SUBJECT,
+  mailTemplate: MAIL_TEMPLATE,
+  mailSubjectAdmin: MAIL_SUBJECT_ADMIN,
+  mailTemplateAdmin: MAIL_TEMPLATE_ADMIN,
+  QQTemplate: QQ_TEMPLATE,
+  TGTemplate: TG_TEMPLATE,
+  WXTemplate: WX_TEMPLATE,
+  DiscordTemplate: DISCORD_TEMPLATE,
+  LarkTemplate: LARK_TEMPLATE,
+};

package/dist/src/config/extend.js

@@ -0,0 +1,38 @@
+const fetch = require('node-fetch');
+const Model = require('think-model');
+const Mongo = require('think-mongo');
+
+module.exports = [
+  Model(think.app),
+  Mongo(think.app),
+  {
+    context: {
+      get serverURL() {
+        const { SERVER_URL } = process.env;
+
+        if (SERVER_URL) {
+          return SERVER_URL;
+        }
+
+        const { protocol, host } = this;
+
+        return `${protocol}://${host}`;
+      },
+      async webhook(type, data) {
+        const { WEBHOOK } = process.env;
+
+        if (!WEBHOOK) {
+          return;
+        }
+
+        return fetch(WEBHOOK, {
+          method: 'POST',
+          headers: {
+            'content-type': 'application/json',
+          },
+          body: JSON.stringify({ type, data }),
+        }).then((resp) => resp.json());
+      },
+    },
+  },
+];

package/dist/src/config/middleware.js

@@ -0,0 +1,66 @@
+const cors = require('@koa/cors');
+const routerREST = require('think-router-rest');
+const isDev = think.env === 'development';
+const isTcb = think.env === 'cloudbase';
+const isDeta = think.env === 'deta' || process.env.DETA_RUNTIME === 'true';
+const isAliyunFC =
+  think.env === 'aliyun-fc' || Boolean(process.env.FC_RUNTIME_VERSION);
+
+module.exports = [
+  {
+    handle: 'dashboard',
+    match: /^\/ui/,
+  },
+
+  {
+    handle: 'meta',
+    options: {
+      logRequest: isDev,
+      sendResponseTime: isDev,
+      requestTimeoutCallback: isTcb || isDeta || isAliyunFC ? false : () => {},
+    },
+  },
+
+  {
+    handle: 'version',
+  },
+
+  { handle: cors },
+
+  {
+    handle: 'trace',
+    enable: !think.isCli,
+    options: {
+      debug: true,
+      contentType: () => 'json',
+      error(err, ctx) {
+        if (/favicon.ico$/.test(ctx.url)) {
+          return;
+        }
+        if (think.isPrevent(err)) {
+          return false;
+        }
+
+        console.error(err);
+      },
+    },
+  },
+
+  {
+    handle: 'payload',
+    options: {
+      keepExtensions: true,
+      limit: '5mb',
+    },
+  },
+
+  {
+    handle: 'router',
+    options: {},
+  },
+
+  { handle: routerREST },
+
+  'logic',
+  'controller',
+];

package/dist/src/config/router.js

@@ -0,0 +1 @@
+module.exports = [];

package/dist/src/controller/article.js

@@ -0,0 +1,91 @@
+const BaseRest = require('./rest');
+
+module.exports = class extends BaseRest {
+  constructor(ctx) {
+    super(ctx);
+    this.modelInstance = this.service(
+      `storage/${this.config('storage')}`,
+      'Counter'
+    );
+  }
+
+  async getAction() {
+    const { path, type } = this.get();
+
+    // path is required
+    if (!Array.isArray(path) || !path.length) {
+      return this.json(0);
+    }
+
+    const resp = await this.modelInstance.select({ url: ['IN', path] });
+
+    if (think.isEmpty(resp)) {
+      const data = type.reduce((o, field) => {
+        o[field] = 0;
+
+        return o;
+      }, {});
+
+      return this.json(type.length === 1 ? data[type[0]] : data);
+    }
+
+    const respObj = resp.reduce((o, n) => {
+      o[n.url] = n;
+
+      return o;
+    }, {});
+
+    const data = [];
+
+    for (let i = 0; i < path.length; i++) {
+      const url = path[i];
+      let counters = {};
+
+      for (let j = 0; j < type.length; j++) {
+        const field = type[j];
+
+        counters[field] =
+          respObj[url] && respObj[url][field] ? respObj[url][field] : 0;
+      }
+
+      if (type.length === 1) {
+        counters = counters[type[0]];
+      }
+      data.push(counters);
+    }
+
+    return this.json(path.length === 1 ? data[0] : data);
+  }
+
+  async postAction() {
+    const { path, type, action } = this.post();
+    const resp = await this.modelInstance.select({ url: path });
+
+    if (think.isEmpty(resp)) {
+      if (action === 'desc') {
+        return this.json(0);
+      }
+
+      const count = 1;
+
+      await this.modelInstance.add(
+        { url: path, [type]: count },
+        { access: { read: true, write: true } }
+      );
+
+      return this.json(count);
+    }
+
+    const ret = await this.modelInstance.update(
+      (counter) => ({
+        [type]:
+          action === 'desc'
+            ? (counter[type] || 1) - 1
+            : (counter[type] || 0) + 1,
+      }),
+      { objectId: ['IN', resp.map(({ objectId }) => objectId)] }
+    );
+
+    return this.json(ret[0][type]);
+  }
+};