@bitblit/ratchet-common 6.0.146-alpha → 6.0.148-alpha

package/src/network/remote-file-tracker/remote-file-tracker-push-options.ts

@@ -0,0 +1,4 @@
+export interface RemoteFileTrackerPushOptions {
+  force?: boolean; // If set, overwrites the remote file even if out of sync
+  backup?: boolean; // If set, the remote file will be backed up before push occurs
+}

package/src/network/remote-file-tracker/remote-file-tracker.ts

@@ -0,0 +1,117 @@
+import { RemoteStatusData } from './remote-status-data.js';
+import { RemoteStatusDataAndContent } from './remote-status-data-and-content.js';
+import { FileTransferResultType } from './file-transfer-result-type.js';
+import { FileTransferResult } from './file-transfer-result.js';
+import { Logger } from '../../logger/logger.js';
+import { RemoteFileTrackerOptions } from './remote-file-tracker-options.js';
+import { RequireRatchet } from '../../lang/require-ratchet.js';
+import { RemoteFileTrackerPushOptions } from './remote-file-tracker-push-options.js';
+import { WebStreamRatchet } from '../../lang/web-stream-ratchet.js';
+
+export class RemoteFileTracker<KeyType> {
+  // Updated every type you sync or pull
+  private _remoteStatusData: RemoteStatusData<KeyType>;
+
+  constructor(private opts: RemoteFileTrackerOptions<KeyType>) {
+    RequireRatchet.notNullOrUndefined(opts, 'opts');
+    RequireRatchet.notNullOrUndefined(opts.provider, 'opts.provider');
+    RequireRatchet.notNullOrUndefined(opts.key, 'opts.key');
+  }
+
+  public get remoteStatusData(): RemoteStatusData<KeyType> {
+    // Gen a copy to prevent accidental corruption
+    return Object.assign({}, this._remoteStatusData);
+  }
+
+  // Rereads the remote side
+  public async sync(): Promise<RemoteStatusData<KeyType>> {
+    this._remoteStatusData = await this.opts.provider.readRemoteStatus(this.opts.key);
+    return this._remoteStatusData;
+  }
+
+  public async pullRemoteData(ifNewerThan?: RemoteStatusData<KeyType>): Promise<RemoteStatusDataAndContent<KeyType>> {
+    const rval: RemoteStatusDataAndContent<KeyType> = await this.opts.provider.pullRemoteData(this.opts.key, ifNewerThan);
+    if (rval) {
+      this._remoteStatusData = rval.status;
+    }
+    return rval;
+  }
+
+  public static async dataAsString(data: RemoteStatusDataAndContent<any>): Promise<string> {
+    let rval: string = null;
+    if (data?.content) {
+      rval = await WebStreamRatchet.webReadableStreamToString(data.content);
+    }
+    return rval;
+  }
+
+  public static async dataAsUint8Array(data: RemoteStatusDataAndContent<any>): Promise<Uint8Array> {
+    let rval: Uint8Array = null;
+    if (data?.content) {
+      rval = await WebStreamRatchet.webReadableStreamToUint8Array(data.content);
+    } else {
+      Logger.warn('Was unable to read as array since content is missing');
+    }
+    return rval;
+  }
+
+  public static async dataAsObject<T>(data: RemoteStatusDataAndContent<any>): Promise<T> {
+    let rval: T = null;
+    if (data?.content) {
+      const txt: string = await this.dataAsString(data);
+      rval = JSON.parse(txt);
+    }
+    return rval;
+  }
+
+  // Will throw exception if remote was modified since the last update
+  public async pushStreamToRemote(src: ReadableStream, inPushOpts?: RemoteFileTrackerPushOptions): Promise<RemoteStatusData<KeyType>> {
+    RequireRatchet.notNullOrUndefined(src, 'src');
+    const pushOpts: RemoteFileTrackerPushOptions = Object.assign({ force: false, backup: false }, inPushOpts);
+    const result: FileTransferResult = await this.opts.provider.sendDataToRemote(src, this.opts.key, pushOpts, this._remoteStatusData);
+    if (result.type === FileTransferResultType.Updated) {
+      Logger.info('Sent %d bytes to remote, re-reading sync');
+      await this.sync();
+    }
+    return this._remoteStatusData;
+  }
+
+  public async pushStringToRemote(src: string, inPushOpts?: RemoteFileTrackerPushOptions): Promise<RemoteStatusData<KeyType>> {
+    RequireRatchet.notNullOrUndefined(src, 'src');
+    const asString: ReadableStream = WebStreamRatchet.stringToWebReadableStream(src);
+    return this.pushStreamToRemote(asString, inPushOpts);
+  }
+
+  public async pushUint8ArrayToRemote(src: Uint8Array, inPushOpts?: RemoteFileTrackerPushOptions): Promise<RemoteStatusData<KeyType>> {
+    RequireRatchet.notNullOrUndefined(src, 'src');
+    const asString: ReadableStream = WebStreamRatchet.uint8ArrayToWebReadableStream(src);
+    return this.pushStreamToRemote(asString, inPushOpts);
+  }
+
+  public async pushObjectJsonToRemote(src: any, inPushOpts?: RemoteFileTrackerPushOptions): Promise<RemoteStatusData<KeyType>> {
+    RequireRatchet.notNullOrUndefined(src, 'src');
+    const asString: string = JSON.stringify(src);
+    return this.pushStringToRemote(asString, inPushOpts);
+  }
+
+  // If skipUpdateLocal is NOT set, the next call will succeed because
+  // the data is updated as part of the read
+  public async modifiedSinceLastSync(skipUpdateLocal?: boolean): Promise<boolean> {
+    const newData: RemoteStatusData<KeyType> = await this.opts.provider.readRemoteStatus(this.opts.key);
+    const rval: boolean = !RemoteFileTracker.statusMatch(newData, this._remoteStatusData);
+    if (!skipUpdateLocal) {
+      this._remoteStatusData = newData;
+    }
+    return rval;
+  }
+
+  public static statusMatch(rsd1: RemoteStatusData<any>, rsd2: RemoteStatusData<any>): boolean {
+    return (
+      rsd1 &&
+      rsd2 &&
+      rsd1.remoteHash === rsd2.remoteHash &&
+      rsd1.remoteSizeInBytes === rsd2.remoteSizeInBytes &&
+      rsd1.remoteLastUpdatedEpochMs === rsd2.remoteLastUpdatedEpochMs
+    );
+  }
+}

