@stacksjs/orm 0.72.16 → 0.72.18

package/dist/models/commerce/WaitlistProduct.ts

@@ -0,0 +1,151 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'WaitlistProduct',
+  table: 'waitlist_products',
+  primaryKey: 'id',
+  autoIncrement: true,
+  belongsTo: ['Product', 'Customer'],
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'name', 'email', 'phone', 'partySize', 'notificationPreference', 'source', 'notes', 'status'],
+      searchable: ['name', 'email', 'phone', 'source'],
+      sortable: ['name', 'partySize', 'createdAt', 'updatedAt', 'status'],
+      filterable: ['notificationPreference', 'source', 'status'],
+    },
+
+    useSeeder: {
+      count: 10,
+    },
+
+    useApi: {
+      uri: 'waitlist-products',
+      routes: ['index', 'store', 'show', 'update', 'destroy'],
+      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(),
+    },
+
+    email: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().email().max(255),
+        message: {
+          max: 'Email must have a maximum of 255 characters',
+        },
+      },
+      factory: faker => faker.internet.email(),
+    },
+
+    phone: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(100),
+        message: {
+          max: 'Phone number must have a maximum of 100 characters',
+        },
+      },
+      factory: faker => faker.phone.number(),
+    },
+
+    quantity: {
+      order: 4,
+      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: 20 }),
+    },
+
+    notificationPreference: {
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['sms', 'email', 'both']).required(),
+      },
+      factory: faker => faker.helpers.arrayElement(['sms', 'email', 'both']),
+    },
+
+    source: {
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(100),
+        message: {
+          max: 'Source must have a maximum of 100 characters',
+        },
+      },
+      factory: faker => faker.helpers.arrayElement(['website', 'social_media', 'in-store', 'email', 'app', 'referral', 'other']),
+    },
+
+    notes: {
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(500),
+      },
+      factory: faker => faker.lorem.paragraph(),
+    },
+
+    status: {
+      default: 'waiting',
+      order: 8,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['waiting', 'purchased', 'notified', 'cancelled']).required(),
+      },
+      factory: faker => faker.helpers.arrayElement(['waiting', 'purchased', 'notified', 'cancelled']),
+    },
+
+    notifiedAt: {
+      order: 9,
+      fillable: true,
+      validation: {
+        rule: schema.date(),
+      },
+      factory: faker => faker.date.future().toISOString().slice(0, 19).replace('T', ' '),
+    },
+    purchasedAt: {
+      order: 10,
+      fillable: true,
+      validation: {
+        rule: schema.date(),
+      },
+      factory: faker => faker.date.future().toISOString().slice(0, 19).replace('T', ' '),
+    },
+    cancelledAt: {
+      order: 11,
+      fillable: true,
+      validation: {
+        rule: schema.date(),
+      },
+      factory: faker => faker.date.future().toISOString().slice(0, 19).replace('T', ' '),
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/dist/models/commerce/WaitlistRestaurant.ts

@@ -0,0 +1,189 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'WaitlistRestaurant',
+  table: 'waitlist_restaurants',
+  primaryKey: 'id',
+  autoIncrement: true,
+  belongsTo: ['Customer'],
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSearch: {
+      displayable: ['id', 'name', 'email', 'phone', 'partySize', 'checkInTime', 'tablePreference', 'status', 'quotedWaitTime', 'actualWaitTime', 'queuePosition'],
+      searchable: ['name', 'email', 'phone'],
+      sortable: ['name', 'partySize', 'checkInTime', 'createdAt', 'updatedAt', 'status', 'queuePosition'],
+      filterable: ['tablePreference', 'status'],
+    },
+
+    useSeeder: {
+      count: 10,
+    },
+
+    useApi: {
+      uri: 'waitlist-restaurants',
+      routes: ['index', 'store', 'show', 'update', 'destroy'],
+      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(),
+    },
+
+    email: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().email().max(255),
+        message: {
+          max: 'Email must have a maximum of 255 characters',
+        },
+      },
+      factory: faker => faker.internet.email(),
+    },
+
+    phone: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(100),
+        message: {
+          max: 'Phone number must have a maximum of 100 characters',
+        },
+      },
+      factory: faker => faker.phone.number(),
+    },
+
+    partySize: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(1),
+        message: {
+          min: 'Party size must be at least 1',
+        },
+      },
+      factory: faker => faker.number.int({ min: 1, max: 20 }),
+    },
+
+    checkInTime: {
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp().required(),
+      },
+      factory: (faker) => {
+        const date = faker.date.future()
+        return date.toISOString().slice(0, 19).replace('T', ' ')
+      },
+    },
+
+    tablePreference: {
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['indoor', 'bar', 'booth', 'no_preference']).required(),
+      },
+      factory: faker => faker.helpers.arrayElement(['indoor', 'bar', 'booth', 'no_preference']),
+    },
+
+    status: {
+      default: 'waiting',
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['waiting', 'seated', 'cancelled', 'no_show']).required(),
+      },
+      factory: faker => faker.helpers.arrayElement(['waiting', 'seated', 'cancelled', 'no_show']),
+    },
+
+    quoted_wait_time: {
+      order: 8,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(0),
+        message: {
+          min: 'Quoted wait time must be at least 0 minutes',
+        },
+      },
+      factory: faker => faker.number.int({ min: 0, max: 120 }),
+    },
+
+    actual_wait_time: {
+      order: 9,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+        message: {
+          min: 'Actual wait time must be at least 0 minutes',
+        },
+      },
+      factory: faker => faker.helpers.maybe(() => faker.number.int({ min: 0, max: 180 }), { probability: 0.7 }),
+    },
+
+    queue_position: {
+      order: 10,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(1),
+        message: {
+          min: 'Queue position must be at least 1',
+        },
+      },
+      factory: faker => faker.helpers.maybe(() => faker.number.int({ min: 1, max: 50 }), { probability: 0.7 }),
+    },
+
+    seatedAt: {
+      order: 11,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp(),
+      },
+      factory: (faker) => {
+        const date = faker.date.future()
+        return date.toISOString().slice(0, 19).replace('T', ' ')
+      },
+    },
+
+    noShowAt: {
+      order: 12,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp(),
+      },
+      factory: (faker) => {
+        const date = faker.date.future()
+        return date.toISOString().slice(0, 19).replace('T', ' ')
+      },
+    },
+
+    cancelledAt: {
+      order: 13,
+      fillable: true,
+      validation: {
+        rule: schema.timestamp(),
+      },
+      factory: (faker) => {
+        const date = faker.date.future()
+        return date.toISOString().slice(0, 19).replace('T', ' ')
+      },
+    },
+  },
+
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/dist/models/realtime/Websocket.ts

