create-ej-app 24.0.0 → 26.0.0

package/template/saas-starter/src/lib/otel.ts

@@ -0,0 +1,27 @@
+import { SpanStatusCode, trace } from '@opentelemetry/api'
+
+function getSpan() {
+  const span = trace.getActiveSpan()
+  return span
+}
+
+export function recordWideEvent(attributes: Record<string, any>) {
+  const span = getSpan()
+  if (!span) return
+
+  span.setAttributes(attributes)
+}
+
+export function recordError(err: unknown) {
+  const span = getSpan()
+  if (!span) return
+
+  span.setStatus({
+    code: SpanStatusCode.ERROR,
+    message: err instanceof Error ? err.message : String(err)
+  })
+
+  span.recordException(err instanceof Error ? err : String(err))
+
+  return span.spanContext().traceId
+}

package/template/saas-starter/src/lib/plans.ts

@@ -0,0 +1,63 @@
+import { env } from '~/env'
+
+export type Plan = {
+  id: 'free' | 'pro' | 'ultimate'
+  name: string
+  maxMembers: number
+  stripePrice?: {
+    monthly: {
+      id: string
+      amount: number
+      currency: string
+    }
+    annual: {
+      id: string
+      amount: number
+      currency: string
+    }
+  }
+  canUseTrial?: boolean
+}
+
+export const PLANS: Plan[] = [
+  {
+    id: 'free',
+    name: 'Free',
+    maxMembers: 1
+  },
+  {
+    id: 'pro',
+    name: 'Pro',
+    maxMembers: 25,
+    stripePrice: {
+      monthly: {
+        id: env.STRIPE_PRICE_PRO_MONTHLY,
+        amount: 2000,
+        currency: 'USD'
+      },
+      annual: {
+        id: env.STRIPE_PRICE_PRO_ANNUAL,
+        amount: 20000,
+        currency: 'USD'
+      }
+    },
+    canUseTrial: true
+  },
+  {
+    id: 'ultimate',
+    name: 'Ultimate',
+    maxMembers: 100,
+    stripePrice: {
+      monthly: {
+        id: env.STRIPE_PRICE_ULTIMATE_MONTHLY,
+        amount: 10000,
+        currency: 'USD'
+      },
+      annual: {
+        id: env.STRIPE_PRICE_ULTIMATE_ANNUAL,
+        amount: 100000,
+        currency: 'USD'
+      }
+    }
+  }
+]

package/template/saas-starter/src/lib/safe-action-client.ts

@@ -0,0 +1,75 @@
+'use client'
+
+import {
+  useMutation,
+  useQuery,
+  type UseMutationOptions,
+  type UseQueryOptions
+} from '@tanstack/react-query'
+import type { SafeActionResult } from 'next-safe-action'
+
+type AnyAction = (
+  ...args: any[]
+) => Promise<SafeActionResult<any, any, any, any, any>>
+type ActionInput<T extends AnyAction> = Parameters<T>[0]
+type ActionData<T extends AnyAction> = Awaited<ReturnType<T>>['data']
+
+class SafeActionError extends Error {
+  constructor(
+    public message: string,
+    public validationErrors?: Record<string, string[] | undefined>
+  ) {
+    super(message)
+  }
+}
+
+export function useSafeActionQuery<TAction extends AnyAction>(
+  key: string,
+  action: TAction,
+  input: ActionInput<TAction>,
+  options?: Omit<UseQueryOptions<ActionData<TAction>>, 'queryKey' | 'queryFn'>
+) {
+  return useQuery({
+    queryKey: [key, input],
+    queryFn: async () => {
+      const result = await action(input)
+
+      if (result?.serverError) {
+        throw new SafeActionError(result.serverError)
+      }
+
+      if (result?.validationErrors) {
+        throw new SafeActionError('Validation failed', result.validationErrors)
+      }
+
+      return result?.data
+    },
+    ...options
+  })
+}
+
+export function useSafeActionMutation<TAction extends AnyAction>(
+  action: TAction,
+  options?: UseMutationOptions<
+    ActionData<TAction>,
+    SafeActionError,
+    ActionInput<TAction>
+  >
+) {
+  return useMutation({
+    mutationFn: async (input: ActionInput<TAction>) => {
+      const result = await action(input)
+
+      if (result?.serverError) {
+        throw new SafeActionError(result.serverError)
+      }
+
+      if (result?.validationErrors) {
+        throw new SafeActionError('Validation failed', result.validationErrors)
+      }
+
+      return result?.data
+    },
+    ...options
+  })
+}

