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

package/dist/node.d.ts

@@ -1,4 +1,4 @@
-import { S as SDKConfig, F as FetchCmsBundlesOptions, a as FetchTranslationBundlesOptions, T as TranslationBundleInfo, b as FetchMergedTranslationBundlesOptions, C as CMSProvider, Q as QueryOptions } from './index-DqDNlXSE.js';
+import { C as CMSProvider, T as TranslationBundleInfo, F as FetchCmsBundlesOptions, a as FetchTranslationBundlesOptions, S as SDKConfig, b as FetchMergedTranslationBundlesOptions, Q as QueryOptions } from './index-DqDNlXSE.js';
 export { B as BundleItem, c as CmsBundleInfo, d as ContentStore, e as S3Config, f as S3RetryConfig, g as TranslationFilterConfig, h as fetchCmsBundles, i as fetchMergedTranslationBundles, j as fetchTranslationBundles, k as getDefaultS3RetryConfig, q as queryCmsBundle } from './index-DqDNlXSE.js';
 
 /**
@@ -11,6 +11,65 @@ export { B as BundleItem, c as CmsBundleInfo, d as ContentStore, e as S3Config,
  */
 declare function trimDepth(value: unknown, remaining: number): unknown;
 
+type ContentRefreshScope = 'cms' | 'translations' | 'all';
+interface ContentRefreshRequest {
+    scope?: ContentRefreshScope;
+    cms?: CMSProvider;
+    content_types?: string[];
+    projects?: string[];
+    locales?: string[];
+}
+/** Defaults applied when the request omits fields (set by the host application). */
+interface ContentRefreshDefaults {
+    scope?: ContentRefreshScope;
+    cms?: CMSProvider;
+    contentTypes?: string[];
+    translationProjects?: string[];
+    locales?: string[];
+}
+interface ContentRefreshError {
+    step: string;
+    message: string;
+}
+interface ContentRefreshResult {
+    ok: boolean;
+    scope: ContentRefreshScope;
+    cmsFiles?: Record<string, string>;
+    translationFiles?: TranslationBundleInfo;
+    errors: ContentRefreshError[];
+    durationMs: number;
+}
+interface ContentRefreshFetchers {
+    fetchCmsBundles: (options: FetchCmsBundlesOptions) => Promise<Record<string, string>>;
+    fetchTranslationBundles: (options: FetchTranslationBundlesOptions) => Promise<TranslationBundleInfo>;
+}
+/** Base64 of `username:password` (value only — prefix with `Basic ` in the header). */
+declare function encodeBasicAuthCredentials(username: string, password: string): string;
+/**
+ * Validates `Authorization: Basic <base64>` against the expected credentials
+ * (base64 of `user:pass`, same as staging site basic auth).
+ */
+declare function assertContentRefreshBasicAuth(authorizationHeader: string | undefined, expectedCredentialsBase64: string): void;
+declare class ContentRefreshAuthError extends Error {
+    readonly statusCode: number;
+    constructor(message: string, statusCode: number);
+}
+/**
+ * Pull the latest bundles from S3 into the host app's configured output directory.
+ */
+declare function executeContentRefresh(fetchers: ContentRefreshFetchers, request: ContentRefreshRequest, defaults?: ContentRefreshDefaults): Promise<ContentRefreshResult>;
+interface PostContentRefreshResponse {
+    target: string;
+    ok: boolean;
+    status: number;
+    body?: unknown;
+    error?: string;
+}
+/**
+ * Ask a remote application (web-site, web-app, …) to refresh its local content cache.
+ */
+declare function postContentRefresh(target: string, url: string, basicAuth: string, request: ContentRefreshRequest): Promise<PostContentRefreshResponse>;
+
 declare class ContentStoreSDK {
     private store;
     private outputDir;
@@ -39,6 +98,41 @@ declare class ContentStoreSDK {
      * Queries a previously fetched bundle from the local filesystem.
      */
     queryCmsBundle(cms: CMSProvider, contentType: string, options?: QueryOptions): Promise<unknown[]>;
+    /**
+     * Download the latest bundles from S3 (same as the hosted refresh HTTP endpoint).
+     */
+    refreshContent(request?: ContentRefreshRequest, defaults?: ContentRefreshDefaults): Promise<ContentRefreshResult>;
+}
+
+/** Minimal request shape for Next.js Pages API routes (`pages/api/*`). */
+interface NextPagesContentRefreshRequest {
+    method?: string;
+    headers: {
+        authorization?: string | string[];
+    };
+    body?: ContentRefreshRequest;
 }
+/** Minimal response shape for Next.js Pages API routes. */
+interface NextPagesContentRefreshResponse {
+    status(code: number): {
+        json(body: unknown): void;
+    };
+}
+interface NextContentRefreshHandlerConfig {
+    sdk: ContentStoreSDK;
+    /** Base64 of `username:password` (same value as `CONTENT_REFRESH_BASIC_AUTH`). */
+    basicAuth: string;
+    defaults?: ContentRefreshDefaults;
+}
+/** @deprecated Use {@link NextContentRefreshHandlerConfig}. */
+type NextPagesContentRefreshHandlerConfig = NextContentRefreshHandlerConfig;
+/**
+ * Handler for a Next.js Pages API route (e.g. pages/api/internal/content-refresh.ts).
+ */
+declare function createNextPagesApiContentRefreshHandler(config: NextContentRefreshHandlerConfig): (req: NextPagesContentRefreshRequest, res: NextPagesContentRefreshResponse) => Promise<void>;
+/**
+ * Handler for a Next.js App Router route (e.g. app/api/internal/content-refresh/route.ts).
+ */
+declare function handleNextAppRouterContentRefresh(request: Request, config: NextContentRefreshHandlerConfig): Promise<Response>;
 
-export { CMSProvider, ContentStoreSDK, FetchCmsBundlesOptions, FetchMergedTranslationBundlesOptions, FetchTranslationBundlesOptions, QueryOptions, SDKConfig, TranslationBundleInfo, trimDepth };
+export { CMSProvider, ContentRefreshAuthError, type ContentRefreshDefaults, type ContentRefreshRequest, type ContentRefreshResult, type ContentRefreshScope, ContentStoreSDK, FetchCmsBundlesOptions, FetchMergedTranslationBundlesOptions, FetchTranslationBundlesOptions, type NextContentRefreshHandlerConfig, type NextPagesContentRefreshHandlerConfig, type NextPagesContentRefreshRequest, type NextPagesContentRefreshResponse, type PostContentRefreshResponse, QueryOptions, SDKConfig, TranslationBundleInfo, assertContentRefreshBasicAuth, createNextPagesApiContentRefreshHandler, encodeBasicAuthCredentials, executeContentRefresh, handleNextAppRouterContentRefresh, postContentRefresh, trimDepth };

package/dist/node.js

@@ -13,9 +13,7 @@ var ContentStore = class {
       credentials: {
         accessKeyId: cfg.accessKeyId,
         secretAccessKey: cfg.secretAccessKey
-      },
-      requestChecksumCalculation: "WHEN_REQUIRED",
-      responseChecksumValidation: "WHEN_REQUIRED"
+      }
     });
     this.bucket = cfg.bucket;
   }
