create-ecomiq 0.1.0

package/README.md

@@ -0,0 +1,50 @@
+# create-ecomiq
+
+Scaffold interactivo de storefronts Ecomiq (estilo `create-vite` / `create-next-app`).
+
+```bash
+npm create ecomiq@latest
+# o
+npx create-ecomiq@latest my-store
+```
+
+## Flujo
+
+1. Nombre del proyecto
+2. **Domain** — se valida con `GET /v1/settings` + `x-Store-Domain`
+3. **Template** — catálogo en R2 (`templates.json`); hoy solo `default`
+4. Package manager + install
+
+## Flags
+
+```bash
+create-ecomiq my-store \
+  --domain marketplace \
+  --template default \
+  --pm pnpm \
+  --yes
+```
+
+| Flag | Descripción |
+| --- | --- |
+| `--domain` | Domain de la tienda (obligatorio con `--yes`) |
+| `--template` | Id del template (`default`) |
+| `--pm` | `npm` \| `pnpm` \| `yarn` \| `bun` |
+| `--yes` / `-y` | Sin prompts |
+| `--skip-install` | Solo archivos |
+
+## Templates
+
+Los zips viven en R2:
+
+- `https://pub-2b5396b516d940dbb1088d750701749c.r2.dev/templates.json`
+- `https://pub-2b5396b516d940dbb1088d750701749c.r2.dev/template-{id}.zip`
+
+Tras el scaffold usa la CLI del framework:
+
+```bash
+cd my-store
+npm run dev      # ecomiq dev
+npm run build
+npm run deploy
+```

package/bin/create-ecomiq.mjs

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { runCreate } from '../src/index.mjs'
+
+try {
+  await runCreate(process.argv.slice(2))
+} catch (error) {
+  const message = error instanceof Error ? error.message : 'Error desconocido'
+  console.error(`\n  ✖ ${message}\n`)
+  process.exitCode = 1
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "create-ecomiq",
+  "version": "0.1.0",
+  "description": "Scaffold interactivo de storefronts Ecomiq (estilo create-vite)",
+  "type": "module",
+  "license": "MIT",
+  "author": "Ecomiq",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ecomiq/ecomiq-storefront.git",
+    "directory": "packages/create-ecomiq"
+  },
+  "homepage": "https://github.com/ecomiq/ecomiq-storefront/tree/main/packages/create-ecomiq",
+  "bugs": {
+    "url": "https://github.com/ecomiq/ecomiq-storefront/issues"
+  },
+  "keywords": [
+    "ecomiq",
+    "create-ecomiq",
+    "scaffold",
+    "storefront",
+    "ecommerce"
+  ],
+  "bin": {
+    "create-ecomiq": "./bin/create-ecomiq.mjs"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.11.0",
+    "adm-zip": "^0.6.0"
+  },
+  "devDependencies": {
+    "@types/adm-zip": "^0.5.8"
+  },
+  "scripts": {}
+}

package/src/index.mjs

