orionplace-react 0.7.8 → 0.8.0

package/src/setup.mjs

@@ -1,274 +0,0 @@
-import { readFile, readdir, lstat, mkdir, writeFile, rename, unlink } from 'node:fs/promises';
-import { resolve, dirname, relative, sep } from 'node:path';
-import { createHash } from 'node:crypto';
-import { backendUrl, frontendDomain } from './validation.mjs';
-import { projectReadme } from './project-readme.mjs';
-
-const metadata = JSON.parse(await readFile(new URL('../package.json', import.meta.url), 'utf8'));
-const hash     = text => createHash('sha256').update(text).digest('hex');
-// Generated files a customer may already own: keep theirs untouched instead of failing.
-const optional = ['app/layout.tsx', 'app/page.tsx', 'app/page.module.css', 'app/globals.css', 'proxy.ts'];
-
-async function read(path) {
-  try { return await readFile(path, 'utf8'); }
-  catch (error) { if (error.code === 'ENOENT') return null; throw error; }
-}
-async function safePath(root, name) {
-  const target = resolve(root, name);
-  if (relative(root, target).startsWith('..') || target === root) throw new Error('Invalid generated path');
-  let cursor = root;
-  for (const piece of relative(root, target).split(sep)) {
-    cursor = resolve(cursor, piece);
-    try { if ((await lstat(cursor)).isSymbolicLink()) throw new Error(`Refusing symbolic link: ${name}`); }
-    catch (error) { if (error.code !== 'ENOENT') throw error; }
-  }
-  return target;
-}
-async function directoryExists(root, name) {
-  try { return (await lstat(resolve(root, name))).isDirectory(); }
-  catch (error) { if (error.code === 'ENOENT') return false; throw error; }
-}
-// The former template, replaced while the customer has not changed it.
-const previousNextConfig = `import type { NextConfig } from 'next';
-
-const nextConfig: NextConfig = {};
-
-export default nextConfig;
-`;
-const nextConfigTemplate = `import type { NextConfig } from 'next';
-import { androidAppConfig } from './orionplace/runtime/app.mjs';
-
-// The Android app build (ORIONPLACE_APP_ORIGIN) is a static export of the
-// app's own page; see orionplace/runtime/app.mjs.
-const nextConfig: NextConfig = androidAppConfig({});
-
-export default nextConfig;
-`;
-const tsconfigTemplate = {
-  compilerOptions: {
-    target: 'ES2022', lib: ['dom', 'dom.iterable', 'esnext'], allowJs: true, skipLibCheck: true,
-    strict: true, noEmit: true, esModuleInterop: true, module: 'esnext', moduleResolution: 'bundler',
-    resolveJsonModule: true, isolatedModules: true, jsx: 'react-jsx', incremental: true,
-    plugins: [{ name: 'next' }], paths: { '@/*': ['./*'] },
-  },
-  include: ['next-env.d.ts', '**/*.ts', '**/*.tsx', '.next/types/**/*.ts', '.next/dev/types/**/*.ts'],
-  exclude: ['node_modules'],
-};
-/**
- * Next.js needs no plugin registration: the gateway is a route handler in the
- * project. Only a conflicting /api rewrite or redirect must be resolved first.
- */
-function inspectNextConfig(source) {
-  const cleaned = source.replace(/\/\*[\s\S]*?\*\//g, '').replace(/(^|[^:])\/\/.*$/gm, '$1');
-  if (/\b(?:rewrites|redirects)\b/.test(cleaned) && /source\s*:\s*['"`]\/api(?:\/|['"`])/.test(cleaned)) {
-    throw new Error('Remove the conflicting /api rewrite or redirect from the Next.js configuration: Orionplace handles API routing. No files were changed.');
-  }
-  if (/\boutput\s*:\s*['"`]export['"`]/.test(cleaned)) {
-    throw new Error('Static export cannot read domain files. Use the default Node.js server output. No files were changed.');
-  }
-}
-function updateEnvironment(source, domain) {
-  const lines  = (source || '').split(/\r?\n/);
-  let updated  = false;
-  const result = lines.flatMap(line => {
-    if (!/^\s*(?:export\s+)?MIMIC_FRONT_DOMAIN\s*=/.test(line)) return [line];
-    if (updated) return [];
-    updated = true;
-    return [`MIMIC_FRONT_DOMAIN="${domain}"`];
-  });
-  if (!updated) result.push(`MIMIC_FRONT_DOMAIN="${domain}"`);
-  return result.join('\n').replace(/^\n/, '').replace(/\n*$/, '\n');
-}
-
-export async function setupProject({ cwd = process.cwd(), action = 'set', field, value, dryRun = false } = {}) {
-  if (!['set', 'add', 'remove', 'update'].includes(action) ||
-      (['add', 'remove'].includes(action) && field !== 'frontend') || (action === 'update' && field)) {
-    throw new Error('Use set backend, add frontend, remove frontend, set mimic, or set frontend.');
-  }
-  const root    = resolve(cwd);
-  const setting = field === 'backend' ? backendUrl(value) : ['frontend', 'mimic'].includes(field) ? frontendDomain(value) : null;
-  if (field && !setting) throw new Error('Choose backend, frontend, or mimic.');
-  const names   = ['package.json', 'next.config.ts', 'next.config.js', 'next.config.mjs', 'orionplace/settings.json', 'orionplace/.generated.json', '.env', '.gitignore'];
-  const current = {};
-  for (const name of names) current[name] = await read(await safePath(root, name));
-  const pkg          = current['package.json'] ? JSON.parse(current['package.json']) : { name: 'orionplace-storefront', private: true, version: '0.1.0' };
-  const dependencies = { ...pkg.devDependencies, ...pkg.dependencies };
-  if (action === 'update' && (!dependencies.next || !current['orionplace/settings.json'] || !current['orionplace/.generated.json'])) {
-    throw new Error('Update requires an initialized Orionplace React project. Run init first.');
-  }
-  if (!dependencies.next && ['nuxt', '@sveltejs/kit'].some(name => dependencies[name])) throw new Error('This package sets up Next.js projects only.');
-  if (dependencies.next && !/^(?:[~^]|>=)?16(?:\.|$)/.test(dependencies.next)) {
-    throw new Error('This release supports Next.js 16. Upgrade your Next.js dependency before setup.');
-  }
-  const configs = ['next.config.ts', 'next.config.js', 'next.config.mjs'].filter(name => current[name] !== null);
-  if (configs.length > 1) throw new Error('Multiple Next.js configuration files found; keep one root config.');
-  const configName = configs[0] || 'next.config.ts';
-  if (configs.length) inspectNextConfig(current[configName]);
-  // The App Router lives in app/ or src/app/; generated source follows it.
-  const base       = await directoryExists(root, 'src/app') || (!await directoryExists(root, 'app') && await directoryExists(root, 'src')) ? 'src/' : '';
-  if (await directoryExists(root, `${base}pages`)) {
-    throw new Error('This release generates App Router source. Remove or migrate the Pages Router directory first.');
-  }
-  for (const directory of [`${base}app/api`, `${base}pages/api`]) {
-    const path  = await safePath(root, directory);
-    let entries = [];
-    try { entries = await readdir(path); }
-    catch (error) { if (error.code !== 'ENOENT') throw error; }
-    if (entries.some(name => name.startsWith('[...') && name !== '[...orionplace]')) {
-      throw new Error(`Existing API catch-all in ${directory}. Resolve this route conflict first.`);
-    }
-  }
-  const settings = current['orionplace/settings.json'] ? JSON.parse(current['orionplace/settings.json']) : {};
-  const previous = current['orionplace/.generated.json'] ? JSON.parse(current['orionplace/.generated.json']) : {};
-  if (settings.backend) settings.backend = backendUrl(settings.backend);
-  if (settings.frontend) settings.frontend = frontendDomain(settings.frontend);
-  const oldFrontend = settings.frontend;
-  const frontends   = settings.frontends ?? (settings.frontend ? [settings.frontend] : []);
-  if (!Array.isArray(frontends)) throw new Error('settings.frontends must be an array of domain names.');
-  settings.frontends = [...new Set(frontends.map(frontendDomain))];
-  if (settings.frontend && !settings.frontends.includes(settings.frontend)) settings.frontends.unshift(settings.frontend);
-  if (field === 'backend') settings.backend = setting;
-  if (field === 'mimic') {
-    if (!settings.frontends.includes(setting)) {
-      throw new Error(`Add this frontend before selecting it for MIMIC: ${setting}`);
-    }
-    settings.frontend = setting;
-  }
-  if (field === 'frontend') {
-    if (action === 'remove') {
-      if (!settings.frontends.includes(setting)) throw new Error(`Frontend is not managed by this project: ${setting}`);
-      settings.frontends = settings.frontends.filter(domain => domain !== setting);
-      if (settings.frontend === setting) settings.frontend = settings.frontends[0];
-    } else {
-      if (!settings.frontends.includes(setting)) settings.frontends.push(setting);
-      // Adding an alias preserves the local development domain. "set" selects it.
-      if (action === 'set' || !settings.frontend) settings.frontend = setting;
-    }
-  }
-  settings.frontend ||= settings.frontends[0];
-  if (!settings.frontend) delete settings.frontend;
-  const manifest  = { ...previous };
-  const changes   = new Map();
-  const preserved = [];
-  async function plan(name, content, { managed = false, preserve = false } = {}) {
-    const path     = await safePath(root, name);
-    const existing = await read(path);
-    if (managed && existing !== null && existing !== content && previous[name] !== hash(existing)) {
-      if (preserve && previous[name]) { preserved.push(name); return; }
-      throw new Error(`Refusing to overwrite ${name}: it is not an unchanged generated file. No files were changed.`);
-    }
-    if (existing !== content) changes.set(name, content);
-    if (managed) manifest[name] = hash(content);
-  }
-  async function planRemoval(name) {
-    const existing = await read(await safePath(root, name));
-    if (existing !== null && previous[name] !== hash(existing)) {
-      throw new Error(`Refusing to remove ${name}: it is not an unchanged generated file. No files were changed.`);
-    }
-    if (existing !== null) changes.set(name, null);
-    delete manifest[name];
-  }
-  // All checks and content generation happen before the first write.
-  const isNewNext                             = !dependencies.next;
-  if (current[configName] === previousNextConfig) {
-    // The former template is ours to replace, as an unchanged generated file.
-    previous[configName] = hash(previousNextConfig);
-  }
-  if (!configs.length || current[configName] === previousNextConfig) {
-    await plan(configName, nextConfigTemplate, { managed: true, preserve: true });
-  }
-  pkg.scripts                               ||= {};
-  pkg.scripts.dev                           ||= 'next dev';
-  pkg.scripts.build                         ||= 'next build';
-  pkg.scripts.start                         ||= 'next start';
-  pkg.scripts['orionplace:backend']         ||= 'orionplace-react set backend';
-  pkg.scripts['orionplace:frontend']        ||= 'orionplace-react set frontend';
-  pkg.scripts['orionplace:add-frontend']    ||= 'orionplace-react add frontend';
-  pkg.scripts['orionplace:remove-frontend'] ||= 'orionplace-react remove frontend';
-  pkg.scripts['orionplace:mimic']           ||= 'orionplace-react set mimic';
-  pkg.scripts['orionplace:help']            ||= 'orionplace-react help';
-  pkg.scripts['orionplace:sitemap']         ||= 'orionplace-react sitemap rebuild';
-  pkg.scripts['orionplace:update']          ||= 'orionplace-react update';
-  pkg.dependencies                          ||= {};
-  pkg.dependencies.zustand                  ||= dependencies.zustand || '^5.0.15';
-  pkg.dependencies['country-flag-icons']    ||= dependencies['country-flag-icons'] || '^1.6.20';
-  pkg.dependencies['libphonenumber-js']     ||= dependencies['libphonenumber-js'] || '^1.13.10';
-  pkg.dependencies.dompurify                ||= dependencies.dompurify || '^3.4.13';
-  pkg.dependencies['orionplace-react']      ||= dependencies['orionplace-react'] || `^${metadata.version}`;
-  if (action === 'update') {
-    pkg.dependencies['orionplace-react'] = metadata.version;
-    if (pkg.devDependencies) delete pkg.devDependencies['orionplace-react'];
-  }
-  if (isNewNext) {
-    pkg.dependencies.next                    = '^16.3.4';
-    pkg.dependencies.react                 ||= '^19.3.0';
-    pkg.dependencies['react-dom']          ||= '^19.3.0';
-    pkg.devDependencies                    ||= {};
-    pkg.devDependencies.typescript         ||= '^5.9.3';
-    pkg.devDependencies['@types/node']     ||= '^22.18.0';
-    pkg.devDependencies['@types/react']    ||= '^19.3.0';
-    pkg.devDependencies['@types/react-dom'] ||= '^19.3.0';
-  }
-  const templateRoot = new URL('../templates/', import.meta.url);
-  async function planTemplates(directory = '') {
-    for (const entry of await readdir(new URL(directory, templateRoot), { withFileTypes: true })) {
-      const name = directory + entry.name;
-      if (entry.isDirectory()) { await planTemplates(name + '/'); continue; }
-      const target = base + name;
-      // Never replace a customer's own layout, page, styles or middleware.
-      if (optional.includes(name) && !previous[target] && await read(await safePath(root, target)) !== null) continue;
-      const source = await readFile(new URL(name, templateRoot), 'utf8');
-      await plan(target, source, { managed: true, preserve: true });
-    }
-  }
-  await planTemplates();
-  const existingTsconfig = await read(await safePath(root, 'tsconfig.json'));
-  if (existingTsconfig === null || previous['tsconfig.json'] === hash(existingTsconfig)) {
-    const configuration = structuredClone(tsconfigTemplate);
-    configuration.compilerOptions.paths = {
-      '@/*': [`./${base}*`],
-      '@orionplace-runtime/*': ['./orionplace/runtime/*'],
-    };
-    await plan('tsconfig.json', JSON.stringify(configuration, null, 2) + '\n', { managed: true });
-  } else {
-    // Custom JSONC/extends settings belong to the customer; document the alias merge.
-    preserved.push('tsconfig.json');
-  }
-  await plan('package.json', JSON.stringify(pkg, null, 2) + '\n');
-  await plan('orionplace/runtime/marketplace.mjs', await readFile(new URL('../runtime/marketplace.mjs', import.meta.url), 'utf8'), { managed: true, preserve: true });
-  await plan('orionplace/runtime/marketplace.d.mts', await readFile(new URL('../runtime/marketplace.d.mts', import.meta.url), 'utf8'), { managed: true, preserve: true });
-  await plan('orionplace/runtime/app.mjs', await readFile(new URL('../runtime/app.mjs', import.meta.url), 'utf8'), { managed: true, preserve: true });
-  await plan('orionplace/runtime/app.d.mts', await readFile(new URL('../runtime/app.d.mts', import.meta.url), 'utf8'), { managed: true, preserve: true });
-  await plan('orionplace/README.md', projectReadme(settings, base), { managed: true, preserve: true });
-  // A new project starts explicitly empty; keep a pre-existing manual setting on init.
-  const hasMimicSetting = /^\s*(?:export\s+)?MIMIC_FRONT_DOMAIN\s*=/m.test(current['.env'] || '');
-  if (action !== 'update' && (settings.frontend || oldFrontend || !hasMimicSetting)) {
-    await plan('.env', updateEnvironment(current['.env'], settings.frontend || ''));
-  }
-  if (settings.backend && action !== 'update') {
-    const mappings = action === 'remove' || field === 'mimic' ? []
-      : field === 'frontend' ? [setting] : settings.frontends;
-    for (const domain of mappings) {
-      await plan(`sitemaps/${domain}.cfg`, settings.backend + '\n', { managed: true });
-    }
-  }
-  if (action === 'remove') await planRemoval(`sitemaps/${setting}.cfg`);
-  let ignore = current['.gitignore'] || '';
-  for (const entry of ['node_modules/', '.next/', 'out/', 'next-env.d.ts', '.env', '.env.*', '!.env.example']) {
-    if (!ignore.split(/\r?\n/).includes(entry)) ignore = ignore.replace(/\n*$/, '\n') + entry + '\n';
-  }
-  await plan('.gitignore', ignore);
-  if (action !== 'update') await plan('orionplace/settings.json', JSON.stringify(settings, null, 2) + '\n');
-  await plan('orionplace/.generated.json', JSON.stringify(manifest, null, 2) + '\n');
-  if (!dryRun) {
-    for (const [name, content] of changes) {
-      const target = await safePath(root, name);
-      if (content === null) { await unlink(target); continue; }
-      await mkdir(dirname(target), { recursive: true });
-      const temporary = `${target}.orionplace-${process.pid}.tmp`;
-      await writeFile(temporary, content, { mode: name === '.env' ? 0o600 : 0o644, flag: 'wx' });
-      await rename(temporary, target);
-    }
-  }
-  return { root, settings, changed: [...changes.keys()], removed: [...changes].filter(([, content]) => content === null).map(([name]) => name), preserved, dryRun, isNewNext, base };
-}

package/src/sitemap.mjs

@@ -1,93 +0,0 @@
-import { existsSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
-import { relative, resolve } from 'node:path';
-import { pathToFileURL } from 'node:url';
-
-const metadata = JSON.parse(await readFile(new URL('../package.json', import.meta.url), 'utf8'));
-const cli      = metadata.name;
-
-/**
- * The project's own gateway runtime (orionplace/runtime/marketplace.mjs): the
- * sitemap is built with the code the running storefront uses.
- */
-async function projectRuntime(root) {
-  const path    = resolve(root, 'orionplace/runtime/marketplace.mjs');
-  if (!existsSync(path)) {
-    throw new Error(`No orionplace/runtime/marketplace.mjs in ${root}. Run this in the storefront project (or pass --cwd).`);
-  }
-  const runtime = await import(pathToFileURL(path).href);
-  if (typeof runtime.rebuildMarketplaceSitemap !== 'function') {
-    throw new Error(`This project's runtime has no sitemap support. Run npx ${cli} update first.`);
-  }
-  return runtime;
-}
-
-/**
- * The storefront reads SITEMAPS_DIR and ORIONPLACE_CACHE_DIR from the
- * project's .env; the command uses the same folders. Variables already set
- * in the shell win.
- */
-async function projectEnvironment(root) {
-  let source = '';
-  try { source = await readFile(resolve(root, '.env'), 'utf8'); }
-  catch (error) { if (error.code !== 'ENOENT') throw error; }
-  for (const line of source.split(/\r?\n/)) {
-    const match = /^\s*(?:export\s+)?(SITEMAPS_DIR|ORIONPLACE_CACHE_DIR)\s*=\s*(.*?)\s*$/.exec(line);
-    if (!match || process.env[match[1]] !== undefined) continue;
-    const value = match[2].replace(/^(['"])(.*)\1$/, '$2');
-    if (value) process.env[match[1]] = resolve(root, value);
-  }
-}
-
-async function domainsFor(runtime, root, domain) {
-  if (domain) {
-    const normalized = runtime.normalizeFrontDomain(domain);
-    if (!normalized) throw new Error(`Invalid frontend domain: ${domain}`);
-    return [normalized];
-  }
-  const domains = await runtime.marketplaceDomains(root);
-  if (!domains.length) throw new Error(`No frontend domains yet. Add one: npx ${cli} add frontend <shop.example.com>`);
-  return domains;
-}
-
-function age(built, now = Date.now()) {
-  const minutes = Math.max(0, Math.round((now - Date.parse(built)) / 60_000));
-  return minutes < 60 ? `${minutes} min ago` : `${Math.floor(minutes / 60)} h ${minutes % 60} min ago`;
-}
-
-/**
- * `sitemap rebuild [domain]`: build the sitemap of every frontend domain (or
- * one) now. `sitemap status [domain]`: show when each was built.
- * @param {{cwd: string, action: string, domain?: string, log?: (line: string) => void}} options
- * @returns {Promise<number>} exit code
- */
-export async function sitemapCommand({ cwd, action, domain, log = console.log }) {
-  if (!['rebuild', 'status'].includes(action)) {
-    throw new Error(`Use: npx ${cli} sitemap rebuild [domain] | sitemap status [domain]`);
-  }
-  const root    = resolve(cwd);
-  await projectEnvironment(root);
-  const runtime = await projectRuntime(root);
-  const domains = await domainsFor(runtime, root, domain);
-  let failed    = 0;
-  for (const name of domains) {
-    if (action === 'status') {
-      const sitemap = await runtime.readSitemapCache(name, root);
-      const stale   = sitemap && Date.now() - Date.parse(sitemap.built) >= runtime.SITEMAP_LIFETIME;
-      log(sitemap
-        ? `${name}: built ${sitemap.built} (${age(sitemap.built)}), ${runtime.sitemapUrlCount(sitemap)} URLs${stale ? '; rebuilt at the next crawl' : ''}`
-        : `${name}: not built yet; built at the first /sitemap.xml request or with: npx ${cli} sitemap rebuild`);
-      continue;
-    }
-    const started = Date.now();
-    try {
-      const done = await runtime.rebuildMarketplaceSitemap(name, { root });
-      log(`${name}: ${done.urls} URLs (${done.pages} pages, ${done.publications} journal publications) in ${((Date.now() - started) / 1000).toFixed(1)} s`);
-      log(`  saved ${relative(root, done.path)}; the running storefront serves it now at https://${name}/sitemap.xml`);
-    } catch (error) {
-      failed++;
-      log(`${name}: not rebuilt: ${error?.message ?? error}`);
-    }
-  }
-  return failed ? 1 : 0;
-}

package/src/update.mjs

@@ -1,36 +0,0 @@
-import { spawn } from 'node:child_process';
-import { resolve } from 'node:path';
-import { setupProject } from './setup.mjs';
-
-export function runNpm(args, cwd) {
-  const npmCli      = process.env.npm_execpath;
-  const command     = npmCli ? process.execPath : 'npm';
-  const commandArgs = npmCli ? [npmCli, ...args] : args;
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, commandArgs, { cwd, stdio: 'inherit', shell: false });
-    child.once('error', reject);
-    child.once('exit', (code, signal) => code === 0 ? resolve() : reject(new Error(
-      `npm ${args[0]} failed (${signal || code}).`,
-    )));
-  });
-}
-
-export async function updateProject({ cwd = process.cwd(), dryRun = false, local = false, npm = runNpm } = {}) {
-  cwd = resolve(cwd);
-  // Validate before downloading or writing; the latest CLI repeats preflight with its own templates.
-  const preview = await setupProject({ cwd, action: 'update', dryRun: true });
-  if (!local) {
-    console.log('Checking the latest Orionplace React release…');
-    await npm(['exec', '--yes', '--prefer-online', '--package=orionplace-react@latest', '--',
-      'orionplace-react', 'update', '--local', '--cwd', cwd, ...(dryRun ? ['--dry-run'] : [])], cwd);
-    return null; // The latest CLI reports its own changes.
-  }
-  if (dryRun) return preview;
-  const result = await setupProject({ cwd, action: 'update' });
-  try {
-    await npm(['install', '--no-audit', '--no-fund'], cwd);
-  } catch (error) {
-    throw new Error(`Source files were updated, but dependency installation failed. Run npm install in the project, then retry update. ${error.message}`);
-  }
-  return result;
-}

package/src/validation.mjs

@@ -1,27 +0,0 @@
-import { isIP } from 'node:net';
-const dns = /^(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
-
-export function frontendDomain(value) {
-  let url;
-  try { url = new URL(value.includes('://') ? value : `https://${value}`); }
-  catch { throw new Error('Use a public frontend hostname, for example shop.example.com.'); }
-  const domain = url.hostname.toLowerCase().replace(/\.$/, '');
-  if (!dns.test(domain) || isIP(domain) || url.username || url.password || url.port ||
-      url.search || url.hash || url.pathname !== '/' || !['http:', 'https:'].includes(url.protocol)) {
-    throw new Error('Frontend must be a public hostname without a port, path, or credentials.');
-  }
-  return domain;
-}
-
-export function backendUrl(value) {
-  let url;
-  try { url = new URL(value.includes('://') ? value : `https://${value}`); }
-  catch { throw new Error('Use the personal backend domain shown in your Orionplace account.'); }
-  const path = url.pathname.replace(/\/+$/, '');
-  if (url.protocol !== 'https:' || !dns.test(url.hostname) ||
-      !url.hostname.endsWith('.orionplace.app') || url.username || url.password ||
-      url.port || url.search || url.hash || !['', '/api'].includes(path)) {
-    throw new Error('Backend must be https://<your-project>.orionplace.app or its /api URL.');
-  }
-  return `${url.origin}/api`;
-}