@plyaz/types 1.15.20 → 1.16.0

package/dist/logger/enums.d.ts

@@ -30,6 +30,16 @@ export declare const LOGGER_SERVICES: {
     readonly WEBHOOK_SERVICE: "WebhookService";
     readonly TEMPLATE_ENGINE: "TemplateEngine";
     readonly ATTACHMENT_RESOLVER: "AttachmentResolver";
+    readonly STORAGE_SERVICE: "StorageService";
+    readonly STORAGE_ADAPTER: "StorageAdapter";
+    readonly CLOUDFLARE_R2_ADAPTER: "CloudflareR2Adapter";
+    readonly SUPABASE_STORAGE_ADAPTER: "SupabaseStorageAdapter";
+    readonly ADAPTER_REGISTRY: "AdapterRegistry";
+    readonly MEDIA_PROCESSOR: "MediaProcessor";
+    readonly METADATA_EXTRACTOR: "MetadataExtractor";
+    readonly VIRUS_SCANNER: "VirusScanner";
+    readonly TEMPLATE_RENDERER: "TemplateRenderer";
+    readonly COMPLIANCE_MANAGER: "ComplianceManager";
     readonly CONFIG_MANAGER: "ConfigManager";
     readonly CONFIG_VALIDATOR: "ConfigValidator";
 };

package/dist/notifications/types.d.ts

@@ -9,7 +9,6 @@
 import type { UnknownRecord, Promisable } from 'type-fest';
 import type { MessageCatalog, PackageErrorLike } from '../errors';
 import type { WEBHOOK_ENCRYPTION_METHOD, WEBHOOK_EVENT_TYPE, SIGNATURE_METHOD } from './enums';
-import type z from 'zod';
 /**
  * Notification channels supported by the system
  */
