@pcg/graphql-kit 1.0.0-alpha.1

package/.turbo/turbo-lint.log

@@ -0,0 +1,4 @@
+
+> @pcg/graphql-kit@1.0.0-alpha.0 lint /Users/vangolenko/node/pcg/packages/graphql-kit
+> eslint "src/**/*.ts" --fix
+

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @pcg/graphql-kit
+
+## 1.0.0-alpha.1
+
+### Minor Changes
+
+- Initial release of @pcg/graphql-kit package. GraphQL utilities and error handling for NestJS Apollo.

package/eslint.config.js

@@ -0,0 +1,5 @@
+import deepEslint, { defineConfig } from '@deepvision/eslint-plugin';
+
+export default defineConfig([
+  deepEslint.configs.vue,
+]);

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@pcg/graphql-kit",
+  "version": "1.0.0-alpha.1",
+  "description": "GraphQL utilities and error handling for NestJS Apollo",
+  "license": "MIT",
+  "author": {
+    "email": "code@deepvision.team",
+    "name": "DeepVision Code"
+  },
+  "contributors": [
+    "Vitaliy Angolenko <v.angolenko@deepvision.software>",
+    "Sergii Sadovyi <s.sadovyi@deepvision.software>"
+  ],
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "dependencies": {
+    "@apollo/client": "^3.13.0",
+    "graphql": "^16.10.0"
+  },
+  "devDependencies": {
+    "@vitest/ui": "^3.2.4",
+    "vitest": "^3.2.4"
+  },
+  "scripts": {
+    "dev": "tsdown --watch",
+    "build": "tsdown",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint \"src/**/*.ts\" --fix"
+  }
+}

package/src/graphql-error-log.ts

@@ -0,0 +1,105 @@
+import { type ApolloError } from '@apollo/client/core';
+import { type ErrorResponse } from '@apollo/client/link/error';
+import { print } from 'graphql';
+
+import { isNestJsGraphQLError } from './tools';
+
+export const getErrorMessages = (error: ErrorResponse | ApolloError) => {
+  const messages: string[] = [];
+  // eslint-disable-next-line @typescript-eslint/no-deprecated -- Safe to use in Apollo Client 3.x
+  const { graphQLErrors, networkError } = error;
+  const operation = 'operation' in error ? error.operation : undefined;
+  const stack = 'stack' in error ? error.stack : undefined;
+  let printedQuery: string;
+
+  if (operation) {
+    printedQuery = print(operation.query);
+  }
+
+  if (graphQLErrors) {
+    graphQLErrors.forEach((error) => {
+      if (isNestJsGraphQLError(error)) {
+        messages.push(`[NestJs GraphQL Error] ${error.message} (${error.extensions.key})`);
+      } else {
+        messages.push(`[GraphQL Error] ${error.message}`);
+      }
+
+      if (operation) {
+        messages.push(logOperation(printedQuery, error.locations));
+        if (Object.keys(operation.variables).length) {
+          messages.push(`with variables: ${JSON.stringify(operation.variables, null, 2)}`);
+        }
+      }
+
+      if (isNestJsGraphQLError(error)) {
+        messages.push(`with context: ${JSON.stringify(error.extensions.context, null, 2)}`);
+
+        if (error.extensions.errorStack) {
+          messages.push(`with stack: ${JSON.stringify(error.extensions.errorStack, null, 2)}`);
+        }
+      }
+    });
+  }
+
+  if (networkError) {
+    messages.push(`[GraphQL Network Error] ${networkError}`);
+  }
+
+  if (stack) {
+    messages.push(stack);
+  }
+
+  return messages;
+};
+
+export const logErrorMessages = (error: ApolloError | ErrorResponse, printStack = true) => {
+  getErrorMessages(error).forEach((message) => {
+    const result = /\[([\w ]*)](.*)/.exec(message);
+    if (result) {
+      const [, tag, msg] = result;
+      console.log(`%c${tag}`, 'color:white;border-radius:3px;background:#ff4400;font-weight:bold;padding:2px 6px;', msg);
+    } else {
+      console.log(message);
+    }
+  });
+
+  if (printStack) {
+    let stack = new Error().stack;
+    if (stack == null) {
+      return;
+    }
+
+    const newLineIndex = stack.indexOf('\n');
+    stack = stack.slice(stack.indexOf('\n', newLineIndex + 1));
+    console.log(`%c${stack}`, 'color:grey;');
+  }
+};
+
+interface ErrorLocation {
+  line: number;
+  column: number;
+}
+
+const logOperation = (printedQuery: string, locations: readonly ErrorLocation[] | undefined) => {
+  const lines = printedQuery.split('\n');
+  const l = lines.length;
+  const result = lines.slice();
+  const lineMap: Record<number, number> = {
+  };
+  for (let i = 0; i < l; i++) {
+    lineMap[i] = i;
+  }
+
+  if (locations) {
+    for (const { line, column } of locations) {
+      const index = lineMap[line];
+      result.splice(index, 0, '▲'.padStart(column, ' '));
+      // Offset remaining lines
+      for (let i = index + 1; i < l; i++) {
+        lineMap[i]++;
+      }
+    }
+  }
+
+  return result.join('\n');
+};

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './graphql-error-log';
+export * from './tools';
+export * from './types';

