@tandem-language-exchange/content-store 1.2.23 → 1.3.0

package/dist/{chunk-NQHWG4XM.js → chunk-ZX5KC4F5.js}

@@ -1,54 +1,471 @@
 #!/usr/bin/env node
 import {
   config
-} from "./chunk-Y6HC4NYU.js";
+} from "./chunk-OCAIIQZW.js";
 import {
   ContentStore,
   buildCmsObjectKey,
   buildTranslationObjectKey,
   contentTypeForTranslationKey
-} from "./chunk-LZHYKLAU.js";
+} from "./chunk-VBJ6LVMY.js";
 import {
   allProjects,
   defaultLocales
-} from "./chunk-SF7FCBR2.js";
+} from "./chunk-RZLDRXNQ.js";
+
+// src/server/adapters/azure/types.ts
+var AZURE_DEVOPS_PROJECT_KEYS = [
+  "web-site",
+  "web-app",
+  "web-invites"
+];
+
+// src/server/adapters/azure/client.ts
+var AzureDevOpsClient = class {
+  constructor(config3) {
+    this.config = config3;
+    const org = config3.organization.replace(/^\/+|\/+$/g, "");
+    const project = encodeURIComponent(config3.project);
+    this.baseUrl = `https://dev.azure.com/${org}/${project}`;
+  }
+  baseUrl;
+  /**
+   * Call any Azure DevOps REST endpoint under the configured organization and project.
+   */
+  async request(options) {
+    const {
+      method = "GET",
+      path,
+      query = {},
+      body,
+      apiVersion = this.config.apiVersion,
+      headers: extraHeaders = {}
+    } = options;
+    if (!this.config.pat) {
+      throw new Error(
+        "Azure DevOps is not configured (set AZURE_DEVOPS_ACCESS_TOKEN)"
+      );
+    }
+    const url = this.buildUrl(path, { ...query, "api-version": apiVersion });
+    const headers = {
+      Authorization: this.basicAuthHeader(),
+      Accept: "application/json",
+      ...extraHeaders
+    };
+    const init = { method, headers };
+    if (body !== void 0) {
+      headers["Content-Type"] = "application/json";
+      init.body = JSON.stringify(body);
+    }
+    const response = await fetch(url, init);
+    const text = await response.text();
+    let parsed;
+    if (text) {
+      try {
+        parsed = JSON.parse(text);
+      } catch {
+        parsed = text;
+      }
+    }
+    if (!response.ok) {
+      const errBody = parsed;
+      const detail = errBody?.message ?? (typeof parsed === "string" ? parsed : JSON.stringify(parsed));
+      throw new Error(
+        `Azure DevOps ${method} ${path} failed (${response.status}): ${detail}`
+      );
+    }
+    return parsed;
+  }
+  buildUrl(path, query) {
+    const base = /^https?:\/\//i.test(path) ? path : `${this.baseUrl}${path}`;
+    const url = new URL(base);
+    for (const [key, value] of Object.entries(query)) {
+      if (value !== void 0) {
+        url.searchParams.set(key, String(value));
+      }
+    }
+    return url.toString();
+  }
+  basicAuthHeader() {
+    const encoded = Buffer.from(`:${this.config.pat}`).toString("base64");
+    return `Basic ${encoded}`;
+  }
+};
+function createAzureDevOpsClient(config3) {
+  return new AzureDevOpsClient(config3);
+}
+
+// src/server/adapters/azure/pipelines.ts
+function isAzureDevOpsProjectKey(value) {
+  return AZURE_DEVOPS_PROJECT_KEYS.includes(value);
+}
+function resolveProjectConfig(azureConfig, project) {
+  const projectConfig = azureConfig.projects[project];
+  if (!projectConfig) {
+    throw new Error(`Unknown Azure DevOps project "${project}"`);
+  }
+  return projectConfig;
+}
+async function triggerPipelineBuild(azureConfig, project, variables = {}) {
+  const { pipeline } = resolveProjectConfig(azureConfig, project);
+  if (!pipeline?.id) {
+    throw new Error(
+      `No pipeline id configured for project "${project}" (instance ENVIRONMENT=${azureConfig.instanceEnvironment}, Azure=${azureConfig.pipelineEnvironment})`
+    );
+  }
+  const client = createAzureDevOpsClient({
+    organization: azureConfig.organization,
+    project,
+    pat: azureConfig.pat,
+    apiVersion: azureConfig.apiVersion
+  });
+  const run = await client.request({
+    method: "POST",
+    path: `/_apis/pipelines/${pipeline.id}/runs`,
+    body: {
+      resources: {
+        repositories: {
+          self: {
+            refName: pipeline.refName
+          }
+        }
+      },
+      variables
+    }
+  });
+  return {
+    project,
+    instanceEnvironment: azureConfig.instanceEnvironment,
+    pipelineEnvironment: azureConfig.pipelineEnvironment,
+    pipelineId: pipeline.id,
+    refName: pipeline.refName,
+    run
+  };
+}
+function formatPipelineRunSummary(result) {
+  const {
+    run,
+    project,
+    instanceEnvironment,
+    pipelineEnvironment,
+    pipelineId,
+    refName
+  } = result;
+  const webUrl = run._links?.web?.href ?? run.url;
+  const envLabel = instanceEnvironment === pipelineEnvironment ? `\`${pipelineEnvironment}\`` : `\`${instanceEnvironment}\` \u2192 Azure \`${pipelineEnvironment}\``;
+  const lines = [
+    `Environment ${envLabel} \u2014 project \`${project}\`, pipeline id \`${pipelineId}\`, ref \`${refName}\``,
+    `Run #${run.id}${run.state ? ` \u2014 state: \`${run.state}\`` : ""}`
+  ];
+  if (webUrl) {
+    lines.push(`<${webUrl}|Open run in Azure DevOps>`);
+  }
+  return lines.join("\n");
+}
+
+// src/server/adapters/azure/environment.ts
+var PRODUCTION_ALIASES = /* @__PURE__ */ new Set(["production", "live", "prod"]);
+var STAGING_ALIASES = /* @__PURE__ */ new Set(["staging", "beta", "development", "dev", "local"]);
+function normalizeToAzureEnvironment(instanceEnvironment) {
+  const key = instanceEnvironment.trim().toLowerCase();
+  if (!key) {
+    console.warn(
+      "[azure] Empty ENVIRONMENT; defaulting Azure pipeline environment to staging"
+    );
+    return "staging";
+  }
+  if (PRODUCTION_ALIASES.has(key)) {
+    return "production";
+  }
+  if (STAGING_ALIASES.has(key)) {
+    return "staging";
+  }
+  console.warn(
+    `[azure] Unrecognized ENVIRONMENT="${instanceEnvironment}"; defaulting Azure pipeline environment to staging`
+  );
+  return "staging";
+}
+function pipelineRefForAzure(pipelineEnvironment) {
+  return `refs/heads/${pipelineEnvironment}`;
+}
+
+// src/shared/content-refresh.ts
+import { timingSafeEqual } from "crypto";
+async function postContentRefresh(target, url, apiToken, request) {
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiToken}`,
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify(request)
+    });
+    const text = await response.text();
+    let body;
+    if (text) {
+      try {
+        body = JSON.parse(text);
+      } catch {
+        body = text;
+      }
+    }
+    return {
+      target,
+      ok: response.ok,
+      status: response.status,
+      body,
+      error: response.ok ? void 0 : typeof body === "object" && body !== null && "error" in body ? String(body.error) : `HTTP ${response.status}`
+    };
+  } catch (err) {
+    return {
+      target,
+      ok: false,
+      status: 0,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+
+// src/server/content-refresh-notify.ts
+function isContentRefreshEnabledForInstance(instanceEnvironment) {
+  return normalizeToAzureEnvironment(instanceEnvironment) === "staging";
+}
+async function notifyContentRefreshTargets(notifyConfig, request, projects) {
+  if (!notifyConfig.enabled || !notifyConfig.apiToken) {
+    return [];
+  }
+  const keys = projects ?? AZURE_DEVOPS_PROJECT_KEYS.filter(
+    (p) => notifyConfig.targets[p]?.url
+  );
+  const results = [];
+  for (const project of keys) {
+    const url = notifyConfig.targets[project]?.url;
+    if (!url) {
+      continue;
+    }
+    const result = await postContentRefresh(
+      project,
+      url,
+      notifyConfig.apiToken,
+      request
+    );
+    results.push(result);
+    if (result.ok) {
+      console.log(
+        `[content-refresh] Notified ${project} (${result.status})`
+      );
+    } else {
+      console.error(
+        `[content-refresh] Failed to notify ${project}: ${result.error ?? result.status}`
+      );
+    }
+  }
+  return results;
+}
 
 // src/server/config.ts
 import dotenv from "dotenv";
+
+// src/server/restrictedCron.ts
+var MAX_SEARCH_MINUTES = 366 * 24 * 60;
+function tokenize(expr) {
+  return expr.trim().split(/\s+/).map((s) => s.trim()).filter(Boolean);
+}
+function validateScheduleCronExpression(expr) {
+  const parts = tokenize(expr);
+  if (parts.length !== 2) {
+    throw new Error(
+      `Schedule cron must be exactly two fields (minute hour), whitespace-separated; got ${parts.length} field(s): "${expr}"`
+    );
+  }
+  const minuteSpec = parts[0];
+  const hourSpec = parts[1];
+  parseField(minuteSpec, 0, 59, "minute");
+  parseField(hourSpec, 0, 23, "hour");
+  return `${minuteSpec} ${hourSpec}`;
+}
+function parseField(spec, lo, hi, fieldName) {
+  const subs = spec.split(",").map((s) => s.trim()).filter(Boolean);
+  if (subs.length === 0) {
+    throw new Error(`Empty ${fieldName} field in cron`);
+  }
+  const preds = subs.map((sub) => parseSubfield(sub, lo, hi, fieldName));
+  return (n) => preds.some((p) => p(n));
+}
+function parseSubfield(sub, lo, hi, fieldName) {
+  if (sub === "*") {
+    return () => true;
+  }
+  if (sub.startsWith("*/")) {
+    const step = parseInt(sub.slice(2), 10);
+    if (!Number.isFinite(step) || step < 1) {
+      throw new Error(`Invalid step in ${fieldName} field: "${sub}"`);
+    }
+    return (n) => n >= lo && n <= hi && n % step === 0;
+  }
+  if (sub.includes("-")) {
+    const [a, b] = sub.split("-").map((x) => parseInt(x.trim(), 10));
+    if (!Number.isFinite(a) || !Number.isFinite(b)) {
+      throw new Error(`Invalid range in ${fieldName} field: "${sub}"`);
+    }
+    if (a < lo || b > hi || a > b) {
+      throw new Error(`Range out of bounds in ${fieldName} field: "${sub}"`);
+    }
+    return (n) => n >= a && n <= b;
+  }
+  const v = parseInt(sub, 10);
+  if (!Number.isFinite(v) || v < lo || v > hi) {
+    throw new Error(`Invalid value in ${fieldName} field: "${sub}"`);
+  }
+  return (n) => n === v;
+}
+function floorToMinuteStart(d) {
+  const t = new Date(d.getTime());
+  t.setSeconds(0, 0);
+  return t;
+}
+function addOneMinute(d) {
+  const t = new Date(d.getTime());
+  t.setMinutes(t.getMinutes() + 1, 0, 0);
+  return t;
+}
+function matchesAtMinuteStart(minutePred, hourPred, d) {
+  return minutePred(d.getMinutes()) && hourPred(d.getHours());
+}
+function nextCronFireAfter(expr, after) {
+  const parts = tokenize(expr);
+  if (parts.length !== 2) {
+    throw new Error(
+      `nextCronFireAfter expects exactly two fields (minute hour); got ${parts.length}: "${expr}"`
+    );
+  }
+  const minutePred = parseField(parts[0], 0, 59, "minute");
+  const hourPred = parseField(parts[1], 0, 23, "hour");
+  let d = floorToMinuteStart(after);
+  if (d.getTime() <= after.getTime()) {
+    d = addOneMinute(d);
+  }
+  for (let i = 0; i < MAX_SEARCH_MINUTES; i++) {
+    if (matchesAtMinuteStart(minutePred, hourPred, d)) {
+      return d;
+    }
+    d = addOneMinute(d);
+  }
+  throw new Error(`No cron match within ${MAX_SEARCH_MINUTES} minutes for "${expr}"`);
+}
+
+// src/server/config.ts
 dotenv.config({ path: ".env.local" });
 dotenv.config();
+function readScheduleCronEnv() {
+  return {
+    scheduleCron: (process.env.SCHEDULE_CRON ?? "").trim(),
+    cmsCronRaw: (process.env.SCHEDULE_CMS_CRON ?? "").trim(),
+    translationCronRaw: (process.env.SCHEDULE_TRANSLATION_CRON ?? "").trim()
+  };
+}
+function resolveScheduleCron(jobSpecific, globalCron, jobLabel) {
+  const raw = jobSpecific || globalCron;
+  if (!raw) return null;
+  try {
+    return validateScheduleCronExpression(raw);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    console.error(`[config] Invalid ${jobLabel} schedule cron: ${msg}`);
+    return null;
+  }
+}
 function parseScheduledCmsJobConfig() {
-  const intervalMinutes = parseInt(process.env.SCHEDULE_INTERVAL_MINUTES ?? "0", 10);
-  const enabled = Number.isFinite(intervalMinutes) && intervalMinutes > 0;
+  const { scheduleCron, cmsCronRaw } = readScheduleCronEnv();
   const runOnStart = (process.env.SCHEDULE_RUN_ON_START ?? "true").toLowerCase() !== "false";
-  const task = (process.env.SCHEDULE_TASK ?? "sync").trim();
   const syncCms = (process.env.SCHEDULE_SYNC_CMS ?? "").trim();
-  const rawTypes = process.env.SCHEDULE_SYNC_TYPES?.trim();
+  const rawTypes = process.env.SCHEDULE_SYNC_CONTENT_TYPES?.trim();
   const syncTypes = rawTypes ? rawTypes.split(",").map((s) => s.trim()).filter(Boolean) : void 0;
+  const resolved = resolveScheduleCron(cmsCronRaw, scheduleCron, "CMS");
+  const cmsOk = !!syncCms && (syncCms === "contentful" || syncCms === "sanity");
+  if (resolved !== null && !cmsOk) {
+    console.warn(
+      '[config] CMS schedule cron is set but SCHEDULE_SYNC_CMS is missing or not "contentful"|"sanity"; scheduled CMS sync is disabled.'
+    );
+  }
+  const enabled = resolved !== null && cmsOk;
   return {
     enabled,
-    intervalMinutes,
+    cronExpression: resolved ?? "",
     runOnStart,
-    task,
     syncCms: syncCms || void 0,
     syncTypes
   };
 }
 function parseScheduledTranslationJobConfig() {
-  const intervalMinutes = parseInt(process.env.SCHEDULE_INTERVAL_MINUTES ?? "0", 10);
-  const enabled = Number.isFinite(intervalMinutes) && intervalMinutes > 0;
+  const { scheduleCron, translationCronRaw } = readScheduleCronEnv();
   const runOnStart = (process.env.SCHEDULE_RUN_ON_START ?? "true").toLowerCase() !== "false";
-  const task = (process.env.SCHEDULE_TASK ?? "sync").trim();
   const rawProjects = process.env.SCHEDULE_SYNC_TRANSLATION_PROJECTS?.trim();
   const syncProjects = rawProjects ? rawProjects.split(",").map((s) => s.trim()).filter(Boolean) : void 0;
+  const resolved = resolveScheduleCron(
+    translationCronRaw,
+    scheduleCron,
+    "translation"
+  );
+  const enabled = resolved !== null;
   return {
     enabled,
-    intervalMinutes,
+    cronExpression: resolved ?? "",
     runOnStart,
-    task,
     syncProjects
   };
 }
+function projectEnvSlug(project) {
+  return project.toUpperCase().replace(/-/g, "_");
+}
+function readProjectPipeline(project, pipelineEnvironment) {
+  const slug = projectEnvSlug(project);
+  const id = parseInt(process.env[`AZURE_${slug}_PIPELINE_ID`]?.trim() ?? "0", 10);
+  return { id, refName: pipelineRefForAzure(pipelineEnvironment) };
+}
+function parseAzureDevOpsConfig(instanceEnvironment) {
+  const pipelineEnvironment = normalizeToAzureEnvironment(instanceEnvironment);
+  const pat = process.env.AZURE_DEVOPS_ACCESS_TOKEN?.trim() ?? "";
+  const defaultProjectRaw = (process.env.AZURE_DEVOPS_DEFAULT_PROJECT ?? "web-site").trim();
+  const defaultProject = AZURE_DEVOPS_PROJECT_KEYS.includes(
+    defaultProjectRaw
+  ) ? defaultProjectRaw : "web-site";
+  const projects = Object.fromEntries(
+    AZURE_DEVOPS_PROJECT_KEYS.map((project) => [
+      project,
+      { pipeline: readProjectPipeline(project, pipelineEnvironment) }
+    ])
+  );
+  return {
+    enabled: pat.length > 0,
+    organization: process.env.AZURE_DEVOPS_ORGANIZATION?.trim() || "tripod-technology",
+    pat,
+    apiVersion: process.env.AZURE_DEVOPS_API_VERSION?.trim() || "7.1",
+    defaultProject,
+    instanceEnvironment,
+    pipelineEnvironment,
+    projects
+  };
+}
+function readContentRefreshUrl(project) {
+  const slug = projectEnvSlug(project);
+  return process.env[`AZURE_${slug}_CONTENT_REFRESH_URL`]?.trim() || void 0;
+}
+function parseContentRefreshConfig(instanceEnvironment, contentStoreApiToken) {
+  const targets = Object.fromEntries(
+    AZURE_DEVOPS_PROJECT_KEYS.map((project) => [
+      project,
+      { url: readContentRefreshUrl(project) }
+    ])
+  );
+  return {
+    enabled: isContentRefreshEnabledForInstance(instanceEnvironment),
+    apiToken: process.env.CONTENT_REFRESH_API_TOKEN?.trim() || contentStoreApiToken,
+    targets
+  };
+}
 var config2 = {
   ...config,
   contentful: {
@@ -89,6 +506,11 @@ var config2 = {
   },
   scheduledCmsJob: parseScheduledCmsJobConfig(),
   scheduledTranslationJob: parseScheduledTranslationJobConfig(),
+  azure: parseAzureDevOpsConfig(config.environment),
+  contentRefresh: parseContentRefreshConfig(
+    config.environment,
+    process.env.CONTENT_STORE_API_TOKEN ?? ""
+  ),
   slack: {
     enabled: (process.env.SLACK_BOT_TOKEN ?? "").length > 0,
     botToken: process.env.SLACK_BOT_TOKEN ?? "",
@@ -96,7 +518,8 @@ var config2 = {
     appToken: process.env.SLACK_APP_TOKEN ?? "",
     notifyChannel: process.env.SLACK_NOTIFY_CHANNEL ?? "",
     cmdSyncContent: process.env.SLACK_CMD_SYNC_CONTENT ?? "/sync-content",
-    cmdSyncTranslations: process.env.SLACK_CMD_SYNC_TRANSLATIONS ?? "/sync-translations"
+    cmdSyncTranslations: process.env.SLACK_CMD_SYNC_TRANSLATIONS ?? "/sync-translations",
+    cmdTriggerBuild: process.env.SLACK_CMD_TRIGGER_BUILD ?? "/trigger-build"
   }
 };
 
@@ -452,8 +875,8 @@ async function syncTranslations(projects, locales) {
           );
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
-          errors.push({ project, locale, resource: resource.resource, error: message });
-          console.error(`  x ${project} / ${resource.resource} - ${locale}: ${message}`);
+          errors.push({ project, locale, error: message });
+          console.error(`  x ${project} - ${locale}: ${message}`);
         }
       }
     }
@@ -462,6 +885,12 @@ async function syncTranslations(projects, locales) {
 }
 
 export {
+  AZURE_DEVOPS_PROJECT_KEYS,
+  isAzureDevOpsProjectKey,
+  triggerPipelineBuild,
+  formatPipelineRunSummary,
+  notifyContentRefreshTargets,
+  nextCronFireAfter,
   config2 as config,
   summariseCmsEntries,
   summariseCmsErrors,
@@ -469,4 +898,4 @@ export {
   syncCmsContent,
   syncTranslations
 };
-//# sourceMappingURL=chunk-NQHWG4XM.js.map
+//# sourceMappingURL=chunk-ZX5KC4F5.js.map