@classytic/revenue 1.1.2 → 1.1.3

package/dist/escrow.enums-CZGrrdg7.mjs

@@ -0,0 +1,101 @@
+//#region src/enums/monetization.enums.ts
+/**
+* Monetization Enums
+* @classytic/revenue
+*
+* General monetization enums and constants
+*/
+const MONETIZATION_TYPES = {
+	FREE: "free",
+	PURCHASE: "purchase",
+	SUBSCRIPTION: "subscription"
+};
+const MONETIZATION_TYPE_VALUES = Object.values(MONETIZATION_TYPES);
+const monetizationTypeSet = new Set(MONETIZATION_TYPE_VALUES);
+function isMonetizationType(value) {
+	return typeof value === "string" && monetizationTypeSet.has(value);
+}
+
+//#endregion
+//#region src/enums/settlement.enums.ts
+/**
+* Settlement Enums
+* @classytic/revenue
+*
+* Enums for settlement/payout tracking
+*/
+const SETTLEMENT_STATUS = {
+	PENDING: "pending",
+	PROCESSING: "processing",
+	COMPLETED: "completed",
+	FAILED: "failed",
+	CANCELLED: "cancelled"
+};
+const SETTLEMENT_STATUS_VALUES = Object.values(SETTLEMENT_STATUS);
+/**
+* Type guard for settlement status
+*/
+function isSettlementStatus(value) {
+	return typeof value === "string" && SETTLEMENT_STATUS_VALUES.includes(value);
+}
+const SETTLEMENT_TYPE = {
+	SPLIT_PAYOUT: "split_payout",
+	PLATFORM_WITHDRAWAL: "platform_withdrawal",
+	MANUAL_PAYOUT: "manual_payout",
+	ESCROW_RELEASE: "escrow_release"
+};
+const SETTLEMENT_TYPE_VALUES = Object.values(SETTLEMENT_TYPE);
+/**
+* Type guard for settlement type
+*/
+function isSettlementType(value) {
+	return typeof value === "string" && SETTLEMENT_TYPE_VALUES.includes(value);
+}
+
+//#endregion
+//#region src/enums/escrow.enums.ts
+/**
+* Escrow/Hold Enums
+* @classytic/revenue
+*
+* Enums for platform-as-intermediary payment flow
+*/
+const HOLD_STATUS = {
+	PENDING: "pending",
+	HELD: "held",
+	RELEASED: "released",
+	CANCELLED: "cancelled",
+	EXPIRED: "expired",
+	PARTIALLY_RELEASED: "partially_released"
+};
+const HOLD_STATUS_VALUES = Object.values(HOLD_STATUS);
+const RELEASE_REASON = {
+	PAYMENT_VERIFIED: "payment_verified",
+	MANUAL_RELEASE: "manual_release",
+	AUTO_RELEASE: "auto_release",
+	DISPUTE_RESOLVED: "dispute_resolved"
+};
+const RELEASE_REASON_VALUES = Object.values(RELEASE_REASON);
+const HOLD_REASON = {
+	PAYMENT_VERIFICATION: "payment_verification",
+	FRAUD_CHECK: "fraud_check",
+	MANUAL_REVIEW: "manual_review",
+	DISPUTE: "dispute",
+	COMPLIANCE: "compliance"
+};
+const HOLD_REASON_VALUES = Object.values(HOLD_REASON);
+const holdStatusSet = new Set(HOLD_STATUS_VALUES);
+const releaseReasonSet = new Set(RELEASE_REASON_VALUES);
+const holdReasonSet = new Set(HOLD_REASON_VALUES);
+function isHoldStatus(value) {
+	return typeof value === "string" && holdStatusSet.has(value);
+}
+function isReleaseReason(value) {
+	return typeof value === "string" && releaseReasonSet.has(value);
+}
+function isHoldReason(value) {
+	return typeof value === "string" && holdReasonSet.has(value);
+}
+
+//#endregion
+export { MONETIZATION_TYPE_VALUES as _, RELEASE_REASON as a, isHoldStatus as c, SETTLEMENT_STATUS_VALUES as d, SETTLEMENT_TYPE as f, MONETIZATION_TYPES as g, isSettlementType as h, HOLD_STATUS_VALUES as i, isReleaseReason as l, isSettlementStatus as m, HOLD_REASON_VALUES as n, RELEASE_REASON_VALUES as o, SETTLEMENT_TYPE_VALUES as p, HOLD_STATUS as r, isHoldReason as s, HOLD_REASON as t, SETTLEMENT_STATUS as u, isMonetizationType as v };

