Merge pull request #107 from t3rr11/feature/adding-basic-graphql-support

Added basic GraphQL support

Author: t3rr11

apps/backend/package.json

@@ -17,6 +17,7 @@
     "axios": "^1.18.1",
     "fastify": "^5.10.0",
     "form-data": "^4.0.6",
+    "graphql": "^16.14.2",
     "node-fetch": "^3.3.2",
     "simple-git": "^3.36.0",
     "zod": "^4.4.3"

apps/backend/src/controllers/collection.controller.ts

@@ -1,8 +1,9 @@
 import { FastifyPluginAsync } from 'fastify';
 import { CollectionService } from '../services/collection.service';
 import { OpenApiService } from '../services/openapi.service';
-import type { AuthConfig, BodyType, FormDataEntry } from '../models/proxy';
+import type { SavedRequest } from '../models/collection';
 import type { SyncApplyBody } from '../models/openapi-sync';
+import { createRequestPayloadSchema, updateRequestPayloadSchema } from '../dtos/collection.dto';
 
 interface Options {
   collectionService: CollectionService;
@@ -35,48 +36,43 @@ const collectionController: FastifyPluginAsync<Options> = async (server, opts) =
     async (request, _reply) => {
       const collection = await collectionService.update(request.params.id, request.body);
       return collection;
-    },
+    }
   );
 
   server.delete<{ Params: { id: string } }>('/collections/:id', async (request, _reply) => {
     await collectionService.delete(request.params.id);
     return { success: true };
   });
 
-  server.post<{ Params: { id: string } }>(
-    '/collections/:id/duplicate',
-    async (request, reply) => {
-      const collection = await collectionService.duplicateCollection(request.params.id);
-      return reply.code(201).send(collection);
-    },
-  );
+  server.post<{ Params: { id: string } }>('/collections/:id/duplicate', async (request, reply) => {
+    const collection = await collectionService.duplicateCollection(request.params.id);
+    return reply.code(201).send(collection);
+  });
 
   server.put<{ Params: { id: string }; Body: { targetOrder: number } }>(
     '/collections/:id/move',
     async (request, _reply) => {
       const { targetOrder } = request.body;
       const collection = await collectionService.moveCollection(request.params.id, targetOrder);
       return collection;
-    },
+    }
   );
 
   server.post<{
     Params: { id: string };
-    Body: { name: string; method: string; url: string; headers?: Record<string, string>; body?: string; bodyType?: BodyType; formDataEntries?: FormDataEntry[]; auth?: AuthConfig; folderId?: string };
+    Body: SavedRequest;
   }>('/collections/:id/requests', async (request, reply) => {
-    const { name, method, url, headers, body, bodyType, formDataEntries, auth, folderId } = request.body;
-    if (!name || !method || !url) {
-      return reply.code(400).send({ error: 'Name, method, and URL are required' });
-    }
-    const saved = await collectionService.addRequest(request.params.id, { name, method, url, headers, body, bodyType, formDataEntries, auth, folderId });
+    const data = createRequestPayloadSchema.parse(request.body);
+    const saved = await collectionService.addRequest(request.params.id, data);
     return reply.code(201).send(saved);
   });
 
   server.put<{
     Params: { id: string; requestId: string };
-    Body: { name?: string; method?: string; url?: string; headers?: Record<string, string>; body?: string; auth?: AuthConfig; folderId?: string };
+    Body: Partial<SavedRequest>;
   }>('/collections/:id/requests/:requestId', async (request, _reply) => {
-    const saved = await collectionService.updateRequest(request.params.id, request.params.requestId, request.body);
+    const updates = updateRequestPayloadSchema.parse(request.body);
+    const saved = await collectionService.updateRequest(request.params.id, request.params.requestId, updates);
     return saved;
   });
 
@@ -85,15 +81,15 @@ const collectionController: FastifyPluginAsync<Options> = async (server, opts) =
     async (request, _reply) => {
       await collectionService.deleteRequest(request.params.id, request.params.requestId);
       return { success: true };
-    },
+    }
   );
 
   server.post<{ Params: { id: string; requestId: string } }>(
     '/collections/:id/requests/:requestId/duplicate',
     async (request, reply) => {
       const saved = await collectionService.duplicateRequest(request.params.id, request.params.requestId);
       return reply.code(201).send(saved);
-    },
+    }
   );
 
   server.post<{ Params: { id: string }; Body: { name: string; parentId?: string } }>(
@@ -105,23 +101,23 @@ const collectionController: FastifyPluginAsync<Options> = async (server, opts) =
       }
       const saved = await collectionService.addFolder(request.params.id, { name, parentId });
       return reply.code(201).send(saved);
