@axinom/mosaic-graphql-common 0.1.0-rc.0

package/src/plugins/validation-directives-plugin.ts

@@ -0,0 +1,141 @@
+import { camelCase, Plugin, SchemaBuilder } from 'graphile-build';
+import inflection from 'inflection';
+import { Dict } from '../common';
+
+interface Constraint {
+  id: number;
+  name: string;
+  tableId: number;
+  tableIndexes: [number];
+  definition: string;
+}
+
+interface Constraints {
+  [Key: string]: Constraint[];
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function loadDbConstraints(builder: SchemaBuilder): Promise<any[]> {
+  const constraintQuery = `
+    SELECT
+      oid, conname, conrelid, conkey, pg_get_constraintdef(oid) AS definition
+    FROM
+      pg_constraint
+    WHERE
+      contype = 'c' AND conrelid > 0;`;
+
+  // this pgConfig is not part of the public TS builder API so it may change
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const queryResult = await (builder as any).options.pgConfig.query(
+    constraintQuery,
+  );
+  return queryResult.rows;
+}
+
+async function getConstraints(builder: SchemaBuilder): Promise<Constraints> {
+  const constraints: Constraints = {};
+  const rows = await loadDbConstraints(builder);
+  for (const row of rows) {
+    const key = `${row.conrelid}`;
+    constraints[key] = constraints[key] || [];
+    constraints[key].push({
+      id: row.oid,
+      name: row.conname,
+      tableId: row.conrelid,
+      definition: row.definition,
+      tableIndexes: row.conkey,
+    });
+  }
+  return constraints;
+}
+
+function mapCheckToValidation(constraint: string): string {
+  const regex =
+    /CHECK\s*\(\s*([a-zA-Z0-9_]+\.){0,1}([a-zA-Z0-9_]+)\s*\(\s*(['a-zA-Z0-9_]+)\s*,\s*(['a-zA-Z0-9_]+)/gm;
+
+  const result = regex.exec(constraint);
+  if (result?.length && result.length > 4) {
+    switch (result[2]) {
+      // custom handle when parameters are used - otherwise default is fine
+      case 'constraint_max_length':
+        return `@maxLength(${result[4]})`;
+      case 'constraint_min_length':
+        return `@minLength(${result[4]})`;
+      default:
+        // eslint-disable-next-line no-case-declarations
+        const constraintName = inflection.camelize(
+          result[2].replace('constraint_', ''),
+          true,
+        );
+        return `@${constraintName}()`;
+    }
+  }
+
+  return '';
+}
+/**
+ *  Plugin that adds validation directives to graphql schema descriptions.
+ */
+export const ValidationDirectivesPlugin: Plugin = async (builder) => {
+  const constraints = await getConstraints(builder);
+
+  builder.hook('GraphQLInputObjectType:fields', (fields, _build, context) => {
+    const tableConstraints =
+      constraints[`${context.scope.pgIntrospection?.id}`];
+    const columnMappings: Dict<{ annotations: string[] }> = {};
+    // check if there are any constraints in the DB
+    if (tableConstraints && Object.keys(fields).length) {
+      for (const constraint of tableConstraints) {
+        for (const tableIndex of constraint.tableIndexes) {
+          // find the DB column by its index with 'pg_constraint.conkey'
+          const column = context.scope.pgIntrospection.attributes.find(
+            (at: { num: number }) => at.num === tableIndex,
+          );
+
+          const validation = mapCheckToValidation(constraint.definition);
+          if (validation) {
+            // Converting the column name to camelCase to follow the general GraphQL naming pattern when adding it to the description.
+            const prop = camelCase(column.name);
+            columnMappings[prop] = columnMappings[prop] ?? { annotations: [] };
+            columnMappings[prop].annotations.push(validation);
+          }
+        }
+      }
+    }
+
+    for (const prop in columnMappings) {
+      const f = fields[prop];
+      if (f) {
+        const annotations = columnMappings[prop].annotations.sort().join('\n');
+        f.description = f.description
+          ? `${f.description}\n${annotations}`
+          : annotations;
+      }
+    }
+
+    return fields;
+  });
+
+  builder.hook('GraphQLSchema', (schemaConfig /*, build*/) => {
+    return schemaConfig;
+    // The following would allow to add custom directives.
+    // They can only be used on the server! They are not sent back to clients.
+    // return {
+    //   ...schemaConfig,
+    //   directives: [
+    //     ...(schemaConfig.directives || []),
+    //     build.newWithHooks(
+    //       build.graphql.GraphQLDirective,
+    //       {
+    //         name: 'upper',
+    //         locations: ['FIELD_DEFINITION', 'FIELD'],
+    //         args: {
+    //           name: { type: build.graphql.GraphQLString },
+    //         },
+    //       },
+    //       { isUpperDirective: true },
+    //     ),
+    //   ],
+    // };
+  });
+};

package/src/postgraphile/enhance-graphql-errors.spec.ts

@@ -0,0 +1,241 @@
+import { GraphQLError, Source } from 'graphql';
+import 'jest-extended';
+import {
+  GeneralGraphQlErrorCode,
+  GraphQlOperation,
+  enhanceGraphqlErrors,
+} from './enhance-graphql-errors';
+
+const iso8601Regex =
+  /^[0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])T([0-1][0-9]|2[0-3])(:[0-5][0-9]){2}(\.[0-9]{0,6})?(Z|\+00:00)$/;
+const UNIT_TEST_ERROR = 'UNIT_TEST_ERROR';
+
+describe('graphqlErrorHandler', () => {
+  let timestampBeforeTest: Date;
+  const mockLog = jest.fn();
+  const dateAfterTestStart = (received: string | Date): void => {
+    const parsedDate = new Date(received).getTime();
+    expect(parsedDate).toBeGreaterThanOrEqual(timestampBeforeTest.getTime());
+  };
+
+  beforeEach(async () => {
+    const date = new Date();
+    date.setSeconds(date.getSeconds() - 10);
+    timestampBeforeTest = date;
+  });
+
+  afterEach(async () => {
+    jest.restoreAllMocks();
+  });
+
+  it('minimal internal server error -> valid response', async () => {
+    // Arrange
+    const gqlError = new GraphQLError(
+      'test',
+      undefined,
+      null,
+      null,
+      null,
+      new Error('original'),
+      {
+        code: UNIT_TEST_ERROR,
+      },
+    );
+
+    // Act
+    const enhancedErrors = enhanceGraphqlErrors([gqlError]);
+
+    // Assert
+    expect(enhancedErrors).toHaveLength(1);
+    const enhancedError = enhancedErrors[0];
+    expect(enhancedError.timestamp).toMatch(iso8601Regex);
+    dateAfterTestStart(enhancedError.timestamp);
+    expect(enhancedError).toEqual({
+      timestamp: enhancedError.timestamp,
+      message: 'test',
+      details: undefined,
+      code: GeneralGraphQlErrorCode,
+      extensions: {
+        exception: {
+          code: GeneralGraphQlErrorCode,
+        },
+        operationName: undefined,
+        timestamp: expect.any(String),
+      },
+    });
+    expect(Object.keys(enhancedError)).toHaveLength(5);
+  });
+
+  it('multiple minimal errors -> valid response', async () => {
+    // Arrange
+    const gqlError = new GraphQLError(
+      'test',
+      undefined,
+      null,
+      null,
+      null,
+      new Error('original'),
+      null,
+    );
+
+    // Act
+    const enhancedErrors = enhanceGraphqlErrors([gqlError, gqlError]);
+
+    // Assert
+    expect(enhancedErrors).toHaveLength(2);
+    dateAfterTestStart(enhancedErrors[0].timestamp);
+    dateAfterTestStart(enhancedErrors[1].timestamp);
+    expect(enhancedErrors[0].code).toBe(GeneralGraphQlErrorCode);
+    expect(enhancedErrors[1].code).toBe(GeneralGraphQlErrorCode);
+    expect(enhancedErrors[0].message).toBe('test');
+    expect(enhancedErrors[1].message).toBe('test');
+  });
+
+  it('enhances and logs GraphQL errors', () => {
+    // Arrange
+    const gqlErrors = [
+      new GraphQLError(
+        'test',
+        undefined,
+        null,
+        null,
+        null,
+        new Error('original'),
+        {
+          code: UNIT_TEST_ERROR,
+        },
+      ),
+    ];
+
+    // Act
+    const enhancedErrors = enhanceGraphqlErrors(gqlErrors, undefined, mockLog);
+
+    // Assert
+    expect(enhancedErrors).toHaveLength(1);
+    expect(mockLog).toHaveBeenCalledTimes(1);
+  });
+
+  it('enhances GraphQL errors with additional error mapper', () => {
+    // Arrange
+    const gqlErrors = [
+      new GraphQLError(
+        'test',
+        undefined,
+        null,
+        null,
+        null,
+        new Error('original'),
+        {
+          code: UNIT_TEST_ERROR,
+        },
+      ),
+    ];
+    const errorMapper = (error: GraphQLError) => ({
+      ...error,
+      code: 'CUSTOM_ERROR_CODE',
+    });
+
+    // Act
+    const enhancedErrors = enhanceGraphqlErrors(
+      gqlErrors,
+      'test',
+      errorMapper,
+      undefined,
+    );
+
+    // Assert
+    expect(enhancedErrors).toHaveLength(1);
+    expect(enhancedErrors[0].code).toBe('CUSTOM_ERROR_CODE');
+  });
+
+  it('contains all original data', () => {
+    // Arrange
+    const gqlError = new GraphQLError(
+      'internal',
+      undefined,
+      new Source(`mutation DeleteAsset {
+        deleteAsset(input: {id: 1}) {
+          asset {
+            id
+            title
+          }
+        }
+      }`),
+      [11],
+      ['deleteAsset'],
+      null,
+      {
+        code: UNIT_TEST_ERROR,
+      },
+    );
+
+    // Act
+    const enhancedErrors = enhanceGraphqlErrors(
+      [gqlError],
+      undefined,
+      undefined,
+    );
+
+    // Assert
+    expect(enhancedErrors).toHaveLength(1);
+    const enhancedError = enhancedErrors[0];
+    expect(enhancedError).toEqual({
+      timestamp: enhancedError.timestamp,
+      locations: [
+        {
+          column: 12,
+          line: 1,
+        },
+      ],
+      message: 'internal',
+      path: ['deleteAsset'],
+      details: undefined,
+      code: GeneralGraphQlErrorCode,
+      extensions: {
+        exception: {
+          code: GeneralGraphQlErrorCode,
+        },
+        operationName: undefined,
+        timestamp: expect.any(String),
+      },
+    });
+  });
+
+  it('maps the request data for logging', () => {
+    // Arrange
+    const gqlError = new GraphQLError(
+      'internal',
+      undefined,
+      new Source(`mutation MyDeleteAsset {
+        deleteAsset(input: {id: 1}) {
+          asset {
+            id
+            title
+          }
+        }
+      }`),
+      [11],
+      ['deleteAsset'],
+      null,
+      {
+        code: UNIT_TEST_ERROR,
+      },
+    );
+    let requestInfo: GraphQlOperation[] | undefined = undefined;
+
+    // Act
+    enhanceGraphqlErrors([gqlError], undefined, undefined, (_e, r) => {
+      requestInfo = r;
+    });
+
+    // Assert
+    expect(requestInfo).toBeDefined();
+    expect(requestInfo).toEqual([
+      {
+        name: 'MyDeleteAsset',
+        operation: 'mutation',
+        rootEndpoints: ['deleteAsset'],
+      },
+    ]);
+  });
+});

package/src/postgraphile/enhance-graphql-errors.ts

@@ -0,0 +1,138 @@
+import {
+  FieldNode,
+  GraphQLError,
+  OperationDefinitionNode,
+  OperationTypeNode,
+  Source,
+  parse,
+} from 'graphql';
+import { GraphQLErrorExtended } from 'postgraphile';
+import { Dict } from '../common';
+
+/**
+ * A GraphQLErrorExtended object with additional properties.
+ * This error is thrown by the GraphQL API and returned to the original requester.
+ */
+export declare type GraphQLErrorEnhanced = GraphQLErrorExtended & {
+  extensions: {
+    /** The timestamp when the error was raised */
+    timestamp: string;
+  };
+  //TODO: remove backwards compatibility after 01-11-2023
+  timestamp: string;
+  code: string;
+  details?: Dict<unknown>;
+};
+
+export const GeneralGraphQlErrorCode = 'GENERAL_GRAPHQL_ERROR';
+
+/**
+ * Contains data about the failed GraphQL request without exposing passed variables, since they can contain sensitive values.
+ */
+export interface GraphQlOperation {
+  /**
+   * Type of operation, e.g. query, mutation or subscription.
+   */
+  operationType?: OperationTypeNode;
+  /**
+   * Name of operation, if defined.
+   */
+  operationName?: string;
+  /**
+   * List of root endpoints, since a single operation can perform multiple queries/mutations.
+   */
+  rootEndpoints?: string[];
+}
+
+const basicErrorMapper = (
+  error: GraphQLError,
+  operationName?: string,
+): GraphQLErrorEnhanced => {
+  return {
+    ...error,
+    message: error.message ?? 'No error description was provided',
+    extensions: {
+      timestamp: new Date().toISOString(),
+      operationName,
+      exception: {
+        code: GeneralGraphQlErrorCode,
+      },
+    },
+    //TODO: remove backwards compatibility after 01-11-2023
+    timestamp: new Date().toISOString(),
+    code: GeneralGraphQlErrorCode,
+    details: undefined,
+  };
+};
+
+const getGraphQlOperations = (
+  requestBody: string,
+): GraphQlOperation[] | undefined => {
+  try {
+    const parsedGqlRequest = parse(requestBody);
+    return (parsedGqlRequest.definitions as OperationDefinitionNode[]).map(
+      (op) => ({
+        name: op.name?.value ?? 'NO_OPERATION_NAME',
+        operation: op.operation,
+        rootEndpoints: op.selectionSet.selections.map(
+          (selection) => (selection as FieldNode).name.value,
+        ),
+      }),
+    );
+  } catch {
+    // Unable to parse the GraphQL request string.
+    return undefined;
+  }
+};
+
+/**
+ * Default graphql error handler. Extracts information to return as an error response (timestamp, message, code and path parameters) and logs error and response information using provided logger.
+ *
+ * @param errors - Array of original graphql errors
+ * @param operationName - The operation name that was executed in case the request contained more than one operation. Found in `req.body.operationName`.
+ * @param customizeFields - Override error fields message, exception code, and add extensions fields with your custom values. Extension fields are added to the extensions object and cannot use existing field names.
+ * @param log - allows you to log the error with parts of the GraphQL request data
+ */
+export const enhanceGraphqlErrors = (
+  errors: readonly GraphQLError[],
+  operationName?: string,
+  customizeFields?: (
+    error: GraphQLError,
+    originalError?: Error | null,
+  ) =>
+    | {
+        message?: string;
+        code?: string;
+        extensions?: Dict<unknown>;
+      }
+    | undefined,
+  log?: (error: GraphQLErrorEnhanced, operations?: GraphQlOperation[]) => void,
+): GraphQLErrorEnhanced[] => {
+  return errors.map((error) => {
+    const enhancedError = basicErrorMapper(error, operationName);
+
+    if (customizeFields) {
+      const custom = customizeFields(error, error.originalError);
+      enhancedError.message = custom?.message ?? enhancedError.message;
+      enhancedError.extensions = {
+        ...custom?.extensions,
+        ...enhancedError.extensions,
+      };
+      enhancedError.extensions.exception.code =
+        custom?.code ?? enhancedError.extensions.exception.code;
+
+      //TODO: remove backwards compatibility after 01-11-2023
+      enhancedError.code = enhancedError.extensions.exception.code;
+      enhancedError.details = custom?.extensions;
+    }
+
+    if (log) {
+      const originalError = error.originalError as Error & { source: Source };
+      const request = error.source?.body || originalError?.source?.body;
+      const graphQlOperations = getGraphQlOperations(request);
+      log(enhancedError, graphQlOperations);
+    }
+
+    return enhancedError;
+  });
+};

package/src/postgraphile/index.ts

@@ -0,0 +1,3 @@
+export * from './enhance-graphql-errors';
+export * from './postgraphile-options-builder';
+export * from './websocket-utils';