@tatara/cli 0.10.0 → 0.11.0

package/templates/features/notifications/files/src/modules/notifications/consumers/fanout.ts

@@ -0,0 +1,6 @@
+import type { FanoutConsumer } from "@tatara/notifications";
+import { consumers } from "#modules/notifications/services/notifier";
+
+/** Resolves a notification's recipients and queues one delivery per user. */
+const fanout: FanoutConsumer = consumers[0];
+export default fanout;

package/templates/features/notifications/files/src/modules/notifications/routes/notifications.routes.ts

@@ -0,0 +1,168 @@
+import { createRoute, z } from "@hono/zod-openapi";
+import { currentPrincipal, requireAuth } from "@tatara/auth";
+import {
+	cursorPage,
+	cursorPageSchema,
+	cursorQuerySchema,
+	decodeCursor,
+	errorResponses,
+	jsonBody,
+	jsonContent,
+	success,
+	successSchema,
+} from "@tatara/http";
+import type { Context } from "hono";
+import { createRouter, defineRoutes } from "#core/http/routes";
+import { notificationStore as store } from "#modules/notifications/services/store";
+// tatara:slot imports
+
+const guard = [
+	requireAuth(),
+	// tatara:slot guard
+];
+
+/** The org the inbox belongs to; apps without organizations have one, "default". */
+function inbox(c: Context) {
+	const principal = currentPrincipal(c);
+	return { orgId: principal.orgId ?? "default", userId: principal.userId };
+}
+
+const notificationSchema = z
+	.object({
+		id: z.string(),
+		name: z.string(),
+		title: z.string(),
+		body: z.string().nullable(),
+		url: z.string().nullable(),
+		readAt: z.string().nullable(),
+		createdAt: z.string(),
+	})
+	.openapi("Notification");
+
+const position = z.object({ createdAt: z.iso.datetime(), id: z.string() });
+const security = [{ bearerAuth: [] }];
+const router = createRouter();
+
+router.openapi(
+	createRoute({
+		method: "get",
+		path: "/",
+		tags: ["Notifications"],
+		summary: "The caller's notifications, newest first",
+		middleware: guard,
+		security,
+		request: { query: cursorQuerySchema.extend({ unread: z.stringbool().optional() }) },
+		responses: {
+			200: jsonContent(cursorPageSchema(notificationSchema), "A page of notifications"),
+			...errorResponses(400, 401),
+		},
+	}),
+	async (c) => {
+		const { cursor, limit, unread } = c.req.valid("query");
+		const before = cursor ? decodeCursor(position, cursor) : undefined;
+		const rows = await store.list(inbox(c).orgId, inbox(c).userId, {
+			limit: limit + 1,
+			unreadOnly: unread,
+			...(before ? { before: { createdAt: new Date(before.createdAt), id: before.id } } : {}),
+		});
+		const page = cursorPage(rows, limit, (r) => ({ createdAt: r.createdAt.toISOString(), id: r.id }));
+		return c.json(
+			{
+				...page,
+				data: page.data.map((r) => ({
+					...r,
+					readAt: r.readAt?.toISOString() ?? null,
+					createdAt: r.createdAt.toISOString(),
+				})),
+			},
+			200,
+		);
+	},
+);
+
+router.openapi(
+	createRoute({
+		method: "get",
+		path: "/unread-count",
+		tags: ["Notifications"],
+		summary: "How many of the caller's notifications are unread",
+		middleware: guard,
+		security,
+		responses: {
+			200: jsonContent(successSchema(z.object({ count: z.number().int() })), "The unread count"),
+			...errorResponses(401),
+		},
+	}),
+	async (c) => {
+		const { orgId, userId } = inbox(c);
+		return c.json(success({ count: await store.unreadCount(orgId, userId) }), 200);
+	},
+);
+
+router.openapi(
+	createRoute({
+		method: "post",
+		path: "/read",
+		tags: ["Notifications"],
+		summary: "Mark the caller's notifications read: some, or all",
+		middleware: guard,
+		security,
+		request: {
+			body: jsonBody(
+				z.union([z.object({ ids: z.array(z.string()).min(1).max(100) }), z.object({ all: z.literal(true) })]),
+				"Which to mark read",
+			),
+		},
+		responses: {
+			200: jsonContent(successSchema(z.object({ updated: z.number().int() })), "How many changed"),
+			...errorResponses(400, 401),
+		},
+	}),
+	async (c) => {
+		const body = c.req.valid("json");
+		const { orgId, userId } = inbox(c);
+		const updated = await store.markRead(orgId, userId, "all" in body ? "all" : body.ids);
+		return c.json(success({ updated }), 200);
+	},
+);
+
+const tokenSchema = z.object({ token: z.string().min(1).max(512), device: z.string().max(255).optional() });
+
+router.openapi(
+	createRoute({
+		method: "post",
+		path: "/push-tokens",
+		tags: ["Notifications"],
+		summary: "Register this device for push",
+		middleware: guard,
+		security,
+		request: { body: jsonBody(tokenSchema, "The device's FCM token") },
+		responses: { 204: { description: "Registered" }, ...errorResponses(400, 401) },
+	}),
+	async (c) => {
+		const { token, device } = c.req.valid("json");
+		await store.addPushToken(inbox(c).userId, token, device ?? null);
+		return c.body(null, 204);
+	},
+);
+
+router.openapi(
+	createRoute({
+		method: "delete",
+		path: "/push-tokens",
+		tags: ["Notifications"],
+		summary: "Stop push to this device (e.g. on sign-out)",
+		middleware: guard,
+		security,
+		request: { body: jsonBody(tokenSchema.pick({ token: true }), "The device's FCM token") },
+		responses: { 204: { description: "Removed" }, ...errorResponses(400, 401) },
+	}),
+	async (c) => {
+		const { token } = c.req.valid("json");
+		// only the caller's own device
+		if ((await store.pushTokens(inbox(c).userId)).includes(token)) await store.removePushTokens([token]);
+		return c.body(null, 204);
+	},
+);
+
+export default defineRoutes({ app: "api", basePath: "/notifications", router });

