c8y-nitro 0.10.3 → 0.11.0

package/dist/{client-BmSKIcuq.mjs → tenant-0MBgBY_o.mjs}

@@ -1,12 +1,12 @@
-import { t as createError } from "./logging-BUYT8Z2V.mjs";
-import { BasicAuth, Client, MicroserviceClientRequestAuth } from "@c8y/client";
+import { t as createError } from "./logging-B1PuWdiF.mjs";
+import process from "node:process";
+import { useRuntimeConfig } from "nitro/runtime-config";
 import { defineCachedFunction } from "nitro/cache";
 import { Buffer } from "node:buffer";
 import { createHash, randomBytes } from "node:crypto";
-import process from "node:process";
-import { useRuntimeConfig } from "nitro/runtime-config";
+import { Client, MicroserviceClientRequestAuth } from "@c8y/client";
 import { useNitroHooks } from "nitro/app";
-//#region src/utils/internal/common.ts
+// src/utils/internal/common.ts
 /**
 * Whether two sets of tenant credentials are equivalent for the purposes of
 * change detection: same tenant, user, and password. Used to detect a
@@ -41,119 +41,7 @@ function convertRequestHeadersToC8yFormat(request) {
 	if (cookie) headers.cookie = cookie;
 	return headers;
 }
-//#endregion
-//#region src/utils/internal/tenant.ts
-const USER_TENANT_CACHE_SALT = randomBytes(32).toString("hex");
-function getCookieValue(cookieHeader, name) {
-	try {
-		const value = cookieHeader?.match(`(^|;)\\s*${name}\\s*=\\s*([^;]+)`);
-		return value ? value.pop() : void 0;
-	} catch {
-		return;
-	}
-}
-function getCurrentUserTenantCacheKeyMaterial(requestOrEvent) {
-	const request = "req" in requestOrEvent ? requestOrEvent.req : requestOrEvent;
-	const cookieAuth = getCookieValue(request.headers.get("cookie"), "authorization");
-	if (cookieAuth) return `cookie:${cookieAuth}`;
-	const authorization = request.headers.get("authorization");
-	if (authorization) return `header:${authorization}`;
-}
-function createCurrentUserTenantCacheKey(requestOrEvent) {
-	const material = getCurrentUserTenantCacheKeyMaterial(requestOrEvent);
-	if (!material) throw new Error("Cannot create current user tenant cache key without auth material");
-	return createHash("sha256").update(USER_TENANT_CACHE_SALT).update(":").update(material).digest("hex");
-}
-function tryGetTenantFromBasicAuth(requestOrEvent) {
-	const authorization = ("req" in requestOrEvent ? requestOrEvent.req : requestOrEvent).headers.get("authorization");
-	if (!authorization?.startsWith("Basic ")) return;
-	try {
-		const decoded = Buffer.from(authorization.slice(6), "base64").toString("utf8");
-		const separatorIndex = decoded.indexOf(":");
-		const userPart = separatorIndex === -1 ? decoded : decoded.slice(0, separatorIndex);
-		const slashIndex = userPart.indexOf("/");
-		if (slashIndex <= 0) return;
-		return userPart.slice(0, slashIndex);
-	} catch {
-		return;
-	}
-}
-const getCurrentUserTenantId = defineCachedFunction(async (requestOrEvent) => {
-	const basicTenant = tryGetTenantFromBasicAuth(requestOrEvent);
-	if (basicTenant) return basicTenant;
-	return (await useUserClient(requestOrEvent).tenant.current()).data.name;
-}, {
-	maxAge: 60,
-	name: "_c8y_nitro_get_current_user_tenant_id",
-	group: "c8y_nitro",
-	swr: false,
-	getKey: (requestOrEvent) => createCurrentUserTenantCacheKey(requestOrEvent),
-	shouldBypassCache: (requestOrEvent) => !getCurrentUserTenantCacheKeyMaterial(requestOrEvent)
-});
-const cachedTenantDomain = defineCachedFunction(async (requestOrEvent, _tenantId) => {
-	return (await useUserClient(requestOrEvent).tenant.current()).data.domainName;
-}, {
-	maxAge: 86400,
-	name: "_c8y_nitro_get_user_tenant_domain",
-	group: "c8y_nitro",
-	swr: false,
-	getKey: (_requestOrEvent, tenantId) => tenantId
-});
-/**
-* Resolves the public domain of the current user's tenant (e.g. `tenant.cumulocity.com`)
-* via `/tenant/currentTenant` with the user's credentials from the current request.
-* @param requestOrEvent - The H3Event or ServerRequest from the current request
-*/
-async function getUserTenantDomain(requestOrEvent) {
-	const tenantId = await getCurrentUserTenantId(requestOrEvent);
-	return cachedTenantDomain(requestOrEvent, tenantId);
-}
-const FAST_DOMAIN_SUCCESS_TTL = 6e4;
-const FAST_DOMAIN_FAILURE_TTL = 1e4;
-const FAST_DOMAIN_MAX_ENTRIES = 1e3;
-const fastDomainCache = /* @__PURE__ */ new Map();
-/**
-* Best-effort variant of {@link getUserTenantDomain} for per-request hot paths:
-* never throws (returns `undefined` for unauthenticated requests or failed
-* lookups) and memoizes results in-process per auth material. Failures are
-* cached briefly so requests with unresolvable credentials don't trigger a
-* platform call each time.
-* @param requestOrEvent - The H3Event or ServerRequest from the current request
-* @param resolveDomain - Domain resolver, only overridden in tests
-*/
-async function tryGetUserTenantDomainFast(requestOrEvent, resolveDomain = getUserTenantDomain) {
-	if (!getCurrentUserTenantCacheKeyMaterial(requestOrEvent)) return;
-	const key = createCurrentUserTenantCacheKey(requestOrEvent);
-	const now = Date.now();
-	const cached = fastDomainCache.get(key);
-	if (cached && cached.expiresAt > now) return cached.domain;
-	let domain;
-	try {
-		domain = await resolveDomain(requestOrEvent);
-	} catch {
-		domain = void 0;
-	}
-	if (!fastDomainCache.has(key) && fastDomainCache.size >= FAST_DOMAIN_MAX_ENTRIES) fastDomainCache.delete(fastDomainCache.keys().next().value);
-	fastDomainCache.set(key, {
-		domain,
-		expiresAt: now + (domain ? FAST_DOMAIN_SUCCESS_TTL : FAST_DOMAIN_FAILURE_TTL)
-	});
-	return domain;
-}
-/**
-* Builds the public URL a request is reachable at through the platform proxy:
-* `https://<tenant domain>/service/<contextPath><pathname><search>`.
-* The proxy strips the `/service/<contextPath>` prefix before the request
-* reaches the microservice, so it is re-added here.
-* @param tenantDomain - Public domain of the tenant (e.g. `tenant.cumulocity.com`)
-* @param contextPath - Context path of the microservice
-* @param url - URL the request was received with (only pathname and search are used)
-*/
-function buildPublicRequestUrl(tenantDomain, contextPath, url) {
-	return new URL(`https://${tenantDomain}/service/${contextPath}${url.pathname}${url.search}`);
-}
-//#endregion
-//#region src/utils/credentials.ts
+// src/utils/credentials.ts
 let prevCredentials = null;
 function shouldEmitTenantCredentialsUpdated(prev, next) {
 	if (!prev) return true;
@@ -247,8 +135,7 @@ const useDeployedTenantCredentials = Object.assign(async () => {
 		return await useDeployedTenantCredentials();
 	}
 });
