@meistrari/data-token 0.0.12 → 0.0.14

package/dist/adapters/elysia.d.mts

@@ -0,0 +1,45 @@
+import Elysia, { Context } from 'elysia';
+
+/**
+ * Obtain an instance of the data token plugin for Elysia
+ * @param url - The URL of the JWKS endpoint
+ * @param skipOnError - Whether to skip the error and return null if the token is invalid
+ * @param getToken - A function to get the token from the context
+ * @returns An Elysia plugin
+ *
+ * @example
+ * ```ts
+ * import { createDataTokenPlugin } from 'elysia-jwt'
+ *
+ * const app = new Elysia()
+ * const dataToken = createDataTokenPlugin((c) => c.env.JWKS_URL)
+ *
+ * app.use(dataToken)
+ *    .get('/', ({ authData }) => ({ authData }))
+ * ```
+ */
+declare function createDataTokenPlugin(url: string, skipOnError?: boolean, getToken?: (c: Context) => string): Elysia<"", false, {
+    decorator: {};
+    store: {};
+    derive: {
+        readonly authData?: any;
+    };
+    resolve: {};
+}, {
+    type: {};
+    error: {};
+}, {
+    schema: {};
+    macro: {};
+    macroFn: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+}>;
+
+export { createDataTokenPlugin };

package/dist/adapters/elysia.d.ts

@@ -1,5 +1,5 @@
-import type { Context } from 'elysia';
-import Elysia from 'elysia';
+import Elysia, { Context } from 'elysia';
+
 /**
  * Obtain an instance of the data token plugin for Elysia
  * @param url - The URL of the JWKS endpoint
@@ -12,28 +12,17 @@ import Elysia from 'elysia';
  * import { createDataTokenPlugin } from 'elysia-jwt'
  *
  * const app = new Elysia()
- * const dataToken = createDataTokenPlugin('https://some.api.com/well-known/jwks.json')
+ * const dataToken = createDataTokenPlugin((c) => c.env.JWKS_URL)
  *
  * app.use(dataToken)
  *    .get('/', ({ authData }) => ({ authData }))
  * ```
  */