package/dist/{escrow.enums-CE0VQsfe.d.ts → escrow.enums-DwdLuuve.d.mts}

@@ -1,3 +1,4 @@
+//#region src/enums/subscription.enums.d.ts
 /**
  * Subscription Enums
  * @classytic/revenue
@@ -8,13 +9,13 @@
  * Subscription Status
  */
 declare const SUBSCRIPTION_STATUS: {
-    readonly ACTIVE: "active";
-    readonly PAUSED: "paused";
-    readonly CANCELLED: "cancelled";
-    readonly EXPIRED: "expired";
-    readonly PENDING: "pending";
-    readonly PENDING_RENEWAL: "pending_renewal";
-    readonly INACTIVE: "inactive";
+  readonly ACTIVE: "active";
+  readonly PAUSED: "paused";
+  readonly CANCELLED: "cancelled";
+  readonly EXPIRED: "expired";
+  readonly PENDING: "pending";
+  readonly PENDING_RENEWAL: "pending_renewal";
+  readonly INACTIVE: "inactive";
 };
 type SubscriptionStatus = typeof SUBSCRIPTION_STATUS;
 type SubscriptionStatusValue = SubscriptionStatus[keyof SubscriptionStatus];
@@ -23,16 +24,17 @@ declare const SUBSCRIPTION_STATUS_VALUES: SubscriptionStatusValue[];
  * Supported plan intervals
  */
 declare const PLAN_KEYS: {
-    readonly MONTHLY: "monthly";
-    readonly QUARTERLY: "quarterly";
-    readonly YEARLY: "yearly";
+  readonly MONTHLY: "monthly";
+  readonly QUARTERLY: "quarterly";
+  readonly YEARLY: "yearly";
 };
 type PlanKeys = typeof PLAN_KEYS;
 type PlanKeyValue = PlanKeys[keyof PlanKeys];
 declare const PLAN_KEY_VALUES: PlanKeyValue[];
 declare function isSubscriptionStatus(value: unknown): value is SubscriptionStatusValue;
 declare function isPlanKey(value: unknown): value is PlanKeyValue;
-
+//#endregion
+//#region src/enums/escrow.enums.d.ts
 /**
  * Escrow/Hold Enums
  * @classytic/revenue
@@ -40,31 +42,31 @@ declare function isPlanKey(value: unknown): value is PlanKeyValue;
  * Enums for platform-as-intermediary payment flow
  */
 declare const HOLD_STATUS: {
-    readonly PENDING: "pending";
-    readonly HELD: "held";
-    readonly RELEASED: "released";
-    readonly CANCELLED: "cancelled";
-    readonly EXPIRED: "expired";
-    readonly PARTIALLY_RELEASED: "partially_released";
+  readonly PENDING: "pending";
+  readonly HELD: "held";
+  readonly RELEASED: "released";
+  readonly CANCELLED: "cancelled";
+  readonly EXPIRED: "expired";
+  readonly PARTIALLY_RELEASED: "partially_released";
 };
 type HoldStatus = typeof HOLD_STATUS;
 type HoldStatusValue = HoldStatus[keyof HoldStatus];
 declare const HOLD_STATUS_VALUES: HoldStatusValue[];
 declare const RELEASE_REASON: {
-    readonly PAYMENT_VERIFIED: "payment_verified";
-    readonly MANUAL_RELEASE: "manual_release";
-    readonly AUTO_RELEASE: "auto_release";
-    readonly DISPUTE_RESOLVED: "dispute_resolved";
+  readonly PAYMENT_VERIFIED: "payment_verified";
+  readonly MANUAL_RELEASE: "manual_release";
+  readonly AUTO_RELEASE: "auto_release";
+  readonly DISPUTE_RESOLVED: "dispute_resolved";
 };
 type ReleaseReason = typeof RELEASE_REASON;
 type ReleaseReasonValue = ReleaseReason[keyof ReleaseReason];
 declare const RELEASE_REASON_VALUES: ReleaseReasonValue[];
 declare const HOLD_REASON: {
-    readonly PAYMENT_VERIFICATION: "payment_verification";
-    readonly FRAUD_CHECK: "fraud_check";
-    readonly MANUAL_REVIEW: "manual_review";
-    readonly DISPUTE: "dispute";
-    readonly COMPLIANCE: "compliance";
+  readonly PAYMENT_VERIFICATION: "payment_verification";
+  readonly FRAUD_CHECK: "fraud_check";
+  readonly MANUAL_REVIEW: "manual_review";
+  readonly DISPUTE: "dispute";
+  readonly COMPLIANCE: "compliance";
 };
 type HoldReason = typeof HOLD_REASON;
 type HoldReasonValue = HoldReason[keyof HoldReason];
