@stacksjs/defaults 0.70.380 → 0.71.2

package/app/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)

package/app/Models/commerce/AuctionItem.ts

@@ -0,0 +1,204 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * One lot in an auction.
+ *
+ * Every money column is integer cents. A benefit auction adds several hundred
+ * bids together and reports the total to a board; floats lose that argument.
+ */
+export default defineModel({
+  name: 'AuctionItem',
+  table: 'auction_items',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+
+    useSearch: {
+      displayable: ['id', 'lotNumber', 'title', 'status', 'startingBid', 'donorName'],
+      searchable: ['title', 'description', 'donorName', 'category'],
+      sortable: ['lotNumber', 'startingBid', 'closesAt'],
+      filterable: ['status', 'category'],
+    },
+
+    useApi: {
+      uri: 'auction-items',
+      middleware: { read: ['auth'], write: ['auth'] },
+    },
+
+    observe: true,
+  },
+
+  belongsTo: ['Auction'],
+  hasMany: ['Bid'],
+
+  indexes: [
+    { name: 'auction_items_auction_id_index', columns: ['auction_id'] },
+    { name: 'auction_items_status_index', columns: ['status'] },
+  ],
+
+  attributes: {
+    lotNumber: {
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(1),
+        message: {
+          required: 'Lot number is required',
+        },
+      },
+      factory: faker => faker.number.int({ min: 1, max: 120 }),
+    },
+
+    title: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(160),
+        message: {
+          required: 'Title is required',
+        },
+      },
+      factory: faker => faker.commerce.productName(),
+    },
+
+    description: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.string(),
+      },
+      factory: faker => faker.lorem.paragraph(),
+    },
+
+    imageUrl: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(500),
+      },
+      factory: () => '',
+    },
+
+    category: {
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(60),
+      },
+      factory: faker => faker.helpers.arrayElement(['experiences', 'travel', 'dining', 'sports', 'art', 'services']),
+    },
+
+    /** Who donated the lot. It goes on the tax letter and the thank-you note. */
+    donorName: {
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(160),
+      },
+      factory: faker => faker.company.name(),
+    },
+
+    /**
+     * What the lot is worth, in cents. Drives the sell-through report and the
+     * "paid over value" number the development office cares about.
+     */
+    fairMarketValue: {
+      order: 7,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: faker => faker.number.int({ min: 5000, max: 200000 }),
+    },
+
+    startingBid: {
+      order: 8,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(0),
+        message: {
+          required: 'Starting bid is required',
+        },
+      },
+      factory: faker => faker.number.int({ min: 2500, max: 50000 }),
+    },
+
+    /**
+     * A fixed increment for this lot, in cents. Null - the normal case - means
+     * the auction-wide ladder applies, which steps bigger as the money gets
+     * bigger.
+     */
+    minIncrement: {
+      order: 9,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: () => null,
+    },
+
+    /** Bid at or above this and the lot sells immediately. */
+    buyNowPrice: {
+      order: 10,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: () => null,
+    },
+
+    /** Below this the lot passes rather than selling. */
+    reservePrice: {
+      order: 11,
+      fillable: true,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: () => null,
+    },
+
+    status: {
+      default: 'open',
+      order: 12,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['open', 'closed', 'sold', 'passed']).required(),
+      },
+      factory: () => 'open',
+    },
+
+    /**
+     * A per-lot close, so a gala can stagger its sections and the room is not
+     * asked to watch a hundred lots end at once. Null falls back to the
+     * auction's own close. Anti-snipe extensions are written here.
+     */
+    closesAt: {
+      order: 13,
+      fillable: true,
+      validation: {
+        rule: schema.date(),
+      },
+      factory: () => null,
+    },
+
+    /** How many times anti-snipe has already extended this lot. */
+    extensionCount: {
+      default: 0,
+      order: 14,
+      fillable: false,
+      validation: {
+        rule: schema.number().min(0),
+      },
+      factory: () => 0,
+    },
+  },
+
+  dashboard: {
+    icon: 'i-hugeicons-package',
+    label: 'Lots',
+  },
+} as const)

package/app/Models/commerce/Bid.ts

