betterstart-cli 0.0.99 → 0.0.101

package/dist/read-namespaced-template-UXU7OCY3.js

@@ -0,0 +1,13 @@
+import {
+  applyAdminNamespaceToContent,
+  readTemplate
+} from "./chunk-TIJEHWRF.js";
+
+// adapters/next/template-reader/read-namespaced-template.ts
+function readNamespacedTemplate(relativePath, namespace) {
+  return applyAdminNamespaceToContent(readTemplate(relativePath), namespace);
+}
+export {
+  readNamespacedTemplate
+};
+//# sourceMappingURL=read-namespaced-template-UXU7OCY3.js.map

package/dist/read-namespaced-template-UXU7OCY3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../adapters/next/template-reader/read-namespaced-template.ts"],"sourcesContent":["import { applyAdminNamespaceToContent } from '@next-adapter/config/namespace/apply-admin-namespace-to-content.js'\nimport { readTemplate } from './read-template.js'\n\nexport function readNamespacedTemplate(relativePath: string, namespace: string): string {\n  return applyAdminNamespaceToContent(readTemplate(relativePath), namespace)\n}\n"],"mappings":";;;;;;AAGO,SAAS,uBAAuB,cAAsB,WAA2B;AACtF,SAAO,6BAA6B,aAAa,YAAY,GAAG,SAAS;AAC3E;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "betterstart-cli",
-  "version": "0.0.99",
+  "version": "0.0.101",
   "description": "A production ready dashboard,tailored for you in 5 Minutes.",
   "type": "module",
   "main": "./dist/index.js",

package/dist/assets/adapters/next/integrations/resend/actions/resend.ts

