@theihtisham/devtools-with-cloud 1.0.0

package/src/lib/test-runner/assertions.ts

@@ -0,0 +1,163 @@
+/**
+ * Built-in assertion library for API tests.
+ */
+
+export interface AssertionResult {
+  name: string;
+  passed: boolean;
+  error?: string;
+  duration: number;
+}
+
+/**
+ * Built-in assertion functions that can evaluate test expressions.
+ */
+export const assertions = {
+  equals: (actual: unknown, expected: unknown): boolean => actual === expected,
+  notEquals: (actual: unknown, expected: unknown): boolean => actual !== expected,
+  greaterThan: (actual: number, expected: number): boolean => actual > expected,
+  lessThan: (actual: number, expected: number): boolean => actual < expected,
+  contains: (actual: string, expected: string): boolean => actual.includes(expected),
+  matches: (actual: string, pattern: RegExp): boolean => pattern.test(actual),
+  hasProperty: (obj: unknown, prop: string): boolean => typeof obj === 'object' && obj !== null && prop in obj,
+  isArray: (val: unknown): boolean => Array.isArray(val),
+  isObject: (val: unknown): boolean => typeof val === 'object' && val !== null && !Array.isArray(val),
+  isString: (val: unknown): boolean => typeof val === 'string',
+  isNumber: (val: unknown): boolean => typeof val === 'number',
+  isBoolean: (val: unknown): boolean => typeof val === 'boolean',
+  hasStatus: (status: number, expected: number): boolean => status === expected,
+  hasHeader: (headers: Record<string, string>, name: string): boolean => {
+    return headers[name.toLowerCase()] !== undefined;
+  },
+  hasHeaderWithValue: (headers: Record<string, string>, name: string, value: string): boolean => {
+    return headers[name.toLowerCase()] === value;
+  },
+  jsonPathEquals: (json: unknown, path: string, expected: unknown): boolean => {
+    const actual = getJsonPathValue(json, path);
+    return actual === expected;
+  },
+  jsonPathExists: (json: unknown, path: string): boolean => {
+    return getJsonPathValue(json, path) !== undefined;
+  },
+};
+
+function getJsonPathValue(data: unknown, path: string): unknown {
+  const parts = path.replace(/\[(\d+)]/g, '.$1').split('.');
+  let current: unknown = data;
+
+  for (const part of parts) {
+    if (current === null || current === undefined) return undefined;
+
+    if (Array.isArray(current)) {
+      const index = parseInt(part, 10);
+      if (isNaN(index)) return undefined;
+      current = current[index];
+    } else if (typeof current === 'object') {
+      current = (current as Record<string, unknown>)[part];
+    } else {
+      return undefined;
+    }
+  }
+
+  return current;
+}
+
+/**
+ * Run a set of simple assertions against a response.
+ */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export function runAssertions(
+  testCode: string,
+  response: {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: string;
+    duration: number;
+  },
+): AssertionResult[] {
+  const results: AssertionResult[] = [];
+
+  try {
+    const json = (() => {
+      try { return JSON.parse(response.body); } catch { return null; }
+    })();
+
+    const pm: any = {
+      response: {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+        body: response.body,
+        duration: response.duration,
+        json: () => json,
+      },
+      test: (name: string, fn: () => void) => {
+        const start = performance.now();
+        try {
+          fn();
+          const existing = results.find((r) => r.name === name);
+          if (!existing) {
+            results.push({
+              name,
+              passed: true,
+              duration: performance.now() - start,
+            });
+          }
+        } catch (e) {
+          results.push({
+            name,
+            passed: false,
+            error: e instanceof Error ? e.message : String(e),
+            duration: performance.now() - start,
+          });
+        }
+      },
+      expect: (val: any) => ({
+        to: {
+          equal: (expected: any) => {
+            results.push({ name: `Expect ${JSON.stringify(val)} to equal ${JSON.stringify(expected)}`, passed: val === expected, duration: 0 });
+          },
+          be: {
+            an: (type: string) => {
+              const typeMap: Record<string, (v: any) => boolean> = {
+                array: Array.isArray,
+                object: (v: any) => typeof v === 'object' && v !== null && !Array.isArray(v),
+                string: (v: any) => typeof v === 'string',
+                number: (v: any) => typeof v === 'number',
+              };
+              const check = typeMap[type];
+              results.push({ name: `Expect ${JSON.stringify(val)} to be ${type}`, passed: check ? check(val) : false, duration: 0 });
+              return { and: { greaterThan: (n: number) => { results.push({ name: `Expect ${JSON.stringify(val)} to be greater than ${n}`, passed: typeof val === 'number' && val > n, duration: 0 }); } } };
+            },
+            below: (n: number) => {
+              results.push({ name: `Expect ${JSON.stringify(val)} to be below ${n}`, passed: typeof val === 'number' && val < n, duration: 0 });
+            },
+          },
+          exist: () => {
+            results.push({ name: 'Expect value to exist', passed: val !== undefined && val !== null, duration: 0 });
+          },
+          have: {
+            status: (expected: number) => {
+              results.push({ name: `Status code is ${expected}`, passed: response.status === expected, duration: 0 });
+            },
+          },
+        },
+      }),
+    };
+
+    // Execute the test code in a sandboxed function
+    const fn = new Function('pm', 'console', testCode);
+    fn(pm, console);
+  } catch (e) {
+    results.push({
+      name: 'Test execution',
+      passed: false,
+      error: e instanceof Error ? e.message : String(e),
+      duration: 0,
+    });
+  }
+
+  return results;
+}
+/* eslint-enable @typescript-eslint/no-explicit-any */

