betterstart-cli 0.0.104 → 0.0.105

package/dist/assets/adapters/next/templates/renderers/generators/form-pipeline/form-actions/generate-form-actions.ts

@@ -1,505 +0,0 @@
-export function renderFormActionsSearchTemplate({ map }: { map: string }): string {
-  return `    const search = filters?.search
-    if (search && typeof search === 'string' && search.trim()) {
-      const searchTerm = \`%\${search.trim().toLowerCase()}%\`
-      conditions.push(
-        or(
-${map}
-        )
-      )
-    }
-`
-}
-
-export function renderFormActionsComponentTemplate({
-  pascal,
-  dataFields,
-  formName,
-  idPlaceholder
-}: {
-  pascal: string
-  dataFields: string
-  formName: string
-  idPlaceholder: string
-}): string {
-  return `export interface ${pascal}SubmissionData {
-  id: string
-${dataFields}
-  ipAddress: string | null
-  userAgent: string | null
-  submittedAt: string
-  createdAt: string
-  updatedAt: string
-}
-
-export interface ${pascal}SubmissionsResponse {
-  submissions: ${pascal}SubmissionData[]
-  total: number
-}
-
-export interface Get${pascal}SubmissionsFilters {
-  search?: string
-  submittedAtFrom?: string
-  submittedAtTo?: string
-  limit?: number
-  offset?: number
-  orderBy?: string
-  orderDirection?: 'asc' | 'desc'
-}
-
-export interface Create${pascal}SubmissionInput {
-${dataFields}
-  ipAddress?: string
-  userAgent?: string
-}
-
-export interface Create${pascal}SubmissionResult {
-  success: boolean
-  error?: string
-  submission?: ${pascal}SubmissionData
-}
-
-export interface Delete${pascal}SubmissionResult {
-  success: boolean
-  error?: string
-  count?: number
-}
-
-export const CACHE_TAG = '${formName}:submissions:all'
-export const CACHE_TAG_BY_ID = (id: string) => \`${formName}:submissions:id:${idPlaceholder}\`
-`
-}
-
-export function renderFormActionsServerActionTemplate({
-  sort,
-  tableName,
-  cacheReadImport,
-  pascal,
-  exclusiveDateUpperBoundSource,
-  sortableColumnsMap,
-  cacheLifeLine,
-  searchBlock,
-  formName
-}: {
-  sort: string
-  tableName: string
-  cacheReadImport: string
-  pascal: string
-  exclusiveDateUpperBoundSource: string
-  sortableColumnsMap: string
-  cacheLifeLine: string
-  searchBlock: string
-  formName: string
-}): string {
-  return `'use server'
-
-import { ${sort} } from 'drizzle-orm'
-import db from '@admin/db'
-import { ${tableName} } from '@admin/db/schema'
-${cacheReadImport}
-import { CACHE_TAG } from './types'
-import type {
-  Get${pascal}SubmissionsFilters,
-  ${pascal}SubmissionsResponse,
-  ${pascal}SubmissionData
-} from './types'
-
-${exclusiveDateUpperBoundSource}
-
-const SORTABLE_COLUMNS = {
-${sortableColumnsMap}
-} as const
-
-export async function get${pascal}Submissions(
-  filters?: Get${pascal}SubmissionsFilters
-): Promise<${pascal}SubmissionsResponse> {
-  'use cache'${cacheLifeLine}
-  cacheTag(CACHE_TAG)
-
-  try {
-    const conditions = []
-${searchBlock}    if (filters?.submittedAtFrom) {
-      conditions.push(gte(${tableName}.submittedAt, filters.submittedAtFrom))
-    }
-    const submittedAtExclusiveTo = getExclusiveDateUpperBound(filters?.submittedAtTo)
-    if (submittedAtExclusiveTo) {
-      conditions.push(lt(${tableName}.submittedAt, submittedAtExclusiveTo))
-    }
-
-    const query = db.select().from(${tableName})
-
-    const sortColumn = filters?.orderBy && filters.orderBy in SORTABLE_COLUMNS
-      ? SORTABLE_COLUMNS[filters.orderBy as keyof typeof SORTABLE_COLUMNS]
-      : ${tableName}.submittedAt
-    const sortFn =
-      filters?.orderBy && filters.orderBy in SORTABLE_COLUMNS
-        ? filters.orderDirection === 'desc'
-          ? desc
-          : asc
-        : desc
-    const orderClause = sortFn(sortColumn)
-
-    const orderedQuery = conditions.length > 0
-      ? query.where(and(...conditions)).orderBy(orderClause)
-      : query.orderBy(orderClause)
-
-    const limit = filters?.limit
-    const offset = filters?.offset
-    const isPaginated = typeof limit === 'number' && limit > 0
-    let results: unknown[]
-    if (isPaginated) {
-      const paginatedQuery = typeof offset === 'number' && offset > 0
-        ? orderedQuery.limit(limit).offset(offset)
-        : orderedQuery.limit(limit)
-      results = await paginatedQuery
-    } else {
-      results = await orderedQuery
-    }
-
-    const total = isPaginated
-      ? Number(
-          (
-            await db
-              .select({ count: sql\`count(*)\` })
-              .from(${tableName})
-              .where(conditions.length > 0 ? and(...conditions) : undefined)
-          )[0]?.count ?? 0
-        )
-      : results.length
-
-    return {
-      submissions: results as ${pascal}SubmissionData[],
-      total
-    }
-  } catch (error) {
-    console.error('Error fetching ${formName} submissions:', error)
-    throw new Error('Failed to fetch ${formName} submissions')
-  }
-}
-`
-}
-
-export function renderFormActionsServerActionDetailsTemplate({
-  tableName,
-  cacheReadImport,
-  pascal,
-  cacheLifeLine,
-  formName
-}: {
-  tableName: string
-  cacheReadImport: string
-  pascal: string
-  cacheLifeLine: string
-  formName: string
-}): string {
-  return `'use server'
-
-import { eq } from 'drizzle-orm'
-import db from '@admin/db'
-import { ${tableName} } from '@admin/db/schema'
-${cacheReadImport}
-import { CACHE_TAG, CACHE_TAG_BY_ID } from './types'
-import type { ${pascal}SubmissionData } from './types'
-
-export async function get${pascal}Submission(id: string): Promise<${pascal}SubmissionData | null> {
-  'use cache'${cacheLifeLine}
-  cacheTag(CACHE_TAG_BY_ID(id))
-  cacheTag(CACHE_TAG)
-
-  try {
-    const [submission] = await db
-      .select()
-      .from(${tableName})
-      .where(eq(${tableName}.id, id))
-      .limit(1)
-    return (submission as ${pascal}SubmissionData) ?? null
-  } catch (error) {
-    console.error(\`Error fetching ${formName} submission \${id}:\`, error)
-    throw new Error('Failed to fetch ${formName} submission')
-  }
-}
-`
-}
-
-export function renderFormActionsServerActionLabelTemplate({
-  tableName,
-  cacheInvalidationFn,
-  mailchimpImport,
-  lifecycleHookImport,
-  pascal,
-  createLifecycleContext,
-  beforeHook,
-  validation,
-  formSettingsKey,
-  schemaNotificationFallback,
-  formName,
-  schemaLabel,
-  submitterEmailFieldNull,
-  mailchimpCall,
-  createResultLifecycleContext,
-  afterHook
-}: {
-  tableName: string
-  cacheInvalidationFn: string
-  mailchimpImport: string
-  lifecycleHookImport: string
-  pascal: string
-  createLifecycleContext: string
-  beforeHook: string
-  validation: string
-  formSettingsKey: string
-  schemaNotificationFallback: string
-  formName: string
-  schemaLabel: string
-  submitterEmailFieldNull: string
-  mailchimpCall: string
-  createResultLifecycleContext: string
-  afterHook: string
-}): string {
-  return `'use server'
-
-import { getSession } from '@admin/auth/middleware'
-import db from '@admin/db'
-import { ${tableName} } from '@admin/db/schema'
-import { getFormSettings } from '@admin/actions/forms'
-import { sendFormEmails } from '@admin/actions/email/send-form-emails'
-import { getTouchedFieldNames } from '@admin/utils/audit/get-touched-field-names'
-import { ${cacheInvalidationFn} } from 'next/cache'
-${mailchimpImport}
-import { CACHE_TAG, CACHE_TAG_BY_ID } from './types'
-${lifecycleHookImport}
-import type { Create${pascal}SubmissionInput, Create${pascal}SubmissionResult, ${pascal}SubmissionData } from './types'
-
-export async function create${pascal}Submission(
-  data: Create${pascal}SubmissionInput
-): Promise<Create${pascal}SubmissionResult> {
-  try {
-    const session = await getSession()
-    const now = new Date().toISOString()
-    const auditRequestMetadata = await getAuditRequestMetadata()
-    const changedFields = getTouchedFieldNames(data as unknown as Record<string, unknown>)
-    const lifecycleContext = ${createLifecycleContext}
-    ${beforeHook}
-
-    ${validation}
-
-    const [submission] = await db
-      .insert(${tableName})
-      .values({
-        ...data,
-        submittedAt: now
-      })
-      .returning()
-    const created${pascal}Submission = submission as ${pascal}SubmissionData
-
-    const settings = await getFormSettings('${formSettingsKey}')
-    const notificationEmails = settings?.notificationEmails
-      ? settings.notificationEmails.split(',').map((e: string) => e.trim()).filter(Boolean)
-      : ${schemaNotificationFallback}
-
-    await sendFormEmails({
-      formName: '${formName}',
-      formLabel: '${schemaLabel}',
-      notificationEmails,
-      submitterEmail: ${submitterEmailFieldNull},
-      submissionData: { ...data },
-      submittedAt: created${pascal}Submission.submittedAt,
-    })${mailchimpCall}
-
-    ${cacheInvalidationFn}(CACHE_TAG)
-    ${cacheInvalidationFn}(CACHE_TAG_BY_ID(created${pascal}Submission.id))
-    const created${pascal}SubmissionContext = ${createResultLifecycleContext}
-    ${afterHook}
-
-    return {
-      success: true,
-      submission: created${pascal}Submission
-    }
-  } catch (error) {
-    console.error('Error creating ${formName} submission:', error)
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to create ${formName} submission'
-    }
-  }
-}
-`
-}
-
-export function renderFormActionsServerActionBeforeDeleteTemplate({
-  tableName,
-  cacheInvalidationFn,
-  lifecycleHookImport,
-  pascal,
-  deleteLifecycleContext,
-  beforeHook,
-  afterHook,
-  formName
-}: {
-  tableName: string
-  cacheInvalidationFn: string
-  lifecycleHookImport: string
-  pascal: string
-  deleteLifecycleContext: string
-  beforeHook: string
-  afterHook: string
-  formName: string
-}): string {
-  return `'use server'
-
-import { getSession } from '@admin/auth/middleware'
-import { eq } from 'drizzle-orm'
-import db from '@admin/db'
-import { ${tableName} } from '@admin/db/schema'
-import { ${cacheInvalidationFn} } from 'next/cache'
-import { CACHE_TAG, CACHE_TAG_BY_ID } from './types'
-${lifecycleHookImport}
-import type { Delete${pascal}SubmissionResult } from './types'
-
-export async function delete${pascal}Submission(id: string): Promise<Delete${pascal}SubmissionResult> {
-  try {
-    const session = await getSession()
-    const now = new Date().toISOString()
-    const auditRequestMetadata = await getAuditRequestMetadata()
-    const lifecycleContext = ${deleteLifecycleContext}
-    ${beforeHook}
-
-    await db.delete(${tableName}).where(eq(${tableName}.id, id))
-    ${cacheInvalidationFn}(CACHE_TAG)
-    ${cacheInvalidationFn}(CACHE_TAG_BY_ID(id))
-    ${afterHook}
-    return { success: true }
-  } catch (error) {
-    console.error(\`Error deleting ${formName} submission \${id}:\`, error)
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to delete ${formName} submission'
-    }
-  }
-}
-`
-}
-
-export function renderFormActionsServerActionBeforeDeleteBranchTemplate({
-  tableName,
-  cacheInvalidationFn,
-  lifecycleHookImport,
-  pascal,
-  deleteLifecycleContext,
-  beforeHook,
-  afterHook,
-  formName
-}: {
-  tableName: string
-  cacheInvalidationFn: string
-  lifecycleHookImport: string
-  pascal: string
-  deleteLifecycleContext: string
-  beforeHook: string
-  afterHook: string
-  formName: string
-}): string {
-  return `'use server'
-
-import { getSession } from '@admin/auth/middleware'
-import { eq, or } from 'drizzle-orm'
-import db from '@admin/db'
-import { ${tableName} } from '@admin/db/schema'
-import { ${cacheInvalidationFn} } from 'next/cache'
-import { CACHE_TAG, CACHE_TAG_BY_ID } from './types'
-${lifecycleHookImport}
-import type { Delete${pascal}SubmissionResult } from './types'
-
-export async function deleteBulk${pascal}Submissions(ids: string[]): Promise<Delete${pascal}SubmissionResult> {
-  try {
-    if (ids.length === 0) return { success: true, count: 0 }
-    const session = await getSession()
-    const now = new Date().toISOString()
-    const auditRequestMetadata = await getAuditRequestMetadata()
-    const lifecycleContexts = ids.map((id) => (${deleteLifecycleContext}))
-
-    for (const lifecycleContext of lifecycleContexts) {
-      ${beforeHook}
-    }
-
-    await db.delete(${tableName}).where(
-      or(...ids.map(id => eq(${tableName}.id, id)))
-    )
-    ${cacheInvalidationFn}(CACHE_TAG)
-    for (const id of ids) {
-      ${cacheInvalidationFn}(CACHE_TAG_BY_ID(id))
-    }
-    for (const lifecycleContext of lifecycleContexts) {
-      ${afterHook}
-    }
-    return { success: true, count: ids.length }
-  } catch (error) {
-    console.error(\`Error bulk deleting ${formName} submissions:\`, error)
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Failed to bulk delete ${formName} submissions'
-    }
-  }
-}
-`
-}
-
-export function renderFormActionsServerActionDetailsBranchTemplate({
-  pascal,
-  kebab
-}: {
-  pascal: string
-  kebab: string
-}): string {
-  return `'use server'
-
-import { get${pascal}Submissions } from './get-${kebab}-submissions'
-
-import { EXCLUSIVE_DATE_UPPER_BOUND_SOURCE } from '@cli-constants/generators.js'
-import { SEARCHABLE_FORM_FIELD_TYPES, SORTABLE_FORM_FIELD_TYPES } from '@cli-constants/schema-codegen.js'
-export async function export${pascal}SubmissionsCSV(): Promise<string> {
-  const { submissions } = await get${pascal}Submissions()
-  if (submissions.length === 0) return ''
-  const headers = Object.keys(submissions[0]).join(',')
-  const rows = submissions.map((sub) =>
-    Object.values(sub)
-      .map((val: unknown) => {
-        if (val === null || val === undefined) return ''
-        const str = String(val)
-        if (str.includes(',') || str.includes('"') || str.includes('\\n')) {
-          return \`"\${str.replace(/"/g, '""')}"\`
-        }
-        return str
-      })
-      .join(',')
-  )
-  return [headers, ...rows].join('\\n')
-}
-`
-}
-
-export function renderFormActionsContentTemplate({
-  pascal,
-  kebab,
-  exportBarrelLine
-}: {
-  pascal: string
-  kebab: string
-  exportBarrelLine: string
-}): string {
-  return `export type {
-  ${pascal}SubmissionData,
-  ${pascal}SubmissionsResponse,
-  Get${pascal}SubmissionsFilters,
-  Create${pascal}SubmissionInput,
-  Create${pascal}SubmissionResult,
-  Delete${pascal}SubmissionResult
-} from './types'
-export { get${pascal}Submissions } from './get-${kebab}-submissions'
-export { get${pascal}Submission } from './get-${kebab}-submission'
-export { create${pascal}Submission } from './create-${kebab}-submission'
-export { delete${pascal}Submission } from './delete-${kebab}-submission'
-export { deleteBulk${pascal}Submissions } from './delete-bulk-${kebab}-submissions'${exportBarrelLine}
-export { CACHE_TAG, CACHE_TAG_BY_ID } from './types'
-`
-}