-//#endregion
-//#region src/utils/client.ts
+// src/utils/client.ts
 /**
 * Creates a Cumulocity client authenticated with the current user's credentials.\
 * Extracts credentials from the Authorization header of the current request.
@@ -266,30 +153,119 @@ function useUserClient(requestOrEvent) {
 	const auth = new MicroserviceClientRequestAuth(headers);
 	const client = new Client(auth, process.env.C8Y_BASEURL);
 	const forwardedHost = request.headers.get("x-forwarded-host")?.split(",")[0]?.trim();
-	client.core.defaultHeaders["X-Forwarded-Host"] = forwardedHost || process.env.C8Y_BASEURL;
+	if (forwardedHost) client.core.defaultHeaders["X-Forwarded-Host"] = forwardedHost;
 	request.context ??= {};
 	request.context["c8y_user_client"] = client;
 	return client;
 }
+// src/utils/internal/tenant.ts
+const USER_TENANT_CACHE_SALT = randomBytes(32).toString("hex");
+function getCookieValue(cookieHeader, name) {
+	try {
+		const value = cookieHeader?.match(`(^|;)\\s*${name}\\s*=\\s*([^;]+)`);
+		return value ? value.pop() : void 0;
+	} catch {
+		return;
+	}
+}
+function getCurrentUserTenantCacheKeyMaterial(requestOrEvent) {
+	const request = "req" in requestOrEvent ? requestOrEvent.req : requestOrEvent;
+	const cookieAuth = getCookieValue(request.headers.get("cookie"), "authorization");
+	if (cookieAuth) return `cookie:${cookieAuth}`;
+	const authorization = request.headers.get("authorization");
+	if (authorization) return `header:${authorization}`;
+}
+function createCurrentUserTenantCacheKey(requestOrEvent) {
+	const material = getCurrentUserTenantCacheKeyMaterial(requestOrEvent);
+	if (!material) throw new Error("Cannot create current user tenant cache key without auth material");
+	return createHash("sha256").update(USER_TENANT_CACHE_SALT).update(":").update(material).digest("hex");
+}
+function tryGetTenantFromBasicAuth(requestOrEvent) {
+	const authorization = ("req" in requestOrEvent ? requestOrEvent.req : requestOrEvent).headers.get("authorization");
+	if (!authorization?.startsWith("Basic ")) return;
+	try {
+		const decoded = Buffer.from(authorization.slice(6), "base64").toString("utf8");
+		const separatorIndex = decoded.indexOf(":");
+		const userPart = separatorIndex === -1 ? decoded : decoded.slice(0, separatorIndex);
+		const slashIndex = userPart.indexOf("/");
+		if (slashIndex <= 0) return;
+		return userPart.slice(0, slashIndex);
+	} catch {
+		return;
+	}
+}
+const getCurrentUserTenantId = defineCachedFunction(async (requestOrEvent) => {
+	const basicTenant = tryGetTenantFromBasicAuth(requestOrEvent);
+	if (basicTenant) return basicTenant;
+	return (await useUserClient(requestOrEvent).tenant.current()).data.name;
+}, {
+	maxAge: 60,
+	name: "_c8y_nitro_get_current_user_tenant_id",
+	group: "c8y_nitro",
+	swr: false,
+	getKey: (requestOrEvent) => createCurrentUserTenantCacheKey(requestOrEvent),
+	shouldBypassCache: (requestOrEvent) => !getCurrentUserTenantCacheKeyMaterial(requestOrEvent)
+});
+const cachedTenantDomain = defineCachedFunction(async (requestOrEvent, _tenantId) => {
+	return (await useUserClient(requestOrEvent).tenant.current()).data.domainName;
+}, {
+	maxAge: 86400,
+	name: "_c8y_nitro_get_user_tenant_domain",
+	group: "c8y_nitro",
+	swr: false,
+	getKey: (_requestOrEvent, tenantId) => tenantId
+});
 /**
-* Creates a Cumulocity client for the tenant where this microservice is deployed.\
-* Uses the bootstrap tenant ID from runtime config to identify the deployed tenant.\
-* @returns A configured Cumulocity Client instance for the deployed tenant
-* @example
-* // Get client for the tenant hosting this microservice:
-* const client = await useDeployedTenantClient()
-* const { data } = await client.application.list()
+* Resolves the public domain of the current user's tenant (e.g. `tenant.cumulocity.com`)
+* via `/tenant/currentTenant` with the user's credentials from the current request.
+* @param requestOrEvent - The H3Event or ServerRequest from the current request
 */
