@carlonicora/nextjs-jsonapi 1.15.0 → 1.16.0

package/src/features/billing/stripe-product/components/lists/ProductsList.tsx

@@ -0,0 +1,206 @@
+"use client";
+
+import { Archive, ChevronDown, ChevronUp, Edit, Package, RefreshCw } from "lucide-react";
+import { useState } from "react";
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+  Button,
+} from "../../../../../shadcnui";
+import { PricesList } from "../../../stripe-price/components/lists/PricesList";
+import { StripeProductInterface } from "../../data/stripe-product.interface";
+import { StripeProductService } from "../../data/stripe-product.service";
+import { ProductEditor } from "../forms/ProductEditor";
+
+type ProductsListProps = {
+  products: StripeProductInterface[];
+  onProductsChange: () => void;
+};
+
+export function ProductsList({ products, onProductsChange }: ProductsListProps) {
+  const [expandedProductId, setExpandedProductId] = useState<string | null>(null);
+  const [editingProduct, setEditingProduct] = useState<StripeProductInterface | null>(null);
+  const [archivingProductId, setArchivingProductId] = useState<string | null>(null);
+  const [reactivatingProductId, setReactivatingProductId] = useState<string | null>(null);
+  const [productToArchive, setProductToArchive] = useState<StripeProductInterface | null>(null);
+  const [productToReactivate, setProductToReactivate] = useState<StripeProductInterface | null>(null);
+
+  const handleArchive = async () => {
+    if (!productToArchive) {
+      return;
+    }
+
+    setArchivingProductId(productToArchive.id);
+    try {
+      const archivedProduct = await StripeProductService.archiveProduct({ id: productToArchive.id });
+      setProductToArchive(null); // Close dialog on success
+      onProductsChange();
+    } catch (error) {
+      console.error("[ProductsList] Failed to archive product:", error);
+      // Keep dialog open on error so user can retry or cancel
+    } finally {
+      setArchivingProductId(null);
+    }
+  };
+
+  const handleReactivate = async () => {
+    if (!productToReactivate) {
+      return;
+    }
+
+    setReactivatingProductId(productToReactivate.id);
+    try {
+      const reactivatedProduct = await StripeProductService.reactivateProduct({ id: productToReactivate.id });
+      setProductToReactivate(null); // Close dialog on success
+      onProductsChange();
+    } catch (error) {
+      // Keep dialog open on error so user can retry or cancel
+    } finally {
+      setReactivatingProductId(null);
+    }
+  };
+
+  const toggleExpand = (productId: string) => {
+    setExpandedProductId(expandedProductId === productId ? null : productId);
+  };
+
+  return (
+    <div className="flex flex-col gap-y-4">
+      {products.map((product) => {
+        const isExpanded = expandedProductId === product.id;
+        const isArchiving = archivingProductId === product.id;
+        const isReactivating = reactivatingProductId === product.id;
+
+        return (
+          <div key={product.id} className="border rounded-lg bg-white shadow-sm hover:shadow-md transition-shadow">
+            {/* Product Card Header */}
+            <div className="flex items-center justify-between p-6">
+              <div className="flex items-center gap-x-4 flex-1">
+                <Package className="h-6 w-6 text-primary" />
+                <div className="flex-1">
+                  <div className="flex items-center gap-x-3">
+                    <h3 className="text-lg font-semibold">{product.name}</h3>
+                    {product.active ? (
+                      <span className="bg-green-100 text-green-800 text-xs px-2 py-1 rounded-full font-medium">
+                        Active
+                      </span>
+                    ) : (
+                      <span className="bg-gray-100 text-gray-800 text-xs px-2 py-1 rounded-full font-medium">
+                        Inactive
+                      </span>
+                    )}
+                  </div>
+                  {product.description && <p className="text-muted-foreground text-sm mt-1">{product.description}</p>}
+                </div>
+              </div>
+
+              {/* Action Buttons */}
+              <div className="flex items-center gap-x-2">
+                <Button variant="outline" size="sm" onClick={() => setEditingProduct(product)}>
+                  <Edit className="h-4 w-4 mr-1" />
+                  Edit
+                </Button>
+                {product.active ? (
+                  <Button
+                    variant="outline"
+                    size="sm"
+                    onClick={() => setProductToArchive(product)}
+                    disabled={isArchiving}
+                  >
+                    <Archive className="h-4 w-4 mr-1" />
+                    {isArchiving ? "Archiving..." : "Archive"}
+                  </Button>
+                ) : (
+                  <Button
+                    variant="outline"
+                    size="sm"
+                    onClick={() => setProductToReactivate(product)}
+                    disabled={isReactivating}
+                  >
+                    <RefreshCw className="h-4 w-4 mr-1" />
+                    {isReactivating ? "Reactivating..." : "Reactivate"}
+                  </Button>
+                )}
+                <Button variant="ghost" size="sm" onClick={() => toggleExpand(product.id)}>
+                  {isExpanded ? <ChevronUp className="h-5 w-5" /> : <ChevronDown className="h-5 w-5" />}
+                </Button>
+              </div>
+            </div>
+
+            {/* Expandable Prices Section */}
+            {isExpanded && (
+              <div className="border-t bg-muted/30 p-6">
+                <PricesList productId={product.id} onPricesChange={onProductsChange} />
+              </div>
+            )}
+          </div>
+        );
+      })}
+
+      {/* Edit Product Modal */}
+      {editingProduct && (
+        <ProductEditor
+          product={editingProduct}
+          open={!!editingProduct}
+          onOpenChange={(open) => !open && setEditingProduct(null)}
+          onSuccess={() => {
+            onProductsChange();
+            setEditingProduct(null);
+          }}
+        />
+      )}
+
+      {/* Archive Product Confirmation Dialog */}
+      <AlertDialog open={!!productToArchive} onOpenChange={(open) => !open && setProductToArchive(null)}>
+        <AlertDialogContent>
+          <AlertDialogHeader>
+            <AlertDialogTitle>Archive Product</AlertDialogTitle>
+            <AlertDialogDescription>
+              Are you sure you want to archive &quot;{productToArchive?.name}&quot;? This will deactivate it and it will
+              no longer be available for new subscriptions.
+            </AlertDialogDescription>
+          </AlertDialogHeader>
+          <AlertDialogFooter>
+            <AlertDialogCancel disabled={!!archivingProductId}>Cancel</AlertDialogCancel>
+            <AlertDialogAction
+              onClick={handleArchive}
+              disabled={!!archivingProductId}
+              className="bg-red-600 hover:bg-red-700"
+            >
+              {archivingProductId ? "Archiving..." : "Archive"}
+            </AlertDialogAction>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
+
+      {/* Reactivate Product Confirmation Dialog */}
+      <AlertDialog open={!!productToReactivate} onOpenChange={(open) => !open && setProductToReactivate(null)}>
+        <AlertDialogContent>
+          <AlertDialogHeader>
+            <AlertDialogTitle>Reactivate Product</AlertDialogTitle>
+            <AlertDialogDescription>
+              Are you sure you want to reactivate &quot;{productToReactivate?.name}&quot;? This will make it available
+              for new subscriptions again.
+            </AlertDialogDescription>
+          </AlertDialogHeader>
+          <AlertDialogFooter>
+            <AlertDialogCancel disabled={!!reactivatingProductId}>Cancel</AlertDialogCancel>
+            <AlertDialogAction
+              onClick={handleReactivate}
+              disabled={!!reactivatingProductId}
+              className="bg-green-600 hover:bg-green-700"
+            >
+              {reactivatingProductId ? "Reactivating..." : "Reactivate"}
+            </AlertDialogAction>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
+    </div>
+  );
+}

