@nymbalhq/platform 0.0.0-stage → 1.0.0

package/dist/chunk-PW6ILJF7.js

@@ -0,0 +1,740 @@
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// src/db/schema/sqlite.ts
+var sqlite_exports = {};
+__export(sqlite_exports, {
+  carts: () => carts,
+  categories: () => categories,
+  customers: () => customers,
+  events: () => events,
+  inventoryReservations: () => inventoryReservations,
+  orderHistory: () => orderHistory,
+  orderRefunds: () => orderRefunds,
+  orderSequences: () => orderSequences,
+  orders: () => orders,
+  processedEvents: () => processedEvents,
+  productCategories: () => productCategories,
+  products: () => products,
+  refreshTokens: () => refreshTokens,
+  reviews: () => reviews,
+  schema: () => schema,
+  stockAdjustments: () => stockAdjustments,
+  variants: () => variants
+});
+import { sql } from "drizzle-orm";
+import { sqliteTable, text, integer, uniqueIndex, index, primaryKey } from "drizzle-orm/sqlite-core";
+var categories = sqliteTable(
+  "categories",
+  {
+    id: text("id").primaryKey(),
+    parentId: text("parent_id"),
+    slug: text("slug").notNull(),
+    name: text("name").notNull(),
+    description: text("description").notNull().default(""),
+    position: integer("position").notNull().default(0),
+    createdAt: text("created_at").notNull()
+  },
+  (t) => ({
+    slugUnique: uniqueIndex("categories_slug_unique").on(t.slug),
+    parentIdx: index("categories_parent_idx").on(t.parentId)
+  })
+);
+var products = sqliteTable(
+  "products",
+  {
+    id: text("id").primaryKey(),
+    slug: text("slug").notNull(),
+    name: text("name").notNull(),
+    description: text("description").notNull().default(""),
+    shortDescription: text("short_description").notNull().default(""),
+    status: text("status", { enum: ["draft", "active", "archived"] }).notNull().default("draft"),
+    type: text("type", { enum: ["simple", "variable"] }).notNull().default("simple"),
+    seoTitle: text("seo_title").notNull().default(""),
+    seoDescription: text("seo_description").notNull().default(""),
+    media: text("media").notNull().default("[]"),
+    metadata: text("metadata").notNull().default("{}"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => ({
+    slugUnique: uniqueIndex("products_slug_unique").on(t.slug),
+    statusIdx: index("products_status_idx").on(t.status)
+  })
+);
+var variants = sqliteTable(
+  "variants",
+  {
+    id: text("id").primaryKey(),
+    productId: text("product_id").notNull(),
+    sku: text("sku").notNull(),
+    name: text("name").notNull().default(""),
+    priceMinor: integer("price_minor").notNull(),
+    compareAtPriceMinor: integer("compare_at_price_minor"),
+    weightGrams: integer("weight_grams"),
+    dimensions: text("dimensions"),
+    stock: integer("stock").notNull().default(0),
+    lowStockThreshold: integer("low_stock_threshold").notNull().default(0),
+    options: text("options").notNull().default("[]"),
+    status: text("status", { enum: ["active", "inactive"] }).notNull().default("active"),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => ({
+    skuUnique: uniqueIndex("variants_sku_unique").on(t.sku),
+    productIdx: index("variants_product_idx").on(t.productId)
+  })
+);
+var productCategories = sqliteTable(
+  "product_categories",
+  {
+    productId: text("product_id").notNull(),
+    categoryId: text("category_id").notNull()
+  },
+  (t) => ({
+    pk: primaryKey({ columns: [t.productId, t.categoryId] }),
+    categoryIdx: index("product_categories_category_idx").on(t.categoryId)
+  })
+);
+var customers = sqliteTable(
+  "customers",
+  {
+    id: text("id").primaryKey(),
+    email: text("email").notNull(),
+    passwordHash: text("password_hash").notNull(),
+    firstName: text("first_name").notNull().default(""),
+    lastName: text("last_name").notNull().default(""),
+    phone: text("phone").notNull().default(""),
+    addresses: text("addresses").notNull().default("[]"),
+    orderCount: integer("order_count").notNull().default(0),
+    totalSpentMinor: integer("total_spent_minor").notNull().default(0),
+    metadata: text("metadata").notNull().default("{}"),
+    roles: text("roles").notNull().default('["customer"]'),
+    requiresPasswordReset: integer("requires_password_reset", { mode: "boolean" }).notNull().default(false),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => ({
+    emailUnique: uniqueIndex("customers_email_unique").on(t.email)
+  })
+);
+var refreshTokens = sqliteTable(
+  "refresh_tokens",
+  {
+    id: text("id").primaryKey(),
+    customerId: text("customer_id").notNull(),
+    tokenHash: text("token_hash").notNull(),
+    revokedAt: text("revoked_at"),
+    replacedByJti: text("replaced_by_jti"),
+    expiresAt: text("expires_at").notNull(),
+    createdAt: text("created_at").notNull()
+  },
+  (t) => ({
+    customerIdx: index("refresh_tokens_customer_idx").on(t.customerId)
+  })
+);
+var orders = sqliteTable(
+  "orders",
+  {
+    id: text("id").primaryKey(),
+    orderNumber: text("order_number").notNull(),
+    sequence: integer("sequence").notNull(),
+    customerId: text("customer_id"),
+    status: text("status", {
+      enum: [
+        "pending",
+        "confirmed",
+        "processing",
+        "shipped",
+        "delivered",
+        "cancelled",
+        "refunded",
+        "partially_refunded"
+      ]
+    }).notNull().default("pending"),
+    email: text("email").notNull(),
+    billingAddress: text("billing_address").notNull(),
+    shippingAddress: text("shipping_address").notNull(),
+    lineItems: text("line_items").notNull(),
+    subtotalMinor: integer("subtotal_minor").notNull(),
+    taxTotalMinor: integer("tax_total_minor").notNull().default(0),
+    shippingTotalMinor: integer("shipping_total_minor").notNull().default(0),
+    discountTotalMinor: integer("discount_total_minor").notNull().default(0),
+    totalMinor: integer("total_minor").notNull(),
+    currency: text("currency").notNull(),
+    notes: text("notes").notNull().default(""),
+    metadata: text("metadata").notNull().default("{}"),
+    paymentIntentId: text("payment_intent_id"),
+    /** The cart the order was placed from; null for imported orders. */
+    cartToken: text("cart_token"),
+    capturedMinor: integer("captured_minor").notNull().default(0),
+    capturedAt: text("captured_at"),
+    /** Σ of the succeeded `order_refunds`, written in the transaction that settles each. */
+    refundedMinor: integer("refunded_minor").notNull().default(0),
+    captureMethod: text("capture_method", { enum: ["provider", "manual", "import"] }),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull()
+  },
+  (t) => ({
+    numberUnique: uniqueIndex("orders_number_unique").on(t.orderNumber),
+    sequenceUnique: uniqueIndex("orders_sequence_unique").on(t.sequence),
+    customerIdx: index("orders_customer_idx").on(t.customerId),
+    statusIdx: index("orders_status_idx").on(t.status),
+    paymentIntentIdx: index("orders_payment_intent_idx").on(t.paymentIntentId),
+    // One pending order per cart, whatever the checkout's lock does.
+    pendingCartUnique: uniqueIndex("orders_pending_cart_unique").on(t.cartToken).where(sql`status = 'pending'`)
+  })
+);
+var orderHistory = sqliteTable(
+  "order_history",
+  {
+    id: text("id").primaryKey(),
+    orderId: text("order_id").notNull(),
+    fromStatus: text("from_status"),
+    toStatus: text("to_status").notNull(),
+    actor: text("actor").notNull(),
+    note: text("note").notNull().default(""),
+    timestamp: text("timestamp").notNull()
+  },
+  (t) => ({
+    orderIdx: index("order_history_order_idx").on(t.orderId)
+  })
+);
+var orderRefunds = sqliteTable(
+  "order_refunds",
+  {
+    id: text("id").primaryKey(),
+    orderId: text("order_id").notNull(),
+    amountMinor: integer("amount_minor").notNull(),
+    currency: text("currency").notNull(),
+    providerRefundId: text("provider_refund_id"),
+    status: text("status", { enum: ["pending", "succeeded", "failed"] }).notNull().default("pending"),
+    reason: text("reason"),
+    actor: text("actor").notNull(),
+    createdAt: text("created_at").notNull(),
+    /** The client's key for one refund request: a repeat of it on the order answers the refund it made. */
+    requestId: text("request_id")
+  },
+  (t) => ({
+    orderIdx: index("order_refunds_order_idx").on(t.orderId),
+    requestIdx: uniqueIndex("order_refunds_order_request_idx").on(t.orderId, t.requestId)
+  })
+);
+var orderSequences = sqliteTable("order_sequences", {
+  id: integer("id").primaryKey(),
+  nextValue: integer("next_value").notNull()
+});
+var inventoryReservations = sqliteTable(
+  "inventory_reservations",
+  {
+    reservationId: text("reservation_id").primaryKey(),
+    variantId: text("variant_id").notNull(),
+    qty: integer("qty").notNull(),
+    orderRef: text("order_ref"),
+    expiresAt: text("expires_at").notNull(),
+    createdAt: text("created_at").notNull()
+  },
+  (t) => ({
+    variantIdx: index("inv_reservations_variant_idx").on(t.variantId),
+    expiresIdx: index("inv_reservations_expires_idx").on(t.expiresAt)
+  })
+);
+var stockAdjustments = sqliteTable(
+  "stock_adjustments",
+  {
+    id: text("id").primaryKey(),
+    variantId: text("variant_id").notNull(),
+    adjustment: integer("adjustment").notNull(),
+    reason: text("reason", {
+      enum: ["sale", "return", "manual", "import", "reservation-commit", "reservation-release"]
+    }).notNull(),
+    actor: text("actor").notNull(),
+    previousQty: integer("previous_qty").notNull(),
+    newQty: integer("new_qty").notNull(),
+    timestamp: text("timestamp").notNull()
+  },
+  (t) => ({
+    variantIdx: index("stock_adjustments_variant_idx").on(t.variantId)
+  })
+);
+var reviews = sqliteTable(
+  "reviews",
+  {
+    id: text("id").primaryKey(),
+    productId: text("product_id").notNull(),
+    customerId: text("customer_id"),
+    orderId: text("order_id"),
+    rating: integer("rating").notNull(),
+    title: text("title").notNull().default(""),
+    body: text("body").notNull().default(""),
+    moderationStatus: text("moderation_status", {
+      enum: ["pending", "approved", "rejected"]
+    }).notNull().default("pending"),
+    submittedAt: text("submitted_at").notNull(),
+    moderatedAt: text("moderated_at"),
+    moderatedBy: text("moderated_by")
+  },
+  (t) => ({
+    productIdx: index("reviews_product_idx").on(t.productId),
+    statusIdx: index("reviews_status_idx").on(t.moderationStatus)
+  })
+);
+var carts = sqliteTable(
+  "carts",
+  {
+    token: text("token").primaryKey(),
+    customerId: text("customer_id"),
+    currency: text("currency").notNull(),
+    items: text("items").notNull().default("[]"),
+    lineCount: integer("line_count").notNull().default(0),
+    subtotalMinor: integer("subtotal_minor").notNull().default(0),
+    expiresAt: text("expires_at").notNull(),
+    createdAt: text("created_at").notNull(),
+    updatedAt: text("updated_at").notNull(),
+    /** Set by the abandonment sweeper's claim; every cart write clears it, starting a new inactivity period. */
+    abandonedNotifiedAt: text("abandoned_notified_at")
+  },
+  (t) => ({
+    expiresIdx: index("carts_expires_idx").on(t.expiresAt),
+    updatedIdx: index("carts_updated_idx").on(t.updatedAt)
+  })
+);
+var events = sqliteTable(
+  "events",
+  {
+    seq: integer("seq").primaryKey({ autoIncrement: true }),
+    id: text("id").notNull(),
+    type: text("type").notNull(),
+    envelope: text("envelope").notNull(),
+    createdAt: text("created_at").notNull(),
+    deliveredAt: text("delivered_at"),
+    attempts: integer("attempts").notNull().default(0),
+    deadAt: text("dead_at")
+  },
+  (t) => ({
+    idUnique: uniqueIndex("events_id_unique").on(t.id),
+    undeliveredIdx: index("events_undelivered_idx").on(t.deliveredAt, t.seq)
+  })
+);
+var processedEvents = sqliteTable(
+  "processed_events",
+  {
+    handlerName: text("handler_name").notNull(),
+    eventId: text("event_id").notNull(),
+    processedAt: text("processed_at").notNull()
+  },
+  (t) => ({
+    pk: primaryKey({ columns: [t.handlerName, t.eventId] })
+  })
+);
+var schema = {
+  categories,
+  products,
+  variants,
+  productCategories,
+  customers,
+  refreshTokens,
+  orders,
+  orderHistory,
+  orderSequences,
+  inventoryReservations,
+  stockAdjustments,
+  reviews,
+  carts,
+  events,
+  processedEvents
+};
+
+// src/db/schema/postgres.ts
+var postgres_exports = {};
+__export(postgres_exports, {
+  carts: () => carts2,
+  categories: () => categories2,
+  customers: () => customers2,
+  events: () => events2,
+  inventoryReservations: () => inventoryReservations2,
+  orderHistory: () => orderHistory2,
+  orderRefunds: () => orderRefunds2,
+  orderSequences: () => orderSequences2,
+  orders: () => orders2,
+  processedEvents: () => processedEvents2,
+  productCategories: () => productCategories2,
+  products: () => products2,
+  refreshTokens: () => refreshTokens2,
+  reviews: () => reviews2,
+  schema: () => schema2,
+  stockAdjustments: () => stockAdjustments2,
+  variants: () => variants2
+});
+import { sql as sql2 } from "drizzle-orm";
+import {
+  pgTable,
+  bigserial,
+  text as text2,
+  integer as integer2,
+  timestamp,
+  jsonb,
+  boolean,
+  uniqueIndex as uniqueIndex2,
+  index as index2,
+  primaryKey as primaryKey2
+} from "drizzle-orm/pg-core";
+var categories2 = pgTable(
+  "categories",
+  {
+    id: text2("id").primaryKey(),
+    parentId: text2("parent_id"),
+    slug: text2("slug").notNull(),
+    name: text2("name").notNull(),
+    description: text2("description").notNull().default(""),
+    position: integer2("position").notNull().default(0),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull()
+  },
+  (t) => ({
+    slugUnique: uniqueIndex2("categories_slug_unique").on(t.slug),
+    parentIdx: index2("categories_parent_idx").on(t.parentId)
+  })
+);
+var products2 = pgTable(
+  "products",
+  {
+    id: text2("id").primaryKey(),
+    slug: text2("slug").notNull(),
+    name: text2("name").notNull(),
+    description: text2("description").notNull().default(""),
+    shortDescription: text2("short_description").notNull().default(""),
+    status: text2("status", { enum: ["draft", "active", "archived"] }).notNull().default("draft"),
+    type: text2("type", { enum: ["simple", "variable"] }).notNull().default("simple"),
+    seoTitle: text2("seo_title").notNull().default(""),
+    seoDescription: text2("seo_description").notNull().default(""),
+    media: jsonb("media").notNull().default([]),
+    metadata: jsonb("metadata").notNull().default({}),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull()
+  },
+  (t) => ({
+    slugUnique: uniqueIndex2("products_slug_unique").on(t.slug),
+    statusIdx: index2("products_status_idx").on(t.status)
+  })
+);
+var variants2 = pgTable(
+  "variants",
+  {
+    id: text2("id").primaryKey(),
+    productId: text2("product_id").notNull(),
+    sku: text2("sku").notNull(),
+    name: text2("name").notNull().default(""),
+    priceMinor: integer2("price_minor").notNull(),
+    compareAtPriceMinor: integer2("compare_at_price_minor"),
+    weightGrams: integer2("weight_grams"),
+    dimensions: jsonb("dimensions"),
+    stock: integer2("stock").notNull().default(0),
+    lowStockThreshold: integer2("low_stock_threshold").notNull().default(0),
+    options: jsonb("options").notNull().default([]),
+    status: text2("status", { enum: ["active", "inactive"] }).notNull().default("active"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull()
+  },
+  (t) => ({
+    skuUnique: uniqueIndex2("variants_sku_unique").on(t.sku),
+    productIdx: index2("variants_product_idx").on(t.productId)
+  })
+);
+var productCategories2 = pgTable(
+  "product_categories",
+  {
+    productId: text2("product_id").notNull(),
+    categoryId: text2("category_id").notNull()
+  },
+  (t) => ({
+    pk: primaryKey2({ columns: [t.productId, t.categoryId] }),
+    categoryIdx: index2("product_categories_category_idx").on(t.categoryId)
+  })
+);
+var customers2 = pgTable(
+  "customers",
+  {
+    id: text2("id").primaryKey(),
+    email: text2("email").notNull(),
+    passwordHash: text2("password_hash").notNull(),
+    firstName: text2("first_name").notNull().default(""),
+    lastName: text2("last_name").notNull().default(""),
+    phone: text2("phone").notNull().default(""),
+    addresses: jsonb("addresses").notNull().default([]),
+    orderCount: integer2("order_count").notNull().default(0),
+    totalSpentMinor: integer2("total_spent_minor").notNull().default(0),
+    metadata: jsonb("metadata").notNull().default({}),
+    roles: jsonb("roles").notNull().default(["customer"]),
+    requiresPasswordReset: boolean("requires_password_reset").notNull().default(false),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull()
+  },
+  (t) => ({
+    emailUnique: uniqueIndex2("customers_email_unique").on(t.email)
+  })
+);
+var refreshTokens2 = pgTable(
+  "refresh_tokens",
+  {
+    id: text2("id").primaryKey(),
+    customerId: text2("customer_id").notNull(),
+    tokenHash: text2("token_hash").notNull(),
+    revokedAt: timestamp("revoked_at", { withTimezone: true }),
+    replacedByJti: text2("replaced_by_jti"),
+    expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull()
+  },
+  (t) => ({
+    customerIdx: index2("refresh_tokens_customer_idx").on(t.customerId)
+  })
+);
+var orders2 = pgTable(
+  "orders",
+  {
+    id: text2("id").primaryKey(),
+    orderNumber: text2("order_number").notNull(),
+    sequence: integer2("sequence").notNull(),
+    customerId: text2("customer_id"),
+    status: text2("status", {
+      enum: [
+        "pending",
+        "confirmed",
+        "processing",
+        "shipped",
+        "delivered",
+        "cancelled",
+        "refunded",
+        "partially_refunded"
+      ]
+    }).notNull().default("pending"),
+    email: text2("email").notNull(),
+    billingAddress: jsonb("billing_address").notNull(),
+    shippingAddress: jsonb("shipping_address").notNull(),
+    lineItems: jsonb("line_items").notNull(),
+    subtotalMinor: integer2("subtotal_minor").notNull(),
+    taxTotalMinor: integer2("tax_total_minor").notNull().default(0),
+    shippingTotalMinor: integer2("shipping_total_minor").notNull().default(0),
+    discountTotalMinor: integer2("discount_total_minor").notNull().default(0),
+    totalMinor: integer2("total_minor").notNull(),
+    currency: text2("currency").notNull(),
+    notes: text2("notes").notNull().default(""),
+    metadata: jsonb("metadata").notNull().default({}),
+    paymentIntentId: text2("payment_intent_id"),
+    /** The cart the order was placed from; null for imported orders. */
+    cartToken: text2("cart_token"),
+    capturedMinor: integer2("captured_minor").notNull().default(0),
+    capturedAt: timestamp("captured_at", { withTimezone: true }),
+    /** Σ of the succeeded `order_refunds`, written in the transaction that settles each. */
+    refundedMinor: integer2("refunded_minor").notNull().default(0),
+    captureMethod: text2("capture_method", { enum: ["provider", "manual", "import"] }),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull()
+  },
+  (t) => ({
+    numberUnique: uniqueIndex2("orders_number_unique").on(t.orderNumber),
+    sequenceUnique: uniqueIndex2("orders_sequence_unique").on(t.sequence),
+    customerIdx: index2("orders_customer_idx").on(t.customerId),
+    statusIdx: index2("orders_status_idx").on(t.status),
+    paymentIntentIdx: index2("orders_payment_intent_idx").on(t.paymentIntentId),
+    // One pending order per cart, whatever the checkout's lock does.
+    pendingCartUnique: uniqueIndex2("orders_pending_cart_unique").on(t.cartToken).where(sql2`status = 'pending'`)
+  })
+);
+var orderHistory2 = pgTable(
+  "order_history",
+  {
+    id: text2("id").primaryKey(),
+    orderId: text2("order_id").notNull(),
+    fromStatus: text2("from_status"),
+    toStatus: text2("to_status").notNull(),
+    actor: text2("actor").notNull(),
+    note: text2("note").notNull().default(""),
+    timestamp: timestamp("timestamp", { withTimezone: true }).notNull()
+  },
+  (t) => ({
+    orderIdx: index2("order_history_order_idx").on(t.orderId)
+  })
+);
+var orderRefunds2 = pgTable(
+  "order_refunds",
+  {
+    id: text2("id").primaryKey(),
+    orderId: text2("order_id").notNull(),
+    amountMinor: integer2("amount_minor").notNull(),
+    currency: text2("currency").notNull(),
+    providerRefundId: text2("provider_refund_id"),
+    status: text2("status", { enum: ["pending", "succeeded", "failed"] }).notNull().default("pending"),
+    reason: text2("reason"),
+    actor: text2("actor").notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+    /** The client's key for one refund request: a repeat of it on the order answers the refund it made. */
+    requestId: text2("request_id")
+  },
+  (t) => ({
+    orderIdx: index2("order_refunds_order_idx").on(t.orderId),
+    requestIdx: uniqueIndex2("order_refunds_order_request_idx").on(t.orderId, t.requestId)
+  })
+);
+var orderSequences2 = pgTable("order_sequences", {
+  id: integer2("id").primaryKey(),
+  nextValue: integer2("next_value").notNull()
+});
+var inventoryReservations2 = pgTable(
+  "inventory_reservations",
+  {
+    reservationId: text2("reservation_id").primaryKey(),
+    variantId: text2("variant_id").notNull(),
+    qty: integer2("qty").notNull(),
+    orderRef: text2("order_ref"),
+    expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull()
+  },
+  (t) => ({
+    variantIdx: index2("inv_reservations_variant_idx").on(t.variantId),
+    expiresIdx: index2("inv_reservations_expires_idx").on(t.expiresAt)
+  })
+);
+var stockAdjustments2 = pgTable(
+  "stock_adjustments",
+  {
+    id: text2("id").primaryKey(),
+    variantId: text2("variant_id").notNull(),
+    adjustment: integer2("adjustment").notNull(),
+    reason: text2("reason", {
+      enum: ["sale", "return", "manual", "import", "reservation-commit", "reservation-release"]
+    }).notNull(),
+    actor: text2("actor").notNull(),
+    previousQty: integer2("previous_qty").notNull(),
+    newQty: integer2("new_qty").notNull(),
+    timestamp: timestamp("timestamp", { withTimezone: true }).notNull()
+  },
+  (t) => ({
+    variantIdx: index2("stock_adjustments_variant_idx").on(t.variantId)
+  })
+);
+var reviews2 = pgTable(
+  "reviews",
+  {
+    id: text2("id").primaryKey(),
+    productId: text2("product_id").notNull(),
+    customerId: text2("customer_id"),
+    orderId: text2("order_id"),
+    rating: integer2("rating").notNull(),
+    title: text2("title").notNull().default(""),
+    body: text2("body").notNull().default(""),
+    moderationStatus: text2("moderation_status", {
+      enum: ["pending", "approved", "rejected"]
+    }).notNull().default("pending"),
+    submittedAt: timestamp("submitted_at", { withTimezone: true }).notNull(),
+    moderatedAt: timestamp("moderated_at", { withTimezone: true }),
+    moderatedBy: text2("moderated_by")
+  },
+  (t) => ({
+    productIdx: index2("reviews_product_idx").on(t.productId),
+    statusIdx: index2("reviews_status_idx").on(t.moderationStatus)
+  })
+);
+var carts2 = pgTable(
+  "carts",
+  {
+    token: text2("token").primaryKey(),
+    customerId: text2("customer_id"),
+    currency: text2("currency").notNull(),
+    items: jsonb("items").notNull().default([]),
+    lineCount: integer2("line_count").notNull().default(0),
+    subtotalMinor: integer2("subtotal_minor").notNull().default(0),
+    expiresAt: timestamp("expires_at", { withTimezone: true }).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull(),
+    /** Set by the abandonment sweeper's claim; every cart write clears it, starting a new inactivity period. */
+    abandonedNotifiedAt: timestamp("abandoned_notified_at", { withTimezone: true })
+  },
+  (t) => ({
+    expiresIdx: index2("carts_expires_idx").on(t.expiresAt),
+    updatedIdx: index2("carts_updated_idx").on(t.updatedAt)
+  })
+);
+var events2 = pgTable(
+  "events",
+  {
+    seq: bigserial("seq", { mode: "number" }).primaryKey(),
+    id: text2("id").notNull(),
+    type: text2("type").notNull(),
+    envelope: jsonb("envelope").notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+    deliveredAt: timestamp("delivered_at", { withTimezone: true }),
+    attempts: integer2("attempts").notNull().default(0),
+    deadAt: timestamp("dead_at", { withTimezone: true })
+  },
+  (t) => ({
+    idUnique: uniqueIndex2("events_id_unique").on(t.id),
+    undeliveredIdx: index2("events_undelivered_idx").on(t.deliveredAt, t.seq)
+  })
+);
+var processedEvents2 = pgTable(
+  "processed_events",
+  {
+    handlerName: text2("handler_name").notNull(),
+    eventId: text2("event_id").notNull(),
+    processedAt: timestamp("processed_at", { withTimezone: true }).notNull()
+  },
+  (t) => ({
+    pk: primaryKey2({ columns: [t.handlerName, t.eventId] })
+  })
+);
+var schema2 = {
+  categories: categories2,
+  products: products2,
+  variants: variants2,
+  productCategories: productCategories2,
+  customers: customers2,
+  refreshTokens: refreshTokens2,
+  orders: orders2,
+  orderHistory: orderHistory2,
+  orderSequences: orderSequences2,
+  inventoryReservations: inventoryReservations2,
+  stockAdjustments: stockAdjustments2,
+  reviews: reviews2,
+  carts: carts2,
+  events: events2,
+  processedEvents: processedEvents2
+};
+
+export {
+  categories,
+  products,
+  variants,
+  productCategories,
+  customers,
+  refreshTokens,
+  orders,
+  orderHistory,
+  orderRefunds,
+  orderSequences,
+  inventoryReservations,
+  stockAdjustments,
+  reviews,
+  carts,
+  events,
+  processedEvents,
+  sqlite_exports,
+  categories2,
+  products2,
+  variants2,
+  productCategories2,
+  customers2,
+  refreshTokens2,
+  orders2,
+  orderHistory2,
+  orderRefunds2,
+  orderSequences2,
+  inventoryReservations2,
+  stockAdjustments2,
+  reviews2,
+  carts2,
+  events2,
+  processedEvents2,
+  postgres_exports
+};
+//# sourceMappingURL=chunk-PW6ILJF7.js.map