exisjs 0.6.1 → 0.7.1

package/dist/docs/reference/cache.mdx

@@ -1,132 +0,0 @@
----
-title: "Caching"
-description: "API Reference for ExisJS Caching and Revalidation (`exisjs/cache`)."
----
-
-# Caching (`exisjs/cache`)
-
-ExisJS comes with a highly sophisticated built-in caching system that natively supports **stale-while-revalidate** semantics, intelligent `tags`-based cache invalidation, and multiple backing stores (Memory, FileSystem, and Redis).
-
----
-
-## `cacheMiddleware(options)`
-
-The primary way to use the cache is by attaching the `cacheMiddleware` directly to your GET routes. It intercepts responses, stores them in the cache, and serves them efficiently on subsequent identical requests.
-
-ExisJS automatically injects an `X-Exis-Cache: HIT` or `X-Exis-Cache: MISS` header into the HTTP response so you can debug your cache behavior instantly!
-
-**Class-Based (OOP)**
-```typescript filename="src/http/stats/route.ts"
-import { Controller, Get, Use } from 'exisjs/decorators'
-import { cacheMiddleware } from 'exisjs/cache'
-
-@Controller('/stats')
-export default class StatsController {
-  
-  @Get('/')
-  @Use(
-    cacheMiddleware({
-      ttlMs: 60 * 1000, // 60 seconds
-      keyGenerator: (req) => `stats:${req.query.period || 'all'}`
-    })
-  )
-  async getStats() {
-    return db.queryHeavyStats() 
-  }
-}
-```
-
-**Functional**
-```typescript filename="src/http/stats/route.ts"
-import { controller, route } from 'exisjs/router'
-import { cacheMiddleware } from 'exisjs/cache'
-
-export default controller({
-  getStats: route.get('/', {
-    middleware: [
-      cacheMiddleware({
-        ttlMs: 60 * 1000, // 60 seconds
-        
-        // You MUST provide a keyGenerator to prevent data leaking between users!
-        keyGenerator: (req) => `stats:${req.query.period || 'all'}`
-      })
-    ],
-    async handle() {
-      // This heavy query only runs once every 60 seconds per period
-      return db.queryHeavyStats() 
-    }
-  })
-})
-```
-
-### Options
-
-- **`keyGenerator`** `(req => string)`: **Required.** Generates a unique cache key for the request. Never use a static key if the response varies by User ID or Query Parameters.
-- **`ttlMs`** `(number)`: Time to live in milliseconds. If omitted, the cache never inherently expires based on time (relies on manual tags instead).
-- **`tags`** `(string[] | function)`: A list of tags to associate with this cache entry, used for Next.js-style on-demand revalidation.
-
----
-
-## Tag-Based Cache Invalidation
-
-Instead of waiting for a TTL to expire, you can invalidate caches instantly using tags. This is exactly how Next.js App Router caching works.
-
-When you cache a route, assign it a tag:
-
-```typescript filename="src/http/products/route.ts"
-import { cacheMiddleware } from 'exisjs/cache'
-
-route.get('/:id', {
-  middleware: [
-    cacheMiddleware({
-      // We tag this cache entry with the specific product ID
-      tags: (req) => [`product-${req.params.id}`, 'all-products'],
-      keyGenerator: (req) => `product:${req.params.id}`
-    })
-  ],
-  async handle(ctx) {
-    return db.products.find(ctx.params.id)
-  }
-})
-```
-
-Later, when a user updates the product via a `POST` or `PUT` route, you can instantly bust all caches tied to that tag using `revalidateTag()`!
-
-```typescript filename="src/http/products/route.ts"
-import { revalidateTag } from 'exisjs/cache'
-
-route.put('/:id', {
-  async handle(ctx) {
-    await db.products.update(ctx.params.id, ctx.body)
-    
-    // Instantly purge the cache across the entire cluster!
-    await revalidateTag(`product-${ctx.params.id}`)
-    
-    return { success: true }
-  }
-})
-```
-
----
-
-## Cache Drivers
-
-ExisJS natively provides three driver implementations:
-
-1. **`FileSystemCacheStore`**: (Default). Writes cache data to `.exis/cache/*.json` on the disk. Extremely fast for static data and survives server reboots.
-2. **`MemoryCacheStore`**: Keeps caches purely in RAM. Perfect for development or extremely high-throughput, short-TTL data. (Includes automatic broadcast sync if running in an ExisJS Cluster).
-3. **`RedisCacheStore`**: The standard for production. Uses a minimal Redis client to handle distributed caching across massive fleets of servers.
-
-### Switching Stores Globally
-
-While you can pass a `store` option directly into `cacheMiddleware()`, it is usually better to set the global cache store during application boot:
-
-```typescript filename="src/server.ts"
-import { exis } from 'exisjs'
-import { setCacheStore, RedisCacheStore } from 'exisjs/cache'
-
-const app = exis()
-
-// Use Redis instead of the default FileSystem cache
-setCacheStore(new RedisCacheStore(myRedisClient))
-```

