betterstart-cli 0.0.103 → 0.0.104

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

@@ -0,0 +1,104 @@
+export function renderVersionSnapshotHelpersRowsTemplate({
+  fieldName,
+  relIdCol,
+  junctionVar,
+  entityIdCol
+}: {
+  fieldName: string
+  relIdCol: string
+  junctionVar: string
+  entityIdCol: string
+}): string {
+  return `  const ${fieldName}Rows = await client
+    .select({ ${relIdCol}: ${junctionVar}.${relIdCol} })
+    .from(${junctionVar})
+    .where(eq(${junctionVar}.${entityIdCol}, id))
+  snapshot.${fieldName} = ${fieldName}Rows.map((row) => row.${relIdCol})`
+}
+
+export function renderVersionSnapshotHelpersSourceTemplate({
+  ctxSingular,
+  loadM2MStatements
+}: {
+  ctxSingular: string
+  loadM2MStatements: string
+}): string {
+  return `
+export async function build${ctxSingular}VersionSnapshotWithRelationships(
+  row: Partial<${ctxSingular}> | Record<string, unknown>,
+  client: VersionSnapshotClient = db
+): Promise<Record<string, unknown>> {
+  const source = row as Record<string, unknown>
+  const snapshot = build${ctxSingular}VersionSnapshot(source)
+  const id = typeof source.id === 'string' ? source.id : null
+
+  if (!id) {
+    for (const key of VERSION_M2M_KEYS) {
+      snapshot[key] = Array.isArray(snapshot[key]) ? snapshot[key] : []
+    }
+    return snapshot
+  }
+
+${loadM2MStatements}
+
+  return snapshot
+}
+`
+}
+
+export function renderVersionSnapshotHelpersGeneratedFunctionTemplate({
+  snapshotClientType,
+  snapshotKeys,
+  restoreKeys,
+  m2mKeys,
+  ctxSingular,
+  relationshipSnapshotHelper
+}: {
+  snapshotClientType: string
+  snapshotKeys: string
+  restoreKeys: string
+  m2mKeys: string
+  ctxSingular: string
+  relationshipSnapshotHelper: string
+}): string {
+  return `${snapshotClientType}const VERSION_SNAPSHOT_KEYS = [${snapshotKeys}] as const
+const VERSION_RESTORE_KEYS = [${restoreKeys}] as const
+const VERSION_M2M_KEYS = [${m2mKeys}] as const
+
+export function build${ctxSingular}VersionSnapshot(row: Partial<${ctxSingular}> | Record<string, unknown>): Record<string, unknown> {
+  const source = row as unknown as Record<string, unknown>
+  const snapshot: Record<string, unknown> = {}
+
+  for (const key of VERSION_SNAPSHOT_KEYS) {
+    if (key in source) {
+      snapshot[key] = source[key]
+    }
+  }
+
+  for (const key of VERSION_M2M_KEYS) {
+    snapshot[key] = Array.isArray(snapshot[key]) ? snapshot[key] : []
+  }
+
+  return snapshot
+}
+${relationshipSnapshotHelper}
+
+export function build${ctxSingular}RestoreData(data: Record<string, unknown>): Record<string, unknown> {
+  const restoreData: Record<string, unknown> = {}
+
+  for (const key of VERSION_RESTORE_KEYS) {
+    if (key in data) {
+      restoreData[key] = data[key]
+    }
+  }
+
+  return restoreData
+}
+
+export function has${ctxSingular}VersionChanges(
+  previous: Record<string, unknown>,
+  next: Record<string, unknown>
+): boolean {
+  return JSON.stringify(previous) !== JSON.stringify(next)
+}`
+}

package/dist/assets/adapters/next/templates/renderers/generators/actions/lifecycle-hook-emissions/lifecycle-context.ts

@@ -0,0 +1,22 @@
+export function renderLifecycleContextContentTemplate({
+  userExpression,
+  entityType,
+  schemaType,
+  sourceType,
+  extras
+}: {
+  userExpression: string
+  entityType: string
+  schemaType: string
+  sourceType: string
+  extras: string
+}): string {
+  return `{
+      user: ${userExpression},
+      entityType: '${entityType}',${schemaType}
+      timestamp: now,
+      sourceType: '${sourceType}' as const,
+      ipAddress: auditRequestMetadata.ipAddress,
+      userAgent: auditRequestMetadata.userAgent${extras}
+    }`
+}

