@stacksjs/defaults 0.70.206 → 0.70.208

package/routes/email.ts

@@ -0,0 +1,129 @@
+/**
+ * Default framework email routes (stacksjs/stacks#1880, #1881).
+ *
+ * Mounts:
+ *   - GET  /_stacks/email/unsubscribe/:token   — opt-out via signed link
+ *   - POST /webhooks/email/mailgun             — bounce/complaint events
+ *   - POST /webhooks/email/postmark            — bounce/complaint events
+ *   - POST /webhooks/email/ses                 — SES via SNS
+ *   - POST /webhooks/email/sendgrid            — event webhook
+ *
+ * All routes are CSRF-exempt (they're called by external providers
+ * or anonymous users clicking unsubscribe links). User routes
+ * registered first win, so apps that need to mount their own
+ * handlers at the same path can override.
+ *
+ * Each webhook handler self-disables if its provider credentials
+ * aren't configured — returns 401 with `missing-config` rather
+ * than processing unauthenticated requests.
+ */
+
+import { route } from '@stacksjs/router'
+import {
+  buildUnsubscribeUrl as _ignored, // import-side dep to ensure tree-shake doesn't drop the module
+  handleMailgunWebhook,
+  handlePostmarkWebhook,
+  handleSendgridWebhook,
+  handleSesWebhook,
+  suppress,
+  verifyUnsubscribeToken,
+} from '@stacksjs/email'
+import { config } from '@stacksjs/config'
+import process from 'node:process'
+
+// Touch the import so the bundler keeps it referenced (the helper
+// is used by app code; this file ensures the module loads when
+// the framework routes register).
+void _ignored
+
+interface EmailConfigShape {
+  webhooks?: {
+    mailgun?: { signingKey?: string }
+    postmark?: { username?: string, password?: string, ipAllowlist?: ReadonlyArray<string> }
+    ses?: { autoConfirmSubscriptions?: boolean }
+    sendgrid?: { publicKeyPem?: string }
+  }
+}
+
+function emailConfig(): EmailConfigShape {
+  return ((config as { email?: EmailConfigShape } | undefined)?.email ?? {}) as EmailConfigShape
+}
+
+// ============================================================================
+// Unsubscribe — signed-link opt-out (stacksjs/stacks#1880)
+// ============================================================================
+
+route.get('/_stacks/email/unsubscribe/{token}', async (req) => {
+  const params = (req as unknown as { params?: { token?: string } }).params
+  const token = params?.token ?? ''
+  const result = verifyUnsubscribeToken(token)
+  if (!result.valid || !result.email) {
+    return new Response(
+      `Unsubscribe link invalid or expired (${result.reason ?? 'unknown'}).`,
+      { status: 410, headers: { 'Content-Type': 'text/plain; charset=utf-8' } },
+    )
+  }
+  await suppress(result.email, 'unsubscribe', 'user-initiated via signed URL')
+  return new Response(
+    `You've been unsubscribed. We won't email ${result.email} again.`,
+    { status: 200, headers: { 'Content-Type': 'text/plain; charset=utf-8' } },
+  )
+}).skipCsrf()
+
+// ============================================================================
+// Provider webhooks (stacksjs/stacks#1881)
+// ============================================================================
+
+route.post('/webhooks/email/mailgun', async (req) => {
+  const cfg = emailConfig().webhooks?.mailgun
+  const signingKey = cfg?.signingKey ?? process.env.MAILGUN_WEBHOOK_SIGNING_KEY ?? ''
+  if (!signingKey) {
+    return Response.json({ ok: false, reason: 'missing-config' }, { status: 401 })
+  }
+  const rawBody = await req.text()
+  const result = await handleMailgunWebhook(rawBody, { signingKey })
+  return Response.json(result.body, { status: result.status })
+}).skipCsrf()
+
+route.post('/webhooks/email/postmark', async (req) => {
+  const cfg = emailConfig().webhooks?.postmark
+  const username = cfg?.username ?? process.env.POSTMARK_WEBHOOK_USERNAME ?? ''
+  const password = cfg?.password ?? process.env.POSTMARK_WEBHOOK_PASSWORD ?? ''
+  if (!username || !password) {
+    return Response.json({ ok: false, reason: 'missing-config' }, { status: 401 })
+  }
+  const rawBody = await req.text()
+  const auth = req.headers.get('authorization')
+  // Bun's Request exposes the client IP via the server's `requestIP` API,
+  // not directly on the request. The framework's enhanced-request layer
+  // surfaces it via _clientIp when available; fall back gracefully.
+  const sourceIp = (req as unknown as { _clientIp?: string })._clientIp
+  const result = await handlePostmarkWebhook(rawBody, auth, sourceIp, {
+    username,
+    password,
+    ipAllowlist: cfg?.ipAllowlist,
+  })
+  return Response.json(result.body, { status: result.status })
+}).skipCsrf()
+
+route.post('/webhooks/email/ses', async (req) => {
+  const cfg = emailConfig().webhooks?.ses ?? {}
+  const rawBody = await req.text()
+  const result = await handleSesWebhook(rawBody, {
+    autoConfirmSubscriptions: cfg.autoConfirmSubscriptions,
+  })
+  return Response.json(result.body, { status: result.status })
+}).skipCsrf()
+
+route.post('/webhooks/email/sendgrid', async (req) => {
+  const cfg = emailConfig().webhooks?.sendgrid
+  const publicKeyPem = cfg?.publicKeyPem ?? process.env.SENDGRID_WEBHOOK_PUBLIC_KEY ?? ''
+  if (!publicKeyPem) {
+    return Response.json({ ok: false, reason: 'missing-config' }, { status: 401 })
+  }
+  const rawBody = await req.text()
+  const sig = req.headers.get('x-twilio-email-event-webhook-signature')
+  const ts = req.headers.get('x-twilio-email-event-webhook-timestamp')
+  const result = await handleSendgridWebhook(rawBody, sig, ts, { publicKeyPem })
+  return Response.json(result.body, { status: result.status })
+}).skipCsrf()

