@archiva/archiva-nextjs 0.2.7 → 0.2.8

package/dist/chunk-SQG3CD5M.mjs

@@ -0,0 +1,275 @@
+// src/types.ts
+var ArchivaError = class extends Error {
+  constructor(params) {
+    super(params.message);
+    this.statusCode = params.statusCode;
+    this.code = params.code;
+    this.retryAfterSeconds = params.retryAfterSeconds;
+    this.details = params.details;
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.archiva.app";
+function buildHeaders(apiKey, overrides) {
+  const headers = new Headers(overrides);
+  headers.set("X-Project-Key", apiKey);
+  return headers;
+}
+async function parseError(response) {
+  const retryAfterHeader = response.headers.get("Retry-After");
+  const retryAfterSeconds = retryAfterHeader ? Number(retryAfterHeader) : void 0;
+  let payload = void 0;
+  try {
+    payload = await response.json();
+  } catch {
+    payload = void 0;
+  }
+  const errorMessage = typeof payload === "object" && payload !== null && "error" in payload ? String(payload.error) : response.statusText;
+  let code = "HTTP_ERROR";
+  if (response.status === 401) {
+    code = "UNAUTHORIZED";
+  } else if (response.status === 403) {
+    code = "FORBIDDEN";
+  } else if (response.status === 413) {
+    code = "PAYLOAD_TOO_LARGE";
+  } else if (response.status === 429) {
+    code = "RATE_LIMITED";
+  } else if (response.status === 409) {
+    code = "IDEMPOTENCY_CONFLICT";
+  }
+  throw new ArchivaError({
+    statusCode: response.status,
+    code,
+    message: errorMessage,
+    retryAfterSeconds,
+    details: payload
+  });
+}
+function createRequestId() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+}
+function createIdempotencyKey() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return `idem_${crypto.randomUUID()}`;
+  }
+  return `idem_${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+}
+async function loadEvents(apiKey, params, baseUrl = DEFAULT_BASE_URL) {
+  const url = new URL(`${baseUrl}/api/events`);
+  if (params.entityId) {
+    url.searchParams.set("entityId", params.entityId);
+  }
+  if (params.actorId) {
+    url.searchParams.set("actorId", params.actorId);
+  }
+  if (params.entityType) {
+    url.searchParams.set("entityType", params.entityType);
+  }
+  if (params.actorType) {
+    url.searchParams.set("actorType", params.actorType);
+  }
+  if (params.limit) {
+    url.searchParams.set("limit", String(params.limit));
+  }
+  if (params.cursor) {
+    url.searchParams.set("cursor", params.cursor);
+  }
+  const response = await fetch(url.toString(), {
+    headers: buildHeaders(apiKey)
+  });
+  if (!response.ok) {
+    await parseError(response);
+  }
+  const payload = await response.json();
+  if (!payload || typeof payload !== "object" || !Array.isArray(payload.items)) {
+    throw new ArchivaError({
+      statusCode: response.status,
+      code: "HTTP_ERROR",
+      message: "Invalid response format",
+      details: payload
+    });
+  }
+  const items = payload.items.map((item) => {
+    if (typeof item !== "object" || item === null) {
+      throw new ArchivaError({
+        statusCode: response.status,
+        code: "HTTP_ERROR",
+        message: "Invalid item format in response",
+        details: item
+      });
+    }
+    const event = item;
+    return {
+      id: String(event.id ?? ""),
+      receivedAt: String(event.receivedAt ?? ""),
+      action: String(event.action ?? ""),
+      entityType: String(event.entityType ?? ""),
+      entityId: String(event.entityId ?? ""),
+      actorId: event.actorId !== null && event.actorId !== void 0 ? String(event.actorId) : null,
+      actorType: event.actorType && (event.actorType === "user" || event.actorType === "service" || event.actorType === "system") ? event.actorType : void 0,
+      actorDisplay: event.actorDisplay !== null && event.actorDisplay !== void 0 ? String(event.actorDisplay) : void 0,
+      source: event.source !== null && event.source !== void 0 ? String(event.source) : null
+    };
+  });
+  return {
+    items,
+    nextCursor: typeof payload.nextCursor === "string" ? payload.nextCursor : void 0
+  };
+}
+async function createEvent(apiKey, event, options, baseUrl = DEFAULT_BASE_URL) {
+  const idempotencyKey = options?.idempotencyKey ?? createIdempotencyKey();
+  const requestId = options?.requestId ?? createRequestId();
+  const headers = buildHeaders(apiKey, {
+    "Content-Type": "application/json",
+    "Idempotency-Key": idempotencyKey,
+    "X-Request-Id": requestId
+  });
+  const response = await fetch(`${baseUrl}/api/ingest/event`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(event)
+  });
+  if (!response.ok) {
+    await parseError(response);
+  }
+  const payload = await response.json();
+  if (!payload || typeof payload !== "object" || typeof payload.eventId !== "string") {
+    throw new ArchivaError({
+      statusCode: response.status,
+      code: "HTTP_ERROR",
+      message: "Invalid response format",
+      details: payload
+    });
+  }
+  return {
+    eventId: payload.eventId,
+    replayed: response.status === 200
+  };
+}
+async function createEvents(apiKey, events, options, baseUrl = DEFAULT_BASE_URL) {
+  const results = await Promise.all(
+    events.map(
+      (event, index) => createEvent(
+        apiKey,
+        event,
+        {
+          ...options,
+          idempotencyKey: options?.idempotencyKey ? `${options.idempotencyKey}_${index}` : void 0
+        },
+        baseUrl
+      )
+    )
+  );
+  return {
+    eventIds: results.map((r) => r.eventId)
+  };
+}
+
+// src/actions.ts
+var DEFAULT_BASE_URL2 = "https://api.archiva.app";
+function getApiKey(apiKey) {
+  const resolvedKey = apiKey || process.env.ARCHIVA_SECRET_KEY;
+  if (!resolvedKey) {
+    throw new Error("ARCHIVA_SECRET_KEY environment variable is required, or provide apiKey prop to ArchivaProvider");
+  }
+  return resolvedKey;
+}
+async function loadEvents2(params, apiKey) {
+  const resolvedApiKey = getApiKey(apiKey);
+  return loadEvents(resolvedApiKey, params, DEFAULT_BASE_URL2);
+}
+async function createEvent2(event, options, apiKey) {
+  const resolvedApiKey = getApiKey(apiKey);
+  return createEvent(resolvedApiKey, event, options, DEFAULT_BASE_URL2);
+}
+async function createEvents2(events, options, apiKey) {
+  const resolvedApiKey = getApiKey(apiKey);
+  return createEvents(resolvedApiKey, events, options, DEFAULT_BASE_URL2);
+}
+
+// src/server/frontendTokens.ts
+import "server-only";
+var DEFAULT_API_BASE_URL = "https://api.archiva.app";
+async function createFrontendTokenGET(projectId, apiBaseUrl = DEFAULT_API_BASE_URL) {
+  const secretKey = process.env.ARCHIVA_SECRET_KEY;
+  if (!secretKey || secretKey.trim().length === 0) {
+    const exists = process.env.ARCHIVA_SECRET_KEY !== void 0;
+    throw new Error(
+      `ARCHIVA_SECRET_KEY environment variable is ${exists ? "empty" : "not configured"}. Please set it in your .env.local file (or .env) with a valid value and restart your Next.js dev server. The variable must be in the project root directory and must not be empty.`
+    );
+  }
+  const keyPrefix = secretKey.substring(0, 10);
+  console.log("[Archiva] Using API key prefix:", keyPrefix + "...", "Length:", secretKey.length);
+  const url = new URL(`${apiBaseUrl}/api/v1/frontend-tokens`);
+  const response = await fetch(url.toString(), {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${secretKey}`
+    },
+    body: JSON.stringify({
+      scopes: ["timeline:read"],
+      ...projectId && { projectId }
+    })
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({ error: response.statusText }));
+    const errorMessage = error.error || `Failed to fetch frontend token: ${response.status}`;
+    if (errorMessage.includes("ARCHIVA_SECRET_KEY") || response.status === 401 || response.status === 403) {
+      throw new Error(
+        `Archiva API authentication failed. Check that your ARCHIVA_SECRET_KEY is valid and has the correct permissions. API error: ${errorMessage}`
+      );
+    }
+    throw new Error(errorMessage);
+  }
+  const data = await response.json();
+  if (!data.token || typeof data.expiresAt !== "number") {
+    throw new Error("Invalid token response format");
+  }
+  return {
+    token: data.token,
+    expiresAt: data.expiresAt
+  };
+}
+
+// src/server/handlers/createFrontendTokenRoute.ts
+import "server-only";
+import { NextResponse } from "next/server";
+var DEFAULT_API_BASE_URL2 = "https://api.archiva.app";
+function createFrontendTokenRoute(options) {
+  return async function GET2(request) {
+    try {
+      const searchParams = request.nextUrl.searchParams;
+      const projectId = searchParams.get("projectId") || void 0;
+      const apiBaseUrl = options?.apiBaseUrl || DEFAULT_API_BASE_URL2;
+      const tokenResponse = await createFrontendTokenGET(projectId, apiBaseUrl);
+      return NextResponse.json(tokenResponse);
+    } catch (error) {
+      console.error("Error fetching frontend token:", error);
+      const message = error instanceof Error ? error.message : "Internal server error";
+      const statusCode = message.includes("ARCHIVA_SECRET_KEY") ? 500 : 500;
+      return NextResponse.json(
+        { error: message },
+        { status: statusCode }
+      );
+    }
+  };
+}
+async function GET(request) {
+  const handler = createFrontendTokenRoute();
+  return handler(request);
+}
+
+export {
+  ArchivaError,
+  loadEvents2 as loadEvents,
+  createEvent2 as createEvent,
+  createEvents2 as createEvents,
+  createFrontendTokenGET,
+  createFrontendTokenRoute,
+  GET
+};

