@periodic/strontium-next 1.0.0

package/dist/index.js

@@ -0,0 +1,246 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  STRONTIUM_IDEMPOTENCY_HEADER: () => STRONTIUM_IDEMPOTENCY_HEADER,
+  STRONTIUM_REQUEST_ID_HEADER: () => STRONTIUM_REQUEST_ID_HEADER,
+  STRONTIUM_TRACE_HEADER: () => STRONTIUM_TRACE_HEADER,
+  createBrowserStrontiumClient: () => createBrowserStrontiumClient,
+  createEdgeStrontiumClient: () => createServerStrontiumClient,
+  createServerStrontiumClient: () => createServerStrontiumClient,
+  createStrontiumMiddleware: () => createStrontiumMiddleware,
+  extractStrontiumContext: () => extractStrontiumContext,
+  getClientStrontiumClient: () => getClientStrontiumClient,
+  resetClientInstance: () => resetClientInstance,
+  strontiumRevalidateTag: () => strontiumRevalidateTag,
+  strontiumRevalidateTags: () => strontiumRevalidateTags,
+  taggedRequest: () => taggedRequest,
+  withCacheTags: () => withCacheTags,
+  wrapRouteHandler: () => wrapRouteHandler
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/server.ts
+var import_strontium = require("@periodic/strontium");
+function createServerStrontiumClient(options) {
+  const { request, ...clientConfig } = options;
+  const forwardedHeaders = {};
+  if (request) {
+    const headersToForward = [
+      "x-request-id",
+      "x-correlation-id",
+      "x-trace-id",
+      "x-b3-traceid",
+      "x-b3-spanid",
+      "traceparent",
+      "tracestate",
+      "authorization"
+    ];
+    for (const header of headersToForward) {
+      const value = request.headers.get(header);
+      if (value) {
+        forwardedHeaders[header] = value;
+      }
+    }
+  }
+  return (0, import_strontium.createStrontiumClient)({
+    protocolMode: "idempotent",
+    mode: "strict",
+    timeoutMs: 1e4,
+    retry: {
+      enabled: true,
+      maxAttempts: 3,
+      strategy: "exponential",
+      baseDelayMs: 100,
+      jitter: true,
+      retryOn: ["network", "5xx"]
+    },
+    circuitBreaker: {
+      failureThreshold: 5,
+      resetTimeoutMs: 3e4
+    },
+    ...clientConfig,
+    headers: {
+      ...forwardedHeaders,
+      ...clientConfig.headers ?? {}
+    }
+  });
+}
+
+// src/client.ts
+var import_strontium2 = require("@periodic/strontium");
+var _clientInstance = null;
+function getClientStrontiumClient(config) {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  if (!_clientInstance) {
+    _clientInstance = (0, import_strontium2.createStrontiumClient)({
+      dedupe: true,
+      mode: "performance",
+      ...config
+    });
+  }
+  return _clientInstance;
+}
+function resetClientInstance() {
+  _clientInstance = null;
+}
+function createBrowserStrontiumClient(config) {
+  if (typeof window === "undefined") return null;
+  return (0, import_strontium2.createStrontiumClient)({ dedupe: true, mode: "performance", ...config });
+}
+
+// src/middleware.ts
+var STRONTIUM_REQUEST_ID_HEADER = "x-strontium-request-id";
+var STRONTIUM_IDEMPOTENCY_HEADER = "x-strontium-idempotency-key";
+var STRONTIUM_TRACE_HEADER = "x-strontium-trace-id";
+function generateId(prefix) {
+  return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+}
+function createStrontiumMiddleware(options = {}) {
+  const { idempotencyNamespace = "strontium" } = options;
+  return async function strontiumMiddleware(request, next) {
+    const requestId = request.headers.get(STRONTIUM_REQUEST_ID_HEADER) ?? generateId("req");
+    const idempotencyKey = request.headers.get(STRONTIUM_IDEMPOTENCY_HEADER) ?? generateId(idempotencyNamespace);
+    const traceId = request.headers.get("traceparent") ?? request.headers.get("x-trace-id") ?? generateId("trace");
+    const requestHeaders = new Headers(request.headers);
+    requestHeaders.set(STRONTIUM_REQUEST_ID_HEADER, requestId);
+    requestHeaders.set(STRONTIUM_IDEMPOTENCY_HEADER, idempotencyKey);
+    requestHeaders.set(STRONTIUM_TRACE_HEADER, traceId);
+    const response = await next();
+    response.headers.set(STRONTIUM_REQUEST_ID_HEADER, requestId);
+    response.headers.set(STRONTIUM_TRACE_HEADER, traceId);
+    return response;
+  };
+}
+function extractStrontiumContext(request) {
+  return {
+    requestId: request.headers.get(STRONTIUM_REQUEST_ID_HEADER) ?? generateId("req"),
+    idempotencyKey: request.headers.get(STRONTIUM_IDEMPOTENCY_HEADER) ?? generateId("strontium"),
+    traceId: request.headers.get(STRONTIUM_TRACE_HEADER) ?? void 0
+  };
+}
+
+// src/route-handler.ts
+var import_server = require("next/server");
+var import_strontium3 = require("@periodic/strontium");
+function wrapRouteHandler(handler, _options = {}) {
+  return async function wrappedHandler(request, context) {
+    try {
+      return await handler(request, context);
+    } catch (err) {
+      return mapErrorToResponse(err);
+    }
+  };
+}
+function mapErrorToResponse(err) {
+  if (err instanceof import_strontium3.CircuitOpenError) {
+    return import_server.NextResponse.json(
+      { error: "Service temporarily unavailable", code: err.code },
+      { status: 503, headers: { "Retry-After": "30" } }
+    );
+  }
+  if (err instanceof import_strontium3.TimeoutError) {
+    return import_server.NextResponse.json(
+      { error: "Upstream request timed out", code: err.code },
+      { status: 504 }
+    );
+  }
+  if (err instanceof import_strontium3.RetryExhaustedError) {
+    return import_server.NextResponse.json(
+      { error: "Upstream service unavailable after retries", code: err.code },
+      { status: 502 }
+    );
+  }
+  if (err instanceof import_strontium3.ResponseValidationError) {
+    return import_server.NextResponse.json(
+      { error: "Upstream response failed validation", code: err.code },
+      { status: 502 }
+    );
+  }
+  if (err instanceof import_strontium3.IntegrityViolationError) {
+    return import_server.NextResponse.json(
+      { error: "Request integrity violation", code: err.code },
+      { status: 409 }
+    );
+  }
+  if (err instanceof import_strontium3.NetworkError) {
+    return import_server.NextResponse.json(
+      { error: "Network error communicating with upstream", code: err.code },
+      { status: 502 }
+    );
+  }
+  return import_server.NextResponse.json({ error: "Internal server error" }, { status: 500 });
+}
+
+// src/cache.ts
+function withCacheTags(headers, tags) {
+  return {
+    ...headers,
+    // Next.js reads cache tags from this header in fetch()
+    "x-next-cache-tags": tags.join(",")
+  };
+}
+function taggedRequest(request, tags) {
+  return {
+    ...request,
+    headers: withCacheTags(request.headers ?? {}, tags)
+  };
+}
+async function strontiumRevalidateTag(tag) {
+  try {
+    const { revalidateTag } = await import("next/cache");
+    revalidateTag(tag);
+  } catch {
+  }
+}
+async function strontiumRevalidateTags(tags) {
+  await Promise.all(tags.map(strontiumRevalidateTag));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  STRONTIUM_IDEMPOTENCY_HEADER,
+  STRONTIUM_REQUEST_ID_HEADER,
+  STRONTIUM_TRACE_HEADER,
+  createBrowserStrontiumClient,
+  createEdgeStrontiumClient,
+  createServerStrontiumClient,
+  createStrontiumMiddleware,
+  extractStrontiumContext,
+  getClientStrontiumClient,
+  resetClientInstance,
+  strontiumRevalidateTag,
+  strontiumRevalidateTags,
+  taggedRequest,
+  withCacheTags,
+  wrapRouteHandler
+});

