c8y-nitro 0.3.0 → 0.4.1

package/dist/module/apiClient.mjs

@@ -1,207 +0,0 @@
-import { createC8yManifestFromNitro } from "./manifest.mjs";
-import { dirname, join, relative } from "node:path";
-import { mkdir, writeFile } from "node:fs/promises";
-
-//#region src/module/apiClient.ts
-/**
-* Converts route path to PascalCase function name.
-* Examples:
-* - /health + get -> GetHealth
-* - /health + post -> PostHealth
-* - /someRoute -> SomeRoute (default)
-* - /[id] or /:id + get -> GetById
-* - /api/[multiple]/[params] -> GetApiByMultipleByParams
-* @param path - The route path (e.g., "/api/[id]" or "/api/:id")
-* @param method - HTTP method (get, post, put, delete, etc.)
-*/
-function generateFunctionName(path, method) {
-	return `${method}${path.replace(/^\//, "").replaceAll(".", "_").replaceAll("*", "").split("/").map((seg) => {
-		if (seg.startsWith("[") && seg.endsWith("]")) return `By${capitalize(seg.slice(1, -1))}`;
-		if (seg.startsWith(":")) return `By${capitalize(seg.slice(1))}`;
-		return capitalize(seg);
-	}).join("") || "Index"}`;
-}
-/**
-* Extracts route parameters from path.
-* Example: "/api/[id]/items/[itemId]" or "/api/:id/items/:itemId" -> [{name: "id", type: "string"}, {name: "itemId", type: "string"}]
-* @param path - The route path to extract parameters from
-*/
-function extractParams(path) {
-	const params = [];
-	const segments = path.split("/");
-	for (const seg of segments) if (seg.startsWith("[") && seg.endsWith("]")) {
-		const name = seg.slice(1, -1);
-		params.push(name);
-	} else if (seg.startsWith(":")) {
-		const name = seg.slice(1);
-		params.push(name);
-	}
-	return params;
-}
-/**
-* Capitalizes first letter of a string.
-* @param str - The string to capitalize
-*/
-function capitalize(str) {
-	return str.charAt(0).toUpperCase() + str.slice(1);
-}
-/**
-* Converts a file name to a valid JavaScript class name.
-* Only allows letters, numbers (not at start), $ and _.
-* Removes or replaces invalid characters and ensures PascalCase.
-* Always prefixed with "Generated" for clarity.
-* @param fileName - The file name to convert
-* @example "my-service-api" -> "GeneratedMyServiceApi"
-* @example "playgroundAPIClient" -> "GeneratedPlaygroundAPIClient"
-* @example "special@chars!" -> "GeneratedSpecialchars"
-*/
-function toValidClassName(fileName) {
-	let cleaned = fileName.replace(/\.(ts|js|mjs|cjs|tsx|jsx)$/, "").replace(/[-_.]/g, " ");
-	cleaned = cleaned.replace(/[^a-zA-Z0-9\s$]/g, "");
-	return `Generated${cleaned.split(/\s+/).filter((word) => word.length > 0).map((word) => capitalize(word)).join("")}`;
-}
-/**
-* Generates TypeScript method code for a route in an Angular service.
-* @param route - Parsed route information including path, method, params, and return type
-*/
-function generateMethod(route) {
-	const hasParams = route.params.length > 0;
-	let inlineParamsType = "";
-	if (hasParams) inlineParamsType = `{ ${route.params.map((name) => `${name}: string | number`).join("; ")} }`;
-	const methodParam = hasParams ? `params: ${inlineParamsType}` : "";
-	const returnTypeAnnotation = `Promise<${route.returnType}>`;
-	let pathExpression = `\`\${this.BASE_PATH}${route.path}\``;
-	if (hasParams) pathExpression = `\`\${this.BASE_PATH}${route.path.replace(/\[([^\]]+)\]/g, (_, paramName) => `\${params.${paramName}}`)}\``;
-	const fetchOptions = `{ method: '${route.method}', headers: { 'Content-Type': 'application/json' } }`;
-	return `  async ${route.functionName}(${methodParam}): ${returnTypeAnnotation} {
-    const response = await this.fetchClient.fetch(${pathExpression}, ${fetchOptions});
-    return this.serialize(response);
-  }`;
-}
-/**
-* Helper types for proper type serialization from Nitro.
-* https://github.com/nitrojs/nitro/blob/67b43f2692a41728a2759462b6982c6872ed3a81/src/types/fetch/_serialize.ts
-*/
-const serializationTypes = `type JsonPrimitive = string | number | boolean | string | number | boolean | null;
-type NonJsonPrimitive = undefined | Function | symbol;
-type IsAny<T> = 0 extends 1 & T ? true : false;
-type FilterKeys<TObj extends object, TFilter> = { [TKey in keyof TObj]: TObj[TKey] extends TFilter ? TKey : never }[keyof TObj];
-type Serialize<T> = IsAny<T> extends true ? any : T extends JsonPrimitive | undefined ? T : T extends Map<any, any> | Set<any> ? Record<string, never> : T extends NonJsonPrimitive ? never : T extends {
-  toJSON: () => infer U;
-} ? U : T extends [] ? [] : T extends [unknown, ...unknown[]] ? SerializeTuple<T> : T extends ReadonlyArray<infer U> ? (U extends NonJsonPrimitive ? null : Serialize<U>)[] : T extends object ? SerializeObject<T> : never;
-type SerializeTuple<T extends [unknown, ...unknown[]]> = { [k in keyof T]: T[k] extends NonJsonPrimitive ? null : Serialize<T[k]> };
-type SerializeObject<T extends object> = { [k in keyof Omit<T, FilterKeys<T, NonJsonPrimitive>>]: Serialize<T[k]> };
-type Simplify<TType> = TType extends any[] | Date ? TType : { [K in keyof TType]: Simplify<TType[K]> };
-type Awaited<T> = T extends PromiseLike<infer U> ? Awaited<U> : T;
-type C8ySerialize<T> = T extends void | undefined | null ? undefined : T extends string ? string : Simplify<Serialize<T>>;
-`;
-/**
-* Generates complete Angular API client service.
-* @param routes - Array of parsed routes to generate methods for
-* @param contextPath - The microservice context path (e.g., "my-service")
-* @param className - The class name for the generated service (e.g., "PlaygroundAPIClient")
-*/
-function generateAPIClient(routes, contextPath, className) {
-	return `/* eslint-disable eslint-comments/no-unlimited-disable */
-/* eslint-disable */
-/**
- * Auto-generated Cumulocity API Client
- * Generated by c8y-nitro
- *
- * This Angular service provides typed methods for all Nitro routes.
- * Each method corresponds to a route handler and returns properly typed responses.
- */
-import { Injectable, inject } from '@angular/core'
-import { FetchClient } from '@c8y/client'
-
-// Type helpers for proper serialization
-${serializationTypes}
-
-@Injectable({ providedIn: 'root' })
-export class ${className} {
-  private readonly BASE_PATH = '/service/${contextPath}';
-  private readonly fetchClient: FetchClient = inject(FetchClient)
-
-  /**
-   * Serializes the response based on content type and body.
-   * - Empty body (null, undefined, void) -> undefined
-   * - text/plain (string) -> raw text
-   * - application/json (number, boolean, object, array) -> JSON parsed
-   */
-  private async serialize(response: Response): Promise<any> {
-    const contentType = response.headers.get('content-type');
-    const text = await response.text();
-    
-    // Handle empty responses (null, undefined, empty return)
-    if (!text || text.length === 0) {
-      return undefined;
-    }
-    
-    // Handle plain text responses (strings)
-    if (contentType?.includes('text/plain')) {
-      return text;
-    }
-    
-    // Handle JSON responses (numbers, booleans, objects, arrays)
-    return JSON.parse(text);
-  }
-
-${routes.map((route) => generateMethod(route)).join("\n\n")}
-}`;
-}
-/**
-* Generates the TypeScript return type for a route handler.
-* @param handlerPath - Absolute path to the route handler file
-* @param outputFile - Absolute path to the output API client file
-* @returns TypeScript return type string with proper serialization wrappers
-*/
-function getReturnType(handlerPath, outputFile) {
-	const relativeHandlerPath = relative(dirname(outputFile), handlerPath);
-	return `C8ySerialize<Awaited<ReturnType<typeof import('${(relativeHandlerPath.startsWith(".") ? relativeHandlerPath : `./${relativeHandlerPath}`).replace(/\.ts$/, "")}').default>>>`;
-}
-/**
-* Writes the generated API client to disk.
-* @param nitro - Nitro instance
-* @param options - Complete module options including apiClient and manifest
-*/
-async function writeAPIClient(nitro, options) {
-	const { apiClient: apiClientOptions } = options;
-	if (!apiClientOptions) {
-		nitro.logger.debug("API client generation skipped: no apiClient options provided");
-		return;
-	}
-	const manifest = await createC8yManifestFromNitro(nitro);
-	const serviceName = manifest.name;
-	const serviceContextPath = apiClientOptions.contextPath ?? manifest.contextPath ?? serviceName;
-	const name = `${serviceName}APIClient`;
-	const rootDir = nitro.options.rootDir;
-	const outputDir = join(rootDir, apiClientOptions.dir);
-	const outputFile = join(outputDir, `${name}.ts`);
-	const routes = (nitro.routing.routes._routes ?? []).filter((route) => {
-		return !route.handler.includes("nitro/dist/runtime/internal");
-	}).map((route) => {
-		const path = route.route;
-		const method = (!route.method ? "GET" : route.method).toUpperCase();
-		const params = extractParams(path);
-		const functionName = generateFunctionName(path, method);
-		const returnType = getReturnType(route.handler, outputFile);
-		return {
-			path: path.replace(/:([^/]+)/g, "[$1]"),
-			method,
-			functionName,
-			params,
-			returnType
-		};
-	});
-	if (routes.length === 0) {
-		nitro.logger.warn("No routes found to generate API client");
-		return;
-	}
-	const code = generateAPIClient(routes, serviceContextPath, toValidClassName(name));
-	await mkdir(outputDir, { recursive: true });
-	await writeFile(outputFile, code, "utf-8");
-	nitro.logger.success(`Generated API client with ${routes.length} routes at: ${relative(rootDir, outputFile)}`);
-}
-
-//#endregion
-export { writeAPIClient };

