@infuro/cms-core 1.0.4 → 1.0.6

package/dist/index.js

@@ -119,6 +119,114 @@ This link expires in 1 hour.`
   }
 });
 
+// src/plugins/payment/stripe.ts
+var stripe_exports = {};
+__export(stripe_exports, {
+  StripePaymentService: () => StripePaymentService
+});
+import Stripe from "stripe";
+var StripePaymentService;
+var init_stripe = __esm({
+  "src/plugins/payment/stripe.ts"() {
+    "use strict";
+    StripePaymentService = class {
+      stripe;
+      webhookSecret;
+      constructor(config) {
+        this.stripe = new Stripe(config.secretKey, { apiVersion: "2024-06-20" });
+        this.webhookSecret = config.webhookSecret;
+      }
+      async createPaymentIntent(amount, currency, metadata) {
+        const intent = await this.stripe.paymentIntents.create({
+          amount: Math.round(amount * 100),
+          currency: currency.toLowerCase(),
+          metadata
+        });
+        return {
+          id: intent.id,
+          clientSecret: intent.client_secret || "",
+          amount,
+          currency,
+          status: intent.status
+        };
+      }
+      async capturePayment(paymentId, amount) {
+        try {
+          await this.stripe.paymentIntents.capture(paymentId, {
+            amount_to_capture: amount ? Math.round(amount * 100) : void 0
+          });
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      verifyWebhookSignature(payload, signature) {
+        if (!this.webhookSecret) return false;
+        try {
+          this.stripe.webhooks.constructEvent(payload, signature, this.webhookSecret);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+    };
+  }
+});
+
+// src/plugins/payment/razorpay.ts
+var razorpay_exports = {};
+__export(razorpay_exports, {
+  RazorpayPaymentService: () => RazorpayPaymentService
+});
+import Razorpay from "razorpay";
+import crypto from "crypto";
+var RazorpayPaymentService;
+var init_razorpay = __esm({
+  "src/plugins/payment/razorpay.ts"() {
+    "use strict";
+    RazorpayPaymentService = class {
+      razorpay;
+      keySecret;
+      webhookSecret;
+      constructor(config) {
+        this.razorpay = new Razorpay({
+          key_id: config.keyId,
+          key_secret: config.keySecret
+        });
+        this.keySecret = config.keySecret;
+        this.webhookSecret = config.webhookSecret;
+      }
+      async createPaymentIntent(amount, currency, metadata) {
+        const order = await this.razorpay.orders.create({
+          amount: Math.round(amount * 100),
+          currency: currency.toUpperCase(),
+          notes: metadata
+        });
+        return {
+          id: order.id,
+          clientSecret: order.id,
+          amount,
+          currency,
+          status: order.status
+        };
+      }
+      async capturePayment(paymentId, amount) {
+        try {
+          await this.razorpay.payments.capture(paymentId, amount ? Math.round(amount * 100) : 0, "INR");
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      verifyWebhookSignature(payload, signature) {
+        const secret = this.webhookSecret || this.keySecret;
+        const expectedSignature = crypto.createHmac("sha256", secret).update(typeof payload === "string" ? payload : payload.toString("utf8")).digest("hex");
+        return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expectedSignature));
+      }
+    };
+  }
+});
+
 // src/plugins/registry.ts
 var noopLogger = {
   info: () => {
@@ -547,12 +655,39 @@ function smsPlugin(_config = {}) {
 }
 
 // src/plugins/payment/index.ts
-function paymentPlugin(_config = {}) {
+function paymentPlugin(config) {
   return {
     name: "payment",
     version: "1.0.0",
-    async init() {
-      return null;
+    async init(context) {
+      if (config.provider === "stripe") {
+        const { StripePaymentService: StripePaymentService2 } = await Promise.resolve().then(() => (init_stripe(), stripe_exports));
+        const secretKey = config.secretKey || context.config.STRIPE_SECRET_KEY;
+        if (!secretKey) {
+          context.logger.warn("Payment plugin skipped: Stripe secret key not configured");
+          return void 0;
+        }
+        return new StripePaymentService2({
+          secretKey,
+          webhookSecret: config.webhookSecret || context.config.STRIPE_WEBHOOK_SECRET
+        });
+      }
+      if (config.provider === "razorpay") {
+        const { RazorpayPaymentService: RazorpayPaymentService2 } = await Promise.resolve().then(() => (init_razorpay(), razorpay_exports));
+        const keyId = config.keyId || context.config.RAZORPAY_KEY_ID;
+        const keySecret = config.keySecret || context.config.RAZORPAY_KEY_SECRET;
+        if (!keyId || !keySecret) {
+          context.logger.warn("Payment plugin skipped: Razorpay credentials not configured");
+          return void 0;
+        }
+        return new RazorpayPaymentService2({
+          keyId,
+          keySecret,
+          webhookSecret: config.webhookSecret || context.config.RAZORPAY_WEBHOOK_SECRET
+        });
+      }
+      context.logger.warn(`Payment plugin skipped: unknown provider "${config.provider}"`);
+      return void 0;
     }
   };
 }
@@ -927,7 +1062,7 @@ __decorateClass([
   PrimaryGeneratedColumn5()
 ], Category.prototype, "id", 2);
 __decorateClass([
-  Column5("varchar")
+  Column5("varchar", { unique: true })
 ], Category.prototype, "name", 2);
 __decorateClass([
   Column5({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
@@ -1239,7 +1374,7 @@ Blog = __decorateClass([
 ], Blog);
 
 // src/entities/contact.entity.ts
-import { Entity as Entity13, PrimaryGeneratedColumn as PrimaryGeneratedColumn13, Column as Column13, OneToMany as OneToMany6 } from "typeorm";
+import { Entity as Entity16, PrimaryGeneratedColumn as PrimaryGeneratedColumn16, Column as Column16, OneToMany as OneToMany7 } from "typeorm";
 
 // src/entities/form-submission.entity.ts
 import { Entity as Entity12, PrimaryGeneratedColumn as PrimaryGeneratedColumn12, Column as Column12, ManyToOne as ManyToOne6, JoinColumn as JoinColumn6 } from "typeorm";
@@ -1448,12 +1583,266 @@ FormSubmission = __decorateClass([
   Entity12("form_submissions")
 ], FormSubmission);
 
+// src/entities/address.entity.ts
+import { Entity as Entity13, PrimaryGeneratedColumn as PrimaryGeneratedColumn13, Column as Column13, ManyToOne as ManyToOne7, JoinColumn as JoinColumn7 } from "typeorm";
+var Address = class {
+  id;
+  contactId;
+  tag;
+  line1;
+  line2;
+  city;
+  state;
+  postalCode;
+  country;
+  createdAt;
+  updatedAt;
+  contact;
+};
+__decorateClass([
+  PrimaryGeneratedColumn13()
+], Address.prototype, "id", 2);
+__decorateClass([
+  Column13("int")
+], Address.prototype, "contactId", 2);
+__decorateClass([
+  Column13("varchar", { nullable: true })
+], Address.prototype, "tag", 2);
+__decorateClass([
+  Column13("varchar", { nullable: true })
+], Address.prototype, "line1", 2);
+__decorateClass([
+  Column13("varchar", { nullable: true })
+], Address.prototype, "line2", 2);
+__decorateClass([
+  Column13("varchar", { nullable: true })
+], Address.prototype, "city", 2);
+__decorateClass([
+  Column13("varchar", { nullable: true })
+], Address.prototype, "state", 2);
+__decorateClass([
+  Column13("varchar", { nullable: true })
+], Address.prototype, "postalCode", 2);
+__decorateClass([
+  Column13("varchar", { nullable: true })
+], Address.prototype, "country", 2);
+__decorateClass([
+  Column13({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Address.prototype, "createdAt", 2);
+__decorateClass([
+  Column13({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Address.prototype, "updatedAt", 2);
+__decorateClass([
+  ManyToOne7(() => Contact, (c) => c.addresses, { onDelete: "CASCADE" }),
+  JoinColumn7({ name: "contactId" })
+], Address.prototype, "contact", 2);
+Address = __decorateClass([
+  Entity13("addresses")
+], Address);
+
+// src/entities/order.entity.ts
+import { Entity as Entity14, PrimaryGeneratedColumn as PrimaryGeneratedColumn14, Column as Column14, ManyToOne as ManyToOne8, OneToMany as OneToMany6, JoinColumn as JoinColumn8 } from "typeorm";
+var Order = class {
+  id;
+  orderNumber;
+  contactId;
+  billingAddressId;
+  shippingAddressId;
+  status;
+  subtotal;
+  tax;
+  discount;
+  total;
+  currency;
+  metadata;
+  createdAt;
+  updatedAt;
+  deletedAt;
+  deleted;
+  createdBy;
+  updatedBy;
+  deletedBy;
+  contact;
+  billingAddress;
+  shippingAddress;
+  items;
+  payments;
+};
+__decorateClass([
+  PrimaryGeneratedColumn14()
+], Order.prototype, "id", 2);
+__decorateClass([
+  Column14("varchar", { unique: true })
+], Order.prototype, "orderNumber", 2);
+__decorateClass([
+  Column14("int")
+], Order.prototype, "contactId", 2);
+__decorateClass([
+  Column14("int", { nullable: true })
+], Order.prototype, "billingAddressId", 2);
+__decorateClass([
+  Column14("int", { nullable: true })
+], Order.prototype, "shippingAddressId", 2);
+__decorateClass([
+  Column14("varchar", { default: "pending" })
+], Order.prototype, "status", 2);
+__decorateClass([
+  Column14("decimal", { precision: 12, scale: 2, default: 0 })
+], Order.prototype, "subtotal", 2);
+__decorateClass([
+  Column14("decimal", { precision: 12, scale: 2, default: 0 })
+], Order.prototype, "tax", 2);
+__decorateClass([
+  Column14("decimal", { precision: 12, scale: 2, default: 0 })
+], Order.prototype, "discount", 2);
+__decorateClass([
+  Column14("decimal", { precision: 12, scale: 2, default: 0 })
+], Order.prototype, "total", 2);
+__decorateClass([
+  Column14("varchar", { default: "INR" })
+], Order.prototype, "currency", 2);
+__decorateClass([
+  Column14("jsonb", { nullable: true })
+], Order.prototype, "metadata", 2);
+__decorateClass([
+  Column14({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Order.prototype, "createdAt", 2);
+__decorateClass([
+  Column14({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Order.prototype, "updatedAt", 2);
+__decorateClass([
+  Column14({ type: "timestamp", nullable: true })
+], Order.prototype, "deletedAt", 2);
+__decorateClass([
+  Column14("boolean", { default: false })
+], Order.prototype, "deleted", 2);
+__decorateClass([
+  Column14("int", { nullable: true })
+], Order.prototype, "createdBy", 2);
+__decorateClass([
+  Column14("int", { nullable: true })
+], Order.prototype, "updatedBy", 2);
+__decorateClass([
+  Column14("int", { nullable: true })
+], Order.prototype, "deletedBy", 2);
+__decorateClass([
+  ManyToOne8(() => Contact, { onDelete: "CASCADE" }),
+  JoinColumn8({ name: "contactId" })
+], Order.prototype, "contact", 2);
+__decorateClass([
+  ManyToOne8(() => Address, { onDelete: "SET NULL" }),
+  JoinColumn8({ name: "billingAddressId" })
+], Order.prototype, "billingAddress", 2);
+__decorateClass([
+  ManyToOne8(() => Address, { onDelete: "SET NULL" }),
+  JoinColumn8({ name: "shippingAddressId" })
+], Order.prototype, "shippingAddress", 2);
+__decorateClass([
+  OneToMany6("OrderItem", "order")
+], Order.prototype, "items", 2);
+__decorateClass([
+  OneToMany6("Payment", "order")
+], Order.prototype, "payments", 2);
+Order = __decorateClass([
+  Entity14("orders")
+], Order);
+
+// src/entities/payment.entity.ts
+import { Entity as Entity15, PrimaryGeneratedColumn as PrimaryGeneratedColumn15, Column as Column15, ManyToOne as ManyToOne9, JoinColumn as JoinColumn9 } from "typeorm";
+var Payment = class {
+  id;
+  orderId;
+  contactId;
+  amount;
+  currency;
+  status;
+  method;
+  externalReference;
+  metadata;
+  paidAt;
+  createdAt;
+  updatedAt;
+  deletedAt;
+  deleted;
+  createdBy;
+  updatedBy;
+  deletedBy;
+  order;
+  contact;
+};
+__decorateClass([
+  PrimaryGeneratedColumn15()
+], Payment.prototype, "id", 2);
+__decorateClass([
+  Column15("int")
+], Payment.prototype, "orderId", 2);
+__decorateClass([
+  Column15("int", { nullable: true })
+], Payment.prototype, "contactId", 2);
+__decorateClass([
+  Column15("decimal", { precision: 12, scale: 2 })
+], Payment.prototype, "amount", 2);
+__decorateClass([
+  Column15("varchar", { default: "INR" })
+], Payment.prototype, "currency", 2);
+__decorateClass([
+  Column15("varchar", { default: "pending" })
+], Payment.prototype, "status", 2);
+__decorateClass([
+  Column15("varchar", { nullable: true })
+], Payment.prototype, "method", 2);
+__decorateClass([
+  Column15("varchar", { nullable: true })
+], Payment.prototype, "externalReference", 2);
+__decorateClass([
+  Column15("jsonb", { nullable: true })
+], Payment.prototype, "metadata", 2);
+__decorateClass([
+  Column15({ type: "timestamp", nullable: true })
+], Payment.prototype, "paidAt", 2);
+__decorateClass([
+  Column15({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Payment.prototype, "createdAt", 2);
+__decorateClass([
+  Column15({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Payment.prototype, "updatedAt", 2);
+__decorateClass([
+  Column15({ type: "timestamp", nullable: true })
+], Payment.prototype, "deletedAt", 2);
+__decorateClass([
+  Column15("boolean", { default: false })
+], Payment.prototype, "deleted", 2);
+__decorateClass([
+  Column15("int", { nullable: true })
+], Payment.prototype, "createdBy", 2);
+__decorateClass([
+  Column15("int", { nullable: true })
+], Payment.prototype, "updatedBy", 2);
+__decorateClass([
+  Column15("int", { nullable: true })
+], Payment.prototype, "deletedBy", 2);
+__decorateClass([
+  ManyToOne9(() => Order, (o) => o.payments, { onDelete: "CASCADE" }),
+  JoinColumn9({ name: "orderId" })
+], Payment.prototype, "order", 2);
+__decorateClass([
+  ManyToOne9(() => Contact, { onDelete: "SET NULL" }),
+  JoinColumn9({ name: "contactId" })
+], Payment.prototype, "contact", 2);
+Payment = __decorateClass([
+  Entity15("payments")
+], Payment);
+
 // src/entities/contact.entity.ts
 var Contact = class {
   id;
   name;
   email;
   phone;
+  type;
+  company;
+  taxId;
+  notes;
   createdAt;
   updatedAt;
   deletedAt;
@@ -1462,49 +1851,73 @@ var Contact = class {
   updatedBy;
   deletedBy;
   form_submissions;
+  addresses;
+  orders;
+  payments;
 };
 __decorateClass([
-  PrimaryGeneratedColumn13()
+  PrimaryGeneratedColumn16()
 ], Contact.prototype, "id", 2);
 __decorateClass([
-  Column13("varchar")
+  Column16("varchar")
 ], Contact.prototype, "name", 2);
 __decorateClass([
-  Column13("varchar", { unique: true })
+  Column16("varchar", { unique: true })
 ], Contact.prototype, "email", 2);
 __decorateClass([
-  Column13("varchar", { nullable: true })
+  Column16("varchar", { nullable: true })
 ], Contact.prototype, "phone", 2);
 __decorateClass([
-  Column13({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column16("varchar", { nullable: true })
+], Contact.prototype, "type", 2);
+__decorateClass([
+  Column16("varchar", { nullable: true })
+], Contact.prototype, "company", 2);
+__decorateClass([
+  Column16("varchar", { nullable: true })
+], Contact.prototype, "taxId", 2);
+__decorateClass([
+  Column16("text", { nullable: true })
+], Contact.prototype, "notes", 2);
+__decorateClass([
+  Column16({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Contact.prototype, "createdAt", 2);
 __decorateClass([
-  Column13({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column16({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Contact.prototype, "updatedAt", 2);
 __decorateClass([
-  Column13({ type: "timestamp", nullable: true })
+  Column16({ type: "timestamp", nullable: true })
 ], Contact.prototype, "deletedAt", 2);
 __decorateClass([
-  Column13("boolean", { default: false })
+  Column16("boolean", { default: false })
 ], Contact.prototype, "deleted", 2);
 __decorateClass([
-  Column13("int", { nullable: true })
+  Column16("int", { nullable: true })
 ], Contact.prototype, "createdBy", 2);
 __decorateClass([
-  Column13("int", { nullable: true })
+  Column16("int", { nullable: true })
 ], Contact.prototype, "updatedBy", 2);
 __decorateClass([
-  Column13("int", { nullable: true })
+  Column16("int", { nullable: true })
 ], Contact.prototype, "deletedBy", 2);
 __decorateClass([
-  OneToMany6(() => FormSubmission, (fs) => fs.contact)
+  OneToMany7(() => FormSubmission, (fs) => fs.contact)
 ], Contact.prototype, "form_submissions", 2);
+__decorateClass([
+  OneToMany7(() => Address, (a) => a.contact)
+], Contact.prototype, "addresses", 2);
+__decorateClass([
+  OneToMany7(() => Order, (o) => o.contact)
+], Contact.prototype, "orders", 2);
+__decorateClass([
+  OneToMany7(() => Payment, (p) => p.contact)
+], Contact.prototype, "payments", 2);
 Contact = __decorateClass([
-  Entity13("contacts")
+  Entity16("contacts")
 ], Contact);
 
 // src/entities/config.entity.ts
-import { Entity as Entity14, PrimaryGeneratedColumn as PrimaryGeneratedColumn14, Column as Column14, Unique } from "typeorm";
+import { Entity as Entity17, PrimaryGeneratedColumn as PrimaryGeneratedColumn17, Column as Column17, Unique } from "typeorm";
 var Config = class {
   id;
   settings;
@@ -1521,51 +1934,51 @@ var Config = class {
   deletedBy;
 };
 __decorateClass([
-  PrimaryGeneratedColumn14()
+  PrimaryGeneratedColumn17()
 ], Config.prototype, "id", 2);
 __decorateClass([
-  Column14("varchar")
+  Column17("varchar")
 ], Config.prototype, "settings", 2);
 __decorateClass([
-  Column14("varchar")
+  Column17("varchar")
 ], Config.prototype, "key", 2);
 __decorateClass([
-  Column14("varchar")
+  Column17("varchar")
 ], Config.prototype, "value", 2);
 __decorateClass([
-  Column14("varchar", { default: "private" })
+  Column17("varchar", { default: "private" })
 ], Config.prototype, "type", 2);
 __decorateClass([
-  Column14("boolean", { default: false })
+  Column17("boolean", { default: false })
 ], Config.prototype, "encrypted", 2);
 __decorateClass([
-  Column14({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column17({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Config.prototype, "createdAt", 2);
 __decorateClass([
-  Column14({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column17({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Config.prototype, "updatedAt", 2);
 __decorateClass([
-  Column14({ type: "timestamp", nullable: true })
+  Column17({ type: "timestamp", nullable: true })
 ], Config.prototype, "deletedAt", 2);
 __decorateClass([
-  Column14("boolean", { default: false })
+  Column17("boolean", { default: false })
 ], Config.prototype, "deleted", 2);
 __decorateClass([
-  Column14("int", { nullable: true })
+  Column17("int", { nullable: true })
 ], Config.prototype, "createdBy", 2);
 __decorateClass([
-  Column14("int", { nullable: true })
+  Column17("int", { nullable: true })
 ], Config.prototype, "updatedBy", 2);
 __decorateClass([
-  Column14("int", { nullable: true })
+  Column17("int", { nullable: true })
 ], Config.prototype, "deletedBy", 2);
 Config = __decorateClass([
-  Entity14("configs"),
+  Entity17("configs"),
   Unique(["settings", "key"])
 ], Config);
 
 // src/entities/media.entity.ts
-import { Entity as Entity15, PrimaryGeneratedColumn as PrimaryGeneratedColumn15, Column as Column15 } from "typeorm";
+import { Entity as Entity18, PrimaryGeneratedColumn as PrimaryGeneratedColumn18, Column as Column18 } from "typeorm";
 var Media = class {
   id;
   filename;
@@ -1580,44 +1993,44 @@ var Media = class {
   deleted;
 };
 __decorateClass([
-  PrimaryGeneratedColumn15()
+  PrimaryGeneratedColumn18()
 ], Media.prototype, "id", 2);
 __decorateClass([
-  Column15("varchar")
+  Column18("varchar")
 ], Media.prototype, "filename", 2);
 __decorateClass([
-  Column15("varchar")
+  Column18("varchar")
 ], Media.prototype, "url", 2);
 __decorateClass([
-  Column15("varchar")
+  Column18("varchar")
 ], Media.prototype, "mimeType", 2);
 __decorateClass([
-  Column15("int", { default: 0 })
+  Column18("int", { default: 0 })
 ], Media.prototype, "size", 2);
 __decorateClass([
-  Column15("varchar", { nullable: true })
+  Column18("varchar", { nullable: true })
 ], Media.prototype, "alt", 2);
 __decorateClass([
-  Column15("boolean", { default: false })
+  Column18("boolean", { default: false })
 ], Media.prototype, "isPublic", 2);
 __decorateClass([
-  Column15({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column18({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Media.prototype, "createdAt", 2);
 __decorateClass([
-  Column15({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column18({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Media.prototype, "updatedAt", 2);
 __decorateClass([
-  Column15({ type: "timestamp", nullable: true })
+  Column18({ type: "timestamp", nullable: true })
 ], Media.prototype, "deletedAt", 2);
 __decorateClass([
-  Column15("boolean", { default: false })
+  Column18("boolean", { default: false })
 ], Media.prototype, "deleted", 2);
 Media = __decorateClass([
-  Entity15("media")
+  Entity18("media")
 ], Media);
 
 // src/entities/page.entity.ts
-import { Entity as Entity16, PrimaryGeneratedColumn as PrimaryGeneratedColumn16, Column as Column16, ManyToOne as ManyToOne7, JoinColumn as JoinColumn7 } from "typeorm";
+import { Entity as Entity19, PrimaryGeneratedColumn as PrimaryGeneratedColumn19, Column as Column19, ManyToOne as ManyToOne10, JoinColumn as JoinColumn10 } from "typeorm";
 var Page = class {
   id;
   title;
@@ -1638,96 +2051,785 @@ var Page = class {
   deletedBy;
 };
 __decorateClass([
-  PrimaryGeneratedColumn16()
+  PrimaryGeneratedColumn19()
 ], Page.prototype, "id", 2);
 __decorateClass([
-  Column16("varchar")
+  Column19("varchar")
 ], Page.prototype, "title", 2);
 __decorateClass([
-  Column16("varchar", { unique: true })
+  Column19("varchar", { unique: true })
 ], Page.prototype, "slug", 2);
 __decorateClass([
-  Column16({ type: "jsonb", default: {} })
+  Column19({ type: "jsonb", default: {} })
 ], Page.prototype, "content", 2);
 __decorateClass([
-  Column16("boolean", { default: false })
+  Column19("boolean", { default: false })
 ], Page.prototype, "published", 2);
 __decorateClass([
-  Column16("varchar", { default: "default" })
+  Column19("varchar", { default: "default" })
 ], Page.prototype, "theme", 2);
 __decorateClass([
-  Column16("int", { nullable: true })
+  Column19("int", { nullable: true })
 ], Page.prototype, "parentId", 2);
 __decorateClass([
-  ManyToOne7(() => Page, { onDelete: "SET NULL" }),
-  JoinColumn7({ name: "parentId" })
+  ManyToOne10(() => Page, { onDelete: "SET NULL" }),
+  JoinColumn10({ name: "parentId" })
 ], Page.prototype, "parent", 2);
 __decorateClass([
-  Column16("int", { nullable: true })
+  Column19("int", { nullable: true })
 ], Page.prototype, "seoId", 2);
 __decorateClass([
-  ManyToOne7(() => Seo, { onDelete: "SET NULL" }),
-  JoinColumn7({ name: "seoId" })
+  ManyToOne10(() => Seo, { onDelete: "SET NULL" }),
+  JoinColumn10({ name: "seoId" })
 ], Page.prototype, "seo", 2);
 __decorateClass([
-  Column16({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column19({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Page.prototype, "createdAt", 2);
 __decorateClass([
-  Column16({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  Column19({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Page.prototype, "updatedAt", 2);
 __decorateClass([
-  Column16({ type: "timestamp", nullable: true })
+  Column19({ type: "timestamp", nullable: true })
 ], Page.prototype, "deletedAt", 2);
 __decorateClass([
-  Column16("boolean", { default: false })
+  Column19("boolean", { default: false })
 ], Page.prototype, "deleted", 2);
 __decorateClass([
-  Column16("int", { nullable: true })
+  Column19("int", { nullable: true })
 ], Page.prototype, "createdBy", 2);
 __decorateClass([
-  Column16("int", { nullable: true })
+  Column19("int", { nullable: true })
 ], Page.prototype, "updatedBy", 2);
 __decorateClass([
-  Column16("int", { nullable: true })
+  Column19("int", { nullable: true })
 ], Page.prototype, "deletedBy", 2);
 Page = __decorateClass([
-  Entity16("pages")
+  Entity19("pages")
 ], Page);
 
-// src/entities/index.ts
-var CMS_ENTITY_MAP = {
-  users: User,
-  password_reset_tokens: PasswordResetToken,
-  user_groups: UserGroup,
-  permissions: Permission,
-  blogs: Blog,
-  tags: Tag,
-  categories: Category,
-  comments: Comment,
-  contacts: Contact,
-  forms: Form,
-  form_fields: FormField,
-  form_submissions: FormSubmission,
-  seos: Seo,
-  configs: Config,
-  media: Media,
-  pages: Page
+// src/entities/product-category.entity.ts
+import { Entity as Entity20, PrimaryGeneratedColumn as PrimaryGeneratedColumn20, Column as Column20, ManyToOne as ManyToOne11, OneToMany as OneToMany8, JoinColumn as JoinColumn11 } from "typeorm";
+var ProductCategory = class {
+  id;
+  name;
+  slug;
+  parentId;
+  image;
+  description;
+  metadata;
+  active;
+  sortOrder;
+  createdAt;
+  updatedAt;
+  deletedAt;
+  deleted;
+  createdBy;
+  updatedBy;
+  deletedBy;
+  parent;
+  children;
+  products;
+  collections;
 };
-
-// src/auth/helpers.ts
-var OPEN_ENDPOINTS = [
-  { "/api/contacts": ["POST"] },
-  { "/api/form-submissions": ["POST"] },
-  { "/api/blogs": ["GET"] }
-];
-var PERMISSION_REQUIRED_ENDPOINTS = {};
-function isOpenEndpoint(pathname) {
-  return OPEN_ENDPOINTS.some((endpoint) => pathname.startsWith(Object.keys(endpoint)[0]));
-}
-function getRequiredPermission(pathname) {
-  return null;
-}
-function isPublicMethod(pathname, method) {
+__decorateClass([
+  PrimaryGeneratedColumn20()
+], ProductCategory.prototype, "id", 2);
+__decorateClass([
+  Column20("varchar")
+], ProductCategory.prototype, "name", 2);
+__decorateClass([
+  Column20("varchar", { unique: true })
+], ProductCategory.prototype, "slug", 2);
+__decorateClass([
+  Column20("int", { nullable: true })
+], ProductCategory.prototype, "parentId", 2);
+__decorateClass([
+  Column20("varchar", { nullable: true })
+], ProductCategory.prototype, "image", 2);
+__decorateClass([
+  Column20("text", { nullable: true })
+], ProductCategory.prototype, "description", 2);
+__decorateClass([
+  Column20("jsonb", { nullable: true })
+], ProductCategory.prototype, "metadata", 2);
+__decorateClass([
+  Column20("boolean", { default: true })
+], ProductCategory.prototype, "active", 2);
+__decorateClass([
+  Column20("int", { default: 0 })
+], ProductCategory.prototype, "sortOrder", 2);
+__decorateClass([
+  Column20({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], ProductCategory.prototype, "createdAt", 2);
+__decorateClass([
+  Column20({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], ProductCategory.prototype, "updatedAt", 2);
+__decorateClass([
+  Column20({ type: "timestamp", nullable: true })
+], ProductCategory.prototype, "deletedAt", 2);
+__decorateClass([
+  Column20("boolean", { default: false })
+], ProductCategory.prototype, "deleted", 2);
+__decorateClass([
+  Column20("int", { nullable: true })
+], ProductCategory.prototype, "createdBy", 2);
+__decorateClass([
+  Column20("int", { nullable: true })
+], ProductCategory.prototype, "updatedBy", 2);
+__decorateClass([
+  Column20("int", { nullable: true })
+], ProductCategory.prototype, "deletedBy", 2);
+__decorateClass([
+  ManyToOne11(() => ProductCategory, (c) => c.children, { onDelete: "SET NULL" }),
+  JoinColumn11({ name: "parentId" })
+], ProductCategory.prototype, "parent", 2);
+__decorateClass([
+  OneToMany8(() => ProductCategory, (c) => c.parent)
+], ProductCategory.prototype, "children", 2);
+__decorateClass([
+  OneToMany8("Product", "category")
+], ProductCategory.prototype, "products", 2);
+__decorateClass([
+  OneToMany8("Collection", "category")
+], ProductCategory.prototype, "collections", 2);
+ProductCategory = __decorateClass([
+  Entity20("product_categories")
+], ProductCategory);
+
+// src/entities/collection.entity.ts
+import { Entity as Entity22, PrimaryGeneratedColumn as PrimaryGeneratedColumn22, Column as Column22, ManyToOne as ManyToOne13, OneToMany as OneToMany10, JoinColumn as JoinColumn13 } from "typeorm";
+
+// src/entities/brand.entity.ts
+import { Entity as Entity21, PrimaryGeneratedColumn as PrimaryGeneratedColumn21, Column as Column21, OneToMany as OneToMany9, ManyToOne as ManyToOne12, JoinColumn as JoinColumn12 } from "typeorm";
+var Brand = class {
+  id;
+  name;
+  slug;
+  logo;
+  metadata;
+  description;
+  active;
+  sortOrder;
+  createdAt;
+  updatedAt;
+  deletedAt;
+  deleted;
+  createdBy;
+  updatedBy;
+  deletedBy;
+  seoId;
+  seo;
+  products;
+  collections;
+};
+__decorateClass([
+  PrimaryGeneratedColumn21()
+], Brand.prototype, "id", 2);
+__decorateClass([
+  Column21("varchar")
+], Brand.prototype, "name", 2);
+__decorateClass([
+  Column21("varchar", { unique: true })
+], Brand.prototype, "slug", 2);
+__decorateClass([
+  Column21("varchar", { nullable: true })
+], Brand.prototype, "logo", 2);
+__decorateClass([
+  Column21("jsonb", { nullable: true })
+], Brand.prototype, "metadata", 2);
+__decorateClass([
+  Column21("text", { nullable: true })
+], Brand.prototype, "description", 2);
+__decorateClass([
+  Column21("boolean", { default: true })
+], Brand.prototype, "active", 2);
+__decorateClass([
+  Column21("int", { default: 0 })
+], Brand.prototype, "sortOrder", 2);
+__decorateClass([
+  Column21({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Brand.prototype, "createdAt", 2);
+__decorateClass([
+  Column21({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Brand.prototype, "updatedAt", 2);
+__decorateClass([
+  Column21({ type: "timestamp", nullable: true })
+], Brand.prototype, "deletedAt", 2);
+__decorateClass([
+  Column21("boolean", { default: false })
+], Brand.prototype, "deleted", 2);
+__decorateClass([
+  Column21("int", { nullable: true })
+], Brand.prototype, "createdBy", 2);
+__decorateClass([
+  Column21("int", { nullable: true })
+], Brand.prototype, "updatedBy", 2);
+__decorateClass([
+  Column21("int", { nullable: true })
+], Brand.prototype, "deletedBy", 2);
+__decorateClass([
+  Column21("int", { nullable: true })
+], Brand.prototype, "seoId", 2);
+__decorateClass([
+  ManyToOne12(() => Seo, { onDelete: "SET NULL" }),
+  JoinColumn12({ name: "seoId" })
+], Brand.prototype, "seo", 2);
+__decorateClass([
+  OneToMany9("Product", "brand")
+], Brand.prototype, "products", 2);
+__decorateClass([
+  OneToMany9("Collection", "brand")
+], Brand.prototype, "collections", 2);
+Brand = __decorateClass([
+  Entity21("brands")
+], Brand);
+
+// src/entities/collection.entity.ts
+var Collection = class {
+  id;
+  categoryId;
+  brandId;
+  name;
+  slug;
+  description;
+  image;
+  metadata;
+  active;
+  sortOrder;
+  createdAt;
+  updatedAt;
+  deletedAt;
+  deleted;
+  createdBy;
+  updatedBy;
+  deletedBy;
+  seoId;
+  seo;
+  category;
+  brand;
+  products;
+};
+__decorateClass([
+  PrimaryGeneratedColumn22()
+], Collection.prototype, "id", 2);
+__decorateClass([
+  Column22("int", { nullable: true })
+], Collection.prototype, "categoryId", 2);
+__decorateClass([
+  Column22("int", { nullable: true })
+], Collection.prototype, "brandId", 2);
+__decorateClass([
+  Column22("varchar")
+], Collection.prototype, "name", 2);
+__decorateClass([
+  Column22("varchar", { unique: true })
+], Collection.prototype, "slug", 2);
+__decorateClass([
+  Column22("text", { nullable: true })
+], Collection.prototype, "description", 2);
+__decorateClass([
+  Column22("varchar", { nullable: true })
+], Collection.prototype, "image", 2);
+__decorateClass([
+  Column22("jsonb", { nullable: true })
+], Collection.prototype, "metadata", 2);
+__decorateClass([
+  Column22("boolean", { default: true })
+], Collection.prototype, "active", 2);
+__decorateClass([
+  Column22("int", { default: 0 })
+], Collection.prototype, "sortOrder", 2);
+__decorateClass([
+  Column22({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Collection.prototype, "createdAt", 2);
+__decorateClass([
+  Column22({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Collection.prototype, "updatedAt", 2);
+__decorateClass([
+  Column22({ type: "timestamp", nullable: true })
+], Collection.prototype, "deletedAt", 2);
+__decorateClass([
+  Column22("boolean", { default: false })
+], Collection.prototype, "deleted", 2);
+__decorateClass([
+  Column22("int", { nullable: true })
+], Collection.prototype, "createdBy", 2);
+__decorateClass([
+  Column22("int", { nullable: true })
+], Collection.prototype, "updatedBy", 2);
+__decorateClass([
+  Column22("int", { nullable: true })
+], Collection.prototype, "deletedBy", 2);
+__decorateClass([
+  Column22("int", { nullable: true })
+], Collection.prototype, "seoId", 2);
+__decorateClass([
+  ManyToOne13(() => Seo, { onDelete: "SET NULL" }),
+  JoinColumn13({ name: "seoId" })
+], Collection.prototype, "seo", 2);
+__decorateClass([
+  ManyToOne13(() => ProductCategory, (c) => c.collections, { onDelete: "SET NULL" }),
+  JoinColumn13({ name: "categoryId" })
+], Collection.prototype, "category", 2);
+__decorateClass([
+  ManyToOne13(() => Brand, (b) => b.collections, { onDelete: "SET NULL" }),
+  JoinColumn13({ name: "brandId" })
+], Collection.prototype, "brand", 2);
+__decorateClass([
+  OneToMany10("Product", "collection")
+], Collection.prototype, "products", 2);
+Collection = __decorateClass([
+  Entity22("collections")
+], Collection);
+
+// src/entities/product.entity.ts
+import { Entity as Entity23, PrimaryGeneratedColumn as PrimaryGeneratedColumn23, Column as Column23, ManyToOne as ManyToOne14, OneToMany as OneToMany11, JoinColumn as JoinColumn14 } from "typeorm";
+var Product = class {
+  id;
+  collectionId;
+  brandId;
+  categoryId;
+  sku;
+  slug;
+  name;
+  price;
+  compareAtPrice;
+  quantity;
+  status;
+  featured;
+  metadata;
+  createdAt;
+  updatedAt;
+  deletedAt;
+  deleted;
+  createdBy;
+  updatedBy;
+  deletedBy;
+  seoId;
+  seo;
+  collection;
+  brand;
+  category;
+  attributes;
+  taxes;
+};
+__decorateClass([
+  PrimaryGeneratedColumn23()
+], Product.prototype, "id", 2);
+__decorateClass([
+  Column23("int", { nullable: true })
+], Product.prototype, "collectionId", 2);
+__decorateClass([
+  Column23("int", { nullable: true })
+], Product.prototype, "brandId", 2);
+__decorateClass([
+  Column23("int", { nullable: true })
+], Product.prototype, "categoryId", 2);
+__decorateClass([
+  Column23("varchar", { nullable: true })
+], Product.prototype, "sku", 2);
+__decorateClass([
+  Column23("varchar", { unique: true, nullable: true })
+], Product.prototype, "slug", 2);
+__decorateClass([
+  Column23("varchar", { nullable: true })
+], Product.prototype, "name", 2);
+__decorateClass([
+  Column23("decimal", { precision: 12, scale: 2 })
+], Product.prototype, "price", 2);
+__decorateClass([
+  Column23("decimal", { precision: 12, scale: 2, nullable: true })
+], Product.prototype, "compareAtPrice", 2);
+__decorateClass([
+  Column23("int", { default: 0 })
+], Product.prototype, "quantity", 2);
+__decorateClass([
+  Column23("varchar", { default: "draft" })
+], Product.prototype, "status", 2);
+__decorateClass([
+  Column23("boolean", { default: false })
+], Product.prototype, "featured", 2);
+__decorateClass([
+  Column23("jsonb", { nullable: true })
+], Product.prototype, "metadata", 2);
+__decorateClass([
+  Column23({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Product.prototype, "createdAt", 2);
+__decorateClass([
+  Column23({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Product.prototype, "updatedAt", 2);
+__decorateClass([
+  Column23({ type: "timestamp", nullable: true })
+], Product.prototype, "deletedAt", 2);
+__decorateClass([
+  Column23("boolean", { default: false })
+], Product.prototype, "deleted", 2);
+__decorateClass([
+  Column23("int", { nullable: true })
+], Product.prototype, "createdBy", 2);
+__decorateClass([
+  Column23("int", { nullable: true })
+], Product.prototype, "updatedBy", 2);
+__decorateClass([
+  Column23("int", { nullable: true })
+], Product.prototype, "deletedBy", 2);
+__decorateClass([
+  Column23("int", { nullable: true })
+], Product.prototype, "seoId", 2);
+__decorateClass([
+  ManyToOne14(() => Seo, { onDelete: "SET NULL" }),
+  JoinColumn14({ name: "seoId" })
+], Product.prototype, "seo", 2);
+__decorateClass([
+  ManyToOne14(() => Collection, (c) => c.products, { onDelete: "SET NULL" }),
+  JoinColumn14({ name: "collectionId" })
+], Product.prototype, "collection", 2);
+__decorateClass([
+  ManyToOne14(() => Brand, (b) => b.products, { onDelete: "SET NULL" }),
+  JoinColumn14({ name: "brandId" })
+], Product.prototype, "brand", 2);
+__decorateClass([
+  ManyToOne14(() => ProductCategory, (c) => c.products, { onDelete: "SET NULL" }),
+  JoinColumn14({ name: "categoryId" })
+], Product.prototype, "category", 2);
+__decorateClass([
+  OneToMany11("ProductAttribute", "product")
+], Product.prototype, "attributes", 2);
+__decorateClass([
+  OneToMany11("ProductTax", "product")
+], Product.prototype, "taxes", 2);
+Product = __decorateClass([
+  Entity23("products")
+], Product);
+
+// src/entities/attribute.entity.ts
+import { Entity as Entity24, PrimaryGeneratedColumn as PrimaryGeneratedColumn24, Column as Column24 } from "typeorm";
+var Attribute = class {
+  id;
+  name;
+  slug;
+  type;
+  options;
+  metadata;
+  active;
+  sortOrder;
+  createdAt;
+  updatedAt;
+  deletedAt;
+  deleted;
+  createdBy;
+  updatedBy;
+  deletedBy;
+};
+__decorateClass([
+  PrimaryGeneratedColumn24()
+], Attribute.prototype, "id", 2);
+__decorateClass([
+  Column24("varchar")
+], Attribute.prototype, "name", 2);
+__decorateClass([
+  Column24("varchar", { unique: true })
+], Attribute.prototype, "slug", 2);
+__decorateClass([
+  Column24("varchar", { default: "text" })
+], Attribute.prototype, "type", 2);
+__decorateClass([
+  Column24("jsonb", { nullable: true })
+], Attribute.prototype, "options", 2);
+__decorateClass([
+  Column24("jsonb", { nullable: true })
+], Attribute.prototype, "metadata", 2);
+__decorateClass([
+  Column24("boolean", { default: true })
+], Attribute.prototype, "active", 2);
+__decorateClass([
+  Column24("int", { default: 0 })
+], Attribute.prototype, "sortOrder", 2);
+__decorateClass([
+  Column24({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Attribute.prototype, "createdAt", 2);
+__decorateClass([
+  Column24({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Attribute.prototype, "updatedAt", 2);
+__decorateClass([
+  Column24({ type: "timestamp", nullable: true })
+], Attribute.prototype, "deletedAt", 2);
+__decorateClass([
+  Column24("boolean", { default: false })
+], Attribute.prototype, "deleted", 2);
+__decorateClass([
+  Column24("int", { nullable: true })
+], Attribute.prototype, "createdBy", 2);
+__decorateClass([
+  Column24("int", { nullable: true })
+], Attribute.prototype, "updatedBy", 2);
+__decorateClass([
+  Column24("int", { nullable: true })
+], Attribute.prototype, "deletedBy", 2);
+Attribute = __decorateClass([
+  Entity24("attributes")
+], Attribute);
+
+// src/entities/product-attribute.entity.ts
+import { Entity as Entity25, PrimaryGeneratedColumn as PrimaryGeneratedColumn25, Column as Column25, ManyToOne as ManyToOne15, JoinColumn as JoinColumn15 } from "typeorm";
+var ProductAttribute = class {
+  id;
+  productId;
+  attributeId;
+  value;
+  metadata;
+  createdAt;
+  updatedAt;
+  product;
+  attribute;
+};
+__decorateClass([
+  PrimaryGeneratedColumn25()
+], ProductAttribute.prototype, "id", 2);
+__decorateClass([
+  Column25("int")
+], ProductAttribute.prototype, "productId", 2);
+__decorateClass([
+  Column25("int")
+], ProductAttribute.prototype, "attributeId", 2);
+__decorateClass([
+  Column25("varchar")
+], ProductAttribute.prototype, "value", 2);
+__decorateClass([
+  Column25("jsonb", { nullable: true })
+], ProductAttribute.prototype, "metadata", 2);
+__decorateClass([
+  Column25({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], ProductAttribute.prototype, "createdAt", 2);
+__decorateClass([
+  Column25({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], ProductAttribute.prototype, "updatedAt", 2);
+__decorateClass([
+  ManyToOne15(() => Product, (p) => p.attributes, { onDelete: "CASCADE" }),
+  JoinColumn15({ name: "productId" })
+], ProductAttribute.prototype, "product", 2);
+__decorateClass([
+  ManyToOne15(() => Attribute, { onDelete: "CASCADE" }),
+  JoinColumn15({ name: "attributeId" })
+], ProductAttribute.prototype, "attribute", 2);
+ProductAttribute = __decorateClass([
+  Entity25("product_attributes")
+], ProductAttribute);
+
+// src/entities/tax.entity.ts
+import { Entity as Entity26, PrimaryGeneratedColumn as PrimaryGeneratedColumn26, Column as Column26 } from "typeorm";
+var Tax = class {
+  id;
+  name;
+  slug;
+  rate;
+  isDefault;
+  description;
+  active;
+  metadata;
+  createdAt;
+  updatedAt;
+  deletedAt;
+  deleted;
+  createdBy;
+  updatedBy;
+  deletedBy;
+};
+__decorateClass([
+  PrimaryGeneratedColumn26()
+], Tax.prototype, "id", 2);
+__decorateClass([
+  Column26("varchar")
+], Tax.prototype, "name", 2);
+__decorateClass([
+  Column26("varchar", { unique: true })
+], Tax.prototype, "slug", 2);
+__decorateClass([
+  Column26("decimal", { precision: 5, scale: 2 })
+], Tax.prototype, "rate", 2);
+__decorateClass([
+  Column26("boolean", { default: false })
+], Tax.prototype, "isDefault", 2);
+__decorateClass([
+  Column26("text", { nullable: true })
+], Tax.prototype, "description", 2);
+__decorateClass([
+  Column26("boolean", { default: true })
+], Tax.prototype, "active", 2);
+__decorateClass([
+  Column26("jsonb", { nullable: true })
+], Tax.prototype, "metadata", 2);
+__decorateClass([
+  Column26({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Tax.prototype, "createdAt", 2);
+__decorateClass([
+  Column26({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Tax.prototype, "updatedAt", 2);
+__decorateClass([
+  Column26({ type: "timestamp", nullable: true })
+], Tax.prototype, "deletedAt", 2);
+__decorateClass([
+  Column26("boolean", { default: false })
+], Tax.prototype, "deleted", 2);
+__decorateClass([
+  Column26("int", { nullable: true })
+], Tax.prototype, "createdBy", 2);
+__decorateClass([
+  Column26("int", { nullable: true })
+], Tax.prototype, "updatedBy", 2);
+__decorateClass([
+  Column26("int", { nullable: true })
+], Tax.prototype, "deletedBy", 2);
+Tax = __decorateClass([
+  Entity26("taxes")
+], Tax);
+
+// src/entities/product-tax.entity.ts
+import { Entity as Entity27, PrimaryGeneratedColumn as PrimaryGeneratedColumn27, Column as Column27, ManyToOne as ManyToOne16, JoinColumn as JoinColumn16 } from "typeorm";
+var ProductTax = class {
+  id;
+  productId;
+  taxId;
+  rate;
+  createdAt;
+  updatedAt;
+  product;
+  tax;
+};
+__decorateClass([
+  PrimaryGeneratedColumn27()
+], ProductTax.prototype, "id", 2);
+__decorateClass([
+  Column27("int")
+], ProductTax.prototype, "productId", 2);
+__decorateClass([
+  Column27("int")
+], ProductTax.prototype, "taxId", 2);
+__decorateClass([
+  Column27("decimal", { precision: 5, scale: 2, nullable: true })
+], ProductTax.prototype, "rate", 2);
+__decorateClass([
+  Column27({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], ProductTax.prototype, "createdAt", 2);
+__decorateClass([
+  Column27({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], ProductTax.prototype, "updatedAt", 2);
+__decorateClass([
+  ManyToOne16(() => Product, (p) => p.taxes, { onDelete: "CASCADE" }),
+  JoinColumn16({ name: "productId" })
+], ProductTax.prototype, "product", 2);
+__decorateClass([
+  ManyToOne16(() => Tax, { onDelete: "CASCADE" }),
+  JoinColumn16({ name: "taxId" })
+], ProductTax.prototype, "tax", 2);
+ProductTax = __decorateClass([
+  Entity27("product_taxes")
+], ProductTax);
+
+// src/entities/order-item.entity.ts
+import { Entity as Entity28, PrimaryGeneratedColumn as PrimaryGeneratedColumn28, Column as Column28, ManyToOne as ManyToOne17, JoinColumn as JoinColumn17 } from "typeorm";
+var OrderItem = class {
+  id;
+  orderId;
+  productId;
+  quantity;
+  unitPrice;
+  tax;
+  total;
+  metadata;
+  createdAt;
+  updatedAt;
+  order;
+  product;
+};
+__decorateClass([
+  PrimaryGeneratedColumn28()
+], OrderItem.prototype, "id", 2);
+__decorateClass([
+  Column28("int")
+], OrderItem.prototype, "orderId", 2);
+__decorateClass([
+  Column28("int")
+], OrderItem.prototype, "productId", 2);
+__decorateClass([
+  Column28("int", { default: 1 })
+], OrderItem.prototype, "quantity", 2);
+__decorateClass([
+  Column28("decimal", { precision: 12, scale: 2 })
+], OrderItem.prototype, "unitPrice", 2);
+__decorateClass([
+  Column28("decimal", { precision: 12, scale: 2, default: 0 })
+], OrderItem.prototype, "tax", 2);
+__decorateClass([
+  Column28("decimal", { precision: 12, scale: 2 })
+], OrderItem.prototype, "total", 2);
+__decorateClass([
+  Column28("jsonb", { nullable: true })
+], OrderItem.prototype, "metadata", 2);
+__decorateClass([
+  Column28({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], OrderItem.prototype, "createdAt", 2);
+__decorateClass([
+  Column28({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], OrderItem.prototype, "updatedAt", 2);
+__decorateClass([
+  ManyToOne17(() => Order, (o) => o.items, { onDelete: "CASCADE" }),
+  JoinColumn17({ name: "orderId" })
+], OrderItem.prototype, "order", 2);
+__decorateClass([
+  ManyToOne17(() => Product, { onDelete: "CASCADE" }),
+  JoinColumn17({ name: "productId" })
+], OrderItem.prototype, "product", 2);
+OrderItem = __decorateClass([
+  Entity28("order_items")
+], OrderItem);
+
+// src/entities/index.ts
+var CMS_ENTITY_MAP = {
+  users: User,
+  password_reset_tokens: PasswordResetToken,
+  user_groups: UserGroup,
+  permissions: Permission,
+  blogs: Blog,
+  tags: Tag,
+  categories: Category,
+  comments: Comment,
+  contacts: Contact,
+  addresses: Address,
+  forms: Form,
+  form_fields: FormField,
+  form_submissions: FormSubmission,
+  seos: Seo,
+  configs: Config,
+  media: Media,
+  pages: Page,
+  product_categories: ProductCategory,
+  collections: Collection,
+  products: Product,
+  attributes: Attribute,
+  product_attributes: ProductAttribute,
+  taxes: Tax,
+  product_taxes: ProductTax,
+  orders: Order,
+  order_items: OrderItem,
+  payments: Payment,
+  brands: Brand
+};
+
+// src/auth/helpers.ts
+var OPEN_ENDPOINTS = [
+  { "/api/contacts": ["POST"] },
+  { "/api/form-submissions": ["POST"] },
+  { "/api/blogs": ["GET"] }
+];
+var PERMISSION_REQUIRED_ENDPOINTS = {};
+function isOpenEndpoint(pathname) {
+  return OPEN_ENDPOINTS.some((endpoint) => pathname.startsWith(Object.keys(endpoint)[0]));
+}
+function getRequiredPermission(pathname) {
+  return null;
+}
+function isPublicMethod(pathname, method) {
   for (const endpoint of OPEN_ENDPOINTS) {
     const key = Object.keys(endpoint)[0];
     if (pathname.startsWith(key) && endpoint[key].includes(method)) return true;
@@ -1880,7 +2982,7 @@ function getNextAuthOptions(config) {
 }
 
 // src/api/crud.ts
-import { ILike, Like } from "typeorm";
+import { ILike, Like, MoreThan } from "typeorm";
 var DATE_COLUMN_TYPES = /* @__PURE__ */ new Set([
   "date",
   "datetime",
@@ -1925,14 +3027,156 @@ function createCrudHandler(dataSource, entityMap, options) {
       if (!resource || !entity) {
         return json({ error: "Invalid resource" }, { status: 400 });
       }
-      const repo = dataSource.getRepository(entity);
       const { searchParams } = new URL(req.url);
       const page = Number(searchParams.get("page")) || 1;
-      const limit = Number(searchParams.get("limit")) || 10;
+      const limit = Math.min(Number(searchParams.get("limit")) || 10, 100);
       const skip = (page - 1) * limit;
-      const sortField = searchParams.get("sortField") || "createdAt";
+      const sortFieldRaw = searchParams.get("sortField") || "createdAt";
       const sortOrder = searchParams.get("sortOrder") === "desc" ? "DESC" : "ASC";
       const search = searchParams.get("search");
+      if (resource === "orders") {
+        const repo2 = dataSource.getRepository(entity);
+        const allowedSort = ["id", "orderNumber", "contactId", "status", "total", "currency", "createdAt", "updatedAt"];
+        const sortField = allowedSort.includes(sortFieldRaw) ? sortFieldRaw : "createdAt";
+        const sortOrderOrders = searchParams.get("sortOrder") === "asc" ? "ASC" : "DESC";
+        const statusFilter = searchParams.get("status")?.trim();
+        const dateFrom = searchParams.get("dateFrom")?.trim();
+        const dateTo = searchParams.get("dateTo")?.trim();
+        const paymentRef = searchParams.get("paymentRef")?.trim();
+        let orderIdsFromPayment = null;
+        if (paymentRef && entityMap["payments"]) {
+          const paymentRepo = dataSource.getRepository(entityMap["payments"]);
+          const payments = await paymentRepo.createQueryBuilder("p").select("p.orderId").where("p.externalReference = :ref", { ref: paymentRef }).orWhere("p.metadata->>'razorpayPaymentId' = :ref", { ref: paymentRef }).getRawMany();
+          orderIdsFromPayment = payments.map((r) => r.orderId);
+          if (orderIdsFromPayment.length === 0) {
+            return json({ total: 0, page, limit, totalPages: 0, data: [] });
+          }
+        }
+        const qb = repo2.createQueryBuilder("order").leftJoinAndSelect("order.contact", "contact").leftJoinAndSelect("order.items", "items").leftJoinAndSelect("items.product", "product").leftJoinAndSelect("product.collection", "collection").orderBy(`order.${sortField}`, sortOrderOrders).skip(skip).take(limit);
+        if (search && typeof search === "string" && search.trim()) {
+          const term = `%${search.trim()}%`;
+          qb.andWhere(
+            "(order.orderNumber ILIKE :term OR contact.name ILIKE :term OR contact.email ILIKE :term)",
+            { term }
+          );
+        }
+        if (statusFilter) qb.andWhere("order.status = :status", { status: statusFilter });
+        if (dateFrom) qb.andWhere("order.createdAt >= :dateFrom", { dateFrom: /* @__PURE__ */ new Date(dateFrom + "T00:00:00.000Z") });
+        if (dateTo) qb.andWhere("order.createdAt <= :dateTo", { dateTo: /* @__PURE__ */ new Date(dateTo + "T23:59:59.999Z") });
+        if (orderIdsFromPayment && orderIdsFromPayment.length) qb.andWhere("order.id IN (:...orderIds)", { orderIds: orderIdsFromPayment });
+        const [rows, total2] = await qb.getManyAndCount();
+        const data2 = rows.map((order) => {
+          const contact = order.contact;
+          const items = order.items ?? [];
+          const itemsSummary = items.map((i) => {
+            const label = i.product?.collection?.name ?? i.product?.name ?? "Product";
+            return `${label} \xD7 ${i.quantity}`;
+          }).join(", ") || "\u2014";
+          return {
+            ...order,
+            contact: contact ? { id: contact.id, name: contact.name, email: contact.email, phone: contact.phone } : null,
+            itemsSummary
+          };
+        });
+        return json({ total: total2, page, limit, totalPages: Math.ceil(total2 / limit), data: data2 });
+      }
+      if (resource === "payments") {
+        const repo2 = dataSource.getRepository(entity);
+        const allowedSort = ["id", "orderId", "amount", "currency", "status", "method", "paidAt", "createdAt", "updatedAt"];
+        const sortField = allowedSort.includes(sortFieldRaw) ? sortFieldRaw : "createdAt";
+        const sortOrderPayments = searchParams.get("sortOrder") === "asc" ? "ASC" : "DESC";
+        const statusFilter = searchParams.get("status")?.trim();
+        const dateFrom = searchParams.get("dateFrom")?.trim();
+        const dateTo = searchParams.get("dateTo")?.trim();
+        const methodFilter = searchParams.get("method")?.trim();
+        const orderNumberParam = searchParams.get("orderNumber")?.trim();
+        const qb = repo2.createQueryBuilder("payment").leftJoinAndSelect("payment.order", "ord").leftJoinAndSelect("ord.contact", "orderContact").leftJoinAndSelect("payment.contact", "contact").orderBy(`payment.${sortField}`, sortOrderPayments).skip(skip).take(limit);
+        if (search && typeof search === "string" && search.trim()) {
+          const term = `%${search.trim()}%`;
+          qb.andWhere(
+            "(orderContact.name ILIKE :term OR orderContact.email ILIKE :term OR contact.name ILIKE :term OR contact.email ILIKE :term)",
+            { term }
+          );
+        }
+        if (statusFilter) qb.andWhere("payment.status = :status", { status: statusFilter });
+        if (dateFrom) qb.andWhere("payment.createdAt >= :dateFrom", { dateFrom: /* @__PURE__ */ new Date(dateFrom + "T00:00:00.000Z") });
+        if (dateTo) qb.andWhere("payment.createdAt <= :dateTo", { dateTo: /* @__PURE__ */ new Date(dateTo + "T23:59:59.999Z") });
+        if (methodFilter) qb.andWhere("payment.method = :method", { method: methodFilter });
+        if (orderNumberParam) qb.andWhere("ord.orderNumber ILIKE :orderNumber", { orderNumber: `%${orderNumberParam}%` });
+        const [rows, total2] = await qb.getManyAndCount();
+        const data2 = rows.map((payment) => {
+          const order = payment.order;
+          const orderContact = order?.contact;
+          const contact = payment.contact;
+          const customer = orderContact ?? contact;
+          return {
+            ...payment,
+            order: order ? { id: order.id, orderNumber: order.orderNumber, contact: orderContact ? { name: orderContact.name, email: orderContact.email } : null } : null,
+            contact: customer ? { id: customer.id, name: customer.name, email: customer.email } : null
+          };
+        });
+        return json({ total: total2, page, limit, totalPages: Math.ceil(total2 / limit), data: data2 });
+      }
+      if (resource === "products") {
+        const repo2 = dataSource.getRepository(entity);
+        const statusFilter = searchParams.get("status")?.trim();
+        const inventory = searchParams.get("inventory")?.trim();
+        const productWhere = {};
+        if (statusFilter) productWhere.status = statusFilter;
+        if (inventory === "in_stock") productWhere.quantity = MoreThan(0);
+        if (inventory === "out_of_stock") productWhere.quantity = 0;
+        if (search && typeof search === "string" && search.trim()) {
+          productWhere.name = ILike(`%${search.trim()}%`);
+        }
+        const [data2, total2] = await repo2.findAndCount({
+          where: Object.keys(productWhere).length ? productWhere : void 0,
+          skip,
+          take: limit,
+          order: { [sortFieldRaw]: sortOrder }
+        });
+        return json({ total: total2, page, limit, totalPages: Math.ceil(total2 / limit), data: data2 });
+      }
+      if (resource === "contacts") {
+        const repo2 = dataSource.getRepository(entity);
+        const allowedSort = ["id", "name", "email", "createdAt", "type"];
+        const sortField = allowedSort.includes(sortFieldRaw) ? sortFieldRaw : "createdAt";
+        const sortOrderContacts = searchParams.get("sortOrder") === "asc" ? "ASC" : "DESC";
+        const typeFilter2 = searchParams.get("type")?.trim();
+        const orderIdParam = searchParams.get("orderId")?.trim();
+        const includeSummary = searchParams.get("includeSummary") === "1";
+        const qb = repo2.createQueryBuilder("contact").orderBy(`contact.${sortField}`, sortOrderContacts).skip(skip).take(limit);
+        if (search && typeof search === "string" && search.trim()) {
+          const term = `%${search.trim()}%`;
+          qb.andWhere("(contact.name ILIKE :term OR contact.email ILIKE :term OR contact.phone ILIKE :term)", { term });
+        }
+        if (typeFilter2) qb.andWhere("contact.type = :type", { type: typeFilter2 });
+        if (orderIdParam) {
+          const orderId = Number(orderIdParam);
+          if (!Number.isNaN(orderId)) {
+            qb.andWhere('contact.id IN (SELECT "contactId" FROM orders WHERE id = :orderId)', { orderId });
+          }
+        }
+        if (includeSummary && entityMap["orders"] && entityMap["payments"]) {
+          qb.loadRelationCountAndMap("contact._orderCount", "contact.orders");
+          const [rows, total3] = await qb.getManyAndCount();
+          const contactIds = rows.map((c) => c.id);
+          const paymentRepo = dataSource.getRepository(entityMap["payments"]);
+          const paidByContact = await paymentRepo.createQueryBuilder("p").select("p.contactId", "contactId").addSelect("COALESCE(SUM(CAST(p.amount AS DECIMAL)), 0)", "total").where("p.contactId IN (:...ids)", { ids: contactIds.length ? contactIds : [0] }).andWhere("p.status = :status", { status: "completed" }).groupBy("p.contactId").getRawMany();
+          const totalPaidMap = new Map(paidByContact.map((r) => [r.contactId, Number(r.total)]));
+          const data3 = rows.map((c) => {
+            const { _orderCount, ...rest } = c;
+            return {
+              ...rest,
+              orderCount: _orderCount ?? 0,
+              totalPaid: totalPaidMap.get(rest.id) ?? 0
+            };
+          });
+          return json({ total: total3, page, limit, totalPages: Math.ceil(total3 / limit), data: data3 });
+        }
+        const [data2, total2] = await qb.getManyAndCount();
+        return json({ total: total2, page, limit, totalPages: Math.ceil(total2 / limit), data: data2 });
+      }
+      const repo = dataSource.getRepository(entity);
       const typeFilter = searchParams.get("type");
       let where = {};
       if (resource === "media") {
@@ -1946,7 +3190,7 @@ function createCrudHandler(dataSource, entityMap, options) {
       const [data, total] = await repo.findAndCount({
         skip,
         take: limit,
-        order: { [sortField]: sortOrder },
+        order: { [sortFieldRaw]: sortOrder },
         where
       });
       return json({ total, page, limit, totalPages: Math.ceil(total / limit), data });
@@ -1966,6 +3210,107 @@ function createCrudHandler(dataSource, entityMap, options) {
       sanitizeBodyForEntity(repo, body);
       const created = await repo.save(repo.create(body));
       return json(created, { status: 201 });
+    },
+    async GET_METADATA(req, resource) {
+      const authError = await requireAuth(req);
+      if (authError) return authError;
+      const entity = entityMap[resource];
+      if (!resource || !entity) {
+        return json({ error: "Invalid resource" }, { status: 400 });
+      }
+      const repo = dataSource.getRepository(entity);
+      const meta = repo.metadata;
+      const uniqueFromIndices = /* @__PURE__ */ new Set();
+      for (const idx of meta.indices) {
+        if (idx.isUnique && idx.columns.length === 1) {
+          uniqueFromIndices.add(idx.columns[0].propertyName);
+        }
+      }
+      for (const uniq of meta.uniques) {
+        if (uniq.columns.length === 1) {
+          uniqueFromIndices.add(uniq.columns[0].propertyName);
+        }
+      }
+      const columns = meta.columns.map((col) => ({
+        name: col.propertyName,
+        type: typeof col.type === "string" ? col.type : col.type?.name ?? "unknown",
+        nullable: col.isNullable,
+        isUnique: uniqueFromIndices.has(col.propertyName),
+        isPrimary: col.isPrimary,
+        default: col.default
+      }));
+      const uniqueColumns = [...uniqueFromIndices];
+      return json({ columns, uniqueColumns });
+    },
+    async BULK_POST(req, resource) {
+      const authError = await requireAuth(req);
+      if (authError) return authError;
+      const entity = entityMap[resource];
+      if (!resource || !entity) {
+        return json({ error: "Invalid resource" }, { status: 400 });
+      }
+      const body = await req.json();
+      const { records, upsertKey = "id" } = body;
+      if (!Array.isArray(records) || records.length === 0) {
+        return json({ error: "Records array is required" }, { status: 400 });
+      }
+      const repo = dataSource.getRepository(entity);
+      for (const record of records) {
+        sanitizeBodyForEntity(repo, record);
+      }
+      try {
+        const result = await repo.upsert(records, {
+          conflictPaths: [upsertKey],
+          skipUpdateIfNoValuesChanged: true
+        });
+        return json({
+          success: true,
+          imported: result.identifiers.length,
+          identifiers: result.identifiers
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Bulk import failed";
+        return json({ error: message }, { status: 400 });
+      }
+    },
+    async GET_EXPORT(req, resource) {
+      const authError = await requireAuth(req);
+      if (authError) return authError;
+      const entity = entityMap[resource];
+      if (!resource || !entity) {
+        return json({ error: "Invalid resource" }, { status: 400 });
+      }
+      const { searchParams } = new URL(req.url);
+      const format = searchParams.get("format") || "csv";
+      const repo = dataSource.getRepository(entity);
+      const meta = repo.metadata;
+      const hasDeleted = meta.columns.some((c) => c.propertyName === "deleted");
+      const where = hasDeleted ? { deleted: false } : {};
+      const data = await repo.find({ where });
+      const excludeCols = /* @__PURE__ */ new Set(["deletedAt", "deletedBy", "deleted"]);
+      const columns = meta.columns.filter((c) => !excludeCols.has(c.propertyName)).map((c) => c.propertyName);
+      if (format === "json") {
+        return json(data);
+      }
+      const escapeCSV = (val) => {
+        if (val === null || val === void 0) return "";
+        const str = typeof val === "object" ? JSON.stringify(val) : String(val);
+        if (str.includes(",") || str.includes('"') || str.includes("\n")) {
+          return `"${str.replace(/"/g, '""')}"`;
+        }
+        return str;
+      };
+      const header = columns.join(",");
+      const rows = data.map(
+        (row) => columns.map((col) => escapeCSV(row[col])).join(",")
+      );
+      const csv = [header, ...rows].join("\n");
+      return new Response(csv, {
+        headers: {
+          "Content-Type": "text/csv; charset=utf-8",
+          "Content-Disposition": `attachment; filename="${resource}.csv"`
+        }
+      });
     }
   };
 }
