refactor: move all accessories to root (#177)

* refactor: move all accessories to root

* fix issues

cheetah.ts

@@ -65,7 +65,7 @@ export type AppConfig = {
 
  oauth?: {
  store: OAuthStore
- cookie?: Parameters<ResponseContext['cookie']>[2]
+ cookie?: Parameters<ResponseContext['setCookie']>[2]
  onSignIn?: (
  c: Context,
  data: OAuthSessionData,
@@ -82,6 +82,16 @@ export type AppConfig = {
  * @since v1.3
  */
  debug?: boolean
+
+ /**
+ * Desc
+ *
+ * @since v1.4
+ */
+ versioning?: {
+ highest: 'v4'
+ lowest: `v${string}`
+ }
 }
 
 export class cheetah extends base<cheetah>() {

jwt.ts

@@ -0,0 +1,92 @@
+// Copyright 2023 Samuel Kopp. All rights reserved. Apache-2.0 license.
+import {
+ decode,
+ encode,
+} from 'https://deno.land/std@0.198.0/encoding/base64.ts'
+import {
+ create,
+ getNumericDate,
+ Payload as JwtPayload,
+ verify as _verify,
+ VerifyOptions,
+} from 'https://deno.land/x/djwt@v2.8/mod.ts'
+
+interface Payload {
+ iss?: string
+ sub?: string
+ aud?: string[] | string
+ /**
+ * A `Date` object or a `number` (in seconds) when the JWT will expire.
+ */
+ exp?: Date | number
+ /**
+ * A `Date` object or a `number` (in seconds) until which the JWT will be invalid.
+ */
+ nbf?: Date | number
+ iat?: number
+ jti?: string
+ [key: string]: unknown
+}
+
+export async function createKey() {
+ const key = await crypto.subtle.generateKey(
+ { name: 'HMAC', hash: 'SHA-512' },
+ true,
+ ['sign', 'verify'],
+ )
+
+ const exportedKey = await crypto.subtle.exportKey('raw', key)
+
+ return encode(exportedKey)
+}
+
+export function importKey(key: string) {
+ return crypto.subtle.importKey(
+ 'raw',
+ decode(key).buffer,
+ { name: 'HMAC', hash: 'SHA-512' },
+ true,
+ ['sign', 'verify'],
+ )
+}
+
+/**
+ * Sign a payload.
+ */
+// deno-lint-ignore ban-types
+export async function sign<T extends Record<string, unknown> = {}>(
+ payload: T & Payload,
+ secret: string | CryptoKey,
+) {
+ const key = typeof secret === 'string' ? await importKey(secret) : secret
+
+ const { exp, nbf, ...rest } = payload
+
+ return await create({ alg: 'HS512', typ: 'JWT' }, {
+ ...(exp && { exp: getNumericDate(exp) }),
+ ...(nbf && { nbf: getNumericDate(nbf) }),
+ ...rest,
+ }, key)
+}
+
+/**
+ * Verify the validity of a JWT.
+ */
+export async function verify<T extends Record<string, unknown> = Payload>(
+ token: string,
+ secret: string | CryptoKey,
+ options?: VerifyOptions,
+) {
+ try {
+ const key = typeof secret === 'string' ? await importKey(secret) : secret
+
+ return await _verify(token, key, options) as JwtPayload & T
+ } catch (_err) {
+ return
+ }
+}
+
+export default {
+ sign,
+ verify,
+}

location_data.ts

@@ -0,0 +1,146 @@
+// Copyright 2023 Samuel Kopp. All rights reserved. Apache-2.0 license.
+import { IncomingRequestCfProperties } from 'https://cdn.jsdelivr.net/npm/@cloudflare/workers-types@4.20230814.0/index.ts'
+import { Context } from './context.ts'
+
+type CloudflareRequest = Request & {
+ cf: IncomingRequestCfProperties
+}
+
+/**
+ * Inspect the geolocation data of the incoming request.
+ *
+ * You must either deploy your app to [Cloudflare Workers](https://developers.cloudflare.com/workers/runtime-apis/request/#incomingrequestcfproperties) or use [Cloudflare as a proxy](https://developers.cloudflare.com/support/network/configuring-ip-geolocation/) to use the `LocationData` API.
+ */
+export class LocationData {
+ #c: Context
+
+ constructor(c: Context) {
+ this.#c = c
+ }
+
+ /**
+ * The city the request originated from.
+ *
+ * @example 'Austin'
+ */
+ get city() {
+ const city = (this.#c.req.raw as CloudflareRequest).cf?.city
+
+ if (!city && this.#c.__app.proxy === 'cloudflare') {
+ return this.#c.req.headers['cf-ipcity']
+ }
+
+ return city
+ }
+
+ /**
+ * If known, the ISO 3166-2 name for the first level region associated with the IP address of the incoming request.
+ *
+ * @example 'Texas'
+ */
+ get region() {
+ return (this.#c.req.raw as CloudflareRequest).cf?.region
+ }
+
+ /**
+ * The [ISO 3166-1 Alpha 2](https://www.iso.org/iso-3166-country-codes.html) country code the request originated from.
+ *
+ * If you're using CLoudflare Workers and your worker is [configured to accept TOR connections](https://support.cloudflare.com/hc/en-us/articles/203306930-Understanding-Cloudflare-Tor-support-and-Onion-Routing), this may also be `T1`, indicating a request that originated over TOR.
+ *
+ * If Cloudflare is unable to determine where the request originated this property is omitted.
+ *
+ * @example 'GB'
+ */
+ get country(): IncomingRequestCfProperties['country'] {
+ const country = (this.#c.req.raw as CloudflareRequest).cf?.country
+
+ if (!country && this.#c.__app.proxy === 'cloudflare') {
+ return this.#c.req
+ .headers['cf-ipcountry'] as IncomingRequestCfProperties['country']
+ }
+
+ return country
+ }
+
+ /**
+ * A two-letter code indicating the continent the request originated from.
+ *
+ * @example 'NA'
+ */
+ get continent(): IncomingRequestCfProperties['continent'] {
+ const continent = (this.#c.req.raw as CloudflareRequest).cf?.continent
+
+ if (!continent && this.#c.__app.proxy === 'cloudflare') {
+ return this.#c.req
+ .headers['cf-ipcontinent'] as IncomingRequestCfProperties['continent']
+ }
+
+ return continent
+ }
+
+ /**
+ * If known, the ISO 3166-2 code for the first-level region associated with the IP address of the incoming request.
+ *
+ * @example 'TX'
+ */
+ get regionCode(): IncomingRequestCfProperties['regionCode'] {
+ return (this.#c.req.raw as CloudflareRequest).cf?.regionCode
+ }
+
+ /**
+ * Latitude of the incoming request.
+ *
+ * @example '30.27130'
+ */
+ get latitude(): IncomingRequestCfProperties['latitude'] {
+ const latitude = (this.#c.req.raw as CloudflareRequest).cf?.latitude
+
+ if (!latitude && this.#c.__app.proxy === 'cloudflare') {
+ return this.#c.req.headers['cf-iplatitude']
+ }
+
+ return latitude
+ }
+
+ /**
+ * Longitude of the incoming request.
+ *
+ * @example '-97.74260'
+ */
+ get longitude(): IncomingRequestCfProperties['longitude'] {
+ const longitude = (this.#c.req.raw as CloudflareRequest).cf?.longitude
+
+ if (!longitude && this.#c.__app.proxy === 'cloudflare') {
+ return this.#c.req.headers['cf-iplongitude']
+ }
+
+ return longitude
+ }
+
+ /**
+ * Postal code of the incoming request.
+ *
+ * @example '78701'
+ */
+ get postalCode(): IncomingRequestCfProperties['postalCode'] {
+ return (this.#c.req.raw as CloudflareRequest).cf?.postalCode
+ }
+
+ /**
+ * Timezone of the incoming request.
+ *
+ * @example 'America/Chicago'
+ */
+ get timezone(): IncomingRequestCfProperties['timezone'] {
+ return (this.#c.req.raw as CloudflareRequest).cf?.timezone
+ }
+
+ /**
+ * The three-letter [IATA](https://en.wikipedia.org/wiki/IATA_airport_code) airport code of the data center that the request hit.
+ *
+ * @example 'DFW'
+ */
+ get datacenter(): IncomingRequestCfProperties['colo'] {
+ return (this.#c.req.raw as CloudflareRequest).cf?.colo
+ }
+}

mod.ts

@@ -6,56 +6,66 @@ export { Context } from './context.ts'
 export { Exception } from './exception.ts'
 export { createExtension } from './extensions.ts'
 export type { Extension } from './extensions.ts'
+export { default as jwt } from './jwt.ts'
+export { LocationData } from './location_data.ts'
+export { otp } from './otp.ts'
+export { sendMail } from './send_mail.ts'
+export { Store } from './store.ts'
 
 /* crypto ------------------------------------------------------------------- */
 
 import { decode } from 'https://deno.land/std@0.198.0/encoding/base64.ts'
+import { Context } from './context.ts'
 
-export async function encrypt(key: string, message: string) {
- const iv = crypto.getRandomValues(new Uint8Array(12)),
- ivStr = Array.from(iv)
- .map((byte) => String.fromCharCode(byte))
- .join(''),
- alg = { name: 'AES-GCM', iv },
- cryptoKey = await crypto.subtle.importKey(
- 'raw',
- decode(key).buffer,
- alg,
- true,
- ['encrypt', 'decrypt'],
- ),
- cipherBuf = await crypto.subtle.encrypt(
- alg,
- cryptoKey,
- new TextEncoder().encode(message),
- ),
- cipherArr = Array.from(new Uint8Array(cipherBuf)),
- cipherStr = cipherArr.map((byte) => String.fromCharCode(byte))
- .join('')
+export async function encrypt(c: Context, message: string) {
+ const key = (c.env('crypto_key') ?? c.env('CRYPTO_KEY')) as string
+
+ const iv = crypto.getRandomValues(new Uint8Array(12))
+ const ivStr = Array.from(iv)
+ .map((byte) => String.fromCharCode(byte))
+ .join('')
+ const alg = { name: 'AES-GCM', iv }
+ const cryptoKey = await crypto.subtle.importKey(
+ 'raw',
+ decode(key).buffer,
+ alg,
+ true,
+ ['encrypt', 'decrypt'],
+ )
+ const cipherBuf = await crypto.subtle.encrypt(
+ alg,
+ cryptoKey,
+ new TextEncoder().encode(message),
+ )
+ const cipherArr = Array.from(new Uint8Array(cipherBuf))
+ const cipherStr = cipherArr.map((byte) => String.fromCharCode(byte))
+ .join('')
 
  return btoa(ivStr + cipherStr)
 }
 
-export async function decrypt(key: string, message: string) {
- const iv = atob(message).slice(0, 12),
- alg = {
- name: 'AES-GCM',
- iv: new Uint8Array(
- Array.from(iv).map((char) => char.charCodeAt(0)),
- ),
- },
- cryptoKey = await crypto.subtle.importKey(
- 'raw',
- decode(key).buffer,
- alg,
- true,
- ['encrypt', 'decrypt'],
- ),
- cipherStr = atob(message).slice(12),
- cipherBuf = new Uint8Array(
- Array.from(cipherStr).map((char) => char.charCodeAt(0)),
+export async function decrypt(c: Context, message: string) {
+ const key = (c.env('crypto_key') ?? c.env('CRYPTO_KEY')) as string
+
+ const iv = atob(message).slice(0, 12)
+ const alg = {
+ name: 'AES-GCM',
+ iv: new Uint8Array(
+ Array.from(iv).map((char) => char.charCodeAt(0)),
  ),
- buf = await crypto.subtle.decrypt(alg, cryptoKey, cipherBuf)
+ }
+ const cryptoKey = await crypto.subtle.importKey(
+ 'raw',
+ decode(key).buffer,
+ alg,
+ true,
+ ['encrypt', 'decrypt'],
+ )
+ const cipherStr = atob(message).slice(12)
+ const cipherBuf = new Uint8Array(
+ Array.from(cipherStr).map((char) => char.charCodeAt(0)),
+ )
+ const buf = await crypto.subtle.decrypt(alg, cryptoKey, cipherBuf)
 
  return new TextDecoder().decode(buf)
 }