package/dist/index.mjs

@@ -0,0 +1,75 @@
+import {
+  STRONTIUM_IDEMPOTENCY_HEADER,
+  STRONTIUM_REQUEST_ID_HEADER,
+  STRONTIUM_TRACE_HEADER,
+  createServerStrontiumClient,
+  createStrontiumMiddleware,
+  extractStrontiumContext,
+  wrapRouteHandler
+} from "./chunk-5YPMJUNO.mjs";
+
+// src/client.ts
+import { createStrontiumClient } from "@periodic/strontium";
+var _clientInstance = null;
+function getClientStrontiumClient(config) {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  if (!_clientInstance) {
+    _clientInstance = createStrontiumClient({
+      dedupe: true,
+      mode: "performance",
+      ...config
+    });
+  }
+  return _clientInstance;
+}
+function resetClientInstance() {
+  _clientInstance = null;
+}
+function createBrowserStrontiumClient(config) {
+  if (typeof window === "undefined") return null;
+  return createStrontiumClient({ dedupe: true, mode: "performance", ...config });
+}
+
+// src/cache.ts
+function withCacheTags(headers, tags) {
+  return {
+    ...headers,
+    // Next.js reads cache tags from this header in fetch()
+    "x-next-cache-tags": tags.join(",")
+  };
+}
+function taggedRequest(request, tags) {
+  return {
+    ...request,
+    headers: withCacheTags(request.headers ?? {}, tags)
+  };
+}
+async function strontiumRevalidateTag(tag) {
+  try {
+    const { revalidateTag } = await import("next/cache");
+    revalidateTag(tag);
+  } catch {
+  }
+}
+async function strontiumRevalidateTags(tags) {
+  await Promise.all(tags.map(strontiumRevalidateTag));
+}
+export {
+  STRONTIUM_IDEMPOTENCY_HEADER,
+  STRONTIUM_REQUEST_ID_HEADER,
+  STRONTIUM_TRACE_HEADER,
+  createBrowserStrontiumClient,
+  createServerStrontiumClient as createEdgeStrontiumClient,
+  createServerStrontiumClient,
+  createStrontiumMiddleware,
+  extractStrontiumContext,
+  getClientStrontiumClient,
+  resetClientInstance,
+  strontiumRevalidateTag,
+  strontiumRevalidateTags,
+  taggedRequest,
+  withCacheTags,
+  wrapRouteHandler
+};

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "@periodic/strontium-next",
+  "version": "1.0.0",
+  "description": "Production-grade Next.js integration for @periodic/strontium — App Router, Pages Router, Edge, and Middleware all covered",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./edge": {
+      "types": "./dist/edge.d.ts",
+      "import": "./dist/edge.mjs",
+      "require": "./dist/edge.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts src/edge.ts --format esm,cjs --dts --clean --external next @periodic/strontium",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src tests --ext .ts",
+    "lint:fix": "eslint src tests --ext .ts --fix",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "format:check": "prettier --check \"src/**/*.ts\"",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run format && npm run build && npm run test"
+  },
+  "keywords": [
+    "next",
+    "nextjs",
+    "http",
+    "client",
+    "middleware",
+    "app-router",
+    "pages-router",
+    "edge",
+    "typescript",
+    "strontium"
+  ],
+  "author": "Uday Thakur <udaythakurwork@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/udaythakur7469/periodic-strontium-next.git"
+  },
+  "bugs": {
+    "url": "https://github.com/udaythakur7469/periodic-strontium-next/issues"
+  },
+  "homepage": "https://github.com/udaythakur7469/periodic-strontium-next#readme",
+  "peerDependencies": {
+    "@periodic/strontium": ">=1.0.0",
+    "next": ">=13.0.0"
+  },
+  "devDependencies": {
+    "@periodic/strontium": "^1.0.0",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.12.7",
+    "@typescript-eslint/eslint-plugin": "^7.0.0",
+    "@typescript-eslint/parser": "^7.0.0",
+    "eslint": "^8.57.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.1.2",
+    "jest": "^29.7.0",
+    "jest-environment-node": "^29.7.0",
+    "next": "^14.2.3",
+    "prettier": "^3.2.5",
+    "ts-jest": "^29.1.2",
+    "tsup": "^8.0.2",
+    "typescript": "^5.4.5"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "sideEffects": false
+}