@stacksjs/orm 0.72.16 → 0.72.18

package/dist/models/commerce/ShippingMethod.ts

@@ -0,0 +1,102 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'ShippingMethod',
+  table: 'shipping_methods',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'name', 'description', 'baseRate', 'freeShipping', 'status'],
+      searchable: ['name', 'description'],
+      sortable: ['name', 'baseRate', 'createdAt', 'updatedAt'],
+      filterable: ['status'],
+    },
+
+    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: 'shipping-methods',
+    },
+
+    observe: true,
+  },
+
+  hasMany: ['ShippingZone', 'ShippingRate'],
+
+  attributes: {
+    name: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(100),
+        message: {
+          max: 'Name must have a maximum of 100 characters',
+        },
+      },
+      factory: faker => faker.commerce.productName(),
+    },
+
+    description: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(500),
+        message: {
+          max: 'Description must have a maximum of 500 characters',
+        },
+      },
+      factory: faker => faker.lorem.paragraph(),
+    },
+
+    baseRate: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(0),
+        message: {
+          min: 'Base rate cannot be negative',
+        },
+      },
+      factory: faker => faker.number.int({ min: 500, max: 5000 }), // 5.00 to 50.00
+    },
+
+    freeShipping: {
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: (faker) => {
+        // 30% chance of being null (N/A), otherwise a minimum order amount
+        return faker.datatype.boolean({ probability: 0.3 })
+          ? null
+          : faker.number.int({ min: 5000, max: 20000 }) // 50.00 to 200.00
+      },
+    },
+
+    status: {
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['active', 'inactive', 'draft']).required(),
+      },
+      factory: faker => faker.helpers.arrayElement(['active', 'inactive', 'draft']),
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/dist/models/commerce/ShippingRate.ts

@@ -0,0 +1,79 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'ShippingRate',
+  table: 'shipping_rates',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'shipping_method_id', 'weight_from', 'weight_to', 'rate'],
+      searchable: ['shipping_method_id'],
+      sortable: ['shipping_method_id', 'weight_from', 'weight_to', 'rate', 'created_at', 'updated_at'],
+      filterable: ['shipping_method_id'],
+    },
+
+    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: 'shipping-rates',
+    },
+
+    observe: true,
+  },
+
+  belongsTo: ['ShippingMethod', 'ShippingZone'],
+
+  attributes: {
+    weightFrom: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.float().required().min(0),
+        message: {
+          min: 'Weight from cannot be negative',
+        },
+      },
+      factory: faker => faker.number.float({ min: 0, max: 10 }),
+    },
+
+    weightTo: {
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.float().required().min(0),
+        message: {
+          min: 'Weight to cannot be negative',
+        },
+      },
+      factory: faker => faker.number.float({ min: 10, max: 50 }),
+    },
+
+    rate: {
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(0),
+        message: {
+          min: 'Rate cannot be negative',
+        },
+      },
+      factory: faker => faker.number.int({ min: 500, max: 5000 }), // 5.00 to 50.00
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/dist/models/commerce/ShippingZone.ts

@@ -0,0 +1,116 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'ShippingZone',
+  table: 'shipping_zones',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'name', 'countries', 'regions', 'postalCodes', 'status'],
+      searchable: ['name'],
+      sortable: ['name', 'createdAt', 'updatedAt'],
+      filterable: ['status'],
+    },
+
+    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: 'shipping-zones',
+    },
+
+    observe: true,
+  },
+
+  belongsTo: ['ShippingMethod'],
+  hasMany: ['ShippingRate'],
+  attributes: {
+    name: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(100),
+        message: {
+          max: 'Name must have a maximum of 100 characters',
+        },
+      },
+      factory: faker => `${faker.location.country()} Zone`,
+    },
+
+    countries: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(1000),
+        message: {
+          max: 'Countries must have a maximum of 1000 characters',
+        },
+      },
+      factory: (faker) => {
+        const countriesCount = faker.number.int({ min: 1, max: 5 })
+        const countries = Array.from({ length: countriesCount }, () => faker.location.country())
+        return JSON.stringify(countries)
+      },
+    },
+
+    regions: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(500),
+        message: {
+          max: 'Regions must have a maximum of 500 characters',
+        },
+      },
+      factory: (faker) => {
+        const continents = ['North America', 'South America', 'Europe', 'Asia', 'Africa', 'Oceania', 'Antarctica']
+        const regionsCount = faker.number.int({ min: 0, max: 3 })
+        const regions = faker.helpers.arrayElements(continents, regionsCount)
+        return JSON.stringify(regions)
+      },
+    },
+
+    postalCodes: {
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(1000),
+        message: {
+          max: 'Postal codes must have a maximum of 1000 characters',
+        },
+      },
+      factory: (faker) => {
+        const codesCount = faker.number.int({ min: 0, max: 10 })
+        // Generate postal/zip codes in various formats
+        const codes = Array.from({ length: codesCount }, () => {
+          return faker.location.zipCode()
+        })
+        return JSON.stringify(codes)
+      },
+    },
+
+    status: {
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['active', 'inactive', 'draft']).required(),
+      },
+      factory: faker => faker.helpers.arrayElement(['active', 'inactive', 'draft']),
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/dist/models/commerce/TaxRate.ts