package/template/saas-starter/src/lib/safe-action.ts

@@ -0,0 +1,67 @@
+import { createSafeActionClient } from 'next-safe-action'
+import { getAuthSession } from './auth'
+import { recordWideEvent } from './otel'
+
+export const actionClient = createSafeActionClient().use(
+  async ({ next, ctx }) => {
+    const authSession = await getAuthSession()
+
+    if (authSession)
+      recordWideEvent({
+        'user.id': authSession.user.id,
+        'user.admin': authSession.isAdmin,
+        'session.id': authSession.session.id
+      })
+
+    return next({
+      ctx: {
+        ...ctx,
+        ...authSession
+      }
+    })
+  }
+)
+
+export const authActionClient = actionClient.use(async ({ ctx, next }) => {
+  if (!ctx?.user || !ctx?.session) {
+    throw new Error('Unauthorized')
+  }
+
+  return next({
+    ctx: {
+      ...ctx,
+      user: ctx.user,
+      session: ctx.session
+    }
+  })
+})
+
+export const adminActionClient = authActionClient.use(async ({ ctx, next }) => {
+  if (!ctx.isAdmin) {
+    throw new Error('Forbidden')
+  }
+
+  return next({
+    ctx: {
+      ...ctx,
+      user: ctx.user,
+      session: ctx.session
+    }
+  })
+})
+
+export const superAdminActionClient = adminActionClient.use(
+  async ({ ctx, next }) => {
+    if (!ctx.isSuperAdmin) {
+      throw new Error('Forbidden')
+    }
+
+    return next({
+      ctx: {
+        ...ctx,
+        user: ctx.user,
+        session: ctx.session
+      }
+    })
+  }
+)

package/template/saas-starter/src/lib/siteConfig.ts

@@ -0,0 +1,4 @@
+export const siteConfig = {
+  name: 'Project Name',
+  description: 'Project Description'
+}

package/template/saas-starter/src/lib/storage.ts