package/src/tools.ts

@@ -0,0 +1,20 @@
+import { type GraphQLFormattedError } from 'graphql';
+
+import { type NestJsApolloError, type NestJsGraphQLError } from './types';
+
+export const isNestJsApolloError = (err: GraphQLFormattedError): err is NestJsApolloError => {
+  return Object.prototype.hasOwnProperty.call(err, 'graphQLErrors');
+};
+
+export const isNestJsGraphQLError = (err: GraphQLFormattedError): err is NestJsGraphQLError => {
+  const nestError = err as NestJsGraphQLError;
+  return Boolean(nestError.extensions) && Boolean(nestError.extensions.context);
+};
+
+export const getFirstNestJsGraphQLError = (err: GraphQLFormattedError): NestJsGraphQLError | null => {
+  if (!isNestJsApolloError(err)) {
+    return null;
+  }
+
+  return err.graphQLErrors[0] ?? null;
+};

package/src/types.ts

@@ -0,0 +1,32 @@
+import { ApolloError } from '@apollo/client/core';
+import { GraphQLError } from 'graphql';
+
+export interface ErrorStackItem {
+  key: string;
+  message: string;
+  context: Record<string, unknown>;
+  stacktrace?: string;
+}
+
+export class NestJsGraphQLError extends GraphQLError {
+  declare extensions: {
+    context: {
+      scope?: string;
+      action?: string;
+      requestId?: string;
+      userId?: string;
+      [attributeName: string]: unknown;
+    };
+    key: string;
+    statusCode: number;
+    errorStack?: ErrorStackItem[];
+    format: 'NESTJS';
+    [attributeName: string]: unknown;
+  };
+}
+
+export type NestJsGraphQLErrors = readonly NestJsGraphQLError[];
+
+export class NestJsApolloError extends ApolloError {
+  declare graphQLErrors: NestJsGraphQLErrors;
+}

package/tests/graphql-error-log.test.ts

