@carlonicora/nextjs-jsonapi 1.15.0 → 1.17.0

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

@@ -0,0 +1,123 @@
+import { AbstractService, EndpointCreator, HttpMethod, Modules, NextRef, PreviousRef } from "../../../../core";
+import { StripePriceInput, StripePriceInterface } from "./stripe-price.interface";
+
+/**
+ * Admin billing service for managing products and prices
+ */
+export class StripePriceService extends AbstractService {
+  /**
+   * List all prices (admin)
+   */
+  static async listPrices(params?: {
+    productId?: string;
+    active?: boolean;
+    next?: NextRef;
+    prev?: PreviousRef;
+  }): Promise<StripePriceInterface[]> {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.StripePrice,
+    });
+
+    if (params?.productId) {
+      endpoint.addAdditionalParam("productId", params.productId);
+    }
+    if (params?.active !== undefined) {
+      endpoint.addAdditionalParam("active", params.active.toString());
+    }
+
+    return this.callApi({
+      type: Modules.StripePrice,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params?.next,
+      previous: params?.prev,
+    });
+  }
+
+  /**
+   * Get a specific price by ID (admin)
+   */
+  static async getPrice(params: { id: string }): Promise<StripePriceInterface> {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.StripePrice,
+      id: params.id,
+    });
+
+    return this.callApi<StripePriceInterface>({
+      type: Modules.StripePrice,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+    });
+  }
+
+  /**
+   * Create a new price (admin)
+   */
+  static async createPrice(params: StripePriceInput): Promise<StripePriceInterface> {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.StripePrice,
+    });
+
+    return this.callApi<StripePriceInterface>({
+      type: Modules.StripePrice,
+      method: HttpMethod.POST,
+      endpoint: endpoint.generate(),
+      input: params,
+    });
+  }
+
+  /**
+   * Update an existing price (admin)
+   */
+  static async updatePrice(params: StripePriceInput): Promise<StripePriceInterface> {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.StripePrice,
+      id: params.id,
+    });
+
+    return this.callApi<StripePriceInterface>({
+      type: Modules.StripePrice,
+      method: HttpMethod.PUT,
+      endpoint: endpoint.generate(),
+      input: params,
+    });
+  }
+
+  /**
+   * Archive a price (admin)
+   *
+   * Sets the price as inactive. Archived prices cannot be used for new subscriptions.
+   */
+  static async archivePrice(params: { id: string }): Promise<void> {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.StripePrice,
+      id: params.id,
+      childEndpoint: "archive",
+    });
+
+    await this.callApi({
+      type: Modules.StripePrice,
+      method: HttpMethod.POST,
+      endpoint: endpoint.generate(),
+    });
+  }
+
+  /**
+   * Reactivate a price (admin)
+   *
+   * Sets the price as active. Active prices can be used for new subscriptions.
+   */
+  static async reactivatePrice(params: { id: string }): Promise<void> {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.StripePrice,
+      id: params.id,
+      childEndpoint: "archive",
+    });
+
+    await this.callApi({
+      type: Modules.StripePrice,
+      method: HttpMethod.DELETE,
+      endpoint: endpoint.generate(),
+    });
+  }
+}

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

