Merge pull request #245 from mi-examples/feat/variables-editor-import-values

Variables Editor: import values from another page

Author: sergak01

package-lock.json

@@ -3,6 +3,7 @@ import { BaseAPI } from './base.js';
 import { unavailablePageDataError } from './unavailable-json-api.js';
 
 export interface Page {
+  id: number;
   name: string;
   enabled: 'Y' | 'N';
   visible_in_homepage: 'Y' | 'N';
@@ -62,7 +63,7 @@ export class PageAPI extends BaseAPI {
     ).data;
   }
 
-  async create(page: Page, headers?: Headers) {
+  async create(page: Omit<Page, 'id'>, headers?: Headers) {
     return (
       await this.axios.post<{ page: Page }>('/api/page', page, {
         withCredentials: true,

src/api/page.ts

@@ -304,3 +304,96 @@ export function buildPageVariablesExport(
   }));
 }
 
+export interface ImportCandidate {
+  name: string;
+  sourceValue: string;
+  tagType: string;
+}
+
+export interface ImportSkip {
+  name: string;
+  sourceValue: string;
+  reason: string;
+}
+
+export interface PageVariablesImportPlan {
+  importable: ImportCandidate[];
+  skipped: ImportSkip[];
+}
+
+/**
+ * Whether `value` can structurally apply to `tag`'s type — a hard yes/no, unlike
+ * `validateValueAgainstTag()`'s always-a-warning checks. Deliberately skips select/multiselect's
+ * declared-option check: two pages can legitimately point a same-named select at different
+ * datasets/sources, so an option-list mismatch doesn't mean the value can't apply.
+ */
+function typeCompatibilityIssue(tag: TemplateVariableTag, value: string): string | null {
+  switch (tag.tag_type) {
+    case 'boolean':
+      return BOOLEAN_ALLOWED_VALUES.includes(value)
+        ? null
+        : `Not a recognized boolean value ("${value}").`;
+
+    case 'color':
+      return value === '' || COLOR_PATTERN.test(value) ? null : `Not a recognized color value ("${value}").`;
+
+    case 'list': {
+      if (value === '') {
+        return null;
+      }
+
+      try {
+        const parsed = JSON.parse(value);
+
+        return parsed === null || Array.isArray(parsed) ? null : 'Value is valid JSON but not an array.';
+      } catch {
+        return 'Value is not valid JSON.';
+      }
+    }
+
+    default:
+      return null;
+  }
+}
+
+/**
+ * Plans an import of `sourceValues` (another page's live variable values) into the current
+ * page's schema: matches by variable name first (anything unmatched is skipped outright), then
+ * checks the matched value against the target tag's type. Nothing here writes anything — the
+ * caller decides what to actually apply.
+ */
+export function planPageVariablesImport(
+  schema: TemplateVariablesSchema | null,
+  sourceValues: PageVariableEntry[],
+): PageVariablesImportPlan {
+  const schemaMap = new Map<string, TemplateVariableTag>((schema?.tags ?? []).map((tag) => [tag.name, tag]));
+  const importable: ImportCandidate[] = [];
+  const skipped: ImportSkip[] = [];
+
+  for (const entry of sourceValues) {
+    const tag = schemaMap.get(entry.name);
+
+    if (!tag) {
+      skipped.push({
+        name: entry.name,
+        sourceValue: entry.value,
+        reason: "Not in the current page's schema.",
+      });
+
+      continue;
+    }
+
+    const issue = typeCompatibilityIssue(tag, entry.value);
+
+    if (issue) {
+      skipped.push({ name: entry.name, sourceValue: entry.value, reason: issue });
+
+      continue;
+    }
+
+    importable.push({ name: entry.name, sourceValue: entry.value, tagType: tag.tag_type || 'text' });
+  }
+
+  return { importable, skipped };
+}
+

src/lib/page-variables-diff.ts

@@ -2,7 +2,7 @@ import axios, { Axios } from 'axios';
 import http from 'node:http';
 import https from 'node:https';
 import { JSDOM } from 'jsdom';
-import { AssetsAPI, PageAPI, AssetsV7API, PageTemplateAPI, PageVariableAPI, PageVariableTagEntry } from '../api/index.js';
+import { AssetsAPI, Page, PageAPI, AssetsV7API, PageTemplateAPI, PageVariableAPI, PageVariableTagEntry } from '../api/index.js';
 import { isUnavailableJsonApiError } from '../api/unavailable-json-api.js';
 import { createLogger } from './logger.js';
 import { colors, getTokenErrorInfo, logTokenError } from './helpers/index.js';
@@ -444,6 +444,28 @@ export class MiAPI {
     );
   }
 
+  /**
+   * List every portal page (`/api/page`) — used by the Variables Editor's "import values from
+   * another page" picker to offer candidate source pages.
+   *
+   * @param headers
+   */
+  async listPages(headers: Headers = this.#headers): Promise<Page[]> {
+    return this.pageApi.getAll(this.#clearHeaders(headers));
+  }
+
+  /**
+   * Get another page's live variable values via `/api/page_variable`, by numeric page id.
+   * Unlike `getLivePageVariables()`, this deliberately does not touch `this.appId` — it's for
+   * reading a *different* page's values (e.g. to import from), not the current page's.
+   *
+   * @param pageId
+   * @param headers
+   */
+  async getPageVariablesFor(pageId: number, headers: Headers = this.#headers): Promise<PageVariableTagEntry[]> {
+    return this.pageVariableApi.getById(pageId, this.#clearHeaders(headers));
+  }
+
   /** Whether this page has no associated template — no `__template_variables.json`, no page variables. */
   get isTemplateLess(): boolean {
     return !!this.templateLess;