@blamejs/core 0.4.1

package/lib/forms.js

@@ -0,0 +1,378 @@
+"use strict";
+/**
+ * Forms — CSRF tokens, HTML rendering, server-side validation.
+ *
+ * Three concerns the framework owns at the form layer:
+ *
+ *   1. CSRF tokens. Generation is a 32-byte random hex string;
+ *      verification is constant-time. The middleware in
+ *      lib/middleware/csrf-protect.js does the actual gating —
+ *      this module provides the primitives the operator (or
+ *      template) calls to issue a token and embed it.
+ *
+ *   2. Form HTML rendering. forms.render({ action, fields, csrfToken })
+ *      produces a complete <form> element with auto-escaped attributes,
+ *      a hidden CSRF input, and field-type dispatch (text / email /
+ *      password / number / checkbox / radio / textarea / select /
+ *      hidden / submit). All values pass through escapeAttribute so
+ *      the form can't be hijacked by user-supplied attribute payloads.
+ *
+ *   3. Server-side validation. forms.validate(spec, body) walks the
+ *      same field spec the renderer accepts and returns
+ *      { valid, errors, values } — coerced types, required-field
+ *      checks, length bounds, regex pattern, enum membership.
+ *
+ * The renderer + validator share their field spec on purpose: an
+ * operator's "this is what the form looks like" is also "this is
+ * what the form expects." A change to the spec adjusts both.
+ *
+ * Public API:
+ *
+ *   forms.generateCsrfToken()          → "<64 hex chars>"
+ *   forms.verifyCsrfToken(submitted, expected) → boolean (timing-safe)
+ *   forms.render(spec)                 → string (complete <form>…</form>)
+ *   forms.validate(spec, body)         → { valid, errors, values }
+ *   forms.escapeAttribute(value)       → string (double-quoted-attr context)
+ *   forms.escapeHtml = template.escapeHtml (re-export for convenience)
+ */
+var nodeCrypto = require("crypto");
+var template = require("./template");
+
+// ============================================================
+// CSRF token primitives
+// ============================================================
+
+var CSRF_TOKEN_BYTES = 32;
+
+function generateCsrfToken() {
+  return nodeCrypto.randomBytes(CSRF_TOKEN_BYTES).toString("hex");
+}
+
+function verifyCsrfToken(submitted, expected) {
+  if (typeof submitted !== "string" || typeof expected !== "string") return false;
+  if (submitted.length === 0 || submitted.length !== expected.length) return false;
+  var a = Buffer.from(submitted, "utf8");
+  var b = Buffer.from(expected, "utf8");
+  if (a.length !== b.length) return false;
+  return nodeCrypto.timingSafeEqual(a, b);
+}
+
+// ============================================================
+// Attribute escaping
+// ============================================================
+//
+// More strict than template.escapeHtml: escapes the same set plus
+// backtick (some browsers treat ` as an attribute delimiter under
+// quirks-mode parsing) and = (defense-in-depth for unquoted-attribute
+// contexts the renderer happens to produce). Forms render attributes
+// in double-quoted contexts only, so this is belt-and-suspenders.
+
+var ATTR_ESCAPE_MAP = {
+  "&": "&amp;", "<": "&lt;", ">": "&gt;",
+  '"': "&quot;", "'": "&#x27;",
+  "`": "&#x60;", "=": "&#x3D;",
+};
+var ATTR_ESCAPE_RE = /[&<>"'`=]/g;
+
+function escapeAttribute(value) {
+  if (value === null || value === undefined) return "";
+  var s = typeof value === "string" ? value : String(value);
+  return s.replace(ATTR_ESCAPE_RE, function (c) { return ATTR_ESCAPE_MAP[c]; });
+}
+
+// ============================================================
+// Form rendering
+// ============================================================
+//
+// spec = {
+//   action:       string                      — form action URL (required)
+//   method:       "POST" (default) | "GET" | …
+//   csrfToken:    string                      — embedded as <input name="_csrf">
+//   csrfFieldName: string (default "_csrf")   — match what csrfProtect expects
+//   id, className: string                     — top-level form attributes
+//   fields:       FieldSpec[]
+//   submitLabel:  string (default "Submit")   — auto-appended submit button
+//                                                if no field of type=submit present
+//   enctype:      string                      — multipart/form-data etc.
+//   autocomplete: string                      — "off" / "on"
+// }
+//
+// FieldSpec common keys:
+//   name:     string (required)
+//   type:     "text" | "email" | "password" | "number" | "tel" | "url" |
+//             "search" | "date" | "time" | "datetime-local" | "checkbox" |
+//             "radio" | "textarea" | "select" | "hidden" | "submit"
+//   value:    initial value (auto-escaped)
+//   label:    string                            — wraps a <label>
+//   placeholder, required, readonly, disabled, autocomplete
+//   min, max, step, pattern, minlength, maxlength
+//   options:  [{ value, label, selected? }]     — for select / radio
+//   rows, cols                                  — for textarea
+
+var INPUT_TYPES = {
+  "text": 1, "email": 1, "password": 1, "number": 1, "tel": 1, "url": 1,
+  "search": 1, "date": 1, "time": 1, "datetime-local": 1, "month": 1, "week": 1,
+  "checkbox": 1, "radio": 1, "hidden": 1, "submit": 1, "color": 1,
+  "file": 1, "range": 1, "image": 1, "reset": 1, "button": 1,
+};
+
+function _renderInput(field) {
+  var attrs = [
+    'type="' + escapeAttribute(field.type) + '"',
+    'name="' + escapeAttribute(field.name) + '"',
+  ];
+  if (field.value !== undefined && field.value !== null) {
+    attrs.push('value="' + escapeAttribute(field.value) + '"');
+  }
+  if (field.placeholder)  attrs.push('placeholder="' + escapeAttribute(field.placeholder) + '"');
+  if (field.required)     attrs.push("required");
+  if (field.readonly)     attrs.push("readonly");
+  if (field.disabled)     attrs.push("disabled");
+  if (field.checked)      attrs.push("checked");
+  if (field.autocomplete) attrs.push('autocomplete="' + escapeAttribute(field.autocomplete) + '"');
+  if (field.pattern)      attrs.push('pattern="' + escapeAttribute(field.pattern) + '"');
+  if (field.min !== undefined)        attrs.push('min="' + escapeAttribute(field.min) + '"');
+  if (field.max !== undefined)        attrs.push('max="' + escapeAttribute(field.max) + '"');
+  if (field.step !== undefined)       attrs.push('step="' + escapeAttribute(field.step) + '"');
+  if (field.minlength !== undefined)  attrs.push('minlength="' + escapeAttribute(field.minlength) + '"');
+  if (field.maxlength !== undefined)  attrs.push('maxlength="' + escapeAttribute(field.maxlength) + '"');
+  if (field.id)           attrs.push('id="' + escapeAttribute(field.id) + '"');
+  if (field.className)    attrs.push('class="' + escapeAttribute(field.className) + '"');
+  return "<input " + attrs.join(" ") + ">";
+}
+
+function _renderTextarea(field) {
+  var attrs = ['name="' + escapeAttribute(field.name) + '"'];
+  if (field.placeholder)              attrs.push('placeholder="' + escapeAttribute(field.placeholder) + '"');
+  if (field.required)                 attrs.push("required");
+  if (field.readonly)                 attrs.push("readonly");
+  if (field.disabled)                 attrs.push("disabled");
+  if (field.rows !== undefined)       attrs.push('rows="' + escapeAttribute(field.rows) + '"');
+  if (field.cols !== undefined)       attrs.push('cols="' + escapeAttribute(field.cols) + '"');
+  if (field.minlength !== undefined)  attrs.push('minlength="' + escapeAttribute(field.minlength) + '"');
+  if (field.maxlength !== undefined)  attrs.push('maxlength="' + escapeAttribute(field.maxlength) + '"');
+  if (field.id)                       attrs.push('id="' + escapeAttribute(field.id) + '"');
+  if (field.className)                attrs.push('class="' + escapeAttribute(field.className) + '"');
+  var body = field.value !== undefined && field.value !== null ? template.escapeHtml(field.value) : "";
+  return "<textarea " + attrs.join(" ") + ">" + body + "</textarea>";
+}
+
+function _renderSelect(field) {
+  var attrs = ['name="' + escapeAttribute(field.name) + '"'];
+  if (field.required)  attrs.push("required");
+  if (field.disabled)  attrs.push("disabled");
+  if (field.multiple)  attrs.push("multiple");
+  if (field.id)        attrs.push('id="' + escapeAttribute(field.id) + '"');
+  if (field.className) attrs.push('class="' + escapeAttribute(field.className) + '"');
+  var options = field.options || [];
+  var optionsHtml = options.map(function (o) {
+    var optAttrs = ['value="' + escapeAttribute(o.value) + '"'];
+    var selected = (o.selected) || (field.value !== undefined && String(field.value) === String(o.value));
+    if (selected) optAttrs.push("selected");
+    if (o.disabled) optAttrs.push("disabled");
+    return "<option " + optAttrs.join(" ") + ">" + template.escapeHtml(o.label === undefined ? o.value : o.label) + "</option>";
+  }).join("");
+  return "<select " + attrs.join(" ") + ">" + optionsHtml + "</select>";
+}
+
+function _renderField(field) {
+  if (!field || !field.name || typeof field.name !== "string") {
+    throw new Error("forms.render: each field requires a name");
+  }
+  var type = field.type || "text";
+  var control;
+  if (type === "textarea") control = _renderTextarea(field);
+  else if (type === "select") control = _renderSelect(field);
+  else if (INPUT_TYPES[type])  control = _renderInput(field);
+  else throw new Error("forms.render: unsupported field type: " + type);
+
+  // Hidden + submit fields don't need a label wrapper
+  if (type === "hidden" || type === "submit") return control;
+
+  if (field.label) {
+    return "<label>" + template.escapeHtml(field.label) + " " + control + "</label>";
+  }
+  return control;
+}
+
+function render(spec) {
+  if (!spec || typeof spec.action !== "string" || spec.action.length === 0) {
+    throw new Error("forms.render: spec.action is required");
+  }
+  if (!Array.isArray(spec.fields)) {
+    throw new Error("forms.render: spec.fields must be an array");
+  }
+  var method = (spec.method || "POST").toUpperCase();
+  var attrs = [
+    'method="' + escapeAttribute(method) + '"',
+    'action="' + escapeAttribute(spec.action) + '"',
+  ];
+  if (spec.id)           attrs.push('id="' + escapeAttribute(spec.id) + '"');
+  if (spec.className)    attrs.push('class="' + escapeAttribute(spec.className) + '"');
+  if (spec.enctype)      attrs.push('enctype="' + escapeAttribute(spec.enctype) + '"');
+  if (spec.autocomplete) attrs.push('autocomplete="' + escapeAttribute(spec.autocomplete) + '"');
+  if (spec.target)       attrs.push('target="' + escapeAttribute(spec.target) + '"');
+
+  var inner = "";
+
+  // CSRF hidden input. State-changing methods need it; safe methods
+  // (GET/HEAD) don't. We still render it on POST etc. when csrfToken
+  // is provided; the middleware decides whether it's required.
+  if (spec.csrfToken && method !== "GET" && method !== "HEAD") {
+    var csrfFieldName = spec.csrfFieldName || "_csrf";
+    inner += '<input type="hidden" name="' + escapeAttribute(csrfFieldName) +
+             '" value="' + escapeAttribute(spec.csrfToken) + '">';
+  }
+
+  for (var i = 0; i < spec.fields.length; i++) {
+    inner += _renderField(spec.fields[i]);
+  }
+
+  // Auto-submit button if the operator didn't include one
+  var hasSubmit = spec.fields.some(function (f) { return f.type === "submit"; });
+  if (!hasSubmit) {
+    inner += '<button type="submit">' + template.escapeHtml(spec.submitLabel || "Submit") + "</button>";
+  }
+
+  return "<form " + attrs.join(" ") + ">" + inner + "</form>";
+}
+
+// ============================================================
+// Server-side validation
+// ============================================================
+//
+// validate(spec, body) → { valid, errors, values }
+//
+// errors is a map fieldName → message (only failing fields). values is
+// the coerced data: number/checkbox/etc. converted to their canonical
+// types. body is whatever the operator passes — typically an object
+// from URLSearchParams or JSON parse.
+
+function _coerce(field, raw) {
+  // Checkbox special-case: browsers omit unchecked boxes from the
+  // submission entirely, so `raw === undefined` means "unchecked"
+  // (false), not "not provided." Coerce to false BEFORE the generic
+  // undefined-passthrough below.
+  if (field.type === "checkbox") {
+    if (raw === undefined || raw === null || raw === "" || raw === "false" || raw === "0") return false;
+    return true;
+  }
+  if (raw === undefined) return undefined;
+  switch (field.type) {
+  case "number":
+  case "range":
+    if (raw === "" || raw === null) return null;
+    var n = Number(raw);
+    return Number.isFinite(n) ? n : NaN;
+  case "date":
+  case "datetime-local":
+  case "time":
+    return typeof raw === "string" ? raw : String(raw);
+  default:
+    return typeof raw === "string" ? raw : String(raw);
+  }
+}
+
+function _isEmpty(v) {
+  return v === undefined || v === null || v === "";
+}
+
+function validate(spec, body) {
+  if (!spec || !Array.isArray(spec.fields)) {
+    throw new Error("forms.validate: spec.fields must be an array");
+  }
+  body = body || {};
+  var errors = {};
+  var values = {};
+
+  for (var i = 0; i < spec.fields.length; i++) {
+    var f = spec.fields[i];
+    if (!f.name) continue;
+    if (f.type === "submit") continue;     // submit buttons aren't data
+
+    var raw = body[f.name];
+    var coerced = _coerce(f, raw);
+    values[f.name] = coerced;
+
+    if (f.required && _isEmpty(coerced) && coerced !== false) {
+      errors[f.name] = f.errorMessages && f.errorMessages.required
+        ? f.errorMessages.required
+        : (f.label || f.name) + " is required";
+      continue;
+    }
+    if (_isEmpty(coerced)) continue;
+
+    // Type-specific checks
+    if (f.type === "number" || f.type === "range") {
+      if (Number.isNaN(coerced)) {
+        errors[f.name] = (f.label || f.name) + " must be a number";
+        continue;
+      }
+      if (f.min !== undefined && coerced < Number(f.min)) {
+        errors[f.name] = (f.label || f.name) + " must be ≥ " + f.min;
+        continue;
+      }
+      if (f.max !== undefined && coerced > Number(f.max)) {
+        errors[f.name] = (f.label || f.name) + " must be ≤ " + f.max;
+        continue;
+      }
+    }
+    if (f.type === "email" && typeof coerced === "string") {
+      // Pragmatic email check — RFC 5322 is impractical to regex
+      // correctly; this catches obvious nonsense ("foo", "foo@",
+      // "@bar") without over-engineering.
+      if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(coerced)) {
+        errors[f.name] = (f.label || f.name) + " must be a valid email address";
+        continue;
+      }
+    }
+    if (f.type === "url" && typeof coerced === "string") {
+      try { new URL(coerced); }
+      catch (_e) { errors[f.name] = (f.label || f.name) + " must be a valid URL"; continue; }
+    }
+    if (typeof coerced === "string") {
+      if (f.minlength !== undefined && coerced.length < Number(f.minlength)) {
+        errors[f.name] = (f.label || f.name) + " must be at least " + f.minlength + " characters";
+        continue;
+      }
+      if (f.maxlength !== undefined && coerced.length > Number(f.maxlength)) {
+        errors[f.name] = (f.label || f.name) + " must be at most " + f.maxlength + " characters";
+        continue;
+      }
+      if (f.pattern) {
+        var re;
+        try { re = new RegExp("^(?:" + f.pattern + ")$"); }
+        catch (_e) { /* invalid pattern in spec — operator bug; skip */ continue; }
+        if (!re.test(coerced)) {
+          errors[f.name] = f.errorMessages && f.errorMessages.pattern
+            ? f.errorMessages.pattern
+            : (f.label || f.name) + " has an invalid format";
+          continue;
+        }
+      }
+    }
+    if ((f.type === "select" || f.type === "radio") && Array.isArray(f.options)) {
+      var allowed = f.options.map(function (o) { return String(o.value); });
+      if (allowed.indexOf(String(coerced)) === -1) {
+        errors[f.name] = (f.label || f.name) + " has an invalid value";
+        continue;
+      }
+    }
+  }
+
+  return {
+    valid:   Object.keys(errors).length === 0,
+    errors:  errors,
+    values:  values,
+  };
+}
+
+module.exports = {
+  generateCsrfToken:  generateCsrfToken,
+  verifyCsrfToken:    verifyCsrfToken,
+  render:             render,
+  validate:           validate,
+  escapeAttribute:    escapeAttribute,
+  escapeHtml:         template.escapeHtml,
+  CSRF_TOKEN_BYTES:   CSRF_TOKEN_BYTES,
+};