@@ -0,0 +1,156 @@
+import { AbstractApiData, JsonApiHydratedDataInterface, Modules } from "../../../../core";
+import { StripeProductInterface } from "../../stripe-product";
+import { PriceRecurring, StripePriceInput, StripePriceInterface } from "./stripe-price.interface";
+
+export class StripePrice extends AbstractApiData implements StripePriceInterface {
+  private _stripePriceId?: string;
+  private _productId?: string;
+  private _product?: StripeProductInterface;
+  private _active: boolean = true;
+  private _currency?: string;
+  private _unitAmount?: number;
+  private _recurring?: PriceRecurring;
+  private _priceType?: "one_time" | "recurring";
+  private _nickname?: string;
+  private _lookupKey?: string;
+  private _metadata?: Record<string, any>;
+  private _description?: string;
+  private _features?: string[];
+
+  get stripePriceId(): string {
+    if (!this._stripePriceId) throw new Error("stripePriceId is not defined");
+    return this._stripePriceId;
+  }
+
+  get productId(): string {
+    if (!this._productId) throw new Error("productId is not defined");
+    return this._productId;
+  }
+
+  get product(): StripeProductInterface | undefined {
+    return this._product;
+  }
+
+  get active(): boolean {
+    return this._active;
+  }
+
+  get currency(): string {
+    if (!this._currency) throw new Error("currency is not defined");
+    return this._currency;
+  }
+
+  get unitAmount(): number | undefined {
+    return this._unitAmount;
+  }
+
+  get recurring(): PriceRecurring | undefined {
+    return this._recurring;
+  }
+
+  get priceType(): "one_time" | "recurring" {
+    if (!this._priceType) throw new Error("priceType is not defined");
+    return this._priceType;
+  }
+
+  get nickname(): string | undefined {
+    return this._nickname;
+  }
+
+  get lookupKey(): string | undefined {
+    return this._lookupKey;
+  }
+
+  get metadata(): Record<string, any> | undefined {
+    return this._metadata;
+  }
+
+  get description(): string | undefined {
+    return this._description;
+  }
+
+  get features(): string[] | undefined {
+    return this._features;
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    this._stripePriceId = data.jsonApi.attributes.stripePriceId;
+    this._productId = data.jsonApi.attributes.productId;
+    this._active = data.jsonApi.attributes.active ?? true;
+    this._currency = data.jsonApi.attributes.currency;
+    this._unitAmount = data.jsonApi.attributes.unitAmount;
+    this._priceType = data.jsonApi.attributes.priceType;
+
+    // Construct recurring object from flat attributes
+    if (data.jsonApi.attributes.recurringInterval) {
+      this._recurring = {
+        interval: data.jsonApi.attributes.recurringInterval,
+        intervalCount: data.jsonApi.attributes.recurringIntervalCount ?? 1,
+        usageType: data.jsonApi.attributes.recurringUsageType,
+      };
+    }
+
+    this._nickname = data.jsonApi.attributes.nickname;
+    this._lookupKey = data.jsonApi.attributes.lookupKey;
+
+    this._metadata = data.jsonApi.attributes.metadata
+      ? typeof data.jsonApi.attributes.metadata === "string"
+        ? JSON.parse(data.jsonApi.attributes.metadata)
+        : data.jsonApi.attributes.metadata
+      : undefined;
+
+    this._description = data.jsonApi.attributes.description;
+    this._features = data.jsonApi.attributes.features
+      ? typeof data.jsonApi.attributes.features === "string"
+        ? JSON.parse(data.jsonApi.attributes.features)
+        : data.jsonApi.attributes.features
+      : undefined;
+
+    // Hydrate product relationship
+    this._product = this._readIncluded(data, "product", Modules.StripeProduct) as StripeProductInterface;
+
+    return this;
+  }
+
+  createJsonApi(data: StripePriceInput): any {
+    const response: any = {
+      data: {
+        type: Modules.StripePrice.name,
+        id: data.id,
+        attributes: {},
+      },
+    };
+
+    if ("productId" in data && data.productId) {
+      response.data.attributes.productId = data.productId;
+    }
+    if ("currency" in data && data.currency) {
+      response.data.attributes.currency = data.currency;
+    }
+    if ("unitAmount" in data && data.unitAmount !== undefined) {
+      response.data.attributes.unitAmount = data.unitAmount;
+    }
+    if ("active" in data && data.active !== undefined) {
+      response.data.attributes.active = data.active;
+    }
+    if ("nickname" in data && data.nickname !== undefined) {
+      response.data.attributes.nickname = data.nickname;
+    }
+    if ("metadata" in data && data.metadata) {
+      response.data.attributes.metadata = data.metadata;
+    }
+    if ("recurring" in data && data.recurring) {
+      response.data.attributes.recurring = data.recurring;
+    }
+    if ("description" in data && data.description !== undefined) {
+      response.data.attributes.description = data.description;
+    }
+    if ("features" in data && data.features !== undefined) {
+      response.data.attributes.features = JSON.stringify(data.features);
+    }
+
+    return response;
+  }
+}

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

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

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

@@ -0,0 +1,9 @@
+import { ModuleFactory } from "../../../permissions";
+import { StripePrice } from "./data/stripe-price";
+
+export const StripePriceModule = (factory: ModuleFactory) =>
+  factory({
+    name: "stripe-prices",
+    model: StripePrice,
+    moduleId: "a7d3e5f1-8c9b-4a2e-b6d7-3f1c8e9a4b5d",
+  });

package/src/features/billing/stripe-product/components/containers/ProductsAdminContainer.tsx

