@nextsparkjs/core 0.1.0-beta.191 → 0.1.0-beta.192

package/scripts/build/registry/host/static-imports.mjs

@@ -0,0 +1,317 @@
+/**
+ * Generated-module gate for the generated host (#203)
+ *
+ * NextSpark writes every file under `src/app` and `.nextspark/registries` itself, so instead of
+ * guessing how a runtime lookup might be spelled, each generated file is validated against a
+ * small allowed grammar. Anything outside it - any expression, call, member access, function,
+ * class, `export *`, computed key or spread - is a violation, which rules out selecting a module
+ * by a runtime value however it is written.
+ *
+ * Grammar `facade` (route files), top-level statements only:
+ *   - a directive prologue of `'use client'`
+ *   - `import X from '<string>'`, `import { a, b as c } from '<string>'`, type-only imports
+ *   - `export { a, b as c } from '<string>'`
+ *   - `export { local, local as name }` of names imported in the same file
+ *   - `export const name = <literal>` where the literal is exactly what `evaluateNextLiteral`
+ *     (Next's extract-const-value) accepts
+ *
+ * The `facade` grammar also allows a fixed stylesheet import, `import '<string>.css'`: the root layout
+ * imports the project's global stylesheet. It selects no module by a runtime value: the specifier is a
+ * string literal, and only a `.css` one is accepted.
+ *
+ * Grammar `composed-facade` (a route whose default export or Route Handler methods are a fixed
+ * composition, render.mjs / entity-routes.mjs): the `facade` grammar plus
+ *   - at most one `export default <composition>`, and
+ *   - any number of `export const NAME = <composition>`,
+ * where a composition is `wrapper(arg, ...)`: the callee is a name imported in the same file, each argument
+ * is an imported name, a string literal, an array of string literals, or a nested composition. No other
+ * call, member access, spread or expression is accepted, so a composition can only apply fixed, statically
+ * imported modules to each other: `export default withPublicMessages(Template)`,
+ * `export default createEntityListRoute(taskEntityConfig, Template)`,
+ * `export const POST = createStripeWebhookRoute(stripeWebhookExtensions)`.
+ *
+ * Grammar `dev-facade` (the root layout of a `nextspark dev` generation, render.mjs): the
+ * `composed-facade` grammar, except that the only composition is exactly one `export default` whose
+ * outermost callee is `withGenerationStatus`, imported from './_nextspark/generation-status' - a fixed
+ * composition of fixed modules, never emitted by a production preparation.
+ *
+ * Grammar `registry` (`.nextspark/registries`):
+ *   - the same imports
+ *   - `export const NAME = <value>` where value is an object or array literal (optionally
+ *     `as const` / `satisfies T`) whose keys are identifiers or string/number literals and whose
+ *     leaves are literals (string, number, boolean, null, plain template) or identifiers imported
+ *     in the same file; shorthand properties only for imported names; no computed keys, spreads,
+ *     methods, getters/setters or calls
+ *
+ * @module core/scripts/build/registry/host/static-imports
+ */
+
+import { loadTypeScriptFor } from '../shared/typescript-compiler.mjs'
+import { evaluateNextLiteral } from './next-literal.mjs'
+
+export const GRAMMARS = ['facade', 'composed-facade', 'dev-facade', 'registry']
+
+/** The module the `dev-facade` grammar's composition imports its wrapper from. */
+export const DEV_STATUS_SPECIFIER = './_nextspark/generation-status'
+/** The wrapper a dev root layout composes with. */
+export const DEV_STATUS_WRAPPER = 'withGenerationStatus'
+
+const ALLOWED_DIRECTIVES = new Set(['use client'])
+
+const INTERNAL = '@nextsparkjs/core/routes/_internal/'
+
+/**
+ * The composition wrappers of core the generator writes calls of, by the exact module specifier that exports them.
+ * `withSuperadminMessages` / `withDevtoolsMessages` are deliberately absent: a protected group's override is composed only
+ * with the guard wrappers, which put core's role check around the project's layout.
+ */
+export const CORE_COMPOSITION_WRAPPERS = Object.freeze({
+  [`${INTERNAL}root-layout`]: ['withRootLayout'],
+  [`${INTERNAL}root-layout.ppr`]: ['withRootLayout'],
+  [`${INTERNAL}auth-layout`]: ['withAuthMessages'],
+  [`${INTERNAL}public-layout`]: ['withPublicMessages'],
+  [`${INTERNAL}superadmin-layout`]: ['withSuperadminGuard'],
+  [`${INTERNAL}devtools-layout`]: ['withDevtoolsGuard'],
+  // The Cache Components modules (variants.json): the same wrappers over that mode's messages, each imported from the module
+  // that exports it. `withSuperadminMessages` / `withDevtoolsMessages` stay absent here too.
+  [`${INTERNAL}auth-layout.cc`]: ['withAuthMessages'],
+  [`${INTERNAL}public-layout.cc`]: ['withPublicMessages'],
+  [`${INTERNAL}superadmin-layout.cc`]: ['withSuperadminGuard'],
+  [`${INTERNAL}devtools-layout.cc`]: ['withDevtoolsGuard'],
+  // Every page and layout under /superadmin and /devtools (the manifest's `access`).
+  [`${INTERNAL}area-access`]: ['withSuperadminAccess', 'withDevtoolsAccess', 'withSuperadminMetadata', 'withDevtoolsMetadata', 'withSuperadminRouteAccess', 'withDevtoolsRouteAccess'],
+  [`${INTERNAL}entity-layout-route`]: ['createEntityLayoutRoute'],
+  [`${INTERNAL}entity-list-route`]: ['createEntityListRoute'],
+  [`${INTERNAL}entity-detail-route`]: ['createEntityDetailRoute'],
+  [`${INTERNAL}entity-create-route`]: ['createEntityCreateRoute'],
+  [`${INTERNAL}entity-edit-route`]: ['createEntityEditRoute'],
+  [`${INTERNAL}public-item-route`]: ['createPublicItemRoute', 'createPublicItemMetadata'],
+  [`${INTERNAL}public-item-route.cc`]: ['createPublicItemRoute', 'createPublicItemMetadata'],
+  [`${INTERNAL}public-archive-route`]: ['createPublicArchiveRoute', 'createPublicArchiveMetadata'],
+  [`${INTERNAL}billing-webhooks`]: ['createStripeWebhookRoute', 'createPolarWebhookRoute'],
+  [DEV_STATUS_SPECIFIER]: [DEV_STATUS_WRAPPER],
+})
+
+/** The callees that take the array of child entity names as their second argument. */
+const CHILD_NAMES_CALLEES = new Set(['createEntityDetailRoute'])
+
+function hasModifier(node, kind) {
+  return Boolean(node.modifiers?.some(modifier => modifier.kind === kind))
+}
+
+/**
+ * Violations of `grammar` in a parsed generated module.
+ * @returns {{ kind: string, line: number, text: string }[]}
+ */
+export function validateGeneratedSourceFile(sourceFile, ts, grammar, wrappers = CORE_COMPOSITION_WRAPPERS) {
+  if (!GRAMMARS.includes(grammar)) throw new Error(`Unknown generated-module grammar "${grammar}"`)
+  const facade = grammar !== 'registry'
+  const composing = grammar === 'composed-facade' || grammar === 'dev-facade'
+  const K = ts.SyntaxKind
+  const violations = []
+  const report = (kind, node, detail) =>
+    violations.push({
+      kind,
+      line: sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1,
+      text: `${detail ? `${detail}: ` : ''}${node.getText(sourceFile).replace(/\s+/g, ' ').slice(0, 120)}`,
+    })
+
+  // Pass 1: imports (they may appear anywhere at top level; their names are what exports and
+  // registry leaves may reference).
+  const imported = new Set()
+  // local name -> where a named import comes from (a composition callee must be an allowlisted wrapper)
+  const importedFrom = new Map()
+  const defaultImports = new Set()
+  const devWrappers = new Set()
+  let composed = 0
+  for (const statement of sourceFile.statements) {
+    if (!ts.isImportDeclaration(statement)) continue
+    const clause = statement.importClause
+    if (!clause) {
+      // Only a fixed stylesheet: `import '@/styles/globals.css'`.
+      if (!(facade && ts.isStringLiteral(statement.moduleSpecifier) && /\.css$/.test(statement.moduleSpecifier.text))) report('side-effect-import', statement)
+      continue
+    }
+    if (clause.namedBindings && !ts.isNamedImports(clause.namedBindings)) {
+      report('namespace-import', statement)
+      continue
+    }
+    if (clause.isTypeOnly) continue
+    if (clause.name) {
+      imported.add(clause.name.text)
+      defaultImports.add(clause.name.text)
+    }
+    if (statement.moduleSpecifier.text === DEV_STATUS_SPECIFIER) {
+      for (const element of clause.namedBindings?.elements ?? []) {
+        if (!element.isTypeOnly && (element.propertyName ?? element.name).text === DEV_STATUS_WRAPPER) devWrappers.add(element.name.text)
+      }
+    }
+    for (const element of clause.namedBindings?.elements ?? []) {
+      if (element.isTypeOnly) continue
+      imported.add(element.name.text)
+      importedFrom.set(element.name.text, { specifier: statement.moduleSpecifier.text, name: (element.propertyName ?? element.name).text })
+    }
+  }
+
+  let prologue = true
+  for (const statement of sourceFile.statements) {
+    if (ts.isExpressionStatement(statement) && ts.isStringLiteral(statement.expression) && prologue) {
+      if (!facade || !ALLOWED_DIRECTIVES.has(statement.expression.text)) report('directive', statement, 'directive not allowed')
+      continue
+    }
+    prologue = false
+
+    if (ts.isImportDeclaration(statement)) continue
+
+    // composed-facade: `export default wrapper(...)`, once; dev-facade: once, outermost `withGenerationStatus`.
+    if (ts.isExportAssignment(statement) && !statement.isExportEquals && composing) {
+      composed += 1
+      const problem = compositionProblem(statement.expression, ts, imported, importedFrom, wrappers)
+      if (composed > 1) report('composition', statement, 'only one composed `export default`')
+      else if (problem) report('composition', statement, problem)
+      else if (grammar === 'dev-facade') {
+        // `withGenerationStatus(<default import | composition>)`, nothing else.
+        const call = statement.expression
+        const [argument] = call.arguments
+        const ok =
+          ts.isIdentifier(call.expression) &&
+          devWrappers.has(call.expression.text) &&
+          call.arguments.length === 1 &&
+          (ts.isCallExpression(argument) || (ts.isIdentifier(argument) && defaultImports.has(argument.text)))
+        if (!ok) report('composition', statement, `only \`export default ${DEV_STATUS_WRAPPER}(<default import or composition>)\``)
+      }
+      continue
+    }
+
+    if (ts.isExportDeclaration(statement)) {
+      if (!statement.exportClause || !ts.isNamedExports(statement.exportClause)) {
+        report('export-star', statement)
+        continue
+      }
+      if (statement.moduleSpecifier) {
+        if (!facade) report('re-export', statement, 'registries do not re-export')
+        continue
+      }
+      if (statement.isTypeOnly) continue
+      for (const element of statement.exportClause.elements) {
+        const local = (element.propertyName ?? element.name).text
+        if (!element.isTypeOnly && !imported.has(local)) report('export-of-local', element, `"${local}" is not an imported name`)
+      }
+      continue
+    }
+
+    if (ts.isVariableStatement(statement)) {
+      const isConst = (statement.declarationList.flags & ts.NodeFlags.Const) !== 0
+      if (!hasModifier(statement, K.ExportKeyword) || !isConst || statement.modifiers.length !== 1) {
+        report('declaration', statement, 'only `export const` declarations are allowed')
+        continue
+      }
+      for (const declaration of statement.declarationList.declarations) {
+        if (!ts.isIdentifier(declaration.name) || !declaration.initializer || declaration.type) {
+          report('declaration', declaration, 'expected `export const name = value`')
+          continue
+        }
+        if (facade) {
+          const literal = evaluateNextLiteral(declaration.initializer, ts)
+          if ('unsupported' in literal) {
+            // `export const POST = wrapper(...)`: a composition instead of a literal (composed-facade only).
+            const problem = grammar === 'composed-facade' && ts.isCallExpression(declaration.initializer) ? compositionProblem(declaration.initializer, ts, imported, importedFrom, wrappers) : null
+            if (grammar !== 'composed-facade' || !ts.isCallExpression(declaration.initializer)) report('non-literal', declaration.initializer, literal.unsupported)
+            else if (problem) report('composition', declaration.initializer, problem)
+          }
+        } else {
+          validateRegistryValue(declaration.initializer, ts, imported, report, true)
+        }
+      }
+      continue
+    }
+
+    report('statement', statement, `${K[statement.kind]} is not allowed in a generated ${grammar}`)
+  }
+  return violations
+}
+
+
+/**
+ * Why `node` is not a composition (`wrapper(arg, ...)` where `wrapper` is an allowlisted core wrapper imported from the exact
+ * specifier that exports it, and each argument an imported name or a nested composition), or null when it is one.
+ */
+function compositionProblem(node, ts, imported, importedFrom, wrappers) {
+  if (!ts.isCallExpression(node)) return 'expected a call of a core composition wrapper'
+  if (node.typeArguments || node.questionDotToken) return 'no type arguments or optional calls'
+  if (!ts.isIdentifier(node.expression) || !imported.has(node.expression.text)) return 'the callee must be a name imported in this file'
+  const origin = importedFrom.get(node.expression.text)
+  if (!origin || !wrappers[origin.specifier]?.includes(origin.name)) {
+    return `"${node.expression.text}" is not a core composition wrapper (allowed: the wrappers of CORE_COMPOSITION_WRAPPERS, imported from the module that exports them)`
+  }
+  const callee = origin.name
+  for (const [index, argument] of node.arguments.entries()) {
+    if (ts.isIdentifier(argument)) {
+      if (!imported.has(argument.text)) return `"${argument.text}" is not an imported name`
+    } else if (ts.isArrayLiteralExpression(argument) && index === 1 && CHILD_NAMES_CALLEES.has(callee)) {
+      if (!argument.elements.every(element => ts.isStringLiteral(element))) return 'the child entity names are string literals'
+    } else if (ts.isCallExpression(argument)) {
+      const nested = compositionProblem(argument, ts, imported, importedFrom, wrappers)
+      if (nested) return nested
+    } else {
+      return 'arguments are imported names or nested compositions (only createEntityDetailRoute takes a second argument that is an array of child entity names)'
+    }
+  }
+  return null
+}
+
+/** A registry value: object/array literals whose leaves are literals or imported identifiers. */
+function validateRegistryValue(node, ts, imported, report, root = false) {
+  const K = ts.SyntaxKind
+  if (ts.isAsExpression(node) || ts.isSatisfiesExpression(node)) return validateRegistryValue(node.expression, ts, imported, report, root)
+  if (ts.isObjectLiteralExpression(node)) {
+    for (const property of node.properties) {
+      if (ts.isPropertyAssignment(property)) {
+        if (!ts.isIdentifier(property.name) && !ts.isStringLiteral(property.name) && !ts.isNumericLiteral(property.name)) {
+          report('computed-key', property)
+          continue
+        }
+        validateRegistryValue(property.initializer, ts, imported, report)
+      } else if (ts.isShorthandPropertyAssignment(property)) {
+        if (!imported.has(property.name.text) || property.objectAssignmentInitializer) report('shorthand', property, 'shorthand of a name that is not imported')
+      } else {
+        report('property', property, `${K[property.kind]} is not allowed in a registry`)
+      }
+    }
+    return
+  }
+  if (ts.isArrayLiteralExpression(node)) {
+    for (const element of node.elements) {
+      if (ts.isSpreadElement(element) || ts.isOmittedExpression(element)) report('array-element', element.kind === K.OmittedExpression ? node : element)
+      else validateRegistryValue(element, ts, imported, report)
+    }
+    return
+  }
+  if (root) {
+    report('registry-value', node, 'a registry export must be an object or array literal')
+    return
+  }
+  if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node) || ts.isNumericLiteral(node) ||
+      node.kind === K.TrueKeyword || node.kind === K.FalseKeyword || node.kind === K.NullKeyword) return
+  if (ts.isIdentifier(node) && imported.has(node.text)) return
+  report('registry-leaf', node, 'registry leaves must be literals or imported identifiers')
+}
+
+/**
+ * Parse `source` (TS/TSX/JS by its file name) and validate it against `grammar`. A file that
+ * does not parse is itself a violation.
+ */
+export function validateGeneratedModule({ ts, source, file, grammar, wrappers }) {
+  const sourceFile = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true, ts.getScriptKindFromFileName(file))
+  const [parseError] = sourceFile.parseDiagnostics ?? []
+  if (parseError) {
+    const { line } = sourceFile.getLineAndCharacterOfPosition(parseError.start ?? 0)
+    return [{ kind: 'parse-error', line: line + 1, text: ts.flattenDiagnosticMessageText(parseError.messageText, ' ') }]
+  }
+  return validateGeneratedSourceFile(sourceFile, ts, grammar, wrappers)
+}
+
+/** `validateGeneratedModule` with the registry build's TypeScript compiler. */
+export async function checkGeneratedModule({ source, file, grammar, projectRoot = process.cwd(), wrappers }) {
+  return validateGeneratedModule({ ts: await loadTypeScriptFor(projectRoot), source, file, grammar, wrappers })
+}

