vls-openapi-generator 1.3.3 → 1.4.0

package/dist/generate-openapi.js

@@ -46,17 +46,18 @@ const HANDLERS_DIR = path.join(process.cwd(), 'dist', 'src', 'handlers');
 const SCHEMAS_DIR = path.join(process.cwd(), 'dist', 'src', 'schemas');
 const OUTPUT_FILE = path.join(process.cwd(), 'openapi.json');
 const generateOpenAPI = async () => {
+    console.info('Generating Open API documentation...');
     const args = process.argv;
     const params = {};
     for (let i = 2; i < args.length; i += 2) {
         const key = args[i].replace('--', '');
         params[key] = args[i + 1];
     }
-    console.info('Generating Open API documentation...');
     await (0, util_1.promisify)(child_process_1.exec)('rm -rf ./dist');
     await (0, util_1.promisify)(child_process_1.exec)('npx tsc');
     const handlerFiles = await fs_1.promises.readdir(HANDLERS_DIR);
     const existingOpenAPIFile = JSON.parse(await fs_1.promises.readFile(OPENAPI_FILE, 'utf-8'));
+    existingOpenAPIFile.paths = {};
     for (const handler of handlerFiles) {
         const fileName = path.parse(handler).name;
         const { bodySchema, queryParametersSchema, eventResponseParametersSchema, eventResponseModulesSchema, OPENAPI_CONFIG: openAPIConfig } = (await Promise.resolve(`${path.join(SCHEMAS_DIR, fileName + '.js')}`).then(s => __importStar(require(s))).catch(() => ({})));
@@ -117,5 +118,6 @@ const generateOpenAPI = async () => {
         };
     }
     await fs_1.promises.writeFile(OUTPUT_FILE, JSON.stringify(existingOpenAPIFile, undefined, 4));
+    console.info('Open API documentation generated successfully');
 };
 exports.generateOpenAPI = generateOpenAPI;

package/dist/index.js

@@ -21,21 +21,12 @@ __exportStar(require("./lambda-type"), exports);
 (async () => {
     try {
         await (0, generate_openapi_1.generateOpenAPI)();
-        console.info('Open API documentation generated successfully');
+        if (process.argv.includes('--upload')) {
+            await (0, upload_openapi_js_1.uploadOpenAPI)();
+        }
     }
     catch (error) {
         console.error(error);
         process.exit(1);
     }
-    if (process.argv.includes('--upload')) {
-        console.info('Uploading Open API documentation to Postman...');
-        try {
-            await (0, upload_openapi_js_1.uploadOpenAPI)();
-            console.info('Open API documentation uploaded successfully');
-        }
-        catch (error) {
-            console.error(error);
-            process.exit(1);
-        }
-    }
 })().catch(console.error);

package/dist/postman-service.d.ts

@@ -1,13 +1,50 @@
-import { OpenAPI } from './openapi-type';
 export declare class PostmanService {
     private client;
-    constructor(apiKey: string);
+    private workspaceID;
+    constructor(apiKey: string, workspaceID: string);
     getCollections: () => Promise<{
         collections: {
             id: string;
             name: string;
         }[];
     }>;
-    deleteCollection: (collectionID: string) => Promise<import("axios").AxiosResponse<any, any>>;
-    createCollection: (payload: OpenAPI) => Promise<import("axios").AxiosResponse<any, any>>;
+    getCollection: (id: string) => Promise<{
+        collection: {
+            info: {
+                _postman_id: string;
+                name: string;
+            };
+            item: {
+                id: string;
+                name: "development" | "production";
+                item: object[];
+            }[];
+            variable: {
+                key: string;
+                value: string;
+            }[];
+        };
+    }>;
+    createCollection: (partnerName: string) => Promise<string>;
+    deleteFolder: (collectionID: string, folderID: string) => Promise<import("axios").AxiosResponse<any, any>>;
+    createFolder: (collectionID: string, folderName: string) => Promise<import("axios").AxiosResponse<any, any>>;
+    updateCollection: (collectionID: string, collection: object) => Promise<import("axios").AxiosResponse<any, any>>;
+    updateVariablesCollection: (collectionID: string, variables: {
+        key: string;
+        value: string;
+    }[]) => Promise<import("axios").AxiosResponse<any, any>>;
+    getAllEnvironments: () => Promise<{
+        environments: {
+            id: string;
+            name: string;
+        }[];
+    }>;
+    createEnvironment: (name: string, values: {
+        key: string;
+        value: string;
+    }[]) => Promise<import("axios").AxiosResponse<any, any>>;
+    updateEnvironment: (id: string, name: string, values: {
+        key: string;
+        value: string;
+    }[]) => Promise<import("axios").AxiosResponse<any, any>>;
 }