package/src/features/billing/stripe-product/components/lists/index.ts

@@ -0,0 +1 @@
+export * from "./ProductsList";

package/src/features/billing/stripe-product/data/index.ts

@@ -0,0 +1,3 @@
+export * from "./stripe-product";
+export * from "./stripe-product.interface";
+export * from "./stripe-product.service";

package/src/features/billing/stripe-product/data/stripe-product.interface.ts

@@ -0,0 +1,18 @@
+import { ApiDataInterface, StripePriceInterface } from "../../../../core";
+
+export interface StripeProductInterface extends ApiDataInterface {
+  get stripeProductId(): string;
+  get name(): string;
+  get description(): string | undefined;
+  get active(): boolean;
+  get metadata(): Record<string, any> | undefined;
+  get stripePrices(): StripePriceInterface[];
+}
+
+export type StripeProductInput = {
+  id: string;
+  name?: string;
+  description?: string;
+  active?: boolean;
+  metadata?: Record<string, any>;
+};

package/src/features/billing/stripe-product/data/stripe-product.service.ts

@@ -0,0 +1,112 @@
+import { AbstractService, EndpointCreator, HttpMethod, Modules, NextRef, PreviousRef } from "../../../../core";
+import { StripeProductInput, StripeProductInterface } from "./stripe-product.interface";
+
+export class StripeProductService extends AbstractService {
+  /**
+   * List all products (admin)
+   */
+  static async listProducts(params?: {
+    active?: boolean;
+    next?: NextRef;
+    prev?: PreviousRef;
+  }): Promise<StripeProductInterface[]> {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.StripeProduct,
+    });
+
+    if (params?.active !== undefined) {
+      endpoint.addAdditionalParam("active", params.active.toString());
+    }
+
+    return this.callApi({
+      type: Modules.StripeProduct,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params?.next,
+      previous: params?.prev,
+    });
+  }
+
+  /**
+   * Get a specific product by ID (admin)
+   */
+  static async getProduct(params: { id: string }): Promise<StripeProductInterface> {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.StripeProduct,
+      id: params.id,
+    });
+
+    return this.callApi<StripeProductInterface>({
+      type: Modules.StripeProduct,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+    });
+  }
+
+  /**
+   * Create a new product (admin)
+   */
+  static async createProduct(params: StripeProductInput): Promise<StripeProductInterface> {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.StripeProduct,
+    });
+
+    return this.callApi<StripeProductInterface>({
+      type: Modules.StripeProduct,
+      method: HttpMethod.POST,
+      endpoint: endpoint.generate(),
+      input: params,
+    });
+  }
+
+  /**
+   * Update an existing product (admin)
+   */
+  static async updateProduct(params: StripeProductInput): Promise<StripeProductInterface> {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.StripeProduct,
+      id: params.id,
+    });
+
+    return this.callApi<StripeProductInterface>({
+      type: Modules.StripeProduct,
+      method: HttpMethod.PUT,
+      endpoint: endpoint.generate(),
+      input: params,
+    });
+  }
+
+  /**
+   * Archive a product (admin)
+   */
+  static async archiveProduct(params: { id: string }): Promise<StripeProductInterface> {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.StripeProduct,
+      id: params.id,
+      childEndpoint: "archive",
+    });
+
+    return this.callApi<StripeProductInterface>({
+      type: Modules.StripeProduct,
+      method: HttpMethod.POST,
+      endpoint: endpoint.generate(),
+    });
+  }
+
+  /**
+   * Reactivate a product (admin) - sets active to true
+   */
+  static async reactivateProduct(params: { id: string }): Promise<StripeProductInterface> {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.StripeProduct,
+      id: params.id,
+      childEndpoint: "archive",
+    });
+
+    return this.callApi<StripeProductInterface>({
+      type: Modules.StripeProduct,
+      method: HttpMethod.DELETE,
+      endpoint: endpoint.generate(),
+    });
+  }
+}

