@mantiq/core 0.5.21 → 0.5.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mantiq/core",
-  "version": "0.5.21",
+  "version": "0.5.23",
   "description": "Service container, router, middleware, HTTP kernel, config, and exception handler",
   "type": "module",
   "license": "MIT",

package/src/application/Application.ts

@@ -189,9 +189,7 @@ export class Application extends ContainerImpl {
             providers.push(mod[providerName])
           }
         } catch (e) {
-          if (process.env.APP_DEBUG === 'true') {
-            console.warn(`[Mantiq] Failed to load provider from ${file}:`, (e as Error)?.message ?? e)
-          }
+          console.warn(`[Mantiq] Failed to load provider from ${file}:`, (e as Error)?.message ?? e)
         }
       }
     } catch {
@@ -212,11 +210,64 @@ export class Application extends ContainerImpl {
     coreProviders: Constructor<ServiceProvider>[] = [],
     userProviders: Constructor<ServiceProvider>[] = [],
   ): Promise<void> {
+    this.validateEnvironment()
     const packageProviders = await this.discoverPackageProviders()
     await this.registerProviders([...coreProviders, ...packageProviders, ...userProviders])
     await this.bootProviders()
   }
 
+  /**
+   * Validate environment variables on startup.
+   * Called at the beginning of bootstrap() to catch misconfigurations early.
+   *
+   * Checks:
+   * - APP_ENV must be set
+   * - APP_KEY format (if set): must start with 'base64:' and decode to exactly 32 bytes
+   * - Warns if APP_DEBUG=true in production
+   */
+  validateEnvironment(): void {
+    // APP_ENV must be set
+    if (!process.env['APP_ENV']) {
+      throw new Error(
+        'APP_ENV is not set. Set it in your .env file (e.g., APP_ENV=local).',
+      )
+    }
+
+    // Validate APP_KEY format when present
+    const appKey = process.env['APP_KEY']
+    if (appKey) {
+      if (!appKey.startsWith('base64:')) {
+        throw new Error(
+          'APP_KEY must start with "base64:". Generate one with: bun mantiq key:generate',
+        )
+      }
+
+      try {
+        const decoded = Buffer.from(appKey.slice(7), 'base64')
+        if (decoded.length !== 32) {
+          throw new Error(
+            `APP_KEY must decode to exactly 32 bytes (got ${decoded.length}). ` +
+            'Generate one with: bun mantiq key:generate',
+          )
+        }
+      } catch (e) {
+        if (e instanceof Error && e.message.startsWith('APP_KEY must')) {
+          throw e
+        }
+        throw new Error(
+          'APP_KEY contains invalid base64 data. Generate one with: bun mantiq key:generate',
+        )
+      }
+    }
+
+    // Warn on APP_DEBUG=true in production
+    if (process.env['APP_ENV'] === 'production' && process.env['APP_DEBUG'] === 'true') {
+      console.warn(
+        '[Mantiq] WARNING: APP_DEBUG=true in production. This may expose sensitive data.',
+      )
+    }
+  }
+
   // ── Provider lifecycle ────────────────────────────────────────────────────
 
   /**
@@ -250,7 +301,12 @@ export class Application extends ContainerImpl {
    */
   async bootProviders(): Promise<void> {
     for (const provider of this.providers) {
-      await provider.boot()
+      try {
+        await provider.boot()
+      } catch (e) {
+        const name = provider.constructor?.name ?? 'Unknown'
+        console.error(`[Mantiq] ${name}.boot() failed:`, (e as Error)?.stack ?? e)
+      }
     }
     this.booted = true
   }
@@ -295,9 +351,11 @@ export class Application extends ContainerImpl {
             await deferredProvider.boot()
             this.providers.push(deferredProvider)
           }
-          // @internal: sync wrapper — deferred providers must not have async register/boot
-          // that relies on other async operations. In practice this is fine.
-          void boot()
+          // Deferred boot — catch and log errors instead of swallowing
+          boot().catch((e) => {
+            const name = deferredProvider.constructor?.name ?? 'DeferredProvider'
+            console.error(`[Mantiq] ${name} deferred boot failed:`, (e as Error)?.stack ?? e)
+          })
           return super.make(abstract)
         }
       }

package/src/cache/FileCacheStore.ts

