@theihtisham/devtools-with-cloud 1.0.0

package/src/app/api/import/curl/route.ts

@@ -0,0 +1,18 @@
+import { NextRequest } from 'next/server';
+import { success, error } from '@/lib/utils/api-response';
+import { ImportCurlSchema } from '@/lib/utils/validation';
+import { parseCurl } from '@/lib/importers/curl-parser';
+
+export async function POST(req: NextRequest): Promise<Response> {
+  try {
+    const body = await req.json();
+    const parsed = ImportCurlSchema.parse(body);
+
+    const request = parseCurl(parsed.command);
+    request.name = parsed.name ?? `${request.method} ${request.url}`;
+
+    return success({ request }) as Response;
+  } catch (err) {
+    return error(err) as Response;
+  }
+}

package/src/app/api/import/har/route.ts

@@ -0,0 +1,20 @@
+import { NextRequest } from 'next/server';
+import { success, error } from '@/lib/utils/api-response';
+import { ImportHarSchema } from '@/lib/utils/validation';
+import { importHar } from '@/lib/importers/har-parser';
+
+export async function POST(req: NextRequest): Promise<Response> {
+  try {
+    const body = await req.json();
+    const parsed = ImportHarSchema.parse(body);
+
+    const result = importHar(parsed.har);
+
+    return success({
+      entries: result.entries,
+      entryCount: result.entries.length,
+    }) as Response;
+  } catch (err) {
+    return error(err) as Response;
+  }
+}

package/src/app/api/import/openapi/route.ts

@@ -0,0 +1,21 @@
+import { NextRequest } from 'next/server';
+import { success, error } from '@/lib/utils/api-response';
+import { ImportOpenApiSchema } from '@/lib/utils/validation';
+import { importOpenApi } from '@/lib/importers/openapi';
+
+export async function POST(req: NextRequest): Promise<Response> {
+  try {
+    const body = await req.json();
+    const parsed = ImportOpenApiSchema.parse(body);
+
+    const collection = importOpenApi(parsed.spec);
+    collection.name = parsed.collectionName ?? collection.name;
+
+    return success({
+      collection,
+      endpointCount: collection.endpoints.length,
+    }) as Response;
+  } catch (err) {
+    return error(err) as Response;
+  }
+}

package/src/app/api/import/postman/route.ts

@@ -0,0 +1,21 @@
+import { NextRequest } from 'next/server';
+import { success, error } from '@/lib/utils/api-response';
+import { ImportPostmanSchema } from '@/lib/utils/validation';
+import { importPostman } from '@/lib/importers/postman';
+
+export async function POST(req: NextRequest): Promise<Response> {
+  try {
+    const body = await req.json();
+    const parsed = ImportPostmanSchema.parse(body);
+
+    const collection = importPostman(parsed.collection);
+
+    return success({
+      collection,
+      folderCount: collection.folders.length,
+      requestCount: collection.requests.length + collection.folders.reduce((sum, f) => sum + f.requests.length, 0),
+    }) as Response;
+  } catch (err) {
+    return error(err) as Response;
+  }
+}

package/src/app/api/proxy/route.ts

@@ -0,0 +1,35 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { proxyRequest, handleCorsPreflight } from '@/lib/http/proxy';
+import { success, error } from '@/lib/utils/api-response';
+
+export async function OPTIONS(): Promise<NextResponse> {
+  return handleCorsPreflight();
+}
+
+export async function POST(req: NextRequest): Promise<NextResponse> {
+  try {
+    const body = await req.json() as {
+      url: string;
+      method: string;
+      headers?: Record<string, string>;
+      body?: string;
+    };
+
+    if (!body.url) {
+      return NextResponse.json(
+        { success: false, error: { message: 'URL is required', code: 'VALIDATION_ERROR' } },
+        { status: 400 },
+      );
+    }
+
+    return await proxyRequest(
+      req,
+      body.url,
+      body.method ?? 'GET',
+      body.headers ?? {},
+      body.body ?? null,
+    );
+  } catch (err) {
+    return error(err);
+  }
+}

