digio / oaat / 12

pending completion

Build # 12

Build Type

Pull #1

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/digio/oaat/commit/<a class=hub.com/digio/oaat/commit/<a class="double-link" href="https://git"><a class=hub.com/digio/oaat/commit/<a class="double-link" href="https://git"><a class=hub.com/digio/oaat/commit/aac22345ad9ce71d6b9820f6911687b80981f2b6">aac22345a<a href="https://github.com/digio/oaat/commit/aac22345ad9ce71d6b9820f6911687b80981f2b6">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/digio/oaat/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/digio/oaat/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/digio/oaat/commit/aac22345ad9ce71d6b9820f6911687b80981f2b6&quot;&gt;aac22345a&lt;/a&gt;&lt;a href=&quot;https://github.com/digio/oaat/commit/aac22345ad9ce71d6b9820f6911687b80981f2b6&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/digio/oaat/commit/aac22345ad9ce71d6b9820f6911687b8&lt;/a&gt;0981f2b6">&quot;&gt;Merge &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/digio/oaat/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/digio/oaat/commit/<a class="double-link" href="https://github.com/digio/oaat/commit/bb8c4dbc1d42cbdf7712229f553ecdd0b01a3bd3">bb8c4dbc1</a><a href="https://github.com/digio/oaat/commit/aac22345ad9ce71d6b9820f6911687b80981f2b6">&amp;quot;&amp;gt;bb8c4dbc1&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;bb8c4dbc1&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/digio/oaat/commit/aac22345ad9ce71d6b9820f6911687b80981f&lt;/a&gt;2b6&quot;&gt; into &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/digio/oaat/commit/<a class="double-link" href="https://github.com/digio/oaat/commit/f8ca5112b">f8ca5112b">f8ca5112b</a>

Pull Request Pull Request #1: feat(logging): standardise endpoint logging

Run Details

150 of 260 branches covered (57.69%)

Branch coverage included in aggregate %.

18 of 18 new or added lines in 5 files covered. (100.0%)

346 of 603 relevant lines covered (57.38%)

5.31 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/build.js

const { join } = require('upath');
const logger = require('winston');
const {
  EXAMPLE_PROP_NAME,
  IGNORE_PROPERTY_PROP_NAME,
  IGNORE_ENDPOINT_NAME,
  MOCK_FILE_PROP,
  pipe,
  getAbsSpecFilePath,
  readJsonFile,
  traverse,
  validateSpecObj,
  writeOutputFile,
} = require('./utils');
const cloneDeep = require('lodash/cloneDeep');
const { readFileSync } = require('fs');
const { getShortEndpointName } = require('./utils/endpoints');

const AMAZON_INTEGRATION_PROP = 'x-amazon-apigateway-integration';
const WEB_PAGE_SPEC_FILE_TOKEN = '"$$_specFileUrl_$$"';
const WEB_PAGE_LOGO_TOKEN = '$$_logoUrl_$$';
const WEB_PAGE_TITLE = '$$_title_$$';
const WEB_PAGE_FAVICON_HREF = '$$_faviconHref_$$';
const APPLICATION_JSON = 'application/json';

async function addGatewayInfo(specFile, server, config) {
  const specObj = readJsonFile(specFile);
  await validateSpecObj({ specObj }); // We have to validate before we try to read the file cntents
  const absSpecFilePath = getAbsSpecFilePath(specFile);
  const destPath = getAbsSpecFilePath(config.outputFile ? config.outputFile : specFile);
  const serverUrl = server || specObj.servers[0].url;

  // define the data processing pipeline
  const pipeline = pipe(
    setServerUrl,
    decorateExistingEndpoints,
    removeSchemasIfMock,
    addRequiredSchemas,
    addSpecFileEndpoint,
    addWebsiteEndpoint,
    filterSchemas,
    writeOutputFile,
    () => {
      if (config.mock) {
        logger.info(`Written ${config.outputFile} with mock responses`);
      } else if (config.proxy) {
        logger.info(`Written ${config.outputFile}, proxying responses to ${serverUrl}`);
      } else {
        logger.info(`Written ${config.outputFile}`);
      }
    },
  );

  return pipeline({
    specObj,
    serverUrl,
    destPath,
    specFile,
    originalSpecObj: cloneDeep(specObj),
    absSpecFilePath,
    config,
  });
}

