@theihtisham/devtools-with-cloud 1.0.0

package/src/lib/exporters/openapi.ts

@@ -0,0 +1,193 @@
+export interface ExportRequest {
+  name: string;
+  method: string;
+  url: string;
+  description?: string;
+  headers: { key: string; value: string }[];
+  params: { key: string; value: string }[];
+  body?: string;
+  bodyType?: string;
+}
+
+export interface ExportCollection {
+  name: string;
+  description?: string;
+  requests: ExportRequest[];
+  baseUrl?: string;
+}
+
+/**
+ * Export a collection to OpenAPI 3.1 specification.
+ */
+export function exportToOpenApi(collection: ExportCollection): string {
+  const spec: Record<string, unknown> = {
+    openapi: '3.1.0',
+    info: {
+      title: collection.name,
+      description: collection.description,
+      version: '1.0.0',
+    },
+    servers: collection.baseUrl
+      ? [{ url: collection.baseUrl }]
+      : [],
+    paths: {},
+    components: {
+      schemas: {},
+      securitySchemes: {},
+    },
+  };
+
+  const paths: Record<string, Record<string, unknown>> = {};
+  const schemas: Record<string, Record<string, unknown>> = {};
+
+  for (const req of collection.requests) {
+    const path = extractPath(req.url);
+    const method = req.method.toLowerCase();
+
+    if (!paths[path]) {
+      paths[path] = {} as Record<string, unknown>;
+    }
+
+    const operation: Record<string, unknown> = {
+      operationId: toOperationId(method, path),
+      summary: req.name,
+      description: req.description,
+      tags: [collection.name],
+      parameters: buildParameters(req),
+      responses: {},
+    };
+
+    // Build request body
+    if (req.body && req.bodyType !== 'none') {
+      const contentType = req.bodyType === 'json' ? 'application/json'
+        : req.bodyType === 'urlencoded' ? 'application/x-www-form-urlencoded'
+        : req.bodyType === 'form' ? 'multipart/form-data'
+        : 'text/plain';
+
+      let schema: Record<string, unknown>;
+      if (req.bodyType === 'json') {
+        try {
+          const parsed = JSON.parse(req.body);
+          schema = inferSchema(parsed, req.name);
+        } catch {
+          schema = { type: 'string' };
+        }
+      } else {
+        schema = { type: 'string' };
+      }
+
+      const schemaName = `${toPascalCase(req.name)}Body`;
+      schemas[schemaName] = schema;
+
+      operation['requestBody'] = {
+        required: true,
+        content: {
+          [contentType]: {
+            schema: { $ref: `#/components/schemas/${schemaName}` },
+          },
+        },
+      };
+    }
+
+    // Add default response
+    operation['responses'] = {
+      '200': {
+        description: 'Successful response',
+      },
+    };
+
+    paths[path]![method] = operation;
+  }
+
+  spec['paths'] = paths;
+  (spec['components'] as Record<string, unknown>)['schemas'] = schemas;
+
+  return JSON.stringify(spec, null, 2);
+}
+
+function extractPath(url: string): string {
+  try {
+    const urlObj = new URL(url);
+    return urlObj.pathname;
+  } catch {
+    // Might be a path without host
+    if (url.startsWith('/')) return url;
+    return `/${url}`;
+  }
+}
+
+function toOperationId(method: string, path: string): string {
+  const segments = path
+    .split('/')
+    .filter(Boolean)
+    .map((s) => s.replace(/[{}]/g, '').replace(/[^a-zA-Z0-9]/g, '_'));
+
+  return `${method}${segments.map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join('')}`;
+}
+
+function toPascalCase(str: string): string {
+  return str
+    .replace(/[^a-zA-Z0-9]+(.)/g, (_, c: string) => c.toUpperCase())
+    .replace(/^[a-z]/, (c) => c.toUpperCase())
+    .replace(/[^a-zA-Z0-9]/g, '');
+}
+
+function buildParameters(req: ExportRequest): Array<Record<string, unknown>> {
+  const parameters: Array<Record<string, unknown>> = [];
+
+  for (const param of req.params) {
+    parameters.push({
+      name: param.key,
+      in: 'query',
+      required: false,
+      schema: { type: 'string' },
+    });
+  }
+
+  for (const header of req.headers) {
+    const name = header.key.toLowerCase();
+    if (name === 'authorization' || name === 'content-type' || name === 'accept') continue;
+
+    parameters.push({
+      name: header.key,
+      in: 'header',
+      required: false,
+      schema: { type: 'string' },
+    });
+  }
+
+  return parameters;
+}
+
+function inferSchema(data: unknown, prefix: string): Record<string, unknown> {
+  if (data === null) return { type: 'string', nullable: true };
+  if (typeof data === 'string') return { type: 'string', example: data };
+  if (typeof data === 'number') return Number.isInteger(data) ? { type: 'integer', example: data } : { type: 'number', example: data };
+  if (typeof data === 'boolean') return { type: 'boolean', example: data };
+
+  if (Array.isArray(data)) {
+    if (data.length === 0) return { type: 'array', items: {} };
+    return {
+      type: 'array',
+      items: inferSchema(data[0], prefix),
+      example: data,
+    };
+  }
+
+  if (typeof data === 'object') {
+    const properties: Record<string, unknown> = {};
+    const obj = data as Record<string, unknown>;
+
+    for (const [key, value] of Object.entries(obj)) {
+      properties[key] = inferSchema(value, `${prefix}_${key}`);
+    }
+
+    return {
+      type: 'object',
+      properties,
+      example: data,
+    };
+  }
+
+  return { type: 'string' };
+}