package/stores/[name].stx

@@ -0,0 +1,16 @@
+<script>
+const route = useRoute()
+function name() { return String(route.params.name || '') }
+
+// set the title of the page
+</script>
+
+<main>
+  <div class="flex gap-x-4">
+    <SettingsSidebar />
+
+    <div class="container mx-auto p-4 sm:p-6 lg:p-8">
+      <SettingsFormManager :name="name()" />
+    </div>
+  </div>
+</main>

package/stores/git.ts

@@ -0,0 +1,71 @@
+const owner = 'stacksjs'
+const repo = 'stacks'
+const numberOfCommits = 10
+
+// Assuming you are using a library like Axios for HTTP requests
+const apiUrl = `https://api.github.com/repos/${owner}/${repo}`
+
+const token = ''
+
+declare const defineStore: any
+declare const useHttpFetch: any
+
+export const useGitStore = defineStore('git', {
+  state: (): any => {
+    return {
+      commitLists: [] as any[],
+      workflowRuns: [] as any[],
+      workflowRun: {} as any,
+    }
+  },
+
+  actions: {
+    async fetchCommits(this: any): Promise<void> {
+      const fetch = await useHttpFetch(apiUrl)
+
+      fetch.setToken(token)
+
+      const response = await fetch.get(`/commits?per_page=${numberOfCommits}`)
+
+      this.commitLists = response
+    },
+
+    async fetchWorkflowActions(this: any): Promise<void> {
+      const fetch = await useHttpFetch(apiUrl)
+
+      fetch.setToken(token)
+
+      const response = await fetch.get(`/actions/runs?per_page=${numberOfCommits}`)
+
+      this.workflowRuns = response.workflow_runs
+    },
+
+    async fetchWorkflowAction(this: any, id: number): Promise<void> {
+      const fetch = await useHttpFetch(apiUrl)
+
+      fetch.setToken(token)
+
+      const response = await fetch.get(`/actions/runs/${id}`)
+
+      this.workflowRun = response
+    },
+  },
+
+  getters: {
+    getCommits(state: any): any[] {
+      return state.commitLists
+    },
+
+    hasCommits(state: any) {
+      return state.commitLists.length
+    },
+
+    hasWorkflowRuns(state: any) {
+      return state.workflowRuns.length
+    },
+
+    getWorkflowRuns(state: any): any[] {
+      return state.workflowRuns
+    },
+  },
+})

