@smbcheeky/error-object-from-payload 1.1.5

package/dist/index.mjs

@@ -0,0 +1,573 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// src/index.ts
+import { ErrorObject as ErrorObject2 } from "@smbcheeky/error-object";
+
+// src/builder/index.ts
+import { ErrorObject } from "@smbcheeky/error-object";
+
+// src/utils.ts
+var addPrefixPathVariants = (prefix, array) => {
+  if (typeof prefix === "string") {
+    return array.concat(
+      array.map((s) => typeof s === "string" ? `${prefix}.${s}` : s)
+    );
+  }
+  if (Array.isArray(prefix) && prefix.length > 0 && typeof (prefix == null ? void 0 : prefix[0]) === "string") {
+    const result = [...array];
+    for (const p of prefix) {
+      const temp = array.map((s) => typeof s === "string" ? `${p}.${s}` : s);
+      result.push(...temp);
+    }
+    return result;
+  }
+  return array;
+};
+var DEFAULT_BUILD_OPTIONS = {
+  pathToErrors: ["errors", "errs"],
+  pathToCode: addPrefixPathVariants("error", [
+    "code",
+    "err_code",
+    "errorCode",
+    "error_code"
+  ]),
+  pathToNumberCode: addPrefixPathVariants("error", [
+    "numberCode",
+    "err_number_code",
+    "errorNumberCode",
+    "error_number_code"
+  ]),
+  pathToMessage: addPrefixPathVariants("error", [
+    "message",
+    "err_message",
+    "errorMessage",
+    "error_message"
+  ]),
+  pathToDetails: addPrefixPathVariants("error", [
+    "details",
+    "err_details",
+    "errorDetails",
+    "error_details"
+  ]),
+  pathToDomain: addPrefixPathVariants("error", [
+    "domain",
+    "errorDomain",
+    "error_domain",
+    "err_domain",
+    "type"
+  ]),
+  transform: (beforeTransform) => {
+    let newCode = beforeTransform.code;
+    if (beforeTransform.code === void 0 || beforeTransform.code === null) {
+      const value = beforeTransform.numberCode;
+      if (value !== void 0 && value !== null) {
+        newCode = value.toString();
+      }
+    }
+    return __spreadProps(__spreadValues({}, beforeTransform), {
+      code: newCode
+    });
+  }
+};
+
+// src/builder/valuesFromPaths.ts
+var __processAllValuesFromPaths = (objectToParse, options) => {
+  let codeBeforeTransform;
+  let codePath;
+  if (!("pathToCode" in options)) {
+    return "pathToCodeIsInvalid";
+  }
+  if (!Array.isArray(options.pathToCode)) {
+    return "pathToCodeIsNotAnArray";
+  }
+  for (const path of options.pathToCode) {
+    if (typeof path !== "string") {
+      return "pathToCodeValuesAreNotStrings";
+    }
+    const found = findNestedValueForPath(objectToParse, path);
+    if (found !== void 0 && found !== null) {
+      if (typeof found === "string") {
+        codePath = path;
+        codeBeforeTransform = found;
+        break;
+      }
+      if (Array.isArray(found) || typeof found === "object") {
+        codePath = path;
+        codeBeforeTransform = JSON.stringify(found);
+        break;
+      }
+    }
+  }
+  let numberCodeBeforeTransform;
+  let numberCodePath;
+  if (!("pathToNumberCode" in options)) {
+    return "pathToNumberCodeIsInvalid";
+  }
+  if (!Array.isArray(options.pathToNumberCode)) {
+    return "pathToNumberCodeIsNotAnArray";
+  }
+  for (const path of options.pathToNumberCode) {
+    if (typeof path !== "string") {
+      return "pathToNumberCodeValuesAreNotStrings";
+    }
+    const found = findNestedValueForPath(objectToParse, path);
+    if (found !== void 0 && found !== null && typeof found === "number" && !isNaN(found)) {
+      numberCodePath = path;
+      numberCodeBeforeTransform = found;
+      break;
+    }
+  }
+  let messageBeforeTransform;
+  let messagePath;
+  if (!("pathToMessage" in options)) {
+    return "pathToMessageIsInvalid";
+  }
+  if (!Array.isArray(options.pathToMessage)) {
+    return "pathToMessageIsNotAnArray";
+  }
+  for (const path of options.pathToMessage) {
+    if (typeof path !== "string") {
+      return "pathToMessageValuesAreNotStrings";
+    }
+    const found = findNestedValueForPath(objectToParse, path);
+    if (found !== void 0 && found !== null) {
+      if (typeof found === "string") {
+        messagePath = path;
+        messageBeforeTransform = found;
+        break;
+      }
+      if (Array.isArray(found) || typeof found === "object") {
+        messagePath = path;
+        messageBeforeTransform = JSON.stringify(found);
+        break;
+      }
+    }
+  }
+  let detailsBeforeTransform;
+  let detailsPath;
+  if (!("pathToDetails" in options)) {
+    return "pathToDetailsIsInvalid";
+  }
+  if (!Array.isArray(options.pathToDetails)) {
+    return "pathToDetailsIsNotAnArray";
+  }
+  for (const path of options.pathToDetails) {
+    if (typeof path !== "string") {
+      return "pathToDetailsValuesAreNotStrings";
+    }
+    const found = findNestedValueForPath(objectToParse, path);
+    if (found !== void 0 && found !== null) {
+      if (typeof found === "string") {
+        detailsPath = path;
+        detailsBeforeTransform = found;
+        break;
+      }
+      if (Array.isArray(found) || typeof found === "object") {
+        detailsPath = path;
+        detailsBeforeTransform = JSON.stringify(found);
+        break;
+      }
+    }
+  }
+  let domainBeforeTransform;
+  let domainPath;
+  if (!("pathToDomain" in options)) {
+    return "pathToDomainIsInvalid";
+  }
+  if (!Array.isArray(options.pathToDomain)) {
+    return "pathToDomainIsNotAnArray";
+  }
+  for (const path of options.pathToDomain) {
+    if (typeof path !== "string") {
+      return "pathToDomainValuesAreNotStrings";
+    }
+    const found = findNestedValueForPath(objectToParse, path);
+    if (found !== void 0 && found !== null) {
+      if (typeof found === "string") {
+        domainPath = path;
+        domainBeforeTransform = found;
+        break;
+      }
+      if (Array.isArray(found) || typeof found === "object") {
+        domainPath = path;
+        domainBeforeTransform = JSON.stringify(found);
+        break;
+      }
+    }
+  }
+  return {
+    codeBeforeTransform,
+    codePath,
+    numberCodeBeforeTransform,
+    numberCodePath,
+    messageBeforeTransform,
+    messagePath,
+    detailsBeforeTransform,
+    detailsPath,
+    domainBeforeTransform,
+    domainPath
+  };
+};
+
+// src/builder/index.ts
+var buildSummariesFromObject = (input, withOptions) => {
+  try {
+    const options = withOptions != null ? withOptions : __spreadValues({}, DEFAULT_BUILD_OPTIONS);
+    if (input === void 0 || input === null) {
+      return ["isNullish"];
+    }
+    if (typeof input !== "object") {
+      return ["isNotAnObject"];
+    }
+    let errors = [];
+    let errorsPath;
+    let didDetectErrorsArray = false;
+    if ("pathToErrors" in options) {
+      if (!Array.isArray(options.pathToErrors)) {
+        return ["pathToErrorsIsNotAnArray"];
+      }
+      for (const path of options.pathToErrors) {
+        if (typeof path !== "string") {
+          return ["pathToErrorsValuesAreNotStrings"];
+        }
+        const found = findNestedValueForPath(input, path);
+        if (found && Array.isArray(found)) {
+          errors = found;
+          errorsPath = path;
+          didDetectErrorsArray = true;
+          break;
+        }
+      }
+    }
+    if (errors.length === 0) {
+      errors = [input];
+    }
+    let summaries = [];
+    for (const errorMaybeObject of errors) {
+      const summary = buildSummaryFromObject(
+        errorMaybeObject,
+        errorsPath,
+        didDetectErrorsArray,
+        options
+      );
+      summaries.push(summary);
+    }
+    return summaries;
+  } catch (generalError) {
+    ErrorObject.SHOW_ERROR_LOGS && console.log(
+      "[ErrorObject]",
+      "Error during buildSummariesFromObject():",
+      generalError
+    );
+    return ["generalBuildSummariesFromObjectError"];
+  }
+};
+var buildSummaryFromObject = (maybeObject, errorsPath, didDetectErrorsArray, withOptions) => {
+  try {
+    const options = withOptions != null ? withOptions : __spreadValues({}, DEFAULT_BUILD_OPTIONS);
+    if (maybeObject === void 0 || maybeObject === null) {
+      return "buildSummaryIsNullish";
+    }
+    let objectToParse;
+    if (typeof maybeObject === "string") {
+      try {
+        const json = JSON.parse(maybeObject);
+        if (json !== void 0 && json !== null && typeof json === "object") {
+          objectToParse = json;
+        }
+      } catch (e) {
+      }
+      if (objectToParse === maybeObject) {
+        objectToParse = { code: "unknown", message: maybeObject };
+      }
+    }
+    if (objectToParse === void 0 || objectToParse === null) {
+      objectToParse = maybeObject;
+    }
+    if (typeof objectToParse !== "object") {
+      return "buildSummaryIsNotAnObject";
+    }
+    const valuesResult = __processAllValuesFromPaths(objectToParse, options);
+    if (typeof valuesResult === "string") {
+      return valuesResult;
+    }
+    const {
+      codeBeforeTransform,
+      codePath,
+      numberCodeBeforeTransform,
+      numberCodePath,
+      messageBeforeTransform,
+      messagePath,
+      detailsBeforeTransform,
+      detailsPath,
+      domainBeforeTransform,
+      domainPath
+    } = valuesResult;
+    if ("transform" in options && typeof options.transform !== "function") {
+      return "transformIsNotAFunction";
+    }
+    const beforeTransform = {
+      code: codeBeforeTransform,
+      numberCode: numberCodeBeforeTransform,
+      message: messageBeforeTransform,
+      details: detailsBeforeTransform,
+      domain: domainBeforeTransform
+    };
+    const values = options.transform ? options.transform(beforeTransform, objectToParse) : beforeTransform;
+    if (values === void 0 || values === null || typeof values !== "object") {
+      return "transformResultIsNotAValidObject";
+    }
+    if (values.code && typeof values.code !== "string") {
+      return "transformCodeResultIsNotString";
+    }
+    if (values.numberCode !== void 0 && values.numberCode !== null && typeof values.numberCode !== "number") {
+      return "transformNumberCodeResultIsNotNumber";
+    }
+    if (values.numberCode !== void 0 && values.numberCode !== null && isNaN(values.numberCode)) {
+      return "transformNumberCodeResultIsNaN";
+    }
+    if (values.message && typeof values.message !== "string") {
+      return "transformMessageResultIsNotString";
+    }
+    if (values.details && typeof values.details !== "string") {
+      return "transformDetailsResultIsNotString";
+    }
+    if (values.domain && typeof values.domain !== "string") {
+      return "transformDomainResultIsNotString";
+    }
+    return {
+      didDetectErrorsArray: didDetectErrorsArray ? true : void 0,
+      input: objectToParse,
+      path: errorsPath,
+      value: {
+        code: codePath || codeBeforeTransform || values.code ? {
+          path: codePath,
+          beforeTransform: codeBeforeTransform,
+          value: values.code
+        } : void 0,
+        numberCode: numberCodePath || numberCodeBeforeTransform !== void 0 && numberCodeBeforeTransform !== null || values.numberCode !== void 0 && values.numberCode !== null ? {
+          path: numberCodePath,
+          beforeTransform: numberCodeBeforeTransform,
+          value: values.numberCode
+        } : void 0,
+        message: messagePath || messageBeforeTransform || values.message ? {
+          path: messagePath,
+          beforeTransform: messageBeforeTransform,
+          value: values.message
+        } : void 0,
+        details: detailsPath || detailsBeforeTransform || values.details ? {
+          path: detailsPath,
+          beforeTransform: detailsBeforeTransform,
+          value: values.details
+        } : void 0,
+        domain: domainPath || domainBeforeTransform || values.domain ? {
+          path: domainPath,
+          beforeTransform: domainBeforeTransform,
+          value: values.domain
+        } : void 0
+      }
+    };
+  } catch (generalError) {
+    ErrorObject.SHOW_ERROR_LOGS && console.log(
+      "[ErrorObject]",
+      "Error during buildSummaryFromObject():",
+      generalError
+    );
+    return "generalBuildSummaryFromObjectError";
+  }
+};
+var findNestedValueForPath = (value, path) => {
+  var _a;
+  if (!path || !value) {
+    return void 0;
+  }
+  const normalizedPath = (_a = path == null ? void 0 : path.replace("[", "")) == null ? void 0 : _a.replace("]", "");
+  return !normalizedPath ? void 0 : normalizedPath.split(".").reduce((acc, key) => {
+    if (key.length === 0) {
+      return acc;
+    }
+    const numericKey = Number(key);
+    const resolvedKey = isNaN(numericKey) ? key : numericKey;
+    return acc && typeof acc === "object" ? acc[resolvedKey] : void 0;
+  }, value);
+};
+
+// src/index.ts
+var checkInputForInitialObject = (input, withOptions) => {
+  try {
+    const options = withOptions != null ? withOptions : __spreadValues({}, DEFAULT_BUILD_OPTIONS);
+    if (input === void 0 || input === null) {
+      return "checkIsNullish";
+    }
+    if (typeof input !== "object") {
+      return "checkIsNotAnObject";
+    }
+    if ("checkInputObjectForValues" in options) {
+      if (typeof options.checkInputObjectForValues !== "object") {
+        return "checkInputObjectForValuesIsNotAnObject";
+      }
+      const checkInputObjectForValues = Object.entries(
+        options.checkInputObjectForValues
+      );
+      for (const [key, rule] of checkInputObjectForValues) {
+        const foundValue = findNestedValueForPath(input, key);
+        if (rule.exists ? foundValue !== rule.value : foundValue === rule.value) {
+          return "checkInputObjectForValuesFailed";
+        }
+      }
+    }
+    if ("checkInputObjectForTypes" in options) {
+      if (typeof options.checkInputObjectForTypes !== "object") {
+        return "checkInputObjectForTypesIsNotAnObject";
+      }
+      const checkInputObjectForTypes = Object.entries(
+        options.checkInputObjectForTypes
+      );
+      for (const [key, rule] of checkInputObjectForTypes) {
+        const foundValue = findNestedValueForPath(input, key);
+        if (rule.valueIsArray) {
+          if (rule.exists ? !Array.isArray(foundValue) : Array.isArray(foundValue)) {
+            return "checkInputObjectForTypesValueIsArrayFailed";
+          }
+        }
+        if (rule.exists ? typeof foundValue !== rule.type : typeof foundValue === rule.type) {
+          return "checkInputObjectForTypesFailed";
+        }
+      }
+    }
+    if ("checkInputObjectForKeys" in options) {
+      if (typeof options.checkInputObjectForKeys !== "object") {
+        return "checkInputObjectForKeysIsNotAnObject";
+      }
+      const checkInputObjectForKeys = Object.entries(
+        options.checkInputObjectForKeys
+      );
+      for (const [key, rule] of checkInputObjectForKeys) {
+        const foundValue = findNestedValueForPath(input, key);
+        if (rule.exists ? !foundValue : foundValue) {
+          return "checkInputObjectForKeysFailed";
+        }
+      }
+    }
+  } catch (error) {
+    ErrorObject2.SHOW_ERROR_LOGS && console.log(
+      "[ErrorObject]",
+      "Error during checkInputForInitialObject():",
+      error
+    );
+  }
+  return void 0;
+};
+var processErrorObjectResult = (summaries, raw, fallbackError) => {
+  const processingErrors = [];
+  try {
+    const validErrors = summaries.filter((summary) => {
+      var _a, _b;
+      if (typeof summary === "string") {
+        processingErrors.push({ errorCode: summary, summary: void 0 });
+        return false;
+      }
+      if (typeof summary !== "object") {
+        processingErrors.push({
+          errorCode: "invalidSummary",
+          summary: void 0
+        });
+        return false;
+      }
+      const code = (_a = summary.value.code) == null ? void 0 : _a.value;
+      const message = (_b = summary.value.message) == null ? void 0 : _b.value;
+      if (code !== void 0 && code !== null && typeof code === "string") {
+        if (message !== void 0 && message !== null && typeof message === "string") {
+          return true;
+        }
+      }
+      processingErrors.push({ errorCode: "unknownCodeOrMessage", summary });
+      return false;
+    }).map((s) => {
+      var _a, _b, _c, _d, _e;
+      const summary = s;
+      const code = (_a = summary.value.code) == null ? void 0 : _a.value;
+      const numberCode = (_b = summary.value.numberCode) == null ? void 0 : _b.value;
+      const message = (_c = summary.value.message) == null ? void 0 : _c.value;
+      const details = (_d = summary.value.details) == null ? void 0 : _d.value;
+      const domain = (_e = summary.value.domain) == null ? void 0 : _e.value;
+      if (code !== void 0 && code !== null && typeof code === "string") {
+        if (message !== void 0 && message !== null && typeof message === "string") {
+          return new ErrorObject2({
+            code,
+            message,
+            numberCode,
+            details,
+            domain,
+            summary,
+            processingErrors
+          });
+        }
+      }
+      return null;
+    }).filter(
+      (s) => s !== null && s !== void 0 && s instanceof ErrorObject2
+    );
+    if (validErrors.length > 0) {
+      const [firstError, ...nextErrors] = validErrors;
+      const error = firstError.setNextErrors((nextErrors == null ? void 0 : nextErrors.length) > 0 ? nextErrors : void 0).setRaw(raw);
+      return {
+        error,
+        force: error != null ? error : fallbackError.setProcessingErrors(processingErrors)
+      };
+    }
+  } catch (error) {
+    ErrorObject2.SHOW_ERROR_LOGS && console.log(
+      "[ErrorObject]",
+      "Error during processErrorObjectResult():",
+      error
+    );
+  }
+  return {
+    error: void 0,
+    force: processingErrors.length > 0 ? fallbackError.setProcessingErrors(processingErrors) : fallbackError
+  };
+};
+var fromPayload = (value, withOptions) => {
+  const options = __spreadValues(__spreadValues({}, DEFAULT_BUILD_OPTIONS), withOptions != null ? withOptions : {});
+  const fallbackError = ErrorObject2.fallback().setRaw(value);
+  const checksFailed = checkInputForInitialObject(value, options);
+  if (checksFailed !== void 0) {
+    return {
+      error: void 0,
+      force: fallbackError.setProcessingErrors([
+        { errorCode: checksFailed, summary: void 0 }
+      ])
+    };
+  }
+  let summaries;
+  if ("pathToErrors" in options) {
+    summaries = buildSummariesFromObject(value, options);
+  } else {
+    summaries = [buildSummaryFromObject(value, void 0, false, options)];
+  }
+  return processErrorObjectResult(summaries, value, fallbackError);
+};
+export {
+  DEFAULT_BUILD_OPTIONS,
+  addPrefixPathVariants,
+  fromPayload
+};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@smbcheeky/error-object-from-payload",
+  "description": "Create ErrorObjects from any payload with simple rules and benefit from step-to-step debugging logs for the entire process.",
+  "version": "1.1.5",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "pack": "yarn build && npm pack",
+    "release": "yarn build && npm publish --access public",
+    "lint": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@smbcheeky/error-object": "^1.1.4"
+  },
+  "devDependencies": {
+    "tsup": "^6.5.0",
+    "typescript": "^4.9.4"
+  },
+  "license": "MIT",
+  "private": false,
+  "homepage": "https://www.npmjs.com/~stefan-at-smb",
+  "author": {
+    "name": "Stefan B.",
+    "email": "stefan@smbcheeky.com",
+    "url": "https://www.npmjs.com/~stefan-at-smb"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SMBCheeky/error-object-from-payload.git"
+  },
+  "bugs": {
+    "url": "https://github.com/SMBCheeky/error-object-from-payload/issues"
+  },
+  "keywords": [
+    "exceptions",
+    "errors",
+    "handling",
+    "try",
+    "throw",
+    "catch",
+    "caught",
+    "instanceof",
+    "debug",
+    "neverthrow",
+    "result",
+    "ok"
+  ],
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE",
+    "package.json"
+  ]
+}