-
Notifications
You must be signed in to change notification settings - Fork 1.1k
/
helper.ts
159 lines (141 loc) · 4.43 KB
/
helper.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
/**
* This file is part of the NocoBase (R) project.
* Copyright (c) 2020-2024 NocoBase Co., Ltd.
* Authors: NocoBase Team.
*
* This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
* For more information, please refer to: https://www.nocobase.com/agreement.
*/
import cors from '@koa/cors';
import { requestLogger } from '@nocobase/logger';
import { Resourcer } from '@nocobase/resourcer';
import { uid } from '@nocobase/utils';
import { Command } from 'commander';
import { randomUUID } from 'crypto';
import fs from 'fs';
import i18next from 'i18next';
import bodyParser from 'koa-bodyparser';
import { resolve } from 'path';
import { createHistogram, RecordableHistogram } from 'perf_hooks';
import Application, { ApplicationOptions } from './application';
import { dataWrapping } from './middlewares/data-wrapping';
import { i18n } from './middlewares/i18n';
export function createI18n(options: ApplicationOptions) {
const instance = i18next.createInstance();
instance.init({
lng: 'en-US',
resources: {},
keySeparator: false,
nsSeparator: false,
...options.i18n,
});
return instance;
}
export function createResourcer(options: ApplicationOptions) {
return new Resourcer({ ...options.resourcer });
}
export function registerMiddlewares(app: Application, options: ApplicationOptions) {
app.use(async (ctx, next) => {
app.context.reqId = randomUUID();
await next();
});
app.use(requestLogger(app.name, app.requestLogger, options.logger?.request), { tag: 'logger' });
app.use(
cors({
exposeHeaders: ['content-disposition'],
...options.cors,
}),
{
tag: 'cors',
after: 'bodyParser',
},
);
if (options.bodyParser !== false) {
const bodyLimit = '10mb';
app.use(
bodyParser({
jsonLimit: bodyLimit,
formLimit: bodyLimit,
textLimit: bodyLimit,
...options.bodyParser,
}),
{
tag: 'bodyParser',
after: 'logger',
},
);
}
app.use(async (ctx, next) => {
ctx.getBearerToken = () => {
const token = ctx.get('Authorization').replace(/^Bearer\s+/gi, '');
return token || ctx.query.token;
};
await next();
});
app.use(i18n, { tag: 'i18n', after: 'cors' });
if (options.dataWrapping !== false) {
app.use(dataWrapping(), { tag: 'dataWrapping', after: 'i18n' });
}
app.use(app.dataSourceManager.middleware(), { tag: 'dataSource', after: 'dataWrapping' });
}
export const createAppProxy = (app: Application) => {
return new Proxy(app, {
get(target, prop, ...args) {
if (typeof prop === 'string' && ['on', 'once', 'addListener'].includes(prop)) {
return (eventName: string, listener: any) => {
listener['_reinitializable'] = true;
return target[prop](eventName, listener);
};
}
return Reflect.get(target, prop, ...args);
},
});
};
export const getCommandFullName = (command: Command) => {
const names = [];
names.push(command.name());
let parent = command?.parent;
while (parent) {
if (!parent?.parent) {
break;
}
names.unshift(parent.name());
parent = parent.parent;
}
return names.join('.');
};
/* istanbul ignore next -- @preserve */
export const tsxRerunning = async () => {
const file = resolve(process.cwd(), 'storage/app.watch.ts');
await fs.promises.writeFile(file, `export const watchId = '${uid()}';`, 'utf-8');
};
/* istanbul ignore next -- @preserve */
export const enablePerfHooks = (app: Application) => {
app.context.getPerfHistogram = (name: string) => {
if (!app.perfHistograms.has(name)) {
app.perfHistograms.set(name, createHistogram());
}
return app.perfHistograms.get(name);
};
app.resourcer.define({
name: 'perf',
actions: {
view: async (ctx, next) => {
const result = {};
const histograms = ctx.app.perfHistograms as Map<string, RecordableHistogram>;
const sortedHistograms = [...histograms.entries()].sort(([i, a], [j, b]) => b.mean - a.mean);
sortedHistograms.forEach(([name, histogram]) => {
result[name] = histogram;
});
ctx.body = result;
await next();
},
reset: async (ctx, next) => {
const histograms = ctx.app.perfHistograms as Map<string, RecordableHistogram>;
histograms.forEach((histogram: RecordableHistogram) => histogram.reset());
await next();
},
},
});
app.acl.allow('perf', '*', 'public');
};