package/src/lib/exporters/postman.ts

@@ -0,0 +1,140 @@
+import type { ExportRequest, ExportCollection } from './openapi';
+
+export type { ExportCollection };
+
+/**
+ * Export a collection to Postman Collection v2.1 format.
+ */
+export function exportToPostman(collection: ExportCollection): string {
+  const postmanCollection = {
+    info: {
+      _postman_id: generateId(),
+      name: collection.name,
+      description: collection.description,
+      schema: 'https://schema.getpostman.com/json/collection/v2.1.0/collection.json',
+    },
+    item: collection.requests.map((req) => buildPostmanItem(req)),
+    variable: [],
+  };
+
+  return JSON.stringify(postmanCollection, null, 2);
+}
+
+interface PostmanItem {
+  name: string;
+  request: {
+    method: string;
+    header: Array<{ key: string; value: string; type: string }>;
+    body?: {
+      mode: string;
+      raw?: string;
+      urlencoded?: Array<{ key: string; value: string; type: string }>;
+      formdata?: Array<{ key: string; value: string; type: string }>;
+    };
+    url: {
+      raw: string;
+      protocol: string;
+      host: string[];
+      path: string[];
+      query: Array<{ key: string; value: string }>;
+    };
+    auth?: {
+      type: string;
+      bearer?: Array<{ key: string; value: string; type: string }>;
+    };
+    description?: string;
+  };
+  response: unknown[];
+}
+
+function buildPostmanItem(req: ExportRequest): PostmanItem {
+  const urlParts = parseUrl(req.url);
+
+  const item: PostmanItem = {
+    name: req.name,
+    request: {
+      method: req.method.toUpperCase(),
+      header: req.headers.map((h) => ({
+        key: h.key,
+        value: h.value,
+        type: 'text',
+      })),
+      url: {
+        raw: req.url,
+        protocol: urlParts.protocol,
+        host: urlParts.host,
+        path: urlParts.path,
+        query: req.params.map((p) => ({
+          key: p.key,
+          value: p.value,
+        })),
+      },
+      description: req.description,
+    },
+    response: [],
+  };
+
+  // Build body
+  if (req.body && req.bodyType !== 'none') {
+    switch (req.bodyType) {
+      case 'json':
+      case 'raw':
+        item.request.body = {
+          mode: 'raw',
+          raw: req.body,
+        };
+        break;
+      case 'urlencoded':
+        try {
+          const params = new URLSearchParams(req.body);
+          item.request.body = {
+            mode: 'urlencoded',
+            urlencoded: Array.from(params.entries()).map(([key, value]) => ({
+              key,
+              value,
+              type: 'text',
+            })),
+          };
+        } catch {
+          item.request.body = { mode: 'raw', raw: req.body };
+        }
+        break;
+      case 'form':
+        item.request.body = {
+          mode: 'formdata',
+          formdata: req.body.split('&').map((pair) => {
+            const [key, value] = pair.split('=');
+            return { key: key ?? '', value: value ?? '', type: 'text' };
+          }),
+        };
+        break;
+    }
+  }
+
+  return item;
+}
+
+function parseUrl(url: string): { protocol: string; host: string[]; path: string[] } {
+  try {
+    const urlObj = new URL(url);
+    return {
+      protocol: urlObj.protocol.replace(':', ''),
+      host: urlObj.hostname.split('.'),
+      path: urlObj.pathname.split('/').filter(Boolean),
+    };
+  } catch {
+    return {
+      protocol: 'https',
+      host: ['example', 'com'],
+      path: url.split('/').filter(Boolean),
+    };
+  }
+}
+
+function generateId(): string {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === 'x' ? r : (r & 0x3 | 0x8);
+    return v.toString(16);
+  });
+}

