@cullet/erp-core 1.0.1 → 1.0.3

package/src/core/errors/conflict-error.ts

@@ -11,236 +11,237 @@ type ConflictKind = "already_exists" | "duplicate" | "unique_violation";
  * Metadata attached to conflicts without exposing sensitive values.
  */
 type ConflictErrorMetadata = {
-  kind: ConflictKind;
-  entity: string;
-  operation?: string;
-  field?: string;
-  constraintName?: string;
-  existingId?: string;
-  valueHash?: string;
-  valuePreview?: string;
-  detectedAtIso?: string;
-  correlationId?: string;
-  requestId?: string;
-  commandId?: string;
-  hint?: string;
+    kind: ConflictKind;
+    entity: string;
+    operation?: string;
+    field?: string;
+    constraintName?: string;
+    existingId?: string;
+    valueHash?: string;
+    valuePreview?: string;
+    detectedAtIso?: string;
+    correlationId?: string;
+    requestId?: string;
+    commandId?: string;
+    hint?: string;
 };
 
 type UniqueConstraintViolation = {
-  kind: "unique_violation";
-  constraintName?: string;
-  table?: string;
-  columns?: string[];
+    kind: "unique_violation";
+    constraintName?: string;
+    table?: string;
+    columns?: string[];
 };
 
 abstract class ConflictError extends AppError {
-  public readonly kind: ConflictKind;
+    public readonly kind: ConflictKind;
 
-  protected constructor(
-    params: {
-      message: string;
-      code: string;
-      kind: ConflictKind;
-      metadata: Omit<ConflictErrorMetadata, "kind">;
-      cause?: unknown;
-    } & AppErrorOptions,
-  ) {
-    super(params.message, params.code, {
-      ...params,
-      metadata: {
-        kind: params.kind,
-        ...params.metadata,
-      },
-    });
+    protected constructor(
+        params: {
+            message: string;
+            code: string;
+            kind: ConflictKind;
+            metadata: Omit<ConflictErrorMetadata, "kind">;
+            cause?: unknown;
+        } & AppErrorOptions,
+    ) {
+        super(params.message, params.code, {
+            ...params,
+            metadata: {
+                kind: params.kind,
+                ...params.metadata,
+            },
+        });
 
-    this.kind = params.kind;
-    Object.freeze(this);
-  }
+        this.kind = params.kind;
+        Object.freeze(this);
+    }
 }
 
 class AlreadyExistsError extends ConflictError {
-  private constructor(
-    input: {
-      metadata: Omit<ConflictErrorMetadata, "kind">;
-      cause?: unknown;
-    } & AppErrorOptions,
-  ) {
-    super({
-      message: "A matching record already exists for the requested operation",
-      code: ErrorCodes.conflict.alreadyExists,
-      kind: "already_exists",
-      ...input,
-    });
-  }
+    private constructor(
+        input: {
+            metadata: Omit<ConflictErrorMetadata, "kind">;
+            cause?: unknown;
+        } & AppErrorOptions,
+    ) {
+        super({
+            message:
+                "A matching record already exists for the requested operation",
+            code: ErrorCodes.conflict.alreadyExists,
+            kind: "already_exists",
+            ...input,
+        });
+    }
 
-  static detected(input: {
-    entity: string;
-    operation?: string;
-    field?: string;
-    existingId?: string;
-    valueHash?: string;
-    valuePreview?: string;
-    detectedAtIso?: string;
-    correlationId?: string;
-    requestId?: string;
-    commandId?: string;
-    hint?: string;
-    cause?: unknown;
-  }): AlreadyExistsError {
-    return new AlreadyExistsError({
-      metadata: {
-        entity: input.entity,
-        operation: input.operation ?? "create",
-        field: input.field,
-        existingId: input.existingId,
-        valueHash: input.valueHash,
-        valuePreview: input.valuePreview,
-        detectedAtIso: input.detectedAtIso,
-        correlationId: input.correlationId,
-        requestId: input.requestId,
-        commandId: input.commandId,
-        hint: input.hint ?? "Verify existing records before retrying.",
-      },
-      cause: input.cause,
-    });
-  }
+    static detected(input: {
+        entity: string;
+        operation?: string;
+        field?: string;
+        existingId?: string;
+        valueHash?: string;
+        valuePreview?: string;
+        detectedAtIso?: string;
+        correlationId?: string;
+        requestId?: string;
+        commandId?: string;
+        hint?: string;
+        cause?: unknown;
+    }): AlreadyExistsError {
+        return new AlreadyExistsError({
+            metadata: {
+                entity: input.entity,
+                operation: input.operation ?? "create",
+                field: input.field,
+                existingId: input.existingId,
+                valueHash: input.valueHash,
+                valuePreview: input.valuePreview,
+                detectedAtIso: input.detectedAtIso,
+                correlationId: input.correlationId,
+                requestId: input.requestId,
+                commandId: input.commandId,
+                hint: input.hint ?? "Verify existing records before retrying.",
+            },
+            cause: input.cause,
+        });
+    }
 }
 
 class DuplicateError extends ConflictError {
-  private constructor(
-    input: {
-      metadata: Omit<ConflictErrorMetadata, "kind">;
-      cause?: unknown;
-    } & AppErrorOptions,
-  ) {
-    super({
-      message: "Conflict: an existing record violates uniqueness",
-      code: ErrorCodes.conflict.duplicate,
-      kind: "duplicate",
-      ...input,
-    });
-  }
+    private constructor(
+        input: {
+            metadata: Omit<ConflictErrorMetadata, "kind">;
+            cause?: unknown;
+        } & AppErrorOptions,
+    ) {
+        super({
+            message: "Conflict: an existing record violates uniqueness",
+            code: ErrorCodes.conflict.duplicate,
+            kind: "duplicate",
+            ...input,
+        });
+    }
 
-  static detected(input: {
-    entity: string;
-    operation?: string;
-    field?: string;
-    constraintName?: string;
-    existingId?: string;
-    valueHash?: string;
-    valuePreview?: string;
-    detectedAtIso?: string;
-    correlationId?: string;
-    requestId?: string;
-    commandId?: string;
-    hint?: string;
-    cause?: unknown;
-  }): DuplicateError {
-    return new DuplicateError({
-      metadata: {
-        entity: input.entity,
-        operation: input.operation,
-        field: input.field,
-        constraintName: input.constraintName,
-        existingId: input.existingId,
-        valueHash: input.valueHash,
-        valuePreview: input.valuePreview,
-        detectedAtIso: input.detectedAtIso,
-        correlationId: input.correlationId,
-        requestId: input.requestId,
-        commandId: input.commandId,
-        hint:
-          input.hint ??
-          "Adjust the data so it does not duplicate existing records.",
-      },
-      cause: input.cause,
-    });
-  }
+    static detected(input: {
+        entity: string;
+        operation?: string;
+        field?: string;
+        constraintName?: string;
+        existingId?: string;
+        valueHash?: string;
+        valuePreview?: string;
+        detectedAtIso?: string;
+        correlationId?: string;
+        requestId?: string;
+        commandId?: string;
+        hint?: string;
+        cause?: unknown;
+    }): DuplicateError {
+        return new DuplicateError({
+            metadata: {
+                entity: input.entity,
+                operation: input.operation,
+                field: input.field,
+                constraintName: input.constraintName,
+                existingId: input.existingId,
+                valueHash: input.valueHash,
+                valuePreview: input.valuePreview,
+                detectedAtIso: input.detectedAtIso,
+                correlationId: input.correlationId,
+                requestId: input.requestId,
+                commandId: input.commandId,
+                hint:
+                    input.hint ??
+                    "Adjust the data so it does not duplicate existing records.",
+            },
+            cause: input.cause,
+        });
+    }
 }
 
 class UniqueConstraintViolationError extends ConflictError {
-  private constructor(
-    input: {
-      metadata: Omit<ConflictErrorMetadata, "kind"> & {
-        violation: UniqueConstraintViolation;
-      };
-      cause?: unknown;
-    } & AppErrorOptions,
-  ) {
-    super({
-      message: "Uniqueness violation in storage",
-      code: ErrorCodes.conflict.uniqueViolation,
-      kind: "unique_violation",
-      ...input,
-    });
-  }
+    private constructor(
+        input: {
+            metadata: Omit<ConflictErrorMetadata, "kind"> & {
+                violation: UniqueConstraintViolation;
+            };
+            cause?: unknown;
+        } & AppErrorOptions,
+    ) {
+        super({
+            message: "Uniqueness violation in storage",
+            code: ErrorCodes.conflict.uniqueViolation,
+            kind: "unique_violation",
+            ...input,
+        });
+    }
+
+    static detected(input: {
+        entity: string;
+        operation?: string;
+        constraintName?: string;
+        table?: string;
+        columns?: string[];
+        detectedAtIso?: string;
+        correlationId?: string;
+        requestId?: string;
+        commandId?: string;
+        cause?: unknown;
+    }): UniqueConstraintViolationError {
+        return new UniqueConstraintViolationError({
+            metadata: {
+                entity: input.entity,
+                operation: input.operation,
+                constraintName: input.constraintName,
+                detectedAtIso: input.detectedAtIso,
+                correlationId: input.correlationId,
+                requestId: input.requestId,
+                commandId: input.commandId,
+                violation: {
+                    kind: "unique_violation",
+                    constraintName: input.constraintName,
+                    table: input.table,
+                    columns: input.columns,
+                },
+                hint: "Uniqueness conflict detected in the database.",
+            },
+            cause: input.cause,
+        });
+    }
+}
 