@@ -0,0 +1,86 @@
+"use client";
+
+import { Package } from "lucide-react";
+import { useEffect, useState } from "react";
+import { getRoleId } from "../../../../../roles";
+import { Button } from "../../../../../shadcnui";
+import { useCurrentUserContext } from "../../../../user/contexts";
+import { StripeProductInterface } from "../../data/stripe-product.interface";
+import { StripeProductService } from "../../data/stripe-product.service";
+import { ProductEditor } from "../forms/ProductEditor";
+import { ProductsList } from "../lists/ProductsList";
+
+export function ProductsAdminContainer() {
+  const { hasRole } = useCurrentUserContext();
+  const [products, setProducts] = useState<StripeProductInterface[]>([]);
+  const [loading, setLoading] = useState<boolean>(true);
+  const [showCreateProduct, setShowCreateProduct] = useState<boolean>(false);
+
+  // Check if user has Administrator role
+  if (!hasRole(getRoleId().Administrator)) {
+    return (
+      <div className="flex h-64 items-center justify-center">
+        <p className="text-red-600 font-semibold">Permission denied. Administrator access required.</p>
+      </div>
+    );
+  }
+
+  const loadProducts = async () => {
+    setLoading(true);
+    try {
+      const fetchedProducts = await StripeProductService.listProducts();
+      setProducts(fetchedProducts);
+    } catch (error) {
+      console.error("[ProductsAdminContainer] Failed to load products:", error);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  useEffect(() => {
+    loadProducts();
+  }, []);
+
+  if (loading) {
+    return (
+      <div className="flex h-64 items-center justify-center">
+        <p className="text-muted-foreground">Loading products...</p>
+      </div>
+    );
+  }
+
+  return (
+    <div className="flex w-full flex-col gap-y-6">
+      {/* Header */}
+      <div className="flex items-center justify-between">
+        <div className="flex items-center gap-x-3">
+          <Package className="h-8 w-8" />
+          <h1 className="text-3xl font-bold">Product & Price Management</h1>
+        </div>
+        <Button onClick={() => setShowCreateProduct(true)}>Create Product</Button>
+      </div>
+
+      {/* Empty State */}
+      {products.length === 0 && (
+        <div className="bg-muted/50 flex flex-col items-center justify-center gap-y-4 rounded-lg border-2 border-dashed p-12">
+          <Package className="text-muted-foreground h-16 w-16" />
+          <div className="text-center">
+            <h3 className="mb-2 text-xl font-semibold">No products yet</h3>
+            <p className="text-muted-foreground mb-4">
+              Create your first product to start offering subscriptions to your customers.
+            </p>
+            <Button onClick={() => setShowCreateProduct(true)}>Create Your First Product</Button>
+          </div>
+        </div>
+      )}
+
+      {/* Products List */}
+      {products.length > 0 && <ProductsList products={products} onProductsChange={loadProducts} />}
+
+      {/* Create Product Modal */}
+      {showCreateProduct && (
+        <ProductEditor open={showCreateProduct} onOpenChange={setShowCreateProduct} onSuccess={loadProducts} />
+      )}
+    </div>
+  );
+}

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

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

package/src/features/billing/stripe-product/components/forms/ProductEditor.tsx

@@ -0,0 +1,100 @@
+"use client";
+
+import { zodResolver } from "@hookform/resolvers/zod";
+import { useState } from "react";
+import { SubmitHandler, useForm } from "react-hook-form";
+import { v4 } from "uuid";
+import { z } from "zod";
+import { FormCheckbox, FormInput, FormTextarea } from "../../../../../components";
+import { CommonEditorButtons } from "../../../../../components/forms/CommonEditorButtons";
+import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle, Form } from "../../../../../shadcnui";
+import { StripeProductInterface } from "../../data/stripe-product.interface";
+import { StripeProductService } from "../../data/stripe-product.service";
+
+type ProductEditorProps = {
+  product?: StripeProductInterface;
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  onSuccess: () => void;
+};
+
+export function ProductEditor({ product, open, onOpenChange, onSuccess }: ProductEditorProps) {
+  const [isSubmitting, setIsSubmitting] = useState<boolean>(false);
+
+  const formSchema = z.object({
+    name: z.string().min(1, { message: "Product name is required" }),
+    description: z.string().optional(),
+    active: z.boolean(),
+  });
+
+  const form = useForm<z.infer<typeof formSchema>>({
+    resolver: zodResolver(formSchema),
+    defaultValues: {
+      name: product?.name || "",
+      description: product?.description || "",
+      active: product?.active ?? true,
+    },
+  });
+
+  const onSubmit: SubmitHandler<z.infer<typeof formSchema>> = async (values) => {
+    setIsSubmitting(true);
+
+    try {
+      if (product) {
+        // Update existing product
+        await StripeProductService.updateProduct({
+          id: product.id,
+          name: values.name,
+          description: values.description,
+          active: values.active,
+        });
+      } else {
+        // Create new product
+        await StripeProductService.createProduct({
+          id: v4(),
+          name: values.name,
+          description: values.description,
+          active: values.active,
+        });
+      }
+
+      onSuccess();
+      onOpenChange(false);
+    } catch (error) {
+      console.error("[ProductEditor] Failed to save product:", error);
+    } finally {
+      setIsSubmitting(false);
+    }
+  };
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className="max-w-2xl">
+        <DialogHeader>
+          <DialogTitle>{product ? "Edit Product" : "Create Product"}</DialogTitle>
+          <DialogDescription>
+            {product ? `Update the details for ${product.name}` : "Create a new product to offer to your customers"}
+          </DialogDescription>
+        </DialogHeader>
+
+        <Form {...form}>
+          <form onSubmit={form.handleSubmit(onSubmit)} className="flex flex-col gap-y-4">
+            <FormInput form={form} id="name" name="Product Name" placeholder="Enter product name" isRequired />
+
+            <FormTextarea
+              form={form}
+              id="description"
+              name="Description"
+              placeholder="Enter product description (optional)"
+              className="min-h-32"
+            />
+
+            <FormCheckbox form={form} id="active" name="Active" />
+
+            <CommonEditorButtons isEdit={!!product} form={form} disabled={isSubmitting} setOpen={onOpenChange} />
+          </form>
+        </Form>
+      </DialogContent>
+    </Dialog>
+  );
+}

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

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

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

@@ -0,0 +1,3 @@
+export * from "./containers";
+export * from "./forms";
+export * from "./lists";