@powership/server/out/graphql/errorHandler.cjs

Powership server

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.defaultHandler = exports.Processed = void 0;
exports.maskErrors = maskErrors;
exports.setDefaultHandler = setDefaultHandler;
var _utils = require("@powership/utils");
var _graphql = require("graphql");
var _BaseRequestHandler = require("../BaseRequestHandler.cjs");
// Mark field/type/schema
const Processed = exports.Processed = Symbol();

// Modifies errors before sending to the user
let defaultHandler = function (err) {
  if ((0, _BaseRequestHandler.isHttpError)(err)) {
    return err;
  }
  const errId = `gql#${(0, _utils.ulid)()}`;
  err.message = `${err.message}: ${errId}`;
  console.error(err && err.stack || err);
  err.message = `Internal Error: ${errId}`;
  return err;
};

// Changes the default error handler function
exports.defaultHandler = defaultHandler;
function setDefaultHandler(handlerFn) {
  exports.defaultHandler = defaultHandler = handlerFn;
}

// Masks graphql schemas, types or individual fields
function maskErrors(thing, fn = defaultHandler) {
  if (thing instanceof _graphql.GraphQLSchema) {
    maskSchema(thing, fn);
  } else if (thing instanceof _graphql.GraphQLObjectType) {
    maskType(thing, fn);
  } else {
    maskField(thing, fn);
  }
}
function maskField(field, fn) {
  const resolveFn = field.resolve;
  if (field[Processed] || !resolveFn) {
    return;
  }
  field[Processed] = true;
  field.resolve = async function (...args) {
    try {
      const out = resolveFn.call(this, ...args);
      return await Promise.resolve(out);
    } catch (e) {
      throw fn(e, args);
    }
  };

  // save the original resolve function
  field.resolve._resolveFn = resolveFn;
}
function maskType(type, fn) {
  if (type[Processed] || !type.getFields) {
    return;
  }
  const fields = type.getFields();
  for (const fieldName in fields) {
    if (!Object.hasOwnProperty.call(fields, fieldName)) {
      continue;
    }
    maskField(fields[fieldName], fn);
  }
}
function maskSchema(schema, fn) {
  const types = schema.getTypeMap();
  for (const typeName in types) {
    if (!Object.hasOwnProperty.call(types, typeName)) {
      continue;
    }
    maskType(types[typeName], fn);
  }
}
//# sourceMappingURL=errorHandler.cjs.map