@pradip1995/create-storefront-app 0.3.0 → 0.3.1

package/bin/create-storefront-app.js

@@ -195,7 +195,7 @@ function scaffoldProject(args) {
         "storefront:build": "npm run storefront:build --prefix storefront",
         "dev:backend": "npm run dev --prefix backend",
         "build:backend": "npm run build --prefix backend",
-        seed: "npm run seed --prefix backend",
+        seed: "npm run seed --prefix backend && node scripts/sync-publishable-key.mjs --from-db",
       },
     }
     writeJson(join(projectRoot, "package.json"), rootPkg)
@@ -208,6 +208,12 @@ function scaffoldProject(args) {
     scaffoldStorefront(join(projectRoot, "storefront"), args)
     scaffoldBackend(join(projectRoot, "backend"), args)
     scaffoldDocker(projectRoot, args)
+
+    mkdirSync(join(projectRoot, "scripts"), { recursive: true })
+    cpSync(
+      join(PKG_ROOT, "templates/root/scripts/sync-publishable-key.mjs"),
+      join(projectRoot, "scripts/sync-publishable-key.mjs")
+    )
   } else {
     scaffoldStorefront(projectRoot, args, { flat: true })
     writeFileSync(

package/lib/versions.js

@@ -1,7 +1,7 @@
 /** Published package semver ranges — bump when releasing framework/components. */
 export const COMMERCE_CORE_VERSION = "^4.0.2"
 export const FRAMEWORK_VERSION = "^0.2.1"
-export const FRAMEWORK_COMPILER_VERSION = "^0.2.4"
+export const FRAMEWORK_COMPILER_VERSION = "^0.2.6"
 export const COMPONENTS_VERSION = ">=0.2.0 <0.4.0"
 
 export const FRAMEWORK_PACKAGES = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pradip1995/create-storefront-app",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Scaffold a segment-based Medusa storefront using @pradip1995/framework packages",
   "license": "MIT",
   "type": "module",

package/templates/backend/.cursor/commands/seed-backend.md

@@ -1,16 +1,21 @@
 # Seed Medusa backend
 
-From project root:
+From project root (recommended — also syncs publishable key to storefront):
+
+```bash
+npm run seed
+```
+
+Backend only:
 
 ```bash
 cd backend
 npm run seed
+node ../scripts/sync-publishable-key.mjs --from-db
 ```
 
 Requires PostgreSQL running and `DATABASE_URL` set in `backend/.env`.
 
-After seed:
+## After seed
 
-1. Start backend: `npm run dev`
-2. Copy publishable API key from Admin into `storefront/.env.local`
-3. Start storefront: `cd ../storefront && npm run dev`
+`scripts/sync-publishable-key.mjs` reads the publishable key from Postgres and updates `storefront/.env.local`. Then start storefront: `npm run dev:storefront`.

package/templates/backend/.cursor/rules/medusa-backend.mdc

@@ -12,7 +12,7 @@ alwaysApply: false
 |------|---------|
 | `medusa-config.ts` | Plugins + modules wiring |
 | `config/medusa-plugin-versions.json` | npm version map for all plugins |
-| `config/homepage-config.json` | Dynamic-config schema (sync with storefront build) |
+| `config/homepage-config.json` | Dynamic-config schema — **synced from storefront build** when sections change |
 | `.env` | Database, CORS, secrets, integrations |
 | `src/scripts/seed.ts` | Region, sales channel, publishable API key, sample product |
 
@@ -31,8 +31,7 @@ From project root: `make up-infra` then local `npm run dev`, or `make up` for fu
 
 ## After seed
 
-1. Open Medusa Admin → Settings → Publishable API Keys
-2. Copy token into `storefront/.env.local` as `NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY`
+From project root, `npm run seed` or `make seed` syncs the publishable key into `storefront/.env.local` (via `scripts/sync-publishable-key.mjs`, reads from Postgres — no backend code changes).
 
 ## Plugin versions
 

package/templates/backend/config/README.md

@@ -2,20 +2,22 @@
 
 | File | Purpose |
 |------|---------|
-| `homepage-config.json` | **Schema** — field definitions for Medusa Admin (`medusa-plugin-dynamic-config`) |
-| `homepage-config.defaults.json` | **Default values** extracted from schema `defaultValue` fields (reference + bootstrap) |
+| `homepage-config.json` | **Schema** for Medusa Admin — **auto-synced** from storefront build |
+| `homepage-config.defaults.json` | Default values from schema `defaultValue` fields (auto-synced) |
 
 ## Workflow
 
-1. Edit `homepage-config.json` when adding/removing admin fields.
-2. Run `npm run dynamic-config:defaults` to refresh default values.
-3. Restart backend — schema is loaded from `medusa-config.ts`.
-4. Set live content in **Medusa Admin** (Dynamic Config).
+1. Edit **`storefront/pages.config.json`** (add/remove/reorder segments).
+2. Run **`npm run storefront:build`** in `storefront/` (or `npm run dev:storefront`).
+3. `storefront-build` writes filtered schema here based on segments + workflows in use.
+4. Restart Medusa backend so Admin picks up schema changes.
 
-The **storefront does not copy this schema**. It reads runtime values from:
+Optional manual refresh of defaults only:
 
+```bash
+cd backend && npm run dynamic-config:defaults
 ```
-GET /store/dynamic-config
-```
 
-Configure values in Admin after `npm run seed`.
+Runtime content is edited in **Medusa Admin** (Dynamic Config). The storefront loads values via `GET /store/dynamic-config`.
+
+Override entire schema: add `storefront/dynamic-config.schema.json` (see framework docs).

package/templates/backend/src/scripts/seed.ts

@@ -206,7 +206,5 @@ export default async function seedStore({ container }: ExecArgs) {
   logger.info("=== Seed complete ===")
   logger.info(`Region: ${SEED_REGION_NAME} (${SEED_COUNTRIES.join(", ")})`)
   logger.info(`Publishable API key id: ${publishableKey.id}`)
-  logger.info("Copy the publishable key token from Medusa Admin → Settings → Publishable API Keys")
-  logger.info("into storefront/.env.local as NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY")
   logger.info(`Sample product: ${products[0]?.handle}`)
 }

package/templates/docker/Makefile

@@ -72,8 +72,10 @@ health: ## Check backend and storefront HTTP health
 admin-create: ## Create admin user (ADMIN_EMAIL / ADMIN_PASSWORD)
 	$(COMPOSE) exec backend npx medusa user -e $(ADMIN_EMAIL) -p '$(ADMIN_PASSWORD)'
 
-seed: ## Run Medusa seed script (regions, publishable key, sample product)
+seed: ## Run Medusa seed, then sync publishable key to storefront env
 	$(COMPOSE) exec backend npx medusa exec ./src/scripts/seed.ts
+	@token=$$($(COMPOSE) exec -T postgres psql -U {{POSTGRES_USER}} -d {{POSTGRES_DB}} -tAc "SELECT token FROM api_key WHERE type = 'publishable' AND deleted_at IS NULL AND revoked_at IS NULL ORDER BY created_at DESC LIMIT 1" | tr -d '[:space:]'); \
+	node scripts/sync-publishable-key.mjs "$$token"
 
 db-shell: ## Open psql in postgres container
 	$(COMPOSE) exec postgres psql -U {{POSTGRES_USER}} -d {{POSTGRES_DB}}

package/templates/root/.cursor/commands/docker-dev.md

@@ -19,14 +19,9 @@ npm run dev:storefront   # terminal 2
 
 ## After seed
 
-Copy publishable API key into:
+`make seed` runs Medusa seed unchanged, then `scripts/sync-publishable-key.mjs` reads the token from Postgres and updates:
 
-- `storefront/.env.local` (local dev)
-- `docker/frontend.build.defaults` + rebuild storefront image (Docker)
-
-```bash
-make build-storefront
-make up-storefront
-```
+- `storefront/.env.local`
+- `docker/.env` and `docker/frontend.build.defaults` (when using Docker)
 
 Mailpit: http://localhost:8025

package/templates/root/.cursor/rules/monorepo-layout.mdc

@@ -33,7 +33,7 @@ See `Makefile` and command `docker-dev`.
 1. Set `DATABASE_URL` in `backend/.env`
 2. `npm run dev:backend` (migrations)
 3. `npm run seed` (region, API key, sample product)
-4. Copy publishable key → `storefront/.env.local`
+4. Run `npm run seed` from project root (syncs publishable key to `storefront/.env.local` via Postgres)
 
 ## Build
 

package/templates/root/scripts/sync-publishable-key.mjs

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+/**
+ * Sync NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY into storefront/.env.local and docker env files.
+ * Does not modify Medusa backend — reads the token from Postgres after seed.
+ *
+ * Usage:
+ *   node scripts/sync-publishable-key.mjs --from-db
+ *   node scripts/sync-publishable-key.mjs pk_abc123...
+ *   echo pk_abc... | node scripts/sync-publishable-key.mjs --stdin
+ */
+import { execSync } from "child_process"
+import { existsSync, readFileSync, writeFileSync } from "fs"
+import { dirname, join } from "path"
+import { fileURLToPath } from "url"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const projectRoot = join(__dirname, "..")
+const ENV_KEY = "NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY"
+
+const SQL = `SELECT token FROM api_key WHERE type = 'publishable' AND deleted_at IS NULL AND revoked_at IS NULL ORDER BY created_at DESC LIMIT 1`
+
+function upsertEnvLine(content, key, value) {
+  const line = `${key}=${value}`
+  const regex = new RegExp(`^${key}=.*$`, "m")
+  if (regex.test(content)) return content.replace(regex, line)
+  return `${content.replace(/\n?$/, "")}\n${line}\n`
+}
+
+function updateEnvFile(filePath, token) {
+  if (!existsSync(filePath)) return false
+  writeFileSync(filePath, upsertEnvLine(readFileSync(filePath, "utf8"), ENV_KEY, token))
+  return true
+}
+
+function parseEnvFile(path) {
+  if (!existsSync(path)) return {}
+  const vars = {}
+  for (const line of readFileSync(path, "utf8").split("\n")) {
+    const m = line.match(/^([A-Z0-9_]+)=(.*)$/)
+    if (m) vars[m[1]] = m[2]
+  }
+  return vars
+}
+
+function readDatabaseUrl() {
+  const backendEnv = join(projectRoot, "backend", ".env")
+  const vars = parseEnvFile(backendEnv)
+  return vars.DATABASE_URL || process.env.DATABASE_URL || null
+}
+
+function queryTokenViaPsql(databaseUrl) {
+  const out = execSync(`psql "${databaseUrl}" -tAc "${SQL}"`, {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  })
+  return out.trim()
+}
+
+function isValidToken(token) {
+  return typeof token === "string" && token.startsWith("pk_") && !token.includes("...")
+}
+
+function resolveToken() {
+  const args = process.argv.slice(2)
+
+  if (args.includes("--stdin")) {
+    const fromStdin = readFileSync(0, "utf8").trim()
+    if (isValidToken(fromStdin)) return fromStdin
+  }
+
+  const positional = args.filter((a) => !a.startsWith("--"))
+  if (positional[0] && isValidToken(positional[0])) return positional[0]
+
+  if (args.includes("--from-db") || args.length === 0) {
+    const databaseUrl = readDatabaseUrl()
+    if (!databaseUrl) {
+      throw new Error("DATABASE_URL not found in backend/.env")
+    }
+    const token = queryTokenViaPsql(databaseUrl)
+    if (isValidToken(token)) return token
+    throw new Error("No publishable API key in database — run seed first")
+  }
+
+  throw new Error("Pass pk_ token, --stdin, or --from-db")
+}
+
+try {
+  const token = resolveToken()
+  const targets = [
+    join(projectRoot, "storefront", ".env.local"),
+    join(projectRoot, "docker", ".env"),
+    join(projectRoot, "docker", "frontend.build.defaults"),
+  ]
+  const updated = targets.filter((p) => updateEnvFile(p, token))
+
+  if (updated.length === 0) {
+    console.error("sync-publishable-key: no env files updated (storefront/.env.local missing?)")
+    process.exit(1)
+  }
+
+  console.log("sync-publishable-key: set NEXT_PUBLIC_MEDUSA_PUBLISHABLE_KEY in:")
+  for (const p of updated) {
+    console.log(`  ${p.replace(`${projectRoot}/`, "")}`)
+  }
+} catch (error) {
+  console.error(`sync-publishable-key: ${error.message}`)
+  process.exit(1)
+}

package/templates/shared/.cursor/rules/customize-sections.mdc

@@ -20,7 +20,13 @@ Each entry in `segments` renders top-to-bottom:
 ]
 ```
 
-**Reorder** — change array order, then `npm run storefront:build`.
+**Reorder / add / remove sections** — edit `pages.config.json`, then:
+
+```bash
+npm run storefront:build
+```
+
+This regenerates the Next.js app **and** syncs `backend/config/homepage-config.json` (Admin fields for your active segments). Restart the backend after schema changes.
 
 **Remove** — delete the line and remove the package from `package.json` if unused elsewhere.
 

package/templates/shared/.cursor/rules/storefront-architecture.mdc

@@ -24,7 +24,7 @@ This folder (`storefront/`) is a **config client**, not a hand-written Next.js a
 |------|---------|
 | `.generated-app/` | Full Next.js app from `storefront-build` |
 
-Homepage content (hero, promo, logo, etc.) is **not** generated here — it comes from Medusa `GET /store/dynamic-config`. Schema lives in `../backend/config/homepage-config.json`.
+Homepage content (hero, promo, logo, etc.) comes from Medusa `GET /store/dynamic-config`. The **schema** in `../backend/config/homepage-config.json` is updated automatically when you run `npm run storefront:build` after changing `pages.config.json`.
 
 After any change to config, deps, or `theme-overrides.css`:
 

package/templates/shared/README.md

@@ -30,7 +30,7 @@ make admin-create
 | API        | {{BACKEND_URL}} |
 | Mailpit    | http://localhost:8025 |
 
-After `make seed`, update `docker/frontend.build.defaults` and `storefront/.env.local` with the publishable key, then `make build-storefront` if using Docker for the storefront.
+After `make seed` or `npm run seed`, the publishable key is read from Postgres and written to `storefront/.env.local` and `docker/` env files (no backend code changes).
 
 Default admin: `make admin-create` (see `Makefile` for `ADMIN_EMAIL` / `ADMIN_PASSWORD`).
 
@@ -94,7 +94,7 @@ make clean         # remove containers + volumes
 | Home sections | `storefront/pages.config.json` |
 | Colors / fonts | `storefront/theme-overrides.css` |
 | Medusa plugins | `backend/medusa-config.ts` + `backend/config/medusa-plugin-versions.json` |
-| Homepage admin fields | `backend/config/homepage-config.json` |
+| Homepage admin fields | `backend/config/homepage-config.json` (auto-synced on `storefront:build`) |
 | Docker secrets | `docker/.env` |
 
 Cursor guides: `.cursor/` in each folder.