package/templates/features/notifications/files/src/modules/notifications/services/notifier.ts

@@ -0,0 +1,59 @@
+import {
+	consolePush,
+	consoleSms,
+	createNotifier,
+	fcmPush,
+	type NotificationsOf,
+	type PushSender,
+	type SmsSender,
+	twilioSms,
+} from "@tatara/notifications";
+import { env } from "#core/config/env";
+import { enqueue } from "#core/jobs/index";
+import { logger } from "#core/logging/logger";
+import { notifications } from "#generated/notifications";
+import { notificationStore } from "#modules/notifications/services/store";
+import { auth } from "#modules/users/services/auth";
+// tatara:slot imports
+
+function sms(): SmsSender {
+	if (env.SMS_DRIVER !== "twilio") return consoleSms(logger);
+	if (!env.TWILIO_ACCOUNT_SID || !env.TWILIO_AUTH_TOKEN || !env.TWILIO_FROM)
+		throw new Error("SMS_DRIVER=twilio needs TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN and TWILIO_FROM");
+	return twilioSms({ accountSid: env.TWILIO_ACCOUNT_SID, authToken: env.TWILIO_AUTH_TOKEN, from: env.TWILIO_FROM });
+}
+
+function push(): PushSender {
+	if (env.PUSH_DRIVER !== "fcm") return consolePush(logger);
+	if (!env.FCM_PROJECT_ID || !env.FCM_CLIENT_EMAIL || !env.FCM_PRIVATE_KEY)
+		throw new Error("PUSH_DRIVER=fcm needs FCM_PROJECT_ID, FCM_CLIENT_EMAIL and FCM_PRIVATE_KEY");
+	return fcmPush({ projectId: env.FCM_PROJECT_ID, clientEmail: env.FCM_CLIENT_EMAIL, privateKey: env.FCM_PRIVATE_KEY });
+}
+
+// tatara:slot helpers
+
+/**
+ * `notify({ orgId, to, notification, data })`: stores the inbox entry and sends each channel through
+ * jobs. Notifications are `notifications/*.ts` in any module (`defineNotification`).
+ */
+export const { notify, consumers } = createNotifier<NotificationsOf<typeof notifications>>({
+	notifications,
+	store: notificationStore,
+	enqueue: enqueue as never,
+	// tatara:slot recipients
+	async contact(userId) {
+		const { adapter } = await auth.$context;
+		const user = await adapter.findOne<{ email?: string; phoneNumber?: string | null; language?: string | null }>({
+			model: "user",
+			where: [{ field: "id", value: userId }],
+		});
+		// language: add it as a user field (better-auth additionalFields) to notify in each user's own
+		return user
+			? { email: user.email ?? null, phone: user.phoneNumber ?? null, language: user.language ?? null }
+			: null;
+	},
+	sms: sms(),
+	push: push(),
+	// tatara:slot senders
+	logger,
+});