function setServerUrl(params) {
  const { specObj, serverUrl } = params;

  if (serverUrl) {
    specObj.servers = [{ url: serverUrl }];
  }

  return params;
}

function decorateExistingEndpoints(params) {
  const { specObj } = params;

  specObj.paths = mockAPIEndpoints(params);

  return params;
}

function mockAPIEndpoints(params) {
  const { specObj, config, destPath, serverUrl } = params;
  const newConfig = { isMock: config.mock, isProxy: config.proxy, destPath, serverUrl };
  return Object.keys(specObj.paths).reduce(
    (acc, path) => ({ ...acc, ...transformEndpoint(newConfig, path, specObj.paths[path]) }),
    {},
  );
}

// For each response in the endpoint, we need to produce a new endpoint with example data
// (except for the 200 response, which inherits the original endpointName
function transformEndpoint(config, path, data) {
  const newEndPoints = Object.keys(data).reduce((acc, method) => {
    // If this path-method should be ignored, ignore it
    if (data[method][IGNORE_ENDPOINT_NAME]) {
      return acc;
    }

    // Attach the path-status (with child-method) configs to the accumulated config.
    // Effectively, we group the path-status keys together, with their method
    // config as a child property - just like in specFile
    const pathStatusConfig = transformEndpointMethod(config, path, method, data[method]);
    Object.keys(pathStatusConfig).forEach((pathStatus) => {
      acc[pathStatus] = { ...acc[pathStatus], ...pathStatusConfig[pathStatus] };
    });

    return acc;
  }, {});

  return newEndPoints;
}

// We need to iterate over the response codes as well
function transformEndpointMethod(config, path, method, data) {
  if (config.isMock) {
    const newEndPoints = Object.keys(data.responses).reduce((acc, statusCode) => {
      // We get back an array of configs, which could be empty
      const mockConfigs = mockEndpointMethodStatus({ path, method, statusCode, data, destPath: config.destPath });

      // logger.debug('config', newPath, config);

      mockConfigs.forEach(({ newPath, apiConfig }) => {
        acc[newPath] = { ...acc[newPath], ...apiConfig };
      });

      return { ...acc };
    }, {});
    // logger.debug(newEndPoints);
    return newEndPoints;
  }

  if (config.isProxy) {
    const newEndPoints = proxyEndpointMethod(path, method, config.serverUrl, data);
    logger.debug('newEndpoints', newEndPoints);
    return newEndPoints;
  }

  // Else, the only thing we wand to do is have the web and swagger endpoints (not expose the specObj endpoints)
  return {};
}

function mockEndpointMethodStatus(mockMethodParams) {
  const { path, method, statusCode, data, destPath } = mockMethodParams;

  // If the response should be ignored, ignore it.
  if (data.responses[statusCode][IGNORE_ENDPOINT_NAME]) {
    logger.info(`Ignoring '${getShortEndpointName(method, path)}' ${statusCode}`);
    return [];
  }
  const endpointName = statusCode === '200' ? path : `${path}/${statusCode}`;

  // Use the x-mock-file prop instead of the x-examples
  const mockFileObj = data.responses[statusCode][MOCK_FILE_PROP];

  // the list of configs to create
  let configs = [];

  // If it is a string, great
  if (typeof mockFileObj === 'string') {
    logger.info(`Mocking '${getShortEndpointName(method, endpointName)}' with '${mockFileObj}'`);
    configs.push({
      pathName: endpointName,
      responseData: readResponseFile(destPath, mockFileObj),
      parameters: data.parameters,
    });
  }

  // if it is an object, we need to build an array of responses.
  // Object looks like this: { "endpointName": "responseFile", "endPoint2": ... }
  if (typeof mockFileObj === 'object') {
    const mockFiles = Object.entries(mockFileObj);

    // This approach only makes sense for path-parameters. Anything else - body, query or header params - won't work.

    configs = mockFiles.map(([pathName, responseFilePath]) => {
      logger.info(`Mocking '${getShortEndpointName(method, pathName)}' with ${responseFilePath}`);
      return {
        pathName,
        responseData: readResponseFile(destPath, responseFilePath),
        parameters: [], // Set this to blank, as by using multiple mock responses, we are indicating that we have pre-filled the parameters.
      };
    });

    // Also add the default config as an endpoint
    logger.info(`Mocking '${getShortEndpointName(method, endpointName)}' with ${mockFiles[0][1]}`);
    configs.push({ pathName: endpointName, responseData: mockFiles[0][1], parameters: data.parameters });
  }

  return configs.map(({ pathName, responseData }) => ({
    newPath: pathName,
    apiConfig: {
      [method]: {
        ...data,
        // Remove these so we can remove the existing components/schemas block and so APIG doesn't complain
        parameters: undefined,
        requestBody: undefined,
        security: undefined,
        responses: {
          [statusCode]: {
            ...data.responses[statusCode],
            // Remove the examples and custom headers
            [MOCK_FILE_PROP]: undefined,
            [EXAMPLE_PROP_NAME]: undefined,
            [IGNORE_PROPERTY_PROP_NAME]: undefined,
            // Replace the application/json schema (because it doesn't matter at all for the mock API, and the schema isn't needed by APIG)
            // Doing this also avoids a bunch of APIG errors that can occur due schema-features that it does not support
            content: {
              [APPLICATION_JSON]: {
                schema: { $ref: '#/components/schemas/Empty' },
              },
            },
          },
        },
        ...getAWSMockIntegrationResponse(statusCode, { [APPLICATION_JSON]: JSON.stringify(responseData) }),
      },
    },
  }));
}