@@ -0,0 +1,129 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * One bid on one lot.
+ *
+ * Bidders are identified by name and email rather than by a user account: a
+ * benefit auction is bid on by grandparents on borrowed phones, and requiring
+ * a signup between them and their paddle costs the school real money.
+ *
+ * `maxAmount` is the private proxy ceiling. It must never be selected into a
+ * template or an API response - the whole mechanism depends on nobody being
+ * able to see how far the other side is willing to go. `hidden` keeps it out of
+ * the generated CRUD responses; the queries in `@stacksjs/auctions` that feed
+ * the public catalogue select columns explicitly for the same reason.
+ */
+export default defineModel({
+  name: 'Bid',
+  table: 'bids',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+
+    useSearch: {
+      displayable: ['id', 'bidderName', 'amount', 'status', 'placedAt'],
+      searchable: ['bidderName', 'bidderEmail'],
+      sortable: ['placedAt', 'amount'],
+      filterable: ['status'],
+    },
+
+    // Read is authenticated: the bid history of a lot is staff information
+    // while the auction is live. Writes never come through generated CRUD -
+    // a bid has to go through the engine, so the app owns that route.
+    useApi: {
+      uri: 'bids',
+      routes: ['index', 'show'],
+      middleware: ['auth'],
+    },
+
+    observe: true,
+  },
+
+  belongsTo: ['Auction', 'AuctionItem'],
+
+  indexes: [
+    { name: 'bids_auction_item_id_index', columns: ['auction_item_id'] },
+    { name: 'bids_auction_id_index', columns: ['auction_id'] },
+    { name: 'bids_bidder_email_index', columns: ['bidder_email'] },
+    { name: 'bids_status_index', columns: ['status'] },
+  ],
+
+  attributes: {
+    bidderName: {
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(160),
+        message: {
+          required: 'Your name is required',
+        },
+      },
+      factory: faker => faker.person.fullName(),
+    },
+
+    bidderEmail: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().email().required(),
+        message: {
+          required: 'Your email is required',
+          email: 'That does not look like an email address',
+        },
+      },
+      factory: faker => faker.internet.email().toLowerCase(),
+    },
+
+    /** The public number: what this bidder is currently committed to, in cents. */
+    amount: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(1),
+        message: {
+          required: 'A bid amount is required',
+        },
+      },
+      factory: faker => faker.number.int({ min: 5000, max: 200000 }),
+    },
+
+    /** The private ceiling, in cents. Null means "this amount only". */
+    maxAmount: {
+      order: 4,
+      fillable: true,
+      hidden: true,
+      validation: {
+        rule: schema.number().min(1),
+      },
+      factory: () => null,
+    },
+
+    status: {
+      default: 'leading',
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['leading', 'outbid', 'won', 'lost', 'invalid']).required(),
+      },
+      factory: () => 'outbid',
+    },
+
+    placedAt: {
+      order: 6,
+      fillable: true,
+      validation: {
+        rule: schema.date().required(),
+      },
+      factory: faker => faker.date.recent().toISOString(),
+    },
+  },
+
+  dashboard: {
+    icon: 'i-hugeicons-hand-pointing-right-01',
+    label: 'Bids',
+  },
+} as const)

package/app/Models/commerce/Pledge.ts

