betterstart-cli 0.0.103 → 0.0.104

package/dist/assets/adapters/next/templates/renderers/generators/actions/entity-file-contents/gen-get-select-options-content.ts

@@ -0,0 +1,55 @@
+export function renderGenGetSelectOptionsContentServerActionTemplate({
+  ctxSelectOptionsTableVar,
+  ctxCacheReadImport,
+  ctxCamelSingular,
+  ctxSingular,
+  selectOptionFieldNames,
+  ctxCacheLifeLine,
+  ctxSingularText
+}: {
+  ctxSelectOptionsTableVar: string
+  ctxCacheReadImport: string
+  ctxCamelSingular: string
+  ctxSingular: string
+  selectOptionFieldNames: string
+  ctxCacheLifeLine: string
+  ctxSingularText: string
+}): string {
+  return `'use server'
+
+import db from '@admin/db'
+import { ${ctxSelectOptionsTableVar} } from '@admin/db/schema'
+import { asc, eq } from 'drizzle-orm'
+${ctxCacheReadImport}
+import { ${ctxCamelSingular}SelectOptionsCacheTags } from './types'
+import type { ${ctxSingular}SelectOption, ${ctxSingular}SelectOptionFieldName } from './types'
+
+const SELECT_OPTION_FIELDS = [${selectOptionFieldNames}] as const
+
+function isSelectOptionFieldName(fieldName: string): fieldName is ${ctxSingular}SelectOptionFieldName {
+  return (SELECT_OPTION_FIELDS as readonly string[]).includes(fieldName)
+}
+
+export async function get${ctxSingular}SelectOptions(
+  fieldName: ${ctxSingular}SelectOptionFieldName
+): Promise<${ctxSingular}SelectOption[]> {
+  'use cache'${ctxCacheLifeLine}
+  cacheTag(${ctxCamelSingular}SelectOptionsCacheTags.byField(fieldName))
+
+  if (!isSelectOptionFieldName(fieldName)) return []
+
+  try {
+    const rows = await db
+      .select()
+      .from(${ctxSelectOptionsTableVar})
+      .where(eq(${ctxSelectOptionsTableVar}.fieldName, fieldName))
+      .orderBy(asc(${ctxSelectOptionsTableVar}.label))
+
+    return rows as ${ctxSingular}SelectOption[]
+  } catch (error) {
+    console.error('Error fetching ${ctxSingularText} select options:', error)
+    return []
+  }
+}
+`
+}

package/dist/assets/adapters/next/templates/renderers/generators/actions/entity-file-contents/gen-get-versions-content.ts

@@ -0,0 +1,19 @@
+export function renderGenGetVersionsContentServerActionTemplate({
+  ctxSingular,
+  ctxPlural
+}: {
+  ctxSingular: string
+  ctxPlural: string
+}): string {
+  return `'use server'
+
+import { getEntityVersions } from '@admin/actions/entity-versions'
+import type { EntityVersionWithAuthor } from '@admin/actions/entity-versions'
+
+export async function getVersionsBy${ctxSingular}Id(
+  id: string
+): Promise<EntityVersionWithAuthor[]> {
+  return getEntityVersions('${ctxPlural}', id)
+}
+`
+}

package/dist/assets/adapters/next/templates/renderers/generators/actions/entity-file-contents/gen-m2m-files.ts

