orionplace-react 0.3.1 → 0.4.0

package/README.md

@@ -317,6 +317,8 @@ npx orionplace-react add frontend www.shop.example.com
 npx orionplace-react remove frontend www.shop.example.com
 npx orionplace-react set mimic shop.example.com
 sudo npx orionplace-react install
+npx orionplace-react status
+sudo npx orionplace-react restart
 npx orionplace-react help
 ```
 
@@ -363,9 +365,34 @@ builds the project, runs it as the system service `orionplace-shop` on a free
 local port and connects each storefront domain with nginx and a Let's Encrypt
 certificate. Run it again after code or package updates; the service keeps its
 port. Options: `--name <service>`, `--port <port>`, `--user <user>`,
-`--no-domains`, `--yes`, `--dry-run`. Full guide:
+`--no-build` (install the build already in the folder), `--no-domains`, `--yes`,
+`--dry-run`. Full guide:
 [Install a storefront](https://orionmarket.place/en/sandbox/install/storefront?framework=react).
 
+### Manage the service
+
+Run these in the project folder, or name the service from anywhere with
+`--name shop`:
+
+```bash
+npx orionplace-react status            # running?, autostart, port, home page answer, domains
+sudo npx orionplace-react start
+sudo npx orionplace-react stop
+sudo npx orionplace-react restart      # waits until the home page answers again
+sudo npx orionplace-react logs 200     # last log lines; --follow keeps reading
+npx orionplace-react list              # every storefront service on this server
+sudo npx orionplace-react uninstall    # stop and remove the service (alias: cleanup)
+```
+
+`start` and `restart` wait up to 90 seconds for the home page and print the
+last log lines when it does not answer. `status` ends with code 3 when the
+storefront is stopped or does not answer, so scripts and monitors can use it.
+`uninstall` (or `cleanup`) stops the service, takes it out of autostart and
+deletes its unit file and registration; the project folder and its build stay.
+With the `orionplace` server tool it runs `orionplace app remove`, which also
+turns the storefront's domains into a placeholder page. `--dry-run` shows what it
+would remove; `--yes` skips the question.
+
 ## Generated files
 
 | Path                                    | Purpose                                                                          |
@@ -440,8 +467,14 @@ The corresponding `.cfg` is read on every request. Backend URLs must use HTTPS,
 end in `/api`, and belong to `*.orionplace.app`. API methods, query strings, bodies,
 authorization and cookies are forwarded. Backend statuses are retained and cookie
 Domain attributes are removed to bind cookies to the storefront. Gateway responses
-use `Cache-Control: no-store`. Network failures return `502`. Cross-site mutations
-are rejected with `403`.
+use `Cache-Control: no-store`. Network failures return `502`.
+
+A changing request (POST, PUT, PATCH, DELETE) from another site is rejected with
+`403`. A request from the page's own host or the storefront domain passes, and the
+backend receives it with the storefront domain's origin
+(`https://shop.example.com`), the one it accepts forms from. So a host that shows
+the storefront through `X-Front-Domain`, such as a preview host or a local port,
+can sign in too.
 
 Browser requests use `/api/...`. Server components call the same gateway in process
 through `lib/orionplace/appLoadServer.ts`, which forwards the current request's

package/bin/orionplace-react.mjs

@@ -2,6 +2,7 @@
 import { setupProject } from '../src/setup.mjs';
 import { updateProject } from '../src/update.mjs';
 import { installService } from '../src/install.mjs';
