@stacksjs/orm 0.72.16 → 0.72.18

package/dist/models/commerce/DriverPing.ts

@@ -0,0 +1,103 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * One position fix from a driver's device.
+ *
+ * The append-only history behind `drivers.latitude/longitude`. A tracking map
+ * needs the present position, but everything else about a delivery needs the
+ * series: drawing the path already travelled, replaying a disputed drop,
+ * measuring how long a stop actually took, and deriving an ETA from recent
+ * speed rather than straight-line distance.
+ *
+ * Deliberately not `useSearch` (indexing a row every few seconds is pointless
+ * and expensive) and not `useApi` (writes come through
+ * `recordDriverPing`, which does the fan-out, and reads are scoped to a
+ * route). `usePrunable` keeps the table from growing without bound.
+ */
+export default defineModel({
+  name: 'DriverPing',
+  table: 'driver_pings',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSeeder: { count: 0 },
+  },
+
+  belongsTo: ['Driver', 'DeliveryRoute'],
+
+  attributes: {
+    latitude: {
+      order: 1,
+      required: true,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(-90).max(90),
+        message: {
+          min: 'Latitude must be between -90 and 90',
+          max: 'Latitude must be between -90 and 90',
+        },
+      },
+      factory: faker => faker.location.latitude(),
+    },
+
+    longitude: {
+      order: 2,
+      required: true,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(-180).max(180),
+        message: {
+          min: 'Longitude must be between -180 and 180',
+          max: 'Longitude must be between -180 and 180',
+        },
+      },
+      factory: faker => faker.location.longitude(),
+    },
+
+    /** Degrees clockwise from true north. */
+    heading: {
+      order: 3,
+      fillable: true,
+      validation: { rule: schema.number().min(0).max(360) },
+      factory: faker => faker.number.int({ min: 0, max: 359 }),
+    },
+
+    /** Metres per second. */
+    speed: {
+      order: 4,
+      fillable: true,
+      default: 0,
+      validation: { rule: schema.number().min(0) },
+      factory: faker => faker.number.int({ min: 0, max: 30 }),
+    },
+
+    /**
+     * Reported horizontal accuracy in metres. Worth keeping: a fix with 800m
+     * of error should move the marker differently than one with 5m, and
+     * without this the map cannot tell them apart.
+     */
+    accuracy: {
+      order: 5,
+      fillable: true,
+      validation: { rule: schema.number().min(0) },
+      factory: faker => faker.number.int({ min: 3, max: 60 }),
+    },
+
+    /**
+     * When the device took the fix, which is not when the server received it.
+     * A driver through a tunnel sends five fixes at once on the far side, and
+     * ordering them by arrival draws a path that never happened.
+     */
+    recordedAt: {
+      order: 6,
+      required: true,
+      fillable: true,
+      validation: { rule: schema.timestamp().required() },
+      factory: () => new Date().toISOString(),
+    },
+  },
+} as const)

package/dist/models/commerce/GiftCard.ts