@@ -72,5 +74,5 @@ declare const HOLD_REASON_VALUES: HoldReasonValue[];
 declare function isHoldStatus(value: unknown): value is HoldStatusValue;
 declare function isReleaseReason(value: unknown): value is ReleaseReasonValue;
 declare function isHoldReason(value: unknown): value is HoldReasonValue;
-
-export { type HoldStatusValue as H, type PlanKeyValue as P, type ReleaseReasonValue as R, type SubscriptionStatusValue as S, isPlanKey as a, type HoldReasonValue as b, isHoldStatus as c, isReleaseReason as d, isHoldReason as e, SUBSCRIPTION_STATUS as f, type SubscriptionStatus as g, SUBSCRIPTION_STATUS_VALUES as h, isSubscriptionStatus as i, PLAN_KEYS as j, type PlanKeys as k, PLAN_KEY_VALUES as l, HOLD_STATUS as m, type HoldStatus as n, HOLD_STATUS_VALUES as o, RELEASE_REASON as p, type ReleaseReason as q, RELEASE_REASON_VALUES as r, HOLD_REASON as s, type HoldReason as t, HOLD_REASON_VALUES as u };
+//#endregion
+export { SubscriptionStatusValue as C, SubscriptionStatus as S, isSubscriptionStatus as T, PLAN_KEY_VALUES as _, HoldReason as a, SUBSCRIPTION_STATUS as b, HoldStatusValue as c, ReleaseReason as d, ReleaseReasonValue as f, PLAN_KEYS as g, isReleaseReason as h, HOLD_STATUS_VALUES as i, RELEASE_REASON as l, isHoldStatus as m, HOLD_REASON_VALUES as n, HoldReasonValue as o, isHoldReason as p, HOLD_STATUS as r, HoldStatus as s, HOLD_REASON as t, RELEASE_REASON_VALUES as u, PlanKeyValue as v, isPlanKey as w, SUBSCRIPTION_STATUS_VALUES as x, PlanKeys as y };

package/dist/idempotency-DaYcUGY1.mjs