package/src/lib/graphql/builder.ts

@@ -0,0 +1,249 @@
+/**
+ * GraphQL Query Builder — fluent API for constructing GraphQL queries and mutations.
+ */
+
+import type {
+  GraphQLOperationType,
+  GraphQLVariable,
+  GraphQLField,
+  GraphQLFragment,
+  GraphQLQuery,
+} from './types';
+
+export class QueryBuilder {
+  private operationType: GraphQLOperationType = 'query';
+  private operationName?: string;
+  private variables: GraphQLVariable[] = [];
+  private fields: GraphQLField[] = [];
+  private fragments: GraphQLFragment[] = [];
+
+  /**
+   * Start a query operation.
+   */
+  query(name?: string): this {
+    this.operationType = 'query';
+    this.operationName = name;
+    return this;
+  }
+
+  /**
+   * Start a mutation operation.
+   */
+  mutation(name?: string): this {
+    this.operationType = 'mutation';
+    this.operationName = name;
+    return this;
+  }
+
+  /**
+   * Start a subscription operation.
+   */
+  subscription(name?: string): this {
+    this.operationType = 'subscription';
+    this.operationName = name;
+    return this;
+  }
+
+  /**
+   * Add a field to the selection set.
+   * Supports nested subfields and arguments.
+   */
+  field(name: string, args?: Record<string, string>, subfields?: GraphQLField[] | string[]): this {
+    const fieldEntry: GraphQLField = { name };
+
+    if (args && Object.keys(args).length > 0) {
+      fieldEntry.arguments = Object.entries(args).map(([key, value]) => ({
+        name: key,
+        value,
+      }));
+    }
+
+    if (subfields && subfields.length > 0) {
+      fieldEntry.subfields = subfields.map((sf) =>
+        typeof sf === 'string' ? { name: sf } : sf,
+      );
+    }
+
+    this.fields.push(fieldEntry);
+    return this;
+  }
+
+  /**
+   * Add a field with an alias.
+   */
+  aliasField(alias: string, name: string, args?: Record<string, string>, subfields?: GraphQLField[] | string[]): this {
+    const fieldEntry: GraphQLField = { name, alias };
+
+    if (args && Object.keys(args).length > 0) {
+      fieldEntry.arguments = Object.entries(args).map(([key, value]) => ({
+        name: key,
+        value,
+      }));
+    }
+
+    if (subfields && subfields.length > 0) {
+      fieldEntry.subfields = subfields.map((sf) =>
+        typeof sf === 'string' ? { name: sf } : sf,
+      );
+    }
+
+    this.fields.push(fieldEntry);
+    return this;
+  }
+
+  /**
+   * Add a variable definition.
+   */
+  variable(name: string, type: string, defaultValue?: string): this {
+    this.variables.push({ name, type, defaultValue });
+    return this;
+  }
+
+  /**
+   * Define a fragment that can be spread into fields.
+   */
+  fragment(name: string, onType: string, fields: GraphQLField[] | string[]): this {
+    this.fragments.push({
+      name,
+      onType,
+      fields: fields.map((f) => (typeof f === 'string' ? { name: f } : f)),
+    });
+    return this;
+  }
+
+  /**
+   * Spread a fragment into the top-level selection set.
+   */
+  spreadFragment(fragmentName: string): this {
+    this.fields.push({ name: `...${fragmentName}`, fragments: [fragmentName] });
+    return this;
+  }
+
+  /**
+   * Build the GraphQL query string.
+   */
+  build(): string {
+    const parts: string[] = [];
+
+    // Build fragments first
+    for (const fragment of this.fragments) {
+      parts.push(buildFragmentString(fragment));
+    }
+
+    // Build the main operation
+    parts.push(buildOperationString(
+      this.operationType,
+      this.operationName,
+      this.variables,
+      this.fields,
+    ));
+
+    return parts.join('\n\n');
+  }
+
+  /**
+   * Build and return the structured query object.
+   */
+  toQuery(): GraphQLQuery {
+    return {
+      operationType: this.operationType,
+      name: this.operationName,
+      variables: [...this.variables],
+      fields: [...this.fields],
+      fragments: [...this.fragments],
+    };
+  }
+
+  /**
+   * Reset the builder for reuse.
+   */
+  reset(): this {
+    this.operationType = 'query';
+    this.operationName = undefined;
+    this.variables = [];
+    this.fields = [];
+    this.fragments = [];
+    return this;
+  }
+}
+
+/**
+ * Build the operation string: query/mutation/subscription { ... }
+ */
+function buildOperationString(
+  type: GraphQLOperationType,
+  name: string | undefined,
+  variables: GraphQLVariable[],
+  fields: GraphQLField[],
+): string {
+  let operation = type;
+
+  if (name) {
+    operation += ` ${name}`;
+  }
+
+  if (variables.length > 0) {
+    const varDefs = variables.map((v) => {
+      let def = `$${v.name}: ${v.type}`;
+      if (v.defaultValue !== undefined) {
+        def += ` = ${v.defaultValue}`;
+      }
+      return def;
+    });
+    operation += `(${varDefs.join(', ')})`;
+  }
+
+  const selectionSet = buildSelectionSet(fields);
+  return `${operation} ${selectionSet}`;
+}
+
+/**
+ * Build a selection set: { field1 field2(arg: val) { sub } }
+ */
+function buildSelectionSet(fields: GraphQLField[]): string {
+  if (fields.length === 0) return '{}';
+
+  const parts = fields.map((field) => buildFieldString(field));
+  return `{ ${parts.join(' ')} }`;
+}
+
+/**
+ * Build a single field string, recursively handling subfields.
+ */
+function buildFieldString(field: GraphQLField): string {
+  let str = '';
+
+  // Handle fragment spreads
+  if (field.name.startsWith('...')) {
+    return field.name;
+  }
+
+  // Alias
+  if (field.alias) {
+    str += `${field.alias}: `;
+  }
+
+  // Field name
+  str += field.name;
+
+  // Arguments
+  if (field.arguments && field.arguments.length > 0) {
+    const args = field.arguments.map((arg) => `${arg.name}: ${arg.value}`);
+    str += `(${args.join(', ')})`;
+  }
+
+  // Subfields
+  if (field.subfields && field.subfields.length > 0) {
+    str += ` ${buildSelectionSet(field.subfields)}`;
+  }
+
+  return str;
+}
+
+/**
+ * Build a fragment definition string.
+ */
+function buildFragmentString(fragment: GraphQLFragment): string {
+  const selectionSet = buildSelectionSet(fragment.fields);
+  return `fragment ${fragment.name} on ${fragment.onType} ${selectionSet}`;
+}