@@ -0,0 +1,195 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'GiftCard',
+  table: 'gift_cards',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'code', 'initialBalance', 'currentBalance', 'status', 'expiryDate', 'isActive'],
+      searchable: ['code', 'recipientName', 'recipientEmail', 'purchaserId'],
+      sortable: ['createdAt', 'expiryDate', 'initialBalance', 'currentBalance'],
+      filterable: ['status', 'isDigital', 'isReloadable', 'isActive'],
+    },
+
+    useSeeder: {
+      count: 20,
+    },
+
+    useApi: {
+      uri: 'gift-cards',
+      middleware: ['auth'],
+    },
+
+    observe: true,
+  },
+
+  belongsTo: ['Customer'],
+  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(12).toUpperCase(),
+    },
+
+    initialBalance: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(1),
+      },
+      factory: faker => faker.number.int({ min: 100, max: 2000 }),
+    },
+
+    currentBalance: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(0),
+      },
+      factory: () => 1,
+    },
+
+    currency: {
+      order: 4,
+      fillable: true,
+      default: 'USD',
+      validation: {
+        rule: schema.string().required().max(3),
+      },
+      factory: faker => faker.helpers.arrayElement(['USD', 'EUR', 'GBP', 'CAD', 'AUD']),
+    },
+
+    status: {
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['ACTIVE', 'USED', 'EXPIRED', 'DEACTIVATED']).required(),
+      },
+      factory: faker => faker.helpers.arrayElement(['ACTIVE', 'USED', 'EXPIRED', 'DEACTIVATED']),
+    },
+
+    purchaser_id: {
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.string.uuid(),
+    },
+
+    recipient_email: {
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.string().email(),
+      },
+      factory: faker => faker.helpers.maybe(() => faker.internet.email(), { probability: 0.7 }),
+    },
+
+    recipientName: {
+      order: 8,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.helpers.maybe(() => faker.person.fullName(), { probability: 0.6 }),
+    },
+
+    personalMessage: {
+      order: 9,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.helpers.maybe(() => faker.lorem.sentence(), { probability: 0.4 }),
+    },
+
+    isDigital: {
+      default: false,
+      order: 10,
+      fillable: true,
+      validation: {
+        rule: schema.boolean(),
+      },
+      factory: faker => faker.datatype.boolean({ probability: 0.8 }), // 80% digital
+    },
+
+    isReloadable: {
+      default: false,
+      order: 11,
+      fillable: true,
+      validation: {
+        rule: schema.boolean(),
+      },
+      factory: faker => faker.datatype.boolean({ probability: 0.3 }), // 30% reloadable
+    },
+
+    isActive: {
+      order: 12,
+      fillable: true,
+      default: true,
+      validation: {
+        rule: schema.boolean(),
+      },
+      factory: faker => faker.datatype.boolean({ probability: 0.9 }), // 90% active
+    },
+
+    expiryDate: {
+      order: 13,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp(),
+        message: {
+          timestamp: 'Expiry date must be a valid timestamp',
+        },
+      },
+      factory: (faker) => {
+        const date = faker.date.future()
+        return date.toISOString().slice(0, 19).replace('T', ' ')
+      },
+    },
+
+    lastUsedDate: {
+      order: 14,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp(),
+        message: {
+          timestamp: 'Last used date must be a valid timestamp',
+        },
+      },
+      factory: (faker) => {
+        const date = faker.date.future()
+        return date.toISOString().slice(0, 19).replace('T', ' ')
+      },
+    },
+
+    templateId: {
+      order: 15,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.helpers.maybe(() => faker.string.uuid(), { probability: 0.5 }),
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/dist/models/commerce/LicenseKey.ts

@@ -0,0 +1,89 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'LicenseKey',
+  table: 'license_keys',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'key', 'template', 'expiryDate', 'status'],
+      searchable: ['key'],
+      sortable: ['template', 'expiryDate', 'status', 'createdAt', 'updatedAt'],
+      filterable: ['status', 'template'],
+    },
+
+    useSeeder: {
+      count: 10,
+    },
+
+    useApi: {
+      uri: 'license-keys',
+      middleware: ['auth'],
+    },
+
+    observe: true,
+  },
+
+  belongsTo: ['Customer', 'Product', 'Order'],
+
+  attributes: {
+    key: {
+      unique: true,
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().matches(/^[A-Z0-9]{4}(?:-[A-Z0-9]{4}){4}$/).required(),
+        message: {
+          matches: 'License key must be in the format XXXX-XXXX-XXXX-XXXX-XXXX',
+        },
+      },
+      factory: (faker) => {
+        const generateBlock = () => faker.string.alphanumeric({ length: 4, casing: 'upper' })
+        return `${generateBlock()}-${generateBlock()}-${generateBlock()}-${generateBlock()}-${generateBlock()}`
+      },
+    },
+
+    template: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['Standard License', 'Premium License', 'Enterprise License']).required(),
+      },
+      factory: faker => faker.helpers.arrayElement(['Standard License', 'Premium License', 'Enterprise License']),
+    },
+
+    expiryDate: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp().required(),
+        message: {
+          timestamp: 'Expiry date must be a valid timestamp',
+        },
+      },
+      factory: (faker) => {
+        const date = faker.date.future()
+        return date.toISOString().slice(0, 19).replace('T', ' ')
+      },
+    },
+
+    status: {
+      default: 'unassigned',
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['active', 'inactive', 'unassigned']),
+      },
+      factory: faker => faker.helpers.arrayElement(['active', 'inactive', 'unassigned']),
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/dist/models/commerce/LoyaltyPoint.ts

@@ -0,0 +1,108 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'LoyaltyPoint',
+  table: 'loyalty_points',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'walletId', 'points', 'source', 'description', 'expiryDate', 'isUsed'],
+      searchable: ['description', 'source', 'sourceReferenceId'],
+      sortable: ['createdAt', 'points', 'expiryDate'],
+      filterable: ['walletId', 'source', 'isUsed'],
+    },
+
+    useSeeder: {
+      count: 50,
+    },
+
+    useApi: {
+      uri: 'loyalty-points',
+      middleware: ['auth'],
+    },
+
+    observe: true,
+  },
+
+  attributes: {
+    walletId: {
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().required(),
+      },
+      factory: faker => faker.string.uuid(),
+    },
+
+    points: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(1),
+      },
+      factory: faker => faker.number.int({ min: 1, max: 500 }),
+    },
+
+    source: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.helpers.arrayElement(['ORDER', 'PROMOTION', 'REFERRAL', 'MANUAL']),
+    },
+
+    sourceReferenceId: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.string.uuid(),
+    },
+
+    description: {
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.helpers.arrayElement([
+        `Points earned from order #${faker.string.alphanumeric(8).toUpperCase()}`,
+        `Bonus points from promotion`,
+        `Referral bonus for inviting a friend`,
+        `Manual adjustment by administrator`,
+      ]),
+    },
+
+    expiryDate: {
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp(),
+      },
+      factory: (faker) => {
+        const date = faker.date.future()
+        return date.toISOString().slice(0, 19).replace('T', ' ')
+      },
+    },
+
+    isUsed: {
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.boolean(),
+      },
+      factory: faker => faker.datatype.boolean({ probability: 0.3 }), // 30% chance of being used
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/dist/models/commerce/LoyaltyReward.ts

@@ -0,0 +1,129 @@
+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: {
+      // 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: '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/dist/models/commerce/Manufacturer.ts

@@ -0,0 +1,90 @@
+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: {
+      // 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-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: {
+      default: false,
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.boolean(),
+      },
+      factory: faker => faker.datatype.boolean({ probability: 0.2 }),
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)