package/src/lib/test-runner/reporter.ts

@@ -0,0 +1,90 @@
+import type { TestSuiteResult, TestRunResult } from './runner';
+
+export interface TestReport {
+  summary: {
+    total: number;
+    passed: number;
+    failed: number;
+    duration: number;
+    timestamp: string;
+  };
+  results: Array<{
+    name: string;
+    method: string;
+    url: string;
+    status: number;
+    passed: boolean;
+    assertions: Array<{
+      name: string;
+      passed: boolean;
+      error?: string;
+    }>;
+    error?: string;
+  }>;
+}
+
+/**
+ * Generate a test report from suite results.
+ */
+export function generateReport(suiteResult: TestSuiteResult): TestReport {
+  return {
+    summary: {
+      total: suiteResult.totalTests,
+      passed: suiteResult.passed,
+      failed: suiteResult.failed,
+      duration: suiteResult.duration,
+      timestamp: new Date().toISOString(),
+    },
+    results: suiteResult.results.map(formatResult),
+  };
+}
+
+function formatResult(result: TestRunResult): TestReport['results'][number] {
+  return {
+    name: result.requestName,
+    method: result.method,
+    url: result.url,
+    status: result.status,
+    passed: result.passed,
+    assertions: result.assertions.map((a) => ({
+      name: a.name,
+      passed: a.passed,
+      error: a.error,
+    })),
+    error: result.error,
+  };
+}
+
+/**
+ * Format a test report as Markdown.
+ */
+export function reportToMarkdown(report: TestReport): string {
+  const lines: string[] = [
+    '# Test Report',
+    '',
+    `**Date:** ${report.summary.timestamp}`,
+    `**Total:** ${report.summary.total} | **Passed:** ${report.summary.passed} | **Failed:** ${report.summary.failed}`,
+    `**Duration:** ${report.summary.duration}ms`,
+    '',
+  ];
+
+  for (const result of report.results) {
+    const icon = result.passed ? 'PASS' : 'FAIL';
+    lines.push(`## [${icon}] ${result.name}`);
+    lines.push(`- **Method:** ${result.method}`);
+    lines.push(`- **URL:** ${result.url}`);
+    lines.push(`- **Status:** ${result.status}`);
+    lines.push('');
+
+    for (const assertion of result.assertions) {
+      const aIcon = assertion.passed ? 'PASS' : 'FAIL';
+      lines.push(`  - [${aIcon}] ${assertion.name}`);
+      if (assertion.error) {
+        lines.push(`    - Error: ${assertion.error}`);
+      }
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}

package/src/lib/test-runner/runner.ts

@@ -0,0 +1,69 @@
+import { runAssertions, type AssertionResult } from './assertions';
+
+export interface TestRunResult {
+  requestId: string;
+  requestName: string;
+  method: string;
+  url: string;
+  status: number;
+  duration: number;
+  assertions: AssertionResult[];
+  passed: boolean;
+  error?: string;
+}
+
+export interface TestSuiteResult {
+  totalTests: number;
+  passed: number;
+  failed: number;
+  duration: number;
+  results: TestRunResult[];
+}
+
+/**
+ * Run tests for a single request/response pair.
+ */
+export function runRequestTests(
+  requestId: string,
+  requestName: string,
+  method: string,
+  url: string,
+  testCode: string,
+  response: {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: string;
+    duration: number;
+  },
+): TestRunResult {
+  const assertionResults = runAssertions(testCode, response);
+  const allPassed = assertionResults.every((r) => r.passed);
+
+  return {
+    requestId,
+    requestName,
+    method,
+    url,
+    status: response.status,
+    duration: response.duration,
+    assertions: assertionResults,
+    passed: allPassed,
+  };
+}
+
+/**
+ * Aggregate results from multiple test runs into a suite.
+ */
+export function aggregateTestResults(results: TestRunResult[]): TestSuiteResult {
+  const totalTests = results.reduce((sum, r) => sum + r.assertions.length, 0);
+  const passed = results.reduce((sum, r) => sum + r.assertions.filter((a) => a.passed).length, 0);
+
+  return {
+    totalTests,
+    passed,
+    failed: totalTests - passed,
+    duration: results.reduce((sum, r) => sum + r.duration, 0),
+    results,
+  };
+}

package/src/lib/utils/api-response.ts

@@ -0,0 +1,85 @@
+import { NextResponse } from 'next/server';
+import { ZodError } from 'zod';
+import { AppError, isAppError, toAppError } from './errors';
+
+interface ApiSuccessResponse<T> {
+  success: true;
+  data: T;
+  meta?: {
+    page?: number;
+    limit?: number;
+    total?: number;
+    [key: string]: unknown;
+  };
+}
+
+interface ApiErrorResponse {
+  success: false;
+  error: {
+    message: string;
+    code: string;
+    details?: unknown;
+  };
+}
+
+export type ApiResponse<T> = ApiSuccessResponse<T> | ApiErrorResponse;
+
+export function success<T>(data: T, meta?: ApiSuccessResponse<T>['meta']): NextResponse<ApiSuccessResponse<T>> {
+  return NextResponse.json(
+    { success: true, data, ...(meta ? { meta } : {}) },
+    { status: 200 },
+  );
+}
+
+export function created<T>(data: T): NextResponse<ApiSuccessResponse<T>> {
+  return NextResponse.json(
+    { success: true, data },
+    { status: 201 },
+  );
+}
+
+export function noContent(): NextResponse {
+  return new NextResponse(null, { status: 204 });
+}
+
+export function error(err: unknown): NextResponse<ApiErrorResponse> {
+  const appError = isAppError(err) ? err : toAppError(err);
+
+  if (err instanceof ZodError) {
+    return NextResponse.json(
+      {
+        success: false,
+        error: {
+          message: 'Validation failed',
+          code: 'VALIDATION_ERROR',
+          details: err.errors.map((e) => ({
+            path: e.path.join('.'),
+            message: e.message,
+          })),
+        },
+      },
+      { status: 400 },
+    );
+  }
+
+  return NextResponse.json(
+    {
+      success: false,
+      error: {
+        message: appError.message,
+        code: appError.code,
+        details: appError.details,
+      },
+    },
+    { status: appError.statusCode },
+  );
+}
+
+export function paginated<T>(
+  data: T[],
+  page: number,
+  limit: number,
+  total: number,
+): NextResponse<ApiSuccessResponse<T[]>> {
+  return success(data, { page, limit, total });
+}

package/src/lib/utils/cn.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}

package/src/lib/utils/content-type.ts

@@ -0,0 +1,123 @@
+export type ContentTypeCategory = 'json' | 'xml' | 'html' | 'text' | 'image' | 'binary' | 'form' | 'unknown';
+
+export interface ContentTypeInfo {
+  category: ContentTypeCategory;
+  mimeType: string;
+  charset: string | null;
+  isText: boolean;
+}
+
+const MIME_CATEGORIES: Record<string, ContentTypeCategory> = {
+  'application/json': 'json',
+  'application/ld+json': 'json',
+  'application/vnd.api+json': 'json',
+  'application/hal+json': 'json',
+  'application/problem+json': 'json',
+  'text/json': 'json',
+  'application/xml': 'xml',
+  'text/xml': 'xml',
+  'application/soap+xml': 'xml',
+  'application/xhtml+xml': 'xml',
+  'application/rss+xml': 'xml',
+  'application/atom+xml': 'xml',
+  'text/html': 'html',
+  'text/plain': 'text',
+  'text/csv': 'text',
+  'text/markdown': 'text',
+  'text/css': 'text',
+  'text/javascript': 'text',
+  'application/javascript': 'text',
+  'application/x-www-form-urlencoded': 'form',
+  'multipart/form-data': 'form',
+  'image/png': 'image',
+  'image/jpeg': 'image',
+  'image/gif': 'image',
+  'image/svg+xml': 'image',
+  'image/webp': 'image',
+  'image/bmp': 'image',
+  'image/x-icon': 'image',
+  'application/pdf': 'binary',
+  'application/zip': 'binary',
+  'application/gzip': 'binary',
+  'application/octet-stream': 'binary',
+};
+
+const TEXT_CATEGORIES: Set<ContentTypeCategory> = new Set([
+  'json', 'xml', 'html', 'text', 'form',
+]);
+
+/**
+ * Parse content type header into structured info.
+ */
+export function parseContentType(header: string | null): ContentTypeInfo {
+  if (!header) {
+    return { category: 'unknown', mimeType: 'application/octet-stream', charset: null, isText: false };
+  }
+
+  const parts = header.split(';').map((p) => p.trim());
+  const mimeType = (parts[0] ?? 'application/octet-stream').toLowerCase();
+
+  let charset: string | null = null;
+  for (let i = 1; i < parts.length; i++) {
+    const part = parts[i];
+    if (part?.startsWith('charset=')) {
+      charset = part.slice('charset='.length).replace(/"/g, '');
+    }
+  }
+
+  const category = MIME_CATEGORIES[mimeType] ?? 'binary';
+  const isText = TEXT_CATEGORIES.has(category) || mimeType.startsWith('text/');
+
+  return { category, mimeType, charset, isText };
+}
+
+/**
+ * Detect content type from response body content.
+ */
+export function detectContentFromBody(body: string): ContentTypeCategory {
+  const trimmed = body.trim();
+
+  if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+    try {
+      JSON.parse(trimmed);
+      return 'json';
+    } catch {
+      // Not valid JSON
+    }
+  }
+
+  if (trimmed.startsWith('<?xml') || trimmed.startsWith('<xml') || trimmed.startsWith('<rss')) {
+    return 'xml';
+  }
+
+  if (trimmed.startsWith('<!DOCTYPE') || trimmed.startsWith('<html') || trimmed.startsWith('<HTML')) {
+    return 'html';
+  }
+
+  return 'text';
+}
+
+/**
+ * Get file extension for a content type.
+ */
+export function getExtensionForMimeType(mimeType: string): string {
+  const map: Record<string, string> = {
+    'application/json': 'json',
+    'application/xml': 'xml',
+    'text/xml': 'xml',
+    'text/html': 'html',
+    'text/plain': 'txt',
+    'text/csv': 'csv',
+    'text/css': 'css',
+    'application/javascript': 'js',
+    'application/pdf': 'pdf',
+    'image/png': 'png',
+    'image/jpeg': 'jpg',
+    'image/gif': 'gif',
+    'image/svg+xml': 'svg',
+    'image/webp': 'webp',
+    'application/zip': 'zip',
+    'application/gzip': 'gz',
+  };
+  return map[mimeType] ?? 'bin';
+}

package/src/lib/utils/download.ts

@@ -0,0 +1,53 @@
+/**
+ * Create a download trigger for files from the browser.
+ */
+export function downloadFile(filename: string, content: string, mimeType: string = 'text/plain'): void {
+  const blob = new Blob([content], { type: mimeType });
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement('a');
+  link.href = url;
+  link.download = filename;
+  document.body.appendChild(link);
+  link.click();
+  document.body.removeChild(link);
+  URL.revokeObjectURL(url);
+}
+
+/**
+ * Download binary data as a file.
+ */
+export function downloadBinary(filename: string, data: Uint8Array, mimeType: string = 'application/octet-stream'): void {
+  const blob = new Blob([data as BlobPart], { type: mimeType });
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement('a');
+  link.href = url;
+  link.download = filename;
+  document.body.appendChild(link);
+  link.click();
+  document.body.removeChild(link);
+  URL.revokeObjectURL(url);
+}
+
+/**
+ * Read a file as text.
+ */
+export function readFileAsText(file: File): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(reader.result as string);
+    reader.onerror = () => reject(new Error(`Failed to read file: ${file.name}`));
+    reader.readAsText(file);
+  });
+}
+
+/**
+ * Read a file as a data URL (for binary files).
+ */
+export function readFileAsDataUrl(file: File): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(reader.result as string);
+    reader.onerror = () => reject(new Error(`Failed to read file: ${file.name}`));
+    reader.readAsDataURL(file);
+  });
+}

