vls-openapi-generator 1.3.4 → 1.5.0

package/dist/generate-openapi.js

@@ -46,13 +46,13 @@ 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);
@@ -61,6 +61,7 @@ const generateOpenAPI = async () => {
     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(() => ({})));
+        const { LAMBDA_CONFIG } = (await Promise.resolve(`${path.join(HANDLERS_DIR, `${fileName}.js`)}`).then(s => __importStar(require(s))));
         const bodyComponent = (0, zod_openapi_1.generateSchema)(bodySchema ?? zod_1.z.never(), undefined, '3.0');
         const queryParametersComponent = (0, zod_openapi_1.generateSchema)(queryParametersSchema ?? zod_1.z.never(), undefined, '3.0');
         const eventResponseComponent = (0, zod_openapi_1.generateSchema)(zod_1.z.object({
@@ -91,7 +92,7 @@ const generateOpenAPI = async () => {
             }
         }
         existingOpenAPIFile.paths['/' + fileName] = {
-            post: {
+            [LAMBDA_CONFIG?.method?.toLowerCase() ?? 'post']: {
                 tags: openAPIConfig.tags,
                 parameters: queryParametersSchema ? queryParameters : undefined,
                 requestBody: bodySchema
@@ -118,5 +119,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

@@ -16,28 +16,17 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const generate_openapi_1 = require("./generate-openapi");
-// import { uploadOpenAPI } from './upload-openapi.js';
+const upload_openapi_js_1 = require("./upload-openapi.js");
 __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 uploadOpenAPI();
-    //
-    //         console.info('Open API documentation uploaded successfully');
-    //     } catch (error) {
-    //         console.error(error);
-    //
-    //         process.exit(1);
-    //     }
-    // }
 })().catch(console.error);

package/dist/lambda-type.d.ts

@@ -1,3 +1,12 @@
 export type OpenAPIConfig = {
     tags: string[];
 };
+export type LambdaConfig = {
+    cron?: {
+        schedule: string;
+        input?: Record<string, unknown>;
+    };
+    timeout?: number;
+    memorySize?: number;
+    method?: 'GET' | 'POST';
+};

package/dist/openapi-type.d.ts

@@ -12,32 +12,30 @@ export type OpenAPI = {
     }, {
         url: string;
     }];
-    paths: Record<string, {
-        post: {
-            parameters: {
-                name: string;
-                in: 'query';
-                schema: ReturnType<typeof generateSchema>;
-            }[] | undefined;
-            requestBody: {
-                required: true;
+    paths: Record<string, Partial<Record<'get' | 'post', {
+        parameters: {
+            name: string;
+            in: 'query';
+            schema: ReturnType<typeof generateSchema>;
+        }[] | undefined;
+        requestBody: {
+            required: true;
+            content: {
+                'application/json': {
+                    schema: ReturnType<typeof generateSchema>;
+                };
+            };
+        } | undefined;
+        responses: {
+            200: {
+                description: string;
                 content: {
                     'application/json': {
                         schema: ReturnType<typeof generateSchema>;
                     };
-                };
-            } | undefined;
-            responses: {
-                200: {
-                    description: string;
-                    content: {
-                        'application/json': {
-                            schema: ReturnType<typeof generateSchema>;
-                        };
-                    } | undefined;
-                };
+                } | undefined;
             };
-            tags: string[];
         };
-    }>;
+        tags: string[];
+    }>>>;
 };

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.4",
+    "version": "1.5.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

@@ -5,7 +5,7 @@ import 'module-alias/register.js';
 import * as path from 'path';
 import { promisify } from 'util';
 import { z } from 'zod';
-import { OpenAPIConfig } from './lambda-type';
+import { LambdaConfig, OpenAPIConfig } from './lambda-type';
 import { OpenAPI } from './openapi-type';
 
 const OPENAPI_FILE = path.join(process.cwd(), 'openapi.json');
@@ -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,8 +24,6 @@ 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');
 
@@ -49,6 +49,10 @@ export const generateOpenAPI = async (): Promise<void> => {
             OPENAPI_CONFIG: OpenAPIConfig;
         };
 
+        const { LAMBDA_CONFIG } = (await import(path.join(HANDLERS_DIR, `${fileName}.js`))) as {
+            LAMBDA_CONFIG?: LambdaConfig;
+        };
+
         const bodyComponent = generateSchema(bodySchema ?? z.never(), undefined, '3.0');
         const queryParametersComponent = generateSchema(queryParametersSchema ?? z.never(), undefined, '3.0');
         const eventResponseComponent = generateSchema(
@@ -88,7 +92,7 @@ export const generateOpenAPI = async (): Promise<void> => {
         }
 
         existingOpenAPIFile.paths['/' + fileName] = {
-            post: {
+            [LAMBDA_CONFIG?.method?.toLowerCase() ?? 'post']: {
                 tags: openAPIConfig.tags,
                 parameters: queryParametersSchema ? queryParameters : undefined,
                 requestBody: bodySchema
@@ -116,4 +120,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

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import { generateOpenAPI } from './generate-openapi';
-// import { uploadOpenAPI } from './upload-openapi.js';
+import { uploadOpenAPI } from './upload-openapi.js';
 
 export * from './lambda-type';
 
@@ -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/lambda-type.ts

@@ -1,3 +1,13 @@
 export type OpenAPIConfig = {
     tags: string[];
 };
+
+export type LambdaConfig = {
+    cron?: {
+        schedule: string;
+        input?: Record<string, unknown>;
+    };
+    timeout?: number;
+    memorySize?: number;
+    method?: 'GET' | 'POST';
+};

package/src/openapi-type.ts

@@ -6,39 +6,42 @@ export type OpenAPI = {
     servers: [{ url: string }, { url: string }, { url: string }];
     paths: Record<
         string,
-        {
-            post: {
-                parameters:
-                    | {
-                          name: string;
-                          in: 'query';
-                          schema: ReturnType<typeof generateSchema>;
-                      }[]
-                    | undefined;
-                requestBody:
-                    | {
-                          required: true;
-                          content: {
-                              'application/json': {
-                                  schema: ReturnType<typeof generateSchema>;
-                              };
-                          };
-                      }
-                    | undefined;
-                responses: {
-                    200: {
-                        description: string;
-                        content:
-                            | {
+        Partial<
+            Record<
+                'get' | 'post',
+                {
+                    parameters:
+                        | {
+                              name: string;
+                              in: 'query';
+                              schema: ReturnType<typeof generateSchema>;
+                          }[]
+                        | undefined;
+                    requestBody:
+                        | {
+                              required: true;
+                              content: {
                                   'application/json': {
                                       schema: ReturnType<typeof generateSchema>;
                                   };
-                              }
-                            | undefined;
+                              };
+                          }
+                        | undefined;
+                    responses: {
+                        200: {
+                            description: string;
+                            content:
+                                | {
+                                      'application/json': {
+                                          schema: ReturnType<typeof generateSchema>;
+                                      };
+                                  }
+                                | undefined;
+                        };
                     };
-                };
-                tags: string[];
-            };
-        }
+                    tags: string[];
+                }
+            >
+        >
     >;
 };

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');
 };