@@ -0,0 +1,151 @@
+export function renderGenM2MFilesServerActionTemplate({
+  junctionVar,
+  ctxCacheReadImport,
+  ctxCamelPlural,
+  relPascal,
+  ctxSingular,
+  ctxSingularText,
+  ctxCacheLifeLine,
+  relIdCol,
+  entityIdCol,
+  rel
+}: {
+  junctionVar: string
+  ctxCacheReadImport: string
+  ctxCamelPlural: string
+  relPascal: string
+  ctxSingular: string
+  ctxSingularText: string
+  ctxCacheLifeLine: string
+  relIdCol: string
+  entityIdCol: string
+  rel: string
+}): string {
+  return `'use server'
+
+import db from '@admin/db'
+import { ${junctionVar} } from '@admin/db/schema'
+import { eq } from 'drizzle-orm'
+${ctxCacheReadImport}
+import { ${ctxCamelPlural}CacheTags } from './types'
+
+export async function get${relPascal}For${ctxSingular}(${ctxSingularText}Id: string): Promise<string[]> {
+  'use cache'${ctxCacheLifeLine}
+  cacheTag(${ctxCamelPlural}CacheTags.byId(${ctxSingularText}Id))
+  cacheTag(${ctxCamelPlural}CacheTags.all)
+
+  try {
+    const results = await db
+      .select({ ${relIdCol}: ${junctionVar}.${relIdCol} })
+      .from(${junctionVar})
+      .where(eq(${junctionVar}.${entityIdCol}, ${ctxSingularText}Id))
+    return results.map((r) => r.${relIdCol})
+  } catch (error) {
+    console.error('Error fetching ${rel} for ${ctxSingularText}:', error)
+    return []
+  }
+}
+`
+}
+
+export function renderGenM2MFilesServerActionDetailsTemplate({
+  junctionVar,
+  ctxTableVar,
+  ctxCacheInvalidationFn,
+  ctxCamelPlural,
+  ctxSingular,
+  relPascal,
+  ctxSingularText,
+  rel,
+  fName,
+  ctxPlural,
+  entityIdCol,
+  relSingular,
+  relIdCol
+}: {
+  junctionVar: string
+  ctxTableVar: string
+  ctxCacheInvalidationFn: string
+  ctxCamelPlural: string
+  ctxSingular: string
+  relPascal: string
+  ctxSingularText: string
+  rel: string
+  fName: string
+  ctxPlural: string
+  entityIdCol: string
+  relSingular: string
+  relIdCol: string
+}): string {
+  return `'use server'
+
+import db from '@admin/db'
+import { requireRole, UserRole } from '@admin/auth/middleware'
+import { ${junctionVar}, ${ctxTableVar} } from '@admin/db/schema'
+import { eq } from 'drizzle-orm'
+import { ${ctxCacheInvalidationFn} } from 'next/cache'
+import { createEntityVersion, entityVersionsCacheTags } from '@admin/actions/entity-versions'
+import { ${ctxCamelPlural}CacheTags } from './types'
+import {
+  build${ctxSingular}VersionSnapshotWithRelationships,
+  has${ctxSingular}VersionChanges
+} from './helpers'
+
+export async function set${relPascal}For${ctxSingular}(
+  ${ctxSingularText}Id: string,
+  ${rel}Ids: string[]
+): Promise<{ success: boolean; error?: string }> {
+  const actor = await requireRole([UserRole.ADMIN, UserRole.EDITOR])
+
+  try {
+    await db.transaction(async (tx) => {
+      const [previousRow] = await tx
+        .select()
+        .from(${ctxTableVar})
+        .where(eq(${ctxTableVar}.id, ${ctxSingularText}Id))
+        .limit(1)
+
+      if (!previousRow) {
+        throw new Error('${ctxSingular} not found')
+      }
+
+      const previousSnapshot = await build${ctxSingular}VersionSnapshotWithRelationships(
+        previousRow as Record<string, unknown>,
+        tx
+      )
+      const nextSnapshot = { ...previousSnapshot, ${fName}: ${rel}Ids }
+      const shouldCreateVersion = has${ctxSingular}VersionChanges(previousSnapshot, nextSnapshot)
+
+      if (shouldCreateVersion) {
+        await createEntityVersion(tx, {
+          entityType: '${ctxPlural}',
+          entityId: ${ctxSingularText}Id,
+          data: previousSnapshot,
+          createdBy: actor.id
+        })
+      }
+
+      await tx.delete(${junctionVar}).where(eq(${junctionVar}.${entityIdCol}, ${ctxSingularText}Id))
+      if (${rel}Ids.length > 0) {
+        await tx.insert(${junctionVar}).values(
+          ${rel}Ids.map((${relSingular}Id) => ({
+            ${entityIdCol}: ${ctxSingularText}Id,
+            ${relIdCol}: ${relSingular}Id
+          }))
+        )
+      }
+    })
+    ${ctxCacheInvalidationFn}(${ctxCamelPlural}CacheTags.all)
+    ${ctxCacheInvalidationFn}(${ctxCamelPlural}CacheTags.byId(${ctxSingularText}Id))
+    ${ctxCacheInvalidationFn}(entityVersionsCacheTags.for('${ctxPlural}', ${ctxSingularText}Id))
+    return { success: true }
+  } catch (error) {
+    console.error('Error setting ${rel} for ${ctxSingularText}:', error)
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to set ${rel}'
+    }
+  }
+}
+`
+}