package/dist/module/autoBootstrap.mjs

@@ -1,54 +0,0 @@
-import { createC8yManifest } from "./manifest.mjs";
-import { createBasicAuthHeader, createMicroservice, findMicroserviceByName, getBootstrapCredentials, subscribeToApplication } from "../cli/utils/c8y-api.mjs";
-import { writeBootstrapCredentials } from "../cli/utils/env-file.mjs";
-import process from "node:process";
-
-//#region src/module/autoBootstrap.ts
-/**
-* Automatically bootstraps the microservice to the development tenant if needed.
-* Runs silently - only logs if bootstrap was performed or if errors occur.
-* @param nitro - Nitro instance
-*/
-async function autoBootstrap(nitro) {
-	try {
-		if ([
-			"C8Y_BOOTSTRAP_TENANT",
-			"C8Y_BOOTSTRAP_USER",
-			"C8Y_BOOTSTRAP_PASSWORD"
-		].every((v) => process.env[v])) return;
-		if ([
-			"C8Y_BASEURL",
-			"C8Y_DEVELOPMENT_TENANT",
-			"C8Y_DEVELOPMENT_USER",
-			"C8Y_DEVELOPMENT_PASSWORD"
-		].filter((v) => !process.env[v]).length > 0) return;
-		const baseUrl = process.env.C8Y_BASEURL.endsWith("/") ? process.env.C8Y_BASEURL.slice(0, -1) : process.env.C8Y_BASEURL;
-		const authHeader = createBasicAuthHeader(process.env.C8Y_DEVELOPMENT_TENANT, process.env.C8Y_DEVELOPMENT_USER, process.env.C8Y_DEVELOPMENT_PASSWORD);
-		const manifest = await createC8yManifest(nitro.options.rootDir, nitro.options.c8y?.manifest, nitro.logger);
-		const existingApp = await findMicroserviceByName(baseUrl, manifest.name, authHeader);
-		let appId;
-		if (existingApp) {
-			appId = existingApp.id;
-			nitro.logger.debug(`Microservice "${manifest.name}" already exists (ID: ${appId}), retrieving bootstrap credentials...`);
-		} else {
-			appId = (await createMicroservice(baseUrl, manifest, authHeader)).id;
-			nitro.logger.debug(`Microservice "${manifest.name}" created (ID: ${appId})`);
-		}
-		await subscribeToApplication(baseUrl, process.env.C8Y_DEVELOPMENT_TENANT, appId, authHeader);
-		const credentials = await getBootstrapCredentials(baseUrl, appId, authHeader);
-		const envFileName = await writeBootstrapCredentials(nitro.options.rootDir, {
-			C8Y_BOOTSTRAP_TENANT: credentials.tenant,
-			C8Y_BOOTSTRAP_USER: credentials.name,
-			C8Y_BOOTSTRAP_PASSWORD: credentials.password
-		});
-		process.env.C8Y_BOOTSTRAP_TENANT = credentials.tenant;
-		process.env.C8Y_BOOTSTRAP_USER = credentials.name;
-		process.env.C8Y_BOOTSTRAP_PASSWORD = credentials.password;
-		nitro.logger.success(`Auto-bootstrap complete! Bootstrap credentials written to ${envFileName}`);
-	} catch (error) {
-		nitro.logger.warn("Auto-bootstrap failed:", error instanceof Error ? error.message : String(error));
-	}
-}
-
-//#endregion
-export { autoBootstrap };

