@theihtisham/devtools-with-cloud 1.0.0

package/src/lib/ai/test-generator.ts

@@ -0,0 +1,161 @@
+/**
+ * AI test generator - generates test assertions from request/response data.
+ * Uses OpenAI-compatible API.
+ */
+
+interface RequestData {
+  method: string;
+  url: string;
+  headers: Record<string, string>;
+  body?: string;
+}
+
+interface ResponseData {
+  status: number;
+  statusText: string;
+  headers: Record<string, string>;
+  body: string;
+  duration: number;
+}
+
+/**
+ * Generate test assertions from a request/response pair.
+ * Returns JavaScript test code as a string.
+ */
+export async function generateTests(
+  request: RequestData,
+  response: ResponseData,
+  apiKey?: string,
+  baseUrl?: string,
+  model?: string,
+): Promise<string> {
+  // If no API key, generate basic tests locally
+  if (!apiKey) {
+    return generateLocalTests(request, response);
+  }
+
+  try {
+    const openaiUrl = `${baseUrl ?? 'https://api.openai.com/v1'}/chat/completions`;
+    const responseJson = parseBody(response.body);
+
+    const prompt = buildTestGenerationPrompt(request, response, responseJson);
+
+    const res = await fetch(openaiUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify({
+        model: model ?? 'gpt-4o',
+        messages: [
+          { role: 'system', content: 'You are an API testing expert. Generate test assertions in JavaScript. Use pm.test(), pm.expect(), and pm.response APIs similar to Postman.' },
+          { role: 'user', content: prompt },
+        ],
+        temperature: 0.3,
+        max_tokens: 2000,
+      }),
+    });
+
+    if (!res.ok) {
+      return generateLocalTests(request, response);
+    }
+
+    const data = await res.json() as { choices: Array<{ message: { content: string } }> };
+    const content = data.choices?.[0]?.message?.content;
+    if (content) {
+      // Extract code from markdown code blocks if present
+      const codeMatch = content.match(/```(?:javascript|js)?\n([\s\S]*?)```/);
+      return codeMatch?.[1]?.trim() ?? content.trim();
+    }
+
+    return generateLocalTests(request, response);
+  } catch {
+    return generateLocalTests(request, response);
+  }
+}
+
+function parseBody(body: string): unknown {
+  try {
+    return JSON.parse(body);
+  } catch {
+    return null;
+  }
+}
+
+function buildTestGenerationPrompt(request: RequestData, response: ResponseData, responseJson: unknown): string {
+  return `Generate 5-10 API test assertions for this request/response pair:
+
+Request:
+- Method: ${request.method}
+- URL: ${request.url}
+- Headers: ${JSON.stringify(request.headers)}
+
+Response:
+- Status: ${response.status} ${response.statusText}
+- Duration: ${response.duration}ms
+- Body: ${typeof responseJson === 'object' ? JSON.stringify(responseJson, null, 2).slice(0, 2000) : response.body.slice(0, 1000)}
+
+Generate tests using pm.test() syntax:
+- Status code checks
+- Response body structure validation
+- Field type/value assertions
+- Performance checks
+- Header checks
+
+Output ONLY the JavaScript test code, no explanations.`;
+}
+
+function generateLocalTests(request: RequestData, response: ResponseData): string {
+  const tests: string[] = [];
+
+  // Status code test
+  tests.push(`pm.test("Status code is ${response.status}", () => {
+  pm.expect(pm.response.status).to.equal(${response.status});
+});`);
+
+  // Response time test
+  tests.push(`pm.test("Response time is less than 5000ms", () => {
+  pm.expect(pm.response.duration).to.be.below(5000);
+});`);
+
+  // Content type test
+  const contentType = response.headers['content-type'];
+  if (contentType) {
+    tests.push(`pm.test("Has Content-Type header", () => {
+  pm.expect(pm.response.headers['content-type']).to.exist;
+});`);
+  }
+
+  // JSON body tests
+  try {
+    const json = JSON.parse(response.body);
+    if (Array.isArray(json)) {
+      tests.push(`pm.test("Response is an array", () => {
+  const json = pm.response.json();
+  pm.expect(json).to.be.an('array');
+});`);
+    } else if (typeof json === 'object' && json !== null) {
+      const keys = Object.keys(json);
+      if (keys.length > 0) {
+        tests.push(`pm.test("Response is an object", () => {
+  const json = pm.response.json();
+  pm.expect(json).to.be.an('object');
+});`);
+      }
+    }
+  } catch {
+    tests.push(`pm.test("Response has body", () => {
+  pm.expect(pm.response.body).to.exist;
+});`);
+  }
+
+  // Method-specific tests
+  if (request.method === 'POST' && response.status === 201) {
+    tests.push(`pm.test("POST returns 201 Created", () => {
+  pm.expect(pm.response.status).to.equal(201);
+});`);
+  }
+
+  return tests.join('\n\n');
+}