-async function useDeployedTenantClient() {
-	const creds = await useSubscribedTenantCredentials();
-	const tenant = process.env.C8Y_BOOTSTRAP_TENANT;
-	if (!creds[tenant]) throw createError({
-		message: `No subscribed tenant credentials found for tenant '${tenant}'`,
-		status: 500
+async function getUserTenantDomain(requestOrEvent) {
+	const tenantId = await getCurrentUserTenantId(requestOrEvent);
+	return cachedTenantDomain(requestOrEvent, tenantId);
+}
+const FAST_DOMAIN_SUCCESS_TTL = 6e4;
+const FAST_DOMAIN_FAILURE_TTL = 1e4;
+const FAST_DOMAIN_MAX_ENTRIES = 1e3;
+const fastDomainCache = /* @__PURE__ */ new Map();
+/**
+* Best-effort variant of {@link getUserTenantDomain} for per-request hot paths:
+* never throws (returns `undefined` for unauthenticated requests or failed
+* lookups) and memoizes results in-process per auth material. Failures are
+* cached briefly so requests with unresolvable credentials don't trigger a
+* platform call each time.
+* @param requestOrEvent - The H3Event or ServerRequest from the current request
+* @param resolveDomain - Domain resolver, only overridden in tests
+*/
+async function tryGetUserTenantDomainFast(requestOrEvent, resolveDomain = getUserTenantDomain) {
+	if (!getCurrentUserTenantCacheKeyMaterial(requestOrEvent)) return;
+	const key = createCurrentUserTenantCacheKey(requestOrEvent);
+	const now = Date.now();
+	const cached = fastDomainCache.get(key);
+	if (cached && cached.expiresAt > now) return cached.domain;
+	let domain;
+	try {
+		domain = await resolveDomain(requestOrEvent);
+	} catch {
+		domain = void 0;
+	}
+	if (!fastDomainCache.has(key) && fastDomainCache.size >= FAST_DOMAIN_MAX_ENTRIES) fastDomainCache.delete(fastDomainCache.keys().next().value);
+	fastDomainCache.set(key, {
+		domain,
+		expiresAt: now + (domain ? FAST_DOMAIN_SUCCESS_TTL : FAST_DOMAIN_FAILURE_TTL)
 	});
-	const client = new Client(new BasicAuth(creds[tenant]), process.env.C8Y_BASEURL);
-	client.core.tenant = tenant;
-	return client;
+	return domain;
+}
+/**
+* Builds the public URL a request is reachable at through the platform proxy:
+* `https://<tenant domain>/service/<contextPath><pathname><search>`.
+* The proxy strips the `/service/<contextPath>` prefix before the request
+* reaches the microservice, so it is re-added here.
+* @param tenantDomain - Public domain of the tenant (e.g. `tenant.cumulocity.com`)
+* @param contextPath - Context path of the microservice
+* @param url - URL the request was received with (only pathname and search are used)
+*/
+function buildPublicRequestUrl(tenantDomain, contextPath, url) {
+	return new URL(`https://${tenantDomain}/service/${contextPath}${url.pathname}${url.search}`);
 }
-//#endregion
-export { buildPublicRequestUrl as n, tryGetUserTenantDomainFast as r, useDeployedTenantClient as t };
+export { tryGetUserTenantDomainFast as n, buildPublicRequestUrl as t };

package/dist/testing/setup.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/testing/setup.mjs

@@ -0,0 +1,62 @@
+import { t as DEFAULTS } from "../defaults-CrrCinRJ.mjs";
+import { _ as FakeWebSocket, a as unhandledMessage, b as waitForRealtimeStartup, c as splitPath, i as platform, o as compileRoute, r as markRunning, s as matchRoute, v as realtime, y as trackInflight } from "../scope-CxEPZ74p.mjs";
+import { t as setTestingHooks } from "../testing-D5VjeD-F.mjs";
+import process from "node:process";
+import { FetchClient } from "@c8y/client";
+import { afterEach, beforeAll, beforeEach, expect, inject } from "vitest";
+// src/testing/setup.ts
+FetchClient.prototype.fetch = async function(url, init) {
+	const options = this.adjustOptionsForFormData(this.getFetchOptions(init));
+	const fullUrl = new URL(this.getUrl(url, init), process.env.C8Y_BASEURL || DEFAULTS.baseUrl);
+	const body = options.body;
+	if (body && typeof body.getBuffer === "function" && typeof body.getBoundary === "function") {
+		const headers = new Headers(options.headers);
+		headers.set("content-type", `multipart/form-data; boundary=${body.getBoundary()}`);
+		return platform.fetch(new Request(fullUrl, {
+			...options,
+			headers,
+			body: body.getBuffer()
+		}));
+	}
+	return platform.fetch(new Request(fullUrl, options));
+};
+const originalFetch = globalThis.fetch;
+globalThis.fetch = (async (input, init) => {
+	const request = new Request(input, init);
+	const platformOrigin = new URL(process.env.C8Y_BASEURL || DEFAULTS.baseUrl).origin;
+	return new URL(request.url).origin === platformOrigin ? platform.fetch(request) : originalFetch(input, init);
+});
+setTestingHooks({ WebSocket: FakeWebSocket });
+platform.prepare(inject("c8yNitroTest") ?? {});
+trackInflight(() => platform.inflight);
+beforeAll(async () => {
+	markRunning();
+	const { useNitroApp } = await import("nitro/app");
+	await useNitroApp().ready;
+	await waitForRealtimeStartup();
+});
+beforeEach(async () => {
+	platform.baseline = inject("c8yNitroTest") ?? {};
+	platform.reset();
+	realtime.dropPending();
+	const { useSubscribedTenantCredentials, useTenantOptions } = await import("c8y-nitro/utils");
+	await useSubscribedTenantCredentials.invalidate();
+	await useTenantOptions.invalidateAll();
+});
+afterEach(() => {
+	const unhandled = platform.unhandled;
+	platform.unhandled = [];
+	if (unhandled.length > 0 && platform.onUnhandledRequest === "error") throw new Error(unhandledMessage(unhandled));
+});
+expect.extend({ toHaveReceived(_received, pattern, options = {}) {
+	const route = compileRoute(pattern);
+	const matching = platform.calls.filter((call) => matchRoute(route, call.method, splitPath(call.path)));
+	const pass = options.times === void 0 ? matching.length > 0 : matching.length === options.times;
+	const expected = options.times === void 0 ? "at least one request" : `${options.times} request(s)`;
+	const received = platform.calls.length > 0 ? platform.calls.map((call) => `  ${call.method} ${call.path}`).join("\n") : "  (none)";
+	return {
+		pass,
+		message: () => pass ? `expected no request matching ${pattern}, but got ${matching.length}` : `expected ${expected} matching ${pattern}, got ${matching.length}.\nRequests to the platform in this test:\n${received}`
+	};
+} });
+export {};

package/dist/testing/vite.d.mts

@@ -0,0 +1,26 @@
+import { i as C8yTestOptions } from "../types-D663gk80.mjs";
+import { Plugin } from "vite";
+/**
+ * Vite plugin that turns Nitro's Vitest environment into a fake Cumulocity
+ * tenant. Add it next to `nitro()` in `vitest.config.ts`:
+ *
+ * - Requests of the real `@c8y/client` are answered in memory by the fake
+ *   tenant behind `c8y` from `c8y-nitro/testing`. Nothing reaches the network.
+ * - The `C8Y_*` dev and bootstrap env is set (existing `test.env` values win).
+ * - Before every test, the tenant is reset to `options` and c8y-nitro's caches
+ *   are cleared.
+ *
+ * @example
+ * ```ts
+ * import { nitro } from 'nitro/vite'
+ * import { c8yTest } from 'c8y-nitro/testing/vite'
+ * import { defineConfig } from 'vitest/config'
+ *
+ * export default defineConfig({
+ *   plugins: [nitro(), c8yTest({ user: { userName: 'alice', roles: ['ROLE_ORDERS_READ'] } })],
+ * })
+ * ```
+ * @param options - Baseline state of the fake tenant for every test
+ */
+export declare function c8yTest(options?: C8yTestOptions): Plugin;
+export type { C8yTestOptions };

package/dist/testing/vite.mjs

@@ -0,0 +1,58 @@
+import { n as PROVIDE_KEY, t as DEFAULTS } from "../defaults-CrrCinRJ.mjs";
+import { fileURLToPath } from "node:url";
+// src/testing/vite.ts
+/**
+* Vite plugin that turns Nitro's Vitest environment into a fake Cumulocity
+* tenant. Add it next to `nitro()` in `vitest.config.ts`:
+*
+* - Requests of the real `@c8y/client` are answered in memory by the fake
+*   tenant behind `c8y` from `c8y-nitro/testing`. Nothing reaches the network.
+* - The `C8Y_*` dev and bootstrap env is set (existing `test.env` values win).
+* - Before every test, the tenant is reset to `options` and c8y-nitro's caches
+*   are cleared.
+*
+* @example
+* ```ts
+* import { nitro } from 'nitro/vite'
+* import { c8yTest } from 'c8y-nitro/testing/vite'
+* import { defineConfig } from 'vitest/config'
+*
+* export default defineConfig({
+*   plugins: [nitro(), c8yTest({ user: { userName: 'alice', roles: ['ROLE_ORDERS_READ'] } })],
+* })
+* ```
+* @param options - Baseline state of the fake tenant for every test
+*/
+function c8yTest(options = {}) {
+	const setupFile = fileURLToPath(new URL("./setup.mjs", import.meta.url));
+	const tenant = options.tenant ?? DEFAULTS.tenant;
+	const user = options.user === void 0 ? DEFAULTS.user : options.user;
+	return {
+		name: "c8y-nitro:test",
+		config(config) {
+			const env = {
+				C8Y_BASEURL: options.baseUrl ?? DEFAULTS.baseUrl,
+				C8Y_BOOTSTRAP_TENANT: tenant,
+				C8Y_BOOTSTRAP_USER: DEFAULTS.bootstrapUser,
+				C8Y_BOOTSTRAP_PASSWORD: DEFAULTS.bootstrapPassword,
+				C8Y_DEVELOPMENT_TENANT: user?.tenant ?? tenant,
+				C8Y_DEVELOPMENT_USER: user?.userName ?? DEFAULTS.user.userName,
+				C8Y_DEVELOPMENT_PASSWORD: DEFAULTS.developmentPassword
+			};
+			return { test: {
+				setupFiles: [setupFile],
+				env: {
+					...env,
+					...config.test?.env
+				}
+			} };
+		},
+		configEnvironment(name) {
+			return name === "nitro" ? { resolve: { external: ["@c8y/client"] } } : void 0;
+		},
+		configureVitest({ project }) {
+			project.provide(PROVIDE_KEY, JSON.parse(JSON.stringify(options)));
+		}
+	};
+}
+export { c8yTest };

package/dist/testing-D5VjeD-F.mjs

@@ -0,0 +1,14 @@
+// src/utils/internal/testing.ts
+/**
+* Test seam for `c8y-nitro/testing`. Its setup file stores replacements here
+* (on `globalThis`, so the server's copy of c8y-nitro sees them); in
+* production nothing is set and every helper returns `undefined`.
+*/
+const TESTING_HOOKS = Symbol.for("c8y-nitro.testing");
+function useTestingHooks() {
+	return globalThis[TESTING_HOOKS];
+}
+function setTestingHooks(hooks) {
+	globalThis[TESTING_HOOKS] = hooks;
+}
+export { useTestingHooks as n, setTestingHooks as t };