@@ -0,0 +1,181 @@
+import {
+  DeleteObjectCommand,
+  PutObjectCommand,
+  S3Client
+} from '@aws-sdk/client-s3'
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner'
+import { createId } from '@paralleldrive/cuid2'
+import { and, eq, lt } from 'drizzle-orm'
+import { db } from '~/db'
+import { fileUploadsTable } from '~/db/schema'
+import { env } from '~/env'
+import {
+  PRESIGNED_URL_TTL_SECONDS,
+  TEMP_CLEANUP_THRESHOLD_MS
+} from './constants'
+
+/*
+R2 Policy need to be set
+[
+  {
+    "AllowedOrigins": [
+      "http://localhost:3000"
+    ],
+    "AllowedMethods": [
+      "PUT"
+    ],
+    "AllowedHeaders": [
+      "content-type",
+      "content-length"
+    ]
+  }
+]
+*/
+
+export function isR2Configured(): boolean {
+  return !!(
+    env.R2_ACCOUNT_ID &&
+    env.R2_ACCESS_KEY_ID &&
+    env.R2_SECRET_ACCESS_KEY &&
+    env.R2_BUCKET_NAME &&
+    env.R2_PUBLIC_URL
+  )
+}
+
+let _r2Client: S3Client | null = null
+
+function getR2Client(): S3Client {
+  if (_r2Client) return _r2Client
+
+  const configured = isR2Configured()
+  if (!configured) {
+    throw new Error('R2 storage is not configured')
+  }
+
+  _r2Client = new S3Client({
+    region: 'auto',
+    endpoint: `https://${env.R2_ACCOUNT_ID}.r2.cloudflarestorage.com`,
+    credentials: {
+      accessKeyId: env.R2_ACCESS_KEY_ID!,
+      secretAccessKey: env.R2_SECRET_ACCESS_KEY!
+    }
+  })
+
+  return _r2Client
+}
+
+export async function deleteFile(key: string): Promise<void> {
+  const client = getR2Client()
+  await client.send(
+    new DeleteObjectCommand({
+      Bucket: env.R2_BUCKET_NAME,
+      Key: key
+    })
+  )
+
+  await db.delete(fileUploadsTable).where(eq(fileUploadsTable.key, key))
+}
+
+export async function generateUploadUrl(params: {
+  filename: string
+  mimeType: string
+  size: number
+  uploadedBy: string
+  organizationId?: string | null
+}): Promise<{
+  uploadUrl: string
+  key: string
+}> {
+  const ext = params.filename.split('.').pop()?.toLowerCase() ?? 'bin'
+  const folder = params.organizationId
+    ? `uploads/organizations/${params.organizationId}`
+    : `uploads/misc`
+
+  const fileId = createId()
+  const key = `${folder}/${fileId}.${ext}`
+
+  const client = getR2Client()
+  const uploadUrl = await getSignedUrl(
+    client,
+    new PutObjectCommand({
+      Bucket: env.R2_BUCKET_NAME!,
+      Key: key,
+      ContentType: params.mimeType,
+      ContentLength: params.size
+    }),
+    { expiresIn: PRESIGNED_URL_TTL_SECONDS }
+  )
+
+  await db.insert(fileUploadsTable).values({
+    id: `file_upload_${fileId}`,
+    key,
+    originalName: params.filename,
+    mimeType: params.mimeType,
+    size: params.size,
+    isTemp: true,
+    uploadedBy: params.uploadedBy,
+    organizationId: params.organizationId
+  })
+
+  return { uploadUrl, key }
+}
+
+export async function confirmUpload(
+  newKey: string,
+  oldKey?: string | null
+): Promise<void> {
+  await db
+    .update(fileUploadsTable)
+    .set({ isTemp: false })
+    .where(eq(fileUploadsTable.key, newKey))
+
+  if (oldKey && isR2Configured()) {
+    await deleteFile(oldKey).catch(() => {
+      // Non-fatal: old file cleanup failure should not block the save
+    })
+  }
+}
+
+export function isR2Key(value: string | null | undefined): value is string {
+  return !!value && !value.startsWith('data:') && !value.startsWith('https://')
+}
+
+export function resolveImageUrl(
+  value: string | null | undefined
+): string | null {
+  if (!value) return null
+  if (!isR2Key(value)) return value
+  if (!isR2Configured()) return null
+  return `${env.R2_PUBLIC_URL}/${value}`
+}
+
+export async function cleanupTempUploads(): Promise<{
+  deleted: number
+  errors: number
+}> {
+  const threshold = new Date(Date.now() - TEMP_CLEANUP_THRESHOLD_MS)
+
+  const stale = await db
+    .select({ id: fileUploadsTable.id, key: fileUploadsTable.key })
+    .from(fileUploadsTable)
+    .where(
+      and(
+        eq(fileUploadsTable.isTemp, true),
+        lt(fileUploadsTable.createdAt, threshold)
+      )
+    )
+
+  let deleted = 0
+  let errors = 0
+
+  for (const file of stale) {
+    try {
+      await deleteFile(file.key)
+      deleted++
+    } catch {
+      errors++
+    }
+  }
+
+  return { deleted, errors }
+}

package/template/saas-starter/src/lib/stripe.ts

@@ -0,0 +1,6 @@
+import Stripe from 'stripe'
+import { env } from '~/env'
+
+export const stripeClient = new Stripe(env.STRIPE_SECRET_KEY, {
+  apiVersion: '2026-05-27.dahlia'
+})

