@stacksjs/defaults 0.70.58 → 0.70.60

package/app/Actions/Monitoring/ErrorGroupAction.ts

@@ -0,0 +1,21 @@
+import { Action } from '@stacksjs/actions'
+import { errors } from '@stacksjs/commerce'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'Error Group',
+  description: 'Fetch all errors in a specific group (by type and message)',
+  method: 'GET',
+  async handle(request: RequestInstance) {
+    const type = decodeURIComponent(request.string('type'))
+    const message = decodeURIComponent(request.string('message'))
+
+    if (!type || !message) {
+      return response.json({ error: 'Both type and message are required' }, 400)
+    }
+
+    const results = await errors.fetchByGroup(type, message)
+
+    return response.json({ data: results })
+  },
+})

package/app/Actions/Monitoring/ErrorIgnoreAction.ts

@@ -0,0 +1,25 @@
+import { Action } from '@stacksjs/actions'
+import { errors } from '@stacksjs/commerce'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'Error Ignore',
+  description: 'Ignore all errors in a group',
+  method: 'PATCH',
+  async handle(request: RequestInstance) {
+    const type = request.string('type')
+    const message = request.string('message')
+
+    if (!type || !message) {
+      return response.json({ error: 'Both type and message are required' }, 400)
+    }
+
+    const success = await errors.ignoreGroup(type, message)
+
+    if (!success) {
+      return response.json({ error: 'Failed to ignore errors' }, 500)
+    }
+
+    return response.json({ data: { success: true, message: 'Errors ignored successfully' } })
+  },
+})

package/app/Actions/Monitoring/ErrorIndexAction.ts

@@ -0,0 +1,14 @@
+import { Action } from '@stacksjs/actions'
+import { errors } from '@stacksjs/commerce'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'Error Index',
+  description: 'Fetch all grouped errors (Sentry-like aggregation)',
+  method: 'GET',
+  async handle() {
+    const results = await errors.fetchGrouped()
+
+    return response.json({ data: results })
+  },
+})

package/app/Actions/Monitoring/ErrorResolveAction.ts

@@ -0,0 +1,25 @@
+import { Action } from '@stacksjs/actions'
+import { errors } from '@stacksjs/commerce'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'Error Resolve',
+  description: 'Resolve all errors in a group',
+  method: 'PATCH',
+  async handle(request: RequestInstance) {
+    const type = request.string('type')
+    const message = request.string('message')
+
+    if (!type || !message) {
+      return response.json({ error: 'Both type and message are required' }, 400)
+    }
+
+    const success = await errors.resolveGroup(type, message)
+
+    if (!success) {
+      return response.json({ error: 'Failed to resolve errors' }, 500)
+    }
+
+    return response.json({ data: { success: true, message: 'Errors resolved successfully' } })
+  },
+})

package/app/Actions/Monitoring/ErrorShowAction.ts

@@ -0,0 +1,19 @@
+import { Action } from '@stacksjs/actions'
+import { errors } from '@stacksjs/commerce'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'Error Show',
+  description: 'Fetch a single error by ID',
+  method: 'GET',
+  async handle(request: RequestInstance) {
+    const id = request.getParamAsInt('id')
+    const result = await errors.fetchById(id)
+
+    if (!result) {
+      return response.json({ error: 'Error not found' }, 404)
+    }
+
+    return response.json({ data: result })
+  },
+})

package/app/Actions/Monitoring/ErrorStatsAction.ts

@@ -0,0 +1,14 @@
+import { Action } from '@stacksjs/actions'
+import { errors } from '@stacksjs/commerce'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'Error Stats',
+  description: 'Fetch error statistics',
+  method: 'GET',
+  async handle() {
+    const stats = await errors.fetchStats()
+
+    return response.json({ data: stats })
+  },
+})

package/app/Actions/Monitoring/ErrorTimelineAction.ts

@@ -0,0 +1,14 @@
+import { Action } from '@stacksjs/actions'
+import { errors } from '@stacksjs/commerce'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'Error Timeline',
+  description: 'Fetch error timeline (hourly counts for last 24 hours)',
+  method: 'GET',
+  async handle() {
+    const timeline = await errors.fetchTimeline()
+
+    return response.json({ data: timeline })
+  },
+})

package/app/Actions/Monitoring/ErrorUnresolveAction.ts

