@stacksjs/orm 0.72.16 → 0.72.18

package/dist/models/commerce/Bid.ts

@@ -0,0 +1,129 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * One bid on one lot.
+ *
+ * Bidders are identified by name and email rather than by a user account: a
+ * benefit auction is bid on by grandparents on borrowed phones, and requiring
+ * a signup between them and their paddle costs the school real money.
+ *
+ * `maxAmount` is the private proxy ceiling. It must never be selected into a
+ * template or an API response - the whole mechanism depends on nobody being
+ * able to see how far the other side is willing to go. `hidden` keeps it out of
+ * the generated CRUD responses; the queries in `@stacksjs/auctions` that feed
+ * the public catalogue select columns explicitly for the same reason.
+ */
+export default defineModel({
+  name: 'Bid',
+  table: 'bids',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+
+    useSearch: {
+      displayable: ['id', 'bidderName', 'amount', 'status', 'placedAt'],
+      searchable: ['bidderName', 'bidderEmail'],
+      sortable: ['placedAt', 'amount'],
+      filterable: ['status'],
+    },
+
+    // Read is authenticated: the bid history of a lot is staff information
+    // while the auction is live. Writes never come through generated CRUD -
+    // a bid has to go through the engine, so the app owns that route.
+    useApi: {
+      uri: 'bids',
+      routes: ['index', 'show'],
+      middleware: ['auth'],
+    },
+
+    observe: true,
+  },
+
+  belongsTo: ['Auction', 'AuctionItem'],
+
+  indexes: [
+    { name: 'bids_auction_item_id_index', columns: ['auction_item_id'] },
+    { name: 'bids_auction_id_index', columns: ['auction_id'] },
+    { name: 'bids_bidder_email_index', columns: ['bidder_email'] },
+    { name: 'bids_status_index', columns: ['status'] },
+  ],
+
+  attributes: {
+    bidderName: {
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(160),
+        message: {
+          required: 'Your name is required',
+        },
+      },
+      factory: faker => faker.person.fullName(),
+    },
+
+    bidderEmail: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().email().required(),
+        message: {
+          required: 'Your email is required',
+          email: 'That does not look like an email address',
+        },
+      },
+      factory: faker => faker.internet.email().toLowerCase(),
+    },
+
+    /** The public number: what this bidder is currently committed to, in cents. */
+    amount: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(1),
+        message: {
+          required: 'A bid amount is required',
+        },
+      },
+      factory: faker => faker.number.int({ min: 5000, max: 200000 }),
+    },
+
+    /** The private ceiling, in cents. Null means "this amount only". */
+    maxAmount: {
+      order: 4,
+      fillable: true,
+      hidden: true,
+      validation: {
+        rule: schema.number().min(1),
+      },
+      factory: () => null,
+    },
+
+    status: {
+      default: 'leading',
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['leading', 'outbid', 'won', 'lost', 'invalid']).required(),
+      },
+      factory: () => 'outbid',
+    },
+
+    placedAt: {
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.date().required(),
+      },
+      factory: faker => faker.date.recent().toISOString(),
+    },
+  },
+
+  dashboard: {
+    icon: 'i-hugeicons-hand-pointing-right-01',
+    label: 'Bids',
+  },
+} as const)

package/dist/models/commerce/Cart.ts