@@ -0,0 +1,268 @@
+/**
+ * CLI create-ecomiq — scaffold interactivo de storefronts.
+ *
+ *   npx create-ecomiq@latest [dir]
+ *   npm create ecomiq@latest
+ */
+import * as p from '@clack/prompts'
+import { basename, resolve } from 'node:path'
+import { verifyDomain } from './verify-domain.mjs'
+import { downloadTemplateZip, listTemplates } from './templates.mjs'
+import {
+  detectPackageManager,
+  extractTemplateZip,
+  installDependencies,
+  resolveTargetDirectory,
+  slugifyDeployName,
+  writeProjectConfig,
+} from './scaffold.mjs'
+
+/**
+ * @param {string[]} argv
+ */
+export function parseArgs(argv) {
+  /** @type {{
+   *   dir?: string
+   *   domain?: string
+   *   template?: string
+   *   pm?: 'npm' | 'pnpm' | 'yarn' | 'bun'
+   *   yes: boolean
+   *   skipInstall: boolean
+   *   help: boolean
+   * }} */
+  const out = {
+    yes: false,
+    skipInstall: false,
+    help: false,
+  }
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i]
+    if (arg === '--help' || arg === '-h') {
+      out.help = true
+      continue
+    }
+    if (arg === '--yes' || arg === '-y') {
+      out.yes = true
+      continue
+    }
+    if (arg === '--skip-install') {
+      out.skipInstall = true
+      continue
+    }
+    if (arg === '--domain') {
+      out.domain = argv[++i]
+      continue
+    }
+    if (arg === '--template') {
+      out.template = argv[++i]
+      continue
+    }
+    if (arg === '--pm') {
+      const value = argv[++i]
+      if (value === 'npm' || value === 'pnpm' || value === 'yarn' || value === 'bun') {
+        out.pm = value
+      } else {
+        throw new Error(`Package manager no soportado: ${value}`)
+      }
+      continue
+    }
+    if (arg.startsWith('-')) {
+      throw new Error(`Flag desconocida: ${arg}`)
+    }
+    if (!out.dir) out.dir = arg
+  }
+
+  return out
+}
+
+function printHelp() {
+  console.log(`
+  Uso
+    create-ecomiq [dir] [opciones]
+
+  Opciones
+    --domain <slug>       Domain de la tienda (x-Store-Domain)
+    --template <id>       Template (default: default)
+    --pm <npm|pnpm|yarn|bun>
+    --yes, -y             Sin prompts (requiere --domain)
+    --skip-install        No ejecutar install
+    --help, -h
+
+  Ejemplos
+    npx create-ecomiq@latest my-store
+    npm create ecomiq@latest
+    create-ecomiq . --domain marketplace --template default --yes
+`)
+}
+
+/**
+ * @param {string[]} argv
+ */
+export async function runCreate(argv) {
+  const args = parseArgs(argv)
+  if (args.help) {
+    printHelp()
+    return
+  }
+
+  p.intro('◈ create-ecomiq')
+
+  if (args.yes && !args.domain) {
+    throw new Error('Con --yes debes pasar --domain')
+  }
+
+  let projectName = args.dir
+  if (!projectName && !args.yes) {
+    const answer = await p.text({
+      message: '¿Nombre del proyecto?',
+      placeholder: 'my-store',
+      defaultValue: 'my-store',
+      validate: (value) => {
+        if (!value.trim()) return 'El nombre es obligatorio'
+      },
+    })
+    if (p.isCancel(answer)) {
+      p.cancel('Cancelado')
+      process.exitCode = 1
+      return
+    }
+    projectName = answer.trim()
+  }
+  projectName = (projectName ?? 'my-store').trim() || 'my-store'
+
+  const targetDir = resolveTargetDirectory(
+    projectName === '.' ? process.cwd() : resolve(process.cwd(), projectName),
+  )
+  const folderName = basename(targetDir)
+
+  let domain = args.domain?.trim()
+  let storeName = domain ?? ''
+
+  if (!args.yes) {
+    while (true) {
+      const answer = await p.text({
+        message: 'Domain de la tienda (x-Store-Domain)',
+        placeholder: 'marketplace',
+        initialValue: domain ?? '',
+        validate: (value) => {
+          if (!value.trim()) return 'El domain es obligatorio'
+        },
+      })
+      if (p.isCancel(answer)) {
+        p.cancel('Cancelado')
+        process.exitCode = 1
+        return
+      }
+
+      const spinner = p.spinner()
+      spinner.start('Verificando domain en la API…')
+      const result = await verifyDomain(answer.trim())
+      if (!result.ok) {
+        spinner.stop(result.message)
+        p.log.error(result.message)
+        domain = answer.trim()
+        continue
+      }
+      spinner.stop(`Tienda: ${result.storeName}`)
+      domain = result.domain
+      storeName = result.storeName
+      break
+    }
+  } else {
+    const spinner = p.spinner()
+    spinner.start('Verificando domain en la API…')
+    const result = await verifyDomain(domain)
+    if (!result.ok) {
+      spinner.stop(result.message)
+      throw new Error(result.message)
+    }
+    spinner.stop(`Tienda: ${result.storeName}`)
+    domain = result.domain
+    storeName = result.storeName
+  }
+
+  const templates = await listTemplates()
+  let templateId = args.template?.trim() || 'default'
+
+  if (!args.yes) {
+    const options = templates.map((tpl) => ({
+      value: tpl.id,
+      label: tpl.name,
+      hint: tpl.description,
+    }))
+    const selected = await p.select({
+      message: 'Elige un template',
+      options: options.length ? options : [{ value: 'default', label: 'Default' }],
+      initialValue: templateId,
+    })
+    if (p.isCancel(selected)) {
+      p.cancel('Cancelado')
+      process.exitCode = 1
+      return
+    }
+    templateId = selected
+  } else if (!templates.some((tpl) => tpl.id === templateId) && templateId !== 'default') {
+    throw new Error(`Template desconocido: ${templateId}`)
+  }
+
+  let pm = args.pm ?? detectPackageManager()
+  if (!args.yes && !args.pm) {
+    const selected = await p.select({
+      message: 'Package manager',
+      options: [
+        { value: 'npm', label: 'npm' },
+        { value: 'pnpm', label: 'pnpm' },
+        { value: 'yarn', label: 'yarn' },
+        { value: 'bun', label: 'bun' },
+      ],
+      initialValue: pm,
+    })
+    if (p.isCancel(selected)) {
+      p.cancel('Cancelado')
+      process.exitCode = 1
+      return
+    }
+    pm = selected
+  }
+
+  const deployName = slugifyDeployName(folderName)
+  const downloadSpinner = p.spinner()
+  downloadSpinner.start(`Descargando template "${templateId}"…`)
+  const zipBytes = await downloadTemplateZip(templateId)
+  downloadSpinner.stop('Template descargado')
+
+  const extractSpinner = p.spinner()
+  extractSpinner.start('Extrayendo archivos…')
+  extractTemplateZip(zipBytes, targetDir, templateId)
+  writeProjectConfig(targetDir, { domain, deployName })
+  extractSpinner.stop('Proyecto listo')
+
+  if (!args.skipInstall) {
+    const installSpinner = p.spinner()
+    installSpinner.start(`Instalando con ${pm}…`)
+    try {
+      await installDependencies(targetDir, pm)
+      installSpinner.stop('Dependencias instaladas')
+    } catch (error) {
+      installSpinner.stop('Install falló')
+      throw error
+    }
+  }
+
+  const rel =
+    targetDir === process.cwd() ? '.' : projectName === '.' ? '.' : projectName
+
+  p.outro(
+    [
+      `Storefront para ${storeName} (${domain})`,
+      '',
+      `  cd ${rel}`,
+      args.skipInstall ? `  ${pm} install` : null,
+      `  ${pm === 'npm' ? 'npm run' : pm} dev`,
+      '',
+    ]
+      .filter(Boolean)
+      .join('\n'),
+  )
+}