@@ -0,0 +1,25 @@
+import { Action } from '@stacksjs/actions'
+import { errors } from '@stacksjs/commerce'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'Error Unresolve',
+  description: 'Unresolve (reopen) all errors in a group',
+  method: 'PATCH',
+  async handle(request: RequestInstance) {
+    const type = request.string('type')
+    const message = request.string('message')
+
+    if (!type || !message) {
+      return response.json({ error: 'Both type and message are required' }, 400)
+    }
+
+    const success = await errors.unresolveGroup(type, message)
+
+    if (!success) {
+      return response.json({ error: 'Failed to unresolve errors' }, 500)
+    }
+
+    return response.json({ data: { success: true, message: 'Errors unresolved successfully' } })
+  },
+})

package/app/Actions/NotifyUser.ts

@@ -0,0 +1,10 @@
+import { Action } from '@stacksjs/actions'
+
+export default new Action({
+  name: 'NotifyUser',
+  description: 'Notify User After Creation',
+  method: 'GET',
+  async handle() {
+    // console.log('test')
+  },
+})

package/app/Actions/Password/PasswordResetAction.ts

@@ -0,0 +1,54 @@
+import { Action } from '@stacksjs/actions'
+import { passwordResets, RateLimiter } from '@stacksjs/auth'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'PasswordResetAction',
+  description: 'Password Reset',
+  method: 'POST',
+  async handle(request) {
+    const token = request.get('token')
+    const password = request.get('password')
+    const passwordConfirmation = request.get('password_confirmation')
+    const email = request.get('email')
+
+    // Validate required fields
+    if (!token || !password || !email) {
+      return response.error('Missing required fields', 422)
+    }
+
+    // Validate password confirmation
+    if (password !== passwordConfirmation) {
+      return response.error('Password confirmation does not match', 422)
+    }
+
+    // Validate password strength (minimum 8 characters)
+    if (password.length < 8) {
+      return response.error('Password must be at least 8 characters', 422)
+    }
+
+    // Rate limit password reset attempts by email
+    const rateLimitKey = `password_reset_attempt:${email.toLowerCase()}`
+    if (await RateLimiter.isRateLimited(rateLimitKey)) {
+      return response.error('Too many password reset attempts. Please try again later.', 429)
+    }
+
+    // Attempt to reset the password
+    // This handles user existence check internally and returns a detailed result
+    const result = await passwordResets(email).resetPassword(token, password)
+
+    if (!result.success) {
+      // Record failed attempt for rate limiting
+      await RateLimiter.recordFailedAttempt(rateLimitKey)
+
+      // Return appropriate error message without leaking user existence
+      // Both "user not found" and "invalid token" return the same generic message
+      return response.error(result.message || 'Invalid or expired reset token', 400)
+    }
+
+    // Clear rate limit on successful reset
+    await RateLimiter.resetAttempts(rateLimitKey)
+
+    return response.success('Password has been reset successfully')
+  },
+})

package/app/Actions/Password/SendPasswordResetEmailAction.ts

@@ -0,0 +1,66 @@
+import { Action } from '@stacksjs/actions'
+import { RateLimiter } from '@stacksjs/auth'
+import { User } from '@stacksjs/orm'
+import { job } from '@stacksjs/queue'
+import { response } from '@stacksjs/router'
+import { schema } from '@stacksjs/validation'
+
+export default new Action({
+  name: 'SendPasswordResetEmailAction',
+  description: 'Send Password Reset Email',
+  method: 'POST',
+  validations: {
+    email: {
+      rule: schema.string().email().required(),
+    },
+  },
+  async handle(request) {
+    console.log('[Action] SendPasswordResetEmailAction.handle() called')
+
+    const email = request.get('email')
+    console.log('[Action] Email from request:', email)
+
+    if (!email) {
+      console.log('[Action] No email provided, returning 422')
+      return response.error('Email is required', 422)
+    }
+
+    // Rate limit password reset requests by email
+    const rateLimitKey = `password_reset:${email.toLowerCase()}`
+    if (await RateLimiter.isRateLimited(rateLimitKey)) {
+      console.log('[Action] Rate limited for:', rateLimitKey)
+      return response.error('Too many password reset attempts. Please try again later.', 429)
+    }
+
+    // Record the attempt
+    await RateLimiter.recordFailedAttempt(rateLimitKey)
+    console.log('[Action] Recorded rate limit attempt')
+
+    // Check if user exists
+    console.log('[Action] Looking up user by email...')
+    const user = await User.where('email', email).first()
+
+    if (!user) {
+      console.log('[Action] User not found for email:', email)
+      return response.error('No account found with this email address.', 404)
+    }
+    console.log('[Action] User found:', user.id)
+
+    // Dispatch password reset email job to queue (with 10 second delay)
+    console.log('[Action] About to dispatch SendPasswordResetEmailJob with 10s delay...')
+    try {
+      await job('SendPasswordResetEmailJob', { email })
+        .onQueue('emails')
+        .dispatch()
+      console.log('[Action] Job dispatched successfully with 10s delay!')
+    }
+    catch (error) {
+      console.error('[Action] Failed to dispatch email job for', email)
+      console.error('[Action] Error:', error)
+      return response.error('Failed to send password reset email. Please try again later.', 500)
+    }
+
+    console.log('[Action] Returning success response')
+    return response.success('Password reset link has been sent to your email.')
+  },
+})

