@timeback/sdk 0.1.4

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

@@ -0,0 +1,47 @@
+/**
+ * Native Fetch API Handler
+ *
+ * Universal handler for any runtime that supports the Web Fetch API:
+ * Bun, Deno, Cloudflare Workers, Hono, etc.
+ */
+import type { AnyTimebackInput, NativeHandlerOptions } 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)`
+ *
+ * Also accepts identity-only instances from `createTimebackIdentity()`.
+ *
+ * @param input - Timeback instance or handlers (full or identity-only)
+ * @returns Universal request handler
+ *
+ * @example
+ * ```typescript
+ * import { createTimeback } from '@timeback/sdk'
+ * import { toNativeHandler } from '@timeback/sdk/native'
+ *
+ * const timeback = await createTimeback({ ... })
+ *
+ * // 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: AnyTimebackInput | 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;AAKH,OAAO,KAAK,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAYrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,eAAe,CAC9B,KAAK,EAAE,gBAAgB,GAAG,oBAAoB,GAC5C,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAwCrC"}

package/dist/server/adapters/native.js

@@ -0,0 +1,190 @@
+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/server/lib/utils.ts
+function mapEnvForApi(env) {
+  if (env === "local" || env === "staging") {
+    return "staging";
+  }
+  return "production";
+}
+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/shared/constants.ts
+var ROUTES = {
+  ACTIVITY: "/activity",
+  IDENTITY: {
+    SIGNIN: "/identity/signin",
+    SIGNOUT: "/identity/signout",
+    CALLBACK: "/identity/callback"
+  },
+  USER: {
+    ME: "/user/me"
+  }
+};
+
+// src/server/adapters/utils.ts
+function normalizePathname(path) {
+  const raw = path.trim();
+  if (raw === "") {
+    return "/";
+  }
+  const queryIndex = raw.indexOf("?");
+  if (queryIndex === -1) {
+    return raw;
+  }
+  const pathname = raw.slice(0, queryIndex);
+  if (pathname === "") {
+    return "/";
+  }
+  return pathname;
+}
+function normalizeBasePath(basePath) {
+  let raw = normalizePathname(basePath);
+  if (raw !== "" && !raw.startsWith("/")) {
+    raw = `/${raw}`;
+  }
+  if (raw === "/" || raw === "") {
+    return "";
+  }
+  if (raw.endsWith("/")) {
+    return raw.slice(0, -1);
+  }
+  return raw;
+}
+function matchTimebackRoute(params) {
+  const method = params.method.toUpperCase();
+  const pathname = normalizePathname(params.pathname);
+  const callbackPath = params.callbackPath ? normalizePathname(params.callbackPath) : undefined;
+  if (callbackPath && pathname === callbackPath) {
+    return method === "GET" ? "identity.callback" : null;
+  }
+  const basePathInput = params.basePath;
+  const hasBasePath = basePathInput !== undefined;
+  const basePath = hasBasePath ? normalizeBasePath(basePathInput) : undefined;
+  const matchesRelative = (relative) => {
+    if (method === "GET") {
+      if (relative === ROUTES.IDENTITY.SIGNIN)
+        return "identity.signIn";
+      if (relative === ROUTES.IDENTITY.CALLBACK)
+        return "identity.callback";
+      if (relative === ROUTES.IDENTITY.SIGNOUT)
+        return "identity.signOut";
+      if (relative === ROUTES.USER.ME)
+        return "user.me";
+    }
+    if (method === "POST") {
+      if (relative === ROUTES.ACTIVITY)
+        return "activity";
+    }
+    return null;
+  };
+  if (hasBasePath && basePath !== undefined) {
+    if (basePath !== "" && pathname === basePath)
+      return null;
+    if (basePath !== "" && !pathname.startsWith(`${basePath}/`))
+      return null;
+    const relativeRaw = basePath === "" ? pathname : pathname.slice(basePath.length);
+    const relative = relativeRaw.startsWith("/") ? relativeRaw : `/${relativeRaw}`;
+    return matchesRelative(relative);
+  }
+  if (method === "GET") {
+    if (pathname.endsWith(ROUTES.IDENTITY.SIGNIN))
+      return "identity.signIn";
+    if (pathname.endsWith(ROUTES.IDENTITY.CALLBACK))
+      return "identity.callback";
+    if (pathname.endsWith(ROUTES.IDENTITY.SIGNOUT))
+      return "identity.signOut";
+    if (pathname.endsWith(ROUTES.USER.ME))
+      return "user.me";
+  }
+  if (method === "POST") {
+    if (pathname.endsWith(ROUTES.ACTIVITY))
+      return "activity";
+  }
+  return null;
+}
+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/native.ts
+function isNativeHandlerOptions(v) {
+  return typeof v === "object" && v !== null && "timeback" in v;
+}
+function toNativeHandler(input) {
+  const { timeback, callbackPath } = isNativeHandlerOptions(input) ? input : { timeback: input, callbackPath: undefined };
+  const handle = getHandlers(timeback);
+  return (req) => {
+    const url = new URL(req.url);
+    const path = url.pathname;
+    const method = req.method;
+    const route = matchTimebackRoute({
+      pathname: path,
+      method,
+      callbackPath
+    });
+    if (route === "identity.signIn")
+      return handle.identity.signIn(req);
+    if (route === "identity.callback")
+      return handle.identity.callback(req);
+    if (route === "identity.signOut")
+      return Promise.resolve(handle.identity.signOut());
+    if (route === "user.me") {
+      if (!hasUserHandler(handle)) {
+        return Promise.resolve(jsonResponse({ error: "Not found" }, 404));
+      }
+      return handle.user.me(req);
+    }
+    if (route === "activity") {
+      if (!hasActivityHandler(handle)) {
+        return Promise.resolve(jsonResponse({ error: "Not found" }, 404));
+      }
+      return handle.activity(req);
+    }
+    return Promise.resolve(jsonResponse({ error: "Not found" }, 404));
+  };
+}
+export {
+  toNativeHandler
+};

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