package/dist/assets/adapters/next/templates/renderers/generators/actions/lifecycle-hook-emissions/lifecycle-hook-import.ts

@@ -0,0 +1,4 @@
+export function renderLifecycleHookImportContentTemplate(): string {
+  return `\nimport { getAuditRequestMetadata } from '@admin/actions/audit/get-audit-request-metadata'
+import { runAfterHooks, runBeforeHooks } from '@admin/lib/lifecycle-hooks'`
+}

package/dist/assets/adapters/next/templates/renderers/generators/actions/markdown-renderer.ts

@@ -0,0 +1,411 @@
+export function renderGenMarkdownRendererContentComponentTemplate(): string {
+  return `import { randomUUID } from 'node:crypto'
+import { createRequire } from 'node:module'
+import katex from 'katex'
+import MarkdownIt from 'markdown-it'
+import sanitizeHtml from 'sanitize-html'
+
+type MarkdownToken = MarkdownIt.Token
+
+interface DollarMathOptions {
+  allow_space?: boolean
+  allow_digits?: boolean
+  double_inline?: boolean
+  allow_labels?: boolean
+  renderer?: (content: string, options: { displayMode: boolean }) => string
+  labelNormalizer?: (label: string) => string
+  labelRenderer?: (label: string) => string
+}
+
+type DollarMathPlugin = (md: MarkdownIt, options?: DollarMathOptions) => void
+
+const dollarmathModule = createRequire(import.meta.url)('markdown-it-dollarmath') as
+  | DollarMathPlugin
+  | { default: DollarMathPlugin }
+const dollarmath =
+  typeof dollarmathModule === 'function' ? dollarmathModule : dollarmathModule.default
+
+interface MarkdownInlineState {
+  src: string
+  pos: number
+  md: MarkdownIt
+  env: unknown
+  tokens: MarkdownToken[]
+  push(type: string, tag: string, nesting: -1 | 0 | 1): MarkdownToken
+}
+
+interface MarkdownBlockState {
+  src: string
+  bMarks: number[]
+  tShift: number[]
+  sCount: number[]
+  eMarks: number[]
+  blkIndent: number
+  line: number
+  push(type: string, tag: string, nesting: -1 | 0 | 1): MarkdownToken
+}
+
+interface MarkdownRenderContext {
+  placeholderPrefix: string
+  trustedMathHtml: string[]
+}
+
+const highlightColorNames = new Set([
+  'gray',
+  'brown',
+  'orange',
+  'yellow',
+  'green',
+  'blue',
+  'purple',
+  'pink',
+  'red'
+])
+
+const mathBlockEnvironmentNames = new Set([
+  'align',
+  'align*',
+  'aligned',
+  'alignedat',
+  'alignedat*',
+  'array',
+  'bmatrix',
+  'cases',
+  'equation',
+  'equation*',
+  'gather',
+  'gather*',
+  'gathered',
+  'matrix',
+  'multline',
+  'multline*',
+  'pmatrix',
+  'smallmatrix',
+  'split',
+  'vmatrix'
+])
+
+const cssLengthPattern = /^-?(?:(?:\\d+(?:\\.\\d+)?)|(?:\\.\\d+))(?:em|ex|mu|px|rem|%)$|^0$/
+const cssBorderWidthPattern = /^(?:(?:\\d+(?:\\.\\d+)?)|(?:\\.\\d+))(?:em|px|rem)$|^0$/
+
+let activeRenderContext: MarkdownRenderContext | null = null
+
+function renderKatex(content: string, displayMode: boolean) {
+  return katex.renderToString(content, {
+    displayMode,
+    output: 'htmlAndMathml',
+    throwOnError: false,
+    strict: 'ignore',
+    trust: false
+  })
+}
+
+function renderTrustedMathPlaceholder(content: string, displayMode: boolean) {
+  const html = sanitizeKatexHtml(renderKatex(content, displayMode))
+  if (!activeRenderContext) return html
+
+  const placeholder = \`\${activeRenderContext.placeholderPrefix + activeRenderContext.trustedMathHtml.length}__\`
+  activeRenderContext.trustedMathHtml.push(html)
+  return placeholder
+}
+
+function slugify(text: string): string {
+  return text
+    .toLowerCase()
+    .trim()
+    .replace(/[^\\w\\s-]/g, '')
+    .replace(/\\s+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-+|-+$/g, '')
+}
+
+function headingAnchorPlugin(md: MarkdownIt) {
+  md.core.ruler.push('heading_anchors', (state) => {
+    const tokens = state.tokens
+    for (let i = 0; i < tokens.length; i++) {
+      const token = tokens[i]
+      if (token.type !== 'heading_open') continue
+
+      const contentToken = tokens[i + 1]
+      if (!contentToken || contentToken.type !== 'inline' || !contentToken.content) continue
+
+      const slug = slugify(contentToken.content)
+      const idIndex = token.attrIndex('id')
+      if (idIndex < 0) {
+        token.attrPush(['id', slug])
+      } else if (token.attrs) {
+        token.attrs[idIndex][1] = slug
+      }
+    }
+    return true
+  })
+}
+
+function betterStartMathPlugin(md: MarkdownIt) {
+  md.inline.ruler.before('escape', 'betterstart_bracket_inline_math', tokenizeBracketInlineMath)
+  md.block.ruler.before('paragraph', 'betterstart_bracket_block_math', tokenizeBracketBlockMath, {
+    alt: ['paragraph', 'reference', 'blockquote', 'list']
+  })
+}
+
+function tokenizeBracketInlineMath(state: MarkdownInlineState, silent: boolean): boolean {
+  if (!state.src.startsWith('\\\\(', state.pos)) return false
+
+  const closingIndex = findUnescapedSequence(state.src, '\\\\)', state.pos + 2)
+  if (closingIndex === -1) return false
+
+  const content = state.src.slice(state.pos + 2, closingIndex)
+  if (!content.trim() || content.includes('\\n')) return false
+
+  if (!silent) {
+    const token = state.push('html_inline', '', 0)
+    token.content = renderTrustedMathPlaceholder(content, false)
+  }
+
+  state.pos = closingIndex + 2
+  return true
+}
+
+function tokenizeBracketBlockMath(
+  state: MarkdownBlockState,
+  startLine: number,
+  endLine: number,
+  silent: boolean
+): boolean {
+  if (state.sCount[startLine] - state.blkIndent >= 4) return false
+
+  const startPosition = state.bMarks[startLine] + state.tShift[startLine]
+  const firstLine = state.src.slice(startPosition, state.eMarks[startLine])
+
+  if (firstLine.startsWith('\\\\[')) {
+    const closingIndex = findUnescapedSequence(state.src, '\\\\]', startPosition + 2)
+    if (closingIndex === -1) return false
+
+    const closingLine = findLineForPosition(state, startLine, endLine, closingIndex + 2)
+    if (closingLine === -1) return false
+    if (/\\S/.test(state.src.slice(closingIndex + 2, state.eMarks[closingLine]))) return false
+
+    if (!silent) {
+      const token = state.push('html_block', '', 0)
+      token.block = true
+      token.content = renderTrustedMathPlaceholder(state.src.slice(startPosition + 2, closingIndex).trim(), true)
+      token.markup = '\\\\[\\\\]'
+      token.map = [startLine, closingLine + 1]
+    }
+
+    state.line = closingLine + 1
+    return true
+  }
+
+  const environmentMatch = /^\\\\begin\\{([^}]+)\\}/.exec(firstLine)
+  if (!environmentMatch || !mathBlockEnvironmentNames.has(environmentMatch[1])) return false
+
+  const closingSequence = \`\\\\end{\${environmentMatch[1]}}\`
+  const closingIndex = findUnescapedSequence(state.src, closingSequence, startPosition + environmentMatch[0].length)
+  if (closingIndex === -1) return false
+
+  const closingEnd = closingIndex + closingSequence.length
+  const closingLine = findLineForPosition(state, startLine, endLine, closingEnd)
+  if (closingLine === -1) return false
+  if (/\\S/.test(state.src.slice(closingEnd, state.eMarks[closingLine]))) return false
+
+  if (!silent) {
+    const token = state.push('html_block', '', 0)
+    token.block = true
+    token.content = renderTrustedMathPlaceholder(state.src.slice(startPosition, closingEnd).trim(), true)
+    token.markup = '\\\\begin'
+    token.map = [startLine, closingLine + 1]
+  }
+
+  state.line = closingLine + 1
+  return true
+}
+
+function findLineForPosition(
+  state: MarkdownBlockState,
+  startLine: number,
+  endLine: number,
+  position: number
+) {
+  for (let line = startLine; line < endLine; line++) {
+    if (position <= state.eMarks[line]) return line
+  }
+
+  return -1
+}
+
+function findUnescapedSequence(value: string, sequence: string, start: number) {
+  let index = value.indexOf(sequence, start)
+
+  while (index !== -1) {
+    if (!isEscaped(value, index)) return index
+    index = value.indexOf(sequence, index + sequence.length)
+  }
+
+  return -1
+}
+
+function isEscaped(value: string, index: number) {
+  let slashCount = 0
+
+  for (let offset = index - 1; offset >= 0 && value[offset] === '\\\\'; offset--) {
+    slashCount++
+  }
+
+  return slashCount % 2 === 1
+}
+
+const md = MarkdownIt({
+  html: true,
+  linkify: true,
+  typographer: true,
+  breaks: true
+})
+  .use(headingAnchorPlugin)
+  .use(betterStartMathPlugin)
+  .use(dollarmath, {
+    allow_space: false,
+    allow_digits: false,
+    double_inline: true,
+    allow_labels: true,
+    renderer(content: string, { displayMode }: { displayMode: boolean }) {
+      return renderTrustedMathPlaceholder(content, displayMode)
+    },
+    labelNormalizer(label: string) {
+      const normalized = label
+        .trim()
+        .replace(/[\\s]+/g, '-')
+        .replace(/[^A-Za-z0-9_.:-]/g, '')
+      return normalized || 'equation'
+    },
+    labelRenderer(label: string) {
+      return \`<a id="\${label}" href="#\${label}" class="mathlabel" title="Permalink to this equation">&para;</a>\`
+    }
+  })
+
+function sanitizeMarkdownHtml(html: string): string {
+  return sanitizeHtml(html, {
+    allowedTags: sanitizeHtml.defaults.allowedTags.concat([
+      'img',
+      'u',
+      'span'
+    ]),
+    allowedAttributes: {
+      ...sanitizeHtml.defaults.allowedAttributes,
+      a: ['href', 'name', 'target', 'rel', 'id'],
+      annotation: ['encoding'],
+      h1: ['id'],
+      h2: ['id'],
+      h3: ['id'],
+      h4: ['id'],
+      h5: ['id'],
+      h6: ['id'],
+      img: ['src', 'alt', 'title', 'width', 'height'],
+      span: ['aria-hidden', 'data-highlight-color']
+    },
+    allowedSchemes: ['http', 'https', 'mailto', 'tel'],
+    transformTags: {
+      span(tagName, attribs) {
+        const highlightColor = attribs['data-highlight-color']
+        const sanitizedAttribs: Record<string, string> = {}
+
+        if (highlightColor && highlightColorNames.has(highlightColor)) {
+          sanitizedAttribs['data-highlight-color'] = highlightColor
+        }
+
+        return {
+          tagName,
+          attribs: sanitizedAttribs
+        }
+      }
+    }
+  })
+}
+
+function sanitizeKatexHtml(html: string): string {
+  return sanitizeHtml(html, {
+    allowedTags: [
+      'annotation',
+      'div',
+      'math',
+      'mfrac',
+      'mi',
+      'mn',
+      'mo',
+      'mover',
+      'mrow',
+      'msqrt',
+      'mspace',
+      'mstyle',
+      'msub',
+      'msubsup',
+      'msup',
+      'mtable',
+      'mtd',
+      'mtext',
+      'mtr',
+      'semantics',
+      'span'
+    ],
+    allowedAttributes: {
+      annotation: ['encoding'],
+      div: ['class', 'style'],
+      math: ['xmlns'],
+      span: ['class', 'style', 'aria-hidden'],
+      mtd: ['columnalign'],
+      mtr: ['rowalign'],
+      mstyle: ['scriptlevel', 'displaystyle'],
+      mspace: ['width'],
+      mrow: ['class'],
+      mo: ['stretchy', 'fence', 'separator', 'lspace', 'rspace'],
+      mi: ['mathvariant'],
+      mn: ['mathvariant'],
+      mtext: ['mathvariant'],
+      semantics: [],
+      mfrac: ['linethickness']
+    },
+    allowedStyles: {
+      '*': {
+        'border-bottom-width': [cssBorderWidthPattern],
+        'border-style': [/^solid$/],
+        'border-width': [cssBorderWidthPattern],
+        height: [cssLengthPattern],
+        left: [cssLengthPattern],
+        'margin-left': [cssLengthPattern],
+        'margin-right': [cssLengthPattern],
+        'min-width': [cssLengthPattern],
+        'padding-left': [cssLengthPattern],
+        position: [/^relative$/],
+        top: [cssLengthPattern],
+        'vertical-align': [cssLengthPattern],
+        width: [cssLengthPattern]
+      }
+    }
+  })
+}
+
+export function renderMarkdownSync(src: string): string {
+  const context: MarkdownRenderContext = {
+    placeholderPrefix: \`__BETTERSTART_KATEX_\${randomUUID()}_\`,
+    trustedMathHtml: []
+  }
+
+  activeRenderContext = context
+  let html: string
+  try {
+    html = md.render(src)
+  } finally {
+    activeRenderContext = null
+  }
+
+  let sanitized = sanitizeMarkdownHtml(html)
+  context.trustedMathHtml.forEach((mathHtml, index) => {
+    sanitized = sanitized
+      .split(\`\${context.placeholderPrefix + index}__\`)
+      .join(mathHtml)
+  })
+
+  return sanitized
+}
+`
+}