package/templates/features/notifications/files/src/modules/notifications/tests/notifications.test.ts

@@ -0,0 +1,72 @@
+import type { InlineDriver } from "@tatara/jobs";
+import { beforeEach, describe, expect, it } from "vitest";
+import { jobs } from "#core/jobs/index";
+import { notify } from "#modules/notifications/services/notifier";
+import { notificationStore } from "#modules/notifications/services/store";
+import { api } from "#tests/helpers/api";
+import { authenticate } from "#tests/helpers/auth";
+import { resetDatabase } from "#tests/helpers/db";
+
+const drain = () => (jobs.driver as InlineDriver).drain();
+
+beforeEach(async () => {
+	await resetDatabase();
+});
+
+describe("notifications", () => {
+	it("puts a notification in the user's inbox, once per idempotency key", async () => {
+		const user = await authenticate();
+		const orgId = user.orgId ?? "default";
+		for (let i = 0; i < 2; i++)
+			await notify({
+				orgId,
+				to: { user: user.userId },
+				notification: "example.welcome",
+				data: { name: "Ada" },
+				idempotencyKey: "welcome",
+			});
+		await drain();
+		const list = await api.get<{ data: { id: string; title: string }[]; meta: { nextCursor: string | null } }>(
+			"/api/notifications",
+			{ headers: user.headers },
+		);
+		expect(list.status).toBe(200);
+		expect(list.body.data.map((n) => n.title)).toEqual(["Welcome, Ada"]);
+		expect(list.body.meta.nextCursor).toBeNull();
+	});
+
+	it("marks only the caller's notifications read", async () => {
+		const [me, other] = [await authenticate(), await authenticate()];
+		for (const user of [me, other])
+			await notify({ orgId: user.orgId ?? "default", to: { user: user.userId }, notification: "example.welcome", data: { name: "x" } });
+		await drain();
+		const count = (h: Record<string, string>) =>
+			api.get<{ data: { count: number } }>("/api/notifications/unread-count", { headers: h });
+		expect((await count(me.headers)).body.data.count).toBe(1);
+		const read = await api.post<{ data: { updated: number } }>("/api/notifications/read", { all: true }, { headers: me.headers });
+		expect(read.body.data.updated).toBe(1);
+		expect((await count(me.headers)).body.data.count).toBe(0);
+		expect((await count(other.headers)).body.data.count).toBe(1);
+	});
+
+	it("lets one delivery take a channel at a time, in the database", async () => {
+		const { id } = await notificationStore.claim({
+			id: crypto.randomUUID(),
+			orgId: "default",
+			userId: "u1",
+			name: "example.welcome",
+			inApp: null,
+			idempotencyKey: crypto.randomUUID(),
+		});
+		const takes = await Promise.all([1, 2, 3].map(() => notificationStore.claimChannel(id, "email")));
+		expect(takes.filter(Boolean)).toHaveLength(1);
+		expect(await notificationStore.claimChannel(id, "sms")).toBe(true);
+		await notificationStore.releaseChannel(id, "email");
+		expect(await notificationStore.claimChannel(id, "email")).toBe(true);
+		expect(await notificationStore.claimChannel(id, "sms")).toBe(false);
+	});
+
+	it("needs a signed-in user", async () => {
+		expect((await api.get("/api/notifications")).status).toBe(401);
+	});
+});

package/templates/features/notifications/files+drizzle/src/modules/notifications/services/store.ts

@@ -0,0 +1,5 @@
+import { drizzleNotificationStore } from "@tatara/notifications/drizzle";
+import { db } from "#core/db/client";
+import * as tables from "#modules/notifications/db/notifications.schema";
+
+export const notificationStore = drizzleNotificationStore(db, tables);

package/templates/features/notifications/files+drizzle+mysql/src/modules/notifications/db/notifications.schema.ts