package/src/scaffold.mjs

@@ -0,0 +1,194 @@
+import { spawn } from 'node:child_process'
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs'
+import { tmpdir } from 'node:os'
+import { dirname, join, resolve } from 'node:path'
+import AdmZip from 'adm-zip'
+
+/**
+ * @param {string} name
+ */
+export function slugifyDeployName(name) {
+  const slug = name
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+  return slug || 'my-storefront'
+}
+
+/**
+ * @param {{ domain: string, deployName: string }} options
+ */
+export function buildEcomiqConfig({ domain, deployName }) {
+  return `import { defineConfig } from '@ecomiq/storefront/config'
+
+export default defineConfig({
+  // Identidad para x-Store-Domain: slug corto o dominio completo
+  // (marketplace | marketplace.ecomiq.app | marketplace.pe)
+  domain: ${JSON.stringify(domain)},
+
+  theme: {
+    primary: 'oklch(0.45 0.15 165)',
+    radius: '0.75rem',
+  },
+
+  // Portable: Node por defecto. Opt-in a workerd con runtime: 'workerd'.
+  dev: { port: 3000 },
+
+  deploy: {
+    target: 'cloudflare',
+    name: ${JSON.stringify(deployName)},
+    // routes: [{ pattern: 'tienda.example.com', custom_domain: true }],
+  },
+})
+`
+}
+
+/**
+ * @param {string} configSource
+ * @param {{ domain: string, deployName: string }} patch
+ */
+export function patchEcomiqConfigSource(configSource, patch) {
+  let next = configSource
+  if (/domain:\s*['"][^'"]*['"]/.test(next)) {
+    next = next.replace(/domain:\s*['"][^'"]*['"]/, `domain: ${JSON.stringify(patch.domain)}`)
+  }
+  if (/name:\s*['"][^'"]*['"]/.test(next)) {
+    // Solo el name dentro de deploy (primera aparición tras deploy suele bastar;
+    // fallback: reescribir archivo completo si el patrón es ambiguo).
+    next = next.replace(
+      /(deploy:\s*\{[\s\S]*?name:\s*)['"][^'"]*['"]/,
+      `$1${JSON.stringify(patch.deployName)}`,
+    )
+  }
+  return next
+}
+
+/**
+ * Extrae un zip a destino (JS puro vía adm-zip; Windows/macOS/Linux sin CLI).
+ * Espera raíz `template-{id}/` o archivos sueltos.
+ * @param {Uint8Array | Buffer} zipBytes
+ * @param {string} destDir
+ * @param {string} templateId
+ */
+export function extractTemplateZip(zipBytes, destDir, templateId) {
+  mkdirSync(destDir, { recursive: true })
+  const staging = mkdtempSync(join(tmpdir(), 'create-ecomiq-'))
+
+  try {
+    const zip = new AdmZip(Buffer.from(zipBytes))
+    zip.extractAllTo(staging, /* overwrite */ true)
+
+    const nested = join(staging, `template-${templateId}`)
+    const source = existsSync(nested) ? nested : findExtractedRoot(staging)
+    if (!source) {
+      throw new Error(`No se encontró el contenido del template "${templateId}" en el zip`)
+    }
+
+    copyTree(source, destDir)
+  } finally {
+    rmSync(staging, { recursive: true, force: true })
+  }
+}
+
+function findExtractedRoot(staging) {
+  const entries = readdirSync(staging, { withFileTypes: true })
+  const dirs = entries.filter((entry) => entry.isDirectory())
+  if (dirs.length === 1) return join(staging, dirs[0].name)
+  if (entries.some((entry) => entry.name === 'ecomiq.config.js' || entry.name === 'package.json')) {
+    return staging
+  }
+  return null
+}
+
+function copyTree(from, to) {
+  mkdirSync(to, { recursive: true })
+  for (const entry of readdirSync(from, { withFileTypes: true })) {
+    const src = join(from, entry.name)
+    const dest = join(to, entry.name)
+    if (entry.isDirectory()) {
+      copyTree(src, dest)
+    } else {
+      mkdirSync(dirname(dest), { recursive: true })
+      // rename across devices can fail; read/write is safer for tmp → project
+      writeFileSync(dest, readFileSync(src))
+    }
+  }
+}
+
+/**
+ * @param {string} destDir
+ * @param {{ domain: string, deployName: string }} options
+ */
+export function writeProjectConfig(destDir, { domain, deployName }) {
+  const configPath = join(destDir, 'ecomiq.config.js')
+  if (existsSync(configPath)) {
+    const current = readFileSync(configPath, 'utf8')
+    writeFileSync(configPath, patchEcomiqConfigSource(current, { domain, deployName }))
+    return
+  }
+  writeFileSync(configPath, buildEcomiqConfig({ domain, deployName }))
+}
+
+/**
+ * @param {string} destDir
+ * @param {'npm' | 'pnpm' | 'yarn' | 'bun'} pm
+ */
+export function installDependencies(destDir, pm) {
+  const args =
+    pm === 'yarn' ? ['install'] : pm === 'pnpm' ? ['install'] : pm === 'bun' ? ['install'] : ['install']
+
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn(pm, args, {
+      cwd: destDir,
+      stdio: 'inherit',
+      shell: process.platform === 'win32',
+      env: { ...process.env, CI: process.env.CI ?? 'true' },
+    })
+    child.on('exit', (code) => {
+      if (code === 0) resolvePromise()
+      else reject(new Error(`${pm} install salió con código ${code}`))
+    })
+    child.on('error', reject)
+  })
+}
+
+/**
+ * Detecta package manager desde user-agent de npm_config o locks.
+ * @param {string} [cwd]
+ * @returns {'npm' | 'pnpm' | 'yarn' | 'bun'}
+ */
+export function detectPackageManager(cwd = process.cwd()) {
+  const ua = process.env.npm_config_user_agent ?? ''
+  if (ua.includes('pnpm')) return 'pnpm'
+  if (ua.includes('yarn')) return 'yarn'
+  if (ua.includes('bun')) return 'bun'
+  if (existsSync(join(cwd, 'pnpm-lock.yaml'))) return 'pnpm'
+  if (existsSync(join(cwd, 'yarn.lock'))) return 'yarn'
+  if (existsSync(join(cwd, 'bun.lockb')) || existsSync(join(cwd, 'bun.lock'))) return 'bun'
+  return 'npm'
+}
+
+/**
+ * @param {string} targetPath
+ */
+export function resolveTargetDirectory(targetPath) {
+  const resolved = resolve(targetPath)
+  if (existsSync(resolved)) {
+    const entries = readdirSync(resolved)
+    if (entries.length > 0) {
+      throw new Error(`El directorio ya existe y no está vacío: ${resolved}`)
+    }
+  } else {
+    mkdirSync(resolved, { recursive: true })
+  }
+  return resolved
+}

