@pradip1995/framework-compiler 0.2.4 → 0.3.0

package/bin/backend-build.js

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+/**
+ * backend-build — reads plugins.config.json + backend.config.json,
+ * generates Medusa backend into .generated-backend/ (gitignored).
+ */
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  writeFileSync,
+} from "fs"
+import { join, dirname, resolve } from "path"
+import { fileURLToPath } from "url"
+import { createRequire } from "module"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const require = createRequire(import.meta.url)
+const COMPILER_ROOT = join(__dirname, "..")
+const TEMPLATE_ROOT = join(COMPILER_ROOT, "backend-templates")
+
+const { generateMedusaConfig } = require(join(TEMPLATE_ROOT, "generate-medusa-config.cjs"))
+const {
+  buildBackendPackageJson,
+  resolveEnabledPlugins,
+  resolveDependencies,
+} = require(join(TEMPLATE_ROOT, "generate-backend-package.cjs"))
+const { buildHomepageConfigDefaults } = require(
+  join(TEMPLATE_ROOT, "scripts", "build-homepage-defaults.cjs")
+)
+
+const clientDir = resolve(process.cwd())
+const outDir = join(clientDir, ".generated-backend")
+
+function loadJson(path) {
+  return JSON.parse(readFileSync(path, "utf8"))
+}
+
+function applyTemplate(content, vars) {
+  return content.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? "")
+}
+
+function copyDir(src, dest, { skip = [] } = {}) {
+  if (!existsSync(src)) return
+  mkdirSync(dest, { recursive: true })
+  for (const entry of readdirSync(src, { withFileTypes: true })) {
+    if (skip.includes(entry.name)) continue
+    const from = join(src, entry.name)
+    const to = join(dest, entry.name)
+    if (entry.isDirectory()) {
+      copyDir(from, to, { skip })
+    } else {
+      cpSync(from, to)
+    }
+  }
+}
+
+function resolveTemplateVars(backendConfig) {
+  const defaultRegion = backendConfig.defaultRegion || "in"
+  const regionCurrency = {
+    in: { currency: "inr", name: "India" },
+    us: { currency: "usd", name: "United States" },
+    gb: { currency: "gbp", name: "United Kingdom" },
+    eu: { currency: "eur", name: "Europe" },
+  }
+  const meta = regionCurrency[defaultRegion] || {
+    currency: defaultRegion.length === 2 ? defaultRegion : "usd",
+    name: defaultRegion.toUpperCase(),
+  }
+
+  return {
+    DEFAULT_REGION: defaultRegion,
+    DEFAULT_CURRENCY: meta.currency,
+    DEFAULT_REGION_NAME: meta.name,
+  }
+}
+
+function preserveHomepageConfig() {
+  const configDir = join(outDir, "config")
+  const homepagePath = join(configDir, "homepage-config.json")
+  const defaultsPath = join(configDir, "homepage-config.defaults.json")
+  if (!existsSync(homepagePath)) return null
+  return {
+    homepage: readFileSync(homepagePath, "utf8"),
+    defaults: existsSync(defaultsPath) ? readFileSync(defaultsPath, "utf8") : null,
+  }
+}
+
+function restoreHomepageConfig(configDir, preserved) {
+  if (!preserved) return
+  writeFileSync(join(configDir, "homepage-config.json"), preserved.homepage)
+  if (preserved.defaults) {
+    writeFileSync(join(configDir, "homepage-config.defaults.json"), preserved.defaults)
+  } else {
+    const schema = JSON.parse(preserved.homepage)
+    writeFileSync(
+      join(configDir, "homepage-config.defaults.json"),
+      `${JSON.stringify(buildHomepageConfigDefaults(schema), null, 2)}\n`
+    )
+  }
+}
+
+function main() {
+  console.log("backend build")
+  console.log("  client:", clientDir)
+  console.log("  output:", outDir)
+
+  const pluginsConfigPath = join(clientDir, "plugins.config.json")
+  const backendConfigPath = join(clientDir, "backend.config.json")
+
+  if (!existsSync(pluginsConfigPath)) {
+    console.error("Missing plugins.config.json in", clientDir)
+    process.exit(1)
+  }
+  if (!existsSync(backendConfigPath)) {
+    console.error("Missing backend.config.json in", clientDir)
+    process.exit(1)
+  }
+
+  const pluginsConfig = loadJson(pluginsConfigPath)
+  const backendConfig = loadJson(backendConfigPath)
+  const defaults = loadJson(join(TEMPLATE_ROOT, "medusa-plugin-versions.json"))
+
+  const enabledPlugins = resolveEnabledPlugins(pluginsConfig, backendConfig, defaults)
+  const { medusa, plugins } = resolveDependencies(pluginsConfig, enabledPlugins, defaults)
+  const preset = backendConfig.preset || "full"
+  const templateVars = resolveTemplateVars(backendConfig)
+
+  const preservedHomepage = preserveHomepageConfig()
+
+  if (existsSync(outDir)) {
+    rmSync(outDir, { recursive: true, force: true })
+  }
+  mkdirSync(outDir, { recursive: true })
+
+  copyDir(join(TEMPLATE_ROOT, "src"), join(outDir, "src"))
+  copyDir(join(TEMPLATE_ROOT, "scripts"), join(outDir, "scripts"))
+  cpSync(join(TEMPLATE_ROOT, "tsconfig.json"), join(outDir, "tsconfig.json"))
+
+  const seedContent = applyTemplate(
+    readFileSync(join(TEMPLATE_ROOT, "src", "scripts", "seed.ts"), "utf8"),
+    templateVars
+  )
+  writeFileSync(join(outDir, "src", "scripts", "seed.ts"), seedContent)
+
+  const configDir = join(outDir, "config")
+  mkdirSync(configDir, { recursive: true })
+  if (preservedHomepage) {
+    restoreHomepageConfig(configDir, preservedHomepage)
+  } else {
+    cpSync(join(TEMPLATE_ROOT, "config", "homepage-config.json"), join(configDir, "homepage-config.json"))
+    const schema = loadJson(join(configDir, "homepage-config.json"))
+    writeFileSync(
+      join(configDir, "homepage-config.defaults.json"),
+      `${JSON.stringify(buildHomepageConfigDefaults(schema), null, 2)}\n`
+    )
+  }
+
+  writeFileSync(
+    join(outDir, "medusa-config.ts"),
+    generateMedusaConfig({ enabledPlugins, preset })
+  )
+
+  writeFileSync(
+    join(outDir, "package.json"),
+    `${JSON.stringify(
+      buildBackendPackageJson({
+        medusa,
+        plugins,
+        projectName: backendConfig.projectName || "store",
+      }),
+      null,
+      2
+    )}\n`
+  )
+
+  writeFileSync(join(outDir, ".npmrc"), "legacy-peer-deps=true\n")
+
+  const envSource = join(clientDir, ".env")
+  if (existsSync(envSource)) {
+    cpSync(envSource, join(outDir, ".env"))
+  }
+
+  console.log("  plugins:", enabledPlugins.length)
+  console.log("Done.")
+}
+
+main()

