bozonx-social-media-posting 1.1.0

package/dist/src/modules/post/dto/post-request.dto.d.ts

@@ -0,0 +1,56 @@
+import { PostType } from '../../../common/enums/index.js';
+import type { MediaInput } from '../../../common/types/index.js';
+/**
+ * Post request DTO
+ * Contains all data needed to publish a post to a social media platform
+ */
+export declare class PostRequestDto {
+    /** Target social media platform (e.g., 'telegram') */
+    platform: string;
+    /** Post content/text body (optional if media is provided) */
+    body?: string;
+    /** Post type (auto-detected if not specified) */
+    type?: PostType;
+    /**
+     * Format of the body content.
+     * Standard values: 'text', 'html', 'md'
+     * Platform-specific values (e.g., 'MarkdownV2' for Telegram) are also supported
+     */
+    bodyFormat?: string;
+    /** Post title (used by platforms that support it, max 1000 characters) */
+    title?: string;
+    /** Post description/summary (used by platforms that support it, max 5000 characters) */
+    description?: string;
+    /** Cover image (for image posts or article thumbnails) */
+    cover?: MediaInput;
+    /** Video file (for video posts) */
+    video?: MediaInput;
+    /** Audio file (for audio posts) */
+    audio?: MediaInput;
+    /** Document file (for document posts) */
+    document?: MediaInput;
+    /** Multiple media files (for album/gallery posts) */
+    media?: MediaInput[];
+    /** Named account from configuration */
+    account?: string;
+    /** Platform-agnostic channel/chat identifier (e.g., @mychannel, -100123456789, or 123456789) */
+    channelId?: string | number;
+    /** Inline authentication credentials (alternative to account) */
+    auth?: Record<string, any>;
+    /** Platform-specific options */
+    options?: Record<string, any>;
+    /** Disable notification (silent message) */
+    disableNotification?: boolean;
+    /** Post tags/hashtags (max 200 items, each max 300 characters) */
+    tags?: string[];
+    /** Scheduled publication time (ISO 8601 format, max 50 characters) */
+    scheduledAt?: string;
+    /** Post language code (e.g., 'en', 'ru', max 50 characters) */
+    postLanguage?: string;
+    /** Publication mode: publish immediately or save as draft */
+    mode?: 'publish' | 'draft';
+    /** Idempotency key to prevent duplicate posts (max 1000 characters) */
+    idempotencyKey?: string;
+    /** Maximum body length override (max 500,000 characters) */
+    maxBody?: number;
+}

package/dist/src/modules/post/dto/post-request.dto.js