package/dist/postman-service.js

@@ -6,19 +6,58 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostmanService = void 0;
 const axios_1 = __importDefault(require("axios"));
 class PostmanService {
-    constructor(apiKey) {
+    constructor(apiKey, workspaceID) {
         this.getCollections = async () => {
             return (await this.client.get('/collections')).data;
         };
-        this.deleteCollection = async (collectionID) => {
-            return await this.client.delete(`/collections/${collectionID}`);
+        this.getCollection = async (id) => {
+            return (await this.client.get(`/collections/${id}?workspace=${this.workspaceID}`)).data;
         };
-        this.createCollection = async (payload) => {
-            return await this.client.post('/import/openapi', {
-                type: 'json',
-                input: payload
+        this.createCollection = async (partnerName) => {
+            return (await this.client.post(`/collections?workspace=${this.workspaceID}`, {
+                collection: {
+                    info: {
+                        name: partnerName,
+                        schema: 'https://schema.getpostman.com/json/collection/v2.1.0/collection.json'
+                    },
+                    item: []
+                }
+            })).data.collection.id;
+        };
+        this.deleteFolder = async (collectionID, folderID) => {
+            return await this.client.delete(`/collections/${collectionID}/folders/${folderID}`);
+        };
+        this.createFolder = async (collectionID, folderName) => {
+            return await this.client.post(`/collections/${collectionID}/folders`, {
+                name: folderName
+            });
+        };
+        this.updateCollection = async (collectionID, collection) => {
+            return await this.client.put(`/collections/${collectionID}`, collection);
+        };
+        this.updateVariablesCollection = async (collectionID, variables) => {
+            return await this.client.patch(`/collections/${collectionID}`, { collection: { variable: variables } });
+        };
+        this.getAllEnvironments = async () => {
+            return (await this.client.get(`/environments?workspace=${this.workspaceID}`)).data;
+        };
+        this.createEnvironment = async (name, values) => {
+            return await this.client.post(`/environments?workspace=${this.workspaceID}`, {
+                environment: {
+                    name,
+                    values: values.map(({ key, value }) => ({ key, value, enabled: true, type: 'default' }))
+                }
+            });
+        };
+        this.updateEnvironment = async (id, name, values) => {
+            return await this.client.put(`/environments/${id}?workspace=${this.workspaceID}`, {
+                environment: {
+                    name,
+                    values: values.map(({ key, value }) => ({ key, value, enabled: true, type: 'default' }))
+                }
             });
         };
+        this.workspaceID = workspaceID;
         this.client = axios_1.default.create({
             baseURL: 'https://api.getpostman.com',
             headers: {

package/dist/upload-openapi.js

@@ -36,15 +36,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.uploadOpenAPI = void 0;
 const fs_1 = require("fs");
 require("module-alias/register.js");
+const openapi_to_postmanv2_1 = require("openapi-to-postmanv2");
 const path = __importStar(require("path"));
+const util_1 = require("util");
 const postman_service_1 = require("./postman-service");
 const OPENAPI_FILE = path.join(process.cwd(), 'openapi.json');
 const uploadOpenAPI = async () => {
+    console.info('Uploading Open API documentation to Postman...');
     const args = process.argv;
     const params = {};
     for (let i = 2; i < args.length;) {
         const key = args[i].replace('--', '');
         params[key] = args[i + 1];
+        if (!params[key]) {
+            i++;
+            continue;
+        }
         if (params[key].startsWith('--')) {
             i++;
             delete params[key];
@@ -61,12 +68,63 @@ const uploadOpenAPI = async () => {
     if (!params['stack-name']) {
         throw new Error('Stack name is missing.');
     }
-    const postmanService = new postman_service_1.PostmanService(postmanToken);
-    const stackCollection = (await postmanService.getCollections()).collections.find((x) => x.name === stackName);
-    if (stackCollection) {
-        await postmanService.deleteCollection(stackCollection.id);
+    const splitStackName = stackName.split('-');
+    const environment = splitStackName.pop();
+    const partnerName = splitStackName.join('-');
+    if (environment !== 'development' && environment !== 'production') {
+        throw new Error('Stack name should end with development or production. Example: example-development');
+    }
+    const postmanService = new postman_service_1.PostmanService(postmanToken, '489fad1b-5992-4ffe-8427-1f82f3ca0661');
+    const { collections } = await postmanService.getCollections();
+    let collectionID = '';
+    const stackCollection = collections.find((x) => x.name === partnerName);
+    if (!stackCollection) {
+        collectionID = await postmanService.createCollection(partnerName);
     }
+    else {
+        collectionID = stackCollection.id;
+    }
+    const { collection: { item } } = await postmanService.getCollection(collectionID);
+    const folder = item.find((x) => x.name === environment);
+    if (folder) {
+        await postmanService.deleteFolder(collectionID, folder.id);
+    }
+    await postmanService.createFolder(collectionID, environment);
+    const collection = await postmanService.getCollection(collectionID);
     const existingOpenAPIFile = JSON.parse(await fs_1.promises.readFile(OPENAPI_FILE, 'utf-8'));
-    await postmanService.createCollection(existingOpenAPIFile);
+    const convertPromise = (0, util_1.promisify)(openapi_to_postmanv2_1.convert);
+    const converted = await convertPromise({
+        data: JSON.stringify(existingOpenAPIFile),
+        type: 'json'
+    }, {
+        folderStrategy: 'Tags'
+    });
+    if (!converted.result) {
+        throw new Error('Failed to convert Open API to Postman collection');
+    }
+    const convertedData = converted.output[0].data;
+    for (const item of collection.collection.item) {
+        if (item.name === environment) {
+            item.item = convertedData.item ?? [];
+            break;
+        }
+    }
+    await postmanService.updateCollection(collectionID, collection);
+    const baseUrl = existingOpenAPIFile.servers.find((x) => x.url.includes(environment))?.url;
+    if (!baseUrl) {
+        console.warn(`Base URL was not found with the given environment. Environment will not be updated. Given environment: ${environment}`);
+        return;
+    }
+    const environments = (await postmanService.getAllEnvironments()).environments;
+    const stackEnvironment = environments.find((x) => x.name === stackName);
+    if (!stackEnvironment) {
+        await postmanService.createEnvironment(stackName, [{ key: 'baseUrl', value: baseUrl }]);
+    }
+    else {
+        await postmanService.updateEnvironment(stackEnvironment.id, stackEnvironment.name, [
+            { key: 'baseUrl', value: baseUrl }
+        ]);
+    }
+    console.info('Open API documentation uploaded successfully');
 };
 exports.uploadOpenAPI = uploadOpenAPI;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "vls-openapi-generator",
-    "version": "1.3.3",
+    "version": "1.4.0",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "scripts": {
@@ -17,7 +17,8 @@
     "dependencies": {
         "@anatine/zod-openapi": "^2.2.7",
         "axios": "^1.7.9",
-        "module-alias": "^2.2.3"
+        "module-alias": "^2.2.3",
+        "openapi-to-postmanv2": "^4.25.0"
     },
     "devDependencies": {
         "@commitlint/config-conventional": "^19.5.0",
@@ -25,6 +26,7 @@
         "@semantic-release/git": "^10.0.1",
         "@semantic-release/npm": "^12.0.1",
         "@types/node": "^20.14.8",
+        "@types/openapi-to-postmanv2": "^3.2.4",
         "commitlint": "^19.5.0",
         "eslint": "^9.12.0",
         "husky": "^9.1.6",

package/src/generate-openapi.ts

@@ -14,6 +14,8 @@ const SCHEMAS_DIR = path.join(process.cwd(), 'dist', 'src', 'schemas');
 const OUTPUT_FILE = path.join(process.cwd(), 'openapi.json');
 
 export const generateOpenAPI = async (): Promise<void> => {
+    console.info('Generating Open API documentation...');
+
     const args = process.argv;
     const params: Record<string, string> = {};
 
@@ -22,14 +24,14 @@ export const generateOpenAPI = async (): Promise<void> => {
         params[key] = args[i + 1];
     }
 
-    console.info('Generating Open API documentation...');
-
     await promisify(exec)('rm -rf ./dist');
     await promisify(exec)('npx tsc');
 
     const handlerFiles = await fs.readdir(HANDLERS_DIR);
     const existingOpenAPIFile = JSON.parse(await fs.readFile(OPENAPI_FILE, 'utf-8')) as OpenAPI;
 
+    existingOpenAPIFile.paths = {};
+
     for (const handler of handlerFiles) {
         const fileName = path.parse(handler).name;
 
@@ -114,4 +116,5 @@ export const generateOpenAPI = async (): Promise<void> => {
     }
 
     await fs.writeFile(OUTPUT_FILE, JSON.stringify(existingOpenAPIFile, undefined, 4));
+    console.info('Open API documentation generated successfully');
 };

package/src/index.ts

@@ -9,24 +9,12 @@ export * from './lambda-type';
     try {
         await generateOpenAPI();
 
-        console.info('Open API documentation generated successfully');
+        if (process.argv.includes('--upload')) {
+            await uploadOpenAPI();
+        }
     } catch (error) {
         console.error(error);
 
         process.exit(1);
     }
-
-    if (process.argv.includes('--upload')) {
-        console.info('Uploading Open API documentation to Postman...');
-
-        try {
-            await uploadOpenAPI();
-
-            console.info('Open API documentation uploaded successfully');
-        } catch (error) {
-            console.error(error);
-
-            process.exit(1);
-        }
-    }
 })().catch(console.error);

package/src/postman-service.ts

@@ -1,10 +1,11 @@
 import axios, { Axios } from 'axios';
-import { OpenAPI } from './openapi-type';
 
 export class PostmanService {
     private client: Axios;
+    private workspaceID: string;
 
-    constructor(apiKey: string) {
+    constructor(apiKey: string, workspaceID: string) {
+        this.workspaceID = workspaceID;
         this.client = axios.create({
             baseURL: 'https://api.getpostman.com',
             headers: {
@@ -25,14 +26,80 @@ export class PostmanService {
         ).data;
     };
 
-    public deleteCollection = async (collectionID: string) => {
-        return await this.client.delete(`/collections/${collectionID}`);
+    public getCollection = async (id: string) => {
+        return (
+            await this.client.get<{
+                collection: {
+                    info: {
+                        _postman_id: string;
+                        name: string;
+                    };
+                    item: { id: string; name: 'development' | 'production'; item: object[] }[];
+                    variable: { key: string; value: string }[];
+                };
+            }>(`/collections/${id}?workspace=${this.workspaceID}`)
+        ).data;
+    };
+
+    public createCollection = async (partnerName: string) => {
+        return (
+            await this.client.post<{
+                collection: {
+                    id: string;
+                };
+            }>(`/collections?workspace=${this.workspaceID}`, {
+                collection: {
+                    info: {
+                        name: partnerName,
+                        schema: 'https://schema.getpostman.com/json/collection/v2.1.0/collection.json'
+                    },
+                    item: []
+                }
+            })
+        ).data.collection.id;
     };
 
-    public createCollection = async (payload: OpenAPI) => {
-        return await this.client.post('/import/openapi', {
-            type: 'json',
-            input: payload
+    public deleteFolder = async (collectionID: string, folderID: string) => {
+        return await this.client.delete(`/collections/${collectionID}/folders/${folderID}`);
+    };
+
+    public createFolder = async (collectionID: string, folderName: string) => {
+        return await this.client.post(`/collections/${collectionID}/folders`, {
+            name: folderName
+        });
+    };
+
+    public updateCollection = async (collectionID: string, collection: object) => {
+        return await this.client.put(`/collections/${collectionID}`, collection);
+    };
+
+    public updateVariablesCollection = async (collectionID: string, variables: { key: string; value: string }[]) => {
+        return await this.client.patch(`/collections/${collectionID}`, { collection: { variable: variables } });
+    };
+
+    public getAllEnvironments = async () => {
+        return (
+            await this.client.get<{ environments: { id: string; name: string }[] }>(
+                `/environments?workspace=${this.workspaceID}`
+            )
+        ).data;
+    };
+
+    public createEnvironment = async (name: string, values: { key: string; value: string }[]) => {
+        return await this.client.post(`/environments?workspace=${this.workspaceID}`, {
+            environment: {
+                name,
+                values: values.map(({ key, value }) => ({ key, value, enabled: true, type: 'default' }))
+            }
+        });
+    };
+
+    public updateEnvironment = async (id: string, name: string, values: { key: string; value: string }[]) => {
+        return await this.client.put(`/environments/${id}?workspace=${this.workspaceID}`, {
+            environment: {
+                name,
+                values: values.map(({ key, value }) => ({ key, value, enabled: true, type: 'default' }))
+            }
         });
     };
 }

package/src/upload-openapi.ts

@@ -1,12 +1,16 @@
 import { promises as fs } from 'fs';
 import 'module-alias/register.js';
+import { convert } from 'openapi-to-postmanv2';
 import * as path from 'path';
+import { promisify } from 'util';
 import { OpenAPI } from './openapi-type';
 import { PostmanService } from './postman-service';
 
 const OPENAPI_FILE = path.join(process.cwd(), 'openapi.json');
 
 export const uploadOpenAPI = async (): Promise<void> => {
+    console.info('Uploading Open API documentation to Postman...');
+
     const args = process.argv;
     const params: Record<string, string> = {};
 
@@ -14,6 +18,11 @@ export const uploadOpenAPI = async (): Promise<void> => {
         const key = args[i].replace('--', '');
         params[key] = args[i + 1];
 
+        if (!params[key]) {
+            i++;
+            continue;
+        }
+
         if (params[key].startsWith('--')) {
             i++;
             delete params[key];
@@ -33,15 +42,92 @@ export const uploadOpenAPI = async (): Promise<void> => {
         throw new Error('Stack name is missing.');
     }
 
-    const postmanService = new PostmanService(postmanToken);
+    const splitStackName = stackName.split('-');
+    const environment = splitStackName.pop();
+    const partnerName = splitStackName.join('-');
+
+    if (environment !== 'development' && environment !== 'production') {
+        throw new Error('Stack name should end with development or production. Example: example-development');
+    }
+
+    const postmanService = new PostmanService(postmanToken, '489fad1b-5992-4ffe-8427-1f82f3ca0661');
+
+    const { collections } = await postmanService.getCollections();
+
+    let collectionID = '';
 
-    const stackCollection = (await postmanService.getCollections()).collections.find((x) => x.name === stackName);
+    const stackCollection = collections.find((x) => x.name === partnerName);
 
-    if (stackCollection) {
-        await postmanService.deleteCollection(stackCollection.id);
+    if (!stackCollection) {
+        collectionID = await postmanService.createCollection(partnerName);
+    } else {
+        collectionID = stackCollection.id;
     }
 
+    const {
+        collection: { item }
+    } = await postmanService.getCollection(collectionID);
+
+    const folder = item.find((x) => x.name === environment);
+
+    if (folder) {
+        await postmanService.deleteFolder(collectionID, folder.id);
+    }
+
+    await postmanService.createFolder(collectionID, environment);
+
+    const collection = await postmanService.getCollection(collectionID);
+
     const existingOpenAPIFile = JSON.parse(await fs.readFile(OPENAPI_FILE, 'utf-8')) as OpenAPI;
 
-    await postmanService.createCollection(existingOpenAPIFile);
+    const convertPromise = promisify(convert);
+
+    const converted = await convertPromise(
+        {
+            data: JSON.stringify(existingOpenAPIFile),
+            type: 'json'
+        },
+        {
+            folderStrategy: 'Tags'
+        }
+    );
+
+    if (!converted.result) {
+        throw new Error('Failed to convert Open API to Postman collection');
+    }
+
+    const convertedData = converted.output[0].data;
+
+    for (const item of collection.collection.item) {
+        if (item.name === environment) {
+            item.item = convertedData.item ?? [];
+            break;
+        }
+    }
+
+    await postmanService.updateCollection(collectionID, collection);
+
+    const baseUrl = existingOpenAPIFile.servers.find((x) => x.url.includes(environment))?.url;
+
+    if (!baseUrl) {
+        console.warn(
+            `Base URL was not found with the given environment. Environment will not be updated. Given environment: ${environment}`
+        );
+
+        return;
+    }
+
+    const environments = (await postmanService.getAllEnvironments()).environments;
+
+    const stackEnvironment = environments.find((x) => x.name === stackName);
+
+    if (!stackEnvironment) {
+        await postmanService.createEnvironment(stackName, [{ key: 'baseUrl', value: baseUrl }]);
+    } else {
+        await postmanService.updateEnvironment(stackEnvironment.id, stackEnvironment.name, [
+            { key: 'baseUrl', value: baseUrl }
+        ]);
+    }
+
+    console.info('Open API documentation uploaded successfully');
 };