package/bin/storefront-build.js

@@ -132,9 +132,7 @@ function main() {
   // Copy static assets: plugin public/ dirs, then client overrides
   copyPublicAssets(packages, clientDir, outDir)
 
-  console.log(
-    "  dynamic-config: schema in backend/config/homepage-config.json — storefront fetches GET /store/dynamic-config"
-  )
+  syncBackendDynamicConfigFromBuild(pagesConfig)
 
   console.log("  generated:", packages.segments.length, "segments,", packages.layouts.length, "layouts,", packages.workflows.length, "workflows")
   console.log("Done.")
@@ -274,6 +272,34 @@ function copyPublicAssets(packages, clientDir, outDir) {
   }
 }
 
+function syncBackendDynamicConfigFromBuild(pagesConfig) {
+  try {
+    const { syncBackendDynamicConfig } = require("../dynamic-config-schema/sync-backend-schema.cjs")
+    const result = syncBackendDynamicConfig({
+      clientDir,
+      pagesConfig,
+      compilerDir: join(__dirname, ".."),
+    })
+
+    if (result.synced) {
+      console.log(
+        `  dynamic-config: synced ${result.fieldCount} field(s) to backend/config/homepage-config.json`
+      )
+      for (const warning of result.warnings || []) {
+        console.warn(`  dynamic-config: ${warning}`)
+      }
+    } else if (result.warnings?.length) {
+      console.warn(`  dynamic-config: ${result.warnings.join("; ")}`)
+    } else {
+      console.log(
+        "  dynamic-config: no ../backend/ — storefront reads GET /store/dynamic-config at runtime"
+      )
+    }
+  } catch (error) {
+    console.warn(`  dynamic-config: backend sync skipped (${error.message})`)
+  }
+}
+
 function loadPagesConfig(clientDir) {
   const jsonPath = join(clientDir, "pages.config.json")
   if (existsSync(jsonPath)) {

package/dynamic-config-schema/segment-field-map.json

@@ -0,0 +1,53 @@
+{
+  "always": [
+    "logo",
+    "website-description",
+    "promo-bar",
+    "social-links",
+    "footer-shop-label",
+    "footer-company-label",
+    "footer-newsletter-label",
+    "footer-newsletter-description"
+  ],
+  "segments": {
+    "@pradip1995/segment-hero": ["homepage-banner-array", "app-banner-array"],
+    "@pradip1995/segment-promotional-banners": ["promotional-banner-array"],
+    "@pradip1995/segment-why-choose-us": ["why-choose-us-title", "why-choose-us-features"],
+    "@pradip1995/segment-features": ["trust-strip-features"],
+    "@pradip1995/segment-reviews-marquee": [
+      "rating-title",
+      "rating-eyebrow",
+      "rating-description",
+      "ratings"
+    ],
+    "@pradip1995/segment-new-arrivals": [
+      "new-arrivals-title",
+      "new-arrivals-view-all",
+      "new-arrivals-empty-message"
+    ],
+    "@pradip1995/segment-bestsellers-carousel": ["bestsellers-title", "bestsellers-view-all"],
+    "@pradip1995/segment-loved-by-moms": ["loved-by-moms-title", "loved-by-moms-view-all"],
+    "@pradip1995/segment-shop-by-category": ["shop-by-category-title", "shop-by-category-cta"],
+    "@pradip1995/segment-shop-by-age": ["shop-by-age-title"],
+    "@pradip1995/segment-collections-showcase": [
+      "collections-showcase-eyebrow",
+      "collections-showcase-title"
+    ],
+    "@pradip1995/segment-related-products": ["related-products-title"],
+    "@pradip1995/segment-help": ["faq-array", "contact-us"]
+  },
+  "workflows": {
+    "@pradip1995/workflow-store": ["store-page-title", "store-page-empty-message"],
+    "@pradip1995/workflow-cart": ["cart-summary-title", "cart-empty-message", "cart-empty-button"],
+    "@pradip1995/workflow-checkout": ["checkout-form-title", "checkout-summary-title"],
+    "@pradip1995/workflow-wishlist": [
+      "wishlist-sign-in-title",
+      "wishlist-sign-in-description",
+      "wishlist-sign-in-button",
+      "wishlist-empty-title",
+      "wishlist-empty-description",
+      "wishlist-empty-button"
+    ],
+    "@pradip1995/workflow-help": ["faq-array", "contact-us"]
+  }
+}

package/dynamic-config-schema/sync-backend-schema.cjs

@@ -0,0 +1,124 @@
+/**
+ * Filter homepage-config schema from pages.config segments/workflows
+ * and sync to ../backend/config/ (monorepo scaffold layout).
+ */
+const { existsSync, readFileSync, writeFileSync, mkdirSync } = require("fs")
+const { join, dirname } = require("path")
+
+function resolveSchemaBundleDir(compilerDir) {
+  const compilerBundle = join(compilerDir, "dynamic-config-schema")
+  if (existsSync(join(compilerBundle, "schemas", "homepage-config.json"))) {
+    return compilerBundle
+  }
+
+  const bundled = join(__dirname, "..")
+  if (existsSync(join(bundled, "schemas", "homepage-config.json"))) return bundled
+
+  let dir = compilerDir
+  for (let depth = 0; depth < 8; depth++) {
+    const candidate = join(dir, "packages", "framework-compiler", "dynamic-config-schema")
+    if (existsSync(join(candidate, "schemas", "homepage-config.json"))) return candidate
+    const candidate2 = join(dir, "packages", "dynamic-config-schema")
+    if (existsSync(join(candidate2, "schemas", "homepage-config.json"))) return candidate2
+    const parent = dirname(dir)
+    if (parent === dir) break
+    dir = parent
+  }
+  return null
+}
+
+function loadJson(path) {
+  return JSON.parse(readFileSync(path, "utf8"))
+}
+
+function collectRequiredStructureIds(pagesConfig, fieldMap) {
+  const required = new Set(fieldMap.always || [])
+
+  for (const page of pagesConfig) {
+    const workflowFields = fieldMap.workflows?.[page.workflow]
+    if (workflowFields) workflowFields.forEach((id) => required.add(id))
+
+    for (const segment of page.segments || []) {
+      const segmentFields = fieldMap.segments?.[segment]
+      if (segmentFields) {
+        segmentFields.forEach((id) => required.add(id))
+      }
+    }
+  }
+
+  return required
+}
+
+function filterHomepageSchema(fullSchema, requiredIds) {
+  const structure = (fullSchema.structure || []).filter((field) => requiredIds.has(field.id))
+  return { ...fullSchema, structure }
+}
+
+function buildHomepageDefaults(schema) {
+  const defaultsPath = join(__dirname, "build-defaults.cjs")
+  const { buildHomepageConfigDefaults } = require(defaultsPath)
+  return buildHomepageConfigDefaults(schema)
+}
+
+/**
+ * @param {{ clientDir: string, pagesConfig: object[], compilerDir?: string }} options
+ * @returns {{ synced: boolean, fieldCount?: number, warnings?: string[] }}
+ */
+function syncBackendDynamicConfig({ clientDir, pagesConfig, compilerDir }) {
+  const fromDir = compilerDir || join(__dirname, "..")
+  const schemaDir = resolveSchemaBundleDir(fromDir)
+  if (!schemaDir) {
+    return { synced: false, warnings: ["dynamic-config schema bundle not found"] }
+  }
+
+  const backendRoot = join(clientDir, "..", "backend")
+  const configOnlyLayout = existsSync(join(backendRoot, "plugins.config.json"))
+  const backendConfigDir = configOnlyLayout
+    ? join(backendRoot, ".generated-backend", "config")
+    : join(backendRoot, "config")
+  const backendConfigPath = join(backendConfigDir, "homepage-config.json")
+  if (!configOnlyLayout && !existsSync(dirname(backendConfigPath))) {
+    return { synced: false }
+  }
+
+  const clientOverride = join(clientDir, "dynamic-config.schema.json")
+  let fullSchema
+  if (existsSync(clientOverride)) {
+    const payload = loadJson(clientOverride)
+    fullSchema = payload.configs?.["homepage-config"] || payload["homepage-config"] || payload
+  } else {
+    fullSchema = loadJson(join(schemaDir, "schemas", "homepage-config.json"))
+  }
+
+  const fieldMap = loadJson(join(schemaDir, "segment-field-map.json"))
+  const requiredIds = collectRequiredStructureIds(pagesConfig, fieldMap)
+  const filtered = filterHomepageSchema(fullSchema, requiredIds)
+
+  const warnings = []
+  const knownSegments = new Set(Object.keys(fieldMap.segments || {}))
+  for (const page of pagesConfig) {
+    for (const segment of page.segments || []) {
+      if (!knownSegments.has(segment)) {
+        warnings.push(`no dynamic-config mapping for segment ${segment}`)
+      }
+    }
+  }
+
+  mkdirSync(backendConfigDir, { recursive: true })
+  writeFileSync(backendConfigPath, `${JSON.stringify(filtered, null, 2)}\n`)
+
+  const defaults = buildHomepageDefaults(filtered)
+  writeFileSync(
+    join(backendConfigDir, "homepage-config.defaults.json"),
+    `${JSON.stringify(defaults, null, 2)}\n`
+  )
+
+  return {
+    synced: true,
+    fieldCount: filtered.structure.length,
+    warnings,
+    backendConfigPath,
+  }
+}
+
+module.exports = { syncBackendDynamicConfig, collectRequiredStructureIds, filterHomepageSchema }

package/package.json

@@ -1,17 +1,19 @@
 {
   "name": "@pradip1995/framework-compiler",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "type": "module",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
   },
   "bin": {
-    "storefront-build": "./bin/storefront-build.js"
+    "storefront-build": "./bin/storefront-build.js",
+    "backend-build": "./bin/backend-build.js"
   },
   "files": [
     "bin",
     "templates",
+    "backend-templates",
     "dynamic-config-schema"
   ],
   "dependencies": {