package/scripts/build/registry/host/webhooks.mjs

@@ -0,0 +1,93 @@
+/**
+ * Billing webhook extensions of the generated host (#203)
+ *
+ * A project that handles one-time payments (credit packs, upsells) extends core's billing webhooks with a module
+ * of its own. It declares the module in nextspark.config.ts:
+ *
+ * ```ts
+ * export default defineConfig({
+ *   billing: {
+ *     webhookExtensions: {
+ *       stripe: './lib/billing/stripe-webhook-extensions', // exports `stripeWebhookExtensions`
+ *       polar: './lib/billing/polar-webhook-extensions',   // exports `polarWebhookExtensions`
+ *     },
+ *   },
+ * })
+ * ```
+ *
+ * The host then replaces core's webhook route with a composed facade that statically imports that module and hands
+ * it to core's handler (`createStripeWebhookRoute` / `createPolarWebhookRoute`). Nothing is loaded by a path chosen at
+ * runtime, and a project without the setting keeps core's route (no extensions).
+ *
+ * @module core/scripts/build/registry/host/webhooks
+ */
+
+import { existsSync, statSync } from 'node:fs'
+import { isAbsolute, join, posix, relative, sep } from 'node:path'
+
+import { CORE_ROUTES_SPECIFIER } from './core-routes.mjs'
+
+export const WEBHOOK_DIAGNOSTICS = Object.freeze({
+  INVALID: 'NS_HOST_WEBHOOK_EXTENSIONS_INVALID',
+  MISSING: 'NS_HOST_WEBHOOK_EXTENSIONS_MISSING',
+})
+
+const BILLING_WEBHOOKS_MODULE = `${CORE_ROUTES_SPECIFIER}_internal/billing-webhooks`
+
+/** The webhook providers the host can extend: core route, the wrapper it composes and the export it needs. */
+export const WEBHOOK_PROVIDERS = Object.freeze({
+  stripe: { target: 'api/v1/billing/webhooks/stripe/route.ts', wrapper: 'createStripeWebhookRoute', exportName: 'stripeWebhookExtensions' },
+  polar: { target: 'api/v1/billing/webhooks/polar/route.ts', wrapper: 'createPolarWebhookRoute', exportName: 'polarWebhookExtensions' },
+})
+
+const EXTENSIONS = ['ts', 'tsx', 'mts', 'js', 'jsx', 'mjs']
+
+/**
+ * The composed webhook routes for `billing.webhookExtensions`.
+ *
+ * @param {object} input
+ * @param {Record<string, string>|undefined} input.webhookExtensions - the config value: provider -> module path, from the project root
+ * @param {string} input.projectRoot
+ * @param {(specifier: string) => string|null} input.resolveFile - core module specifier -> file
+ * @returns {{ routes: Record<string, object>, diagnostics: object[] }} routes by target, for `planHost({ webhooks })`
+ */
+export function webhookRoutes({ webhookExtensions, projectRoot, resolveFile }) {
+  const routes = {}
+  const diagnostics = []
+  for (const [provider, value] of Object.entries(webhookExtensions ?? {})) {
+    const spec = WEBHOOK_PROVIDERS[provider]
+    const where = `nextspark.config.ts billing.webhookExtensions.${provider}`
+    if (!spec) {
+      diagnostics.push({ code: WEBHOOK_DIAGNOSTICS.INVALID, message: `${where}: "${provider}" is not a webhook provider (expected ${Object.keys(WEBHOOK_PROVIDERS).join(', ')})` })
+      continue
+    }
+    if (typeof value !== 'string' || value.trim() === '') {
+      diagnostics.push({ code: WEBHOOK_DIAGNOSTICS.INVALID, message: `${where} must be the path of a module from the project root, such as "./lib/billing/${provider}-webhook-extensions"` })
+      continue
+    }
+    const path = value.trim().replace(/\\/g, '/')
+    const absolute = isAbsolute(path) ? path : join(projectRoot, path)
+    const inside = relative(projectRoot, absolute).split(sep)
+    if (isAbsolute(path) || inside[0] === '..' || inside.includes('..') || inside[0] === 'node_modules') {
+      diagnostics.push({ code: WEBHOOK_DIAGNOSTICS.INVALID, message: `${where} (${JSON.stringify(value)}) must stay inside the project and not point into node_modules` })
+      continue
+    }
+    const withoutExtension = absolute.replace(new RegExp(`\\.(${EXTENSIONS.join('|')})$`), '')
+    const file = [absolute, ...EXTENSIONS.map(extension => `${withoutExtension}.${extension}`)].find(candidate => existsSync(candidate) && statSync(candidate).isFile())
+    if (!file) {
+      diagnostics.push({ code: WEBHOOK_DIAGNOSTICS.MISSING, message: `${where}: no module found at ${JSON.stringify(value)} (tried ${EXTENSIONS.map(extension => `.${extension}`).join(', ')})` })
+      continue
+    }
+    const specifier = `@/${posix.normalize(relative(projectRoot, withoutExtension).split(sep).join('/'))}`
+    routes[spec.target] = {
+      provider,
+      source: `${where} (${value})`,
+      specifier,
+      file,
+      extensionsSpecifier: specifier,
+      exportName: spec.exportName,
+      wrapper: { name: spec.wrapper, specifier: BILLING_WEBHOOKS_MODULE, file: resolveFile(BILLING_WEBHOOKS_MODULE) },
+    }
+  }
+  return { routes, diagnostics }
+}