@@ -0,0 +1,32 @@
+/**
+ * Next.js Adapter
+ *
+ * Adapts Timeback handlers for Next.js App Router.
+ */
+import type { AnyTimebackInput, NextjsHandlers } from './types';
+/**
+ * Convert Timeback instance to Next.js App Router handlers.
+ *
+ * Wraps the native handler with the `{ GET, POST, ... }` structure
+ * required by Next.js App Router.
+ *
+ * Accepts either the full Timeback instance or just the handlers:
+ * - `toNextjsHandler(timeback)`
+ * - `toNextjsHandler(timeback.handle)`
+ *
+ * Also accepts identity-only instances from `createTimebackIdentity()`.
+ *
+ * @param input - Timeback instance or handlers (full or identity-only)
+ * @returns Object with HTTP method handlers for Next.js App Router
+ *
+ * @example
+ * ```typescript
+ * // app/api/timeback/[...timeback]/route.ts
+ * import { timeback } from '@/lib/timeback'
+ * import { toNextjsHandler } from '@timeback/sdk/nextjs'
+ *
+ * export const { GET, POST } = toNextjsHandler(timeback)
+ * ```
+ */
+export declare function toNextjsHandler(input: AnyTimebackInput): NextjsHandlers;
+//# sourceMappingURL=nextjs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nextjs.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/nextjs.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAE/D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,gBAAgB,GAAG,cAAc,CAUvE"}

package/dist/server/adapters/nextjs.js