package/src/templates.mjs

@@ -0,0 +1,84 @@
+/**
+ * Catálogo y descarga de templates desde R2 público.
+ */
+export const DEFAULT_TEMPLATES_BASE_URL =
+  'https://pub-2b5396b516d940dbb1088d750701749c.r2.dev'
+
+export const FALLBACK_TEMPLATES = [
+  {
+    id: 'default',
+    name: 'Default',
+    description: 'Storefront base: catálogo, carrito, checkout y cuenta',
+  },
+]
+
+/**
+ * @param {{ baseUrl?: string, fetchImpl?: typeof fetch }} [options]
+ * @returns {Promise<Array<{ id: string, name: string, description?: string }>>}
+ */
+export async function listTemplates(options = {}) {
+  const baseUrl = (options.baseUrl ?? DEFAULT_TEMPLATES_BASE_URL).replace(/\/$/, '')
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch
+
+  if (typeof fetchImpl !== 'function') return [...FALLBACK_TEMPLATES]
+
+  try {
+    const response = await fetchImpl(`${baseUrl}/templates.json`, {
+      headers: { Accept: 'application/json' },
+    })
+    if (!response.ok) return [...FALLBACK_TEMPLATES]
+    const json = await response.json()
+    const items = Array.isArray(json)
+      ? json
+      : Array.isArray(json?.templates)
+        ? json.templates
+        : null
+    if (!items?.length) return [...FALLBACK_TEMPLATES]
+
+    return items
+      .filter((item) => item && typeof item.id === 'string' && item.id.trim())
+      .map((item) => ({
+        id: item.id.trim(),
+        name: typeof item.name === 'string' && item.name.trim() ? item.name.trim() : item.id,
+        description:
+          typeof item.description === 'string' ? item.description : undefined,
+      }))
+  } catch {
+    return [...FALLBACK_TEMPLATES]
+  }
+}
+
+/**
+ * @param {string} templateId
+ * @param {{ baseUrl?: string }} [options]
+ */
+export function templateZipUrl(templateId, options = {}) {
+  const baseUrl = (options.baseUrl ?? DEFAULT_TEMPLATES_BASE_URL).replace(/\/$/, '')
+  return `${baseUrl}/template-${templateId}.zip`
+}
+
+/**
+ * @param {string} templateId
+ * @param {{ baseUrl?: string, fetchImpl?: typeof fetch }} [options]
+ * @returns {Promise<Uint8Array>}
+ */
+export async function downloadTemplateZip(templateId, options = {}) {
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch
+  if (typeof fetchImpl !== 'function') {
+    throw new Error('fetch no está disponible en este runtime')
+  }
+
+  const url = templateZipUrl(templateId, options)
+  const response = await fetchImpl(url)
+  if (!response.ok) {
+    throw new Error(
+      `No se pudo descargar el template "${templateId}" (${response.status}): ${url}`,
+    )
+  }
+
+  const buffer = new Uint8Array(await response.arrayBuffer())
+  if (buffer.byteLength === 0) {
+    throw new Error(`El zip del template "${templateId}" está vacío`)
+  }
+  return buffer
+}