@@ -0,0 +1,167 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'TaxRate',
+  table: 'tax_rates',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'name', 'rate', 'type', 'country', 'region', 'status', 'isDefault'],
+      searchable: ['name', 'country', 'region'],
+      sortable: ['name', 'rate', 'status', 'createdAt', 'updatedAt'],
+      filterable: ['status', 'isDefault'],
+    },
+
+    useSeeder: {
+      count: 5,
+    },
+
+    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: 'tax-rates',
+    },
+
+    observe: true,
+  },
+
+  attributes: {
+    name: {
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(255),
+        message: {
+          max: 'Name must have a maximum of 255 characters',
+        },
+      },
+      factory: faker => faker.commerce.productName(),
+    },
+
+    rate: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(0).max(100),
+        message: {
+          min: 'Rate must be greater than or equal to 0',
+          max: 'Rate must be less than or equal to 100',
+        },
+      },
+      factory: faker => faker.number.int({ min: 0, max: 100 }),
+    },
+
+    type: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(100),
+        message: {
+          max: 'Type must have a maximum of 100 characters',
+        },
+      },
+      factory: faker => faker.helpers.arrayElement(['VAT', 'GST', 'Sales Tax', 'Customs Duty']),
+    },
+
+    country: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(100),
+        message: {
+          max: 'Country must have a maximum of 100 characters',
+        },
+      },
+      factory: faker => faker.location.country(),
+    },
+
+    region: {
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['North America', 'South America', 'Europe', 'Asia', 'Africa', 'Oceania', 'Antarctica']),
+      },
+      factory: faker => faker.helpers.arrayElement(['North America', 'South America', 'Europe', 'Asia', 'Africa', 'Oceania', 'Antarctica']),
+    },
+
+    status: {
+      default: 'active',
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['active', 'inactive']),
+      },
+      factory: faker => faker.helpers.arrayElement(['active', 'inactive']),
+    },
+
+    isDefault: {
+      default: false,
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.boolean(),
+      },
+      factory: () => false,
+    },
+
+    /**
+     * A stable name for this component, for code to reference.
+     *
+     * `name` is what an operator reads and edits in the dashboard, so it is
+     * the wrong thing for an application to branch on — renaming "State sales
+     * tax" to "Sales tax (CA)" should not change what gets charged. A code is
+     * the identifier that survives the rename.
+     *
+     * Free-form on purpose. What counts as a component differs by
+     * jurisdiction: `vat`, `gst`, `excise`, `city`, `eco-fee`.
+     */
+    code: {
+      order: 8,
+      fillable: true,
+      default: '',
+      validation: {
+        rule: schema.string().max(64),
+        message: {
+          max: 'Code must have a maximum of 64 characters',
+        },
+      },
+      factory: faker => faker.helpers.arrayElement(['vat', 'gst', 'sales', 'excise', 'city']),
+    },
+
+    /**
+     * Whether a qualifying exemption removes this component.
+     *
+     * Most places tax in parts, and an exemption usually lifts some of them
+     * and not others: groceries escape VAT but not a deposit levy, and a
+     * Californian medical cannabis patient is exempt from sales tax while
+     * still paying excise and the city's business tax. Modelling tax as one
+     * blended number cannot say that, so an app either over-charges the
+     * exempt customer or under-collects tax it owes.
+     *
+     * What *qualifies* is the application's business — a card, a resale
+     * certificate, a charity registration. This only records that the
+     * component is the kind that can be lifted.
+     */
+    exemptible: {
+      order: 9,
+      fillable: true,
+      default: false,
+      validation: {
+        rule: schema.boolean(),
+      },
+      factory: () => false,
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/dist/models/commerce/Transaction.ts

@@ -0,0 +1,127 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'Transaction',
+  table: 'transactions',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'orderId', 'amount', 'status', 'paymentMethod', 'createdAt'],
+      searchable: ['id', 'orderId', 'status', 'paymentMethod', 'transactionReference'],
+      sortable: ['createdAt', 'amount'],
+      filterable: ['status', 'paymentMethod'],
+    },
+
+    useSeeder: {
+      count: 20,
+    },
+
+    useApi: {
+      uri: 'transactions',
+      middleware: ['auth'],
+    },
+
+    observe: true,
+  },
+
+  belongsTo: ['Order'],
+
+  attributes: {
+    amount: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(0.01),
+      },
+      factory: faker => faker.number.int({ min: 5, max: 500 }),
+    },
+
+    status: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.string().required(),
+      },
+      factory: faker => faker.helpers.arrayElement(['PENDING', 'COMPLETED', 'FAILED', 'REFUNDED']),
+    },
+
+    paymentMethod: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.string().required(),
+      },
+      factory: faker => faker.helpers.arrayElement(['CREDIT_CARD', 'DEBIT_CARD', 'CASH', 'WALLET']),
+    },
+
+    paymentDetails: {
+      order: 5,
+      fillable: true,
+      hidden: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: (faker) => {
+        const paymentMethod = faker.helpers.arrayElement(['CREDIT_CARD', 'DEBIT_CARD', 'CASH', 'WALLET'])
+
+        let details
+        if (paymentMethod === 'CREDIT_CARD' || paymentMethod === 'DEBIT_CARD') {
+          details = {
+            last4: faker.finance.creditCardNumber('####'),
+            expiry: `${faker.date.future().getMonth() + 1}/${String(faker.date.future().getFullYear()).slice(-2)}`,
+            brand: faker.helpers.arrayElement(['Visa', 'Mastercard', 'Amex', 'Discover']),
+          }
+        }
+        else if (paymentMethod === 'WALLET') {
+          details = {
+            wallet_id: faker.string.uuid(),
+            transaction_id: faker.string.alphanumeric(12),
+          }
+        }
+        else {
+          details = {
+            receipt_number: faker.string.alphanumeric(8).toUpperCase(),
+          }
+        }
+
+        return JSON.stringify(details)
+      },
+    },
+
+    transactionReference: {
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.string.alphanumeric(16).toUpperCase(),
+    },
+
+    loyaltyPointsEarned: {
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.number.int({ min: 0, max: 100 }),
+    },
+
+    loyaltyPointsRedeemed: {
+      order: 8,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.number.int({ min: 0, max: 50 }),
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)