@oatscenter/trellis 0.100.0-rc.1

package/env.js

@@ -0,0 +1,10 @@
+import { env } from "node:process";
+/** Reads native service environment configuration when permission is available. */
+export function getEnv(key) {
+    try {
+        return env[key];
+    }
+    catch {
+        return undefined;
+    }
+}

package/errors/AuthError.d.ts

@@ -0,0 +1,30 @@
+import Type, { type Static } from "typebox";
+import { TrellisError } from "./TrellisError.ts";
+export declare const AuthErrorDataSchema: Type.TObject<{
+    id: Type.TString;
+    type: Type.TLiteral<"AuthError">;
+    message: Type.TString;
+    reason: Type.TString;
+    context: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+    traceId: Type.TOptional<Type.TString>;
+}>;
+export type AuthErrorData = Static<typeof AuthErrorDataSchema>;
+/**
+ * Error for authentication and authorization failures.
+ */
+export declare class AuthError extends TrellisError<AuthErrorData> {
+    readonly name: "AuthError";
+    readonly reason: AuthErrorData["reason"];
+    constructor(options: ErrorOptions & {
+        reason: AuthErrorData["reason"];
+        message?: string;
+        context?: Record<string, unknown>;
+        id?: string;
+    });
+    /**
+     * Serializes error to a plain object.
+     *
+     * @returns Plain object representation of the error
+     */
+    toSerializable(): AuthErrorData;
+}

package/errors/AuthError.js

@@ -0,0 +1,34 @@
+import Type, {} from "typebox";
+import { TrellisError } from "./TrellisError.js";
+export const AuthErrorDataSchema = Type.Object({
+    id: Type.String(),
+    type: Type.Literal("AuthError"),
+    message: Type.String(),
+    reason: Type.String(),
+    context: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+    traceId: Type.Optional(Type.String()),
+});
+/**
+ * Error for authentication and authorization failures.
+ */
+export class AuthError extends TrellisError {
+    name = "AuthError";
+    reason;
+    constructor(options) {
+        const { reason, message, ...baseOptions } = options;
+        super(message ?? `Auth failed: ${reason}`, baseOptions);
+        this.reason = reason;
+    }
+    /**
+     * Serializes error to a plain object.
+     *
+     * @returns Plain object representation of the error
+     */
+    toSerializable() {
+        return {
+            ...this.baseSerializable(),
+            type: this.name,
+            reason: this.reason,
+        };
+    }
+}

package/errors/KVError.d.ts

@@ -0,0 +1,30 @@
+import Type, { type Static } from "typebox";
+import { TrellisError } from "./TrellisError.ts";
+export declare const KVErrorDataSchema: Type.TObject<{
+    id: Type.TString;
+    type: Type.TLiteral<"KVError">;
+    message: Type.TString;
+    operation: Type.TOptional<Type.TString>;
+    context: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+    traceId: Type.TOptional<Type.TString>;
+}>;
+export type KVErrorData = Static<typeof KVErrorDataSchema>;
+/**
+ * Error for KV storage operations.
+ * Used when key-value store operations fail.
+ */
+export declare class KVError extends TrellisError<KVErrorData> {
+    readonly name: "KVError";
+    readonly operation?: string;
+    constructor(options: ErrorOptions & {
+        operation?: string;
+        context?: Record<string, unknown>;
+        id?: string;
+    });
+    /**
+     * Serializes error to a plain object.
+     *
+     * @returns Plain object representation of the error
+     */
+    toSerializable(): KVErrorData;
+}

package/errors/KVError.js

@@ -0,0 +1,36 @@
+import Type, {} from "typebox";
+import { TrellisError } from "./TrellisError.js";
+export const KVErrorDataSchema = Type.Object({
+    id: Type.String(),
+    type: Type.Literal("KVError"),
+    message: Type.String(),
+    operation: Type.Optional(Type.String()),
+    context: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+    traceId: Type.Optional(Type.String()),
+});
+/**
+ * Error for KV storage operations.
+ * Used when key-value store operations fail.
+ */
+export class KVError extends TrellisError {
+    name = "KVError";
+    operation;
+    constructor(options) {
+        const { operation, ...baseOptions } = options;
+        const msg = `KV ${operation || ""} failed`;
+        super(msg, baseOptions);
+        this.operation = operation;
+    }
+    /**
+     * Serializes error to a plain object.
+     *
+     * @returns Plain object representation of the error
+     */
+    toSerializable() {
+        return {
+            ...this.baseSerializable(),
+            type: this.name,
+            operation: this.operation,
+        };
+    }
+}