@@ -1,138 +0,0 @@
-import type {
-  AdminEmailProvider,
-  PasswordResetEmailInput,
-  SendEmailInput,
-  SendEmailResult
-} from '@admin/actions/email/types'
-import { Resend } from 'resend'
-
-const NOT_CONFIGURED_REASON =
-  'Resend email delivery requires BETTERSTART_RESEND_API_KEY and BETTERSTART_EMAIL_FROM.'
-
-let cachedClient: Resend | null = null
-let cachedApiKey: string | null = null
-
-function getEnvValue(key: string): string | null {
-  const value = process.env[key]?.trim()
-  return value && value.length > 0 ? value : null
-}
-
-function getFromAddress(): string | null {
-  return getEnvValue('BETTERSTART_EMAIL_FROM')
-}
-
-function getResendClient(): Resend | null {
-  const apiKey = getEnvValue('BETTERSTART_RESEND_API_KEY')
-  if (!apiKey) {
-    return null
-  }
-
-  if (!cachedClient || cachedApiKey !== apiKey) {
-    cachedClient = new Resend(apiKey)
-    cachedApiKey = apiKey
-  }
-
-  return cachedClient
-}
-
-function isConfigured(): boolean {
-  return Boolean(getResendClient() && getFromAddress())
-}
-
-function htmlToText(html: string): string {
-  return html
-    .replace(/<style[\s\S]*?<\/style>/gi, '')
-    .replace(/<script[\s\S]*?<\/script>/gi, '')
-    .replace(/<br\s*\/?>/gi, '\n')
-    .replace(/<\/(p|div|h[1-6]|li|tr)>/gi, '\n')
-    .replace(/<[^>]+>/g, '')
-    .replace(/&nbsp;/g, ' ')
-    .replace(/&amp;/g, '&')
-    .replace(/&lt;/g, '<')
-    .replace(/&gt;/g, '>')
-    .replace(/&quot;/g, '"')
-    .replace(/&#39;/g, "'")
-    .replace(/\n{3,}/g, '\n\n')
-    .trim()
-}
-
-async function sendEmail(input: SendEmailInput): Promise<SendEmailResult> {
-  const client = getResendClient()
-  const from = getFromAddress()
-
-  if (!client || !from) {
-    return {
-      delivered: false,
-      reason: NOT_CONFIGURED_REASON
-    }
-  }
-
-  try {
-    const result = await client.emails.send({
-      from,
-      to: input.to,
-      subject: input.subject,
-      html: input.html,
-      text: htmlToText(input.html)
-    })
-
-    if (result.error) {
-      return {
-        delivered: false,
-        reason: result.error.message
-      }
-    }
-
-    return { delivered: true }
-  } catch (error) {
-    return {
-      delivered: false,
-      reason: error instanceof Error ? error.message : 'Resend email delivery failed.'
-    }
-  }
-}
-
-function escapeHtml(value: string): string {
-  return value
-    .replace(/&/g, '&amp;')
-    .replace(/</g, '&lt;')
-    .replace(/>/g, '&gt;')
-    .replace(/"/g, '&quot;')
-    .replace(/'/g, '&#39;')
-}
-
-function renderPasswordResetEmail(input: PasswordResetEmailInput): string {
-  const displayName = input.user.name?.trim() || input.user.email
-  const escapedName = escapeHtml(displayName)
-  const escapedUrl = escapeHtml(input.url)
-
-  return `<!doctype html>
-<html>
-  <body style="margin:0;background:#f8fafc;font-family:Inter,-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;color:#0f172a;">
-    <div style="margin:0 auto;max-width:560px;padding:40px 20px;">
-      <div style="border-radius:12px;background:#ffffff;padding:32px;border:1px solid #e2e8f0;">
-        <h1 style="margin:0 0 16px;font-size:24px;line-height:32px;">Reset your password</h1>
-        <p style="margin:0 0 16px;font-size:16px;line-height:24px;">Hi ${escapedName},</p>
-        <p style="margin:0 0 24px;font-size:16px;line-height:24px;">Use the button below to reset your BetterStart Admin password.</p>
-        <p style="margin:0 0 24px;">
-          <a href="${escapedUrl}" style="display:inline-block;border-radius:8px;background:#0f172a;color:#ffffff;padding:12px 18px;text-decoration:none;font-weight:600;">Reset password</a>
-        </p>
-        <p style="margin:0;color:#64748b;font-size:14px;line-height:20px;">If you did not request this email, you can safely ignore it.</p>
-      </div>
-    </div>
-  </body>
-</html>`
-}
-
-export const resendEmailProvider: AdminEmailProvider = {
-  id: 'resend',
-  isConfigured,
-  sendEmail,
-  async sendPasswordResetEmail(input) {
-    return sendEmail({
-      to: input.user.email,
-      subject: 'Reset your password',
-      html: renderPasswordResetEmail(input)
-    })
-  }
-}

package/dist/assets/adapters/next/templates/init/lib/actions/webhooks/dispatch.ts

@@ -1,134 +0,0 @@
-import type { ActiveWebhookEndpoint } from './internal-get-active-endpoints'
-import db from '@admin/db'
-import { webhookDeliveries } from '@admin/db/schema'
-import { createWebhookEventId, signWebhookPayload } from '@admin/utils/webhook/signature'
-import { and, desc, eq, notInArray } from 'drizzle-orm'
-import { after } from 'next/server'
-import { getActiveEndpointsForEvent } from './internal-get-active-endpoints'
-
-const MAX_ATTEMPTS = 3
-const RETRY_DELAYS_MS = [1_000, 5_000]
-const REQUEST_TIMEOUT_MS = 10_000
-const DELIVERY_LOG_LIMIT = 100
-
-export function emitWebhookEvent(event: string, data: unknown): void {
-  const eventId = createWebhookEventId()
-  const body = JSON.stringify({
-    id: eventId,
-    event,
-    timestamp: new Date().toISOString(),
-    data
-  })
-
-  try {
-    after(() => deliverWebhookEvent(eventId, event, body))
-  } catch (error) {
-    console.error('Webhook dispatch skipped (no request scope):', {
-      event,
-      error
-    })
-  }
-}
-
-async function deliverWebhookEvent(eventId: string, event: string, body: string): Promise<void> {
-  try {
-    const endpoints = await getActiveEndpointsForEvent(event)
-    if (endpoints.length === 0) return
-
-    await Promise.allSettled(
-      endpoints.map((endpoint) => deliverToEndpoint(endpoint, eventId, event, body))
-    )
-  } catch (error) {
-    console.error('Webhook delivery failed:', { event, error })
-  }
-}
-
-async function deliverToEndpoint(
-  endpoint: ActiveWebhookEndpoint,
-  eventId: string,
-  event: string,
-  body: string
-): Promise<void> {
-  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
-    const startedAt = Date.now()
-    let statusCode: number | null = null
-    let errorMessage: string | null = null
-
-    try {
-      const timestamp = Math.floor(Date.now() / 1000).toString()
-      const response = await fetch(endpoint.url, {
-        method: 'POST',
-        headers: {
-          'content-type': 'application/json',
-          'x-webhook-id': eventId,
-          'x-webhook-timestamp': timestamp,
-          'x-webhook-signature': signWebhookPayload(endpoint.secret, timestamp, body)
-        },
-        body,
-        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
-      })
-      statusCode = response.status
-      if (!response.ok) errorMessage = `Webhook returned status ${response.status}`
-    } catch (error) {
-      errorMessage = error instanceof Error ? error.message : 'Webhook request failed'
-    }
-
-    await recordWebhookDelivery({
-      webhookId: endpoint.id,
-      event,
-      eventId,
-      attempt,
-      success: errorMessage === null,
-      statusCode,
-      durationMs: Date.now() - startedAt,
-      error: errorMessage
-    })
-
-    if (errorMessage === null) return
-    if (attempt < MAX_ATTEMPTS) {
-      await new Promise((resolve) => setTimeout(resolve, RETRY_DELAYS_MS[attempt - 1]))
-    }
-  }
-}
-
-export async function recordWebhookDelivery(entry: {
-  webhookId: string
-  event: string
-  eventId: string
-  attempt: number
-  success: boolean
-  statusCode: number | null
-  durationMs: number
-  error: string | null
-}): Promise<void> {
-  try {
-    await db.insert(webhookDeliveries).values(entry)
-    await pruneWebhookDeliveries(entry.webhookId)
-  } catch (error) {
-    console.error('Failed to record webhook delivery:', {
-      event: entry.event,
-      error
-    })
-  }
-}
-
-async function pruneWebhookDeliveries(webhookId: string): Promise<void> {
-  const keepRows = await db
-    .select({ id: webhookDeliveries.id })
-    .from(webhookDeliveries)
-    .where(eq(webhookDeliveries.webhookId, webhookId))
-    .orderBy(desc(webhookDeliveries.createdAt))
-    .limit(DELIVERY_LOG_LIMIT)
-
-  if (keepRows.length < DELIVERY_LOG_LIMIT) return
-
-  await db.delete(webhookDeliveries).where(
-    and(
-      eq(webhookDeliveries.webhookId, webhookId),
-      notInArray(
-        webhookDeliveries.id,
-        keepRows.map((row) => row.id)
-      )
-    )
-  )
-}

package/dist/assets/adapters/next/templates/init/utils/audit/audit.ts

@@ -1,54 +0,0 @@
-const REDACTED_FIELD_PATTERNS = [/password/i, /token/i, /secret/i, /key/i]
-const SYSTEM_FIELD_NAMES = new Set([
-  'id',
-  'createdAt',
-  'updatedAt',
-  'createdBy',
-  'updatedBy',
-  'createdByUser',
-  'updatedByUser'
-])
-
-function shouldTrackField(fieldName: string): boolean {
-  if (SYSTEM_FIELD_NAMES.has(fieldName)) return false
-  return !REDACTED_FIELD_PATTERNS.some((pattern) => pattern.test(fieldName))
-}
-
-function normalizeComparableValue(value: unknown): string {
-  if (value instanceof Date) return value.toISOString()
-  if (Array.isArray(value)) {
-    return JSON.stringify(value.map((item) => normalizeComparableValue(item)))
-  }
-  if (value && typeof value === 'object') {
-    const entries = Object.entries(value as Record<string, unknown>)
-      .sort(([a], [b]) => a.localeCompare(b))
-      .map(([key, item]) => [key, normalizeComparableValue(item)])
-    return JSON.stringify(entries)
-  }
-
-  return JSON.stringify(value ?? null)
-}
-
-export function getTouchedFieldNames(input: Record<string, unknown> | null | undefined): string[] {
-  if (!input) return []
-
-  return Object.keys(input)
-    .filter(shouldTrackField)
-    .sort((a, b) => a.localeCompare(b))
-}
-
-export function getChangedFieldNames(
-  previous: Record<string, unknown> | null | undefined,
-  next: Record<string, unknown> | null | undefined
-): string[] {
-  if (!next) return []
-
-  return Object.keys(next)
-    .filter(shouldTrackField)
-    .filter((fieldName) => {
-      const previousValue = previous?.[fieldName]
-      const nextValue = next[fieldName]
-      return normalizeComparableValue(previousValue) !== normalizeComparableValue(nextValue)
-    })
-    .sort((a, b) => a.localeCompare(b))
-}

package/dist/assets/adapters/next/templates/init/utils/auth/roles.ts

@@ -1,17 +0,0 @@
-import { ADMIN_ACCESS_ROLES, UserRole } from '@admin/types/auth'
-
-export function isUserRole(value: unknown): value is UserRole {
-  return typeof value === 'string' && Object.values(UserRole).includes(value as UserRole)
-}
-
-export function hasRequiredRole(userRole: UserRole, allowedRoles: readonly UserRole[]): boolean {
-  return allowedRoles.includes(userRole)
-}
-
-export function canAccessAdmin(role: unknown): role is UserRole.ADMIN | UserRole.EDITOR {
-  return isUserRole(role) && hasRequiredRole(role, ADMIN_ACCESS_ROLES)
-}
-
-export function getAdminPostLoginPath(role: unknown): '/admin' | '/admin/profile' {
-  return canAccessAdmin(role) ? '/admin' : '/admin/profile'
-}

package/dist/assets/adapters/next/templates/init/utils/date/date.ts

@@ -1,100 +0,0 @@
-import type { DateRange } from 'react-day-picker'
-import { format, isAfter, isValid, parse } from 'date-fns'
-
-const DATE_RANGE_INPUT_FORMAT = 'MMM d, yyyy'
-const DATE_RANGE_PARAM_FORMAT = 'yyyy-MM-dd'
-const DATE_RANGE_TIME_PATTERN = /^([01]\d|2[0-3]):([0-5]\d)$/
-
-export const DATE_RANGE_START_TIME = '00:00'
-export const DATE_RANGE_END_TIME = '23:59'
-
-export function getExclusiveDateUpperBound(value?: string): string | null {
-  if (!value) return null
-
-  const date = new Date(`${value}T00:00:00.000Z`)
-  if (Number.isNaN(date.getTime())) return null
-
-  date.setUTCDate(date.getUTCDate() + 1)
-  return date.toISOString().slice(0, 10)
-}
-
-export function parseDateInputValue(value?: string): Date | undefined {
-  if (!value) return undefined
-
-  const parsed = new Date(`${value}T00:00:00`)
-  return Number.isNaN(parsed.getTime()) ? undefined : parsed
-}
-
-export function buildDateRange(from?: string, to?: string): DateRange | undefined {
-  const fromDate = parseDateInputValue(from)
-  const toDate = parseDateInputValue(to)
-
-  if (!fromDate && !toDate) return undefined
-
-  return {
-    from: fromDate,
-    to: toDate
-  }
-}
-
-export function formatDateRangeInputDate(date?: Date) {
-  return date ? format(date, DATE_RANGE_INPUT_FORMAT) : ''
-}
-
-export function formatDateRangeParamDate(date: Date) {
-  return format(date, DATE_RANGE_PARAM_FORMAT)
-}
-
-function formatDateRangeTriggerDate(date: Date, includeYear = false) {
-  return format(date, includeYear ? 'MMM d, yyyy' : 'MMM d')
-}
-
-export function parseEditableDateRangeDate(value: string) {
-  const trimmedValue = value.trim()
-  if (!trimmedValue) return undefined
-
-  const isoDate = parseDateInputValue(trimmedValue)
-  if (isoDate) return isoDate
-
-  const parsed = parse(trimmedValue, DATE_RANGE_INPUT_FORMAT, new Date())
-  if (isValid(parsed)) return parsed
-
-  const fallback = new Date(trimmedValue)
-  return isValid(fallback) ? fallback : undefined
-}
-
-export function normalizeDateRangeTime(value: string, fallback: string) {
-  return DATE_RANGE_TIME_PATTERN.test(value) ? value : fallback
-}
-
-export function getOrderedDateRange(range?: DateRange) {
-  if (!range?.from) return range
-  if (!range.to || !isAfter(range.from, range.to)) return range
-
-  return {
-    from: range.to,
-    to: range.from
-  }
-}
-
-export function getDateRangeTriggerLabel(
-  from?: Date,
-  to?: Date,
-  placeholder = 'Pick a date range'
-) {
-  if (!from) return placeholder
-  if (!to) return `${formatDateRangeTriggerDate(from, true)} - ...`
-
-  const sameYear = from.getFullYear() === to.getFullYear()
-  const sameMonth = sameYear && from.getMonth() === to.getMonth()
-
-  if (sameMonth) {
-    return `${formatDateRangeTriggerDate(from)} - ${format(to, 'd')}`
-  }
-
-  if (sameYear) {
-    return `${formatDateRangeTriggerDate(from)} - ${formatDateRangeTriggerDate(to)}`
-  }
-
-  return `${formatDateRangeTriggerDate(from, true)} - ${formatDateRangeTriggerDate(to, true)}`
-}