function readResponseFile(destPath, relResponseFilePath) {
  try {
    return require(join(destPath, relResponseFilePath));
  } catch {
    logger.debug(`Could not read ${destPath}${relResponseFilePath}`);
    return '';
  }
}

function proxyEndpointMethod(path, method, serverUrl, data) {
  const requestParameters = {};
  // Must be in the format: "integration.request.{path|querystring|header}.{paramName}" : "method.request.{path|querystring|header}.{paramName}"

  return {
    [path]: {
      [method]: {
        ...data,
        ...getAWSHttpProxyIntegrationResponse(method, `${serverUrl}${path}`),
      },
    },
  };
}

function getAWSSupportedDefinitions(data) {
  return traverse(data, filterNonAWSSupportedNodes);
}

function filterNonAWSSupportedNodes(obj, key) {
  if (key === 'example') {
    return { ...obj, [key]: undefined };
  }
  return obj;
}

function removeSchemasIfMock(params) {
  // If we are using a Mock integration, the schemas aren't needed at all (other than the ones we add next)
  const { config, specObj } = params;

  if (config.mock) {
    specObj.components.schemas = undefined;
    specObj.components.securitySchemes = undefined;
    specObj.components.requestBodies = undefined;
  }

  return params;
}

function addRequiredSchemas(params) {
  const { specObj } = params;

  specObj.components.schemas = specObj.components.schemas || {};

  // Add the Empty type for API Gateway CORS responses
  specObj.components.schemas.Empty = {
    type: 'object',
    title: 'Empty response model for AWS + CORS use',
  };

  // Add the StringResponse type too
  specObj.components.schemas.StringResponse = {
    type: 'string',
    title: 'String-type workaround for API Gateway',
  };

  return params;
}

function addSpecFileEndpoint(params) {
  const { originalSpecObj, specObj, config, serverUrl } = params;

  // We can filter out the AMAZON_INTEGRATION_PROP properties, as they are quite large
  const filteredSwagger = getSmallerSwaggerForWebsite(originalSpecObj);

  // Add the serverUrl to the list of servers if it is not already in the list
  const urls = new Set(filteredSwagger.servers.map((i) => i.url));
  if (!urls.has(serverUrl)) {
    filteredSwagger.servers.unshift({ url: serverUrl });
  }

  specObj.paths[config.specFileEndpoint] = {
    get: {
      'x-ignore': true,
      tags: ['meta'],
      summary: 'Open API Spec schema',
      parameters: [],
      responses: {
        200: {
          description: 'Successful Operation',
          content: {
            [APPLICATION_JSON]: {
              schema: {
                $ref: '#/components/schemas/StringResponse', // Just need *something* for this to work
              },
            },
          },
          headers: {
            'Access-Control-Allow-Origin': {
              schema: {
                type: 'string',
              },
            },
            'Access-Control-Allow-Methods': {
              schema: {
                type: 'string',
              },
            },
            'Access-Control-Allow-Headers': {
              schema: {
                type: 'string',
              },
            },
          },
        },
      },
      ...getAWSMockIntegrationResponse(
        '200',
        { [APPLICATION_JSON]: JSON.stringify(filteredSwagger).replace(/"\$ref"/g, '"\\$ref"') }, // We need to escape "$ref", as AWS treats any property starting with "$" as a Velocity template variable!
        {
          'method.response.header.Access-Control-Allow-Methods': "'GET,OPTIONS'",
          'method.response.header.Access-Control-Allow-Headers':
            "'Content-Type,X-Amz-Date,Authorization,X-Api-Key,X-Amz-Security-Token'",
          'method.response.header.Access-Control-Allow-Origin': "'*'",
        },
      ),
    },
    ...getCORSOptionsResponse(),
  };

  return params;
}