package/dist/assets/adapters/next/templates/renderers/generators/actions/entity-file-contents/gen-restore-content.ts

@@ -0,0 +1,123 @@
+export function renderGenRestoreContentServerActionTemplate({
+  join,
+  ctxCacheInvalidationFn,
+  ctxCamelPlural,
+  ctxSingular,
+  kebabSingular,
+  snapshotImport,
+  lifecycleHookImport,
+  ctxPlural,
+  restoreContext,
+  beforeHook,
+  ctxTableVar,
+  currentSnapshot,
+  restoreM2MContent,
+  afterHookAfterRestore,
+  ctxCamelSingular,
+  ctxSingularText
+}: {
+  join: string
+  ctxCacheInvalidationFn: string
+  ctxCamelPlural: string
+  ctxSingular: string
+  kebabSingular: string
+  snapshotImport: string
+  lifecycleHookImport: string
+  ctxPlural: string
+  restoreContext: string
+  beforeHook: string
+  ctxTableVar: string
+  currentSnapshot: string
+  restoreM2MContent: string
+  afterHookAfterRestore: string
+  ctxCamelSingular: string
+  ctxSingularText: string
+}): string {
+  return `'use server'
+
+import db from '@admin/db'
+import { requireRole, UserRole } from '@admin/auth/middleware'
+import { ${join} } from '@admin/db/schema'
+import { and, eq } from 'drizzle-orm'
+import { ${ctxCacheInvalidationFn} } from 'next/cache'
+import { createEntityVersion, entityVersionsCacheTags } from '@admin/actions/entity-versions'
+import { ${ctxCamelPlural}CacheTags } from './types'
+import { get${ctxSingular}ById } from './get-${kebabSingular}-by-id'
+import {
+  build${ctxSingular}RestoreData,
+  ${snapshotImport}
+} from './helpers'
+${lifecycleHookImport}
+import type { ${ctxSingular}UpdateResult, ${ctxSingular} } from './types'
+
+export async function restore${ctxSingular}Version(
+  versionId: string
+): Promise<${ctxSingular}UpdateResult> {
+  const actor = await requireRole([UserRole.ADMIN, UserRole.EDITOR])
+
+  try {
+    const actorId = actor.id
+    const now = new Date().toISOString()
+
+    const [versionRow] = await db
+      .select()
+      .from(entityVersions)
+      .where(and(eq(entityVersions.id, versionId), eq(entityVersions.entityType, '${ctxPlural}')))
+      .limit(1)
+
+    if (!versionRow) throw new Error('${ctxSingular} version not found')
+
+    const versionData = versionRow.data as Record<string, unknown>
+    const restoreData = build${ctxSingular}RestoreData(versionData)
+    const auditRequestMetadata = await getAuditRequestMetadata()
+    const lifecycleContext = ${restoreContext}
+    ${beforeHook}
+
+    const result = await db.transaction(async (tx) => {
+      const [currentRow] = await tx
+        .select()
+        .from(${ctxTableVar})
+        .where(eq(${ctxTableVar}.id, versionRow.entityId))
+        .limit(1)
+
+      if (!currentRow) throw new Error('${ctxSingular} not found')
+
+      await createEntityVersion(tx, {
+        entityType: '${ctxPlural}',
+        entityId: versionRow.entityId,
+        data: ${currentSnapshot},
+        createdBy: actorId
+      })
+${restoreM2MContent}
+      return tx.update(${ctxTableVar})
+        .set({ ...restoreData, updatedAt: now, updatedBy: actorId })
+        .where(eq(${ctxTableVar}.id, versionRow.entityId))
+        .returning()
+    })
+
+    if (result.length === 0) throw new Error('${ctxSingular} not found')
+
+    ${ctxCacheInvalidationFn}(${ctxCamelPlural}CacheTags.all)
+    ${ctxCacheInvalidationFn}(${ctxCamelPlural}CacheTags.byId(versionRow.entityId))
+    ${ctxCacheInvalidationFn}(entityVersionsCacheTags.for('${ctxPlural}', versionRow.entityId))
+    const restored${ctxSingular} = await get${ctxSingular}ById(versionRow.entityId)
+    ${afterHookAfterRestore}
+
+    return {
+      success: true,
+      ${ctxCamelSingular}: restored${ctxSingular} ?? (result[0] as unknown as ${ctxSingular})
+    }
+  } catch (error) {
+    console.error('Error restoring ${ctxSingularText} version:', error)
+    throw new Error(error instanceof Error ? error.message : 'Failed to restore ${ctxSingularText} version')
+  }
+}
+`
+}
+
+export function renderGenRestoreContentTemplate({ ctxSingular }: { ctxSingular: string }): string {
+  return `{
+      ...lifecycleContext,
+      data: (restored${ctxSingular} ?? result[0]) as unknown as Record<string, unknown>
+    }`
+}

