miqro 7.0.1 → 7.0.3

package/src/common/jsx.ts

@@ -0,0 +1,562 @@
+import { Runtime } from "@miqro/jsx";
+import { createNodeRuntime } from "@miqro/jsx-node";
+import { basename, dirname, extname, relative, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+import { Request, Response, CORSOptions, Logger, APIRoute } from "@miqro/core";
+import { Parser, Schema } from "@miqro/parser";
+import { APIRouteSchema, SessionHandlerOptionsSchema } from "@miqro/core";
+import { cwd } from "node:process";
+
+import { esBuild } from "./esbuild.js";
+// import { assertGlobalTampered, browserJSXGlobals } from "../services/globals.js";
+import { APIOptions, ServerConfig, WSConfig, AuthConfig, DBConfig, LogConfig, MiddlewareConfig, ErrorConfig, DocConfig } from "../types.js";
+import { JSX_TMP_DIR } from "./paths.js";
+import { CLEAR_JSX_CACHE } from "./constants.js";
+import { getAsset, initAsset, validateAsset } from "./assets.js";
+import { calculateChecksumFromBuffer } from "./checksum.js";
+import { HandlerWithOptionsSchema, RouteOptionsSchema } from "@miqro/core/build/types.js";
+import { Migration } from "@miqro/query";
+import { mkdirASync, rmdirASync, unlinkASync, writeFileASync } from "./fs.js";
+
+let jsxJSBuffer: null | Buffer = null; // Buffer.from(getAsset("jsx.dom.js"));
+let jsxJSBufferChecksumPromise: null | Promise<string> = null; // calculateChecksumFromBuffer(jsxJSBuffer);
+
+/*export async function initJSXJS(logger: Logger) {
+  jsxJSBuffer = jsxJSBuffer ? jsxJSBuffer : Buffer.from(getAsset("jsx.dom.js"));
+  jsxJSBufferChecksumPromise = jsxJSBufferChecksumPromise ? jsxJSBufferChecksumPromise : calculateChecksumFromBuffer(jsxJSBuffer);
+  return initAsset(logger, getJSXJSPath(), jsxJSBuffer, true, jsxJSBufferChecksumPromise, false);
+}
+
+export async function validateJSXJS(logger: Logger) {
+  const checksum = await jsxJSBufferChecksumPromise;
+  if (!checksum) {
+    throw new Error("error calculating checksum");
+  }
+  return validateAsset(logger, getJSXJSPath(), checksum);
+}*/
+
+export interface Dict<T> {
+  [key: string]: T | Dict<T>;
+}
+
+const parser = new Parser();
+
+export interface InflateError {
+  filePath: string;
+  error: Error;
+}
+
+export interface InflateOptions {
+  // embemedJSX: boolean;
+  minify: boolean;
+  useExport: boolean;
+  platform?: string;
+  mainFields?: string;
+  external?: string[];
+  logger?: Logger | Console;
+}
+
+const DEFAULT_ESOPTION = {
+  platform: "neutral",
+  mainFields: "module,main",
+  // platform: "node",
+  bundle: true,
+  jsxFactory: "JSX.createElement",
+  jsxFragment: "JSX.Fragment"
+};
+
+function JSXTemplate(inFile: string/*, jsxPath: string | false = false*/, useExport = true): string {
+  // const PRE = ``;
+  // return `${jsxPath ? PRE : ""}\n${useExport ? `export * from "${inFile}";import * as lib from "${inFile}";export default lib.default;` : `import * as lib from "${inFile}"`}`;
+  return `${useExport ? `export * from "${inFile}";import * as lib from "${inFile}";export default lib.default;` : `import * as lib from "${inFile}"`}`;
+}
+
+export async function inflateJSX(inFile: string, options: InflateOptions): Promise<string> {
+  const tmpBuildDir = resolve(JSX_TMP_DIR, String(process.pid), "build", Date.now() + "-" + randomUUID());
+  const inFileTmp = resolve(tmpBuildDir, basename(inFile) + ".mjs");
+  //const jsxJSPath = getJSXJSPath();//resolve(tmpBuildDir, "jsx.js");
+  const logger = options.logger; //getLogger(`${SERVER_IDENTIFIER}_JSX`);
+
+  try {
+
+    // if (!options.embemedJSX) {
+    await mkdirASync(tmpBuildDir, {
+      recursive: true
+    });
+    await writeFileASync(inFileTmp, JSXTemplate(inFile/*, false*/, options.useExport));
+    //await writeFileASync(inFileTmp, browserJSXGlobals(relative(tmpBuildDir, inFile), false));
+    logger?.trace("inflating [%s] from [%s]. to change the import folder set JSX_TMP", relative(cwd(), inFile), dirname(relative(JSX_TMP_DIR, inFileTmp)));
+    const { outputFiles: [{ contents }] } = await esBuild({
+      ...DEFAULT_ESOPTION,
+      entryPoints: [inFileTmp],
+      minify: options.minify,
+      platform: options.platform !== undefined ? options.platform : DEFAULT_ESOPTION.platform,
+      mainFields: options.mainFields !== undefined ? options.mainFields : DEFAULT_ESOPTION.mainFields,
+      external: options.external ? options.external : undefined,
+    });
+    if (CLEAR_JSX_CACHE) {
+      logger?.trace("clearing cache at [%s] to change this behaivor set CLEAR_JSX_CACHE to 0", tmpBuildDir);
+      await unlinkASync(inFileTmp);
+      await rmdirASync(tmpBuildDir);
+    }
+    return contents;
+    /*} else {
+      await mkdirASync(tmpBuildDir, {
+        recursive: true
+      });
+      //await writeFileASync(jsxJSPath, Buffer.from(getAsset("jsx-dom-bundle")));
+      await writeFileASync(inFileTmp, browserJSXGlobals(inFile, false));
+      //await writeFileASync(inFileTmp, browserJSXGlobals(relative(tmpBuildDir, inFile), relative(tmpBuildDir, jsxJSPath)));
+      logger?.trace("inflating [%s] from [%s] with jsx.js embedded. to change the import folder set JSX_TMP", relative(cwd(), inFile), dirname(relative(JSX_TMP_DIR, inFileTmp)));
+      const { outputFiles: [{ contents }] } = await esBuild({
+        ...DEFAULT_ESOPTION,
+        entryPoints: [inFileTmp],
+        minify: options.minify,
+        platform: options.platform !== undefined ? options.platform : DEFAULT_ESOPTION.platform,
+        mainFields: options.mainFields !== undefined ? options.mainFields : DEFAULT_ESOPTION.mainFields,
+        external: options.external ? options.external : undefined
+      });
+      if (CLEAR_JSX_CACHE) {
+        logger?.trace("clearing cache at [%s] to change this behaivor set CLEAR_JSX_CACHE to 0", tmpBuildDir);
+        await unlinkASync(inFileTmp);
+        //await unlinkASync(jsxJSPath);
+        await rmdirASync(tmpBuildDir);
+      }
+      return contents;
+    }*/
+  } catch (e) {
+    logger?.error("error with: " + inFile);
+    logger?.error(e);
+    /*if (options.embemedJSX) {
+      if (CLEAR_JSX_CACHE) {
+        logger?.trace("clearing cache at [%s] to change this behaivor set CLEAR_JSX_CACHE to 0", tmpBuildDir);
+        await unlinkASync(inFileTmp);
+        //await unlinkASync(jsxJSPath);
+        await rmdirASync(tmpBuildDir);
+      } else {
+        //console.error("errors on: " + tmpBuildDir);
+        logger?.error("error with: %s", inFileTmp);
+        logger?.trace("NOT clearing cache. to change this behaivor set CLEAR_JSX_CACHE to 1", tmpBuildDir);
+      }
+    }*/
+    throw e;
+  }
+}
+
+export const APIOptionsSchema: Schema<APIOptions> = {
+  type: "object?",
+  properties: {
+    basePath: "string?",
+    path: "string?|string[]?",
+    method: "string?|string[]?",
+    parser: {
+      type: "object?",
+      properties: {
+        parse: "function"
+      },
+      mode: "add_extra"
+    },
+    middleware: "function[]!?",
+    session: {
+      type: "object?|function?",
+      properties: SessionHandlerOptionsSchema.properties
+    },
+    ...RouteOptionsSchema.properties
+  },
+  //mode:"add_extra"
+};
+
+export interface HTMLModule {
+  default: JSX.Element | ((req: Request | null, res: Response | null) => (Promise<JSX.Element> | JSX.Element));
+  apiOptions?: APIOptions;
+}
+
+export const HTMLModuleSchema: Schema<HTMLModule> = {
+  type: "object",
+  properties: {
+    default: {
+      type: "function|object"
+    },
+    apiOptions: APIOptionsSchema
+  },
+  //mode:"add_extra"
+}
+
+export type JSONModuleValue = string | object;
+
+export interface JSONModule {
+  default: JSONModuleValue | ((req: Request | null, res: Response | null) => (Promise<JSONModuleValue> | JSONModuleValue));
+  apiOptions?: APIOptions;
+}
+
+export const JSONModuleSchema: Schema<JSONModule> = {
+  type: "object",
+  properties: {
+    default: {
+      type: "function|object|string"
+    },
+    apiOptions: APIOptionsSchema
+  },
+  //mode:"add_extra"
+}
+
+export const MigrationSchema: Schema<Migration> = {
+  type: "object",
+  properties: {
+    up: "function",
+    down: "function"
+  },
+  mode: "add_extra"
+}
+
+export const CORSOptionsSchema: Schema<CORSOptions> = {
+  type: "object",
+  properties: {
+    origins: "string[]?|string?",
+    validate: "function?",
+    methods: "string?",
+    preflightContinue: "boolean?"
+  },
+  //mode:"add_extra"
+}
+
+export const WSConfigSchema: Schema<WSConfig> = {
+  type: "object",
+  properties: {
+    path: "string",
+    disabled: "boolean?",
+    maxConnections: "number?",
+    validate: "function?",
+    onConnection: "function?",
+    onMessage: "function?",
+    onDisconnect: "function?"
+  },
+  //mode:"add_extra"
+};
+
+export const DBConfigSchema: Schema<DBConfig> = {
+  type: "object",
+  properties: {
+    url: "string?",
+    disabled: "boolean?",
+    storage: "string?",
+    dialect: "string?",
+    name: "string"
+  },
+  //mode:"add_extra"
+}
+
+export const ServerConfigSchema: Schema<ServerConfig> = {
+  type: "object",
+  properties: {
+    preload: "function?",
+    unload: "function?",
+    stop: "function?",
+    start: "function?",
+    load: "function?"
+  },
+  //mode:"add_extra"
+};
+
+export const LogConfigSchema: Schema<LogConfig> = {
+  type: "object",
+  properties: {
+    level: {
+      type: "enum?",
+      enumValues: ["error", "warn", "info", "debug", "trace", "none"]
+    },
+    replaceConsoleTransport: "boolean?",
+    replaceFileTransport: "boolean?",
+    write: "function"
+  },
+  //mode:"add_extra"
+};
+
+export const AuthConfigSchema: Schema<AuthConfig> = {
+  type: "object",
+  properties: {
+    ...SessionHandlerOptionsSchema.properties
+  },
+  //mode:"add_extra"
+}
+
+export const MiddlewareConfigSchema: Schema<MiddlewareConfig> = {
+  type: "object",
+  properties: {
+    middleware: {
+      type: "Array",
+      arrayType: "function|object",
+      required: false,
+      properties: {
+        ...HandlerWithOptionsSchema.properties
+      }
+    },
+    post: {
+      type: "Array",
+      arrayType: "function|object",
+      required: false,
+      properties: {
+        ...HandlerWithOptionsSchema.properties
+      }
+    }
+  },
+}
+
+export const ErrorConfigSchema: Schema<ErrorConfig> = {
+  type: "object",
+  properties: {
+    catch: {
+      type: "Array",
+      required: false,
+      arrayType: "function"
+    }
+  },
+}
+
+export const DocConfigSchema: Schema<DocConfig> = {
+  type: "object",
+  properties: {
+    publish: {
+      type: "dict?",
+      dictType: "object",
+      properties: {
+        type: {
+          type: "enum?",
+          enumValues: ["HTML", "MD", "JSON"]
+        },
+        all: "boolean?"
+      }
+    }
+  }
+}
+
+export async function importAPIRoute(inFile: string, logger?: Logger) {
+  const isCJS = extname(inFile) === ".cjs";
+  const mod = isCJS ? (await importJSXFile(inFile, logger)).default.default : (await importJSXFile(inFile, logger)).default;
+  const module = typeof mod === "function" ? { handler: mod } : parser.parse(mod, APIRouteSchema, basename(inFile));
+  if (module !== undefined) {
+    return module as APIRoute;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importMigrationModule(inFile: string, logger?: Logger) {
+  const isCJS = extname(inFile) === ".cjs";
+  const mod = isCJS ? (await importJSXFile(inFile, logger)).default.default : (await importJSXFile(inFile, logger)).default;
+  const module = parser.parse(mod, MigrationSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importHTMLModule(inFile: string, logger?: Logger) {
+  const module = (await importJSXFile(inFile, logger));
+  parser.parse(module.default, HTMLModuleSchema.properties.default, `${basename(inFile)}.default`);
+  parser.parse(module.apiOptions, APIOptionsSchema, `${basename(inFile)}.apiOptions`);
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importJSONModule(inFile: string, logger?: Logger) {
+  const module = (await importJSXFile(inFile, logger));
+  parser.parse(module.default, JSONModuleSchema.properties.default, `${basename(inFile)}.default`);
+  parser.parse(module.apiOptions, APIOptionsSchema, `${basename(inFile)}.apiOptions`);
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importAuthModule(inFile: string, logger?: Logger) {
+  const isCJS = extname(inFile) === ".cjs";
+  const mod = isCJS ? (await importJSXFile(inFile, logger)).default.default : (await importJSXFile(inFile, logger)).default;
+
+  const module = parser.parse(mod, AuthConfigSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importMiddlewareConfigModule(inFile: string, logger?: Logger) {
+  const isCJS = extname(inFile) === ".cjs";
+  const mod = isCJS ? (await importJSXFile(inFile, logger)).default.default : (await importJSXFile(inFile, logger)).default;
+
+  const module = parser.parse(mod, MiddlewareConfigSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importErrorConfigModule(inFile: string, logger?: Logger) {
+  const isCJS = extname(inFile) === ".cjs";
+  const mod = isCJS ? (await importJSXFile(inFile, logger)).default.default : (await importJSXFile(inFile, logger)).default;
+
+  const module = parser.parse(mod, ErrorConfigSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importDocConfigModule(inFile: string, logger?: Logger) {
+  const isCJS = extname(inFile) === ".cjs";
+  const mod = isCJS ? (await importJSXFile(inFile, logger)).default.default : (await importJSXFile(inFile, logger)).default;
+
+  const module = parser.parse(mod, DocConfigSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importConfigConfigModule(inFile: string, logger?: Logger) {
+  const isCJS = extname(inFile) === ".cjs";
+  const mod = isCJS ? (await importJSXFile(inFile, logger)).default.default : (await importJSXFile(inFile, logger)).default;
+
+  const module = parser.parse(mod, MiddlewareConfigSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importCORSModule(inFile: string, logger?: Logger) {
+  const isCJS = extname(inFile) === ".cjs";
+  const mod = isCJS ? (await importJSXFile(inFile, logger)).default.default : (await importJSXFile(inFile, logger)).default;
+
+  const module = parser.parse(mod, CORSOptionsSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importWSConfigModule(inFile: string, logger?: Logger) {
+  const isCJS = extname(inFile) === ".cjs";
+  const mod = isCJS ? (await importJSXFile(inFile, logger)).default.default : (await importJSXFile(inFile, logger)).default;
+
+  const module = parser.parse(mod, WSConfigSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importDBConfigModule(inFile: string, logger?: Logger) {
+  const isCJS = extname(inFile) === ".cjs";
+  const mod = isCJS ? (await importJSXFile(inFile, logger)).default.default : (await importJSXFile(inFile, logger)).default;
+
+  const module = parser.parse(mod, DBConfigSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importLogConfigModule(inFile: string, logger?: Logger) {
+  const module = parser.parse((await importJSXFile(inFile, logger)).default, LogConfigSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importServerConfigModule(inFile: string, logger?: Logger) {
+  const isCJS = extname(inFile) === ".cjs";
+  const mod = isCJS ? (await importJSXFile(inFile, logger)).default.default : (await importJSXFile(inFile, logger)).default;
+
+  const module = parser.parse(mod, ServerConfigSchema, basename(inFile));
+  if (module !== undefined) {
+    return module;
+  } else {
+    throw new Error(`error with module [${inFile}] undefined`);
+  }
+}
+
+export async function importJSXFile(inFile: string, logger?: Logger | Console): Promise<any> {
+  const inflatedCode = await inflateJSX(inFile, {
+    // embemedJSX: false,
+    minify: false,
+    useExport: true,
+    platform: "node",
+    logger
+  });
+  const tmpBuildDir = resolve(JSX_TMP_DIR, String(process.pid), "import", Date.now() + "-" + randomUUID());
+  // const inFileTmp = resolve(tmpBuildDir, basename(inFile) + ".mjs");
+  const inFileTmp = resolve(tmpBuildDir, basename(inFile) + ".cjs");
+  //const logger = getLogger(`${SERVER_IDENTIFIER}_JSX`);
+  await mkdirASync(tmpBuildDir, {
+    recursive: true
+  });
+  try {
+    await writeFileASync(inFileTmp, inflatedCode);
+    // assertGlobalTampered();
+    logger?.trace("importing [%s] from [%s]. to change the import folder set JSX_TMP", relative(cwd(), inFile), dirname(relative(JSX_TMP_DIR, inFileTmp)));
+    logger?.debug("importing [%s]", relative(cwd(), inFile));
+    const module = await import(resolve(inFileTmp));
+    // console.dir(module);
+    // assertGlobalTampered();
+    if (CLEAR_JSX_CACHE) {
+      logger?.trace("clearing cache at [%s]. to change this behaivor set CLEAR_JSX_CACHE to 0", tmpBuildDir);
+      await unlinkASync(inFileTmp);
+      await rmdirASync(tmpBuildDir);
+    }
+    return module.default;
+  } catch (e) {
+    logger?.error(e);
+    logger?.error("error with2: " + inFile);
+    if (CLEAR_JSX_CACHE) {
+      logger?.trace("clearing cache at [%s] to change this behaivor set CLEAR_JSX_CACHE to 0", tmpBuildDir);
+      await unlinkASync(inFileTmp);
+      await rmdirASync(tmpBuildDir);
+    } else {
+      //console.error("errors on: " + tmpBuildDir);
+      logger?.error("error with: %s", inFileTmp);
+      logger?.trace("NOT clearing cache. to change this behaivor set CLEAR_JSX_CACHE to 1", tmpBuildDir);
+    }
+    throw e;
+  }
+}
+
+export function jsx2HTML(out: JSX.Element, runtime?: Runtime): string {
+  runtime = runtime ? runtime : createNodeRuntime();
+  const element = runtime.createElement("root");
+  const container = runtime.createContainer(element, {
+    shadowInit: false, runtimeOptions: {
+      disableEffects: true,
+      disableEvents: true,
+      disableRefListener: true,
+      disableRefresh: true
+    }
+  });
+  container.render(out);
+  //console.log("jsx2HTML [%s]", element);
+  let HTML = "";
+  for (let i = 0; i < element.childNodes.length; i++) {
+    const child = element.childNodes[i];
+    //console.log("jsx2HTML child [%s]", child);
+    //console.log("jsx2HTML child [%s]", (child as any).toString("  ", -1));
+    HTML += (child as any).toString("  ", -1);
+  }
+  container.disconnect();
+  //console.log("jsx2HTML [%s]", HTML);
+  return HTML;
+}

package/src/common/jwt.ts

@@ -0,0 +1,85 @@
+import { EncryptJWT, EncryptOptions, JWTDecryptOptions, JWTDecryptResult, JWTPayload, JWTVerifyOptions, JWTVerifyResult, ProtectedHeaderParameters, SignJWT, SignOptions, decodeJwt, decodeProtectedHeader, jwtDecrypt as joseJWTDecrypt, jwtVerify } from "jose";
+import { KeyObject } from "node:crypto";
+import { EncryptJWTOptions, JWTSignOptions } from "../types.js";
+
+/**
+ * creates a JWT encrypted token with jose
+ * 
+ * @param payload the payload to encrypt
+ * @param secret the secret example. const secret = createSecretKey(process.env.JWT_SECRET, 'utf-8');
+ * @param options options like expiratation date, issuer and audience
+ * @returns 
+ */
+export async function encryptJWT(payload: JWTPayload, secret: KeyObject, options?: Partial<EncryptJWTOptions>): Promise<string> {
+  const en = new EncryptJWT(payload)
+    .setProtectedHeader({
+      alg: options?.alg ? options?.alg : 'dir',
+      enc: options?.enc ? options?.enc : 'A128CBC-HS256'
+    })
+    .setIssuedAt(options?.iat)
+    .setIssuer(options?.iss ? options?.iss : 'urn:example:issuer')
+    .setAudience(options?.aud ? options?.aud : 'urn:example:audience')
+    .setExpirationTime(options?.exp ? options?.exp : '2h');
+
+  return await en.encrypt(secret, options?.options);
+}
+
+/**
+ * decrypts a JWT token with jose
+ * @param jwt the JWT token
+ * @param secret the secret example. const secret = createSecretKey(process.env.JWT_SECRET, 'utf-8');
+ * @param options options like issuer and audience
+ * @returns 
+ */
+export async function decryptJWT<PayloadType = JWTPayload>(jwt: string, secret: KeyObject, options?: Partial<JWTDecryptOptions>): Promise<JWTDecryptResult<PayloadType>> {
+  return await joseJWTDecrypt(jwt, secret, options)
+}
+
+/**
+ * verify a JWT token with jose
+ * @param jwt the JWT token
+ * @param secret the secret example. const secret = createSecretKey(process.env.JWT_SECRET, 'utf-8');
+ * @param options options like issuer and audience
+ * @returns 
+ */
+export async function verifyJWT<PayloadType = JWTPayload>(jwt: string, secret: KeyObject, options?: Partial<JWTVerifyOptions>): Promise<JWTVerifyResult<PayloadType>> {
+  return await jwtVerify(jwt, secret, options)
+}
+
+/**
+ * creates a signed JWT with jose
+ * 
+ * @param payload the payload to encrypt
+ * @param secret the secret example. const secret = createSecretKey(process.env.JWT_SECRET, 'utf-8');
+ * @param options options like expiratation date, issuer and audience
+ * @returns 
+ */
+export async function signJWT(payload: JWTPayload, secret: KeyObject, options?: Partial<JWTSignOptions>): Promise<string> {
+  const sign = new SignJWT(payload)
+    .setProtectedHeader({
+      alg: options?.alg ? options?.alg : 'HS256',
+    })
+    .setIssuedAt(options?.iat)
+    .setIssuer(options?.iss ? options?.iss : 'urn:example:issuer')
+    .setAudience(options?.aud ? options?.aud : 'urn:example:audience')
+    .setExpirationTime(options?.exp ? options?.exp : '2h');
+  return sign.sign(secret, options?.options);
+}
+
+/**
+ * decodes a protected header with jose
+ * @param token 
+ * @returns 
+ */
+export function decodeProtectedHeaderJWT(token: string | object): ProtectedHeaderParameters {
+  return decodeProtectedHeader(token);
+}
+
+/**
+ * decodes a jwt token
+ * @param jwt 
+ * @returns 
+ */
+export function decodeJWT<PayloadType = JWTPayload>(jwt: string): PayloadType & JWTPayload {
+  return decodeJwt<PayloadType>(jwt)
+}