package/src/features/billing/stripe-product/data/stripe-product.ts

@@ -0,0 +1,74 @@
+import { AbstractApiData, JsonApiHydratedDataInterface, Modules, StripePriceInterface } from "../../../../core";
+import { StripeProductInput, StripeProductInterface } from "./stripe-product.interface";
+
+export class StripeProduct extends AbstractApiData implements StripeProductInterface {
+  private _stripeProductId?: string;
+  private _name?: string;
+  private _description?: string;
+  private _active: boolean = true;
+  private _metadata?: Record<string, any>;
+
+  private _stripePrices: StripePriceInterface[] = [];
+
+  get stripeProductId(): string {
+    if (!this._stripeProductId) throw new Error("stripeProductId is not defined");
+    return this._stripeProductId;
+  }
+
+  get name(): string {
+    if (!this._name) throw new Error("name is not defined");
+    return this._name;
+  }
+
+  get description(): string | undefined {
+    return this._description;
+  }
+
+  get active(): boolean {
+    return this._active;
+  }
+
+  get metadata(): Record<string, any> | undefined {
+    return this._metadata;
+  }
+
+  get stripePrices(): StripePriceInterface[] {
+    return this._stripePrices ?? [];
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    this._stripeProductId = data.jsonApi.attributes.stripeProductId;
+    this._name = data.jsonApi.attributes.name;
+    this._description = data.jsonApi.attributes.description;
+    this._active = data.jsonApi.attributes.active ?? true;
+
+    this._metadata = data.jsonApi.attributes.metadata
+      ? typeof data.jsonApi.attributes.metadata === "string"
+        ? JSON.parse(data.jsonApi.attributes.metadata)
+        : data.jsonApi.attributes.metadata
+      : undefined;
+
+    this._stripePrices = this._readIncluded(data, "stripePrices", Modules.StripePrice) as StripePriceInterface[];
+
+    return this;
+  }
+
+  createJsonApi(data: StripeProductInput): any {
+    const response: any = {
+      data: {
+        type: Modules.StripeProduct.name,
+        id: data.id,
+        attributes: {},
+      },
+    };
+
+    if (data.name) response.data.attributes.name = data.name;
+    if (data.description !== undefined) response.data.attributes.description = data.description;
+    if (data.active !== undefined) response.data.attributes.active = data.active;
+    if (data.metadata) response.data.attributes.metadata = data.metadata;
+
+    return response;
+  }
+}

package/src/features/billing/stripe-product/index.ts

@@ -0,0 +1,2 @@
+export * from "./data";
+export * from "./stripe-product.module";

package/src/features/billing/stripe-product/stripe-product.module.ts

@@ -0,0 +1,9 @@
+import { ModuleFactory } from "../../../permissions";
+import { StripeProduct } from "./data";
+
+export const StripeProductModule = (factory: ModuleFactory) =>
+  factory({
+    name: "stripe-products",
+    model: StripeProduct,
+    moduleId: "f8c4a1e9-3b2d-4f7a-9e5c-1d8a6b3c9f2e",
+  });