package/dist/assets/adapters/next/templates/renderers/generators/actions/select-fields-resolver.ts

@@ -0,0 +1,99 @@
+export function renderResolveSelectFieldsSourceDynamicRowsTemplate({
+  selectOptionsTableVar
+}: {
+  selectOptionsTableVar: string
+}): string {
+  return `
+  const dynamicRows = await db
+    .select({
+      fieldName: ${selectOptionsTableVar}.fieldName,
+      label: ${selectOptionsTableVar}.label,
+      value: ${selectOptionsTableVar}.value
+    })
+    .from(${selectOptionsTableVar})
+
+  for (const row of dynamicRows) {
+    labelMaps[row.fieldName] ??= {}
+    labelMaps[row.fieldName][row.value] = row.label
+  }
+`
+}
+
+export function renderResolveSelectFieldsSourceStaticSelectOptionLabelsTemplate({
+  staticLabelMaps,
+  exportedExport,
+  singular,
+  dynamicRowsBlock,
+  assignments
+}: {
+  staticLabelMaps: string
+  exportedExport: string
+  singular: string
+  dynamicRowsBlock: string
+  assignments: string
+}): string {
+  return `const STATIC_SELECT_OPTION_LABELS = {
+${staticLabelMaps}
+} satisfies Record<string, Record<string, string>>
+
+function cloneSelectOptionLabelMaps(): Record<string, Record<string, string>> {
+  return Object.fromEntries(
+    Object.entries(STATIC_SELECT_OPTION_LABELS).map(([fieldName, labels]) => [
+      fieldName,
+      { ...labels }
+    ])
+  )
+}
+
+function toSelectOptionValues(value: unknown, labels: Record<string, string>): SelectOptionValue[] {
+  const values = Array.isArray(value) ? value : value ? [value] : []
+
+  return values
+    .filter((item): item is string => typeof item === 'string' && item.length > 0)
+    .map((item) => ({
+      label: labels[item] ?? item,
+      value: item
+    }))
+}
+
+function resolveSelectFieldPath(
+  source: Record<string, unknown>,
+  path: readonly string[],
+  labels: Record<string, string>
+): void {
+  const [fieldName, ...rest] = path
+  if (!fieldName) return
+
+  if (rest.length === 0) {
+    source[fieldName] = toSelectOptionValues(source[fieldName], labels)
+    return
+  }
+
+  const value = source[fieldName]
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      if (item && typeof item === 'object') {
+        resolveSelectFieldPath(item as Record<string, unknown>, rest, labels)
+      }
+    }
+    return
+  }
+
+  if (value && typeof value === 'object') {
+    resolveSelectFieldPath(value as Record<string, unknown>, rest, labels)
+  }
+}
+
+${exportedExport}async function resolve${singular}SelectFields(rows: ${singular}[]): Promise<${singular}[]> {
+  if (rows.length === 0) return rows
+
+  const labelMaps = cloneSelectOptionLabelMaps()
+${dynamicRowsBlock}
+  for (const row of rows) {
+    const source = row as unknown as Record<string, unknown>
+${assignments}
+  }
+
+  return rows
+}`
+}