package/app/Actions/Password/VerifyResetTokenAction.ts

@@ -0,0 +1,27 @@
+import { Action } from '@stacksjs/actions'
+import { passwordResets } from '@stacksjs/auth'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'VerifyResetTokenAction',
+  description: 'Verify Password Reset Token',
+  method: 'POST',
+  async handle(request) {
+    const token = request.get('token')
+    const email = request.get('email')
+
+    // Validate required fields
+    if (!token || !email) {
+      return response.error('Token and email are required', 422)
+    }
+
+    // Verify the token
+    const isValid = await passwordResets(email).verifyToken(token)
+
+    if (!isValid) {
+      return response.error('Invalid or expired reset token', 400)
+    }
+
+    return response.success('Token is valid')
+  },
+})

package/app/Actions/Payment/CancelSubscriptionAction.ts

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

package/app/Actions/Payment/CreateCheckoutAction.ts

@@ -0,0 +1,28 @@
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'CreateCheckoutAction',
+  description: 'Create Checkout link for stripe',
+  method: 'POST',
+  async handle(request: RequestInstance) {
+    const user = await request.user()
+
+    if (!user)
+      return response.unauthorized('Authentication required')
+
+    const checkout = await user?.checkout([
+      {
+        priceId: 'price_1QBEfsBv6MhUdo23avVV0kqx',
+        quantity: 1,
+      },
+    ], {
+      enableTax: true,
+      allowPromotions: true,
+      cancel_url: 'https://google.com',
+      success_url: 'https://google.com',
+    })
+
+    return response.json(checkout)
+  },
+})

package/app/Actions/Payment/CreateInvoiceSubscription.ts

@@ -0,0 +1,18 @@
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'CreateInvoiceSubscription',
+  description: 'Create Invoice Subscription for Stripe',
+  method: 'POST',
+  async handle(request: RequestInstance) {
+    const user = await request.user()
+
+    if (!user)
+      return response.unauthorized('Authentication required')
+
+    const subscription = await user?.newSubscriptionInvoice('pro', 'stacks_pro_monthly')
+
+    return response.json(subscription)
+  },
+})

package/app/Actions/Payment/CreatePaymentIntentAction.ts

@@ -0,0 +1,31 @@
+import { Action } from '@stacksjs/actions'
+import { HttpError } from '@stacksjs/error-handling'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'CreatePaymentIntentAction',
+  description: 'Create Payment Intent for stripe',
+  method: 'POST',
+  async handle(request: RequestInstance) {
+    const productId = Number(request.get('productId'))
+
+    const product = await Product.find(productId)
+
+    const user = await request.user()
+
+    if (!user)
+      return response.unauthorized('Authentication required')
+
+    if (!product) {
+      throw new HttpError(422, 'Product not found!')
+    }
+
+    const paymentIntent = await user?.paymentIntent({
+      amount: Number(product.unit_price),
+      currency: 'usd',
+      payment_method_types: ['card'],
+    })
+
+    return response.json(paymentIntent)
+  },
+})

package/app/Actions/Payment/CreateSetupIntentAction.ts

@@ -0,0 +1,20 @@
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'CreateSetupIntentAction',
+  description: 'Create Setup Intent for stripe',
+  method: 'POST',
+  async handle(request: RequestInstance) {
+    const user = await request.user()
+
+    if (!user)
+      return response.unauthorized('Authentication required')
+
+    const setupIntent = await user?.createSetupIntent({
+      payment_method_types: ['card', 'link', 'us_bank_account'],
+    })
+
+    return response.json(setupIntent)
+  },
+})

package/app/Actions/Payment/CreateSubscriptionAction.ts

@@ -0,0 +1,23 @@
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'CreateSubscriptionAction',
+  description: 'Create Subscription for stripe',
+  method: 'POST',
+  async handle(request: RequestInstance) {
+    const type = request.get('type') as string
+    const plan = request.get('plan') as string
+    const period = request.get('period') 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?.newSubscription(plan, type, { description, metadata: { period } })
+
+    return response.json(subscription?.paymentIntent)
+  },
+})

