@zaaxch/tailframe 2.2.0 → 3.0.0

package/src/owned-sources.mjs

@@ -0,0 +1,479 @@
+import {
+	appErrorSource,
+	applySchemaCliSource,
+	createRequestContextSource,
+	csrfSource,
+	firebaseSource,
+	httpErrorsSource,
+	mongoUsersSource,
+	rateLimitSource,
+	readEnvSource,
+	requestContextSource,
+	rpcHandlerSource,
+	rpcSource,
+	schemaLifecycleSource,
+	useCaseSource
+} from "./service-templates.mjs";
+import {
+	extensionAuthStoreSource,
+	notificationHostSource,
+	notificationStoreSource,
+	uiErrorMessagesSource,
+	uiErrorsSource,
+	uiHttpSource,
+	uiRpcSource
+} from "./ui-templates.mjs";
+
+const requestContextTestSource = `import type { Request } from "express";
+import { verifyFirebaseToken } from "@/platform/auth/firebase";
+import { createRequestContext } from "@/platform/http/createRequestContext";
+
+jest.mock("@/platform/auth/firebase", () => ({ verifyFirebaseToken: jest.fn() }));
+
+const verifyToken = verifyFirebaseToken as jest.MockedFunction<typeof verifyFirebaseToken>;
+const request = (headers: Request["headers"] = {}) => ({ headers }) as Request;
+
+beforeEach(() => verifyToken.mockReset());
+
+it("creates and caches an anonymous context with a bounded request id", async () => {
+	const req = request({ "x-request-id": "request.safe:1" });
+	const first = await createRequestContext(req);
+	const second = await createRequestContext(req);
+	expect(first).toEqual({ requestId: "request.safe:1" });
+	expect(second).toBe(first);
+	expect(verifyToken).not.toHaveBeenCalled();
+});
+
+it("replaces malformed and oversized request ids", async () => {
+	for (const value of ["contains spaces", "x".repeat(129)]) {
+		const context = await createRequestContext(request({ "x-request-id": value }));
+		expect(context.requestId).not.toBe(value);
+		expect(context.requestId).toMatch(/^[a-f0-9-]{36}$/);
+	}
+});
+
+it("strictly parses one Bearer token", async () => {
+	for (const authorization of ["bearer token", "Bearer", "Bearer  token", "Bearer token extra", "Basic token"]) {
+		await expect(createRequestContext(request({ authorization }))).rejects.toMatchObject({
+			code: "UNAUTHENTICATED",
+			kind: "unauthenticated"
+		});
+	}
+	expect(verifyToken).not.toHaveBeenCalled();
+});
+
+it("maps verified and unverified Firebase email claims and verifies only once", async () => {
+	verifyToken.mockResolvedValueOnce({ uid: "verified", email: "v@example.com", email_verified: true } as never);
+	const verifiedRequest = request({ authorization: "Bearer verified-token" });
+	const verified = await createRequestContext(verifiedRequest);
+	expect(verified.principal).toEqual({ uid: "verified", email: "v@example.com", emailVerified: true });
+	await createRequestContext(verifiedRequest);
+	expect(verifyToken).toHaveBeenCalledTimes(1);
+
+	verifyToken.mockResolvedValueOnce({ uid: "unverified", email: "u@example.com" } as never);
+	const unverified = await createRequestContext(request({ authorization: "Bearer unverified-token" }));
+	expect(unverified.principal).toEqual({ uid: "unverified", email: "u@example.com", emailVerified: false });
+});
+`;
+
+const errorTranslationTestSource = `import { AppError, type FailureKind } from "@/core/errors";
+import { errorHandler } from "@/platform/http/errors";
+
+const statuses: Array<[FailureKind, number]> = [
+	["invalid", 400],
+	["unauthenticated", 401],
+	["forbidden", 403],
+	["not_found", 404],
+	["conflict", 409],
+	["unprocessable", 422],
+	["rate_limited", 429],
+	["unavailable", 503],
+	["internal", 500]
+];
+
+it.each(statuses)("translates %s to HTTP %i", (kind, status) => {
+	const json = jest.fn();
+	const response = { status: jest.fn(() => ({ json })) } as never;
+	errorHandler(new AppError("CODE", "message", kind), {} as never, response, jest.fn());
+	expect((response as { status: jest.Mock }).status).toHaveBeenCalledWith(status);
+	expect(json).toHaveBeenCalledWith({ error: { code: "CODE", message: "message" } });
+});
+`;
+
+const rateLimitTestSource = `import type { Request } from "express";
+import { RateLimiterRes } from "rate-limiter-flexible";
+import { createRateLimiter } from "@/platform/http/rateLimit";
+
+const mockConsume = jest.fn();
+jest.mock("rate-limiter-flexible", () => {
+	class MockRateLimiterRes {}
+	return {
+		RateLimiterRes: MockRateLimiterRes,
+		RateLimiterRedis: jest.fn().mockImplementation(() => ({ consume: mockConsume }))
+	};
+});
+
+const policy = { keyPrefix: "test", points: 2, durationSeconds: 60, key: "identity-or-ip" as const };
+
+beforeEach(() => mockConsume.mockReset());
+
+it("uses the authenticated identity and allows a request within budget", async () => {
+	mockConsume.mockResolvedValue(undefined);
+	const request = {
+		headers: {},
+		ip: "127.0.0.1",
+		requestContext: { requestId: "test", principal: { uid: "user-1", emailVerified: false } }
+	} as Request;
+	const next = jest.fn();
+	await (createRateLimiter({} as never, policy) as never as Function)(request, {}, next);
+	expect(mockConsume).toHaveBeenCalledWith("user:user-1");
+	expect(next).toHaveBeenCalledWith();
+});
+
+it("translates exhausted and unavailable limiter failures", async () => {
+	const request = { headers: {}, ip: "127.0.0.1", requestContext: { requestId: "test" } } as Request;
+	const exhausted = jest.fn();
+	mockConsume.mockRejectedValueOnce(new RateLimiterRes());
+	await (createRateLimiter({} as never, policy) as never as Function)(request, {}, exhausted);
+	expect(exhausted.mock.calls[0]?.[0]).toMatchObject({ kind: "rate_limited", code: "RATE_LIMITED" });
+
+	const unavailable = jest.fn();
+	mockConsume.mockRejectedValueOnce(new Error("redis down"));
+	await (createRateLimiter({} as never, policy) as never as Function)(request, {}, unavailable);
+	expect(unavailable.mock.calls[0]?.[0]).toMatchObject({ kind: "unavailable", code: "RATE_LIMIT_UNAVAILABLE" });
+});
+`;
+
+const notificationTestSource = `import { mount } from "@vue/test-utils";
+import { createPinia, setActivePinia } from "pinia";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { nextTick } from "vue";
+import NotificationHost from "@/app/components/NotificationHost.vue";
+import { useNotificationStore } from "@/app/stores/notification.store";
+
+describe("notification shell", () => {
+	beforeEach(() => {
+		vi.useFakeTimers();
+		setActivePinia(createPinia());
+	});
+	afterEach(() => vi.useRealTimers());
+
+	it("orders, dismisses, times, and clears notifications", async () => {
+		const store = useNotificationStore();
+		const host = mount(NotificationHost);
+		const first = store.notify({ message: "first", kind: "warning", durationMs: 1000 });
+		const second = store.notify({ message: "second", kind: "success", durationMs: 1000 });
+		expect(store.active?.id).toBe(first);
+		await nextTick();
+		expect(host.text()).toContain("first");
+		vi.advanceTimersByTime(1000);
+		await nextTick();
+		expect(store.active?.id).toBe(second);
+		store.dismiss(second);
+		expect(store.active).toBeUndefined();
+		store.notify({ message: "third" });
+		store.clear();
+		expect(store.queue).toEqual([]);
+		host.unmount();
+	});
+});
+`;
+
+const flutterErrorsSource = `enum FailureKind {
+  invalid,
+  unauthenticated,
+  forbidden,
+  notFound,
+  conflict,
+  unprocessable,
+  rateLimited,
+  unavailable,
+  internal,
+  network,
+}
+
+class ServiceException implements Exception {
+  const ServiceException({
+    required this.code,
+    required this.message,
+    required this.kind,
+    this.statusCode,
+    this.details,
+  });
+
+  final String code;
+  final String message;
+  final FailureKind kind;
+  final int? statusCode;
+  final Object? details;
+
+  @override
+  String toString() => message;
+}
+
+FailureKind failureKindForStatus(int? statusCode) {
+  if (statusCode == null) return FailureKind.network;
+  if (statusCode == 401) return FailureKind.unauthenticated;
+  if (statusCode == 403) return FailureKind.forbidden;
+  if (statusCode == 404) return FailureKind.notFound;
+  if (statusCode == 409) return FailureKind.conflict;
+  if (statusCode == 422) return FailureKind.unprocessable;
+  if (statusCode == 429) return FailureKind.rateLimited;
+  if (statusCode == 503) return FailureKind.unavailable;
+  if (statusCode >= 500) return FailureKind.internal;
+  return FailureKind.invalid;
+}
+`;
+
+const flutterRpcSource = `typedef JsonObject = Map<String, dynamic>;
+
+JsonObject? rpcErrorFrom(Object? value) {
+  if (value is! JsonObject) return null;
+  final error = value['error'];
+  return error is JsonObject ? error : null;
+}
+
+T rpcResult<T>(Object? value) {
+  if (value is! JsonObject || !value.containsKey('result')) {
+    throw const FormatException('The server returned an invalid response.');
+  }
+  return value['result'] as T;
+}
+`;
+
+const flutterNotificationSource = `import 'dart:async';
+
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+
+enum NotificationKind { info, success, warning, error }
+
+class AppNotification {
+  const AppNotification({
+    required this.id,
+    required this.message,
+    required this.kind,
+    required this.duration,
+  });
+
+  final int id;
+  final String message;
+  final NotificationKind kind;
+  final Duration duration;
+}
+
+class NotificationState {
+  const NotificationState(this.queue);
+
+  final List<AppNotification> queue;
+  AppNotification? get active => queue.isEmpty ? null : queue.first;
+}
+
+class NotificationNotifier extends Notifier<NotificationState> {
+  Timer? _timer;
+  int _nextId = 1;
+
+  @override
+  NotificationState build() => const NotificationState([]);
+
+  void notify(
+    String message, {
+    NotificationKind kind = NotificationKind.info,
+    Duration duration = const Duration(seconds: 4),
+  }) {
+    final notification = AppNotification(
+      id: _nextId++,
+      message: message,
+      kind: kind,
+      duration: duration,
+    );
+    final wasEmpty = state.queue.isEmpty;
+    state = NotificationState([...state.queue, notification]);
+    if (wasEmpty) _scheduleActive();
+  }
+
+  void dismiss(int id) {
+    final wasActive = state.active?.id == id;
+    state = NotificationState(
+      state.queue.where((notification) => notification.id != id).toList(),
+    );
+    if (wasActive) _scheduleActive();
+  }
+
+  void clear() {
+    _timer?.cancel();
+    _timer = null;
+    state = const NotificationState([]);
+  }
+
+  void _scheduleActive() {
+    _timer?.cancel();
+    _timer = null;
+    final notification = state.active;
+    if (notification != null && notification.duration > Duration.zero) {
+      _timer = Timer(notification.duration, () => dismiss(notification.id));
+    }
+  }
+}
+
+final notificationProvider =
+    NotifierProvider<NotificationNotifier, NotificationState>(
+      NotificationNotifier.new,
+    );
+`;
+
+const flutterNotificationHostSource = `import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+
+import '../state/notification_notifier.dart';
+
+class NotificationHost extends ConsumerWidget {
+  const NotificationHost({super.key});
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    final notification = ref.watch(notificationProvider).active;
+    if (notification == null) return const SizedBox.shrink();
+    final colors = Theme.of(context).colorScheme;
+    final background = switch (notification.kind) {
+      NotificationKind.info => colors.primary,
+      NotificationKind.success => Colors.green.shade800,
+      NotificationKind.warning => Colors.orange.shade900,
+      NotificationKind.error => colors.error,
+    };
+    return Semantics(
+      liveRegion: true,
+      child: Material(
+        color: background,
+        borderRadius: BorderRadius.circular(12),
+        elevation: 6,
+        child: Padding(
+          padding: const EdgeInsets.symmetric(horizontal: 16, vertical: 12),
+          child: Row(
+            mainAxisSize: MainAxisSize.min,
+            children: [
+              Flexible(
+                child: Text(
+                  notification.message,
+                  style: const TextStyle(color: Colors.white),
+                ),
+              ),
+              IconButton(
+                tooltip: 'Dismiss notification',
+                color: Colors.white,
+                onPressed: () => ref
+                    .read(notificationProvider.notifier)
+                    .dismiss(notification.id),
+                icon: const Icon(Icons.close),
+              ),
+            ],
+          ),
+        ),
+      ),
+    );
+  }
+}
+`;
+
+const flutterNotificationsPublicSource = `export '../state/notification_notifier.dart'
+    show
+        NotificationKind,
+        NotificationNotifier,
+        NotificationState,
+        notificationProvider;
+`;
+
+const flutterNotificationTestSource = (packageName) => `import 'package:${packageName}/app/public/notifications.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+
+void main() {
+  testWidgets('orders, dismisses, times, and clears notifications', (
+    tester,
+  ) async {
+    final container = ProviderContainer();
+    addTearDown(container.dispose);
+    final notifier = container.read(notificationProvider.notifier);
+
+    notifier.notify(
+      'first',
+      kind: NotificationKind.warning,
+      duration: const Duration(milliseconds: 10),
+    );
+    notifier.notify(
+      'second',
+      kind: NotificationKind.success,
+      duration: Duration.zero,
+    );
+    expect(container.read(notificationProvider).active?.message, 'first');
+
+    await tester.pump(const Duration(milliseconds: 11));
+    expect(container.read(notificationProvider).active?.message, 'second');
+    final second = container.read(notificationProvider).active!;
+    notifier.dismiss(second.id);
+    expect(container.read(notificationProvider).active, isNull);
+
+    notifier.notify('third', duration: Duration.zero);
+    notifier.clear();
+    expect(container.read(notificationProvider).queue, isEmpty);
+  });
+}
+`;
+
+export function ownedSources(config, { flutterPackageName } = {}) {
+	const profiles = new Set(config.profiles);
+	if (config.kind === "service") {
+		const files = {
+			"src/core/RequestContext.ts": requestContextSource,
+			"src/core/UseCase.ts": useCaseSource,
+			"src/core/errors.ts": appErrorSource,
+			"src/core/SchemaLifecycle.ts": schemaLifecycleSource,
+			"src/platform/config/readEnv.ts": readEnvSource,
+			"src/platform/http/createRequestContext.ts": createRequestContextSource(profiles.has("firebase") ? "firebase" : "none"),
+			"src/platform/http/csrf.ts": csrfSource,
+			"src/platform/http/errors.ts": httpErrorsSource,
+			"src/platform/http/rpc.ts": rpcSource,
+			"src/platform/http/rpcHandler.ts": rpcHandlerSource,
+			"src/app/cli/applySchema.ts": applySchemaCliSource,
+			"src/platform/http/__tests__/errors.test.ts": errorTranslationTestSource
+		};
+		if (profiles.has("firebase")) {
+			files["src/platform/auth/firebase.ts"] = firebaseSource;
+			files["src/platform/http/__tests__/createRequestContext.test.ts"] = requestContextTestSource;
+		}
+		if (profiles.has("rate-limit")) {
+			files["src/platform/http/rateLimit.ts"] = rateLimitSource;
+			files["src/platform/http/__tests__/rateLimit.test.ts"] = rateLimitTestSource;
+		}
+		if (profiles.has("mongo")) files["deploy/mongo/10-create-users.js"] = mongoUsersSource;
+		return files;
+	}
+	if (config.kind === "ui" || config.kind === "extension") {
+		const files = {
+			"src/core/errors.ts": uiErrorsSource,
+			"src/core/rpc.ts": uiRpcSource,
+			"src/platform/errors.ts": uiErrorMessagesSource,
+			"src/platform/http.ts": uiHttpSource
+		};
+		if (config.kind === "extension" && profiles.has("firebase")) {
+			files["src/app/stores/auth.store.ts"] = extensionAuthStoreSource;
+		}
+		if (profiles.has("notifications")) {
+			files["src/app/stores/notification.store.ts"] = notificationStoreSource;
+			files["src/app/components/NotificationHost.vue"] = notificationHostSource;
+			files["src/app/__tests__/notificationStore.test.ts"] = notificationTestSource;
+		}
+		return files;
+	}
+	const files = {
+		"lib/core/errors.dart": flutterErrorsSource,
+		"lib/core/rpc.dart": flutterRpcSource
+	};
+	if (profiles.has("notifications")) {
+		if (!flutterPackageName) throw new Error("Flutter notification sources require a package name");
+		files["lib/app/state/notification_notifier.dart"] = flutterNotificationSource;
+		files["lib/app/components/notification_host.dart"] = flutterNotificationHostSource;
+		files["lib/app/public/notifications.dart"] = flutterNotificationsPublicSource;
+		files["test/notification_notifier_test.dart"] = flutterNotificationTestSource(flutterPackageName);
+	}
+	return files;
+}