@@ -0,0 +1,195 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { ArrayMaxSize, IsArray, IsBoolean, IsEnum, IsNumber, IsObject, IsOptional, IsString, Max, MaxLength, Min, } from 'class-validator';
+import { PostType } from '../../../common/enums/index.js';
+import { IsMediaInput, IsMediaInputArray, } from '../../../common/validators/media-input.validator.js';
+import { IsValidBodyLength, MAX_BODY_LIMIT, } from '../../../common/validators/body-length.validator.js';
+import { IsChannelId } from '../../../common/validators/channel-id.validator.js';
+import { HasContent } from '../../../common/validators/has-content.validator.js';
+/**
+ * Post request DTO
+ * Contains all data needed to publish a post to a social media platform
+ */
+let PostRequestDto = class PostRequestDto {
+    /** Target social media platform (e.g., 'telegram') */
+    platform;
+    /** Post content/text body (optional if media is provided) */
+    body;
+    /** Post type (auto-detected if not specified) */
+    type = PostType.AUTO;
+    /**
+     * Format of the body content.
+     * Standard values: 'text', 'html', 'md'
+     * Platform-specific values (e.g., 'MarkdownV2' for Telegram) are also supported
+     */
+    bodyFormat = 'text';
+    /** Post title (used by platforms that support it, max 1000 characters) */
+    title;
+    /** Post description/summary (used by platforms that support it, max 5000 characters) */
+    description;
+    /** Cover image (for image posts or article thumbnails) */
+    cover;
+    /** Video file (for video posts) */
+    video;
+    /** Audio file (for audio posts) */
+    audio;
+    /** Document file (for document posts) */
+    document;
+    /** Multiple media files (for album/gallery posts) */
+    media;
+    /** Named account from configuration */
+    account;
+    /** Platform-agnostic channel/chat identifier (e.g., @mychannel, -100123456789, or 123456789) */
+    channelId;
+    /** Inline authentication credentials (alternative to account) */
+    auth;
+    /** Platform-specific options */
+    options;
+    /** Disable notification (silent message) */
+    disableNotification;
+    /** Post tags/hashtags (max 200 items, each max 300 characters) */
+    tags;
+    /** Scheduled publication time (ISO 8601 format, max 50 characters) */
+    scheduledAt;
+    /** Post language code (e.g., 'en', 'ru', max 50 characters) */
+    postLanguage;
+    /** Publication mode: publish immediately or save as draft */
+    mode;
+    /** Idempotency key to prevent duplicate posts (max 1000 characters) */
+    idempotencyKey;
+    /** Maximum body length override (max 500,000 characters) */
+    maxBody;
+};
+__decorate([
+    IsString(),
+    __metadata("design:type", String)
+], PostRequestDto.prototype, "platform", void 0);
+__decorate([
+    IsOptional(),
+    IsString(),
+    IsValidBodyLength(),
+    __metadata("design:type", String)
+], PostRequestDto.prototype, "body", void 0);
+__decorate([
+    IsOptional(),
+    IsEnum(PostType),
+    __metadata("design:type", String)
+], PostRequestDto.prototype, "type", void 0);
+__decorate([
+    IsOptional(),
+    IsString(),
+    MaxLength(50),
+    __metadata("design:type", String)
+], PostRequestDto.prototype, "bodyFormat", void 0);
+__decorate([
+    IsOptional(),
+    IsString(),
+    MaxLength(1000),
+    __metadata("design:type", String)
+], PostRequestDto.prototype, "title", void 0);
+__decorate([
+    IsOptional(),
+    IsString(),
+    MaxLength(5000),
+    __metadata("design:type", String)
+], PostRequestDto.prototype, "description", void 0);
+__decorate([
+    IsOptional(),
+    IsMediaInput(),
+    __metadata("design:type", Object)
+], PostRequestDto.prototype, "cover", void 0);
+__decorate([
+    IsOptional(),
+    IsMediaInput(),
+    __metadata("design:type", Object)
+], PostRequestDto.prototype, "video", void 0);
+__decorate([
+    IsOptional(),
+    IsMediaInput(),
+    __metadata("design:type", Object)
+], PostRequestDto.prototype, "audio", void 0);
+__decorate([
+    IsOptional(),
+    IsMediaInput(),
+    __metadata("design:type", Object)
+], PostRequestDto.prototype, "document", void 0);
+__decorate([
+    IsOptional(),
+    IsMediaInputArray(),
+    __metadata("design:type", Array)
+], PostRequestDto.prototype, "media", void 0);
+__decorate([
+    IsOptional(),
+    IsString(),
+    __metadata("design:type", String)
+], PostRequestDto.prototype, "account", void 0);
+__decorate([
+    IsOptional(),
+    IsChannelId(),
+    __metadata("design:type", Object)
+], PostRequestDto.prototype, "channelId", void 0);
+__decorate([
+    IsOptional(),
+    IsObject(),
+    __metadata("design:type", Object)
+], PostRequestDto.prototype, "auth", void 0);
+__decorate([
+    IsOptional(),
+    IsObject(),
+    __metadata("design:type", Object)
+], PostRequestDto.prototype, "options", void 0);
+__decorate([
+    IsOptional(),
+    IsBoolean(),
+    __metadata("design:type", Boolean)
+], PostRequestDto.prototype, "disableNotification", void 0);
+__decorate([
+    IsOptional(),
+    IsArray(),
+    ArrayMaxSize(200),
+    IsString({ each: true }),
+    MaxLength(300, { each: true }),
+    __metadata("design:type", Array)
+], PostRequestDto.prototype, "tags", void 0);
+__decorate([
+    IsOptional(),
+    IsString(),
+    MaxLength(50),
+    __metadata("design:type", String)
+], PostRequestDto.prototype, "scheduledAt", void 0);
+__decorate([
+    IsOptional(),
+    IsString(),
+    MaxLength(50),
+    __metadata("design:type", String)
+], PostRequestDto.prototype, "postLanguage", void 0);
+__decorate([
+    IsOptional(),
+    IsEnum(['publish', 'draft']),
+    __metadata("design:type", String)
+], PostRequestDto.prototype, "mode", void 0);
+__decorate([
+    IsOptional(),
+    IsString(),
+    MaxLength(1000),
+    __metadata("design:type", String)
+], PostRequestDto.prototype, "idempotencyKey", void 0);
+__decorate([
+    IsOptional(),
+    IsNumber(),
+    Min(1),
+    Max(MAX_BODY_LIMIT),
+    __metadata("design:type", Number)
+], PostRequestDto.prototype, "maxBody", void 0);
+PostRequestDto = __decorate([
+    HasContent()
+], PostRequestDto);
+export { PostRequestDto };
+//# sourceMappingURL=post-request.dto.js.map

