@stacksjs/defaults 0.70.57 → 0.70.59

package/app/Actions/Payment/StorePaymentMethodAction.ts

@@ -0,0 +1,20 @@
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'StorePaymentMethodAction',
+  description: 'Store the customers payment methods',
+  method: 'POST',
+  async handle(request: RequestInstance) {
+    const user = await request.user()
+
+    if (!user)
+      return response.unauthorized('Authentication required')
+
+    const paymentIntent = request.get('setupIntent') as string
+
+    const paymentMethod = await user?.addPaymentMethod(paymentIntent)
+
+    return response.json(paymentMethod)
+  },
+})

package/app/Actions/Payment/StoreTransactionAction.ts

@@ -0,0 +1,20 @@
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'StoreTransactionAction',
+  description: 'Store transactions',
+  method: 'POST',
+  async handle(request: RequestInstance) {
+    const productId = Number(request.get('productId'))
+
+    const user = await request.user()
+
+    if (!user)
+      return response.unauthorized('Authentication required')
+
+    const transaction = await user?.storeTransaction(productId)
+
+    return response.json(transaction)
+  },
+})

package/app/Actions/Payment/UpdateCustomerAction.ts

@@ -0,0 +1,24 @@
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'UpdateCustomerAction',
+  description: 'Update customer detauls',
+  method: 'POST',
+  async handle(request: RequestInstance) {
+    const user = await request.user()
+
+    if (!user)
+      return response.unauthorized('Authentication required')
+
+    const customer = await user?.syncStripeCustomerDetails({ address: {
+      line1: '123 Elm St',
+      city: 'Austin',
+      state: 'TX',
+      postal_code: '78701',
+      country: 'US',
+    } })
+
+    return response.json(customer)
+  },
+})

package/app/Actions/Payment/UpdateDefaultPaymentMethodAction.ts

@@ -0,0 +1,18 @@
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'UpdateDefaultPaymentMethodAction',
+  description: 'Update the customers default payment method',
+  method: 'POST',
+  async handle(request: RequestInstance) {
+    const user = await request.user()
+
+    if (!user)
+      return response.unauthorized('Authentication required')
+
+    const paymentMethod = Number(request.get('paymentMethod'))
+
+    await user?.setDefaultPaymentMethod(paymentMethod)
+  },
+})

package/app/Actions/Payment/UpdateSubscriptionAction.ts

@@ -0,0 +1,22 @@
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'UpdateSubscriptionAction',
+  description: 'Update Subscription for stripe',
+  method: 'POST',
+  async handle(request: RequestInstance) {
+    const type = request.get('type') as string
+    const plan = request.get('plan') as string
+    const description = request.get('description') as string
+
+    const user = await request.user()
+
+    if (!user)
+      return response.unauthorized('Authentication required')
+
+    const subscription = await user?.updateSubscription(plan, type, { description })
+
+    return response.json(subscription?.paymentIntent)
+  },
+})

package/app/Actions/Queue/FetchQueuesAction.ts

@@ -0,0 +1,14 @@
+import { Action } from '@stacksjs/actions'
+import { Job } from '@stacksjs/orm'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'FetchQueuesAction',
+  description: 'Fetch all the queues',
+  method: 'GET',
+  async handle() {
+    const queues = await Job.all()
+
+    return response.json(queues)
+  },
+})

package/app/Actions/README.md