package/scripts/build/registry/index.mjs

@@ -18,8 +18,6 @@ export {
   discoverNestedEntities,
   discoverThemes,
   discoverThemeRouteFiles,
-  discoverTemplates,
-  discoverThemeTemplates,
   discoverBlocks,
   discoverMiddlewares,
   discoverPermissionsConfig,
@@ -31,11 +29,12 @@ export {
 export {
   generatePluginRegistry,
   generatePluginRegistryClient,
+  generatePluginCatalog,
   generateEntityRegistry,
   generateEntityRegistryClient,
   generateThemeRegistry,
-  generateTemplateRegistry,
-  generateTemplateRegistryClient,
+  generateThemeRegistryClient,
+  generateAppConfigClient,
   generateBlockRegistry,
   generateMiddlewareRegistry,
   generateTranslationRegistry,
@@ -51,22 +50,14 @@ export {
 
 // Post-build tasks
 export {
-  analyzeTemplates,
-  generateMissingPages,
-  generateTemplatePage,
   displayTreeStructure,
   generateTestEntitiesJson,
-  extractEntityTestData,
-  cleanupOldRouteFiles,
-  cleanupOrphanedTemplates
+  extractEntityTestData
 } from './post-build/index.mjs'
 
 // Validation
 export { validateEntityConfigurations } from './validation/entity-validator.mjs'
 
-// Watch mode
-export { watchContents } from './watch.mjs'
-
 /**
  * Build all registries
  *

package/scripts/build/registry/post-build/index.mjs

@@ -1,17 +1,10 @@
 /**
  * Post-Build Module - Tasks that run after registry generation
  *
- * Handles page generation, cleanup, test fixtures, and tree display.
+ * Handles test fixtures and tree display.
  *
  * @module core/scripts/build/registry/post-build
  */
 
-export { analyzeTemplates, generateMissingPages, generateTemplatePage } from './page-generator.mjs'
 export { displayTreeStructure } from './tree-display.mjs'
 export { generateTestEntitiesJson, generateTestBlocksJson, extractEntityTestData } from './test-fixtures.mjs'
-export {
-  cleanupOldRouteFiles,
-  cleanupOrphanedTemplates,
-  mapTemplateToAppPath,
-  cleanupDeletedTemplate
-} from './route-cleanup.mjs'

package/scripts/build/registry/post-build/own-gitignores.mjs

@@ -1,8 +1,7 @@
 /**
  * The .gitignore files nextspark keeps in the two directories none of whose
  * content has a place in git: .nextspark/backups, where each backup of a file
- * the registry build or `nextspark sync:app` replaces or removes goes into a
- * directory named as it is created, and .nextspark/registries, which the
+ * nextspark replaces or removes goes into a directory named as it is created, and .nextspark/registries, which the
  * registry build writes again on every run. A .gitignore in a directory that
  * ignores everything in it covers all of it, named however and holding any
  * .gitignore of its own: git takes the patterns of the deepest .gitignore over
@@ -13,8 +12,8 @@
  * before - a .gitignore leaves tracked: each build that rewrites them leaves
  * them modified in git, and says so, with how to stop tracking them.
  *
- * `nextspark sync:app` reads them, and writes the one for backups, through this
- * module, loaded from the core installed in the project.
+ * The CLI reads them, and writes the one for backups, through this module, loaded from the core
+ * installed in the project.
  *
  * @module core/scripts/build/registry/post-build/own-gitignores
  */

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

@@ -21,19 +21,18 @@ const __dirname = dirname(__filename)
 const rootDir = join(__dirname, '../../../../../..')
 
 /**
- * The directory of the active theme's Cypress fixtures, which the build writes
+ * The directory of the project's Cypress fixtures, which the build writes
  * entities.json and blocks.json into when it exists, and the root those writes
  * may land under: the project's, or the monorepo's, where the themes of the
  * monorepo are.
  *
  * @param {object} config - Configuration object from getConfig()
- * @returns {{ fixturesDir: string, root: string } | null} Null when no theme is active
+ * @returns {{ fixturesDir: string, root: string } | null} The project fixture location
  */
 export function testFixturesPlace(config) {
-  if (!config.activeTheme) return null
   return {
-    fixturesDir: join(config.themesDir, config.activeTheme, 'tests', 'cypress', 'fixtures'),
-    root: config.isMonorepoMode ? config.monorepoRoot : config.projectRoot,
+    fixturesDir: join(config.projectSourceDir, 'tests', 'cypress', 'fixtures'),
+    root: config.projectRoot,
   }
 }
 
@@ -101,33 +100,27 @@ export async function extractEntityTestData(configPath, entityDir) {
 }
 
 /**
- * Generate entities.json test fixture for the active theme
+ * Generate entities.json test fixture for the project
  * 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, CONFIG = DEFAULT_CONFIG) {
-  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)
+  const projectName = CONFIG.projectName
+  const theme = themes[0]
   if (!theme) {
-    verbose(`Active theme "${activeTheme}" not found, skipping test fixtures generation`)
+    verbose('No project theme config found, skipping test fixtures generation')
     return
   }
 
   // Check if tests directory exists
   const { fixturesDir, root } = testFixturesPlace(CONFIG)
   if (!existsSync(fixturesDir)) {
-    verbose(`Test fixtures directory not found for theme "${activeTheme}", skipping`)
+    verbose(`Test fixtures directory not found for project "${projectName}", skipping`)
     return
   }
 
-  log(`Generating test fixtures for theme: ${activeTheme}`, 'build')
+  log(`Generating test fixtures for project: ${projectName}`, 'build')
 
   // Build entities data
   const entitiesData = {}
@@ -154,10 +147,11 @@ export async function generateTestEntitiesJson(entities, themes, CONFIG = DEFAUL
         configFilePath = join(entityDir, `${singularName}.config.ts`)
       }
     } else if (entity.themeContext) {
-      entityDir = join(CONFIG.themesDir, entity.themeContext.themeName, 'entities', entity.relativePath)
+      entityDir = join(CONFIG.projectSourceDir, 'entities', entity.relativePath)
       configFilePath = join(entityDir, `${entity.name}.config.ts`)
     } else if (entity.pluginContext) {
-      entityDir = join(CONFIG.pluginsDir, entity.pluginContext.pluginName, 'entities', entity.relativePath)
+      const pluginSource = CONFIG.pluginSources?.find(plugin => plugin.name === entity.pluginContext.pluginName)
+      entityDir = join(pluginSource?.sourceDir ?? join(CONFIG.pluginsDir, entity.pluginContext.pluginName), 'entities', entity.relativePath)
       configFilePath = join(entityDir, `${entity.name}.config.ts`)
     }
 
@@ -190,32 +184,28 @@ export async function generateTestEntitiesJson(entities, themes, CONFIG = DEFAUL
   const jsonContent = {
     $schema: './entities.schema.json',
     _warning: 'AUTO-GENERATED by build-registry.mjs - DO NOT EDIT MANUALLY',
-    _theme: activeTheme,
+    _theme: projectName,
     entities: entitiesData
   }
 
   // Write the file
   const outputPath = join(fixturesDir, 'entities.json')
   await projectFiles(root).writeFile(outputPath, JSON.stringify(jsonContent, null, 2), 'utf8')
-  log(`entities.json generated for theme "${activeTheme}"`, 'success')
+  log(`entities.json generated for project "${projectName}"`, 'success')
 }
 
 /**
- * Generate blocks.json test fixture for the active theme
+ * Generate blocks.json test fixture for the project
  * This file is used by Cypress tests for block-related testing
  * @param {Array} blocks - All discovered blocks
  */
 export async function generateTestBlocksJson(blocks, CONFIG = DEFAULT_CONFIG) {
-  const activeTheme = CONFIG.activeTheme
-  if (!activeTheme) {
-    verbose('No active theme set, skipping blocks.json generation')
-    return
-  }
+  const projectName = CONFIG.projectName
 
   // Check if tests directory exists
   const { fixturesDir, root } = testFixturesPlace(CONFIG)
   if (!existsSync(fixturesDir)) {
-    verbose(`Test fixtures directory not found for theme "${activeTheme}", skipping blocks.json`)
+    verbose(`Test fixtures directory not found for project "${projectName}", skipping blocks.json`)
     return
   }
 
@@ -241,12 +231,12 @@ export async function generateTestBlocksJson(blocks, CONFIG = DEFAULT_CONFIG) {
   const jsonContent = {
     $schema: './blocks.schema.json',
     _warning: 'AUTO-GENERATED by build-registry.mjs - DO NOT EDIT MANUALLY',
-    _theme: activeTheme,
+    _theme: projectName,
     _totalBlocks: blocks.length,
     ...blocksData
   }
 
   const outputPath = join(fixturesDir, 'blocks.json')
   await projectFiles(root).writeFile(outputPath, JSON.stringify(jsonContent, null, 2), 'utf8')
-  log(`blocks.json generated for theme "${activeTheme}" (${blocks.length} blocks)`, 'success')
+  log(`blocks.json generated for project "${projectName}" (${blocks.length} blocks)`, 'success')
 }