function addWebsiteEndpoint(params) {
  const { specObj, config } = params;
  // Read the template
  const websiteTemplate = readFileSync(join(__dirname, 'web/index.html')).toString();

  // Inject the specFile document into the template, replacing the template variable $$_swaggerObj_$$
  const websiteData = websiteTemplate
    .replace(WEB_PAGE_SPEC_FILE_TOKEN, `'${config.specFileEndpoint}'`)
    .replace(WEB_PAGE_LOGO_TOKEN, config.webLogoUrl)
    .replace(WEB_PAGE_TITLE, config.webTitle)
    .replace(WEB_PAGE_FAVICON_HREF, config.webFaviconHref);

  logger.debug('Website data', websiteData);

  specObj.paths[config.specUIEndpoint] = {
    get: {
      'x-ignore': true,
      tags: ['meta'],
      responses: {
        200: {
          description: '200 response',
          content: {
            'text/html': {
              schema: { $ref: '#/components/schemas/StringResponse' },
              example: {
                value: '<html><body>Your HTML text</body></html>',
              },
            },
          },
        },
      },
      ...getAWSMockIntegrationResponse(200, { 'text/html': websiteData }),
    },
  };

  return params;
}

function filterSchemas(params) {
  const { specObj } = params;
  // Filter the schemas AFTER we have built the website, so that the schemas have examples
  specObj.components.schemas = getAWSSupportedDefinitions(specObj.components.schemas);

  return params;
}

/**
 * Remove data from the swagger.json that doesn't need to be rendered.
 * @param data
 * @return {*}
 */
function getSmallerSwaggerForWebsite(data) {
  return traverse(data, filterNonWebsiteRequiredNodes);
}

function filterNonWebsiteRequiredNodes(obj, key) {
  if (key === AMAZON_INTEGRATION_PROP) {
    return { ...obj, [key]: undefined };
  }
  return obj;
}

function getAWSMockIntegrationResponse(statusCode, responseTemplates, responseParameters) {
  return {
    [AMAZON_INTEGRATION_PROP]: {
      type: 'MOCK',
      responses: {
        default: {
          statusCode: String(statusCode),
          responseTemplates,
          responseParameters,
        },
      },
      requestTemplates: {
        [APPLICATION_JSON]: '{"statusCode": 200}',
      },
      passthroughBehavior: 'when_no_match',
    },
  };
}

function getAWSHttpProxyIntegrationResponse(httpMethod, uri, requestParameters) {
  return {
    [AMAZON_INTEGRATION_PROP]: {
      type: 'HTTP_PROXY',
      httpMethod,
      uri,
      requestParameters,
    },
  };
}

function getCORSOptionsResponse() {
  return {
    options: {
      responses: {
        200: {
          description: '200 response',
          content: {
            [APPLICATION_JSON]: {
              schema: {
                $ref: '#/components/schemas/Empty',
              },
            },
          },
          headers: {
            'Access-Control-Allow-Origin': {
              schema: {
                type: 'string',
              },
            },
            'Access-Control-Allow-Methods': {
              schema: {
                type: 'string',
              },
            },
            'Access-Control-Allow-Headers': {
              schema: {
                type: 'string',
              },
            },
          },
        },
      },
      ...getAWSMockIntegrationResponse('200', undefined, {
        'method.response.header.Access-Control-Allow-Methods': "'GET,OPTIONS'",
        'method.response.header.Access-Control-Allow-Headers':
          "'Content-Type,X-Amz-Date,Authorization,X-Api-Key,X-Amz-Security-Token'",
        'method.response.header.Access-Control-Allow-Origin': "'*'",
      }),
    },
  };
}

module.exports = {
  addGatewayInfo,
};