package/dist/module/c8yzip.mjs

@@ -1,66 +0,0 @@
-import { createC8yManifestFromNitro } from "./manifest.mjs";
-import { createDockerImage } from "./docker.mjs";
-import { join } from "pathe";
-import { mkdir, readFile, stat, writeFile } from "fs/promises";
-import JSZip from "jszip";
-import Spinnies from "spinnies";
-import { colors } from "consola/utils";
-
-//#region src/module/c8yzip.ts
-const spinnies = new Spinnies();
-function formatBytes(bytes) {
-	if (bytes === 0) return "0 B";
-	const k = 1024;
-	const sizes = [
-		"B",
-		"kB",
-		"MB",
-		"GB"
-	];
-	const i = Math.floor(Math.log(bytes) / Math.log(k));
-	return `${(bytes / k ** i).toFixed(1)} ${sizes[i]}`;
-}
-/**
-* Resolve the output path for the zip file based on options and manifest
-* @param rootDir - Root directory of the project
-* @param options - Zip options with optional name and outputDir
-* @param manifest - Cumulocity manifest containing name and version
-* @returns Absolute path to the output zip file
-*/
-function resolveZipOutputPath(rootDir, options, manifest) {
-	return join(join(rootDir, options.outputDir ?? "./"), typeof options.name === "function" ? options.name(manifest.name, manifest.version) : options.name ?? `${manifest.name}-${manifest.version}.zip`);
-}
-async function createC8yZip(nitro, options = {}) {
-	const startTime = Date.now();
-	const spinnerName = "c8y-zip";
-	spinnies.add(spinnerName, { text: "Creating Dockerfile..." });
-	spinnies.update(spinnerName, { text: "Building Docker image..." });
-	const imageTarPath = await createDockerImage(nitro);
-	spinnies.update(spinnerName, { text: "Creating manifest..." });
-	const manifest = await createC8yManifestFromNitro(nitro);
-	spinnies.update(spinnerName, { text: "Reading image.tar..." });
-	const imageTarBuffer = await readFile(imageTarPath);
-	spinnies.update(spinnerName, { text: "Building zip file..." });
-	const zip = new JSZip();
-	zip.file("image.tar", imageTarBuffer);
-	zip.file("cumulocity.json", JSON.stringify(manifest, null, 2));
-	const zipBuffer = await zip.generateAsync({
-		type: "nodebuffer",
-		compression: "STORE"
-	});
-	const outputFile = resolveZipOutputPath(nitro.options.rootDir, options, manifest);
-	const outputDir = join(outputFile, "..");
-	spinnies.update(spinnerName, { text: "Writing zip file..." });
-	await mkdir(outputDir, { recursive: true });
-	await writeFile(outputFile, zipBuffer);
-	const zipSize = formatBytes((await stat(outputFile)).size);
-	const duration = Date.now() - startTime;
-	spinnies.remove(spinnerName);
-	spinnies.stopAll();
-	nitro.logger.success(`Cumulocity zip built in ${duration}ms`);
-	nitro.logger.log(colors.gray(`  └─ ${outputFile} (${zipSize})`));
-	nitro.logger.info("Zip file can be uploaded to Cumulocity IoT platform");
-}
-
-//#endregion
-export { createC8yZip };

