@stacksjs/orm 0.72.16 → 0.72.17

package/dist/models/TeamInvitation.ts

@@ -0,0 +1,159 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * A single-use invitation to join a team.
+ *
+ * The raw bearer token is only returned by the dedicated invite action and
+ * sent to the recipient. This model stores its SHA-256 digest so generated
+ * API responses and database reads cannot leak a usable invitation.
+ */
+export default defineModel({
+  name: 'TeamInvitation',
+  table: 'team_invitations',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  indexes: [
+    {
+      name: 'team_invitations_token_hash_unique',
+      columns: ['token_hash'],
+      unique: true,
+    },
+    {
+      name: 'team_invitations_pending_key_unique',
+      columns: ['pending_key'],
+      unique: true,
+    },
+    {
+      name: 'team_invitations_team_email_status_index',
+      columns: ['team_id', 'email', 'status'],
+    },
+  ],
+
+  belongsTo: ['Team'],
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSeeder: { count: 0 },
+    useSearch: {
+      displayable: ['id', 'teamId', 'email', 'role', 'status', 'deliveryStatus', 'expiresAt', 'createdAt'],
+      searchable: ['email'],
+      sortable: ['email', 'role', 'status', 'expiresAt', 'createdAt', 'updatedAt'],
+      filterable: ['teamId', 'role', 'status', 'deliveryStatus'],
+    },
+    useApi: {
+      uri: 'team-invitations',
+      routes: ['index', 'show', 'destroy'],
+      middleware: ['auth', 'team'],
+    },
+  },
+
+  attributes: {
+    teamId: {
+      required: true,
+      fillable: true,
+      validation: {
+        rule: schema.number().required(),
+      },
+    },
+
+    email: {
+      required: true,
+      fillable: true,
+      validation: {
+        rule: schema.string().email().required().max(320),
+      },
+    },
+
+    role: {
+      required: true,
+      fillable: true,
+      default: 'member',
+      validation: {
+        rule: schema.enum(['admin', 'member', 'viewer']),
+      },
+    },
+
+    tokenHash: {
+      required: true,
+      hidden: true,
+      validation: {
+        rule: schema.string().required().max(64),
+      },
+    },
+
+    pendingKey: {
+      required: false,
+      hidden: true,
+      validation: {
+        rule: schema.string().max(384),
+      },
+    },
+
+    invitedByUserId: {
+      required: false,
+      validation: {
+        rule: schema.number(),
+      },
+    },
+
+    acceptedByUserId: {
+      required: false,
+      validation: {
+        rule: schema.number(),
+      },
+    },
+
+    status: {
+      required: true,
+      fillable: true,
+      default: 'pending',
+      validation: {
+        rule: schema.enum(['pending', 'accepted', 'revoked', 'expired']),
+      },
+    },
+
+    deliveryStatus: {
+      required: true,
+      default: 'pending',
+      validation: {
+        rule: schema.enum(['pending', 'sent', 'failed']),
+      },
+    },
+
+    deliveryError: {
+      required: false,
+      hidden: true,
+      validation: {
+        rule: schema.string().max(2000),
+      },
+    },
+
+    expiresAt: {
+      required: true,
+      validation: {
+        rule: schema.timestamp().required(),
+      },
+    },
+
+    deliveredAt: {
+      required: false,
+      validation: {
+        rule: schema.timestamp(),
+      },
+    },
+
+    acceptedAt: {
+      required: false,
+      validation: {
+        rule: schema.timestamp(),
+      },
+    },
+  },
+
+  dashboard: {
+    enabled: false,
+  },
+} as const)

package/dist/models/TeamMember.ts

@@ -0,0 +1,88 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * A user's membership in one team.
+ *
+ * The auth package already resolves active-team context from this table.
+ * Keeping the pivot as a model gives applications a typed, model-driven
+ * schema and an authenticated REST surface instead of relying on an
+ * undocumented table that may not exist.
+ */
+export default defineModel({
+  name: 'TeamMember',
+  table: 'team_members',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  indexes: [
+    {
+      name: 'team_members_team_user_unique',
+      columns: ['team_id', 'user_id'],
+      unique: true,
+    },
+    {
+      name: 'team_members_user_status_index',
+      columns: ['user_id', 'status'],
+    },
+  ],
+
+  belongsTo: ['Team', 'User'],
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useSeeder: { count: 0 },
+    useSearch: {
+      displayable: ['id', 'teamId', 'userId', 'role', 'status', 'createdAt'],
+      searchable: [],
+      sortable: ['role', 'status', 'createdAt', 'updatedAt'],
+      filterable: ['teamId', 'userId', 'role', 'status'],
+    },
+    useApi: {
+      uri: 'team-members',
+      routes: ['index', 'store', 'show', 'update', 'destroy'],
+      middleware: ['auth', 'team'],
+    },
+  },
+
+  attributes: {
+    teamId: {
+      required: true,
+      fillable: true,
+      validation: {
+        rule: schema.number().required(),
+      },
+    },
+
+    userId: {
+      required: true,
+      fillable: true,
+      validation: {
+        rule: schema.number().required(),
+      },
+    },
+
+    role: {
+      required: true,
+      fillable: true,
+      default: 'member',
+      validation: {
+        rule: schema.enum(['owner', 'admin', 'member', 'viewer']),
+      },
+    },
+
+    status: {
+      required: true,
+      fillable: true,
+      default: 'active',
+      validation: {
+        rule: schema.enum(['active', 'suspended']),
+      },
+    },
+  },
+
+  dashboard: {
+    enabled: false,
+  },
+} as const)