package/src/network/remote-file-tracker/remote-file-tracking-provider.ts

@@ -0,0 +1,19 @@
+// An interface to define an object that provides remote file sync (and keep syncd)
+// capabilities.  Mainly in common so I don't have to import AWS into my sqlite package
+// or vice versa
+
+import { RemoteStatusData } from './remote-status-data.js';
+import { RemoteStatusDataAndContent } from './remote-status-data-and-content.js';
+import { FileTransferResult } from './file-transfer-result.js';
+import { RemoteFileTrackerPushOptions } from './remote-file-tracker-push-options.js';
+
+export interface RemoteFileTrackingProvider<KeyType> {
+  readRemoteStatus(key: KeyType): Promise<RemoteStatusData<KeyType>>;
+  pullRemoteData(key: KeyType, ifNewerThan?: RemoteStatusData<KeyType>): Promise<RemoteStatusDataAndContent<KeyType>>;
+  sendDataToRemote(
+    src: ReadableStream,
+    key: KeyType,
+    opts: RemoteFileTrackerPushOptions,
+    checkStatus: RemoteStatusData<KeyType>,
+  ): Promise<FileTransferResult>;
+}

package/src/network/remote-file-tracker/remote-status-data-and-content.ts

@@ -0,0 +1,6 @@
+import { RemoteStatusData } from './remote-status-data.js';
+
+export interface RemoteStatusDataAndContent<KeyType> {
+  status: RemoteStatusData<KeyType>;
+  content: ReadableStream;
+}

package/src/network/remote-file-tracker/remote-status-data.ts

@@ -0,0 +1,7 @@
+export interface RemoteStatusData<KeyType> {
+  key: KeyType;
+  statusTakenEpochMs: number;
+  remoteSizeInBytes: number;
+  remoteLastUpdatedEpochMs: number;
+  remoteHash: string;
+}

package/src/network/restful-api-http-error.spec.ts

@@ -0,0 +1,13 @@
+import { RestfulApiHttpError } from './restful-api-http-error.js';
+import { describe, expect, test } from 'vitest';
+
+describe('#restfulApiHttpError', function () {
+  test('should check if the error is a given class', async () => {
+    const testError: Error = new RestfulApiHttpError('test').withHttpStatusCode(404);
+    const nonHttpError: Error = new Error('Not HTTP');
+    expect(RestfulApiHttpError.errorIs40x(testError)).toBeTruthy();
+    expect(RestfulApiHttpError.errorIs50x(testError)).toBeFalsy();
+    expect(RestfulApiHttpError.errorIs40x(nonHttpError)).toBeFalsy();
+    expect(RestfulApiHttpError.errorIs50x(testError)).toBeFalsy();
+  });
+});

