@useatlas/create 0.0.1

package/templates/nextjs-standalone/src/lib/__tests__/errors.test.ts

@@ -0,0 +1,256 @@
+import { describe, it, expect } from "bun:test";
+import {
+  parseChatError,
+  authErrorMessage,
+} from "@atlas/api/lib/errors";
+
+/* ------------------------------------------------------------------ */
+/*  Helpers                                                            */
+/* ------------------------------------------------------------------ */
+
+/** Build an Error whose .message is a JSON string (mimics AI SDK chat errors). */
+function jsonError(body: Record<string, unknown>): Error {
+  return new Error(JSON.stringify(body));
+}
+
+/* ------------------------------------------------------------------ */
+/*  parseChatError                                                     */
+/* ------------------------------------------------------------------ */
+
+describe("parseChatError", () => {
+  // 1. Non-JSON fallback
+  it("returns generic fallback when error.message is not JSON", () => {
+    const info = parseChatError(new Error("network timeout"), "none");
+    expect(info.title).toBe("Something went wrong. Please try again.");
+    expect(info.code).toBeUndefined();
+  });
+
+  // 2–5. auth_error × each auth mode
+  it("auth_error + simple-key → API key message", () => {
+    const info = parseChatError(jsonError({ error: "auth_error" }), "simple-key");
+    expect(info.title).toContain("API key");
+    expect(info.code).toBe("auth_error");
+  });
+
+  it("auth_error + managed → session expired message", () => {
+    const info = parseChatError(jsonError({ error: "auth_error" }), "managed");
+    expect(info.title).toContain("sign in");
+    expect(info.code).toBe("auth_error");
+  });
+
+  it("auth_error + byot → token expired message", () => {
+    const info = parseChatError(jsonError({ error: "auth_error" }), "byot");
+    expect(info.title).toContain("token");
+    expect(info.code).toBe("auth_error");
+  });
+
+  it("auth_error + none → unexpected auth error message", () => {
+    const info = parseChatError(jsonError({ error: "auth_error" }), "none");
+    expect(info.title).toContain("unexpected");
+    expect(info.code).toBe("auth_error");
+  });
+
+  // 6. rate_limited WITH retryAfterSeconds
+  it("rate_limited with retryAfterSeconds → includes countdown", () => {
+    const info = parseChatError(
+      jsonError({ error: "rate_limited", retryAfterSeconds: 30 }),
+      "none",
+    );
+    expect(info.title).toBe("Too many requests.");
+    expect(info.detail).toContain("30 seconds");
+    expect(info.retryAfterSeconds).toBe(30);
+    expect(info.code).toBe("rate_limited");
+  });
+
+  // 7. rate_limited WITHOUT retryAfterSeconds
+  it("rate_limited without retryAfterSeconds → generic wait message", () => {
+    const info = parseChatError(
+      jsonError({ error: "rate_limited" }),
+      "none",
+    );
+    expect(info.title).toBe("Too many requests.");
+    expect(info.detail).toBe("Please wait before trying again.");
+    expect(info.retryAfterSeconds).toBeUndefined();
+    expect(info.code).toBe("rate_limited");
+  });
+
+  // 8. rate_limited with negative retryAfterSeconds → clamped to 0
+  it("rate_limited with negative retryAfterSeconds → clamped to 0", () => {
+    const info = parseChatError(
+      jsonError({ error: "rate_limited", retryAfterSeconds: -5 }),
+      "none",
+    );
+    expect(info.retryAfterSeconds).toBe(0);
+    expect(info.detail).toContain("0 seconds");
+  });
+
+  // 9. rate_limited with very large retryAfterSeconds → clamped to 300
+  it("rate_limited with huge retryAfterSeconds → clamped to 300", () => {
+    const info = parseChatError(
+      jsonError({ error: "rate_limited", retryAfterSeconds: 9999 }),
+      "none",
+    );
+    expect(info.retryAfterSeconds).toBe(300);
+    expect(info.detail).toContain("300 seconds");
+  });
+
+  // 10. configuration_error
+  it("configuration_error → includes server message as detail", () => {
+    const info = parseChatError(
+      jsonError({ error: "configuration_error", message: "Missing API key" }),
+      "none",
+    );
+    expect(info.title).toBe("Atlas is not fully configured.");
+    expect(info.detail).toBe("Missing API key");
+    expect(info.code).toBe("configuration_error");
+  });
+
+  // 11. no_datasource
+  it("no_datasource → correct title", () => {
+    const info = parseChatError(
+      jsonError({ error: "no_datasource" }),
+      "none",
+    );
+    expect(info.title).toBe("No data source configured.");
+    expect(info.code).toBe("no_datasource");
+  });
+
+  // 12. invalid_request
+  it("invalid_request → correct title", () => {
+    const info = parseChatError(
+      jsonError({ error: "invalid_request" }),
+      "none",
+    );
+    expect(info.title).toBe("Invalid request.");
+    expect(info.code).toBe("invalid_request");
+  });
+
+  // 13. provider_model_not_found
+  it("provider_model_not_found → correct title", () => {
+    const info = parseChatError(
+      jsonError({ error: "provider_model_not_found" }),
+      "none",
+    );
+    expect(info.title).toBe("The configured AI model was not found.");
+    expect(info.code).toBe("provider_model_not_found");
+  });
+
+  // 14. provider_auth_error
+  it("provider_auth_error → correct title", () => {
+    const info = parseChatError(
+      jsonError({ error: "provider_auth_error", message: "Bad credentials" }),
+      "none",
+    );
+    expect(info.title).toBe("The AI provider could not authenticate.");
+    expect(info.detail).toBe("Bad credentials");
+    expect(info.code).toBe("provider_auth_error");
+  });
+
+  // 15. provider_rate_limit
+  it("provider_rate_limit → correct title", () => {
+    const info = parseChatError(
+      jsonError({ error: "provider_rate_limit" }),
+      "none",
+    );
+    expect(info.title).toBe("The AI provider is rate limiting requests.");
+    expect(info.code).toBe("provider_rate_limit");
+  });
+
+  // 16. provider_timeout
+  it("provider_timeout → correct title", () => {
+    const info = parseChatError(
+      jsonError({ error: "provider_timeout" }),
+      "none",
+    );
+    expect(info.title).toBe("The AI provider timed out.");
+    expect(info.code).toBe("provider_timeout");
+  });
+
+  // 17. provider_unreachable
+  it("provider_unreachable → correct title", () => {
+    const info = parseChatError(
+      jsonError({ error: "provider_unreachable" }),
+      "none",
+    );
+    expect(info.title).toBe("Could not reach the AI provider.");
+    expect(info.code).toBe("provider_unreachable");
+  });
+
+  // 18. internal_error with message
+  it("internal_error with message → passes through server message", () => {
+    const info = parseChatError(
+      jsonError({ error: "internal_error", message: "DB pool exhausted" }),
+      "none",
+    );
+    expect(info.title).toBe("DB pool exhausted");
+    expect(info.code).toBe("internal_error");
+  });
+
+  // 19. internal_error without message
+  it("internal_error without message → generic fallback", () => {
+    const info = parseChatError(
+      jsonError({ error: "internal_error" }),
+      "none",
+    );
+    expect(info.title).toBe("An unexpected error occurred.");
+    expect(info.code).toBe("internal_error");
+  });
+
+  // 20. Unknown code with message
+  it("unknown code with message → passes through server message", () => {
+    const info = parseChatError(
+      jsonError({ error: "something_new", message: "New error type" }),
+      "none",
+    );
+    expect(info.title).toBe("New error type");
+    expect(info.code).toBeUndefined();
+  });
+
+  // 21. Unknown code without message
+  it("unknown code without message → generic fallback", () => {
+    const info = parseChatError(
+      jsonError({ error: "something_new" }),
+      "none",
+    );
+    expect(info.title).toBe("Something went wrong. Please try again.");
+  });
+
+  // 22. Valid JSON but error field is not a string
+  it("error field is a number → default case", () => {
+    const info = parseChatError(
+      jsonError({ error: 42, message: "Unexpected" }),
+      "none",
+    );
+    expect(info.title).toBe("Unexpected");
+    expect(info.code).toBeUndefined();
+  });
+
+  // 23. Valid JSON but empty object
+  it("empty JSON object → default case", () => {
+    const info = parseChatError(jsonError({}), "none");
+    expect(info.title).toBe("Something went wrong. Please try again.");
+    expect(info.code).toBeUndefined();
+  });
+});
+
+/* ------------------------------------------------------------------ */
+/*  authErrorMessage                                                   */
+/* ------------------------------------------------------------------ */
+
+describe("authErrorMessage", () => {
+  it("simple-key → mentions API key", () => {
+    expect(authErrorMessage("simple-key")).toContain("API key");
+  });
+
+  it("managed → mentions sign in", () => {
+    expect(authErrorMessage("managed")).toContain("sign in");
+  });
+
+  it("byot → mentions token", () => {
+    expect(authErrorMessage("byot")).toContain("token");
+  });
+
+  it("none → mentions unexpected", () => {
+    expect(authErrorMessage("none")).toContain("unexpected");
+  });
+});