package/errors/OperationLifecycleError.d.ts

@@ -0,0 +1,110 @@
+import Type, { type Static } from "typebox";
+import { TrellisError } from "./TrellisError.ts";
+export declare const OperationNotFoundErrorDataSchema: Type.TObject<{
+    id: Type.TString;
+    type: Type.TLiteral<"OperationNotFoundError">;
+    message: Type.TString;
+    operationId: Type.TString;
+    context: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+    traceId: Type.TOptional<Type.TString>;
+}>;
+export type OperationNotFoundErrorData = Static<typeof OperationNotFoundErrorDataSchema>;
+/**
+ * Error raised when a requested Trellis operation id cannot be found.
+ */
+export declare class OperationNotFoundError extends TrellisError<OperationNotFoundErrorData> {
+    readonly name: "OperationNotFoundError";
+    readonly operationId: string;
+    constructor(options: ErrorOptions & {
+        operationId: string;
+        message?: string;
+        context?: Record<string, unknown>;
+        id?: string;
+        traceId?: string;
+    });
+    /**
+     * Serializes error to a plain object.
+     *
+     * @returns Plain object representation of the error.
+     */
+    toSerializable(): OperationNotFoundErrorData;
+}
+export declare const OperationAlreadyTerminalErrorDataSchema: Type.TObject<{
+    id: Type.TString;
+    type: Type.TLiteral<"OperationAlreadyTerminalError">;
+    message: Type.TString;
+    operationId: Type.TString;
+    state: Type.TOptional<Type.TString>;
+    operation: Type.TOptional<Type.TString>;
+    service: Type.TOptional<Type.TString>;
+    context: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+    traceId: Type.TOptional<Type.TString>;
+}>;
+export type OperationAlreadyTerminalErrorData = Static<typeof OperationAlreadyTerminalErrorDataSchema>;
+/**
+ * Error raised when a Trellis operation lifecycle mutation targets a terminal operation.
+ */
+export declare class OperationAlreadyTerminalError extends TrellisError<OperationAlreadyTerminalErrorData> {
+    readonly name: "OperationAlreadyTerminalError";
+    readonly operationId: string;
+    readonly state?: string;
+    readonly operation?: string;
+    readonly service?: string;
+    constructor(options: ErrorOptions & {
+        operationId: string;
+        state?: string;
+        operation?: string;
+        service?: string;
+        message?: string;
+        context?: Record<string, unknown>;
+        id?: string;
+        traceId?: string;
+    });
+    /**
+     * Serializes error to a plain object.
+     *
+     * @returns Plain object representation of the error.
+     */
+    toSerializable(): OperationAlreadyTerminalErrorData;
+}
+export declare const OperationMismatchErrorDataSchema: Type.TObject<{
+    id: Type.TString;
+    type: Type.TLiteral<"OperationMismatchError">;
+    message: Type.TString;
+    operationId: Type.TString;
+    expectedService: Type.TString;
+    expectedOperation: Type.TString;
+    actualService: Type.TOptional<Type.TString>;
+    actualOperation: Type.TOptional<Type.TString>;
+    context: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+    traceId: Type.TOptional<Type.TString>;
+}>;
+export type OperationMismatchErrorData = Static<typeof OperationMismatchErrorDataSchema>;
+/**
+ * Error raised when a Trellis operation id belongs to a different service or operation.
+ */
+export declare class OperationMismatchError extends TrellisError<OperationMismatchErrorData> {
+    readonly name: "OperationMismatchError";
+    readonly operationId: string;
+    readonly expectedService: string;
+    readonly expectedOperation: string;
+    readonly actualService?: string;
+    readonly actualOperation?: string;
+    constructor(options: ErrorOptions & {
+        operationId: string;
+        expectedService: string;
+        expectedOperation: string;
+        actualService?: string;
+        actualOperation?: string;
+        message?: string;
+        context?: Record<string, unknown>;
+        id?: string;
+        traceId?: string;
+    });
+    /**
+     * Serializes error to a plain object.
+     *
+     * @returns Plain object representation of the error.
+     */
+    toSerializable(): OperationMismatchErrorData;
+}

