betterstart-cli 0.0.104 → 0.0.105

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

@@ -1,55 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,151 +0,0 @@
-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

@@ -1,123 +0,0 @@
-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

@@ -1,187 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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
-}`
-}