@timeback/sdk 0.1.4

package/dist/server/adapters/svelte-kit.d.ts

@@ -0,0 +1,84 @@
+/**
+ * SvelteKit Adapter
+ *
+ * Adapts Timeback handlers for SvelteKit.
+ * Supports both hooks-based (recommended) and route-based approaches.
+ */
+import type { AnyTimebackInput, SvelteKitHandlerOptions, SvelteKitHandlers, SvelteKitRequestEvent } from './types';
+/**
+ * SvelteKit server hook handler for Timeback.
+ *
+ * This is the **recommended** approach for SvelteKit integration.
+ * It intercepts requests at the hooks level, providing deeper integration
+ * with SvelteKit's request lifecycle.
+ *
+ * @param options - Handler options
+ * @returns Response from either Timeback or the resolve chain
+ *
+ * @example
+ * ```typescript
+ * // hooks.server.ts
+ * import { timeback } from '$lib/timeback'
+ * import { svelteKitHandler } from '@timeback/sdk/svelte-kit'
+ * import { building } from '$app/environment'
+ *
+ * export async function handle({ event, resolve }) {
+ *   return svelteKitHandler({
+ *     timeback,
+ *     event,
+ *     resolve,
+ *     building,
+ *   })
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // hooks.server.ts - with session in event.locals
+ * import { timeback } from '$lib/timeback'
+ * import { svelteKitHandler } from '@timeback/sdk/svelte-kit'
+ * import { building } from '$app/environment'
+ *
+ * export async function handle({ event, resolve }) {
+ *   // Optionally populate event.locals with user session
+ *   // const session = await getSessionFromCookie(event.cookies)
+ *   // if (session) {
+ *   //   event.locals.user = session.user
+ *   // }
+ *
+ *   return svelteKitHandler({
+ *     timeback,
+ *     event,
+ *     resolve,
+ *     building,
+ *   })
+ * }
+ * ```
+ */
+export declare function svelteKitHandler<TEvent extends SvelteKitRequestEvent>(options: SvelteKitHandlerOptions<TEvent>): Promise<Response>;
+/**
+ * Convert Timeback instance to SvelteKit route handlers.
+ *
+ * This is an **alternative** approach using SvelteKit's route handlers.
+ * Use this if you prefer explicit route files over hooks.
+ *
+ * Accepts either the full Timeback instance or just the handlers:
+ * - `toSvelteKitHandler(timeback)`
+ * - `toSvelteKitHandler(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 SvelteKit
+ *
+ * @example
+ * ```typescript
+ * // src/routes/api/timeback/[...path]/+server.ts
+ * import { timeback } from '$lib/timeback'
+ * import { toSvelteKitHandler } from '@timeback/sdk/svelte-kit'
+ *
+ * export const { GET, POST } = toSvelteKitHandler(timeback)
+ * ```
+ */
+export declare function toSvelteKitHandler(input: AnyTimebackInput): SvelteKitHandlers;
+//# sourceMappingURL=svelte-kit.d.ts.map

package/dist/server/adapters/svelte-kit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"svelte-kit.d.ts","sourceRoot":"","sources":["../../../src/server/adapters/svelte-kit.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,EACX,gBAAgB,EAChB,uBAAuB,EACvB,iBAAiB,EACjB,qBAAqB,EAErB,MAAM,SAAS,CAAA;AAMhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,SAAS,qBAAqB,EAC1E,OAAO,EAAE,uBAAuB,CAAC,MAAM,CAAC,GACtC,OAAO,CAAC,QAAQ,CAAC,CAqDnB;AAMD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,gBAAgB,GAAG,iBAAiB,CAgB7E"}

package/dist/server/adapters/svelte-kit.js

@@ -0,0 +1,243 @@
+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/svelte-kit.ts
+async function svelteKitHandler(options) {
+  const {
+    timeback,
+    event,
+    resolve,
+    building = false,
+    basePath = "/api/timeback",
+    callbackPath
+  } = options;
+  if (building) {
+    return resolve(event);
+  }
+  const { url, request } = event;
+  const handle = getHandlers(timeback);
+  const path = url.pathname;
+  const method = request.method;
+  const route = matchTimebackRoute({ pathname: path, method, basePath, callbackPath });
+  if (!route)
+    return resolve(event);
+  if (route === "identity.signOut")
+    return handle.identity.signOut();
+  if (route === "identity.signIn")
+    return await handle.identity.signIn(request);
+  if (route === "identity.callback")
+    return await handle.identity.callback(request);
+  if (route === "user.me") {
+    if (!hasUserHandler(handle))
+      return resolve(event);
+    return await handle.user.me(request);
+  }
+  if (route === "activity") {
+    if (!hasActivityHandler(handle))
+      return resolve(event);
+    return await handle.activity(request);
+  }
+  return resolve(event);
+}
+function toSvelteKitHandler(input) {
+  const handler = toNativeHandler(input);
+  const wrapHandler = (nativeHandler) => {
+    return (event) => nativeHandler(event.request);
+  };
+  return {
+    GET: wrapHandler(handler),
+    POST: wrapHandler(handler),
+    PUT: wrapHandler(handler),
+    DELETE: wrapHandler(handler),
+    PATCH: wrapHandler(handler)
+  };
+}
+export {
+  toSvelteKitHandler,
+  svelteKitHandler
+};

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

@@ -0,0 +1,42 @@
+/**
+ * TanStack Start Adapter
+ *
+ * Adapts Timeback handlers for TanStack Start.
+ * Uses file-based API routes with TanStack's createFileRoute.
+ */
+import type { AnyTimebackInput, TanStackStartHandlerOptions, TanStackStartHandlers } 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)`
+ *
+ * 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 TanStack Start
+ *
+ * @example
+ * ```typescript
+ * // src/routes/api/timeback/$.ts
+ * import { createFileRoute } from '@tanstack/react-router'
+ * import { timeback } from '~/lib/timeback'
+ * import { toTanStackStartHandler } from '@timeback/sdk/tanstack-start'
+ *
+ * const handlers = toTanStackStartHandler(timeback)
+ *
+ * export const Route = createFileRoute('/api/timeback/$')({
+ *   server: { handlers }
+ * })
+ * ```
+ */
+export declare function toTanStackStartHandler(input: AnyTimebackInput | 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;AAKH,OAAO,KAAK,EACX,gBAAgB,EAEhB,2BAA2B,EAC3B,qBAAqB,EACrB,MAAM,SAAS,CAAA;AAMhB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,sBAAsB,CACrC,KAAK,EAAE,gBAAgB,GAAG,2BAA2B,GACnD,qBAAqB,CAsCvB;AAcD;;GAEG;AACH,eAAO,MAAM,oBAAoB,+BAAyB,CAAA"}