@@ -0,0 +1,219 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { GraphQLError } from 'graphql';
+import {
+    describe,
+    expect,
+    it,
+    vi,
+} from 'vitest';
+
+import {
+    getErrorMessages,
+    logErrorMessages,
+} from '@/graphql-error-log.js';
+import { NestJsGraphQLError } from '@/types.js';
+
+describe('graphql-error-log', () => {
+  describe('getErrorMessages', () => {
+    it('should return empty array for error without graphQLErrors and networkError', () => {
+      const error: any = {
+        graphQLErrors: undefined,
+        networkError: undefined,
+      };
+      const messages = getErrorMessages(error);
+      expect(messages).toEqual([]);
+    });
+
+    it('should handle graphQLErrors', () => {
+      const error: any = {
+        graphQLErrors: [new GraphQLError('Test GraphQL Error')],
+        networkError: undefined,
+      };
+      const messages = getErrorMessages(error);
+      expect(messages).toContain('[GraphQL Error] Test GraphQL Error');
+    });
+
+    it('should handle NestJsGraphQLError with key', () => {
+      const nestError = new NestJsGraphQLError('NestJs Error', {
+        extensions: {
+          context: {
+            userId: '123',
+          },
+          key: 'CUSTOM_ERROR',
+          statusCode: 400,
+        },
+      });
+      const error: any = {
+        graphQLErrors: [nestError],
+        networkError: undefined,
+      };
+      const messages = getErrorMessages(error);
+      expect(messages.some((msg: string) => msg.includes('[NestJs GraphQL Error]'))).toBe(true);
+      expect(messages.some((msg: string) => msg.includes('CUSTOM_ERROR'))).toBe(true);
+    });
+
+    it('should handle network errors', () => {
+      const networkError = new Error('Network failure');
+      const error: any = {
+        graphQLErrors: undefined,
+        networkError,
+      };
+      const messages = getErrorMessages(error);
+      expect(messages).toContain('[GraphQL Network Error] Error: Network failure');
+    });
+
+    it('should handle both graphQLErrors and networkError', () => {
+      const graphqlError = new GraphQLError('GraphQL Error');
+      const networkError = new Error('Network Error');
+      const error: any = {
+        graphQLErrors: [graphqlError],
+        networkError,
+      };
+      const messages = getErrorMessages(error);
+      expect(messages.some((msg: string) => msg.includes('GraphQL Error'))).toBe(true);
+      expect(messages.some((msg: string) => msg.includes('Network Error'))).toBe(true);
+    });
+
+    it('should handle multiple graphQLErrors', () => {
+      const error: any = {
+        graphQLErrors: [
+          new GraphQLError('Error 1'),
+          new GraphQLError('Error 2'),
+          new GraphQLError('Error 3'),
+        ],
+        networkError: undefined,
+      };
+      const messages = getErrorMessages(error);
+      expect(messages.filter((msg: string) => msg.includes('[GraphQL Error]')).length).toBe(3);
+    });
+
+    it('should include context for NestJsGraphQLError', () => {
+      const nestError = new NestJsGraphQLError('NestJs Error', {
+        extensions: {
+          context: {
+            userId: '123',
+            scope: 'admin',
+          },
+          key: 'AUTH_ERROR',
+          statusCode: 401,
+        },
+      });
+      const error: any = {
+        graphQLErrors: [nestError],
+        networkError: undefined,
+      };
+      const messages = getErrorMessages(error);
+      expect(messages.some((msg: string) => msg.includes('with context'))).toBe(true);
+      expect(messages.some((msg: string) => msg.includes('userId'))).toBe(true);
+    });
+
+    it('should include errorStack for NestJsGraphQLError', () => {
+      const nestError = new NestJsGraphQLError('NestJs Error', {
+        extensions: {
+          context: {
+            userId: '123',
+          },
+          key: 'ERROR',
+          statusCode: 400,
+          errorStack: [
+            {
+              key: 'VALIDATION_ERROR',
+              message: 'Invalid input',
+              context: {
+                field: 'email',
+              },
+            },
+          ],
+        },
+      });
+      const error: any = {
+        graphQLErrors: [nestError],
+        networkError: undefined,
+      };
+      const messages = getErrorMessages(error);
+      expect(messages.some((msg: string) => msg.includes('with stack'))).toBe(true);
+    });
+  });
+
+  describe('logErrorMessages', () => {
+    it('should call console.log for each message', () => {
+      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+      const error: any = {
+        graphQLErrors: [new GraphQLError('Test Error')],
+        networkError: undefined,
+      };
+
+      logErrorMessages(error, false);
+
+      expect(consoleSpy).toHaveBeenCalled();
+      consoleSpy.mockRestore();
+    });
+
+    it('should format error tags correctly', () => {
+      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+      const error: any = {
+        graphQLErrors: [new GraphQLError('Test Error')],
+        networkError: undefined,
+      };
+
+      logErrorMessages(error, false);
+
+      const calls = consoleSpy.mock.calls.map((call: any) => call[0]);
+      expect(calls.some((call: any) => typeof call === 'string' && call.includes('GraphQL Error'))).toBe(true);
+
+      consoleSpy.mockRestore();
+    });
+
+    it('should include stack trace when printStack is true', () => {
+      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+      const error: any = {
+        graphQLErrors: [new GraphQLError('Test Error')],
+        networkError: undefined,
+      };
+
+      logErrorMessages(error, true);
+
+      const calls = consoleSpy.mock.calls;
+      expect(calls.length).toBeGreaterThan(0);
+
+      consoleSpy.mockRestore();
+    });
+
+    it('should handle NestJsGraphQLError tags correctly', () => {
+      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+      const nestError = new NestJsGraphQLError('NestJs Error', {
+        extensions: {
+          context: {
+          },
+          key: 'CUSTOM_ERROR',
+          statusCode: 400,
+        },
+      });
+      const error: any = {
+        graphQLErrors: [nestError],
+        networkError: undefined,
+      };
+
+      logErrorMessages(error, false);
+
+      const calls = consoleSpy.mock.calls.map((call: any) => call[0]);
+      expect(calls.some((call: any) => typeof call === 'string' && call.includes('NestJs GraphQL Error'))).toBe(true);
+
+      consoleSpy.mockRestore();
+    });
+
+    it('should handle default printStack value', () => {
+      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+      const error: any = {
+        graphQLErrors: [new GraphQLError('Test Error')],
+        networkError: undefined,
+      };
+
+      logErrorMessages(error);
+
+      expect(consoleSpy).toHaveBeenCalled();
+
+      consoleSpy.mockRestore();
+    });
+  });
+});

