@stacksjs/orm 0.72.16 → 0.72.18

package/dist/models/commerce/Order.ts

@@ -0,0 +1,198 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'Order',
+  table: 'orders',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'customerId', 'status', 'totalAmount', 'orderType', 'createdAt'],
+      searchable: ['id', 'customerId', 'status', 'orderType'],
+      sortable: ['createdAt', 'updatedAt', 'totalAmount', 'estimatedDeliveryTime'],
+      filterable: ['status', 'orderType', 'customerId'],
+    },
+
+    useSeeder: {
+      count: 20,
+    },
+
+    useApi: {
+      uri: 'orders',
+      middleware: ['auth'],
+    },
+
+    observe: true,
+  },
+
+  hasMany: ['OrderItem', 'Payment', 'LicenseKey', 'DeliveryStop'],
+  belongsTo: ['Customer', 'Coupon'],
+
+  attributes: {
+    status: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().required(),
+      },
+      /*
+       * The canonical vocabulary is `OrderStatus` in
+       * `commerce/src/orders/events.ts`, which is what `canTransition` and
+       * `emitForStatus` are keyed on. The factory used to generate
+       * PREPARING / READY / CANCELED, none of which are in that union, so
+       * seeded orders could not legally transition anywhere.
+       *
+       * The column stays a free string rather than an enum: existing
+       * databases hold the old spellings, and adding a CHECK constraint here
+       * would fail their next migration rather than fix their data.
+       */
+      factory: faker => faker.helpers.arrayElement(['PENDING', 'PROCESSING', 'SHIPPED', 'OUT_FOR_DELIVERY', 'DELIVERED']),
+    },
+
+    totalAmount: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(0),
+      },
+      factory: faker => faker.number.int({ min: 100, max: 2000 }),
+    },
+
+    currency: {
+      order: 4,
+      fillable: true,
+      default: 'USD',
+      validation: {
+        rule: schema.string().required().max(3),
+      },
+      factory: faker => faker.helpers.arrayElement(['USD', 'EUR', 'GBP', 'CAD', 'AUD']),
+    },
+
+    taxAmount: {
+      default: 0,
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.number.int({ min: 10, max: 200 }),
+    },
+
+    discountAmount: {
+      default: 0,
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.number.int({ min: 0, max: 150 }),
+    },
+
+    deliveryFee: {
+      default: 0,
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.number.int({ min: 0, max: 100 }),
+    },
+
+    tipAmount: {
+      default: 0,
+      order: 8,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.number.int({ min: 0, max: 200 }),
+    },
+
+    orderType: {
+      order: 9,
+      fillable: true,
+      validation: {
+        rule: schema.string().required(),
+      },
+      factory: faker => faker.helpers.arrayElement(['DINE_IN', 'TAKEOUT', 'DELIVERY']),
+    },
+
+    deliveryAddress: {
+      order: 10,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.location.streetAddress(),
+    },
+
+    specialInstructions: {
+      order: 11,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.helpers.maybe(() => faker.lorem.sentence(), { probability: 0.3 }),
+    },
+
+    estimatedDeliveryTime: {
+      order: 12,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: (faker) => {
+        const now = new Date()
+        const futureDate = new Date(now.getTime() + faker.number.int({ min: 15, max: 120 }) * 60000)
+        return futureDate.toISOString()
+      },
+    },
+
+    /**
+     * Unguessable handle for the customer-facing tracking page.
+     *
+     * A tracking URL is opened from an SMS, on a phone, by someone who is not
+     * signed in, so it authorises on possession of this token. Sequential
+     * order ids would let anyone walk the table.
+     */
+    trackingToken: {
+      order: 13,
+      unique: true,
+      fillable: true,
+      validation: { rule: schema.string().max(64) },
+      factory: faker => faker.string.alphanumeric({ length: 32 }),
+    },
+
+    /** Geocoded delivery destination, so the map has somewhere to point. */
+    deliveryLatitude: {
+      order: 14,
+      fillable: true,
+      validation: { rule: schema.number().min(-90).max(90) },
+      factory: faker => faker.location.latitude(),
+    },
+
+    deliveryLongitude: {
+      order: 15,
+      fillable: true,
+      validation: { rule: schema.number().min(-180).max(180) },
+      factory: faker => faker.location.longitude(),
+    },
+
+    appliedCouponId: {
+      order: 16,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.helpers.maybe(() => faker.string.uuid(), { probability: 0.2 }),
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/dist/models/commerce/OrderIdempotency.ts

@@ -0,0 +1,34 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'OrderIdempotency',
+  table: 'order_idempotency',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useTimestamps: true,
+  },
+
+  dashboard: { enabled: false },
+
+  belongsTo: ['Order'],
+
+  attributes: {
+    idempotencyKey: {
+      fillable: true,
+      unique: true,
+      validation: {
+        rule: schema.string().required().max(255),
+      },
+    },
+    orderId: {
+      required: true,
+      fillable: true,
+      validation: {
+        rule: schema.number().required(),
+      },
+    },
+  },
+} as const)