package/src/verify-domain.mjs

@@ -0,0 +1,65 @@
+/**
+ * Verifica que un domain exista en la API storefront (GET /v1/settings).
+ */
+export const DEFAULT_SETTINGS_URL = 'https://storefront.ecomiq.pe/v1/settings'
+
+/**
+ * @param {string} domain
+ * @param {{ settingsUrl?: string, fetchImpl?: typeof fetch }} [options]
+ * @returns {Promise<{ ok: true, storeName: string, domain: string, settings: unknown } | { ok: false, status: number, message: string }>}
+ */
+export async function verifyDomain(domain, options = {}) {
+  const trimmed = domain.trim()
+  if (!trimmed) {
+    return { ok: false, status: 0, message: 'El domain es obligatorio' }
+  }
+
+  const settingsUrl = options.settingsUrl ?? DEFAULT_SETTINGS_URL
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch
+  if (typeof fetchImpl !== 'function') {
+    return { ok: false, status: 0, message: 'fetch no está disponible en este runtime' }
+  }
+
+  let response
+  try {
+    response = await fetchImpl(settingsUrl, {
+      method: 'GET',
+      headers: {
+        Accept: 'application/json',
+        'x-Store-Domain': trimmed,
+      },
+    })
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : 'Error de red'
+    return { ok: false, status: 0, message: `No se pudo contactar la API: ${detail}` }
+  }
+
+  if (!response.ok) {
+    return {
+      ok: false,
+      status: response.status,
+      message:
+        response.status === 404
+          ? `No existe una tienda con domain "${trimmed}"`
+          : `La API respondió ${response.status} para domain "${trimmed}"`,
+    }
+  }
+
+  let settings
+  try {
+    settings = await response.json()
+  } catch {
+    return { ok: false, status: response.status, message: 'La API no devolvió JSON válido' }
+  }
+
+  const storeName =
+    settings &&
+    typeof settings === 'object' &&
+    settings.store &&
+    typeof settings.store === 'object' &&
+    typeof settings.store.name === 'string'
+      ? settings.store.name
+      : trimmed
+
+  return { ok: true, storeName, domain: trimmed, settings }
+}