@-xun/project/dist/packages/common/src/error.js

A library to help me wrangle the complex landscape between monorepos and polyrepos

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.XPackageJsonNotParsableError = exports.ProjectError = exports.NotAGitRepositoryError = exports.DuplicatePackageNameError = exports.DuplicatePackageIdError = exports.CommonErrorMessage = void 0;
exports.isDuplicatePackageIdError = isDuplicatePackageIdError;
exports.isDuplicatePackageNameError = isDuplicatePackageNameError;
exports.isNotAGitRepositoryError = isNotAGitRepositoryError;
exports.isProjectError = isProjectError;
exports.isXPackageJsonNotParsableError = isXPackageJsonNotParsableError;
var _types = require("node:util/types");
var _namedAppErrors = require("named-app-errors");
const $type = Symbol.for('object-type-hint');
const $type_ProjectError = Symbol.for('object-type-hint:ProjectError');
const $type_NotAGitRepositoryError = Symbol.for('object-type-hint:NotAGitRepositoryError');
const $type_XPackageJsonNotParsableError = Symbol.for('object-type-hint:XPackageJsonNotParsableError');
const $type_DuplicatePackageNameError = Symbol.for('object-type-hint:DuplicatePackageNameError');
const $type_DuplicatePackageIdError = Symbol.for('object-type-hint:DuplicatePackageIdError');
function isProjectError(parameter) {
  return (0, _types.isNativeError)(parameter) && $type in parameter && Array.isArray(parameter[$type]) && parameter[$type].includes($type_ProjectError);
}
function isNotAGitRepositoryError(parameter) {
  return isProjectError(parameter) && parameter[$type].includes($type_NotAGitRepositoryError);
}
function isXPackageJsonNotParsableError(parameter) {
  return isProjectError(parameter) && parameter[$type].includes($type_XPackageJsonNotParsableError);
}
function isDuplicatePackageNameError(parameter) {
  return isProjectError(parameter) && parameter[$type].includes($type_DuplicatePackageNameError);
}
function isDuplicatePackageIdError(parameter) {
  return isProjectError(parameter) && parameter[$type].includes($type_DuplicatePackageIdError);
}
class ProjectError extends Error {
  [$type] = [$type_ProjectError];
  constructor(reason, options = {}, message = undefined, superOptions = {}) {
    let {
      cause
    } = options;
    message = message ?? (typeof reason === 'string' ? reason : reason?.message) ?? CommonErrorMessage.Generic();
    if (!('cause' in options)) {
      cause = typeof reason === 'string' ? undefined : reason;
    }
    super(message, {
      cause,
      ...superOptions
    });
  }
}
exports.ProjectError = ProjectError;
(0, _namedAppErrors.makeNamedError)(ProjectError, 'ProjectError');
class NotAGitRepositoryError extends ProjectError {
  [$type] = [$type_NotAGitRepositoryError, $type_ProjectError];
  constructor(message = undefined) {
    super(message ?? CommonErrorMessage.NotAGitRepositoryError());
  }
}
exports.NotAGitRepositoryError = NotAGitRepositoryError;
(0, _namedAppErrors.makeNamedError)(NotAGitRepositoryError, 'NotAGitRepositoryError');
class XPackageJsonNotParsableError extends ProjectError {
  [$type] = [$type_XPackageJsonNotParsableError, $type_ProjectError];
  constructor(packageJsonPath, reason, message = undefined) {
    super(message ?? CommonErrorMessage.PackageJsonNotParsable(packageJsonPath, reason));
    this.packageJsonPath = packageJsonPath;
    this.reason = reason;
  }
}
exports.XPackageJsonNotParsableError = XPackageJsonNotParsableError;
(0, _namedAppErrors.makeNamedError)(XPackageJsonNotParsableError, 'XPackageJsonNotParsableError');
class DuplicatePackageNameError extends ProjectError {
  [$type] = [$type_DuplicatePackageNameError, $type_ProjectError];
  constructor(packageName, firstPath, secondPath, message = undefined) {
    super(message ?? CommonErrorMessage.DuplicatePackageName(packageName, firstPath, secondPath));
    this.packageName = packageName;
    this.firstPath = firstPath;
    this.secondPath = secondPath;
  }
}
exports.DuplicatePackageNameError = DuplicatePackageNameError;
(0, _namedAppErrors.makeNamedError)(DuplicatePackageNameError, 'DuplicatePackageNameError');
class DuplicatePackageIdError extends ProjectError {
  [$type] = [$type_DuplicatePackageIdError, $type_ProjectError];
  constructor(id, firstPath, secondPath, message = undefined) {
    super(message ?? CommonErrorMessage.DuplicatePackageId(id, firstPath, secondPath));
    this.id = id;
    this.firstPath = firstPath;
    this.secondPath = secondPath;
  }
}
exports.DuplicatePackageIdError = DuplicatePackageIdError;
(0, _namedAppErrors.makeNamedError)(DuplicatePackageIdError, 'DuplicatePackageIdError');
const CommonErrorMessage = exports.CommonErrorMessage = {
  Generic() {
    return 'an error occurred that caused this software to crash';
  },
  GuruMeditation() {
    return 'an impossible scenario occurred';
  },
  NotAGitRepositoryError() {
    return 'unable to locate git repository root';
  },
  PackageJsonNotParsable(packageJsonPath, reason) {
    return `unable to parse ${packageJsonPath}: ${(0, _types.isNativeError)(reason) ? reason.message : String(reason)}`;
  },
  DuplicatePackageName(packageName, firstPath, secondPath) {
    return `the following packages must not have the same name "${packageName}":\n` + `  ${firstPath}\n` + `  ${secondPath}`;
  },
  DuplicatePackageId(id, firstPath, secondPath) {
    return `the following unnamed packages must not have the same package-id "${id}":\n` + `  ${firstPath}\n` + `  ${secondPath}`;
  }
};