@coraltravelcenter/b2c-landing-builder 2.6.2 → 2.7.0

package/README.md

@@ -22,6 +22,7 @@ b2c-landing-vite check
 b2c-landing-vite dev
 b2c-landing-vite build
 b2c-landing-vite deploy
+b2c-landing-vite deploy --dry-run
 b2c-landing-vite deploy --update
 b2c-landing-vite deploy --assets-only
 b2c-landing-vite block:add hero
@@ -40,6 +41,10 @@ b2c-landing-vite update
 - `deploy` при первом запуске предлагает выбрать application, layout и HTML-зону,
   создаёт CMS-страницу и размещает блоки в порядке `order.json`. При повторном
   запуске для опубликованной страницы создаётся checkout-версия.
+- `deploy --dry-run` выполняет свежую локальную сборку, читает состояние CMS и
+  показывает точный план загрузки ассетов, создания версии и изменений виджетов.
+  Страница, виджеты, ассеты и локальный deploy-state при этом не изменяются.
+- `deploy --assets-only --dry-run` показывает только план синхронизации ассетов.
 - `deploy --update` обновляет сохранённую версию страницы без создания новой.
 - `block:add` создаёт файлы в выбранных форматах разметки и стилей.
 - `block:rename` атомарно переименовывает все файлы блока и обновляет порядок.

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@coraltravelcenter/b2c-landing-builder",
-  "version": "2.6.2",
+  "version": "2.7.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@coraltravelcenter/b2c-landing-builder",
-      "version": "2.6.2",
+      "version": "2.7.0",
       "license": "MIT",
       "dependencies": {
         "@clack/prompts": "1.7.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coraltravelcenter/b2c-landing-builder",
-  "version": "2.6.2",
+  "version": "2.7.0",
   "description": "CLI and build toolkit for B2C landing projects",
   "type": "module",
   "bin": {

package/src/cli/index.mjs

@@ -8,6 +8,7 @@ Commands:
   dev                       Start the Vite development server
   build                     Build CMS-ready HTML files
   deploy                    Build, sync assets, and deploy CMS widgets
+  deploy --dry-run          Show the exact deploy plan without changing CMS
   deploy --update           Update the current CMS version in place
   deploy --assets-only      Build and sync assets with the B2C CDN
   check                     Validate project configuration
@@ -77,9 +78,11 @@ export async function runCli(args) {
     return;
   }
   if (command === "deploy") {
-    const allowed = new Set(["--assets-only", "--update"]);
-    if (rest.some((argument) => !allowed.has(argument)) || rest.length > 1) {
-      throw new Error("Usage: b2c-landing-vite deploy [--assets-only | --update]");
+    const allowed = new Set(["--assets-only", "--update", "--dry-run"]);
+    const flags = new Set(rest);
+    if (rest.some((argument) => !allowed.has(argument)) || flags.size !== rest.length ||
+      (flags.has("--assets-only") && flags.has("--update"))) {
+      throw new Error("Usage: b2c-landing-vite deploy [--assets-only | --update] [--dry-run]");
     }
     const config = await loadConfig();
     validateProject(config);
@@ -87,7 +90,16 @@ export async function runCli(args) {
     await runCli(["build"]);
     const {getBackofficeToken} = await import("../deploy/auth.mjs");
     const token = await getBackofficeToken({brand: preset.id});
-    const {deployAssetsOnly, deployProject} = await import("../deploy/deploy.mjs");
+    const {deployAssetsOnly, deployProject, planDeployment} = await import("../deploy/deploy.mjs");
+    if (flags.has("--dry-run")) {
+      return planDeployment({
+        config,
+        preset,
+        token,
+        update: flags.has("--update"),
+        assetsOnly: flags.has("--assets-only"),
+      });
+    }
     if (rest.includes("--assets-only")) return deployAssetsOnly({config, preset, token});
     return deployProject({config, preset, token, update: rest.includes("--update")});
   }

package/src/deploy/assets.mjs

@@ -4,22 +4,57 @@ export function changedAssets(manifest, state) {
   return manifest.assets.filter((asset) => state.assets?.[asset.path]?.sha256 !== asset.sha256);
 }
 
+function filesFromListing(listing) {
+  const files = Array.isArray(listing) ? listing : listing?.files || [];
+  return new Set(files.map((file) => typeof file === "string" ? path.posix.basename(file) : file.name));
+}
+
+export async function planAssetChanges({manifest, state, listFiles, remoteRoot = "/content"}) {
+  const pending = changedAssets(manifest, state);
+  if (!listFiles) {
+    return {upload: pending, skip: [], unchanged: manifest.assets.length - pending.length};
+  }
+  const directories = new Map();
+  const namesInDirectory = (directory) => {
+    if (!directories.has(directory)) {
+      directories.set(directory, Promise.resolve(listFiles(directory)).then(filesFromListing));
+    }
+    return directories.get(directory);
+  };
+  const upload = [];
+  const skip = [];
+  await Promise.all(pending.map(async (asset) => {
+    const remotePath = path.posix.join("/", remoteRoot, manifest.assetsPrefix, asset.path);
+    const names = await namesInDirectory(path.posix.dirname(remotePath));
+    (names.has(path.posix.basename(remotePath)) ? skip : upload).push(asset);
+  }));
+  const byPath = (left, right) => left.path.localeCompare(right.path);
+  return {
+    upload: upload.sort(byPath),
+    skip: skip.sort(byPath),
+    unchanged: manifest.assets.length - pending.length,
+  };
+}
+
 export async function uploadChangedAssets({
   manifest,
   state,
   root = process.cwd(),
   uploadFile,
+  listFiles,
   remoteRoot = "/content",
   concurrency = 5,
 }) {
-  const pending = changedAssets(manifest, state);
+  const plan = await planAssetChanges({manifest, state, listFiles, remoteRoot});
   const assets = {...state.assets};
   const uploaded = [];
+  const skipped = plan.skip.map((asset) => asset.path);
+  for (const asset of plan.skip) assets[asset.path] = {...asset, immutable: true};
   let cursor = 0;
 
   async function worker() {
-    while (cursor < pending.length) {
-      const asset = pending[cursor++];
+    while (cursor < plan.upload.length) {
+      const asset = plan.upload[cursor++];
       const localPath = path.join(root, ...(manifest.assetsDirectory || "public").split("/"), ...asset.path.split("/"));
       const remotePath = path.posix.join("/", remoteRoot, manifest.assetsPrefix, asset.path);
       const result = await uploadFile(remotePath, localPath);
@@ -28,11 +63,12 @@ export async function uploadChangedAssets({
     }
   }
 
-  const workerCount = Math.min(Math.max(1, concurrency), pending.length || 1);
+  const workerCount = Math.min(Math.max(1, concurrency), plan.upload.length || 1);
   await Promise.all(Array.from({length: workerCount}, () => worker()));
   return {
     state: {...state, assets},
     uploaded: uploaded.sort(),
-    unchanged: manifest.assets.length - pending.length,
+    skipped: skipped.sort(),
+    unchanged: plan.unchanged,
   };
 }

package/src/deploy/backoffice-client.mjs

@@ -100,10 +100,17 @@ export class BackofficeClient {
     return this.request("PUT", "/Content/UpdateDocumentStatus", {body: {pageContentId, documentStatus}});
   }
 
+  async listFiles(remoteDirectory) {
+    const result = await this.request("GET", "/FileManagement/ListFiles", {
+      query: {path: remoteDirectory.replace(/^\/+/, "")},
+    });
+    return result?.result || result;
+  }
+
   async uploadFile(remotePath, localPath) {
     const parsed = path.posix.parse(remotePath);
     const form = new FormData();
-    form.append("Body.OverWrite", "true");
+    form.append("Body.OverWrite", "false");
     form.append("Body.Path", parsed.dir.replace(/^\/+/, ""));
     form.append("Body.Files", new Blob([fs.readFileSync(localPath)]), parsed.base);
     const result = await this.request("POST", "/FileManagement/UploadFile", {form});

package/src/deploy/deploy.mjs

@@ -1,9 +1,68 @@
-import {uploadChangedAssets} from "./assets.mjs";
+import {planAssetChanges, uploadChangedAssets} from "./assets.mjs";
 import {BackofficeClient} from "./backoffice-client.mjs";
 import {readBuildManifest} from "./manifest.mjs";
 import {readDeploymentState, writeDeploymentState} from "./state.mjs";
-import {createPagePlacement, prepareExistingPage} from "./page.mjs";
-import {syncWidgets} from "./widgets.mjs";
+import {createPagePlacement, prepareExistingPage, selectNewPagePlacement} from "./page.mjs";
+import {planWidgetChanges, syncWidgets} from "./widgets.mjs";
+
+function paths(items) {
+  return items.map((item) => item.path);
+}
+
+function logList(log, label, items) {
+  log(`[dry-run] ${label}: ${items.length ? items.join(", ") : "none"}`);
+}
+
+export async function planDeployment({
+  config,
+  preset,
+  root = process.cwd(),
+  token,
+  client,
+  update = false,
+  assetsOnly = false,
+  prompts,
+  log = console.log,
+}) {
+  const manifest = readBuildManifest(root);
+  const api = client || new BackofficeClient({brand: preset.id, token});
+  const previous = readDeploymentState(preset.id, manifest.folder, root);
+  const assets = await planAssetChanges({
+    manifest,
+    state: previous,
+    remoteRoot: new URL(preset.assetsBase).pathname,
+    listFiles: api.listFiles?.bind(api),
+  });
+  log(`[dry-run] no CMS data will be changed`);
+  log(`[dry-run] target: ${preset.assetsBase}/${manifest.assetsPrefix}/`);
+  logList(log, "assets to upload", paths(assets.upload));
+  logList(log, "existing assets to skip", paths(assets.skip));
+  log(`[dry-run] unchanged assets: ${assets.unchanged}`);
+  if (assetsOnly) return {assets};
+
+  let placement;
+  let pageContent;
+  let page;
+  if (previous.placement) {
+    placement = previous.placement;
+    pageContent = await api.getContent(placement.pageContentId);
+    const checkout = !update && [1, 4].includes(pageContent.status);
+    page = {action: checkout ? "create checkout version" : "update current version", pageContentId: placement.pageContentId};
+  } else {
+    const selected = await selectNewPagePlacement({client: api, manifest, prompts});
+    placement = selected.placement;
+    pageContent = {pageContents: []};
+    page = {action: "create page", ...selected.draft};
+  }
+  const widgets = planWidgetChanges({manifest, placement, pageContent, root});
+  log(`[dry-run] page: ${page.action}${page.pageName ? ` “${page.pageName}”` : ""}`);
+  log(`[dry-run] area: ${placement.layoutAreaId}, insertion position: ${Math.max(0, placement.orderIndex) + 1}`);
+  logList(log, "widgets to add", widgets.add);
+  logList(log, "widgets to update", widgets.update);
+  logList(log, "widgets to remove", widgets.remove);
+  logList(log, "widgets to reorder", widgets.reorder.map((item) => `${item.title} (${item.from} → ${item.to})`));
+  return {assets, page, placement, widgets};
+}
 
 export async function deployAssetsOnly({
   config,
@@ -30,9 +89,13 @@ export async function deployAssetsOnly({
     root,
     remoteRoot: new URL(preset.assetsBase).pathname,
     uploadFile: api.uploadFile.bind(api),
+    listFiles: api.listFiles?.bind(api),
   });
   writeDeploymentState(preset.id, manifest.folder, result.state, root);
-  log(`[deploy] assets: uploaded=${result.uploaded.length}, unchanged=${result.unchanged}`);
+  log(`[deploy] assets: uploaded=${result.uploaded.length}, skipped=${result.skipped.length}, unchanged=${result.unchanged}`);
+  if (result.skipped.length) {
+    log(`[deploy] existing assets were not overwritten: ${result.skipped.join(", ")}. Rename changed files to publish new URLs.`);
+  }
   return {...result, target: String(cdnUrl)};
 }
 
@@ -56,6 +119,7 @@ export async function deployProject({
     root,
     remoteRoot: new URL(preset.assetsBase).pathname,
     uploadFile: api.uploadFile.bind(api),
+    listFiles: api.listFiles?.bind(api),
   });
   const page = previous.placement
     ? await prepareExistingPage({client: api, placement: previous.placement, update})
@@ -72,7 +136,10 @@ export async function deployProject({
   const preview = page.pageContent.uniqueId
     ? `https://${preset.domain}/preview/${page.pageContent.uniqueId}/`
     : null;
-  log(`[deploy] assets: uploaded=${assets.uploaded.length}, unchanged=${assets.unchanged}`);
+  log(`[deploy] assets: uploaded=${assets.uploaded.length}, skipped=${assets.skipped.length}, unchanged=${assets.unchanged}`);
+  if (assets.skipped.length) {
+    log(`[deploy] existing assets were not overwritten: ${assets.skipped.join(", ")}. Rename changed files to publish new URLs.`);
+  }
   log(`[deploy] widgets: added=${widgets.added}, updated=${widgets.updated}, removed=${widgets.removed}`);
   if (preview) log(`[deploy] preview: ${preview}`);
   return {assets, widgets, placement: page.placement, preview};

package/src/deploy/page.mjs

@@ -37,7 +37,7 @@ async function defaultPrompts() {
   };
 }
 
-export async function createPagePlacement({client, manifest, prompts}) {
+export async function selectNewPagePlacement({client, manifest, prompts}) {
   prompts ||= await defaultPrompts();
   const pageName = await prompts.text({
     message: "New CMS page name",
@@ -88,11 +88,24 @@ export async function createPagePlacement({client, manifest, prompts}) {
       value: index,
     })),
   });
-  const created = await client.createPage({applicationId, layoutId, name: pageName.trim()});
+  return {
+    draft: {applicationId, layoutId, pageName: pageName.trim()},
+    placement: {pageContentId: null, layoutAreaId, orderIndex},
+  };
+}
+
+export async function createPagePlacement(options) {
+  const selected = await selectNewPagePlacement(options);
+  const {client} = options;
+  const created = await client.createPage({
+    applicationId: selected.draft.applicationId,
+    layoutId: selected.draft.layoutId,
+    name: selected.draft.pageName,
+  });
   if (!created?.pageContentId) throw new Error("Backoffice did not return pageContentId for the new page");
   return {
     pageContent: await client.getContent(created.pageContentId),
-    placement: {pageContentId: created.pageContentId, layoutAreaId, orderIndex},
+    placement: {...selected.placement, pageContentId: created.pageContentId},
   };
 }
 

package/src/deploy/widgets.mjs

@@ -23,6 +23,24 @@ function widgetsForPlacement(pageContent, layoutAreaId, folder) {
   );
 }
 
+export function planWidgetChanges({manifest, placement, pageContent, root = process.cwd()}) {
+  const bundles = readDeployBundles(manifest, root);
+  const existing = widgetsForPlacement(pageContent || {}, placement.layoutAreaId, manifest.folder);
+  const bundleTitles = new Set(bundles.map((bundle) => bundle.title));
+  return {
+    add: bundles.filter((bundle) => !existing.some((widget) => widget.cmsTitle === bundle.title))
+      .map((bundle) => bundle.title),
+    update: bundles.filter((bundle) => existing.some((widget) => widget.cmsTitle === bundle.title))
+      .map((bundle) => bundle.title),
+    reorder: bundles.flatMap((bundle, index) => {
+      const widget = existing.find((candidate) => candidate.cmsTitle === bundle.title);
+      const to = Math.max(0, placement.orderIndex) + 1 + index;
+      return widget && widget.order !== to ? [{title: bundle.title, from: widget.order, to}] : [];
+    }),
+    remove: existing.filter((widget) => !bundleTitles.has(widget.cmsTitle)).map((widget) => widget.cmsTitle),
+  };
+}
+
 export async function syncWidgets({client, manifest, placement, pageContent, root = process.cwd()}) {
   const bundles = readDeployBundles(manifest, root);
   const existing = widgetsForPlacement(pageContent, placement.layoutAreaId, manifest.folder);