@pradip1995/create-storefront-app 0.2.3 → 0.3.1

package/bin/create-storefront-app.js

@@ -4,6 +4,8 @@ import { join, dirname, resolve } from "path"
 import { fileURLToPath } from "url"
 import { execSync } from "child_process"
 import { buildDependencies } from "../lib/deps.js"
+import { scaffoldBackend } from "../lib/scaffold-backend.js"
+import { scaffoldDocker } from "../lib/scaffold-docker.js"
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const PKG_ROOT = join(__dirname, "..")
@@ -19,6 +21,7 @@ function parseArgs(argv) {
     port: 8000,
     install: true,
     noPrompt: false,
+    withBackend: true,
   }
   const positional = []
 
@@ -32,6 +35,7 @@ function parseArgs(argv) {
     else if (arg === "--default-region" && argv[i + 1]) args.defaultRegion = argv[++i]
     else if (arg === "--port" && argv[i + 1]) args.port = Number(argv[++i])
     else if (arg === "--no-install") args.install = false
+    else if (arg === "--no-backend") args.withBackend = false
     else if (arg === "--no-prompt" || arg === "-y") args.noPrompt = true
     else if (arg === "--help" || arg === "-h") args.help = true
     else if (!arg.startsWith("-")) positional.push(arg)
@@ -43,26 +47,34 @@ function parseArgs(argv) {
 
 function printHelp() {
   console.log(`
-create-storefront-app — Scaffold a segment-based Medusa storefront
+create-storefront-app — Scaffold Medusa backend + segment-based storefront
 
 Usage:
   npx @pradip1995/create-storefront-app <project-name> [options]
 
+Creates:
+  <project-name>/
+    backend/     Medusa v2 (medusa dev, medusa build, seed)
+    storefront/  Segment storefront (storefront-build + Next.js)
+    docker-compose.yml, Makefile, docker/   (when backend is included)
+
+Requires: Node 20+, npm. Docker optional (see README after scaffold).
+
 Options:
-  --preset <full|minimal>     Page/segment preset (default: full)
+  --preset <full|minimal>     Page/segment + plugin preset (default: full)
+  --no-backend                Storefront only (no backend/ folder)
   --dir <path>                Parent directory (default: cwd)
   --backend-url <url>         Medusa backend URL (default: http://localhost:9000)
-  --publishable-key <key>     Medusa publishable API key (default: pk_test)
+  --publishable-key <key>     Storefront publishable key placeholder (default: pk_test)
   --base-url <url>            Storefront URL (default: http://localhost:8000)
   --default-region <code>     Default country code (default: in)
-  --port <number>             Dev server port (default: 8000)
+  --port <number>             Storefront dev port (default: 8000)
   --no-install                Skip npm install after scaffold
-  --no-prompt, -y             Non-interactive (use flag defaults)
+  --no-prompt, -y             Non-interactive
 
 Examples:
   npx @pradip1995/create-storefront-app my-shop
-  npx @pradip1995/create-storefront-app my-shop --preset minimal \\
-    --publishable-key pk_xxx --backend-url http://localhost:9000
+  npx @pradip1995/create-storefront-app my-shop --preset minimal --no-install
 `)
 }
 
@@ -74,74 +86,54 @@ function applyTemplate(content, vars) {
   return content.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? "")
 }
 
-function scaffoldProject(args) {
-  const projectRoot = join(args.dir, args.name)
-  if (existsSync(projectRoot)) {
-    console.error(`Error: ${projectRoot} already exists`)
-    process.exit(1)
-  }
-
+function scaffoldStorefront(storefrontRoot, args, { flat = false } = {}) {
   const presetDir = join(PKG_ROOT, "templates", args.preset)
-  if (!existsSync(join(presetDir, "pages.config.json"))) {
-    console.error(`Unknown preset "${args.preset}". Use full or minimal.`)
-    process.exit(1)
-  }
 
-  mkdirSync(projectRoot, { recursive: true })
-  mkdirSync(join(projectRoot, "public"), { recursive: true })
+  mkdirSync(storefrontRoot, { recursive: true })
+  mkdirSync(join(storefrontRoot, "public"), { recursive: true })
 
-  const pagesConfig = JSON.parse(
-    readFileSync(join(presetDir, "pages.config.json"), "utf8")
-  )
-  writeJson(join(projectRoot, "pages.config.json"), pagesConfig)
+  const pagesConfig = JSON.parse(readFileSync(join(presetDir, "pages.config.json"), "utf8"))
+  writeJson(join(storefrontRoot, "pages.config.json"), pagesConfig)
 
   const storefrontConfig = JSON.parse(
     readFileSync(join(PKG_ROOT, "templates/shared/storefront.config.json"), "utf8")
   )
   storefrontConfig.defaultCountryCode = args.defaultRegion
-  writeJson(join(projectRoot, "storefront.config.json"), storefrontConfig)
+  writeJson(join(storefrontRoot, "storefront.config.json"), storefrontConfig)
 
-  cpSync(join(PKG_ROOT, "templates/shared/public"), join(projectRoot, "public"), {
+  cpSync(join(PKG_ROOT, "templates/shared/public"), join(storefrontRoot, "public"), {
     recursive: true,
   })
 
   const cursorTemplate = join(PKG_ROOT, "templates/shared/.cursor")
   if (existsSync(cursorTemplate)) {
-    cpSync(cursorTemplate, join(projectRoot, ".cursor"), { recursive: true })
+    cpSync(cursorTemplate, join(storefrontRoot, ".cursor"), { recursive: true })
   }
 
   const themeOverridesTemplate = join(PKG_ROOT, "templates/shared/theme-overrides.css")
   if (existsSync(themeOverridesTemplate)) {
-    writeFileSync(
-      join(projectRoot, "theme-overrides.css"),
-      readFileSync(themeOverridesTemplate, "utf8")
-    )
+    writeFileSync(join(storefrontRoot, "theme-overrides.css"), readFileSync(themeOverridesTemplate, "utf8"))
   }
 
   writeFileSync(
-    join(projectRoot, ".gitignore"),
+    join(storefrontRoot, ".gitignore"),
     readFileSync(join(PKG_ROOT, "templates/shared/gitignore"), "utf8")
   )
   writeFileSync(
-    join(projectRoot, ".npmrc"),
+    join(storefrontRoot, ".npmrc"),
     readFileSync(join(PKG_ROOT, "templates/shared/npmrc"), "utf8")
   )
 
-  const envTemplate = readFileSync(
-    join(PKG_ROOT, "templates/shared/env.example"),
-    "utf8"
-  )
-  writeFileSync(
-    join(projectRoot, ".env.local"),
-    applyTemplate(envTemplate, {
-      BACKEND_URL: args.backendUrl,
-      BASE_URL: args.baseUrl,
-      DEFAULT_REGION: args.defaultRegion,
-      PUBLISHABLE_KEY: args.publishableKey,
-    })
-  )
+  const envTemplate = readFileSync(join(PKG_ROOT, "templates/shared/env.example"), "utf8")
+  const envVars = {
+    BACKEND_URL: args.backendUrl,
+    BASE_URL: args.baseUrl,
+    DEFAULT_REGION: args.defaultRegion,
+    PUBLISHABLE_KEY: args.publishableKey,
+  }
+  writeFileSync(join(storefrontRoot, ".env.local"), applyTemplate(envTemplate, envVars))
   writeFileSync(
-    join(projectRoot, ".env.example"),
+    join(storefrontRoot, ".env.example"),
     applyTemplate(envTemplate, {
       BACKEND_URL: "http://localhost:9000",
       BASE_URL: "http://localhost:8000",
@@ -151,7 +143,7 @@ function scaffoldProject(args) {
   )
 
   const pkg = {
-    name: args.name,
+    name: flat ? args.name : `${args.name}-storefront`,
     private: true,
     scripts: {
       "storefront:build": "storefront-build",
@@ -161,7 +153,81 @@ function scaffoldProject(args) {
     },
     dependencies: buildDependencies(pagesConfig),
   }
-  writeJson(join(projectRoot, "package.json"), pkg)
+  writeJson(join(storefrontRoot, "package.json"), pkg)
+}
+
+function scaffoldProject(args) {
+  const projectRoot = join(args.dir, args.name)
+  if (existsSync(projectRoot)) {
+    console.error(`Error: ${projectRoot} already exists`)
+    process.exit(1)
+  }
+
+  const presetDir = join(PKG_ROOT, "templates", args.preset)
+  if (!existsSync(join(presetDir, "pages.config.json"))) {
+    console.error(`Unknown preset "${args.preset}". Use full or minimal.`)
+    process.exit(1)
+  }
+
+  mkdirSync(projectRoot, { recursive: true })
+
+  if (args.withBackend) {
+    writeFileSync(
+      join(projectRoot, ".gitignore"),
+      readFileSync(join(PKG_ROOT, "templates/shared/root-gitignore"), "utf8")
+    )
+    writeFileSync(
+      join(projectRoot, "README.md"),
+      applyTemplate(readFileSync(join(PKG_ROOT, "templates/shared/README.md"), "utf8"), {
+        PROJECT_NAME: args.name,
+        BASE_URL: args.baseUrl,
+        BACKEND_URL: args.backendUrl,
+        DEFAULT_REGION: args.defaultRegion,
+      })
+    )
+
+    const rootPkg = {
+      name: args.name,
+      private: true,
+      scripts: {
+        "dev:storefront": "npm run dev --prefix storefront",
+        "build:storefront": "npm run build --prefix storefront",
+        "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 && node scripts/sync-publishable-key.mjs --from-db",
+      },
+    }
+    writeJson(join(projectRoot, "package.json"), rootPkg)
+
+    const rootCursor = join(PKG_ROOT, "templates/root/.cursor")
+    if (existsSync(rootCursor)) {
+      cpSync(rootCursor, join(projectRoot, ".cursor"), { recursive: true })
+    }
+
+    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(
+      join(projectRoot, "README.md"),
+      applyTemplate(
+        readFileSync(join(PKG_ROOT, "templates/shared/storefront-only-README.md"), "utf8"),
+        {
+          PROJECT_NAME: args.name,
+          BASE_URL: args.baseUrl,
+          DEFAULT_REGION: args.defaultRegion,
+        }
+      )
+    )
+  }
 
   return projectRoot
 }
@@ -174,30 +240,52 @@ function main() {
   }
 
   console.log(
-    `Creating storefront "${args.name}" (preset: ${args.preset})...`
+    `Creating "${args.name}" (preset: ${args.preset}${args.withBackend ? ", with Medusa backend" : ""})...`
   )
 
   const projectRoot = scaffoldProject(args)
 
   if (args.install) {
     console.log("\nInstalling dependencies...")
-    try {
-      execSync("npm install", { cwd: projectRoot, stdio: "inherit" })
-    } catch {
-      console.warn("\nWarning: npm install failed. Run `npm install` manually in the project directory.")
+    const dirs = args.withBackend
+      ? [join(projectRoot, "backend"), join(projectRoot, "storefront")]
+      : [projectRoot]
+    for (const dir of dirs) {
+      try {
+        execSync("npm install", { cwd: dir, stdio: "inherit" })
+      } catch {
+        console.warn(`Warning: npm install failed in ${dir}`)
+      }
     }
   }
 
-  console.log(`
-Done! Created ${projectRoot}
+  const nextSteps = args.withBackend
+    ? `
+Next steps:
+  cd ${args.name}
+
+  Docker (full stack):
+    make up && make migrate && make seed && make admin-create
 
+  Local Node (Docker infra):
+    make up-infra
+    npm run dev:backend          # terminal 1
+    npm run seed && npm run dev:storefront   # terminal 2
+
+  Fully local:
+    cd backend && npm run dev    # set DATABASE_URL in backend/.env
+    cd backend && npm run seed
+    cd ../storefront && npm run dev
+
+See README.md, Makefile, and .cursor/ guides.
+`
+    : `
 Next steps:
   cd ${args.name}
   npm run dev
+`
 
-Edit pages.config.json, theme-overrides.css, or .cursor/ guides.
-See .cursor/commands/ for theme, sections, and troubleshooting workflows.
-`)
+  console.log(`Done! Created ${projectRoot}${nextSteps}`)
 }
 
 main()

package/lib/build-backend-package.js

@@ -0,0 +1,54 @@
+import { readFileSync } from "fs"
+import { dirname, join } from "path"
+import { fileURLToPath } from "url"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const VERSIONS = JSON.parse(
+  readFileSync(join(__dirname, "medusa-plugin-versions.json"), "utf8")
+)
+
+/** Build backend/package.json dependencies from medusa-plugin-versions.json */
+export function buildBackendDependencies(preset = "full") {
+  const pluginKeys =
+    preset === "minimal" ? VERSIONS.minimalPlugins : VERSIONS.fullPlugins
+  const plugins = {}
+  for (const key of pluginKeys) {
+    if (VERSIONS.plugins[key]) plugins[key] = VERSIONS.plugins[key]
+  }
+  return {
+    medusa: { ...VERSIONS.medusa },
+    plugins,
+  }
+}
+
+export function buildBackendPackageJson(preset = "full", projectName = "backend") {
+  const { medusa, plugins } = buildBackendDependencies(preset)
+  return {
+    name: `${projectName}-backend`,
+    version: "0.0.1",
+    private: true,
+    description: "Medusa backend for segment-based storefront",
+    license: "MIT",
+    scripts: {
+      dev: "medusa develop",
+      build:
+        "TS_NODE_COMPILER=typescript TS_NODE_TRANSPILE_ONLY=true MEDUSA_ADMIN_DISABLE_SW=true medusa build",
+      start: "medusa start",
+      seed: "medusa exec ./src/scripts/seed.ts",
+      "dynamic-config:defaults": "node scripts/build-dynamic-config-defaults.mjs",
+    },
+    dependencies: {
+      ...medusa,
+      ...plugins,
+    },
+    devDependencies: {
+      "@types/node": "^20.12.11",
+      typescript: "^5.6.2",
+    },
+    engines: {
+      node: ">=20",
+    },
+  }
+}
+
+export { VERSIONS }

package/lib/build-homepage-defaults.cjs

@@ -0,0 +1,50 @@
+/**
+ * Build initial homepage-config values from schema structure defaultValue fields.
+ * Used by backend scaffold and `npm run dynamic-config:defaults`.
+ */
+
+function buildDefaultsFromStructure(fields) {
+  const result = {}
+  for (const field of fields) {
+    const value = buildDefaultForField(field)
+    if (value !== undefined) {
+      result[field.id] = value
+    }
+  }
+  return result
+}
+
+function buildDefaultForField(field) {
+  if (field.defaultValue !== undefined) {
+    return field.defaultValue
+  }
+
+  if (field.type === "object" && field.children?.length) {
+    const nested = buildDefaultsFromStructure(field.children)
+    return Object.keys(nested).length > 0 ? nested : undefined
+  }
+
+  if (field.type === "array" && field.children?.length) {
+    const [itemSchema] = field.children
+    if (itemSchema?.type === "object" && itemSchema.children?.length) {
+      const itemDefaults = buildDefaultsFromStructure(itemSchema.children)
+      if (Object.keys(itemDefaults).length > 0) {
+        return [{ [itemSchema.id]: itemDefaults }]
+      }
+    }
+    return undefined
+  }
+
+  return undefined
+}
+
+function buildHomepageConfigDefaults(configSchema) {
+  if (!configSchema?.structure?.length) return {}
+  return buildDefaultsFromStructure(configSchema.structure)
+}
+
+module.exports = {
+  buildDefaultsFromStructure,
+  buildDefaultForField,
+  buildHomepageConfigDefaults,
+}

package/lib/deps.js

@@ -1,6 +1,7 @@
 import {
   COMMERCE_CORE_VERSION,
   FRAMEWORK_VERSION,
+  FRAMEWORK_COMPILER_VERSION,
   COMPONENTS_VERSION,
   FRAMEWORK_PACKAGES,
   RUNTIME_DEPS,
@@ -68,7 +69,8 @@ export function buildDependencies(pages) {
   }
 
   for (const name of FRAMEWORK_PACKAGES) {
-    deps[name] = FRAMEWORK_VERSION
+    deps[name] =
+      name === "@pradip1995/framework-compiler" ? FRAMEWORK_COMPILER_VERSION : FRAMEWORK_VERSION
   }
 
   for (const name of [

package/lib/docker-template-vars.js

@@ -0,0 +1,32 @@
+/** Derive Docker / Postgres identifiers from project name */
+export function sanitizeProjectSlug(name) {
+  const slug = String(name)
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "")
+    .slice(0, 24)
+  return slug || "shop"
+}
+
+/** Shared template vars for backend env, docker-compose, Makefile */
+export function buildDockerTemplateVars(args) {
+  const slug = sanitizeProjectSlug(args.name)
+  const postgresUser = slug
+  const postgresPassword = `${slug}_secret`
+  const postgresDb = `${slug}_medusa`
+
+  return {
+    PROJECT_NAME: args.name,
+    CONTAINER_PREFIX: slug,
+    POSTGRES_USER: postgresUser,
+    POSTGRES_PASSWORD: postgresPassword,
+    POSTGRES_DB: postgresDb,
+    BACKEND_URL: args.backendUrl,
+    BASE_URL: args.baseUrl,
+    DEFAULT_REGION: args.defaultRegion,
+    DATABASE_URL: `postgres://${postgresUser}:${postgresPassword}@localhost:5432/${postgresDb}?sslmode=disable`,
+    DATABASE_URL_DOCKER: `postgres://${postgresUser}:${postgresPassword}@postgres:5432/${postgresDb}?sslmode=disable`,
+    PUBLISHABLE_KEY: args.publishableKey || "pk_test",
+    ADMIN_EMAIL: `admin@${slug}.local`,
+    ADMIN_PASSWORD: `${slug.charAt(0).toUpperCase()}${slug.slice(1)}@123`,
+  }
+}

package/lib/medusa-plugin-versions.json

@@ -0,0 +1,55 @@
+{
+  "medusa": {
+    "@medusajs/admin-sdk": "2.12.3",
+    "@medusajs/auth-google": "2.12.3",
+    "@medusajs/cli": "2.12.3",
+    "@medusajs/framework": "2.12.3",
+    "@medusajs/medusa": "2.12.3",
+    "@medusajs/test-utils": "2.12.3"
+  },
+  "plugins": {
+    "medusa-product-helper": "0.0.73",
+    "medusa-dynamic-metadata": "0.0.7",
+    "medusa-plugin-dynamic-config": "^0.0.25",
+    "medusa-review-rating": "^0.0.38",
+    "medusa-contact-us": "^0.0.26",
+    "customer-registration": "^0.0.124",
+    "stock-monitoring": "^0.0.5",
+    "medusa-invoice-sbl": "^0.0.11",
+    "order-management": "^0.0.78",
+    "medusa-shiprocket-fulfillment-sbl": "0.0.28",
+    "medusa-notification-token-management": "^0.0.1",
+    "medusa-customer-file-upload": "0.0.1",
+    "medusa-analytics": "0.0.24",
+    "medusa-export": "^0.0.5",
+    "medusa-payment-provider": "0.0.1",
+    "@tsc_tech/medusa-plugin-smtp": "^0.0.3",
+    "medusa-twilio-sms": "^2.0.2",
+    "medusa-notification-provider": "^0.0.2"
+  },
+  "minimalPlugins": [
+    "medusa-product-helper",
+    "medusa-dynamic-metadata",
+    "medusa-plugin-dynamic-config",
+    "medusa-review-rating",
+    "medusa-contact-us",
+    "customer-registration"
+  ],
+  "fullPlugins": [
+    "medusa-product-helper",
+    "stock-monitoring",
+    "medusa-invoice-sbl",
+    "medusa-dynamic-metadata",
+    "medusa-review-rating",
+    "medusa-plugin-dynamic-config",
+    "medusa-contact-us",
+    "order-management",
+    "customer-registration",
+    "medusa-shiprocket-fulfillment-sbl",
+    "medusa-notification-token-management",
+    "medusa-customer-file-upload",
+    "medusa-analytics",
+    "medusa-export",
+    "medusa-payment-provider"
+  ]
+}

package/lib/scaffold-backend.js

@@ -0,0 +1,107 @@
+import { cpSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs"
+import { join, dirname } from "path"
+import { fileURLToPath } from "url"
+import { buildBackendPackageJson, VERSIONS } from "./build-backend-package.js"
+import { buildDockerTemplateVars } from "./docker-template-vars.js"
+import { createRequire } from "module"
+
+const require = createRequire(import.meta.url)
+const { buildHomepageConfigDefaults } = require("./build-homepage-defaults.cjs")
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const PKG_ROOT = join(__dirname, "..")
+const BACKEND_TEMPLATE = join(PKG_ROOT, "templates", "backend")
+
+const REGION_CURRENCY = {
+  in: { currency: "inr", name: "India" },
+  us: { currency: "usd", name: "United States" },
+  gb: { currency: "gbp", name: "United Kingdom" },
+  eu: { currency: "eur", name: "Europe" },
+}
+
+function applyTemplate(content, vars) {
+  return content.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? "")
+}
+
+function regionMeta(defaultRegion) {
+  return (
+    REGION_CURRENCY[defaultRegion] || {
+      currency: defaultRegion.length === 2 ? defaultRegion : "usd",
+      name: defaultRegion.toUpperCase(),
+    }
+  )
+}
+
+export function scaffoldBackend(backendRoot, args) {
+  const { preset, name, backendUrl, baseUrl, defaultRegion } = args
+  const meta = regionMeta(defaultRegion)
+  const dockerVars = buildDockerTemplateVars(args)
+  const templateVars = {
+    PROJECT_NAME: name,
+    BACKEND_URL: backendUrl,
+    BASE_URL: baseUrl,
+    DEFAULT_REGION: defaultRegion,
+    DEFAULT_CURRENCY: meta.currency,
+    DEFAULT_REGION_NAME: meta.name,
+    POSTGRES_USER: dockerVars.POSTGRES_USER,
+    POSTGRES_PASSWORD: dockerVars.POSTGRES_PASSWORD,
+    POSTGRES_DB: dockerVars.POSTGRES_DB,
+    DATABASE_URL: dockerVars.DATABASE_URL,
+  }
+
+  mkdirSync(backendRoot, { recursive: true })
+
+  const medusaConfigSrc =
+    preset === "minimal"
+      ? join(BACKEND_TEMPLATE, "medusa-config.minimal.ts")
+      : join(BACKEND_TEMPLATE, "medusa-config.full.ts")
+  writeFileSync(join(backendRoot, "medusa-config.ts"), readFileSync(medusaConfigSrc, "utf8"))
+
+  cpSync(join(BACKEND_TEMPLATE, "tsconfig.json"), join(backendRoot, "tsconfig.json"))
+  cpSync(join(BACKEND_TEMPLATE, "gitignore"), join(backendRoot, ".gitignore"))
+  cpSync(join(PKG_ROOT, "templates/shared/npmrc"), join(backendRoot, ".npmrc"))
+  cpSync(join(BACKEND_TEMPLATE, "config"), join(backendRoot, "config"), { recursive: true })
+  cpSync(join(BACKEND_TEMPLATE, "src"), join(backendRoot, "src"), { recursive: true })
+  cpSync(join(BACKEND_TEMPLATE, "scripts"), join(backendRoot, "scripts"), { recursive: true })
+
+  const homepageSchema = JSON.parse(
+    readFileSync(join(backendRoot, "config/homepage-config.json"), "utf8")
+  )
+  writeFileSync(
+    join(backendRoot, "config/homepage-config.defaults.json"),
+    `${JSON.stringify(buildHomepageConfigDefaults(homepageSchema), null, 2)}\n`
+  )
+
+  writeFileSync(
+    join(backendRoot, "config", "medusa-plugin-versions.json"),
+    JSON.stringify(VERSIONS, null, 2) + "\n"
+  )
+
+  const seedContent = applyTemplate(
+    readFileSync(join(BACKEND_TEMPLATE, "src/scripts/seed.ts"), "utf8"),
+    templateVars
+  )
+  mkdirSync(join(backendRoot, "src/scripts"), { recursive: true })
+  writeFileSync(join(backendRoot, "src/scripts/seed.ts"), seedContent)
+
+  writeFileSync(
+    join(backendRoot, ".env.template"),
+    applyTemplate(readFileSync(join(BACKEND_TEMPLATE, "env.template"), "utf8"), templateVars)
+  )
+  writeFileSync(
+    join(backendRoot, ".env"),
+    applyTemplate(readFileSync(join(BACKEND_TEMPLATE, "env.template"), "utf8"), templateVars)
+  )
+
+  writeFileSync(
+    join(backendRoot, "package.json"),
+    JSON.stringify(buildBackendPackageJson(preset, name), null, 2) + "\n"
+  )
+
+  const backendCursor = join(BACKEND_TEMPLATE, ".cursor")
+  if (existsSync(backendCursor)) {
+    cpSync(backendCursor, join(backendRoot, ".cursor"), { recursive: true })
+  }
+
+  return backendRoot
+}