@@ -0,0 +1,40 @@
+import { boolean, index, mysqlTable, text, timestamp, varchar } from "drizzle-orm/mysql-core";
+
+const ts = () => timestamp({ mode: "date", fsp: 3 });
+
+/** One row per user per notification; `in_app` false rows only record what was sent. */
+export const notifications = mysqlTable(
+	"notifications",
+	{
+		id: varchar({ length: 36 }).primaryKey(),
+		orgId: varchar({ length: 255 }).notNull(),
+		userId: varchar({ length: 255 }).notNull(),
+		name: varchar({ length: 255 }).notNull(),
+		title: text().notNull(),
+		body: text(),
+		url: text(),
+		inApp: boolean().notNull().default(true),
+		idempotencyKey: varchar({ length: 255 }).notNull().unique(),
+		// each channel is taken once, by a conditional update on its column
+		sentInApp: boolean().notNull().default(false),
+		sentEmail: boolean().notNull().default(false),
+		sentSms: boolean().notNull().default(false),
+		sentPush: boolean().notNull().default(false),
+		readAt: ts(),
+		createdAt: ts().notNull().defaultNow(),
+	},
+	(t) => [index("notifications_inbox").on(t.orgId, t.userId, t.createdAt)],
+);
+
+/** Devices that receive push, by FCM token. */
+export const pushTokens = mysqlTable(
+	"push_tokens",
+	{
+		token: varchar({ length: 512 }).primaryKey(),
+		userId: varchar({ length: 255 }).notNull(),
+		device: varchar({ length: 255 }),
+		createdAt: ts().notNull().defaultNow(),
+		lastSeenAt: ts().notNull().defaultNow(),
+	},
+	(t) => [index("push_tokens_user").on(t.userId)],
+);

package/templates/features/notifications/files+drizzle+postgres/src/modules/notifications/db/notifications.schema.ts

@@ -0,0 +1,41 @@
+import { boolean, index, pgTable, text, timestamp, varchar } from "drizzle-orm/pg-core";
+
+// milliseconds, like the Date a cursor carries: finer and rows would fall between pages
+const ts = () => timestamp({ withTimezone: true, mode: "date", precision: 3 });
+
+/** One row per user per notification; `in_app` false rows only record what was sent. */
+export const notifications = pgTable(
+	"notifications",
+	{
+		id: varchar({ length: 36 }).primaryKey(),
+		orgId: varchar({ length: 255 }).notNull(),
+		userId: varchar({ length: 255 }).notNull(),
+		name: varchar({ length: 255 }).notNull(),
+		title: text().notNull(),
+		body: text(),
+		url: text(),
+		inApp: boolean().notNull().default(true),
+		idempotencyKey: varchar({ length: 255 }).notNull().unique(),
+		// each channel is taken once, by a conditional update on its column
+		sentInApp: boolean().notNull().default(false),
+		sentEmail: boolean().notNull().default(false),
+		sentSms: boolean().notNull().default(false),
+		sentPush: boolean().notNull().default(false),
+		readAt: ts(),
+		createdAt: ts().notNull().defaultNow(),
+	},
+	(t) => [index("notifications_inbox").on(t.orgId, t.userId, t.createdAt)],
+);
+
+/** Devices that receive push, by FCM token. */
+export const pushTokens = pgTable(
+	"push_tokens",
+	{
+		token: varchar({ length: 512 }).primaryKey(),
+		userId: varchar({ length: 255 }).notNull(),
+		device: varchar({ length: 255 }),
+		createdAt: ts().notNull().defaultNow(),
+		lastSeenAt: ts().notNull().defaultNow(),
+	},
+	(t) => [index("push_tokens_user").on(t.userId)],
+);

package/templates/features/notifications/files+prisma/prisma/models/notifications.prisma

@@ -0,0 +1,34 @@
+// One row per user per notification; in_app false rows only record what was sent.
+
+model Notification {
+  id             String    @id @db.VarChar(36)
+  orgId          String    @map("org_id") @db.VarChar(255)
+  userId         String    @map("user_id") @db.VarChar(255)
+  name           String    @db.VarChar(255)
+  title          String    @db.Text
+  body           String?   @db.Text
+  url            String?   @db.Text
+  inApp          Boolean   @default(true) @map("in_app")
+  idempotencyKey String    @unique @map("idempotency_key") @db.VarChar(255)
+  sentInApp      Boolean   @default(false) @map("sent_in_app")
+  sentEmail      Boolean   @default(false) @map("sent_email")
+  sentSms        Boolean   @default(false) @map("sent_sms")
+  sentPush       Boolean   @default(false) @map("sent_push")
+  readAt         DateTime? @map("read_at")
+  createdAt      DateTime  @default(now()) @map("created_at")
+
+  @@index([orgId, userId, createdAt], map: "notifications_inbox")
+  @@map("notifications")
+}
+
+// Devices that receive push, by FCM token.
+model PushToken {
+  token      String   @id @db.VarChar(512)
+  userId     String   @map("user_id") @db.VarChar(255)
+  device     String?  @db.VarChar(255)
+  createdAt  DateTime @default(now()) @map("created_at")
+  lastSeenAt DateTime @default(now()) @map("last_seen_at")
+
+  @@index([userId], map: "push_tokens_user")
+  @@map("push_tokens")
+}