package/dist/index.js

@@ -299,6 +299,9 @@ async function loadEvents(apiKey, params, baseUrl = DEFAULT_BASE_URL) {
   if (params.entityType) {
     url.searchParams.set("entityType", params.entityType);
   }
+  if (params.actorType) {
+    url.searchParams.set("actorType", params.actorType);
+  }
   if (params.limit) {
     url.searchParams.set("limit", String(params.limit));
   }
@@ -320,8 +323,30 @@ async function loadEvents(apiKey, params, baseUrl = DEFAULT_BASE_URL) {
       details: payload
     });
   }
+  const items = payload.items.map((item) => {
+    if (typeof item !== "object" || item === null) {
+      throw new ArchivaError({
+        statusCode: response.status,
+        code: "HTTP_ERROR",
+        message: "Invalid item format in response",
+        details: item
+      });
+    }
+    const event = item;
+    return {
+      id: String(event.id ?? ""),
+      receivedAt: String(event.receivedAt ?? ""),
+      action: String(event.action ?? ""),
+      entityType: String(event.entityType ?? ""),
+      entityId: String(event.entityId ?? ""),
+      actorId: event.actorId !== null && event.actorId !== void 0 ? String(event.actorId) : null,
+      actorType: event.actorType && (event.actorType === "user" || event.actorType === "service" || event.actorType === "system") ? event.actorType : void 0,
+      actorDisplay: event.actorDisplay !== null && event.actorDisplay !== void 0 ? String(event.actorDisplay) : void 0,
+      source: event.source !== null && event.source !== void 0 ? String(event.source) : null
+    };
+  });
   return {
-    items: payload.items,
+    items,
     nextCursor: typeof payload.nextCursor === "string" ? payload.nextCursor : void 0
   };
 }