package/src/lib/utils/errors.ts

@@ -0,0 +1,92 @@
+export class AppError extends Error {
+  constructor(
+    message: string,
+    public readonly statusCode: number = 500,
+    public readonly code: string = 'INTERNAL_ERROR',
+    public readonly details?: unknown,
+  ) {
+    super(message);
+    this.name = 'AppError';
+    Object.setPrototypeOf(this, AppError.prototype);
+  }
+}
+
+export class ValidationError extends AppError {
+  constructor(message: string, details?: unknown) {
+    super(message, 400, 'VALIDATION_ERROR', details);
+    this.name = 'ValidationError';
+    Object.setPrototypeOf(this, ValidationError.prototype);
+  }
+}
+
+export class NotFoundError extends AppError {
+  constructor(resource: string, id?: string) {
+    super(
+      id ? `${resource} with id '${id}' not found` : `${resource} not found`,
+      404,
+      'NOT_FOUND',
+    );
+    this.name = 'NotFoundError';
+    Object.setPrototypeOf(this, NotFoundError.prototype);
+  }
+}
+
+export class UnauthorizedError extends AppError {
+  constructor(message: string = 'Unauthorized') {
+    super(message, 401, 'UNAUTHORIZED');
+    this.name = 'UnauthorizedError';
+    Object.setPrototypeOf(this, UnauthorizedError.prototype);
+  }
+}
+
+export class ForbiddenError extends AppError {
+  constructor(message: string = 'Forbidden') {
+    super(message, 403, 'FORBIDDEN');
+    this.name = 'ForbiddenError';
+    Object.setPrototypeOf(this, ForbiddenError.prototype);
+  }
+}
+
+export class TimeoutError extends AppError {
+  constructor(timeout: number) {
+    super(`Request timed out after ${timeout}ms`, 408, 'TIMEOUT');
+    this.name = 'TimeoutError';
+    Object.setPrototypeOf(this, TimeoutError.prototype);
+  }
+}
+
+export class NetworkError extends AppError {
+  constructor(message: string) {
+    super(message, 502, 'NETWORK_ERROR');
+    this.name = 'NetworkError';
+    Object.setPrototypeOf(this, NetworkError.prototype);
+  }
+}
+
+export class SSLError extends AppError {
+  constructor(message: string) {
+    super(message, 502, 'SSL_ERROR');
+    this.name = 'SSLError';
+    Object.setPrototypeOf(this, SSLError.prototype);
+  }
+}
+
+export class RateLimitError extends AppError {
+  constructor(message: string = 'Rate limit exceeded') {
+    super(message, 429, 'RATE_LIMIT');
+    this.name = 'RateLimitError';
+    Object.setPrototypeOf(this, RateLimitError.prototype);
+  }
+}
+
+export function isAppError(error: unknown): error is AppError {
+  return error instanceof AppError;
+}
+
+export function toAppError(error: unknown): AppError {
+  if (isAppError(error)) return error;
+  if (error instanceof Error) {
+    return new AppError(error.message, 500, 'INTERNAL_ERROR');
+  }
+  return new AppError('An unknown error occurred', 500, 'UNKNOWN_ERROR');
+}