@littlebearapps/platform-admin-sdk 2.0.0 → 2.1.0

package/templates/full/dashboard/src/lib/cloudflare/project-registry.ts

@@ -0,0 +1,451 @@
+/**
+ * Project Registry - D1-backed resource-to-project mapping
+ *
+ * Provides project identification for Cloudflare resources using
+ * the D1 registry as the source of truth, with pattern matching fallback.
+ *
+ * Tables:
+ * - project_registry: Project metadata (id, name, color, status)
+ * - resource_project_mapping: Maps (resource_type, resource_id) → project_id
+ * - resource_types: Valid resource types with metadata
+ */
+
+import type { D1Database } from '@cloudflare/workers-types';
+
+// =============================================================================
+// TYPES
+// =============================================================================
+
+export interface Project {
+  projectId: string;
+  displayName: string;
+  description: string | null;
+  color: string | null;
+  icon: string | null;
+  owner: string | null;
+  repoPath: string | null;
+  status: 'active' | 'archived' | 'development';
+  /** Primary resource type for utilization tracking (e.g., 'd1', 'workers', 'vectorize') */
+  primaryResource: ResourceType | null;
+  /** Custom limit for the primary resource (overrides global CF_ALLOWANCES) */
+  customLimit: number | null;
+  /** Full GitHub repository URL (e.g., 'https://github.com/your-org/your-project') */
+  repoUrl: string | null;
+  /** GitHub repository identifier (e.g., 'your-org/your-project') */
+  githubRepoId: string | null;
+}
+
+export interface ResourceMapping {
+  resourceType: ResourceType;
+  resourceId: string;
+  resourceName: string;
+  projectId: string;
+  environment: 'production' | 'staging' | 'preview' | 'development';
+  notes: string | null;
+}
+
+export type ResourceType =
+  | 'worker'
+  | 'd1'
+  | 'kv'
+  | 'r2'
+  | 'vectorize'
+  | 'queue'
+  | 'workflow'
+  | 'ai_gateway'
+  | 'workers_ai'
+  | 'durable_object'
+  | 'pages'
+  | 'analytics_engine';
+
+// =============================================================================
+// REGISTRY CACHE
+// =============================================================================
+
+/**
+ * In-memory cache for registry data.
+ * Refreshed per-request or when TTL expires.
+ */
+interface RegistryCache {
+  projects: Map<string, Project>;
+  resourcesByName: Map<string, ResourceMapping>;
+  resourcesById: Map<string, ResourceMapping>;
+  loadedAt: number;
+}
+
+let cache: RegistryCache | null = null;
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+
+/**
+ * Check if cache is valid (exists and not expired)
+ */
+function isCacheValid(): boolean {
+  return cache !== null && Date.now() - cache.loadedAt < CACHE_TTL_MS;
+}
+
+/**
+ * Clear the in-memory cache (call after updates)
+ */
+export function clearRegistryCache(): void {
+  cache = null;
+}
+
+// =============================================================================
+// D1 QUERIES
+// =============================================================================
+
+/**
+ * Load all projects from D1
+ */
+async function loadProjects(db: D1Database): Promise<Map<string, Project>> {
+  const result = await db
+    .prepare(
+      `
+      SELECT
+        project_id, display_name, description, color, icon, owner, repo_path, status,
+        primary_resource, custom_limit, repo_url, github_repo_id
+      FROM project_registry
+      WHERE status != 'archived'
+      ORDER BY project_id
+    `
+    )
+    .all<{
+      project_id: string;
+      display_name: string;
+      description: string | null;
+      color: string | null;
+      icon: string | null;
+      owner: string | null;
+      repo_path: string | null;
+      status: string;
+      primary_resource: string | null;
+      custom_limit: number | null;
+      repo_url: string | null;
+      github_repo_id: string | null;
+    }>();
+
+  const projects = new Map<string, Project>();
+  for (const row of result.results ?? []) {
+    projects.set(row.project_id, {
+      projectId: row.project_id,
+      displayName: row.display_name,
+      description: row.description,
+      color: row.color,
+      icon: row.icon,
+      owner: row.owner,
+      repoPath: row.repo_path,
+      status: row.status as Project['status'],
+      primaryResource: row.primary_resource as ResourceType | null,
+      customLimit: row.custom_limit,
+      repoUrl: row.repo_url,
+      githubRepoId: row.github_repo_id,
+    });
+  }
+
+  return projects;
+}
+
+/**
+ * Load all resource mappings from D1
+ */
+async function loadResourceMappings(
+  db: D1Database
+): Promise<{ byName: Map<string, ResourceMapping>; byId: Map<string, ResourceMapping> }> {
+  const result = await db
+    .prepare(
+      `
+      SELECT 
+        resource_type, resource_id, resource_name, project_id, environment, notes
+      FROM resource_project_mapping
+      ORDER BY resource_type, resource_name
+    `
+    )
+    .all<{
+      resource_type: string;
+      resource_id: string;
+      resource_name: string;
+      project_id: string;
+      environment: string;
+      notes: string | null;
+    }>();
+
+  const byName = new Map<string, ResourceMapping>();
+  const byId = new Map<string, ResourceMapping>();
+
+  for (const row of result.results ?? []) {
+    const mapping: ResourceMapping = {
+      resourceType: row.resource_type as ResourceType,
+      resourceId: row.resource_id,
+      resourceName: row.resource_name,
+      projectId: row.project_id,
+      environment: row.environment as ResourceMapping['environment'],
+      notes: row.notes,
+    };
+
+    // Index by both name and ID for flexible lookups
+    // Key format: "{type}:{name}" or "{type}:{id}"
+    const nameKey = `${row.resource_type}:${row.resource_name.toLowerCase()}`;
+    const idKey = `${row.resource_type}:${row.resource_id}`;
+
+    byName.set(nameKey, mapping);
+    byId.set(idKey, mapping);
+  }
+
+  return { byName, byId };
+}
+
+/**
+ * Load the full registry into cache
+ */
+async function loadRegistry(db: D1Database): Promise<RegistryCache> {
+  const [projects, resources] = await Promise.all([loadProjects(db), loadResourceMappings(db)]);
+
+  cache = {
+    projects,
+    resourcesByName: resources.byName,
+    resourcesById: resources.byId,
+    loadedAt: Date.now(),
+  };
+
+  console.log(
+    `[ProjectRegistry] Loaded ${projects.size} projects, ${resources.byName.size} resource mappings`
+  );
+
+  return cache;
+}
+
+/**
+ * Get the registry cache, loading from D1 if needed
+ */
+async function getRegistry(db: D1Database): Promise<RegistryCache> {
+  if (isCacheValid() && cache) {
+    return cache;
+  }
+  return loadRegistry(db);
+}
+
+// =============================================================================
+// PUBLIC API
+// =============================================================================
+
+/**
+ * Get all active projects
+ */
+export async function getProjects(db: D1Database): Promise<Project[]> {
+  const registry = await getRegistry(db);
+  return Array.from(registry.projects.values());
+}
+
+/**
+ * Get a specific project by ID
+ */
+export async function getProject(db: D1Database, projectId: string): Promise<Project | null> {
+  const registry = await getRegistry(db);
+  return registry.projects.get(projectId) ?? null;
+}
+
+/**
+ * Identify which project a resource belongs to.
+ *
+ * Lookup order:
+ * 1. D1 registry by resource name (case-insensitive)
+ * 2. D1 registry by resource ID
+ * 3. Fallback pattern matching (for resources not yet in registry)
+ *
+ * @param db - D1 database binding
+ * @param resourceType - Type of resource (worker, d1, kv, etc.)
+ * @param resourceNameOrId - Resource name or Cloudflare ID
+ * @returns Project ID or null if not found
+ */
+export async function identifyProjectFromRegistry(
+  db: D1Database,
+  resourceType: ResourceType,
+  resourceNameOrId: string
+): Promise<string | null> {
+  const registry = await getRegistry(db);
+
+  // Try lookup by name first (case-insensitive)
+  const nameKey = `${resourceType}:${resourceNameOrId.toLowerCase()}`;
+  const byName = registry.resourcesByName.get(nameKey);
+  if (byName) {
+    return byName.projectId;
+  }
+
+  // Try lookup by ID
+  const idKey = `${resourceType}:${resourceNameOrId}`;
+  const byId = registry.resourcesById.get(idKey);
+  if (byId) {
+    return byId.projectId;
+  }
+
+  // Not found in registry
+  return null;
+}
+
+/**
+ * Get all resources for a specific project
+ */
+export async function getProjectResources(
+  db: D1Database,
+  projectId: string
+): Promise<ResourceMapping[]> {
+  const registry = await getRegistry(db);
+  const resources: ResourceMapping[] = [];
+
+  registry.resourcesByName.forEach((mapping) => {
+    if (mapping.projectId === projectId) {
+      resources.push(mapping);
+    }
+  });
+
+  return resources;
+}
+
+/**
+ * Get resources by type for a project
+ */
+export async function getProjectResourcesByType(
+  db: D1Database,
+  projectId: string,
+  resourceType: ResourceType
+): Promise<ResourceMapping[]> {
+  const all = await getProjectResources(db, projectId);
+  return all.filter((r) => r.resourceType === resourceType);
+}
+
+/**
+ * Count resources by project
+ */
+export async function getResourceCountsByProject(db: D1Database): Promise<Map<string, number>> {
+  const registry = await getRegistry(db);
+  const counts = new Map<string, number>();
+
+  registry.resourcesByName.forEach((mapping) => {
+    const current = counts.get(mapping.projectId) ?? 0;
+    counts.set(mapping.projectId, current + 1);
+  });
+
+  return counts;
+}
+
+/**
+ * Get resource count by type for a project
+ */
+export async function getResourceCountByType(
+  db: D1Database,
+  projectId: string
+): Promise<Record<ResourceType, number>> {
+  const resources = await getProjectResources(db, projectId);
+  const counts: Record<string, number> = {};
+
+  for (const r of resources) {
+    counts[r.resourceType] = (counts[r.resourceType] ?? 0) + 1;
+  }
+
+  return counts as Record<ResourceType, number>;
+}
+
+// =============================================================================
+// REGISTRY UPDATES
+// =============================================================================
+
+/**
+ * Add or update a resource mapping
+ */
+export async function upsertResourceMapping(
+  db: D1Database,
+  mapping: Omit<ResourceMapping, 'notes'> & { notes?: string | null }
+): Promise<void> {
+  await db
+    .prepare(
+      `
+      INSERT OR REPLACE INTO resource_project_mapping 
+        (resource_type, resource_id, resource_name, project_id, environment, notes, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, unixepoch())
+    `
+    )
+    .bind(
+      mapping.resourceType,
+      mapping.resourceId,
+      mapping.resourceName,
+      mapping.projectId,
+      mapping.environment,
+      mapping.notes ?? null
+    )
+    .run();
+
+  // Clear cache to pick up changes
+  clearRegistryCache();
+}
+
+/**
+ * Remove a resource mapping
+ */
+export async function deleteResourceMapping(
+  db: D1Database,
+  resourceType: ResourceType,
+  resourceId: string
+): Promise<void> {
+  await db
+    .prepare(
+      `
+      DELETE FROM resource_project_mapping 
+      WHERE resource_type = ? AND resource_id = ?
+    `
+    )
+    .bind(resourceType, resourceId)
+    .run();
+
+  clearRegistryCache();
+}
+
+/**
+ * Add a new project
+ */
+export async function createProject(
+  db: D1Database,
+  project: Omit<Project, 'status'> & { status?: Project['status'] }
+): Promise<void> {
+  await db
+    .prepare(
+      `
+      INSERT INTO project_registry 
+        (project_id, display_name, description, color, icon, owner, repo_path, status, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, unixepoch())
+    `
+    )
+    .bind(
+      project.projectId,
+      project.displayName,
+      project.description,
+      project.color,
+      project.icon,
+      project.owner,
+      project.repoPath,
+      project.status ?? 'active'
+    )
+    .run();
+
+  clearRegistryCache();
+}
+
+/**
+ * Update project status
+ */
+export async function updateProjectStatus(
+  db: D1Database,
+  projectId: string,
+  status: Project['status']
+): Promise<void> {
+  await db
+    .prepare(
+      `
+      UPDATE project_registry SET status = ?, updated_at = unixepoch()
+      WHERE project_id = ?
+    `
+    )
+    .bind(status, projectId)
+    .run();
+
+  clearRegistryCache();
+}

