@platecms/delta-errors 0.7.0

package/README.md

@@ -0,0 +1,36 @@
+# errors
+
+This package contains all error related implementations for both frontend and backend.
+
+- [Features](#features)
+  - [Base classes and types](#base-classes-and-types)
+  - [Error classes](#error-classes)
+
+## Features
+
+This package contains errors and their context types that can be returned as API responses.  
+For example, the `InvalidPrnError` is not in here, because it should be returned as a `BadRequestError` if it is thrown.
+
+Furthermore, these are all called "errors". The difference between errors and exceptions is specific to languages (or even frameworks):
+
+- TypeScript/JavaScript uses errors exclusively. NestJS has exceptions to return as responses.
+- Python uses exceptions exclusively.
+
+### Base classes and types
+
+- `PlateError` - Abstract base class for all Plate errors. Extends the standard `Error` class and provides context and error code functionality.
+- `ErrorCode` - Enum containing all available error codes for identifying different types of errors.
+- `ResourceErrorContext` - Interface defining the context structure for resource-related errors, including action type and resource type information.
+
+### Error classes
+
+- `BadRequestError` - Thrown when the request is malformed or contains invalid parameters.
+- `ForbiddenError` - Thrown when the user is authenticated but does not have sufficient permissions to access a resource.
+- `InternalServerError` - Thrown when an unexpected error occurs on the server side.
+- `InvalidCastError` - Thrown when a CAST is invalid or malformed.
+- `InvalidPrnError` - Thrown when a PRN is invalid or malformed.
+- `NotFoundError` - Thrown when a requested resource cannot be found.
+- `NotImplementedError` - Thrown when attempting to use functionality that has not been implemented.
+- `UnauthorizedError` - Thrown when authentication is required but not provided or is invalid.
+- `UnprocessableContentError` - Thrown when the request content is semantically incorrect.
+- `ValidationFailedError` - Thrown when request validation fails.

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@platecms/delta-errors",
+  "version": "0.7.0",
+  "description": "Error classes and their data for the Delta platform.",
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://bitbucket.org/startmetplate/delta.git"
+  },
+  "homepage": "https://bitbucket.org/startmetplate/delta/src/dev/packages/errors",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "files": [
+    "src/**/*"
+  ],
+  "peerDependencies": {
+    "@platecms/delta-types": "0.7.0",
+    "tslib": "2.8.1",
+    "class-transformer": "0.5.1",
+    "reflect-metadata": "0.2.2",
+    "class-validator": "0.14.2"
+  }
+}

package/src/index.ts

@@ -0,0 +1,15 @@
+export * from "./lib/errors/bad-request.error";
+export * from "./lib/errors/class-validator.error";
+export * from "./lib/errors/forbidden.error";
+export * from "./lib/errors/internal-server.error";
+export * from "./lib/errors/not-found.error";
+export * from "./lib/errors/not-implemented.error";
+export * from "./lib/errors/unauthorized.error";
+export * from "./lib/errors/unprocessable-content.error";
+export * from "./lib/errors/validation-failed.error";
+export * from "./lib/helpers/to-class-validator-error.helper";
+export type * from "./lib/types/base-error-context.type";
+export type * from "./lib/types/base-validation-error-data.interface";
+export * from "./lib/types/error-code.enum";
+export * from "./lib/types/plate.error";
+export type * from "./lib/types/resource-access-error-context.type";

package/src/lib/errors/bad-request.error.ts

@@ -0,0 +1,14 @@
+import { BaseErrorContext } from "../types/base-error-context.type";
+import { ErrorCode } from "../types/error-code.enum";
+import { PlateError } from "../types/plate.error";
+
+/**
+ * A request is malformed.
+ */
+export class BadRequestError extends PlateError {
+  public override readonly code = ErrorCode.BAD_REQUEST;
+
+  public constructor(message: string, context: BaseErrorContext = {}) {
+    super(message, context);
+  }
+}

package/src/lib/errors/class-validator.error.ts

@@ -0,0 +1,26 @@
+import { BaseValidationErrorData } from "../types/base-validation-error-data.interface";
+import { ErrorCode } from "../types/error-code.enum";
+import { PlateError } from "../types/plate.error";
+import { ValidationErrorContext } from "../types/validation-error-context.interface";
+
+interface ClassValidatorErrorData extends BaseValidationErrorData {
+  /**
+   * The constraint that failed.
+   */
+  constraint: string;
+}
+
+/**
+ * The request failed validation due to class-validator.
+ * @remarks This error can be thrown when using class-validator to validate an object.
+ * @remarks This error can be removed once we replace class-validator with our own validation framework.
+ */
+class ClassValidatorError extends PlateError<ValidationErrorContext<ClassValidatorErrorData>> {
+  public override readonly code = ErrorCode.VALIDATION_FAILED;
+
+  public constructor(context: ValidationErrorContext<ClassValidatorErrorData>) {
+    super("Validation failed!", context);
+  }
+}
+
+export { ClassValidatorError, type ClassValidatorErrorData };

package/src/lib/errors/forbidden.error.ts

@@ -0,0 +1,18 @@
+import { ErrorCode } from "../types/error-code.enum";
+import { PlateError } from "../types/plate.error";
+import { ResourceAccessErrorContext } from "../types/resource-access-error-context.type";
+
+/**
+ * The client does not have access to the requested resource.
+ * @remarks This corresponds with status 403 in the HTTP definition.
+ */
+export class ForbiddenError extends PlateError<ResourceAccessErrorContext> {
+  public override readonly code = ErrorCode.FORBIDDEN;
+
+  public constructor(context: ResourceAccessErrorContext) {
+    super(
+      `The client does not have the permission to perform '${context.action}' on '${context.resourceType}'.`,
+      context,
+    );
+  }
+}

package/src/lib/errors/internal-server.error.ts

@@ -0,0 +1,22 @@
+import { BaseErrorContext } from "../types/base-error-context.type";
+import { ErrorCode } from "../types/error-code.enum";
+import { PlateError } from "../types/plate.error";
+
+export interface InternalServerErrorContext extends BaseErrorContext {
+  /**
+   * The error that caused this internal server error.
+   */
+  readonly originalError: Error;
+}
+
+/**
+ * An unexpected error occurred on the server.
+ * @remarks This corresponds with status 500 in the HTTP definition.
+ */
+export class InternalServerError extends PlateError<InternalServerErrorContext> {
+  public override readonly code = ErrorCode.INTERNAL_SERVER_ERROR;
+
+  public constructor(context: InternalServerErrorContext) {
+    super("Something unexpected went wrong!", context);
+  }
+}

package/src/lib/errors/not-found.error.ts

@@ -0,0 +1,24 @@
+import { BaseErrorContext } from "../types/base-error-context.type";
+import { ErrorCode } from "../types/error-code.enum";
+import { PlateError } from "../types/plate.error";
+
+export interface NotFoundErrorContext extends BaseErrorContext {
+  resourceType: string;
+
+  /**
+   * The value that was used to retrieve the resource. This can be a PRN, email, path, slug, etc.
+   */
+  identifier: string;
+}
+
+/**
+ * A requested resource cannot be found.
+ * @remarks This corresponds with status 404 in the HTTP definition.
+ */
+export class NotFoundError extends PlateError<NotFoundErrorContext> {
+  public override readonly code = ErrorCode.NOT_FOUND;
+
+  public constructor(context: NotFoundErrorContext) {
+    super(`${context.resourceType} with PRN '${context.identifier}' could not be found.`, context);
+  }
+}

package/src/lib/errors/not-implemented.error.ts

@@ -0,0 +1,14 @@
+import { ErrorCode } from "../types/error-code.enum";
+import { PlateError } from "../types/plate.error";
+
+/**
+ * The requested functionality has not been implemented.
+ * @remarks This corresponds with status 501 in the HTTP definition.
+ */
+export class NotImplementedError extends PlateError<null> {
+  public override readonly code = ErrorCode.NOT_IMPLEMENTED;
+
+  public constructor() {
+    super("The functionality is not yet implemented.", null);
+  }
+}

package/src/lib/errors/unauthorized.error.ts

@@ -0,0 +1,15 @@
+import { BaseErrorContext } from "../types/base-error-context.type";
+import { ErrorCode } from "../types/error-code.enum";
+import { PlateError } from "../types/plate.error";
+
+/**
+ * The client is not authenticated.
+ * @remarks This corresponds with status 401 in the HTTP definition.
+ */
+export class UnauthorizedError extends PlateError<BaseErrorContext | null> {
+  public override readonly code = ErrorCode.UNAUTHORIZED;
+
+  public constructor(context: BaseErrorContext | null = null) {
+    super("The client is not authenticated.", context);
+  }
+}

package/src/lib/errors/unprocessable-content.error.ts

@@ -0,0 +1,27 @@
+import { BaseErrorContext } from "../types/base-error-context.type";
+import { ErrorCode } from "../types/error-code.enum";
+import { PlateError } from "../types/plate.error";
+
+export interface UnprocessableContentErrorContext extends BaseErrorContext {
+  /**
+   * The resource type that was attempted to be accessed.
+   */
+  resourceType: string;
+
+  /**
+   * The reason why the request is unprocessable.
+   */
+  reason: string;
+}
+
+/**
+ * A valid request was submitted but unable to be followed due to semantic errors.
+ * @remarks This is used as a fallback code, as most such errors will be returned as a more specific exception like ValidationFailedException.
+ */
+export class UnprocessableContentError extends PlateError<UnprocessableContentErrorContext> {
+  public override readonly code = ErrorCode.UNPROCESSABLE_CONTENT;
+
+  public constructor(message: string, context: UnprocessableContentErrorContext) {
+    super(message, context);
+  }
+}

package/src/lib/errors/validation-failed.error.ts

@@ -0,0 +1,41 @@
+import { BaseValidationErrorData } from "../types/base-validation-error-data.interface";
+import { ErrorCode } from "../types/error-code.enum";
+import { PlateError } from "../types/plate.error";
+import { ValidationErrorContext } from "../types/validation-error-context.interface";
+
+interface ValidationFailedErrorData extends BaseValidationErrorData {
+  /**
+   * The rule that failed.
+   */
+  validationRule: {
+    /**
+     * The type of the rule that failed.
+     * @example Count, StringFormat, etc.
+     */
+    ruleType: string;
+
+    /**
+     * Only set if the validation was a dynamically created validation rule.
+     */
+    prn: string | undefined;
+
+    /**
+     * Additional settings of the validation rule, e.g. min, max, regex.
+     */
+    settings: object;
+  };
+}
+
+/**
+ * The request failed validation.
+ * @remarks This error can be thrown for either hardcoded validations (like a required field for an input DTO) or dynamic validation rules (like in the internal validation system).
+ */
+class ValidationFailedError extends PlateError<ValidationErrorContext<ValidationFailedErrorData>> {
+  public override readonly code = ErrorCode.VALIDATION_FAILED;
+
+  public constructor(context: ValidationErrorContext<ValidationFailedErrorData>) {
+    super("Validation failed.", context);
+  }
+}
+
+export { ValidationFailedError, type ValidationFailedErrorData };

package/src/lib/helpers/to-class-validator-error.helper.spec.ts

@@ -0,0 +1,361 @@
+import {
+  IsArray,
+  IsEmail,
+  IsNotEmpty,
+  IsNumber,
+  Matches,
+  Max,
+  Min,
+  MinLength,
+  ValidateNested,
+  validate,
+} from "class-validator";
+import { ClassValidatorError } from "../errors/class-validator.error";
+import { toClassValidatorError } from "./to-class-validator-error.helper";
+
+// Test classes to create realistic validation errors
+class UserRegistrationDto {
+  @IsEmail({}, { message: "email must be an email" })
+  public email!: string;
+
+  @MinLength(8, { message: "password must be longer than or equal to 8 characters" })
+  @Matches(/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)/u, {
+    message: "password must match /^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)/ regular expression",
+  })
+  public password!: string;
+
+  @IsNotEmpty({ message: "firstName should not be empty" })
+  public firstName!: string;
+
+  @IsNotEmpty({ message: "lastName should not be empty" })
+  public lastName!: string;
+
+  @IsNumber({}, { message: "age must be a number" })
+  @Min(18, { message: "age must not be less than 18" })
+  @Max(100, { message: "age must not be greater than 100" })
+  public age!: number;
+}
+
+class CountryDto {
+  @IsNotEmpty({ message: "code should not be empty" })
+  public code!: string;
+
+  @IsNotEmpty({ message: "name should not be empty" })
+  public name!: string;
+}
+
+class NestedAddressDto {
+  @IsNotEmpty({ message: "street should not be empty" })
+  public street!: string;
+
+  @IsNotEmpty({ message: "city should not be empty" })
+  public city!: string;
+
+  @IsNotEmpty({ message: "zipCode should not be empty" })
+  public zipCode!: string;
+
+  @ValidateNested()
+  public country!: CountryDto;
+}
+
+class UserWithAddressDto {
+  @IsEmail({}, { message: "email must be an email" })
+  public email!: string;
+
+  @ValidateNested()
+  public address!: NestedAddressDto;
+}
+
+class ArrayItemDto {
+  @IsNotEmpty({ message: "item should not be empty" })
+  public item!: string;
+}
+
+class ArrayContainerDto {
+  @IsArray({ message: "items must be an array" })
+  @ValidateNested({ each: true })
+  public items!: ArrayItemDto[];
+}
+
+describe("toClassValidatorError", () => {
+  it("handles empty validation errors array", () => {
+    // Act
+    const result = toClassValidatorError([]);
+
+    // Assert
+    expect(result).toBeInstanceOf(ClassValidatorError);
+    expect(result.message).toBe("Validation failed!");
+    expect(result.context.validationErrors).toEqual([]);
+    expect(result.code).toBe("VALIDATION_FAILED");
+  });
+
+  it("handles single validation error", async () => {
+    // Arrange
+    const userDto = new UserRegistrationDto();
+    userDto.email = "invalid-email";
+    userDto.password = "ValidPass123";
+    userDto.firstName = "Crazy";
+    userDto.lastName = "Frog";
+    userDto.age = 25;
+    const validationErrors = await validate(userDto);
+
+    // Act
+    const result = toClassValidatorError(validationErrors);
+
+    // Assert
+    expect(result).toBeInstanceOf(ClassValidatorError);
+    expect(result.message).toBe("Validation failed!");
+    expect(result.context.validationErrors).toHaveLength(1);
+    expect(result.context.validationErrors[0]).toEqual({
+      path: ["email"],
+      message: "email must be an email",
+      constraint: "isEmail",
+      provided: "invalid-email",
+    });
+  });
+
+  it("handles multiple top-level validation errors", async () => {
+    // Arrange
+    const userDto = new UserRegistrationDto();
+    userDto.email = "invalid-email";
+    userDto.password = "ValidPass123";
+    userDto.firstName = "Crazy";
+    userDto.lastName = "Frog";
+    userDto.age = 150; // Above maximum age
+    const validationErrors = await validate(userDto);
+
+    // Act
+    const result = toClassValidatorError(validationErrors);
+
+    // Assert
+    expect(result.context.validationErrors).toHaveLength(2); // email + age
+    expect(result.context.validationErrors[0]).toEqual({
+      path: ["email"],
+      message: "email must be an email",
+      constraint: "isEmail",
+      provided: "invalid-email",
+    });
+    expect(result.context.validationErrors[1]).toEqual({
+      path: ["age"],
+      message: "age must not be greater than 100",
+      constraint: "max",
+      provided: 150,
+    });
+  });
+
+  it("handles multiple constraints on single property", async () => {
+    // Arrange
+    const userDto = new UserRegistrationDto();
+    userDto.email = "valid@email.com";
+    userDto.password = "123"; // Invalid: too short and doesn't match pattern
+    userDto.firstName = "Crazy";
+    userDto.lastName = "Frog";
+    userDto.age = 25;
+    const validationErrors = await validate(userDto);
+
+    // Act
+    const result = toClassValidatorError(validationErrors);
+
+    // Assert
+    expect(result.context.validationErrors).toHaveLength(2);
+    const passwordErrors = result.context.validationErrors.filter((error) => error.path.includes("password"));
+    expect(passwordErrors).toHaveLength(2);
+    expect(passwordErrors).toEqual(
+      expect.arrayContaining([
+        {
+          path: ["password"],
+          message: "password must be longer than or equal to 8 characters",
+          constraint: "minLength",
+          provided: "123",
+        },
+        {
+          path: ["password"],
+          message: "password must match /^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)/ regular expression",
+          constraint: "matches",
+          provided: "123",
+        },
+      ]),
+    );
+  });
+
+  it("handles nested validation errors", async () => {
+    // Arrange
+    const userWithAddressDto = Object.assign(new UserWithAddressDto(), {
+      email: "invalid-email",
+      address: Object.assign(new NestedAddressDto(), {
+        street: "",
+        city: "",
+        zipCode: "",
+        country: Object.assign(new CountryDto(), {
+          code: "",
+          name: "",
+        }),
+      }),
+    });
+    const validationErrors = await validate(userWithAddressDto);
+
+    // Act
+    const result = toClassValidatorError(validationErrors);
+
+    // Assert
+    expect(result.context.validationErrors.length).toBeGreaterThan(0);
+    expect(result.context.validationErrors).toEqual(
+      expect.arrayContaining([
+        {
+          path: ["email"],
+          message: "email must be an email",
+          constraint: "isEmail",
+          provided: "invalid-email",
+        },
+        {
+          path: ["address", "street"],
+          message: "street should not be empty",
+          constraint: "isNotEmpty",
+          provided: "",
+        },
+        {
+          path: ["address", "city"],
+          message: "city should not be empty",
+          constraint: "isNotEmpty",
+          provided: "",
+        },
+        {
+          path: ["address", "zipCode"],
+          message: "zipCode should not be empty",
+          constraint: "isNotEmpty",
+          provided: "",
+        },
+        {
+          path: ["address", "country", "code"],
+          message: "code should not be empty",
+          constraint: "isNotEmpty",
+          provided: "",
+        },
+        {
+          path: ["address", "country", "name"],
+          message: "name should not be empty",
+          constraint: "isNotEmpty",
+          provided: "",
+        },
+      ]),
+    );
+  });
+
+  it("handles array validation errors", async () => {
+    // Arrange
+    const arrayDto = new ArrayContainerDto();
+    arrayDto.items = "not-an-array" as unknown as ArrayItemDto[];
+    const validationErrors = await validate(arrayDto);
+
+    // Act
+    const result = toClassValidatorError(validationErrors);
+
+    // Assert
+    expect(result.context.validationErrors).toEqual(
+      expect.arrayContaining([
+        {
+          path: ["items"],
+          message: "items must be an array",
+          constraint: "isArray",
+          provided: "not-an-array",
+        },
+        {
+          path: ["items"],
+          message: "each value in nested property items must be either object or array",
+          constraint: "nestedValidation",
+          provided: "not-an-array",
+        },
+      ]),
+    );
+  });
+
+  it("handles nested array validation errors", async () => {
+    // Arrange
+    const arrayDto = new ArrayContainerDto();
+    arrayDto.items = [
+      Object.assign(new ArrayItemDto(), { item: "" }), // Empty item
+      Object.assign(new ArrayItemDto(), { item: "valid" }),
+      Object.assign(new ArrayItemDto(), { item: "" }), // Empty item
+    ];
+    const validationErrors = await validate(arrayDto);
+
+    // Act
+    const result = toClassValidatorError(validationErrors);
+
+    // Assert
+    expect(result.context.validationErrors).toHaveLength(2);
+    expect(result.context.validationErrors).toEqual(
+      expect.arrayContaining([
+        {
+          path: ["items", "0", "item"],
+          message: "item should not be empty",
+          constraint: "isNotEmpty",
+          provided: "",
+        },
+        {
+          path: ["items", "2", "item"],
+          message: "item should not be empty",
+          constraint: "isNotEmpty",
+          provided: "",
+        },
+      ]),
+    );
+  });
+
+  it("handles errors with multiple constraints and data types", async () => {
+    // Arrange
+    const userDto = new UserRegistrationDto();
+    userDto.email = "not-an-email";
+    userDto.password = "weak";
+    userDto.firstName = "";
+    userDto.lastName = "";
+    userDto.age = 15; // Below minimum age
+    const validationErrors = await validate(userDto);
+
+    // Act
+    const result = toClassValidatorError(validationErrors);
+
+    // Assert
+    expect(result.context.validationErrors).toHaveLength(6); // email + password(2) + firstName + lastName + age
+    expect(result.context.validationErrors).toEqual(
+      expect.arrayContaining([
+        {
+          path: ["email"],
+          message: "email must be an email",
+          constraint: "isEmail",
+          provided: "not-an-email",
+        },
+        {
+          path: ["password"],
+          message: "password must be longer than or equal to 8 characters",
+          constraint: "minLength",
+          provided: "weak",
+        },
+        {
+          path: ["password"],
+          message: "password must match /^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)/ regular expression",
+          constraint: "matches",
+          provided: "weak",
+        },
+        {
+          path: ["firstName"],
+          message: "firstName should not be empty",
+          constraint: "isNotEmpty",
+          provided: "",
+        },
+        {
+          path: ["lastName"],
+          message: "lastName should not be empty",
+          constraint: "isNotEmpty",
+          provided: "",
+        },
+        {
+          path: ["age"],
+          message: "age must not be less than 18",
+          constraint: "min",
+          provided: 15,
+        },
+      ]),
+    );
+  });
+});

