@useatlas/create 0.0.5 → 0.0.7

package/templates/nextjs-standalone/src/ui/lib/fetch-client.ts

@@ -0,0 +1,84 @@
+/**
+ * Lightweight typed fetch wrapper for Atlas API calls.
+ * Centralizes URL construction, header injection, credential handling,
+ * and error behavior so callers don't repeat the same fetch pattern.
+ */
+
+export interface AtlasFetchOptions {
+  apiUrl: string;
+  getHeaders: () => Record<string, string>;
+  getCredentials: () => RequestCredentials;
+}
+
+export interface AtlasFetch {
+  /** Raw fetch with URL/header/credential wiring but no error handling. */
+  raw: (method: string, path: string, body?: unknown) => Promise<Response>;
+  get: <T>(path: string) => Promise<T>;
+  post: <T>(path: string, body?: unknown) => Promise<T>;
+  patch: <T>(path: string, body?: unknown) => Promise<T>;
+  del: (path: string) => Promise<void>;
+}
+
+export function createAtlasFetch(opts: AtlasFetchOptions): AtlasFetch {
+  async function raw(
+    method: string,
+    path: string,
+    body?: unknown,
+  ): Promise<Response> {
+    try {
+      return await fetch(`${opts.apiUrl}${path}`, {
+        method,
+        headers: {
+          ...opts.getHeaders(),
+          ...(body !== undefined
+            ? { "Content-Type": "application/json" }
+            : {}),
+        },
+        credentials: opts.getCredentials(),
+        ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+      });
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.warn(`fetch ${method} ${path}: network error:`, msg);
+      throw new Error(`Network error during ${method} ${path}: ${msg}`, {
+        cause: err,
+      });
+    }
+  }
+
+  async function request<T>(
+    method: string,
+    path: string,
+    body?: unknown,
+  ): Promise<T> {
+    const res = await raw(method, path, body);
+
+    if (!res.ok) {
+      console.warn(`fetch ${method} ${path}: HTTP ${res.status}`);
+      throw new Error(`Failed to ${method} ${path} (HTTP ${res.status})`);
+    }
+
+    // Handle 204 No Content
+    if (res.status === 204) return undefined as T;
+
+    try {
+      return (await res.json()) as T;
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.warn(`fetch ${method} ${path}: invalid JSON response:`, msg);
+      throw new Error(
+        `Invalid JSON response from ${method} ${path} (HTTP ${res.status})`,
+        { cause: err },
+      );
+    }
+  }
+
+  return {
+    raw,
+    get: <T>(path: string) => request<T>("GET", path),
+    post: <T>(path: string, body?: unknown) => request<T>("POST", path, body),
+    patch: <T>(path: string, body?: unknown) =>
+      request<T>("PATCH", path, body),
+    del: (path: string) => request<void>("DELETE", path),
+  };
+}

package/templates/nextjs-standalone/src/ui/lib/fetch-error.ts

@@ -0,0 +1,54 @@
+/**
+ * Structured error from a failed fetch operation.
+ * May represent an HTTP error response (with status and optional requestId)
+ * or a network-level failure (status undefined).
+ */
+export interface FetchError {
+  message: string;
+  status?: number;
+  requestId?: string;
+}
+
+/**
+ * Extract a structured error from a failed fetch response.
+ * Parses the JSON body for `message` and `requestId` fields; falls back to
+ * a status-only message if the body isn't JSON.
+ */
+export async function extractFetchError(res: Response): Promise<FetchError> {
+  let message = `HTTP ${res.status}`;
+  let requestId: string | undefined;
+  try {
+    const body: unknown = await res.json();
+    if (typeof body === "object" && body !== null) {
+      const obj = body as Record<string, unknown>;
+      if (typeof obj.message === "string") message = obj.message;
+      if (typeof obj.requestId === "string") requestId = obj.requestId;
+    }
+  } catch (err) {
+    // Non-JSON body is expected — log unexpected errors (e.g. body already consumed) for debugging.
+    if (!(err instanceof SyntaxError)) {
+      console.debug("extractFetchError: unexpected error reading response body", err);
+    }
+  }
+  return { message, status: res.status, ...(requestId && { requestId }) };
+}
+
+/**
+ * Convert a FetchError into a user-friendly message.
+ * Replaces known HTTP status codes (401, 403, 404, 503) with admin-specific
+ * guidance; falls back to the raw error message for other codes or non-HTTP
+ * errors. Appends request ID for log correlation when available.
+ */
+export function friendlyError(err: FetchError): string {
+  let msg: string;
+  if (err.status === 401) msg = "Not authenticated. Please sign in.";
+  else if (err.status === 403)
+    msg = "Access denied. Admin role required to view this page.";
+  else if (err.status === 404)
+    msg = "This feature is not enabled on this server.";
+  else if (err.status === 503)
+    msg = "A required service is unavailable. Check server configuration.";
+  else msg = err.message;
+  if (err.requestId) msg += ` (Request ID: ${err.requestId})`;
+  return msg;
+}

