@postman-enricher/shared 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Caio Pizzol
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './matcher.js';
+export * from './walker.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './matcher.js';
+export * from './walker.js';

package/dist/matcher.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Endpoint matching utilities for filtering
+ */
+/**
+ * Normalize a path for comparison
+ * Converts various path formats to a consistent format for matching
+ * @param path - URL path to normalize
+ * @param rules - Optional normalization rules mapping
+ * @returns Normalized path
+ */
+export declare function normalizePath(path: string, rules?: Record<string, string>): string;
+/**
+ * Check if an endpoint matches based on method and path
+ * @param method - HTTP method
+ * @param path - URL path
+ * @param endpoints - Map of endpoints to include
+ * @param rules - Optional normalization rules
+ * @returns True if endpoint should be included
+ */
+export declare function shouldIncludeEndpoint(method: string, path: string, endpoints: Record<string, boolean>, rules?: Record<string, string>): boolean;

package/dist/matcher.js

@@ -0,0 +1,38 @@
+/**
+ * Endpoint matching utilities for filtering
+ */
+/**
+ * Normalize a path for comparison
+ * Converts various path formats to a consistent format for matching
+ * @param path - URL path to normalize
+ * @param rules - Optional normalization rules mapping
+ * @returns Normalized path
+ */
+export function normalizePath(path, rules = {}) {
+    let normalized = path.replace(/:(\w+)/g, ':$1'); // Keep :param format as is
+    // Apply custom normalization rules if provided
+    normalized = normalized.replace(/\{[^}]+\}/g, (match) => {
+        // Check custom rules first
+        for (const [pattern, replacement] of Object.entries(rules)) {
+            if (match.includes(pattern)) {
+                return replacement;
+            }
+        }
+        // Default: remove braces and keep content
+        return ':' + match.slice(1, -1);
+    });
+    return normalized;
+}
+/**
+ * Check if an endpoint matches based on method and path
+ * @param method - HTTP method
+ * @param path - URL path
+ * @param endpoints - Map of endpoints to include
+ * @param rules - Optional normalization rules
+ * @returns True if endpoint should be included
+ */
+export function shouldIncludeEndpoint(method, path, endpoints, rules = {}) {
+    const normalizedPath = normalizePath(path, rules);
+    const endpointKey = `${method} ${normalizedPath}`;
+    return endpoints[endpointKey] || false;
+}

package/dist/types.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Postman Collection Types
+ */
+export interface PostmanUrl {
+    raw?: string;
+    protocol?: string;
+    host?: string | string[];
+    path?: string | string[];
+    query?: PostmanQueryParam[];
+    variable?: PostmanVariable[];
+}
+export interface PostmanQueryParam {
+    key: string;
+    value: string;
+    disabled?: boolean;
+    description?: string | {
+        content: string;
+        type: string;
+    };
+}
+export interface PostmanVariable {
+    key: string;
+    value: string;
+    type?: string;
+    disabled?: boolean;
+    description?: string | {
+        content: string;
+        type: string;
+    };
+}
+export interface PostmanHeader {
+    key: string;
+    value: string;
+    disabled?: boolean;
+    description?: string | {
+        content: string;
+        type: string;
+    };
+}
+export interface PostmanBody {
+    mode: string;
+    raw?: string;
+    options?: {
+        raw?: {
+            language?: string;
+            headerFamily?: string;
+        };
+    };
+}
+export interface PostmanRequest {
+    name: string;
+    description?: string;
+    url: PostmanUrl;
+    method: string;
+    header?: PostmanHeader[];
+    body?: PostmanBody;
+    auth?: any;
+}
+export interface PostmanResponse {
+    id?: string;
+    name: string;
+    originalRequest?: PostmanRequest;
+    status: string;
+    code: number;
+    header?: PostmanHeader[];
+    body?: string;
+    _postman_previewlanguage?: string;
+}
+export interface PostmanItem {
+    id?: string;
+    name: string;
+    description?: string;
+    item?: PostmanItem[];
+    request?: PostmanRequest;
+    response?: PostmanResponse[];
+    event?: PostmanEvent[];
+}
+export interface PostmanEvent {
+    listen: string;
+    script: {
+        type: string;
+        exec: string[];
+    };
+}
+export interface PostmanInfo {
+    name: string;
+    description?: string;
+    schema: string;
+    _postman_id?: string;
+}
+export interface PostmanCollection {
+    info: PostmanInfo;
+    item: PostmanItem[];
+    variable?: PostmanVariable[];
+    event?: PostmanEvent[];
+}
+/**
+ * Configuration Types
+ */
+export interface FilterConfig {
+    include?: Record<string, boolean>;
+    note?: string;
+    normalizationRules?: Record<string, string>;
+}
+export interface DescriptionConfig {
+    collection?: Record<string, {
+        name?: string;
+        description?: string;
+    }>;
+    folders?: Record<string, string>;
+    requests?: Record<string, string>;
+}
+export interface ExampleResponse {
+    name: string;
+    status: string;
+    code: number;
+    body?: any;
+}
+export interface ExampleConfig {
+    requests?: Record<string, {
+        body?: any;
+    }>;
+    responses?: Record<string, ExampleResponse>;
+}
+export interface VariableConfig {
+    path?: Record<string, string>;
+    query?: Record<string, string>;
+    environment?: Record<string, string>;
+    descriptions?: Record<string, string>;
+    baseUrlVar?: string;
+}
+export interface TestConfig {
+    auto?: boolean;
+}
+export interface EnrichmentConfig {
+    filter?: FilterConfig;
+    descriptions?: DescriptionConfig;
+    examples?: ExampleConfig;
+    variables?: VariableConfig;
+    tests?: TestConfig;
+}