package/src/app/api/requests/[id]/execute/route.ts

@@ -0,0 +1,85 @@
+import { NextRequest } from 'next/server';
+import { prisma } from '@/lib/db/client';
+import { success, error } from '@/lib/utils/api-response';
+import { NotFoundError } from '@/lib/utils/errors';
+import { executeRequest } from '@/lib/http/client';
+import { buildRequest } from '@/lib/http/request-builder';
+import type { AuthConfig } from '@/lib/utils/validation';
+
+interface RouteContext {
+  params: { id: string };
+}
+
+export async function POST(req: NextRequest, context: RouteContext): Promise<Response> {
+  try {
+    const { id } = context.params;
+
+    const request = await prisma.request.findUnique({
+      where: { id },
+    });
+
+    if (!request) {
+      throw new NotFoundError('Request', id);
+    }
+
+    // Get environment variables (use default environment)
+    const collection = await prisma.collection.findUnique({ where: { id: request.collectionId } });
+    const workspaceId = collection?.workspaceId;
+    const env = await prisma.environment.findFirst({
+      where: workspaceId ? { workspaceId, isDefault: true } : { isDefault: true },
+    });
+
+    const variables: Record<string, string> = {};
+    if (env && Array.isArray(env.variables)) {
+      for (const v of (env.variables as Array<{ key: string; value: string; enabled?: boolean }>)) {
+        if (v.enabled !== false) {
+          variables[v.key] = v.value;
+        }
+      }
+    }
+
+    // Build the request
+    const built = buildRequest(
+      request.method as 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'TRACE' | 'CONNECT',
+      request.url,
+      request.headers as Array<{ key: string; value: string; enabled: boolean }>,
+      request.params as Array<{ key: string; value: string; enabled: boolean }>,
+      request.body as { raw?: string; form?: Array<{ key: string; value: string; enabled: boolean }>; graphql?: { query: string; variables?: string } } | null,
+      request.bodyType,
+      request.auth as AuthConfig | null,
+      variables,
+    );
+
+    // Execute
+    const response = await executeRequest({
+      method: built.method,
+      url: built.url,
+      headers: built.headers,
+      body: built.body,
+      timeout: 30000,
+      followRedirects: true,
+      maxRedirects: 5,
+      verifySSL: true,
+    });
+
+    // Save to history
+    await prisma.history.create({
+      data: {
+        requestId: id,
+        method: request.method,
+        url: built.url,
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+        body: response.body,
+        bodySize: response.bodySize,
+        timing: response.timing,
+        duration: response.timing.total,
+      },
+    });
+
+    return success(response) as Response;
+  } catch (err) {
+    return error(err) as Response;
+  }
+}

package/src/app/api/requests/[id]/history/route.ts

@@ -0,0 +1,23 @@
+import { NextRequest } from 'next/server';
+import { prisma } from '@/lib/db/client';
+import { success, error } from '@/lib/utils/api-response';
+
+interface RouteContext {
+  params: { id: string };
+}
+
+export async function GET(_req: NextRequest, context: RouteContext): Promise<Response> {
+  try {
+    const { id } = context.params;
+
+    const history = await prisma.history.findMany({
+      where: { requestId: id },
+      orderBy: { createdAt: 'desc' },
+      take: 50,
+    });
+
+    return success(history) as Response;
+  } catch (err) {
+    return error(err) as Response;
+  }
+}

package/src/app/api/requests/[id]/route.ts

