@umituz/web-payment 0.0.0-stage → 1.0.0

package/dist/product.mapper-CnY1ISOp.d.ts

@@ -0,0 +1,97 @@
+import { b as BillingCycle } from './billing-cycle.enum--hJRYlgP.js';
+
+declare const POLAR_AMOUNT_TYPE: Readonly<{
+    readonly FIXED: "fixed";
+    readonly CUSTOM: "custom";
+    readonly FREE: "free";
+    readonly SEAT_BASED: "seat_based";
+    readonly METERED_UNIT: "metered_unit";
+}>;
+type AmountType = (typeof POLAR_AMOUNT_TYPE)[keyof typeof POLAR_AMOUNT_TYPE];
+
+interface ProductDto {
+    id: string;
+    name: string;
+    description: string | null;
+    is_recurring: boolean;
+    recurring_interval: string | null;
+    is_archived: boolean;
+    organization_id: string;
+    prices: ProductPriceDto[];
+    benefits: ProductBenefitDto[];
+    metadata: Record<string, unknown>;
+    created_at: string;
+    modified_at: string | null;
+}
+interface ProductPriceDto {
+    id: string;
+    type: string;
+    amount_type: string;
+    amount?: number;
+    currency: string;
+    recurring_interval?: string;
+    is_archived: boolean;
+    product_id: string;
+    legacy?: boolean;
+}
+interface ProductBenefitDto {
+    id: string;
+    type: string;
+    description: string | null;
+    properties: Record<string, unknown>;
+}
+interface ProductListResponseDto {
+    items: ProductDto[];
+    pagination: {
+        total_count: number;
+        max_page: number;
+    };
+}
+interface ProductPrice {
+    id: string;
+    type: AmountType;
+    amountType: AmountType;
+    amount?: number;
+    currency: string;
+    recurringInterval?: BillingCycle;
+    isArchived: boolean;
+    productId: string;
+    legacy?: boolean;
+}
+interface ProductBenefit {
+    id: string;
+    type: string;
+    description: string | null;
+    properties: Record<string, unknown>;
+}
+interface Product {
+    id: string;
+    name: string;
+    description: string | null;
+    isRecurring: boolean;
+    recurringInterval: BillingCycle | null;
+    isArchived: boolean;
+    organizationId: string;
+    prices: ProductPrice[];
+    benefits: ProductBenefit[];
+    metadata: Record<string, unknown>;
+    createdAt: string;
+    modifiedAt: string | null;
+}
+interface ProductListResponse {
+    items: Product[];
+    pagination: {
+        totalCount: number;
+        maxPage: number;
+    };
+}
+interface ProductListParams {
+    organizationId?: string;
+    isRecurring?: boolean;
+    page?: number;
+    limit?: number;
+}
+declare function mapProduct(dto: ProductDto | null | undefined): Product;
+declare function mapProductList(dto: ProductListResponseDto | null | undefined): ProductListResponse;
+
+export { type AmountType as A, POLAR_AMOUNT_TYPE as P, type Product as a, type ProductBenefit as b, type ProductBenefitDto as c, type ProductDto as d, type ProductListParams as e, type ProductListResponse as f, type ProductListResponseDto as g, type ProductPrice as h, type ProductPriceDto as i, mapProductList as j, mapProduct as m };

package/dist/product.mapper-noVl-sel.d.mts