1	const { join } = require('upath');	×
2	const logger = require('winston');	×
3	const {
4	EXAMPLE_PROP_NAME,
5	IGNORE_PROPERTY_PROP_NAME,
6	IGNORE_ENDPOINT_NAME,
7	MOCK_FILE_PROP,
8	pipe,
9	getAbsSpecFilePath,
10	readJsonFile,
11	traverse,
12	validateSpecObj,
13	writeOutputFile,
14	} = require('./utils');	×
15	const cloneDeep = require('lodash/cloneDeep');	×
16	const { readFileSync } = require('fs');	×
17	const { getShortEndpointName } = require('./utils/endpoints');	×
18
19	const AMAZON_INTEGRATION_PROP = 'x-amazon-apigateway-integration';	×
20	const WEB_PAGE_SPEC_FILE_TOKEN = '"$$_specFileUrl_$$"';	×
21	const WEB_PAGE_LOGO_TOKEN = '$$_logoUrl_$$';	×
22	const WEB_PAGE_TITLE = '$$_title_$$';	×
23	const WEB_PAGE_FAVICON_HREF = '$$_faviconHref_$$';	×
24	const APPLICATION_JSON = 'application/json';	×
25
26	async function addGatewayInfo(specFile, server, config) {
27	const specObj = readJsonFile(specFile);	×
28	await validateSpecObj({ specObj }); // We have to validate before we try to read the file cntents	×
29	const absSpecFilePath = getAbsSpecFilePath(specFile);	×
30	const destPath = getAbsSpecFilePath(config.outputFile ? config.outputFile : specFile);	×
31	const serverUrl = server \|\| specObj.servers[0].url;	×
32
33	// define the data processing pipeline
34	const pipeline = pipe(	×
35	setServerUrl,
36	decorateExistingEndpoints,
37	removeSchemasIfMock,
38	addRequiredSchemas,
39	addSpecFileEndpoint,
40	addWebsiteEndpoint,
41	filterSchemas,
42	writeOutputFile,
43	() => {
44	if (config.mock) {	×
45	logger.info(`Written ${config.outputFile} with mock responses`);	×
46	} else if (config.proxy) {	×
47	logger.info(`Written ${config.outputFile}, proxying responses to ${serverUrl}`);	×
48	} else {
49	logger.info(`Written ${config.outputFile}`);	×
50	}
51	},
52	);
53
54	return pipeline({	×
55	specObj,
56	serverUrl,
57	destPath,
58	specFile,
59	originalSpecObj: cloneDeep(specObj),
60	absSpecFilePath,
61	config,
62	});
63	}
64
65	function setServerUrl(params) {
66	const { specObj, serverUrl } = params;	×
67
68	if (serverUrl) {	×
69	specObj.servers = [{ url: serverUrl }];	×
70	}
71
72	return params;	×
73	}
74
75	function decorateExistingEndpoints(params) {
76	const { specObj } = params;	×
77
78	specObj.paths = mockAPIEndpoints(params);	×
79
80	return params;	×
81	}
82
83	function mockAPIEndpoints(params) {
84	const { specObj, config, destPath, serverUrl } = params;	×
85	const newConfig = { isMock: config.mock, isProxy: config.proxy, destPath, serverUrl };	×
86	return Object.keys(specObj.paths).reduce(	×
87	(acc, path) => ({ ...acc, ...transformEndpoint(newConfig, path, specObj.paths[path]) }),	×
88	{},
89	);
90	}
91
92	// For each response in the endpoint, we need to produce a new endpoint with example data
93	// (except for the 200 response, which inherits the original endpointName
94	function transformEndpoint(config, path, data) {
95	const newEndPoints = Object.keys(data).reduce((acc, method) => {	×
96	// If this path-method should be ignored, ignore it
97	if (data[method][IGNORE_ENDPOINT_NAME]) {	×
98	return acc;	×
99	}
100
101	// Attach the path-status (with child-method) configs to the accumulated config.
102	// Effectively, we group the path-status keys together, with their method
103	// config as a child property - just like in specFile
104	const pathStatusConfig = transformEndpointMethod(config, path, method, data[method]);	×
105	Object.keys(pathStatusConfig).forEach((pathStatus) => {	×
106	acc[pathStatus] = { ...acc[pathStatus], ...pathStatusConfig[pathStatus] };	×
107	});
108
109	return acc;	×
110	}, {});
111
112	return newEndPoints;	×
113	}
114
115	// We need to iterate over the response codes as well
116	function transformEndpointMethod(config, path, method, data) {
117	if (config.isMock) {	×
118	const newEndPoints = Object.keys(data.responses).reduce((acc, statusCode) => {	×
119	// We get back an array of configs, which could be empty
120	const mockConfigs = mockEndpointMethodStatus({ path, method, statusCode, data, destPath: config.destPath });	×
121
122	// logger.debug('config', newPath, config);
123
124	mockConfigs.forEach(({ newPath, apiConfig }) => {	×
125	acc[newPath] = { ...acc[newPath], ...apiConfig };	×
126	});
127
128	return { ...acc };	×
129	}, {});
130	// logger.debug(newEndPoints);
131	return newEndPoints;	×
132	}
133
134	if (config.isProxy) {	×
135	const newEndPoints = proxyEndpointMethod(path, method, config.serverUrl, data);	×
136	logger.debug('newEndpoints', newEndPoints);	×
137	return newEndPoints;	×
138	}
139
140	// Else, the only thing we wand to do is have the web and swagger endpoints (not expose the specObj endpoints)
141	return {};	×
142	}
143
144	function mockEndpointMethodStatus(mockMethodParams) {
145	const { path, method, statusCode, data, destPath } = mockMethodParams;	×
146
147	// If the response should be ignored, ignore it.
148	if (data.responses[statusCode][IGNORE_ENDPOINT_NAME]) {	×
149	logger.info(`Ignoring '${getShortEndpointName(method, path)}' ${statusCode}`);	×
150	return [];	×
151	}
152	const endpointName = statusCode === '200' ? path : `${path}/${statusCode}`;	×
153
154	// Use the x-mock-file prop instead of the x-examples
155	const mockFileObj = data.responses[statusCode][MOCK_FILE_PROP];	×
156
157	// the list of configs to create
158	let configs = [];	×
159
160	// If it is a string, great
161	if (typeof mockFileObj === 'string') {	×
162	logger.info(`Mocking '${getShortEndpointName(method, endpointName)}' with '${mockFileObj}'`);	×
163	configs.push({	×
164	pathName: endpointName,
165	responseData: readResponseFile(destPath, mockFileObj),
166	parameters: data.parameters,
167	});
168	}
169
170	// if it is an object, we need to build an array of responses.
171	// Object looks like this: { "endpointName": "responseFile", "endPoint2": ... }
172	if (typeof mockFileObj === 'object') {	×
173	const mockFiles = Object.entries(mockFileObj);	×
174
175	// This approach only makes sense for path-parameters. Anything else - body, query or header params - won't work.
176
177	configs = mockFiles.map(([pathName, responseFilePath]) => {	×
178	logger.info(`Mocking '${getShortEndpointName(method, pathName)}' with ${responseFilePath}`);	×
179	return {	×
180	pathName,
181	responseData: readResponseFile(destPath, responseFilePath),
182	parameters: [], // Set this to blank, as by using multiple mock responses, we are indicating that we have pre-filled the parameters.
183	};
184	});
185
186	// Also add the default config as an endpoint
187	logger.info(`Mocking '${getShortEndpointName(method, endpointName)}' with ${mockFiles[0][1]}`);	×
188	configs.push({ pathName: endpointName, responseData: mockFiles[0][1], parameters: data.parameters });	×
189	}
190
191	return configs.map(({ pathName, responseData }) => ({	×
192	newPath: pathName,
193	apiConfig: {
194	[method]: {
195	...data,
196	// Remove these so we can remove the existing components/schemas block and so APIG doesn't complain
197	parameters: undefined,
198	requestBody: undefined,
199	security: undefined,
200	responses: {
201	[statusCode]: {
202	...data.responses[statusCode],
203	// Remove the examples and custom headers
204	[MOCK_FILE_PROP]: undefined,
205	[EXAMPLE_PROP_NAME]: undefined,
206	[IGNORE_PROPERTY_PROP_NAME]: undefined,
207	// Replace the application/json schema (because it doesn't matter at all for the mock API, and the schema isn't needed by APIG)
208	// Doing this also avoids a bunch of APIG errors that can occur due schema-features that it does not support
209	content: {
210	[APPLICATION_JSON]: {
211	schema: { $ref: '#/components/schemas/Empty' },
212	},
213	},
214	},
215	},
216	...getAWSMockIntegrationResponse(statusCode, { [APPLICATION_JSON]: JSON.stringify(responseData) }),
217	},
218	},
219	}));
220	}
221
222	function readResponseFile(destPath, relResponseFilePath) {
223	try {	×
224	return require(join(destPath, relResponseFilePath));	×
225	} catch {
226	logger.debug(`Could not read ${destPath}${relResponseFilePath}`);	×
227	return '';	×
228	}
229	}
230
231	function proxyEndpointMethod(path, method, serverUrl, data) {
232	const requestParameters = {};	×
233	// Must be in the format: "integration.request.{path\|querystring\|header}.{paramName}" : "method.request.{path\|querystring\|header}.{paramName}"
234
235	return {	×
236	[path]: {
237	[method]: {
238	...data,
239	...getAWSHttpProxyIntegrationResponse(method, `${serverUrl}${path}`),
240	},
241	},
242	};
243	}
244
245	function getAWSSupportedDefinitions(data) {
246	return traverse(data, filterNonAWSSupportedNodes);	×
247	}
248
249	function filterNonAWSSupportedNodes(obj, key) {
250	if (key === 'example') {	×
251	return { ...obj, [key]: undefined };	×
252	}
253	return obj;	×
254	}
255
256	function removeSchemasIfMock(params) {
257	// If we are using a Mock integration, the schemas aren't needed at all (other than the ones we add next)
258	const { config, specObj } = params;	×
259
260	if (config.mock) {	×
261	specObj.components.schemas = undefined;	×
262	specObj.components.securitySchemes = undefined;	×
263	specObj.components.requestBodies = undefined;	×
264	}
265
266	return params;	×
267	}
268
269	function addRequiredSchemas(params) {
270	const { specObj } = params;	×
271
272	specObj.components.schemas = specObj.components.schemas \|\| {};	×
273
274	// Add the Empty type for API Gateway CORS responses
275	specObj.components.schemas.Empty = {	×
276	type: 'object',
277	title: 'Empty response model for AWS + CORS use',
278	};
279
280	// Add the StringResponse type too
281	specObj.components.schemas.StringResponse = {	×
282	type: 'string',
283	title: 'String-type workaround for API Gateway',
284	};
285
286	return params;	×
287	}
288
289	function addSpecFileEndpoint(params) {
290	const { originalSpecObj, specObj, config, serverUrl } = params;	×
291
292	// We can filter out the AMAZON_INTEGRATION_PROP properties, as they are quite large
293	const filteredSwagger = getSmallerSwaggerForWebsite(originalSpecObj);	×
294
295	// Add the serverUrl to the list of servers if it is not already in the list
296	const urls = new Set(filteredSwagger.servers.map((i) => i.url));	×
297	if (!urls.has(serverUrl)) {	×
298	filteredSwagger.servers.unshift({ url: serverUrl });	×
299	}
300
301	specObj.paths[config.specFileEndpoint] = {	×
302	get: {
303	'x-ignore': true,
304	tags: ['meta'],
305	summary: 'Open API Spec schema',
306	parameters: [],
307	responses: {
308	200: {
309	description: 'Successful Operation',
310	content: {
311	[APPLICATION_JSON]: {
312	schema: {
313	$ref: '#/components/schemas/StringResponse', // Just need something for this to work
314	},
315	},
316	},
317	headers: {
318	'Access-Control-Allow-Origin': {
319	schema: {
320	type: 'string',
321	},
322	},
323	'Access-Control-Allow-Methods': {
324	schema: {
325	type: 'string',
326	},
327	},
328	'Access-Control-Allow-Headers': {
329	schema: {
330	type: 'string',
331	},
332	},
333	},
334	},
335	},
336	...getAWSMockIntegrationResponse(
337	'200',
338	{ [APPLICATION_JSON]: JSON.stringify(filteredSwagger).replace(/"\$ref"/g, '"\\$ref"') }, // We need to escape "$ref", as AWS treats any property starting with "$" as a Velocity template variable!
339	{
340	'method.response.header.Access-Control-Allow-Methods': "'GET,OPTIONS'",
341	'method.response.header.Access-Control-Allow-Headers':
342	"'Content-Type,X-Amz-Date,Authorization,X-Api-Key,X-Amz-Security-Token'",
343	'method.response.header.Access-Control-Allow-Origin': "'*'",
344	},
345	),
346	},
347	...getCORSOptionsResponse(),
348	};
349
350	return params;	×
351	}
352
353	function addWebsiteEndpoint(params) {
354	const { specObj, config } = params;	×
355	// Read the template
356	const websiteTemplate = readFileSync(join(__dirname, 'web/index.html')).toString();	×
357
358	// Inject the specFile document into the template, replacing the template variable $$_swaggerObj_$$
359	const websiteData = websiteTemplate	×
360	.replace(WEB_PAGE_SPEC_FILE_TOKEN, `'${config.specFileEndpoint}'`)
361	.replace(WEB_PAGE_LOGO_TOKEN, config.webLogoUrl)
362	.replace(WEB_PAGE_TITLE, config.webTitle)
363	.replace(WEB_PAGE_FAVICON_HREF, config.webFaviconHref);
364
365	logger.debug('Website data', websiteData);	×
366
367	specObj.paths[config.specUIEndpoint] = {	×
368	get: {
369	'x-ignore': true,
370	tags: ['meta'],
371	responses: {
372	200: {
373	description: '200 response',
374	content: {
375	'text/html': {
376	schema: { $ref: '#/components/schemas/StringResponse' },
377	example: {
378	value: '<html><body>Your HTML text</body></html>',
379	},
380	},
381	},
382	},
383	},
384	...getAWSMockIntegrationResponse(200, { 'text/html': websiteData }),
385	},
386	};
387
388	return params;	×
389	}
390
391	function filterSchemas(params) {
392	const { specObj } = params;	×
393	// Filter the schemas AFTER we have built the website, so that the schemas have examples
394	specObj.components.schemas = getAWSSupportedDefinitions(specObj.components.schemas);	×
395
396	return params;	×
397	}
398
399	/**
400	* Remove data from the swagger.json that doesn't need to be rendered.
401	* @param data
402	* @return {*}
403	*/
404	function getSmallerSwaggerForWebsite(data) {
405	return traverse(data, filterNonWebsiteRequiredNodes);	×
406	}
407
408	function filterNonWebsiteRequiredNodes(obj, key) {
409	if (key === AMAZON_INTEGRATION_PROP) {	×
410	return { ...obj, [key]: undefined };	×
411	}
412	return obj;	×
413	}
414
415	function getAWSMockIntegrationResponse(statusCode, responseTemplates, responseParameters) {
416	return {	×
417	[AMAZON_INTEGRATION_PROP]: {
418	type: 'MOCK',
419	responses: {
420	default: {
421	statusCode: String(statusCode),
422	responseTemplates,
423	responseParameters,
424	},
425	},
426	requestTemplates: {
427	[APPLICATION_JSON]: '{"statusCode": 200}',
428	},
429	passthroughBehavior: 'when_no_match',
430	},
431	};
432	}
433
434	function getAWSHttpProxyIntegrationResponse(httpMethod, uri, requestParameters) {
435	return {	×
436	[AMAZON_INTEGRATION_PROP]: {
437	type: 'HTTP_PROXY',
438	httpMethod,
439	uri,
440	requestParameters,
441	},
442	};
443	}
444
445	function getCORSOptionsResponse() {
446	return {	×
447	options: {
448	responses: {
449	200: {
450	description: '200 response',
451	content: {
452	[APPLICATION_JSON]: {
453	schema: {
454	$ref: '#/components/schemas/Empty',
455	},
456	},
457	},
458	headers: {
459	'Access-Control-Allow-Origin': {
460	schema: {
461	type: 'string',
462	},
463	},
464	'Access-Control-Allow-Methods': {
465	schema: {
466	type: 'string',
467	},
468	},
469	'Access-Control-Allow-Headers': {
470	schema: {
471	type: 'string',
472	},
473	},
474	},
475	},
476	},
477	...getAWSMockIntegrationResponse('200', undefined, {
478	'method.response.header.Access-Control-Allow-Methods': "'GET,OPTIONS'",
479	'method.response.header.Access-Control-Allow-Headers':
480	"'Content-Type,X-Amz-Date,Authorization,X-Api-Key,X-Amz-Security-Token'",
481	'method.response.header.Access-Control-Allow-Origin': "'*'",
482	}),
483	},
484	};
485	}
486
487	module.exports = {	×
488	addGatewayInfo,
489	};

digio / oaat / 12

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous