nestia 2.1.0-dev.20220504 → 2.1.0-dev.20220505
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/.github/ISSUE_TEMPLATE/BUG_REPORT.md +42 -0
- package/.github/ISSUE_TEMPLATE/FEATURE_REQUEST.md +13 -0
- package/.github/ISSUE_TEMPLATE/QUESTION.md +11 -0
- package/.github/PULL_REQUEST_TEMPLATE.md +13 -0
- package/CODE_OF_CONDUCT.md +133 -0
- package/README.md +248 -2
- package/lib/analyses/ControllerAnalyzer.d.ts.map +1 -1
- package/lib/analyses/ControllerAnalyzer.js +3 -1
- package/lib/factories/CommentFactory.d.ts +5 -0
- package/lib/factories/CommentFactory.d.ts.map +1 -0
- package/lib/factories/CommentFactory.js +14 -0
- package/lib/factories/MetadataCollection.d.ts +14 -0
- package/lib/factories/MetadataCollection.d.ts.map +1 -0
- package/lib/factories/MetadataCollection.js +83 -0
- package/lib/factories/MetadataFactory.d.ts +8 -0
- package/lib/factories/MetadataFactory.d.ts.map +1 -0
- package/lib/factories/MetadataFactory.js +255 -0
- package/lib/factories/SchemaFactory.d.ts +9 -0
- package/lib/factories/SchemaFactory.d.ts.map +1 -0
- package/lib/factories/SchemaFactory.js +179 -0
- package/lib/factories/TypeFactry.d.ts +7 -0
- package/lib/factories/TypeFactry.d.ts.map +1 -0
- package/lib/factories/TypeFactry.js +76 -0
- package/lib/generates/SwaggerGenerator.d.ts.map +1 -1
- package/lib/generates/SwaggerGenerator.js +62 -22
- package/lib/structures/IMetadata.d.ts +21 -0
- package/lib/structures/IMetadata.d.ts.map +1 -0
- package/lib/structures/IMetadata.js +3 -0
- package/lib/structures/ISwagger.d.ts +3 -1
- package/lib/structures/ISwagger.d.ts.map +1 -1
- package/lib/structures/TypeEntry.d.ts +10 -0
- package/lib/structures/TypeEntry.d.ts.map +1 -0
- package/lib/structures/TypeEntry.js +22 -0
- package/package.json +1 -1
|
@@ -0,0 +1,255 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
var __read = (this && this.__read) || function (o, n) {
|
|
3
|
+
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
|
4
|
+
if (!m) return o;
|
|
5
|
+
var i = m.call(o), r, ar = [], e;
|
|
6
|
+
try {
|
|
7
|
+
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
|
8
|
+
}
|
|
9
|
+
catch (error) { e = { error: error }; }
|
|
10
|
+
finally {
|
|
11
|
+
try {
|
|
12
|
+
if (r && !r.done && (m = i["return"])) m.call(i);
|
|
13
|
+
}
|
|
14
|
+
finally { if (e) throw e.error; }
|
|
15
|
+
}
|
|
16
|
+
return ar;
|
|
17
|
+
};
|
|
18
|
+
var __values = (this && this.__values) || function(o) {
|
|
19
|
+
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
|
20
|
+
if (m) return m.call(o);
|
|
21
|
+
if (o && typeof o.length === "number") return {
|
|
22
|
+
next: function () {
|
|
23
|
+
if (o && i >= o.length) o = void 0;
|
|
24
|
+
return { value: o && o[i++], done: !o };
|
|
25
|
+
}
|
|
26
|
+
};
|
|
27
|
+
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
|
28
|
+
};
|
|
29
|
+
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
|
|
30
|
+
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
|
|
31
|
+
if (ar || !(i in from)) {
|
|
32
|
+
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
|
|
33
|
+
ar[i] = from[i];
|
|
34
|
+
}
|
|
35
|
+
}
|
|
36
|
+
return to.concat(ar || Array.prototype.slice.call(from));
|
|
37
|
+
};
|
|
38
|
+
var __importDefault = (this && this.__importDefault) || function (mod) {
|
|
39
|
+
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
40
|
+
};
|
|
41
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
42
|
+
exports.MetadataFactory = void 0;
|
|
43
|
+
var crypto_1 = __importDefault(require("crypto"));
|
|
44
|
+
var typescript_1 = __importDefault(require("typescript"));
|
|
45
|
+
var Singleton_1 = require("tstl/thread/Singleton");
|
|
46
|
+
var CommentFactory_1 = require("./CommentFactory");
|
|
47
|
+
var MetadataCollection_1 = require("./MetadataCollection");
|
|
48
|
+
var TypeFactry_1 = require("./TypeFactry");
|
|
49
|
+
var MetadataFactory;
|
|
50
|
+
(function (MetadataFactory) {
|
|
51
|
+
MetadataFactory.Collection = MetadataCollection_1.MetadataCollection;
|
|
52
|
+
function generate(checker, type, collection) {
|
|
53
|
+
if (collection === void 0) { collection = new MetadataFactory.Collection(true); }
|
|
54
|
+
// CONSTRUCT SCHEMA WITH OBJECTS
|
|
55
|
+
var metadata = explore(collection, checker, type);
|
|
56
|
+
if (metadata === null)
|
|
57
|
+
return null;
|
|
58
|
+
// RETURNS WITH STORAGE
|
|
59
|
+
var storage = collection.storage();
|
|
60
|
+
return { metadata: metadata, storage: storage };
|
|
61
|
+
}
|
|
62
|
+
MetadataFactory.generate = generate;
|
|
63
|
+
function explore(collection, checker, type) {
|
|
64
|
+
if (type === null)
|
|
65
|
+
return null;
|
|
66
|
+
var schema = {
|
|
67
|
+
atomics: new Set(),
|
|
68
|
+
arraies: new Map(),
|
|
69
|
+
objects: new Set(),
|
|
70
|
+
nullable: false,
|
|
71
|
+
required: true,
|
|
72
|
+
};
|
|
73
|
+
if (iterate(collection, checker, schema, type) === false)
|
|
74
|
+
return null;
|
|
75
|
+
return schema;
|
|
76
|
+
}
|
|
77
|
+
function iterate(collection, checker, schema, type, parentEscaped) {
|
|
78
|
+
var e_1, _a, e_2, _b;
|
|
79
|
+
if (parentEscaped === void 0) { parentEscaped = false; }
|
|
80
|
+
// ESCAPE toJSON() METHOD
|
|
81
|
+
var _c = __read(TypeFactry_1.TypeFactory.escape(checker, type), 2), converted = _c[0], partialEscaped = _c[1];
|
|
82
|
+
if (partialEscaped === true)
|
|
83
|
+
type = converted;
|
|
84
|
+
// WHEN UNION TYPE
|
|
85
|
+
var escaped = partialEscaped || parentEscaped;
|
|
86
|
+
if (type.isUnion())
|
|
87
|
+
return type.types.every(function (t) { return iterate(collection, checker, schema, t, escaped); });
|
|
88
|
+
// NODE AND ATOMIC TYPE CHECKER
|
|
89
|
+
var node = checker.typeToTypeNode(type, undefined, undefined);
|
|
90
|
+
if (!node)
|
|
91
|
+
return false;
|
|
92
|
+
var filter = function (flag) { return (type.getFlags() & flag) !== 0; };
|
|
93
|
+
var check = function (flag, literal, className) {
|
|
94
|
+
var _a;
|
|
95
|
+
if (filter(flag) || filter(literal) || ((_a = type.symbol) === null || _a === void 0 ? void 0 : _a.escapedName) === className) {
|
|
96
|
+
schema.atomics.add(className.toLowerCase());
|
|
97
|
+
return true;
|
|
98
|
+
}
|
|
99
|
+
return false;
|
|
100
|
+
};
|
|
101
|
+
// UNKNOWN, NULL OR UNDEFINED
|
|
102
|
+
if (filter(typescript_1.default.TypeFlags.Unknown) || filter(typescript_1.default.TypeFlags.Never) || filter(typescript_1.default.TypeFlags.Any))
|
|
103
|
+
return false;
|
|
104
|
+
else if (filter(typescript_1.default.TypeFlags.Null))
|
|
105
|
+
return escaped ? false : schema.nullable = true;
|
|
106
|
+
else if (filter(typescript_1.default.TypeFlags.Undefined) || filter(typescript_1.default.TypeFlags.Void) || filter(typescript_1.default.TypeFlags.VoidLike))
|
|
107
|
+
return escaped ? false : !(schema.required = false);
|
|
108
|
+
try {
|
|
109
|
+
// ATOMIC VALUE TYPES
|
|
110
|
+
for (var _d = __values(ATOMICS.get()), _e = _d.next(); !_e.done; _e = _d.next()) {
|
|
111
|
+
var _f = __read(_e.value, 3), flag = _f[0], literal = _f[1], className = _f[2];
|
|
112
|
+
if (check(flag, literal, className) === true)
|
|
113
|
+
return escaped ? false : true;
|
|
114
|
+
}
|
|
115
|
+
}
|
|
116
|
+
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
|
117
|
+
finally {
|
|
118
|
+
try {
|
|
119
|
+
if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
|
|
120
|
+
}
|
|
121
|
+
finally { if (e_1) throw e_1.error; }
|
|
122
|
+
}
|
|
123
|
+
// WHEN TUPLE
|
|
124
|
+
if (typescript_1.default.isTupleTypeNode(node)) {
|
|
125
|
+
if (escaped || node.elements.length === 0)
|
|
126
|
+
return false;
|
|
127
|
+
var elemSchema = explore(collection, checker, checker.getTypeFromTypeNode(node.elements[0]));
|
|
128
|
+
if (elemSchema === null)
|
|
129
|
+
return false;
|
|
130
|
+
try {
|
|
131
|
+
for (var _g = __values(node.elements.slice(1)), _h = _g.next(); !_h.done; _h = _g.next()) {
|
|
132
|
+
var elem = _h.value;
|
|
133
|
+
if (iterate(collection, checker, elemSchema, checker.getTypeFromTypeNode(elem)) === false)
|
|
134
|
+
return false;
|
|
135
|
+
}
|
|
136
|
+
}
|
|
137
|
+
catch (e_2_1) { e_2 = { error: e_2_1 }; }
|
|
138
|
+
finally {
|
|
139
|
+
try {
|
|
140
|
+
if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
|
|
141
|
+
}
|
|
142
|
+
finally { if (e_2) throw e_2.error; }
|
|
143
|
+
}
|
|
144
|
+
}
|
|
145
|
+
// WHEN ARRAY
|
|
146
|
+
else if (typescript_1.default.isArrayTypeNode(node) || !!type.getNumberIndexType()) {
|
|
147
|
+
if (escaped)
|
|
148
|
+
return false;
|
|
149
|
+
var elemType = type.getNumberIndexType()
|
|
150
|
+
|| checker.getTypeArguments(type)[0]
|
|
151
|
+
|| null;
|
|
152
|
+
var elemSchema = explore(collection, checker, elemType);
|
|
153
|
+
var key = get_uid(elemSchema);
|
|
154
|
+
schema.arraies.set(key, elemSchema);
|
|
155
|
+
}
|
|
156
|
+
// WHEN OBJECT, MAYBE
|
|
157
|
+
else if (filter(typescript_1.default.TypeFlags.Object)) {
|
|
158
|
+
if (type.isIntersection()) {
|
|
159
|
+
var fakeCollection_1 = new MetadataFactory.Collection(true);
|
|
160
|
+
var fakeSchema_1 = {
|
|
161
|
+
atomics: new Set(),
|
|
162
|
+
arraies: new Map(),
|
|
163
|
+
objects: new Set(),
|
|
164
|
+
nullable: false,
|
|
165
|
+
required: true,
|
|
166
|
+
};
|
|
167
|
+
if (type.types.every(function (t) { return iterate(fakeCollection_1, checker, fakeSchema_1, t); }) === false)
|
|
168
|
+
return false;
|
|
169
|
+
else if (fakeSchema_1.atomics.size || fakeSchema_1.arraies.size || !fakeSchema_1.objects.size)
|
|
170
|
+
return false;
|
|
171
|
+
}
|
|
172
|
+
var key = emplace(collection, checker, type, schema.nullable);
|
|
173
|
+
schema.objects.add(collection.inline
|
|
174
|
+
? "components#/schemas/".concat(key)
|
|
175
|
+
: "#/components/schemas/".concat(key));
|
|
176
|
+
}
|
|
177
|
+
return !escaped;
|
|
178
|
+
}
|
|
179
|
+
function emplace(collection, checker, parent, nullable) {
|
|
180
|
+
var e_3, _a;
|
|
181
|
+
var _b, _c;
|
|
182
|
+
// CHECK MEMORY
|
|
183
|
+
var _d = __read(collection.emplace(checker, parent, nullable), 2), id = _d[0], object = _d[1];
|
|
184
|
+
if (object === null)
|
|
185
|
+
return id;
|
|
186
|
+
// PREPARE ASSETS
|
|
187
|
+
var isClass = parent.isClass();
|
|
188
|
+
var pred = isClass
|
|
189
|
+
? function (node) { return (typescript_1.default.isParameter(node) || typescript_1.default.isPropertyDeclaration(node)); }
|
|
190
|
+
: function (node) { return (typescript_1.default.isPropertySignature(node) || typescript_1.default.isTypeLiteralNode(node)); };
|
|
191
|
+
try {
|
|
192
|
+
for (var _e = __values(parent.getApparentProperties()), _f = _e.next(); !_f.done; _f = _e.next()) {
|
|
193
|
+
var prop = _f.value;
|
|
194
|
+
// CHECK NODE IS A FORMAL PROPERTY
|
|
195
|
+
var node = (prop.getDeclarations() || [])[0];
|
|
196
|
+
if (!node || !pred(node))
|
|
197
|
+
continue;
|
|
198
|
+
else if (node.getChildren().some(function (child) { return TypeFactry_1.TypeFactory.is_function(child); }))
|
|
199
|
+
continue;
|
|
200
|
+
// CHECK NOT PRIVATE OR PROTECTED MEMBER
|
|
201
|
+
if (isClass) {
|
|
202
|
+
var kind = (_c = (_b = node.getChildren()[0]) === null || _b === void 0 ? void 0 : _b.getChildren()[0]) === null || _c === void 0 ? void 0 : _c.kind;
|
|
203
|
+
if (kind === typescript_1.default.SyntaxKind.PrivateKeyword || kind === typescript_1.default.SyntaxKind.ProtectedKeyword)
|
|
204
|
+
continue;
|
|
205
|
+
}
|
|
206
|
+
// GET EXACT TYPE
|
|
207
|
+
var key = node.name.getText();
|
|
208
|
+
var type = checker.getTypeOfSymbolAtLocation(prop, node);
|
|
209
|
+
// CHILD METADATA BY ADDITIONAL EXPLORATION
|
|
210
|
+
var child = explore(collection, checker, type);
|
|
211
|
+
if (child) {
|
|
212
|
+
if (node.questionToken)
|
|
213
|
+
child.required = false;
|
|
214
|
+
child.description = CommentFactory_1.CommentFactory.generate(prop.getDocumentationComment(checker));
|
|
215
|
+
}
|
|
216
|
+
object.properties[key] = child;
|
|
217
|
+
}
|
|
218
|
+
}
|
|
219
|
+
catch (e_3_1) { e_3 = { error: e_3_1 }; }
|
|
220
|
+
finally {
|
|
221
|
+
try {
|
|
222
|
+
if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
|
|
223
|
+
}
|
|
224
|
+
finally { if (e_3) throw e_3.error; }
|
|
225
|
+
}
|
|
226
|
+
return id;
|
|
227
|
+
}
|
|
228
|
+
function get_uid(schema) {
|
|
229
|
+
if (schema === null)
|
|
230
|
+
return "null";
|
|
231
|
+
return crypto_1.default.createHash("sha256")
|
|
232
|
+
.update(JSON.stringify(to_primitive(schema)))
|
|
233
|
+
.digest("base64");
|
|
234
|
+
}
|
|
235
|
+
function to_primitive(schema) {
|
|
236
|
+
if (schema === null)
|
|
237
|
+
return null;
|
|
238
|
+
return {
|
|
239
|
+
atomics: Array.from(schema.atomics),
|
|
240
|
+
arraies: __spreadArray([], __read(schema.arraies), false).map(function (_a) {
|
|
241
|
+
var _b = __read(_a, 2), key = _b[0], value = _b[1];
|
|
242
|
+
return [key, to_primitive(value)];
|
|
243
|
+
}),
|
|
244
|
+
objects: Array.from(schema.objects),
|
|
245
|
+
nullable: schema.nullable
|
|
246
|
+
};
|
|
247
|
+
}
|
|
248
|
+
})(MetadataFactory = exports.MetadataFactory || (exports.MetadataFactory = {}));
|
|
249
|
+
var ATOMICS = new Singleton_1.Singleton(function () { return [
|
|
250
|
+
[typescript_1.default.TypeFlags.BooleanLike, typescript_1.default.TypeFlags.BooleanLiteral, "Boolean"],
|
|
251
|
+
[typescript_1.default.TypeFlags.NumberLike, typescript_1.default.TypeFlags.NumberLiteral, "Number"],
|
|
252
|
+
[typescript_1.default.TypeFlags.BigIntLike, typescript_1.default.TypeFlags.BigIntLiteral, "BigInt"],
|
|
253
|
+
[typescript_1.default.TypeFlags.StringLike, typescript_1.default.TypeFlags.StringLiteral, "String"]
|
|
254
|
+
]; });
|
|
255
|
+
//# sourceMappingURL=MetadataFactory.js.map
|
|
@@ -0,0 +1,9 @@
|
|
|
1
|
+
import { IMetadata } from "../structures/IMetadata";
|
|
2
|
+
export declare namespace SchemaFactory {
|
|
3
|
+
function application(app: IMetadata.IApplication | null): any[];
|
|
4
|
+
function schema(meta: IMetadata | null): any;
|
|
5
|
+
function components(storage: IMetadata.IStorage | null): {
|
|
6
|
+
schemas: Record<string, any>;
|
|
7
|
+
};
|
|
8
|
+
}
|
|
9
|
+
//# sourceMappingURL=SchemaFactory.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"SchemaFactory.d.ts","sourceRoot":"","sources":["../../src/factories/SchemaFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEpD,yBAAiB,aAAa,CAC9B;IACI,SAAgB,WAAW,CAAC,GAAG,EAAE,SAAS,CAAC,YAAY,GAAG,IAAI,SAQ7D;IAKD,SAAgB,MAAM,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI,GAAG,GAAG,CAyBlD;IA6BD,SAAgB,UAAU,CAAC,OAAO,EAAE,SAAS,CAAC,QAAQ,GAAG,IAAI;;MAO5D;CAqBJ"}
|
|
@@ -0,0 +1,179 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
var __assign = (this && this.__assign) || function () {
|
|
3
|
+
__assign = Object.assign || function(t) {
|
|
4
|
+
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
|
5
|
+
s = arguments[i];
|
|
6
|
+
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
|
|
7
|
+
t[p] = s[p];
|
|
8
|
+
}
|
|
9
|
+
return t;
|
|
10
|
+
};
|
|
11
|
+
return __assign.apply(this, arguments);
|
|
12
|
+
};
|
|
13
|
+
var __values = (this && this.__values) || function(o) {
|
|
14
|
+
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
|
15
|
+
if (m) return m.call(o);
|
|
16
|
+
if (o && typeof o.length === "number") return {
|
|
17
|
+
next: function () {
|
|
18
|
+
if (o && i >= o.length) o = void 0;
|
|
19
|
+
return { value: o && o[i++], done: !o };
|
|
20
|
+
}
|
|
21
|
+
};
|
|
22
|
+
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
|
23
|
+
};
|
|
24
|
+
var __read = (this && this.__read) || function (o, n) {
|
|
25
|
+
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
|
26
|
+
if (!m) return o;
|
|
27
|
+
var i = m.call(o), r, ar = [], e;
|
|
28
|
+
try {
|
|
29
|
+
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
|
30
|
+
}
|
|
31
|
+
catch (error) { e = { error: error }; }
|
|
32
|
+
finally {
|
|
33
|
+
try {
|
|
34
|
+
if (r && !r.done && (m = i["return"])) m.call(i);
|
|
35
|
+
}
|
|
36
|
+
finally { if (e) throw e.error; }
|
|
37
|
+
}
|
|
38
|
+
return ar;
|
|
39
|
+
};
|
|
40
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
41
|
+
exports.SchemaFactory = void 0;
|
|
42
|
+
var SchemaFactory;
|
|
43
|
+
(function (SchemaFactory) {
|
|
44
|
+
function application(app) {
|
|
45
|
+
return [
|
|
46
|
+
schema((app === null || app === void 0 ? void 0 : app.metadata) || null),
|
|
47
|
+
{
|
|
48
|
+
components: components((app === null || app === void 0 ? void 0 : app.storage) || null)
|
|
49
|
+
}
|
|
50
|
+
];
|
|
51
|
+
}
|
|
52
|
+
SchemaFactory.application = application;
|
|
53
|
+
/* -----------------------------------------------------------
|
|
54
|
+
SCHEMA
|
|
55
|
+
----------------------------------------------------------- */
|
|
56
|
+
function schema(meta) {
|
|
57
|
+
var e_1, _a, e_2, _b, e_3, _c;
|
|
58
|
+
if (meta === null)
|
|
59
|
+
return {};
|
|
60
|
+
var unions = [];
|
|
61
|
+
try {
|
|
62
|
+
for (var _d = __values(meta.atomics), _e = _d.next(); !_e.done; _e = _d.next()) {
|
|
63
|
+
var type = _e.value;
|
|
64
|
+
unions.push(generate_atomic(type, meta.nullable));
|
|
65
|
+
}
|
|
66
|
+
}
|
|
67
|
+
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
|
68
|
+
finally {
|
|
69
|
+
try {
|
|
70
|
+
if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
|
|
71
|
+
}
|
|
72
|
+
finally { if (e_1) throw e_1.error; }
|
|
73
|
+
}
|
|
74
|
+
try {
|
|
75
|
+
for (var _f = __values(meta.objects.values()), _g = _f.next(); !_g.done; _g = _f.next()) {
|
|
76
|
+
var address = _g.value;
|
|
77
|
+
unions.push(generate_pointer(address));
|
|
78
|
+
}
|
|
79
|
+
}
|
|
80
|
+
catch (e_2_1) { e_2 = { error: e_2_1 }; }
|
|
81
|
+
finally {
|
|
82
|
+
try {
|
|
83
|
+
if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
|
|
84
|
+
}
|
|
85
|
+
finally { if (e_2) throw e_2.error; }
|
|
86
|
+
}
|
|
87
|
+
try {
|
|
88
|
+
for (var _h = __values(meta.arraies.values()), _j = _h.next(); !_j.done; _j = _h.next()) {
|
|
89
|
+
var schema_1 = _j.value;
|
|
90
|
+
unions.push(generate_array(schema_1, meta.nullable));
|
|
91
|
+
}
|
|
92
|
+
}
|
|
93
|
+
catch (e_3_1) { e_3 = { error: e_3_1 }; }
|
|
94
|
+
finally {
|
|
95
|
+
try {
|
|
96
|
+
if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
|
|
97
|
+
}
|
|
98
|
+
finally { if (e_3) throw e_3.error; }
|
|
99
|
+
}
|
|
100
|
+
if (unions.length === 0)
|
|
101
|
+
return { description: meta.description };
|
|
102
|
+
else if (unions.length === 1)
|
|
103
|
+
return __assign({ description: meta.description }, unions[0]);
|
|
104
|
+
else
|
|
105
|
+
return {
|
|
106
|
+
description: meta.description,
|
|
107
|
+
anyOf: unions
|
|
108
|
+
};
|
|
109
|
+
}
|
|
110
|
+
SchemaFactory.schema = schema;
|
|
111
|
+
function generate_atomic(type, nullable) {
|
|
112
|
+
return {
|
|
113
|
+
type: type,
|
|
114
|
+
nullable: nullable,
|
|
115
|
+
};
|
|
116
|
+
}
|
|
117
|
+
function generate_pointer(address) {
|
|
118
|
+
return {
|
|
119
|
+
$ref: address
|
|
120
|
+
};
|
|
121
|
+
}
|
|
122
|
+
function generate_array(metadata, nullable) {
|
|
123
|
+
return {
|
|
124
|
+
type: "array",
|
|
125
|
+
items: schema(metadata),
|
|
126
|
+
nullable: nullable
|
|
127
|
+
};
|
|
128
|
+
}
|
|
129
|
+
/* -----------------------------------------------------------
|
|
130
|
+
COMPONENTS
|
|
131
|
+
----------------------------------------------------------- */
|
|
132
|
+
function components(storage) {
|
|
133
|
+
var e_4, _a;
|
|
134
|
+
var schemas = {};
|
|
135
|
+
try {
|
|
136
|
+
for (var _b = __values(Object.entries(storage || [])), _c = _b.next(); !_c.done; _c = _b.next()) {
|
|
137
|
+
var _d = __read(_c.value, 2), key = _d[0], value = _d[1];
|
|
138
|
+
schemas[key] = generate_object(value);
|
|
139
|
+
}
|
|
140
|
+
}
|
|
141
|
+
catch (e_4_1) { e_4 = { error: e_4_1 }; }
|
|
142
|
+
finally {
|
|
143
|
+
try {
|
|
144
|
+
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
|
145
|
+
}
|
|
146
|
+
finally { if (e_4) throw e_4.error; }
|
|
147
|
+
}
|
|
148
|
+
return { schemas: schemas };
|
|
149
|
+
}
|
|
150
|
+
SchemaFactory.components = components;
|
|
151
|
+
function generate_object(obj) {
|
|
152
|
+
var e_5, _a;
|
|
153
|
+
var properties = {};
|
|
154
|
+
var required = [];
|
|
155
|
+
try {
|
|
156
|
+
for (var _b = __values(Object.entries(obj.properties || [])), _c = _b.next(); !_c.done; _c = _b.next()) {
|
|
157
|
+
var _d = __read(_c.value, 2), key = _d[0], value = _d[1];
|
|
158
|
+
properties[key] = schema(value);
|
|
159
|
+
if ((value === null || value === void 0 ? void 0 : value.required) === true)
|
|
160
|
+
required.push(key);
|
|
161
|
+
}
|
|
162
|
+
}
|
|
163
|
+
catch (e_5_1) { e_5 = { error: e_5_1 }; }
|
|
164
|
+
finally {
|
|
165
|
+
try {
|
|
166
|
+
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
|
|
167
|
+
}
|
|
168
|
+
finally { if (e_5) throw e_5.error; }
|
|
169
|
+
}
|
|
170
|
+
return {
|
|
171
|
+
type: "object",
|
|
172
|
+
properties: properties,
|
|
173
|
+
nullable: obj.nullable,
|
|
174
|
+
required: required,
|
|
175
|
+
description: obj.description,
|
|
176
|
+
};
|
|
177
|
+
}
|
|
178
|
+
})(SchemaFactory = exports.SchemaFactory || (exports.SchemaFactory = {}));
|
|
179
|
+
//# sourceMappingURL=SchemaFactory.js.map
|
|
@@ -0,0 +1,7 @@
|
|
|
1
|
+
import ts from "typescript";
|
|
2
|
+
export declare namespace TypeFactory {
|
|
3
|
+
function escape(checker: ts.TypeChecker, type: ts.Type): [ts.Type, boolean];
|
|
4
|
+
function is_function(node: ts.Node): boolean;
|
|
5
|
+
function full_name(checker: ts.TypeChecker, type: ts.Type): string;
|
|
6
|
+
}
|
|
7
|
+
//# sourceMappingURL=TypeFactry.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"TypeFactry.d.ts","sourceRoot":"","sources":["../../src/factories/TypeFactry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,yBAAiB,WAAW,CAC5B;IACI,SAAgB,MAAM,CAAC,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,CAIjF;IAED,SAAgB,WAAW,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,OAAO,CAGlD;IAuCD,SAAgB,SAAS,CAAC,OAAO,EAAE,EAAE,CAAC,WAAW,EAAE,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,MAAM,CAoCxE;CAiBJ"}
|
|
@@ -0,0 +1,76 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
var __importDefault = (this && this.__importDefault) || function (mod) {
|
|
3
|
+
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
4
|
+
};
|
|
5
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
6
|
+
exports.TypeFactory = void 0;
|
|
7
|
+
var typescript_1 = __importDefault(require("typescript"));
|
|
8
|
+
var TypeFactory;
|
|
9
|
+
(function (TypeFactory) {
|
|
10
|
+
function escape(checker, type) {
|
|
11
|
+
var converted = get_return_type(checker, type, "toJSON");
|
|
12
|
+
return [converted || type, !!converted];
|
|
13
|
+
}
|
|
14
|
+
TypeFactory.escape = escape;
|
|
15
|
+
function is_function(node) {
|
|
16
|
+
return get_function(node) !== null;
|
|
17
|
+
}
|
|
18
|
+
TypeFactory.is_function = is_function;
|
|
19
|
+
function get_function(node) {
|
|
20
|
+
return typescript_1.default.isFunctionLike(node)
|
|
21
|
+
? node
|
|
22
|
+
: (typescript_1.default.isPropertyAssignment(node) || typescript_1.default.isPropertyDeclaration(node))
|
|
23
|
+
? typescript_1.default.isFunctionLike(node.initializer)
|
|
24
|
+
? node.initializer
|
|
25
|
+
: null
|
|
26
|
+
: null;
|
|
27
|
+
}
|
|
28
|
+
function get_return_type(checker, type, name) {
|
|
29
|
+
// FIND TO-JSON METHOD
|
|
30
|
+
var symbol = type.getProperty(name);
|
|
31
|
+
if (!symbol)
|
|
32
|
+
return null;
|
|
33
|
+
else if (!symbol.declarations || !symbol.declarations[0])
|
|
34
|
+
return null;
|
|
35
|
+
// GET FUNCTION DECLARATION
|
|
36
|
+
var declaration = symbol.declarations[0];
|
|
37
|
+
var functor = get_function(declaration);
|
|
38
|
+
if (functor === null)
|
|
39
|
+
return null;
|
|
40
|
+
// RETURNS THE RETURN-TYPE
|
|
41
|
+
var signature = checker.getSignatureFromDeclaration(functor);
|
|
42
|
+
return signature ? signature.getReturnType() : null;
|
|
43
|
+
}
|
|
44
|
+
function full_name(checker, type) {
|
|
45
|
+
// PRIMITIVE
|
|
46
|
+
var symbol = type.getSymbol() || type.aliasSymbol;
|
|
47
|
+
if (symbol === undefined)
|
|
48
|
+
return checker.typeToString(type, undefined, undefined);
|
|
49
|
+
// UNION OR INTERSECT
|
|
50
|
+
else if (type.aliasSymbol === undefined && type.isUnionOrIntersection()) {
|
|
51
|
+
var joiner = type.isIntersection() ? " & " : " | ";
|
|
52
|
+
return type.types.map(function (child) { return full_name(checker, child); }).join(joiner);
|
|
53
|
+
}
|
|
54
|
+
//----
|
|
55
|
+
// SPECIALIZATION
|
|
56
|
+
//----
|
|
57
|
+
var name = get_name(symbol);
|
|
58
|
+
// CHECK GENERIC
|
|
59
|
+
var generic = checker.getTypeArguments(type);
|
|
60
|
+
return generic.length
|
|
61
|
+
? name === "Promise"
|
|
62
|
+
? full_name(checker, generic[0])
|
|
63
|
+
: "".concat(name, "<").concat(generic.map(function (child) { return full_name(checker, child); }).join(", "), ">")
|
|
64
|
+
: name;
|
|
65
|
+
}
|
|
66
|
+
TypeFactory.full_name = full_name;
|
|
67
|
+
function explore_name(name, decl) {
|
|
68
|
+
return typescript_1.default.isModuleBlock(decl)
|
|
69
|
+
? explore_name("".concat(decl.parent.name.getText(), ".").concat(name), decl.parent.parent)
|
|
70
|
+
: name;
|
|
71
|
+
}
|
|
72
|
+
function get_name(symbol) {
|
|
73
|
+
return explore_name(symbol.escapedName.toString(), symbol.getDeclarations()[0].parent);
|
|
74
|
+
}
|
|
75
|
+
})(TypeFactory = exports.TypeFactory || (exports.TypeFactory = {}));
|
|
76
|
+
//# sourceMappingURL=TypeFactry.js.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"SwaggerGenerator.d.ts","sourceRoot":"","sources":["../../src/generates/SwaggerGenerator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,YAAY,CAAC;
|
|
1
|
+
{"version":3,"file":"SwaggerGenerator.d.ts","sourceRoot":"","sources":["../../src/generates/SwaggerGenerator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,YAAY,CAAC;AAG5B,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAU9C,yBAAiB,gBAAgB,CACjC;IACI,SAAsB,QAAQ,CAEtB,OAAO,EAAE,EAAE,CAAC,WAAW,EACvB,MAAM,EAAE,cAAc,CAAC,QAAQ,EAC/B,SAAS,EAAE,MAAM,EAAE,GACpB,OAAO,CAAC,IAAI,CAAC,CAsCnB;CAuMJ"}
|