@@ -0,0 +1,66 @@
+import { NextRequest } from 'next/server';
+import { prisma } from '@/lib/db/client';
+import { success, noContent, error } from '@/lib/utils/api-response';
+import { NotFoundError } from '@/lib/utils/errors';
+import { UpdateRequestSchema } from '@/lib/utils/validation';
+
+interface RouteContext {
+  params: { id: string };
+}
+
+export async function GET(_req: NextRequest, context: RouteContext): Promise<Response> {
+  try {
+    const { id } = context.params;
+    const request = await prisma.request.findUnique({
+      where: { id },
+    });
+
+    if (!request) {
+      throw new NotFoundError('Request', id);
+    }
+
+    return success(request) as Response;
+  } catch (err) {
+    return error(err) as Response;
+  }
+}
+
+export async function PUT(req: NextRequest, context: RouteContext): Promise<Response> {
+  try {
+    const { id } = context.params;
+    const body = await req.json();
+    const parsed = UpdateRequestSchema.parse({ ...body, id });
+
+    const request = await prisma.request.update({
+      where: { id },
+      data: {
+        name: parsed.name,
+        description: parsed.description,
+        method: parsed.method,
+        url: parsed.url,
+        headers: parsed.headers,
+        params: parsed.params,
+        body: parsed.body,
+        bodyType: parsed.bodyType,
+        auth: parsed.auth,
+        preRequestScript: parsed.preRequestScript,
+        tests: parsed.tests,
+        sortOrder: parsed.sortOrder,
+      },
+    });
+
+    return success(request) as Response;
+  } catch (err) {
+    return error(err) as Response;
+  }
+}
+
+export async function DELETE(_req: NextRequest, context: RouteContext): Promise<Response> {
+  try {
+    const { id } = context.params;
+    await prisma.request.delete({ where: { id } });
+    return noContent() as Response;
+  } catch (err) {
+    return error(err) as Response;
+  }
+}

package/src/app/api/requests/route.ts

@@ -0,0 +1,49 @@
+import { NextRequest } from 'next/server';
+import { prisma } from '@/lib/db/client';
+import { success, created, error } from '@/lib/utils/api-response';
+import { CreateRequestSchema } from '@/lib/utils/validation';
+
+export async function GET(req: NextRequest): Promise<Response> {
+  try {
+    const { searchParams } = new URL(req.url);
+    const collectionId = searchParams.get('collectionId');
+
+    const requests = await prisma.request.findMany({
+      where: collectionId ? { collectionId } : undefined,
+      orderBy: { sortOrder: 'asc' },
+    });
+
+    return success(requests) as Response;
+  } catch (err) {
+    return error(err) as Response;
+  }
+}
+
+export async function POST(req: NextRequest): Promise<Response> {
+  try {
+    const body = await req.json();
+    const parsed = CreateRequestSchema.parse(body);
+
+    const request = await prisma.request.create({
+      data: {
+        name: parsed.name,
+        description: parsed.description,
+        collectionId: parsed.collectionId,
+        method: parsed.method,
+        url: parsed.url,
+        headers: parsed.headers,
+        params: parsed.params,
+        body: parsed.body,
+        bodyType: parsed.bodyType,
+        auth: parsed.auth,
+        preRequestScript: parsed.preRequestScript,
+        tests: parsed.tests,
+        sortOrder: parsed.sortOrder,
+      },
+    });
+
+    return created(request) as Response;
+  } catch (err) {
+    return error(err) as Response;
+  }
+}

package/src/app/api/workspaces/route.ts

@@ -0,0 +1,38 @@
+import { NextRequest } from 'next/server';
+import { prisma } from '@/lib/db/client';
+import { success, created, error } from '@/lib/utils/api-response';
+import { CreateWorkspaceSchema } from '@/lib/utils/validation';
+
+export async function GET(): Promise<Response> {
+  try {
+    const workspaces = await prisma.workspace.findMany({
+      include: {
+        collections: { orderBy: { sortOrder: 'asc' } },
+        environments: { orderBy: { createdAt: 'asc' } },
+      },
+      orderBy: { updatedAt: 'desc' },
+    });
+    return success(workspaces) as Response;
+  } catch (err) {
+    return error(err) as Response;
+  }
+}
+
+export async function POST(req: NextRequest): Promise<Response> {
+  try {
+    const body = await req.json();
+    const parsed = CreateWorkspaceSchema.parse(body);
+
+    const workspace = await prisma.workspace.create({
+      data: {
+        name: parsed.name,
+        description: parsed.description,
+        userId: parsed.userId,
+      },
+    });
+
+    return created(workspace) as Response;
+  } catch (err) {
+    return error(err) as Response;
+  }
+}