-    },
+    }
   );
 
   server.put<{ Params: { id: string; folderId: string }; Body: { name?: string; parentId?: string } }>(
     '/collections/:id/folders/:folderId',
     async (request, _reply) => {
       const saved = await collectionService.updateFolder(request.params.id, request.params.folderId, request.body);
       return saved;
-    },
+    }
   );
 
   server.delete<{ Params: { id: string; folderId: string } }>(
     '/collections/:id/folders/:folderId',
     async (request, _reply) => {
       await collectionService.deleteFolder(request.params.id, request.params.folderId);
       return { success: true };
-    },
+    }
   );
 
   server.put<{
@@ -162,7 +158,7 @@ const collectionController: FastifyPluginAsync<Options> = async (server, opts) =
       }
       const result = await openApiService.importSpec(source, { name, linkSpec });
       return reply.code(201).send(result);
-    },
+    }
   );
 
   server.get<{ Params: { id: string } }>('/collections/:id/export', async (request, _reply) => {
@@ -178,7 +174,7 @@ const collectionController: FastifyPluginAsync<Options> = async (server, opts) =
     '/collections/:id/sync-openapi/apply',
     async (request, _reply) => {
       return openApiService.applySync(request.params.id, request.body);
-    },
+    }
   );
 
   server.delete<{ Params: { id: string } }>('/collections/:id/openapi-link', async (request, _reply) => {

apps/backend/src/controllers/graphql-schema-profile.controller.ts

@@ -0,0 +1,56 @@
+import type { FastifyPluginAsync } from 'fastify';
+import type { CreateGraphQLSchemaProfile } from '../models/graphql-schema-profile';
+import { GraphQLSchemaProfileService } from '../services/graphql-schema-profile.service';
+import { graphqlSchemaCacheInputSchema, graphqlSchemaProfileInputSchema } from '../dtos/graphql-schema-profile.dto';
+
+interface Options {
+  graphqlSchemaProfileService: GraphQLSchemaProfileService;
+}
+
+const graphqlSchemaProfileController: FastifyPluginAsync<Options> = async (server, options) => {
+  const { graphqlSchemaProfileService } = options;
+
+  server.get('/graphql/schema-profiles', async () => graphqlSchemaProfileService.getAll());
+
+  server.get<{ Params: { id: string } }>('/graphql/schema-profiles/:id', async request =>
+    graphqlSchemaProfileService.getById(request.params.id),
+  );
+
+  server.post<{ Body: CreateGraphQLSchemaProfile }>('/graphql/schema-profiles', async (request, reply) => {
+    const profile = graphqlSchemaProfileService.create(graphqlSchemaProfileInputSchema.parse(request.body));
+    return reply.code(201).send(profile);
+  });
+
+  server.put<{ Params: { id: string }; Body: CreateGraphQLSchemaProfile }>(
+    '/graphql/schema-profiles/:id',
+    async request => graphqlSchemaProfileService.update(
+      request.params.id,
+      graphqlSchemaProfileInputSchema.parse(request.body),
+    ),
+  );
+
+  server.delete<{ Params: { id: string } }>('/graphql/schema-profiles/:id', async request => {
+    graphqlSchemaProfileService.delete(request.params.id);
+    return { success: true };
+  });
+
+  server.get<{ Params: { id: string } }>('/graphql/schema-profiles/:id/cache', async request => ({
+    cache: graphqlSchemaProfileService.getCache(request.params.id),
+  }));
+
+  server.put<{
+    Params: { id: string };
+    Body: { sourceUrl: string; introspection: unknown };
+  }>('/graphql/schema-profiles/:id/cache', async request => {
+    const input = graphqlSchemaCacheInputSchema.parse(request.body);
+    return {
+      cache: graphqlSchemaProfileService.saveCache(
+        request.params.id,
+        input.sourceUrl,
+        input.introspection,
+      ),
+    };
+  });
+};
+
+export default graphqlSchemaProfileController;

apps/backend/src/controllers/graphql-test.controller.ts

@@ -0,0 +1,79 @@
+import type { FastifyPluginAsync } from 'fastify';
+import { buildSchema, graphql } from 'graphql';
+
+const schema = buildSchema(`
+  type User {
+    id: ID!
+    name: String!
+    email: String!
+    role: Role!
+  }
+
+  enum Role {
+    ADMIN
+    MEMBER
+  }
+
+  type Query {
+    users: [User!]!
+    user(id: ID!): User
+    fieldError: String
+  }
+
+  type Mutation {
+    updateUserName(id: ID!, name: String!): User
+  }
+`);
+
+const users = [
+  { id: '1', name: 'Ada Lovelace', email: 'ada@example.com', role: 'ADMIN' },
+  { id: '2', name: 'Grace Hopper', email: 'grace@example.com', role: 'MEMBER' },
+];
+
+const rootValue = {
+  users: () => users,
+  user: ({ id }: { id: string }) => users.find(user => user.id === id) ?? null,
+  updateUserName: ({ id, name }: { id: string; name: string }) => {
+    const user = users.find(item => item.id === id);
+    return user ? { ...user, name } : null;
+  },
+  fieldError: () => {
+    throw new Error('This field intentionally failed');
+  },
+};
+
+export const graphqlTestRoutes: FastifyPluginAsync = async server => {
+  server.post<{
+    Body: { query?: string; variables?: Record<string, unknown>; operationName?: string };
+  }>('/test/graphql', async (request, reply) => {
+    if (!request.body.query) return reply.code(400).send({ error: 'GraphQL query is required' });
+    return graphql({
+      schema,
+      source: request.body.query,
+      rootValue,
+      variableValues: request.body.variables,
+      operationName: request.body.operationName,
+    });
+  });
+
+  server.get<{
+    Querystring: { query?: string; variables?: string; operationName?: string };
+  }>('/test/graphql', async (request, reply) => {
+    if (!request.query.query) return reply.code(400).send({ error: 'GraphQL query is required' });
+    let variables: Record<string, unknown> | undefined;
+    if (request.query.variables) {
+      try {
+        variables = JSON.parse(request.query.variables) as Record<string, unknown>;
+      } catch {
+        return reply.code(400).send({ error: 'GraphQL variables must be valid JSON' });
+      }
+    }
+    return graphql({
+      schema,
+      source: request.query.query,
+      rootValue,
+      variableValues: variables,
+      operationName: request.query.operationName,
+    });
+  });
+};

apps/backend/src/dtos/collection.dto.ts

@@ -19,9 +19,10 @@ export const updateCollectionSchema = z.object({
     .optional(),
 });
 
-export const addRequestSchema = z.object({
+const requestFieldsSchema = z.object({
   id: z.string(),
   name: z.string().min(1, 'Request name is required').trim(),
+  requestType: z.enum(['http', 'graphql']).optional(),
   method: z.string().min(1, 'HTTP method is required'),
   url: z.string(),
   headers: z.record(z.string(), z.string()).optional(),
@@ -33,11 +34,53 @@ export const addRequestSchema = z.object({
   folderId: z.string().optional(),
   order: z.number().optional(),
   operationId: z.string().optional(),
+  preRequestScript: z.string().optional(),
+  testScript: z.string().optional(),
+  graphql: z
+    .object({
+      document: z.string(),
+      variables: z.string(),
+      operationName: z.string().optional(),
+      transport: z.enum(['post', 'get']),
+      schemaProfileId: z.string().optional(),
+    })
+    .optional(),
 });
 
-export const updateRequestSchema = addRequestSchema
+function validateRequestShape(
+  value: Pick<
+    Partial<z.infer<typeof requestFieldsSchema>>,
+    'requestType' | 'graphql' | 'body' | 'formDataEntries'
+  >,
+  context: z.RefinementCtx,
+): void {
+  if (value.requestType === 'graphql') {
+    if (!value.graphql) {
+      context.addIssue({ code: 'custom', path: ['graphql'], message: 'GraphQL request configuration is required' });
+    }
+    if (value.body !== undefined || value.formDataEntries !== undefined) {
+      context.addIssue({ code: 'custom', path: ['body'], message: 'HTTP body fields are not valid for GraphQL requests' });
+    }
+  } else if (value.requestType === 'http' && value.graphql !== undefined) {
+    context.addIssue({ code: 'custom', path: ['graphql'], message: 'GraphQL configuration is not valid for HTTP requests' });
+  }
+}
+
+export const addRequestSchema = requestFieldsSchema.superRefine(validateRequestShape);
+
+export const createRequestPayloadSchema = requestFieldsSchema
+  .omit({ id: true, collectionId: true })
+  .superRefine(validateRequestShape);
+
+export const updateRequestSchema = requestFieldsSchema
   .omit({ id: true })
-  .partial();
+  .partial()
+  .superRefine(validateRequestShape);
+
+export const updateRequestPayloadSchema = requestFieldsSchema
+  .omit({ id: true, collectionId: true })
+  .partial()
+  .superRefine(validateRequestShape);
 
 export const moveRequestSchema = z.object({
   targetCollectionId: z.string(),

apps/backend/src/dtos/graphql-schema-profile.dto.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+
+export const graphqlSchemaProfileInputSchema = z.object({
+  name: z.string().trim().min(1, 'Schema profile name is required'),
+  sourceType: z.enum(['endpoint', 'sdl', 'introspection-json']),
+  sourceUrl: z.string().optional(),
+  content: z.string().optional(),
+});
+
+export const graphqlSchemaCacheInputSchema = z.object({
+  sourceUrl: z.string().min(1, 'Schema source URL is required'),
+  introspection: z.unknown(),
+});

apps/backend/src/models/collection.ts

@@ -26,9 +26,20 @@ export interface Collection {
 /** Stable id of the system-managed catch-all collection. */
 export const UNCATEGORIZED_COLLECTION_ID = 'uncategorized';
 
+export type RequestType = 'http' | 'graphql';
+
+export interface GraphQLRequestConfig {
+  document: string;
+  variables: string;
+  operationName?: string;
+  transport: 'post' | 'get';
+  schemaProfileId?: string;
+}
+
 export interface SavedRequest {
   id: string;
   name: string;
+  requestType?: RequestType;
   method: string;
   url: string;
   headers?: Record<string, string>;
@@ -42,6 +53,7 @@ export interface SavedRequest {
   operationId?: string;
   preRequestScript?: string;
   testScript?: string;
+  graphql?: GraphQLRequestConfig;
 }
 
 export interface OpenApiEnvironmentVariable {