package/src/lib/helpers/to-class-validator-error.helper.ts

@@ -0,0 +1,41 @@
+import { ValidationError } from "class-validator";
+import { ClassValidatorError, ClassValidatorErrorData } from "../errors/class-validator.error";
+
+/**
+ * Flattens class-validator errors into a list of ClassValidatorErrorData.
+ * @param errors - The class-validator errors.
+ * @returns A list of ClassValidatorErrorData.
+ */
+function toClassValidatorErrorData(errors: ValidationError[]): ClassValidatorErrorData[] {
+  const issues: ClassValidatorErrorData[] = [];
+
+  function visit(error: ValidationError, path: string[] = []): void {
+    const currentPath = [...path, error.property].filter(Boolean);
+
+    const constraints = error.constraints ?? {};
+    for (const [constraint, message] of Object.entries(constraints)) {
+      issues.push({
+        path: currentPath,
+        message,
+        constraint,
+        provided: error.value,
+      });
+    }
+
+    (error.children ?? []).forEach((child) => visit(child, currentPath));
+  }
+
+  errors.forEach((error) => visit(error));
+  return issues;
+}
+
+/**
+ * Converts class-validator errors to a ClassValidatorError.
+ * @param errors - The class-validator errors.
+ * @returns A ClassValidatorError.
+ */
+function toClassValidatorError(errors: ValidationError[]): ClassValidatorError {
+  return new ClassValidatorError({ validationErrors: toClassValidatorErrorData(errors) });
+}
+
+export { toClassValidatorError };