@@ -0,0 +1,202 @@
+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/server/lib/utils.ts
+function mapEnvForApi(env) {
+  if (env === "local" || env === "staging") {
+    return "staging";
+  }
+  return "production";
+}
+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/shared/constants.ts
+var ROUTES = {
+  ACTIVITY: "/activity",
+  IDENTITY: {
+    SIGNIN: "/identity/signin",
+    SIGNOUT: "/identity/signout",
+    CALLBACK: "/identity/callback"
+  },
+  USER: {
+    ME: "/user/me"
+  }
+};
+
+// src/server/adapters/utils.ts
+function normalizePathname(path) {
+  const raw = path.trim();
+  if (raw === "") {
+    return "/";
+  }
+  const queryIndex = raw.indexOf("?");
+  if (queryIndex === -1) {
+    return raw;
+  }
+  const pathname = raw.slice(0, queryIndex);
+  if (pathname === "") {
+    return "/";
+  }
+  return pathname;
+}
+function normalizeBasePath(basePath) {
+  let raw = normalizePathname(basePath);
+  if (raw !== "" && !raw.startsWith("/")) {
+    raw = `/${raw}`;
+  }
+  if (raw === "/" || raw === "") {
+    return "";
+  }
+  if (raw.endsWith("/")) {
+    return raw.slice(0, -1);
+  }
+  return raw;
+}
+function matchTimebackRoute(params) {
+  const method = params.method.toUpperCase();
+  const pathname = normalizePathname(params.pathname);
+  const callbackPath = params.callbackPath ? normalizePathname(params.callbackPath) : undefined;
+  if (callbackPath && pathname === callbackPath) {
+    return method === "GET" ? "identity.callback" : null;
+  }
+  const basePathInput = params.basePath;
+  const hasBasePath = basePathInput !== undefined;
+  const basePath = hasBasePath ? normalizeBasePath(basePathInput) : undefined;
+  const matchesRelative = (relative) => {
+    if (method === "GET") {
+      if (relative === ROUTES.IDENTITY.SIGNIN)
+        return "identity.signIn";
+      if (relative === ROUTES.IDENTITY.CALLBACK)
+        return "identity.callback";
+      if (relative === ROUTES.IDENTITY.SIGNOUT)
+        return "identity.signOut";
+      if (relative === ROUTES.USER.ME)
+        return "user.me";
+    }
+    if (method === "POST") {
+      if (relative === ROUTES.ACTIVITY)
+        return "activity";
+    }
+    return null;
+  };
+  if (hasBasePath && basePath !== undefined) {
+    if (basePath !== "" && pathname === basePath)
+      return null;
+    if (basePath !== "" && !pathname.startsWith(`${basePath}/`))
+      return null;
+    const relativeRaw = basePath === "" ? pathname : pathname.slice(basePath.length);
+    const relative = relativeRaw.startsWith("/") ? relativeRaw : `/${relativeRaw}`;
+    return matchesRelative(relative);
+  }
+  if (method === "GET") {
+    if (pathname.endsWith(ROUTES.IDENTITY.SIGNIN))
+      return "identity.signIn";
+    if (pathname.endsWith(ROUTES.IDENTITY.CALLBACK))
+      return "identity.callback";
+    if (pathname.endsWith(ROUTES.IDENTITY.SIGNOUT))
+      return "identity.signOut";
+    if (pathname.endsWith(ROUTES.USER.ME))
+      return "user.me";
+  }
+  if (method === "POST") {
+    if (pathname.endsWith(ROUTES.ACTIVITY))
+      return "activity";
+  }
+  return null;
+}
+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/native.ts
+function isNativeHandlerOptions(v) {
+  return typeof v === "object" && v !== null && "timeback" in v;
+}
+function toNativeHandler(input) {
+  const { timeback, callbackPath } = isNativeHandlerOptions(input) ? input : { timeback: input, callbackPath: undefined };
+  const handle = getHandlers(timeback);
+  return (req) => {
+    const url = new URL(req.url);
+    const path = url.pathname;
+    const method = req.method;
+    const route = matchTimebackRoute({
+      pathname: path,
+      method,
+      callbackPath
+    });
+    if (route === "identity.signIn")
+      return handle.identity.signIn(req);
+    if (route === "identity.callback")
+      return handle.identity.callback(req);
+    if (route === "identity.signOut")
+      return Promise.resolve(handle.identity.signOut());
+    if (route === "user.me") {
+      if (!hasUserHandler(handle)) {
+        return Promise.resolve(jsonResponse({ error: "Not found" }, 404));
+      }
+      return handle.user.me(req);
+    }
+    if (route === "activity") {
+      if (!hasActivityHandler(handle)) {
+        return Promise.resolve(jsonResponse({ error: "Not found" }, 404));
+      }
+      return handle.activity(req);
+    }
+    return Promise.resolve(jsonResponse({ error: "Not found" }, 404));
+  };
+}
+
+// src/server/adapters/nextjs.ts
+function toNextjsHandler(input) {
+  const handler = toNativeHandler(input);
+  return {
+    GET: handler,
+    POST: handler,
+    PUT: handler,
+    DELETE: handler,
+    PATCH: handler
+  };
+}
+export {
+  toNextjsHandler
+};

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