package/dist/docs/reference/circuit-breaker.mdx

@@ -1,71 +0,0 @@
----
-title: "Circuit Breaker"
-description: "Strict API Reference for the Circuit Breaker resilience utility."
----
-
-# Circuit Breaker (`exisjs/app`)
-
-This document provides the strict API signatures and TypeScript interfaces exported for the `CircuitBreaker` utility. For high-level resilience guides, see the [Circuit Breaker Guide](/docs/circuit-breaker).
-
----
-
-## `CircuitBreaker` Class
-
-The `CircuitBreaker` class is a state machine that monitors the execution of async actions to prevent cascading failures.
-
-```typescript
-import { CircuitBreaker } from 'exisjs/app'
-
-class CircuitBreaker {
-  constructor(options?: CircuitBreakerOptions)
-  
-  // The current state of the breaker
-  public state: CircuitState
-  
-  // Executes the provided async action through the breaker
-  fire<T>(action: () => Promise<T>): Promise<T>
-}
-```
-
-### `CircuitBreakerOptions`
-
-```typescript
-interface CircuitBreakerOptions {
-  /** Maximum number of sequential failures before the breaker transitions to OPEN */
-  failureThreshold?: number // Default: 5
-  
-  /** Time to wait (in ms) before transitioning from OPEN to HALF_OPEN to test recovery */
-  resetTimeoutMs?: number   // Default: 10000 (10 seconds)
-}
-```
-
----
-
-## `CircuitState` Enum
-
-The circuit breaker operates in one of three states.
-
-```typescript
-enum CircuitState {
-  // Normal operation, all requests pass
-  CLOSED = 'CLOSED',
-  
-  // Failing, all requests are instantly rejected
-  OPEN = 'OPEN',
-  
-  // Testing recovery, exactly ONE request is allowed through
-  HALF_OPEN = 'HALF_OPEN',
-}
-```
-
----
-
-## `CircuitBreakerError`
-
-If `fire()` is called while the breaker is `OPEN` (or if it is `HALF_OPEN` and a probe is already in flight), the breaker will instantly reject the promise with a `CircuitBreakerError`.
-
-```typescript
-class CircuitBreakerError extends Error {
-  constructor(message: string)
-}
-```

package/dist/docs/reference/queue.mdx

