@theihtisham/devtools-with-cloud 1.0.0

package/src/lib/importers/openapi.ts

@@ -0,0 +1,324 @@
+import type { HttpMethod } from '@/lib/utils/validation';
+
+export interface ImportedEndpoint {
+  name: string;
+  method: HttpMethod;
+  url: string;
+  description?: string;
+  headers: { key: string; value: string; enabled: boolean }[];
+  params: { key: string; value: string; enabled: boolean }[];
+  body?: {
+    raw?: string;
+  };
+  bodyType?: string;
+  auth?: unknown;
+}
+
+export interface ImportedCollection {
+  name: string;
+  description?: string;
+  endpoints: ImportedEndpoint[];
+}
+
+/**
+ * Import an OpenAPI 3.x specification into a collection.
+ * Supports both JSON and YAML formats.
+ */
+export function importOpenApi(spec: string): ImportedCollection {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(spec);
+  } catch {
+    // Try YAML (basic support)
+    try {
+      parsed = parseSimpleYaml(spec);
+    } catch {
+      throw new Error('Invalid OpenAPI spec: must be valid JSON or YAML');
+    }
+  }
+
+  const api = parsed as Record<string, unknown>;
+  const info = api['info'] as Record<string, string> | undefined;
+  const paths = api['paths'] as Record<string, Record<string, unknown>> | undefined;
+  const servers = api['servers'] as Array<{ url: string }> | undefined;
+  const components = api['components'] as Record<string, unknown> | undefined;
+
+  if (!paths || typeof paths !== 'object') {
+    throw new Error('Invalid OpenAPI spec: missing or invalid "paths" object');
+  }
+
+  const baseUrl = servers?.[0]?.url ?? '';
+
+  const collection: ImportedCollection = {
+    name: info?.['title'] ?? 'Imported API',
+    description: info?.['description'],
+    endpoints: [],
+  };
+
+  const httpMethods = new Set(['get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace']);
+
+  for (const [path, methods] of Object.entries(paths)) {
+    if (!methods || typeof methods !== 'object') continue;
+
+    for (const [method, operation] of Object.entries(methods)) {
+      if (!httpMethods.has(method.toLowerCase())) continue;
+
+      const op = operation as Record<string, unknown>;
+      const parameters = (op['parameters'] ?? []) as Array<Record<string, unknown>>;
+      const requestBody = op['requestBody'] as Record<string, unknown> | undefined;
+      const security = op['security'] as Array<Record<string, unknown>> | undefined;
+
+      const headers: ImportedEndpoint['headers'] = [];
+      const params: ImportedEndpoint['params'] = [];
+
+      for (const param of parameters) {
+        const paramName = param['name'] as string;
+        const paramIn = param['in'] as string;
+        const paramValue = getExampleValue(param);
+
+        if (paramIn === 'query') {
+          params.push({ key: paramName, value: paramValue, enabled: true });
+        } else if (paramIn === 'header') {
+          headers.push({ key: paramName, value: paramValue, enabled: true });
+        }
+      }
+
+      let body: ImportedEndpoint['body'];
+      let bodyType: string | undefined;
+
+      if (requestBody) {
+        const content = requestBody['content'] as Record<string, Record<string, unknown>> | undefined;
+        if (content) {
+          const jsonContent = content['application/json'];
+          if (jsonContent) {
+            const schema = jsonContent['schema'] as Record<string, unknown> | undefined;
+            if (schema) {
+              const example = resolveSchemaExample(schema, components);
+              body = { raw: JSON.stringify(example, null, 2) };
+              bodyType = 'json';
+              headers.push({ key: 'Content-Type', value: 'application/json', enabled: true });
+            }
+          }
+
+          if (!body) {
+            const formContent = content['application/x-www-form-urlencoded'];
+            if (formContent) {
+              const schema = formContent['schema'] as Record<string, unknown> | undefined;
+              if (schema) {
+                const example = resolveSchemaExample(schema, components);
+                body = { raw: JSON.stringify(example, null, 2) };
+                bodyType = 'urlencoded';
+              }
+            }
+          }
+        }
+      }
+
+      let auth: unknown;
+      if (security && security.length > 0) {
+        const securitySchemes = (components?.['securitySchemes'] ?? {}) as Record<string, Record<string, unknown>>;
+        const schemeName = Object.keys(security[0] ?? {})[0];
+        if (schemeName && securitySchemes[schemeName]) {
+          auth = securitySchemeToAuth(securitySchemes[schemeName]!);
+        }
+      }
+
+      const operationId = (op['operationId'] as string) ?? `${method.toUpperCase()} ${path}`;
+      const summary = op['summary'] as string | undefined;
+
+      collection.endpoints.push({
+        name: summary ?? operationId,
+        method: method.toUpperCase() as HttpMethod,
+        url: baseUrl ? `${baseUrl}${path}` : path,
+        description: (op['description'] as string) ?? summary,
+        headers,
+        params,
+        body,
+        bodyType,
+        auth,
+      });
+    }
+  }
+
+  return collection;
+}
+
+function getExampleValue(param: Record<string, unknown>): string {
+  const example = param['example'];
+  if (example !== undefined) return String(example);
+
+  const schema = param['schema'] as Record<string, unknown> | undefined;
+  if (schema) {
+    if (schema['example'] !== undefined) return String(schema['example']);
+    if (schema['default'] !== undefined) return String(schema['default']);
+    if (schema['enum'] && Array.isArray(schema['enum']) && schema['enum'].length > 0) {
+      return String(schema['enum'][0]);
+    }
+  }
+
+  return '';
+}
+
+function resolveSchemaExample(
+  schema: Record<string, unknown>,
+  components?: Record<string, unknown>,
+  visited: Set<string> = new Set(),
+): unknown {
+  // Handle $ref
+  if (schema['$ref']) {
+    const refPath = (schema['$ref'] as string).replace('#/', '').split('/');
+    let resolved: unknown = { '#': components };
+
+    for (const segment of refPath) {
+      if (typeof resolved !== 'object' || resolved === null) return {};
+      const refKey = `${refPath.join('/')}`;
+      if (visited.has(refKey)) return {};
+      visited.add(refKey);
+      resolved = (resolved as Record<string, unknown>)[segment];
+    }
+
+    if (typeof resolved === 'object' && resolved !== null) {
+      return resolveSchemaExample(resolved as Record<string, unknown>, components, visited);
+    }
+    return resolved;
+  }
+
+  if (schema['example'] !== undefined) return schema['example'];
+  if (schema['default'] !== undefined) return schema['default'];
+
+  const type = schema['type'] as string;
+
+  if (type === 'object') {
+    const properties = schema['properties'] as Record<string, Record<string, unknown>> | undefined;
+    if (!properties) return {};
+
+    const result: Record<string, unknown> = {};
+    for (const [key, propSchema] of Object.entries(properties)) {
+      result[key] = resolveSchemaExample(propSchema, components, visited);
+    }
+    return result;
+  }
+
+  if (type === 'array') {
+    const items = schema['items'] as Record<string, unknown> | undefined;
+    if (items) {
+      return [resolveSchemaExample(items, components, visited)];
+    }
+    return [];
+  }
+
+  if (type === 'string') return '';
+  if (type === 'number' || type === 'integer') return 0;
+  if (type === 'boolean') return false;
+
+  return null;
+}
+
+function securitySchemeToAuth(scheme: Record<string, unknown>): unknown {
+  const type = scheme['type'] as string;
+
+  if (type === 'http') {
+    const schemeName = scheme['scheme'] as string;
+    if (schemeName === 'basic') {
+      return { type: 'basic', username: '', password: '' };
+    }
+    if (schemeName === 'bearer') {
+      return { type: 'bearer', token: '', prefix: 'Bearer' };
+    }
+  }
+
+  if (type === 'apiKey') {
+    return {
+      type: 'apikey',
+      key: scheme['name'] as string,
+      value: '',
+      addTo: (scheme['in'] as string) === 'query' ? 'query' : 'header',
+    };
+  }
+
+  if (type === 'oauth2') {
+    return { type: 'oauth2', grantType: 'authorization_code' };
+  }
+
+  return { type: 'none' };
+}
+
+/**
+ * Basic YAML parser for OpenAPI specs (no external dependency).
+ * Handles simple key-value pairs and nested objects.
+ */
+function parseSimpleYaml(input: string): unknown {
+  const lines = input.split('\n');
+  const result: unknown = undefined;
+  const stack: Array<{ indent: number; obj: Record<string, unknown>; key: string | null }> = [];
+  let root: Record<string, unknown> = {};
+
+  stack.push({ indent: -1, obj: root, key: null });
+
+  for (const rawLine of lines) {
+    if (rawLine.trim() === '' || rawLine.trim().startsWith('#')) continue;
+
+    const indent = rawLine.search(/\S/);
+    const line = rawLine.trim();
+
+    // Pop stack to find parent
+    while (stack.length > 1 && stack[stack.length - 1]!.indent >= indent) {
+      stack.pop();
+    }
+
+    const parent = stack[stack.length - 1]!;
+
+    // Array item
+    if (line.startsWith('- ')) {
+      const value = parseYamlValue(line.slice(2));
+      const parentObj = parent.obj;
+      if (parent.key && Array.isArray(parentObj[parent.key])) {
+        (parentObj[parent.key] as unknown[]).push(value);
+      }
+      continue;
+    }
+
+    // Key-value pair
+    const colonIndex = line.indexOf(':');
+    if (colonIndex === -1) continue;
+
+    const key = line.slice(0, colonIndex).trim();
+    const valueStr = line.slice(colonIndex + 1).trim();
+
+    if (valueStr === '') {
+      // New nested object
+      const newObj: Record<string, unknown> = {};
+      if (parent.key && Array.isArray(parent.obj[parent.key])) {
+        (parent.obj[parent.key] as unknown[]).push(newObj);
+      } else {
+        parent.obj[key] = newObj;
+      }
+      stack.push({ indent, obj: newObj, key: null });
+    } else {
+      const value = parseYamlValue(valueStr);
+      if (parent.key && Array.isArray(parent.obj[parent.key])) {
+        // Not common, skip
+      } else {
+        parent.obj[key] = value;
+      }
+    }
+
+    root = stack[0]!.obj;
+  }
+
+  return root || result;
+}
+
+function parseYamlValue(value: string): unknown {
+  if (value === 'null' || value === '~') return null;
+  if (value === 'true') return true;
+  if (value === 'false') return false;
+  if (value.startsWith('"') && value.endsWith('"')) return value.slice(1, -1);
+  if (value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
+  if (/^-?\d+$/.test(value)) return parseInt(value, 10);
+  if (/^-?\d+\.\d+$/.test(value)) return parseFloat(value);
+  if (value.startsWith('[') && value.endsWith(']')) {
+    return value.slice(1, -1).split(',').map((v) => parseYamlValue(v.trim()));
+  }
+  return value;
+}

package/src/lib/importers/postman.ts

@@ -0,0 +1,312 @@
+import type { HttpMethod } from '@/lib/utils/validation';
+
+export interface ImportedPostmanCollection {
+  name: string;
+  description?: string;
+  folders: ImportedFolder[];
+  requests: ImportedPostmanRequest[];
+  variables: Record<string, string>;
+}
+
+export interface ImportedFolder {
+  name: string;
+  description?: string;
+  requests: ImportedPostmanRequest[];
+}
+
+export interface ImportedPostmanRequest {
+  name: string;
+  method: HttpMethod;
+  url: string;
+  headers: { key: string; value: string; enabled: boolean }[];
+  params: { key: string; value: string; enabled: boolean }[];
+  body?: {
+    raw?: string;
+    form?: { key: string; value: string; enabled: boolean }[];
+  };
+  bodyType?: string;
+  auth?: unknown;
+  preRequestScript?: string;
+  tests?: string;
+}
+
+/**
+ * Import a Postman Collection v2.1 JSON.
+ */
+export function importPostman(collectionJson: string): ImportedPostmanCollection {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(collectionJson);
+  } catch {
+    throw new Error('Invalid Postman collection: must be valid JSON');
+  }
+
+  const collection = parsed as Record<string, unknown>;
+
+  // Handle wrapped format: { info: { schema: ... }, item: [...] }
+  const info = collection['info'] as Record<string, unknown> | undefined;
+  const items = collection['item'] as PostmanItem[] | undefined;
+
+  if (!items || !Array.isArray(items)) {
+    throw new Error('Invalid Postman collection: missing "item" array');
+  }
+
+  const variables = collection['variable'] as Array<{ key: string; value: string }> | undefined;
+  const vars: Record<string, string> = {};
+  if (variables && Array.isArray(variables)) {
+    for (const v of variables) {
+      if (v.key) vars[v.key] = v.value ?? '';
+    }
+  }
+
+  const result: ImportedPostmanCollection = {
+    name: (info?.['name'] as string) ?? 'Imported Collection',
+    description: info?.['description'] as string,
+    folders: [],
+    requests: [],
+    variables: vars,
+  };
+
+  // Process items recursively
+  processItems(items, result);
+
+  return result;
+}
+
+interface PostmanItem {
+  name?: string;
+  item?: PostmanItem[];
+  request?: PostmanRequest;
+  description?: string;
+  event?: Array<{
+    listen: string;
+    script: { exec: string[] | string };
+  }>;
+}
+
+interface PostmanRequest {
+  method?: string;
+  url?: string | {
+    raw?: string;
+    protocol?: string;
+    host?: string[];
+    path?: string[];
+    query?: Array<{ key: string; value: string; disabled?: boolean }>;
+    variable?: Array<{ key: string; value: string }>;
+  };
+  header?: Array<{ key: string; value: string; disabled?: boolean }>;
+  body?: {
+    mode?: string;
+    raw?: string;
+    urlencoded?: Array<{ key: string; value: string; disabled?: boolean }>;
+    formdata?: Array<{ key: string; value: string; type?: string; disabled?: boolean }>;
+    graphql?: { query: string; variables?: string };
+  };
+  auth?: {
+    type?: string;
+    basic?: Array<{ key: string; value: string }>;
+    bearer?: Array<{ key: string; value: string }>;
+    apikey?: Array<{ key: string; value: string }>;
+    oauth2?: Array<{ key: string; value: string }>;
+    awsv4?: Array<{ key: string; value: string }>;
+  };
+}
+
+function processItems(items: PostmanItem[], result: ImportedPostmanCollection, folderName?: string): void {
+  for (const item of items) {
+    if (item.item && Array.isArray(item.item)) {
+      // This is a folder
+      const folder: ImportedFolder = {
+        name: item.name ?? 'Unnamed Folder',
+        description: item.description,
+        requests: [],
+      };
+
+      processFolderItems(item.item, folder);
+      result.folders.push(folder);
+    } else if (item.request) {
+      const request = parsePostmanRequest(item);
+      if (folderName) {
+        // Will be added to folder by caller
+      }
+      result.requests.push(request);
+    }
+  }
+}
+
+function processFolderItems(items: PostmanItem[], folder: ImportedFolder): void {
+  for (const item of items) {
+    if (item.request) {
+      folder.requests.push(parsePostmanRequest(item));
+    }
+  }
+}
+
+function parsePostmanRequest(item: PostmanItem): ImportedPostmanRequest {
+  const req = item.request!;
+  const method = (req.method?.toUpperCase() ?? 'GET') as HttpMethod;
+
+  // Parse URL
+  let url = '';
+  const params: ImportedPostmanRequest['params'] = [];
+
+  if (typeof req.url === 'string') {
+    url = req.url;
+  } else if (req.url) {
+    if (req.url.raw) {
+      url = req.url.raw;
+    } else if (req.url.host && req.url.path) {
+      url = `${req.url.protocol ?? 'https'}://${req.url.host.join('.')}/${req.url.path.join('/')}`;
+    }
+
+    if (req.url.query) {
+      for (const q of req.url.query) {
+        params.push({ key: q.key, value: q.value ?? '', enabled: !q.disabled });
+      }
+    }
+  }
+
+  // Parse headers
+  const headers: ImportedPostmanRequest['headers'] = [];
+  if (req.header) {
+    for (const h of req.header) {
+      headers.push({ key: h.key, value: h.value, enabled: !h.disabled });
+    }
+  }
+
+  // Parse body
+  let body: ImportedPostmanRequest['body'];
+  let bodyType: string | undefined;
+
+  if (req.body) {
+    switch (req.body.mode) {
+      case 'raw':
+        body = { raw: req.body.raw ?? '' };
+        bodyType = 'raw';
+        // Check if it's JSON
+        try {
+          JSON.parse(req.body.raw ?? '');
+          bodyType = 'json';
+        } catch { /* not json */ }
+        break;
+      case 'urlencoded':
+        body = {
+          form: (req.body.urlencoded ?? []).map((f) => ({
+            key: f.key,
+            value: f.value,
+            enabled: !f.disabled,
+          })),
+        };
+        bodyType = 'urlencoded';
+        break;
+      case 'formdata':
+        body = {
+          form: (req.body.formdata ?? []).map((f) => ({
+            key: f.key,
+            value: f.value,
+            enabled: !f.disabled,
+          })),
+        };
+        bodyType = 'form';
+        break;
+      case 'graphql':
+        if (req.body.graphql) {
+          body = {
+            raw: JSON.stringify({
+              query: req.body.graphql.query,
+              variables: req.body.graphql.variables
+                ? JSON.parse(req.body.graphql.variables)
+                : undefined,
+            }, null, 2),
+          };
+          bodyType = 'graphql';
+        }
+        break;
+    }
+  }
+
+  // Parse auth
+  let auth: unknown;
+  if (req.auth) {
+    auth = parsePostmanAuth(req.auth);
+  }
+
+  // Parse scripts
+  let preRequestScript: string | undefined;
+  let tests: string | undefined;
+
+  if (item.event) {
+    for (const event of item.event) {
+      const script = typeof event.script?.exec === 'string'
+        ? event.script.exec
+        : (event.script?.exec ?? []).join('\n');
+
+      if (event.listen === 'prerequest') {
+        preRequestScript = script;
+      } else if (event.listen === 'test') {
+        tests = script;
+      }
+    }
+  }
+
+  return {
+    name: item.name ?? 'Unnamed Request',
+    method,
+    url,
+    headers,
+    params,
+    body,
+    bodyType,
+    auth,
+    preRequestScript,
+    tests,
+  };
+}
+
+function parsePostmanAuth(auth: PostmanRequest['auth']): unknown {
+  if (!auth) return undefined;
+
+  const getAuthValue = (items: Array<{ key: string; value: string }> | undefined, key: string): string => {
+    const item = items?.find((i) => i.key === key);
+    return item?.value ?? '';
+  };
+
+  switch (auth.type) {
+    case 'basic':
+      return {
+        type: 'basic',
+        username: getAuthValue(auth.basic, 'username'),
+        password: getAuthValue(auth.basic, 'password'),
+      };
+    case 'bearer':
+      return {
+        type: 'bearer',
+        token: getAuthValue(auth.bearer, 'token'),
+      };
+    case 'apikey':
+      return {
+        type: 'apikey',
+        key: getAuthValue(auth.apikey, 'key'),
+        value: getAuthValue(auth.apikey, 'value'),
+        addTo: getAuthValue(auth.apikey, 'in') === 'query' ? 'query' : 'header',
+      };
+    case 'oauth2':
+      return {
+        type: 'oauth2',
+        accessTokenUrl: getAuthValue(auth.oauth2, 'accessTokenUrl'),
+        clientId: getAuthValue(auth.oauth2, 'clientId'),
+        clientSecret: getAuthValue(auth.oauth2, 'clientSecret'),
+        token: getAuthValue(auth.oauth2, 'accessToken'),
+      };
+    case 'awsv4':
+      return {
+        type: 'aws',
+        accessKey: getAuthValue(auth.awsv4, 'accessKey'),
+        secretKey: getAuthValue(auth.awsv4, 'secretKey'),
+        region: getAuthValue(auth.awsv4, 'region'),
+        service: getAuthValue(auth.awsv4, 'service'),
+      };
+    default:
+      return undefined;
+  }
+}