@infuro/cms-core 1.0.4 → 1.0.6

package/dist/index.cjs

@@ -140,12 +140,123 @@ This link expires in 1 hour.`
   }
 });
 
+// src/plugins/payment/stripe.ts
+var stripe_exports = {};
+__export(stripe_exports, {
+  StripePaymentService: () => StripePaymentService
+});
+var import_stripe, StripePaymentService;
+var init_stripe = __esm({
+  "src/plugins/payment/stripe.ts"() {
+    "use strict";
+    import_stripe = __toESM(require("stripe"), 1);
+    StripePaymentService = class {
+      stripe;
+      webhookSecret;
+      constructor(config) {
+        this.stripe = new import_stripe.default(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
+});
+var import_razorpay, import_crypto, RazorpayPaymentService;
+var init_razorpay = __esm({
+  "src/plugins/payment/razorpay.ts"() {
+    "use strict";
+    import_razorpay = __toESM(require("razorpay"), 1);
+    import_crypto = __toESM(require("crypto"), 1);
+    RazorpayPaymentService = class {
+      razorpay;
+      keySecret;
+      webhookSecret;
+      constructor(config) {
+        this.razorpay = new import_razorpay.default({
+          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 = import_crypto.default.createHmac("sha256", secret).update(typeof payload === "string" ? payload : payload.toString("utf8")).digest("hex");
+        return import_crypto.default.timingSafeEqual(Buffer.from(signature), Buffer.from(expectedSignature));
+      }
+    };
+  }
+});
+
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  Attribute: () => Attribute,
   Blog: () => Blog,
+  Brand: () => Brand,
   CMS_ENTITY_MAP: () => CMS_ENTITY_MAP,
   Category: () => Category,
+  Collection: () => Collection,
   Comment: () => Comment,
   Config: () => Config,
   Contact: () => Contact,
@@ -156,12 +267,20 @@ __export(src_exports, {
   FormSubmission: () => FormSubmission,
   Media: () => Media,
   OPEN_ENDPOINTS: () => OPEN_ENDPOINTS,
+  Order: () => Order,
+  OrderItem: () => OrderItem,
   PERMISSION_REQUIRED_ENDPOINTS: () => PERMISSION_REQUIRED_ENDPOINTS,
   Page: () => Page,
   PasswordResetToken: () => PasswordResetToken,
+  Payment: () => Payment,
   Permission: () => Permission,
+  Product: () => Product,
+  ProductAttribute: () => ProductAttribute,
+  ProductCategory: () => ProductCategory,
+  ProductTax: () => ProductTax,
   Seo: () => Seo,
   Tag: () => Tag,
+  Tax: () => Tax,
   User: () => User,
   UserGroup: () => UserGroup,
   analyticsPlugin: () => analyticsPlugin,
@@ -635,12 +754,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;
     }
   };
 }
@@ -1006,7 +1152,7 @@ __decorateClass([
   (0, import_typeorm5.PrimaryGeneratedColumn)()
 ], Category.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm5.Column)("varchar")
+  (0, import_typeorm5.Column)("varchar", { unique: true })
 ], Category.prototype, "name", 2);
 __decorateClass([
   (0, import_typeorm5.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
@@ -1318,7 +1464,7 @@ Blog = __decorateClass([
 ], Blog);
 
 // src/entities/contact.entity.ts
-var import_typeorm13 = require("typeorm");
+var import_typeorm16 = require("typeorm");
 
 // src/entities/form-submission.entity.ts
 var import_typeorm12 = require("typeorm");
@@ -1527,12 +1673,266 @@ FormSubmission = __decorateClass([
   (0, import_typeorm12.Entity)("form_submissions")
 ], FormSubmission);
 
+// src/entities/address.entity.ts
+var import_typeorm13 = require("typeorm");
+var Address = class {
+  id;
+  contactId;
+  tag;
+  line1;
+  line2;
+  city;
+  state;
+  postalCode;
+  country;
+  createdAt;
+  updatedAt;
+  contact;
+};
+__decorateClass([
+  (0, import_typeorm13.PrimaryGeneratedColumn)()
+], Address.prototype, "id", 2);
+__decorateClass([
+  (0, import_typeorm13.Column)("int")
+], Address.prototype, "contactId", 2);
+__decorateClass([
+  (0, import_typeorm13.Column)("varchar", { nullable: true })
+], Address.prototype, "tag", 2);
+__decorateClass([
+  (0, import_typeorm13.Column)("varchar", { nullable: true })
+], Address.prototype, "line1", 2);
+__decorateClass([
+  (0, import_typeorm13.Column)("varchar", { nullable: true })
+], Address.prototype, "line2", 2);
+__decorateClass([
+  (0, import_typeorm13.Column)("varchar", { nullable: true })
+], Address.prototype, "city", 2);
+__decorateClass([
+  (0, import_typeorm13.Column)("varchar", { nullable: true })
+], Address.prototype, "state", 2);
+__decorateClass([
+  (0, import_typeorm13.Column)("varchar", { nullable: true })
+], Address.prototype, "postalCode", 2);
+__decorateClass([
+  (0, import_typeorm13.Column)("varchar", { nullable: true })
+], Address.prototype, "country", 2);
+__decorateClass([
+  (0, import_typeorm13.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Address.prototype, "createdAt", 2);
+__decorateClass([
+  (0, import_typeorm13.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Address.prototype, "updatedAt", 2);
+__decorateClass([
+  (0, import_typeorm13.ManyToOne)(() => Contact, (c) => c.addresses, { onDelete: "CASCADE" }),
+  (0, import_typeorm13.JoinColumn)({ name: "contactId" })
+], Address.prototype, "contact", 2);
+Address = __decorateClass([
+  (0, import_typeorm13.Entity)("addresses")
+], Address);
+
+// src/entities/order.entity.ts
+var import_typeorm14 = require("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([
+  (0, import_typeorm14.PrimaryGeneratedColumn)()
+], Order.prototype, "id", 2);
+__decorateClass([
+  (0, import_typeorm14.Column)("varchar", { unique: true })
+], Order.prototype, "orderNumber", 2);
+__decorateClass([
+  (0, import_typeorm14.Column)("int")
+], Order.prototype, "contactId", 2);
+__decorateClass([
+  (0, import_typeorm14.Column)("int", { nullable: true })
+], Order.prototype, "billingAddressId", 2);
+__decorateClass([
+  (0, import_typeorm14.Column)("int", { nullable: true })
+], Order.prototype, "shippingAddressId", 2);
+__decorateClass([
+  (0, import_typeorm14.Column)("varchar", { default: "pending" })
+], Order.prototype, "status", 2);
+__decorateClass([
+  (0, import_typeorm14.Column)("decimal", { precision: 12, scale: 2, default: 0 })
+], Order.prototype, "subtotal", 2);
+__decorateClass([
+  (0, import_typeorm14.Column)("decimal", { precision: 12, scale: 2, default: 0 })
+], Order.prototype, "tax", 2);
+__decorateClass([
+  (0, import_typeorm14.Column)("decimal", { precision: 12, scale: 2, default: 0 })
+], Order.prototype, "discount", 2);
+__decorateClass([
+  (0, import_typeorm14.Column)("decimal", { precision: 12, scale: 2, default: 0 })
+], Order.prototype, "total", 2);
+__decorateClass([
+  (0, import_typeorm14.Column)("varchar", { default: "INR" })
+], Order.prototype, "currency", 2);
+__decorateClass([
+  (0, import_typeorm14.Column)("jsonb", { nullable: true })
+], Order.prototype, "metadata", 2);
+__decorateClass([
+  (0, import_typeorm14.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Order.prototype, "createdAt", 2);
+__decorateClass([
+  (0, import_typeorm14.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Order.prototype, "updatedAt", 2);
+__decorateClass([
+  (0, import_typeorm14.Column)({ type: "timestamp", nullable: true })
+], Order.prototype, "deletedAt", 2);
+__decorateClass([
+  (0, import_typeorm14.Column)("boolean", { default: false })
+], Order.prototype, "deleted", 2);
+__decorateClass([
+  (0, import_typeorm14.Column)("int", { nullable: true })
+], Order.prototype, "createdBy", 2);
+__decorateClass([
+  (0, import_typeorm14.Column)("int", { nullable: true })
+], Order.prototype, "updatedBy", 2);
+__decorateClass([
+  (0, import_typeorm14.Column)("int", { nullable: true })
+], Order.prototype, "deletedBy", 2);
+__decorateClass([
+  (0, import_typeorm14.ManyToOne)(() => Contact, { onDelete: "CASCADE" }),
+  (0, import_typeorm14.JoinColumn)({ name: "contactId" })
+], Order.prototype, "contact", 2);
+__decorateClass([
+  (0, import_typeorm14.ManyToOne)(() => Address, { onDelete: "SET NULL" }),
+  (0, import_typeorm14.JoinColumn)({ name: "billingAddressId" })
+], Order.prototype, "billingAddress", 2);
+__decorateClass([
+  (0, import_typeorm14.ManyToOne)(() => Address, { onDelete: "SET NULL" }),
+  (0, import_typeorm14.JoinColumn)({ name: "shippingAddressId" })
+], Order.prototype, "shippingAddress", 2);
+__decorateClass([
+  (0, import_typeorm14.OneToMany)("OrderItem", "order")
+], Order.prototype, "items", 2);
+__decorateClass([
+  (0, import_typeorm14.OneToMany)("Payment", "order")
+], Order.prototype, "payments", 2);
+Order = __decorateClass([
+  (0, import_typeorm14.Entity)("orders")
+], Order);
+
+// src/entities/payment.entity.ts
+var import_typeorm15 = require("typeorm");
+var Payment = class {
+  id;
+  orderId;
+  contactId;
+  amount;
+  currency;
+  status;
+  method;
+  externalReference;
+  metadata;
+  paidAt;
+  createdAt;
+  updatedAt;
+  deletedAt;
+  deleted;
+  createdBy;
+  updatedBy;
+  deletedBy;
+  order;
+  contact;
+};
+__decorateClass([
+  (0, import_typeorm15.PrimaryGeneratedColumn)()
+], Payment.prototype, "id", 2);
+__decorateClass([
+  (0, import_typeorm15.Column)("int")
+], Payment.prototype, "orderId", 2);
+__decorateClass([
+  (0, import_typeorm15.Column)("int", { nullable: true })
+], Payment.prototype, "contactId", 2);
+__decorateClass([
+  (0, import_typeorm15.Column)("decimal", { precision: 12, scale: 2 })
+], Payment.prototype, "amount", 2);
+__decorateClass([
+  (0, import_typeorm15.Column)("varchar", { default: "INR" })
+], Payment.prototype, "currency", 2);
+__decorateClass([
+  (0, import_typeorm15.Column)("varchar", { default: "pending" })
+], Payment.prototype, "status", 2);
+__decorateClass([
+  (0, import_typeorm15.Column)("varchar", { nullable: true })
+], Payment.prototype, "method", 2);
+__decorateClass([
+  (0, import_typeorm15.Column)("varchar", { nullable: true })
+], Payment.prototype, "externalReference", 2);
+__decorateClass([
+  (0, import_typeorm15.Column)("jsonb", { nullable: true })
+], Payment.prototype, "metadata", 2);
+__decorateClass([
+  (0, import_typeorm15.Column)({ type: "timestamp", nullable: true })
+], Payment.prototype, "paidAt", 2);
+__decorateClass([
+  (0, import_typeorm15.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Payment.prototype, "createdAt", 2);
+__decorateClass([
+  (0, import_typeorm15.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Payment.prototype, "updatedAt", 2);
+__decorateClass([
+  (0, import_typeorm15.Column)({ type: "timestamp", nullable: true })
+], Payment.prototype, "deletedAt", 2);
+__decorateClass([
+  (0, import_typeorm15.Column)("boolean", { default: false })
+], Payment.prototype, "deleted", 2);
+__decorateClass([
+  (0, import_typeorm15.Column)("int", { nullable: true })
+], Payment.prototype, "createdBy", 2);
+__decorateClass([
+  (0, import_typeorm15.Column)("int", { nullable: true })
+], Payment.prototype, "updatedBy", 2);
+__decorateClass([
+  (0, import_typeorm15.Column)("int", { nullable: true })
+], Payment.prototype, "deletedBy", 2);
+__decorateClass([
+  (0, import_typeorm15.ManyToOne)(() => Order, (o) => o.payments, { onDelete: "CASCADE" }),
+  (0, import_typeorm15.JoinColumn)({ name: "orderId" })
+], Payment.prototype, "order", 2);
+__decorateClass([
+  (0, import_typeorm15.ManyToOne)(() => Contact, { onDelete: "SET NULL" }),
+  (0, import_typeorm15.JoinColumn)({ name: "contactId" })
+], Payment.prototype, "contact", 2);
+Payment = __decorateClass([
+  (0, import_typeorm15.Entity)("payments")
+], Payment);
+
 // src/entities/contact.entity.ts
 var Contact = class {
   id;
   name;
   email;
   phone;
+  type;
+  company;
+  taxId;
+  notes;
   createdAt;
   updatedAt;
   deletedAt;
@@ -1541,49 +1941,73 @@ var Contact = class {
   updatedBy;
   deletedBy;
   form_submissions;
+  addresses;
+  orders;
+  payments;
 };
 __decorateClass([
-  (0, import_typeorm13.PrimaryGeneratedColumn)()
+  (0, import_typeorm16.PrimaryGeneratedColumn)()
 ], Contact.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm13.Column)("varchar")
+  (0, import_typeorm16.Column)("varchar")
 ], Contact.prototype, "name", 2);
 __decorateClass([
-  (0, import_typeorm13.Column)("varchar", { unique: true })
+  (0, import_typeorm16.Column)("varchar", { unique: true })
 ], Contact.prototype, "email", 2);
 __decorateClass([
-  (0, import_typeorm13.Column)("varchar", { nullable: true })
+  (0, import_typeorm16.Column)("varchar", { nullable: true })
 ], Contact.prototype, "phone", 2);
 __decorateClass([
-  (0, import_typeorm13.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm16.Column)("varchar", { nullable: true })
+], Contact.prototype, "type", 2);
+__decorateClass([
+  (0, import_typeorm16.Column)("varchar", { nullable: true })
+], Contact.prototype, "company", 2);
+__decorateClass([
+  (0, import_typeorm16.Column)("varchar", { nullable: true })
+], Contact.prototype, "taxId", 2);
+__decorateClass([
+  (0, import_typeorm16.Column)("text", { nullable: true })
+], Contact.prototype, "notes", 2);
+__decorateClass([
+  (0, import_typeorm16.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Contact.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm13.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm16.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Contact.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm13.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm16.Column)({ type: "timestamp", nullable: true })
 ], Contact.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm13.Column)("boolean", { default: false })
+  (0, import_typeorm16.Column)("boolean", { default: false })
 ], Contact.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm13.Column)("int", { nullable: true })
+  (0, import_typeorm16.Column)("int", { nullable: true })
 ], Contact.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm13.Column)("int", { nullable: true })
+  (0, import_typeorm16.Column)("int", { nullable: true })
 ], Contact.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm13.Column)("int", { nullable: true })
+  (0, import_typeorm16.Column)("int", { nullable: true })
 ], Contact.prototype, "deletedBy", 2);
 __decorateClass([
-  (0, import_typeorm13.OneToMany)(() => FormSubmission, (fs) => fs.contact)
+  (0, import_typeorm16.OneToMany)(() => FormSubmission, (fs) => fs.contact)
 ], Contact.prototype, "form_submissions", 2);
+__decorateClass([
+  (0, import_typeorm16.OneToMany)(() => Address, (a) => a.contact)
+], Contact.prototype, "addresses", 2);
+__decorateClass([
+  (0, import_typeorm16.OneToMany)(() => Order, (o) => o.contact)
+], Contact.prototype, "orders", 2);
+__decorateClass([
+  (0, import_typeorm16.OneToMany)(() => Payment, (p) => p.contact)
+], Contact.prototype, "payments", 2);
 Contact = __decorateClass([
-  (0, import_typeorm13.Entity)("contacts")
+  (0, import_typeorm16.Entity)("contacts")
 ], Contact);
 
 // src/entities/config.entity.ts
-var import_typeorm14 = require("typeorm");
+var import_typeorm17 = require("typeorm");
 var Config = class {
   id;
   settings;
@@ -1600,51 +2024,51 @@ var Config = class {
   deletedBy;
 };
 __decorateClass([
-  (0, import_typeorm14.PrimaryGeneratedColumn)()
+  (0, import_typeorm17.PrimaryGeneratedColumn)()
 ], Config.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm14.Column)("varchar")
+  (0, import_typeorm17.Column)("varchar")
 ], Config.prototype, "settings", 2);
 __decorateClass([
-  (0, import_typeorm14.Column)("varchar")
+  (0, import_typeorm17.Column)("varchar")
 ], Config.prototype, "key", 2);
 __decorateClass([
-  (0, import_typeorm14.Column)("varchar")
+  (0, import_typeorm17.Column)("varchar")
 ], Config.prototype, "value", 2);
 __decorateClass([
-  (0, import_typeorm14.Column)("varchar", { default: "private" })
+  (0, import_typeorm17.Column)("varchar", { default: "private" })
 ], Config.prototype, "type", 2);
 __decorateClass([
-  (0, import_typeorm14.Column)("boolean", { default: false })
+  (0, import_typeorm17.Column)("boolean", { default: false })
 ], Config.prototype, "encrypted", 2);
 __decorateClass([
-  (0, import_typeorm14.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm17.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Config.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm14.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm17.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Config.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm14.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm17.Column)({ type: "timestamp", nullable: true })
 ], Config.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm14.Column)("boolean", { default: false })
+  (0, import_typeorm17.Column)("boolean", { default: false })
 ], Config.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm14.Column)("int", { nullable: true })
+  (0, import_typeorm17.Column)("int", { nullable: true })
 ], Config.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm14.Column)("int", { nullable: true })
+  (0, import_typeorm17.Column)("int", { nullable: true })
 ], Config.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm14.Column)("int", { nullable: true })
+  (0, import_typeorm17.Column)("int", { nullable: true })
 ], Config.prototype, "deletedBy", 2);
 Config = __decorateClass([
-  (0, import_typeorm14.Entity)("configs"),
-  (0, import_typeorm14.Unique)(["settings", "key"])
+  (0, import_typeorm17.Entity)("configs"),
+  (0, import_typeorm17.Unique)(["settings", "key"])
 ], Config);
 
 // src/entities/media.entity.ts
-var import_typeorm15 = require("typeorm");
+var import_typeorm18 = require("typeorm");
 var Media = class {
   id;
   filename;
@@ -1659,44 +2083,44 @@ var Media = class {
   deleted;
 };
 __decorateClass([
-  (0, import_typeorm15.PrimaryGeneratedColumn)()
+  (0, import_typeorm18.PrimaryGeneratedColumn)()
 ], Media.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm15.Column)("varchar")
+  (0, import_typeorm18.Column)("varchar")
 ], Media.prototype, "filename", 2);
 __decorateClass([
-  (0, import_typeorm15.Column)("varchar")
+  (0, import_typeorm18.Column)("varchar")
 ], Media.prototype, "url", 2);
 __decorateClass([
-  (0, import_typeorm15.Column)("varchar")
+  (0, import_typeorm18.Column)("varchar")
 ], Media.prototype, "mimeType", 2);
 __decorateClass([
-  (0, import_typeorm15.Column)("int", { default: 0 })
+  (0, import_typeorm18.Column)("int", { default: 0 })
 ], Media.prototype, "size", 2);
 __decorateClass([
-  (0, import_typeorm15.Column)("varchar", { nullable: true })
+  (0, import_typeorm18.Column)("varchar", { nullable: true })
 ], Media.prototype, "alt", 2);
 __decorateClass([
-  (0, import_typeorm15.Column)("boolean", { default: false })
+  (0, import_typeorm18.Column)("boolean", { default: false })
 ], Media.prototype, "isPublic", 2);
 __decorateClass([
-  (0, import_typeorm15.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm18.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Media.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm15.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm18.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Media.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm15.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm18.Column)({ type: "timestamp", nullable: true })
 ], Media.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm15.Column)("boolean", { default: false })
+  (0, import_typeorm18.Column)("boolean", { default: false })
 ], Media.prototype, "deleted", 2);
 Media = __decorateClass([
-  (0, import_typeorm15.Entity)("media")
+  (0, import_typeorm18.Entity)("media")
 ], Media);
 
 // src/entities/page.entity.ts
-var import_typeorm16 = require("typeorm");
+var import_typeorm19 = require("typeorm");
 var Page = class {
   id;
   title;
@@ -1717,86 +2141,775 @@ var Page = class {
   deletedBy;
 };
 __decorateClass([
-  (0, import_typeorm16.PrimaryGeneratedColumn)()
+  (0, import_typeorm19.PrimaryGeneratedColumn)()
 ], Page.prototype, "id", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("varchar")
+  (0, import_typeorm19.Column)("varchar")
 ], Page.prototype, "title", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("varchar", { unique: true })
+  (0, import_typeorm19.Column)("varchar", { unique: true })
 ], Page.prototype, "slug", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)({ type: "jsonb", default: {} })
+  (0, import_typeorm19.Column)({ type: "jsonb", default: {} })
 ], Page.prototype, "content", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("boolean", { default: false })
+  (0, import_typeorm19.Column)("boolean", { default: false })
 ], Page.prototype, "published", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("varchar", { default: "default" })
+  (0, import_typeorm19.Column)("varchar", { default: "default" })
 ], Page.prototype, "theme", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("int", { nullable: true })
+  (0, import_typeorm19.Column)("int", { nullable: true })
 ], Page.prototype, "parentId", 2);
 __decorateClass([
-  (0, import_typeorm16.ManyToOne)(() => Page, { onDelete: "SET NULL" }),
-  (0, import_typeorm16.JoinColumn)({ name: "parentId" })
+  (0, import_typeorm19.ManyToOne)(() => Page, { onDelete: "SET NULL" }),
+  (0, import_typeorm19.JoinColumn)({ name: "parentId" })
 ], Page.prototype, "parent", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("int", { nullable: true })
+  (0, import_typeorm19.Column)("int", { nullable: true })
 ], Page.prototype, "seoId", 2);
 __decorateClass([
-  (0, import_typeorm16.ManyToOne)(() => Seo, { onDelete: "SET NULL" }),
-  (0, import_typeorm16.JoinColumn)({ name: "seoId" })
+  (0, import_typeorm19.ManyToOne)(() => Seo, { onDelete: "SET NULL" }),
+  (0, import_typeorm19.JoinColumn)({ name: "seoId" })
 ], Page.prototype, "seo", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm19.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Page.prototype, "createdAt", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+  (0, import_typeorm19.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
 ], Page.prototype, "updatedAt", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)({ type: "timestamp", nullable: true })
+  (0, import_typeorm19.Column)({ type: "timestamp", nullable: true })
 ], Page.prototype, "deletedAt", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("boolean", { default: false })
+  (0, import_typeorm19.Column)("boolean", { default: false })
 ], Page.prototype, "deleted", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("int", { nullable: true })
+  (0, import_typeorm19.Column)("int", { nullable: true })
 ], Page.prototype, "createdBy", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("int", { nullable: true })
+  (0, import_typeorm19.Column)("int", { nullable: true })
 ], Page.prototype, "updatedBy", 2);
 __decorateClass([
-  (0, import_typeorm16.Column)("int", { nullable: true })
+  (0, import_typeorm19.Column)("int", { nullable: true })
 ], Page.prototype, "deletedBy", 2);
 Page = __decorateClass([
-  (0, import_typeorm16.Entity)("pages")
+  (0, import_typeorm19.Entity)("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
+var import_typeorm20 = require("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"] },
+__decorateClass([
+  (0, import_typeorm20.PrimaryGeneratedColumn)()
+], ProductCategory.prototype, "id", 2);
+__decorateClass([
+  (0, import_typeorm20.Column)("varchar")
+], ProductCategory.prototype, "name", 2);
+__decorateClass([
+  (0, import_typeorm20.Column)("varchar", { unique: true })
+], ProductCategory.prototype, "slug", 2);
+__decorateClass([
+  (0, import_typeorm20.Column)("int", { nullable: true })
+], ProductCategory.prototype, "parentId", 2);
+__decorateClass([
+  (0, import_typeorm20.Column)("varchar", { nullable: true })
+], ProductCategory.prototype, "image", 2);
+__decorateClass([
+  (0, import_typeorm20.Column)("text", { nullable: true })
+], ProductCategory.prototype, "description", 2);
+__decorateClass([
+  (0, import_typeorm20.Column)("jsonb", { nullable: true })
+], ProductCategory.prototype, "metadata", 2);
+__decorateClass([
+  (0, import_typeorm20.Column)("boolean", { default: true })
+], ProductCategory.prototype, "active", 2);
+__decorateClass([
+  (0, import_typeorm20.Column)("int", { default: 0 })
+], ProductCategory.prototype, "sortOrder", 2);
+__decorateClass([
+  (0, import_typeorm20.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], ProductCategory.prototype, "createdAt", 2);
+__decorateClass([
+  (0, import_typeorm20.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], ProductCategory.prototype, "updatedAt", 2);
+__decorateClass([
+  (0, import_typeorm20.Column)({ type: "timestamp", nullable: true })
+], ProductCategory.prototype, "deletedAt", 2);
+__decorateClass([
+  (0, import_typeorm20.Column)("boolean", { default: false })
+], ProductCategory.prototype, "deleted", 2);
+__decorateClass([
+  (0, import_typeorm20.Column)("int", { nullable: true })
+], ProductCategory.prototype, "createdBy", 2);
+__decorateClass([
+  (0, import_typeorm20.Column)("int", { nullable: true })
+], ProductCategory.prototype, "updatedBy", 2);
+__decorateClass([
+  (0, import_typeorm20.Column)("int", { nullable: true })
+], ProductCategory.prototype, "deletedBy", 2);
+__decorateClass([
+  (0, import_typeorm20.ManyToOne)(() => ProductCategory, (c) => c.children, { onDelete: "SET NULL" }),
+  (0, import_typeorm20.JoinColumn)({ name: "parentId" })
+], ProductCategory.prototype, "parent", 2);
+__decorateClass([
+  (0, import_typeorm20.OneToMany)(() => ProductCategory, (c) => c.parent)
+], ProductCategory.prototype, "children", 2);
+__decorateClass([
+  (0, import_typeorm20.OneToMany)("Product", "category")
+], ProductCategory.prototype, "products", 2);
+__decorateClass([
+  (0, import_typeorm20.OneToMany)("Collection", "category")
+], ProductCategory.prototype, "collections", 2);
+ProductCategory = __decorateClass([
+  (0, import_typeorm20.Entity)("product_categories")
+], ProductCategory);
+
+// src/entities/collection.entity.ts
+var import_typeorm22 = require("typeorm");
+
+// src/entities/brand.entity.ts
+var import_typeorm21 = require("typeorm");
+var Brand = class {
+  id;
+  name;
+  slug;
+  logo;
+  metadata;
+  description;
+  active;
+  sortOrder;
+  createdAt;
+  updatedAt;
+  deletedAt;
+  deleted;
+  createdBy;
+  updatedBy;
+  deletedBy;
+  seoId;
+  seo;
+  products;
+  collections;
+};
+__decorateClass([
+  (0, import_typeorm21.PrimaryGeneratedColumn)()
+], Brand.prototype, "id", 2);
+__decorateClass([
+  (0, import_typeorm21.Column)("varchar")
+], Brand.prototype, "name", 2);
+__decorateClass([
+  (0, import_typeorm21.Column)("varchar", { unique: true })
+], Brand.prototype, "slug", 2);
+__decorateClass([
+  (0, import_typeorm21.Column)("varchar", { nullable: true })
+], Brand.prototype, "logo", 2);
+__decorateClass([
+  (0, import_typeorm21.Column)("jsonb", { nullable: true })
+], Brand.prototype, "metadata", 2);
+__decorateClass([
+  (0, import_typeorm21.Column)("text", { nullable: true })
+], Brand.prototype, "description", 2);
+__decorateClass([
+  (0, import_typeorm21.Column)("boolean", { default: true })
+], Brand.prototype, "active", 2);
+__decorateClass([
+  (0, import_typeorm21.Column)("int", { default: 0 })
+], Brand.prototype, "sortOrder", 2);
+__decorateClass([
+  (0, import_typeorm21.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Brand.prototype, "createdAt", 2);
+__decorateClass([
+  (0, import_typeorm21.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Brand.prototype, "updatedAt", 2);
+__decorateClass([
+  (0, import_typeorm21.Column)({ type: "timestamp", nullable: true })
+], Brand.prototype, "deletedAt", 2);
+__decorateClass([
+  (0, import_typeorm21.Column)("boolean", { default: false })
+], Brand.prototype, "deleted", 2);
+__decorateClass([
+  (0, import_typeorm21.Column)("int", { nullable: true })
+], Brand.prototype, "createdBy", 2);
+__decorateClass([
+  (0, import_typeorm21.Column)("int", { nullable: true })
+], Brand.prototype, "updatedBy", 2);
+__decorateClass([
+  (0, import_typeorm21.Column)("int", { nullable: true })
+], Brand.prototype, "deletedBy", 2);
+__decorateClass([
+  (0, import_typeorm21.Column)("int", { nullable: true })
+], Brand.prototype, "seoId", 2);
+__decorateClass([
+  (0, import_typeorm21.ManyToOne)(() => Seo, { onDelete: "SET NULL" }),
+  (0, import_typeorm21.JoinColumn)({ name: "seoId" })
+], Brand.prototype, "seo", 2);
+__decorateClass([
+  (0, import_typeorm21.OneToMany)("Product", "brand")
+], Brand.prototype, "products", 2);
+__decorateClass([
+  (0, import_typeorm21.OneToMany)("Collection", "brand")
+], Brand.prototype, "collections", 2);
+Brand = __decorateClass([
+  (0, import_typeorm21.Entity)("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([
+  (0, import_typeorm22.PrimaryGeneratedColumn)()
+], Collection.prototype, "id", 2);
+__decorateClass([
+  (0, import_typeorm22.Column)("int", { nullable: true })
+], Collection.prototype, "categoryId", 2);
+__decorateClass([
+  (0, import_typeorm22.Column)("int", { nullable: true })
+], Collection.prototype, "brandId", 2);
+__decorateClass([
+  (0, import_typeorm22.Column)("varchar")
+], Collection.prototype, "name", 2);
+__decorateClass([
+  (0, import_typeorm22.Column)("varchar", { unique: true })
+], Collection.prototype, "slug", 2);
+__decorateClass([
+  (0, import_typeorm22.Column)("text", { nullable: true })
+], Collection.prototype, "description", 2);
+__decorateClass([
+  (0, import_typeorm22.Column)("varchar", { nullable: true })
+], Collection.prototype, "image", 2);
+__decorateClass([
+  (0, import_typeorm22.Column)("jsonb", { nullable: true })
+], Collection.prototype, "metadata", 2);
+__decorateClass([
+  (0, import_typeorm22.Column)("boolean", { default: true })
+], Collection.prototype, "active", 2);
+__decorateClass([
+  (0, import_typeorm22.Column)("int", { default: 0 })
+], Collection.prototype, "sortOrder", 2);
+__decorateClass([
+  (0, import_typeorm22.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Collection.prototype, "createdAt", 2);
+__decorateClass([
+  (0, import_typeorm22.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Collection.prototype, "updatedAt", 2);
+__decorateClass([
+  (0, import_typeorm22.Column)({ type: "timestamp", nullable: true })
+], Collection.prototype, "deletedAt", 2);
+__decorateClass([
+  (0, import_typeorm22.Column)("boolean", { default: false })
+], Collection.prototype, "deleted", 2);
+__decorateClass([
+  (0, import_typeorm22.Column)("int", { nullable: true })
+], Collection.prototype, "createdBy", 2);
+__decorateClass([
+  (0, import_typeorm22.Column)("int", { nullable: true })
+], Collection.prototype, "updatedBy", 2);
+__decorateClass([
+  (0, import_typeorm22.Column)("int", { nullable: true })
+], Collection.prototype, "deletedBy", 2);
+__decorateClass([
+  (0, import_typeorm22.Column)("int", { nullable: true })
+], Collection.prototype, "seoId", 2);
+__decorateClass([
+  (0, import_typeorm22.ManyToOne)(() => Seo, { onDelete: "SET NULL" }),
+  (0, import_typeorm22.JoinColumn)({ name: "seoId" })
+], Collection.prototype, "seo", 2);
+__decorateClass([
+  (0, import_typeorm22.ManyToOne)(() => ProductCategory, (c) => c.collections, { onDelete: "SET NULL" }),
+  (0, import_typeorm22.JoinColumn)({ name: "categoryId" })
+], Collection.prototype, "category", 2);
+__decorateClass([
+  (0, import_typeorm22.ManyToOne)(() => Brand, (b) => b.collections, { onDelete: "SET NULL" }),
+  (0, import_typeorm22.JoinColumn)({ name: "brandId" })
+], Collection.prototype, "brand", 2);
+__decorateClass([
+  (0, import_typeorm22.OneToMany)("Product", "collection")
+], Collection.prototype, "products", 2);
+Collection = __decorateClass([
+  (0, import_typeorm22.Entity)("collections")
+], Collection);
+
+// src/entities/product.entity.ts
+var import_typeorm23 = require("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([
+  (0, import_typeorm23.PrimaryGeneratedColumn)()
+], Product.prototype, "id", 2);
+__decorateClass([
+  (0, import_typeorm23.Column)("int", { nullable: true })
+], Product.prototype, "collectionId", 2);
+__decorateClass([
+  (0, import_typeorm23.Column)("int", { nullable: true })
+], Product.prototype, "brandId", 2);
+__decorateClass([
+  (0, import_typeorm23.Column)("int", { nullable: true })
+], Product.prototype, "categoryId", 2);
+__decorateClass([
+  (0, import_typeorm23.Column)("varchar", { nullable: true })
+], Product.prototype, "sku", 2);
+__decorateClass([
+  (0, import_typeorm23.Column)("varchar", { unique: true, nullable: true })
+], Product.prototype, "slug", 2);
+__decorateClass([
+  (0, import_typeorm23.Column)("varchar", { nullable: true })
+], Product.prototype, "name", 2);
+__decorateClass([
+  (0, import_typeorm23.Column)("decimal", { precision: 12, scale: 2 })
+], Product.prototype, "price", 2);
+__decorateClass([
+  (0, import_typeorm23.Column)("decimal", { precision: 12, scale: 2, nullable: true })
+], Product.prototype, "compareAtPrice", 2);
+__decorateClass([
+  (0, import_typeorm23.Column)("int", { default: 0 })
+], Product.prototype, "quantity", 2);
+__decorateClass([
+  (0, import_typeorm23.Column)("varchar", { default: "draft" })
+], Product.prototype, "status", 2);
+__decorateClass([
+  (0, import_typeorm23.Column)("boolean", { default: false })
+], Product.prototype, "featured", 2);
+__decorateClass([
+  (0, import_typeorm23.Column)("jsonb", { nullable: true })
+], Product.prototype, "metadata", 2);
+__decorateClass([
+  (0, import_typeorm23.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Product.prototype, "createdAt", 2);
+__decorateClass([
+  (0, import_typeorm23.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Product.prototype, "updatedAt", 2);
+__decorateClass([
+  (0, import_typeorm23.Column)({ type: "timestamp", nullable: true })
+], Product.prototype, "deletedAt", 2);
+__decorateClass([
+  (0, import_typeorm23.Column)("boolean", { default: false })
+], Product.prototype, "deleted", 2);
+__decorateClass([
+  (0, import_typeorm23.Column)("int", { nullable: true })
+], Product.prototype, "createdBy", 2);
+__decorateClass([
+  (0, import_typeorm23.Column)("int", { nullable: true })
+], Product.prototype, "updatedBy", 2);
+__decorateClass([
+  (0, import_typeorm23.Column)("int", { nullable: true })
+], Product.prototype, "deletedBy", 2);
+__decorateClass([
+  (0, import_typeorm23.Column)("int", { nullable: true })
+], Product.prototype, "seoId", 2);
+__decorateClass([
+  (0, import_typeorm23.ManyToOne)(() => Seo, { onDelete: "SET NULL" }),
+  (0, import_typeorm23.JoinColumn)({ name: "seoId" })
+], Product.prototype, "seo", 2);
+__decorateClass([
+  (0, import_typeorm23.ManyToOne)(() => Collection, (c) => c.products, { onDelete: "SET NULL" }),
+  (0, import_typeorm23.JoinColumn)({ name: "collectionId" })
+], Product.prototype, "collection", 2);
+__decorateClass([
+  (0, import_typeorm23.ManyToOne)(() => Brand, (b) => b.products, { onDelete: "SET NULL" }),
+  (0, import_typeorm23.JoinColumn)({ name: "brandId" })
+], Product.prototype, "brand", 2);
+__decorateClass([
+  (0, import_typeorm23.ManyToOne)(() => ProductCategory, (c) => c.products, { onDelete: "SET NULL" }),
+  (0, import_typeorm23.JoinColumn)({ name: "categoryId" })
+], Product.prototype, "category", 2);
+__decorateClass([
+  (0, import_typeorm23.OneToMany)("ProductAttribute", "product")
+], Product.prototype, "attributes", 2);
+__decorateClass([
+  (0, import_typeorm23.OneToMany)("ProductTax", "product")
+], Product.prototype, "taxes", 2);
+Product = __decorateClass([
+  (0, import_typeorm23.Entity)("products")
+], Product);
+
+// src/entities/attribute.entity.ts
+var import_typeorm24 = require("typeorm");
+var Attribute = class {
+  id;
+  name;
+  slug;
+  type;
+  options;
+  metadata;
+  active;
+  sortOrder;
+  createdAt;
+  updatedAt;
+  deletedAt;
+  deleted;
+  createdBy;
+  updatedBy;
+  deletedBy;
+};
+__decorateClass([
+  (0, import_typeorm24.PrimaryGeneratedColumn)()
+], Attribute.prototype, "id", 2);
+__decorateClass([
+  (0, import_typeorm24.Column)("varchar")
+], Attribute.prototype, "name", 2);
+__decorateClass([
+  (0, import_typeorm24.Column)("varchar", { unique: true })
+], Attribute.prototype, "slug", 2);
+__decorateClass([
+  (0, import_typeorm24.Column)("varchar", { default: "text" })
+], Attribute.prototype, "type", 2);
+__decorateClass([
+  (0, import_typeorm24.Column)("jsonb", { nullable: true })
+], Attribute.prototype, "options", 2);
+__decorateClass([
+  (0, import_typeorm24.Column)("jsonb", { nullable: true })
+], Attribute.prototype, "metadata", 2);
+__decorateClass([
+  (0, import_typeorm24.Column)("boolean", { default: true })
+], Attribute.prototype, "active", 2);
+__decorateClass([
+  (0, import_typeorm24.Column)("int", { default: 0 })
+], Attribute.prototype, "sortOrder", 2);
+__decorateClass([
+  (0, import_typeorm24.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Attribute.prototype, "createdAt", 2);
+__decorateClass([
+  (0, import_typeorm24.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Attribute.prototype, "updatedAt", 2);
+__decorateClass([
+  (0, import_typeorm24.Column)({ type: "timestamp", nullable: true })
+], Attribute.prototype, "deletedAt", 2);
+__decorateClass([
+  (0, import_typeorm24.Column)("boolean", { default: false })
+], Attribute.prototype, "deleted", 2);
+__decorateClass([
+  (0, import_typeorm24.Column)("int", { nullable: true })
+], Attribute.prototype, "createdBy", 2);
+__decorateClass([
+  (0, import_typeorm24.Column)("int", { nullable: true })
+], Attribute.prototype, "updatedBy", 2);
+__decorateClass([
+  (0, import_typeorm24.Column)("int", { nullable: true })
+], Attribute.prototype, "deletedBy", 2);
+Attribute = __decorateClass([
+  (0, import_typeorm24.Entity)("attributes")
+], Attribute);
+
+// src/entities/product-attribute.entity.ts
+var import_typeorm25 = require("typeorm");
+var ProductAttribute = class {
+  id;
+  productId;
+  attributeId;
+  value;
+  metadata;
+  createdAt;
+  updatedAt;
+  product;
+  attribute;
+};
+__decorateClass([
+  (0, import_typeorm25.PrimaryGeneratedColumn)()
+], ProductAttribute.prototype, "id", 2);
+__decorateClass([
+  (0, import_typeorm25.Column)("int")
+], ProductAttribute.prototype, "productId", 2);
+__decorateClass([
+  (0, import_typeorm25.Column)("int")
+], ProductAttribute.prototype, "attributeId", 2);
+__decorateClass([
+  (0, import_typeorm25.Column)("varchar")
+], ProductAttribute.prototype, "value", 2);
+__decorateClass([
+  (0, import_typeorm25.Column)("jsonb", { nullable: true })
+], ProductAttribute.prototype, "metadata", 2);
+__decorateClass([
+  (0, import_typeorm25.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], ProductAttribute.prototype, "createdAt", 2);
+__decorateClass([
+  (0, import_typeorm25.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], ProductAttribute.prototype, "updatedAt", 2);
+__decorateClass([
+  (0, import_typeorm25.ManyToOne)(() => Product, (p) => p.attributes, { onDelete: "CASCADE" }),
+  (0, import_typeorm25.JoinColumn)({ name: "productId" })
+], ProductAttribute.prototype, "product", 2);
+__decorateClass([
+  (0, import_typeorm25.ManyToOne)(() => Attribute, { onDelete: "CASCADE" }),
+  (0, import_typeorm25.JoinColumn)({ name: "attributeId" })
+], ProductAttribute.prototype, "attribute", 2);
+ProductAttribute = __decorateClass([
+  (0, import_typeorm25.Entity)("product_attributes")
+], ProductAttribute);
+
+// src/entities/tax.entity.ts
+var import_typeorm26 = require("typeorm");
+var Tax = class {
+  id;
+  name;
+  slug;
+  rate;
+  isDefault;
+  description;
+  active;
+  metadata;
+  createdAt;
+  updatedAt;
+  deletedAt;
+  deleted;
+  createdBy;
+  updatedBy;
+  deletedBy;
+};
+__decorateClass([
+  (0, import_typeorm26.PrimaryGeneratedColumn)()
+], Tax.prototype, "id", 2);
+__decorateClass([
+  (0, import_typeorm26.Column)("varchar")
+], Tax.prototype, "name", 2);
+__decorateClass([
+  (0, import_typeorm26.Column)("varchar", { unique: true })
+], Tax.prototype, "slug", 2);
+__decorateClass([
+  (0, import_typeorm26.Column)("decimal", { precision: 5, scale: 2 })
+], Tax.prototype, "rate", 2);
+__decorateClass([
+  (0, import_typeorm26.Column)("boolean", { default: false })
+], Tax.prototype, "isDefault", 2);
+__decorateClass([
+  (0, import_typeorm26.Column)("text", { nullable: true })
+], Tax.prototype, "description", 2);
+__decorateClass([
+  (0, import_typeorm26.Column)("boolean", { default: true })
+], Tax.prototype, "active", 2);
+__decorateClass([
+  (0, import_typeorm26.Column)("jsonb", { nullable: true })
+], Tax.prototype, "metadata", 2);
+__decorateClass([
+  (0, import_typeorm26.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Tax.prototype, "createdAt", 2);
+__decorateClass([
+  (0, import_typeorm26.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], Tax.prototype, "updatedAt", 2);
+__decorateClass([
+  (0, import_typeorm26.Column)({ type: "timestamp", nullable: true })
+], Tax.prototype, "deletedAt", 2);
+__decorateClass([
+  (0, import_typeorm26.Column)("boolean", { default: false })
+], Tax.prototype, "deleted", 2);
+__decorateClass([
+  (0, import_typeorm26.Column)("int", { nullable: true })
+], Tax.prototype, "createdBy", 2);
+__decorateClass([
+  (0, import_typeorm26.Column)("int", { nullable: true })
+], Tax.prototype, "updatedBy", 2);
+__decorateClass([
+  (0, import_typeorm26.Column)("int", { nullable: true })
+], Tax.prototype, "deletedBy", 2);
+Tax = __decorateClass([
+  (0, import_typeorm26.Entity)("taxes")
+], Tax);
+
+// src/entities/product-tax.entity.ts
+var import_typeorm27 = require("typeorm");
+var ProductTax = class {
+  id;
+  productId;
+  taxId;
+  rate;
+  createdAt;
+  updatedAt;
+  product;
+  tax;
+};
+__decorateClass([
+  (0, import_typeorm27.PrimaryGeneratedColumn)()
+], ProductTax.prototype, "id", 2);
+__decorateClass([
+  (0, import_typeorm27.Column)("int")
+], ProductTax.prototype, "productId", 2);
+__decorateClass([
+  (0, import_typeorm27.Column)("int")
+], ProductTax.prototype, "taxId", 2);
+__decorateClass([
+  (0, import_typeorm27.Column)("decimal", { precision: 5, scale: 2, nullable: true })
+], ProductTax.prototype, "rate", 2);
+__decorateClass([
+  (0, import_typeorm27.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], ProductTax.prototype, "createdAt", 2);
+__decorateClass([
+  (0, import_typeorm27.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], ProductTax.prototype, "updatedAt", 2);
+__decorateClass([
+  (0, import_typeorm27.ManyToOne)(() => Product, (p) => p.taxes, { onDelete: "CASCADE" }),
+  (0, import_typeorm27.JoinColumn)({ name: "productId" })
+], ProductTax.prototype, "product", 2);
+__decorateClass([
+  (0, import_typeorm27.ManyToOne)(() => Tax, { onDelete: "CASCADE" }),
+  (0, import_typeorm27.JoinColumn)({ name: "taxId" })
+], ProductTax.prototype, "tax", 2);
+ProductTax = __decorateClass([
+  (0, import_typeorm27.Entity)("product_taxes")
+], ProductTax);
+
+// src/entities/order-item.entity.ts
+var import_typeorm28 = require("typeorm");
+var OrderItem = class {
+  id;
+  orderId;
+  productId;
+  quantity;
+  unitPrice;
+  tax;
+  total;
+  metadata;
+  createdAt;
+  updatedAt;
+  order;
+  product;
+};
+__decorateClass([
+  (0, import_typeorm28.PrimaryGeneratedColumn)()
+], OrderItem.prototype, "id", 2);
+__decorateClass([
+  (0, import_typeorm28.Column)("int")
+], OrderItem.prototype, "orderId", 2);
+__decorateClass([
+  (0, import_typeorm28.Column)("int")
+], OrderItem.prototype, "productId", 2);
+__decorateClass([
+  (0, import_typeorm28.Column)("int", { default: 1 })
+], OrderItem.prototype, "quantity", 2);
+__decorateClass([
+  (0, import_typeorm28.Column)("decimal", { precision: 12, scale: 2 })
+], OrderItem.prototype, "unitPrice", 2);
+__decorateClass([
+  (0, import_typeorm28.Column)("decimal", { precision: 12, scale: 2, default: 0 })
+], OrderItem.prototype, "tax", 2);
+__decorateClass([
+  (0, import_typeorm28.Column)("decimal", { precision: 12, scale: 2 })
+], OrderItem.prototype, "total", 2);
+__decorateClass([
+  (0, import_typeorm28.Column)("jsonb", { nullable: true })
+], OrderItem.prototype, "metadata", 2);
+__decorateClass([
+  (0, import_typeorm28.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], OrderItem.prototype, "createdAt", 2);
+__decorateClass([
+  (0, import_typeorm28.Column)({ type: "timestamp", default: () => "CURRENT_TIMESTAMP" })
+], OrderItem.prototype, "updatedAt", 2);
+__decorateClass([
+  (0, import_typeorm28.ManyToOne)(() => Order, (o) => o.items, { onDelete: "CASCADE" }),
+  (0, import_typeorm28.JoinColumn)({ name: "orderId" })
+], OrderItem.prototype, "order", 2);
+__decorateClass([
+  (0, import_typeorm28.ManyToOne)(() => Product, { onDelete: "CASCADE" }),
+  (0, import_typeorm28.JoinColumn)({ name: "productId" })
+], OrderItem.prototype, "product", 2);
+OrderItem = __decorateClass([
+  (0, import_typeorm28.Entity)("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 = {};
@@ -1959,7 +3072,7 @@ function getNextAuthOptions(config) {
 }
 
 // src/api/crud.ts
-var import_typeorm17 = require("typeorm");
+var import_typeorm29 = require("typeorm");
 var DATE_COLUMN_TYPES = /* @__PURE__ */ new Set([
   "date",
   "datetime",
@@ -2004,28 +3117,170 @@ 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 = (0, import_typeorm29.MoreThan)(0);
+        if (inventory === "out_of_stock") productWhere.quantity = 0;
+        if (search && typeof search === "string" && search.trim()) {
+          productWhere.name = (0, import_typeorm29.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") {
         const mediaWhere = {};
-        if (search) mediaWhere.filename = (0, import_typeorm17.ILike)(`%${search}%`);
-        if (typeFilter) mediaWhere.mimeType = (0, import_typeorm17.Like)(`${typeFilter}/%`);
+        if (search) mediaWhere.filename = (0, import_typeorm29.ILike)(`%${search}%`);
+        if (typeFilter) mediaWhere.mimeType = (0, import_typeorm29.Like)(`${typeFilter}/%`);
         where = Object.keys(mediaWhere).length > 0 ? mediaWhere : {};
       } else if (search) {
-        where = [{ name: (0, import_typeorm17.ILike)(`%${search}%`) }, { title: (0, import_typeorm17.ILike)(`%${search}%`) }];
+        where = [{ name: (0, import_typeorm29.ILike)(`%${search}%`) }, { title: (0, import_typeorm29.ILike)(`%${search}%`) }];
       }
       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 });
@@ -2045,6 +3300,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"`
+        }
+      });
     }
   };
 }
