timeback 0.1.2 → 0.1.4

package/dist/server/adapters/nuxt.js

@@ -1,673 +0,0 @@
-import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-// src/shared/constants.ts
-var ROUTES = {
-  ACTIVITY: "/activity",
-  IDENTITY: {
-    SIGNIN: "/identity/signin",
-    SIGNOUT: "/identity/signout",
-    CALLBACK: "/identity/callback"
-  },
-  USER: {
-    ME: "/user/me"
-  }
-};
-
-// ../internal/logger/src/debug.ts
-var patterns = null;
-var debugAll = false;
-var debugEnvSet = false;
-function patternToRegex(pattern) {
-  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
-  const regexStr = escaped.replace(/\*/g, ".*");
-  return new RegExp(`^${regexStr}$`);
-}
-function parseDebugEnv() {
-  if (patterns !== null)
-    return;
-  patterns = [];
-  if (typeof process === "undefined" || !process.env?.DEBUG) {
-    debugEnvSet = false;
-    return;
-  }
-  debugEnvSet = true;
-  const debugValue = process.env.DEBUG.trim();
-  if (debugValue === "1" || debugValue === "true" || debugValue === "*") {
-    debugAll = true;
-    return;
-  }
-  const parts = debugValue.split(",").map((p) => p.trim()).filter(Boolean);
-  for (const part of parts) {
-    if (part.startsWith("-")) {
-      patterns.push({
-        regex: patternToRegex(part.slice(1)),
-        exclude: true
-      });
-    } else {
-      patterns.push({
-        regex: patternToRegex(part),
-        exclude: false
-      });
-    }
-  }
-  const hasInclude = patterns.some((p) => !p.exclude);
-  if (!hasInclude && patterns.length > 0) {
-    debugAll = true;
-  }
-}
-function shouldShowDebug(scope) {
-  parseDebugEnv();
-  if (!debugEnvSet) {
-    return true;
-  }
-  if (debugAll) {
-    if (scope) {
-      for (const pattern of patterns) {
-        if (pattern.exclude && pattern.regex.test(scope)) {
-          return false;
-        }
-      }
-    }
-    return true;
-  }
-  if (!scope) {
-    return false;
-  }
-  for (const pattern of patterns) {
-    if (pattern.exclude && pattern.regex.test(scope)) {
-      return false;
-    }
-  }
-  for (const pattern of patterns) {
-    if (!pattern.exclude && pattern.regex.test(scope)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-// ../internal/logger/src/env.ts
-function isBrowser() {
-  return typeof globalThis !== "undefined" && "window" in globalThis;
-}
-function detectEnvironment() {
-  if (isBrowser()) {
-    return "browser";
-  }
-  if (typeof process !== "undefined" && process.env) {
-    if (process.env["NODE_ENV"] === "test" || process.env["BUN_ENV"] === "test") {
-      return "test";
-    }
-    if (false) {}
-    if (process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI || process.env.CIRCLECI || process.env.JENKINS_URL || process.env.BUILDKITE) {
-      return "ci";
-    }
-  }
-  return "terminal";
-}
-
-// ../internal/logger/src/formatters/terminal.ts
-var nodeInspect;
-if (!isBrowser()) {
-  try {
-    const util = await import("node:util");
-    nodeInspect = util.inspect;
-  } catch {}
-}
-var colors = {
-  reset: "\x1B[0m",
-  bold: "\x1B[1m",
-  dim: "\x1B[2m",
-  red: "\x1B[31m",
-  yellow: "\x1B[33m",
-  blue: "\x1B[34m",
-  cyan: "\x1B[36m"
-};
-function getLevelColor(level) {
-  switch (level) {
-    case "debug":
-      return colors.blue;
-    case "info":
-      return colors.cyan;
-    case "warn":
-      return colors.yellow;
-    case "error":
-      return colors.red;
-  }
-}
-function getConsoleMethod(level) {
-  switch (level) {
-    case "debug":
-      return console.debug;
-    case "info":
-      return console.info;
-    case "warn":
-      return console.warn;
-    case "error":
-      return console.error;
-  }
-}
-function formatContext(context) {
-  if (nodeInspect) {
-    return nodeInspect(context, {
-      depth: null,
-      colors: true,
-      breakLength: 80,
-      compact: false
-    });
-  }
-  return JSON.stringify(context, null, 2);
-}
-var terminalFormatter = (entry) => {
-  const levelColor = getLevelColor(entry.level);
-  const consoleMethod = getConsoleMethod(entry.level);
-  const levelUpper = entry.level.toUpperCase().padEnd(5);
-  const isoString = entry.timestamp.toISOString().replace(/\.\d{3}Z$/, "");
-  const timestamp = `${colors.dim}[${isoString}]${colors.reset}`;
-  const level = `${levelColor}${levelUpper}${colors.reset}`;
-  const scope = entry.scope ? `${colors.bold}[${entry.scope}]${colors.reset} ` : "";
-  const prefix = `${timestamp} ${level} ${scope}${entry.message}`;
-  if (entry.context && Object.keys(entry.context).length > 0) {
-    consoleMethod(prefix, formatContext(entry.context));
-  } else {
-    consoleMethod(prefix);
-  }
-};
-// ../internal/logger/src/formatters/ci.ts
-var LEVEL_PREFIX = {
-  debug: "[DEBUG]",
-  info: "[INFO]",
-  warn: "[WARN]",
-  error: "[ERROR]"
-};
-function formatContext2(context) {
-  return Object.entries(context).map(([key, value]) => `${key}=${formatValue(value)}`).join(" ");
-}
-function formatValue(value) {
-  if (typeof value === "string")
-    return value;
-  if (typeof value === "number")
-    return String(value);
-  if (typeof value === "boolean")
-    return String(value);
-  if (value === null)
-    return "null";
-  if (value === undefined)
-    return "undefined";
-  return JSON.stringify(value);
-}
-var ciFormatter = (entry) => {
-  const parts = [];
-  parts.push(entry.timestamp.toISOString());
-  parts.push(LEVEL_PREFIX[entry.level]);
-  if (entry.scope) {
-    parts.push(`[${entry.scope}]`);
-  }
-  parts.push(entry.message);
-  if (entry.context && Object.keys(entry.context).length > 0) {
-    parts.push(formatContext2(entry.context));
-  }
-  console.log(parts.join(" "));
-};
-// ../internal/logger/src/formatters/production.ts
-var productionFormatter = (entry) => {
-  const output = {
-    timestamp: entry.timestamp.toISOString(),
-    level: entry.level,
-    ...entry.scope && { scope: entry.scope },
-    msg: entry.message
-  };
-  if (entry.context && Object.keys(entry.context).length > 0) {
-    Object.assign(output, entry.context);
-  }
-  console.log(JSON.stringify(output));
-};
-// ../internal/logger/src/formatters/browser.ts
-var LEVEL_STYLES = {
-  debug: "color: gray",
-  info: "color: #0ea5e9",
-  warn: "color: #f59e0b",
-  error: "color: #ef4444; font-weight: bold"
-};
-var LEVEL_METHODS = {
-  debug: "log",
-  info: "info",
-  warn: "warn",
-  error: "error"
-};
-var browserFormatter = (entry) => {
-  const method = LEVEL_METHODS[entry.level];
-  const style = LEVEL_STYLES[entry.level];
-  const prefix = entry.scope ? `[${entry.scope}]` : "";
-  const label = `%c${prefix} ${entry.message}`;
-  if (entry.context && Object.keys(entry.context).length > 0) {
-    console[method](label, style, entry.context);
-  } else {
-    console[method](label, style);
-  }
-};
-// ../internal/logger/src/logger.ts
-var LOG_LEVELS = ["debug", "info", "warn", "error"];
-function getFormatter(env) {
-  switch (env) {
-    case "terminal":
-      return terminalFormatter;
-    case "ci":
-      return ciFormatter;
-    case "production":
-      return productionFormatter;
-    case "browser":
-      return browserFormatter;
-    case "test":
-      return () => {};
-  }
-}
-function getDefaultMinLevel() {
-  if (typeof process !== "undefined" && process.env?.DEBUG) {
-    return "debug";
-  }
-  return "info";
-}
-function shouldLog(level, minLevel) {
-  return LOG_LEVELS.indexOf(level) >= LOG_LEVELS.indexOf(minLevel);
-}
-
-class Logger {
-  scope;
-  minLevel;
-  environment;
-  formatter;
-  defaultContext;
-  constructor(options = {}) {
-    this.scope = options.scope;
-    this.minLevel = options.minLevel ?? getDefaultMinLevel();
-    this.defaultContext = options.defaultContext ?? {};
-    this.environment = options.environment ?? detectEnvironment();
-    this.formatter = getFormatter(this.environment);
-  }
-  child(scope) {
-    const childScope = this.scope ? `${this.scope}:${scope}` : scope;
-    return new Logger({
-      scope: childScope,
-      minLevel: this.minLevel,
-      environment: this.environment,
-      defaultContext: { ...this.defaultContext }
-    });
-  }
-  withContext(context) {
-    return new Logger({
-      scope: this.scope,
-      minLevel: this.minLevel,
-      environment: this.environment,
-      defaultContext: { ...this.defaultContext, ...context }
-    });
-  }
-  debug(message, context) {
-    this.log("debug", message, context);
-  }
-  info(message, context) {
-    this.log("info", message, context);
-  }
-  warn(message, context) {
-    this.log("warn", message, context);
-  }
-  error(message, context) {
-    this.log("error", message, context);
-  }
-  log(level, message, context) {
-    if (level === "debug" && !shouldShowDebug(this.scope)) {
-      return;
-    }
-    if (!shouldLog(level, this.minLevel)) {
-      return;
-    }
-    const entry = {
-      level,
-      message,
-      scope: this.scope,
-      context: context || Object.keys(this.defaultContext).length > 0 ? { ...this.defaultContext, ...context } : undefined,
-      timestamp: new Date
-    };
-    this.formatter(entry);
-  }
-}
-function createLogger(options = {}) {
-  return new Logger(options);
-}
-// src/server/lib/logger.ts
-function isDebug() {
-  try {
-    const debug = typeof process === "undefined" ? undefined : process.env.DEBUG;
-    return debug === "1" || debug === "true";
-  } catch {
-    return false;
-  }
-}
-function createScopedLogger(scope) {
-  return createLogger({
-    scope: `timeback:${scope}`,
-    minLevel: isDebug() ? "debug" : "warn"
-  });
-}
-var ssoLog = createScopedLogger("sso");
-var oidcLog = createScopedLogger("oidc");
-
-// src/server/lib/oidc.ts
-var discoveryCache = new Map;
-async function fetchDiscoveryDocument(issuer) {
-  const cached = discoveryCache.get(issuer);
-  if (cached) {
-    return cached;
-  }
-  const url = `${issuer}/.well-known/openid-configuration`;
-  const response = await fetch(url);
-  if (!response.ok) {
-    oidcLog.error("Discovery fetch failed", { status: response.status });
-    throw new Error(`Failed to fetch OIDC discovery: ${response.statusText}`);
-  }
-  const doc = await response.json();
-  oidcLog.debug("Fetched OIDC discovery document", {
-    authEndpoint: doc.authorization_endpoint,
-    tokenEndpoint: doc.token_endpoint
-  });
-  discoveryCache.set(issuer, doc);
-  return doc;
-}
-function getIssuer(env) {
-  switch (env) {
-    case "production":
-      return "https://cognito-idp.us-east-1.amazonaws.com/us-east-1_3uhuoRM3R";
-    case "staging":
-      return "https://cognito-idp.us-east-1.amazonaws.com/us-east-1_5EUwTP9XD";
-    case "local":
-      throw new Error("Local environment is not yet supported for OIDC");
-  }
-}
-async function buildAuthorizationUrl(params) {
-  const discovery = await fetchDiscoveryDocument(params.issuer);
-  const url = new URL(discovery.authorization_endpoint);
-  url.searchParams.set("response_type", "code");
-  url.searchParams.set("client_id", params.clientId);
-  url.searchParams.set("redirect_uri", params.redirectUri);
-  url.searchParams.set("scope", "openid profile email");
-  url.searchParams.set("state", params.state);
-  return url.toString();
-}
-async function exchangeCodeForTokens(params) {
-  const discovery = await fetchDiscoveryDocument(params.issuer);
-  const response = await fetch(discovery.token_endpoint, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/x-www-form-urlencoded"
-    },
-    body: new URLSearchParams({
-      grant_type: "authorization_code",
-      client_id: params.clientId,
-      client_secret: params.clientSecret,
-      code: params.code,
-      redirect_uri: params.redirectUri
-    })
-  });
-  if (!response.ok) {
-    const text = await response.text();
-    oidcLog.error("Token exchange failed", { status: response.status, body: text });
-    throw new Error(`Token exchange failed: ${response.status} ${text}`);
-  }
-  const tokens = await response.json();
-  oidcLog.debug("Received tokens from IdP", { expiresIn: tokens.expires_in });
-  return tokens;
-}
-async function getUserInfo(params) {
-  const discovery = await fetchDiscoveryDocument(params.issuer);
-  const response = await fetch(discovery.userinfo_endpoint, {
-    headers: {
-      Authorization: `Bearer ${params.accessToken}`
-    }
-  });
-  if (!response.ok) {
-    throw new Error(`UserInfo request failed: ${response.statusText}`);
-  }
-  return response.json();
-}
-// src/server/lib/utils.ts
-function jsonResponse(data, status = 200, headers) {
-  const responseHeaders = new Headers(headers);
-  responseHeaders.set("Content-Type", "application/json");
-  return new Response(JSON.stringify(data), { status, headers: responseHeaders });
-}
-function redirectResponse(url, headers) {
-  const responseHeaders = new Headers(headers);
-  responseHeaders.set("Location", url);
-  return new Response(null, { status: 302, headers: responseHeaders });
-}
-function encodeBase64Url(data) {
-  const json = JSON.stringify(data);
-  return btoa(json).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-}
-function decodeBase64Url(encoded) {
-  const padded = encoded.replace(/-/g, "+").replace(/_/g, "/");
-  const json = atob(padded);
-  return JSON.parse(json);
-}
-// src/server/adapters/utils.ts
-function getHandlers(input) {
-  return "handle" in input ? input.handle : input;
-}
-function hasActivityHandler(handlers) {
-  return "activity" in handlers;
-}
-function hasUserHandler(handlers) {
-  return "user" in handlers;
-}
-
-// src/server/adapters/nuxt.ts
-function bufferNodeBody(req) {
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    req.on("data", (chunk) => {
-      if (!chunk)
-        return;
-      if (chunk instanceof Buffer)
-        return void chunks.push(chunk);
-      if (typeof chunk === "string")
-        return void chunks.push(Buffer.from(chunk, "utf-8"));
-      if (chunk instanceof Uint8Array)
-        return void chunks.push(Buffer.from(chunk));
-    });
-    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
-    req.on("error", (chunk) => {
-      if (chunk instanceof Error) {
-        reject(chunk);
-      }
-    });
-  });
-}
-function getPathFromEvent(event) {
-  if (event.path) {
-    return event.path;
-  }
-  if (event.request) {
-    const url = event.request.url;
-    if (url.startsWith("http://") || url.startsWith("https://")) {
-      return new URL(url).pathname;
-    }
-    return url.split("?")[0] ?? "/";
-  }
-  const reqUrl = event.node?.req?.url;
-  return (reqUrl?.split("?")[0] ?? "/") || "/";
-}
-function firstHeaderValue(value) {
-  if (!value)
-    return;
-  if (Array.isArray(value))
-    return value[0]?.trim();
-  return value.split(",")[0]?.trim();
-}
-function buildAbsoluteUrlFromNodeRequest(req) {
-  const rawUrl = req.url ?? "/";
-  if (rawUrl.startsWith("http://") || rawUrl.startsWith("https://")) {
-    return new URL(rawUrl).href;
-  }
-  const forwardedProto = firstHeaderValue(req.headers["x-forwarded-proto"]);
-  const protocol = forwardedProto === "https" ? "https" : forwardedProto === "http" ? "http" : "http";
-  const forwardedHost = firstHeaderValue(req.headers["x-forwarded-host"]);
-  const host = forwardedHost || req.headers.host || "localhost";
-  return new URL(rawUrl, `${protocol}://${host}`).href;
-}
-function getUrlFromEvent(event) {
-  if (event.request) {
-    return event.request.url;
-  }
-  const req = event.node?.req;
-  if (!req) {
-    throw new Error("Cannot determine URL from Nuxt event");
-  }
-  return buildAbsoluteUrlFromNodeRequest(req);
-}
-function getMethodFromEvent(event) {
-  if (event.request) {
-    return event.request.method;
-  }
-  return event.node?.req?.method ?? "GET";
-}
-async function toWebRequest(event) {
-  if (event.request) {
-    return event.request;
-  }
-  const req = event.node?.req;
-  if (!req) {
-    throw new Error("Cannot convert Nuxt event to Request: no request object found");
-  }
-  const url = getUrlFromEvent(event);
-  const method = req.method ?? "GET";
-  const headers = new Headers;
-  for (const [key, value] of Object.entries(req.headers)) {
-    if (value) {
-      headers.set(key, Array.isArray(value) ? value.join(", ") : value);
-    }
-  }
-  const init = {
-    method,
-    headers
-  };
-  if (["POST", "PUT", "PATCH", "DELETE"].includes(method)) {
-    const body = await bufferNodeBody(req);
-    if (body) {
-      init.body = body;
-    }
-  }
-  return new Request(url, init);
-}
-function isTimebackPath(pathname, basePath) {
-  const normalizedBase = basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
-  return pathname === normalizedBase || pathname.startsWith(`${normalizedBase}/`);
-}
-async function nuxtHandler(options) {
-  const { timeback, event, basePath = "/api/timeback", callbackPath } = options;
-  const path = getPathFromEvent(event);
-  const method = getMethodFromEvent(event);
-  const handle = getHandlers(timeback);
-  if (callbackPath && path === callbackPath && method === "GET") {
-    const request = await toWebRequest(event);
-    return handle.identity.callback(request);
-  }
-  if (!isTimebackPath(path, basePath)) {
-    return;
-  }
-  if (method === "GET") {
-    if (path.endsWith(ROUTES.IDENTITY.SIGNIN)) {
-      const request = await toWebRequest(event);
-      return handle.identity.signIn(request);
-    }
-    if (path.endsWith(ROUTES.IDENTITY.CALLBACK)) {
-      const request = await toWebRequest(event);
-      return handle.identity.callback(request);
-    }
-    if (path.endsWith(ROUTES.IDENTITY.SIGNOUT)) {
-      return handle.identity.signOut();
-    }
-  }
-  if (hasUserHandler(handle)) {
-    if (method === "GET" && path.endsWith(ROUTES.USER.ME)) {
-      const request = await toWebRequest(event);
-      return handle.user.me(request);
-    }
-  }
-  if (hasActivityHandler(handle)) {
-    if (method === "POST" && path.endsWith(ROUTES.ACTIVITY)) {
-      const request = await toWebRequest(event);
-      return handle.activity(request);
-    }
-  }
-  return;
-}
-function toNuxtHandler(input) {
-  const options = isHandlerOptions(input) ? input : { timeback: input };
-  const { timeback, callbackPath } = options;
-  const handle = getHandlers(timeback);
-  const routeHandler = async (event) => {
-    const path = getPathFromEvent(event);
-    const method = getMethodFromEvent(event);
-    if (callbackPath && path === callbackPath && method === "GET") {
-      const request = await toWebRequest(event);
-      return handle.identity.callback(request);
-    }
-    if (method === "GET") {
-      if (path.endsWith(ROUTES.IDENTITY.SIGNIN)) {
-        const request = await toWebRequest(event);
-        return handle.identity.signIn(request);
-      }
-      if (path.endsWith(ROUTES.IDENTITY.CALLBACK)) {
-        const request = await toWebRequest(event);
-        return handle.identity.callback(request);
-      }
-      if (path.endsWith(ROUTES.IDENTITY.SIGNOUT)) {
-        return handle.identity.signOut();
-      }
-    }
-    if (hasUserHandler(handle)) {
-      if (method === "GET" && path.endsWith(ROUTES.USER.ME)) {
-        const request = await toWebRequest(event);
-        return handle.user.me(request);
-      }
-    }
-    if (hasActivityHandler(handle)) {
-      if (method === "POST" && path.endsWith(ROUTES.ACTIVITY)) {
-        const request = await toWebRequest(event);
-        return handle.activity(request);
-      }
-    }
-    return jsonResponse({ error: "Not found" }, 404);
-  };
-  return {
-    GET: routeHandler,
-    POST: routeHandler,
-    PUT: routeHandler,
-    DELETE: routeHandler,
-    PATCH: routeHandler
-  };
-}
-function isHandlerOptions(input) {
-  return typeof input === "object" && input !== null && "timeback" in input;
-}
-export {
-  toNuxtHandler,
-  nuxtHandler
-};