package/dist/assets/adapters/next/templates/renderers/generators/actions/entity-file-contents/gen-update-content.ts

@@ -0,0 +1,187 @@
+export function renderGenUpdateContentServerActionTemplate({
+  ctxTableVar,
+  ctxCacheInvalidationFn,
+  ctxCamelPlural,
+  ctxSingular,
+  kebabSingular,
+  snapshotImport,
+  lifecycleHookImport,
+  markdownImport,
+  updateContext,
+  beforeHook,
+  updateBeforePublishBlock,
+  slugSourceValue,
+  toKebabCase,
+  ctxFieldMeta,
+  htmlUpdateBlock,
+  previousSnapshot,
+  ctxPlural,
+  updateResultContext,
+  updateAfterPublishBlock,
+  afterHook,
+  ctxCamelSingular,
+  ctxSingularText
+}: {
+  ctxTableVar: string
+  ctxCacheInvalidationFn: string
+  ctxCamelPlural: string
+  ctxSingular: string
+  kebabSingular: string
+  snapshotImport: string
+  lifecycleHookImport: string
+  markdownImport: string
+  updateContext: string
+  beforeHook: string
+  updateBeforePublishBlock: string
+  slugSourceValue: string
+  toKebabCase: string
+  ctxFieldMeta: string
+  htmlUpdateBlock: string
+  previousSnapshot: string
+  ctxPlural: string
+  updateResultContext: string
+  updateAfterPublishBlock: string
+  afterHook: string
+  ctxCamelSingular: string
+  ctxSingularText: string
+}): string {
+  return `'use server'
+
+import db from '@admin/db'
+import { requireRole, UserRole } from '@admin/auth/middleware'
+import { ${ctxTableVar} } from '@admin/db/schema'
+import { eq } from 'drizzle-orm'
+import { ${ctxCacheInvalidationFn} } from 'next/cache'
+import { createEntityVersion, entityVersionsCacheTags } from '@admin/actions/entity-versions'
+import { ${ctxCamelPlural}CacheTags } from './types'
+import { get${ctxSingular}ById } from './get-${kebabSingular}-by-id'
+import { getChangedFieldNames } from '@admin/utils/audit/get-changed-field-names'
+import {
+  build${ctxSingular}RestoreData,
+  get${ctxSingular}SlugRetryLimit,
+  is${ctxSingular}SlugConflict,
+  resolveUnique${ctxSingular}Slug,
+  ${snapshotImport},
+  has${ctxSingular}VersionChanges
+} from './helpers'
+${lifecycleHookImport}
+import type { ${ctxSingular}UpdateInput, ${ctxSingular}UpdateResult, ${ctxSingular} } from './types'${markdownImport}
+
+export async function update${ctxSingular}(input: ${ctxSingular}UpdateInput): Promise<${ctxSingular}UpdateResult> {
+  const actor = await requireRole([UserRole.ADMIN, UserRole.EDITOR])
+
+  try {
+    const { id, ...updateData } = input
+    const actorId = actor.id
+    const now = new Date().toISOString()
+    const auditRequestMetadata = await getAuditRequestMetadata()
+    const [previousRow] = await db
+      .select()
+      .from(${ctxTableVar})
+      .where(eq(${ctxTableVar}.id, id))
+      .limit(1)
+
+    if (!previousRow) throw new Error('${ctxSingular} not found')
+
+    const lifecycleContext = ${updateContext}
+    ${beforeHook}
+${updateBeforePublishBlock}
+    const requestedUpdateSlug = updateData.slug
+    let changedFields: string[] = []
+    let result: (typeof ${ctxTableVar}.$inferSelect)[] | null = null
+    for (let attempt = 0; attempt < get${ctxSingular}SlugRetryLimit(); attempt += 1) {
+      try {
+        if (requestedUpdateSlug !== undefined) {
+          updateData.slug = await resolveUnique${ctxSingular}Slug(db, {
+            requestedSlug: requestedUpdateSlug,
+            sourceValue: ${slugSourceValue},
+            fallbackPrefix: '${toKebabCase}',
+            currentId: id
+          })
+        }
+
+        const fieldMeta = [
+        ${ctxFieldMeta}
+        ]
+
+        const processedData: Record<string, unknown> = {}
+        for (const [key, value] of Object.entries(updateData)) {
+          if (key === 'published') { processedData[key] = value; continue }
+          const field = fieldMeta.find(f => f.name === key)
+          if (!field) continue
+          if (field.type === 'list') {
+            processedData[key] = value || []
+          } else if (!field.required && ['number', 'decimal'].includes(field.type)) {
+            processedData[key] =
+              value === undefined ||
+              value === null ||
+              value === '' ||
+              (typeof value === 'number' && Number.isNaN(value))
+                ? null
+                : value
+          } else if (!field.required && ['date', 'timestamp', 'time', 'string', 'email', 'varchar', 'text', 'select', 'relationship'].includes(field.type)) {
+            processedData[key] = value && value !== '' ? value : null
+          } else {
+            processedData[key] = value
+          }
+        }
+${htmlUpdateBlock}
+        changedFields = getChangedFieldNames(
+          previousRow as unknown as Record<string, unknown>,
+          processedData
+        )
+        result = await db.transaction(async (tx) => {
+          const previousSnapshot = ${previousSnapshot}
+          const nextSnapshot = {
+            ...previousSnapshot,
+            ...build${ctxSingular}RestoreData(processedData)
+          }
+          const shouldCreateVersion = has${ctxSingular}VersionChanges(previousSnapshot, nextSnapshot)
+
+          if (shouldCreateVersion) {
+            await createEntityVersion(tx, {
+              entityType: '${ctxPlural}',
+              entityId: id,
+              data: previousSnapshot,
+              createdBy: actorId
+            })
+          }
+
+          return tx.update(${ctxTableVar})
+            .set({ ...processedData, updatedAt: now, updatedBy: actorId })
+            .where(eq(${ctxTableVar}.id, id))
+            .returning()
+        })
+        break
+      } catch (error) {
+        if (is${ctxSingular}SlugConflict(error) && attempt < get${ctxSingular}SlugRetryLimit() - 1) {
+          continue
+        }
+        throw error
+      }
+    }
+
+    if (!result) throw new Error('${ctxSingular} not found')
+
+    if (result.length === 0) throw new Error('${ctxSingular} not found')
+
+    ${ctxCacheInvalidationFn}(${ctxCamelPlural}CacheTags.all)
+    ${ctxCacheInvalidationFn}(${ctxCamelPlural}CacheTags.byId(id))
+    ${ctxCacheInvalidationFn}(entityVersionsCacheTags.for('${ctxPlural}', id))
+    const updated${ctxSingular} = await get${ctxSingular}ById(id)
+    const updated${ctxSingular}Data = updated${ctxSingular} ?? (result[0] as unknown as ${ctxSingular})
+    const updated${ctxSingular}Context = ${updateResultContext}
+${updateAfterPublishBlock}
+    ${afterHook}
+
+    return {
+      success: true,
+      ${ctxCamelSingular}: updated${ctxSingular}Data
+    }
+  } catch (error) {
+    console.error('Error updating ${ctxSingularText}:', error)
+    throw new Error(error instanceof Error ? error.message : 'Failed to update ${ctxSingularText}')
+  }
+}
+`
+}

