@twin.org/web 0.0.1-next.9 → 0.0.2-next.3

package/dist/types/models/IJwtPayload.d.ts

@@ -1,37 +1,6 @@
+import type { JWTPayload } from "jose";
 /**
  * The fields in a JSON Web Token payload.
  */
-export interface IJwtPayload {
-    /**
-     * Additional fields in the payload.
-     */
-    [key: string]: unknown;
-    /**
-     * The issuer of the token.
-     */
-    iss?: string;
-    /**
-     * The subject of the token.
-     */
-    sub?: string;
-    /**
-     * The audience of the token.
-     */
-    aud?: string;
-    /**
-     * The expiration time of the token.
-     */
-    exp?: number;
-    /**
-     * The not before time of the token.
-     */
-    nbf?: number;
-    /**
-     * The issued at time of the token.
-     */
-    iat?: number;
-    /**
-     * The JWT ID.
-     */
-    jti?: string;
+export interface IJwtPayload extends JWTPayload {
 }

package/dist/types/models/jwkCryptoKey.d.ts

@@ -0,0 +1,4 @@
+/**
+ * The crypto key for a JWK.
+ */
+export type JwkCryptoKey = CryptoKey | Uint8Array;

package/dist/types/models/mimeTypes.d.ts

@@ -22,6 +22,10 @@ export declare const MimeTypes: {
      * JSON-LD - application/ld+json
      */
     readonly JsonLd: "application/ld+json";
+    /**
+     * JWT - application/jwt
+     */
+    readonly Jwt: "application/jwt";
     /**
      * XML - application/xml
      */
@@ -34,6 +38,10 @@ export declare const MimeTypes: {
      * Application GZIP - application/gzip
      */
     readonly Gzip: "application/gzip";
+    /**
+     * Application deflate - application/zlib
+     */
+    readonly Zlib: "application/zlib";
     /**
      * Application BZIP2 - application/x-bzip2
      */

package/dist/types/utils/fetchHelper.d.ts

@@ -44,6 +44,13 @@ export declare class FetchHelper {
      * @returns The cache entry if it exists.
      */
     static getCacheEntry<T>(url: string): Promise<T | undefined>;
+    /**
+     * Set a cache entry.
+     * @param url The url for the request.
+     * @param value The value to cache.
+     * @returns The cache entry if it exists.
+     */
+    static setCacheEntry<T>(url: string, value: T): Promise<void>;
     /**
      * Remove a cache entry.
      * @param url The url for the request.

package/dist/types/utils/jwk.d.ts

@@ -0,0 +1,41 @@
+import type { IJwk } from "../models/IJwk";
+import type { JwkCryptoKey } from "../models/jwkCryptoKey";
+/**
+ * Class to handle JSON Web Keys.
+ */
+export declare class Jwk {
+    /**
+     * Convert the JWK to a crypto key.
+     * @param jwk The JWK to convert.
+     * @param alg The alg to be used, defaults to jwk.alg.
+     * @returns The crypto key.
+     */
+    static toCryptoKey(jwk: IJwk, alg?: string): Promise<JwkCryptoKey>;
+    /**
+     * Convert the Ed25519 private key to a crypto key.
+     * @param privateKey The private key to use.
+     * @returns The crypto key.
+     */
+    static fromEd25519Private(privateKey: Uint8Array): Promise<IJwk>;
+    /**
+     * Convert the Ed25519 public key to a crypto key.
+     * @param publicKey The private key to use.
+     * @returns The crypto key.
+     */
+    static fromEd25519Public(publicKey: Uint8Array): Promise<IJwk>;
+    /**
+     * Convert the JWK to raw keys.
+     * @param jwk The JWK to convert to raw.
+     * @returns The crypto key.
+     */
+    static toRaw(jwk: IJwk): Promise<{
+        publicKey?: Uint8Array;
+        privateKey?: Uint8Array;
+    }>;
+    /**
+     * Generate a KID for the JWK.
+     * @param jwk The JWK to generate a KID for.
+     * @returns The KID.
+     */
+    static generateKid(jwk: IJwk): Promise<string>;
+}

package/dist/types/utils/jws.d.ts

@@ -0,0 +1,22 @@
+import type { JwkCryptoKey } from "../models/jwkCryptoKey";
+/**
+ * Class to handle JSON Web Signatures.
+ */
+export declare class Jws {
+    /**
+     * Create a signature.
+     * @param privateKey The private key to use.
+     * @param hash The hash to sign.
+     * @param algOverride An optional algorithm override.
+     * @returns The signature.
+     */
+    static create(privateKey: JwkCryptoKey, hash: Uint8Array, algOverride?: string): Promise<string>;
+    /**
+     * Verify a signature.
+     * @param jws The signature to verify.
+     * @param publicKey The public key to verify the signature with.
+     * @param hash The hash to verify.
+     * @returns True if the signature was verified.
+     */
+    static verify(jws: string, publicKey: JwkCryptoKey, hash: Uint8Array): Promise<boolean>;
+}

package/dist/types/utils/jwt.d.ts

@@ -1,8 +1,8 @@
 import type { IJwtHeader } from "../models/IJwtHeader";
 import type { IJwtPayload } from "../models/IJwtPayload";
-import { JwtAlgorithms } from "../models/jwtAlgorithms";
+import type { JwkCryptoKey } from "../models/jwkCryptoKey";
 /**
- * Class to encode and decode JSON Web Tokens.
+ * Class to handle JSON Web Tokens.
  */
 export declare class Jwt {
     /**
@@ -12,7 +12,7 @@ export declare class Jwt {
      * @param key The key for signing the token, can be omitted if a signer is provided.
      * @returns The encoded token.
      */
-    static encode<U extends IJwtHeader, T extends IJwtPayload>(header: U, payload: T, key: Uint8Array): Promise<string>;
+    static encode<T extends IJwtHeader, U extends IJwtPayload>(header: T, payload: U, key: JwkCryptoKey): Promise<string>;
     /**
      * Encode a token.
      * @param header The header to encode.
@@ -20,15 +20,15 @@ export declare class Jwt {
      * @param signer Custom signer method.
      * @returns The encoded token.
      */
-    static encodeWithSigner<U extends IJwtHeader, T extends IJwtPayload>(header: U, payload: T, signer: (alg: JwtAlgorithms, key: Uint8Array | undefined, payload: Uint8Array) => Promise<Uint8Array>): Promise<string>;
+    static encodeWithSigner<T extends IJwtHeader, U extends IJwtPayload>(header: T, payload: U, signer: (header: IJwtHeader, payload: IJwtPayload, key: JwkCryptoKey | undefined) => Promise<string>): Promise<string>;
     /**
      * Decode a token.
      * @param token The token to decode.
      * @returns The decoded payload.
      */
-    static decode<U extends IJwtHeader, T extends IJwtPayload>(token: string): Promise<{
-        header?: U;
-        payload?: T;
+    static decode<T extends IJwtHeader, U extends IJwtPayload>(token: string): Promise<{
+        header?: T;
+        payload?: U;
         signature?: Uint8Array;
     }>;
     /**
@@ -37,11 +37,9 @@ export declare class Jwt {
      * @param key The key for verifying the token
      * @returns The decoded payload.
      */
-    static verify<U extends IJwtHeader, T extends IJwtPayload>(token: string, key: Uint8Array): Promise<{
-        verified: boolean;
-        header?: U;
-        payload?: T;
-        signature?: Uint8Array;
+    static verify<T extends IJwtHeader, U extends IJwtPayload>(token: string, key: JwkCryptoKey): Promise<{
+        header: T;
+        payload: U;
     }>;
     /**
      * Verify a token.
@@ -49,37 +47,77 @@ export declare class Jwt {
      * @param verifier Custom verification method.
      * @returns The decoded payload.
      */
-    static verifyWithVerifier<U extends IJwtHeader, T extends IJwtPayload>(token: string, verifier: (alg: JwtAlgorithms, key: Uint8Array | undefined, payload: Uint8Array, signature: Uint8Array) => Promise<boolean>): Promise<{
-        verified: boolean;
-        header?: U;
-        payload?: T;
-        signature?: Uint8Array;
+    static verifyWithVerifier<T extends IJwtHeader, U extends IJwtPayload>(token: string, verifier: (token: string, key: JwkCryptoKey | undefined) => Promise<{
+        header: T;
+        payload: U;
+    }>): Promise<{
+        header: T;
+        payload: U;
     }>;
     /**
      * Verify a token by parts.
-     * @param header The header to verify.
-     * @param payload The payload to verify.
-     * @param signature The signature to verify.
+     * @param token The token to verify.
      * @param key The key for verifying the token, if not provided no verification occurs.
      * @param verifier Custom verification method.
      * @returns True if the parts are verified.
      */
-    static verifySignature<U extends IJwtHeader, T extends IJwtPayload>(header?: U, payload?: T, signature?: Uint8Array, key?: Uint8Array, verifier?: (alg: JwtAlgorithms, key: Uint8Array | undefined, payload: Uint8Array, signature: Uint8Array) => Promise<boolean>): Promise<boolean>;
+    static verifySignature<T extends IJwtHeader, U extends IJwtPayload>(token: string, key?: JwkCryptoKey, verifier?: (token: string, key: JwkCryptoKey | undefined) => Promise<{
+        header: T;
+        payload: U;
+    }>): Promise<{
+        header: T;
+        payload: U;
+    }>;
     /**
      * The default signer for the JWT.
-     * @param alg The algorithm to use.
-     * @param key The key to sign with.
+     * @param header The header to sign.
      * @param payload The payload to sign.
+     * @param key The optional key to sign with.
      * @returns The signature.
      */
-    static defaultSigner(alg: JwtAlgorithms, key: Uint8Array | undefined, payload: Uint8Array): Promise<Uint8Array>;
+    static defaultSigner(header: IJwtHeader, payload: IJwtPayload, key: JwkCryptoKey | undefined): Promise<string>;
     /**
      * The default verifier for the JWT.
-     * @param alg The algorithm to use.
+     * @param token The token to verify.
      * @param key The key to verify with.
-     * @param payload The payload to verify.
-     * @param signature The signature to verify.
-     * @returns True if the signature was verified.
+     * @returns The header and payload if verification successful.
+     */
+    static defaultVerifier<T extends IJwtHeader, U extends IJwtPayload>(token: string, key: JwkCryptoKey | undefined): Promise<{
+        header: T;
+        payload: U;
+    }>;
+    /**
+     * Create bytes for signing from header and payload.
+     * @param header The header.
+     * @param payload The payload.
+     * @returns The bytes to sign.
+     */
+    static toSigningBytes<T extends IJwtHeader, U extends IJwtPayload>(header: T, payload: U): Uint8Array;
+    /**
+     * Create header and payload from signing bytes.
+     * @param signingBytes The signing bytes from a token.
+     * @returns The header and payload.
+     * @throws If the signing bytes are invalid
+     */
+    static fromSigningBytes<T extends IJwtHeader, U extends IJwtPayload>(signingBytes: Uint8Array): {
+        header: T;
+        payload: U;
+    };
+    /**
+     * Convert signed bytes and signature bytes to token.
+     * @param signingBytes The signed bytes.
+     * @param signature The signature.
+     * @returns The token.
+     */
+    static tokenFromBytes(signingBytes: Uint8Array, signature: Uint8Array): string;
+    /**
+     * Convert the token to signing bytes and signature bytes.
+     * @param token The token to convert to bytes.
+     * @returns The decoded bytes.
+     * @throws If the token is invalid.
      */
-    static defaultVerifier(alg: JwtAlgorithms, key: Uint8Array | undefined, payload: Uint8Array, signature: Uint8Array): Promise<boolean>;
+    static tokenToBytes(token: string): {
+        signingBytes: Uint8Array;
+        signature: Uint8Array;
+    };
 }