@@ -1978,6 +3323,44 @@ function createCrudByIdHandler(dataSource, entityMap, options) {
       const entity = entityMap[resource];
       if (!entity) return json({ error: "Invalid resource" }, { status: 400 });
       const repo = dataSource.getRepository(entity);
+      if (resource === "orders") {
+        const order = await repo.findOne({
+          where: { id: Number(id) },
+          relations: ["contact", "billingAddress", "shippingAddress", "items", "items.product", "items.product.collection", "payments"]
+        });
+        if (!order) return json({ message: "Not found" }, { status: 404 });
+        return json(order);
+      }
+      if (resource === "contacts") {
+        const contact = await repo.findOne({
+          where: { id: Number(id) },
+          relations: ["form_submissions", "form_submissions.form", "orders", "payments", "addresses"]
+        });
+        if (!contact) return json({ message: "Not found" }, { status: 404 });
+        const orders = contact.orders ?? [];
+        const payments = contact.payments ?? [];
+        const totalPaid = payments.filter((p) => p.status === "completed").reduce((sum, p) => sum + Number(p.amount ?? 0), 0);
+        const lastOrderAt = orders.length > 0 ? orders.reduce((latest, o) => {
+          const t = o.createdAt ? new Date(o.createdAt).getTime() : 0;
+          return t > latest ? t : latest;
+        }, 0) : null;
+        return json({
+          ...contact,
+          summary: {
+            totalOrders: orders.length,
+            totalPaid,
+            lastOrderAt: lastOrderAt ? new Date(lastOrderAt).toISOString() : null
+          }
+        });
+      }
+      if (resource === "payments") {
+        const payment = await repo.findOne({
+          where: { id: Number(id) },
+          relations: ["order", "order.contact", "contact"]
+        });
+        if (!payment) return json({ message: "Not found" }, { status: 404 });
+        return json(payment);
+      }
       const item = await repo.findOne({ where: { id: Number(id) } });
       return item ? json(item) : json({ message: "Not found" }, { status: 404 });
     },