package/src/app/globals.css

@@ -0,0 +1,99 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+@layer base {
+  :root {
+    --background: 0 0% 100%;
+    --foreground: 222.2 84% 4.9%;
+    --card: 0 0% 100%;
+    --card-foreground: 222.2 84% 4.9%;
+    --popover: 0 0% 100%;
+    --popover-foreground: 222.2 84% 4.9%;
+    --primary: 221.2 83.2% 53.3%;
+    --primary-foreground: 210 40% 98%;
+    --secondary: 210 40% 96.1%;
+    --secondary-foreground: 222.2 47.4% 11.2%;
+    --muted: 210 40% 96.1%;
+    --muted-foreground: 215.4 16.3% 46.9%;
+    --accent: 210 40% 96.1%;
+    --accent-foreground: 222.2 47.4% 11.2%;
+    --destructive: 0 84.2% 60.2%;
+    --destructive-foreground: 210 40% 98%;
+    --border: 214.3 31.8% 91.4%;
+    --input: 214.3 31.8% 91.4%;
+    --ring: 221.2 83.2% 53.3%;
+    --radius: 0.5rem;
+  }
+
+  .dark {
+    --background: 222.2 84% 4.9%;
+    --foreground: 210 40% 98%;
+    --card: 222.2 84% 4.9%;
+    --card-foreground: 210 40% 98%;
+    --popover: 222.2 84% 4.9%;
+    --popover-foreground: 210 40% 98%;
+    --primary: 217.2 91.2% 59.8%;
+    --primary-foreground: 222.2 47.4% 11.2%;
+    --secondary: 217.2 32.6% 17.5%;
+    --secondary-foreground: 210 40% 98%;
+    --muted: 217.2 32.6% 17.5%;
+    --muted-foreground: 215 20.2% 65.1%;
+    --accent: 217.2 32.6% 17.5%;
+    --accent-foreground: 210 40% 98%;
+    --destructive: 0 62.8% 30.6%;
+    --destructive-foreground: 210 40% 98%;
+    --border: 217.2 32.6% 17.5%;
+    --input: 217.2 32.6% 17.5%;
+    --ring: 224.3 76.3% 48%;
+  }
+}
+
+@layer base {
+  * {
+    @apply border-border;
+  }
+  body {
+    @apply bg-background text-foreground;
+  }
+}
+
+/* Monaco editor overrides */
+.monaco-editor .margin,
+.monaco-editor,
+.monaco-editor-background,
+.monaco-editor .inputarea.ime-input {
+  background-color: transparent !important;
+}
+
+/* Custom scrollbar */
+::-webkit-scrollbar {
+  width: 8px;
+  height: 8px;
+}
+
+::-webkit-scrollbar-track {
+  @apply bg-transparent;
+}
+
+::-webkit-scrollbar-thumb {
+  @apply bg-border rounded-full;
+}
+
+::-webkit-scrollbar-thumb:hover {
+  @apply bg-muted-foreground/50;
+}
+
+/* Split pane resize handle */
+.resize-handle {
+  @apply relative;
+}
+
+.resize-handle::after {
+  content: '';
+  @apply absolute inset-0 transition-colors;
+}
+
+.resize-handle:hover::after {
+  @apply bg-primary/20;
+}

package/src/app/layout.tsx

@@ -0,0 +1,24 @@
+import type { Metadata } from 'next';
+import { Inter } from 'next/font/google';
+import './globals.css';
+
+const inter = Inter({ subsets: ['latin'] });
+
+export const metadata: Metadata = {
+  title: 'APITester - Open-Source API Testing Tool',
+  description: 'A beautiful, open-source API testing tool with AI-powered features. The Postman alternative built for modern developers.',
+};
+
+export default function RootLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return (
+    <html lang="en" className="dark">
+      <body className={inter.className}>
+        {children}
+      </body>
+    </html>
+  );
+}