@contractspec/example.marketplace 3.7.6 → 3.8.2

package/dist/entities/index.js

@@ -1,250 +1,12 @@
 // @bun
-// src/entities/store.ts
+// src/entities/order.ts
 import {
   defineEntity,
   defineEntityEnum,
   field,
   index
 } from "@contractspec/lib.schema";
-var StoreStatusEnum = defineEntityEnum({
-  name: "StoreStatus",
-  values: ["PENDING", "ACTIVE", "SUSPENDED", "CLOSED"],
-  schema: "marketplace",
-  description: "Status of a store."
-});
-var StoreTypeEnum = defineEntityEnum({
-  name: "StoreType",
-  values: ["INDIVIDUAL", "BUSINESS", "ENTERPRISE"],
-  schema: "marketplace",
-  description: "Type of store account."
-});
-var StoreEntity = defineEntity({
-  name: "Store",
-  description: "A seller storefront on the marketplace.",
-  schema: "marketplace",
-  map: "store",
-  fields: {
-    id: field.id({ description: "Unique store ID" }),
-    name: field.string({ description: "Store display name" }),
-    slug: field.string({ description: "URL-friendly identifier" }),
-    description: field.string({ isOptional: true }),
-    status: field.enum("StoreStatus", { default: "PENDING" }),
-    type: field.enum("StoreType", { default: "INDIVIDUAL" }),
-    ownerId: field.foreignKey({ description: "Store owner user ID" }),
-    organizationId: field.foreignKey({ isOptional: true }),
-    logoFileId: field.string({
-      isOptional: true,
-      description: "Logo file reference"
-    }),
-    bannerFileId: field.string({
-      isOptional: true,
-      description: "Banner file reference"
-    }),
-    email: field.string({ isOptional: true }),
-    phone: field.string({ isOptional: true }),
-    website: field.string({ isOptional: true }),
-    country: field.string({ isOptional: true }),
-    currency: field.string({ default: '"USD"' }),
-    timezone: field.string({ isOptional: true }),
-    commissionRate: field.decimal({
-      default: 0.1,
-      description: "Platform commission rate (e.g., 0.1 = 10%)"
-    }),
-    isVerified: field.boolean({ default: false }),
-    verifiedAt: field.dateTime({ isOptional: true }),
-    settings: field.json({ isOptional: true }),
-    metadata: field.json({ isOptional: true }),
-    totalProducts: field.int({ default: 0 }),
-    totalOrders: field.int({ default: 0 }),
-    totalRevenue: field.decimal({ default: 0 }),
-    averageRating: field.decimal({ default: 0 }),
-    createdAt: field.createdAt(),
-    updatedAt: field.updatedAt(),
-    products: field.hasMany("Product"),
-    orders: field.hasMany("Order"),
-    payouts: field.hasMany("Payout")
-  },
-  indexes: [
-    index.unique(["slug"]),
-    index.on(["ownerId"]),
-    index.on(["status"]),
-    index.on(["country", "status"]),
-    index.on(["averageRating"])
-  ],
-  enums: [StoreStatusEnum, StoreTypeEnum]
-});
-var StoreCategoryEntity = defineEntity({
-  name: "StoreCategory",
-  description: "Category assignment for stores.",
-  schema: "marketplace",
-  map: "store_category",
-  fields: {
-    id: field.id(),
-    storeId: field.foreignKey(),
-    categoryId: field.foreignKey(),
-    isPrimary: field.boolean({ default: false }),
-    createdAt: field.createdAt(),
-    store: field.belongsTo("Store", ["storeId"], ["id"], {
-      onDelete: "Cascade"
-    })
-  },
-  indexes: [index.unique(["storeId", "categoryId"]), index.on(["categoryId"])]
-});
-
-// src/entities/product.ts
-import {
-  defineEntity as defineEntity2,
-  defineEntityEnum as defineEntityEnum2,
-  field as field2,
-  index as index2
-} from "@contractspec/lib.schema";
-var ProductStatusEnum = defineEntityEnum2({
-  name: "ProductStatus",
-  values: [
-    "DRAFT",
-    "PENDING_REVIEW",
-    "ACTIVE",
-    "OUT_OF_STOCK",
-    "DISCONTINUED",
-    "REJECTED"
-  ],
-  schema: "marketplace",
-  description: "Status of a product listing."
-});
-var ProductTypeEnum = defineEntityEnum2({
-  name: "ProductType",
-  values: ["PHYSICAL", "DIGITAL", "SERVICE", "SUBSCRIPTION"],
-  schema: "marketplace",
-  description: "Type of product."
-});
-var ProductEntity = defineEntity2({
-  name: "Product",
-  description: "A product listing on the marketplace.",
-  schema: "marketplace",
-  map: "product",
-  fields: {
-    id: field2.id({ description: "Unique product ID" }),
-    storeId: field2.foreignKey(),
-    name: field2.string({ description: "Product name" }),
-    slug: field2.string({ description: "URL-friendly identifier" }),
-    description: field2.string({ isOptional: true }),
-    shortDescription: field2.string({ isOptional: true }),
-    status: field2.enum("ProductStatus", { default: "DRAFT" }),
-    type: field2.enum("ProductType", { default: "PHYSICAL" }),
-    price: field2.decimal({ description: "Base price" }),
-    compareAtPrice: field2.decimal({
-      isOptional: true,
-      description: "Original price for showing discounts"
-    }),
-    currency: field2.string({ default: '"USD"' }),
-    sku: field2.string({ isOptional: true }),
-    barcode: field2.string({ isOptional: true }),
-    quantity: field2.int({ default: 0 }),
-    trackInventory: field2.boolean({ default: true }),
-    allowBackorder: field2.boolean({ default: false }),
-    lowStockThreshold: field2.int({ default: 5 }),
-    weight: field2.decimal({ isOptional: true }),
-    weightUnit: field2.string({ default: '"kg"' }),
-    categoryId: field2.string({ isOptional: true }),
-    tags: field2.string({ isArray: true }),
-    primaryImageId: field2.string({ isOptional: true }),
-    seoTitle: field2.string({ isOptional: true }),
-    seoDescription: field2.string({ isOptional: true }),
-    attributes: field2.json({
-      isOptional: true,
-      description: "Custom product attributes"
-    }),
-    reviewCount: field2.int({ default: 0 }),
-    averageRating: field2.decimal({ default: 0 }),
-    totalSold: field2.int({ default: 0 }),
-    createdAt: field2.createdAt(),
-    updatedAt: field2.updatedAt(),
-    publishedAt: field2.dateTime({ isOptional: true }),
-    store: field2.belongsTo("Store", ["storeId"], ["id"]),
-    variants: field2.hasMany("ProductVariant"),
-    orderItems: field2.hasMany("OrderItem"),
-    reviews: field2.hasMany("Review")
-  },
-  indexes: [
-    index2.unique(["storeId", "slug"]),
-    index2.on(["storeId", "status"]),
-    index2.on(["status", "publishedAt"]),
-    index2.on(["categoryId", "status"]),
-    index2.on(["averageRating"]),
-    index2.on(["totalSold"]),
-    index2.on(["price"])
-  ],
-  enums: [ProductStatusEnum, ProductTypeEnum]
-});
-var ProductVariantEntity = defineEntity2({
-  name: "ProductVariant",
-  description: "A variant of a product with specific options.",
-  schema: "marketplace",
-  map: "product_variant",
-  fields: {
-    id: field2.id(),
-    productId: field2.foreignKey(),
-    name: field2.string({ description: 'Variant name (e.g., "Large / Blue")' }),
-    options: field2.json({
-      description: 'Variant options (e.g., {size: "L", color: "Blue"})'
-    }),
-    price: field2.decimal({ description: "Variant-specific price" }),
-    compareAtPrice: field2.decimal({ isOptional: true }),
-    sku: field2.string({ isOptional: true }),
-    barcode: field2.string({ isOptional: true }),
-    quantity: field2.int({ default: 0 }),
-    imageId: field2.string({ isOptional: true }),
-    isActive: field2.boolean({ default: true }),
-    position: field2.int({ default: 0 }),
-    createdAt: field2.createdAt(),
-    updatedAt: field2.updatedAt(),
-    product: field2.belongsTo("Product", ["productId"], ["id"], {
-      onDelete: "Cascade"
-    })
-  },
-  indexes: [
-    index2.on(["productId", "sku"]),
-    index2.on(["productId", "position"]),
-    index2.on(["barcode"])
-  ]
-});
-var CategoryEntity = defineEntity2({
-  name: "Category",
-  description: "Product category for organization.",
-  schema: "marketplace",
-  map: "category",
-  fields: {
-    id: field2.id(),
-    name: field2.string(),
-    slug: field2.string(),
-    description: field2.string({ isOptional: true }),
-    parentId: field2.string({ isOptional: true }),
-    path: field2.string({ description: "Full path for hierarchical queries" }),
-    level: field2.int({ default: 0 }),
-    position: field2.int({ default: 0 }),
-    imageId: field2.string({ isOptional: true }),
-    isActive: field2.boolean({ default: true }),
-    createdAt: field2.createdAt(),
-    updatedAt: field2.updatedAt(),
-    parent: field2.belongsTo("Category", ["parentId"], ["id"]),
-    children: field2.hasMany("Category")
-  },
-  indexes: [
-    index2.unique(["slug"]),
-    index2.on(["parentId", "position"]),
-    index2.on(["path"]),
-    index2.on(["isActive"])
-  ]
-});
-
-// src/entities/order.ts
-import {
-  defineEntity as defineEntity3,
-  defineEntityEnum as defineEntityEnum3,
-  field as field3,
-  index as index3
-} from "@contractspec/lib.schema";
-var OrderStatusEnum = defineEntityEnum3({
+var OrderStatusEnum = defineEntityEnum({
   name: "OrderStatus",
   values: [
     "PENDING",
@@ -261,7 +23,7 @@ var OrderStatusEnum = defineEntityEnum3({
   schema: "marketplace",
   description: "Status of an order."
 });
-var PaymentStatusEnum = defineEntityEnum3({
+var PaymentStatusEnum = defineEntityEnum({
   name: "PaymentStatus",
   values: [
     "PENDING",
@@ -274,384 +36,622 @@ var PaymentStatusEnum = defineEntityEnum3({
   schema: "marketplace",
   description: "Status of payment."
 });
-var OrderEntity = defineEntity3({
+var OrderEntity = defineEntity({
   name: "Order",
   description: "A purchase order on the marketplace.",
   schema: "marketplace",
   map: "order",
   fields: {
-    id: field3.id({ description: "Unique order ID" }),
-    orderNumber: field3.string({ description: "Human-readable order number" }),
-    buyerId: field3.foreignKey({ description: "Buyer user ID" }),
-    storeId: field3.foreignKey({ description: "Seller store ID" }),
-    status: field3.enum("OrderStatus", { default: "PENDING" }),
-    paymentStatus: field3.enum("PaymentStatus", { default: "PENDING" }),
-    subtotal: field3.decimal({ description: "Sum of item prices" }),
-    shippingTotal: field3.decimal({ default: 0 }),
-    taxTotal: field3.decimal({ default: 0 }),
-    discountTotal: field3.decimal({ default: 0 }),
-    total: field3.decimal({ description: "Final total" }),
-    currency: field3.string({ default: '"USD"' }),
-    platformFee: field3.decimal({ description: "Platform commission amount" }),
-    sellerPayout: field3.decimal({ description: "Amount due to seller" }),
-    shippingAddress: field3.json({ isOptional: true }),
-    billingAddress: field3.json({ isOptional: true }),
-    shippingMethod: field3.string({ isOptional: true }),
-    trackingNumber: field3.string({ isOptional: true }),
-    trackingUrl: field3.string({ isOptional: true }),
-    paymentMethod: field3.string({ isOptional: true }),
-    paymentIntentId: field3.string({ isOptional: true }),
-    buyerNote: field3.string({ isOptional: true }),
-    sellerNote: field3.string({ isOptional: true }),
-    internalNote: field3.string({ isOptional: true }),
-    createdAt: field3.createdAt(),
-    updatedAt: field3.updatedAt(),
-    paidAt: field3.dateTime({ isOptional: true }),
-    shippedAt: field3.dateTime({ isOptional: true }),
-    deliveredAt: field3.dateTime({ isOptional: true }),
-    completedAt: field3.dateTime({ isOptional: true }),
-    cancelledAt: field3.dateTime({ isOptional: true }),
-    store: field3.belongsTo("Store", ["storeId"], ["id"]),
-    items: field3.hasMany("OrderItem"),
-    refunds: field3.hasMany("Refund")
+    id: field.id({ description: "Unique order ID" }),
+    orderNumber: field.string({ description: "Human-readable order number" }),
+    buyerId: field.foreignKey({ description: "Buyer user ID" }),
+    storeId: field.foreignKey({ description: "Seller store ID" }),
+    status: field.enum("OrderStatus", { default: "PENDING" }),
+    paymentStatus: field.enum("PaymentStatus", { default: "PENDING" }),
+    subtotal: field.decimal({ description: "Sum of item prices" }),
+    shippingTotal: field.decimal({ default: 0 }),
+    taxTotal: field.decimal({ default: 0 }),
+    discountTotal: field.decimal({ default: 0 }),
+    total: field.decimal({ description: "Final total" }),
+    currency: field.string({ default: '"USD"' }),
+    platformFee: field.decimal({ description: "Platform commission amount" }),
+    sellerPayout: field.decimal({ description: "Amount due to seller" }),
+    shippingAddress: field.json({ isOptional: true }),
+    billingAddress: field.json({ isOptional: true }),
+    shippingMethod: field.string({ isOptional: true }),
+    trackingNumber: field.string({ isOptional: true }),
+    trackingUrl: field.string({ isOptional: true }),
+    paymentMethod: field.string({ isOptional: true }),
+    paymentIntentId: field.string({ isOptional: true }),
+    buyerNote: field.string({ isOptional: true }),
+    sellerNote: field.string({ isOptional: true }),
+    internalNote: field.string({ isOptional: true }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    paidAt: field.dateTime({ isOptional: true }),
+    shippedAt: field.dateTime({ isOptional: true }),
+    deliveredAt: field.dateTime({ isOptional: true }),
+    completedAt: field.dateTime({ isOptional: true }),
+    cancelledAt: field.dateTime({ isOptional: true }),
+    store: field.belongsTo("Store", ["storeId"], ["id"]),
+    items: field.hasMany("OrderItem"),
+    refunds: field.hasMany("Refund")
   },
   indexes: [
-    index3.unique(["orderNumber"]),
-    index3.on(["buyerId", "status"]),
-    index3.on(["storeId", "status"]),
-    index3.on(["status", "createdAt"]),
-    index3.on(["paymentStatus"]),
-    index3.on(["createdAt"])
+    index.unique(["orderNumber"]),
+    index.on(["buyerId", "status"]),
+    index.on(["storeId", "status"]),
+    index.on(["status", "createdAt"]),
+    index.on(["paymentStatus"]),
+    index.on(["createdAt"])
   ],
   enums: [OrderStatusEnum, PaymentStatusEnum]
 });
-var OrderItemEntity = defineEntity3({
+var OrderItemEntity = defineEntity({
   name: "OrderItem",
   description: "An item within an order.",
   schema: "marketplace",
   map: "order_item",
   fields: {
-    id: field3.id(),
-    orderId: field3.foreignKey(),
-    productId: field3.foreignKey(),
-    variantId: field3.string({ isOptional: true }),
-    productName: field3.string(),
-    variantName: field3.string({ isOptional: true }),
-    sku: field3.string({ isOptional: true }),
-    unitPrice: field3.decimal(),
-    quantity: field3.int(),
-    subtotal: field3.decimal(),
-    quantityFulfilled: field3.int({ default: 0 }),
-    quantityRefunded: field3.int({ default: 0 }),
-    createdAt: field3.createdAt(),
-    updatedAt: field3.updatedAt(),
-    order: field3.belongsTo("Order", ["orderId"], ["id"], {
+    id: field.id(),
+    orderId: field.foreignKey(),
+    productId: field.foreignKey(),
+    variantId: field.string({ isOptional: true }),
+    productName: field.string(),
+    variantName: field.string({ isOptional: true }),
+    sku: field.string({ isOptional: true }),
+    unitPrice: field.decimal(),
+    quantity: field.int(),
+    subtotal: field.decimal(),
+    quantityFulfilled: field.int({ default: 0 }),
+    quantityRefunded: field.int({ default: 0 }),
+    createdAt: field.createdAt(),
+    updatedAt: field.updatedAt(),
+    order: field.belongsTo("Order", ["orderId"], ["id"], {
       onDelete: "Cascade"
     }),
-    product: field3.belongsTo("Product", ["productId"], ["id"])
+    product: field.belongsTo("Product", ["productId"], ["id"])
   },
-  indexes: [index3.on(["orderId"]), index3.on(["productId"])]
+  indexes: [index.on(["orderId"]), index.on(["productId"])]
 });
-var RefundEntity = defineEntity3({
+var RefundEntity = defineEntity({
   name: "Refund",
   description: "A refund for an order.",
   schema: "marketplace",
   map: "refund",
   fields: {
-    id: field3.id(),
-    orderId: field3.foreignKey(),
-    amount: field3.decimal(),
-    currency: field3.string(),
-    reason: field3.string(),
-    notes: field3.string({ isOptional: true }),
-    status: field3.string({ default: '"PENDING"' }),
-    refundId: field3.string({
+    id: field.id(),
+    orderId: field.foreignKey(),
+    amount: field.decimal(),
+    currency: field.string(),
+    reason: field.string(),
+    notes: field.string({ isOptional: true }),
+    status: field.string({ default: '"PENDING"' }),
+    refundId: field.string({
       isOptional: true,
       description: "Payment provider refund ID"
     }),
-    issuedBy: field3.foreignKey({ description: "User who issued the refund" }),
-    createdAt: field3.createdAt(),
-    processedAt: field3.dateTime({ isOptional: true }),
-    order: field3.belongsTo("Order", ["orderId"], ["id"]),
-    items: field3.hasMany("RefundItem")
+    issuedBy: field.foreignKey({ description: "User who issued the refund" }),
+    createdAt: field.createdAt(),
+    processedAt: field.dateTime({ isOptional: true }),
+    order: field.belongsTo("Order", ["orderId"], ["id"]),
+    items: field.hasMany("RefundItem")
   },
-  indexes: [index3.on(["orderId"]), index3.on(["status"])]
+  indexes: [index.on(["orderId"]), index.on(["status"])]
 });
-var RefundItemEntity = defineEntity3({
+var RefundItemEntity = defineEntity({
   name: "RefundItem",
   description: "An item within a refund.",
   schema: "marketplace",
   map: "refund_item",
   fields: {
-    id: field3.id(),
-    refundId: field3.foreignKey(),
-    orderItemId: field3.foreignKey(),
-    quantity: field3.int(),
-    amount: field3.decimal(),
-    createdAt: field3.createdAt(),
-    refund: field3.belongsTo("Refund", ["refundId"], ["id"], {
+    id: field.id(),
+    refundId: field.foreignKey(),
+    orderItemId: field.foreignKey(),
+    quantity: field.int(),
+    amount: field.decimal(),
+    createdAt: field.createdAt(),
+    refund: field.belongsTo("Refund", ["refundId"], ["id"], {
       onDelete: "Cascade"
     }),
-    orderItem: field3.belongsTo("OrderItem", ["orderItemId"], ["id"])
+    orderItem: field.belongsTo("OrderItem", ["orderItemId"], ["id"])
   },
-  indexes: [index3.on(["refundId"]), index3.on(["orderItemId"])]
+  indexes: [index.on(["refundId"]), index.on(["orderItemId"])]
 });
 
 // src/entities/payout.ts
 import {
-  defineEntity as defineEntity4,
-  defineEntityEnum as defineEntityEnum4,
-  field as field4,
-  index as index4
+  defineEntity as defineEntity2,
+  defineEntityEnum as defineEntityEnum2,
+  field as field2,
+  index as index2
 } from "@contractspec/lib.schema";
-var PayoutStatusEnum = defineEntityEnum4({
+var PayoutStatusEnum = defineEntityEnum2({
   name: "PayoutStatus",
   values: ["PENDING", "PROCESSING", "PAID", "FAILED", "CANCELLED"],
   schema: "marketplace",
   description: "Status of a payout."
 });
-var PayoutScheduleEnum = defineEntityEnum4({
+var PayoutScheduleEnum = defineEntityEnum2({
   name: "PayoutSchedule",
   values: ["DAILY", "WEEKLY", "BIWEEKLY", "MONTHLY", "MANUAL"],
   schema: "marketplace",
   description: "Payout schedule frequency."
 });
-var PayoutEntity = defineEntity4({
+var PayoutEntity = defineEntity2({
   name: "Payout",
   description: "A payout to a seller.",
   schema: "marketplace",
   map: "payout",
   fields: {
-    id: field4.id({ description: "Unique payout ID" }),
-    storeId: field4.foreignKey(),
-    payoutNumber: field4.string({ description: "Human-readable payout number" }),
-    status: field4.enum("PayoutStatus", { default: "PENDING" }),
-    grossAmount: field4.decimal({ description: "Total before fees" }),
-    platformFees: field4.decimal({ description: "Platform fees deducted" }),
-    otherDeductions: field4.decimal({ default: 0 }),
-    netAmount: field4.decimal({ description: "Final payout amount" }),
-    currency: field4.string({ default: '"USD"' }),
-    periodStart: field4.dateTime({ description: "Start of payout period" }),
-    periodEnd: field4.dateTime({ description: "End of payout period" }),
-    paymentMethod: field4.string({ isOptional: true }),
-    paymentReference: field4.string({ isOptional: true }),
-    bankAccountId: field4.string({ isOptional: true }),
-    bankAccountLast4: field4.string({ isOptional: true }),
-    notes: field4.string({ isOptional: true }),
-    failureReason: field4.string({ isOptional: true }),
-    orderCount: field4.int({ default: 0 }),
-    createdAt: field4.createdAt(),
-    updatedAt: field4.updatedAt(),
-    scheduledAt: field4.dateTime({ isOptional: true }),
-    processedAt: field4.dateTime({ isOptional: true }),
-    paidAt: field4.dateTime({ isOptional: true }),
-    store: field4.belongsTo("Store", ["storeId"], ["id"]),
-    items: field4.hasMany("PayoutItem")
+    id: field2.id({ description: "Unique payout ID" }),
+    storeId: field2.foreignKey(),
+    payoutNumber: field2.string({ description: "Human-readable payout number" }),
+    status: field2.enum("PayoutStatus", { default: "PENDING" }),
+    grossAmount: field2.decimal({ description: "Total before fees" }),
+    platformFees: field2.decimal({ description: "Platform fees deducted" }),
+    otherDeductions: field2.decimal({ default: 0 }),
+    netAmount: field2.decimal({ description: "Final payout amount" }),
+    currency: field2.string({ default: '"USD"' }),
+    periodStart: field2.dateTime({ description: "Start of payout period" }),
+    periodEnd: field2.dateTime({ description: "End of payout period" }),
+    paymentMethod: field2.string({ isOptional: true }),
+    paymentReference: field2.string({ isOptional: true }),
+    bankAccountId: field2.string({ isOptional: true }),
+    bankAccountLast4: field2.string({ isOptional: true }),
+    notes: field2.string({ isOptional: true }),
+    failureReason: field2.string({ isOptional: true }),
+    orderCount: field2.int({ default: 0 }),
+    createdAt: field2.createdAt(),
+    updatedAt: field2.updatedAt(),
+    scheduledAt: field2.dateTime({ isOptional: true }),
+    processedAt: field2.dateTime({ isOptional: true }),
+    paidAt: field2.dateTime({ isOptional: true }),
+    store: field2.belongsTo("Store", ["storeId"], ["id"]),
+    items: field2.hasMany("PayoutItem")
   },
   indexes: [
-    index4.unique(["payoutNumber"]),
-    index4.on(["storeId", "status"]),
-    index4.on(["status", "scheduledAt"]),
-    index4.on(["periodStart", "periodEnd"])
+    index2.unique(["payoutNumber"]),
+    index2.on(["storeId", "status"]),
+    index2.on(["status", "scheduledAt"]),
+    index2.on(["periodStart", "periodEnd"])
   ],
   enums: [PayoutStatusEnum]
 });
-var PayoutItemEntity = defineEntity4({
+var PayoutItemEntity = defineEntity2({
   name: "PayoutItem",
   description: "An order included in a payout.",
   schema: "marketplace",
   map: "payout_item",
   fields: {
-    id: field4.id(),
-    payoutId: field4.foreignKey(),
-    orderId: field4.foreignKey(),
-    orderTotal: field4.decimal(),
-    platformFee: field4.decimal(),
-    netAmount: field4.decimal(),
-    createdAt: field4.createdAt(),
-    payout: field4.belongsTo("Payout", ["payoutId"], ["id"], {
+    id: field2.id(),
+    payoutId: field2.foreignKey(),
+    orderId: field2.foreignKey(),
+    orderTotal: field2.decimal(),
+    platformFee: field2.decimal(),
+    netAmount: field2.decimal(),
+    createdAt: field2.createdAt(),
+    payout: field2.belongsTo("Payout", ["payoutId"], ["id"], {
       onDelete: "Cascade"
     }),
-    order: field4.belongsTo("Order", ["orderId"], ["id"])
+    order: field2.belongsTo("Order", ["orderId"], ["id"])
   },
-  indexes: [index4.on(["payoutId"]), index4.on(["orderId"])]
+  indexes: [index2.on(["payoutId"]), index2.on(["orderId"])]
 });
-var BankAccountEntity = defineEntity4({
+var BankAccountEntity = defineEntity2({
   name: "BankAccount",
   description: "A bank account for receiving payouts.",
   schema: "marketplace",
   map: "bank_account",
   fields: {
-    id: field4.id(),
-    storeId: field4.foreignKey(),
-    accountHolderName: field4.string(),
-    accountType: field4.string({ default: '"CHECKING"' }),
-    bankName: field4.string({ isOptional: true }),
-    last4: field4.string({ description: "Last 4 digits of account" }),
-    routingLast4: field4.string({ isOptional: true }),
-    externalId: field4.string({
+    id: field2.id(),
+    storeId: field2.foreignKey(),
+    accountHolderName: field2.string(),
+    accountType: field2.string({ default: '"CHECKING"' }),
+    bankName: field2.string({ isOptional: true }),
+    last4: field2.string({ description: "Last 4 digits of account" }),
+    routingLast4: field2.string({ isOptional: true }),
+    externalId: field2.string({
       isOptional: true,
       description: "External provider account ID"
     }),
-    isDefault: field4.boolean({ default: false }),
-    isVerified: field4.boolean({ default: false }),
-    createdAt: field4.createdAt(),
-    updatedAt: field4.updatedAt(),
-    verifiedAt: field4.dateTime({ isOptional: true }),
-    store: field4.belongsTo("Store", ["storeId"], ["id"])
+    isDefault: field2.boolean({ default: false }),
+    isVerified: field2.boolean({ default: false }),
+    createdAt: field2.createdAt(),
+    updatedAt: field2.updatedAt(),
+    verifiedAt: field2.dateTime({ isOptional: true }),
+    store: field2.belongsTo("Store", ["storeId"], ["id"])
   },
-  indexes: [index4.on(["storeId", "isDefault"]), index4.on(["externalId"])]
+  indexes: [index2.on(["storeId", "isDefault"]), index2.on(["externalId"])]
 });
-var PayoutSettingsEntity = defineEntity4({
+var PayoutSettingsEntity = defineEntity2({
   name: "PayoutSettings",
   description: "Payout configuration for a store.",
   schema: "marketplace",
   map: "payout_settings",
   fields: {
-    id: field4.id(),
-    storeId: field4.foreignKey(),
-    schedule: field4.enum("PayoutSchedule", { default: "WEEKLY" }),
-    dayOfWeek: field4.int({
+    id: field2.id(),
+    storeId: field2.foreignKey(),
+    schedule: field2.enum("PayoutSchedule", { default: "WEEKLY" }),
+    dayOfWeek: field2.int({
       isOptional: true,
       description: "Day for weekly/biweekly (0=Sunday)"
     }),
-    dayOfMonth: field4.int({
+    dayOfMonth: field2.int({
       isOptional: true,
       description: "Day for monthly (1-28)"
     }),
-    minimumPayout: field4.decimal({
+    minimumPayout: field2.decimal({
       default: 50,
       description: "Minimum amount for payout"
     }),
-    defaultBankAccountId: field4.string({ isOptional: true }),
-    createdAt: field4.createdAt(),
-    updatedAt: field4.updatedAt(),
-    store: field4.belongsTo("Store", ["storeId"], ["id"])
+    defaultBankAccountId: field2.string({ isOptional: true }),
+    createdAt: field2.createdAt(),
+    updatedAt: field2.updatedAt(),
+    store: field2.belongsTo("Store", ["storeId"], ["id"])
   },
-  indexes: [index4.unique(["storeId"])],
+  indexes: [index2.unique(["storeId"])],
   enums: [PayoutScheduleEnum]
 });
 
+// src/entities/product.ts
+import {
+  defineEntity as defineEntity3,
+  defineEntityEnum as defineEntityEnum3,
+  field as field3,
+  index as index3
+} from "@contractspec/lib.schema";
+var ProductStatusEnum = defineEntityEnum3({
+  name: "ProductStatus",
+  values: [
+    "DRAFT",
+    "PENDING_REVIEW",
+    "ACTIVE",
+    "OUT_OF_STOCK",
+    "DISCONTINUED",
+    "REJECTED"
+  ],
+  schema: "marketplace",
+  description: "Status of a product listing."
+});
+var ProductTypeEnum = defineEntityEnum3({
+  name: "ProductType",
+  values: ["PHYSICAL", "DIGITAL", "SERVICE", "SUBSCRIPTION"],
+  schema: "marketplace",
+  description: "Type of product."
+});
+var ProductEntity = defineEntity3({
+  name: "Product",
+  description: "A product listing on the marketplace.",
+  schema: "marketplace",
+  map: "product",
+  fields: {
+    id: field3.id({ description: "Unique product ID" }),
+    storeId: field3.foreignKey(),
+    name: field3.string({ description: "Product name" }),
+    slug: field3.string({ description: "URL-friendly identifier" }),
+    description: field3.string({ isOptional: true }),
+    shortDescription: field3.string({ isOptional: true }),
+    status: field3.enum("ProductStatus", { default: "DRAFT" }),
+    type: field3.enum("ProductType", { default: "PHYSICAL" }),
+    price: field3.decimal({ description: "Base price" }),
+    compareAtPrice: field3.decimal({
+      isOptional: true,
+      description: "Original price for showing discounts"
+    }),
+    currency: field3.string({ default: '"USD"' }),
+    sku: field3.string({ isOptional: true }),
+    barcode: field3.string({ isOptional: true }),
+    quantity: field3.int({ default: 0 }),
+    trackInventory: field3.boolean({ default: true }),
+    allowBackorder: field3.boolean({ default: false }),
+    lowStockThreshold: field3.int({ default: 5 }),
+    weight: field3.decimal({ isOptional: true }),
+    weightUnit: field3.string({ default: '"kg"' }),
+    categoryId: field3.string({ isOptional: true }),
+    tags: field3.string({ isArray: true }),
+    primaryImageId: field3.string({ isOptional: true }),
+    seoTitle: field3.string({ isOptional: true }),
+    seoDescription: field3.string({ isOptional: true }),
+    attributes: field3.json({
+      isOptional: true,
+      description: "Custom product attributes"
+    }),
+    reviewCount: field3.int({ default: 0 }),
+    averageRating: field3.decimal({ default: 0 }),
+    totalSold: field3.int({ default: 0 }),
+    createdAt: field3.createdAt(),
+    updatedAt: field3.updatedAt(),
+    publishedAt: field3.dateTime({ isOptional: true }),
+    store: field3.belongsTo("Store", ["storeId"], ["id"]),
+    variants: field3.hasMany("ProductVariant"),
+    orderItems: field3.hasMany("OrderItem"),
+    reviews: field3.hasMany("Review")
+  },
+  indexes: [
+    index3.unique(["storeId", "slug"]),
+    index3.on(["storeId", "status"]),
+    index3.on(["status", "publishedAt"]),
+    index3.on(["categoryId", "status"]),
+    index3.on(["averageRating"]),
+    index3.on(["totalSold"]),
+    index3.on(["price"])
+  ],
+  enums: [ProductStatusEnum, ProductTypeEnum]
+});
+var ProductVariantEntity = defineEntity3({
+  name: "ProductVariant",
+  description: "A variant of a product with specific options.",
+  schema: "marketplace",
+  map: "product_variant",
+  fields: {
+    id: field3.id(),
+    productId: field3.foreignKey(),
+    name: field3.string({ description: 'Variant name (e.g., "Large / Blue")' }),
+    options: field3.json({
+      description: 'Variant options (e.g., {size: "L", color: "Blue"})'
+    }),
+    price: field3.decimal({ description: "Variant-specific price" }),
+    compareAtPrice: field3.decimal({ isOptional: true }),
+    sku: field3.string({ isOptional: true }),
+    barcode: field3.string({ isOptional: true }),
+    quantity: field3.int({ default: 0 }),
+    imageId: field3.string({ isOptional: true }),
+    isActive: field3.boolean({ default: true }),
+    position: field3.int({ default: 0 }),
+    createdAt: field3.createdAt(),
+    updatedAt: field3.updatedAt(),
+    product: field3.belongsTo("Product", ["productId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [
+    index3.on(["productId", "sku"]),
+    index3.on(["productId", "position"]),
+    index3.on(["barcode"])
+  ]
+});
+var CategoryEntity = defineEntity3({
+  name: "Category",
+  description: "Product category for organization.",
+  schema: "marketplace",
+  map: "category",
+  fields: {
+    id: field3.id(),
+    name: field3.string(),
+    slug: field3.string(),
+    description: field3.string({ isOptional: true }),
+    parentId: field3.string({ isOptional: true }),
+    path: field3.string({ description: "Full path for hierarchical queries" }),
+    level: field3.int({ default: 0 }),
+    position: field3.int({ default: 0 }),
+    imageId: field3.string({ isOptional: true }),
+    isActive: field3.boolean({ default: true }),
+    createdAt: field3.createdAt(),
+    updatedAt: field3.updatedAt(),
+    parent: field3.belongsTo("Category", ["parentId"], ["id"]),
+    children: field3.hasMany("Category")
+  },
+  indexes: [
+    index3.unique(["slug"]),
+    index3.on(["parentId", "position"]),
+    index3.on(["path"]),
+    index3.on(["isActive"])
+  ]
+});
+
 // src/entities/review.ts
 import {
-  defineEntity as defineEntity5,
-  defineEntityEnum as defineEntityEnum5,
-  field as field5,
-  index as index5
+  defineEntity as defineEntity4,
+  defineEntityEnum as defineEntityEnum4,
+  field as field4,
+  index as index4
 } from "@contractspec/lib.schema";
-var ReviewStatusEnum = defineEntityEnum5({
+var ReviewStatusEnum = defineEntityEnum4({
   name: "ReviewStatus",
   values: ["PENDING", "APPROVED", "REJECTED", "FLAGGED"],
   schema: "marketplace",
   description: "Status of a review."
 });
-var ReviewTypeEnum = defineEntityEnum5({
+var ReviewTypeEnum = defineEntityEnum4({
   name: "ReviewType",
   values: ["PRODUCT", "STORE", "ORDER"],
   schema: "marketplace",
   description: "Type of review."
 });
-var ReviewEntity = defineEntity5({
+var ReviewEntity = defineEntity4({
   name: "Review",
   description: "A customer review on the marketplace.",
   schema: "marketplace",
   map: "review",
   fields: {
-    id: field5.id({ description: "Unique review ID" }),
-    type: field5.enum("ReviewType", { default: "PRODUCT" }),
-    productId: field5.string({ isOptional: true }),
-    storeId: field5.string({ isOptional: true }),
-    orderId: field5.string({ isOptional: true }),
-    orderItemId: field5.string({ isOptional: true }),
-    authorId: field5.foreignKey({ description: "Reviewer user ID" }),
-    rating: field5.int({ description: "Rating 1-5" }),
-    title: field5.string({ isOptional: true }),
-    content: field5.string({ isOptional: true }),
-    isVerifiedPurchase: field5.boolean({ default: false }),
-    status: field5.enum("ReviewStatus", { default: "PENDING" }),
-    hasMedia: field5.boolean({ default: false }),
-    helpfulCount: field5.int({ default: 0 }),
-    notHelpfulCount: field5.int({ default: 0 }),
-    moderatedBy: field5.string({ isOptional: true }),
-    moderatedAt: field5.dateTime({ isOptional: true }),
-    moderationNote: field5.string({ isOptional: true }),
-    hasResponse: field5.boolean({ default: false }),
-    createdAt: field5.createdAt(),
-    updatedAt: field5.updatedAt(),
-    product: field5.belongsTo("Product", ["productId"], ["id"]),
-    store: field5.belongsTo("Store", ["storeId"], ["id"]),
-    responses: field5.hasMany("ReviewResponse"),
-    votes: field5.hasMany("ReviewVote")
+    id: field4.id({ description: "Unique review ID" }),
+    type: field4.enum("ReviewType", { default: "PRODUCT" }),
+    productId: field4.string({ isOptional: true }),
+    storeId: field4.string({ isOptional: true }),
+    orderId: field4.string({ isOptional: true }),
+    orderItemId: field4.string({ isOptional: true }),
+    authorId: field4.foreignKey({ description: "Reviewer user ID" }),
+    rating: field4.int({ description: "Rating 1-5" }),
+    title: field4.string({ isOptional: true }),
+    content: field4.string({ isOptional: true }),
+    isVerifiedPurchase: field4.boolean({ default: false }),
+    status: field4.enum("ReviewStatus", { default: "PENDING" }),
+    hasMedia: field4.boolean({ default: false }),
+    helpfulCount: field4.int({ default: 0 }),
+    notHelpfulCount: field4.int({ default: 0 }),
+    moderatedBy: field4.string({ isOptional: true }),
+    moderatedAt: field4.dateTime({ isOptional: true }),
+    moderationNote: field4.string({ isOptional: true }),
+    hasResponse: field4.boolean({ default: false }),
+    createdAt: field4.createdAt(),
+    updatedAt: field4.updatedAt(),
+    product: field4.belongsTo("Product", ["productId"], ["id"]),
+    store: field4.belongsTo("Store", ["storeId"], ["id"]),
+    responses: field4.hasMany("ReviewResponse"),
+    votes: field4.hasMany("ReviewVote")
   },
   indexes: [
-    index5.on(["productId", "status", "createdAt"]),
-    index5.on(["storeId", "status", "createdAt"]),
-    index5.on(["authorId"]),
-    index5.on(["orderId"]),
-    index5.on(["status"]),
-    index5.on(["rating"]),
-    index5.on(["isVerifiedPurchase", "status"])
+    index4.on(["productId", "status", "createdAt"]),
+    index4.on(["storeId", "status", "createdAt"]),
+    index4.on(["authorId"]),
+    index4.on(["orderId"]),
+    index4.on(["status"]),
+    index4.on(["rating"]),
+    index4.on(["isVerifiedPurchase", "status"])
   ],
   enums: [ReviewStatusEnum, ReviewTypeEnum]
 });
-var ReviewResponseEntity = defineEntity5({
+var ReviewResponseEntity = defineEntity4({
   name: "ReviewResponse",
   description: "A seller response to a review.",
   schema: "marketplace",
   map: "review_response",
   fields: {
-    id: field5.id(),
-    reviewId: field5.foreignKey(),
-    authorId: field5.foreignKey(),
-    content: field5.string(),
-    createdAt: field5.createdAt(),
-    updatedAt: field5.updatedAt(),
-    review: field5.belongsTo("Review", ["reviewId"], ["id"], {
+    id: field4.id(),
+    reviewId: field4.foreignKey(),
+    authorId: field4.foreignKey(),
+    content: field4.string(),
+    createdAt: field4.createdAt(),
+    updatedAt: field4.updatedAt(),
+    review: field4.belongsTo("Review", ["reviewId"], ["id"], {
       onDelete: "Cascade"
     })
   },
-  indexes: [index5.on(["reviewId"]), index5.on(["authorId"])]
+  indexes: [index4.on(["reviewId"]), index4.on(["authorId"])]
 });
-var ReviewVoteEntity = defineEntity5({
+var ReviewVoteEntity = defineEntity4({
   name: "ReviewVote",
   description: "A helpfulness vote on a review.",
   schema: "marketplace",
   map: "review_vote",
   fields: {
-    id: field5.id(),
-    reviewId: field5.foreignKey(),
-    userId: field5.foreignKey(),
-    isHelpful: field5.boolean(),
-    createdAt: field5.createdAt(),
-    review: field5.belongsTo("Review", ["reviewId"], ["id"], {
+    id: field4.id(),
+    reviewId: field4.foreignKey(),
+    userId: field4.foreignKey(),
+    isHelpful: field4.boolean(),
+    createdAt: field4.createdAt(),
+    review: field4.belongsTo("Review", ["reviewId"], ["id"], {
       onDelete: "Cascade"
     })
   },
-  indexes: [index5.unique(["reviewId", "userId"]), index5.on(["userId"])]
+  indexes: [index4.unique(["reviewId", "userId"]), index4.on(["userId"])]
 });
-var ReviewReportEntity = defineEntity5({
+var ReviewReportEntity = defineEntity4({
   name: "ReviewReport",
   description: "A report/flag on a review.",
   schema: "marketplace",
   map: "review_report",
   fields: {
-    id: field5.id(),
-    reviewId: field5.foreignKey(),
-    reporterId: field5.foreignKey(),
-    reason: field5.string({ description: "Report reason category" }),
-    details: field5.string({ isOptional: true }),
-    status: field5.string({ default: '"PENDING"' }),
-    resolvedBy: field5.string({ isOptional: true }),
-    resolvedAt: field5.dateTime({ isOptional: true }),
-    resolution: field5.string({ isOptional: true }),
+    id: field4.id(),
+    reviewId: field4.foreignKey(),
+    reporterId: field4.foreignKey(),
+    reason: field4.string({ description: "Report reason category" }),
+    details: field4.string({ isOptional: true }),
+    status: field4.string({ default: '"PENDING"' }),
+    resolvedBy: field4.string({ isOptional: true }),
+    resolvedAt: field4.dateTime({ isOptional: true }),
+    resolution: field4.string({ isOptional: true }),
+    createdAt: field4.createdAt(),
+    review: field4.belongsTo("Review", ["reviewId"], ["id"])
+  },
+  indexes: [
+    index4.on(["reviewId"]),
+    index4.on(["status"]),
+    index4.on(["reporterId"])
+  ]
+});
+
+// src/entities/store.ts
+import {
+  defineEntity as defineEntity5,
+  defineEntityEnum as defineEntityEnum5,
+  field as field5,
+  index as index5
+} from "@contractspec/lib.schema";
+var StoreStatusEnum = defineEntityEnum5({
+  name: "StoreStatus",
+  values: ["PENDING", "ACTIVE", "SUSPENDED", "CLOSED"],
+  schema: "marketplace",
+  description: "Status of a store."
+});
+var StoreTypeEnum = defineEntityEnum5({
+  name: "StoreType",
+  values: ["INDIVIDUAL", "BUSINESS", "ENTERPRISE"],
+  schema: "marketplace",
+  description: "Type of store account."
+});
+var StoreEntity = defineEntity5({
+  name: "Store",
+  description: "A seller storefront on the marketplace.",
+  schema: "marketplace",
+  map: "store",
+  fields: {
+    id: field5.id({ description: "Unique store ID" }),
+    name: field5.string({ description: "Store display name" }),
+    slug: field5.string({ description: "URL-friendly identifier" }),
+    description: field5.string({ isOptional: true }),
+    status: field5.enum("StoreStatus", { default: "PENDING" }),
+    type: field5.enum("StoreType", { default: "INDIVIDUAL" }),
+    ownerId: field5.foreignKey({ description: "Store owner user ID" }),
+    organizationId: field5.foreignKey({ isOptional: true }),
+    logoFileId: field5.string({
+      isOptional: true,
+      description: "Logo file reference"
+    }),
+    bannerFileId: field5.string({
+      isOptional: true,
+      description: "Banner file reference"
+    }),
+    email: field5.string({ isOptional: true }),
+    phone: field5.string({ isOptional: true }),
+    website: field5.string({ isOptional: true }),
+    country: field5.string({ isOptional: true }),
+    currency: field5.string({ default: '"USD"' }),
+    timezone: field5.string({ isOptional: true }),
+    commissionRate: field5.decimal({
+      default: 0.1,
+      description: "Platform commission rate (e.g., 0.1 = 10%)"
+    }),
+    isVerified: field5.boolean({ default: false }),
+    verifiedAt: field5.dateTime({ isOptional: true }),
+    settings: field5.json({ isOptional: true }),
+    metadata: field5.json({ isOptional: true }),
+    totalProducts: field5.int({ default: 0 }),
+    totalOrders: field5.int({ default: 0 }),
+    totalRevenue: field5.decimal({ default: 0 }),
+    averageRating: field5.decimal({ default: 0 }),
     createdAt: field5.createdAt(),
-    review: field5.belongsTo("Review", ["reviewId"], ["id"])
+    updatedAt: field5.updatedAt(),
+    products: field5.hasMany("Product"),
+    orders: field5.hasMany("Order"),
+    payouts: field5.hasMany("Payout")
   },
   indexes: [
-    index5.on(["reviewId"]),
+    index5.unique(["slug"]),
+    index5.on(["ownerId"]),
     index5.on(["status"]),
-    index5.on(["reporterId"])
-  ]
+    index5.on(["country", "status"]),
+    index5.on(["averageRating"])
+  ],
+  enums: [StoreStatusEnum, StoreTypeEnum]
+});
+var StoreCategoryEntity = defineEntity5({
+  name: "StoreCategory",
+  description: "Category assignment for stores.",
+  schema: "marketplace",
+  map: "store_category",
+  fields: {
+    id: field5.id(),
+    storeId: field5.foreignKey(),
+    categoryId: field5.foreignKey(),
+    isPrimary: field5.boolean({ default: false }),
+    createdAt: field5.createdAt(),
+    store: field5.belongsTo("Store", ["storeId"], ["id"], {
+      onDelete: "Cascade"
+    })
+  },
+  indexes: [index5.unique(["storeId", "categoryId"]), index5.on(["categoryId"])]
 });
 // src/entities/index.ts
 var marketplaceEntities = [