1
const whitelist = ["/bot6112359xxx:xxx"];
2
//示例const whitelist = ["/bot123456:"];
3
const tg_host = "api.telegram.org";
4

5
addEventListener('fetch', event => {
6
    event.respondWith(handleRequest(event.request))
7
})
8

9
function validate(path) {
10
    for (var i = 0; i < whitelist.length; i++) {
11
        if (path.startsWith(whitelist[i]))
12
            return true;
13
    }
14
    return false;
15
}
16

17
async function handleRequest(request) {
18
    var u = new URL(request.url);
19
    u.host = tg_host;
20
    if (!validate(u.pathname))
21
        return new Response('Unauthorized', {
22
            status: 403
23
        });
24
    var req = new Request(u, {
25
        method: request.method,
26
        headers: request.headers,
27
        body: request.body
28
    });
29
    const result = await fetch(req);
30
    return result;
31
}

1
/**
2
 * Helper functions to check if the request uses
3
 * corresponding method.
4
 *
5
 */
6
const Method = (method) => (req) => req.method.toLowerCase() === method.toLowerCase();
7
const Get = Method('get');
8
const Post = Method('post');
9

10
const Path = (regExp) => (req) => {
11
  const url = new URL(req.url);
12
  const path = url.pathname;
13
  return path.match(regExp) && path.match(regExp)[0] === path;
14
};
15

16
/*
17
 * The regex to get the bot_token and api_method from request URL
18
 * as the first and second backreference respectively.
19
 */
20
const URL_PATH_REGEX = /^\/bot(?<bot_token>[^/]+)\/(?<api_method>[a-z]+)/i;
21

22
/**
23
 * Router handles the logic of what handler is matched given conditions
24
 * for each request
25
 */
26
class Router {
27
  constructor() {
28
    this.routes = [];
29
  }
30

31
  handle(conditions, handler) {
32
    this.routes.push({
33
      conditions,
34
      handler,
35
    });
36
    return this;
37
  }
38

39
  get(url, handler) {
40
    return this.handle([Get, Path(url)], handler);
41
  }
42

43
  post(url, handler) {
44
    return this.handle([Post, Path(url)], handler);
45
  }
46

47
  all(handler) {
48
    return this.handler([], handler);
49
  }
50

51
  route(req) {
52
    const route = this.resolve(req);
53

54
    if (route) {
55
      return route.handler(req);
56
    }
57

58
    const description = 'No matching route found';
59
    const error_code = 404;
60

61
    return new Response(
62
      JSON.stringify({
63
        ok: false,
64
        error_code,
65
        description,
66
      }),
67
      {
68
        status: error_code,
69
        statusText: description,
70
        headers: {
71
          'content-type': 'application/json',
72
        },
73
      }
74
    );
75
  }
76

77
  /**
78
   * It returns the matching route that returns true
79
   * for all the conditions if any.
80
   */
81
  resolve(req) {
82
    return this.routes.find((r) => {
83
      if (!r.conditions || (Array.isArray(r) && !r.conditions.length)) {
84
        return true;
85
      }
86

87
      if (typeof r.conditions === 'function') {
88
        return r.conditions(req);
89
      }
90

91
      return r.conditions.every((c) => c(req));
92
    });
93
  }
94
}
95

96
/**
97
 * Sends a POST request with JSON data to Telegram Bot API
98
 * and reads in the response body.
99
 * @param {Request} request the incoming request
100
 */
101
async function handler(request) {
102
  // Extract the URl method from the request.
103
  const { url, ..._request } = request;
104

105
  const { pathname: path, search } = new URL(url);
106

107
  // Leave the first match as we are interested only in backreferences.
108
  const { bot_token, api_method } = path.match(URL_PATH_REGEX).groups;
109

110
  // Build the URL
111
  const api_url = 'https://api.telegram.org/bot' + bot_token + '/' + api_method + search;
112

113
  // Get the response from API.
114
  const response = await fetch(api_url, _request);
115

116
  const result = await response.text();
117

118
  const res = new Response(result, _request);
119

120
  res.headers.set('Content-Type', 'application/json');
121

122
  return res;
123
}
124

125
/**
126
 * Handles the incoming request.
127
 * @param {Request} request the incoming request.
128
 */
129
async function handleRequest(request) {
130
  const r = new Router();
131
  r.get(URL_PATH_REGEX, (req) => handler(req));
132
  r.post(URL_PATH_REGEX, (req) => handler(req));
133

134
  const resp = await r.route(request);
135
  return resp;
136
}
137

138
/**
139
 * Hook into the fetch event.
140
 */
141
addEventListener('fetch', (event) => {
142
  event.respondWith(handleRequest(event.request));
143
});