@@ -0,0 +1,172 @@
+import { d as err, v as ok } from "./commission-split-BzB8cd39.mjs";
+import { nanoid } from "nanoid";
+
+//#region src/shared/utils/resilience/idempotency.ts
+/**
+* Idempotency Utilities
+* @classytic/revenue
+*
+* Prevent duplicate operations with idempotency keys
+* Inspired by: Stripe, Amazon SQS deduplication
+*/
+/**
+* Simple in-memory idempotency store
+* Use Redis/database store in production
+*/
+var MemoryIdempotencyStore = class {
+	records = /* @__PURE__ */ new Map();
+	cleanupInterval = null;
+	constructor(cleanupIntervalMs = 6e4) {
+		this.cleanupInterval = setInterval(() => {
+			this.cleanup();
+		}, cleanupIntervalMs);
+	}
+	async get(key) {
+		const record = this.records.get(key);
+		if (!record) return null;
+		if (record.expiresAt < /* @__PURE__ */ new Date()) {
+			this.records.delete(key);
+			return null;
+		}
+		return record;
+	}
+	async set(key, record) {
+		this.records.set(key, record);
+	}
+	async delete(key) {
+		this.records.delete(key);
+	}
+	async exists(key) {
+		return await this.get(key) !== null;
+	}
+	cleanup() {
+		const now = /* @__PURE__ */ new Date();
+		for (const [key, record] of this.records) if (record.expiresAt < now) this.records.delete(key);
+	}
+	destroy() {
+		if (this.cleanupInterval) {
+			clearInterval(this.cleanupInterval);
+			this.cleanupInterval = null;
+		}
+		this.records.clear();
+	}
+};
+var IdempotencyError = class extends Error {
+	constructor(message, code) {
+		super(message);
+		this.code = code;
+		this.name = "IdempotencyError";
+	}
+};
+/**
+* Idempotency manager
+*/
+var IdempotencyManager = class {
+	store;
+	ttl;
+	prefix;
+	constructor(config = {}) {
+		this.store = config.store ?? new MemoryIdempotencyStore();
+		this.ttl = config.ttl ?? 1440 * 60 * 1e3;
+		this.prefix = config.prefix ?? "idem:";
+	}
+	/**
+	* Generate a unique idempotency key
+	*/
+	generateKey() {
+		return `${this.prefix}${nanoid(21)}`;
+	}
+	/**
+	* Hash request parameters for validation
+	* Uses deterministic JSON serialization and simple hash function
+	*/
+	hashRequest(params) {
+		let normalized;
+		if (params === null || params === void 0) normalized = null;
+		else if (typeof params === "object" && !Array.isArray(params)) normalized = Object.keys(params).sort().reduce((acc, key) => {
+			acc[key] = params[key];
+			return acc;
+		}, {});
+		else normalized = params;
+		const json = JSON.stringify(normalized);
+		let hash = 0;
+		for (let i = 0; i < json.length; i++) {
+			const char = json.charCodeAt(i);
+			hash = (hash << 5) - hash + char;
+			hash = hash & hash;
+		}
+		return Math.abs(hash).toString(36);
+	}
+	/**
+	* Execute operation with idempotency protection
+	*/
+	async execute(key, params, operation) {
+		const fullKey = key.startsWith(this.prefix) ? key : `${this.prefix}${key}`;
+		const requestHash = this.hashRequest(params);
+		const existing = await this.store.get(fullKey);
+		if (existing) {
+			if (existing.requestHash !== requestHash) return err(new IdempotencyError("Idempotency key used with different request parameters", "REQUEST_MISMATCH"));
+			if (existing.status === "completed" && existing.result !== void 0) return ok(existing.result);
+			if (existing.status === "pending") return err(new IdempotencyError("Request with this idempotency key is already in progress", "REQUEST_IN_PROGRESS"));
+			if (existing.status === "failed") await this.store.delete(fullKey);
+		}
+		const record = {
+			key: fullKey,
+			status: "pending",
+			createdAt: /* @__PURE__ */ new Date(),
+			requestHash,
+			expiresAt: new Date(Date.now() + this.ttl)
+		};
+		await this.store.set(fullKey, record);
+		try {
+			const result = await operation();
+			record.status = "completed";
+			record.result = result;
+			record.completedAt = /* @__PURE__ */ new Date();
+			await this.store.set(fullKey, record);
+			return ok(result);
+		} catch (error) {
+			record.status = "failed";
+			await this.store.set(fullKey, record);
+			throw error;
+		}
+	}
+	/**
+	* Check if operation with key was already completed
+	*/
+	async wasCompleted(key) {
+		const fullKey = key.startsWith(this.prefix) ? key : `${this.prefix}${key}`;
+		return (await this.store.get(fullKey))?.status === "completed";
+	}
+	/**
+	* Get cached result for key
+	*/
+	async getCached(key) {
+		const fullKey = key.startsWith(this.prefix) ? key : `${this.prefix}${key}`;
+		const record = await this.store.get(fullKey);
+		return record?.status === "completed" ? record.result ?? null : null;
+	}
+	/**
+	* Invalidate a key (force re-execution on next call)
+	*/
+	async invalidate(key) {
+		const fullKey = key.startsWith(this.prefix) ? key : `${this.prefix}${key}`;
+		await this.store.delete(fullKey);
+	}
+	/**
+	* Destroy the idempotency manager and cleanup resources
+	* Call this when shutting down to prevent memory leaks
+	*/
+	destroy() {
+		if (this.store instanceof MemoryIdempotencyStore) this.store.destroy();
+	}
+};
+/**
+* Create idempotency manager
+*/
+function createIdempotencyManager(config) {
+	return new IdempotencyManager(config);
+}
+
+//#endregion
+export { createIdempotencyManager as n, IdempotencyManager as t };