package/src/lib/types/base-error-context.type.ts

@@ -0,0 +1,6 @@
+export interface BaseErrorContext {
+  /**
+   * The operation that was performed when the error occurred.
+   */
+  operation?: string;
+}

package/src/lib/types/base-validation-error-data.interface.ts

@@ -0,0 +1,16 @@
+export interface BaseValidationErrorData {
+  /**
+   * Location of the error in the object.
+   */
+  path: string[];
+
+  /**
+   * Human-readable error description, only to be used by developers.
+   */
+  message: string;
+
+  /**
+   * The value that failed validation.
+   */
+  provided: unknown;
+}

package/src/lib/types/error-code.enum.ts

@@ -0,0 +1,12 @@
+export const enum ErrorCode {
+  INVALID_PRN = "INVALID_PRN",
+  INVALID_CAST = "INVALID_CAST",
+  NOT_FOUND = "NOT_FOUND",
+  BAD_REQUEST = "BAD_REQUEST",
+  UNPROCESSABLE_CONTENT = "UNPROCESSABLE_CONTENT",
+  VALIDATION_FAILED = "VALIDATION_FAILED",
+  UNAUTHORIZED = "UNAUTHORIZED",
+  FORBIDDEN = "FORBIDDEN",
+  NOT_IMPLEMENTED = "NOT_IMPLEMENTED",
+  INTERNAL_SERVER_ERROR = "INTERNAL_SERVER_ERROR",
+}

