betterstart-cli 0.0.104 → 0.0.106

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

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

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

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

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

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