swagger-typescript-api/src/components.js at master · FlyAlgorithm/swagger-typescript-api · GitHub

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
const _ = require("lodash");
const { parseSchema } = require("./schema");
const { config } = require("./config");

/**
 * @typedef {"schemas" | "examples" | "headers" | "parameters" | "requestBodies" | "responses" | "securitySchemes"} ComponentName
 * @typedef {object} RawTypeData
 * @typedef {{ type, typeIdentifier, name, description, content }} TypeData
 *
 * @typedef {{
 *  typeName: string;
 *  componentName: ComponentName;
 *  rawTypeData: RawTypeData;
 *  typeData: TypeData | null;
 * }} TypeInfo
 */

/**
 *
 * @param {ComponentName} componentName
 * @param {string} typeName
 * @param {RawTypeData} rawTypeData
 * @returns {TypeInfo}
 */
const createComponent = (componentName, typeName, rawTypeData) => {
  const $ref = `#/components/${componentName}/${typeName}`;

  const componentSchema = {
    $ref,
    typeName,
    rawTypeData,
    componentName,
    typeData: null,
  };

  const usageComponent = config.hooks.onCreateComponent(componentSchema) || componentSchema;

  config.componentsMap[$ref] = usageComponent;

  return usageComponent;
};

/**
 * @returns {{ [key: string]: TypeInfo }}
 */
const createComponentsMap = (components) => {
  config.componentsMap = {};

  _.each(components, (component, componentName) =>
    _.each(component, (rawTypeData, typeName) =>
      createComponent(componentName, typeName, rawTypeData),
    ),
  );

  return config.componentsMap;
};

/**
 *
 * @param {{ [key: string]: TypeInfo }} componentsMap
 * @param {ComponentName} componentName
 * @returns {TypeInfo[]}
 */
const filterComponentsMap = (componentsMap, componentName) =>
  _.filter(componentsMap, (v, ref) => _.startsWith(ref, `#/components/${componentName}`));

/**
 *
 * @param {TypeInfo} typeInfo
 * @returns {TypeData}
 */
const getTypeData = (typeInfo) => {
  if (!typeInfo.typeData) {
    typeInfo.typeData = parseSchema(typeInfo.rawTypeData, typeInfo.typeName);
  }

  return typeInfo.typeData;
};

/**
 *
 * @param {string} ref
 * @returns {TypeInfo | undefined}
 */
const getComponentByRef = (ref) => config.componentsMap[ref];

module.exports = {
  getTypeData,
  createComponent,
  createComponentsMap,
  filterComponentsMap,
  getComponentByRef,
};