package/errors/OperationLifecycleError.js

@@ -0,0 +1,142 @@
+import Type, {} from "typebox";
+import { TrellisError } from "./TrellisError.js";
+export const OperationNotFoundErrorDataSchema = Type.Object({
+    id: Type.String(),
+    type: Type.Literal("OperationNotFoundError"),
+    message: Type.String(),
+    operationId: Type.String(),
+    context: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+    traceId: Type.Optional(Type.String()),
+});
+/**
+ * Error raised when a requested Trellis operation id cannot be found.
+ */
+export class OperationNotFoundError extends TrellisError {
+    name = "OperationNotFoundError";
+    operationId;
+    constructor(options) {
+        const { operationId, message, ...baseOptions } = options;
+        super(message ?? `Operation not found: ${operationId}`, baseOptions);
+        this.operationId = operationId;
+    }
+    /**
+     * Serializes error to a plain object.
+     *
+     * @returns Plain object representation of the error.
+     */
+    toSerializable() {
+        const base = this.baseSerializable();
+        return {
+            id: base.id,
+            type: this.name,
+            message: base.message,
+            operationId: this.operationId,
+            ...(base.context !== undefined ? { context: base.context } : {}),
+            ...(base.traceId !== undefined ? { traceId: base.traceId } : {}),
+        };
+    }
+}
+export const OperationAlreadyTerminalErrorDataSchema = Type.Object({
+    id: Type.String(),
+    type: Type.Literal("OperationAlreadyTerminalError"),
+    message: Type.String(),
+    operationId: Type.String(),
+    state: Type.Optional(Type.String()),
+    operation: Type.Optional(Type.String()),
+    service: Type.Optional(Type.String()),
+    context: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+    traceId: Type.Optional(Type.String()),
+});
+/**
+ * Error raised when a Trellis operation lifecycle mutation targets a terminal operation.
+ */
+export class OperationAlreadyTerminalError extends TrellisError {
+    name = "OperationAlreadyTerminalError";
+    operationId;
+    state;
+    operation;
+    service;
+    constructor(options) {
+        const { operationId, state, operation, service, message, ...baseOptions } = options;
+        super(message ?? `Operation already terminal: ${operationId}`, baseOptions);
+        this.operationId = operationId;
+        this.state = state;
+        this.operation = operation;
+        this.service = service;
+    }
+    /**
+     * Serializes error to a plain object.
+     *
+     * @returns Plain object representation of the error.
+     */
+    toSerializable() {
+        const base = this.baseSerializable();
+        return {
+            id: base.id,
+            type: this.name,
+            message: base.message,
+            operationId: this.operationId,
+            ...(this.state !== undefined ? { state: this.state } : {}),
+            ...(this.operation !== undefined ? { operation: this.operation } : {}),
+            ...(this.service !== undefined ? { service: this.service } : {}),
+            ...(base.context !== undefined ? { context: base.context } : {}),
+            ...(base.traceId !== undefined ? { traceId: base.traceId } : {}),
+        };
+    }
+}
+export const OperationMismatchErrorDataSchema = Type.Object({
+    id: Type.String(),
+    type: Type.Literal("OperationMismatchError"),
+    message: Type.String(),
+    operationId: Type.String(),
+    expectedService: Type.String(),
+    expectedOperation: Type.String(),
+    actualService: Type.Optional(Type.String()),
+    actualOperation: Type.Optional(Type.String()),
+    context: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+    traceId: Type.Optional(Type.String()),
+});
+/**
+ * Error raised when a Trellis operation id belongs to a different service or operation.
+ */
+export class OperationMismatchError extends TrellisError {
+    name = "OperationMismatchError";
+    operationId;
+    expectedService;
+    expectedOperation;
+    actualService;
+    actualOperation;
+    constructor(options) {
+        const { operationId, expectedService, expectedOperation, actualService, actualOperation, message, ...baseOptions } = options;
+        super(message ?? `Operation mismatch: ${operationId}`, baseOptions);
+        this.operationId = operationId;
+        this.expectedService = expectedService;
+        this.expectedOperation = expectedOperation;
+        this.actualService = actualService;
+        this.actualOperation = actualOperation;
+    }
+    /**
+     * Serializes error to a plain object.
+     *
+     * @returns Plain object representation of the error.
+     */
+    toSerializable() {
+        const base = this.baseSerializable();
+        return {
+            id: base.id,
+            type: this.name,
+            message: base.message,
+            operationId: this.operationId,
+            expectedService: this.expectedService,
+            expectedOperation: this.expectedOperation,
+            ...(this.actualService !== undefined
+                ? { actualService: this.actualService }
+                : {}),
+            ...(this.actualOperation !== undefined
+                ? { actualOperation: this.actualOperation }
+                : {}),
+            ...(base.context !== undefined ? { context: base.context } : {}),
+            ...(base.traceId !== undefined ? { traceId: base.traceId } : {}),
+        };
+    }
+}