package/src/network/restful-api-http-error.ts

@@ -0,0 +1,173 @@
+import { NumberRatchet } from '../lang/number-ratchet.js';
+import { StringRatchet } from '../lang/string-ratchet.js';
+
+/**
+ * 2023-07-18 : I moved this class from Epsilon over to common because 1) It has no
+ * dependencies so it's a light lift and 2) unicorn showed me it is helpful to have
+ * it available on the client side.
+ *
+ * This class is meant to provide a more robust and standardized error class for
+ * throwing things across the http wire in restful apis.
+ */
+export class RestfulApiHttpError<T = void> extends Error {
+  private static readonly RATCHET_RESTFUL_API_HTTP_ERROR_FLAG_KEY: string = '__ratchetRestfulApiHttpErrorFlag';
+  private _httpStatusCode = 500;
+  private _errors: string[];
+  private _detailErrorCode: number;
+  private _endUserErrors: string[];
+  private _details: T;
+  private _requestId: string;
+  private _wrappedError: Error;
+
+  constructor(...errors: string[]) {
+    super(RestfulApiHttpError.combineErrorStringsWithDefault(errors));
+    Object.setPrototypeOf(this, RestfulApiHttpError.prototype);
+    this._errors = errors;
+    this[RestfulApiHttpError.RATCHET_RESTFUL_API_HTTP_ERROR_FLAG_KEY] = true; // Just used to tell if one has been wrapped
+  }
+
+  public static combineErrorStringsWithDefault(errors: string[], defMessage = 'Internal Server Error'): string {
+    return errors && errors.length > 0 ? errors.join(',') : defMessage;
+  }
+
+  public setFormattedErrorMessage(format: string, ...input: any[]): void {
+    const msg: string = StringRatchet.format(format, ...input);
+    this.errors = [msg];
+  }
+
+  public withFormattedErrorMessage(format: string, ...input: any[]): RestfulApiHttpError<T> {
+    this.setFormattedErrorMessage(format, ...input);
+    return this;
+  }
+
+  public withHttpStatusCode(httpStatusCode: number): RestfulApiHttpError<T> {
+    this.httpStatusCode = httpStatusCode; // Call setter
+    return this;
+  }
+
+  public withErrors(errors: string[]): RestfulApiHttpError<T> {
+    this.errors = errors; // Call setter
+    return this;
+  }
+
+  public withDetailErrorCode(detailErrorCode: number): RestfulApiHttpError<T> {
+    this._detailErrorCode = detailErrorCode; // Call setter
+    return this;
+  }
+
+  public withEndUserErrors(endUserErrors: string[]): RestfulApiHttpError<T> {
+    this._endUserErrors = endUserErrors; // Call setter
+    return this;
+  }
+
+  public withDetails(details: T): RestfulApiHttpError<T> {
+    this._details = details; // Call setter
+    return this;
+  }
+
+  public withRequestId(requestId: string): RestfulApiHttpError<T> {
+    this._requestId = requestId; // Call setter
+    return this;
+  }
+
+  public withWrappedError(err: Error): RestfulApiHttpError<T> {
+    this._wrappedError = err; // Call setter
+    return this;
+  }
+
+  public isWrappedError(): boolean {
+    return !!this._wrappedError;
+  }
+
+  public static wrapError<T = void>(err: Error): RestfulApiHttpError<T> {
+    let rval: RestfulApiHttpError<T> = null;
+    if (RestfulApiHttpError.objectIsRestfulApiHttpError(err)) {
+      rval = err as RestfulApiHttpError<T>;
+    } else {
+      rval = new RestfulApiHttpError<T>(err.message).withWrappedError(err).withHttpStatusCode(500);
+    }
+    return rval;
+  }
+
+  public static objectIsRestfulApiHttpError(obj: any): boolean {
+    return obj && obj[RestfulApiHttpError.RATCHET_RESTFUL_API_HTTP_ERROR_FLAG_KEY] === true;
+  }
+
+  get httpStatusCode(): number {
+    return this._httpStatusCode;
+  }
+
+  set httpStatusCode(value: number) {
+    this._httpStatusCode = value || 500;
+  }
+
+  get errors(): string[] {
+    return this._errors;
+  }
+
+  set errors(value: string[]) {
+    this._errors = value || ['Internal Server Error'];
+    this.message = RestfulApiHttpError.combineErrorStringsWithDefault(this._errors);
+  }
+
+  get detailErrorCode(): number {
+    return this._detailErrorCode;
+  }
+
+  set detailErrorCode(value: number) {
+    this._detailErrorCode = value;
+  }
+
+  get endUserErrors(): string[] {
+    return this._endUserErrors;
+  }
+
+  set endUserErrors(value: string[]) {
+    this._endUserErrors = value;
+  }
+
+  get details(): T {
+    return this._details;
+  }
+
+  set details(value: T) {
+    this._details = value;
+  }
+
+  get requestId(): string {
+    return this._requestId;
+  }
+
+  set requestId(value: string) {
+    this._requestId = value || 'MISSING';
+  }
+
+  get wrappedError(): Error {
+    return this._wrappedError;
+  }
+
+  set wrappedError(value: Error) {
+    this._wrappedError = value;
+  }
+
+  public static errorIsX0x(errIn: Error, xClass: number): boolean {
+    let rval = false;
+    if (errIn && RestfulApiHttpError.objectIsRestfulApiHttpError(errIn)) {
+      const err: RestfulApiHttpError = errIn as RestfulApiHttpError;
+
+      const val: number = NumberRatchet.safeNumber(err.httpStatusCode);
+      const bot: number = xClass * 100;
+      const top: number = bot + 99;
+      rval = val >= bot && val <= top;
+    }
+    return rval;
+  }
+
+  public static errorIs40x(err: Error): boolean {
+    return RestfulApiHttpError.errorIsX0x(err, 4);
+  }
+
+  public static errorIs50x(err: Error): boolean {
+    return RestfulApiHttpError.errorIsX0x(err, 5);
+  }
+}