package/dist/src/modules/post/dto/post-request.dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-request.dto.js","sourceRoot":"","sources":["../../../../../src/modules/post/dto/post-request.dto.ts"],"names":[],"mappings":";;;;;;;;;AAAA,OAAO,EACL,YAAY,EACZ,OAAO,EACP,SAAS,EACT,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,QAAQ,EACR,GAAG,EACH,SAAS,EACT,GAAG,GACJ,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,QAAQ,EAAc,MAAM,gCAAgC,CAAC;AAEtE,OAAO,EACL,YAAY,EACZ,iBAAiB,GAClB,MAAM,qDAAqD,CAAC;AAC7D,OAAO,EACL,iBAAiB,EACjB,cAAc,GACf,MAAM,qDAAqD,CAAC;AAC7D,OAAO,EAAE,WAAW,EAAE,MAAM,oDAAoD,CAAC;AACjF,OAAO,EAAE,UAAU,EAAE,MAAM,qDAAqD,CAAC;AAEjF;;;GAGG;AAEI,IAAM,cAAc,GAApB,MAAM,cAAc;IACzB,sDAAsD;IAEtD,QAAQ,CAAU;IAElB,6DAA6D;IAI7D,IAAI,CAAU;IAEd,iDAAiD;IAGjD,IAAI,GAAc,QAAQ,CAAC,IAAI,CAAC;IAEhC;;;;OAIG;IAIH,UAAU,GAAY,MAAM,CAAC;IAE7B,0EAA0E;IAI1E,KAAK,CAAU;IAEf,wFAAwF;IAIxF,WAAW,CAAU;IAErB,0DAA0D;IAG1D,KAAK,CAAc;IAEnB,mCAAmC;IAGnC,KAAK,CAAc;IAEnB,mCAAmC;IAGnC,KAAK,CAAc;IAEnB,yCAAyC;IAGzC,QAAQ,CAAc;IAEtB,qDAAqD;IAGrD,KAAK,CAAgB;IAErB,uCAAuC;IAGvC,OAAO,CAAU;IAEjB,gGAAgG;IAGhG,SAAS,CAAmB;IAG5B,iEAAiE;IAGjE,IAAI,CAAuB;IAE3B,gCAAgC;IAGhC,OAAO,CAAuB;IAE9B,4CAA4C;IAG5C,mBAAmB,CAAW;IAE9B,kEAAkE;IAMlE,IAAI,CAAY;IAEhB,sEAAsE;IAItE,WAAW,CAAU;IAErB,+DAA+D;IAI/D,YAAY,CAAU;IAEtB,6DAA6D;IAG7D,IAAI,CAAuB;IAE3B,uEAAuE;IAIvE,cAAc,CAAU;IAExB,4DAA4D;IAK5D,OAAO,CAAU;CAClB,CAAA;AA3HC;IADC,QAAQ,EAAE;;gDACO;AAMlB;IAHC,UAAU,EAAE;IACZ,QAAQ,EAAE;IACV,iBAAiB,EAAE;;4CACN;AAKd;IAFC,UAAU,EAAE;IACZ,MAAM,CAAC,QAAQ,CAAC;;4CACe;AAUhC;IAHC,UAAU,EAAE;IACZ,QAAQ,EAAE;IACV,SAAS,CAAC,EAAE,CAAC;;kDACe;AAM7B;IAHC,UAAU,EAAE;IACZ,QAAQ,EAAE;IACV,SAAS,CAAC,IAAI,CAAC;;6CACD;AAMf;IAHC,UAAU,EAAE;IACZ,QAAQ,EAAE;IACV,SAAS,CAAC,IAAI,CAAC;;mDACK;AAKrB;IAFC,UAAU,EAAE;IACZ,YAAY,EAAE;;6CACI;AAKnB;IAFC,UAAU,EAAE;IACZ,YAAY,EAAE;;6CACI;AAKnB;IAFC,UAAU,EAAE;IACZ,YAAY,EAAE;;6CACI;AAKnB;IAFC,UAAU,EAAE;IACZ,YAAY,EAAE;;gDACO;AAKtB;IAFC,UAAU,EAAE;IACZ,iBAAiB,EAAE;;6CACC;AAKrB;IAFC,UAAU,EAAE;IACZ,QAAQ,EAAE;;+CACM;AAKjB;IAFC,UAAU,EAAE;IACZ,WAAW,EAAE;;iDACc;AAM5B;IAFC,UAAU,EAAE;IACZ,QAAQ,EAAE;;4CACgB;AAK3B;IAFC,UAAU,EAAE;IACZ,QAAQ,EAAE;;+CACmB;AAK9B;IAFC,UAAU,EAAE;IACZ,SAAS,EAAE;;2DACkB;AAQ9B;IALC,UAAU,EAAE;IACZ,OAAO,EAAE;IACT,YAAY,CAAC,GAAG,CAAC;IACjB,QAAQ,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;IACxB,SAAS,CAAC,GAAG,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;;4CACf;AAMhB;IAHC,UAAU,EAAE;IACZ,QAAQ,EAAE;IACV,SAAS,CAAC,EAAE,CAAC;;mDACO;AAMrB;IAHC,UAAU,EAAE;IACZ,QAAQ,EAAE;IACV,SAAS,CAAC,EAAE,CAAC;;oDACQ;AAKtB;IAFC,UAAU,EAAE;IACZ,MAAM,CAAC,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;;4CACF;AAM3B;IAHC,UAAU,EAAE;IACZ,QAAQ,EAAE;IACV,SAAS,CAAC,IAAI,CAAC;;sDACQ;AAOxB;IAJC,UAAU,EAAE;IACZ,QAAQ,EAAE;IACV,GAAG,CAAC,CAAC,CAAC;IACN,GAAG,CAAC,cAAc,CAAC;;+CACH;AA7HN,cAAc;IAD1B,UAAU,EAAE;GACA,cAAc,CA8H1B"}

