1 | "use strict";
|
2 | var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
3 | function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
4 | return new (P || (P = Promise))(function (resolve, reject) {
|
5 | function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
6 | function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
7 | function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
8 | step((generator = generator.apply(thisArg, _arguments || [])).next());
|
9 | });
|
10 | };
|
11 | var __generator = (this && this.__generator) || function (thisArg, body) {
|
12 | var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
|
13 | return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
|
14 | function verb(n) { return function (v) { return step([n, v]); }; }
|
15 | function step(op) {
|
16 | if (f) throw new TypeError("Generator is already executing.");
|
17 | while (_) try {
|
18 | if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
|
19 | if (y = 0, t) op = [op[0] & 2, t.value];
|
20 | switch (op[0]) {
|
21 | case 0: case 1: t = op; break;
|
22 | case 4: _.label++; return { value: op[1], done: false };
|
23 | case 5: _.label++; y = op[1]; op = [0]; continue;
|
24 | case 7: op = _.ops.pop(); _.trys.pop(); continue;
|
25 | default:
|
26 | if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
|
27 | if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
|
28 | if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
|
29 | if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
|
30 | if (t[2]) _.ops.pop();
|
31 | _.trys.pop(); continue;
|
32 | }
|
33 | op = body.call(thisArg, _);
|
34 | } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
|
35 | if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
|
36 | }
|
37 | };
|
38 | Object.defineProperty(exports, "__esModule", { value: true });
|
39 | exports.useMiddleware = exports.useController = exports.generateRouter = void 0;
|
40 | var express = require("express");
|
41 | var skip_response_1 = require("./skip.response");
|
42 | var validate_object_1 = require("./validate-object");
|
43 | var http_verb_1 = require("./http-verb");
|
44 | var base_middleware_1 = require("./base.middleware");
|
45 | var logger_1 = require("./logger");
|
46 | function retrieveArgumentsNamesFromRoute(path) {
|
47 | var args = [];
|
48 | var parts = path.split("/");
|
49 | for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {
|
50 | var part = parts_1[_i];
|
51 | if (part.startsWith(":")) {
|
52 | var arg = part.substring(1, part.length);
|
53 | var endIndex = arg.indexOf("(");
|
54 | if (endIndex != -1) {
|
55 | arg = arg.substring(0, endIndex);
|
56 | }
|
57 | args.push(arg);
|
58 | }
|
59 | }
|
60 | return args;
|
61 | }
|
62 | function generateStandardCallback(controller, route, app) {
|
63 | var _this = this;
|
64 | return function (req, res, next) { return __awaiter(_this, void 0, void 0, function () {
|
65 | var _i, _a, verify, passed, f, argsNames, argsValues, _b, argsNames_1, arg, b;
|
66 | return __generator(this, function (_c) {
|
67 | switch (_c.label) {
|
68 | case 0:
|
69 | req.lynx = {
|
70 | route: route
|
71 | };
|
72 | if (!route.verifiers) return [3 , 6];
|
73 | _i = 0, _a = route.verifiers;
|
74 | _c.label = 1;
|
75 | case 1:
|
76 | if (!(_i < _a.length)) return [3 , 6];
|
77 | verify = _a[_i];
|
78 | passed = true;
|
79 | if (!verify.isAsync) return [3 , 3];
|
80 | return [4 , verify.fun(req, res)];
|
81 | case 2:
|
82 | passed = _c.sent();
|
83 | return [3 , 4];
|
84 | case 3:
|
85 | if (verify.fun) {
|
86 | passed = verify.fun(req, res);
|
87 | }
|
88 | else {
|
89 | try {
|
90 | passed = verify(req, res);
|
91 | }
|
92 | catch (e) {
|
93 | logger_1.logger.error(e);
|
94 | }
|
95 | }
|
96 | _c.label = 4;
|
97 | case 4:
|
98 | if (!passed) {
|
99 | return [2 , next()];
|
100 | }
|
101 | _c.label = 5;
|
102 | case 5:
|
103 | _i++;
|
104 | return [3 , 1];
|
105 | case 6:
|
106 | if (!!controller._hasBeenInit) return [3 , 8];
|
107 | return [4 , controller.postConstructor()];
|
108 | case 7:
|
109 | _c.sent();
|
110 | _c.label = 8;
|
111 | case 8:
|
112 | f = controller[route.method];
|
113 | argsNames = retrieveArgumentsNamesFromRoute(route.path);
|
114 | argsValues = [];
|
115 | for (_b = 0, argsNames_1 = argsNames; _b < argsNames_1.length; _b++) {
|
116 | arg = argsNames_1[_b];
|
117 | argsValues.push(req.params[arg]);
|
118 | }
|
119 | if (route.body != null) {
|
120 | b = req.body;
|
121 | if (route.body.schema) {
|
122 | b = new validate_object_1.ValidateObject(b, route.body.schema, req.acceptsLanguages());
|
123 | }
|
124 | argsValues.push(b);
|
125 | }
|
126 | argsValues.push(req);
|
127 | argsValues.push(res);
|
128 | controller._ctxMap = {};
|
129 | f.apply(controller, argsValues)
|
130 | .then(function (r) {
|
131 | if (!r) {
|
132 | logger_1.logger.error("Wait, you have a method in a controller without any return!!");
|
133 | logger_1.logger.error("Method info: " + route.type + " " + route.path);
|
134 | throw new Error("Method without any return!");
|
135 | }
|
136 | if (route.isAPI) {
|
137 | var body = app.apiResponseWrapper.onSuccess(r);
|
138 | return res.send(body);
|
139 | }
|
140 | else {
|
141 | if (r instanceof skip_response_1.default) {
|
142 | r.performResponse(req, res);
|
143 | return next();
|
144 | }
|
145 | if (r.performResponse) {
|
146 | return r.performResponse(req, res);
|
147 | }
|
148 | res.send(r);
|
149 | }
|
150 | })
|
151 | .catch(function (error) {
|
152 | logger_1.logger.info(error);
|
153 | var status = 400;
|
154 | var e = error;
|
155 | if (e.statusCode) {
|
156 | status = e.statusCode;
|
157 | }
|
158 | if (!res.headersSent) {
|
159 | res.status(status);
|
160 | }
|
161 | if (route.isAPI) {
|
162 | var body = app.apiResponseWrapper.onError(error);
|
163 | res.send(body);
|
164 | }
|
165 | else {
|
166 | next(error);
|
167 | }
|
168 | });
|
169 | return [2 ];
|
170 | }
|
171 | });
|
172 | }); };
|
173 | }
|
174 | function generateRouter(app, controller, originalController, routes) {
|
175 | var router = express.Router();
|
176 | for (var _i = 0, _a = originalController.routes; _i < _a.length; _i++) {
|
177 | var route = _a[_i];
|
178 | if (route.isDisabledOn) {
|
179 | if (route.isDisabledOn()) {
|
180 | continue;
|
181 | }
|
182 | }
|
183 | var func = void 0;
|
184 | switch (route.type) {
|
185 | case http_verb_1.HttpVerb.GET:
|
186 | func = router.get;
|
187 | break;
|
188 | case http_verb_1.HttpVerb.POST:
|
189 | func = router.post;
|
190 | break;
|
191 | case http_verb_1.HttpVerb.PUT:
|
192 | func = router.put;
|
193 | break;
|
194 | case http_verb_1.HttpVerb.DELETE:
|
195 | func = router.delete;
|
196 | break;
|
197 | case http_verb_1.HttpVerb.PATCH:
|
198 | func = router.patch;
|
199 | break;
|
200 | default:
|
201 | throw new Error("The decoration type for the method " +
|
202 | route.method +
|
203 | " is invalid");
|
204 | }
|
205 | if (route.name) {
|
206 | routes[route.name] = (originalController.controllerPath +
|
207 | "/" +
|
208 | route.path).replace(/\/\/+/g, "/");
|
209 | }
|
210 | var callback = generateStandardCallback(controller, route, app);
|
211 | var p = route.path;
|
212 | if (!p.startsWith("/")) {
|
213 | p = "/" + p;
|
214 | }
|
215 | if (route.isMultipartForm) {
|
216 | func.call(router, p, app.upload.any(), callback);
|
217 | }
|
218 | else {
|
219 | func.call(router, p, callback);
|
220 | }
|
221 | }
|
222 | return router;
|
223 | }
|
224 | exports.generateRouter = generateRouter;
|
225 | function useController(app, Controller, routes) {
|
226 | if (!Controller.controllerPath) {
|
227 | throw new Error('You should decorate the "' +
|
228 | Controller.name +
|
229 | '" class in order to use it');
|
230 | }
|
231 | var controller = new Controller(app);
|
232 | controller._metadata = Controller;
|
233 | var router = generateRouter(app, controller, Controller, routes);
|
234 | app.express.use(Controller.controllerPath, router);
|
235 | }
|
236 | exports.useController = useController;
|
237 | function generateMiddlewareCallback(middleware) {
|
238 | return function (req, res, next) {
|
239 | var f = middleware.apply;
|
240 | var argsValues = [];
|
241 | argsValues.push(req);
|
242 | argsValues.push(res);
|
243 | f.apply(middleware, argsValues)
|
244 | .then(function (r) {
|
245 | if (r === base_middleware_1.BLOCK_CHAIN) {
|
246 | return;
|
247 | }
|
248 | next();
|
249 | })
|
250 | .catch(function (error) {
|
251 | logger_1.logger.info(error);
|
252 | var status = 400;
|
253 | var e = error;
|
254 | if (e.statusCode) {
|
255 | status = e.statusCode;
|
256 | }
|
257 | res.status(status).send(error);
|
258 | });
|
259 | };
|
260 | }
|
261 | function generateMiddlewares(app, middleware, path) {
|
262 | var callback = generateMiddlewareCallback(middleware);
|
263 | app.express.use(path, callback);
|
264 | }
|
265 | function useMiddleware(app, Middleware) {
|
266 | if (!Middleware.middlewarePath) {
|
267 | throw new Error('You should use at least one Middleware() decorator to a method of the "' +
|
268 | Middleware.name +
|
269 | '" class.');
|
270 | }
|
271 | var middleware = new Middleware(app);
|
272 | generateMiddlewares(app, middleware, Middleware.middlewarePath);
|
273 | }
|
274 | exports.useMiddleware = useMiddleware;
|