@@ -1,155 +0,0 @@
----
-title: "Queues"
-description: "API Reference for ExisJS Background Queues (`exisjs/queue`)."
----
-
-# Queues (`exisjs/queue`)
-
-ExisJS ships with a highly robust, Redis-backed background job queue mechanism. It supports strict payload validation, exponential backoff, delayed execution, and lifecycle observability hooks, seamlessly integrated right into the core framework.
-
----
-
-## Configuration (`exis.config.ts`)
-
-Before using the queue system, you must configure your driver (either `memory` for local development or `redis` for production). This is defined globally in your `exis.config.ts` file.
-
-```typescript filename="exis.config.ts"
-import { defineConfig } from 'exisjs/config'
-
-export default async (phase: string) => {
-  return defineConfig({
-    queue: {
-      driver: phase === 'development' ? 'memory' : 'redis',
-      redisUrl: process.env.REDIS_URL,
-      maxConcurrent: 100, // Maximum active workers
-      maxQueue: 1000      // Maximum waiting jobs
-    }
-  })
-}
-```
-
----
-
-## Defining Jobs (File-Based Routing)
-
-ExisJS uses highly intuitive **File-Based Job Routing**. 
-
-To create a new background job, simply create a file in the `src/jobs/` directory and `export default defineJob(...)`. The framework will automatically discover, load, and bind the job queue on boot!
-
-```typescript filename="src/jobs/SendEmailJob.ts"
-import { defineJob } from 'exisjs/queue'
-import { tex } from 'exisjs/validator'
-
-export default defineJob({
-  name: 'send-email',
-  
-  // ExisJS will automatically validate incoming queue payloads against this schema!
-  schema: tex.object({
-    to: tex.email(),
-    subject: tex.string(),
-    html: tex.string()
-  }),
-  
-  // Set default retry and backoff behavior
-  defaultOptions: {
-    attempts: 3,
-    backoff: {
-      type: 'exponential',
-      delay: 5000 // 5s, 25s, 125s...
-    }
-  },
-
-  // Observability Hooks
-  onJobFailed(payload, err) {
-    console.error(`Job failed on attempt ${payload.attemptsMade}`, err)
-  },
-  
-  onJobFailedPermanently(payload, err) {
-    // Alert Sentry or Slack!
-    console.error(`Job fatally died after all retries!`, err)
-  },
-
-  // The actual background execution logic
-  async handler(job) {
-    // job.data is completely type-safe and strictly validated by the schema!
-    const { to, subject, html } = job.data
-    
-    await mailer.send({ to, subject, html })
-  }
-})
-```
-
-### Job Definition Properties
-- **`name`** *(string)*: Unique identifier for the queue.
-- **`schema`** *(Validator)*: An ExisJS validator object to validate the payload structure.
-- **`handler`** *(function)*: The logic to execute (optional if using file-based job routing).
-- **`defaultOptions`** *(JobOptions)*: Global options for retry counts and delays.
-- **`cron`** *(string)*: A cron expression (e.g. `'0 * * * *'`) for scheduling the job recursively.
-- **Hooks**: `onJobStart`, `onJobSuccess`, `onJobFailed`, `onJobFailedPermanently`.
-
----
-
-## Enqueuing Jobs
-
-You can dispatch a job from anywhere in your application (Controllers, Gateways, Services) using the `enqueue` function.
-
-```typescript filename="src/http/users/route.ts"
-import { controller, route } from 'exisjs/router'
-import { enqueue } from 'exisjs/queue'
-import { SendEmailJob } from '../../jobs/SendEmailJob'
-
-export default controller({
-  register: route.post('/register', {
-    async handle(ctx) {
-      const user = await db.users.create(ctx.body)
-      
-      // Dispatch the job to the background queue!
-      await enqueue('send-email', {
-        to: user.email,
-        subject: 'Welcome to ExisJS!',
-        html: '<h1>Welcome aboard!</h1>'
-      })
-      
-      return { success: true }
-    }
-  })
-})
-```
-
-### Delaying Execution
-You can override the `defaultOptions` on a per-dispatch basis. For example, to delay a job by 15 minutes:
-
-```typescript
-await enqueue('send-email', payload, {
-  delay: 15 * 60 * 1000, // 15 minutes in milliseconds
-  attempts: 5
-})
-```
-
----
-
-### Cron / Scheduled Jobs
-
-Because ExisJS uses file-based routing for jobs, implementing recurring Cron jobs is completely trivial. Just add a `cron` property to your `defineJob` config!
-
-```typescript filename="src/jobs/CleanupJob.ts"
-import { defineJob } from 'exisjs/queue'
-
-export default defineJob({
-  name: 'cleanup-stale-sessions',
-  cron: '0 0 * * *', // Run every day at midnight
-  
-  async handler() {
-    await db.query('DELETE FROM sessions WHERE expiresAt < NOW()')
-  }
-})
-```
-
-### The `JobPayload` Object
-
-When your handler executes, it receives a `JobPayload` containing the following properties:
-- **`id`**: The unique generated UUID for this specific job execution.
-- **`name`**: The name of the queue.
-- **`data`**: The raw, strongly-typed, validated payload.
-- **`attemptsMade`**: How many times this specific job has failed and retried.
-- **`opts`**: The options (delays, backoff strategy) this job is running under.

package/dist/docs/reference/storage.mdx

