@bash-app/bash-common 10.7.0 → 10.9.0

package/src/utils/addressUtils.ts

@@ -1,173 +1,173 @@
-
-const ADDRESS_DELIM = '|';
-
-const googleMapsApiKey = process.env.REACT_APP_GOOGLE_MAP_API_KEY as string;
-
-
-export interface IAddress {
-  place: string;
-  street: string;
-  city: string;
-  state: string;
-  zipCode: string;
-  country: string;
-}
-
-export function addressHasEnoughDataForGeolocation(address: IAddress): boolean {
-  return !!((address.place && address.city && address.state) || (address.street && address.city && address.state));
-}
-
-export function addressValuesToDatabaseAddressString(addressValues: IAddress): string {
-  const { place = '', street, city, state, zipCode, country } = addressValues;
-  return [place, street, city, state, zipCode, country].join(ADDRESS_DELIM);
-}
-
-export function databaseAddressStringToAddressValues(addressString: string | undefined | null): IAddress {
-  if (addressString) {
-    const addressArray = addressString.split(ADDRESS_DELIM);
-    return {
-      place: addressArray[0],
-      street: addressArray[1],
-      city: addressArray[2],
-      state: addressArray[3],
-      zipCode: addressArray[4],
-      country: 'USA'
-    }
-  }
-  return { place: '', street: '', city: '', state: '', zipCode: '', country: '' };
-}
-
-
-export function databaseAddressStringToOneLineString(addressString: string | undefined | null): string {
-  if (addressString) {
-    const address = databaseAddressStringToAddressValues(addressString);
-    let addressArr = address.place ? [address.place] : [];
-    addressArr = [...addressArr, address.street, address.city, address.state];
-    const addressStr = addressArr.filter((str) => !!str).join(', ');
-    return `${addressStr} ${address.zipCode}`;
-  }
-  return '';
-}
-
-export function databaseAddressStringToDisplayString(addressString: string | undefined | null): string {
-  if (addressString) {
-    const oneLineString = databaseAddressStringToOneLineString(addressString);
-    const formatted = oneLineString.replace(/([A-Z])(?=[A-Z][a-z])/g, "$1 ") // Add space between a single uppercase letter and a capitalized word
-                 .replace(/(\d)(?=[A-Z])/g, "$1 ") // Add space between numbers and letters
-                 .replace(/,/g, ", "); // Add space after commas
-    return formatted;
-  }
-  return '';
-}
-
-
-export async function getAddressFromCoordinates( lat: number, lng: number ): Promise<IAddress> {
-  const apiUrl = `https://maps.googleapis.com/maps/api/geocode/json?latlng=${lat},${lng}&key=${googleMapsApiKey}&loading=async`;
-  try {
-    const response = await fetch(apiUrl);
-    const data = await response.json();
-    if (data.results.length > 0) {
-      const addressComponents = data.results[0].address_components;
-
-      let street = "";
-      let city = "";
-      let state = "";
-      let zipCode = "";
-
-      addressComponents.forEach((component: any) => {
-        if (component.types.includes("route")) {
-          street = component.long_name;
-        } else if (component.types.includes("locality")) {
-          city = component.long_name;
-        } else if (component.types.includes("administrative_area_level_1")) {
-          state = component.short_name;
-        } else if (component.types.includes("postal_code")) {
-          zipCode = component.long_name;
-        }
-      });
-
-      return { place: '',  street, city, state, zipCode, country: 'USA' };
-    } else {
-      throw new Error("No address found");
-    }
-  } catch (error) {
-    console.error(error);
-    return {
-      place: '',
-      street: "",
-      city: "",
-      state: "",
-      zipCode: "",
-      country: 'USA'
-    };
-  }
-}
-
-export function extractAddressComponents(place: any): IAddress {
-  const addressComponents = place.address_components;
-  let streetNumber = '';
-  let streetName = '';
-  let city = '';
-  let state = '';
-  let zipCode = '';
-  let country = 'USA';
-
-  addressComponents.forEach((component: any) => {
-    const types = component.types;
-    if (types.includes('street_number')) {
-      streetNumber = component.long_name;
-    }
-    if (types.includes('route')) {
-      streetName = component.long_name;
-    }
-    if (types.includes('locality')) {
-      city = component.long_name;
-    }
-    if (types.includes('administrative_area_level_1')) {
-      state = component.short_name;
-    }
-    if (types.includes('postal_code')) {
-      zipCode = component.long_name;
-    }
-    if (types.includes('country')) {
-      country = component.long_name;
-    }
-  });
-
-  const street = `${streetNumber} ${streetName}`.trim();
-
-  return {
-    place: place.name || '',
-    street,
-    city,
-    state,
-    zipCode,
-    country
-  };
-}
-
-
-export async function getGeoCoordinatesFromAddress(address: IAddress): Promise<{lat: number, lng: number} | undefined> {
-  const addressStr = `${address.street}, ${address.city}, ${address.state} ${address.zipCode}, ${address.country}`;
-
-  const response = await fetch(
-    `https://maps.googleapis.com/maps/api/geocode/json?address=${encodeURIComponent(addressStr)}&key=${googleMapsApiKey}`
-  );
-  if (!response.ok) {
-    console.error('Geocode response was not ok for address: ' + addressStr);
-  }
-
-  const data = await response.json();
-
-  if (data.status === 'OK') {
-    if (data.results?.length) {
-      return data.results[0].geometry.location;
-    }
-    else {
-      console.error('Geocode results were empty with address: ' + addressStr);
-    }
-  }
-  else {
-    console.error(`Geocode was not successful with address: ${addressStr}\nfor the following reason: ${data.status}`);
-  }
-}
+
+const ADDRESS_DELIM = '|';
+
+const googleMapsApiKey = process.env.REACT_APP_GOOGLE_MAP_API_KEY as string;
+
+
+export interface IAddress {
+  place: string;
+  street: string;
+  city: string;
+  state: string;
+  zipCode: string;
+  country: string;
+}
+
+export function addressHasEnoughDataForGeolocation(address: IAddress): boolean {
+  return !!((address.place && address.city && address.state) || (address.street && address.city && address.state));
+}
+
+export function addressValuesToDatabaseAddressString(addressValues: IAddress): string {
+  const { place = '', street, city, state, zipCode, country } = addressValues;
+  return [place, street, city, state, zipCode, country].join(ADDRESS_DELIM);
+}
+
+export function databaseAddressStringToAddressValues(addressString: string | undefined | null): IAddress {
+  if (addressString) {
+    const addressArray = addressString.split(ADDRESS_DELIM);
+    return {
+      place: addressArray[0],
+      street: addressArray[1],
+      city: addressArray[2],
+      state: addressArray[3],
+      zipCode: addressArray[4],
+      country: 'USA'
+    }
+  }
+  return { place: '', street: '', city: '', state: '', zipCode: '', country: '' };
+}
+
+
+export function databaseAddressStringToOneLineString(addressString: string | undefined | null): string {
+  if (addressString) {
+    const address = databaseAddressStringToAddressValues(addressString);
+    let addressArr = address.place ? [address.place] : [];
+    addressArr = [...addressArr, address.street, address.city, address.state];
+    const addressStr = addressArr.filter((str) => !!str).join(', ');
+    return `${addressStr} ${address.zipCode}`;
+  }
+  return '';
+}
+
+export function databaseAddressStringToDisplayString(addressString: string | undefined | null): string {
+  if (addressString) {
+    const oneLineString = databaseAddressStringToOneLineString(addressString);
+    const formatted = oneLineString.replace(/([A-Z])(?=[A-Z][a-z])/g, "$1 ") // Add space between a single uppercase letter and a capitalized word
+                 .replace(/(\d)(?=[A-Z])/g, "$1 ") // Add space between numbers and letters
+                 .replace(/,/g, ", "); // Add space after commas
+    return formatted;
+  }
+  return '';
+}
+
+
+export async function getAddressFromCoordinates( lat: number, lng: number ): Promise<IAddress> {
+  const apiUrl = `https://maps.googleapis.com/maps/api/geocode/json?latlng=${lat},${lng}&key=${googleMapsApiKey}&loading=async`;
+  try {
+    const response = await fetch(apiUrl);
+    const data = await response.json();
+    if (data.results.length > 0) {
+      const addressComponents = data.results[0].address_components;
+
+      let street = "";
+      let city = "";
+      let state = "";
+      let zipCode = "";
+
+      addressComponents.forEach((component: any) => {
+        if (component.types.includes("route")) {
+          street = component.long_name;
+        } else if (component.types.includes("locality")) {
+          city = component.long_name;
+        } else if (component.types.includes("administrative_area_level_1")) {
+          state = component.short_name;
+        } else if (component.types.includes("postal_code")) {
+          zipCode = component.long_name;
+        }
+      });
+
+      return { place: '',  street, city, state, zipCode, country: 'USA' };
+    } else {
+      throw new Error("No address found");
+    }
+  } catch (error) {
+    console.error(error);
+    return {
+      place: '',
+      street: "",
+      city: "",
+      state: "",
+      zipCode: "",
+      country: 'USA'
+    };
+  }
+}
+
+export function extractAddressComponents(place: any): IAddress {
+  const addressComponents = place.address_components;
+  let streetNumber = '';
+  let streetName = '';
+  let city = '';
+  let state = '';
+  let zipCode = '';
+  let country = 'USA';
+
+  addressComponents.forEach((component: any) => {
+    const types = component.types;
+    if (types.includes('street_number')) {
+      streetNumber = component.long_name;
+    }
+    if (types.includes('route')) {
+      streetName = component.long_name;
+    }
+    if (types.includes('locality')) {
+      city = component.long_name;
+    }
+    if (types.includes('administrative_area_level_1')) {
+      state = component.short_name;
+    }
+    if (types.includes('postal_code')) {
+      zipCode = component.long_name;
+    }
+    if (types.includes('country')) {
+      country = component.long_name;
+    }
+  });
+
+  const street = `${streetNumber} ${streetName}`.trim();
+
+  return {
+    place: place.name || '',
+    street,
+    city,
+    state,
+    zipCode,
+    country
+  };
+}
+
+
+export async function getGeoCoordinatesFromAddress(address: IAddress): Promise<{lat: number, lng: number} | undefined> {
+  const addressStr = `${address.street}, ${address.city}, ${address.state} ${address.zipCode}, ${address.country}`;
+
+  const response = await fetch(
+    `https://maps.googleapis.com/maps/api/geocode/json?address=${encodeURIComponent(addressStr)}&key=${googleMapsApiKey}`
+  );
+  if (!response.ok) {
+    console.error('Geocode response was not ok for address: ' + addressStr);
+  }
+
+  const data = await response.json();
+
+  if (data.status === 'OK') {
+    if (data.results?.length) {
+      return data.results[0].geometry.location;
+    }
+    else {
+      console.error('Geocode results were empty with address: ' + addressStr);
+    }
+  }
+  else {
+    console.error(`Geocode was not successful with address: ${addressStr}\nfor the following reason: ${data.status}`);
+  }
+}