@@ -2057,6 +3413,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 });
     },
@@ -2097,8 +3491,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 }));
@@ -2212,7 +3606,7 @@ function createUserAuthApiRouter(config) {
 }
 
 // src/api/cms-handlers.ts
-var import_typeorm18 = require("typeorm");
+var import_typeorm30 = require("typeorm");
 function createDashboardStatsHandler(config) {
   const { dataSource, entityMap, json, requireAuth, requirePermission } = config;
   return async function GET(req) {
@@ -2231,8 +3625,8 @@ function createDashboardStatsHandler(config) {
         repo("form_submissions")?.count() ?? 0,
         repo("users")?.count({ where: { deleted: false } }) ?? 0,
         repo("blogs")?.count({ where: { deleted: false } }) ?? 0,
-        repo("contacts")?.count({ where: { createdAt: (0, import_typeorm18.MoreThanOrEqual)(sevenDaysAgo) } }) ?? 0,
-        repo("form_submissions")?.count({ where: { createdAt: (0, import_typeorm18.MoreThanOrEqual)(sevenDaysAgo) } }) ?? 0
+        repo("contacts")?.count({ where: { createdAt: (0, import_typeorm30.MoreThanOrEqual)(sevenDaysAgo) } }) ?? 0,
+        repo("form_submissions")?.count({ where: { createdAt: (0, import_typeorm30.MoreThanOrEqual)(sevenDaysAgo) } }) ?? 0
       ]);
       return json({
         contacts: { total: contactsCount, recent: recentContacts },
@@ -2585,7 +3979,7 @@ function createUsersApiHandlers(config) {
         const sortField = url.searchParams.get("sortField") || "createdAt";
         const sortOrder = url.searchParams.get("sortOrder") === "desc" ? "DESC" : "ASC";
         const search = url.searchParams.get("search");
-        const where = search ? [{ name: (0, import_typeorm18.ILike)(`%${search}%`) }, { email: (0, import_typeorm18.ILike)(`%${search}%`) }] : {};
+        const where = search ? [{ name: (0, import_typeorm30.ILike)(`%${search}%`) }, { email: (0, import_typeorm30.ILike)(`%${search}%`) }] : {};
         const [data, total] = await userRepo().findAndCount({
           skip,
           take: limit,
@@ -2922,6 +4316,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);
@@ -2951,9 +4356,12 @@ var DEFAULT_ADMIN_NAV = [
 ];
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  Attribute,
   Blog,
+  Brand,
   CMS_ENTITY_MAP,
   Category,
+  Collection,
   Comment,
   Config,
   Contact,
@@ -2964,12 +4372,20 @@ var DEFAULT_ADMIN_NAV = [
   FormSubmission,
   Media,
   OPEN_ENDPOINTS,
+  Order,
+  OrderItem,
   PERMISSION_REQUIRED_ENDPOINTS,
   Page,
   PasswordResetToken,
+  Payment,
   Permission,
+  Product,
+  ProductAttribute,
+  ProductCategory,
+  ProductTax,
   Seo,
   Tag,
+  Tax,
   User,
   UserGroup,
   analyticsPlugin,