@@ -1,116 +0,0 @@
----
-title: "Storage & Uploads"
-description: "API Reference for ExisJS Storage and File Uploads (`exisjs/storage`)."
----
-
-# Storage & Uploads (`exisjs/storage`)
-
-ExisJS provides native, extremely memory-efficient support for handling `multipart/form-data` file uploads.
-
-Instead of buffering large files into RAM (which can easily crash Node.js servers under heavy load), ExisJS streams file chunks directly from the network socket into the disk using a highly optimized Busboy integration.
-
----
-
-## How it Works
-
-When you invoke `streamUpload`, ExisJS takes over the raw socket stream. As bytes come in from the network, they are instantly piped to the disk. 
-
-Because ExisJS parses the multipart stream on the fly:
-1. Your Node.js RAM footprint stays incredibly flat, even when users upload massive 10GB video files.
-2. Form text fields are extracted in real-time. Once the upload finishes, ExisJS automatically merges all text fields directly into `req.body` so your subsequent logic (or validators) can treat them like a normal JSON payload!
-
----
-
-## 1. Functional Example (`streamUpload`)
-
-If you are using the Functional architecture, import the `streamUpload` helper from `exisjs/storage` and pass it your request context.
-
-### Example Usage
-
-```typescript filename="src/http/upload/route.ts"
-import { controller, route } from 'exisjs/router'
-import { streamUpload } from 'exisjs/storage'
-import { HttpError } from 'exisjs/error'
-
-export default controller({
-  uploadAvatar: route.post('/avatar', {
-    async handle(ctx) {
-      try {
-        const { files, fields } = await streamUpload(ctx.req, {
-          dest: './storage/avatars'
-        })
-
-        if (files.length === 0) {
-          throw HttpError.badRequest('No file provided')
-        }
-
-        const uploadedFile = files[0]
-        
-        // Log the fields submitted with the form
-        console.log('User ID associated with upload:', fields.userId)
-
-        return {
-          success: true,
-          filename: uploadedFile.filename,
-          savedAt: uploadedFile.destPath,
-          size: uploadedFile.size,
-          mimetype: uploadedFile.mimetype
-        }
-      } catch (err) {
-        // streamUpload throws HttpErrors if the request isn't valid multipart/form-data
-        throw err
-      }
-    }
-  })
-})
-```
-
-### Return Value
-
-`streamUpload` resolves a Promise containing an object with two properties:
-
-#### 1. `fields` (`Record<string, string>`)
-An object containing all the non-file text fields submitted in the `multipart/form-data` payload. Note that `streamUpload` automatically populates `ctx.req.body` with these fields as well upon completion.
-
-#### 2. `files` (`Array<object>`)
-An array of successfully streamed files. Each object contains:
-- **`fieldname`**: The name of the HTML form field (e.g., `avatar`).
-- **`filename`**: The original name of the file uploaded by the user.
-- **`mimetype`**: The MIME type of the file (e.g., `image/png`).
-- **`destPath`**: The absolute path on your server's disk where the file was safely saved. *Note: ExisJS appends a randomized unique suffix to the filename to prevent overwrites.*
-- **`size`**: The total file size in bytes.
-
----
-
-## 2. Class-Based Example (`req.streamUpload`)
-
-If you are using Object-Oriented `@Controller` classes, ExisJS natively extends the Request object. You do not even need to import `streamUpload`! 
-
-Simply inject the Request object via the `@Req()` decorator and call `req.streamUpload(dest)` directly.
-
-```typescript filename="src/http/upload/route.ts"
-import { Controller, Post, Req } from 'exisjs/decorators'
-import type { Request } from 'exisjs'
-import { HttpError } from 'exisjs/error'
-
-@Controller('/upload')
-export default class UploadController {
-  
-  @Post('/avatar')
-  async handleUpload(@Req() req: Request) {
-    // Exactly identical to streamUpload(req, { dest: ... })
-    // We pass the destination path directly into the Request method
-    const { files, fields } = await req.streamUpload('./storage/avatars')
-    
-    if (!files.length) throw HttpError.badRequest('Missing file')
-    
-    // Remember: fields are also populated into req.body!
-    console.log(req.body.userId === fields.userId) // true!
-    
-    return { 
-      message: 'Upload successful', 
-      files 
-    }
-  }
-}
-```