package/src/template/ratchet-template-renderer.ts

@@ -0,0 +1,8 @@
+/**
+ * tbd
+ * @interface RatchetTemplateRenderer
+ */
+export interface RatchetTemplateRenderer {
+  renderTemplate(templateName: string, context: any, layoutName?: string, partialNames?: string[]): Promise<string>;
+  renderTemplateDirect(templateValue: string, context: any, layoutName?: string): Promise<string>;
+}

package/src/third-party/google/google-recaptcha-ratchet.spec.ts

@@ -0,0 +1,27 @@
+import { GoogleRecaptchaRatchet } from './google-recaptcha-ratchet.js';
+import { describe, expect, test, vi } from 'vitest';
+
+const fakeFetch = vi.fn((_input, _init) =>
+  Promise.resolve({
+    json: () => Promise.resolve({ success: true }),
+  } as Response),
+);
+
+const fakeFailFetch = vi.fn((_input, _init) => Promise.reject('Failed to read'));
+
+describe('#googleRecaptchaService', () => {
+  test('should validate a recaptcha token', async () => {
+    const res: any = await GoogleRecaptchaRatchet.verifyRecaptchaToken('anykey', 'anytoken', fakeFetch);
+    expect(res).toBeTruthy();
+  });
+
+  test('should fail with no token', async () => {
+    const res: any = await GoogleRecaptchaRatchet.verifyRecaptchaToken('anykey', null, fakeFetch);
+    expect(res).toBeFalsy();
+  });
+
+  test('should fail if http fails', async () => {
+    const res: any = await GoogleRecaptchaRatchet.verifyRecaptchaToken('anykey', 'anytoken', fakeFailFetch);
+    expect(res).toBeFalsy();
+  });
+});

package/src/third-party/google/google-recaptcha-ratchet.ts

