@pagopa/io-react-native-jwt 0.4.1

package/src/utils/errors.ts

@@ -0,0 +1,206 @@
+/**
+ * A generic Error that all other JOSE specific Error subclasses extend.
+ *
+ * @example Checking thrown error is a JOSE one
+ *
+ * ```js
+ * if (err instanceof errors.JOSEError) {
+ *   // ...
+ * }
+ * ```
+ */
+export class JOSEError extends Error {
+  /** A unique error code for the particular error subclass. */
+  static get code(): string {
+    return 'ERR_JOSE_GENERIC';
+  }
+
+  /** A unique error code for the particular error subclass. */
+  code: string = 'ERR_JOSE_GENERIC';
+
+  constructor(message?: string) {
+    super(message);
+    this.name = this.constructor.name;
+    // @ts-ignore
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+}
+export class JWTClaimValidationFailed extends JOSEError {
+  static get code(): 'ERR_JWT_CLAIM_VALIDATION_FAILED' {
+    return 'ERR_JWT_CLAIM_VALIDATION_FAILED';
+  }
+
+  code = 'ERR_JWT_CLAIM_VALIDATION_FAILED';
+
+  /** The Claim for which the validation failed. */
+  claim: string;
+
+  /** Reason code for the validation failure. */
+  reason: string;
+
+  constructor(message: string, claim = 'unspecified', reason = 'unspecified') {
+    super(message);
+    this.claim = claim;
+    this.reason = reason;
+  }
+}
+
+/**
+ * An error subclass thrown when a JWT is expired.
+ *
+ * @example Checking thrown error is this one using a stable error code
+ *
+ * ```js
+ * if (err.code === 'ERR_JWT_EXPIRED') {
+ *   // ...
+ * }
+ * ```
+ *
+ * @example Checking thrown error is this one using `instanceof`
+ *
+ * ```js
+ * if (err instanceof errors.JWTExpired) {
+ *   // ...
+ * }
+ * ```
+ */
+export class JWTExpired extends JOSEError implements JWTClaimValidationFailed {
+  static get code(): 'ERR_JWT_EXPIRED' {
+    return 'ERR_JWT_EXPIRED';
+  }
+
+  code = 'ERR_JWT_EXPIRED';
+
+  /** The Claim for which the validation failed. */
+  claim: string;
+
+  /** Reason code for the validation failure. */
+  reason: string;
+
+  constructor(message: string, claim = 'unspecified', reason = 'unspecified') {
+    super(message);
+    this.claim = claim;
+    this.reason = reason;
+  }
+}
+
+/**
+ * An error subclass thrown when a JOSE Algorithm is not allowed per developer preference.
+ *
+ * @example Checking thrown error is this one using a stable error code
+ *
+ * ```js
+ * if (err.code === 'ERR_JOSE_ALG_NOT_ALLOWED') {
+ *   // ...
+ * }
+ * ```
+ *
+ * @example Checking thrown error is this one using `instanceof`
+ *
+ * ```js
+ * if (err instanceof errors.JOSEAlgNotAllowed) {
+ *   // ...
+ * }
+ * ```
+ */
+export class JOSEAlgNotAllowed extends JOSEError {
+  static get code(): 'ERR_JOSE_ALG_NOT_ALLOWED' {
+    return 'ERR_JOSE_ALG_NOT_ALLOWED';
+  }
+
+  code = 'ERR_JOSE_ALG_NOT_ALLOWED';
+}
+
+/**
+ * An error subclass thrown when a particular feature or algorithm is not supported by this
+ * implementation or JOSE in general.
+ *
+ * @example Checking thrown error is this one using a stable error code
+ *
+ * ```js
+ * if (err.code === 'ERR_JOSE_NOT_SUPPORTED') {
+ *   // ...
+ * }
+ * ```
+ *
+ * @example Checking thrown error is this one using `instanceof`
+ *
+ * ```js
+ * if (err instanceof errors.JOSENotSupported) {
+ *   // ...
+ * }
+ * ```
+ */
+export class JOSENotSupported extends JOSEError {
+  static get code(): 'ERR_JOSE_NOT_SUPPORTED' {
+    return 'ERR_JOSE_NOT_SUPPORTED';
+  }
+
+  code = 'ERR_JOSE_NOT_SUPPORTED';
+}
+
+/**
+ * An error subclass thrown when a JWT is invalid.
+ *
+ * @example Checking thrown error is this one using a stable error code
+ *
+ * ```js
+ * if (err.code === 'ERR_JWT_INVALID') {
+ *   // ...
+ * }
+ * ```
+ *
+ * @example Checking thrown error is this one using `instanceof`
+ *
+ * ```js
+ * if (err instanceof errors.JWTInvalid) {
+ *   // ...
+ * }
+ * ```
+ */
+export class JWTInvalid extends JOSEError {
+  static get code(): 'ERR_JWT_INVALID' {
+    return 'ERR_JWT_INVALID';
+  }
+
+  code = 'ERR_JWT_INVALID';
+}
+
+/**
+ * An error subclass thrown when a JWT signature (JWS) is invalid.
+ */
+export class JWSInvalid extends JOSEError {
+  static get code(): 'ERR_JWS_INVALID' {
+    return 'ERR_JWS_INVALID';
+  }
+  code = 'ERR_JWS_INVALID';
+}
+
+/**
+ * An error subclass thrown when JWS signature verification fails.
+ *
+ * @example Checking thrown error is this one using a stable error code
+ *
+ * ```js
+ * if (err.code === 'ERR_JWS_SIGNATURE_VERIFICATION_FAILED') {
+ *   // ...
+ * }
+ * ```
+ *
+ * @example Checking thrown error is this one using `instanceof`
+ *
+ * ```js
+ * if (err instanceof errors.JWSSignatureVerificationFailed) {
+ *   // ...
+ * }
+ * ```
+ */
+export class JWSSignatureVerificationFailed extends JOSEError {
+  static get code(): 'ERR_JWS_SIGNATURE_VERIFICATION_FAILED' {
+    return 'ERR_JWS_SIGNATURE_VERIFICATION_FAILED';
+  }
+
+  code = 'ERR_JWS_SIGNATURE_VERIFICATION_FAILED';
+
+  message = 'signature verification failed';
+}

package/src/utils/is_object.ts

@@ -0,0 +1,20 @@
+function isObjectLike(value: unknown) {
+  return typeof value === 'object' && value !== null;
+}
+
+export default function isObject<T = object>(input: unknown): input is T {
+  if (
+    !isObjectLike(input) ||
+    Object.prototype.toString.call(input) !== '[object Object]'
+  ) {
+    return false;
+  }
+  if (Object.getPrototypeOf(input) === null) {
+    return true;
+  }
+  let proto = input;
+  while (Object.getPrototypeOf(proto) !== null) {
+    proto = Object.getPrototypeOf(proto);
+  }
+  return Object.getPrototypeOf(input) === proto;
+}

package/src/utils/proxy.ts

@@ -0,0 +1,15 @@
+import { NativeModules } from 'react-native';
+
+export const IoReactNativeJwt = NativeModules.IoReactNativeJwt
+  ? NativeModules.IoReactNativeJwt
+  : new Proxy(
+      {
+        //this is a fake implementation to allow local deviceless testing
+        unpackBerEncodedASN1: (a: string, _b: number) => a,
+      },
+      {
+        get: function (target, prop) {
+          return Reflect.get(target, prop);
+        },
+      }
+    );

package/src/utils/secs.ts

@@ -0,0 +1,58 @@
+const minute = 60;
+const hour = minute * 60;
+const day = hour * 24;
+const week = day * 7;
+const year = day * 365.25;
+
+/*
+ * It allows to extract the value and the unit of measurement for the time.
+ * For example, indicating a string like "1s" or "1 second" or "3 hour"
+ * the regex extracts a group made up of [1, "s"], [1, "second"] or [3, "hour"]
+ */
+const REGEX =
+  /^(\d+|\d+\.\d+) ?(seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)$/i;
+
+export default (str: string): number => {
+  const matched = REGEX.exec(str);
+
+  if (!matched) {
+    throw new TypeError('Invalid time period format');
+  }
+
+  const value = parseFloat(matched[1]!);
+  const unit = matched[2]!.toLowerCase();
+
+  switch (unit) {
+    case 'sec':
+    case 'secs':
+    case 'second':
+    case 'seconds':
+    case 's':
+      return Math.round(value);
+    case 'minute':
+    case 'minutes':
+    case 'min':
+    case 'mins':
+    case 'm':
+      return Math.round(value * minute);
+    case 'hour':
+    case 'hours':
+    case 'hr':
+    case 'hrs':
+    case 'h':
+      return Math.round(value * hour);
+    case 'day':
+    case 'days':
+    case 'd':
+      return Math.round(value * day);
+    case 'week':
+    case 'weeks':
+    case 'w':
+      return Math.round(value * week);
+    // years matched
+    default:
+      return Math.round(value * year);
+  }
+};
+
+export const epoch = (date: Date) => Math.floor(date.getTime() / 1000);