@@ -0,0 +1,140 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'Cart',
+  table: 'carts',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'customerId', 'status', 'totalItems', 'subtotal', 'total', 'expiresAt'],
+      searchable: ['id', 'customerId', 'status'],
+      sortable: ['createdAt', 'updatedAt', 'expiresAt', 'total'],
+      filterable: ['status', 'customerId'],
+    },
+
+    useSeeder: {
+      count: 10,
+    },
+
+    useApi: {
+      uri: 'carts',
+      middleware: ['auth'],
+    },
+
+    observe: true,
+  },
+
+  hasMany: ['CartItem'],
+  belongsTo: ['Customer', 'Coupon'],
+
+  attributes: {
+    status: {
+      default: 'active',
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['active', 'abandoned', 'converted', 'expired']),
+      },
+      factory: faker => faker.helpers.arrayElement(['active', 'abandoned', 'converted', 'expired']),
+    },
+
+    totalItems: {
+      default: 0,
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.number.int({ min: 0, max: 20 }),
+    },
+
+    subtotal: {
+      default: 0,
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.number.int({ min: 0, max: 1000 }),
+    },
+
+    taxAmount: {
+      default: 0,
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.number.int({ min: 0, max: 200 }),
+    },
+
+    discountAmount: {
+      default: 0,
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.number.int({ min: 0, max: 100 }),
+    },
+
+    total: {
+      default: 0,
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.number.int({ min: 0, max: 1200 }),
+    },
+
+    expiresAt: {
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp().required(),
+      },
+      factory: (faker) => {
+        const date = faker.date.past()
+        return date.toISOString().slice(0, 19).replace('T', ' ')
+      },
+    },
+
+    currency: {
+      default: 'USD',
+      order: 8,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(3),
+      },
+      factory: faker => faker.helpers.arrayElement(['USD', 'EUR', 'GBP', 'JPY', 'AUD']),
+    },
+
+    notes: {
+      order: 9,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(1000),
+      },
+      factory: faker => faker.lorem.sentence(),
+    },
+
+    appliedCouponId: {
+      order: 10,
+      fillable: true,
+      validation: {
+        rule: schema.string().required(),
+      },
+      factory: () => 'test-coupon-id',
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/dist/models/commerce/CartItem.ts

@@ -0,0 +1,138 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'CartItem',
+  table: 'cart_items',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'cartId', 'productId', 'quantity', 'unitPrice', 'totalPrice'],
+      searchable: ['id', 'cartId', 'productId'],
+      sortable: ['createdAt', 'updatedAt', 'quantity', 'unitPrice'],
+      filterable: ['cartId', 'productId'],
+    },
+
+    useSeeder: {
+      count: 50,
+    },
+
+    useApi: {
+      uri: 'cart-items',
+      middleware: ['auth'],
+    },
+
+    observe: true,
+  },
+
+  belongsTo: ['Cart'],
+
+  attributes: {
+    quantity: {
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(1),
+      },
+      factory: faker => faker.number.int({ min: 1, max: 10 }),
+    },
+
+    unitPrice: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(0),
+      },
+      factory: faker => faker.number.int({ min: 1, max: 1000 }),
+    },
+
+    totalPrice: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(0),
+      },
+      factory: faker => faker.number.int({ min: 1, max: 1000 }),
+    },
+
+    taxRate: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0).max(100),
+      },
+      factory: faker => faker.number.int({ min: 0, max: 20 }),
+    },
+
+    taxAmount: {
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.number.int({ min: 0, max: 50 }),
+    },
+
+    discountPercentage: {
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0).max(100),
+      },
+      factory: faker => faker.number.int({ min: 0, max: 50 }),
+    },
+
+    discountAmount: {
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.number.int({ min: 0, max: 25 }),
+    },
+
+    productName: {
+      order: 8,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(255),
+      },
+      factory: faker => faker.commerce.productName(),
+    },
+
+    productSku: {
+      order: 9,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(100),
+      },
+      factory: faker => faker.string.alphanumeric(10),
+    },
+
+    productImage: {
+      order: 10,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(255),
+      },
+      factory: faker => faker.image.url(),
+    },
+
+    notes: {
+      order: 11,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(500),
+      },
+      factory: faker => faker.lorem.sentence(),
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/dist/models/commerce/Category.ts

@@ -0,0 +1,125 @@
+import { defineModel } from '@stacksjs/orm'
+import { slug } from '@stacksjs/strings'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'Category',
+  table: 'categories',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'name', 'description', 'isActive', 'parentCategoryId', 'displayOrder'],
+      searchable: ['name', 'description'],
+      sortable: ['displayOrder', 'createdAt', 'updatedAt'],
+      filterable: ['parentCategoryId', 'isActive'],
+    },
+
+    useSeeder: {
+      count: 10,
+    },
+
+    useApi: {
+      // Public catalog: anyone may browse, only authenticated callers may
+      // write. Declared explicitly because the trait now defaults BOTH sides to
+      // `auth` — an undeclared read route is how a customer list leaks
+      // (stacksjs/stacks#2224). Behaviour here is unchanged.
+      middleware: { read: [], write: ['auth'] },
+      uri: 'product-categories',
+    },
+
+    observe: true,
+  },
+
+  hasMany: ['Product'],
+  belongsToMany: {
+    posts: {
+      model: 'Post',
+      table: 'categorizable_models',
+      foreignKey: 'category_id',
+      relatedKey: 'categorizable_id',
+      pivot: {
+        columns: {
+          categorizable_type: { default: 'posts' },
+        },
+        timestamps: true,
+        uniques: [['category_id', 'categorizable_id', 'categorizable_type']],
+      },
+    },
+  },
+
+  attributes: {
+    name: {
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(50),
+        message: {
+          max: 'Name must have a maximum of 50 characters',
+        },
+      },
+      factory: faker => faker.commerce.department(),
+    },
+
+    description: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.commerce.productDescription(),
+    },
+
+    slug: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.string().required(),
+      },
+      factory: faker => slug(faker.commerce.department()),
+    },
+
+    imageUrl: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.image.url(),
+    },
+
+    isActive: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.boolean(),
+      },
+      factory: () => true,
+    },
+
+    parentCategoryId: {
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: () => null, // Most categories won't have a parent
+    },
+
+    displayOrder: {
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.number().required(),
+      },
+      factory: faker => faker.number.int({ min: 1, max: 100 }),
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/dist/models/commerce/Coupon.ts