package/dist/models/commerce/OrderItem.ts

@@ -0,0 +1,51 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'OrderItem',
+  table: 'order_items',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useTimestamps: true,
+  },
+
+  belongsTo: ['Order', 'Product'],
+
+  attributes: {
+    quantity: {
+      default: 1,
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(1),
+        message: {
+          min: 'Quantity must be at least 1',
+        },
+      },
+      factory: faker => faker.number.int({ min: 1, max: 5 }),
+    },
+
+    price: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(0),
+        message: {
+          min: 'Price cannot be negative',
+        },
+      },
+      factory: faker => faker.number.int({ min: 5, max: 50 }),
+    },
+
+    special_instructions: {
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.lorem.sentence(),
+    },
+  },
+} as const)

package/dist/models/commerce/Payment.ts

@@ -0,0 +1,182 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'Payment',
+  table: 'payments',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'orderId', 'customerId', 'amount', 'method', 'status', 'date'],
+      searchable: ['orderId', 'customerId', 'referenceNumber'],
+      sortable: ['amount', 'createdAt'],
+      filterable: ['method', 'status', 'date'],
+    },
+
+    useSeeder: {
+      count: 50,
+    },
+
+    useApi: {
+      uri: 'payments',
+      middleware: ['auth'],
+    },
+
+    observe: true,
+  },
+
+  belongsTo: ['Order', 'Customer'],
+
+  attributes: {
+    amount: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(1),
+      },
+      factory: faker => faker.number.int({ min: 1000, max: 50000 }),
+    },
+
+    method: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.enum([
+          'cash',
+          'creditCard',
+          'debitCard',
+          'paypal',
+          'applePay',
+          'googlePay',
+          'bankTransfer',
+          'giftCard',
+        ]).required(),
+      },
+      factory: faker => faker.helpers.arrayElement([
+        'cash',
+        'creditCard',
+        'debitCard',
+        'paypal',
+        'applePay',
+        'googlePay',
+        'bankTransfer',
+        'giftCard',
+      ]),
+    },
+
+    status: {
+      order: 5,
+      fillable: true,
+      default: 'pending',
+      validation: {
+        rule: schema.enum([
+          'pending',
+          'processing',
+          'completed',
+          'failed',
+          'refunded',
+          'partiallyRefunded',
+          'succeeded',
+        ]).required(),
+      },
+      factory: faker => faker.helpers.arrayElement([
+        'pending',
+        'processing',
+        'completed',
+        'failed',
+      ]),
+    },
+
+    currency: {
+      order: 7,
+      fillable: true,
+      default: 'USD',
+      validation: {
+        rule: schema.string().required().max(3),
+      },
+      factory: faker => faker.helpers.arrayElement(['USD', 'EUR', 'GBP', 'CAD', 'AUD']),
+    },
+
+    referenceNumber: {
+      order: 8,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.string.alphanumeric(16).toUpperCase(),
+    },
+
+    cardLastFour: {
+      order: 9,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(4),
+      },
+      factory: faker => faker.helpers.maybe(() => faker.string.numeric(4), { probability: 0.7 }),
+    },
+
+    cardBrand: {
+      order: 10,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.helpers.maybe(() => faker.helpers.arrayElement(['Visa', 'Mastercard', 'Amex', 'Discover']), { probability: 0.7 }),
+    },
+
+    billingEmail: {
+      order: 11,
+      fillable: true,
+      validation: {
+        rule: schema.string().email(),
+      },
+      factory: faker => faker.helpers.maybe(() => faker.internet.email(), { probability: 0.8 }),
+    },
+
+    transactionId: {
+      order: 12,
+      unique: true,
+      fillable: true,
+      foreignKey: false, // This is a payment processor transaction ID string, not a FK to transactions table
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.helpers.maybe(() => faker.string.uuid(), { probability: 0.9 }),
+    },
+
+    paymentProvider: {
+      order: 13,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.helpers.maybe(() => faker.helpers.arrayElement(['stripe', 'paypal', 'square', 'braintree', 'authorizeNet']), { probability: 0.9 }),
+    },
+
+    refundAmount: {
+      order: 14,
+      fillable: true,
+      default: 0,
+      validation: {
+        rule: schema.number().min(0),
+      },
+    },
+
+    notes: {
+      order: 15,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.helpers.maybe(() => faker.lorem.sentence(), { probability: 0.3 }),
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/dist/models/commerce/Pledge.ts

@@ -0,0 +1,112 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * A fund-a-need pledge.
+ *
+ * Fund-a-need is the part of a benefit auction that is not an auction: the room
+ * is asked to give at fixed levels and nobody competes for anything. It shares
+ * the auction only for the tally board, which is why a pledge has an amount and
+ * a level but no lot, no increment and no winner.
+ */
+export default defineModel({
+  name: 'Pledge',
+  table: 'pledges',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+
+    useSearch: {
+      displayable: ['id', 'donorName', 'amount', 'level', 'status'],
+      searchable: ['donorName', 'donorEmail', 'level'],
+      sortable: ['createdAt', 'amount'],
+      filterable: ['status', 'level'],
+    },
+
+    useApi: {
+      uri: 'pledges',
+      middleware: ['auth'],
+    },
+
+    observe: true,
+  },
+
+  belongsTo: ['Auction'],
+
+  indexes: [
+    { name: 'pledges_auction_id_index', columns: ['auction_id'] },
+    { name: 'pledges_status_index', columns: ['status'] },
+  ],
+
+  attributes: {
+    donorName: {
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(160),
+        message: {
+          required: 'Donor name is required',
+        },
+      },
+      factory: faker => faker.person.fullName(),
+    },
+
+    donorEmail: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().email().required(),
+        message: {
+          required: 'Donor email is required',
+        },
+      },
+      factory: faker => faker.internet.email().toLowerCase(),
+    },
+
+    /** The gift, in cents. */
+    amount: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(1),
+        message: {
+          required: 'A pledge amount is required',
+        },
+      },
+      factory: faker => faker.helpers.arrayElement([25000, 50000, 100000, 250000, 500000]),
+    },
+
+    /** The paddle-raise tier this came from, for the tally board. */
+    level: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(40),
+      },
+      factory: faker => faker.helpers.arrayElement(['250', '500', '1000', '2500', '5000']),
+    },
+
+    /**
+     * Pledges made from the room are good the moment a paddle goes up; pledges
+     * taken online are often confirmed by staff afterwards. Only `confirmed`
+     * money counts toward a total anybody reports.
+     */
+    status: {
+      default: 'confirmed',
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['pending', 'confirmed', 'cancelled']).required(),
+      },
+      factory: () => 'confirmed',
+    },
+  },
+
+  dashboard: {
+    icon: 'i-hugeicons-give-blood',
+    label: 'Pledges',
+  },
+} as const)