package/templates/nextjs-standalone/src/lib/__tests__/logger.test.ts

@@ -0,0 +1,200 @@
+import { describe, expect, test } from "bun:test";
+import { Writable } from "stream";
+import pino from "pino";
+import {
+  getLogger,
+  createLogger,
+  withRequestContext,
+  getRequestContext,
+  redactPaths,
+} from "../logger";
+
+describe("logger", () => {
+  test("getLogger returns a pino logger with expected methods", () => {
+    const log = getLogger();
+    expect(typeof log.info).toBe("function");
+    expect(typeof log.error).toBe("function");
+    expect(typeof log.warn).toBe("function");
+    expect(typeof log.debug).toBe("function");
+  });
+
+  test("createLogger returns a child logger with component binding", () => {
+    const log = createLogger("test-component");
+    expect(typeof log.info).toBe("function");
+    const bindings = log.bindings();
+    expect(bindings.component).toBe("test-component");
+  });
+
+  test("withRequestContext makes requestId available via getRequestContext", () => {
+    const requestId = "test-request-123";
+
+    withRequestContext({ requestId }, () => {
+      const ctx = getRequestContext();
+      expect(ctx).toBeDefined();
+      expect(ctx!.requestId).toBe(requestId);
+    });
+  });
+
+  test("getLogger outside request context returns root logger", () => {
+    const log = getLogger();
+    const bindings = log.bindings();
+    expect(bindings.requestId).toBeUndefined();
+  });
+
+  test("getRequestContext returns undefined outside context", () => {
+    const ctx = getRequestContext();
+    expect(ctx).toBeUndefined();
+  });
+
+  test("mixin injects requestId into log output within withRequestContext", () => {
+    const requestId = "mixin-test-456";
+
+    // Create a pino logger that mimics the module's mixin, writing to a stream
+    const chunks: Buffer[] = [];
+    const stream = new Writable({
+      write(chunk: Buffer, _encoding: string, cb: () => void) {
+        chunks.push(chunk);
+        cb();
+      },
+    });
+
+    const testLogger = pino(
+      {
+        level: "info",
+        mixin() {
+          const ctx = getRequestContext();
+          return ctx ? { requestId: ctx.requestId } : {};
+        },
+      },
+      stream,
+    );
+
+    // Outside context — no requestId
+    testLogger.info({ msg: "no-context" });
+    const outsideParsed = JSON.parse(Buffer.concat(chunks).toString());
+    expect(outsideParsed.requestId).toBeUndefined();
+
+    // Inside context — requestId injected by mixin
+    chunks.length = 0;
+    withRequestContext({ requestId }, () => {
+      testLogger.info({ msg: "with-context" });
+    });
+    const insideParsed = JSON.parse(Buffer.concat(chunks).toString());
+    expect(insideParsed.requestId).toBe(requestId);
+  });
+
+  test("withRequestContext propagates user to getRequestContext", () => {
+    const user = { id: "test-user-id", mode: "simple-key" as const, label: "api-key-test" };
+    withRequestContext({ requestId: "req-123", user }, () => {
+      const ctx = getRequestContext();
+      expect(ctx).toBeDefined();
+      expect(ctx!.user).toEqual(user);
+    });
+  });
+
+  test("mixin injects userId and authMode when user is present in context", () => {
+    const chunks: Buffer[] = [];
+    const stream = new Writable({
+      write(chunk: Buffer, _encoding: string, cb: () => void) {
+        chunks.push(chunk);
+        cb();
+      },
+    });
+
+    const testLogger = pino(
+      {
+        level: "info",
+        mixin() {
+          const ctx = getRequestContext();
+          if (!ctx) return {};
+          const base: Record<string, unknown> = { requestId: ctx.requestId };
+          if (ctx.user) {
+            base.userId = ctx.user.id;
+            base.authMode = ctx.user.mode;
+          }
+          return base;
+        },
+      },
+      stream,
+    );
+
+    const user = { id: "api-key-abc12345", mode: "simple-key" as const, label: "api-key-sk-t" };
+    withRequestContext({ requestId: "req-with-user", user }, () => {
+      testLogger.info("authenticated request");
+    });
+
+    const parsed = JSON.parse(Buffer.concat(chunks).toString());
+    expect(parsed.requestId).toBe("req-with-user");
+    expect(parsed.userId).toBe("api-key-abc12345");
+    expect(parsed.authMode).toBe("simple-key");
+  });
+
+  test("redaction replaces sensitive fields with [Redacted]", () => {
+    // Create a test logger with equivalent redact paths (object form for explicit censor assertion)
+    const chunks: Buffer[] = [];
+    const stream = new Writable({
+      write(chunk: Buffer, _encoding: string, cb: () => void) {
+        chunks.push(chunk);
+        cb();
+      },
+    });
+
+    const testLogger = pino(
+      {
+        level: "info",
+        redact: { paths: redactPaths, censor: "[Redacted]" },
+      },
+      stream,
+    );
+
+    testLogger.info({
+      msg: "connection attempt",
+      password: "super-secret-pw",
+      apiKey: "sk-ant-key-12345",
+      connectionString: "postgresql://user:pass@host/db",
+      safe: "this-should-remain",
+    });
+
+    const output = Buffer.concat(chunks).toString();
+    const parsed = JSON.parse(output);
+
+    expect(parsed.password).toBe("[Redacted]");
+    expect(parsed.apiKey).toBe("[Redacted]");
+    expect(parsed.connectionString).toBe("[Redacted]");
+    expect(parsed.safe).toBe("this-should-remain");
+  });
+
+  test("redaction works for nested fields", () => {
+    const chunks: Buffer[] = [];
+    const stream = new Writable({
+      write(chunk: Buffer, _encoding: string, cb: () => void) {
+        chunks.push(chunk);
+        cb();
+      },
+    });
+
+    const testLogger = pino(
+      {
+        level: "info",
+        redact: { paths: redactPaths, censor: "[Redacted]" },
+      },
+      stream,
+    );
+
+    testLogger.info({
+      msg: "nested secret test",
+      config: {
+        password: "nested-secret",
+        apiKey: "nested-key",
+        safe: "visible",
+      },
+    });
+
+    const output = Buffer.concat(chunks).toString();
+    const parsed = JSON.parse(output);
+
+    expect(parsed.config.password).toBe("[Redacted]");
+    expect(parsed.config.apiKey).toBe("[Redacted]");
+    expect(parsed.config.safe).toBe("visible");
+  });
+});