@@ -0,0 +1,36 @@
+/**
+ * Service for functions that communicate to Google Recaptcha service
+ */
+import { Logger } from '../../logger/logger.js';
+import { StringRatchet } from '../../lang/string-ratchet.js';
+import fetch from 'cross-fetch';
+
+export class GoogleRecaptchaRatchet {
+  private static readonly GOOGLE_VERIFY_URL: string = 'https://www.google.com/recaptcha/api/siteverify?secret=${KEY}&response=${TOKEN}';
+
+  public static async verifyRecaptchaToken(
+    keySecret: string,
+    token: string,
+    fetchFn: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response> = fetch,
+  ): Promise<boolean> {
+    Logger.debug('Verifying recaptcha token : %s', token);
+    let rval: boolean = null;
+
+    if (!StringRatchet.safeString(token)) {
+      Logger.warn('Recaptcha validation error, no token passed : %s', token);
+      return rval;
+    }
+
+    Logger.info('Validating Recaptcha via Google API : %s', token);
+    const url: string = StringRatchet.simpleTemplateFill(GoogleRecaptchaRatchet.GOOGLE_VERIFY_URL, { KEY: keySecret, TOKEN: token }, true);
+    try {
+      const resp: Response = await fetchFn(url);
+      const body: any = await resp.json();
+      rval = body && body.success;
+    } catch (err) {
+      Logger.error('Failed to read from google : %s', err);
+      rval = false;
+    }
+    return rval;
+  }
+}

package/src/third-party/twilio/twilio-ratchet.ts

@@ -0,0 +1,92 @@
+import fetch from 'cross-fetch';
+
+import { RequireRatchet } from '../../lang/require-ratchet.js';
+import { Base64Ratchet } from '../../lang/base64-ratchet.js';
+import { StringRatchet } from '../../lang/string-ratchet.js';
+import { Logger } from '../../logger/logger.js';
+
+/**
+ * This class is for people who just need to send an occasionaly outbound text message and don't need
+ * Twilio's 7mb non-tree-shakable library
+ */
+export class TwilioRatchet {
+  // CAW: Switch to api.ashburn to us just us-east-1 ?
+  public static readonly TWILLIO_BASE_API_URL: string = 'https://api.twilio.com/2010-04-01';
+
+  constructor(
+    private accountSid: string,
+    private authToken: string,
+    private outBoundNumber: string,
+  ) {
+    RequireRatchet.notNullOrUndefined(accountSid, 'accountSid');
+    RequireRatchet.notNullOrUndefined(authToken, 'authToken');
+    RequireRatchet.notNullOrUndefined(outBoundNumber, 'outBoundNumber');
+    RequireRatchet.true(TwilioRatchet.isValidE164Number(outBoundNumber), 'outBoundNumber invalid format');
+  }
+
+  // Pass thru for simplification
+  public static async sendMessageDirect(
+    accountSid: string,
+    authToken: string,
+    outBoundNumber: string,
+    recipientPhoneNumbers: string[],
+    message: string,
+  ): Promise<any[]> {
+    const ratchet: TwilioRatchet = new TwilioRatchet(accountSid, authToken, outBoundNumber);
+    const rval: any[] = await ratchet.sendMessage(recipientPhoneNumbers, message);
+    return rval;
+  }
+
+  public static generateTwilioBasicAuth(sid: string, authToken: string): string {
+    const authHeader: string = 'Basic ' + Base64Ratchet.generateBase64VersionOfString(sid + ':' + authToken);
+    return authHeader;
+  }
+
+  public async sendMessage(recipientPhoneNumbers: string[], message: string): Promise<any[]> {
+    const rval: any[] = [];
+    RequireRatchet.notNullOrUndefined(recipientPhoneNumbers, 'recipientPhoneNumbers');
+    RequireRatchet.notNullOrUndefined(StringRatchet.trimToNull(message), 'message');
+    RequireRatchet.true(recipientPhoneNumbers.length > 0, 'recipientPhoneNumbers non-empty');
+
+    if (!!recipientPhoneNumbers && recipientPhoneNumbers.length > 0 && !!StringRatchet.trimToNull(message)) {
+      Logger.info('Sending %s to %j', message, recipientPhoneNumbers);
+
+      for (const phoneNumber of recipientPhoneNumbers) {
+        Logger.info('To: %s', phoneNumber);
+
+        if (!TwilioRatchet.isValidE164Number(phoneNumber)) {
+          throw new Error('number must be E164 format!');
+        }
+        const body: string =
+          'Body=' +
+          encodeURIComponent(message) +
+          '&From=' +
+          encodeURIComponent(this.outBoundNumber) +
+          '&To=' +
+          encodeURIComponent(phoneNumber);
+        const post: any = {
+          method: 'post',
+          headers: {
+            authorization: TwilioRatchet.generateTwilioBasicAuth(this.accountSid, this.authToken),
+            'Content-Type': 'application/x-www-form-urlencoded',
+          },
+          body: body,
+        };
+
+        const res: Response = await fetch(TwilioRatchet.TWILLIO_BASE_API_URL + '/Accounts/' + this.accountSid + '/Messages.json', post);
+        const parsedResponse: any = await res.json();
+        Logger.debug('TwilioRatchet: For %s got %j', phoneNumber, parsedResponse);
+        rval.push(parsedResponse);
+      }
+    } else {
+      Logger.warn('Not sending empty message / empty recipients');
+    }
+
+    return rval;
+  }
+
+  // Validate E164 format
+  public static isValidE164Number(num: string): boolean {
+    return /^\+?[1-9]\d{1,14}$/.test(num);
+  }
+}