package/dist/module/constants.mjs

@@ -1,6 +0,0 @@
-//#region src/module/constants.ts
-const GENERATED_LIVENESS_ROUTE = "/_c8y_nitro/liveness";
-const GENERATED_READINESS_ROUTE = "/_c8y_nitro/readiness";
-
-//#endregion
-export { GENERATED_LIVENESS_ROUTE, GENERATED_READINESS_ROUTE };

package/dist/module/docker.mjs

@@ -1,101 +0,0 @@
-import { basename, join } from "node:path";
-import { mkdir, writeFile } from "node:fs/promises";
-import { x } from "tinyexec";
-
-//#region src/module/docker.ts
-/**
-* Generate the Dockerfile content for a Nitro build
-* @param outputDirName - Name of the output directory (e.g., '.output')
-* @returns Dockerfile content as a string
-*/
-function getDockerfileContent(outputDirName) {
-	return `FROM node:24-slim AS runtime
-
-WORKDIR /app
-
-# Copy the Nitro build output
-COPY ${outputDirName}/ ${outputDirName}/
-
-ENV NODE_ENV=production
-ENV PORT=80
-
-EXPOSE 80
-
-# Run the Nitro server entrypoint. Use source maps to aid debugging if present.
-CMD ["node", "--enable-source-maps", "${outputDirName}/server/index.mjs"]`;
-}
-async function checkDockerInstalled() {
-	try {
-		const result = await x("docker", ["--version"]);
-		if (result.exitCode !== 0) return false;
-		if (result.stderr) return false;
-		return true;
-	} catch {
-		return false;
-	}
-}
-async function writeDockerfile(outputDir) {
-	const outputDirName = basename(outputDir);
-	const c8yDir = join(outputDir, "../.c8y");
-	const dockerfilePath = join(c8yDir, "Dockerfile");
-	await mkdir(c8yDir, { recursive: true });
-	await writeFile(dockerfilePath, getDockerfileContent(outputDirName), "utf-8");
-	return c8yDir;
-}
-async function buildDockerImage(nitro, c8yDir) {
-	const imageName = `${nitro.options.rootDir.split("/").pop() || "c8y-app"}:latest`;
-	const buildContext = join(c8yDir, "..");
-	nitro.logger.debug(`Building Docker image: ${imageName}`);
-	nitro.logger.debug(`Build context: ${buildContext}`);
-	try {
-		const result = await x("docker", [
-			"build",
-			"-t",
-			imageName,
-			"-f",
-			join(c8yDir, "Dockerfile"),
-			buildContext
-		]);
-		if (result.stdout) nitro.logger.debug(result.stdout);
-		if (result.stderr) nitro.logger.debug(result.stderr);
-		if (result.exitCode !== 0) throw new Error(`Docker build failed with exit code ${result.exitCode}`, { cause: result.stderr });
-		nitro.logger.debug(`Docker image built successfully: ${imageName}`);
-		return imageName;
-	} catch (error) {
-		throw new Error("Failed to build Docker image", { cause: error });
-	}
-}
-async function saveDockerImageToTar(nitro, c8yDir, imageName) {
-	const imageTarPath = join(c8yDir, "image.tar");
-	nitro.logger.debug(`Saving Docker image to ${imageTarPath}`);
-	try {
-		const result = await x("docker", [
-			"save",
-			"-o",
-			imageTarPath,
-			imageName
-		]);
-		if (result.stderr) nitro.logger.debug(result.stderr);
-		if (result.exitCode !== 0) throw new Error(`Docker save failed with exit code ${result.exitCode}`, { cause: result.stderr });
-		nitro.logger.debug(`Docker image saved to ${imageTarPath}`);
-		return imageTarPath;
-	} catch (error) {
-		throw new Error("Failed to save Docker image to tar file", { cause: error });
-	}
-}
-/**
-* Create a Docker image from the Nitro build output
-* @param nitro Nitro instance
-* @returns Path to the saved Docker image tar file
-*/
-async function createDockerImage(nitro) {
-	if (!await checkDockerInstalled()) throw new Error("Docker is not installed or not available in PATH. Please install Docker to build images.");
-	nitro.logger.debug("Creating Docker image...");
-	const c8yDir = await writeDockerfile(nitro.options.output.dir);
-	const imageTarPath = await saveDockerImageToTar(nitro, c8yDir, await buildDockerImage(nitro, c8yDir));
-	nitro.logger.debug("Docker image creation complete.");
-	return imageTarPath;
-}
-
-//#endregion
-export { createDockerImage };

