@theihtisham/devtools-with-cloud 1.0.0

package/tests/lib/graphql/builder.test.ts

@@ -0,0 +1,349 @@
+// @ts-nocheck
+import { describe, it, expect } from 'vitest';
+import { QueryBuilder } from '@/lib/graphql/builder';
+import { validateQuery, validateQueryString, validateAgainstSchema } from '@/lib/graphql/validator';
+import type { GraphQLSchema } from '@/lib/graphql/types';
+
+describe('QueryBuilder', () => {
+  describe('basic queries', () => {
+    it('should build a simple query with no name', () => {
+      const result = new QueryBuilder()
+        .query()
+        .field('users')
+        .build();
+
+      expect(result).toContain('query');
+      expect(result).toContain('users');
+    });
+
+    it('should build a named query', () => {
+      const result = new QueryBuilder()
+        .query('GetUsers')
+        .field('users')
+        .build();
+
+      expect(result).toBe('query GetUsers { users }');
+    });
+
+    it('should build a query with multiple fields', () => {
+      const result = new QueryBuilder()
+        .query('getUser')
+        .field('id')
+        .field('name')
+        .field('email')
+        .build();
+
+      expect(result).toBe('query getUser { id name email }');
+    });
+
+    it('should build a mutation', () => {
+      const result = new QueryBuilder()
+        .mutation('createUser')
+        .field('createUser', { input: '{ name: "John" }' }, ['id', 'name'])
+        .build();
+
+      expect(result).toContain('mutation createUser');
+      expect(result).toContain('createUser(input: { name: "John" })');
+      expect(result).toContain('id');
+      expect(result).toContain('name');
+    });
+
+    it('should build a subscription', () => {
+      const result = new QueryBuilder()
+        .subscription('onMessage')
+        .field('messageAdded', {}, ['id', 'text'])
+        .build();
+
+      expect(result).toContain('subscription onMessage');
+      expect(result).toContain('messageAdded');
+    });
+  });
+
+  describe('nested fields', () => {
+    it('should handle nested subfields as strings', () => {
+      const result = new QueryBuilder()
+        .query('getUser')
+        .field('user', { id: '1' }, ['id', 'name', 'email'])
+        .build();
+
+      expect(result).toBe('query getUser { user(id: 1) { id name email } }');
+    });
+
+    it('should handle deeply nested subfields', () => {
+      const result = new QueryBuilder()
+        .query('getUser')
+        .field('user', { id: '1' }, [
+          { name: 'id' },
+          { name: 'profile', subfields: [{ name: 'avatar' }, { name: 'bio' }] },
+        ])
+        .build();
+
+      expect(result).toContain('user(id: 1)');
+      expect(result).toContain('profile { avatar bio }');
+    });
+  });
+
+  describe('variables', () => {
+    it('should add variables to the query', () => {
+      const result = new QueryBuilder()
+        .query('getUser')
+        .variable('userId', 'ID!')
+        .field('user', { id: '$userId' }, ['id', 'name'])
+        .build();
+
+      expect(result).toContain('($userId: ID!)');
+      expect(result).toContain('user(id: $userId)');
+    });
+
+    it('should handle variables with default values', () => {
+      const result = new QueryBuilder()
+        .query('getUsers')
+        .variable('limit', 'Int', '10')
+        .field('users', { limit: '$limit' }, ['id', 'name'])
+        .build();
+
+      expect(result).toContain('($limit: Int = 10)');
+    });
+
+    it('should handle multiple variables', () => {
+      const result = new QueryBuilder()
+        .query('searchUsers')
+        .variable('query', 'String!')
+        .variable('limit', 'Int', '20')
+        .variable('offset', 'Int', '0')
+        .field('search', { query: '$query', limit: '$limit', offset: '$offset' }, ['id', 'name'])
+        .build();
+
+      expect(result).toContain('$query: String!');
+      expect(result).toContain('$limit: Int = 20');
+      expect(result).toContain('$offset: Int = 0');
+    });
+  });
+
+  describe('fragments', () => {
+    it('should define and use a fragment', () => {
+      const result = new QueryBuilder()
+        .fragment('UserFields', 'User', ['id', 'name', 'email'])
+        .query('getUser')
+        .field('user', { id: '1' })
+        .spreadFragment('UserFields')
+        .build();
+
+      expect(result).toContain('fragment UserFields on User { id name email }');
+      expect(result).toContain('...UserFields');
+    });
+
+    it('should define multiple fragments', () => {
+      const result = new QueryBuilder()
+        .fragment('UserFields', 'User', ['id', 'name'])
+        .fragment('PostFields', 'Post', ['id', 'title'])
+        .query('getFeed')
+        .field('feed', {}, [
+          { name: 'id' },
+          { name: 'user', subfields: [{ name: '...UserFields' }] },
+          { name: 'post', subfields: [{ name: '...PostFields' }] },
+        ])
+        .build();
+
+      expect(result).toContain('fragment UserFields on User { id name }');
+      expect(result).toContain('fragment PostFields on Post { id title }');
+    });
+  });
+
+  describe('alias', () => {
+    it('should support field aliases', () => {
+      const result = new QueryBuilder()
+        .query('getUsers')
+        .aliasField('admin', 'user', { role: '"admin"' }, ['id', 'name'])
+        .aliasField('member', 'user', { role: '"member"' }, ['id', 'name'])
+        .build();
+
+      expect(result).toContain('admin: user(role: "admin") { id name }');
+      expect(result).toContain('member: user(role: "member") { id name }');
+    });
+  });
+
+  describe('toQuery', () => {
+    it('should return a structured query object', () => {
+      const query = new QueryBuilder()
+        .query('test')
+        .variable('id', 'ID!')
+        .field('user', { id: '$id' }, ['name'])
+        .toQuery();
+
+      expect(query.operationType).toBe('query');
+      expect(query.name).toBe('test');
+      expect(query.variables).toHaveLength(1);
+      expect(query.fields).toHaveLength(1);
+    });
+  });
+
+  describe('reset', () => {
+    it('should reset the builder state', () => {
+      const builder = new QueryBuilder()
+        .query('test')
+        .field('users')
+        .reset();
+
+      const result = builder.query('newTest').field('posts').build();
+      expect(result).toBe('query newTest { posts }');
+    });
+  });
+});
+
+describe('validateQuery', () => {
+  it('should validate a correct query', () => {
+    const result = validateQuery({
+      operationType: 'query',
+      name: 'test',
+      variables: [],
+      fields: [{ name: 'users' }],
+      fragments: [],
+    });
+
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it('should reject empty selection set', () => {
+    const result = validateQuery({
+      operationType: 'query',
+      variables: [],
+      fields: [],
+      fragments: [],
+    });
+
+    expect(result.valid).toBe(false);
+    expect(result.errors[0]?.message).toContain('empty');
+  });
+
+  it('should reject invalid operation type', () => {
+    const result = validateQuery({
+      operationType: 'invalid' as 'query',
+      variables: [],
+      fields: [{ name: 'test' }],
+      fragments: [],
+    });
+
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.message.includes('Invalid operation type'))).toBe(true);
+  });
+
+  it('should reject variables missing types', () => {
+    const result = validateQuery({
+      operationType: 'query',
+      variables: [{ name: 'id', type: '' }],
+      fields: [{ name: 'test' }],
+      fragments: [],
+    });
+
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.message.includes('missing a type'))).toBe(true);
+  });
+
+  it('should reject fragment missing onType', () => {
+    const result = validateQuery({
+      operationType: 'query',
+      variables: [],
+      fields: [{ name: 'test' }],
+      fragments: [{ name: 'Foo', onType: '', fields: [{ name: 'id' }] }],
+    });
+
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.message.includes('onType'))).toBe(true);
+  });
+});
+
+describe('validateQueryString', () => {
+  it('should validate a correct query string', () => {
+    const result = validateQueryString('query { users { id name } }');
+    expect(result.valid).toBe(true);
+  });
+
+  it('should reject empty query', () => {
+    const result = validateQueryString('');
+    expect(result.valid).toBe(false);
+    expect(result.errors[0]?.message).toContain('empty');
+  });
+
+  it('should reject unbalanced braces', () => {
+    const result = validateQueryString('query { users { id }');
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.message.includes('closing brace'))).toBe(true);
+  });
+
+  it('should reject query not starting with valid keyword', () => {
+    const result = validateQueryString('random { stuff }');
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.message.includes('must start with'))).toBe(true);
+  });
+
+  it('should accept inline query starting with {', () => {
+    const result = validateQueryString('{ users { id } }');
+    expect(result.valid).toBe(true);
+  });
+});
+
+describe('validateAgainstSchema', () => {
+  const mockSchema: GraphQLSchema = {
+    queryType: { name: 'Query' },
+    mutationType: { name: 'Mutation' },
+    types: [
+      {
+        name: 'Query',
+        kind: 'OBJECT',
+        fields: [
+          { name: 'users', type: { name: 'User', kind: 'OBJECT' }, args: [] },
+          { name: 'user', type: { name: 'User', kind: 'OBJECT' }, args: [{ name: 'id', type: { name: 'ID', kind: 'SCALAR' } }] },
+        ],
+      },
+      {
+        name: 'Mutation',
+        kind: 'OBJECT',
+        fields: [
+          { name: 'createUser', type: { name: 'User', kind: 'OBJECT' }, args: [] },
+        ],
+      },
+    ],
+  };
+
+  it('should validate fields that exist in the schema', () => {
+    const result = validateAgainstSchema(
+      { operationType: 'query', variables: [], fields: [{ name: 'users' }], fragments: [] },
+      mockSchema,
+    );
+
+    expect(result.valid).toBe(true);
+  });
+
+  it('should reject fields that do not exist in the schema', () => {
+    const result = validateAgainstSchema(
+      { operationType: 'query', variables: [], fields: [{ name: 'nonexistent' }], fragments: [] },
+      mockSchema,
+    );
+
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.message.includes('does not exist'))).toBe(true);
+  });
+
+  it('should reject when schema has no mutation type', () => {
+    const noMutSchema: GraphQLSchema = {
+      queryType: { name: 'Query' },
+      mutationType: null,
+      types: [
+        {
+          name: 'Query',
+          kind: 'OBJECT',
+          fields: [{ name: 'users', type: { name: 'User', kind: 'OBJECT' }, args: [] }],
+        },
+      ],
+    };
+
+    const result = validateAgainstSchema(
+      { operationType: 'mutation', variables: [], fields: [{ name: 'createUser' }], fragments: [] },
+      noMutSchema,
+    );
+
+    expect(result.valid).toBe(false);
+  });
+});