package/tests/tools.test.ts

@@ -0,0 +1,152 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { GraphQLError } from 'graphql';
+import {
+    describe,
+    expect,
+    it,
+} from 'vitest';
+
+import {
+    getFirstNestJsGraphQLError,
+    isNestJsApolloError,
+    isNestJsGraphQLError,
+} from '@/tools.js';
+import { NestJsGraphQLError } from '@/types.js';
+
+type TestError = GraphQLError | Record<string, unknown>;
+
+describe('tools', () => {
+  describe('isNestJsApolloError', () => {
+    it('should identify apollo errors with graphQLErrors property', () => {
+      const apolloError: TestError = {
+        message: 'test',
+        graphQLErrors: [],
+      };
+      expect(isNestJsApolloError(apolloError as any)).toBe(true);
+    });
+
+    it('should return false for objects without graphQLErrors property', () => {
+      const notApolloError: TestError = {
+        message: 'test',
+      };
+      expect(isNestJsApolloError(notApolloError as any)).toBe(false);
+    });
+
+    it('should return true for errors with non-empty graphQLErrors', () => {
+      const apolloError: TestError = {
+        message: 'Apollo Error',
+        graphQLErrors: [new GraphQLError('Internal error')],
+      };
+      expect(isNestJsApolloError(apolloError as any)).toBe(true);
+    });
+  });
+
+  describe('isNestJsGraphQLError', () => {
+    it('should identify graphql errors with extensions.context', () => {
+      const graphqlError: TestError = {
+        message: 'test',
+        extensions: {
+          context: {
+          },
+        },
+      };
+      expect(isNestJsGraphQLError(graphqlError as any)).toBe(true);
+    });
+
+    it('should return false for errors without extensions', () => {
+      const graphqlError: TestError = {
+        message: 'test',
+      };
+      expect(isNestJsGraphQLError(graphqlError as any)).toBe(false);
+    });
+
+    it('should return false for errors without extensions.context', () => {
+      const graphqlError: TestError = {
+        message: 'test',
+        extensions: {
+          key: 'VALUE',
+        },
+      };
+      expect(isNestJsGraphQLError(graphqlError as any)).toBe(false);
+    });
+
+    it('should return true for errors with context and additional properties', () => {
+      const graphqlError: TestError = {
+        message: 'test',
+        extensions: {
+          context: {
+            scope: 'user',
+            action: 'login',
+            requestId: '123',
+          },
+          key: 'UNAUTHORIZED',
+          statusCode: 401,
+        },
+      };
+      expect(isNestJsGraphQLError(graphqlError as any)).toBe(true);
+    });
+
+    it('should handle errors with null context', () => {
+      const graphqlError: TestError = {
+        message: 'test',
+        extensions: {
+          context: null,
+        },
+      };
+      expect(isNestJsGraphQLError(graphqlError as any)).toBe(false);
+    });
+  });
+
+  describe('getFirstNestJsGraphQLError', () => {
+    it('should return null if error is not apollo error', () => {
+      const error: TestError = {
+        message: 'test',
+      };
+      expect(getFirstNestJsGraphQLError(error as any)).toBeNull();
+    });
+
+    it('should return null if graphQLErrors is empty', () => {
+      const error: TestError = {
+        message: 'test',
+        graphQLErrors: [],
+      };
+      expect(getFirstNestJsGraphQLError(error as any)).toBeNull();
+    });
+
+    it('should return first graphql error from apollo error', () => {
+      const firstError = new GraphQLError('First error');
+      const secondError = new GraphQLError('Second error');
+      const error: TestError = {
+        message: 'Apollo Error',
+        graphQLErrors: [firstError, secondError],
+      };
+      expect(getFirstNestJsGraphQLError(error as any)).toBe(firstError);
+    });
+
+    it('should return single graphql error from apollo error', () => {
+      const error = new GraphQLError('Single error');
+      const apolloError: TestError = {
+        message: 'Apollo Error',
+        graphQLErrors: [error],
+      };
+      expect(getFirstNestJsGraphQLError(apolloError as any)).toBe(error);
+    });
+
+    it('should handle NestJsGraphQLError specifically', () => {
+      const nestError = new NestJsGraphQLError('NestJs error', {
+        extensions: {
+          context: {
+            userId: '123',
+          },
+          key: 'CUSTOM_ERROR',
+          statusCode: 400,
+        },
+      });
+      const apolloError: TestError = {
+        message: 'Apollo Error',
+        graphQLErrors: [nestError],
+      };
+      expect(getFirstNestJsGraphQLError(apolloError as any)).toBe(nestError);
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "moduleResolution": "bundler",
+  },
+  "include": ["src/**/*.ts", "tests/**/*.ts"],
+  "exclude": ["node_modules", "dist"],
+}

package/tsconfig.lib.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "moduleResolution": "bundler",
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"],
+}

package/tsdown.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'tsdown';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+  tsconfig: '../../tsconfig.build.json',
+  outDir: 'dist',
+  dts: true,
+  clean: true,
+  sourcemap: true,
+  format: 'esm',
+});

package/vitest.config.ts

@@ -0,0 +1,19 @@
+// / <reference types="vitest" />
+// eslint-disable-next-line node/no-unpublished-import
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    include: ['tests/**/*.test.ts'],
+    globals: true,
+    typecheck: {
+      tsconfig: './tsconfig.json',
+    },
+  },
+  resolve: {
+    alias: {
+      '@': new URL('./src', import.meta.url).pathname,
+    },
+  },
+});