@nextsparkjs/core 0.1.0-beta.1

package/scripts/build/registry/post-build/route-cleanup.mjs

@@ -0,0 +1,188 @@
+/**
+ * Route Cleanup
+ *
+ * Cleans up old/orphaned route and template files
+ *
+ * @module core/scripts/build/registry/post-build/route-cleanup
+ */
+
+import { existsSync } from 'fs'
+import { readdir, readFile } from 'fs/promises'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+
+import { log, verbose } from '../../../utils/index.mjs'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+// Path from packages/core/scripts/build/registry/post-build/ to project root (6 levels up)
+const rootDir = join(__dirname, '../../../../../..')
+
+/**
+ * Clean up old generated route files
+ */
+export async function cleanupOldRouteFiles() {
+  const appApiDir = join(rootDir, 'app', 'api', 'v1', 'plugin')
+
+  try {
+    // Only clean up if directory exists
+    if (existsSync(appApiDir)) {
+      const entries = await readdir(appApiDir, { withFileTypes: true })
+
+      for (const entry of entries) {
+        if (entry.isDirectory() && entry.name !== '[...path]') {
+          const pluginDir = join(appApiDir, entry.name)
+          const routeFile = join(pluginDir, 'route.ts')
+
+          // Check if this is an auto-generated file
+          if (existsSync(routeFile)) {
+            const content = await readFile(routeFile, 'utf8')
+            if (content.includes('Auto-generated Plugin Route Proxy')) {
+              // Remove the entire plugin route directory
+              await import('fs/promises').then(fs =>
+                fs.rm(pluginDir, { recursive: true, force: true })
+              )
+              verbose(`Cleaned up old route: ${pluginDir}`)
+            }
+          }
+        }
+      }
+    }
+  } catch (error) {
+    verbose(`Error during route cleanup: ${error.message}`)
+  }
+}
+
+/**
+ * Clean up orphaned template files that no longer have corresponding templates
+ * Removes files from app/(templates)/ when their source templates are deleted
+ */
+export async function cleanupOrphanedTemplates(activeTemplates) {
+  const templatesDir = join(rootDir, 'app', '(templates)')
+  if (!existsSync(templatesDir)) {
+    return
+  }
+
+  log('Cleaning up orphaned template files...', 'info')
+
+  // Create a Set of all active template paths for quick lookup
+  const activeTemplatePaths = new Set(
+    activeTemplates.map(template =>
+      join(rootDir, 'app', '(templates)', template.appPath.replace('app/', ''))
+    )
+  )
+
+  let cleaned = 0
+  const dirsToCleanup = []
+
+  async function scanAndCleanDirectory(dir, relativePath = '') {
+    try {
+      const { readdir, stat, unlink } = await import('fs/promises')
+      const entries = await readdir(dir, { withFileTypes: true })
+
+      for (const entry of entries) {
+        const fullPath = join(dir, entry.name)
+        const currentRelativePath = relativePath ? join(relativePath, entry.name) : entry.name
+
+        if (entry.isDirectory()) {
+          await scanAndCleanDirectory(fullPath, currentRelativePath)
+          // Check if directory is empty after scanning
+          const remainingEntries = await readdir(fullPath)
+          if (remainingEntries.length === 0) {
+            dirsToCleanup.push(fullPath)
+          }
+        } else if (entry.isFile() && (entry.name.endsWith('.tsx') || entry.name.endsWith('.ts'))) {
+          // NEVER delete layout files - they are auto-generated and necessary for Next.js hierarchy
+          // Even if the theme doesn't override them, they must exist to provide layout to custom pages
+          if (entry.name === 'layout.tsx' || entry.name === 'layout.ts') {
+            continue
+          }
+
+          // Check if this generated file has a corresponding active template
+          if (!activeTemplatePaths.has(fullPath)) {
+            await unlink(fullPath)
+            log(`Cleaned orphaned file: ${fullPath.replace(rootDir, '')}`, 'info')
+            cleaned++
+          }
+        }
+      }
+    } catch (error) {
+      verbose(`Error scanning directory ${dir}: ${error.message}`)
+    }
+  }
+
+  await scanAndCleanDirectory(templatesDir)
+
+  // Clean up empty directories (in reverse order to handle nested structures)
+  if (dirsToCleanup.length > 0) {
+    const { rmdir } = await import('fs/promises')
+    for (const dir of dirsToCleanup.reverse()) {
+      try {
+        await rmdir(dir)
+        log(`Removed empty directory: ${dir.replace(rootDir, '')}`, 'info')
+      } catch {
+        // Directory might not be empty anymore, ignore
+      }
+    }
+  }
+
+  if (cleaned > 0) {
+    log(`Cleaned up ${cleaned} orphaned template files`, 'success')
+  } else {
+    verbose('No orphaned template files found')
+  }
+}
+
+/**
+ * Map template file path to generated app template path
+ * contents/themes/content-buddy/templates/(public)/pricing/page.tsx → app/(templates)/(public)/pricing/page.tsx
+ */
+export function mapTemplateToAppPath(templateFilePath) {
+  // Extract the part after /templates/
+  const templatesMatch = templateFilePath.match(/\/themes\/[^\/]+\/templates\/(.+)$/)
+  if (!templatesMatch) {
+    return null
+  }
+
+  const relativeTemplatePath = templatesMatch[1]
+  return join(rootDir, 'app', '(templates)', relativeTemplatePath)
+}
+
+/**
+ * Clean up generated template files when original templates are deleted
+ */
+export async function cleanupDeletedTemplate(templateFilePath) {
+  const appTemplatePath = mapTemplateToAppPath(templateFilePath)
+  if (!appTemplatePath || !existsSync(appTemplatePath)) {
+    return
+  }
+
+  try {
+    const { unlink, rmdir } = await import('fs/promises')
+
+    // Remove the generated template file
+    await unlink(appTemplatePath)
+    log(`Removed generated template: ${appTemplatePath.replace(rootDir, '')}`, 'info')
+
+    // Try to remove empty parent directories (but don't fail if they're not empty)
+    let parentDir = dirname(appTemplatePath)
+    const templatesDir = join(rootDir, 'app', '(templates)')
+
+    while (parentDir !== templatesDir && parentDir !== rootDir) {
+      try {
+        const entries = await import('fs/promises').then(fs => fs.readdir(parentDir))
+        if (entries.length === 0) {
+          await rmdir(parentDir)
+          log(`Removed empty directory: ${parentDir.replace(rootDir, '')}`, 'info')
+          parentDir = dirname(parentDir)
+        } else {
+          break // Directory is not empty, stop cleanup
+        }
+      } catch {
+        break // Error reading directory or removing, stop cleanup
+      }
+    }
+  } catch (error) {
+    verbose(`Failed to cleanup template file ${appTemplatePath}: ${error.message}`)
+  }
+}