package/tests/lib/graphql/formatter.test.ts

@@ -0,0 +1,99 @@
+import { describe, it, expect } from 'vitest';
+import { formatQuery, minifyQuery } from '@/lib/graphql/formatter';
+
+describe('formatQuery', () => {
+  it('should format a simple query', () => {
+    const input = 'query{users{id name}}';
+    const result = formatQuery(input);
+
+    expect(result).toContain('query');
+    expect(result).toContain('{');
+    expect(result).toContain('users');
+    expect(result).toContain('id');
+    expect(result).toContain('name');
+    expect(result).toContain('}');
+  });
+
+  it('should format a query with variables', () => {
+    const input = 'query getUser($id:ID!){user(id:$id){id name email}}';
+    const result = formatQuery(input);
+
+    expect(result).toContain('getUser');
+    expect(result).toContain('$id');
+    expect(result).toContain('ID!');
+  });
+
+  it('should format a mutation', () => {
+    const input = 'mutation{createUser(input:{name:"John"}){id name}}';
+    const result = formatQuery(input);
+
+    expect(result).toContain('mutation');
+    expect(result).toContain('createUser');
+  });
+
+  it('should handle fragment definitions', () => {
+    const input = 'fragment UserFields on User{id name email}query{users{...UserFields}}';
+    const result = formatQuery(input);
+
+    expect(result).toContain('fragment UserFields on User');
+    expect(result).toContain('...UserFields');
+  });
+
+  it('should return empty string for empty input', () => {
+    expect(formatQuery('')).toBe('');
+    expect(formatQuery('   ')).toBe('');
+  });
+
+  it('should strip comments', () => {
+    const input = `# This is a comment
+query { # inline comment
+  users { id } # another comment
+}`;
+    const result = formatQuery(input);
+    expect(result).not.toContain('#');
+    expect(result).toContain('users');
+  });
+
+  it('should handle string values', () => {
+    const input = 'query{search(q:"hello world"){id}}';
+    const result = formatQuery(input);
+    expect(result).toContain('"hello world"');
+  });
+});
+
+describe('minifyQuery', () => {
+  it('should minify a formatted query', () => {
+    const input = `
+      query getUser($id: ID!) {
+        user(id: $id) {
+          id
+          name
+          email
+        }
+      }
+    `;
+    const result = minifyQuery(input);
+
+    // Minified should be shorter
+    expect(result.length).toBeLessThan(input.length);
+    // Should still contain all essential parts
+    expect(result).toContain('getUser');
+    expect(result).toContain('$id');
+    expect(result).toContain('user');
+  });
+
+  it('should remove comments when minifying', () => {
+    const input = `# Comment
+query { users { id } }`;
+    const result = minifyQuery(input);
+    expect(result).not.toContain('#');
+  });
+
+  it('should handle already-minified queries', () => {
+    const input = '{users{id name}}';
+    const result = minifyQuery(input);
+    expect(result).toContain('users');
+    expect(result).toContain('id');
+    expect(result).toContain('name');
+  });
+});

