feat: add functions to fetch swagger.json from saddleback server

Author: romantech48

rollup.config.js

@@ -70,6 +70,6 @@ export default {
         file: './dist/index.js',
         format: 'cjs',
     },
-    external: ['camelcase', 'commander', 'fs-extra', 'handlebars', 'json-schema-ref-parser'],
+    external: ['camelcase', 'commander', 'fs-extra', 'handlebars', 'json-schema-ref-parser', 'axios', 'form-data'],
     plugins: getPlugins(),
 };

src/generateSaddlebackSpec.ts

@@ -1,12 +1,16 @@
 import { generate, Options } from './generate';
-import { isString } from './utils/isString';
-import { getOpenApiSpec } from './utils/getOpenApiSpec';
 import { OpenApi } from './openApi/v3/interfaces/OpenApi';
-import { Dictionary } from './utils/types';
 import { OpenApiSchema } from './openApi/v3/interfaces/OpenApiSchema';
-import { removeLodashPrefix } from './utils/removeLodashPrefix';
+import { getOpenApiSpec } from './utils/getOpenApiSpec';
+import { isString } from './utils/isString';
 import { mapSwaggerRef } from './utils/mapSwaggerRef';
+import { removeLodashPrefix } from './utils/removeLodashPrefix';
 import { removeLodashPrefixFromRef } from './utils/removeLodashPrefixFromRef';