package/scripts/build/registry/post-build/test-fixtures.mjs

@@ -0,0 +1,234 @@
+/**
+ * Test Fixtures Generator
+ *
+ * Generates test entity JSON files for Cypress tests
+ *
+ * @module core/scripts/build/registry/post-build/test-fixtures
+ */
+
+import { existsSync } from 'fs'
+import { readFile, writeFile } from 'fs/promises'
+import { join, dirname } from 'path'
+import { fileURLToPath } from 'url'
+
+import { log, verbose } from '../../../utils/index.mjs'
+import { CONFIG } from '../config.mjs'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+// Path from packages/core/scripts/build/registry/post-build/ to project root (6 levels up)
+const rootDir = join(__dirname, '../../../../../..')
+
+/**
+ * Extract test-relevant data from an entity config file using regex
+ * @param {string} configPath - Path to the entity config file
+ * @param {string} entityDir - Directory containing the entity
+ * @returns {Object} Extracted entity data for tests
+ */
+export async function extractEntityTestData(configPath, entityDir) {
+  try {
+    const configContent = await readFile(configPath, 'utf8')
+
+    // Extract slug
+    const slugMatch = configContent.match(/slug:\s*['"]([^'"]+)['"]/)
+    const slug = slugMatch ? slugMatch[1] : null
+
+    // Extract names
+    const singularMatch = configContent.match(/singular:\s*['"]([^'"]+)['"]/)
+    const pluralMatch = configContent.match(/plural:\s*['"]([^'"]+)['"]/)
+    const singular = singularMatch ? singularMatch[1] : slug
+    const plural = pluralMatch ? pluralMatch[1] : slug
+
+    // Extract tableName (defaults to slug)
+    const tableMatch = configContent.match(/tableName:\s*['"]([^'"]+)['"]/)
+    const tableName = tableMatch ? tableMatch[1] : slug
+
+    // Extract filters from ui.dashboard.filters
+    const filtersMatch = configContent.match(/filters:\s*\[([\s\S]*?)\]/m)
+    const filters = []
+    if (filtersMatch) {
+      const filterFieldMatches = filtersMatch[1].matchAll(/field:\s*['"]([^'"]+)['"]/g)
+      for (const match of filterFieldMatches) {
+        filters.push(match[1])
+      }
+    }
+
+    // Try to read fields from separate .fields.ts file
+    const fields = []
+    const fieldsFilePath = join(entityDir, `${slug}.fields.ts`)
+
+    if (existsSync(fieldsFilePath)) {
+      const fieldsContent = await readFile(fieldsFilePath, 'utf8')
+      // Extract field names
+      const fieldNameMatches = fieldsContent.matchAll(/name:\s*['"]([^'"]+)['"]/g)
+      for (const match of fieldNameMatches) {
+        fields.push(match[1])
+      }
+    } else {
+      // Try to extract fields from config file itself
+      const fieldsSection = configContent.match(/fields:\s*\[([\s\S]*?)\](?=,?\s*(?:\/\/|\/\*|[a-zA-Z_]+:|$))/m)
+      if (fieldsSection) {
+        const fieldNameMatches = fieldsSection[1].matchAll(/name:\s*['"]([^'"]+)['"]/g)
+        for (const match of fieldNameMatches) {
+          fields.push(match[1])
+        }
+      }
+    }
+
+    return { slug, singular, plural, tableName, fields, filters }
+  } catch (error) {
+    verbose(`Error extracting test data from ${configPath}: ${error.message}`)
+    return null
+  }
+}
+
+/**
+ * Generate entities.json test fixture for the active theme
+ * This file is used by Cypress tests (POMs and API Controllers)
+ * @param {Array} entities - All discovered entities
+ * @param {Array} themes - All discovered themes
+ */
+export async function generateTestEntitiesJson(entities, themes) {
+  const activeTheme = CONFIG.activeTheme
+  if (!activeTheme) {
+    verbose('No active theme set, skipping test fixtures generation')
+    return
+  }
+
+  // Find the active theme
+  const theme = themes.find(t => t.name === activeTheme)
+  if (!theme) {
+    verbose(`Active theme "${activeTheme}" not found, skipping test fixtures generation`)
+    return
+  }
+
+  // Check if tests directory exists
+  const fixturesDir = join(CONFIG.contentsDir, 'themes', activeTheme, 'tests', 'cypress', 'fixtures')
+  if (!existsSync(fixturesDir)) {
+    verbose(`Test fixtures directory not found for theme "${activeTheme}", skipping`)
+    return
+  }
+
+  log(`Generating test fixtures for theme: ${activeTheme}`, 'build')
+
+  // Build entities data
+  const entitiesData = {}
+
+  for (const entity of entities) {
+    // Determine source
+    let source = 'theme'
+    if (entity.isCore) {
+      source = 'core'
+    } else if (entity.pluginContext) {
+      source = 'plugin'
+    }
+
+    // Get the actual config file path on disk
+    let configFilePath = null
+    let entityDir = null
+
+    if (entity.isCore) {
+      entityDir = join(rootDir, 'core', 'lib', 'entities', 'core', entity.name)
+      // Try different config patterns
+      configFilePath = join(entityDir, `${entity.name}.config.ts`)
+      if (!existsSync(configFilePath) && entity.name.endsWith('s')) {
+        const singularName = entity.name.slice(0, -1)
+        configFilePath = join(entityDir, `${singularName}.config.ts`)
+      }
+    } else if (entity.themeContext) {
+      entityDir = join(CONFIG.contentsDir, 'themes', entity.themeContext.themeName, 'entities', entity.relativePath)
+      configFilePath = join(entityDir, `${entity.name}.config.ts`)
+    } else if (entity.pluginContext) {
+      entityDir = join(CONFIG.contentsDir, 'plugins', entity.pluginContext.pluginName, 'entities', entity.relativePath)
+      configFilePath = join(entityDir, `${entity.name}.config.ts`)
+    }
+
+    if (!configFilePath || !existsSync(configFilePath)) {
+      // Fallback: use basic info from entity object
+      entitiesData[entity.name] = {
+        slug: entity.name,
+        singular: entity.name.endsWith('s') ? entity.name.slice(0, -1) : entity.name,
+        plural: entity.name.charAt(0).toUpperCase() + entity.name.slice(1),
+        tableName: entity.name,
+        fields: [],
+        filters: [],
+        source
+      }
+      continue
+    }
+
+    // Extract detailed data from config
+    const testData = await extractEntityTestData(configFilePath, entityDir)
+    if (testData) {
+      entitiesData[entity.name] = {
+        ...testData,
+        source
+      }
+    }
+  }
+
+  // Build the full JSON structure (selectors are in separate static file: selectors.json)
+  // NOTE: No _generatedAt field to avoid merge conflicts - file only changes when content changes
+  const jsonContent = {
+    $schema: './entities.schema.json',
+    _warning: 'AUTO-GENERATED by build-registry.mjs - DO NOT EDIT MANUALLY',
+    _theme: activeTheme,
+    entities: entitiesData
+  }
+
+  // Write the file
+  const outputPath = join(fixturesDir, 'entities.json')
+  await writeFile(outputPath, JSON.stringify(jsonContent, null, 2), 'utf8')
+  log(`entities.json generated for theme "${activeTheme}"`, 'success')
+}
+
+/**
+ * Generate blocks.json test fixture for the active theme
+ * This file is used by Cypress tests for block-related testing
+ * @param {Array} blocks - All discovered blocks
+ */
+export async function generateTestBlocksJson(blocks) {
+  const activeTheme = CONFIG.activeTheme
+  if (!activeTheme) {
+    verbose('No active theme set, skipping blocks.json generation')
+    return
+  }
+
+  // Check if tests directory exists
+  const fixturesDir = join(CONFIG.contentsDir, 'themes', activeTheme, 'tests', 'cypress', 'fixtures')
+  if (!existsSync(fixturesDir)) {
+    verbose(`Test fixtures directory not found for theme "${activeTheme}", skipping blocks.json`)
+    return
+  }
+
+  // Build blocks data - simplified for tests
+  const blocksData = {
+    available: blocks.map(block => ({
+      slug: block.slug,
+      name: block.name,
+      description: block.description,
+      category: block.category,
+      icon: block.icon,
+      scope: block.scope || ['pages', 'posts']
+    })),
+    categories: [...new Set(blocks.map(b => b.category))].sort(),
+    byCategory: blocks.reduce((acc, block) => {
+      const cat = block.category
+      if (!acc[cat]) acc[cat] = []
+      acc[cat].push(block.slug)
+      return acc
+    }, {})
+  }
+
+  const jsonContent = {
+    $schema: './blocks.schema.json',
+    _warning: 'AUTO-GENERATED by build-registry.mjs - DO NOT EDIT MANUALLY',
+    _theme: activeTheme,
+    _totalBlocks: blocks.length,
+    ...blocksData
+  }
+
+  const outputPath = join(fixturesDir, 'blocks.json')
+  await writeFile(outputPath, JSON.stringify(jsonContent, null, 2), 'utf8')
+  log(`blocks.json generated for theme "${activeTheme}" (${blocks.length} blocks)`, 'success')
+}

