@stacksjs/defaults 0.70.58 → 0.70.59

package/app/Models/commerce/LoyaltyReward.ts

@@ -0,0 +1,124 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'LoyaltyReward',
+  table: 'loyalty_rewards',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'name', 'pointsRequired', 'rewardType', 'isActive'],
+      searchable: ['name', 'description', 'rewardType'],
+      sortable: ['pointsRequired', 'createdAt', 'updatedAt'],
+      filterable: ['rewardType', 'isActive'],
+    },
+
+    useSeeder: {
+      count: 15,
+    },
+
+    useApi: {
+      uri: 'loyalty-rewards',
+    },
+
+    observe: true,
+  },
+
+  belongsTo: ['Product'],
+
+  attributes: {
+    name: {
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().required(),
+      },
+      factory: faker => faker.helpers.arrayElement([
+        `10% discount on your order`,
+        `20% discount on your order`,
+        `Free product with purchase`,
+        `Priority delivery service`,
+      ]),
+    },
+
+    description: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(500),
+      },
+      factory: faker => faker.lorem.paragraph(),
+    },
+
+    pointsRequired: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(1),
+      },
+      factory: faker => faker.number.int({ min: 100, max: 5000 }),
+    },
+
+    rewardType: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.string().required(),
+      },
+      factory: faker => faker.helpers.arrayElement(['DISCOUNT', 'FREE_ITEM', 'PRIORITY_SERVICE']),
+    },
+
+    discountPercentage: {
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0).max(100),
+      },
+      factory: faker => faker.helpers.maybe(() => faker.number.int({ min: 5, max: 50 }), { probability: 0.6 }),
+    },
+
+    freeProductId: {
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.helpers.maybe(() => faker.string.uuid(), { probability: 0.4 }),
+    },
+
+    isActive: {
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.boolean(),
+      },
+      factory: faker => faker.datatype.boolean({ probability: 0.9 }), // 90% active
+    },
+
+    expiryDays: {
+      order: 8,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.helpers.arrayElement([7, 14, 30, 60, 90]),
+    },
+
+    imageUrl: {
+      order: 9,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(255),
+      },
+      factory: faker => faker.image.url().substring(0, 255),
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/app/Models/commerce/Manufacturer.ts

@@ -0,0 +1,84 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'Manufacturer',
+  table: 'manufacturers',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'manufacturer', 'description', 'country', 'featured'],
+      searchable: ['manufacturer', 'description', 'country'],
+      sortable: ['manufacturer', 'country', 'createdAt', 'updatedAt'],
+      filterable: ['country', 'featured'],
+    },
+
+    useSeeder: {
+      count: 30,
+    },
+
+    useApi: {
+      uri: 'product-manufacturers',
+    },
+
+    observe: true,
+  },
+
+  hasMany: ['Product'],
+
+  attributes: {
+    manufacturer: {
+      unique: true,
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(100),
+        message: {
+          max: 'Manufacturer name must have a maximum of 100 characters',
+        },
+      },
+      factory: faker => `${faker.company.name()} ${faker.string.alphanumeric(6)}`,
+    },
+
+    description: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(2000),
+        message: {
+          max: 'Description must have a maximum of 2000 characters',
+        },
+      },
+      factory: faker => `${faker.company.catchPhrase()}. ${faker.company.buzzPhrase()}`,
+    },
+
+    country: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(100),
+        message: {
+          max: 'Country must have a maximum of 100 characters',
+        },
+      },
+      factory: faker => faker.location.country(),
+    },
+
+    featured: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.boolean(),
+      },
+      factory: faker => faker.datatype.boolean({ probability: 0.2 }),
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/app/Models/commerce/Order.ts

@@ -0,0 +1,142 @@
+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',
+    },
+
+    observe: true,
+  },
+
+  hasMany: ['OrderItem', 'Payment', 'LicenseKey'],
+  belongsTo: ['Customer', 'Coupon'],
+
+  attributes: {
+    status: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().required(),
+      },
+      factory: faker => faker.helpers.arrayElement(['PENDING', 'PREPARING', 'READY', 'DELIVERED', 'CANCELED']),
+    },
+
+    totalAmount: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(0),
+      },
+      factory: faker => faker.number.int({ min: 100, max: 2000 }),
+    },
+
+    taxAmount: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.number.int({ min: 10, max: 200 }),
+    },
+
+    discountAmount: {
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.number.int({ min: 0, max: 150 }),
+    },
+
+    deliveryFee: {
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.number.int({ min: 0, max: 100 }),
+    },
+
+    tipAmount: {
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.number.int({ min: 0, max: 200 }),
+    },
+
+    orderType: {
+      order: 8,
+      fillable: true,
+      validation: {
+        rule: schema.string().required(),
+      },
+      factory: faker => faker.helpers.arrayElement(['DINE_IN', 'TAKEOUT', 'DELIVERY']),
+    },
+
+    deliveryAddress: {
+      order: 9,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.location.streetAddress(),
+    },
+
+    specialInstructions: {
+      order: 10,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.helpers.maybe(() => faker.lorem.sentence(), { probability: 0.3 }),
+    },
+
+    estimatedDeliveryTime: {
+      order: 11,
+      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()
+      },
+    },
+
+    appliedCouponId: {
+      order: 12,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.helpers.maybe(() => faker.string.uuid(), { probability: 0.2 }),
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/app/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/app/Models/commerce/Payment.ts

@@ -0,0 +1,163 @@
+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',
+    },
+
+    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.string().required(),
+      },
+      factory: faker => faker.helpers.arrayElement([
+        'creditCard',
+        'debitCard',
+        'paypal',
+        'applePay',
+        'googlePay',
+        'bankTransfer',
+        'giftCard',
+      ]),
+    },
+
+    status: {
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.string().required(),
+      },
+      factory: faker => faker.helpers.arrayElement([
+        'pending',
+        'processing',
+        'completed',
+        'failed',
+        'refunded',
+        'partiallyRefunded',
+      ]),
+    },
+
+    currency: {
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.string().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.finance.creditCardNumber('####'), { 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,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.helpers.maybe(() => faker.number.int({ min: 500, max: 10000 }), { probability: 0.2 }),
+    },
+
+    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/app/Models/commerce/PrintDevice.ts

@@ -0,0 +1,117 @@
+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',
+    },
+
+    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,
+      validation: {
+        rule: schema.unix().required(),
+        message: {
+          invalid: 'Invalid timestamp format',
+        },
+      },
+      factory: faker => faker.date.recent().getTime(),
+    },
+
+    printCount: {
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(0),
+        message: {
+          min: 'Print count cannot be negative',
+        },
+      },
+      factory: faker => faker.number.int({ min: 0, max: 1000 }),
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)