timeback 0.1.0 → 0.1.1

package/dist/server/adapters/nuxt.js

@@ -0,0 +1,663 @@
+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;
+}
+
+// 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 (path.endsWith(ROUTES.USER.ME)) {
+      const request = await toWebRequest(event);
+      return handle.user.me(request);
+    }
+  }
+  if (method === "POST") {
+    if (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 (path.endsWith(ROUTES.USER.ME)) {
+        const request = await toWebRequest(event);
+        return handle.user.me(request);
+      }
+    }
+    if (method === "POST") {
+      if (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
+};

package/dist/server/adapters/tanstack-start.d.ts

@@ -0,0 +1,40 @@
+/**
+ * TanStack Start Adapter
+ *
+ * Adapts Timeback handlers for TanStack Start.
+ * Uses file-based API routes with TanStack's createFileRoute.
+ */
+import type { TanStackStartHandlerOptions, TanStackStartHandlers, TimebackInput } from './types';
+/**
+ * Convert Timeback instance to TanStack Start route handlers.
+ *
+ * TanStack Start uses file-based routing with API routes exporting HTTP method handlers.
+ * This function creates handlers compatible with TanStack Start's route system.
+ *
+ * Accepts either the full Timeback instance or just the handlers:
+ * - `toTanStackStartHandler(timeback)`
+ * - `toTanStackStartHandler(timeback.handle)`
+ *
+ * @param input - Timeback instance or handlers, or options object
+ * @returns Object with HTTP method handlers for TanStack Start
+ *
+ * @example
+ * ```typescript
+ * // src/routes/api/timeback/$.ts
+ * import { createFileRoute } from '@tanstack/react-router'
+ * import { timeback } from '~/lib/timeback'
+ * import { toTanStackStartHandler } from 'timeback/tanstack-start'
+ *
+ * const handlers = toTanStackStartHandler(timeback)
+ *
+ * export const Route = createFileRoute('/api/timeback/$')({
+ *   server: { handlers }
+ * })
+ * ```
+ */
+export declare function toTanStackStartHandler(input: TimebackInput | TanStackStartHandlerOptions): TanStackStartHandlers;
+/**
+ * Alias for toTanStackStartHandler for consistency with other adapters.
+ */
+export declare const tanstackStartHandler: typeof toTanStackStartHandler;
+//# sourceMappingURL=tanstack-start.d.ts.map

package/dist/server/adapters/tanstack-start.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tanstack-start.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/tanstack-start.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EAEX,2BAA2B,EAC3B,qBAAqB,EACrB,aAAa,EACb,MAAM,SAAS,CAAA;AAMhB;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,sBAAsB,CACrC,KAAK,EAAE,aAAa,GAAG,2BAA2B,GAChD,qBAAqB,CAgDvB;AAcD;;GAEG;AACH,eAAO,MAAM,oBAAoB,+BAAyB,CAAA"}