package/dist/assets/adapters/next/templates/renderers/generators/actions/entity-file-contents/generate-resolve-media-function.ts

@@ -0,0 +1,40 @@
+export function renderResolveMediaFunctionIdsTemplate({
+  ctxSingular,
+  collectSingle,
+  collectArrayContent,
+  map,
+  arrayFieldsContent,
+  assignSingle,
+  assignArrayContent
+}: {
+  ctxSingular: string
+  collectSingle: string
+  collectArrayContent: string
+  map: string
+  arrayFieldsContent: string
+  assignSingle: string
+  assignArrayContent: string
+}): string {
+  return `export async function resolve${ctxSingular}MediaFields(rows: ${ctxSingular}[]): Promise<${ctxSingular}[]> {
+  if (rows.length === 0) return rows
+
+  const ids = new Set<string>()
+${collectSingle}${collectArrayContent}
+
+  if (ids.size === 0) {
+    for (const row of rows) {
+${map}${arrayFieldsContent}
+    }
+    return rows
+  }
+
+  const mediaRows = await db.select().from(adminMedia).where(inArray(adminMedia.id, [...ids]))
+  const mediaMap = new Map<string, AdminMedia>(mediaRows.map(m => [m.id, m]))
+
+  for (const row of rows) {
+${assignSingle}${assignArrayContent}
+  }
+
+  return rows
+}`
+}

