@stacksjs/orm 0.72.16 → 0.72.18

package/dist/models/commerce/Customer.ts

@@ -0,0 +1,132 @@
+import type { Attributes } from '@stacksjs/types'
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'Customer',
+  table: 'customers',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'name', 'email', 'phone', 'status'],
+      searchable: ['name', 'email', 'phone'],
+      sortable: ['name', 'totalSpent', 'lastOrder', 'created_at', 'updated_at'],
+      filterable: ['status'],
+    },
+
+    useSeeder: {
+      count: 20,
+    },
+
+    useApi: {
+      uri: 'customers',
+      middleware: ['auth'],
+    },
+
+    observe: true,
+  },
+
+  hasMany: ['Order', 'GiftCard', 'Review', 'Payment', 'LicenseKey', 'WaitlistProduct', 'WaitlistRestaurant'],
+  belongsTo: ['User'],
+
+  attributes: {
+    name: {
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().min(2).max(255),
+        message: {
+          min: 'Name must have a minimum of 2 characters',
+          max: 'Name must have a maximum of 255 characters',
+        },
+      },
+      factory: faker => faker.person.fullName(),
+    },
+
+    email: {
+      unique: true,
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().email(),
+        message: {
+          email: 'Email must be a valid email address',
+        },
+      },
+      factory: faker => faker.internet.email(),
+    },
+
+    phone: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(50),
+        message: {
+          max: 'Phone number must have a maximum of 50 characters',
+        },
+      },
+      factory: faker => faker.phone.number(),
+    },
+
+    totalSpent: {
+      default: 0,
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+        message: {
+          min: 'Total spent cannot be negative',
+        },
+      },
+      factory: faker => faker.number.int({ min: 0, max: 2000 }),
+    },
+
+    lastOrder: {
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.date.recent({ days: 60 }).toISOString().split('T')[0],
+    },
+
+    status: {
+      default: 'Active',
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['Active', 'Inactive']).required(),
+        message: {
+          enum: 'Status must be either Active or Inactive',
+        },
+      },
+      factory: faker => faker.helpers.arrayElement(['Active', 'Inactive']),
+    },
+
+    avatar: {
+      order: 8,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().url(),
+        message: {
+          url: 'Avatar must be a valid URL',
+        },
+      },
+      factory: faker => faker.image.avatar(),
+    },
+  },
+
+  get: {
+    fullContactInfo: (attributes: Attributes) => {
+      return `${attributes.name} (${attributes.email}, ${attributes.phone})`
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/dist/models/commerce/DeliveryRoute.ts

@@ -0,0 +1,127 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'DeliveryRoute',
+  table: 'delivery_routes',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'driver', 'vehicle', 'stops', 'deliveryTime', 'totalDistance', 'lastActive'],
+      searchable: ['driver', 'vehicle'],
+      sortable: ['stops', 'deliveryTime', 'totalDistance', 'lastActive', 'createdAt', 'updatedAt'],
+      filterable: ['driver', 'vehicle'],
+    },
+
+    useSeeder: {
+      count: 5,
+    },
+
+    useApi: {
+      uri: 'delivery-routes',
+      middleware: ['auth'],
+    },
+
+    observe: true,
+  },
+
+  belongsTo: ['Driver'],
+  hasMany: ['DeliveryStop', 'DriverPing'],
+
+  attributes: {
+    driver: {
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(255),
+      },
+      factory: faker => faker.person.fullName(),
+    },
+
+    vehicle: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(255),
+      },
+      factory: faker => faker.vehicle.vehicle(),
+    },
+
+    stops: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(0),
+      },
+      factory: faker => faker.number.int({ min: 1, max: 20 }),
+    },
+
+    deliveryTime: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(0),
+      },
+      factory: faker => faker.number.int({ min: 30, max: 480 }), // 30 minutes to 8 hours
+    },
+
+    totalDistance: {
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(0),
+      },
+      factory: faker => faker.number.int({ min: 5, max: 200 }), // 5 to 200 miles
+    },
+
+    lastActive: {
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.unix().required(),
+      },
+      factory: faker => faker.date.recent().getTime(),
+    },
+
+    /*
+     * Route lifecycle. `stops` and `totalDistance` describe a route that has
+     * already run; a route being followed right now needs to say so, because
+     * that is the difference between a tracking map that draws a moving
+     * vehicle and one that draws yesterday's.
+     */
+    status: {
+      order: 7,
+      fillable: true,
+      default: 'planned',
+      validation: {
+        rule: schema.enum(['planned', 'active', 'completed', 'cancelled']),
+        message: {
+          enum: 'Status must be one of: planned, active, completed, cancelled',
+        },
+      },
+      factory: faker => faker.helpers.arrayElement(['planned', 'active', 'completed']),
+    },
+
+    startedAt: {
+      order: 8,
+      fillable: true,
+      validation: { rule: schema.timestamp() },
+      factory: () => null,
+    },
+
+    completedAt: {
+      order: 9,
+      fillable: true,
+      validation: { rule: schema.timestamp() },
+      factory: () => null,
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/dist/models/commerce/DeliveryStop.ts

@@ -0,0 +1,166 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * One address on a delivery route.
+ *
+ * `DeliveryRoute` records that a route happened and how far it went; this is
+ * the route itself. Without it `stops` is an integer, which is enough to bill
+ * a driver and not nearly enough to tell a customer where their order is: the
+ * link from an order to the vehicle carrying it runs through here.
+ *
+ * Sequence is the planned order. `status` is what actually happened, which
+ * diverges the moment a driver skips a building and comes back to it.
+ */
+export default defineModel({
+  name: 'DeliveryStop',
+  table: 'delivery_stops',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+
+    useSearch: {
+      displayable: ['id', 'sequence', 'status', 'address', 'etaAt'],
+      searchable: ['address', 'recipientName'],
+      sortable: ['sequence', 'etaAt', 'createdAt'],
+      filterable: ['status', 'deliveryRouteId'],
+    },
+
+    useSeeder: { count: 0 },
+
+    useApi: {
+      // A stop names a customer and their address. Staff only, both ways.
+      // Customers reach their own stop through the order tracking route,
+      // which authorises on the order's tracking token instead.
+      middleware: ['auth'],
+      uri: 'delivery-stops',
+    },
+
+    observe: true,
+  },
+
+  belongsTo: ['DeliveryRoute', 'Order'],
+
+  attributes: {
+    /** Position in the planned run, 1-based. */
+    sequence: {
+      order: 1,
+      required: true,
+      fillable: true,
+      default: 1,
+      validation: {
+        rule: schema.number().required().min(1),
+        message: { min: 'Sequence starts at 1' },
+      },
+      factory: faker => faker.number.int({ min: 1, max: 20 }),
+    },
+
+    status: {
+      order: 2,
+      required: true,
+      fillable: true,
+      default: 'pending',
+      validation: {
+        rule: schema.enum(['pending', 'en_route', 'arrived', 'completed', 'failed', 'skipped']),
+        message: {
+          enum: 'Status must be one of: pending, en_route, arrived, completed, failed, skipped',
+        },
+      },
+      factory: faker => faker.helpers.arrayElement(['pending', 'en_route', 'completed']),
+    },
+
+    address: {
+      order: 3,
+      required: true,
+      fillable: true,
+      validation: { rule: schema.string().required().max(255) },
+      factory: faker => faker.location.streetAddress(true),
+    },
+
+    /**
+     * Geocoded destination. Nullable because an address can arrive before it
+     * resolves, and a stop with no coordinates is still a stop the driver can
+     * complete; it just cannot be drawn.
+     */
+    latitude: {
+      order: 4,
+      fillable: true,
+      validation: { rule: schema.number().min(-90).max(90) },
+      factory: faker => faker.location.latitude(),
+    },
+
+    longitude: {
+      order: 5,
+      fillable: true,
+      validation: { rule: schema.number().min(-180).max(180) },
+      factory: faker => faker.location.longitude(),
+    },
+
+    recipientName: {
+      order: 6,
+      fillable: true,
+      validation: { rule: schema.string().max(255) },
+      factory: faker => faker.person.fullName(),
+    },
+
+    recipientPhone: {
+      order: 7,
+      fillable: true,
+      validation: { rule: schema.string().max(40) },
+      factory: faker => faker.phone.number(),
+    },
+
+    /** Current estimate, rewritten as the driver moves. */
+    etaAt: {
+      order: 8,
+      fillable: true,
+      validation: { rule: schema.timestamp() },
+      factory: () => new Date(Date.now() + 25 * 60_000).toISOString(),
+    },
+
+    /**
+     * When the customer was told the driver was close.
+     *
+     * The latch that makes "nearly there" fire once. Without it every ping
+     * inside the radius sends another text, which is roughly one text every
+     * four seconds for the last four hundred metres.
+     */
+    notifiedNearbyAt: {
+      order: 9,
+      fillable: true,
+      validation: { rule: schema.timestamp() },
+      factory: () => null,
+    },
+
+    /** When the driver crossed the arrival radius. */
+    arrivedAt: {
+      order: 10,
+      fillable: true,
+      validation: { rule: schema.timestamp() },
+      factory: () => null,
+    },
+
+    /** When the handover finished. Together with `arrivedAt`, dwell time. */
+    completedAt: {
+      order: 11,
+      fillable: true,
+      validation: { rule: schema.timestamp() },
+      factory: () => null,
+    },
+
+    /** Why a stop failed, or anything the driver needs to record. */
+    notes: {
+      order: 12,
+      fillable: true,
+      validation: { rule: schema.string().max(1000) },
+      factory: () => '',
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/dist/models/commerce/DigitalDelivery.ts

@@ -0,0 +1,106 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'DigitalDelivery',
+  table: 'digital_deliveries',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'name', 'description', 'downloadLimit', 'expiryDays', 'status'],
+      searchable: ['name', 'description'],
+      sortable: ['name', 'downloadLimit', 'expiryDays', 'status', 'createdAt', 'updatedAt'],
+      filterable: ['status'],
+    },
+
+    useSeeder: {
+      count: 10,
+    },
+
+    useApi: {
+      uri: 'digital-deliveries',
+      middleware: ['auth'],
+    },
+
+    observe: true,
+  },
+
+  attributes: {
+    name: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(255),
+        message: {
+          max: 'Name must have a maximum of 255 characters',
+        },
+      },
+      factory: faker => faker.commerce.productName(),
+    },
+
+    description: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.string().required(),
+      },
+      factory: faker => faker.commerce.productDescription(),
+    },
+
+    downloadLimit: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.number.int({ min: 1, max: 100 }),
+    },
+
+    expiryDays: {
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(0),
+      },
+      factory: faker => faker.number.int({ min: 1, max: 365 }),
+    },
+
+    requiresLogin: {
+      default: false,
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.boolean(),
+      },
+      factory: faker => faker.datatype.boolean(),
+    },
+
+    automaticDelivery: {
+      default: false,
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.boolean(),
+      },
+      factory: faker => faker.datatype.boolean(),
+    },
+
+    status: {
+      default: 'active',
+      order: 8,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['active', 'inactive']),
+      },
+      factory: faker => faker.helpers.arrayElement(['active', 'inactive']),
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/dist/models/commerce/Driver.ts