package/dist/models/UsageEvent.ts

@@ -0,0 +1,24 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+export default defineModel({
+  name: 'UsageEvent',
+  table: 'usage_events',
+  belongsTo: ['Team'],
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+    useApi: { uri: 'usage-events', routes: ['index', 'show'], middleware: ['auth', 'team'] },
+  },
+  indexes: [
+    { name: 'usage_events_idempotency_unique', columns: ['idempotency_key'], unique: true },
+    { name: 'usage_events_meter_period', columns: ['team_id', 'meter', 'occurred_at'] },
+  ],
+  attributes: {
+    meter: { required: true, fillable: true, validation: { rule: schema.enum(['contacts', 'email_sends', 'sms_segments', 'ai_generations', 'storage_bytes']) }, factory: () => 'email_sends' },
+    quantity: { required: true, fillable: true, default: 1, validation: { rule: schema.number().min(0) }, factory: () => 1 },
+    idempotencyKey: { required: true, fillable: true, validation: { rule: schema.string().max(255) }, factory: faker => faker.string.uuid() },
+    metadata: { required: false, fillable: true, validation: { rule: schema.json() }, factory: () => JSON.stringify({}) },
+    occurredAt: { required: true, fillable: true, validation: { rule: schema.timestamp() }, factory: () => new Date().toISOString() },
+  },
+} as const)

package/dist/models/User.ts

@@ -0,0 +1,142 @@
+import type { Attributes } from '@stacksjs/types'
+import { defineModel } from '@stacksjs/orm'
+import { makeHash } from '@stacksjs/security'
+// soon, these will be auto-imported
+import { schema } from '@stacksjs/validation'
+import { PASSWORD_MAX_LENGTH, PASSWORD_MIN_LENGTH } from '../password-policy'
+
+export default defineModel({
+  name: 'User', // defaults to the sanitized file name
+  table: 'users', // defaults to the lowercase, plural name of the model name (or the name of the model file)
+  primaryKey: 'id', // defaults to `id`
+  autoIncrement: true, // defaults to true
+
+  // Define composite indexes
+  indexes: [
+    {
+      name: 'users_email_name_index',
+      columns: ['email', 'name'],
+    },
+  ],
+
+  traits: {
+    useAuth: {
+      usePasskey: true,
+    },
+    // Not every app bills through the User model — leave `billable`
+    // off by default here. An app that wants checkout()/
+    // createStripeUser()/activeSubscription() etc. (createBillableMethods
+    // in orm/define-model.ts) should `buddy publish:model User` and
+    // enable the trait on its own app/Models/User.ts override, alongside
+    // the matching users.stripe_id guarantee-ALTER already provided by
+    // ensureUsersAuthColumns() regardless of this flag.
+    billable: false,
+    useUuid: true,
+    useTimestamps: true, // defaults to true, `timestampable` used as an alias
+    useSocials: ['github'],
+    useSearch: {
+      displayable: ['id', 'name', 'email'], // the fields to become d (defaults to all fields)
+      searchable: ['name', 'email'], // the fields to become searchable (defaults to all fields)
+      sortable: ['created_at', 'updated_at'], // the fields to become sortable (defaults to all fields)
+      filterable: [], // the fields to become filterable (defaults to all fields)
+      // options: {}, // you may pass options to the search engine
+    },
+
+    useSeeder: {
+      // defaults to a count of 10, `seedable` used as an alias
+      count: 10,
+    },
+
+    useApi: {
+      uri: 'users', // your-url.com/api/users
+
+      routes: ['index', 'store', 'show'],
+      // Registration is handled by the dedicated, rate-limited
+      // `/register` action. The generated User CRUD surface exposes PII
+      // and must only be available to authenticated operators.
+      middleware: ['auth'],
+    },
+  },
+
+  hasOne: ['Subscriber', 'Driver', 'Author'],
+
+  hasMany: [
+    'PersonalAccessToken',
+    'Customer',
+    'TeamMember',
+  ],
+  attributes: {
+    name: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().min(5).max(100),
+        message: {
+          min: 'Name must have a minimum of 3 characters',
+          max: 'Name must have a maximum of 255 characters',
+        },
+      },
+
+      factory: faker => faker.person.fullName(),
+    },
+
+    email: {
+      unique: true,
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().email().required(),
+        message: {
+          required: 'Email is required',
+          email: 'Email must be a valid email address',
+        },
+      },
+
+      factory: faker => faker.internet.email(),
+    },
+    password: {
+      order: 3,
+      hidden: true,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().min(PASSWORD_MIN_LENGTH).max(PASSWORD_MAX_LENGTH),
+        message: {
+          required: 'Password is required',
+          min: `Password must have a minimum of ${PASSWORD_MIN_LENGTH} characters`,
+          max: `Password must have a maximum of ${PASSWORD_MAX_LENGTH} characters`,
+        },
+      },
+
+      // Must satisfy the rule above, or seeded users fail their own model's
+      // validation. `123456` did once the minimum moved to 8 (#2226).
+      factory: () => 'password1234',
+    },
+
+    avatar: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(2048),
+        message: {
+          max: 'Avatar URL must be at most 2048 characters',
+        },
+      },
+
+      factory: faker => faker.image.avatar(),
+    },
+  },
+  get: {
+    salutationName: (attributes: Attributes) => {
+      return `Mr. ${attributes.name}`
+    },
+  },
+
+  set: {
+    password: async (attributes: Attributes) => {
+      return await makeHash(attributes.password, { algorithm: 'bcrypt' })
+    },
+  },
+  dashboard: {
+    highlight: true,
+  },
+} as const)