-  static detected(input: {
+function translateUniqueViolationToDuplicate(input: {
     entity: string;
     operation?: string;
-    constraintName?: string;
-    table?: string;
-    columns?: string[];
-    detectedAtIso?: string;
-    correlationId?: string;
-    requestId?: string;
-    commandId?: string;
+    violation: UniqueConstraintViolation;
+    field?: string;
+    ctx?: {
+        correlationId?: string;
+        requestId?: string;
+        commandId?: string;
+        nowIso?: string;
+    };
     cause?: unknown;
-  }): UniqueConstraintViolationError {
-    return new UniqueConstraintViolationError({
-      metadata: {
+}): DuplicateError {
+    return DuplicateError.detected({
         entity: input.entity,
         operation: input.operation,
-        constraintName: input.constraintName,
-        detectedAtIso: input.detectedAtIso,
-        correlationId: input.correlationId,
-        requestId: input.requestId,
-        commandId: input.commandId,
-        violation: {
-          kind: "unique_violation",
-          constraintName: input.constraintName,
-          table: input.table,
-          columns: input.columns,
-        },
-        hint: "Uniqueness conflict detected in the database.",
-      },
-      cause: input.cause,
+        field: input.field,
+        constraintName: input.violation.constraintName,
+        detectedAtIso: input.ctx?.nowIso,
+        correlationId: input.ctx?.correlationId,
+        requestId: input.ctx?.requestId,
+        commandId: input.ctx?.commandId,
+        cause: input.cause,
     });
-  }
-}
-
-function translateUniqueViolationToDuplicate(input: {
-  entity: string;
-  operation?: string;
-  violation: UniqueConstraintViolation;
-  field?: string;
-  ctx?: {
-    correlationId?: string;
-    requestId?: string;
-    commandId?: string;
-    nowIso?: string;
-  };
-  cause?: unknown;
-}): DuplicateError {
-  return DuplicateError.detected({
-    entity: input.entity,
-    operation: input.operation,
-    field: input.field,
-    constraintName: input.violation.constraintName,
-    detectedAtIso: input.ctx?.nowIso,
-    correlationId: input.ctx?.correlationId,
-    requestId: input.ctx?.requestId,
-    commandId: input.ctx?.commandId,
-    cause: input.cause,
-  });
 }
 
 export {
-  AlreadyExistsError,
-  ConflictError,
-  DuplicateError,
-  translateUniqueViolationToDuplicate,
-  UniqueConstraintViolationError,
+    AlreadyExistsError,
+    ConflictError,
+    DuplicateError,
+    translateUniqueViolationToDuplicate,
+    UniqueConstraintViolationError,
 };
 
 export type { ConflictErrorMetadata, ConflictKind, UniqueConstraintViolation };

package/src/core/errors/error-codes.ts

@@ -1,59 +1,59 @@
 const ErrorCodes = {
-  authentication: {
-    missingToken: "sec.authn.missing_token",
-    invalidToken: "sec.authn.invalid_token",
-    expiredToken: "sec.authn.expired_token",
-    invalidCredentials: "sec.authn.invalid_credentials",
-  },
-  authorization: {
-    forbidden: "sec.authz.forbidden",
-    policyDenied: "sec.authz.policy_denied",
-    missingCapability: "sec.authz.missing_capability",
-    outOfScope: "sec.authz.out_of_scope",
-  },
-  businessRuleViolation: "business_rule_violation",
-  conflict: {
-    alreadyExists: "conf.already_exists",
-    duplicate: "conf.duplicate",
-    uniqueViolation: "conf.unique_violation",
-  },
-  idempotency: {
-    keyMissing: "idemp.key_missing",
-    inProgress: "idemp.in_progress",
-    payloadMismatch: "idemp.payload_mismatch",
-    replayNotSupported: "idemp.replay_not_supported",
-  },
-  integration: {
-    timeout: "int.timeout",
-    unreachable: "int.unreachable",
-    badResponse: "int.bad_response",
-  },
-  legacyIncompatible: "legacy_incompatible",
-  notFound: "not_found",
-  serialization: {
-    deserializePrefix: "ser.des",
-    serializePrefix: "ser.ser",
-  },
-  temporal: {
-    expired: "tmp.expired",
-    notYetValid: "tmp.not_yet_valid",
-  },
-  unexpected: "unexpected",
-  validation: "validation_error",
+    authentication: {
+        missingToken: "sec.authn.missing_token",
+        invalidToken: "sec.authn.invalid_token",
+        expiredToken: "sec.authn.expired_token",
+        invalidCredentials: "sec.authn.invalid_credentials",
+    },
+    authorization: {
+        forbidden: "sec.authz.forbidden",
+        policyDenied: "sec.authz.policy_denied",
+        missingCapability: "sec.authz.missing_capability",
+        outOfScope: "sec.authz.out_of_scope",
+    },
+    businessRuleViolation: "business_rule_violation",
+    conflict: {
+        alreadyExists: "conf.already_exists",
+        duplicate: "conf.duplicate",
+        uniqueViolation: "conf.unique_violation",
+    },
+    idempotency: {
+        keyMissing: "idemp.key_missing",
+        inProgress: "idemp.in_progress",
+        payloadMismatch: "idemp.payload_mismatch",
+        replayNotSupported: "idemp.replay_not_supported",
+    },
+    integration: {
+        timeout: "int.timeout",
+        unreachable: "int.unreachable",
+        badResponse: "int.bad_response",
+    },
+    legacyIncompatible: "legacy_incompatible",
+    notFound: "not_found",
+    serialization: {
+        deserializePrefix: "ser.des",
+        serializePrefix: "ser.ser",
+    },
+    temporal: {
+        expired: "tmp.expired",
+        notYetValid: "tmp.not_yet_valid",
+    },
+    unexpected: "unexpected",
+    validation: "validation_error",
 } as const;
 
 type SerializationCodeDirection = "deserialize" | "serialize";
 
 function serializationErrorCode(
-  direction: SerializationCodeDirection,
-  category: string,
+    direction: SerializationCodeDirection,
+    category: string,
 ): string {
-  const prefix =
-    direction === "deserialize"
-      ? ErrorCodes.serialization.deserializePrefix
-      : ErrorCodes.serialization.serializePrefix;
+    const prefix =
+        direction === "deserialize"
+            ? ErrorCodes.serialization.deserializePrefix
+            : ErrorCodes.serialization.serializePrefix;
 
-  return `${prefix}.${category}`;
+    return `${prefix}.${category}`;
 }
 
 export { ErrorCodes, serializationErrorCode };