@@ -0,0 +1,61 @@
+# What are Actions
+
+Actions introduce a concept of unique code reusability. They are "functions" that can be called from anywhere in the application. For example, they may be used as a ...
+
+- CLI Command
+- HTTP Controller
+- Event Listener
+- Cron Job
+- Queue Worker
+
+In other words, it is a Stacks primitive that may be called from anywhere in your application. Simplified API development, allowing you to move faster.
+
+> [!TIP]
+> Your "business logic" should be defined as Actions. This allows you to easily reuse your code across different parts of your application, without having to worry about scalability.
+
+## Get Started
+
+The following command will bootstrap a new action file in the `app/Actions` directory.
+
+```sh
+buddy make:action SendWelcomeEmail
+```
+
+### Example
+
+A simple example of an Action that sends a welcome email. _For a closer look, take a look at the [SendWelcomeEmail](./ExampleAction.ts) example action._
+
+```ts
+export default new Action({
+  name: 'SendWelcomeEmail', // could be anything, like `send-welcome-email` or `Send Welcome EmAiL`
+  description: 'An optional description of the action.',
+
+  async handle() {
+    return sendEmail({
+      to: 'some@recipient.com',
+      subject: 'Welcome to our app!',
+      text: 'We are excited to have you here.',
+    })
+  },
+})
+```
+
+## 🚜 Contributing
+
+Please review the [Contributing Guide](https://github.com/stacksjs/contributing) for details.
+
+## 🏝 Community
+
+For help, discussion about best practices, or any other conversation that would benefit from being searchable:
+
+[Discussions on GitHub](https://github.com/stacksjs/stacks/discussions)
+
+For casual chit-chat with others using this package:
+
+[Join the Stacks Discord Server](https://discord.gg/stacksjs)
+
+## 📄 License
+
+The MIT License (MIT). Please see [LICENSE](../../LICENSE.md) for more information.
+
+Made with 💙

package/app/Actions/Realtime/FetchWebsocketsAction.ts

@@ -0,0 +1,14 @@
+import { Action } from '@stacksjs/actions'
+import { db } from '@stacksjs/database'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'Websockets Index',
+  description: 'Websockets Index ORM Action',
+  method: 'GET',
+  async handle() {
+    const results = await db.selectFrom('websockets').selectAll().execute()
+
+    return response.json(results)
+  },
+})

package/app/Actions/RobotsAction.ts

@@ -0,0 +1,61 @@
+import { Action } from '@stacksjs/actions'
+import { config } from '@stacksjs/config'
+import { response } from '@stacksjs/router'
+
+/**
+ * /robots.txt — sensible defaults for any Stacks app.
+ *
+ * Allow everything by default, then disallow the surfaces a search
+ * engine has no reason to see: cart/checkout/orders are transactional,
+ * dashboard/admin/auth are private, and /api endpoints return JSON
+ * (not useful in search indices).
+ *
+ * Apps that want stricter rules can re-register `/robots.txt` in
+ * `routes/api.ts` against their own action — user routes load before
+ * framework routes so the override wins.
+ */
+export default new Action({
+  name: 'RobotsAction',
+  description: 'Generate /robots.txt with safe defaults + sitemap link',
+  method: 'GET',
+
+  async handle() {
+    // Normalize APP_URL the same way SitemapAction does — Stacks .env
+    // files commonly carry `APP_URL=foo.localhost` without a scheme
+    // because the dev proxy bolts on https:// at runtime, but a
+    // robots.txt `Sitemap: …` entry needs an explicit absolute URL or
+    // search engines won't discover the sitemap.
+    let siteUrl = ((config as any).app?.url || 'http://localhost:3000').trim().replace(/\/$/, '')
+    if (!/^https?:\/\//i.test(siteUrl))
+      siteUrl = `https://${siteUrl}`
+
+    const lines = [
+      'User-agent: *',
+      'Allow: /',
+      // Transactional, ephemeral, or per-user surfaces — never useful in
+      // a search index, and crawling them wastes budget.
+      'Disallow: /cart',
+      'Disallow: /checkout',
+      'Disallow: /orders',
+      // Auth endpoints + private admin
+      'Disallow: /login',
+      'Disallow: /register',
+      'Disallow: /logout',
+      'Disallow: /me',
+      'Disallow: /admin',
+      'Disallow: /dashboard',
+      // JSON APIs and framework internals — no human-readable content.
+      'Disallow: /api/',
+      'Disallow: /auth/',
+      'Disallow: /_stx/',
+      'Disallow: /voide/',
+      '',
+      `Sitemap: ${siteUrl}/sitemap.xml`,
+      '',
+    ]
+
+    return response.text(lines.join('\n'), 200, {
+      'Cache-Control': 'public, max-age=86400',
+    })
+  },
+})

package/app/Actions/SendWelcomeEmail.ts

@@ -0,0 +1,40 @@
+import { Action } from '@stacksjs/actions'
+import { config } from '@stacksjs/config'
+import { mail } from '@stacksjs/email'
+
+export interface WelcomeEmailParams {
+  to: string
+  name?: string
+}
+
+export default new Action({
+  name: 'SendWelcomeEmail',
+  description: 'Sends a welcome email to newly registered users',
+
+  async handle({ to, name }: WelcomeEmailParams) {
+    const appName = config.app.name || 'our app'
+    const url = config.app.url || 'https://localhost:5173'
+
+    await mail.send({
+      to,
+      subject: `Welcome to ${appName}!`,
+      text: `
+Hello ${name || 'there'},
+
+Welcome to ${appName}! We're excited to have you on board.
+
+You can access your account at ${url}
+
+If you have any questions, feel free to reach out to our support team.
+
+Best regards,
+The ${appName} Team
+      `.trim(),
+    })
+
+    return {
+      success: true,
+      message: `Welcome email sent to ${to}`,
+    }
+  },
+})

package/app/Actions/SitemapAction.ts

@@ -0,0 +1,234 @@
+import { Action } from '@stacksjs/actions'
+import { config } from '@stacksjs/config'
+import { db } from '@stacksjs/database'
+import { response } from '@stacksjs/router'
+import { existsSync, readdirSync, statSync } from 'node:fs'
+import { join } from 'node:path'
+
+/**
+ * Generate the top-level sitemap.xml.
+ *
+ * Strategy:
+ *   1. Walk resources/views and storage/framework/defaults/resources/views
+ *      collecting static pages — file paths that don't contain `[`
+ *      (dynamic) or `[...]` (catch-all). The static set covers the
+ *      home page, /about, /faq, /products listing, etc.
+ *   2. For dynamic patterns (e.g. resources/views/products/[slug].stx)
+ *      fan out using the database — currently the storefront's
+ *      `products` table by `slug`. Apps with other dynamic models
+ *      (blog posts, categories) can extend this list by re-registering
+ *      the route in `routes/api.ts` against their own action.
+ *   3. Always exclude private surfaces — /cart, /checkout/*,
+ *      /orders/*, /login, /register, /dashboard, /api/* etc. The
+ *      EXCLUDED_PATTERNS list below is the source of truth.
+ *
+ * The output is cached for 1 hour via the `Cache-Control` header so
+ * search engine pings don't hit the DB on every fetch. For larger
+ * catalogs, switch to a sitemap-index (`/sitemap.xml` pointing at
+ * `/sitemap-products.xml` etc.) — left as a follow-up because the
+ * current impl handles up to ~50k URLs in <100ms.
+ */
+
+const PROJECT_VIEWS = 'resources/views'
+const FRAMEWORK_VIEWS = 'storage/framework/defaults/resources/views'
+
+// Path prefixes that should never be indexed. Matched as a literal
+// prefix on the URL path (so '/cart' matches '/cart' and '/cart/x').
+//
+// `/blog/category` and `/blog/post` are framework-default templates
+// for the dynamic CMS detail pages, NOT routes themselves — the
+// actual URLs are `/blog/categories/{slug}` and `/blog/posts/{id}`,
+// emitted by the CMS sitemap. Filename-as-route discovery would
+// otherwise treat the bare templates as static pages and index URLs
+// that 404. Treat them as templates and let CMS-aware sitemaps
+// handle the dynamic fan-out.
+const EXCLUDED_PATTERNS: ReadonlyArray<string | RegExp> = [
+  '/cart',
+  '/checkout',
+  '/orders',
+  '/login',
+  '/register',
+  '/logout',
+  '/dashboard',
+  '/api',
+  '/auth',
+  '/me',
+  '/admin',
+  '/install',
+  '/test-error',
+  '/_stx',
+  '/voide',
+  '/blog/category',
+  '/blog/post',
+  '/blog/categories',
+  '/emails',
+  /^\/\[\.\.\..+\]/, // catch-all pages like /[...all].stx
+]
+
+interface SitemapEntry {
+  loc: string
+  changefreq?: 'always' | 'hourly' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'never'
+  priority?: number
+  lastmod?: string
+}
+
+function isExcluded(urlPath: string): boolean {
+  for (const pat of EXCLUDED_PATTERNS) {
+    if (typeof pat === 'string') {
+      if (urlPath === pat || urlPath.startsWith(`${pat}/`))
+        return true
+    }
+    else if (pat.test(urlPath)) {
+      return true
+    }
+  }
+  return false
+}
+
+function fileToUrl(viewsRoot: string, file: string): string | null {
+  let rel = file.startsWith(viewsRoot) ? file.slice(viewsRoot.length) : file
+  if (rel.startsWith('/'))
+    rel = rel.slice(1)
+  // Strip extension
+  rel = rel.replace(/\.(stx|md|html)$/i, '')
+  // index.stx → '' (root)
+  if (rel === 'index')
+    return '/'
+  if (rel.endsWith('/index'))
+    rel = rel.slice(0, -'/index'.length)
+  return `/${rel}`
+}
+
+function walkViews(root: string): string[] {
+  if (!existsSync(root))
+    return []
+  const out: string[] = []
+  function visit(dir: string) {
+    let entries: string[]
+    try { entries = readdirSync(dir) }
+    catch { return }
+    for (const name of entries) {
+      const full = join(dir, name)
+      let s
+      try { s = statSync(full) }
+      catch { continue }
+      // Skip layouts / components / partials — they're not addressable URLs.
+      if (s.isDirectory()) {
+        if (name === 'layouts' || name === 'components' || name === 'partials' || name === 'emails' || name === 'dashboard')
+          continue
+        visit(full)
+      }
+      else if (/\.(?:stx|md|html)$/i.test(name)) {
+        out.push(full)
+      }
+    }
+  }
+  visit(root)
+  return out
+}
+
+async function discoverProducts(): Promise<SitemapEntry[]> {
+  // Best effort: pull from a `products` table if it exists (storefront
+  // model is the framework default). Apps without commerce schema get
+  // an empty list and the sitemap silently omits this section.
+  try {
+    const rows: Array<{ slug: string, updated_at?: string }> = await (db as any)
+      .selectFrom('products')
+      .where('is_available', '=', 1)
+      .select(['slug', 'updated_at'])
+      .execute()
+    return rows
+      .filter(r => r.slug)
+      .map(r => ({
+        loc: `/products/${r.slug}`,
+        changefreq: 'weekly' as const,
+        priority: 0.8,
+        lastmod: r.updated_at ? new Date(r.updated_at).toISOString().split('T')[0] : undefined,
+      }))
+  }
+  catch {
+    return []
+  }
+}
+
+function staticEntries(): SitemapEntry[] {
+  const seen = new Set<string>()
+  const entries: SitemapEntry[] = []
+
+  for (const root of [PROJECT_VIEWS, FRAMEWORK_VIEWS]) {
+    for (const file of walkViews(root)) {
+      const urlPath = fileToUrl(root, file)
+      if (!urlPath)
+        continue
+      // Dynamic + catch-all paths get filtered out — they're handled
+      // separately (see discoverProducts).
+      if (urlPath.includes('['))
+        continue
+      if (isExcluded(urlPath))
+        continue
+      if (seen.has(urlPath))
+        continue
+      seen.add(urlPath)
+
+      // Home gets top priority + daily; everything else is ~0.6 weekly.
+      // Pages with dynamic data (products listing, blog index) bump up
+      // a touch because they update more often than static copy.
+      const isHome = urlPath === '/'
+      const isHighChurn = /^\/(?:products|blog)\b/.test(urlPath)
+      entries.push({
+        loc: urlPath,
+        changefreq: isHome ? 'daily' : (isHighChurn ? 'daily' : 'weekly'),
+        priority: isHome ? 1.0 : (isHighChurn ? 0.9 : 0.6),
+      })
+    }
+  }
+  return entries
+}
+
+function normalizeSiteUrl(siteUrl: string): string {
+  // Strip trailing slash and ensure a scheme. Stacks `.env` files
+  // commonly carry `APP_URL=foo.localhost` (no protocol — the dev
+  // proxy adds the https:// at runtime), but absolute URLs in a
+  // sitemap need an explicit scheme or search engines will reject
+  // every entry. Default to https:// since that's what the rpx layer
+  // serves; pages forced onto plain HTTP (custom configs) should set
+  // an explicit `http://…` in APP_URL.
+  let u = siteUrl.trim().replace(/\/$/, '')
+  if (!/^https?:\/\//i.test(u))
+    u = `https://${u}`
+  return u
+}
+
+function renderXml(siteUrl: string, entries: SitemapEntry[]): string {
+  const url = normalizeSiteUrl(siteUrl)
+  const xmlEntries = entries.map((e) => {
+    const tags: string[] = [`    <loc>${url}${e.loc}</loc>`]
+    if (e.lastmod)
+      tags.push(`    <lastmod>${e.lastmod}</lastmod>`)
+    if (e.changefreq)
+      tags.push(`    <changefreq>${e.changefreq}</changefreq>`)
+    if (typeof e.priority === 'number')
+      tags.push(`    <priority>${e.priority.toFixed(1)}</priority>`)
+    return `  <url>\n${tags.join('\n')}\n  </url>`
+  }).join('\n')
+
+  return `<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n${xmlEntries}\n</urlset>\n`
+}
+
+export default new Action({
+  name: 'SitemapAction',
+  description: 'Generate the top-level sitemap.xml from views + product catalog',
+  method: 'GET',
+
+  async handle() {
+    const siteUrl = (config as any).app?.url || 'http://localhost:3000'
+    const all: SitemapEntry[] = [
+      ...staticEntries(),
+      ...(await discoverProducts()),
+    ]
+
+    return response.xml(renderXml(siteUrl, all), 200, {
+      'Cache-Control': 'public, max-age=3600',
+    })
+  },
+})