package/app/Actions/Payment/DeleteDefaultPaymentAction.ts

@@ -0,0 +1,18 @@
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'DeleteDefaultPaymentAction',
+  description: 'Delete 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?.deletePaymentMethod(paymentMethod)
+  },
+})

package/app/Actions/Payment/FetchActiveSubscriptionAction.ts

@@ -0,0 +1,18 @@
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'FetchActiveSubscriptionAction',
+  description: 'Fetch the current active subscription',
+  method: 'GET',
+  async handle(request: RequestInstance) {
+    const user = await request.user()
+
+    if (!user)
+      return response.unauthorized('Authentication required')
+
+    const subscription = await user?.activeSubscription()
+
+    return response.json(subscription)
+  },
+})

package/app/Actions/Payment/FetchDefaultPaymentMethodAction.ts

@@ -0,0 +1,18 @@
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'FetchDefaultPaymentMethodAction',
+  description: 'Fetch the users default payment method',
+  method: 'GET',
+  async handle(request: RequestInstance) {
+    const user = await request.user()
+
+    if (!user)
+      return response.unauthorized('Authentication required')
+
+    const paymentMethod = await user?.defaultPaymentMethod()
+
+    return response.json(paymentMethod)
+  },
+})

package/app/Actions/Payment/FetchPaymentCustomerAction.ts

@@ -0,0 +1,18 @@
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'FetchPaymentCustomerAction',
+  description: 'Fetch the payment customer',
+  method: 'GET',
+  async handle(request: RequestInstance) {
+    const user = await request.user()
+
+    if (!user)
+      return response.unauthorized('Authentication required')
+
+    const customer = await user?.asStripeUser()
+
+    return response.json(customer)
+  },
+})

package/app/Actions/Payment/FetchPaymentMethodsAction.ts

@@ -0,0 +1,18 @@
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'FetchPaymentMethodsAction',
+  description: 'Fetch the user payment methods',
+  method: 'GET',
+  async handle(request: RequestInstance) {
+    const user = await request.user()
+
+    if (!user)
+      return response.unauthorized('Authentication required')
+
+    const paymentMethods = await user?.paymentMethods()
+
+    return response.json(paymentMethods)
+  },
+})

package/app/Actions/Payment/FetchProductAction.ts

@@ -0,0 +1,15 @@
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'FetchProductAction',
+  description: 'Fetch the product id',
+  method: 'GET',
+  async handle(request: RequestInstance) {
+    const productId = Number(request.getParam('id'))
+
+    const product = await Product.find(productId)
+
+    return response.json(product)
+  },
+})

package/app/Actions/Payment/FetchTransactionHistoryAction.ts

@@ -0,0 +1,18 @@
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'FetchTransactionHistoryAction',
+  description: 'Fetch the users transaction history',
+  method: 'GET',
+  async handle(request: RequestInstance) {
+    const user = await request.user()
+
+    if (!user)
+      return response.unauthorized('Authentication required')
+
+    const transactions = await PaymentTransaction.where('user_id', user?.id).get()
+
+    return response.json(transactions)
+  },
+})

package/app/Actions/Payment/FetchUserSubscriptionsAction.ts

@@ -0,0 +1,18 @@
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'FetchUserSubscriptionsAction',
+  description: 'Fetch the users subscriptions',
+  method: 'GET',
+  async handle(request: RequestInstance) {
+    const user = await request.user()
+
+    if (!user)
+      return response.unauthorized('Authentication required')
+
+    const subscriptions = await user?.subscriptions
+
+    return response.json(subscriptions)
+  },
+})

package/app/Actions/Payment/SetDefaultPaymentAction.ts

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

package/app/Actions/Payment/SetUserDefaultPaymentAction.ts

@@ -0,0 +1,20 @@
+import { Action } from '@stacksjs/actions'
+import { response } from '@stacksjs/router'
+
+export default new Action({
+  name: 'SetUserDefaultPaymentAction',
+  description: 'Set the customers default payment method from provider callback',
+  method: 'POST',
+  async handle(request: RequestInstance) {
+    const user = await request.user()
+
+    if (!user)
+      return response.unauthorized('Authentication required')
+
+    const paymentId = String(request.get('setupIntent'))
+
+    const paymentMethod = await user?.setUserDefaultPaymentMethod(paymentId)
+
+    return response.json(paymentMethod)
+  },
+})