package/template/saas-starter/src/lib/toast-message.ts

@@ -0,0 +1,15 @@
+'use client'
+
+import { toast } from 'sonner'
+
+export const toastSuccessMessage = (message: string) =>
+  toast.success(message, {
+    richColors: true,
+    position: 'top-center'
+  })
+
+export const toastErrorMessage = (message?: string) =>
+  toast.error(message || 'Something went wrong. Please try again later.', {
+    richColors: true,
+    position: 'top-center'
+  })

package/template/saas-starter/src/lib/validations.ts

@@ -0,0 +1,12 @@
+import z from 'zod'
+
+export const phoneValidation = z
+  .string()
+  .trim()
+  .min(10)
+  .max(20)
+  .regex(/^[\d+\-().\s]+$/)
+
+export const emailValidation = z.email().trim().toLowerCase()
+
+export const stringValidation = z.string().trim().min(1).max(255)

package/template/saas-starter/src/scripts/reset-db.ts

@@ -0,0 +1,22 @@
+import { sql } from 'drizzle-orm'
+import { db } from '~/db'
+import { env } from '~/env'
+
+const resetDb = async () => {
+  if (env.APP_ENV === 'production') {
+    throw new Error('Cannot reset database in production environment.')
+  }
+
+  await db.execute(sql`DROP SCHEMA IF EXISTS public CASCADE;`)
+  await db.execute(sql`CREATE SCHEMA public;`)
+}
+
+if (import.meta.main) {
+  try {
+    await resetDb()
+    process.exit(0)
+  } catch (err) {
+    console.error('Error running reset-db:', err)
+    process.exit(1)
+  }
+}

package/template/saas-starter/src/scripts/seed.ts

@@ -0,0 +1,11 @@
+const seedData = async () => {}
+
+if (import.meta.main) {
+  try {
+    await seedData()
+  } catch (err) {
+    console.error('Error seeding data:', err)
+  } finally {
+    process.exit(0)
+  }
+}

package/template/saas-starter/src/scripts/setup-stripe-plans.ts