package/src/utils/awsS3Utils.ts

@@ -1,100 +1,100 @@
-import {DeleteObjectCommand, PutObjectCommand, S3Client} from "@aws-sdk/client-s3";
-import {getSignedUrl} from "@aws-sdk/s3-request-presigner";
-import {DeleteObjectCommandOutput} from "@aws-sdk/client-s3/dist-types/commands";
-
-const BASE_64_IMAGE_REGEX = /^data:image\/\w+;base64,/;
-
-export class AwsS3Utils {
-  static async uploadBase64String(base64Str: string, assetKey: string): Promise<string | undefined> {
-    const bufferData = Buffer.from(base64Str.replace(BASE_64_IMAGE_REGEX, ""), 'base64');
-    const blobData = new Blob([bufferData]);
-    return AwsS3Utils.uploadFile(blobData, assetKey, 'image/jpeg');
-  }
-
-  static async uploadFile(file: Blob, assetKey: string, mimetype: string): Promise<string | undefined> {
-    const preSignedUrl = await AwsS3Utils.createPreSignedUrl(assetKey, mimetype);
-    const assetUrl = AwsS3Utils.createUrlFromAssetKey(assetKey);
-    const uploadSuccessful = await AwsS3Utils.uploadFileViaPreSignedUrl(file, preSignedUrl, mimetype);
-    if (uploadSuccessful) {
-      return assetUrl;
-    }
-  }
-
-  static async uploadFileViaPreSignedUrl(file: Blob,
-                                         preSignedUrl: string | undefined,
-                                         mimetype: string): Promise<boolean> {
-    try {
-      if (!file) {
-        throw new Error('The file data buffer was undefined; no data to upload.');
-      }
-      if (!preSignedUrl) {
-        throw new Error('The pre-signed url for uploading the file was undefined');
-      }
-      console.log(`Uploading with url: ${preSignedUrl}`);
-      const res = await fetch(preSignedUrl, {
-        method: 'PUT',
-        headers: {
-          'Content-Type': mimetype
-        },
-        body: file
-      });
-
-      if (!res.ok) {
-        throw new Error(`Response was not ok when uploading media file.\nStatus, text: ${res.status}, ${res.statusText}`);
-      }
-      return true;
-    }
-    catch (e) {
-      console.error(`Error when uploading file to: ${preSignedUrl}\n${e}`);
-      return false;
-    }
-  }
-
-  static createUrlFromAssetKey(assetKey: string): string {
-    if (!assetKey) {
-      throw new Error(`Cannot create a url with an assetKey that is undefined`);
-    }
-    return `https://${process.env.CLOUDFRONT_ASSETS_URL}/${assetKey}`;
-  }
-
-  static async createPreSignedUrl(key: string | undefined, mimetype: string | undefined): Promise<string> {
-    if (!key || !mimetype) {
-      throw new Error(`Cannot create a pre-signed url without a key or a mimetype`);
-    }
-    const client = new S3Client({
-      credentials: {
-        accessKeyId: String(process.env.AWS_S3_ACCESS_KEY_ID),
-        secretAccessKey: String(process.env.AWS_S3_SECRET_ACCESS_KEY),
-      },
-      region: String(process.env.AWS_S3_REGION),
-    });
-    const command = new PutObjectCommand({
-      Bucket: String(process.env.AWS_S3_ASSETS_BUCKET_NAME),
-      Key: key,
-      ContentType: mimetype
-    });
-    return getSignedUrl(client, command, {
-      expiresIn: 3600,
-    });
-  }
-
-  static async deleteFile(key: string): Promise<DeleteObjectCommandOutput | undefined> {
-    try {
-      const command = new DeleteObjectCommand({
-        Bucket: String(process.env.AWS_S3_BUCKET_NAME),
-        Key: key,
-      });
-      const client = new S3Client({
-        credentials: {
-          accessKeyId: String(process.env.AWS_S3_ACCESS_KEY_ID),
-          secretAccessKey: String(process.env.AWS_S3_SECRET_ACCESS_KEY),
-        },
-        region: String(process.env.AWS_S3_REGION),
-      });
-      return client.send(command);
-    }
-    catch (e: any) {
-      console.error(e);
-    }
-  }
-}
+import {DeleteObjectCommand, PutObjectCommand, S3Client} from "@aws-sdk/client-s3";
+import {getSignedUrl} from "@aws-sdk/s3-request-presigner";
+import {DeleteObjectCommandOutput} from "@aws-sdk/client-s3/dist-types/commands";
+
+const BASE_64_IMAGE_REGEX = /^data:image\/\w+;base64,/;
+
+export class AwsS3Utils {
+  static async uploadBase64String(base64Str: string, assetKey: string): Promise<string | undefined> {
+    const bufferData = Buffer.from(base64Str.replace(BASE_64_IMAGE_REGEX, ""), 'base64');
+    const blobData = new Blob([bufferData]);
+    return AwsS3Utils.uploadFile(blobData, assetKey, 'image/jpeg');
+  }
+
+  static async uploadFile(file: Blob, assetKey: string, mimetype: string): Promise<string | undefined> {
+    const preSignedUrl = await AwsS3Utils.createPreSignedUrl(assetKey, mimetype);
+    const assetUrl = AwsS3Utils.createUrlFromAssetKey(assetKey);
+    const uploadSuccessful = await AwsS3Utils.uploadFileViaPreSignedUrl(file, preSignedUrl, mimetype);
+    if (uploadSuccessful) {
+      return assetUrl;
+    }
+  }
+
+  static async uploadFileViaPreSignedUrl(file: Blob,
+                                         preSignedUrl: string | undefined,
+                                         mimetype: string): Promise<boolean> {
+    try {
+      if (!file) {
+        throw new Error('The file data buffer was undefined; no data to upload.');
+      }
+      if (!preSignedUrl) {
+        throw new Error('The pre-signed url for uploading the file was undefined');
+      }
+      console.log(`Uploading with url: ${preSignedUrl}`);
+      const res = await fetch(preSignedUrl, {
+        method: 'PUT',
+        headers: {
+          'Content-Type': mimetype
+        },
+        body: file
+      });
+
+      if (!res.ok) {
+        throw new Error(`Response was not ok when uploading media file.\nStatus, text: ${res.status}, ${res.statusText}`);
+      }
+      return true;
+    }
+    catch (e) {
+      console.error(`Error when uploading file to: ${preSignedUrl}\n${e}`);
+      return false;
+    }
+  }
+
+  static createUrlFromAssetKey(assetKey: string): string {
+    if (!assetKey) {
+      throw new Error(`Cannot create a url with an assetKey that is undefined`);
+    }
+    return `https://${process.env.CLOUDFRONT_ASSETS_URL}/${assetKey}`;
+  }
+
+  static async createPreSignedUrl(key: string | undefined, mimetype: string | undefined): Promise<string> {
+    if (!key || !mimetype) {
+      throw new Error(`Cannot create a pre-signed url without a key or a mimetype`);
+    }
+    const client = new S3Client({
+      credentials: {
+        accessKeyId: String(process.env.AWS_S3_ACCESS_KEY_ID),
+        secretAccessKey: String(process.env.AWS_S3_SECRET_ACCESS_KEY),
+      },
+      region: String(process.env.AWS_S3_REGION),
+    });
+    const command = new PutObjectCommand({
+      Bucket: String(process.env.AWS_S3_ASSETS_BUCKET_NAME),
+      Key: key,
+      ContentType: mimetype
+    });
+    return getSignedUrl(client, command, {
+      expiresIn: 3600,
+    });
+  }
+
+  static async deleteFile(key: string): Promise<DeleteObjectCommandOutput | undefined> {
+    try {
+      const command = new DeleteObjectCommand({
+        Bucket: String(process.env.AWS_S3_BUCKET_NAME),
+        Key: key,
+      });
+      const client = new S3Client({
+        credentials: {
+          accessKeyId: String(process.env.AWS_S3_ACCESS_KEY_ID),
+          secretAccessKey: String(process.env.AWS_S3_SECRET_ACCESS_KEY),
+        },
+        region: String(process.env.AWS_S3_REGION),
+      });
+      return client.send(command);
+    }
+    catch (e: any) {
+      console.error(e);
+    }
+  }
+}