@@ -179,7 +177,7 @@ function trimDepth(value, remaining) {
 }
 
 // src/shared/lingohub.ts
-var defaultLocales = ["en", "fr", "de", "es", "it", "pt-br", "ru", "zh-hans", "zh-hant", "ko", "ja"];
+var defaultLocales = ["en", "fr", "de", "es", "it", "pt-br", "uk", "ru", "zh-hans", "zh-hant", "ko", "ja"];
 var localeMapping = {
   ios: {
     "pt-br": "pt",
@@ -232,7 +230,7 @@ var allProjects = {
     },
     {
       resource: "ipad",
-      fileName: "MainiPad.[locale].strings",
+      fileName: "Main_iPad.[locale].strings",
       type: "strings",
       localeMapping: localeMapping.ios
     },
@@ -744,6 +742,137 @@ async function queryCmsBundle(outputDir, cms, contentType, options = {}) {
   return items;
 }
 
+// src/shared/content-refresh.ts
+import { timingSafeEqual } from "crypto";
+function resolveContentRefreshScope(request, defaults) {
+  return request.scope ?? defaults.scope ?? "cms";
+}
+function encodeBasicAuthCredentials(username, password) {
+  return Buffer.from(`${username}:${password}`, "utf8").toString("base64");
+}
+function assertContentRefreshBasicAuth(authorizationHeader, expectedCredentialsBase64) {
+  if (!expectedCredentialsBase64) {
+    throw new ContentRefreshAuthError(
+      "Content refresh basic auth is not configured (set CONTENT_REFRESH_BASIC_AUTH)",
+      500
+    );
+  }
+  if (!authorizationHeader?.startsWith("Basic ")) {
+    throw new ContentRefreshAuthError(
+      "Missing or malformed Authorization header (expected Basic)",
+      401
+    );
+  }
+  const provided = authorizationHeader.slice(6).trim();
+  const bufA = new TextEncoder().encode(provided);
+  const bufB = new TextEncoder().encode(expectedCredentialsBase64);
+  if (bufA.byteLength !== bufB.byteLength || !timingSafeEqual(bufA, bufB)) {
+    throw new ContentRefreshAuthError("Invalid basic auth credentials", 403);
+  }
+}
+var ContentRefreshAuthError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "ContentRefreshAuthError";
+  }
+};
+async function executeContentRefresh(fetchers, request, defaults = {}) {
+  const started = Date.now();
+  const scope = resolveContentRefreshScope(request, defaults);
+  const errors = [];
+  let cmsFiles;
+  let translationFiles;
+  if (scope === "cms" || scope === "all") {
+    const cms = request.cms ?? defaults.cms ?? "contentful";
+    const contentTypes = request.content_types ?? defaults.contentTypes;
+    if (!contentTypes?.length) {
+      errors.push({
+        step: "cms",
+        message: "content_types (or handler defaults.contentTypes) is required for CMS refresh"
+      });
+    } else {
+      try {
+        cmsFiles = await fetchers.fetchCmsBundles({ cms, contentTypes });
+      } catch (err) {
+        errors.push({
+          step: "cms",
+          message: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+  }
+  if (scope === "translations" || scope === "all") {
+    const projects = request.projects ?? defaults.translationProjects;
+    if (!projects?.length) {
+      errors.push({
+        step: "translations",
+        message: "projects (or handler defaults.translationProjects) is required for translation refresh"
+      });
+    } else {
+      const locales = request.locales ?? defaults.locales;
+      try {
+        const projectMap = Object.fromEntries(
+          projects.map((p) => [p, []])
+        );
+        translationFiles = await fetchers.fetchTranslationBundles({
+          projects: projectMap,
+          locales
+        });
+      } catch (err) {
+        errors.push({
+          step: "translations",
+          message: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+  }
+  return {
+    ok: errors.length === 0,
+    scope,
+    cmsFiles,
+    translationFiles,
+    errors,
+    durationMs: Date.now() - started
+  };
+}
+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/sdk/client.ts
 var ContentStoreSDK = class {
   store;
@@ -784,14 +913,97 @@ var ContentStoreSDK = class {
   async queryCmsBundle(cms, contentType, options = {}) {
     return queryCmsBundle(this.outputDir, cms, contentType, options);
   }
+  /**
+   * Download the latest bundles from S3 (same as the hosted refresh HTTP endpoint).
+   */
+  async refreshContent(request = {}, defaults = {}) {
+    return executeContentRefresh(
+      {
+        fetchCmsBundles: (opts) => this.fetchCmsBundles(opts),
+        fetchTranslationBundles: (opts) => this.fetchTranslationBundles(opts)
+      },
+      request,
+      defaults
+    );
+  }
 };
+
+// src/sdk/next-content-refresh.ts
+function readAuthorizationHeader(value) {
+  if (value == null) {
+    return void 0;
+  }
+  if (Array.isArray(value)) {
+    return value[0];
+  }
+  return value;
+}
+async function runContentRefresh(config, authorization, body) {
+  const { sdk, basicAuth, defaults = {} } = config;
+  try {
+    assertContentRefreshBasicAuth(authorization, basicAuth);
+  } catch (err) {
+    if (err instanceof ContentRefreshAuthError) {
+      return { status: err.statusCode, body: { error: err.message } };
+    }
+    throw err;
+  }
+  const result = await executeContentRefresh(
+    {
+      fetchCmsBundles: (opts) => sdk.fetchCmsBundles(opts),
+      fetchTranslationBundles: (opts) => sdk.fetchTranslationBundles(opts)
+    },
+    body,
+    defaults
+  );
+  const status = result.ok ? 200 : result.errors.length > 0 ? 207 : 500;
+  return { status, body: result };
+}
+function createNextPagesApiContentRefreshHandler(config) {
+  return async (req, res) => {
+    if (req.method !== "POST") {
+      res.status(405).json({ error: "Method not allowed" });
+      return;
+    }
+    const { status, body } = await runContentRefresh(
+      config,
+      readAuthorizationHeader(req.headers.authorization),
+      req.body ?? {}
+    );
+    res.status(status).json(body);
+  };
+}
+async function handleNextAppRouterContentRefresh(request, config) {
+  if (request.method !== "POST") {
+    return Response.json({ error: "Method not allowed" }, { status: 405 });
+  }
+  let body = {};
+  try {
+    body = await request.json();
+  } catch {
+    return Response.json({ error: "Invalid JSON body" }, { status: 400 });
+  }
+  const { status, body: payload } = await runContentRefresh(
+    config,
+    request.headers.get("authorization") ?? void 0,
+    body
+  );
+  return Response.json(payload, { status });
+}
 export {
+  ContentRefreshAuthError,
   ContentStore,
   ContentStoreSDK,
+  assertContentRefreshBasicAuth,
+  createNextPagesApiContentRefreshHandler,
+  encodeBasicAuthCredentials,
+  executeContentRefresh,
   fetchCmsBundles,
   fetchMergedTranslationBundles,
   fetchTranslationBundles,
   getDefaultS3RetryConfig,
+  handleNextAppRouterContentRefresh,
+  postContentRefresh,
   queryCmsBundle,
   trimDepth
 };