package/scripts/build/registry/post-build/tree-display.mjs

@@ -0,0 +1,226 @@
+/**
+ * Tree Display
+ *
+ * Displays discovered content structure in console
+ *
+ * @module core/scripts/build/registry/post-build/tree-display
+ */
+
+/**
+ * Display discovered contents in a beautiful tree structure
+ */
+export function displayTreeStructure(plugins, entities, themes) {
+  console.log('Discovered Contents Structure:')
+  console.log()
+  console.log('contents/')
+
+  // Helper function to get tree characters
+  const getTreeChars = (isLast, hasItems) => {
+    if (!hasItems) return '   (empty)'
+    return isLast ? '└──' : '├──'
+  }
+
+  const getSubTreeChars = (isLast) => isLast ? '    ' : '│   '
+
+  /**
+   * Build entity tree from flat list
+   */
+  function buildEntityTree(entities) {
+    const tree = []
+    const entityMap = new Map()
+
+    // Create map for quick lookup
+    entities.forEach(entity => {
+      entityMap.set(entity.name, { ...entity, children: [] })
+    })
+
+    // Build parent-child relationships
+    entities.forEach(entity => {
+      const entityNode = entityMap.get(entity.name)
+      if (entity.parent && entityMap.has(entity.parent)) {
+        entityMap.get(entity.parent).children.push(entityNode)
+      } else if (!entity.parent) {
+        tree.push(entityNode)
+      }
+    })
+
+    return tree
+  }
+
+  /**
+   * Recursively display entity tree
+   */
+  function displayEntityTree(entityNodes, prefix = '') {
+    entityNodes.forEach((entity, index) => {
+      const isLastItem = index === entityNodes.length - 1
+      const features = [
+        entity.hasComponents && 'components',
+        entity.hasHooks && 'hooks',
+        entity.hasMigrations && 'migrations',
+        entity.hasMessages && 'messages',
+        entity.hasAssets && 'assets'
+      ].filter(Boolean)
+      const featureInfo = features.length > 0 ? ` (${features.join(', ')})` : ''
+
+      console.log(`${prefix}${isLastItem ? '└──' : '├──'} ${entity.name}${featureInfo}`)
+
+      // Display config file and migrations
+      const newPrefix = prefix + (isLastItem ? '    ' : '│   ')
+      if (entity.actualConfigFile) {
+        const configLine = `${newPrefix}├── ${entity.actualConfigFile}`
+        console.log(`${configLine}`)
+      }
+      if (entity.hasMigrations) {
+        const migrationsLine = `${newPrefix}└── migrations/`
+        console.log(`${migrationsLine}`)
+      }
+
+      // Recursively display children
+      if (entity.children && entity.children.length > 0) {
+        const childPrefix = newPrefix
+        displayEntityTree(entity.children, childPrefix, isLastItem)
+      }
+    })
+  }
+
+  /**
+   * Display plugin tree with nested entities
+   */
+  function displayPluginTree(plugin, prefix = '', isLast = true) {
+    const info = [
+      plugin.hasAPI && `API [${plugin.routeFiles.length} routes]`,
+      plugin.entities?.length > 0 && `${plugin.entities.length} entities`,
+      plugin.hasMessages && 'messages',
+      plugin.hasAssets && 'assets'
+    ].filter(Boolean).join(', ')
+
+    const pluginInfo = info ? ` (${info})` : ''
+    console.log(`${prefix}${isLast ? '└──' : '├──'} ${plugin.name}${pluginInfo}`)
+
+    const newPrefix = prefix + (isLast ? '    ' : '│   ')
+
+    // Display assets if present
+    if (plugin.hasAssets) {
+      console.log(`${newPrefix}├── assets`)
+    }
+
+    // Display messages if present
+    if (plugin.hasMessages) {
+      console.log(`${newPrefix}├── messages`)
+    }
+
+    // Display entities
+    if (plugin.entities && plugin.entities.length > 0) {
+      console.log(`${newPrefix}├── entities`)
+      const entityTree = buildEntityTree(plugin.entities)
+      displayEntityTree(entityTree, newPrefix + '│   ', false)
+    }
+
+    // Display routes
+    if (plugin.routeFiles && plugin.routeFiles.length > 0) {
+      console.log(`${newPrefix}└── api [${plugin.routeFiles.length} routes]`)
+      plugin.routeFiles.forEach((route, routeIndex) => {
+        const isLastRoute = routeIndex === plugin.routeFiles.length - 1
+        const routePrefix = newPrefix + '    '
+        console.log(`${routePrefix}${isLastRoute ? '└──' : '├──'} ${route.path}`)
+      })
+    }
+  }
+
+  // Display plugins
+  const hasPlugins = plugins.length > 0
+  const hasThemes = themes.length > 0
+
+  const totalSections = [hasPlugins, hasThemes].filter(Boolean).length
+  let sectionIndex = 0
+
+  // Plugins section
+  if (hasPlugins || plugins.length === 0) {
+    sectionIndex++
+    const isLastSection = sectionIndex === totalSections
+    console.log(`${getTreeChars(isLastSection && !hasThemes, hasPlugins)} plugins/`)
+
+    plugins.forEach((plugin, index) => {
+      const isLastPlugin = index === plugins.length - 1
+      const subPrefix = getSubTreeChars(isLastSection && !hasThemes)
+      displayPluginTree(plugin, subPrefix, isLastPlugin)
+    })
+  }
+
+  /**
+   * Display theme tree with entities, routes, and plugin dependencies
+   */
+  function displayThemeTree(theme, prefix = '', isLast = true) {
+    const info = [
+      theme.plugins && theme.plugins.length > 0 && `uses: [${theme.plugins.join(', ')}]`,
+      theme.entities?.length > 0 && `${theme.entities.length} entities`,
+      theme.routeFiles?.length > 0 && `${theme.routeFiles.length} routes`,
+      theme.hasComponents && 'components',
+      theme.hasStyles && 'styles',
+      theme.hasAssets && 'assets',
+      theme.hasMessages && 'messages'
+    ].filter(Boolean).join(', ')
+
+    const themeInfo = info ? ` (${info})` : ''
+    console.log(`${prefix}${isLast ? '└──' : '├──'} ${theme.name}${themeInfo}`)
+
+    const newPrefix = prefix + (isLast ? '    ' : '│   ')
+
+    // Display plugin dependencies
+    if (theme.plugins && theme.plugins.length > 0) {
+      console.log(`${newPrefix}├── plugins: [${theme.plugins.join(', ')}]`)
+    }
+
+    // Display assets if present
+    if (theme.hasAssets) {
+      console.log(`${newPrefix}├── assets`)
+    }
+
+    // Display messages if present
+    if (theme.hasMessages) {
+      console.log(`${newPrefix}├── messages`)
+    }
+
+    // Display styles if present
+    if (theme.hasStyles) {
+      console.log(`${newPrefix}├── styles`)
+    }
+
+    // Display components if present
+    if (theme.hasComponents) {
+      console.log(`${newPrefix}├── components`)
+    }
+
+    // Display entities
+    if (theme.entities && theme.entities.length > 0) {
+      console.log(`${newPrefix}├── entities [${theme.entities.length}]`)
+      const entityTree = buildEntityTree(theme.entities)
+      displayEntityTree(entityTree, newPrefix + '│   ', false)
+    }
+
+    // Display routes
+    if (theme.routeFiles && theme.routeFiles.length > 0) {
+      console.log(`${newPrefix}└── api [${theme.routeFiles.length} routes]`)
+      theme.routeFiles.forEach((route, routeIndex) => {
+        const isLastRoute = routeIndex === theme.routeFiles.length - 1
+        const routePrefix = newPrefix + '    '
+        console.log(`${routePrefix}${isLastRoute ? '└──' : '├──'} ${route.path}`)
+      })
+    }
+  }
+
+  // Themes section
+  if (hasThemes || themes.length === 0) {
+    sectionIndex++
+    const isLastSection = sectionIndex === totalSections
+    console.log(`${getTreeChars(isLastSection && !hasThemes, hasThemes)} themes/`)
+
+    themes.forEach((theme, index) => {
+      const isLastTheme = index === themes.length - 1
+      const subPrefix = getSubTreeChars(isLastSection && !hasThemes)
+      displayThemeTree(theme, subPrefix, isLastTheme)
+    })
+  }
+
+  console.log()
+}