@@ -0,0 +1,186 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'Coupon',
+  table: 'coupons',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'code', 'discountType', 'discountValue', 'startDate', 'endDate'],
+      searchable: ['code', 'description', 'discountType'],
+      sortable: ['createdAt', 'startDate', 'endDate', 'discountValue', 'usageCount'],
+      filterable: ['discountType'],
+    },
+
+    useSeeder: {
+      count: 15,
+    },
+
+    useApi: {
+      uri: 'coupons',
+      middleware: ['auth'],
+    },
+
+    observe: true,
+  },
+
+  belongsTo: ['Product'],
+  hasMany: ['Order'],
+
+  attributes: {
+    code: {
+      unique: true,
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(50),
+        message: {
+          max: 'Code must have a maximum of 50 characters',
+        },
+      },
+      factory: faker => faker.string.alphanumeric(8).toUpperCase(),
+    },
+
+    description: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.commerce.productDescription(),
+    },
+
+    status: {
+      default: 'Active',
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['Active', 'Scheduled', 'Expired']).required(),
+        message: {
+          required: 'Status is required',
+        },
+      },
+      factory: faker => faker.helpers.arrayElement(['Active', 'Scheduled', 'Expired']),
+    },
+
+    isActive: {
+      order: 4,
+      fillable: true,
+      default: true,
+      validation: {
+        rule: schema.boolean().required(),
+      },
+      factory: () => true,
+    },
+
+    discountType: {
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['fixed_amount', 'percentage']).required(),
+        message: {
+          required: 'Discount type is required',
+        },
+      },
+      factory: faker => faker.helpers.arrayElement(['fixed_amount', 'percentage']),
+    },
+
+    discountValue: {
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(0.01),
+        message: {
+          required: 'Discount value is required',
+          min: 'Discount value must be greater than 0.01',
+        },
+      },
+      factory: faker => faker.number.int({ min: 5, max: 50 }),
+    },
+
+    minOrderAmount: {
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+        message: {
+          min: 'Min order amount must be greater than 0',
+        },
+      },
+      factory: faker => faker.number.int({ min: 0, max: 50 }),
+    },
+
+    maxDiscountAmount: {
+      order: 8,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+        message: {
+          min: 'Max discount amount must be greater than 0',
+        },
+      },
+      factory: faker => faker.number.int({ min: 5, max: 100 }),
+    },
+
+    freeProductId: {
+      order: 9,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.string.uuid(),
+    },
+
+    usageLimit: {
+      order: 10,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(1),
+        message: {
+          min: 'Usage limit must be greater than 1',
+        },
+      },
+      factory: faker => faker.number.int({ min: 1, max: 100 }),
+    },
+
+    usageCount: {
+      default: 0,
+      order: 11,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+        message: {
+          min: 'Usage count must be greater than 0',
+        },
+      },
+      factory: faker => faker.number.int({ min: 0, max: 50 }),
+    },
+
+    startDate: {
+      order: 12,
+      fillable: true,
+      validation: {
+        rule: schema.date(),
+      },
+      factory: faker => faker.date.recent().toISOString().slice(0, 10),
+    },
+
+    endDate: {
+      order: 13,
+      fillable: true,
+      validation: {
+        rule: schema.date(),
+      },
+      factory: faker => faker.date.future().toISOString().slice(0, 10),
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)