+import { getApiToken } from './utils/saddleback/getApiToken';
+import { getRequestVerificationToken } from './utils/saddleback/getRequestVerificationToken';
+import { getSessionCookie } from './utils/saddleback/getSessionCookie';
+import { getSwaggerJson } from './utils/saddleback/getSwaggerJson';
+import { Dictionary } from './utils/types';
 
 type Config = Options & {
     useSaddlebackServices?: boolean;
@@ -16,7 +20,54 @@ type Config = Options & {
 };
 
 export const generateSaddlebackSpec = async (config: Config) => {
-   const openApi: OpenApi = isString(config.input) ? await getOpenApiSpec(config.input) : config.input;
+    const username = '[email protected]';
+    const password = "&cY8at<'S5PfJa#k";
+    const swaggerUrl = `https://hc-workflowsservice-dev.azurewebsites.net/api-doc/v1/swagger.json`;
+
+    const loginUrl = `https://identity-dev.saddleback.com/account/login`;
+    const tokenUrl = `https://identity-dev.saddleback.com/connect/authorize/callback`;
+
+    // params
+    const client_id = 'cm';
+    const response_type = 'token';
+    const scope = 'cm-api.default';
+    const redirect_uri = (swaggerUrl.match(new RegExp(`.*\.net`)) || [])[0] + '/api-doc-auth-callback';
+    const response_mode = 'form_post';
+    const state = 'e57a56201103b8bda3981515294649254a764612d871ecbe7a31efb8e3e66c8b';
+    const nonce = '78fd83bf2d178a5c5de18f9f7da3269b34f7daa07d4accc28cd0bdb87f9deee8';
+    const returnUrl = `/connect/authorize/callback?client_id=${client_id}&response_type=${response_type}&scope=${scope}&redirect_uri=${redirect_uri}&state=${state}&nonce=${nonce}&response_mode=${response_mode}`;
+
+    const { requestVerificationToken, cookie } = await getRequestVerificationToken({
+        url: loginUrl,
+        params: { returnUrl },
+    });
+
+    const { cookie: sessionCookie } = await getSessionCookie({
+        url: loginUrl,
+        username,
+        password,
+        cookie,
+        requestVerificationToken,
+        params: { returnUrl },
+    });
+
+    const { apiToken } = await getApiToken({
+        url: tokenUrl,
+        cookie: sessionCookie,
+        params: {
+            client_id,
+            response_type,
+            scope,
+            redirect_uri,
+            state,
+            nonce,
+            response_mode,
+        },
+    });
+
+    const { data: json } = await getSwaggerJson({ url: swaggerUrl, apiToken: apiToken });
+
+    const openApi: OpenApi = isString(config.input) ? await getOpenApiSpec(config.input) : config.input;
 
     if (config.removeLodashPrefixes && openApi.components && openApi.components.schemas) {
         const newSchemas: Dictionary<OpenApiSchema> = {};

src/utils/saddleback/getApiToken.ts

@@ -0,0 +1,27 @@
+import axios from 'axios';
+
+export const getApiToken = async ({
+    url,
+    cookie,
+    params,
+}: {
+    url: string;
+    cookie: string;
+    params: Record<string, string>;
+}): Promise<{ apiToken: string }> => {
+    const response = await axios(url, {
+        method: 'GET',
+        headers: {
+            Cookie: cookie,
+        },
+        params,
+        maxRedirects: 0,
+    });
+
+    const regexp = new RegExp(`type='hidden' name='access_token' value='(.*)'`);
+    const apiToken = response.data.match(regexp)?.[1] || null;
+
+    if (apiToken === null) throw new Error('wrong apiToken getApiToken');
+
+    return { apiToken };
+};

src/utils/saddleback/getRequestVerificationToken.ts

@@ -0,0 +1,27 @@
+import axios from 'axios';
+
+export const getRequestVerificationToken = async ({
+    url,
+    params,
+}: {
+    url: string;
+    params: Record<string, string>;
+}): Promise<{ requestVerificationToken: string; cookie: string }> => {
+    const response0 = await axios(url, {
+        method: 'GET',
+        params,
+        maxRedirects: 0,
+    });
+    const regexp = new RegExp(`<input name="__RequestVerificationToken" type="hidden" value="(.*)"`);
+    const requestVerificationToken = response0.data.match(regexp)?.[1] || null;
+
+    const cookies = response0.headers['set-cookie'];
+    const cookieString = cookies?.reduce((acc, it) => `${acc}${it};`, '') || null;
+
+    if (!requestVerificationToken || !cookieString) throw new Error('getRequestVerificationToken failed');
+
+    return {
+        cookie: cookieString,
+        requestVerificationToken,
+    };
+};

src/utils/saddleback/getSessionCookie.ts

@@ -0,0 +1,50 @@
+import axios, { AxiosError } from 'axios';
+import FormData from 'form-data';
+
+export const getSessionCookie = async ({
+    username,
+    password,
+    requestVerificationToken,
+    url,
+    params,
+    cookie,
+}: {
+    username: string;
+    password: string;
+    requestVerificationToken: string;
+    url: string;
+    params: Record<string, string>;
+    cookie: string;
+}): Promise<{ cookie: string }> => {
+    let cookieString = '';
+
+    try {
+        const form = new FormData();
+        form.append('Username', username);
+        form.append('Password', password);
+        form.append('__RequestVerificationToken', requestVerificationToken);
+
+        const response = await axios(`${url}`, {
+            method: 'POST',
+            data: form,
+            params,
+            headers: {
+                Cookie: cookie,
+                'Content-Type': 'application/x-www-form-urlencoded',
+            },
+            maxRedirects: 0,
+        });
+    } catch (e) {
+        const error = e as AxiosError;
+        if (error.response && error.response.status === 302) {
+            const cookies = error.response?.headers['set-cookie'] || [];
+            cookieString = cookies.reduce((acc, it) => `${acc}${it};`, '') || '';
+        } else {
+            throw new Error('Wrong response getSessionCookie');
+        }
+    } finally {
+        if (cookieString.length === 0) throw new Error('Wrong cookies getSessionCookie');
+
+        return { cookie: cookieString };
+    }
+};

src/utils/saddleback/getSwaggerJson.ts

@@ -0,0 +1,12 @@
+import axios, { AxiosResponse } from 'axios';
+
+export const getSwaggerJson = async ({ url, apiToken }: { url: string; apiToken: string }): Promise<AxiosResponse> => {
+    const response = await axios(url, {
+        method: 'GET',
+        headers: {
+            Cookie: `apiKey=${apiToken}`,
+        },
+        maxRedirects: 0,
+    });
+    return response;
+};