@@ -1664,7 +1663,7 @@ export interface WebhookProcessingResult {
  * @template TPayload - Provider-specific payload type
  * @template TSchema - Zod schema type for validation
  */
-export interface WebhookAdapter<TPayload = unknown, TSchema extends z.ZodType<TPayload> = z.ZodType<TPayload>> {
+export interface WebhookAdapter<TPayload = unknown, TSchema = unknown> {
     /** Provider name (sendgrid, infobip, twilio, etc.) */
     readonly providerName: string;
     /** Channel this webhook handles */

package/dist/storage/compliance.d.ts

@@ -0,0 +1,247 @@
+/**
+ * Storage Compliance Types
+ *
+ * Comprehensive, adapter-agnostic compliance system for:
+ * - GDPR compliance
+ * - Legal retention requirements
+ * - Regulatory compliance (SOX, HIPAA, etc.)
+ * - Data immutability
+ * - Soft delete with grace periods
+ *
+ * @module @plyaz/types/storage/compliance
+ */
+import type { FILE_CATEGORY, STORAGE_JURISDICTION, STORAGE_REGULATORY_FRAMEWORK } from './enums';
+/**
+ * Storage retention policy type
+ */
+export type StorageRetentionPolicyType = 'time-based' | 'legal' | 'regulatory' | 'custom';
+/**
+ * Storage retention strategy for deletion attempts on files under retention
+ */
+export type StorageRetentionStrategy = 'soft-delete' | 'defer' | 'error';
+/**
+ * Storage immutability strategy for deletion attempts on immutable files
+ */
+export type StorageImmutabilityStrategy = 'skip' | 'defer' | 'error';
+/**
+ * Storage deletion reason for audit trail
+ */
+export type StorageDeletionReason = 'user_request' | 'account_deletion' | 'gdpr_erasure' | 'admin_action' | 'retention_expired' | 'policy_enforcement' | 'compliance_requirement' | 'data_cleanup' | 'duplicate_removal' | 'test_data_cleanup' | 'other';
+/**
+ * Jurisdiction-specific compliance rule
+ *
+ * Allows overriding retention requirements per jurisdiction
+ */
+export interface StorageJurisdictionRule {
+    /** Jurisdiction code (uses enum for type safety) */
+    jurisdiction: STORAGE_JURISDICTION;
+    /** Override retention period for this jurisdiction */
+    retentionYears?: number;
+    /** Right to erasure (GDPR Article 17) - user can request deletion */
+    rightToErasure?: boolean;
+    /** Mandatory retention - cannot be deleted before retention expires */
+    mandatoryRetention?: boolean;
+    /** Regulatory frameworks applicable in this jurisdiction */
+    frameworks?: STORAGE_REGULATORY_FRAMEWORK[];
+    /** Description of jurisdiction-specific requirements */
+    description?: string;
+}
+/**
+ * Jurisdiction conflict resolution strategy
+ */
+export type StorageJurisdictionConflictStrategy = 'most-restrictive' | 'least-restrictive' | 'mandatory-wins' | 'custom';
+/**
+ * Storage retention policy definition
+ *
+ * Adapter-agnostic: Works with any storage adapter (R2, Supabase, custom, etc.)
+ */
+export interface StorageRetentionPolicy {
+    /** Policy type */
+    type: StorageRetentionPolicyType;
+    /** Retention period in years */
+    retentionYears: number;
+    /** File is immutable (cannot be deleted before retention expires) */
+    immutable: boolean;
+    /** Use soft delete instead of hard delete */
+    softDelete: boolean;
+    /** Grace period in days after deletion before permanent removal */
+    gracePeriodDays?: number;
+    /** Policy name (for audit/logging) */
+    name?: string;
+    /** Description of the policy */
+    description?: string;
+    /** Jurisdictions this policy applies to (uses enum for type safety) */
+    jurisdictions?: STORAGE_JURISDICTION[];
+    /** Regulatory frameworks (uses enum for type safety - no more "penis" strings!) */
+    regulatoryFrameworks?: STORAGE_REGULATORY_FRAMEWORK[];
+    /** Jurisdiction-specific rules (overrides for specific jurisdictions) */
+    jurisdictionRules?: StorageJurisdictionRule[];
+}
+/**
+ * Storage compliance configuration for storage service
+ *
+ * Adapter-agnostic: Applied at service level, works with any adapter
+ */
+export interface StorageComplianceConfig {
+    /** Default retention policy for all files (required if enabled is true) */
+    defaultRetentionPolicy?: StorageRetentionPolicy;
+    /** Retention policies by file category */
+    retentionPolicies?: Partial<Record<FILE_CATEGORY, StorageRetentionPolicy>>;
+    /** Immutable file path patterns (regex) */
+    immutablePatterns?: RegExp[];
+    /** Enable compliance checks */
+    enabled?: boolean;
+    /** Strict mode (throw errors on violations vs warnings) */
+    strictMode?: boolean;
+    /** Jurisdiction conflict resolution strategy */
+    jurisdictionConflictStrategy?: StorageJurisdictionConflictStrategy;
+    /** Default jurisdictions to apply if not specified */
+    defaultJurisdictions?: STORAGE_JURISDICTION[];
+}
+/**
+ * Storage compliance check result
+ */
+export interface StorageComplianceCheckResult {
+    /** Check passed */
+    allowed: boolean;
+    /** Reason if not allowed */
+    reason?: string;
+    /** Retention policy applied */
+    policy?: StorageRetentionPolicy;
+    /** Retention end date (if applicable) */
+    retentionUntil?: Date;
+    /** Should use soft delete */
+    shouldSoftDelete?: boolean;
+    /** Should defer deletion */
+    shouldDefer?: boolean;
+    /** Grace period end date (if applicable) */
+    gracePeriodUntil?: Date;
+    /** Is immutable */
+    isImmutable?: boolean;
+    /** Is under retention */
+    underRetention?: boolean;
+    /** Pattern matched (if immutable by pattern) */
+    matchedPattern?: RegExp;
+    /** Applicable jurisdictions for this check */
+    applicableJurisdictions?: STORAGE_JURISDICTION[];
+    /** Applicable regulatory frameworks */
+    applicableFrameworks?: STORAGE_REGULATORY_FRAMEWORK[];
+    /** Jurisdiction-specific conflicts detected */
+    jurisdictionConflicts?: Array<{
+        jurisdiction: STORAGE_JURISDICTION;
+        requirement: string;
+        conflictsWith: string;
+    }>;
+}
+/**
+ * Storage delete operation compliance options
+ */
+export interface StorageDeleteComplianceOptions {
+    /** Force delete even if immutable */
+    force?: boolean;
+    /** Ignore retention policy */
+    ignoreRetention?: boolean;
+    /** Deletion reason (for audit) */
+    reason?: StorageDeletionReason | string;
+    /** Override retention policy for this operation */
+    retentionOverride?: Partial<StorageRetentionPolicy>;
+    /** Strategy for files under retention */
+    retentionStrategy?: StorageRetentionStrategy;
+    /** Strategy for immutable files */
+    immutableStrategy?: StorageImmutabilityStrategy;
+    /** Override applicable jurisdictions for this operation */
+    jurisdictionsOverride?: STORAGE_JURISDICTION[];
+    /** Override conflict resolution strategy */
+    conflictStrategyOverride?: StorageJurisdictionConflictStrategy;
+}
+/**
+ * Jurisdiction resolution context
+ *
+ * Provides context for determining applicable jurisdictions
+ */
+export interface StorageJurisdictionContext {
+    /** User's location/jurisdiction */
+    userJurisdiction?: STORAGE_JURISDICTION;
+    /** Entity's (organization/company) jurisdiction */
+    entityJurisdiction?: STORAGE_JURISDICTION;
+    /** Data type category */
+    dataCategory?: FILE_CATEGORY;
+    /** Explicit jurisdictions to apply */
+    explicitJurisdictions?: STORAGE_JURISDICTION[];
+    /** Storage location jurisdiction */
+    storageJurisdiction?: STORAGE_JURISDICTION;
+}
+/**
+ * Storage bulk delete result with compliance tracking
+ */
+export interface StorageBulkDeleteResult {
+    /** Files successfully deleted */
+    deleted: number;
+    /** Files soft deleted */
+    softDeleted: number;
+    /** Files deferred (will be deleted after retention) */
+    deferred: number;
+    /** Files skipped (immutable or excluded) */
+    skipped: number;
+    /** Files that failed to delete */
+    failed: number;
+    /** Deferred file details */
+    deferredFiles?: Array<{
+        fileId: string;
+        filename: string;
+        retentionUntil: Date;
+        reason: string;
+    }>;
+    /** Skipped file details */
+    skippedFiles?: Array<{
+        fileId: string;
+        filename: string;
+        reason: string;
+    }>;
+    /** Failed file details */
+    failedFiles?: Array<{
+        fileId: string;
+        filename: string;
+        error: string;
+    }>;
+}
+/**
+ * Storage compliance event metadata
+ */
+export interface StorageComplianceEventMetadata {
+    /** File ID */
+    fileId: string;
+    /** Filename */
+    filename?: string;
+    /** File category */
+    category?: FILE_CATEGORY;
+    /** Applied policy */
+    policy?: StorageRetentionPolicy;
+    /** User who attempted the action */
+    attemptedBy?: string;
+    /** Action that was attempted */
+    action: 'delete' | 'modify' | 'move';
+    /** Violation reason */
+    violationReason?: string;
+    /** Timestamp */
+    timestamp: Date;
+}
+/**
+ * Storage soft delete metadata
+ */
+export interface StorageSoftDeleteMetadata {
+    /** When the file was soft deleted */
+    deletedAt: Date;
+    /** Who deleted the file */
+    deletedBy: string;
+    /** Deletion reason */
+    reason?: StorageDeletionReason | string;
+    /** Grace period in days */
+    gracePeriodDays?: number;
+    /** When the file will be permanently deleted */
+    permanentDeletionAt?: Date;
+    /** Grace period end date */
+    gracePeriodUntil?: Date;
+    /** Can be restored */
+    canRestore: boolean;
+}