package/dist/src/modules/post/dto/post-response.dto.d.ts

@@ -0,0 +1,41 @@
+import type { PostType } from '../../../common/enums/index.js';
+/**
+ * Successful post publication response
+ */
+export interface PostResponseDto {
+    success: true;
+    data: {
+        /** Platform-specific post ID */
+        postId: string;
+        /** Public URL to the post (if available) */
+        url?: string;
+        /** Platform name */
+        platform: string;
+        /** Actual post type used */
+        type: PostType;
+        /** Publication timestamp (ISO 8601) */
+        publishedAt: string;
+        /** Raw response from platform API */
+        raw?: Record<string, any>;
+        /** Unique request identifier for tracking */
+        requestId: string;
+    };
+}
+/**
+ * Error response for failed post publication
+ */
+export interface ErrorResponseDto {
+    success: false;
+    error: {
+        /** Error code for categorization */
+        code: string;
+        /** Human-readable error message */
+        message: string;
+        /** Additional error details */
+        details?: Record<string, any>;
+        /** Raw error response from platform API */
+        raw?: Record<string, any>;
+        /** Unique request identifier for tracking */
+        requestId: string;
+    };
+}

package/dist/src/modules/post/dto/post-response.dto.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=post-response.dto.js.map

package/dist/src/modules/post/dto/post-response.dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-response.dto.js","sourceRoot":"","sources":["../../../../../src/modules/post/dto/post-response.dto.ts"],"names":[],"mappings":""}