@@ -0,0 +1,200 @@
+import { writeFile } from 'fs/promises'
+import type Stripe from 'stripe'
+import { env } from '~/env'
+import { PLANS } from '~/lib/plans'
+import { stripeClient } from '~/lib/stripe'
+
+const checkStripePriceExists = async (priceId: string) => {
+  try {
+    await stripeClient.prices.retrieve(priceId)
+    return true
+  } catch (err) {
+    if (
+      err &&
+      typeof err === 'object' &&
+      'code' in err &&
+      (err as { code?: string }).code === 'resource_missing'
+    ) {
+      return false
+    }
+    throw err
+  }
+}
+
+const createStripeProduct = async (name: string, planId: string) => {
+  const newProduct = await stripeClient.products.create({
+    name,
+    metadata: { planId }
+  })
+
+  return newProduct.id
+}
+
+const createStripePrice = async (
+  productId: string,
+  planId: string,
+  interval: 'month' | 'year',
+  amount: number,
+  currency: string
+) => {
+  const newPrice = await stripeClient.prices.create({
+    product: productId,
+    currency,
+    unit_amount: amount,
+    recurring: { interval },
+    metadata: { planId }
+  })
+
+  return newPrice.id
+}
+
+type PaidPlanPrices = {
+  planId: string
+  productId: string
+  monthlyPriceId: string
+  annualPriceId: string
+}
+
+const setupStripePlans = async () => {
+  let newEnvString = ''
+  const paidPlans: PaidPlanPrices[] = []
+
+  for (const plan of PLANS) {
+    if (!plan.stripePrice) continue
+
+    const monthlyExists = await checkStripePriceExists(
+      plan.stripePrice.monthly.id
+    )
+    const annualExists = await checkStripePriceExists(
+      plan.stripePrice.annual.id
+    )
+
+    if ((!monthlyExists && annualExists) || (monthlyExists && !annualExists)) {
+      throw new Error(
+        `Inconsistent Stripe price setup for plan ${plan.name}. Monthly exists: ${monthlyExists}, Annual exists: ${annualExists}`
+      )
+    }
+
+    if (monthlyExists && annualExists) {
+      const price = await stripeClient.prices.retrieve(
+        plan.stripePrice.monthly.id
+      )
+      paidPlans.push({
+        planId: plan.id,
+        productId:
+          typeof price.product === 'string' ? price.product : price.product.id,
+        monthlyPriceId: plan.stripePrice.monthly.id,
+        annualPriceId: plan.stripePrice.annual.id
+      })
+      continue
+    }
+
+    const productId = await createStripeProduct(plan.name, plan.id)
+    const monthlyPriceId = await createStripePrice(
+      productId,
+      plan.id,
+      'month',
+      plan.stripePrice.monthly.amount,
+      plan.stripePrice.monthly.currency
+    )
+
+    newEnvString += `\nSTRIPE_PRICE_${plan.id.toUpperCase()}_MONTHLY="${monthlyPriceId}"`
+
+    const annualPriceId = await createStripePrice(
+      productId,
+      plan.id,
+      'year',
+      plan.stripePrice.annual.amount,
+      plan.stripePrice.annual.currency
+    )
+
+    newEnvString += `\nSTRIPE_PRICE_${plan.id.toUpperCase()}_ANNUAL="${annualPriceId}"`
+
+    paidPlans.push({
+      planId: plan.id,
+      productId,
+      monthlyPriceId,
+      annualPriceId
+    })
+  }
+
+  const portalConfigId = await setupPortalConfiguration(paidPlans)
+  if (portalConfigId) {
+    newEnvString += `\nSTRIPE_PORTAL_CONFIGURATION_ID="${portalConfigId}"`
+  }
+
+  newEnvString = newEnvString.trim()
+
+  if (newEnvString) {
+    await writeFile('stripe.txt', newEnvString)
+    console.info('Stripe setup complete. New values written to stripe.txt')
+  } else {
+    console.info('All Stripe plans and portal config already exist.')
+  }
+}
+
+const setupPortalConfiguration = async (paidPlans: PaidPlanPrices[]) => {
+  if (paidPlans.length === 0) return null
+
+  const params: Stripe.BillingPortal.ConfigurationCreateParams = {
+    features: {
+      customer_update: {
+        enabled: true,
+        allowed_updates: ['address', 'name', 'tax_id']
+      },
+      invoice_history: { enabled: true },
+      payment_method_update: { enabled: true },
+      subscription_cancel: {
+        enabled: true,
+        mode: 'at_period_end',
+        cancellation_reason: {
+          enabled: true,
+          options: [
+            'too_expensive',
+            'missing_features',
+            'switched_service',
+            'unused',
+            'other'
+          ]
+        }
+      },
+      subscription_update: {
+        enabled: true,
+        default_allowed_updates: ['price'],
+        proration_behavior: 'create_prorations',
+        products: paidPlans.map(p => ({
+          product: p.productId,
+          prices: [p.monthlyPriceId, p.annualPriceId]
+        }))
+      }
+    }
+  }
+
+  const existingId = env.STRIPE_PORTAL_CONFIGURATION_ID
+  if (existingId) {
+    try {
+      await stripeClient.billingPortal.configurations.update(existingId, params)
+      return null
+    } catch (err) {
+      const isMissing =
+        err &&
+        typeof err === 'object' &&
+        'code' in err &&
+        (err as { code?: string }).code === 'resource_missing'
+      if (!isMissing) throw err
+    }
+  }
+
+  const created = await stripeClient.billingPortal.configurations.create(params)
+  return created.id
+}
+
+if (import.meta.main) {
+  try {
+    await setupStripePlans()
+  } catch (err) {
+    console.error('Error setting up stripe plans:', err)
+  } finally {
+    process.exit(0)
+  }
+}