package/templates/nextjs-standalone/src/lib/__tests__/providers.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, test, afterEach } from "bun:test";
+
+// Import after mocks — getProviderType reads process.env at call time, so no
+// module-level mocking is needed.
+const { getProviderType } = await import("@atlas/api/lib/providers");
+
+// ---------------------------------------------------------------------------
+// Env snapshot — capture/restore only the vars this test touches
+// ---------------------------------------------------------------------------
+
+const origProvider = process.env.ATLAS_PROVIDER;
+const origModel = process.env.ATLAS_MODEL;
+
+afterEach(() => {
+  if (origProvider !== undefined) process.env.ATLAS_PROVIDER = origProvider;
+  else delete process.env.ATLAS_PROVIDER;
+
+  if (origModel !== undefined) process.env.ATLAS_MODEL = origModel;
+  else delete process.env.ATLAS_MODEL;
+});
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("getProviderType", () => {
+  test("defaults to 'anthropic' when no env vars are set", () => {
+    delete process.env.ATLAS_PROVIDER;
+    delete process.env.ATLAS_MODEL;
+    expect(getProviderType()).toBe("anthropic");
+  });
+
+  test("returns 'anthropic' when ATLAS_PROVIDER=anthropic", () => {
+    process.env.ATLAS_PROVIDER = "anthropic";
+    delete process.env.ATLAS_MODEL;
+    expect(getProviderType()).toBe("anthropic");
+  });
+
+  test("returns 'openai' when ATLAS_PROVIDER=openai", () => {
+    process.env.ATLAS_PROVIDER = "openai";
+    expect(getProviderType()).toBe("openai");
+  });
+
+  test("returns 'ollama' when ATLAS_PROVIDER=ollama", () => {
+    process.env.ATLAS_PROVIDER = "ollama";
+    expect(getProviderType()).toBe("ollama");
+  });
+
+  test("returns 'gateway' when ATLAS_PROVIDER=gateway", () => {
+    process.env.ATLAS_PROVIDER = "gateway";
+    expect(getProviderType()).toBe("gateway");
+  });
+
+  // --- Bedrock variants ---------------------------------------------------
+
+  test("returns 'bedrock-anthropic' for bedrock with anthropic.claude model", () => {
+    process.env.ATLAS_PROVIDER = "bedrock";
+    process.env.ATLAS_MODEL = "anthropic.claude-opus-4-6-v1:0";
+    expect(getProviderType()).toBe("bedrock-anthropic");
+  });
+
+  test("returns 'bedrock-anthropic' for bedrock with cross-region anthropic model", () => {
+    process.env.ATLAS_PROVIDER = "bedrock";
+    process.env.ATLAS_MODEL = "us.anthropic.claude-3-7-sonnet-20250219-v1:0";
+    expect(getProviderType()).toBe("bedrock-anthropic");
+  });
+
+  test("returns 'bedrock' for bedrock with non-anthropic model", () => {
+    process.env.ATLAS_PROVIDER = "bedrock";
+    process.env.ATLAS_MODEL = "amazon.nova-pro-v1:0";
+    expect(getProviderType()).toBe("bedrock");
+  });
+
+  test("returns 'bedrock-anthropic' for bedrock with default model (no ATLAS_MODEL)", () => {
+    process.env.ATLAS_PROVIDER = "bedrock";
+    delete process.env.ATLAS_MODEL;
+    // Default bedrock model is anthropic.claude-opus-4-6-v1:0, which contains "anthropic"
+    expect(getProviderType()).toBe("bedrock-anthropic");
+  });
+
+  test("returns 'bedrock-anthropic' for bedrock with claude model (no 'anthropic' in ID)", () => {
+    process.env.ATLAS_PROVIDER = "bedrock";
+    process.env.ATLAS_MODEL = "claude-3-opus-20240229";
+    expect(getProviderType()).toBe("bedrock-anthropic");
+  });
+
+  test("returns 'bedrock' for bedrock with meta llama model", () => {
+    process.env.ATLAS_PROVIDER = "bedrock";
+    process.env.ATLAS_MODEL = "meta.llama3-1-70b-instruct-v1:0";
+    expect(getProviderType()).toBe("bedrock");
+  });
+
+  // --- Invalid provider ----------------------------------------------------
+
+  test("throws for an invalid provider string", () => {
+    process.env.ATLAS_PROVIDER = "typo-provider";
+    expect(() => getProviderType()).toThrow(Error);
+  });
+});