@@ -1,6 +1,7 @@
 import type { CacheStore } from '../contracts/Cache.ts'
 import { join } from 'node:path'
-import { mkdir, rm, readdir } from 'node:fs/promises'
+import { mkdir, rm, readdir, rename } from 'node:fs/promises'
+import { randomBytes } from 'node:crypto'
 
 interface FileCachePayload {
   value: unknown
@@ -91,9 +92,47 @@ export class FileCacheStore implements CacheStore {
     return this.increment(key, -value)
   }
 
+  /**
+   * Store an item in the cache if the key does not already exist.
+   *
+   * Uses write-to-temp + rename to avoid TOCTOU race conditions.
+   * If the key already exists (and is not expired), returns false.
+   */
   async add(key: string, value: unknown, ttl?: number): Promise<boolean> {
-    if (await this.has(key)) return false
-    await this.put(key, value, ttl)
+    await this.ensureDirectory()
+
+    const targetPath = this.path(key)
+
+    // Check if key already exists and is not expired
+    const file = Bun.file(targetPath)
+    if (await file.exists()) {
+      try {
+        const payload: FileCachePayload = await file.json()
+        if (payload.expiresAt === null || Date.now() <= payload.expiresAt) {
+          return false
+        }
+        // Expired — fall through to overwrite
+      } catch {
+        // Corrupted file — fall through to overwrite
+      }
+    }
+
+    // Write to a temp file first, then atomically rename into place
+    const tmpPath = join(this.directory, `_tmp_${randomBytes(8).toString('hex')}.cache`)
+    const payload: FileCachePayload = {
+      value,
+      expiresAt: ttl != null ? Date.now() + ttl * 1000 : null,
+    }
+    await Bun.write(tmpPath, JSON.stringify(payload))
+
+    try {
+      await rename(tmpPath, targetPath)
+    } catch {
+      // Cleanup temp file on failure
+      try { await rm(tmpPath) } catch { /* ignore */ }
+      return false
+    }
+
     return true
   }
 

package/src/cache/MemoryCacheStore.ts

@@ -55,8 +55,20 @@ export class MemoryCacheStore implements CacheStore {
   }
 
   async add(key: string, value: unknown, ttl?: number): Promise<boolean> {
-    if (await this.has(key)) return false
-    await this.put(key, value, ttl)
+    // Atomic check-and-set: read the entry directly and check expiry in one step
+    // to avoid TOCTOU race between has() and put().
+    const existing = this.store.get(key)
+    if (existing) {
+      if (existing.expiresAt === null || Date.now() <= existing.expiresAt) {
+        return false
+      }
+      // Expired — remove and allow re-add
+      this.store.delete(key)
+    }
+    this.store.set(key, {
+      value,
+      expiresAt: ttl != null ? Date.now() + ttl * 1000 : null,
+    })
     return true
   }
 }

package/src/contracts/Request.ts

@@ -11,13 +11,17 @@ export interface MantiqRequest {
   // ── Input ────────────────────────────────────────────────────────────────
   query(key: string, defaultValue?: string): string
   query(): Record<string, string>
-  input(key: string, defaultValue?: any): Promise<any>
-  input(): Promise<Record<string, any>>
+  input<T = any>(key: string, defaultValue?: any): Promise<T>
+  input<T = Record<string, any>>(): Promise<T>
   only(...keys: string[]): Promise<Record<string, any>>
   except(...keys: string[]): Promise<Record<string, any>>
   has(...keys: string[]): boolean
   filled(...keys: string[]): Promise<boolean>
 
+  // ── Body errors ────────────────────────────────────────────────────────
+  hasBodyError(): boolean
+  bodyError(): Error | null
+
   // ── Headers & metadata ───────────────────────────────────────────────────
   header(key: string, defaultValue?: string): string | undefined
   headers(): Record<string, string>
@@ -38,6 +42,7 @@ export interface MantiqRequest {
   param(key: string, defaultValue?: any): any
   params(): Record<string, any>
   setRouteParams(params: Record<string, any>): void
+  setRouteParam(key: string, value: any): void
 
   // ── Session ──────────────────────────────────────────────────────────────
   session(): SessionStore
@@ -50,6 +55,9 @@ export interface MantiqRequest {
   isAuthenticated(): boolean
   setUser(user: any): void
 
+  // ── FormData ────────────────────────────────────────────────────────────
+  formData(): Promise<FormData>
+
   // ── Raw ──────────────────────────────────────────────────────────────────
   raw(): Request
 }

package/src/contracts/Router.ts

@@ -21,6 +21,7 @@ export interface RouteMatch {
   params: Record<string, any>
   middleware: string[]
   routeName?: string | undefined
+  bindings?: Map<string, { model: any; key: string }>
 }
 
 export interface RouteDefinition {
@@ -60,4 +61,5 @@ export interface RouterRoute {
   whereNumber(param: string): this
   whereAlpha(param: string): this
   whereUuid(param: string): this
+  bind(param: string, model: any, key?: string): this
 }

package/src/discovery/Discoverer.ts

@@ -156,9 +156,7 @@ export class Discoverer {
           mod.default(router)
         }
       } catch (e) {
-        if (process.env.APP_DEBUG === 'true') {
-          console.warn(`[Mantiq] Failed to load route file ${file}:`, (e as Error)?.message ?? e)
-        }
+        console.warn(`[Mantiq] Failed to load route file ${file}:`, (e as Error)?.message ?? e)
       }
     }
   }