package/dist/models/commerce/Auction.ts

@@ -0,0 +1,173 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * An auction: a catalogue of lots that opens, takes bids, and closes.
+ *
+ * `eventId` is a plain column rather than a `belongsTo`, because the thing an
+ * auction hangs off is the application's own event model - a gala, a fun run,
+ * a capital campaign evening - and the framework does not ship one. An app that
+ * has an Event model declares `hasOne: ['Auction']` on its side and the column
+ * below is what that resolves through; an app with no events leaves it null and
+ * runs the auction standalone.
+ */
+export default defineModel({
+  name: 'Auction',
+  table: 'auctions',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+
+    useSearch: {
+      displayable: ['id', 'title', 'status', 'opensAt', 'closesAt', 'goalAmount'],
+      searchable: ['title', 'description'],
+      sortable: ['createdAt', 'opensAt', 'closesAt'],
+      filterable: ['status'],
+    },
+
+    useApi: {
+      uri: 'auctions',
+      middleware: { read: ['auth'], write: ['auth'] },
+    },
+
+    observe: true,
+  },
+
+  hasMany: ['AuctionItem', 'Bid', 'Pledge'],
+
+  indexes: [
+    { name: 'auctions_event_id_index', columns: ['event_id'] },
+    { name: 'auctions_status_index', columns: ['status'] },
+  ],
+
+  attributes: {
+    eventId: {
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.number(),
+      },
+      factory: faker => faker.number.int({ min: 1, max: 20 }),
+    },
+
+    title: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(160),
+        message: {
+          required: 'Title is required',
+          max: 'Title must have a maximum of 160 characters',
+        },
+      },
+      factory: () => 'Spring Benefit Auction',
+    },
+
+    description: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.lorem.sentence(),
+    },
+
+    status: {
+      default: 'draft',
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['draft', 'preview', 'open', 'closed', 'settled']).required(),
+        message: {
+          required: 'Status is required',
+        },
+      },
+      factory: () => 'draft',
+    },
+
+    currency: {
+      default: 'USD',
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(3),
+      },
+      factory: () => 'USD',
+    },
+
+    /**
+     * The fundraising target, in cents. Null when the school would rather not
+     * put a number on the wall.
+     */
+    goalAmount: {
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.number.int({ min: 500000, max: 5000000 }),
+    },
+
+    opensAt: {
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.date().required(),
+      },
+      factory: faker => faker.date.soon().toISOString(),
+    },
+
+    closesAt: {
+      order: 8,
+      fillable: true,
+      validation: {
+        rule: schema.date().required(),
+      },
+      factory: faker => faker.date.future().toISOString(),
+    },
+
+    /** How far a lot's close is pushed out when a bid lands in the window. */
+    antiSnipeMinutes: {
+      default: 2,
+      order: 9,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0).max(60),
+      },
+      factory: () => 2,
+    },
+
+    /** How close to the end a bid has to land to trigger an extension. */
+    extendOnBidWindowMinutes: {
+      default: 2,
+      order: 10,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0).max(60),
+      },
+      factory: () => 2,
+    },
+
+    /**
+     * The hard stop. Without it two determined bidders can hold one lot open
+     * all night and the gala staff cannot go home.
+     */
+    maxExtensions: {
+      default: 20,
+      order: 11,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: () => 20,
+    },
+  },
+
+  dashboard: {
+    icon: 'i-hugeicons-auction',
+    label: 'Auctions',
+  },
+} as const)