package/errors/RemoteError.d.ts

@@ -0,0 +1,61 @@
+import { Result, type UnexpectedError, type UnexpectedErrorData } from "@oatscenter/result";
+import Type, { type Static } from "typebox";
+import type { AuthErrorData } from "./AuthError.ts";
+import type { KVErrorData } from "./KVError.ts";
+import type { OperationAlreadyTerminalErrorData, OperationMismatchErrorData, OperationNotFoundErrorData } from "./OperationLifecycleError.ts";
+import type { StoreErrorData } from "./StoreError.ts";
+import type { TransportErrorData } from "./TransportError.ts";
+import type { TransferErrorData } from "./TransferError.ts";
+import { TrellisError } from "./TrellisError.ts";
+import { ValidationError } from "./ValidationError.ts";
+import type { ValidationErrorData } from "./ValidationError.ts";
+export declare const RemoteErrorDataSchema: Type.TObject<{
+    id: Type.TString;
+    type: Type.TLiteral<"RemoteError">;
+    message: Type.TString;
+    remoteError: Type.TAny;
+    context: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+    traceId: Type.TOptional<Type.TString>;
+}>;
+export type RemoteErrorData = Static<typeof RemoteErrorDataSchema>;
+export declare const TrellisErrorDataSchema: Type.TObject<{
+    id: Type.TString;
+    type: Type.TString;
+    message: Type.TString;
+    context: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+    traceId: Type.TOptional<Type.TString>;
+}>;
+export type TrellisErrorData = Static<typeof TrellisErrorDataSchema>;
+export type TransportableTrellisErrorData = UnexpectedErrorData | AuthErrorData | ValidationErrorData | KVErrorData | OperationNotFoundErrorData | OperationAlreadyTerminalErrorData | OperationMismatchErrorData | StoreErrorData | TransportErrorData | TransferErrorData | TrellisErrorData;
+/**
+ * Error for wrapping errors received from remote Trellis services.
+ * This is the only error type with parseJSON/parseObject methods for deserializing remote errors.
+ */
+export declare class RemoteError extends TrellisError<RemoteErrorData> {
+    readonly name: "RemoteError";
+    readonly remoteError: TransportableTrellisErrorData;
+    constructor(options: ErrorOptions & {
+        error: TransportableTrellisErrorData;
+        context?: Record<string, unknown>;
+        id?: string;
+    });
+    /**
+     * Serializes error to a plain object.
+     *
+     * @returns Plain object representation of the error
+     */
+    toSerializable(): RemoteErrorData;
+    /**
+     * Parses and validates a plain object as TrellisErrorData.
+     * Use this to deserialize errors received from remote services.
+     *
+     * @param obj - Plain object to validate
+     * @returns Result containing validated TrellisError or a ValidationError or UnexpectedError
+     */
+    static parse(data: unknown): Result<TransportableTrellisErrorData, ValidationError | UnexpectedError>;
+    /**
+     * Alias for parse() - parses JSON string or object as TrellisErrorData.
+     * @see parse
+     */
+    static parseJSON: typeof RemoteError.parse;
+}

package/errors/RemoteError.js