@@ -0,0 +1,97 @@
+import { b as BillingCycle } from './billing-cycle.enum--hJRYlgP.mjs';
+
+declare const POLAR_AMOUNT_TYPE: Readonly<{
+    readonly FIXED: "fixed";
+    readonly CUSTOM: "custom";
+    readonly FREE: "free";
+    readonly SEAT_BASED: "seat_based";
+    readonly METERED_UNIT: "metered_unit";
+}>;
+type AmountType = (typeof POLAR_AMOUNT_TYPE)[keyof typeof POLAR_AMOUNT_TYPE];
+
+interface ProductDto {
+    id: string;
+    name: string;
+    description: string | null;
+    is_recurring: boolean;
+    recurring_interval: string | null;
+    is_archived: boolean;
+    organization_id: string;
+    prices: ProductPriceDto[];
+    benefits: ProductBenefitDto[];
+    metadata: Record<string, unknown>;
+    created_at: string;
+    modified_at: string | null;
+}
+interface ProductPriceDto {
+    id: string;
+    type: string;
+    amount_type: string;
+    amount?: number;
+    currency: string;
+    recurring_interval?: string;
+    is_archived: boolean;
+    product_id: string;
+    legacy?: boolean;
+}
+interface ProductBenefitDto {
+    id: string;
+    type: string;
+    description: string | null;
+    properties: Record<string, unknown>;
+}
+interface ProductListResponseDto {
+    items: ProductDto[];
+    pagination: {
+        total_count: number;
+        max_page: number;
+    };
+}
+interface ProductPrice {
+    id: string;
+    type: AmountType;
+    amountType: AmountType;
+    amount?: number;
+    currency: string;
+    recurringInterval?: BillingCycle;
+    isArchived: boolean;
+    productId: string;
+    legacy?: boolean;
+}
+interface ProductBenefit {
+    id: string;
+    type: string;
+    description: string | null;
+    properties: Record<string, unknown>;
+}
+interface Product {
+    id: string;
+    name: string;
+    description: string | null;
+    isRecurring: boolean;
+    recurringInterval: BillingCycle | null;
+    isArchived: boolean;
+    organizationId: string;
+    prices: ProductPrice[];
+    benefits: ProductBenefit[];
+    metadata: Record<string, unknown>;
+    createdAt: string;
+    modifiedAt: string | null;
+}
+interface ProductListResponse {
+    items: Product[];
+    pagination: {
+        totalCount: number;
+        maxPage: number;
+    };
+}
+interface ProductListParams {
+    organizationId?: string;
+    isRecurring?: boolean;
+    page?: number;
+    limit?: number;
+}
+declare function mapProduct(dto: ProductDto | null | undefined): Product;
+declare function mapProductList(dto: ProductListResponseDto | null | undefined): ProductListResponse;
+
+export { type AmountType as A, POLAR_AMOUNT_TYPE as P, type Product as a, type ProductBenefit as b, type ProductBenefitDto as c, type ProductDto as d, type ProductListParams as e, type ProductListResponse as f, type ProductListResponseDto as g, type ProductPrice as h, type ProductPriceDto as i, mapProductList as j, mapProduct as m };

package/dist/products.d.mts

