@nextsparkjs/core 0.1.0-beta.3 → 0.1.0-beta.4

package/dist/bin/wizard/validators/files.ts

@@ -1,227 +0,0 @@
-/**
- * Files Validator
- *
- * Validates that all required files and directories exist in the generated theme.
- */
-
-import path from 'path'
-import fs from 'fs-extra'
-import type { WizardConfig } from '../types.js'
-import type { ValidationError, ValidationWarning } from './index.js'
-
-/**
- * Required directories that must exist in every theme
- */
-const REQUIRED_DIRECTORIES = [
-  'config',
-  'entities',
-  'blocks',
-  'messages',
-  'migrations',
-]
-
-/**
- * Required config files that must exist
- */
-const REQUIRED_CONFIG_FILES = [
-  'config/theme.config.ts',
-  'config/app.config.ts',
-]
-
-/**
- * Optional but recommended files
- */
-const RECOMMENDED_FILES = [
-  'config/dev.config.ts',
-  'config/permissions.config.ts',
-  'config/billing.config.ts',
-  'README.md',
-]
-
-/**
- * Validate that all required files and directories exist in the theme
- *
- * Checks for:
- * - config/ directory with configuration files
- * - entities/ directory for entity definitions
- * - blocks/ directory for page builder blocks
- * - messages/ directory with locale files
- * - migrations/ directory for database migrations
- *
- * @param themePath - Absolute path to the theme directory
- * @param config - Wizard configuration
- * @returns Object containing errors and warnings
- */
-export async function validateRequiredFiles(
-  themePath: string,
-  config: WizardConfig
-): Promise<{ errors: ValidationError[]; warnings: ValidationWarning[] }> {
-  const errors: ValidationError[] = []
-  const warnings: ValidationWarning[] = []
-
-  // Check if theme directory exists
-  if (!await fs.pathExists(themePath)) {
-    errors.push({
-      type: 'files',
-      message: `Theme directory not found: ${themePath}`,
-    })
-    return { errors, warnings }
-  }
-
-  // Validate required directories
-  for (const dir of REQUIRED_DIRECTORIES) {
-    const dirPath = path.join(themePath, dir)
-    if (!await fs.pathExists(dirPath)) {
-      errors.push({
-        type: 'files',
-        message: `Required directory missing: ${dir}/`,
-        file: dir,
-      })
-    } else {
-      const stat = await fs.stat(dirPath)
-      if (!stat.isDirectory()) {
-        errors.push({
-          type: 'files',
-          message: `Expected directory but found file: ${dir}`,
-          file: dir,
-        })
-      }
-    }
-  }
-
-  // Validate required config files
-  for (const file of REQUIRED_CONFIG_FILES) {
-    const filePath = path.join(themePath, file)
-    if (!await fs.pathExists(filePath)) {
-      errors.push({
-        type: 'files',
-        message: `Required config file missing: ${file}`,
-        file,
-      })
-    }
-  }
-
-  // Check recommended files and warn if missing
-  for (const file of RECOMMENDED_FILES) {
-    const filePath = path.join(themePath, file)
-    if (!await fs.pathExists(filePath)) {
-      warnings.push({
-        type: 'files',
-        message: `Recommended file missing: ${file}`,
-      })
-    }
-  }
-
-  // Validate messages directory has locale files or directories
-  const messagesDir = path.join(themePath, 'messages')
-  if (await fs.pathExists(messagesDir)) {
-    const items = await fs.readdir(messagesDir)
-
-    // Check for namespace directories (messages/en/, messages/es/, etc.)
-    const localeDirs: string[] = []
-    const localeJsonFiles: string[] = []
-
-    for (const item of items) {
-      const itemPath = path.join(messagesDir, item)
-      const stat = await fs.stat(itemPath)
-      if (stat.isDirectory() && !item.startsWith('.')) {
-        localeDirs.push(item)
-      } else if (item.endsWith('.json')) {
-        localeJsonFiles.push(item.replace('.json', ''))
-      }
-    }
-
-    // Determine structure: namespace directories vs flat files
-    const usingNamespaceDirs = localeDirs.length > 0 && localeDirs.some(d => config.supportedLocales.includes(d))
-    const availableLocales = usingNamespaceDirs ? localeDirs : localeJsonFiles
-
-    if (availableLocales.length === 0) {
-      errors.push({
-        type: 'files',
-        message: 'No locale files or directories found in messages/',
-        file: 'messages/',
-      })
-    } else {
-      // Check that default locale exists
-      if (!availableLocales.includes(config.defaultLocale)) {
-        errors.push({
-          type: 'files',
-          message: `Default locale missing: messages/${config.defaultLocale}${usingNamespaceDirs ? '/' : '.json'}`,
-          file: `messages/${config.defaultLocale}${usingNamespaceDirs ? '/' : '.json'}`,
-        })
-      }
-
-      // Check all supported locales
-      for (const locale of config.supportedLocales) {
-        if (!availableLocales.includes(locale)) {
-          warnings.push({
-            type: 'files',
-            message: `Locale missing for supported locale: messages/${locale}${usingNamespaceDirs ? '/' : '.json'}`,
-          })
-        }
-      }
-    }
-  }
-
-  // Validate migrations directory structure
-  const migrationsDir = path.join(themePath, 'migrations')
-  if (await fs.pathExists(migrationsDir)) {
-    const migrationFiles = await fs.readdir(migrationsDir)
-    const sqlFiles = migrationFiles.filter(f => f.endsWith('.sql'))
-    const tsFiles = migrationFiles.filter(f => f.endsWith('.ts'))
-
-    if (sqlFiles.length === 0 && tsFiles.length === 0) {
-      warnings.push({
-        type: 'files',
-        message: 'No migration files found in migrations/ directory',
-      })
-    }
-
-    // Check for migration index file
-    const indexFile = migrationFiles.find(f => f === 'index.ts' || f === 'index.js')
-    if (!indexFile && tsFiles.length > 0) {
-      warnings.push({
-        type: 'files',
-        message: 'migrations/index.ts file recommended for organizing migrations',
-      })
-    }
-  }
-
-  // Validate entities directory has subdirectories
-  const entitiesDir = path.join(themePath, 'entities')
-  if (await fs.pathExists(entitiesDir)) {
-    const entityItems = await fs.readdir(entitiesDir)
-    const entityDirs = []
-
-    for (const item of entityItems) {
-      const itemPath = path.join(entitiesDir, item)
-      const stat = await fs.stat(itemPath)
-      if (stat.isDirectory() && !item.startsWith('.')) {
-        entityDirs.push(item)
-      }
-    }
-
-    if (entityDirs.length === 0) {
-      warnings.push({
-        type: 'files',
-        message: 'No entity directories found in entities/ directory',
-      })
-    }
-  }
-
-  // Validate blocks directory has subdirectories or files
-  const blocksDir = path.join(themePath, 'blocks')
-  if (await fs.pathExists(blocksDir)) {
-    const blockItems = await fs.readdir(blocksDir)
-    const validBlocks = blockItems.filter(item => !item.startsWith('.'))
-
-    if (validBlocks.length === 0) {
-      warnings.push({
-        type: 'files',
-        message: 'No blocks found in blocks/ directory',
-      })
-    }
-  }
-
-  return { errors, warnings }
-}

