@tandem-language-exchange/content-store 1.3.2 → 1.3.3

package/dist/chunk-POJRKC4G.js

@@ -0,0 +1,1015 @@
+#!/usr/bin/env node
+import {
+  config
+} from "./chunk-OCAIIQZW.js";
+import {
+  ContentStore,
+  buildCmsObjectKey,
+  buildTranslationObjectKey,
+  contentTypeForTranslationKey
+} from "./chunk-VBJ6LVMY.js";
+import {
+  allProjects,
+  defaultLocales
+} from "./chunk-OWL72OTS.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/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 { scheduleCron, cmsCronRaw } = readScheduleCronEnv();
+  const runOnStart = (process.env.SCHEDULE_RUN_ON_START ?? "true").toLowerCase() !== "false";
+  const syncCms = (process.env.SCHEDULE_SYNC_CMS ?? "").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,
+    cronExpression: resolved ?? "",
+    runOnStart,
+    syncCms: syncCms || void 0,
+    syncTypes
+  };
+}
+function parseScheduledTranslationJobConfig() {
+  const { scheduleCron, translationCronRaw } = readScheduleCronEnv();
+  const runOnStart = (process.env.SCHEDULE_RUN_ON_START ?? "true").toLowerCase() !== "false";
+  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,
+    cronExpression: resolved ?? "",
+    runOnStart,
+    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[`CONTENT_REFRESH_${slug}_URL`]?.trim() || void 0;
+}
+function parseContentRefreshConfig(instanceEnvironment) {
+  const targets = Object.fromEntries(
+    AZURE_DEVOPS_PROJECT_KEYS.map((project) => [
+      project,
+      { url: readContentRefreshUrl(project) }
+    ])
+  );
+  return {
+    enabled: isContentRefreshEnabledForInstance(instanceEnvironment),
+    basicAuth: process.env.CONTENT_REFRESH_BASIC_AUTH?.trim() ?? "",
+    targets
+  };
+}
+var config2 = {
+  ...config,
+  contentful: {
+    spaceId: process.env.CONTENTFUL_SPACE_ID ?? "",
+    accessToken: process.env.CONTENTFUL_WEBSITE_TOKEN ?? "",
+    host: process.env.CONTENTFUL_HOST ?? "preview.contentful.com",
+    batchSize: 1e3,
+    maxDepth: 4,
+    contentTypes: [
+      "asset",
+      "page",
+      "longtailPage",
+      "customJson",
+      "banner",
+      "cookieBanner",
+      "downloadPage"
+      // Add Contentful content type IDs here to limit sync scope.
+    ]
+  },
+  sanity: {
+    projectId: process.env.SANITY_PROJECT_ID ?? "",
+    dataset: process.env.SANITY_DATASET ?? "main",
+    token: process.env.SANITY_API_TOKEN ?? "",
+    apiVersion: "2024-01-01"
+  },
+  lingohub: {
+    authToken: process.env.LINGOHUB_AUTH_TOKEN ?? "",
+    workspace: process.env.LINGOHUB_WORKSPACE ?? ""
+  },
+  retry: {
+    maxRetries: parseInt(process.env.RETRY_MAX_RETRIES ?? "5", 10),
+    baseDelayMs: parseInt(process.env.RETRY_BASE_DELAY_MS ?? "1000", 10),
+    maxDelayMs: parseInt(process.env.RETRY_MAX_DELAY_MS ?? "60000", 10)
+  },
+  api: {
+    port: parseInt(process.env.PORT ?? "3030", 10),
+    apiToken: process.env.CONTENT_STORE_API_TOKEN ?? ""
+  },
+  scheduledCmsJob: parseScheduledCmsJobConfig(),
+  scheduledTranslationJob: parseScheduledTranslationJobConfig(),
+  azure: parseAzureDevOpsConfig(config.environment),
+  contentRefresh: parseContentRefreshConfig(config.environment),
+  slack: {
+    enabled: (process.env.SLACK_BOT_TOKEN ?? "").length > 0,
+    botToken: process.env.SLACK_BOT_TOKEN ?? "",
+    signingSecret: process.env.SLACK_SIGNING_SECRET ?? "",
+    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",
+    cmdTriggerBuild: process.env.SLACK_CMD_TRIGGER_BUILD ?? "/trigger-build"
+  }
+};
+
+// src/shared/content-refresh.ts
+import { timingSafeEqual } from "crypto";
+async function postContentRefresh(target, url, basicAuth, request) {
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Basic ${basicAuth}`,
+        "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.basicAuth) {
+    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.basicAuth,
+      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;
+}
+async function notifyClientsAfterCmsSync(result, requestedContentTypes, projects) {
+  const { contentRefresh } = config2;
+  if (!contentRefresh.enabled) {
+    console.log(
+      "[content-refresh] Skipped after CMS sync (disabled on this instance; staging/beta only)"
+    );
+    return [];
+  }
+  if (!contentRefresh.basicAuth) {
+    console.warn(
+      "[content-refresh] Skipped after CMS sync (set CONTENT_REFRESH_BASIC_AUTH)"
+    );
+    return [];
+  }
+  if (result.errors.length > 0) {
+    console.log("[content-refresh] Skipped after CMS sync (sync had errors)");
+    return [];
+  }
+  const types = requestedContentTypes?.length ? requestedContentTypes : result.entries.map((e) => e.contentType);
+  if (types.length === 0) {
+    console.warn("[content-refresh] Skipped after CMS sync (no content types)");
+    return [];
+  }
+  const targets = projects ?? AZURE_DEVOPS_PROJECT_KEYS.filter(
+    (p) => contentRefresh.targets[p]?.url
+  );
+  if (targets.length === 0) {
+    console.warn(
+      "[content-refresh] Skipped after CMS sync (no CONTENT_REFRESH_*_URL configured)"
+    );
+    return [];
+  }
+  console.log(
+    `[content-refresh] Notifying after CMS sync (${result.cms}): ${targets.join(", ")}`
+  );
+  return notifyContentRefreshTargets(
+    contentRefresh,
+    {
+      scope: "cms",
+      cms: result.cms,
+      content_types: types
+    },
+    projects
+  );
+}
+
+// src/server/adapters/contentful-api-usage.ts
+function emptyContentfulApiUsage() {
+  return { cda: 0, cma: 0, cpa: 0 };
+}
+function contentfulApiKindFromHost(host) {
+  const h = host.toLowerCase();
+  if (h.includes("preview")) {
+    return "cpa";
+  }
+  if (h.includes("api.contentful") || h === "api.contentful.com") {
+    return "cma";
+  }
+  return "cda";
+}
+function totalContentfulApiCalls(usage) {
+  return usage.cda + usage.cma + usage.cpa;
+}
+function summariseContentfulApiUsage(usage) {
+  const lines = [];
+  if (usage.cda > 0) {
+    lines.push(`CDA requests: ${usage.cda}`);
+  }
+  if (usage.cpa > 0) {
+    lines.push(`CPA requests: ${usage.cpa}`);
+  }
+  if (usage.cma > 0) {
+    lines.push(`CMA requests: ${usage.cma}`);
+  }
+  lines.push(`Total contentful API calls: ${totalContentfulApiCalls(usage)}`);
+  return lines;
+}
+var ContentfulApiUsageTracker = class {
+  kind;
+  counts = emptyContentfulApiUsage();
+  constructor(host) {
+    this.kind = contentfulApiKindFromHost(host);
+  }
+  recordCall() {
+    this.counts[this.kind] += 1;
+  }
+  snapshot() {
+    return { ...this.counts };
+  }
+};
+
+// src/server/adapters/contentful.ts
+import {
+  createClient
+} from "contentful";
+
+// src/server/sync/retry.ts
+function rateLimitDelayMs(err) {
+  const e = err;
+  if (e?.status === 429 || e?.statusCode === 429) {
+    const reset = e?.headers?.["x-contentful-ratelimit-reset"];
+    return reset ? parseFloat(reset) * 1e3 : 0;
+  }
+  const resp = e?.response;
+  if (resp?.status === 429) {
+    const headers = resp?.headers;
+    const reset = headers?.["x-contentful-ratelimit-reset"];
+    return reset ? parseFloat(reset) * 1e3 : 0;
+  }
+  return null;
+}
+function computeDelay(attempt, baseDelayMs, maxDelayMs) {
+  const exponential = baseDelayMs * Math.pow(2, attempt);
+  const jitter = Math.random() * baseDelayMs;
+  return Math.min(exponential + jitter, maxDelayMs);
+}
+async function withRetry(fn, { maxRetries, baseDelayMs, maxDelayMs }) {
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      if (attempt === maxRetries) throw err;
+      const rlDelay = rateLimitDelayMs(err);
+      let delay;
+      if (rlDelay !== null) {
+        delay = rlDelay > 0 ? rlDelay : computeDelay(attempt, baseDelayMs, maxDelayMs);
+        console.warn(
+          `  Rate limited (attempt ${attempt + 1}/${maxRetries}). Waiting ${Math.round(delay)}ms\u2026`
+        );
+      } else {
+        delay = computeDelay(attempt, baseDelayMs, maxDelayMs);
+        console.warn(
+          `  Request failed (attempt ${attempt + 1}/${maxRetries}): ${err.message}. Retrying in ${Math.round(delay)}ms\u2026`
+        );
+      }
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+  throw new Error("withRetry: unreachable");
+}
+
+// src/server/adapters/contentful.ts
+function stripEnvelope(value, maxDepth, depth = 0, path = /* @__PURE__ */ new WeakSet()) {
+  if (value === null || typeof value !== "object") return value;
+  const obj = value;
+  if (path.has(obj)) return void 0;
+  path.add(obj);
+  try {
+    if (Array.isArray(value)) {
+      return value.map((item) => stripEnvelope(item, maxDepth, depth, path));
+    }
+    const isEnvelope = "sys" in obj && "fields" in obj && typeof obj.fields === "object";
+    if (isEnvelope) {
+      if (depth >= maxDepth) return void 0;
+      const fields = obj.fields;
+      const result2 = {};
+      for (const [k, v] of Object.entries(fields)) {
+        result2[k] = stripEnvelope(v, maxDepth, depth + 1, path);
+      }
+      const sys = obj.sys;
+      if (sys) {
+        const existingMeta = result2.meta;
+        const metaBase = typeof existingMeta === "object" && existingMeta !== null && !Array.isArray(existingMeta) ? existingMeta : {};
+        const _contentType = sys.contentType ? sys.contentType.sys.id : "Asset";
+        result2.meta = { ...metaBase, _id: sys.id, _contentType, _updatedAt: sys.updatedAt };
+      }
+      return result2;
+    }
+    const result = {};
+    for (const [k, v] of Object.entries(obj)) {
+      result[k] = stripEnvelope(v, maxDepth, depth, path);
+    }
+    return result;
+  } finally {
+    path.delete(obj);
+  }
+}
+var ContentfulAdapter = class {
+  name = "contentful";
+  client;
+  batchSize;
+  maxDepth;
+  allowedTypes;
+  retryConfig;
+  apiUsage;
+  constructor(cfg2, retryConfig) {
+    this.client = createClient({
+      space: cfg2.spaceId,
+      accessToken: cfg2.accessToken,
+      host: cfg2.host
+    });
+    this.batchSize = cfg2.batchSize;
+    this.maxDepth = cfg2.maxDepth;
+    this.allowedTypes = cfg2.contentTypes;
+    this.retryConfig = retryConfig;
+    this.apiUsage = new ContentfulApiUsageTracker(cfg2.host);
+  }
+  getContentfulApiUsage() {
+    return this.apiUsage.snapshot();
+  }
+  async getContentTypes() {
+    const response = await withRetry(
+      () => {
+        this.apiUsage.recordCall();
+        return this.client.getContentTypes();
+      },
+      this.retryConfig
+    );
+    const allTypes = response.items.map((ct) => ct.sys.id);
+    if (this.allowedTypes.length > 0) {
+      return allTypes.filter((t) => this.allowedTypes.includes(t));
+    }
+    return allTypes;
+  }
+  /**
+   * Fetches every entry for a content type using batched pagination.
+   * Contentful caps `getEntries` at 1 000 items per call, so we page through
+   * with `skip` until all items are collected.
+   *
+   * The reserved content type `"asset"` fetches from `getAssets()` instead.
+   */
+  async fetchAll(contentType, includeLevels = 4) {
+    if (contentType === "asset") {
+      return this.fetchAllAssets();
+    }
+    const allItems = [];
+    let skip = 0;
+    let total = 0;
+    do {
+      const payload = {
+        content_type: contentType,
+        limit: this.batchSize,
+        skip,
+        include: includeLevels
+      };
+      this.apiUsage.recordCall();
+      const response = await this.client.getEntries(payload);
+      total = response.total;
+      allItems.push(...response.items);
+      skip += response.items.length;
+      if (total > this.batchSize) {
+        console.log(
+          `  [contentful] ${contentType}: fetched ${allItems.length}/${total}`
+        );
+      }
+    } while (skip < total);
+    return {
+      contentType,
+      items: allItems.map((item) => stripEnvelope(item, this.maxDepth)),
+      total
+    };
+  }
+  async fetchAllAssets() {
+    const allItems = [];
+    let skip = 0;
+    let total = 0;
+    do {
+      const response = await withRetry(
+        () => {
+          this.apiUsage.recordCall();
+          return this.client.getAssets({ limit: this.batchSize, skip });
+        },
+        this.retryConfig
+      );
+      total = response.total;
+      allItems.push(...response.items);
+      skip += response.items.length;
+      if (total > this.batchSize) {
+        console.log(
+          `  [contentful] asset: fetched ${allItems.length}/${total}`
+        );
+      }
+    } while (skip < total);
+    return {
+      contentType: "asset",
+      items: allItems.map((item) => stripEnvelope(item, this.maxDepth)),
+      total
+    };
+  }
+};
+
+// src/server/adapters/sanity.ts
+import { createClient as createClient2 } from "@sanity/client";
+var SanityAdapter = class {
+  name = "sanity";
+  client;
+  retryConfig;
+  constructor(cfg2, retryConfig) {
+    this.client = createClient2({
+      projectId: cfg2.projectId,
+      dataset: cfg2.dataset,
+      token: cfg2.token,
+      apiVersion: cfg2.apiVersion,
+      useCdn: false
+    });
+    this.retryConfig = retryConfig;
+  }
+  async getContentTypes() {
+    const types = await withRetry(
+      () => this.client.fetch("array::unique(*[]._type)"),
+      this.retryConfig
+    );
+    return types.filter(
+      (t) => !t.startsWith("system.") && !t.startsWith("sanity.")
+    );
+  }
+  async fetchAll(contentType) {
+    const items = await withRetry(
+      () => this.client.fetch("*[_type == $type]", { type: contentType }),
+      this.retryConfig
+    );
+    console.log(`  [sanity] ${contentType}: fetched ${items.length} items`);
+    return { contentType, items, total: items.length };
+  }
+};
+
+// src/server/adapters/index.ts
+function createAdapter(cms) {
+  switch (cms) {
+    case "contentful":
+      return new ContentfulAdapter(config2.contentful, config2.retry);
+    case "sanity":
+      return new SanityAdapter(config2.sanity, config2.retry);
+    default:
+      throw new Error(`Unknown CMS provider: ${cms}`);
+  }
+}
+
+// src/server/adapters/lingohub.ts
+var cfg = config2.lingohub;
+var apiUrl = "https://api.lingohub.com/v1/" + cfg.workspace + "/projects/";
+async function fetchLingohubResourceRaw(project, resource, locale) {
+  const urlForResourceLocalised = `${apiUrl}${project}/resources/${resource.fileName}?auth_token=${cfg.authToken}`.replace(
+    "[locale]",
+    locale
+  );
+  const res = await fetch(urlForResourceLocalised, { method: "GET" });
+  if (!res.ok) {
+    throw new Error(`Failed to fetch resource \`${resource.fileName}\` (${locale}): ${res.status} - ${res.statusText}`);
+  }
+  return await res.text();
+}
+
+// src/server/sync/engine.ts
+function summariseCmsEntries(result) {
+  return result.entries.map(
+    (e) => `\u2022 \`${e.contentType}\` \u2014 ${e.itemCount} items`
+  );
+}
+function summariseCmsErrors(result) {
+  return result.errors.map(
+    (e) => `\u2022 \`${e.contentType}\` \u2014 ${e.error}`
+  );
+}
+function summariseCmsContentfulApiUsage(result) {
+  if (!result.contentfulApiUsage) {
+    return [];
+  }
+  return summariseContentfulApiUsage(result.contentfulApiUsage);
+}
+function summariseTranslationEntries(entries) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const e of entries) {
+    const key = `${e.project} / ${e.resource}`;
+    const existing = grouped.get(key);
+    if (existing) {
+      existing.locales += 1;
+      existing.bytes += e.itemCount;
+    } else {
+      grouped.set(key, { locales: 1, bytes: e.itemCount });
+    }
+  }
+  return [...grouped.entries()].map(
+    ([key, { locales, bytes }]) => `\u2022 \`${key}\` / [${locales} locale${locales === 1 ? "" : "s"}] \u2014 ${bytes} bytes`
+  );
+}
+async function syncCmsContent(cms, contentTypes, includeLevels) {
+  const adapter = createAdapter(cms);
+  const store = new ContentStore(config2.s3);
+  const timestamp = Math.floor(Date.now() / 1e3);
+  console.log(`
+Starting sync from ${cms} at ${new Date(timestamp * 1e3).toISOString()}`);
+  const typesToSync = contentTypes && contentTypes.length > 0 ? contentTypes : await adapter.getContentTypes();
+  console.log(`Content types to sync: ${typesToSync.join(", ")}
+`);
+  const entries = [];
+  const errors = [];
+  for (const contentType of typesToSync) {
+    try {
+      const result = await adapter.fetchAll(contentType, includeLevels);
+      const objectKey = buildCmsObjectKey(cms, contentType);
+      await store.upload(objectKey, result.items);
+      entries.push({
+        contentType,
+        itemCount: result.total,
+        objectKey
+      });
+      console.log(
+        `  + ${contentType}: ${result.total} items -> ${objectKey}`
+      );
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      errors.push({ contentType, error: message });
+      console.error(`  x ${contentType}: ${message}`);
+    }
+  }
+  const contentfulApiUsage = adapter.getContentfulApiUsage?.();
+  if (contentfulApiUsage) {
+    console.log(
+      `
+Contentful API calls: ${summariseContentfulApiUsage(contentfulApiUsage).join(", ")}`
+    );
+  }
+  console.log(
+    `
+Sync complete: ${entries.length} succeeded, ${errors.length} failed
+`
+  );
+  return { cms, timestamp, entries, errors, contentfulApiUsage };
+}
+async function syncTranslations(projects, locales) {
+  const store = new ContentStore(config2.s3);
+  const entries = [];
+  const errors = [];
+  const timestamp = Math.floor(Date.now() / 1e3);
+  if (!locales) {
+    locales = defaultLocales;
+  }
+  if (!projects) {
+    projects = Object.keys(allProjects);
+  }
+  for (const project of projects) {
+    const resources = allProjects[project];
+    if (!resources) {
+      console.error(`No resources found for ${project}`);
+      continue;
+    }
+    for (const resource of resources) {
+      for (const loc of locales) {
+        const locale = resource.localeMapping && resource.localeMapping[loc] ? resource.localeMapping[loc] : loc;
+        try {
+          const raw = await withRetry(
+            () => fetchLingohubResourceRaw(project, resource, locale),
+            config2.retry
+          );
+          const objectKey = buildTranslationObjectKey(
+            project,
+            resource.fileName,
+            locale
+          );
+          await store.uploadRaw(
+            objectKey,
+            raw,
+            contentTypeForTranslationKey(objectKey)
+          );
+          const byteLength = Buffer.byteLength(raw, "utf8");
+          entries.push({
+            project,
+            resource: resource.resource,
+            locale,
+            itemCount: byteLength,
+            objectKey
+          });
+          console.log(
+            `  + ${project} - ${locale}: ${byteLength} bytes -> ${objectKey}`
+          );
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          errors.push({ project, locale, error: message });
+          console.error(`  x ${project} - ${locale}: ${message}`);
+        }
+      }
+    }
+  }
+  return { timestamp, entries, errors };
+}
+
+export {
+  AZURE_DEVOPS_PROJECT_KEYS,
+  isAzureDevOpsProjectKey,
+  triggerPipelineBuild,
+  formatPipelineRunSummary,
+  notifyContentRefreshTargets,
+  notifyClientsAfterCmsSync,
+  nextCronFireAfter,
+  config2 as config,
+  summariseCmsEntries,
+  summariseCmsErrors,
+  summariseCmsContentfulApiUsage,
+  summariseTranslationEntries,
+  syncCmsContent,
+  syncTranslations
+};
+//# sourceMappingURL=chunk-POJRKC4G.js.map