package/dist/assets/adapters/next/templates/renderers/generators/form-pipeline/form-component-multistep/build-component-source.ts

@@ -1,197 +0,0 @@
-export function renderBuildComponentSourceContentTemplate({
-  pPascal
-}: {
-  pPascal: string
-}): string {
-  return `    <NuqsAdapter>
-      <React.Suspense fallback={null}>
-        <${pPascal}FormInner />
-      </React.Suspense>
-    </NuqsAdapter>`
-}
-
-export function renderBuildComponentSourceGeneratedFunctionTemplate({
-  pPascal,
-  providerOpen
-}: {
-  pPascal: string
-  providerOpen: string
-}): string {
-  return `\nexport function ${pPascal}Form() {
-  return (
-${providerOpen}
-  )
-}\n`
-}
-
-export function renderBuildComponentSourceClientModuleTemplate({
-  pHasListFieldsTrash2,
-  pRhfImport,
-  pPascal,
-  pActionImportPath,
-  pZodFields,
-  fieldErrorHelper,
-  pStepsConst,
-  pDefaults,
-  pFieldArraySetup,
-  pWatchSetup,
-  pSuccessHandler,
-  pSuccessMessage,
-  pStepContentBlocks,
-  pSubmitText,
-  exportWrapper
-}: {
-  pHasListFieldsTrash2: string
-  pRhfImport: string
-  pPascal: string
-  pActionImportPath: string
-  pZodFields: string
-  fieldErrorHelper: string
-  pStepsConst: string
-  pDefaults: string
-  pFieldArraySetup: string
-  pWatchSetup: string
-  pSuccessHandler: string
-  pSuccessMessage: string
-  pStepContentBlocks: string
-  pSubmitText: string
-  exportWrapper: string
-}): string {
-  return `'use client'
-
-import * as React from 'react'
-import { standardSchemaResolver } from '@hookform/resolvers/standard-schema'
-import { ChevronLeft, ChevronRight${pHasListFieldsTrash2} } from 'lucide-react'
-import { createParser, useQueryState } from 'nuqs'
-import { NuqsAdapter } from 'nuqs/adapters/next/app'
-${pRhfImport}
-import { z } from 'zod/v3'
-import { create${pPascal}Submission } from '@admin/actions/${pActionImportPath}'
-
-const formSchema = z.object({
-${pZodFields}
-})
-
-type FormValues = z.infer<typeof formSchema>
-${fieldErrorHelper}
-
-${pStepsConst}
-
-const stepParser = createParser({
-  parse(value) {
-    if (!/^\\d+$/.test(value)) {
-      return null
-    }
-    const step = Number.parseInt(value, 10)
-    if (!Number.isInteger(step) || step < 0 || step >= STEPS.length) {
-      return null
-    }
-    return step
-  },
-  serialize(value) {
-    return String(value)
-  }
-}).withDefault(0)
-
-function ${pPascal}FormInner() {
-  const [currentStep, setCurrentStep] = useQueryState('step', stepParser)
-  const [submitted, setSubmitted] = React.useState(false)
-  const [submitting, startSubmitTransition] = React.useTransition()
-
-  const form = useForm<FormValues>({
-    resolver: standardSchemaResolver(formSchema),
-    defaultValues: {
-${pDefaults}
-    },
-  })
-
-${pFieldArraySetup}${pWatchSetup}
-  async function handleNext() {
-    const stepFields = STEPS[currentStep].fields as (keyof FormValues)[]
-    const isValid = await form.trigger(stepFields, { shouldFocus: true })
-    if (isValid) {
-      setCurrentStep(currentStep + 1)
-    }
-  }
-
-  function handleBack() {
-    setCurrentStep(currentStep - 1)
-  }
-
-  function onSubmit(values: FormValues) {
-    startSubmitTransition(async () => {
-      try {
-        const result = await create${pPascal}Submission(values)
-        if (result.success) {
-          ${pSuccessHandler}
-        } else {
-          form.setError('root', { message: result.error || 'Something went wrong' })
-        }
-      } catch {
-        form.setError('root', { message: 'Something went wrong. Please try again.' })
-      }
-    })
-  }
-
-  if (submitted) {
-    return (
-      <div className="rounded-sm border p-6 text-center">
-        <h3 className="text-lg font-semibold">Thank you!</h3>
-        <p className="mt-2 text-muted-foreground">${pSuccessMessage}</p>
-      </div>
-    )
-  }
-
-  return (
-    <form onSubmit={(event) => event.preventDefault()} className="space-y-8">
-        <div>
-          <h3 className="text-lg font-semibold">{STEPS[currentStep].label}</h3>
-          {'description' in STEPS[currentStep] && STEPS[currentStep].description && (
-            <p className="text-sm text-muted-foreground mt-1">{STEPS[currentStep].description}</p>
-          )}
-        </div>
-
-        <div key={currentStep} className="animate-in fade-in duration-300 space-y-6">
-${pStepContentBlocks}
-        </div>
-
-        {form.formState.errors.root && (
-          <p className="text-sm text-destructive">{form.formState.errors.root.message}</p>
-        )}
-
-        <div className="flex justify-between">
-          <button
-            type="button"
-            onClick={handleBack}
-            disabled={currentStep === 0}
-            className="inline-flex h-9 items-center justify-center rounded-md border border-input bg-background px-4 py-2 text-sm font-medium shadow-xs transition-colors hover:bg-accent hover:text-accent-foreground disabled:pointer-events-none disabled:opacity-50"
-          >
-            <ChevronLeft className="size-4" />
-            Back
-          </button>
-          {currentStep < STEPS.length - 1 ? (
-            <button
-              type="button"
-              onClick={handleNext}
-              className="inline-flex h-9 items-center justify-center rounded-md bg-primary px-4 py-2 text-sm font-medium text-primary-foreground shadow-xs transition-colors hover:bg-primary/90 disabled:pointer-events-none disabled:opacity-50"
-            >
-              Next
-              <ChevronRight className="ml-2 size-4" />
-            </button>
-          ) : (
-            <button
-              type="button"
-              disabled={submitting}
-              aria-busy={submitting}
-              onClick={() => form.handleSubmit(onSubmit)()}
-              className="inline-flex h-9 items-center justify-center rounded-md bg-primary px-4 py-2 text-sm font-medium text-primary-foreground shadow-xs transition-colors hover:bg-primary/90 disabled:pointer-events-none disabled:opacity-50"
-            >
-              {submitting ? 'Submitting…' : ${pSubmitText}}
-            </button>
-          )}
-        </div>
-      </form>
-  )
-}
-${exportWrapper}`
-}

package/dist/assets/adapters/next/templates/renderers/generators/form-pipeline/form-component-shared/build-field-error-helper.ts

@@ -1,16 +0,0 @@
-export function renderBuildFieldErrorHelperSegmentTemplate(): string {
-  return `function getFieldErrorMessage(errors: FieldErrors<FormValues>, path: string): string | undefined {
-  let current: unknown = errors
-  for (const segment of path.split('.')) {
-    if (!current || typeof current !== 'object') {
-      return undefined
-    }
-    current = (current as Record<string, unknown>)[segment]
-  }
-  if (current && typeof current === 'object' && 'message' in current) {
-    const message = (current as { message?: unknown }).message
-    return typeof message === 'string' ? message : undefined
-  }
-  return undefined
-}`
-}