@@ -0,0 +1,64 @@
+import { e as ProductListParams, f as ProductListResponse, a as Product } from './product.mapper-noVl-sel.mjs';
+import './billing-cycle.enum--hJRYlgP.mjs';
+
+interface HttpRequest {
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    url: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+interface HttpResponse<T> {
+    status: number;
+    ok: boolean;
+    data: T | null;
+    text(): Promise<string>;
+}
+interface HttpClient {
+    request<T>(request: HttpRequest): Promise<HttpResponse<T>>;
+}
+declare class FetchHttpClient implements HttpClient {
+    request<T>(request: HttpRequest): Promise<HttpResponse<T>>;
+}
+
+interface ProductApiConfig {
+    apiToken: string;
+    baseUrl?: string;
+}
+interface ProductRequestOptions {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+declare class BillingApiError extends Error {
+    readonly status: number;
+    readonly body?: string | undefined;
+    constructor(message: string, status: number, body?: string | undefined);
+}
+declare function isBillingApiError(error: unknown): error is BillingApiError;
+declare class ProductRepository {
+    private readonly http;
+    private readonly apiToken;
+    private readonly baseUrl;
+    constructor(config: ProductApiConfig, http?: HttpClient);
+    list(params?: ProductListParams, options?: ProductRequestOptions): Promise<ProductListResponse>;
+    findById(productId: string, options?: ProductRequestOptions): Promise<Product | null>;
+    iterateAll(params?: Omit<ProductListParams, 'page' | 'limit'>, options?: {
+        limit?: number;
+        signal?: AbortSignal;
+    }): AsyncIterable<Product>;
+    listAll(params?: Omit<ProductListParams, 'page' | 'limit'>, options?: {
+        limit?: number;
+        signal?: AbortSignal;
+    }): Promise<Product[]>;
+    private authHeaders;
+    private clampLimit;
+}
+declare function getProducts(config: ProductApiConfig, params?: ProductListParams, options?: ProductRequestOptions): Promise<ProductListResponse>;
+declare function getProductById(config: ProductApiConfig, productId: string, options?: ProductRequestOptions): Promise<Product | null>;
+declare function getAllProducts(config: ProductApiConfig, params?: Omit<ProductListParams, 'page' | 'limit'>, options?: {
+    limit?: number;
+    signal?: AbortSignal;
+}): Promise<Product[]>;
+
+export { BillingApiError, FetchHttpClient, type HttpClient, type HttpRequest, type HttpResponse, type ProductApiConfig, ProductRepository, type ProductRequestOptions, getAllProducts, getProductById, getProducts, isBillingApiError };

package/dist/products.d.ts

@@ -0,0 +1,64 @@
+import { e as ProductListParams, f as ProductListResponse, a as Product } from './product.mapper-CnY1ISOp.js';
+import './billing-cycle.enum--hJRYlgP.js';
+
+interface HttpRequest {
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    url: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+interface HttpResponse<T> {
+    status: number;
+    ok: boolean;
+    data: T | null;
+    text(): Promise<string>;
+}
+interface HttpClient {
+    request<T>(request: HttpRequest): Promise<HttpResponse<T>>;
+}
+declare class FetchHttpClient implements HttpClient {
+    request<T>(request: HttpRequest): Promise<HttpResponse<T>>;
+}
+
+interface ProductApiConfig {
+    apiToken: string;
+    baseUrl?: string;
+}
+interface ProductRequestOptions {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+declare class BillingApiError extends Error {
+    readonly status: number;
+    readonly body?: string | undefined;
+    constructor(message: string, status: number, body?: string | undefined);
+}
+declare function isBillingApiError(error: unknown): error is BillingApiError;
+declare class ProductRepository {
+    private readonly http;
+    private readonly apiToken;
+    private readonly baseUrl;
+    constructor(config: ProductApiConfig, http?: HttpClient);
+    list(params?: ProductListParams, options?: ProductRequestOptions): Promise<ProductListResponse>;
+    findById(productId: string, options?: ProductRequestOptions): Promise<Product | null>;
+    iterateAll(params?: Omit<ProductListParams, 'page' | 'limit'>, options?: {
+        limit?: number;
+        signal?: AbortSignal;
+    }): AsyncIterable<Product>;
+    listAll(params?: Omit<ProductListParams, 'page' | 'limit'>, options?: {
+        limit?: number;
+        signal?: AbortSignal;
+    }): Promise<Product[]>;
+    private authHeaders;
+    private clampLimit;
+}
+declare function getProducts(config: ProductApiConfig, params?: ProductListParams, options?: ProductRequestOptions): Promise<ProductListResponse>;
+declare function getProductById(config: ProductApiConfig, productId: string, options?: ProductRequestOptions): Promise<Product | null>;
+declare function getAllProducts(config: ProductApiConfig, params?: Omit<ProductListParams, 'page' | 'limit'>, options?: {
+    limit?: number;
+    signal?: AbortSignal;
+}): Promise<Product[]>;
+
+export { BillingApiError, FetchHttpClient, type HttpClient, type HttpRequest, type HttpResponse, type ProductApiConfig, ProductRepository, type ProductRequestOptions, getAllProducts, getProductById, getProducts, isBillingApiError };

package/dist/products.js

@@ -0,0 +1,370 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/products.ts
+var products_exports = {};
+__export(products_exports, {
+  BillingApiError: () => BillingApiError,
+  FetchHttpClient: () => FetchHttpClient,
+  ProductRepository: () => ProductRepository,
+  getAllProducts: () => getAllProducts,
+  getProductById: () => getProductById,
+  getProducts: () => getProducts,
+  isBillingApiError: () => isBillingApiError
+});
+module.exports = __toCommonJS(products_exports);
+
+// src/infrastructure/constants/billing.constants.ts
+var API_BASE_URL = "https://api.polar.sh/v1";
+var API_MAX_PAGE_SIZE = 100;
+
+// src/infrastructure/http/http-client.ts
+var DEFAULT_TIMEOUT_MS = 15e3;
+var FetchHttpClient = class {
+  async request(request) {
+    const init = {
+      method: request.method,
+      headers: {
+        Accept: "application/json",
+        ...request.headers ?? {}
+      }
+    };
+    if (request.body !== void 0) {
+      init.body = JSON.stringify(request.body);
+      init.headers["Content-Type"] = "application/json";
+    }
+    const timeoutMs = request.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const controller = new AbortController();
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeoutMs);
+    const forwardAbort = () => controller.abort();
+    if (request.signal) {
+      if (request.signal.aborted) controller.abort();
+      else request.signal.addEventListener("abort", forwardAbort);
+    }
+    init.signal = controller.signal;
+    let response;
+    try {
+      response = await fetch(request.url, init);
+    } catch (error) {
+      if (timedOut && error instanceof Error && error.name === "AbortError") {
+        throw new DOMException(`Request timed out after ${timeoutMs}ms`, "TimeoutError");
+      }
+      throw error;
+    } finally {
+      clearTimeout(timer);
+      request.signal?.removeEventListener("abort", forwardAbort);
+    }
+    const bodyText = await response.text();
+    let data = null;
+    if (bodyText.length > 0) {
+      try {
+        data = JSON.parse(bodyText);
+      } catch {
+        data = null;
+      }
+    }
+    return {
+      status: response.status,
+      ok: response.ok,
+      data,
+      text: async () => bodyText
+    };
+  }
+};
+
+// src/infrastructure/query/query-builder.ts
+var QueryBuilder = class {
+  params;
+  constructor(initial) {
+    this.params = new URLSearchParams();
+    if (initial) this.setMany(initial);
+  }
+  set(key, value) {
+    if (value === void 0 || value === null) return this;
+    this.params.set(key, String(value));
+    return this;
+  }
+  setMany(values) {
+    for (const [key, value] of Object.entries(values)) {
+      this.set(key, value);
+    }
+    return this;
+  }
+  toString() {
+    return this.params.toString();
+  }
+};
+
+// src/infrastructure/pagination/page-iterator.ts
+var PageIterator = class {
+  fetcher;
+  limit;
+  signal;
+  constructor(fetcher, options = {}) {
+    this.fetcher = fetcher;
+    this.limit = options.limit ?? 100;
+    this.signal = options.signal;
+  }
+  async *[Symbol.asyncIterator]() {
+    let page = 1;
+    while (true) {
+      if (this.signal?.aborted) return;
+      const current = await this.fetcher.fetchPage(page, this.limit);
+      for (const item of current.items) {
+        if (this.signal?.aborted) return;
+        yield item;
+      }
+      if (current.isLast || page >= current.maxPage) return;
+      page++;
+    }
+  }
+};
+
+// src/infrastructure/utils/pagination-clamp.ts
+var MIN_PAGE_SIZE = 1;
+var PaginationClamp = class {
+  static pageSize(raw, max = API_MAX_PAGE_SIZE) {
+    if (raw === void 0) return max;
+    return Math.min(Math.max(MIN_PAGE_SIZE, raw), max);
+  }
+};
+
+// src/domain/enums/billing-cycle.enum.ts
+var BILLING_CYCLE = Object.freeze({
+  MONTHLY: "monthly",
+  YEARLY: "yearly"
+});
+var BILLING_CYCLE_VALUES = Object.freeze([
+  BILLING_CYCLE.MONTHLY,
+  BILLING_CYCLE.YEARLY
+]);
+var CANONICAL_BILLING_CYCLES = new Set(BILLING_CYCLE_VALUES);
+var BILLING_CYCLE_ALIASES = /* @__PURE__ */ new Map([
+  [BILLING_CYCLE.MONTHLY, BILLING_CYCLE.MONTHLY],
+  ["month", BILLING_CYCLE.MONTHLY],
+  [BILLING_CYCLE.YEARLY, BILLING_CYCLE.YEARLY],
+  ["year", BILLING_CYCLE.YEARLY]
+]);
+function parseBillingCycle(value) {
+  if (typeof value !== "string") return null;
+  return BILLING_CYCLE_ALIASES.get(value.toLowerCase()) ?? null;
+}
+
+// src/domain/mappers/product.mapper.ts
+var KNOWN_AMOUNT_TYPES = /* @__PURE__ */ new Set([
+  "fixed",
+  "custom",
+  "free",
+  "seat_based",
+  "metered_unit"
+]);
+function toAmountType(raw) {
+  if (raw && KNOWN_AMOUNT_TYPES.has(raw)) return raw;
+  return "fixed";
+}
+function toBillingCycle(interval) {
+  return parseBillingCycle(interval);
+}
+function asRecord(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function toPrice(dto) {
+  return {
+    id: String(dto.id),
+    type: toAmountType(dto.type),
+    amountType: toAmountType(dto.amount_type),
+    amount: typeof dto.amount === "number" ? dto.amount : void 0,
+    currency: String(dto.currency),
+    recurringInterval: toBillingCycle(dto.recurring_interval) ?? void 0,
+    isArchived: Boolean(dto.is_archived),
+    productId: String(dto.product_id),
+    legacy: Boolean(dto.legacy)
+  };
+}
+function toBenefit(dto) {
+  return {
+    id: String(dto.id),
+    type: String(dto.type),
+    description: dto.description ?? null,
+    properties: asRecord(dto.properties)
+  };
+}
+function mapProduct(dto) {
+  if (!dto || typeof dto !== "object") {
+    throw new TypeError("mapProduct: expected a product DTO object");
+  }
+  return {
+    id: String(dto.id),
+    name: String(dto.name),
+    description: dto.description ?? null,
+    isRecurring: Boolean(dto.is_recurring),
+    recurringInterval: toBillingCycle(dto.recurring_interval),
+    isArchived: Boolean(dto.is_archived),
+    organizationId: String(dto.organization_id),
+    prices: Array.isArray(dto.prices) ? dto.prices.map(toPrice) : [],
+    benefits: Array.isArray(dto.benefits) ? dto.benefits.map(toBenefit) : [],
+    metadata: asRecord(dto.metadata),
+    createdAt: String(dto.created_at),
+    modifiedAt: dto.modified_at ?? null
+  };
+}
+function mapProductList(dto) {
+  if (!dto || typeof dto !== "object") {
+    return { items: [], pagination: { totalCount: 0, maxPage: 1 } };
+  }
+  return {
+    items: Array.isArray(dto.items) ? dto.items.map(mapProduct) : [],
+    pagination: {
+      totalCount: Number(dto.pagination?.total_count ?? 0),
+      maxPage: Number(dto.pagination?.max_page ?? 1)
+    }
+  };
+}
+
+// src/infrastructure/services/product.repository.ts
+var BillingApiError = class _BillingApiError extends Error {
+  constructor(message, status, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "BillingApiError";
+    Object.setPrototypeOf(this, _BillingApiError.prototype);
+  }
+};
+function isBillingApiError(error) {
+  return error instanceof BillingApiError;
+}
+var ProductRepository = class {
+  http;
+  apiToken;
+  baseUrl;
+  constructor(config, http = new FetchHttpClient()) {
+    this.http = http;
+    this.apiToken = config.apiToken;
+    this.baseUrl = config.baseUrl ?? API_BASE_URL;
+  }
+  async list(params, options) {
+    const query = new QueryBuilder({
+      organization_id: params?.organizationId,
+      is_recurring: params?.isRecurring,
+      page: params?.page,
+      limit: this.clampLimit(params?.limit)
+    });
+    const url = `${this.baseUrl}/products?${query.toString()}`;
+    const response = await this.http.request({
+      method: "GET",
+      url,
+      headers: this.authHeaders(),
+      signal: options?.signal,
+      timeoutMs: options?.timeoutMs
+    });
+    if (!response.ok) {
+      const body = await response.text();
+      throw new BillingApiError(
+        `Billing API error: ${response.status}`,
+        response.status,
+        body
+      );
+    }
+    return mapProductList(response.data);
+  }
+  async findById(productId, options) {
+    const url = `${this.baseUrl}/products/${encodeURIComponent(productId)}`;
+    const response = await this.http.request({
+      method: "GET",
+      url,
+      headers: this.authHeaders(),
+      signal: options?.signal,
+      timeoutMs: options?.timeoutMs
+    });
+    if (response.status === 404) return null;
+    if (!response.ok) {
+      const body = await response.text();
+      throw new BillingApiError(
+        `Billing API error: ${response.status}`,
+        response.status,
+        body
+      );
+    }
+    if (!response.data) {
+      throw new BillingApiError(
+        "Billing API returned an empty product body",
+        response.status
+      );
+    }
+    return mapProduct(response.data);
+  }
+  iterateAll(params, options = {}) {
+    const limit = this.clampLimit(options.limit);
+    const fetcher = {
+      fetchPage: async (page, pageLimit) => {
+        const response = await this.list(
+          { ...params, page, limit: pageLimit },
+          { signal: options.signal }
+        );
+        const pageData = {
+          items: response.items,
+          page,
+          totalCount: response.pagination.totalCount,
+          maxPage: response.pagination.maxPage,
+          isLast: page >= response.pagination.maxPage
+        };
+        return pageData;
+      }
+    };
+    return new PageIterator(fetcher, { limit, signal: options.signal });
+  }
+  async listAll(params, options = {}) {
+    const out = [];
+    for await (const product of this.iterateAll(params, options)) {
+      out.push(product);
+    }
+    return out;
+  }
+  authHeaders() {
+    return { Authorization: `Bearer ${this.apiToken}` };
+  }
+  clampLimit(limit) {
+    return PaginationClamp.pageSize(limit, API_MAX_PAGE_SIZE);
+  }
+};
+var defaultClient = new FetchHttpClient();
+async function getProducts(config, params, options) {
+  return new ProductRepository(config, defaultClient).list(params, options);
+}
+async function getProductById(config, productId, options) {
+  return new ProductRepository(config, defaultClient).findById(productId, options);
+}
+async function getAllProducts(config, params, options = {}) {
+  return new ProductRepository(config, defaultClient).listAll(params, options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BillingApiError,
+  FetchHttpClient,
+  ProductRepository,
+  getAllProducts,
+  getProductById,
+  getProducts,
+  isBillingApiError
+});