-export declare function createDataTokenPlugin(url: string, skipOnError?: boolean, getToken?: (c: Context) => string): Elysia<"", false, {
+declare function createDataTokenPlugin(url: string, skipOnError?: boolean, getToken?: (c: Context) => string): Elysia<"", false, {
     decorator: {};
     store: {};
     derive: {
-        readonly authData: {
-            requestId: string;
-            workspace: {
-                id: string;
-                title: string;
-            };
-            user?: {
-                id: string;
-                email: string;
-                uuid: string | null;
-            } | undefined;
-        } | null;
+        readonly authData?: any;
     };
     resolve: {};
 }, {
@@ -52,3 +41,5 @@ export declare function createDataTokenPlugin(url: string, skipOnError?: boolean
     resolve: {};
     schema: {};
 }>;
+
+export { createDataTokenPlugin };

package/dist/adapters/elysia.mjs

@@ -0,0 +1,21 @@
+import Elysia from 'elysia';
+import { getValidator } from '../index.mjs';
+import 'jose';
+import 'zod';
+
+function createDataTokenPlugin(url, skipOnError = false, getToken = (c) => c.headers["x-data-token"] ?? "") {
+  const validator = getValidator(url);
+  const plugin = new Elysia({ name: "data-token" }).derive({ as: "global" }, async (c) => {
+    const token = getToken(c);
+    const data = await validator(token).catch(() => {
+      if (skipOnError) {
+        return null;
+      }
+      throw new Error("Invalid data token");
+    });
+    return { authData: data };
+  });
+  return plugin;
+}
+
+export { createDataTokenPlugin };

package/dist/adapters/hono.d.mts

@@ -0,0 +1,80 @@
+import * as hono from 'hono';
+import { Context } from 'hono';
+import { z } from 'zod';
+
+declare const DataToken: z.ZodObject<{
+    requestId: z.ZodString;
+    workspace: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        title?: string;
+    }, {
+        id?: string;
+        title?: string;
+    }>;
+    user: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        email: z.ZodString;
+        uuid: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        email?: string;
+        uuid?: string;
+    }, {
+        id?: string;
+        email?: string;
+        uuid?: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    requestId?: string;
+    workspace?: {
+        id?: string;
+        title?: string;
+    };
+    user?: {
+        id?: string;
+        email?: string;
+        uuid?: string;
+    };
+}, {
+    requestId?: string;
+    workspace?: {
+        id?: string;
+        title?: string;
+    };
+    user?: {
+        id?: string;
+        email?: string;
+        uuid?: string;
+    };
+}>;
+type DataToken = z.infer<typeof DataToken>;
+
+type DataTokenContext = {
+    Variables: {
+        authData?: DataToken;
+    };
+};
+/**
+ * Create a data token middleware for Hono
+ * @param url - The URL of the JWKS endpoint
+ * @param skipOnError - Whether to skip the error and return null if the token is invalid
+ * @param getToken - A function to get the token from the context
+ * @returns A Hono middleware
+ *
+ * @example
+ * ```ts
+ * import { createDataTokenMiddleware } from 'hono-jwt'
+ *
+ * const app = new Hono<DataTokenContext>()
+ * const dataToken = createDataTokenMiddleware('https://some.api.com/well-known/jwks.json')
+ *
+ * app.use(dataToken)
+ * app.get('/', c => c.json({ data: c.get('authData') }))
+ * ```
+ */
+declare function createDataTokenMiddleware<Env extends DataTokenContext>(url: string | ((c: Context<Env>) => string), skipOnError?: boolean, getToken?: (c: Context<Env>) => string): hono.MiddlewareHandler<Env, string, {}>;
+
+export { type DataTokenContext, createDataTokenMiddleware };

package/dist/adapters/hono.d.ts

@@ -1,6 +1,58 @@
-import type { Context } from 'hono';
-import type { DataToken } from '../types';
-export type DataTokenContext = {
+import * as hono from 'hono';
+import { Context } from 'hono';
+import { z } from 'zod';
+
+declare const DataToken: z.ZodObject<{
+    requestId: z.ZodString;
+    workspace: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        title?: string;
+    }, {
+        id?: string;
+        title?: string;
+    }>;
+    user: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        email: z.ZodString;
+        uuid: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string;
+        email?: string;
+        uuid?: string;
+    }, {
+        id?: string;
+        email?: string;
+        uuid?: string;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    requestId?: string;
+    workspace?: {
+        id?: string;
+        title?: string;
+    };
+    user?: {
+        id?: string;
+        email?: string;
+        uuid?: string;
+    };
+}, {
+    requestId?: string;
+    workspace?: {
+        id?: string;
+        title?: string;
+    };
+    user?: {
+        id?: string;
+        email?: string;
+        uuid?: string;
+    };
+}>;
+type DataToken = z.infer<typeof DataToken>;
+
+type DataTokenContext = {
     Variables: {
         authData?: DataToken;
     };
@@ -23,4 +75,6 @@ export type DataTokenContext = {
  * app.get('/', c => c.json({ data: c.get('authData') }))
  * ```
  */
-export declare function createDataTokenMiddleware<Env extends DataTokenContext>(url: string | ((c: Context<Env>) => string), skipOnError?: boolean, getToken?: (c: Context<Env>) => string): import("hono").MiddlewareHandler<Env, string, {}>;
+declare function createDataTokenMiddleware<Env extends DataTokenContext>(url: string | ((c: Context<Env>) => string), skipOnError?: boolean, getToken?: (c: Context<Env>) => string): hono.MiddlewareHandler<Env, string, {}>;
+
+export { type DataTokenContext, createDataTokenMiddleware };

package/dist/adapters/hono.mjs

@@ -0,0 +1,24 @@
+import { createMiddleware } from 'hono/factory';
+import { getValidator } from '../index.mjs';
+import 'jose';
+import 'zod';
+
+function createDataTokenMiddleware(url, skipOnError = false, getToken = (c) => c.req.header("x-data-token") ?? "") {
+  return createMiddleware(async (c, next) => {
+    const jwksUrl = typeof url === "function" ? url(c) : url;
+    const validator = getValidator(jwksUrl);
+    const token = getToken(c);
+    try {
+      const data = await validator(token);
+      c.set("authData", data);
+    } catch (error) {
+      if (skipOnError) {
+        return next();
+      }
+      throw error;
+    }
+    await next();
+  });
+}
+
+export { createDataTokenMiddleware };

package/dist/index.d.mts

@@ -0,0 +1,24 @@
+/**
+ * Get a validator function that can validate a data token.
+ *
+ * @param jwksUrl - The URL of the JWKS endpoint.
+ * @param options - The options for the validator.
+ * @param options.algorithms - The algorithms to use for validation.
+ * @returns A function that can validate a data token.
+ */
+declare function getValidator(jwksUrl: string, { algorithms }?: {
+    algorithms: string[];
+}): (token: string) => Promise<{
+    requestId?: string;
+    workspace?: {
+        id?: string;
+        title?: string;
+    };
+    user?: {
+        id?: string;
+        email?: string;
+        uuid?: string;
+    };
+}>;
+
+export { getValidator };

package/dist/index.d.ts

@@ -1,14 +1,24 @@
-export declare function getValidator(jwksUrl: string, { algorithms }?: {
+/**
+ * Get a validator function that can validate a data token.
+ *
+ * @param jwksUrl - The URL of the JWKS endpoint.
+ * @param options - The options for the validator.
+ * @param options.algorithms - The algorithms to use for validation.
+ * @returns A function that can validate a data token.
+ */
+declare function getValidator(jwksUrl: string, { algorithms }?: {
     algorithms: string[];
 }): (token: string) => Promise<{
-    requestId: string;
-    workspace: {
-        id: string;
-        title: string;
+    requestId?: string;
+    workspace?: {
+        id?: string;
+        title?: string;
     };
     user?: {
-        id: string;
-        email: string;
-        uuid: string | null;
-    } | undefined;
+        id?: string;
+        email?: string;
+        uuid?: string;
+    };
 }>;
+
+export { getValidator };

package/dist/index.mjs

@@ -0,0 +1,73 @@
+import { createRemoteJWKSet, jwtVerify, errors } from 'jose';
+import { z } from 'zod';
+
+const sleep = async (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function calculateDelay(options, attempt) {
+  let delay = options.baseDelay * options.factor ** attempt;
+  delay = Math.min(delay, options.maxDelay);
+  if (options.jitter) {
+    const jitterMultiplier = 0.5 + Math.random();
+    delay *= jitterMultiplier;
+  }
+  return Math.round(delay);
+}
+function createExponentialBackoff(userOptions = {}) {
+  const options = {
+    maxRetries: 5,
+    baseDelay: 1e3,
+    factor: 2,
+    maxDelay: 3e4,
+    jitter: true,
+    ...userOptions
+  };
+  return async function executeWithBackoff(fn, errorFilter) {
+    let lastError;
+    for (let attempt = 0; attempt <= options.maxRetries; attempt++) {
+      try {
+        return await fn();
+      } catch (error) {
+        const shouldRetry = errorFilter ? errorFilter(error) : attempt < options.maxRetries;
+        if (!shouldRetry) {
+          throw error;
+        }
+        lastError = error;
+        const delay = calculateDelay(options, attempt);
+        await sleep(delay);
+      }
+    }
+    throw lastError;
+  };
+}
+
+const DataToken = z.object({
+  requestId: z.string(),
+  workspace: z.object({
+    id: z.string(),
+    title: z.string()
+  }),
+  user: z.object({
+    id: z.string(),
+    email: z.string(),
+    uuid: z.string().nullable()
+  }).optional()
+});
+
+const retry = createExponentialBackoff({
+  maxRetries: 3,
+  jitter: true
+});
+function getValidator(jwksUrl, { algorithms } = { algorithms: ["RS256"] }) {
+  const JWKS = createRemoteJWKSet(
+    new URL(jwksUrl),
+    { cacheMaxAge: 0, headers: { "cache-control": "no-cache", "pragma": "no-cache" } }
+  );
+  return async (token) => {
+    const { payload } = await retry(
+      async () => jwtVerify(token, JWKS, { algorithms }),
+      (err) => err instanceof errors.JWKSTimeout || err instanceof Error && err.message.includes("ECONNRESET")
+    );
+    return DataToken.parse(payload);
+  };
+}
+
+export { getValidator };

package/package.json

@@ -1,17 +1,26 @@
 {
   "name": "@meistrari/data-token",
   "type": "module",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "description": "Internal library to verify and decode the API Gateway data token",
   "author": "Roz <roz@meistrari.com>",
   "license": "UNLICENSED",
   "exports": {
-    ".": "./dist/index.js",
-    "./types": "./dist/types.js",
-    "./hono": "./dist/adapters/hono.js",
-    "./elysia": "./dist/adapters/elysia.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    },
+    "./hono": {
+      "types": "./dist/adapters/hono.d.ts",
+      "import": "./dist/adapters/hono.mjs"
+    },
+    "./elysia": {
+      "types": "./dist/adapters/elysia.d.ts",
+      "import": "./dist/adapters/elysia.mjs"
+    }
   },
-  "main": "dist/index.js",
+  "main": "dist/index.mjs",
+  "types": "dist/index.d.ts",
   "files": [
     "dist"
   ],
@@ -20,7 +29,7 @@
   },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "tsc",
+    "build": "unbuild",
     "prepare": "husky",
     "lint": "eslint src",
     "lint:fix": "eslint src --fix",
@@ -34,12 +43,14 @@
   },
   "devDependencies": {
     "@antfu/eslint-config": "^3.0.0",
+    "bun-types": "1.1.38",
     "elysia": "^1.1.9",
     "eslint": "^9.9.1",
     "hono": "^4.5.9",
     "husky": "^9.1.5",
     "lint-staged": "^15.2.9",
-    "typescript": "^5.5.4"
+    "typescript": "^5.5.4",
+    "unbuild": "2.0.0"
   },
   "lint-staged": {
     "*.{js,ts}": [

package/dist/adapters/elysia.js

@@ -1,35 +0,0 @@
-import Elysia from 'elysia';
-import { getValidator } from '..';
-/**
- * Obtain an instance of the data token plugin for Elysia
- * @param url - The URL of the JWKS endpoint
- * @param skipOnError - Whether to skip the error and return null if the token is invalid
- * @param getToken - A function to get the token from the context
- * @returns An Elysia plugin
- *
- * @example
- * ```ts
- * import { createDataTokenPlugin } from 'elysia-jwt'
- *
- * const app = new Elysia()
- * const dataToken = createDataTokenPlugin('https://some.api.com/well-known/jwks.json')
- *
- * app.use(dataToken)
- *    .get('/', ({ authData }) => ({ authData }))
- * ```
- */
-export function createDataTokenPlugin(url, skipOnError = false, getToken = c => c.headers['x-data-token'] ?? '') {
-    const validator = getValidator(url);
-    const plugin = new Elysia({ name: 'data-token' })
-        .derive({ as: 'global' }, async (c) => {
-        const token = getToken(c);
-        const data = await validator(token).catch(() => {
-            if (skipOnError) {
-                return null;
-            }
-            throw new Error('Invalid data token');
-        });
-        return { authData: data };
-    });
-    return plugin;
-}

package/dist/adapters/hono.js

@@ -1,37 +0,0 @@
-import { createMiddleware } from 'hono/factory';
-import { getValidator } from '..';
-/**
- * Create a data token middleware for Hono
- * @param url - The URL of the JWKS endpoint
- * @param skipOnError - Whether to skip the error and return null if the token is invalid
- * @param getToken - A function to get the token from the context
- * @returns A Hono middleware
- *
- * @example
- * ```ts
- * import { createDataTokenMiddleware } from 'hono-jwt'
- *
- * const app = new Hono<DataTokenContext>()
- * const dataToken = createDataTokenMiddleware('https://some.api.com/well-known/jwks.json')
- *
- * app.use(dataToken)
- * app.get('/', c => c.json({ data: c.get('authData') }))
- * ```
- */
-export function createDataTokenMiddleware(url, skipOnError = false, getToken = c => c.req.header('x-data-token') ?? '') {
-    return createMiddleware(async (c, next) => {
-        const jwksUrl = typeof url === 'function' ? url(c) : url;
-        const validator = getValidator(jwksUrl);
-        const token = getToken(c);
-        const data = await validator(token).catch(() => {
-            if (skipOnError) {
-                return null;
-            }
-            throw new Error('Invalid or missing data token');
-        });
-        if (data) {
-            c.set('authData', data);
-        }
-        await next();
-    });
-}

package/dist/index.js

@@ -1,14 +0,0 @@
-import { createRemoteJWKSet, errors, jwtVerify } from 'jose';
-import { createExponentialBackoff } from './retry';
-import { DataToken } from './types';
-const retry = createExponentialBackoff({
-    maxRetries: 3,
-    jitter: true,
-});
-export function getValidator(jwksUrl, { algorithms } = { algorithms: ['RS256'] }) {
-    const JWKS = createRemoteJWKSet(new URL(jwksUrl), { cacheMaxAge: 0, headers: { 'cache-control': 'no-cache', 'pragma': 'no-cache' } });
-    return async (token) => {
-        const { payload } = await retry(async () => jwtVerify(token, JWKS, { algorithms }), err => err instanceof errors.JWKSTimeout || (err instanceof Error && err.message.includes('ECONNRESET')));
-        return DataToken.parse(payload);
-    };
-}

package/dist/retry.d.ts

@@ -1,34 +0,0 @@
-type BackoffOptions = {
-    /**
-     * Maximum number of retry attempts
-     * @default 5
-     */
-    maxRetries?: number;
-    /**
-     * Initial delay in milliseconds
-     * @default 1000 (1 second)
-     */
-    baseDelay?: number;
-    /**
-     * Multiplier for exponential backoff
-     * @default 2
-     */
-    factor?: number;
-    /**
-     * Maximum delay cap in milliseconds
-     * @default 30000 (30 seconds)
-     */
-    maxDelay?: number;
-    /**
-     * Jitter to prevent synchronized retries in distributed systems
-     * @default true
-     */
-    jitter?: boolean;
-};
-/**
- * Create an exponential backoff retry function
- * @param userOptions Configuration options for backoff strategy
- * @returns Retry function with exponential backoff
- */
-declare function createExponentialBackoff(userOptions?: BackoffOptions): <T>(fn: () => Promise<T>, errorFilter?: (error: unknown) => boolean) => Promise<T>;
-export { createExponentialBackoff };

package/dist/retry.js

@@ -1,65 +0,0 @@
-const sleep = async (ms) => new Promise(resolve => setTimeout(resolve, ms));
-/**
- * Calculate delay for a specific retry attempt
- * @param options Backoff configuration options
- * @param attempt Current retry attempt (0-indexed)
- * @returns Calculated delay in milliseconds
- */
-function calculateDelay(options, attempt) {
-    // Basic exponential backoff calculation
-    let delay = options.baseDelay * options.factor ** attempt;
-    // Cap the delay at maxDelay
-    delay = Math.min(delay, options.maxDelay);
-    // Apply jitter if enabled
-    if (options.jitter) {
-        // Add random variation between 0.5x and 1.5x of the calculated delay
-        const jitterMultiplier = 0.5 + Math.random();
-        delay *= jitterMultiplier;
-    }
-    return Math.round(delay);
-}
-/**
- * Create an exponential backoff retry function
- * @param userOptions Configuration options for backoff strategy
- * @returns Retry function with exponential backoff
- */
-function createExponentialBackoff(userOptions = {}) {
-    // Merge default options with user-provided options
-    const options = {
-        maxRetries: 5,
-        baseDelay: 1000,
-        factor: 2,
-        maxDelay: 30000,
-        jitter: true,
-        ...userOptions,
-    };
-    /**
-     * Execute a function with exponential backoff retry strategy
-     * @param fn Function to execute
-     * @param errorFilter Optional function to determine if retry is needed
-     * @returns Promise resolving to the result of the function
-     */
-    return async function executeWithBackoff(fn, errorFilter) {
-        let lastError;
-        for (let attempt = 0; attempt <= options.maxRetries; attempt++) {
-            try {
-                return await fn();
-            }
-            catch (error) {
-                // If no error filter is provided, or the error passes the filter
-                const shouldRetry = errorFilter
-                    ? errorFilter(error)
-                    : attempt < options.maxRetries;
-                if (!shouldRetry) {
-                    throw error;
-                }
-                lastError = error;
-                // Calculate and apply delay
-                const delay = calculateDelay(options, attempt);
-                await sleep(delay);
-            }
-        }
-        throw lastError;
-    };
-}
-export { createExponentialBackoff };

package/dist/types.d.ts

@@ -1,54 +0,0 @@
-import { z } from 'zod';
-export declare const DataToken: z.ZodObject<{
-    requestId: z.ZodString;
-    workspace: z.ZodObject<{
-        id: z.ZodString;
-        title: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        id: string;
-        title: string;
-    }, {
-        id: string;
-        title: string;
-    }>;
-    user: z.ZodOptional<z.ZodObject<{
-        id: z.ZodString;
-        email: z.ZodString;
-        uuid: z.ZodNullable<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        id: string;
-        email: string;
-        uuid: string | null;
-    }, {
-        id: string;
-        email: string;
-        uuid: string | null;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    requestId: string;
-    workspace: {
-        id: string;
-        title: string;
-    };
-    user?: {
-        id: string;
-        email: string;
-        uuid: string | null;
-    } | undefined;
-}, {
-    requestId: string;
-    workspace: {
-        id: string;
-        title: string;
-    };
-    user?: {
-        id: string;
-        email: string;
-        uuid: string | null;
-    } | undefined;
-}>;
-export type DataToken = z.infer<typeof DataToken>;
-export type ValidatorConfig = {
-    jwksUrl: string;
-    algorithms?: string[];
-};

package/dist/types.js

@@ -1,13 +0,0 @@
-import { z } from 'zod';
-export const DataToken = z.object({
-    requestId: z.string(),
-    workspace: z.object({
-        id: z.string(),
-        title: z.string(),
-    }),
-    user: z.object({
-        id: z.string(),
-        email: z.string(),
-        uuid: z.string().nullable(),
-    }).optional(),
-});