package/dist/src/modules/post/dto/preview-response.dto.d.ts

@@ -0,0 +1,33 @@
+import type { PostType } from '../../../common/enums/index.js';
+/**
+ * Successful preview response
+ */
+export interface PreviewResponseDto {
+    success: true;
+    data: {
+        valid: true;
+        /** Detected post type based on content */
+        detectedType: PostType;
+        /** Body content after conversion */
+        convertedBody?: string;
+        /** Target format after conversion */
+        targetFormat: string;
+        /** Length of converted body */
+        convertedBodyLength?: number;
+        /** Validation warnings (non-blocking) */
+        warnings: string[];
+    };
+}
+/**
+ * Preview error response for invalid requests
+ */
+export interface PreviewErrorResponseDto {
+    success: false;
+    data: {
+        valid: false;
+        /** Validation errors (blocking) */
+        errors: string[];
+        /** Validation warnings (non-blocking) */
+        warnings: string[];
+    };
+}

package/dist/src/modules/post/dto/preview-response.dto.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=preview-response.dto.js.map

package/dist/src/modules/post/dto/preview-response.dto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview-response.dto.js","sourceRoot":"","sources":["../../../../../src/modules/post/dto/preview-response.dto.ts"],"names":[],"mappings":""}

package/dist/src/modules/post/idempotency.service.d.ts

@@ -0,0 +1,95 @@
+import { OnModuleDestroy } from '@nestjs/common';
+import { Cache } from '@nestjs/cache-manager';
+import { AppConfigService } from '../app-config/app-config.service.js';
+import { PostRequestDto, PostResponseDto, ErrorResponseDto } from './dto/index.js';
+/**
+ * Idempotency record stored in cache
+ * Tracks request processing status and cached response
+ */
+interface IdempotencyRecord {
+    status: 'processing' | 'completed';
+    response?: PostResponseDto | ErrorResponseDto;
+}
+export declare class IdempotencyService implements OnModuleDestroy {
+    private readonly cache;
+    private readonly appConfig;
+    /** Default TTL for idempotency records in cache (10 minutes) */
+    private static readonly DEFAULT_IDEMPOTENCY_TTL_MINUTES;
+    /** Cleanup interval in milliseconds (5 minutes) */
+    private static readonly CLEANUP_INTERVAL_MS;
+    private readonly logger;
+    /** In-memory map used for atomic idempotency lock management within a single process */
+    private readonly records;
+    /** Interval handle for periodic cleanup */
+    private cleanupInterval?;
+    constructor(cache: Cache, appConfig: AppConfigService);
+    /**
+     * Try to acquire processing lock for the given key or return existing record state.
+     * This method is fully in-memory and synchronous, so it is safe from race conditions
+     * inside a single Node.js process.
+     *
+     * @param key - Idempotency cache key
+     * @returns
+     *  - { acquired: true, status: 'processing' } when current request becomes the owner
+     *  - { acquired: false, status: 'processing' } when another request is already processing
+     *  - { acquired: false, status: 'completed', response } when a completed response is cached
+     */
+    acquireLock(key: string): {
+        acquired: true;
+        status: 'processing';
+    } | {
+        acquired: false;
+        status: 'processing';
+    } | {
+        acquired: false;
+        status: 'completed';
+        response: PostResponseDto | ErrorResponseDto;
+    };
+    /**
+     * Build idempotency cache key from request
+     * Combines user-provided key with content hash for uniqueness
+     * @param request - Post request
+     * @returns Cache key or null if no idempotencyKey provided
+     */
+    buildKey(request: PostRequestDto): string | null;
+    /**
+     * Get idempotency record from cache
+     * @param key - Idempotency cache key
+     * @returns Cached record or undefined if not found
+     */
+    getRecord(key: string): Promise<IdempotencyRecord | undefined>;
+    /**
+     * Mark request as processing in cache
+     * Prevents duplicate processing of the same request
+     * @param key - Idempotency cache key
+     */
+    setProcessing(key: string): Promise<void>;
+    /**
+     * Store completed request response in cache
+     * @param key - Idempotency cache key
+     * @param response - Response to cache (success or error)
+     */
+    setCompleted(key: string, response: PostResponseDto | ErrorResponseDto): Promise<void>;
+    /**
+     * Get TTL for idempotency records in milliseconds
+     * Uses configured value or default if not set
+     * @returns TTL in milliseconds
+     */
+    private getTtlMs;
+    /**
+     * Start periodic cleanup of expired records
+     * Runs every 5 minutes to prevent memory leaks
+     */
+    private startPeriodicCleanup;
+    /**
+     * Cleanup expired records from in-memory map
+     * Called periodically to prevent memory leaks
+     */
+    private cleanupExpiredRecords;
+    /**
+     * Called by NestJS when module is being destroyed
+     * Cleanup interval and clear all records
+     */
+    onModuleDestroy(): void;
+}
+export {};