package/src/lib/auth/api-key.ts

@@ -0,0 +1,28 @@
+import type { ApiKeyAuthSchema } from '@/lib/utils/validation';
+import { z } from 'zod';
+
+type ApiKeyAuthConfig = z.infer<typeof ApiKeyAuthSchema>;
+
+/**
+ * Apply API Key authentication to request headers, query params, or cookies.
+ */
+export function applyApiKeyAuth(
+  headers: Record<string, string>,
+  params: Record<string, string>,
+  config: ApiKeyAuthConfig,
+): void {
+  switch (config.addTo) {
+    case 'header':
+      headers[config.key] = config.value;
+      break;
+    case 'query':
+      params[config.key] = config.value;
+      break;
+    case 'cookie': {
+      const existing = headers['Cookie'] ?? '';
+      const separator = existing ? '; ' : '';
+      headers['Cookie'] = `${existing}${separator}${config.key}=${config.value}`;
+      break;
+    }
+  }
+}

package/src/lib/auth/aws-sig.ts

@@ -0,0 +1,131 @@
+import { createHmac, createHash } from 'crypto';
+
+/**
+ * AWS Signature Version 4 signing implementation.
+ * Signs HTTP requests for AWS services (S3, API Gateway, Lambda, etc.).
+ */
+
+interface AwsSignConfig {
+  accessKey: string;
+  secretKey: string;
+  region: string;
+  service: string;
+  sessionToken?: string;
+}
+
+const AWS4_ALGORITHM = 'AWS4-HMAC-SHA256';
+
+/**
+ * Apply AWS Signature v4 to request headers.
+ */
+export function applyAwsAuth(
+  headers: Record<string, string>,
+  method: string,
+  path: string,
+  accessKey: string,
+  secretKey: string,
+  region: string,
+  service: string,
+  body: string,
+  sessionToken?: string,
+): void {
+  const now = new Date();
+  const dateStamp = formatDate(now);
+  const amzDate = formatAmzDate(now);
+  const host = headers['Host'] ?? headers['host'] ?? '';
+
+  // Create canonical request
+  const payloadHash = sha256Hex(body);
+  headers['x-amz-content-sha256'] = payloadHash;
+  headers['x-amz-date'] = amzDate;
+  if (sessionToken) {
+    headers['x-amz-security-token'] = sessionToken;
+  }
+
+  const signedHeaders = getSignedHeaders(headers, sessionToken !== undefined);
+  const canonicalHeaders = buildCanonicalHeaders(headers, signedHeaders);
+  const canonicalQueryString = ''; // Would need query string parsing for full support
+
+  const canonicalRequest = [
+    method,
+    path,
+    canonicalQueryString,
+    canonicalHeaders,
+    '',
+    signedHeaders,
+    payloadHash,
+  ].join('\n');
+
+  // Create string to sign
+  const credentialScope = `${dateStamp}/${region}/${service}/aws4_request`;
+  const stringToSign = [
+    AWS4_ALGORITHM,
+    amzDate,
+    credentialScope,
+    sha256Hex(canonicalRequest),
+  ].join('\n');
+
+  // Calculate signature
+  const signingKey = getSigningKey(secretKey, dateStamp, region, service);
+  const signature = hmacHex(signingKey, stringToSign);
+
+  // Build authorization header
+  headers['Authorization'] = `${AWS4_ALGORITHM} Credential=${accessKey}/${credentialScope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
+}
+
+function formatDate(date: Date): string {
+  return date.toISOString().replace(/[-:]/g, '').slice(0, 8);
+}
+
+function formatAmzDate(date: Date): string {
+  return date.toISOString().replace(/[-:]/g, '').replace(/\.\d{3}/, '');
+}
+
+function sha256Hex(data: string): string {
+  return createHash('sha256').update(data).digest('hex');
+}
+
+function hmacHex(key: Buffer, data: string): string {
+  return createHmac('sha256', key).update(data).digest('hex');
+}
+
+function hmacBuffer(key: Buffer | string, data: string): Buffer {
+  return createHmac('sha256', key).update(data).digest();
+}
+
+function getSigningKey(
+  secretKey: string,
+  dateStamp: string,
+  region: string,
+  service: string,
+): Buffer {
+  const kDate = hmacBuffer(`AWS4${secretKey}`, dateStamp);
+  const kRegion = hmacBuffer(kDate, region);
+  const kService = hmacBuffer(kRegion, service);
+  return hmacBuffer(kService, 'aws4_request');
+}
+
+function getSignedHeaders(headers: Record<string, string>, hasSessionToken: boolean): string {
+  const headerNames = Object.keys(headers)
+    .map((k) => k.toLowerCase())
+    .filter((name) => {
+      // Sign specific headers
+      const signable = ['host', 'content-type', 'x-amz-date', 'x-amz-content-sha256'];
+      if (hasSessionToken) signable.push('x-amz-security-token');
+      return signable.includes(name);
+    })
+    .sort();
+  return headerNames.join(';');
+}
+
+function buildCanonicalHeaders(headers: Record<string, string>, signedHeaders: string): string {
+  const headerNames = signedHeaders.split(';');
+  return headerNames
+    .map((name) => {
+      const value = Object.entries(headers).find(
+        ([k]) => k.toLowerCase() === name,
+      )?.[1] ?? '';
+      return `${name}:${value.trim()}`;
+    })
+    .join('\n');
+}

package/src/lib/auth/basic.ts

@@ -0,0 +1,17 @@
+import type { BasicAuthSchema } from '@/lib/utils/validation';
+
+type BasicAuthConfig = z.infer<typeof BasicAuthSchema>;
+
+import { z } from 'zod';
+
+/**
+ * Apply Basic authentication to request headers.
+ * Encodes username:password as base64 and adds Authorization header.
+ */
+export function applyBasicAuth(
+  headers: Record<string, string>,
+  config: BasicAuthConfig,
+): void {
+  const credentials = btoa(`${config.username}:${config.password}`);
+  headers['Authorization'] = `Basic ${credentials}`;
+}

package/src/lib/auth/bearer.ts

@@ -0,0 +1,15 @@
+import type { BearerAuthSchema } from '@/lib/utils/validation';
+import { z } from 'zod';
+
+type BearerAuthConfig = z.infer<typeof BearerAuthSchema>;
+
+/**
+ * Apply Bearer token authentication to request headers.
+ */
+export function applyBearerAuth(
+  headers: Record<string, string>,
+  config: BearerAuthConfig,
+): void {
+  const prefix = config.prefix ?? 'Bearer';
+  headers['Authorization'] = `${prefix} ${config.token}`;
+}

package/src/lib/auth/oauth2.ts

@@ -0,0 +1,155 @@
+import type { OAuth2AuthSchema } from '@/lib/utils/validation';
+import { z } from 'zod';
+
+type OAuth2AuthConfig = z.infer<typeof OAuth2AuthSchema>;
+
+export interface OAuth2TokenResponse {
+  access_token: string;
+  token_type: string;
+  expires_in?: number;
+  refresh_token?: string;
+  scope?: string;
+}
+
+/**
+ * Get OAuth2 access token using client credentials flow.
+ */
+export async function getClientCredentialsToken(
+  config: OAuth2AuthConfig,
+): Promise<OAuth2TokenResponse> {
+  if (!config.accessTokenUrl) {
+    throw new Error('Access token URL is required for client credentials flow');
+  }
+  if (!config.clientId || !config.clientSecret) {
+    throw new Error('Client ID and secret are required for client credentials flow');
+  }
+
+  const body = new URLSearchParams({
+    grant_type: 'client_credentials',
+    client_id: config.clientId,
+    client_secret: config.clientSecret,
+  });
+
+  if (config.scope) {
+    body.set('scope', config.scope);
+  }
+
+  const response = await fetch(config.accessTokenUrl, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/x-www-form-urlencoded',
+    },
+    body: body.toString(),
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`OAuth2 token request failed: ${response.status} ${errorText}`);
+  }
+
+  return response.json() as Promise<OAuth2TokenResponse>;
+}
+
+/**
+ * Get OAuth2 access token using password flow.
+ */
+export async function getPasswordToken(
+  config: OAuth2AuthConfig,
+  username: string,
+  password: string,
+): Promise<OAuth2TokenResponse> {
+  if (!config.accessTokenUrl) {
+    throw new Error('Access token URL is required for password flow');
+  }
+  if (!config.clientId) {
+    throw new Error('Client ID is required for password flow');
+  }
+
+  const body = new URLSearchParams({
+    grant_type: 'password',
+    client_id: config.clientId,
+    username,
+    password,
+  });
+
+  if (config.clientSecret) {
+    body.set('client_secret', config.clientSecret);
+  }
+  if (config.scope) {
+    body.set('scope', config.scope);
+  }
+
+  const response = await fetch(config.accessTokenUrl, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/x-www-form-urlencoded',
+    },
+    body: body.toString(),
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`OAuth2 token request failed: ${response.status} ${errorText}`);
+  }
+
+  return response.json() as Promise<OAuth2TokenResponse>;
+}
+
+/**
+ * Refresh an expired OAuth2 access token.
+ */
+export async function refreshOAuth2Token(
+  config: OAuth2AuthConfig,
+  refreshToken: string,
+): Promise<OAuth2TokenResponse> {
+  if (!config.accessTokenUrl || !config.clientId) {
+    throw new Error('Access token URL and client ID are required for token refresh');
+  }
+
+  const body = new URLSearchParams({
+    grant_type: 'refresh_token',
+    client_id: config.clientId,
+    refresh_token: refreshToken,
+  });
+
+  if (config.clientSecret) {
+    body.set('client_secret', config.clientSecret);
+  }
+
+  const response = await fetch(config.accessTokenUrl, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/x-www-form-urlencoded',
+    },
+    body: body.toString(),
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`OAuth2 token refresh failed: ${response.status} ${errorText}`);
+  }
+
+  return response.json() as Promise<OAuth2TokenResponse>;
+}
+
+/**
+ * Build the authorization URL for the authorization code flow.
+ */
+export function buildAuthorizationUrl(config: OAuth2AuthConfig, state: string): string {
+  if (!config.authorizationUrl || !config.clientId) {
+    throw new Error('Authorization URL and client ID are required');
+  }
+
+  const params = new URLSearchParams({
+    response_type: 'code',
+    client_id: config.clientId,
+    redirect_uri: `${typeof window !== 'undefined' ? window.location.origin : ''}/oauth/callback`,
+    state,
+  });
+
+  if (config.scope) {
+    params.set('scope', config.scope);
+  }
+
+  return `${config.authorizationUrl}?${params.toString()}`;
+}

package/src/lib/auth/types.ts

@@ -0,0 +1,16 @@
+import type { AuthConfig } from '@/lib/utils/validation';
+
+export type { AuthConfig };
+
+export interface AuthApplyResult {
+  headers: Record<string, string>;
+  params: Record<string, string>;
+  cookies: Record<string, string>;
+}
+
+/**
+ * Base interface for auth handlers.
+ */
+export interface AuthHandler<T extends AuthConfig> {
+  apply(headers: Record<string, string>, config: T): void;
+}

package/src/lib/db/client.ts

@@ -0,0 +1,15 @@
+import { PrismaClient } from '@prisma/client';
+
+const globalForPrisma = globalThis as unknown as {
+  prisma: PrismaClient | undefined;
+};
+
+export const prisma = globalForPrisma.prisma ?? new PrismaClient({
+  log: process.env['NODE_ENV'] === 'development' ? ['query', 'error', 'warn'] : ['error'],
+});
+
+if (process.env['NODE_ENV'] !== 'production') {
+  globalForPrisma.prisma = prisma;
+}
+
+export default prisma;

package/src/lib/env/manager.ts

@@ -0,0 +1,32 @@
+interface EnvironmentVariable {
+  key: string;
+  value: string;
+  type: string;
+  enabled: boolean;
+}
+
+export interface ResolvedEnvironment {
+  id: string;
+  name: string;
+  variables: Record<string, string>;
+}
+
+/**
+ * Resolve environment variables into a simple key-value map.
+ */
+export function resolveEnvironmentVariables(vars: EnvironmentVariable[]): Record<string, string> {
+  const result: Record<string, string> = {};
+  for (const v of vars) {
+    if (v.enabled) {
+      result[v.key] = v.value;
+    }
+  }
+  return result;
+}
+
+/**
+ * Merge multiple environment variable maps (later ones override earlier ones).
+ */
+export function mergeEnvironments(...envMaps: Record<string, string>[]): Record<string, string> {
+  return envMaps.reduce((acc, map) => ({ ...acc, ...map }), {});
+}

package/src/lib/env/resolver.ts

@@ -0,0 +1,30 @@
+/**
+ * Resolve {{variable_name}} placeholders in strings.
+ * Replaces all occurrences of {{key}} with the corresponding value from the variables map.
+ */
+export function resolveVariables(input: string, variables: Record<string, string>): string {
+  return input.replace(/\{\{(\w+)\}\}/g, (match, key: string) => {
+    const value = variables[key];
+    if (value !== undefined) return value;
+    return match; // Leave unresolved variables as-is
+  });
+}
+
+/**
+ * Extract all variable names from a string (e.g., {{base_url}} -> ['base_url']).
+ */
+export function extractVariables(input: string): string[] {
+  const matches = input.matchAll(/\{\{(\w+)\}\}/g);
+  const vars = new Set<string>();
+  for (const match of matches) {
+    if (match[1]) vars.add(match[1]);
+  }
+  return Array.from(vars);
+}
+
+/**
+ * Check if a string contains any unresolved variables.
+ */
+export function hasUnresolvedVariables(input: string): boolean {
+  return /\{\{\w+\}\}/.test(input);
+}