package/dist/models/commerce/PrintDevice.ts

@@ -0,0 +1,120 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'PrintDevice',
+  table: 'print_devices',
+  primaryKey: 'id',
+  autoIncrement: true,
+  hasMany: ['Receipt'],
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'name', 'macAddress', 'location', 'terminal', 'status', 'lastPing', 'printCount'],
+      searchable: ['name', 'macAddress', 'location', 'terminal'],
+      sortable: ['lastPing', 'printCount'],
+      filterable: ['status'],
+    },
+
+    useSeeder: {
+      count: 5,
+    },
+
+    useApi: {
+      uri: 'print-devices',
+      middleware: ['auth'],
+    },
+
+    observe: true,
+  },
+
+  attributes: {
+    name: {
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(100),
+        message: {
+          max: 'Device name must have a maximum of 100 characters',
+        },
+      },
+      factory: faker => faker.company.name(),
+    },
+
+    macAddress: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(50),
+        message: {
+          max: 'MAC address must have a maximum of 50 characters',
+        },
+      },
+      factory: faker => faker.internet.mac(),
+    },
+
+    location: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(100),
+        message: {
+          max: 'Location must have a maximum of 100 characters',
+        },
+      },
+      factory: faker => faker.location.streetAddress(),
+    },
+
+    terminal: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(50),
+        message: {
+          max: 'Terminal must have a maximum of 50 characters',
+        },
+      },
+      factory: faker => faker.string.alphanumeric(10),
+    },
+
+    status: {
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['online', 'offline', 'warning']).required(),
+      },
+      factory: faker => faker.helpers.arrayElement(['online', 'offline', 'warning']),
+    },
+
+    lastPing: {
+      order: 6,
+      fillable: true,
+      default: 0,
+      validation: {
+        rule: schema.unix(),
+        message: {
+          invalid: 'Invalid timestamp format',
+        },
+      },
+      factory: faker => faker.date.recent().getTime(),
+    },
+
+    printCount: {
+      order: 7,
+      fillable: true,
+      default: 0,
+      validation: {
+        rule: schema.number().min(0),
+        message: {
+          min: 'Print count cannot be negative',
+        },
+      },
+      factory: faker => faker.number.int({ min: 0, max: 1000 }),
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)