package/templates/features/notifications/files+prisma/src/modules/notifications/services/store.ts

@@ -0,0 +1,4 @@
+import { prismaNotificationStore } from "@tatara/notifications/prisma";
+import { db } from "#core/db/client";
+
+export const notificationStore = prismaNotificationStore(db);

package/templates/features/observability/files/src/apps/instrument.ts

@@ -0,0 +1,15 @@
+// Loaded before the app (`node --import ./dist/apps/instrument.mjs …`, set in the Dockerfile):
+// instrumentation can only patch libraries imported after it, so app code comes in dynamically.
+import { register } from "node:module";
+
+const { env } = await import("#core/config/env");
+
+if (env.OTEL_EXPORTER_OTLP_ENDPOINT) {
+	register("@opentelemetry/instrumentation/hook.mjs", import.meta.url);
+	const { startTelemetry } = await import("@tatara/observability");
+	startTelemetry({
+		serviceName: env.OTEL_SERVICE_NAME,
+		endpoint: env.OTEL_EXPORTER_OTLP_ENDPOINT,
+		sampleRatio: env.OTEL_TRACES_SAMPLE_RATIO,
+	});
+}

package/templates/features/realtime/files/src/core/realtime/index.ts

@@ -0,0 +1,29 @@
+import { corsOrigin } from "@tatara/http";
+import { createRealtime } from "@tatara/realtime";
+import { Redis } from "ioredis";
+import { cache } from "#core/cache/index";
+import { env } from "#core/config/env";
+import { logger } from "#core/logging/logger";
+
+/**
+ * The app's websockets: the api attaches them, every process can publish (through Redis). A client
+ * gets a ticket from POST /api/realtime/ticket and connects with `auth: { ticket }`.
+ */
+export const realtime = createRealtime({
+	driver: env.REALTIME_DRIVER,
+	adapter:
+		env.REALTIME_ADAPTER === "redis"
+			? { kind: "redis", redis: () => new Redis(env.REDIS_URL) }
+			: { kind: "memory" },
+	// single-use tickets, kept in the cache
+	tickets: cache,
+	ticketTtlMs: env.REALTIME_TICKET_TTL_SECONDS * 1000,
+	path: env.REALTIME_PATH,
+	allowOrigin: (() => {
+		const allow = corsOrigin(env.CORS_ORIGINS);
+		return (origin: string) => allow(origin) !== null;
+	})(),
+	logger,
+});
+
+export const { publishToUser, publishToOrg, publishTo, disconnectUser, disconnectOrg } = realtime;

package/templates/features/realtime/files/src/modules/realtime/routes/realtime.routes.ts

@@ -0,0 +1,38 @@
+import { createRoute, z } from "@hono/zod-openapi";
+import { currentPrincipal, requireAuth } from "@tatara/auth";
+import { errorResponses, jsonContent, success, successSchema } from "@tatara/http";
+import { env } from "#core/config/env";
+import { createRouter, defineRoutes } from "#core/http/routes";
+import { realtime } from "#core/realtime/index";
+// tatara:slot imports
+
+const router = createRouter();
+
+router.openapi(
+	createRoute({
+		method: "post",
+		path: "/ticket",
+		tags: ["Realtime"],
+		summary: "A single-use ticket to open a websocket as the caller",
+		middleware: [
+			requireAuth(),
+			// tatara:slot guard
+		],
+		security: [{ bearerAuth: [] }],
+		responses: {
+			200: jsonContent(
+				successSchema(z.object({ ticket: z.string(), expiresInMs: z.number().int(), path: z.string() })),
+				"Connect with io(url, { path, auth: { ticket } })",
+			),
+			...errorResponses(401),
+		},
+	}),
+	async (c) => {
+		const principal = currentPrincipal(c);
+		// apps without organizations have one, "default"
+		const ticket = await realtime.issueTicket({ userId: principal.userId, orgId: principal.orgId ?? "default" });
+		return c.json(success({ ...ticket, path: env.REALTIME_PATH }), 200);
+	},
+);
+
+export default defineRoutes({ app: "api", basePath: "/realtime", router });