@@ -0,0 +1,112 @@
+import { defineModel } from '@stacksjs/orm'
+import { schema } from '@stacksjs/validation'
+
+/**
+ * A fund-a-need pledge.
+ *
+ * Fund-a-need is the part of a benefit auction that is not an auction: the room
+ * is asked to give at fixed levels and nobody competes for anything. It shares
+ * the auction only for the tally board, which is why a pledge has an amount and
+ * a level but no lot, no increment and no winner.
+ */
+export default defineModel({
+  name: 'Pledge',
+  table: 'pledges',
+  primaryKey: 'id',
+  autoIncrement: true,
+
+  traits: {
+    useUuid: true,
+    useTimestamps: true,
+
+    useSearch: {
+      displayable: ['id', 'donorName', 'amount', 'level', 'status'],
+      searchable: ['donorName', 'donorEmail', 'level'],
+      sortable: ['createdAt', 'amount'],
+      filterable: ['status', 'level'],
+    },
+
+    useApi: {
+      uri: 'pledges',
+      middleware: ['auth'],
+    },
+
+    observe: true,
+  },
+
+  belongsTo: ['Auction'],
+
+  indexes: [
+    { name: 'pledges_auction_id_index', columns: ['auction_id'] },
+    { name: 'pledges_status_index', columns: ['status'] },
+  ],
+
+  attributes: {
+    donorName: {
+      order: 1,
+      fillable: true,
+      validation: {
+        rule: schema.string().required().max(160),
+        message: {
+          required: 'Donor name is required',
+        },
+      },
+      factory: faker => faker.person.fullName(),
+    },
+
+    donorEmail: {
+      order: 2,
+      fillable: true,
+      validation: {
+        rule: schema.string().email().required(),
+        message: {
+          required: 'Donor email is required',
+        },
+      },
+      factory: faker => faker.internet.email().toLowerCase(),
+    },
+
+    /** The gift, in cents. */
+    amount: {
+      order: 3,
+      fillable: true,
+      validation: {
+        rule: schema.number().required().min(1),
+        message: {
+          required: 'A pledge amount is required',
+        },
+      },
+      factory: faker => faker.helpers.arrayElement([25000, 50000, 100000, 250000, 500000]),
+    },
+
+    /** The paddle-raise tier this came from, for the tally board. */
+    level: {
+      order: 4,
+      fillable: true,
+      validation: {
+        rule: schema.string().max(40),
+      },
+      factory: faker => faker.helpers.arrayElement(['250', '500', '1000', '2500', '5000']),
+    },
+
+    /**
+     * Pledges made from the room are good the moment a paddle goes up; pledges
+     * taken online are often confirmed by staff afterwards. Only `confirmed`
+     * money counts toward a total anybody reports.
+     */
+    status: {
+      default: 'confirmed',
+      order: 5,
+      fillable: true,
+      validation: {
+        rule: schema.enum(['pending', 'confirmed', 'cancelled']).required(),
+      },
+      factory: () => 'confirmed',
+    },
+  },
+
+  dashboard: {
+    icon: 'i-hugeicons-give-blood',
+    label: 'Pledges',
+  },
+} as const)

package/bootstrap.ts

@@ -148,6 +148,13 @@ if (mounts('email', feature('email'))) {
   await route.register(frameworkPath('defaults/routes/email.ts'))
 }
 
+// Form-builder public endpoints (`@stacksjs/forms`). Gated on the `forms`
+// feature, which defaults OFF - an app opts in with config/forms.ts
+// (`buddy forms:install`) and only then do the public submit routes exist.
+if (mounts('forms', feature('forms'))) {
+  await route.register(frameworkPath('defaults/routes/forms.ts'))
+}
+
 // Social sign-in: `/auth/{provider}` + `/auth/{provider}/callback`
 // (stacksjs/stacks#2276). An opt-in bundle, NOT part of the implicit default
 // set or `all` — OAuth callback URLs in an app that configured no provider

package/functions/public-application-url.ts

@@ -12,7 +12,7 @@ function withProtocol(baseUrl: string): string {
   if (/^https?:\/\//i.test(baseUrl))
     return baseUrl
 
-  const host = baseUrl.split('/')[0].split(':')[0].toLowerCase()
+  const host = baseUrl.split('/')[0]?.split(':')[0]?.toLowerCase() ?? ''
   const protocol = ['localhost', '127.0.0.1', '0.0.0.0', '[::1]'].includes(host)
     ? 'http'
     : 'https'

package/ide/vscode/package.json

@@ -2,7 +2,7 @@
   "publisher": "Stacks",
   "name": "vscode-stacks",
   "displayName": "Stacks",
-  "version": "0.70.380",
+  "version": "0.71.2",
   "description": "A modern Stacks development environment.",
   "license": "MIT",
   "funding": "https://github.com/sponsors/chrisbbreuer",

package/package.json

@@ -2,7 +2,7 @@
   "name": "@stacksjs/defaults",
   "type": "module",
   "sideEffects": false,
-  "version": "0.70.380",
+  "version": "0.71.2",
   "description": "The complete managed Stacks application scaffold, including runtime defaults, AI guidance, editor metadata, and npm-backed project support files.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -46,7 +46,7 @@
   "dependencies": {
     "@iconify-json/f7": "^1.2.2",
     "@iconify-json/hugeicons": "^1.2.27",
-    "@stacksjs/mobile": "^0.70.380",
+    "@stacksjs/mobile": "^0.71.2",
     "@stacksjs/sanitizer": "^0.2.113"
   },
   "scripts": {