package/dist/module/manifest.mjs

@@ -1,72 +0,0 @@
-import { GENERATED_LIVENESS_ROUTE, GENERATED_READINESS_ROUTE } from "./constants.mjs";
-import { readPackage } from "pkg-types";
-
-//#region src/module/manifest.ts
-async function readPackageJsonFieldsForManifest(rootDir, logger) {
-	logger?.debug(`Reading package file from ${rootDir}`);
-	const pkg = await readPackage(rootDir);
-	const name = pkg.name?.replace(/^@[^/]+\//, "");
-	const version = pkg.version;
-	const author = pkg.author;
-	const authorName = typeof author === "string" ? author : author?.name;
-	const authorEmail = typeof author === "string" ? void 0 : author?.email;
-	const authorUrl = typeof author === "string" ? void 0 : author?.url;
-	if (!name || !version || !authorName) throw new Error("package.json must contain name, version, and author name fields");
-	const support = typeof pkg.bugs === "string" ? pkg.bugs : pkg.bugs?.url ?? pkg.bugs?.email;
-	const provider = {
-		name: authorName ?? name,
-		domain: authorUrl ?? pkg.homepage,
-		support: support ?? authorEmail
-	};
-	logger?.debug(`Found package.json fields for manifest: name=${name}, version=${version}, provider=${JSON.stringify(provider)}`);
-	return {
-		name,
-		version,
-		provider,
-		contextPath: name
-	};
-}
-/**
-* Creates a Cumulocity manifest from rootDir and options.
-* Standalone function that can be used by CLI or module.
-* @param rootDir - Directory containing package.json
-* @param options - Manifest options
-* @param logger - Optional logger for debug output
-*/
-async function createC8yManifest(rootDir, options = {}, logger) {
-	const { name, version, provider, ...restManifestFields } = await readPackageJsonFieldsForManifest(rootDir, logger);
-	const probeFields = {};
-	if (!options.livenessProbe?.httpGet) probeFields.livenessProbe = {
-		...options.livenessProbe,
-		httpGet: { path: GENERATED_LIVENESS_ROUTE }
-	};
-	if (!options.readinessProbe?.httpGet) probeFields.readinessProbe = {
-		...options.readinessProbe,
-		httpGet: { path: GENERATED_READINESS_ROUTE }
-	};
-	const key = `${name}-key`;
-	const manifest = {
-		...restManifestFields,
-		...probeFields,
-		...options,
-		provider,
-		name,
-		version,
-		apiVersion: "v2",
-		key,
-		type: "MICROSERVICE"
-	};
-	logger?.debug(`Created Cumulocity manifest: ${JSON.stringify(manifest, null, 2)}`);
-	return manifest;
-}
-/**
-* Creates a Cumulocity manifest from a Nitro instance.
-* Convenience wrapper for use in the Nitro module.
-* @param nitro - The Nitro instance
-*/
-async function createC8yManifestFromNitro(nitro) {
-	return createC8yManifest(nitro.options.rootDir, nitro.options.c8y?.manifest, nitro.logger);
-}
-
-//#endregion
-export { createC8yManifest, createC8yManifestFromNitro };

package/dist/module/probeCheck.mjs

@@ -1,30 +0,0 @@
-//#region src/module/probeCheck.ts
-function checkProbes(nitro, manifestOptions = {}) {
-	if (manifestOptions.livenessProbe?.httpGet) {
-		const probe = manifestOptions.livenessProbe.httpGet;
-		checkProbeEndpoint(nitro, probe, "livenessProbe");
-	}
-	if (manifestOptions.readinessProbe?.httpGet) {
-		const probe = manifestOptions.readinessProbe.httpGet;
-		checkProbeEndpoint(nitro, probe, "readinessProbe");
-	}
-}
-function checkProbeEndpoint(nitro, probe, probeType) {
-	const path = probe.path;
-	const method = "GET";
-	const matchingHandlers = nitro.scannedHandlers.filter((h) => h.route === path);
-	if (matchingHandlers.length === 0) {
-		nitro.logger.warn(`${probeType} route "${path}" not found in scanned handlers. The probe will fail at runtime.`);
-		return;
-	}
-	if (!matchingHandlers.some((h) => {
-		if (!h.method) return true;
-		return h.method.toUpperCase() === method.toUpperCase();
-	})) {
-		const availableMethods = matchingHandlers.filter((h) => h.method).map((h) => h.method?.toUpperCase()).join(", ");
-		nitro.logger.warn(`${probeType} route "${path}" exists but does not accept ${method} requests. Available methods: ${availableMethods || "none specified"}. The probe will fail at runtime.`);
-	}
-}
-
-//#endregion
-export { checkProbes };

package/dist/module/register.mjs

@@ -1,58 +0,0 @@
-import { GENERATED_LIVENESS_ROUTE, GENERATED_READINESS_ROUTE } from "./constants.mjs";
-import { join } from "pathe";
-import { fileURLToPath } from "node:url";
-
-//#region src/module/register.ts
-/**
-* Links runtime middleware, handlers, and plugins to the nitro instance.
-* Works by having the handlers in a relative path to this file.
-* Needs to be the same when built.
-* @param nitro - Nitro instance
-* @param options - C8yNitroModuleOptions
-*/
-function registerRuntime(nitro, options = {}) {
-	const thisFilePath = fileURLToPath(new URL(".", import.meta.url));
-	/**
-	* Plugins
-	*/
-	const plugins = [];
-	const c8yVariablesPluginPath = join(thisFilePath, "./runtime/plugins/c8y-variables");
-	plugins.push(c8yVariablesPluginPath);
-	nitro.options.plugins.push(...plugins);
-	/**
-	* Middlewares (global)
-	*/
-	const middlewares = [];
-	const devUserMiddlewarePath = join(thisFilePath, "./runtime/middlewares/dev-user");
-	middlewares.push(devUserMiddlewarePath);
-	nitro.options.handlers.push(...middlewares.map((handler) => ({
-		route: "/**",
-		handler,
-		middleware: true
-	})));
-	/**
-	* Handlers
-	*/
-	const handlers = [];
-	const probeHandlerPath = join(thisFilePath, "./runtime/handlers/liveness-readiness");
-	if (!options.manifest?.livenessProbe?.httpGet) {
-		handlers.push({
-			route: GENERATED_LIVENESS_ROUTE,
-			handler: probeHandlerPath,
-			method: "GET"
-		});
-		nitro.logger.debug(`Generated liveness probe at ${GENERATED_LIVENESS_ROUTE}`);
-	} else nitro.logger.debug("Liveness probe httpGet defined by user; skipping generation");
-	if (!options.manifest?.readinessProbe?.httpGet) {
-		handlers.push({
-			route: GENERATED_READINESS_ROUTE,
-			handler: probeHandlerPath,
-			method: "GET"
-		});
-		nitro.logger.debug(`Generated readiness probe at ${GENERATED_READINESS_ROUTE}`);
-	} else nitro.logger.debug("Readiness probe httpGet defined by user; skipping generation");
-	nitro.options.handlers.push(...handlers);
-}
-
-//#endregion
-export { registerRuntime };

package/dist/module/runtime/handlers/liveness-readiness.ts

@@ -1,7 +0,0 @@
-import { defineEventHandler } from 'nitro/h3'
-
-export default defineEventHandler(async () => {
-  return {
-    status: 'OK',
-  }
-})

package/dist/module/runtime/middlewares/dev-user.ts

@@ -1,25 +0,0 @@
-import { defineHandler } from 'nitro/h3'
-import process from 'node:process'
-import { Buffer } from 'node:buffer'
-import consola from 'consola'
-
-// Middleware to inject a development c8y user into the request during development mode
-export default defineHandler((event) => {
-  if (import.meta.dev) {
-    // in development mode, we check for a development user to inject into the request
-    // this is necessary to correctly use auth middlewares during development
-    const requiredDevEnvVars = ['C8Y_DEVELOPMENT_TENANT', 'C8Y_DEVELOPMENT_USER', 'C8Y_DEVELOPMENT_PASSWORD']
-    const missingDevVars = requiredDevEnvVars.filter((varName) => !process.env[varName])
-    if (missingDevVars.length > 0) {
-      consola.warn(`Missing development environment variables: ${missingDevVars.join(', ')}. Dev user injection will be skipped. Routes requiring authentication or roles will fail.`)
-    } else {
-      // build basic auth header in form "tenant/user:password"
-      const authString = `${process.env.C8Y_DEVELOPMENT_TENANT}/${process.env.C8Y_DEVELOPMENT_USER}:${process.env.C8Y_DEVELOPMENT_PASSWORD}`
-      const encodedAuth = Buffer.from(authString).toString('base64')
-      const authHeader = `Basic ${encodedAuth}`
-
-      // inject auth header into request
-      event.req.headers.set('authorization', authHeader)
-    }
-  }
-})

package/dist/module/runtime/plugins/c8y-variables.ts

@@ -1,24 +0,0 @@
-import { definePlugin } from 'nitro'
-import process from 'node:process'
-
-export default definePlugin(() => {
-  if (import.meta.dev) {
-    const env = process.env
-
-    const requiredVars = ['C8Y_BASEURL', 'C8Y_BOOTSTRAP_TENANT', 'C8Y_BOOTSTRAP_USER', 'C8Y_BOOTSTRAP_PASSWORD']
-    const missingVars = requiredVars.filter((varName) => !env[varName])
-
-    if (missingVars.length > 0) {
-      throw new Error(
-        `Missing required environment variables for development: ${missingVars.join(', ')}\n\n`
-        + `To set up your development environment, run:\n`
-        + `  npx c8y-nitro bootstrap\n\n`
-        + `This command will:\n`
-        + `  1. Require your development tenant credentials (C8Y_BASEURL C8Y_DEVELOPMENT_TENANT, C8Y_DEVELOPMENT_USER, C8Y_DEVELOPMENT_PASSWORD)\n`
-        + `  2. Register your microservice on the tenant\n`
-        + `  3. Generate the necessary bootstrap credentials in a .env file\n\n`
-        + `Make sure you have your development tenant credentials configured first.`,
-      )
-    }
-  }
-})