package/dist/index.mjs

@@ -9,7 +9,7 @@ import {
   createFrontendTokenGET,
   createFrontendTokenRoute,
   loadEvents
-} from "./chunk-WW7LXHTM.mjs";
+} from "./chunk-SQG3CD5M.mjs";
 export {
   ArchivaError,
   ArchivaProvider,

package/dist/server/index.js

@@ -173,6 +173,9 @@ async function loadEvents(apiKey, params, baseUrl = DEFAULT_BASE_URL) {
   if (params.entityType) {
     url.searchParams.set("entityType", params.entityType);
   }
+  if (params.actorType) {
+    url.searchParams.set("actorType", params.actorType);
+  }
   if (params.limit) {
     url.searchParams.set("limit", String(params.limit));
   }
@@ -194,8 +197,30 @@ async function loadEvents(apiKey, params, baseUrl = DEFAULT_BASE_URL) {
       details: payload
     });
   }
+  const items = payload.items.map((item) => {
+    if (typeof item !== "object" || item === null) {
+      throw new ArchivaError({
+        statusCode: response.status,
+        code: "HTTP_ERROR",
+        message: "Invalid item format in response",
+        details: item
+      });
+    }
+    const event = item;
+    return {
+      id: String(event.id ?? ""),
+      receivedAt: String(event.receivedAt ?? ""),
+      action: String(event.action ?? ""),
+      entityType: String(event.entityType ?? ""),
+      entityId: String(event.entityId ?? ""),
+      actorId: event.actorId !== null && event.actorId !== void 0 ? String(event.actorId) : null,
+      actorType: event.actorType && (event.actorType === "user" || event.actorType === "service" || event.actorType === "system") ? event.actorType : void 0,
+      actorDisplay: event.actorDisplay !== null && event.actorDisplay !== void 0 ? String(event.actorDisplay) : void 0,
+      source: event.source !== null && event.source !== void 0 ? String(event.source) : null
+    };
+  });
   return {
-    items: payload.items,
+    items,
     nextCursor: typeof payload.nextCursor === "string" ? payload.nextCursor : void 0
   };
 }

package/dist/server/index.mjs

@@ -5,7 +5,7 @@ import {
   createFrontendTokenGET,
   createFrontendTokenRoute,
   loadEvents
-} from "../chunk-WW7LXHTM.mjs";
+} from "../chunk-SQG3CD5M.mjs";
 export {
   GET,
   createEvent,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archiva/archiva-nextjs",
-  "version": "0.2.07",
+  "version": "0.2.08",
   "description": "Archiva Next.js SDK - Server Actions and Timeline Component",
   "main": "dist/index.js",
   "module": "dist/index.mjs",