package/src/encryption/errors.ts

@@ -1,11 +1,12 @@
 import { MantiqError } from '../errors/MantiqError.ts'
+import { ErrorCodes } from '../errors/ErrorCodes.ts'
 
 /**
  * Thrown when encryption fails (e.g. invalid key, algorithm error).
  */
 export class EncryptionError extends MantiqError {
   constructor(message = 'Could not encrypt the data.', context?: Record<string, any>) {
-    super(message, context)
+    super(message, context, ErrorCodes.ENCRYPTION_FAILED)
   }
 }
 
@@ -14,7 +15,7 @@ export class EncryptionError extends MantiqError {
  */
 export class DecryptionError extends MantiqError {
   constructor(message = 'Could not decrypt the data.', context?: Record<string, any>) {
-    super(message, context)
+    super(message, context, ErrorCodes.DECRYPTION_FAILED)
   }
 }
 
@@ -25,6 +26,8 @@ export class MissingAppKeyError extends MantiqError {
   constructor() {
     super(
       'No application encryption key has been specified. Set the APP_KEY environment variable (use "base64:<key>" format for raw keys).',
+      undefined,
+      ErrorCodes.MISSING_APP_KEY,
     )
   }
 }

package/src/errors/ConfigKeyNotFoundError.ts

@@ -1,7 +1,12 @@
 import { MantiqError } from './MantiqError.ts'
+import { ErrorCodes } from './ErrorCodes.ts'
 
 export class ConfigKeyNotFoundError extends MantiqError {
   constructor(public readonly key: string) {
-    super(`Config key '${key}' not found and no default value provided.`)
+    super(
+      `Config key '${key}' not found and no default value provided.`,
+      undefined,
+      ErrorCodes.CONFIG_NOT_FOUND,
+    )
   }
 }

package/src/errors/ContainerResolutionError.ts

@@ -1,4 +1,5 @@
 import { MantiqError } from './MantiqError.ts'
+import { ErrorCodes } from './ErrorCodes.ts'
 
 export class ContainerResolutionError extends MantiqError {
   constructor(
@@ -8,6 +9,8 @@ export class ContainerResolutionError extends MantiqError {
   ) {
     super(
       `Cannot resolve ${String(abstract)}: ${reason}.${details ? ' ' + details : ''}`,
+      undefined,
+      ErrorCodes.CONTAINER_RESOLUTION,
     )
   }
 }

package/src/errors/ErrorCodes.ts

@@ -0,0 +1,27 @@
+/**
+ * Structured error codes for all MantiqJS framework errors.
+ *
+ * Each error code follows the pattern `E_{CATEGORY}_{DESCRIPTION}`.
+ */
+export const ErrorCodes = {
+  AUTH_UNAUTHENTICATED: 'E_AUTH_UNAUTHENTICATED',
+  AUTH_UNAUTHORIZED: 'E_AUTH_UNAUTHORIZED',
+  AUTH_FORBIDDEN: 'E_AUTH_FORBIDDEN',
+  VALIDATION_FAILED: 'E_VALIDATION_FAILED',
+  MODEL_NOT_FOUND: 'E_MODEL_NOT_FOUND',
+  ROUTE_NOT_FOUND: 'E_ROUTE_NOT_FOUND',
+  CSRF_MISMATCH: 'E_CSRF_MISMATCH',
+  ENCRYPTION_FAILED: 'E_ENCRYPTION_FAILED',
+  DECRYPTION_FAILED: 'E_DECRYPTION_FAILED',
+  MISSING_APP_KEY: 'E_MISSING_APP_KEY',
+  RATE_LIMITED: 'E_RATE_LIMITED',
+  CONTAINER_RESOLUTION: 'E_CONTAINER_RESOLUTION',
+  CONFIG_NOT_FOUND: 'E_CONFIG_NOT_FOUND',
+  QUERY_ERROR: 'E_QUERY_ERROR',
+  CONNECTION_LOST: 'E_CONNECTION_LOST',
+  CONNECTION_FAILED: 'E_CONNECTION_FAILED',
+  DRIVER_NOT_SUPPORTED: 'E_DRIVER_NOT_SUPPORTED',
+  HTTP_ERROR: 'E_HTTP_ERROR',
+} as const
+
+export type ErrorCode = typeof ErrorCodes[keyof typeof ErrorCodes]

package/src/errors/ForbiddenError.ts

@@ -1,7 +1,8 @@
 import { HttpError } from './HttpError.ts'
+import { ErrorCodes } from './ErrorCodes.ts'
 
 export class ForbiddenError extends HttpError {
   constructor(message = 'Forbidden', headers?: Record<string, string>) {
-    super(403, message, headers)
+    super(403, message, headers, undefined, ErrorCodes.AUTH_FORBIDDEN)
   }
 }

package/src/errors/HttpError.ts

@@ -1,4 +1,6 @@
 import { MantiqError } from './MantiqError.ts'
+import { ErrorCodes } from './ErrorCodes.ts'
+import type { ErrorCode } from './ErrorCodes.ts'
 
 /**
  * Base class for all HTTP-facing errors.
@@ -10,7 +12,8 @@ export class HttpError extends MantiqError {
     message: string,
     public readonly headers?: Record<string, string>,
     context?: Record<string, any>,
+    errorCode?: ErrorCode | string,
   ) {
-    super(message, context)
+    super(message, context, errorCode ?? ErrorCodes.HTTP_ERROR)
   }
 }

package/src/errors/MantiqError.ts

@@ -1,14 +1,25 @@
+import type { ErrorCode } from './ErrorCodes.ts'
+
 /**
  * Base error class for all MantiqJS errors.
- * All packages must throw subclasses of this — never raw Error.
+ * All packages must throw subclasses of this -- never raw Error.
  */
 export class MantiqError extends Error {
+  /**
+   * Machine-readable error code for structured error handling.
+   * Subclasses should set this to the appropriate `ErrorCodes.*` value.
+   * Accepts any string to allow packages like OAuth to use spec-defined codes.
+   */
+  public readonly errorCode: ErrorCode | string | undefined
+
   constructor(
     message: string,
     public readonly context?: Record<string, any>,
+    errorCode?: ErrorCode | string,
   ) {
     super(message)
     this.name = this.constructor.name
+    this.errorCode = errorCode
     if (Error.captureStackTrace) {
       Error.captureStackTrace(this, this.constructor)
     }

package/src/errors/NotFoundError.ts

@@ -1,7 +1,8 @@
 import { HttpError } from './HttpError.ts'
+import { ErrorCodes } from './ErrorCodes.ts'
 
 export class NotFoundError extends HttpError {
   constructor(message = 'Not Found', headers?: Record<string, string>) {
-    super(404, message, headers)
+    super(404, message, headers, undefined, ErrorCodes.ROUTE_NOT_FOUND)
   }
 }

package/src/errors/TokenMismatchError.ts

@@ -1,10 +1,11 @@
 import { HttpError } from './HttpError.ts'
+import { ErrorCodes } from './ErrorCodes.ts'
 
 /**
  * Thrown when the CSRF token is missing or invalid.
  */
 export class TokenMismatchError extends HttpError {
   constructor(message = 'CSRF token mismatch.') {
-    super(419, message)
+    super(419, message, undefined, undefined, ErrorCodes.CSRF_MISMATCH)
   }
 }

package/src/errors/TooManyRequestsError.ts

@@ -1,10 +1,11 @@
 import { HttpError } from './HttpError.ts'
+import { ErrorCodes } from './ErrorCodes.ts'
 
 export class TooManyRequestsError extends HttpError {
   constructor(
     message = 'Too Many Requests',
     public readonly retryAfter?: number,
   ) {
-    super(429, message, retryAfter ? { 'Retry-After': String(retryAfter) } : undefined)
+    super(429, message, retryAfter ? { 'Retry-After': String(retryAfter) } : undefined, undefined, ErrorCodes.RATE_LIMITED)
   }
 }

package/src/errors/UnauthorizedError.ts

@@ -1,7 +1,8 @@
 import { HttpError } from './HttpError.ts'
+import { ErrorCodes } from './ErrorCodes.ts'
 
 export class UnauthorizedError extends HttpError {
   constructor(message = 'Unauthorized', headers?: Record<string, string>) {
-    super(401, message, headers)
+    super(401, message, headers, undefined, ErrorCodes.AUTH_UNAUTHENTICATED)
   }
 }

package/src/errors/ValidationError.ts

@@ -1,10 +1,11 @@
 import { HttpError } from './HttpError.ts'
+import { ErrorCodes } from './ErrorCodes.ts'
 
 export class ValidationError extends HttpError {
   constructor(
     public readonly errors: Record<string, string[]>,
     message = 'The given data was invalid.',
   ) {
-    super(422, message, undefined, { errors })
+    super(422, message, undefined, { errors }, ErrorCodes.VALIDATION_FAILED)
   }
 }

package/src/exceptions/DevErrorPage.ts

@@ -10,6 +10,21 @@ import type { MantiqRequest } from '../contracts/Request.ts'
  * - Copy as Markdown button
  * - Source file context when available
  */
+/**
+ * Security: headers that must never appear on the debug page, even in dev mode.
+ * These can contain authentication credentials, session tokens, and CSRF secrets.
+ */
+const SENSITIVE_HEADERS = new Set([
+  'authorization',
+  'cookie',
+  'set-cookie',
+  'x-csrf-token',
+  'x-xsrf-token',
+  'proxy-authorization',
+  'x-api-key',
+  'x-auth-token',
+])
+
 export function renderDevErrorPage(request: MantiqRequest, error: unknown): string {
   const err = error instanceof Error ? error : new Error(String(error))
   const stack = err.stack ?? err.message
@@ -51,8 +66,13 @@ export function renderDevErrorPage(request: MantiqRequest, error: unknown): stri
     })
     .join('')
 
+  // Security: redact sensitive headers to prevent leaking auth tokens,
+  // cookies, and CSRF secrets — even on the dev error page.
   const headersHtml = Object.entries(request.headers())
-    .map(([k, v]) => `<tr><td class="td-key">${escapeHtml(k)}</td><td class="td-val">${escapeHtml(v)}</td></tr>`)
+    .map(([k, v]) => {
+      const redacted = SENSITIVE_HEADERS.has(k.toLowerCase()) ? '********' : v
+      return `<tr><td class="td-key">${escapeHtml(k)}</td><td class="td-val">${escapeHtml(redacted)}</td></tr>`
+    })
     .join('')
 
   const queryString = request.fullUrl().includes('?') ? request.fullUrl().split('?')[1] : ''
@@ -63,14 +83,13 @@ export function renderDevErrorPage(request: MantiqRequest, error: unknown): stri
     }).join('')
     : '<tr><td class="td-val" colspan="2" style="opacity:.5">No query parameters</td></tr>'
 
-  // Markdown for clipboard
+  // Markdown for clipboard — also redact sensitive headers
   const markdown = [
     `# ${err.name}: ${err.message}`,
     '',
     `**Status:** ${statusCode}`,
     `**Method:** ${request.method()}`,
     `**URL:** ${request.fullUrl()}`,
-    `**IP:** ${request.ip()}`,
     `**User Agent:** ${request.userAgent()}`,
     '',
     '## Stack Trace',
@@ -81,7 +100,10 @@ export function renderDevErrorPage(request: MantiqRequest, error: unknown): stri
     '## Request Headers',
     '| Header | Value |',
     '|--------|-------|',
-    ...Object.entries(request.headers()).map(([k, v]) => `| ${k} | ${v} |`),
+    ...Object.entries(request.headers()).map(([k, v]) => {
+      const redacted = SENSITIVE_HEADERS.has(k.toLowerCase()) ? '********' : v
+      return `| ${k} | ${redacted} |`
+    }),
     '',
     `*Bun ${bunVersion} — MantiqJS*`,
   ].join('\n')
@@ -454,7 +476,7 @@ export function renderDevErrorPage(request: MantiqRequest, error: unknown): stri
             <tr><td class="td-key">Method</td><td class="td-val">${escapeHtml(request.method())}</td></tr>
             <tr><td class="td-key">Path</td><td class="td-val">${escapeHtml(request.path())}</td></tr>
             <tr><td class="td-key">Full URL</td><td class="td-val">${escapeHtml(request.fullUrl())}</td></tr>
-            <tr><td class="td-key">IP Address</td><td class="td-val">${escapeHtml(request.ip())}</td></tr>
+            <!-- Security: IP address omitted to prevent leaking client addresses in shared debug output -->
             <tr><td class="td-key">User Agent</td><td class="td-val">${escapeHtml(request.userAgent())}</td></tr>
             <tr><td class="td-key">Expects JSON</td><td class="td-val">${request.expectsJson() ? 'Yes' : 'No'}</td></tr>
             <tr><td class="td-key">Authenticated</td><td class="td-val">${request.isAuthenticated() ? 'Yes' : 'No'}</td></tr>

package/src/exceptions/Handler.ts

@@ -85,6 +85,7 @@ export class DefaultExceptionHandler implements ExceptionHandler {
   ): Response {
     // API routes always get JSON — even in debug mode
     if (request.expectsJson()) {
+      // Security: in production (debug=false), never expose error details
       const body: Record<string, any> = { error: { message: 'Internal Server Error', status: 500 } }
       if (debug && err.stack) {
         body['error']['message'] = err.message

package/src/helpers/signedUrl.ts

@@ -0,0 +1,26 @@
+import { Application } from '../application/Application.ts'
+import type { AesEncrypter } from '../encryption/Encrypter.ts'
+import { UrlSigner } from '../url/UrlSigner.ts'
+import { ENCRYPTER } from './encrypt.ts'
+
+/**
+ * Create a signed URL.
+ *
+ * @example const url = await signedUrl('https://example.com/verify?user=42')
+ */
+export async function signedUrl(url: string, expiresAt?: Date): Promise<string> {
+  const encrypter = Application.getInstance().make<AesEncrypter>(ENCRYPTER)
+  const signer = new UrlSigner(encrypter)
+  return signer.sign(url, expiresAt)
+}
+
+/**
+ * Validate a signed URL.
+ *
+ * @example const valid = await hasValidSignature('https://example.com/verify?user=42&signature=...')
+ */
+export async function hasValidSignature(url: string): Promise<boolean> {
+  const encrypter = Application.getInstance().make<AesEncrypter>(ENCRYPTER)
+  const signer = new UrlSigner(encrypter)
+  return signer.validate(url)
+}

package/src/helpers/url.ts

@@ -0,0 +1,31 @@
+import { Application } from '../application/Application.ts'
+import type { AesEncrypter } from '../encryption/Encrypter.ts'
+import { UrlSigner } from '../url/UrlSigner.ts'
+import { ENCRYPTER } from './encrypt.ts'
+
+/**
+ * Create a signed URL.
+ *
+ * @example
+ * const url = await signedUrl('https://example.com/unsubscribe?user=42')
+ * const temp = await signedUrl('https://example.com/download', new Date(Date.now() + 3600_000))
+ */
+export async function signedUrl(url: string, expiresAt?: Date): Promise<string> {
+  const encrypter = Application.getInstance().make<AesEncrypter>(ENCRYPTER)
+  const signer = new UrlSigner(encrypter)
+  return signer.sign(url, expiresAt)
+}
+
+/**
+ * Validate a signed URL: verify signature and check expiration.
+ *
+ * @example
+ * if (await hasValidSignature(request.fullUrl())) {
+ *   // URL is authentic and not expired
+ * }
+ */
+export async function hasValidSignature(url: string): Promise<boolean> {
+  const encrypter = Application.getInstance().make<AesEncrypter>(ENCRYPTER)
+  const signer = new UrlSigner(encrypter)
+  return signer.validate(url)
+}