@@ -0,0 +1,72 @@
+import { Result, } from "@oatscenter/result";
+import Type, {} from "typebox";
+import { ParseError, Value } from "typebox/value";
+import { TrellisError } from "./TrellisError.js";
+import { ValidationError } from "./ValidationError.js";
+export const RemoteErrorDataSchema = Type.Object({
+    id: Type.String(),
+    type: Type.Literal("RemoteError"),
+    message: Type.String(),
+    remoteError: Type.Any(),
+    context: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+    traceId: Type.Optional(Type.String()),
+});
+export const TrellisErrorDataSchema = Type.Object({
+    id: Type.String(),
+    type: Type.String(),
+    message: Type.String(),
+    context: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+    traceId: Type.Optional(Type.String()),
+}, { additionalProperties: true });
+/**
+ * Error for wrapping errors received from remote Trellis services.
+ * This is the only error type with parseJSON/parseObject methods for deserializing remote errors.
+ */
+export class RemoteError extends TrellisError {
+    name = "RemoteError";
+    remoteError;
+    constructor(options) {
+        const { error, ...baseOptions } = options;
+        super(`Remote error: ${error.message}`, baseOptions);
+        this.remoteError = error;
+    }
+    /**
+     * Serializes error to a plain object.
+     *
+     * @returns Plain object representation of the error
+     */
+    toSerializable() {
+        return {
+            ...this.baseSerializable(),
+            type: this.name,
+            remoteError: this.remoteError,
+        };
+    }
+    /**
+     * Parses and validates a plain object as TrellisErrorData.
+     * Use this to deserialize errors received from remote services.
+     *
+     * @param obj - Plain object to validate
+     * @returns Result containing validated TrellisError or a ValidationError or UnexpectedError
+     */
+    static parse(data) {
+        return Result.try(() => typeof data === "string" ? JSON.parse(data) : data)
+            .andThen((obj) => {
+            const parseResult = Result.try(() => Value.Parse(TrellisErrorDataSchema, obj));
+            if (parseResult.isErr()) {
+                const cause = parseResult.error.cause;
+                if (cause instanceof ParseError) {
+                    const errors = Value.Errors(TrellisErrorDataSchema, obj);
+                    return Result.err(new ValidationError({ errors, cause }));
+                }
+                return Result.err(parseResult.error);
+            }
+            return Result.ok(parseResult.take());
+        });
+    }
+    /**
+     * Alias for parse() - parses JSON string or object as TrellisErrorData.
+     * @see parse
+     */
+    static parseJSON = RemoteError.parse;
+}

package/errors/SchemaValidationError.d.ts

@@ -0,0 +1,48 @@
+import Type, { type Static } from "typebox";
+import { TrellisError } from "./TrellisError.ts";
+export declare const SchemaValidationIssueSchema: Type.TObject<{
+    path: Type.TString;
+    schemaPath: Type.TOptional<Type.TString>;
+    keyword: Type.TString;
+    code: Type.TString;
+    message: Type.TString;
+    label: Type.TOptional<Type.TString>;
+    note: Type.TOptional<Type.TString>;
+    i18nKey: Type.TOptional<Type.TString>;
+    severity: Type.TOptional<Type.TUnion<[Type.TLiteral<"error">, Type.TLiteral<"warning">, Type.TLiteral<"info">]>>;
+    params: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+}>;
+export type SchemaValidationIssue = Static<typeof SchemaValidationIssueSchema>;
+export declare const SchemaValidationErrorDataSchema: Type.TObject<{
+    id: Type.TString;
+    type: Type.TLiteral<"SchemaValidationError">;
+    message: Type.TString;
+    issues: Type.TArray<Type.TObject<{
+        path: Type.TString;
+        schemaPath: Type.TOptional<Type.TString>;
+        keyword: Type.TString;
+        code: Type.TString;
+        message: Type.TString;
+        label: Type.TOptional<Type.TString>;
+        note: Type.TOptional<Type.TString>;
+        i18nKey: Type.TOptional<Type.TString>;
+        severity: Type.TOptional<Type.TUnion<[Type.TLiteral<"error">, Type.TLiteral<"warning">, Type.TLiteral<"info">]>>;
+        params: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+    }>>;
+    context: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+    traceId: Type.TOptional<Type.TString>;
+}>;
+export type SchemaValidationErrorData = Static<typeof SchemaValidationErrorDataSchema>;
+export declare class SchemaValidationError extends TrellisError<SchemaValidationErrorData> {
+    #private;
+    readonly name: "SchemaValidationError";
+    constructor(options: {
+        issues: SchemaValidationIssue[];
+        context?: Record<string, unknown>;
+        cause?: unknown;
+        id?: string;
+    });
+    /** The validation issues that caused this error. */
+    get issues(): readonly SchemaValidationIssue[];
+    toSerializable(): SchemaValidationErrorData;
+}

