timeback 0.0.0-alpha.2 → 0.1.0

package/dist/server/adapters/express.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Express Adapter
+ *
+ * Adapts Timeback handlers for Express and Express-compatible frameworks
+ * (Polka, Fastify with express compat, Restify, etc.).
+ *
+ * Uses minimal generic interfaces that work with any framework implementing
+ * the Express middleware pattern.
+ */
+import type { ExpressLikeHandler, ExpressLikeRouter, TimebackInput } from './types';
+/**
+ * Convert Timeback instance to Express middleware.
+ *
+ * Accepts either the full Timeback instance or just the handlers:
+ * - `toExpressMiddleware(timeback)`
+ * - `toExpressMiddleware(timeback.handle)`
+ *
+ * @param input - Timeback instance or handlers
+ * @returns Express middleware function
+ *
+ * @example
+ * ```typescript
+ * import express from 'express'
+ * import { timeback } from './lib/timeback'
+ * import { toExpressMiddleware } from 'timeback/express'
+ *
+ * const app = express()
+ *
+ * // Mount Timeback routes
+ * app.use('/api/timeback', toExpressMiddleware(timeback))
+ *
+ * app.listen(3000)
+ * ```
+ */
+export declare function toExpressMiddleware(input: TimebackInput): ExpressLikeHandler;
+/**
+ * Mount Timeback routes on an Express router.
+ *
+ * Accepts either the full Timeback instance or just the handlers:
+ * - `mountExpressRoutes(timeback, router)`
+ * - `mountExpressRoutes(timeback.handle, router)`
+ *
+ * @param input - Timeback instance or handlers
+ * @param router - Express router to mount routes on
+ *
+ * @example
+ * ```typescript
+ * import express from 'express'
+ * import { timeback } from './lib/timeback'
+ * import { mountExpressRoutes } from 'timeback/express'
+ *
+ * const app = express()
+ * const router = express.Router()
+ *
+ * mountExpressRoutes(timeback, router)
+ * app.use('/api/timeback', router)
+ *
+ * app.listen(3000)
+ * ```
+ */
+export declare function mountExpressRoutes(input: TimebackInput, router: ExpressLikeRouter): void;
+//# sourceMappingURL=express.d.ts.map

package/dist/server/adapters/express.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"express.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/express.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,OAAO,KAAK,EACX,kBAAkB,EAIlB,iBAAiB,EACjB,aAAa,EACb,MAAM,SAAS,CAAA;AA6FhB;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,aAAa,GAAG,kBAAkB,CA+C5E;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,iBAAiB,GAAG,IAAI,CAiDxF"}

package/dist/server/adapters/express.js

@@ -0,0 +1,565 @@
+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/express.ts
+function toWebRequest(req) {
+  const protocol = req.protocol || "http";
+  const host = req.get("host") || "localhost";
+  const url = `${protocol}://${host}${req.url}`;
+  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: req.method,
+    headers
+  };
+  if (["POST", "PUT", "PATCH"].includes(req.method) && req.body) {
+    init.body = JSON.stringify(req.body);
+  }
+  return new Request(url, init);
+}
+async function sendWebResponse(webRes, res) {
+  res.status(webRes.status);
+  const headers = {};
+  webRes.headers.forEach((value, key) => {
+    headers[key] = value;
+  });
+  res.set(headers);
+  if (webRes.status >= 300 && webRes.status < 400) {
+    const location = webRes.headers.get("Location");
+    if (location) {
+      res.redirect(location);
+      return;
+    }
+  }
+  const text = await webRes.text();
+  res.send(text);
+}
+function toExpressMiddleware(input) {
+  const handle = getHandlers(input);
+  return (req, res, next) => {
+    const webReq = toWebRequest(req);
+    const path = new URL(webReq.url).pathname;
+    const handleRequest = () => {
+      if (req.method === "GET") {
+        if (path.endsWith(ROUTES.IDENTITY.SIGNIN)) {
+          return handle.identity.signIn(webReq);
+        }
+        if (path.endsWith(ROUTES.IDENTITY.CALLBACK)) {
+          return handle.identity.callback(webReq);
+        }
+        if (path.endsWith(ROUTES.IDENTITY.SIGNOUT)) {
+          return Promise.resolve(handle.identity.signOut());
+        }
+      }
+      if (req.method === "POST") {
+        if (path.endsWith(ROUTES.ACTIVITY)) {
+          return handle.activity(webReq);
+        }
+      }
+      return Promise.resolve(undefined);
+    };
+    handleRequest().then((webRes) => {
+      if (webRes) {
+        return sendWebResponse(webRes, res);
+      }
+      next();
+    }).catch(() => {
+      const errorRes = jsonResponse({ error: "Internal server error" }, 500);
+      return sendWebResponse(errorRes, res);
+    });
+  };
+}
+function mountExpressRoutes(input, router) {
+  const handle = getHandlers(input);
+  function createHandler(handler) {
+    return (req, res) => {
+      const webReq = toWebRequest(req);
+      Promise.resolve(handler(webReq)).then((webRes) => sendWebResponse(webRes, res)).catch(() => {
+        const errorRes = jsonResponse({ error: "Internal server error" }, 500);
+        return sendWebResponse(errorRes, res);
+      });
+    };
+  }
+  router.get(ROUTES.IDENTITY.SIGNIN, createHandler((req) => handle.identity.signIn(req)));
+  router.get(ROUTES.IDENTITY.CALLBACK, createHandler((req) => handle.identity.callback(req)));
+  router.get(ROUTES.IDENTITY.SIGNOUT, createHandler(() => handle.identity.signOut()));
+  router.post(ROUTES.ACTIVITY, createHandler((req) => handle.activity(req)));
+}
+export {
+  toExpressMiddleware,
+  mountExpressRoutes
+};

package/dist/server/adapters/native.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Native Fetch API Handler
+ *
+ * Universal handler for any runtime that supports the Web Fetch API:
+ * Bun, Deno, Cloudflare Workers, Hono, etc.
+ */
+import type { NativeHandlerOptions, TimebackInput } from './types';
+/**
+ * Create a native Fetch API handler.
+ *
+ * Returns a universal `(Request) => Promise<Response>` handler that works
+ * with any Fetch API native runtime.
+ *
+ * Accepts either the full Timeback instance or just the handlers:
+ * - `toNativeHandler(timeback)`
+ * - `toNativeHandler(timeback.handle)`
+ *
+ * @param input - Timeback instance or handlers
+ * @returns Universal request handler
+ *
+ * @example
+ * ```typescript
+ * import { createServer } from 'timeback'
+ * import { toNativeHandler } from 'timeback/native'
+ *
+ * const timeback = await createServer({ ... })
+ *
+ * // Simple usage
+ * const handler = toNativeHandler(timeback)
+ *
+ * // With custom callback path
+ * const handler = toNativeHandler({
+ *   timeback,
+ *   callbackPath: '/api/auth/sso/callback/timeback',
+ * })
+ *
+ * // Bun
+ * Bun.serve({ fetch: handler })
+ *
+ * // Deno
+ * Deno.serve(handler)
+ * ```
+ */
+export declare function toNativeHandler(input: TimebackInput | NativeHandlerOptions): (req: Request) => Promise<Response>;
+//# sourceMappingURL=native.d.ts.map

package/dist/server/adapters/native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/native.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAYlE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,eAAe,CAC9B,KAAK,EAAE,aAAa,GAAG,oBAAoB,GACzC,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAyCrC"}