package/stores/payment.ts

@@ -0,0 +1,474 @@
+type PaymentMethod = any
+type Product = any
+type Subscription = any
+type TransactionHistory = any
+
+const apiUrl = `http://localhost:3008`
+
+export const usePaymentStore = defineStore('payment', () => {
+  // TODO: update the any types
+  const loadingStates = ref<Record<string, boolean>>({})
+  const paymentMethods = ref<PaymentMethod[]>([])
+  const transactionHistory = ref<TransactionHistory[]>([])
+  const defaultPaymentMethod = ref<PaymentMethod>({} as PaymentMethod)
+  const product = ref<Product>({} as Product)
+  const activeSubscription = ref<Subscription>({} as Subscription)
+  const subscriptions = ref<Subscription[]>([])
+  const stripeCustomer = ref<any>({} as any)
+  const planState = ref<boolean>(false)
+
+  const getPaymentMethods = computed(() => paymentMethods.value)
+  const getProduct = computed(() => product.value)
+  const getCurrentPlan = computed(() => activeSubscription.value)
+  const getTransactionHistory = computed(() => transactionHistory.value)
+
+  const isLoading = computed(() => loadingStates.value.size)
+
+  const hasPaymentMethods = computed(() =>
+    paymentMethods.value.length > 0
+    || !(defaultPaymentMethod.value == null
+      || (typeof defaultPaymentMethod.value === 'object' && Object.keys(defaultPaymentMethod.value).length === 0)),
+  )
+
+  const getDefaultPaymentMethod = computed(() => defaultPaymentMethod.value)
+  const getStripeCustomer = computed(() => stripeCustomer.value)
+  const getPlanState = computed(() => planState.value)
+
+  async function fetchSetupIntent(id: number): Promise<string> {
+    const url = `http://localhost:3008/payments/create-setup-intent/${id}`
+
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+      },
+    })
+
+    if (!response.ok) {
+      throw new Error(`Failed to fetch setup intent: ${response.status}`)
+    }
+
+    const client: any = await response.json()
+    const clientSecret = client.client_secret
+
+    return clientSecret
+  }
+
+  async function fetchPaymentIntent(id: number, productId: number): Promise<string> {
+    const body = { productId }
+
+    const url = `http://localhost:3008/payments/create-payment-intent/${id}`
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+      },
+      body: JSON.stringify(body),
+    })
+
+    if (!response.ok) {
+      throw new Error(`Failed to create payment intent: ${response.status}`)
+    }
+
+    const client: any = await response.json()
+    const clientSecret = client.client_secret
+
+    return clientSecret
+  }
+
+  async function storeTransaction(id: number, productId: number): Promise<string> {
+    const body = { productId }
+
+    const url = `http://localhost:3008/payments/store-transaction/${id}`
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+      },
+      body: JSON.stringify(body),
+    })
+
+    if (!response.ok) {
+      throw new Error(`Failed to store transaction: ${response.status}`)
+    }
+
+    const client: any = await response.json()
+    const clientSecret = client.client_secret
+
+    return clientSecret
+  }
+
+  async function subscribeToPlan(body: { type: string, plan: string, description: string }): Promise<string> {
+    const url = 'http://localhost:3008/payments/create-subscription'
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+      },
+      body: JSON.stringify(body),
+    })
+
+    const client: any = await response.json()
+
+    ;(globalThis as any).dispatch('subscription:created')
+
+    return client
+  }
+
+  async function updatePlan(body: { type: string, plan: string, description: string }): Promise<string> {
+    const url = 'http://localhost:3008/payments/update-subscription'
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+      },
+      body: JSON.stringify(body),
+    })
+
+    const client: any = await response.json()
+
+    return client
+  }
+
+  async function setDefaultPaymentMethod(paymentId: string): Promise<string> {
+    const url = 'http://localhost:3008/payments/set-default-payment-method/1'
+
+    const body = { paymentId }
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+      },
+      body: JSON.stringify(body),
+    })
+
+    const res: any = await response.json()
+
+    return res
+  }
+
+  async function setUserDefaultPaymentMethod(setupIntent: string): Promise<string> {
+    const url = 'http://localhost:3008/payments/user-default-payment-method/1'
+
+    const body = { setupIntent }
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+      },
+      body: JSON.stringify(body),
+    })
+
+    const res: any = await response.json()
+
+    return res
+  }
+
+  async function storePaymentMethod(setupIntent: string): Promise<string> {
+    const url = 'http://localhost:3008/payments/payment-method/1'
+
+    const body = { setupIntent }
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+      },
+      body: JSON.stringify(body),
+    })
+
+    const res: any = await response.json()
+
+    return res
+  }
+
+  function openPlans() {
+    planState.value = true
+  }
+
+  function closePlans() {
+    planState.value = false
+  }
+
+  async function fetchSubscriptions(): Promise<void> {
+    setLoadingState('fetchSubscriptions')
+
+    const url = 'http://localhost:3008/payments/fetch-user-subscriptions'
+
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+      },
+    })
+
+    if (response.status !== 204) {
+      const res = await response.json() as any[]
+
+      subscriptions.value = res
+    }
+    await response.json()
+
+    removeLoadingState('fetchSubscriptions')
+  }
+
+  async function cancelPlan(): Promise<void> {
+    const url = 'http://localhost:3008/payments/cancel-subscription'
+
+    const providerId = getCurrentPlan.value.subscription.provider_id
+    const subscriptionId = getCurrentPlan.value.subscription.id
+    const body = { providerId, subscriptionId }
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+      },
+      body: JSON.stringify(body),
+    })
+
+    if (response.status !== 204)
+      await response.json()
+  }
+
+  async function fetchUserPaymentMethods(id: number): Promise<void> {
+    setLoadingState('fetchUserPaymentMethods')
+
+    const response: any = await fetch(`${apiUrl}/payments/payment-methods/${id}`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+      },
+    })
+
+    if (response.status !== 204) {
+      const res = await response.json()
+
+      paymentMethods.value = res
+    }
+
+    removeLoadingState('fetchUserPaymentMethods')
+
+    ;(globalThis as any).dispatch('paymentMethods:fetched')
+  }
+
+  async function fetchTransactionHistory(id: number): Promise<void> {
+    setLoadingState('fetchTransactionHistory')
+
+    const response: any = await fetch(`${apiUrl}/payments/fetch-transaction-history/${id}`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+      },
+    })
+
+    if (response.status !== 204) {
+      const res = await response.json()
+
+      transactionHistory.value = res.data
+    }
+
+    removeLoadingState('fetchTransactionHistory')
+  }
+
+  async function deletePaymentMethod(paymentMethod: number): Promise<void> {
+    setLoadingState('deletePaymentMethod')
+    const url = 'http://localhost:3008/payments/delete-payment-method/1'
+
+    const body = { paymentMethod }
+
+    try {
+      await fetch(url, {
+        method: 'DELETE',
+        headers: {
+          'Content-Type': 'application/json',
+          'Accept': 'application/json',
+        },
+        body: JSON.stringify(body),
+      })
+    }
+    catch (err: any) {
+      // eslint-disable-next-line no-console
+      console.log(err)
+    }
+
+    removeLoadingState('deletePaymentMethod')
+  }
+
+  async function updateDefaultPaymentMethod(paymentMethod: string): Promise<void> {
+    setLoadingState('updateDefaultPaymentMethod')
+
+    const url = 'http://localhost:3008/payments/update-default-payment-method/1'
+
+    const body = { paymentMethod }
+
+    try {
+      await fetch(url, {
+        method: 'PUT',
+        headers: {
+          'Content-Type': 'application/json',
+          'Accept': 'application/json',
+        },
+        body: JSON.stringify(body),
+      })
+    }
+    catch (err: any) {
+      // eslint-disable-next-line no-console
+      console.log(err)
+    }
+
+    removeLoadingState('updateDefaultPaymentMethod')
+  }
+
+  async function fetchStripeCustomer(id: number): Promise<void> {
+    setLoadingState('fetchStripeCustomer')
+
+    const response: any = await fetch(`${apiUrl}/payments/fetch-customer/${id}`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+      },
+    })
+
+    if (response.status !== 204) {
+      const res = await response.json()
+      stripeCustomer.value = res
+    }
+
+    removeLoadingState('fetchStripeCustomer')
+  }
+
+  async function fetchDefaultPaymentMethod(id: number): Promise<void> {
+    setLoadingState('fetchDefaultPaymentMethod')
+
+    const response: any = await fetch(`${apiUrl}/payments/default-payment-method/${id}`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+      },
+    })
+
+    if (response.status !== 204) {
+      const res = await response.json()
+
+      defaultPaymentMethod.value = res
+    }
+
+    removeLoadingState('fetchDefaultPaymentMethod')
+  }
+
+  async function fetchProduct(id: number): Promise<void> {
+    setLoadingState('fetchProduct')
+
+    const response: any = await fetch(`${apiUrl}/payments/fetch-product/${id}`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+      },
+    })
+
+    if (response.status !== 204) {
+      const res = await response.json()
+
+      product.value = res
+    }
+
+    removeLoadingState('fetchProduct')
+  }
+
+  async function fetchUserActivePlan(id: number): Promise<void> {
+    setLoadingState('fetchActivePlan')
+    const response: any = await fetch(`${apiUrl}/payments/fetch-active-subscription/${id}`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+      },
+    })
+
+    if (response.status !== 204) {
+      const res = await response.json()
+
+      activeSubscription.value = res
+    }
+    else {
+      activeSubscription.value = {}
+    }
+
+    removeLoadingState('fetchActivePlan')
+
+    ;(globalThis as any).dispatch('subscription:fetched')
+  }
+
+  function setLoadingState(statusKey: string): void {
+    loadingStates.value[statusKey] = true
+  }
+
+  function removeLoadingState(statusKey: string): void {
+    loadingStates.value[statusKey] = false
+  }
+
+  function isStateLoading(statusKey: string): boolean {
+    return loadingStates.value[statusKey] === undefined ? true : loadingStates.value[statusKey]
+  }
+
+  return {
+    paymentMethods,
+    defaultPaymentMethod,
+    stripeCustomer,
+    product,
+    activeSubscription,
+    transactionHistory,
+    isLoading,
+    getPaymentMethods,
+    getProduct,
+    getCurrentPlan,
+    getTransactionHistory,
+    hasPaymentMethods,
+    getDefaultPaymentMethod,
+    getStripeCustomer,
+    getPlanState,
+    fetchSetupIntent,
+    fetchPaymentIntent,
+    storeTransaction,
+    subscribeToPlan,
+    updatePlan,
+    setDefaultPaymentMethod,
+    setUserDefaultPaymentMethod,
+    storePaymentMethod,
+    openPlans,
+    closePlans,
+    fetchSubscriptions,
+    cancelPlan,
+    fetchUserPaymentMethods,
+    fetchTransactionHistory,
+    deletePaymentMethod,
+    updateDefaultPaymentMethod,
+    fetchStripeCustomer,
+    fetchDefaultPaymentMethod,
+    fetchProduct,
+    isStateLoading,
+    fetchUserActivePlan,
+
+  }
+})