package/templates/nextjs-standalone/src/ui/lib/helpers.ts

@@ -82,7 +82,7 @@ export function downloadCSV(csv: string, filename = "atlas-results.csv") {
     a.download = filename;
     a.click();
   } catch (err) {
-    console.error("CSV download failed:", err);
+    console.error("CSV download failed:", err instanceof Error ? err.message : String(err));
     window.alert("CSV download failed");
   } finally {
     if (url) {
@@ -92,6 +92,99 @@ export function downloadCSV(csv: string, filename = "atlas-results.csv") {
   }
 }
 
+/** Strict ISO date pattern: YYYY-MM-DD with optional time component. */
+const ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:\d{2})?)?$/;
+
+/** Coerce a cell value to a typed Excel cell: numbers/booleans pass through, ISO dates become Date objects, null becomes empty string. Exported for testing. */
+export function coerceExcelCell(v: unknown): unknown {
+  if (v == null) return "";
+  if (typeof v === "number" || typeof v === "boolean") return v;
+  if (typeof v === "string" && ISO_DATE_RE.test(v) && !isNaN(Date.parse(v))) {
+    return new Date(v);
+  }
+  return String(v);
+}
+
+/** Trigger an Excel (.xlsx) download in the browser. Dynamically imports exceljs to avoid bundle bloat. */
+export async function downloadExcel(
+  columns: string[],
+  rows: Record<string, unknown>[],
+  filename = "atlas-results.xlsx",
+) {
+  let ExcelJS: typeof import("exceljs");
+  try {
+    ExcelJS = await import("exceljs");
+  } catch (err) {
+    console.error("Failed to load exceljs library:", err instanceof Error ? err.message : String(err));
+    window.alert("Excel export is unavailable. The spreadsheet library failed to load.");
+    return;
+  }
+
+  let url: string | null = null;
+  try {
+    const wb = new ExcelJS.Workbook();
+    const ws = wb.addWorksheet("Results");
+    ws.columns = columns.map((col) => ({ header: col, key: col }));
+    for (const row of rows) {
+      const obj: Record<string, unknown> = {};
+      for (const col of columns) {
+        obj[col] = coerceExcelCell(row[col]);
+      }
+      ws.addRow(obj);
+    }
+    const buffer = await wb.xlsx.writeBuffer();
+    const blob = new Blob([buffer], {
+      type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    });
+    url = URL.createObjectURL(blob);
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = filename;
+    a.click();
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    console.error("Excel download failed:", detail);
+    window.alert(`Excel download failed: ${detail}\n\nYou can try the CSV download as an alternative.`);
+  } finally {
+    if (url) {
+      const blobUrl = url;
+      setTimeout(() => URL.revokeObjectURL(blobUrl), 10_000);
+    }
+  }
+}
+
+const SUGGESTIONS_RE = /<suggestions>\s*([\s\S]*?)\s*<\/suggestions>/g;
+
+/** Extract follow-up suggestions from assistant message content and return the cleaned text + suggestions.
+ *  All `<suggestions>` blocks are stripped; suggestions from all blocks are merged. */
+export function parseSuggestions(content: string): { text: string; suggestions: string[] } {
+  const suggestions: string[] = [];
+  let match;
+  while ((match = SUGGESTIONS_RE.exec(content)) !== null) {
+    const lines = match[1].split("\n").map((l) => l.trim()).filter(Boolean);
+    suggestions.push(...lines);
+  }
+  SUGGESTIONS_RE.lastIndex = 0;
+  if (suggestions.length === 0) return { text: content, suggestions: [] };
+  const text = content.replace(SUGGESTIONS_RE, "").trimEnd();
+  SUGGESTIONS_RE.lastIndex = 0;
+  return { text, suggestions: suggestions.slice(0, 5) };
+}
+
+/**
+ * Normalize a record-or-array field from the API into a flat array.
+ * When the data is a Record, the key is merged in under `keyName`.
+ * Used by both admin entity-detail and schema explorer components.
+ */
+export function normalizeList<T>(
+  data: Record<string, T> | T[] | undefined,
+  keyName: string,
+): (T & Record<string, unknown>)[] {
+  if (!data) return [];
+  if (Array.isArray(data)) return data as (T & Record<string, unknown>)[];
+  return Object.entries(data).map(([key, value]) => ({ ...value, [keyName]: key }));
+}
+
 /** Format a cell value: null as em-dash, numbers with locale formatting, else stringified. */
 export function formatCell(value: unknown): string {
   if (value == null) return "\u2014";

package/templates/nextjs-standalone/src/ui/lib/types.ts

@@ -1,145 +1,154 @@
 /**
  * Shared types for Atlas UI.
  *
- * These are duplicated from @atlas/api to keep the frontend package independent
- * of the API package. The API is the source of truth — keep these in sync.
+ * All types are canonical from @useatlas/types — no local duplication.
  */
 
-// --- Auth types (from @atlas/api/lib/auth/types) ---
-
-export const AUTH_MODES = ["none", "simple-key", "managed", "byot"] as const;
-export type AuthMode = (typeof AUTH_MODES)[number];
-
-// --- Conversation types (from @atlas/api/lib/conversation-types) ---
-
-export type MessageRole = "user" | "assistant" | "system" | "tool";
-export type Surface = "web" | "api" | "mcp" | "slack";
-
-export interface Conversation {
-  id: string;
-  userId: string | null;
-  title: string | null;
-  surface: Surface;
-  connectionId: string | null;
-  starred: boolean;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export interface Message {
-  id: string;
-  conversationId: string;
-  role: MessageRole;
-  content: unknown;
-  createdAt: string;
-}
-
-export interface ConversationWithMessages extends Conversation {
-  messages: Message[];
-}
-
-// --- Error types (from @atlas/api/lib/errors) ---
-
-export const CHAT_ERROR_CODES = [
-  "auth_error",
-  "rate_limited",
-  "configuration_error",
-  "no_datasource",
-  "invalid_request",
-  "provider_model_not_found",
-  "provider_auth_error",
-  "provider_rate_limit",
-  "provider_timeout",
-  "provider_unreachable",
-  "provider_error",
-  "internal_error",
-] as const;
-
-export type ChatErrorCode = (typeof CHAT_ERROR_CODES)[number];
-
-export interface ChatErrorInfo {
-  title: string;
-  detail?: string;
-  retryAfterSeconds?: number;
-  code?: ChatErrorCode;
-}
-
-function authErrorMessage(authMode: AuthMode): string {
-  switch (authMode) {
-    case "simple-key":
-      return "Invalid or missing API key. Check your key and try again.";
-    case "managed":
-      return "Your session has expired. Please sign in again.";
-    case "byot":
-      return "Authentication failed. Your token may have expired.";
-    case "none":
-      return "An unexpected authentication error occurred. Please refresh the page.";
-    default: {
-      const _exhaustive: never = authMode;
-      return `Authentication failed (unknown mode: ${_exhaustive}).`;
-    }
-  }
-}
-
-export function parseChatError(error: Error, authMode: AuthMode): ChatErrorInfo {
-  let parsed: Record<string, unknown>;
-  try {
-    parsed = JSON.parse(error.message);
-  } catch {
-    return { title: "Something went wrong. Please try again." };
-  }
-
-  const code = typeof parsed.error === "string" ? parsed.error : undefined;
-  const serverMessage = typeof parsed.message === "string" ? parsed.message : undefined;
-
-  switch (code) {
-    case "auth_error":
-      return { title: authErrorMessage(authMode), code };
-
-    case "rate_limited": {
-      const raw = typeof parsed.retryAfterSeconds === "number" ? parsed.retryAfterSeconds : undefined;
-      const clamped = raw !== undefined ? Math.max(0, Math.min(raw, 300)) : undefined;
-      return {
-        title: "Too many requests.",
-        detail: clamped !== undefined
-          ? `Try again in ${clamped} seconds.`
-          : "Please wait before trying again.",
-        retryAfterSeconds: clamped,
-        code,
-      };
-    }
-
-    case "configuration_error":
-      return { title: "Atlas is not fully configured.", detail: serverMessage, code };
-
-    case "no_datasource":
-      return { title: "No data source configured.", detail: serverMessage, code };
-
-    case "invalid_request":
-      return { title: "Invalid request.", detail: serverMessage, code };
-
-    case "provider_model_not_found":
-      return { title: "The configured AI model was not found.", detail: serverMessage, code };
-
-    case "provider_auth_error":
-      return { title: "The AI provider could not authenticate.", detail: serverMessage, code };
-
-    case "provider_rate_limit":
-      return { title: "The AI provider is rate limiting requests.", detail: serverMessage, code };
-
-    case "provider_timeout":
-      return { title: "The AI provider timed out.", detail: serverMessage, code };
-
-    case "provider_unreachable":
-      return { title: "Could not reach the AI provider.", detail: serverMessage, code };
-
-    case "provider_error":
-      return { title: "The AI provider returned an error.", detail: serverMessage, code };
-
-    case "internal_error":
-      return { title: serverMessage ?? "An unexpected error occurred.", code };
-
-    default:
-      return { title: serverMessage ?? "Something went wrong. Please try again." };
-  }
-}
+import type { ShareMode } from "@useatlas/types";
+
+export { AUTH_MODES, DB_TYPES } from "@useatlas/types";
+export type {
+  AuthMode,
+  Conversation,
+  Message,
+  ConversationWithMessages,
+  NotebookStateWire,
+  ForkBranchWire,
+  ShareMode,
+  ShareExpiryKey,
+  DeliveryChannel,
+  ScheduledTask,
+  ScheduledTaskWithRuns,
+  ScheduledTaskRunWithTaskName,
+  ConnectionHealth,
+  ConnectionInfo,
+  ConnectionDetail,
+  PoolMetrics,
+  ChatErrorCode,
+  ChatErrorInfo,
+  ClientErrorCode,
+  Dimension,
+  Join,
+  Measure,
+  QueryPattern,
+  SemanticEntitySummary,
+  SemanticEntityDetail,
+  EntityData,
+  ActionApprovalMode,
+  ActionLogEntry,
+  SemanticDiffResponse,
+  SemanticTableDiff,
+  LearnedPattern,
+  LearnedPatternStatus,
+  LearnedPatternSource,
+  PromptCollection,
+  PromptItem,
+  PromptIndustry,
+  QuerySuggestion,
+  ObjectType,
+  WizardEntityColumn,
+  WizardEntityResult,
+  WizardForeignKey,
+  WizardInferredForeignKey,
+  WizardTableEntry,
+} from "@useatlas/types";
+export type {
+  ModelConfigProvider,
+  WorkspaceModelConfig,
+  TestModelConfigResponse,
+} from "@useatlas/types";
+export type {
+  ApprovalRule,
+  ApprovalRuleType,
+  ApprovalRequest,
+  ApprovalStatus,
+} from "@useatlas/types";
+export type {
+  PIICategory,
+  PIIConfidence,
+  MaskingStrategy,
+  PIIColumnClassification,
+  UpdatePIIClassificationRequest,
+  ComplianceReportType,
+  ComplianceReportFilters,
+  DataAccessRow,
+  DataAccessReport,
+  UserActivityRow,
+  UserActivityReport,
+} from "@useatlas/types";
+export type {
+  DeployMode,
+  DeployModeSetting,
+  PlatformWorkspace,
+  PlatformWorkspaceDetail,
+  PlatformWorkspaceUser,
+  PlatformStats,
+  NoisyNeighbor,
+  NoisyNeighborMetric,
+  WorkspaceStatus,
+  PlanTier,
+} from "@useatlas/types";
+export type {
+  WorkspaceBranding,
+  WorkspaceBrandingPublic,
+  SetWorkspaceBrandingInput,
+} from "@useatlas/types";
+export type {
+  OnboardingEmailStep,
+  OnboardingMilestone,
+  OnboardingEmailTrigger,
+  OnboardingEmailRecord,
+  OnboardingEmailStatus,
+  OnboardingEmailPreferences,
+} from "@useatlas/types";
+export type {
+  AbuseLevel,
+  AbuseTrigger,
+  AbuseEvent,
+  AbuseStatus,
+  AbuseThresholdConfig,
+} from "@useatlas/types";
+export type {
+  WorkspaceSLASummary,
+  SLAMetricPoint,
+  WorkspaceSLADetail,
+  SLAAlertStatus,
+  SLAAlertType,
+  SLAAlert,
+  SLAThresholds,
+} from "@useatlas/types";
+export type {
+  BackupEntry,
+  BackupStatus,
+  BackupConfig,
+} from "@useatlas/types";
+export type {
+  Region,
+  RegionConfig,
+  RegionPickerItem,
+  WorkspaceRegion,
+  RegionStatus,
+  MigrationStatus,
+  RegionMigration,
+} from "@useatlas/types";
+export { MIGRATION_STATUSES } from "@useatlas/types";
+export type {
+  CustomDomain,
+  DomainStatus,
+  CertificateStatus,
+} from "@useatlas/types";
+export { DOMAIN_STATUSES, CERTIFICATE_STATUSES } from "@useatlas/types";
+export { BACKUP_STATUSES } from "@useatlas/types";
+export { WELL_KNOWN_REGIONS } from "@useatlas/types";
+export { ABUSE_LEVELS, ABUSE_TRIGGERS } from "@useatlas/types";
+export { SLA_ALERT_STATUSES, SLA_ALERT_TYPES } from "@useatlas/types";
+export { ONBOARDING_EMAIL_STEPS, ONBOARDING_MILESTONES } from "@useatlas/types";
+export { PII_CATEGORIES, MASKING_STRATEGIES, PII_CONFIDENCE_LEVELS, COMPLIANCE_REPORT_TYPES } from "@useatlas/types";
+export { SHARE_EXPIRY_OPTIONS, PROMPT_INDUSTRIES, MODEL_CONFIG_PROVIDERS, APPROVAL_RULE_TYPES, APPROVAL_STATUSES, WORKSPACE_STATUSES, PLAN_TIERS, NOISY_NEIGHBOR_METRICS } from "@useatlas/types";
+export { parseChatError } from "@useatlas/types/errors";
+
+// --- Web-only types (not in @useatlas/types) ---
+
+export type ShareStatus =
+  | { shared: false }
+  | { shared: true; token: string; url: string; expiresAt: string | null; shareMode: ShareMode };

package/templates/nextjs-standalone/tsconfig.json

@@ -17,7 +17,8 @@
     "paths": {
       "@/*": ["./src/*"],
       "@atlas/api/app": ["./src/api/index.ts"],
-      "@atlas/api/*": ["./src/*"]
+      "@atlas/api/*": ["./src/*"],
+      "@atlas/ee/*": ["./ee/src/*"]
     }
   },
   "include": [
@@ -27,5 +28,5 @@
     ".next/types/**/*.ts",
     ".next/dev/types/**/*.ts"
   ],
-  "exclude": ["node_modules"]
+  "exclude": ["node_modules", "src/api/server.ts"]
 }