@@ -0,0 +1,98 @@
+/**
+ * Nuxt Adapter
+ *
+ * Adapts Timeback handlers for Nuxt 3.
+ * Supports both middleware-based (recommended) and route-based approaches.
+ *
+ * This adapter does NOT import h3 or nuxt - it uses minimal interfaces
+ * that are compatible with H3's event structure.
+ */
+import type { AnyTimebackInput, NuxtHandlerOptions, NuxtHandlers, NuxtLikeEvent } from './types';
+/**
+ * Nuxt server middleware handler for Timeback.
+ *
+ * This is the **recommended** approach for Nuxt 3 integration.
+ * It intercepts requests at the middleware level before they reach route handlers.
+ *
+ * Returns a Response if the request matches a Timeback route, or undefined
+ * to let the request continue to other handlers.
+ *
+ * @param options - Handler options
+ * @returns Response from Timeback or undefined to continue
+ *
+ * @example
+ * ```typescript
+ * // server/middleware/timeback.ts
+ * import { timeback } from '~/lib/timeback'
+ * import { nuxtHandler } from '@timeback/sdk/nuxt'
+ *
+ * export default defineEventHandler(async (event) => {
+ *   const response = await nuxtHandler({
+ *     timeback,
+ *     event,
+ *   })
+ *
+ *   if (response) {
+ *     return response
+ *   }
+ * })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // server/middleware/timeback.ts - with custom callback path
+ * import { timeback } from '~/lib/timeback'
+ * import { nuxtHandler } from '@timeback/sdk/nuxt'
+ *
+ * export default defineEventHandler(async (event) => {
+ *   const response = await nuxtHandler({
+ *     timeback,
+ *     event,
+ *     callbackPath: '/api/auth/sso/callback/timeback',
+ *   })
+ *
+ *   if (response) {
+ *     return response
+ *   }
+ * })
+ * ```
+ */
+export declare function nuxtHandler<TEvent extends NuxtLikeEvent>(options: NuxtHandlerOptions<TEvent>): Promise<Response | undefined>;
+/**
+ * Convert Timeback instance to Nuxt route handlers.
+ *
+ * This is an **alternative** approach using Nuxt's catch-all route handlers.
+ * Use this if you prefer explicit route files over middleware.
+ *
+ * Accepts either the full Timeback instance or just the handlers:
+ * - `toNuxtHandler(timeback)`
+ * - `toNuxtHandler(timeback.handle)`
+ *
+ * Also accepts identity-only instances from `createTimebackIdentity()`.
+ *
+ * @param input - Timeback instance or handlers (full or identity-only), or options object
+ * @returns Object with HTTP method handlers for Nuxt
+ *
+ * @example
+ * ```typescript
+ * // server/api/timeback/[...timeback].ts
+ * import { timeback } from '~/lib/timeback'
+ * import { toNuxtHandler } from '@timeback/sdk/nuxt'
+ *
+ * const handlers = toNuxtHandler(timeback)
+ *
+ * export default defineEventHandler(async (event) => {
+ *   const method = event.request?.method ?? event.node?.req?.method ?? 'GET'
+ *   const handler = handlers[method as keyof typeof handlers]
+ *   if (handler) {
+ *     return handler(event)
+ *   }
+ *   return new Response('Method not allowed', { status: 405 })
+ * })
+ * ```
+ */
+export declare function toNuxtHandler(input: AnyTimebackInput | {
+    timeback: AnyTimebackInput;
+    callbackPath?: string;
+}): NuxtHandlers;
+//# sourceMappingURL=nuxt.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nuxt.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/nuxt.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAWH,OAAO,KAAK,EACX,gBAAgB,EAEhB,kBAAkB,EAClB,YAAY,EACZ,aAAa,EACb,MAAM,SAAS,CAAA;AAuMhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAsB,WAAW,CAAC,MAAM,SAAS,aAAa,EAC7D,OAAO,EAAE,kBAAkB,CAAC,MAAM,CAAC,GACjC,OAAO,CAAC,QAAQ,GAAG,SAAS,CAAC,CA6B/B;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,aAAa,CAC5B,KAAK,EAAE,gBAAgB,GAAG;IAAE,QAAQ,EAAE,gBAAgB,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,GAC7E,YAAY,CAwCd"}