package/dist/src/modules/post/idempotency.service.js

@@ -0,0 +1,229 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var IdempotencyService_1;
+import { Injectable, Inject, Logger } from '@nestjs/common';
+import { CACHE_MANAGER, Cache } from '@nestjs/cache-manager';
+import { createHash } from 'crypto';
+import { AppConfigService } from '../app-config/app-config.service.js';
+let IdempotencyService = class IdempotencyService {
+    static { IdempotencyService_1 = this; }
+    cache;
+    appConfig;
+    /** Default TTL for idempotency records in cache (10 minutes) */
+    static DEFAULT_IDEMPOTENCY_TTL_MINUTES = 10;
+    /** Cleanup interval in milliseconds (5 minutes) */
+    static CLEANUP_INTERVAL_MS = 5 * 60 * 1000;
+    logger = new Logger(IdempotencyService_1.name);
+    /** In-memory map used for atomic idempotency lock management within a single process */
+    records = new Map();
+    /** Interval handle for periodic cleanup */
+    cleanupInterval;
+    constructor(cache, appConfig) {
+        this.cache = cache;
+        this.appConfig = appConfig;
+        // Start periodic cleanup of expired records
+        this.startPeriodicCleanup();
+    }
+    /**
+     * Try to acquire processing lock for the given key or return existing record state.
+     * This method is fully in-memory and synchronous, so it is safe from race conditions
+     * inside a single Node.js process.
+     *
+     * @param key - Idempotency cache key
+     * @returns
+     *  - { acquired: true, status: 'processing' } when current request becomes the owner
+     *  - { acquired: false, status: 'processing' } when another request is already processing
+     *  - { acquired: false, status: 'completed', response } when a completed response is cached
+     */
+    acquireLock(key) {
+        const now = Date.now();
+        const ttlMs = this.getTtlMs();
+        const existing = this.records.get(key);
+        if (existing) {
+            if (existing.expiresAt <= now) {
+                this.records.delete(key);
+            }
+            else if (existing.status === 'processing') {
+                return { acquired: false, status: 'processing' };
+            }
+            else if (existing.status === 'completed' && existing.response) {
+                return {
+                    acquired: false,
+                    status: 'completed',
+                    response: existing.response,
+                };
+            }
+        }
+        const record = {
+            status: 'processing',
+            expiresAt: now + ttlMs,
+        };
+        this.records.set(key, record);
+        return { acquired: true, status: 'processing' };
+    }
+    /**
+     * Build idempotency cache key from request
+     * Combines user-provided key with content hash for uniqueness
+     * @param request - Post request
+     * @returns Cache key or null if no idempotencyKey provided
+     */
+    buildKey(request) {
+        if (!request.idempotencyKey) {
+            return null;
+        }
+        const hash = createHash('sha256')
+            .update(JSON.stringify({
+            platform: request.platform,
+            account: request.account,
+            auth: request.auth,
+            body: request.body,
+            type: request.type,
+            media: request.media,
+            video: request.video,
+            audio: request.audio,
+            document: request.document,
+            cover: request.cover,
+            options: request.options,
+        }))
+            .digest('hex');
+        return `idempotency:${request.idempotencyKey}:${hash}`;
+    }
+    /**
+     * Get idempotency record from cache
+     * @param key - Idempotency cache key
+     * @returns Cached record or undefined if not found
+     */
+    async getRecord(key) {
+        try {
+            const record = await this.cache.get(key);
+            if (record !== undefined && record !== null) {
+                return record;
+            }
+        }
+        catch {
+            // Swallow cache errors and fall back to in-memory records
+        }
+        const internal = this.records.get(key);
+        if (!internal) {
+            return undefined;
+        }
+        if (internal.expiresAt <= Date.now()) {
+            this.records.delete(key);
+            return undefined;
+        }
+        return {
+            status: internal.status,
+            response: internal.response,
+        };
+    }
+    /**
+     * Mark request as processing in cache
+     * Prevents duplicate processing of the same request
+     * @param key - Idempotency cache key
+     */
+    async setProcessing(key) {
+        const ttlMs = this.getTtlMs();
+        const record = {
+            status: 'processing',
+            expiresAt: Date.now() + ttlMs,
+        };
+        this.records.set(key, record);
+        try {
+            await this.cache.set(key, { status: 'processing' }, ttlMs);
+        }
+        catch {
+            // Best-effort idempotency: ignore cache backend errors
+        }
+    }
+    /**
+     * Store completed request response in cache
+     * @param key - Idempotency cache key
+     * @param response - Response to cache (success or error)
+     */
+    async setCompleted(key, response) {
+        const ttlMs = this.getTtlMs();
+        const record = {
+            status: 'completed',
+            response,
+            expiresAt: Date.now() + ttlMs,
+        };
+        this.records.set(key, record);
+        try {
+            await this.cache.set(key, { status: 'completed', response }, ttlMs);
+        }
+        catch {
+            // Best-effort idempotency: ignore cache backend errors
+        }
+    }
+    /**
+     * Get TTL for idempotency records in milliseconds
+     * Uses configured value or default if not set
+     * @returns TTL in milliseconds
+     */
+    getTtlMs() {
+        const minutes = typeof this.appConfig.idempotencyTtlMinutes === 'number'
+            ? this.appConfig.idempotencyTtlMinutes
+            : IdempotencyService_1.DEFAULT_IDEMPOTENCY_TTL_MINUTES;
+        return minutes * 60_000;
+    }
+    /**
+     * Start periodic cleanup of expired records
+     * Runs every 5 minutes to prevent memory leaks
+     */
+    startPeriodicCleanup() {
+        this.cleanupInterval = setInterval(() => {
+            this.cleanupExpiredRecords();
+        }, IdempotencyService_1.CLEANUP_INTERVAL_MS);
+        // Don't prevent Node.js from exiting
+        this.cleanupInterval.unref();
+        this.logger.log(`Started periodic cleanup (interval: ${IdempotencyService_1.CLEANUP_INTERVAL_MS}ms)`, 'IdempotencyService');
+    }
+    /**
+     * Cleanup expired records from in-memory map
+     * Called periodically to prevent memory leaks
+     */
+    cleanupExpiredRecords() {
+        const now = Date.now();
+        let cleanedCount = 0;
+        for (const [key, record] of this.records.entries()) {
+            if (record.expiresAt <= now) {
+                this.records.delete(key);
+                cleanedCount++;
+            }
+        }
+        if (cleanedCount > 0) {
+            this.logger.debug(`Cleaned up ${cleanedCount} expired idempotency records. Remaining: ${this.records.size}`, 'IdempotencyService');
+        }
+    }
+    /**
+     * Called by NestJS when module is being destroyed
+     * Cleanup interval and clear all records
+     */
+    onModuleDestroy() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = undefined;
+        }
+        const recordCount = this.records.size;
+        this.records.clear();
+        this.logger.log(`IdempotencyService destroyed. Cleared ${recordCount} records.`, 'IdempotencyService');
+    }
+};
+IdempotencyService = IdempotencyService_1 = __decorate([
+    Injectable(),
+    __param(0, Inject(CACHE_MANAGER)),
+    __metadata("design:paramtypes", [Cache,
+        AppConfigService])
+], IdempotencyService);
+export { IdempotencyService };
+//# sourceMappingURL=idempotency.service.js.map