package/dist/assets/adapters/next/templates/renderers/generators/actions/entity-file-contents/generate-slug-helpers.ts

@@ -0,0 +1,73 @@
+export function renderSlugHelpersComponentTemplate({
+  stringify,
+  ctxSingular,
+  ctxTableVar
+}: {
+  stringify: string
+  ctxSingular: string
+  ctxTableVar: string
+}): string {
+  return `const SLUG_CONSTRAINT_NAME = ${stringify}
+const SLUG_RETRY_LIMIT = 5
+
+type SlugLookupClient = typeof db | Parameters<Parameters<typeof db.transaction>[0]>[0]
+
+interface Resolve${ctxSingular}SlugOptions {
+  requestedSlug?: unknown
+  sourceValue?: unknown
+  fallbackPrefix: string
+  currentId?: string
+}
+
+function toSlugBase(value: unknown): string {
+  if (typeof value !== 'string') return ''
+  return slugify(value)
+}
+
+export function get${ctxSingular}SlugRetryLimit(): number {
+  return SLUG_RETRY_LIMIT
+}
+
+export function is${ctxSingular}SlugConflict(error: unknown): boolean {
+  if (typeof error !== 'object' || error === null) return false
+  const record = error as Record<string, unknown>
+  if (record.code !== '23505') return false
+  const constraint = typeof record.constraint === 'string' ? record.constraint : ''
+  const message = typeof record.message === 'string' ? record.message : ''
+  return constraint === SLUG_CONSTRAINT_NAME || message.includes(SLUG_CONSTRAINT_NAME)
+}
+
+export async function resolveUnique${ctxSingular}Slug(
+  client: SlugLookupClient,
+  options: Resolve${ctxSingular}SlugOptions
+): Promise<string> {
+  const requestedBase = toSlugBase(options.requestedSlug)
+  const sourceBase = requestedBase ? '' : toSlugBase(options.sourceValue)
+  const usesFallback = !requestedBase && !sourceBase
+  const baseSlug = requestedBase || sourceBase || \`\${options.fallbackPrefix}-1\`
+  const rows = await client
+    .select({ id: ${ctxTableVar}.id, slug: ${ctxTableVar}.slug })
+    .from(${ctxTableVar})
+  const usedSlugs = new Set(
+    rows
+      .filter((row) => row.id !== options.currentId)
+      .map((row) => row.slug)
+      .filter((slug): slug is string => typeof slug === 'string' && slug.length > 0)
+  )
+
+  if (!usedSlugs.has(baseSlug)) return baseSlug
+
+  let suffix = 2
+  let candidate = usesFallback
+    ? \`\${options.fallbackPrefix}-\${suffix}\`
+    : \`\${baseSlug}-\${suffix}\`
+  while (usedSlugs.has(candidate)) {
+    suffix += 1
+    candidate = usesFallback
+      ? \`\${options.fallbackPrefix}-\${suffix}\`
+      : \`\${baseSlug}-\${suffix}\`
+  }
+
+  return candidate
+}`
+}