@@ -2018,8 +3401,8 @@ function createForgotPasswordHandler(config) {
       const user = await userRepo.findOne({ where: { email }, select: ["email"] });
       const msg = "If an account exists with this email, you will receive a reset link shortly.";
       if (!user) return json({ message: msg }, { status: 200 });
-      const crypto = await import("crypto");
-      const token = crypto.randomBytes(32).toString("hex");
+      const crypto2 = await import("crypto");
+      const token = crypto2.randomBytes(32).toString("hex");
       const expiresAt = new Date(Date.now() + resetExpiryHours * 60 * 60 * 1e3);
       const tokenRepo = dataSource.getRepository(entityMap.password_reset_tokens);
       await tokenRepo.save(tokenRepo.create({ email: user.email, token, expiresAt }));
@@ -2843,6 +4226,17 @@ function createCmsApiHandler(config) {
       if (path.length === 0) return config.json({ error: "Not found" }, { status: 404 });
       const resource = resolveResource(path[0]);
       if (!crudResources.includes(resource)) return config.json({ error: "Invalid resource" }, { status: 400 });
+      if (path.length === 2) {
+        if (path[1] === "metadata" && method === "GET") {
+          return crud.GET_METADATA(req, resource);
+        }
+        if (path[1] === "bulk" && method === "POST") {
+          return crud.BULK_POST(req, resource);
+        }
+        if (path[1] === "export" && method === "GET") {
+          return crud.GET_EXPORT(req, resource);
+        }
+      }
       if (path.length === 1) {
         if (method === "GET") return crud.GET(req, resource);
         if (method === "POST") return crud.POST(req, resource);
@@ -2871,9 +4265,12 @@ var DEFAULT_ADMIN_NAV = [
   { href: "/admin/pages", label: "Pages" }
 ];
 export {
+  Attribute,
   Blog,
+  Brand,
   CMS_ENTITY_MAP,
   Category,
+  Collection,
   Comment,
   Config,
   Contact,
@@ -2884,12 +4281,20 @@ export {
   FormSubmission,
   Media,
   OPEN_ENDPOINTS,
+  Order,
+  OrderItem,
   PERMISSION_REQUIRED_ENDPOINTS,
   Page,
   PasswordResetToken,
+  Payment,
   Permission,
+  Product,
+  ProductAttribute,
+  ProductCategory,
+  ProductTax,
   Seo,
   Tag,
+  Tax,
   User,
   UserGroup,
   analyticsPlugin,