package/errors/SchemaValidationError.js

@@ -0,0 +1,49 @@
+import Type, {} from "typebox";
+import { TrellisError } from "./TrellisError.js";
+export const SchemaValidationIssueSchema = Type.Object({
+    path: Type.String(),
+    schemaPath: Type.Optional(Type.String()),
+    keyword: Type.String(),
+    code: Type.String(),
+    message: Type.String(),
+    label: Type.Optional(Type.String()),
+    note: Type.Optional(Type.String()),
+    i18nKey: Type.Optional(Type.String()),
+    severity: Type.Optional(Type.Union([
+        Type.Literal("error"),
+        Type.Literal("warning"),
+        Type.Literal("info"),
+    ])),
+    params: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+});
+export const SchemaValidationErrorDataSchema = Type.Object({
+    id: Type.String(),
+    type: Type.Literal("SchemaValidationError"),
+    message: Type.String(),
+    issues: Type.Array(SchemaValidationIssueSchema),
+    context: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+    traceId: Type.Optional(Type.String()),
+});
+export class SchemaValidationError extends TrellisError {
+    name = "SchemaValidationError";
+    #issues;
+    constructor(options) {
+        const { issues: rawIssues, ...baseOptions } = options;
+        const msg = rawIssues
+            .map((issue) => issue.message)
+            .join("\n");
+        super(msg.length ? msg : "Schema validation failed.", baseOptions);
+        this.#issues = rawIssues;
+    }
+    /** The validation issues that caused this error. */
+    get issues() {
+        return this.#issues;
+    }
+    toSerializable() {
+        return {
+            ...this.baseSerializable(),
+            type: this.name,
+            issues: this.#issues,
+        };
+    }
+}

package/errors/StoreError.d.ts

@@ -0,0 +1,21 @@
+import Type, { type Static } from "typebox";
+import { TrellisError } from "./TrellisError.ts";
+export declare const StoreErrorDataSchema: Type.TObject<{
+    id: Type.TString;
+    type: Type.TLiteral<"StoreError">;
+    message: Type.TString;
+    operation: Type.TOptional<Type.TString>;
+    context: Type.TOptional<Type.TRecord<"^.*$", Type.TUnknown>>;
+    traceId: Type.TOptional<Type.TString>;
+}>;
+export type StoreErrorData = Static<typeof StoreErrorDataSchema>;
+export declare class StoreError extends TrellisError<StoreErrorData> {
+    readonly name: "StoreError";
+    readonly operation?: string;
+    constructor(options: ErrorOptions & {
+        operation?: string;
+        context?: Record<string, unknown>;
+        id?: string;
+    });
+    toSerializable(): StoreErrorData;
+}

package/errors/StoreError.js

@@ -0,0 +1,31 @@
+import Type, {} from "typebox";
+import { TrellisError } from "./TrellisError.js";
+export const StoreErrorDataSchema = Type.Object({
+    id: Type.String(),
+    type: Type.Literal("StoreError"),
+    message: Type.String(),
+    operation: Type.Optional(Type.String()),
+    context: Type.Optional(Type.Record(Type.String(), Type.Unknown())),
+    traceId: Type.Optional(Type.String()),
+});
+export class StoreError extends TrellisError {
+    name = "StoreError";
+    operation;
+    constructor(options) {
+        const { operation, ...baseOptions } = options;
+        const message = `Store ${operation || ""} failed`;
+        super(message, baseOptions);
+        this.operation = operation;
+    }
+    toSerializable() {
+        const base = this.baseSerializable();
+        return {
+            id: base.id,
+            type: this.name,
+            message: base.message,
+            ...(this.operation !== undefined ? { operation: this.operation } : {}),
+            ...(base.context !== undefined ? { context: base.context } : {}),
+            ...(base.traceId !== undefined ? { traceId: base.traceId } : {}),
+        };
+    }
+}