package/dist/types.js

@@ -0,0 +1,4 @@
+/**
+ * Postman Collection Types
+ */
+export {};

package/dist/walker.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Collection traversal utilities
+ * Provides a single, reusable way to walk through Postman collection items
+ */
+import type { PostmanItem, PostmanUrl } from './types.js';
+/**
+ * Walk through all items in a collection recursively
+ * @param items - Collection items (requests and folders)
+ * @param handler - Function called for each item
+ */
+export declare function walkCollection(items: PostmanItem[] | undefined, handler: (item: PostmanItem) => void): void;
+/**
+ * Check if an item is a request (not a folder)
+ * @param item - Collection item
+ * @returns True if item is a request
+ */
+export declare function isRequest(item: PostmanItem): boolean;
+/**
+ * Check if an item is a folder
+ * @param item - Collection item
+ * @returns True if item is a folder
+ */
+export declare function isFolder(item: PostmanItem): boolean;
+/**
+ * Get the HTTP method from a request item
+ * @param item - Request item
+ * @returns HTTP method (GET, POST, etc.)
+ */
+export declare function getRequestMethod(item: PostmanItem): string;
+/**
+ * Extract the path from a Postman URL object
+ * @param url - Postman URL object or string
+ * @returns Path portion of the URL
+ */
+export declare function getUrlPath(url: PostmanUrl | string): string;

package/dist/walker.js

@@ -0,0 +1,67 @@
+/**
+ * Collection traversal utilities
+ * Provides a single, reusable way to walk through Postman collection items
+ */
+/**
+ * Walk through all items in a collection recursively
+ * @param items - Collection items (requests and folders)
+ * @param handler - Function called for each item
+ */
+export function walkCollection(items, handler) {
+    if (!items || !Array.isArray(items))
+        return;
+    items.forEach((item) => {
+        // Call handler for this item
+        handler(item);
+        // Recurse into nested items (folders)
+        if (item.item && Array.isArray(item.item)) {
+            walkCollection(item.item, handler);
+        }
+    });
+}
+/**
+ * Check if an item is a request (not a folder)
+ * @param item - Collection item
+ * @returns True if item is a request
+ */
+export function isRequest(item) {
+    return !!item.request;
+}
+/**
+ * Check if an item is a folder
+ * @param item - Collection item
+ * @returns True if item is a folder
+ */
+export function isFolder(item) {
+    return !!item.item && !item.request;
+}
+/**
+ * Get the HTTP method from a request item
+ * @param item - Request item
+ * @returns HTTP method (GET, POST, etc.)
+ */
+export function getRequestMethod(item) {
+    return item.request?.method || 'GET';
+}
+/**
+ * Extract the path from a Postman URL object
+ * @param url - Postman URL object or string
+ * @returns Path portion of the URL
+ */
+export function getUrlPath(url) {
+    if (typeof url === 'string') {
+        return url;
+    }
+    if (url?.path) {
+        if (Array.isArray(url.path)) {
+            return '/' + url.path.join('/');
+        }
+        if (typeof url.path === 'string') {
+            return url.path;
+        }
+    }
+    if (url?.raw) {
+        return url.raw;
+    }
+    return '';
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@postman-enricher/shared",
+  "version": "1.0.0",
+  "description": "Shared types and utilities for Postman Enricher",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@anolilab/semantic-release-pnpm": "^3.0.0",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^12.0.2",
+    "@semantic-release/release-notes-generator": "^14.1.0",
+    "semantic-release": "^25.0.2",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/caiopizzol/openapi-to-postman-complete.git",
+    "directory": "packages/shared"
+  },
+  "bugs": {
+    "url": "https://github.com/caiopizzol/openapi-to-postman-complete/issues"
+  },
+  "homepage": "https://github.com/caiopizzol/openapi-to-postman-complete#readme",
+  "author": "Caio Pizzol",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit"
+  }
+}