@@ -0,0 +1,78 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'Websocket',
+  table: 'websockets',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useTimestamps: true,
+    useSeeder: {
+      count: 20,
+    },
+    useApi: {
+      uri: 'websockets',
+      routes: ['index', 'store', 'show'],
+      middleware: ['auth'],
+    },
+    observe: true,
+  },
+
+  attributes: {
+    type: {
+      required: true,
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['disconnection', 'error', 'success']),
+        message: {
+          in: 'Type must be one of: disconnection, error, success',
+        },
+      },
+      factory: faker => faker.helpers.arrayElement(['success', 'success', 'success', 'disconnection', 'error']),
+    },
+
+    socket: {
+      required: true,
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().min(1).max(255),
+        message: {
+          min: 'Socket identifier must be provided',
+          max: 'Socket identifier must not exceed 255 characters',
+        },
+      },
+      factory: faker => faker.string.alphanumeric(20),
+    },
+
+    details: {
+      required: true,
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.string().min(1).max(1000),
+        message: {
+          min: 'Details must be provided',
+          max: 'Details must not exceed 1000 characters',
+        },
+      },
+      factory: faker => faker.lorem.sentence(),
+    },
+
+    time: {
+      required: true,
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.number(),
+        message: {
+          date: 'Time must be a valid timestamp',
+        },
+      },
+      factory: faker => faker.date.recent().getTime(),
+    },
+  },
+} as const)

package/dist/password-policy.ts

@@ -0,0 +1,46 @@
+/**
+ * One password policy, in one place (stacksjs/stacks#2226).
+ *
+ * The framework shipped three numbers for one product concept: `RegisterAction`
+ * and `LoginAction` accepted six characters, the `User` model declared six, and
+ * `PasswordResetAction` hand-checked eight with `password.length < 8` — not in a
+ * `validations:` block at all, so it could not even be read by the machinery
+ * that reads the others.
+ *
+ * Apps then retyped the rule again in the browser, because an Action's
+ * `validations:` was unreachable from a template. That is how a real app ended
+ * up refusing a 7-character password in the browser that `POST /register` would
+ * have accepted.
+ *
+ * Change the policy here and every declaration follows. An app that wants a
+ * different one edits this file, which is scaffolded into it.
+ */
+
+/**
+ * Minimum length for a NEW password.
+ *
+ * Eight, because that is what the password-reset path already enforced and it
+ * is the weaker of the two that was actually protecting anything. Raising the
+ * registration minimum only affects accounts created from now on.
+ */
+export const PASSWORD_MIN_LENGTH = 8
+
+/**
+ * Maximum length. Also the `varchar` width the User model's column derives
+ * from, so lowering it is a migration, not just a rule change.
+ */
+export const PASSWORD_MAX_LENGTH = 255
+
+export const PASSWORD_POLICY_MESSAGE
+  = `Password must be between ${PASSWORD_MIN_LENGTH} and ${PASSWORD_MAX_LENGTH} characters.`
+
+/**
+ * What a sign-in must require: that a password was supplied, and nothing more.
+ *
+ * Deliberately NOT the policy above. Applying a creation rule to authentication
+ * locks out every account created under a previous, shorter policy — they would
+ * get a 422 before their credentials were ever checked, with a message telling
+ * them their own password is too short. The policy belongs on the paths that
+ * SET a password.
+ */
+export const PASSWORD_PRESENCE_MESSAGE = 'Password is required.'

package/package.json

@@ -2,7 +2,7 @@
   "name": "@stacksjs/orm",
   "type": "module",
   "sideEffects": false,
-  "version": "0.72.16",
+  "version": "0.72.18",
   "description": "The Stacks ORM integration",
   "author": "Chris Breuer",
   "contributors": [
@@ -67,9 +67,9 @@
     "bun-query-builder": "^0.2.44"
   },
   "devDependencies": {
-    "@stacksjs/config": "0.72.16",
+    "@stacksjs/config": "0.72.18",
     "better-dx": "^0.2.23",
-    "@stacksjs/query-builder": "0.72.16",
-    "@stacksjs/types": "0.72.16"
+    "@stacksjs/query-builder": "0.72.18",
+    "@stacksjs/types": "0.72.18"
   }
 }