+import { SERVICE_ACTIONS, SERVICE_ALIASES, controlService, findApp, printService } from '../src/service.mjs';
 import { readFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import { createInterface } from 'node:readline/promises';
@@ -37,9 +38,20 @@ On your Linux server (run from the project root):
   nginx and HTTPS. Run it again after changes or an update to rebuild and restart.
   Server tool: https://orionmarket.place/downloads/orionplace.sh
 
+Manage the installed service (from the project root, or name it with --name):
+  npx orionplace-react status              service, autostart, port and home page answer
+  sudo npx orionplace-react start
+  sudo npx orionplace-react stop
+  sudo npx orionplace-react restart        restart and wait until the home page answers
+  sudo npx orionplace-react logs [lines]   last log lines (100); --follow keeps reading
+  npx orionplace-react list                every storefront service on this server
+  sudo npx orionplace-react uninstall      stop the service and remove it (alias: cleanup);
+                                       the project folder stays
+
 Options: --cwd <directory>  --dry-run  --help  --version
 Update option: --local (apply this CLI version instead of fetching the latest release)
-Install options: --name <service>  --port <port>  --user <user>  --no-domains  --yes
+Install options: --name <service>  --port <port>  --user <user>  --no-build  --no-domains  --yes
+Service options: --name <service>  --follow (logs)  --dry-run --yes (uninstall)
 
 Update downloads the latest release, refreshes unedited source, and installs dependencies.
 It preserves edited source, domain mappings and MIMIC. --dry-run leaves project files unchanged.
@@ -62,11 +74,14 @@ try {
     let cwd          = process.cwd();
     let dryRun       = false;
     let local        = false;
-    const install    = { domains: true, yes: false };
+    let follow       = false;
+    const install    = { domains: true, build: true, yes: false };
     for (let index = 0; index < argv.length; index++) {
       if (argv[index] === '--dry-run') dryRun = true;
       else if (argv[index] === '--local') local = true;
       else if (argv[index] === '--no-domains') install.domains = false;
+      else if (argv[index] === '--no-build') install.build = false;
+      else if (argv[index] === '--follow' || argv[index] === '-f') follow = true;
       else if (argv[index] === '--yes' || argv[index] === '-y') install.yes = true;
       else if (['--name', '--port', '--user'].includes(argv[index])) {
         if (!argv[index + 1]) throw new Error(`${argv[index]} needs a value`);
@@ -77,11 +92,15 @@ try {
       } else if (argv[index].startsWith('--')) throw new Error(`Unknown option: ${argv[index]}`);
       else positional.push(argv[index]);
     }
-    const [command, target] = positional;
+    const [given, target] = positional;
+    const command    = SERVICE_ALIASES[given] || given;
     if (local && command !== 'update') throw new Error('--local is only supported by update.');
-    if (command !== 'install' && (install.name || install.port || install.user || !install.domains || install.yes)) {
-      throw new Error('--name, --port, --user, --no-domains and --yes are install options.');
+    const service    = SERVICE_ACTIONS.includes(command);
+    if (command !== 'install' && (install.port || install.user || !install.domains || !install.build || (install.yes && command !== 'uninstall') || (install.name && !service))) {
+      throw new Error('--port, --user, --no-build, --no-domains and --yes are install options (--yes also for uninstall); --name is for install and the service commands.');
     }
+    if (follow && command !== 'logs') throw new Error('--follow is a logs option.');
+    if (dryRun && service && command !== 'uninstall') throw new Error('--dry-run is only for uninstall among the service commands; status shows the state without changes.');
     let result;
     if (command === 'install' && positional.length === 1) {
       const done = await installService({ cwd, dryRun, ...install });
@@ -92,14 +111,26 @@ try {
       } else {
         console.log(`\nInstalled orionplace-${done.name} (port ${done.port}, user ${done.user}).`);
         for (const domain of done.frontends) {
-          if (!done.connected) console.log(`  - ${domain}: not connected to nginx (see above)`);
+          if (!install.domains) console.log(`  - ${domain}: not connected (--no-domains)`);
+          else if (!done.connected) console.log(`  - ${domain}: not connected to nginx (see above)`);
           else if (done.failed.includes(domain)) console.log(`  ✗ ${domain}: not connected (see above)`);
           else console.log(`  ✓ https://${domain}`);
         }
         if (done.failed.length) console.log('Fix the problems above, then run: sudo orionplace domain add <domain>');
-        console.log(`Manage it with: orionplace app status ${done.name} | orionplace app logs ${done.name}`);
+        console.log(`Manage it from this folder: npx orionplace-react status | sudo npx orionplace-react restart | sudo npx orionplace-react logs`);
         console.log('After code changes or npx orionplace-react update, run sudo npx orionplace-react install again.');
       }
+    } else if (service && positional.length <= (command === 'logs' ? 2 : 1)) {
+      if (command === 'uninstall' && !dryRun && !install.yes && process.stdin.isTTY) {
+        const app    = await findApp({ cwd, name: install.name });
+        const prompt = createInterface({ input: process.stdin, output: process.stdout });
+        let answer;
+        try { answer = await prompt.question(`Stop and remove the service orionplace-${app.NAME}? The project stays in ${app.DIR}. [y/N] `); }
+        finally { prompt.close(); }
+        if (!/^y(es)?$/i.test(answer.trim())) { console.log('Nothing changed.'); process.exit(0); }
+      }
+      const done       = await controlService({ action: command, cwd, name: install.name, lines: positional[1] ?? 100, follow, dryRun });
+      process.exitCode = printService(done);
     } else if (command === 'init' && positional.length <= 2) {
       result = await setupProject({ cwd: target ? resolve(cwd, target) : cwd, dryRun });
     } else if (command === 'update' && positional.length === 1) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orionplace-react",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Next.js 16 storefront for your Orionplace marketplace: setup CLI, server API gateway, typed store and ready-made catalog, cart, checkout and account components in English and Russian, plus an Android app build.",
   "type": "module",
   "license": "MIT",

package/runtime/marketplace.mjs

@@ -208,6 +208,18 @@ export async function forwardMarketplace(request, configuration = {}) {
     }
   }
   headers.set('X-Front-Domain', tenant.domain);
+  // The backend accepts forms from the storefront domain's own origin. A public
+  // host that shows this storefront (MIMIC, a preview host or a local port)
+  // passed the same-origin check above, so it is sent as that origin.
+  let ownOrigin         = false;
+  try {
+    ownOrigin = Boolean(origin) && originHosts.includes(new URL(origin).host);
+  } catch {
+    ownOrigin = false;
+  }
+  if (ownOrigin) {
+    headers.set('origin', `https://${tenant.domain}`);
+  }
   headers.set('Accept-Encoding', 'identity');
   const clientIp        =
     request.headers.get('x-init-ip') ||

package/src/install.mjs

@@ -222,7 +222,7 @@ async function ensureDomains(root, { yes }) {
 }
 
 // The storefront's home page as the public domain sees it -> HTTP status, 0 when down.
-function homeStatus(port, host) {
+export function homeStatus(port, host) {
   return new Promise(done => {
     const call = request({ host: '127.0.0.1', port, path: '/', headers: { host }, timeout: 15000 }, response => {
       response.resume();
@@ -234,7 +234,7 @@ function homeStatus(port, host) {
   });
 }
 
-async function waitForHttp(port, host, seconds = 90) {
+export async function waitForHttp(port, host, seconds = 90) {
   const until = Date.now() + seconds * 1000;
   while (Date.now() < until) {
     const status = await homeStatus(port, host);
@@ -302,7 +302,8 @@ export async function installService({
     return { dryRun, name: service, port: chosen, user: account.name, unitPath, unit, conf, frontends: settings.frontends || [], backend: settings.backend };
   }
 
-  log(`\n==> Building the ${framework.title} storefront ${service}`);
+  const rebuild  = build || !existsSync(join(root, framework.output));
+  log(rebuild ? `\n==> Building the ${framework.title} storefront ${service}` : `\n==> Using the existing build of ${service} (--no-build)`);
   // The website build; ORIONPLACE_APP_ORIGIN would make the Android app build.
   const buildEnv = { ...process.env };
   delete buildEnv.ORIONPLACE_APP_ORIGIN;
@@ -310,7 +311,7 @@ export async function installService({
     const installed = await run('npm', ['install', '--no-audit', '--no-fund'], { cwd: root, env: buildEnv });
     if (installed.code) throw new Error('npm install failed; see the messages above.');
   }
-  if (build || !existsSync(join(root, framework.output))) {
+  if (rebuild) {
     const built = await run('npm', ['run', 'build'], { cwd: root, env: buildEnv });
     if (built.code) throw new Error('The build failed; see the messages above. The running service (if any) was not changed.');
   }

package/src/project-readme.mjs

@@ -353,6 +353,9 @@ The quickest way: prepare the server with the OrionMarketplace server script,
 then run \`sudo npx orionplace-react install\` in this folder. It builds the
 project, runs it as a system service and connects your domains with nginx and
 HTTPS. Steps: [Install a storefront](https://orionmarket.place/en/sandbox/install/storefront?framework=react).
+Then manage it from this folder: \`npx orionplace-react status\`, \`sudo npx orionplace-react restart\`,
+\`sudo npx orionplace-react stop\`, \`sudo npx orionplace-react start\` and \`sudo npx orionplace-react logs\`.
+\`sudo npx orionplace-react uninstall\` (or \`cleanup\`) stops and removes the service; this folder stays.
 
 To set the server up yourself instead:
 

package/src/service.mjs

@@ -0,0 +1,186 @@
+// Manages the storefront service that "install" set up: start, stop, restart,
+// status, logs and the list of every storefront service on this server.
+// The service is found by its folder (the project root) or by --name.
+import { existsSync } from 'node:fs';
+import { readFile, rm } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { defaultPaths, framework, homeStatus, readApps, runCommand, waitForHttp } from './install.mjs';
+
+export const SERVICE_ACTIONS = ['start', 'stop', 'restart', 'status', 'logs', 'list', 'uninstall'];
+// "cleanup" is another name for uninstall.
+export const SERVICE_ALIASES = { cleanup: 'uninstall' };
+
+async function frontends(dir) {
+  try { return JSON.parse(await readFile(join(dir, 'orionplace/settings.json'), 'utf8')).frontends || []; }
+  catch { return []; }
+}
+
+// The registered storefront of this folder, or the one named with --name.
+export async function findApp({ cwd = process.cwd(), name, paths = defaultPaths } = {}) {
+  const apps = await readApps(paths);
+  const root = resolve(cwd);
+  const app  = name ? apps.find(item => item.NAME === name) : apps.find(item => item.DIR === root);
+  if (app) return app;
+  const known = apps.map(item => item.NAME).join(', ');
+  if (name) throw new Error(`No storefront service named ${name}.${known ? ` Installed: ${known}.` : ''}`);
+  throw new Error(`${root} is not installed as a service. Install it first: sudo npx orionplace-${framework.id} install`
+    + (known ? `\nOr name another storefront: --name ${apps[0].NAME} (installed: ${known})` : ''));
+}
+
+// true / false; "unknown" when neither systemd nor OpenRC answers.
+async function isRunning(service, { run, systemd }) {
+  const result = systemd
+    ? await run('systemctl', ['is-active', '--quiet', service], { capture: true })
+    : await run('rc-service', [service, 'status'], { capture: true });
+  return result.code === 0;
+}
+
+async function isEnabled(service, { run, systemd }) {
+  const result = systemd
+    ? await run('systemctl', ['is-enabled', '--quiet', service], { capture: true })
+    : await run('rc-update', ['show', 'default'], { capture: true });
+  return systemd ? result.code === 0 : new RegExp(`^\\s*${service}\\s`, 'm').test(result.output);
+}
+
+async function lastLogs(app, { run, systemd, paths, lines = 40 }) {
+  const result = systemd
+    ? await run('journalctl', ['-u', app.SERVICE || `orionplace-${app.NAME}`, '-n', String(lines), '--no-pager'], { capture: true })
+    : await run('tail', ['-n', String(lines), join(paths.logs, `${app.NAME}.log`)], { capture: true });
+  return result.output;
+}
+
+// One storefront's state: service, autostart, and the home page as its first domain sees it.
+export async function serviceStatus(app, { run = runCommand, systemd = existsSync('/run/systemd/system'), probe = homeStatus } = {}) {
+  const service = app.SERVICE || `orionplace-${app.NAME}`;
+  const domains = await frontends(app.DIR);
+  const running = await isRunning(service, { run, systemd });
+  const enabled = await isEnabled(service, { run, systemd });
+  const http    = running ? await probe(Number(app.PORT), domains[0] || 'localhost') : 0;
+  return { name: app.NAME, service, framework: app.FRAMEWORK, dir: app.DIR, port: Number(app.PORT), running, enabled, http, domains };
+}
+
+/**
+ * controlService({ action, cwd, name, lines, follow }) runs one action and
+ * returns what happened; logs and follow print straight to the terminal.
+ */
+export async function controlService({
+  action, cwd = process.cwd(), name, lines = 100, follow = false,
+  paths = defaultPaths, run = runCommand, uid = process.getuid?.(),
+  systemd = existsSync('/run/systemd/system'), openrc = existsSync('/sbin/openrc-run'),
+  platform = process.platform, probe = homeStatus, wait = waitForHttp, dryRun = false,
+} = {}) {
+  action = SERVICE_ALIASES[action] || action;
+  if (!SERVICE_ACTIONS.includes(action)) throw new Error(`Unknown service command ${action}. Use ${SERVICE_ACTIONS.join(', ')}.`);
+  if (platform !== 'linux') throw new Error(`${action} manages the Linux service that install set up. Run it on your server.`);
+  if (!systemd && !openrc) throw new Error('Neither systemd nor OpenRC was found on this server.');
+
+  if (action === 'list') {
+    const apps = await readApps(paths);
+    return { action, apps: await Promise.all(apps.map(app => serviceStatus(app, { run, systemd, probe }))) };
+  }
+
+  const app     = await findApp({ cwd, name, paths });
+  const service = app.SERVICE || `orionplace-${app.NAME}`;
+  if (action === 'status') return { action, ...await serviceStatus(app, { run, systemd, probe }) };
+
+  if (action === 'logs') {
+    const count = Number(lines);
+    if (!Number.isInteger(count) || count < 1) throw new Error('Give the number of log lines as a whole number, for example: logs 200');
+    const args  = systemd
+      ? ['journalctl', ['-u', service, '-n', String(count), '--no-pager', ...(follow ? ['--follow'] : [])]]
+      : ['tail', ['-n', String(count), ...(follow ? ['-F'] : []), join(paths.logs, `${app.NAME}.log`)]];
+    const result = await run(...args);
+    if (result.code) throw new Error(`${args[0]} could not read the logs of ${service}${uid !== 0 ? `; try: sudo npx orionplace-${framework.id} logs` : ''}.`);
+    return { action, name: app.NAME, service };
+  }
+
+  if (action === 'uninstall') return uninstallService(app, { paths, run, uid, systemd, name, dryRun });
+  if (uid !== 0) throw new Error(`${action} needs root: sudo npx orionplace-${framework.id} ${action}${name ? ` --name ${name}` : ''}`);
+  const result  = systemd
+    ? await run('systemctl', [action, service], { capture: true })
+    : await run('rc-service', [service, action], { capture: true });
+  if (result.code) throw new Error(`Could not ${action} ${service}:\n${result.output.trim()}`);
+  if (action === 'stop') return { action, name: app.NAME, service, running: false };
+
+  const domains = await frontends(app.DIR);
+  const http    = await wait(Number(app.PORT), domains[0] || 'localhost', 90);
+  if (!http) {
+    throw new Error(`${service} did not answer on port ${app.PORT} within 90 seconds. Last log lines:\n${await lastLogs(app, { run, systemd, paths })}`);
+  }
+  return { action, name: app.NAME, service, port: Number(app.PORT), running: true, http, domains };
+}
+
+/**
+ * Stops the service, removes it from autostart, deletes its unit or init
+ * script and its registration. The project folder and its build stay. With
+ * the orionplace server tool, "orionplace app remove" does it and also turns
+ * the storefront's domains into a placeholder page.
+ */
+async function uninstallService(app, { paths, run, uid, systemd, name, dryRun }) {
+  const service  = app.SERVICE || `orionplace-${app.NAME}`;
+  const unitPath = systemd ? join(paths.systemd, `${service}.service`) : join(paths.openrc, service);
+  const confPath = join(paths.etc, 'apps', `${app.NAME}.conf`);
+  const tool     = (paths.tool || []).find(path => existsSync(path));
+  const result   = { action: 'uninstall', name: app.NAME, service, dir: app.DIR, domains: await frontends(app.DIR), tool: Boolean(tool), unitPath, confPath, dryRun };
+  if (dryRun) return result;
+  if (uid !== 0) throw new Error(`uninstall needs root: sudo npx orionplace-${framework.id} uninstall${name ? ` --name ${name}` : ''}`);
+  if (tool) {
+    const removed = await run(tool, ['app', 'remove', app.NAME, '--yes']);
+    if (removed.code) throw new Error(`orionplace app remove ${app.NAME} failed; see the messages above.`);
+    return result;
+  }
+  // A service that is already stopped or missing is fine: the goal is that it is gone.
+  if (systemd) await run('systemctl', ['disable', '--now', service], { capture: true });
+  else {
+    await run('rc-service', [service, 'stop'], { capture: true });
+    await run('rc-update', ['del', service, 'default'], { capture: true });
+  }
+  await rm(unitPath, { force: true });
+  if (systemd) await run('systemctl', ['daemon-reload'], { capture: true });
+  await rm(confPath, { force: true });
+  return result;
+}
+
+// The CLI output of controlService; returns the process exit code.
+export function printService(result, log = console.log) {
+  const line = item => {
+    const state = item.running ? (item.http ? `running, home page HTTP ${item.http}` : 'running, home page does not answer') : 'stopped';
+    return `${item.name.padEnd(16)} ${String(item.framework || '').padEnd(7)} ${String(item.port).padEnd(6)} ${state}`;
+  };
+  if (result.action === 'list') {
+    if (!result.apps.length) {
+      log(`No storefront services on this server. Install one from its folder: sudo npx orionplace-${framework.id} install`);
+      return 0;
+    }
+    log(`${'NAME'.padEnd(16)} ${'TYPE'.padEnd(7)} ${'PORT'.padEnd(6)} STATE`);
+    for (const item of result.apps) log(line(item));
+    return 0;
+  }
+  if (result.action === 'status') {
+    log(`${result.service} (${result.framework || framework.id}) in ${result.dir}`);
+    log(`  Service:   ${result.running ? 'running' : 'stopped'}${result.enabled ? ', starts with the server' : ', does not start with the server'}`);
+    log(`  Port:      127.0.0.1:${result.port}`);
+    log(`  Home page: ${result.running ? (result.http ? `HTTP ${result.http}` : 'does not answer') : '-'}`);
+    for (const domain of result.domains) log(`  Domain:    https://${domain}`);
+    return result.running && result.http && result.http < 500 ? 0 : 3;
+  }
+  if (result.action === 'uninstall') {
+    if (result.dryRun) {
+      log(`Would stop and remove ${result.service}:`);
+      log(result.tool ? `  orionplace app remove ${result.name} --yes (also turns its domains into a placeholder)` : `  ${result.unitPath}\n  ${result.confPath}`);
+      log(`The project stays in ${result.dir}.`);
+      return 0;
+    }
+    log(`Removed the service ${result.service}. The project and its build stay in ${result.dir}; delete the folder when you no longer need it.`);
+    if (!result.tool && result.domains.length) {
+      log(`nginx still sends ${result.domains.join(', ')} to the stopped service; remove those sites from your nginx configuration.`);
+    }
+    log(`Install it again with: sudo npx orionplace-${framework.id} install`);
+    return 0;
+  }
+  if (result.action === 'stop') log(`Stopped ${result.service}.`);
+  else if (result.action === 'start' || result.action === 'restart') {
+    log(`${result.action === 'start' ? 'Started' : 'Restarted'} ${result.service}: home page HTTP ${result.http} on 127.0.0.1:${result.port}.`);
+  }
+  return 0;
+}

package/templates/components/orionplace/subscriptions/StorefrontTariff.README.md

@@ -30,6 +30,12 @@ the callbacks from `TariffPurchaseActions`. A failed required refresh hides the
 dialog, blocks another purchase and exposes Refresh without discarding the
 dialog fields.
 
+For a signed-in customer the component also reads `subscriptions_get` once
+through `onLoadSubscriptions`: plans of a subscription the customer already
+had offer no trial, and a resumed trial opens only after that read, for a
+customer new to the subscription. A failed read leaves the trial shown; the
+backend still refuses a repeated trial.
+
 The component makes requests only through its callbacks. Source is maintained
 in `components/orionplace/subscriptions/StorefrontTariff.tsx`; the plan contract
 is `interfaces/orionplace/subscribeTariff/ISubscribeTariff.ts`.
@@ -85,6 +91,13 @@ is `interfaces/orionplace/subscribeTariff/ISubscribeTariff.ts`.
 обновление не удалось, окно скрывается, новое подключение блокируется и
 появляется кнопка обновления, а заполненные поля окна сохраняются.
 
+Для авторизованного покупателя компонент также один раз читает
+`subscriptions_get` через `onLoadSubscriptions`: тарифы подписки, которая у
+покупателя уже была, не предлагают пробный период, а восстановленный пробный
+выбор открывается только после этого чтения и только для нового покупателя
+подписки. При ошибке чтения пробный период остаётся видимым; повторный пробный
+период всё равно отклоняет сервер.
+
 Компонент отправляет запросы только через переданные функции. Исходный файл:
 `components/orionplace/subscriptions/StorefrontTariff.tsx`; контракт тарифа:
 `interfaces/orionplace/subscribeTariff/ISubscribeTariff.ts`.

package/templates/components/orionplace/subscriptions/StorefrontTariff.tsx

@@ -11,7 +11,12 @@ import {
   useOrionplaceCatalogStore,
   useOrionplaceSelections,
 } from '@/providers/OrionplaceProvider';
-import { selectIsAuthenticated } from '@/stores/orionplace';
+import {
+  selectIsAuthenticated,
+  selectProfile,
+} from '@/stores/orionplace';
+import { selectUsedSubscriptions } from '@/stores/orionplaceCatalog';
+import { tariffResumable } from '@/lib/orionplace/tariffs';
 import type { IBreadcrumb } from '@/interfaces/orionplace/shared/IBreadcrumb';
 import type { ISubscribeTariff } from '@/interfaces/orionplace/subscribeTariff/ISubscribeTariff';
 import type { ITariffSelection } from '@/interfaces/orionplace/subscribeTariff/ITariffSelection';
@@ -89,6 +94,8 @@ export function StorefrontTariff({
     state.tariffs?.data.find((entry) => entry.id === tariffId),
   );
   const catalogStore = useOrionplaceCatalogStore();
+  const profile = useOrionplace((state) => selectProfile(state)?.id);
+  const used = useOrionplaceCatalog(selectUsedSubscriptions(profile));
   const locale = useOrionplaceSelections((state) => state.localeCode);
   const copy = tariffLabels(locale);
   const common = featureLabels(locale);
@@ -273,22 +280,26 @@ export function StorefrontTariff({
     }
   }, [tariff]);
 
+  // A trial chosen before sign-in opens again only for a customer new to
+  // the subscription record (see `tariffResumable`).
+  const resumable = tariffResumable(resume, tariff, used);
+
   useEffect(() => {
     if (
-      !resume ||
-      resume.tariff !== tariffId ||
+      !resumable ||
+      resumable.tariff !== tariffId ||
       !authenticated ||
       !tariff
     ) {
       return;
     }
-    const key = `${resume.tariff}:${resume.price ?? 'trial'}`;
+    const key = `${resumable.tariff}:${resumable.price ?? 'trial'}`;
     if (opened.current === key) {
       return;
     }
     opened.current = key;
-    choose(resume);
-  }, [resume?.tariff, resume?.price, authenticated, tariff]);
+    choose(resumable);
+  }, [resumable?.tariff, resumable?.price, authenticated, tariff]);
 
   return (
     <section

package/templates/components/orionplace/subscriptions/StorefrontTariffs.README.md

@@ -27,6 +27,12 @@ required refresh fails, another purchase remains blocked and Refresh repeats
 both reads. Repeating the already confirmed request is ignored; a different
 plan can still be purchased.
 
+For a signed-in customer the component also reads `subscriptions_get` once
+through `onLoadSubscriptions`: plans of a subscription the customer already
+had offer no trial, and a resumed trial opens only after that read, for a
+customer new to the subscription. A failed read leaves the trial shown; the
+backend still refuses a repeated trial.
+
 The component makes requests only through those callbacks. Source is
 maintained in
 `components/orionplace/subscriptions/StorefrontTariffs.tsx`; the response
@@ -78,6 +84,13 @@ contract is `interfaces/orionplace/subscribes/ISubscriptionApi.ts`.
 обновления повторяет оба чтения. Повтор уже подтверждённого запроса
 игнорируется; другой тариф можно подключить.
 
+Для авторизованного покупателя компонент также один раз читает
+`subscriptions_get` через `onLoadSubscriptions`: тарифы подписки, которая у
+покупателя уже была, не предлагают пробный период, а восстановленный пробный
+выбор открывается только после этого чтения и только для нового покупателя
+подписки. При ошибке чтения пробный период остаётся видимым; повторный пробный
+период всё равно отклоняет сервер.
+
 Компонент отправляет запросы только через эти функции. Исходный файл:
 `components/orionplace/subscriptions/StorefrontTariffs.tsx`; контракт ответа:
 `interfaces/orionplace/subscribes/ISubscriptionApi.ts`.

package/templates/components/orionplace/subscriptions/StorefrontTariffs.tsx

@@ -7,7 +7,12 @@ import {
   useOrionplaceCatalogStore,
   useOrionplaceSelections,
 } from '@/providers/OrionplaceProvider';
-import { selectIsAuthenticated } from '@/stores/orionplace';
+import {
+  selectIsAuthenticated,
+  selectProfile,
+} from '@/stores/orionplace';
+import { selectUsedSubscriptions } from '@/stores/orionplaceCatalog';
+import { tariffResumable } from '@/lib/orionplace/tariffs';
 import type { ISubscriptionTariffsResponse } from '@/interfaces/orionplace/subscribes/ISubscriptionApi';
 import type { ITariffSelection } from '@/interfaces/orionplace/subscribeTariff/ITariffSelection';
 import {
@@ -69,6 +74,12 @@ export function StorefrontTariffs({
     (state) => state.tariffsSnapshot !== undefined,
   );
   const catalogStore            = useOrionplaceCatalogStore();
+  const profile                 = useOrionplace(
+    (state) => selectProfile(state)?.id,
+  );
+  const used                    = useOrionplaceCatalog(
+    selectUsedSubscriptions(profile),
+  );
   const locale                  = useOrionplaceSelections((state) => state.localeCode);
   const labels                  = subscriptionLabels(locale);
   const common                  = featureLabels(locale);
@@ -331,7 +342,13 @@ export function StorefrontTariffs({
             subscriptionId={group.id}
             tariffIds={ids}
             guest={!authenticated}
-            open={authenticated ? resume : undefined}
+            open={authenticated
+              ? tariffResumable(
+                resume,
+                resume && tariffs?.data.find((entry) => entry.id === resume.tariff),
+                used,
+              )
+              : undefined}
             disabled={busy || purchase.needsRefresh}
             pending={purchase.pending}
             suspended={purchase.needsRefresh}

package/templates/components/orionplace/tariffs/TariffCard.tsx

@@ -7,9 +7,12 @@ import {
   type ReactNode,
 } from 'react';
 import {
+  useOrionplace,
   useOrionplaceCatalog,
   useOrionplaceSelections,
 } from '@/providers/OrionplaceProvider';
+import { selectProfile } from '@/stores/orionplace';
+import { selectUsedSubscriptions } from '@/stores/orionplaceCatalog';
 import type { ISubscribeTariff } from '@/interfaces/orionplace/subscribeTariff/ISubscribeTariff';
 import type {
   ITariffSelection,
@@ -18,6 +21,7 @@ import type {
 import {
   tariffIsOpen,
   tariffSubscribeRequest,
+  tariffTrialOpen,
 } from '@/lib/orionplace/tariffs';
 import { tariffPageHref } from '@/lib/orionplace/tariffPage';
 import {
@@ -82,13 +86,16 @@ export function TariffCard({
 }: TariffCardProps) {
   const tariffs = useOrionplaceCatalog((state) => state.tariffs);
   const locale = useOrionplaceSelections((state) => state.localeCode);
+  const profile = useOrionplace((state) => selectProfile(state)?.id);
+  const used = useOrionplaceCatalog(selectUsedSubscriptions(profile));
   const tariff = tariffs?.data.find((entry) => entry.id === tariffId);
   const [selection, setSelection] = useState<ITariffSelection>();
   const [period, setPeriod] = useState<number>();
   const [option, setOption] = useState<number>();
   const opened = useRef('');
   const labels = tariffLabels(locale);
-  const trialBadge = tariff && tariff.trial_days > 0
+  // No trial badge for a customer who already had this subscription record.
+  const trialBadge = tariff && tariffTrialOpen(tariff, used)
     ? tariffText(labels.trialBadge, {
         days: tariffDays(tariff.trial_days, locale),
       })

package/templates/components/orionplace/tariffs/TariffCardPrices.README.md

@@ -7,7 +7,11 @@ currency from the isolated stores. Paid periods are ordered by duration. When
 several are available, choosing one calls `onPeriodChange(tariff_cost_id)`.
 `selectedPeriod` selects that period; a missing or unavailable value falls back
 to the shortest returned paid period. Each amount uses the selected currency's
-left and right symbols. A positive `trial_days` adds the trial action.
+left and right symbols. A positive `trial_days` adds the trial action, unless
+the signed-in customer already had the plan's subscription: the backend gives a
+trial once per subscription. Such a trial-only plan shows that note instead.
+The plan pages load the customer's records with `subscriptions_get` through
+`onLoadSubscriptions`; until they arrive, the trial stays shown.
 
 The plan and its parent subscription must both allow customer subscriptions.
 An administrator-only or closed plan shows its localized reason instead of
@@ -43,7 +47,11 @@ The component makes no requests. Source is maintained in
 `onPeriodChange(tariff_cost_id)`. `selectedPeriod` задаёт период; отсутствующее
 или недоступное значение заменяется самым коротким полученным платным периодом.
 Сумма использует левый и правый символы выбранной валюты. Положительное
-`trial_days` добавляет действие пробного периода.
+`trial_days` добавляет действие пробного периода, если у авторизованного
+покупателя ещё не было подписки этого тарифа: пробный период даётся один раз на
+подписку. Тариф только с пробным периодом тогда показывает это пояснение.
+Страницы тарифов загружают подписки покупателя через `subscriptions_get`
+(`onLoadSubscriptions`); до их получения пробный период показывается.
 
 Тариф и его родительская подписка должны разрешать самостоятельное
 подключение. Для закрытого тарифа или тарифа администратора вместо действий

package/templates/components/orionplace/tariffs/TariffCardPrices.tsx

@@ -2,9 +2,12 @@
 
 import { useId } from 'react';
 import {
+  useOrionplace,
   useOrionplaceCatalog,
   useOrionplaceSelections,
 } from '@/providers/OrionplaceProvider';
+import { selectProfile } from '@/stores/orionplace';
+import { selectUsedSubscriptions } from '@/stores/orionplaceCatalog';
 import type { ITariffSelection } from '@/interfaces/orionplace/subscribeTariff/ITariffSelection';
 import { getAvailableNestedValueFromObject } from '@/lib/orionplace/presentation';
 import {
@@ -13,6 +16,7 @@ import {
   tariffMoney,
   tariffPaidPeriods,
   tariffReturnPath,
+  tariffTrialOpen,
 } from '@/lib/orionplace/tariffs';
 import {
   tariffDays,
@@ -45,6 +49,8 @@ export function TariffCardPrices({
   onRequireSignIn,
 }: TariffCardPricesProps) {
   const tariffs = useOrionplaceCatalog((state) => state.tariffs);
+  const profile = useOrionplace((state) => selectProfile(state)?.id);
+  const used = useOrionplaceCatalog(selectUsedSubscriptions(profile));
   const locale = useOrionplaceSelections((state) => state.localeCode);
   const currencyId = useOrionplaceSelections((state) => state.currencyId);
   const currency = useOrionplaceSelections(
@@ -73,7 +79,9 @@ export function TariffCardPrices({
   }));
   const selected = paidPeriods.find((entry) => entry.price === selectedPeriod) ??
     paidPeriods[0];
-  const trialDuration = tariff.trial_days > 0
+  // A customer who already had this subscription record gets no trial.
+  const trialUsed = tariff.trial_days > 0 && !tariffTrialOpen(tariff, used);
+  const trialDuration = tariff.trial_days > 0 && !trialUsed
     ? duration(tariff.trial_days)
     : '';
   const name = getAvailableNestedValueFromObject(
@@ -87,7 +95,9 @@ export function TariffCardPrices({
       ? labels.closed
       : selected || trialDuration
         ? ''
-        : labels.noPeriods;
+        : trialUsed
+          ? labels.trialUsed
+          : labels.noPeriods;
 
   function choose(price: number | null) {
     if (disabled || availability !== 'open') {

package/templates/hooks/useOrionplaceTariffPurchase.ts

@@ -5,6 +5,16 @@ import type { IProfileResponse } from '@/interfaces/orionplace/accounts/IProfile
 import type { ITariffSubscribeRequest } from '@/interfaces/orionplace/subscribeTariff/ITariffSelection';
 import type { ICustomerSubscriptionsResponse } from '@/interfaces/orionplace/subscribes/ISubscriptionApi';
 import { apiErrorMessage } from '@/lib/orionplace/api';
+import { tariffUsedSubscriptions } from '@/lib/orionplace/tariffs';
+import {
+  useOrionplace,
+  useOrionplaceCatalogStore,
+} from '@/providers/OrionplaceProvider';
+import {
+  selectIsAuthenticated,
+  selectProfile,
+} from '@/stores/orionplace';
+import { selectUsedSubscriptions } from '@/stores/orionplaceCatalog';
 
 type SubscriptionsPage = NonNullable<
   ICustomerSubscriptionsResponse['page_data']
@@ -55,13 +65,28 @@ export function useOrionplaceTariffPurchase(
   const [error, setError] = useState('');
   const [completed, setCompleted] = useState(false);
   const [needsRefresh, setNeedsRefresh] = useState(false);
+  const catalogStore = useOrionplaceCatalogStore();
+  const authenticated = useOrionplace(selectIsAuthenticated);
+  const profileId = useOrionplace((state) => selectProfile(state)?.id);
+
+  function rememberUsed(owner: number | undefined, page: SubscriptionsPage) {
+    if (owner !== undefined) {
+      catalogStore
+        .getState()
+        .setUsedSubscriptions(owner, tariffUsedSubscriptions(page));
+    }
+  }
 
   async function loadAccount(controller: AbortController) {
+    const owner = profileId;
     const subscriptions = await callbacks.current.onLoadSubscriptions({
       endpoint: 'subscriptions_get',
       request: {},
       signal: controller.signal,
     });
+    if (!controller.signal.aborted) {
+      rememberUsed(owner, subscriptions);
+    }
     const profile = await callbacks.current.onLoadProfile({
       endpoint: 'profile_get',
       request: { filters: {} },
@@ -138,6 +163,41 @@ export function useOrionplaceTariffPurchase(
     }
   }
 
+  /*
+   * The plan pages hide the trial of a subscription record the customer
+   * already had (the backend refuses it). They read the records once per
+   * profile; a failed read leaves the trial shown, as for an unknown customer.
+   */
+  useEffect(() => {
+    if (
+      !authenticated ||
+      profileId === undefined ||
+      selectUsedSubscriptions(profileId)(catalogStore.getState())
+    ) {
+      return;
+    }
+    const controller = new AbortController();
+    Promise.resolve(
+      callbacks.current.onLoadSubscriptions({
+        endpoint: 'subscriptions_get',
+        request: {},
+        signal: controller.signal,
+      }),
+    ).then(
+      (page) => {
+        if (!controller.signal.aborted) {
+          rememberUsed(profileId, page);
+        }
+      },
+      () => {
+        if (!controller.signal.aborted) {
+          catalogStore.getState().setUsedSubscriptions(profileId, []);
+        }
+      },
+    );
+    return () => controller.abort();
+  }, [authenticated, profileId, catalogStore]);
+
   useEffect(() => () => active.current?.abort(), []);
 
   return {

package/templates/lib/orionplace/tariffLabels.ts

@@ -9,6 +9,7 @@ const labels = {
     adminOnly:
       'This plan is assigned by the store administrator. It cannot be subscribed to online.',
     closed: 'New subscriptions to this plan are closed.',
+    trialUsed: 'You have already used the trial of this subscription.',
     subscribe: 'Subscribe',
     tryTrial: 'Try',
     perPeriod: 'for {days}',
@@ -56,6 +57,7 @@ const labels = {
     adminOnly:
       'Этот тариф подключает администратор магазина. Самостоятельное подключение недоступно.',
     closed: 'Новые подключения к этому тарифу закрыты.',
+    trialUsed: 'Пробный период этой подписки вы уже использовали.',
     subscribe: 'Подключить',
     tryTrial: 'Попробовать',
     perPeriod: 'за {days}',

package/templates/lib/orionplace/tariffs.ts

@@ -133,6 +133,55 @@ export function tariffSubscribeRequest(
   };
 }
 
+/**
+ * The subscription records the customer already had a period of, paid or
+ * trial, read from the `subscriptions_get` response. The backend gives a trial
+ * only to a customer new to the record, so the plans of these records offer
+ * none.
+ */
+export function tariffUsedSubscriptions(page: {
+  data: { subscription: number | null; tariff: number | null }[];
+  tariffs: { id: number; subscription: number }[];
+}) {
+  const ids = page.data.map(
+    (item) =>
+      item.subscription ??
+      page.tariffs.find((tariff) => tariff.id === item.tariff)?.subscription,
+  );
+
+  return [...new Set(ids.filter((id): id is number => typeof id === 'number'))];
+}
+
+/**
+ * Whether the plan offers its trial: it has trial days and the customer is
+ * not known to have had its subscription record (`used`, see
+ * `tariffUsedSubscriptions`). A guest and a customer whose records are not
+ * loaded yet see the trial; the backend refuses it to a returning customer.
+ */
+export function tariffTrialOpen(
+  tariff: ISubscribeTariff,
+  used: readonly number[] = [],
+) {
+  return tariff.trial_days > 0 && !used.includes(tariff.subscription);
+}
+
+/**
+ * The plan choice to open again after sign-in: a paid period as it is, a
+ * trial only once the customer's records are loaded (`used`) and the
+ * customer is new to the record.
+ */
+export function tariffResumable(
+  selection: ITariffSelection | undefined,
+  tariff: ISubscribeTariff | undefined,
+  used: readonly number[] | undefined,
+) {
+  if (!selection || selection.price !== null) {
+    return selection;
+  }
+
+  return tariff && used && tariffTrialOpen(tariff, used) ? selection : undefined;
+}
+
 export interface TariffFeature {
   key: string;
   label: string;

package/templates/stores/orionplaceCatalog.ts

@@ -23,9 +23,16 @@ export interface OrionplaceCatalogState {
   tariffs: IAppLoadCommon['tariffs'] | null;
   /** Every plan the storefront sells; the subscriptions page reads it. */
   storeTariffs: IAppLoadCommon['tariffs'] | null;
+  /**
+   * The subscription records the signed-in customer already had, for the
+   * profile that loaded them (see `tariffUsedSubscriptions`). A new
+   * Application Load keeps them; another profile ignores them.
+   */
+  usedSubscriptions?: { profile: number; ids: number[] };
   setCatalogTree: (tree: CatalogTree) => void;
   setTariffs: (tariffs: Tariffs) => void;
   setStoreTariffs: (tariffs: Tariffs) => void;
+  setUsedSubscriptions: (profile: number, ids: number[]) => void;
   getTariff: (id: number) => Tariffs['data'][number] | undefined;
   getCatalogCategory: (id: number) => ICategory | undefined;
   getCatalogProducts: (
@@ -81,6 +88,10 @@ export function createOrionplaceCatalogStore(
       });
     },
 
+    setUsedSubscriptions(profile, ids) {
+      set({ usedSubscriptions: { profile, ids } });
+    },
+
     getTariff(id) {
       return get().tariffs?.data.find((tariff) => tariff.id === id);
     },
@@ -131,6 +142,13 @@ export function createOrionplaceCatalogStore(
   }));
 }
 
+/** The records a profile had; undefined until they are loaded. */
+export const selectUsedSubscriptions =
+  (profile: number | undefined) => (state: OrionplaceCatalogState) =>
+    state.usedSubscriptions && state.usedSubscriptions.profile === profile
+      ? state.usedSubscriptions.ids
+      : undefined;
+
 export const selectCatalogRoots = (state: OrionplaceCatalogState) =>
   navigationCatalogCategories(state.catalog);