package/lib/framework-error.js

@@ -0,0 +1,189 @@
+"use strict";
+var observability = require("./observability");
+
+/**
+ * Framework error base class + cross-module operational error classes.
+ *
+ * Two scopes live here:
+ *
+ *   1. FrameworkError — base class every framework error class extends.
+ *      Provides a single `instanceof FrameworkError` check (replacing the
+ *      scattered `isXxxError` boolean flags) plus a stable shape: { name,
+ *      code, message, isFrameworkError: true }.
+ *
+ *   2. Cross-module operational error classes — errors raised by more
+ *      than one module that share a logical domain (e.g. ObjectStoreError
+ *      raised by the 5 object-store adapters + the umbrella). These can't
+ *      live in the umbrella module because adapters would need a circular
+ *      require to access them. They live here, where every adapter can
+ *      import from the same place.
+ *
+ *   3. defineClass(name, opts) — factory that produces a FrameworkError
+ *      subclass with the standard shape. Eliminates the boilerplate that
+ *      every per-domain error class was duplicating across lib/.
+ *
+ * Per-domain VALIDATION errors (SafeSqlError, SafeJsonError, SafeBufferError,
+ * SafeAsyncError, AtomicFileError, ChainWriterError, ClusterStorageError,
+ * NotLeaderError, FrameworkSchemaError, *SafeError parser families) stay
+ * co-located with their primitive module — they're single-owner, single-
+ * domain, and the *-safe filename convention already declares ownership.
+ * They extend FrameworkError so the unified `instanceof` check works.
+ *
+ * Operational error classes here all share:
+ *   { name, code, message, permanent: bool, isFrameworkError: true }
+ * Adapters that talk over HTTP also carry `statusCode` for retry
+ * classification.
+ */
+
+class FrameworkError extends Error {
+  constructor(message, code) {
+    super(message);
+    this.name = "FrameworkError";
+    this.code = code || "framework/invalid";
+    this.isFrameworkError = true;
+  }
+}
+
+// defineClass — factory for the standard FrameworkError-subclass shape
+// every per-domain error followed by hand. Variants the factory covers:
+//
+//   defineClass("MyError")
+//     constructor: (code, message, permanent)
+//     fields:      name, permanent, isMyError
+//
+//   defineClass("MyError", { withStatusCode: true })
+//     constructor: (code, message, permanent, statusCode)
+//     fields:      + statusCode  (HTTP-shaped operational errors)
+//
+//   defineClass("MyError", { alwaysPermanent: true })
+//     constructor: (code, message)
+//     fields:      permanent always true (auth failures, validation)
+//
+//   defineClass("MyError", { withCause: true })
+//     constructor: (code, message, cause)
+//     fields:      + cause  (errors that wrap an upstream cause)
+//
+// Returns the constructor. Operators can attach extra static helpers
+// to it after creation if they need to.
+function defineClass(name, opts) {
+  if (typeof name !== "string" || name.length === 0) {
+    throw new Error("defineClass: name must be a non-empty string");
+  }
+  opts = opts || {};
+  var alwaysPermanent = !!opts.alwaysPermanent;
+  var withStatusCode  = !!opts.withStatusCode;
+  var withCause       = !!opts.withCause;
+  if (alwaysPermanent && (withStatusCode || withCause)) {
+    throw new Error("defineClass: alwaysPermanent is mutually exclusive with withStatusCode / withCause");
+  }
+  var flagKey = "is" + name;
+
+  // Generated class — uses an anonymous class expression so we can set
+  // the constructor name explicitly via Object.defineProperty (matters
+  // for stack traces and instanceof debugging).
+  var GeneratedError = class extends FrameworkError {
+    constructor(code, message, arg3, arg4) {
+      super(message, code);
+      this.name = name;
+      this[flagKey] = true;
+      if (alwaysPermanent) {
+        this.permanent = true;
+      } else if (withCause) {
+        this.cause = arg3;
+      } else {
+        this.permanent = !!arg3;
+        if (withStatusCode) this.statusCode = arg4;
+      }
+      // Framework-error class counter — routed into framework_errors_total
+      // when a metrics registry is active. observability.event is safe to
+      // call here even during framework-error's own load: observability's
+      // dependencies on metrics + tracing are themselves lazy-required
+      // and only resolve at first call (post-load).
+      try { observability.event("error.construct", 1, { class: name }); }
+      catch (_e) { /* defensive — no observability sink should ever break a constructor */ }
+    }
+  };
+  Object.defineProperty(GeneratedError, "name", { value: name, configurable: true });
+  // Per-class factory — collapses the boilerplate every module used to
+  // write as `function _err(code, msg, perm) { return new XxxError(...); }`.
+  // Now: `var _err = XxxError.factory;` (one line, same call shape).
+  GeneratedError.factory = function (code, message, arg3, arg4) {
+    return new GeneratedError(code, message, arg3, arg4);
+  };
+  return GeneratedError;
+}
+
+// ---- Cross-module operational classes (defined via the factory) ----
+
+var ObjectStoreError      = defineClass("ObjectStoreError",      { withStatusCode: true });
+var LogStreamError        = defineClass("LogStreamError",        { withStatusCode: true });
+var QueueError            = defineClass("QueueError");
+var ExternalDbError       = defineClass("ExternalDbError");
+var ClusterError          = defineClass("ClusterError");
+var ClusterProviderError  = defineClass("ClusterProviderError");
+var HandlerError          = defineClass("HandlerError",          { withCause: true });
+var StorageError          = defineClass("StorageError");
+// AuthError covers password / passkey / TOTP failures at the framework
+// layer (lib/auth/*). Always permanent — auth failures are not transient
+// ("retry might work"); they're "this credential doesn't match" or
+// "this input was malformed".
+var AuthError             = defineClass("AuthError",             { alwaysPermanent: true });
+var JobsError             = defineClass("JobsError");
+var SchedulerError        = defineClass("SchedulerError");
+var SessionError          = defineClass("SessionError");
+var SlugError             = defineClass("SlugError",             { alwaysPermanent: true });
+var WebhookError          = defineClass("WebhookError",          { alwaysPermanent: true });
+var ApiKeyError           = defineClass("ApiKeyError",           { alwaysPermanent: true });
+var PermissionsError      = defineClass("PermissionsError",      { alwaysPermanent: true });
+// CacheError is alwaysPermanent: bad opts / missing key / closed-state
+// errors are programming bugs, not transient. Backend-level transient
+// failures (cluster DB unavailable mid-fetch) become observability +
+// audit signals; they don't escape as exceptions to the caller.
+var CacheError            = defineClass("CacheError",            { alwaysPermanent: true });
+// SeederError is alwaysPermanent: load failures, bad-shape seed files,
+// missing deps, and cycle errors are programming bugs. Per-seed runtime
+// failures get wrapped in this class with the seed name in the message
+// — operators see "seeders/run-failed: 0042-x.js: <cause>" not a raw
+// driver exception.
+var SeederError           = defineClass("SeederError",           { alwaysPermanent: true });
+// I18nError is alwaysPermanent: bad locale tags, malformed translation
+// trees, missing-key in throw mode, and bad input to formatters are
+// programming bugs. Missing keys in default ("return-key") mode return
+// the key without throwing — runtime hot-path semantics, not error.
+var I18nError             = defineClass("I18nError",             { alwaysPermanent: true });
+// NotifyError is alwaysPermanent: bad opts, unknown channels, transport
+// contract violations are programming bugs. Per-send transient failures
+// (the kind retry can recover) are surfaced from the underlying transport
+// with their own shape; only after retry exhaustion does notify wrap
+// them into NotifyError SEND_FAILED — at that point they ARE permanent.
+var NotifyError           = defineClass("NotifyError",           { alwaysPermanent: true });
+// TestingError is alwaysPermanent: bad inputs to test helpers
+// (NaN clock, non-fn predicate, path-traversal tempDir prefix) and
+// waitFor timeouts are programming bugs at test-write time.
+var TestingError          = defineClass("TestingError",          { alwaysPermanent: true });
+
+module.exports = {
+  FrameworkError:         FrameworkError,
+  defineClass:            defineClass,
+  ObjectStoreError:       ObjectStoreError,
+  LogStreamError:         LogStreamError,
+  QueueError:             QueueError,
+  ExternalDbError:        ExternalDbError,
+  ClusterError:           ClusterError,
+  ClusterProviderError:   ClusterProviderError,
+  HandlerError:           HandlerError,
+  StorageError:           StorageError,
+  AuthError:              AuthError,
+  JobsError:              JobsError,
+  SchedulerError:         SchedulerError,
+  SessionError:           SessionError,
+  SlugError:              SlugError,
+  WebhookError:           WebhookError,
+  ApiKeyError:            ApiKeyError,
+  PermissionsError:       PermissionsError,
+  CacheError:             CacheError,
+  SeederError:            SeederError,
+  I18nError:              I18nError,
+  NotifyError:            NotifyError,
+  TestingError:           TestingError,
+};