package/src/lib/types/plate.error.ts

@@ -0,0 +1,26 @@
+import { BaseErrorContext } from "./base-error-context.type";
+import { ErrorCode } from "./error-code.enum";
+
+/**
+ * A base class for all Plate errors.
+ */
+export abstract class PlateError<
+  TContext extends BaseErrorContext | BaseErrorContext[] | null = BaseErrorContext,
+> extends Error {
+  /**
+   * The context of the error.
+   * @remarks This is used to provide additional information about the error. The data included depends on the error type.
+   */
+  public readonly context: TContext;
+
+  /**
+   * The error code.
+   * @remarks This is used to identify the type of error that occurred.
+   */
+  public abstract readonly code: ErrorCode;
+
+  public constructor(message: string, context: TContext) {
+    super(message);
+    this.context = context;
+  }
+}

package/src/lib/types/resource-access-error-context.type.ts

@@ -0,0 +1,17 @@
+import { ActionType } from "@platecms/delta-types";
+import { BaseErrorContext } from "./base-error-context.type";
+
+/**
+ * The context of a resource error.
+ */
+export interface ResourceAccessErrorContext extends BaseErrorContext {
+  /**
+   * The action that was attempted.
+   */
+  action: ActionType;
+
+  /**
+   * The resource type that was attempted to be accessed.
+   */
+  resourceType: string;
+}

package/src/lib/types/validation-error-context.interface.ts

@@ -0,0 +1,6 @@
+import { BaseValidationErrorData } from "./base-validation-error-data.interface";
+import { BaseErrorContext } from "./base-error-context.type";
+
+export interface ValidationErrorContext<TValidationErrorData extends BaseValidationErrorData> extends BaseErrorContext {
+  validationErrors: TValidationErrorData[];
+}