package/dist/bin/wizard/validators/i18n.ts

@@ -1,394 +0,0 @@
-/**
- * i18n Validator
- *
- * Validates internationalization completeness for the generated theme.
- */
-
-import path from 'path'
-import fs from 'fs-extra'
-import type { WizardConfig } from '../types.js'
-import type { ValidationError, ValidationWarning } from './index.js'
-
-/**
- * Get all translation keys from a JSON object recursively
- */
-function getTranslationKeys(obj: Record<string, unknown>, prefix = ''): string[] {
-  const keys: string[] = []
-
-  for (const key of Object.keys(obj)) {
-    const fullKey = prefix ? `${prefix}.${key}` : key
-    const value = obj[key]
-
-    if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
-      keys.push(...getTranslationKeys(value as Record<string, unknown>, fullKey))
-    } else {
-      keys.push(fullKey)
-    }
-  }
-
-  return keys
-}
-
-/**
- * Compare two sets of keys and find missing ones
- */
-function findMissingKeys(referenceKeys: string[], targetKeys: string[]): string[] {
-  const targetSet = new Set(targetKeys)
-  return referenceKeys.filter(key => !targetSet.has(key))
-}
-
-/**
- * Find extra keys that exist in target but not in reference
- */
-function findExtraKeys(referenceKeys: string[], targetKeys: string[]): string[] {
-  const referenceSet = new Set(referenceKeys)
-  return targetKeys.filter(key => !referenceSet.has(key))
-}
-
-/**
- * Validate i18n translations for completeness
- *
- * Checks that:
- * - All supported locales have translation files
- * - All namespaces exist in each locale
- * - Translation keys are consistent across locales
- *
- * @param themePath - Absolute path to the theme directory
- * @param config - Wizard configuration
- * @returns Object containing errors and warnings
- */
-export async function validateI18n(
-  themePath: string,
-  config: WizardConfig
-): Promise<{ errors: ValidationError[]; warnings: ValidationWarning[] }> {
-  const errors: ValidationError[] = []
-  const warnings: ValidationWarning[] = []
-
-  const messagesDir = path.join(themePath, 'messages')
-
-  // Check if messages directory exists
-  if (!await fs.pathExists(messagesDir)) {
-    errors.push({
-      type: 'i18n',
-      message: 'messages/ directory not found',
-    })
-    return { errors, warnings }
-  }
-
-  // Get all locale files
-  const items = await fs.readdir(messagesDir)
-  const localeFiles: string[] = []
-  const localeDirs: string[] = []
-
-  for (const item of items) {
-    const itemPath = path.join(messagesDir, item)
-    const stat = await fs.stat(itemPath)
-
-    if (stat.isDirectory() && !item.startsWith('.')) {
-      localeDirs.push(item)
-    } else if (item.endsWith('.json')) {
-      localeFiles.push(item.replace('.json', ''))
-    }
-  }
-
-  // Determine if using flat files or namespace directories
-  const usingNamespaceDirs = localeDirs.length > 0 && localeDirs.some(d => config.supportedLocales.includes(d))
-  const availableLocales = usingNamespaceDirs ? localeDirs : localeFiles
-
-  // Check that all supported locales exist
-  for (const locale of config.supportedLocales) {
-    if (!availableLocales.includes(locale)) {
-      errors.push({
-        type: 'i18n',
-        message: `Missing translations for locale: ${locale}`,
-        file: `messages/${locale}${usingNamespaceDirs ? '/' : '.json'}`,
-      })
-    }
-  }
-
-  // Validate translation completeness using default locale as reference
-  const defaultLocale = config.defaultLocale
-
-  if (usingNamespaceDirs) {
-    // Namespace directory structure: messages/en/common.json, messages/es/common.json
-    await validateNamespaceDirectories(
-      messagesDir,
-      defaultLocale,
-      config.supportedLocales,
-      errors,
-      warnings
-    )
-  } else {
-    // Flat file structure: messages/en.json, messages/es.json
-    await validateFlatFiles(
-      messagesDir,
-      defaultLocale,
-      config.supportedLocales,
-      errors,
-      warnings
-    )
-  }
-
-  // Validate entity messages if they exist
-  const entitiesDir = path.join(themePath, 'entities')
-  if (await fs.pathExists(entitiesDir)) {
-    await validateEntityMessages(
-      entitiesDir,
-      config,
-      errors,
-      warnings
-    )
-  }
-
-  return { errors, warnings }
-}
-
-/**
- * Validate namespace directory structure
- */
-async function validateNamespaceDirectories(
-  messagesDir: string,
-  defaultLocale: string,
-  supportedLocales: string[],
-  errors: ValidationError[],
-  warnings: ValidationWarning[]
-): Promise<void> {
-  const defaultLocaleDir = path.join(messagesDir, defaultLocale)
-
-  if (!await fs.pathExists(defaultLocaleDir)) {
-    errors.push({
-      type: 'i18n',
-      message: `Default locale directory not found: messages/${defaultLocale}/`,
-      file: `messages/${defaultLocale}/`,
-    })
-    return
-  }
-
-  // Get namespaces from default locale
-  const namespaceFiles = await fs.readdir(defaultLocaleDir)
-  const namespaces = namespaceFiles
-    .filter(f => f.endsWith('.json'))
-    .map(f => f.replace('.json', ''))
-
-  if (namespaces.length === 0) {
-    warnings.push({
-      type: 'i18n',
-      message: `No namespace files found in messages/${defaultLocale}/`,
-    })
-    return
-  }
-
-  // Check each locale has all namespaces and keys
-  for (const locale of supportedLocales) {
-    if (locale === defaultLocale) continue
-
-    const localeDir = path.join(messagesDir, locale)
-    if (!await fs.pathExists(localeDir)) continue
-
-    for (const namespace of namespaces) {
-      const defaultFile = path.join(defaultLocaleDir, `${namespace}.json`)
-      const localeFile = path.join(localeDir, `${namespace}.json`)
-
-      if (!await fs.pathExists(localeFile)) {
-        errors.push({
-          type: 'i18n',
-          message: `Missing namespace file: messages/${locale}/${namespace}.json`,
-          file: `messages/${locale}/${namespace}.json`,
-        })
-        continue
-      }
-
-      // Compare keys
-      try {
-        const defaultContent = await fs.readJson(defaultFile)
-        const localeContent = await fs.readJson(localeFile)
-
-        const defaultKeys = getTranslationKeys(defaultContent)
-        const localeKeys = getTranslationKeys(localeContent)
-
-        const missingKeys = findMissingKeys(defaultKeys, localeKeys)
-        const extraKeys = findExtraKeys(defaultKeys, localeKeys)
-
-        if (missingKeys.length > 0) {
-          warnings.push({
-            type: 'i18n',
-            message: `Locale ${locale}/${namespace}.json missing ${missingKeys.length} keys: ${missingKeys.slice(0, 3).join(', ')}${missingKeys.length > 3 ? '...' : ''}`,
-          })
-        }
-
-        if (extraKeys.length > 0) {
-          warnings.push({
-            type: 'i18n',
-            message: `Locale ${locale}/${namespace}.json has ${extraKeys.length} extra keys not in default locale`,
-          })
-        }
-      } catch (error) {
-        errors.push({
-          type: 'i18n',
-          message: `Invalid JSON in messages/${locale}/${namespace}.json`,
-          file: `messages/${locale}/${namespace}.json`,
-        })
-      }
-    }
-  }
-}
-
-/**
- * Validate flat file structure
- */
-async function validateFlatFiles(
-  messagesDir: string,
-  defaultLocale: string,
-  supportedLocales: string[],
-  errors: ValidationError[],
-  warnings: ValidationWarning[]
-): Promise<void> {
-  const defaultFile = path.join(messagesDir, `${defaultLocale}.json`)
-
-  if (!await fs.pathExists(defaultFile)) {
-    errors.push({
-      type: 'i18n',
-      message: `Default locale file not found: messages/${defaultLocale}.json`,
-      file: `messages/${defaultLocale}.json`,
-    })
-    return
-  }
-
-  let defaultContent: Record<string, unknown>
-  let defaultKeys: string[]
-
-  try {
-    defaultContent = await fs.readJson(defaultFile)
-    defaultKeys = getTranslationKeys(defaultContent)
-  } catch (error) {
-    errors.push({
-      type: 'i18n',
-      message: `Invalid JSON in messages/${defaultLocale}.json`,
-      file: `messages/${defaultLocale}.json`,
-    })
-    return
-  }
-
-  // Check each locale file
-  for (const locale of supportedLocales) {
-    if (locale === defaultLocale) continue
-
-    const localeFile = path.join(messagesDir, `${locale}.json`)
-    if (!await fs.pathExists(localeFile)) continue
-
-    try {
-      const localeContent = await fs.readJson(localeFile)
-      const localeKeys = getTranslationKeys(localeContent)
-
-      const missingKeys = findMissingKeys(defaultKeys, localeKeys)
-      const extraKeys = findExtraKeys(defaultKeys, localeKeys)
-
-      if (missingKeys.length > 0) {
-        warnings.push({
-          type: 'i18n',
-          message: `Locale ${locale}.json missing ${missingKeys.length} keys: ${missingKeys.slice(0, 3).join(', ')}${missingKeys.length > 3 ? '...' : ''}`,
-        })
-      }
-
-      if (extraKeys.length > 0) {
-        warnings.push({
-          type: 'i18n',
-          message: `Locale ${locale}.json has ${extraKeys.length} extra keys not in default locale`,
-        })
-      }
-    } catch (error) {
-      errors.push({
-        type: 'i18n',
-        message: `Invalid JSON in messages/${locale}.json`,
-        file: `messages/${locale}.json`,
-      })
-    }
-  }
-}
-
-/**
- * Validate entity-level message files
- */
-async function validateEntityMessages(
-  entitiesDir: string,
-  config: WizardConfig,
-  errors: ValidationError[],
-  warnings: ValidationWarning[]
-): Promise<void> {
-  const entityItems = await fs.readdir(entitiesDir)
-
-  for (const entity of entityItems) {
-    const entityPath = path.join(entitiesDir, entity)
-    const stat = await fs.stat(entityPath)
-
-    if (!stat.isDirectory() || entity.startsWith('.')) continue
-
-    const entityMessagesDir = path.join(entityPath, 'messages')
-    if (!await fs.pathExists(entityMessagesDir)) continue
-
-    const messageFiles = await fs.readdir(entityMessagesDir)
-    const localeFiles = messageFiles
-      .filter(f => f.endsWith('.json'))
-      .map(f => f.replace('.json', ''))
-
-    // Check that default locale exists
-    if (!localeFiles.includes(config.defaultLocale)) {
-      warnings.push({
-        type: 'i18n',
-        message: `Entity ${entity} missing default locale: entities/${entity}/messages/${config.defaultLocale}.json`,
-      })
-      continue
-    }
-
-    // Check that all supported locales exist
-    for (const locale of config.supportedLocales) {
-      if (!localeFiles.includes(locale)) {
-        warnings.push({
-          type: 'i18n',
-          message: `Entity ${entity} missing locale: entities/${entity}/messages/${locale}.json`,
-        })
-      }
-    }
-
-    // Validate key consistency for entity messages
-    const defaultFile = path.join(entityMessagesDir, `${config.defaultLocale}.json`)
-    if (!await fs.pathExists(defaultFile)) continue
-
-    try {
-      const defaultContent = await fs.readJson(defaultFile)
-      const defaultKeys = getTranslationKeys(defaultContent)
-
-      for (const locale of config.supportedLocales) {
-        if (locale === config.defaultLocale) continue
-
-        const localeFile = path.join(entityMessagesDir, `${locale}.json`)
-        if (!await fs.pathExists(localeFile)) continue
-
-        try {
-          const localeContent = await fs.readJson(localeFile)
-          const localeKeys = getTranslationKeys(localeContent)
-          const missingKeys = findMissingKeys(defaultKeys, localeKeys)
-
-          if (missingKeys.length > 0) {
-            warnings.push({
-              type: 'i18n',
-              message: `Entity ${entity}/${locale}.json missing ${missingKeys.length} keys`,
-            })
-          }
-        } catch {
-          errors.push({
-            type: 'i18n',
-            message: `Invalid JSON in entities/${entity}/messages/${locale}.json`,
-            file: `entities/${entity}/messages/${locale}.json`,
-          })
-        }
-      }
-    } catch {
-      errors.push({
-        type: 'i18n',
-        message: `Invalid JSON in entities/${entity}/messages/${config.defaultLocale}.json`,
-        file: `entities/${entity}/messages/${config.defaultLocale}.json`,
-      })
-    }
-  }
-}