package/src/third-party/twilio/twilio-verify-ratchet.ts

@@ -0,0 +1,83 @@
+import fetch from 'cross-fetch';
+
+import { RequireRatchet } from '../../lang/require-ratchet.js';
+import { Logger } from '../../logger/logger.js';
+import { TwilioRatchet } from './twilio-ratchet.js';
+
+/**
+ * This is for JUST hitting the Twilio verify service (useful for 2FA/One time passwords) without
+ * needing a phone number
+ */
+export class TwilioVerifyRatchet {
+  public static readonly TWILLIO_BASE_VERIFY_URL: string = 'https://verify.twilio.com/v2/Services/';
+
+  constructor(
+    private accountSid: string,
+    private authToken: string,
+    private serviceSid: string,
+  ) {
+    RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(accountSid, 'accountSid');
+    RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(authToken, 'authToken');
+    RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(serviceSid, 'serviceSid');
+  }
+
+  public async sendVerificationTokenUsingTwilioVerify(recipientPhoneNumber: string): Promise<string> {
+    RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(recipientPhoneNumber, 'recipientPhoneNumber');
+    RequireRatchet.true(TwilioRatchet.isValidE164Number(recipientPhoneNumber), 'recipientPhoneNumber must be E164');
+    const phone: string = recipientPhoneNumber.startsWith('+1') ? recipientPhoneNumber : '+1' + recipientPhoneNumber;
+    const body: string = 'Channel=sms&To=' + encodeURIComponent(phone);
+    const post: any = {
+      method: 'post',
+      headers: {
+        authorization: TwilioRatchet.generateTwilioBasicAuth(this.accountSid, this.authToken),
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: body,
+    };
+
+    const url: string = TwilioVerifyRatchet.TWILLIO_BASE_VERIFY_URL + this.serviceSid + '/Verifications';
+    const res: Response = await fetch(url, post);
+    const respBody: string = await res.text();
+    return respBody;
+  }
+
+  public async simpleCheckVerificationTokenUsingTwilioVerify(recipientPhoneNumber: string, code: string): Promise<boolean> {
+    const val: TwilioVerifyCheckResponse = await this.checkVerificationTokenUsingTwilioVerify(recipientPhoneNumber, code);
+    return val && val.status === 'approved';
+  }
+
+  public async checkVerificationTokenUsingTwilioVerify(recipientPhoneNumber: string, code: string): Promise<TwilioVerifyCheckResponse> {
+    RequireRatchet.notNullUndefinedOrOnlyWhitespaceString(recipientPhoneNumber, 'recipientPhoneNumber');
+    RequireRatchet.true(TwilioRatchet.isValidE164Number(recipientPhoneNumber), 'recipientPhoneNumber must be E164');
+    const phone: string = recipientPhoneNumber.startsWith('+1') ? recipientPhoneNumber : '+1' + recipientPhoneNumber;
+    const body: string = 'To=' + encodeURIComponent(phone) + '&Code=' + encodeURIComponent(code);
+    const post: any = {
+      method: 'post',
+      headers: {
+        authorization: TwilioRatchet.generateTwilioBasicAuth(this.accountSid, this.authToken),
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: body,
+    };
+
+    const url: string = TwilioVerifyRatchet.TWILLIO_BASE_VERIFY_URL + this.serviceSid + '/VerificationCheck';
+    Logger.info('Using %s / %j', url, post);
+    const res: Response = await fetch(url, post);
+    const parsedResponse: TwilioVerifyCheckResponse = await res.json();
+    return parsedResponse;
+  }
+}
+
+export interface TwilioVerifyCheckResponse {
+  status: string;
+  payee: string;
+  date_updated: string;
+  account_sid: string;
+  to: string;
+  amount: string;
+  valid: boolean;
+  sid: string;
+  date_created: string;
+  service_sid: string;
+  channel: string;
+}