@@ -0,0 +1,168 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'Driver',
+  table: 'drivers',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  belongsTo: ['User'],
+  hasMany: ['DeliveryRoute', 'DriverPing'],
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'name', 'phone', 'vehicleNumber', 'license', 'status'],
+      searchable: ['name', 'phone', 'vehicleNumber', 'license'],
+      sortable: ['name', 'status', 'createdAt', 'updatedAt'],
+      filterable: ['status'],
+    },
+
+    useSeeder: {
+      count: 10,
+    },
+
+    useApi: {
+      uri: 'drivers',
+      middleware: ['auth'],
+    },
+
+    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.person.fullName(),
+    },
+
+    phone: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(255),
+        message: {
+          max: 'Phone number must have a maximum of 255 characters',
+        },
+      },
+      factory: faker => faker.phone.number(),
+    },
+
+    vehicleNumber: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(255),
+        message: {
+          max: 'Vehicle number must have a maximum of 255 characters',
+        },
+      },
+      factory: faker => faker.vehicle.vrm(),
+    },
+
+    license: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(255),
+        message: {
+          max: 'License number must have a maximum of 255 characters',
+        },
+      },
+      factory: faker => faker.string.alphanumeric({ length: 10, casing: 'upper' }),
+    },
+
+    status: {
+      default: 'active',
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['active', 'on_delivery', 'on_break', 'offline']),
+      },
+      factory: faker => faker.helpers.arrayElement(['active', 'on_delivery', 'on_break']),
+    },
+
+    /*
+     * Last known position.
+     *
+     * Denormalised from the `driver_pings` series on purpose: "where is this
+     * driver right now" is asked on every map frame and by every tracking
+     * page, and answering it with a MAX(recorded_at) subquery over a table
+     * that grows by a row every few seconds is the wrong shape. The series is
+     * the history; these three columns are the present.
+     */
+    latitude: {
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.number().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: 7,
+      fillable: true,
+      validation: {
+        rule: schema.number().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, so a map can rotate the marker. */
+    heading: {
+      order: 8,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0).max(360),
+      },
+      factory: faker => faker.number.int({ min: 0, max: 359 }),
+    },
+
+    /** Metres per second, as reported by the device. */
+    speed: {
+      order: 9,
+      fillable: true,
+      default: 0,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: () => 0,
+    },
+
+    /*
+     * When the last fix landed. A tracking map needs this to say "updated 4
+     * seconds ago" and, more importantly, to stop claiming a driver is at a
+     * position that is ten minutes stale.
+     */
+    lastPingAt: {
+      order: 10,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp(),
+      },
+      factory: () => new Date().toISOString(),
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)