package/templates/full/dashboard/src/lib/notifications/api.ts

@@ -0,0 +1,197 @@
+/**
+ * Notification API Client
+ *
+ * Functions for interacting with the platform-notifications worker.
+ * Used by dashboard components to fetch and manage notifications.
+ *
+ * @module dashboard/lib/notifications/api
+ * @created 2026-02-03
+ * @task task-303.1
+ */
+
+import type {
+  Notification,
+  NotificationListResponse,
+  UnreadCountResponse,
+  MarkReadResponse,
+  NotificationPreferences,
+  CreateNotificationRequest,
+  NotificationQueryParams,
+} from './types';
+
+/** Base URL for notification API (via service binding proxy) */
+const API_BASE = '/api/notifications';
+
+/**
+ * Fetch notifications with optional filters
+ */
+export async function getNotifications(
+  params: NotificationQueryParams = {}
+): Promise<NotificationListResponse> {
+  const searchParams = new URLSearchParams();
+  if (params.project) searchParams.set('project', params.project);
+  if (params.source) searchParams.set('source', params.source);
+  if (params.category) searchParams.set('category', params.category);
+  if (params.limit) searchParams.set('limit', String(params.limit));
+  if (params.offset) searchParams.set('offset', String(params.offset));
+
+  const url = `${API_BASE}?${searchParams.toString()}`;
+  const response = await fetch(url);
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch notifications: ${response.statusText}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Get unread notification count for badge display
+ */
+export async function getUnreadCount(): Promise<number> {
+  const response = await fetch(`${API_BASE}/unread-count`);
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch unread count: ${response.statusText}`);
+  }
+
+  const data: UnreadCountResponse = await response.json();
+  return data.count;
+}
+
+/**
+ * Mark a single notification as read
+ */
+export async function markAsRead(notificationId: string): Promise<MarkReadResponse> {
+  const response = await fetch(`${API_BASE}/${notificationId}/read`, {
+    method: 'POST',
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to mark notification as read: ${response.statusText}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Mark all notifications as read
+ */
+export async function markAllAsRead(): Promise<MarkReadResponse> {
+  const response = await fetch(`${API_BASE}/read-all`, {
+    method: 'POST',
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to mark all notifications as read: ${response.statusText}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Create a new notification (internal use)
+ */
+export async function createNotification(
+  data: CreateNotificationRequest
+): Promise<{ success: boolean; id: string }> {
+  const response = await fetch(API_BASE, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(data),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to create notification: ${response.statusText}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Get user notification preferences
+ */
+export async function getPreferences(): Promise<NotificationPreferences> {
+  const response = await fetch(`${API_BASE}/preferences`);
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch preferences: ${response.statusText}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Update user notification preferences
+ */
+export async function updatePreferences(
+  preferences: Partial<NotificationPreferences>
+): Promise<{ success: boolean; preferences: NotificationPreferences }> {
+  const response = await fetch(`${API_BASE}/preferences`, {
+    method: 'PUT',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(preferences),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to update preferences: ${response.statusText}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Get category icon name (for Lucide icons)
+ */
+export function getCategoryIcon(category: Notification['category']): string {
+  switch (category) {
+    case 'error':
+      return 'alert-circle';
+    case 'warning':
+      return 'alert-triangle';
+    case 'success':
+      return 'check-circle';
+    case 'info':
+    default:
+      return 'info';
+  }
+}
+
+/**
+ * Get category color class (Tailwind)
+ */
+export function getCategoryColor(category: Notification['category']): string {
+  switch (category) {
+    case 'error':
+      return 'text-red-500 dark:text-red-400';
+    case 'warning':
+      return 'text-amber-500 dark:text-amber-400';
+    case 'success':
+      return 'text-green-500 dark:text-green-400';
+    case 'info':
+    default:
+      return 'text-blue-500 dark:text-blue-400';
+  }
+}
+
+/**
+ * Format notification timestamp for display
+ */
+export function formatTimestamp(timestamp: number): string {
+  const date = new Date(timestamp * 1000);
+  const now = new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffMins = Math.floor(diffMs / 60000);
+  const diffHours = Math.floor(diffMins / 60);
+  const diffDays = Math.floor(diffHours / 24);
+
+  if (diffMins < 1) return 'Just now';
+  if (diffMins < 60) return `${diffMins}m ago`;
+  if (diffHours < 24) return `${diffHours}h ago`;
+  if (diffDays < 7) return `${diffDays}d ago`;
+
+  return date.toLocaleDateString('en-AU', {
+    day: 'numeric',
+    month: 'short',
+  });
+}