package/tests/lib/http/request-builder.test.ts

@@ -0,0 +1,160 @@
+import { describe, it, expect, vi } from 'vitest';
+
+// Mock auth modules before importing the module under test
+vi.mock('@/lib/auth/basic', () => ({
+  applyBasicAuth: vi.fn((headers: Record<string, string>, config: { username: string; password: string }) => {
+    headers['Authorization'] = `Basic ${btoa(`${config.username}:${config.password}`)}`;
+  }),
+}));
+
+vi.mock('@/lib/auth/bearer', () => ({
+  applyBearerAuth: vi.fn((headers: Record<string, string>, config: { token: string; prefix: string }) => {
+    headers['Authorization'] = `${config.prefix} ${config.token}`;
+  }),
+}));
+
+vi.mock('@/lib/auth/api-key', () => ({
+  applyApiKeyAuth: vi.fn((headers: Record<string, string>, params: Record<string, string>, config: { key: string; value: string; addTo: string }) => {
+    if (config.addTo === 'header') headers[config.key] = config.value;
+    else if (config.addTo === 'query') params[config.key] = config.value;
+  }),
+}));
+
+vi.mock('@/lib/auth/aws-sig', () => ({
+  applyAwsAuth: vi.fn((headers: Record<string, string>) => {
+    headers['Authorization'] = 'AWS4-HMAC-SHA256 mock-signature';
+  }),
+}));
+
+// Mock resolver to pass through variables
+vi.mock('@/lib/env/resolver', () => ({
+  resolveVariables: vi.fn((input: string, vars: Record<string, string> = {}) => {
+    return input.replace(/\{\{(\w+)\}\}/g, (_: string, key: string) => vars[key] ?? `{{${key}}}`);
+  }),
+}));
+
+import { buildRequest } from '@/lib/http/request-builder';
+
+describe('buildRequest', () => {
+  const baseUrl = 'https://api.example.com';
+
+  it('should build a basic GET request', () => {
+    const result = buildRequest('GET', baseUrl, [], [], null, 'none', null);
+
+    expect(result.method).toBe('GET');
+    expect(result.url).toContain('api.example.com');
+    expect(result.body).toBeNull();
+    expect(result.headers).toEqual({});
+  });
+
+  it('should resolve variables in URL', () => {
+    const result = buildRequest(
+      'GET', '{{base_url}}/users', [], [], null, 'none', null,
+      { base_url: 'https://api.example.com' },
+    );
+    expect(result.url).toContain('https://api.example.com/users');
+  });
+
+  it('should include enabled headers', () => {
+    const headers = [
+      { key: 'Content-Type', value: 'application/json', enabled: true },
+      { key: 'X-Disabled', value: 'skip', enabled: false },
+    ];
+    const result = buildRequest('GET', baseUrl, headers, [], null, 'none', null);
+    expect(result.headers['Content-Type']).toBe('application/json');
+    expect(result.headers['X-Disabled']).toBeUndefined();
+  });
+
+  it('should resolve variables in headers', () => {
+    const headers = [
+      { key: 'Authorization', value: 'Bearer {{token}}', enabled: true },
+    ];
+    const result = buildRequest('GET', baseUrl, headers, [], null, 'none', null, { token: 'abc123' });
+    expect(result.headers['Authorization']).toBe('Bearer abc123');
+  });
+
+  it('should include enabled query params', () => {
+    const params = [
+      { key: 'page', value: '1', enabled: true },
+      { key: 'disabled', value: 'skip', enabled: false },
+    ];
+    const result = buildRequest('GET', baseUrl, [], params, null, 'none', null);
+    expect(result.url).toContain('page=1');
+    expect(result.url).not.toContain('disabled');
+  });
+
+  it('should build JSON body', () => {
+    const body = { raw: '{"key":"value"}' };
+    const result = buildRequest('POST', baseUrl, [], [], body, 'json', null);
+    expect(result.body).toBe('{"key":"value"}');
+    expect(result.headers['Content-Type']).toBe('application/json');
+  });
+
+  it('should build urlencoded body', () => {
+    const body = {
+      form: [
+        { key: 'username', value: 'test', enabled: true },
+        { key: 'password', value: 'pass', enabled: true },
+      ],
+    };
+    const result = buildRequest('POST', baseUrl, [], [], body, 'urlencoded', null);
+    expect(result.body).toBe('username=test&password=pass');
+    expect(result.headers['Content-Type']).toBe('application/x-www-form-urlencoded');
+  });
+
+  it('should return null body for none body type', () => {
+    const result = buildRequest('GET', baseUrl, [], [], null, 'none', null);
+    expect(result.body).toBeNull();
+  });
+
+  it('should return null body when body is undefined', () => {
+    const result = buildRequest('GET', baseUrl, [], [], undefined, undefined, null);
+    expect(result.body).toBeNull();
+  });
+
+  it('should build raw body with text/plain content type', () => {
+    const body = { raw: 'plain text content' };
+    const result = buildRequest('POST', baseUrl, [], [], body, 'raw', null);
+    expect(result.body).toBe('plain text content');
+    expect(result.headers['Content-Type']).toBe('text/plain');
+  });
+
+  it('should build graphql body', () => {
+    const body = {
+      graphql: {
+        query: '{ users { id name } }',
+        variables: '{"limit": 10}',
+      },
+    };
+    const result = buildRequest('POST', baseUrl, [], [], body, 'graphql', null);
+    expect(result.headers['Content-Type']).toBe('application/json');
+    const parsed = JSON.parse(result.body as string);
+    expect(parsed.query).toBe('{ users { id name } }');
+    expect(parsed.variables).toEqual({ limit: 10 });
+  });
+
+  it('should build binary body', () => {
+    const body = { binary: 'base64data' };
+    const result = buildRequest('POST', baseUrl, [], [], body, 'binary', null);
+    expect(result.body).toBe('base64data');
+    expect(result.headers['Content-Type']).toBe('application/octet-stream');
+  });
+
+  it('should not set Content-Type if user already provided one', () => {
+    const headers = [{ key: 'Content-Type', value: 'application/vnd.api+json', enabled: true }];
+    const body = { raw: '{"data":"test"}' };
+    const result = buildRequest('POST', baseUrl, headers, [], body, 'json', null);
+    expect(result.headers['Content-Type']).toBe('application/vnd.api+json');
+  });
+
+  it('should skip disabled form pairs in urlencoded body', () => {
+    const body = {
+      form: [
+        { key: 'keep', value: 'yes', enabled: true },
+        { key: 'skip', value: 'no', enabled: false },
+      ],
+    };
+    const result = buildRequest('POST', baseUrl, [], [], body, 'urlencoded', null);
+    expect(result.body).toBe('keep=yes');
+  });
+});