package/templates/features/realtime/files/tests/tatara/realtime.test.ts

@@ -0,0 +1,37 @@
+import { serve } from "@hono/node-server";
+import type { Server } from "node:http";
+import type { AddressInfo } from "node:net";
+import { io } from "socket.io-client";
+import { afterAll, describe, expect, it } from "vitest";
+import { app } from "#apps/api/app";
+import { env } from "#core/config/env";
+import { publishToUser, realtime } from "#core/realtime/index";
+import { authenticate } from "#tests/helpers/auth";
+
+let server: Server | undefined;
+afterAll(() => new Promise((r) => (server ? server.close(r) : r(undefined))));
+
+describe("realtime", () => {
+	it("connects with a ticket from the API and receives what the app publishes to the user", async () => {
+		server = await new Promise<Server>((resolve) => {
+			const started = serve({ fetch: app.fetch, port: 0 }, () => resolve(started as Server));
+		});
+		await realtime.attach(server);
+		const url = `http://localhost:${(server.address() as AddressInfo).port}`;
+
+		const user = await authenticate();
+		const res = await fetch(`${url}/api/realtime/ticket`, { method: "POST", headers: user.headers });
+		expect(res.status).toBe(200);
+		const { ticket } = ((await res.json()) as { data: { ticket: string } }).data;
+
+		const socket = io(url, { path: env.REALTIME_PATH, transports: ["websocket"], auth: { ticket }, reconnection: false });
+		await new Promise<void>((resolve, reject) => {
+			socket.on("connect", resolve);
+			socket.on("connect_error", reject);
+		});
+		const got = new Promise((r) => socket.once("hello", r));
+		await publishToUser(user.orgId ?? "default", user.userId, "hello", { n: 1 });
+		expect(await got).toEqual({ n: 1 });
+		socket.close();
+	});
+});

package/templates/versions.json

@@ -31,15 +31,35 @@
   "@aws-sdk/s3-request-presigner": "3.1152.0",
   "nodemailer": "10.1.1",
   "@types/nodemailer": "8.0.2",
-  "@tatara/core": "0.1.1",
-  "@tatara/http": "0.1.1",
-  "@tatara/db": "0.2.1",
+  "@tatara/core": "0.1.2",
+  "@tatara/http": "0.1.2",
+  "@tatara/db": "0.2.2",
   "@tatara/testing": "0.1.1",
   "@tatara/auth": "0.2.0",
   "@tatara/keycloak": "0.1.2",
-  "@tatara/authz": "0.3.0",
+  "@tatara/authz": "0.3.1",
   "@tatara/storage": "0.2.0",
-  "@tatara/email": "0.2.0",
+  "@tatara/email": "0.3.0",
   "@tatara/i18n": "0.1.0",
-  "@tatara/jobs": "0.2.0"
+  "@tatara/jobs": "0.3.0",
+  "@tatara/cache": "0.1.0",
+  "openapi-typescript": "7.13.0",
+  "kafkajs": "2.2.4",
+  "@tatara/notifications": "0.1.0",
+  "@tatara/realtime": "0.1.0",
+  "socket.io": "4.8.4",
+  "socket.io-client": "4.8.4",
+  "@socket.io/redis-adapter": "8.3.0",
+  "@socket.io/redis-emitter": "5.1.0",
+  "@tatara/observability": "0.1.0",
+  "@opentelemetry/api": "1.10.0",
+  "@opentelemetry/sdk-node": "0.300.0",
+  "@opentelemetry/sdk-trace": "3.0.0",
+  "@opentelemetry/sdk-metrics": "3.0.0",
+  "@opentelemetry/resources": "3.0.0",
+  "@opentelemetry/exporter-trace-otlp-http": "0.300.0",
+  "@opentelemetry/exporter-metrics-otlp-http": "0.300.0",
+  "@opentelemetry/auto-instrumentations-node": "0.82.0",
+  "@opentelemetry/instrumentation": "0.300.0",
+  "@hono/otel": "1.3.0"
 }