package/dist/docs/reference/swagger.mdx

@@ -1,132 +0,0 @@
----
-title: "Swagger & OpenAPI"
-description: "API Reference for ExisJS auto-generated Swagger UI (`exisjs/swagger`)."
----
-
-# Swagger / OpenAPI (`exisjs/swagger`)
-
-ExisJS ships with native, zero-configuration OpenAPI 3.0 generation.
-
-Because ExisJS routes strongly integrate with `exisjs/validator`, the framework automatically introspects your validators (`tex.object`, `tex.string`, etc.) across all controllers and automatically generates a fully interactive Swagger UI!
-
----
-
-## 1. Global Setup (`exis.config.ts`)
-
-Because the Swagger engine needs to read all registered routes at boot time, you mount it globally using a Plugin.
-
-Create a new file in your `plugins` directory:
-
-```typescript filename="src/plugins/swagger.ts"
-import { definePlugin } from 'exisjs/plugin'
-import { serveSwagger } from 'exisjs/swagger'
-
-export const swaggerPlugin = definePlugin({
-  name: 'swagger-ui',
-  register(app) {
-    serveSwagger(app, {
-      path: '/docs',               // The URL where the UI will be served
-      title: 'My ExisJS API',
-      version: '1.0.0',
-      
-      // Optionally attach global OpenAPI components (like Bearer Auth definitions)
-      components: {
-        securitySchemes: {
-          bearerAuth: {
-            type: 'http',
-            scheme: 'bearer',
-            bearerFormat: 'JWT',
-          }
-        }
-      }
-    })
-  }
-})
-```
-
-Then, natively register your plugin in `exis.config.ts`:
-
-```typescript filename="exis.config.ts"
-import { defineConfig } from 'exisjs/config'
-import { swaggerPlugin } from './src/plugins/swagger'
-
-export default defineConfig({
-  plugins: [
-    swaggerPlugin()
-  ]
-})
-```
-
----
-
-## 2. Automatic Schema Inference
-
-You do not need to write YAML files or manually define your request bodies in Swagger. ExisJS reads the schemas directly from your code!
-
-### Functional Architecture
-
-When using the `route.*` functions, anything you pass to `schema.body`, `schema.query`, or `schema.response` is instantly injected into the Swagger documentation.
-
-```typescript filename="src/http/users/route.ts"
-import { controller, route } from 'exisjs/router'
-import { tex } from 'exisjs/validator'
-
-export default controller({
-  createUser: route.post('/', {
-    schema: {
-      // ExisJS automatically builds an OpenAPI schema from this validator!
-      body: tex.object({
-        email: tex.email(),
-        age: tex.number({ min: 18 })
-      }),
-      response: tex.object({
-        id: tex.string(),
-        success: tex.boolean()
-      })
-    },
-    async handle(ctx) {
-      return { id: '123', success: true }
-    }
-  })
-})
-```
-
-### Class-Based (OOP) Architecture
-
-If you are using OOP Decorators, ExisJS achieves the exact same result by reading your `@Body()`, `@Query()`, and `@Returns()` decorators.
-
-```typescript filename="src/http/users/route.ts"
-import { Controller, Post, Body, Returns } from 'exisjs/decorators'
-import { tex } from 'exisjs/validator'
-
-const CreateUserSchema = tex.object({
-  email: tex.email(),
-  age: tex.number({ min: 18 })
-})
-
-const ResponseSchema = tex.object({
-  id: tex.string(),
-  success: tex.boolean()
-})
-
-@Controller('/users')
-export default class UserController {
-  
-  @Post('/')
-  @Returns(ResponseSchema)
-  async createUser(@Body(CreateUserSchema) body: any) {
-    return { id: '123', success: true }
-  }
-}
-```
-
----
-
-## 3. Accessing the UI
-
-Once you boot your application, simply navigate to the `path` you defined in your plugin:
-
-- **Swagger UI**: `http://localhost:4000/docs`
-- **Raw OpenAPI JSON**: `http://localhost:4000/docs/json`
-
-The generated Swagger UI is fully interactive, meaning you can authenticate and test your API directly from the browser!

package/dist/integrations/drizzle.d.ts

@@ -1,10 +0,0 @@
-/**
- * Zero-config Drizzle ORM Integration.
- *
- * Automatically initializes Drizzle using `process.env.DATABASE_URL`.
- *
- * Peer Dependencies required:
- *   npm install drizzle-orm postgres
- */
-export declare function drizzle<TSchema extends Record<string, unknown>>(schema: TSchema): any;
-//# sourceMappingURL=drizzle.d.ts.map

package/dist/integrations/drizzle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"drizzle.d.ts","sourceRoot":"","sources":["../../src/integrations/drizzle.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,wBAAgB,OAAO,CAAC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7D,MAAM,EAAE,OAAO,OA6BhB"}

package/dist/integrations/drizzle.js

@@ -1,34 +0,0 @@
-"use strict";
-/**
- * Zero-config Drizzle ORM Integration.
- *
- * Automatically initializes Drizzle using `process.env.DATABASE_URL`.
- *
- * Peer Dependencies required:
- *   npm install drizzle-orm postgres
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.drizzle = drizzle;
-function drizzle(schema) {
-    const url = process.env.DATABASE_URL;
-    if (!url) {
-        throw new Error('process.env.DATABASE_URL is missing. Cannot initialize Drizzle.');
-    }
-    // Dynamic require to avoid bloating the core framework bundle if Drizzle isn't used.
-    let postgres;
-    let drizzleOrm;
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        postgres = require('postgres');
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        drizzleOrm = require('drizzle-orm/postgres-js');
-    }
-    catch {
-        throw new Error('Missing dependencies. Please run: npm install drizzle-orm postgres');
-    }
-    // Initialize the connection pool
-    const sql = postgres(url, { max: 10 });
-    // Return the drizzle client
-    return drizzleOrm.drizzle(sql, { schema });
-}
-//# sourceMappingURL=drizzle.js.map

package/dist/integrations/drizzle.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"drizzle.js","sourceRoot":"","sources":["../../src/integrations/drizzle.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;AAEH,0BA8BC;AA9BD,SAAgB,OAAO,CACrB,MAAe;IAEf,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,YAAY,CAAA;IACpC,IAAI,CAAC,GAAG,EAAE,CAAC;QACT,MAAM,IAAI,KAAK,CACb,iEAAiE,CAClE,CAAA;IACH,CAAC;IAED,qFAAqF;IACrF,IAAI,QAAa,CAAA;IACjB,IAAI,UAAe,CAAA;IAEnB,IAAI,CAAC;QACH,iEAAiE;QACjE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC,CAAA;QAC9B,iEAAiE;QACjE,UAAU,GAAG,OAAO,CAAC,yBAAyB,CAAC,CAAA;IACjD,CAAC;IAAC,MAAM,CAAC;QACP,MAAM,IAAI,KAAK,CACb,oEAAoE,CACrE,CAAA;IACH,CAAC;IAED,iCAAiC;IACjC,MAAM,GAAG,GAAG,QAAQ,CAAC,GAAG,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,CAAC,CAAA;IAEtC,4BAA4B;IAC5B,OAAO,UAAU,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,MAAM,EAAE,CAAC,CAAA;AAC5C,CAAC"}

package/dist/integrations/jwt.d.ts

@@ -1,12 +0,0 @@
-import { type JWTOptions } from '../auth/jwt';
-export declare const jwt: {
-    /**
-     * Automatically signs a JWT token using `process.env.JWT_SECRET`.
-     */
-    sign(payload: Record<string, unknown>, options?: JWTOptions): string;
-    /**
-     * Automatically verifies a JWT token using `process.env.JWT_SECRET`.
-     */
-    verify<T = unknown>(token: string): T;
-};
-//# sourceMappingURL=jwt.d.ts.map

package/dist/integrations/jwt.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"jwt.d.ts","sourceRoot":"","sources":["../../src/integrations/jwt.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,UAAU,EAAE,MAAM,aAAa,CAAA;AAEjE,eAAO,MAAM,GAAG;IACd;;OAEG;kBACW,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,YAAY,UAAU,GAAG,MAAM;IASpE;;OAEG;WACI,CAAC,mBAAmB,MAAM,GAAG,CAAC;CAQtC,CAAA"}