@8ms/helpers 2.0.16 → 2.0.18

package/aws/s3/AwsS3Namespace.d.ts

@@ -40,14 +40,19 @@ export declare class AwsS3Namespace extends BaseNamespace {
      */
     listFolders: (bucket: string, folder: string) => Promise<string[]>;
     move: (fromBucket: string, fromKey: string, toBucket: string, toKey: string) => Promise<void>;
-    readBrotli: (bucket: string, key: string, isJson?: boolean) => Promise<ReadFileResponse>;
+    readBrotli: (bucket: string, key: string, brotliOptions?: object, awsS3Options?: Options) => Promise<ReadFileResponse>;
+    readJsonBrotli: (bucket: string, key: string, brotliOptions?: object, awsS3Options?: Options) => Promise<ReadFileResponse>;
     readBuffer: (bucket: string, key: string) => Promise<ReadBufferResponse>;
     fileExists: (bucket: string, key: string) => Promise<boolean>;
-    readFile: (bucket: string, key: string, isJson?: boolean) => Promise<ReadFileResponse>;
-    readGzip: (bucket: string, key: string, isJson?: boolean) => Promise<ReadFileResponse>;
-    writeBrotli: (bucket: string, key: string, data: any, isJson?: boolean, options?: Options) => Promise<import("@aws-sdk/client-s3").PutObjectCommandOutput>;
+    readFile: (bucket: string, key: string, options?: Options) => Promise<ReadFileResponse>;
+    readJson: (bucket: string, key: string) => Promise<ReadFileResponse>;
+    readJsonGzip: (bucket: string, key: string, gzipOptions?: object, awsS3Options?: Options) => Promise<ReadFileResponse>;
+    readGzip: (bucket: string, key: string, gzipOptions?: object, awsS3Options?: Options) => Promise<ReadFileResponse>;
+    writeBrotli: (bucket: string, key: string, data: any, brotliOptions?: object, awsS3Options?: Options) => Promise<import("@aws-sdk/client-s3").PutObjectCommandOutput>;
     writeFile: (bucket: string, key: string, data: any, options?: Options) => Promise<import("@aws-sdk/client-s3").PutObjectCommandOutput>;
-    writeGzip: (bucket: string, key: string, data: any, isJson?: boolean, options?: Options) => Promise<import("@aws-sdk/client-s3").PutObjectCommandOutput>;
+    writeJson: (bucket: string, key: string, data: any, options?: Options) => Promise<import("@aws-sdk/client-s3").PutObjectCommandOutput>;
+    writeJsonGzip: (bucket: string, key: string, data: any, gzipOptions?: object, awsS3Options?: Options) => Promise<import("@aws-sdk/client-s3").PutObjectCommandOutput>;
+    writeGzip: (bucket: string, key: string, data: any, gzipOptions?: object, awsS3Options?: Options) => Promise<import("@aws-sdk/client-s3").PutObjectCommandOutput>;
     /**
      * Get a presigned post URL so we can upload directly to S3 via frontend.
      */

package/aws/s3/AwsS3Namespace.js

@@ -206,17 +206,23 @@ class AwsS3Namespace extends _class_1.BaseNamespace {
                 Key: fromKey,
             }));
         };
-        this.readBrotli = async (bucket, key, isJson = true) => {
+        this.readBrotli = async (bucket, key, brotliOptions = {}, awsS3Options = {}) => {
             await this.ensureInit();
-            let response = await this.readFile(bucket, key, isJson);
+            const apiResponse = await this.readFile(bucket, key, awsS3Options);
             // Cache exists and is still within our caching timeframe
-            if (undefined !== response.body) {
-                response.body = await (0, server_2.getBrotliDecompressed)(response.body);
-                if (false !== isJson) {
-                    response.body = JSON.parse(response.body);
-                }
+            if (undefined !== apiResponse.body) {
+                apiResponse.body = await (0, server_2.getBrotliDecompressed)(apiResponse.body, brotliOptions);
             }
-            return response;
+            return apiResponse;
+        };
+        this.readJsonBrotli = async (bucket, key, brotliOptions = {}, awsS3Options = {}) => {
+            await this.ensureInit();
+            const apiResponse = await this.readFile(bucket, key, awsS3Options);
+            if (undefined !== apiResponse.body) {
+                apiResponse.body = await (0, server_2.getBrotliDecompressed)(apiResponse.body, brotliOptions);
+                apiResponse.body = JSON.parse(apiResponse.body) || null;
+            }
+            return apiResponse;
         };
         this.readBuffer = async (bucket, key) => {
             await this.ensureInit();
@@ -264,7 +270,7 @@ class AwsS3Namespace extends _class_1.BaseNamespace {
             }
             return response;
         };
-        this.readFile = async (bucket, key, isJson = true) => {
+        this.readFile = async (bucket, key, options = {}) => {
             await this.ensureInit();
             let response = (0, cloneDeep_1.default)(server_3.readFileDefault);
             const today = (0, date_1.getToday)();
@@ -276,6 +282,7 @@ class AwsS3Namespace extends _class_1.BaseNamespace {
                 const apiResponse = await this.client.send(new GetObjectCommand({
                     Bucket: bucket,
                     Key: key,
+                    ...options,
                 }));
                 //console.log('apiResponse', apiResponse);
                 if ((0, server_1.isResponse200)(apiResponse)) {
@@ -283,19 +290,15 @@ class AwsS3Namespace extends _class_1.BaseNamespace {
                     // Convert the date to unix
                     response.modified.unix = modified.toUnixInteger();
                     // Compare now to unix
-                    response.modified.vs_now.months = today.diff(modified, 'months').months;
-                    response.modified.vs_now.days = today.diff(modified, 'days').days;
-                    response.modified.vs_now.hours = today.diff(modified, 'hours').hours;
-                    response.modified.vs_now.minutes = today.diff(modified, 'minutes').minutes;
+                    response.modified.vs_now.months = today.diff(modified, "months").months;
+                    response.modified.vs_now.days = today.diff(modified, "days").days;
+                    response.modified.vs_now.hours = today.diff(modified, "hours").hours;
+                    response.modified.vs_now.minutes = today.diff(modified, "minutes").minutes;
                     // Compare now to midnight
-                    response.modified.vs_midnight.hours = today.diff(midnight, 'hours').hours;
-                    response.modified.vs_midnight.minutes = today.diff(midnight, 'minutes').hours;
+                    response.modified.vs_midnight.hours = today.diff(midnight, "hours").hours;
+                    response.modified.vs_midnight.minutes = today.diff(midnight, "minutes").hours;
                     // Convert stream into a string
                     response.body = await (0, string_1.getStringFromStream)(apiResponse.Body);
-                    // If we need to return JSON, parse it. On error return undefined
-                    if (false !== isJson) {
-                        response.body = JSON.parse(response.body) || null;
-                    }
                 }
             }
             catch (error) {
@@ -304,29 +307,34 @@ class AwsS3Namespace extends _class_1.BaseNamespace {
             }
             return response;
         };
-        this.readGzip = async (bucket, key, isJson = true) => {
+        this.readJson = async (bucket, key) => {
             await this.ensureInit();
-            let response = await this.readFile(bucket, key, isJson);
-            // Cache exists and is still within our caching timeframe
-            if (undefined !== response.body) {
-                response.body = await (0, server_2.getGzipDecompressed)(response.body);
-                if (false !== isJson) {
-                    response.body = JSON.parse(response.body);
-                }
+            const apiResponse = await this.readFile(bucket, key);
+            apiResponse.body = JSON.parse(apiResponse.body) || null;
+            return apiResponse;
+        };
+        this.readJsonGzip = async (bucket, key, gzipOptions = {}, awsS3Options = {}) => {
+            await this.ensureInit();
+            const apiResponse = await this.readFile(bucket, key, awsS3Options);
+            if (undefined !== apiResponse.body) {
+                apiResponse.body = await (0, server_2.getGzipDecompressed)(apiResponse.body, gzipOptions);
+                apiResponse.body = JSON.parse(apiResponse.body) || null;
             }
-            return response;
+            return apiResponse;
         };
-        this.writeBrotli = async (bucket, key, data, isJson = true, options = {}) => {
+        this.readGzip = async (bucket, key, gzipOptions = {}, awsS3Options = {}) => {
             await this.ensureInit();
-            let finalData = data;
-            if (false !== isJson) {
-                finalData = JSON.stringify(data);
+            const apiResponse = await this.readFile(bucket, key, awsS3Options);
+            if (undefined !== apiResponse.body) {
+                apiResponse.body = await (0, server_2.getGzipDecompressed)(apiResponse.body, gzipOptions);
             }
-            // Compress the data
-            const brotliData = await (0, server_2.getBrotliCompressed)({
-                input: finalData,
-            });
-            const apiResponse = await this.writeFile(bucket, key, brotliData, options);
+            return apiResponse;
+        };
+        this.writeBrotli = async (bucket, key, data, brotliOptions = {}, awsS3Options = {}) => {
+            await this.ensureInit();
+            let finalData = data;
+            finalData = await (0, server_2.getBrotliCompressed)(finalData, brotliOptions);
+            const apiResponse = await this.writeFile(bucket, key, finalData, awsS3Options);
             return apiResponse;
         };
         this.writeFile = async (bucket, key, data, options = {}) => {
@@ -340,15 +348,23 @@ class AwsS3Namespace extends _class_1.BaseNamespace {
             }));
             return apiResponse;
         };
-        this.writeGzip = async (bucket, key, data, isJson = true, options = {}) => {
+        this.writeJson = async (bucket, key, data, options = {}) => {
+            await this.ensureInit();
+            const apiResponse = await this.writeFile(bucket, key, JSON.stringify(data), options);
+            return apiResponse;
+        };
+        this.writeJsonGzip = async (bucket, key, data, gzipOptions = {}, awsS3Options = {}) => {
+            await this.ensureInit();
+            let finalData = JSON.stringify(data);
+            finalData = await (0, server_2.getGzipCompressed)(finalData, gzipOptions);
+            const apiResponse = await this.writeFile(bucket, key, finalData, awsS3Options);
+            return apiResponse;
+        };
+        this.writeGzip = async (bucket, key, data, gzipOptions = {}, awsS3Options = {}) => {
             await this.ensureInit();
             let finalData = data;
-            if (false !== isJson) {
-                finalData = JSON.stringify(data);
-            }
-            // Compress the data
-            const gzipData = await (0, server_2.getGzipCompressed)(finalData);
-            const apiResponse = await this.writeFile(bucket, key, gzipData, options);
+            finalData = await (0, server_2.getGzipCompressed)(finalData, gzipOptions);
+            const apiResponse = await this.writeFile(bucket, key, finalData, awsS3Options);
             return apiResponse;
         };
         /**

package/aws/ses/AwsSesNamespace.d.ts

@@ -1,18 +1,9 @@
 import { BaseNamespace } from "../../_class";
 import { AwsConfig } from "../server";
-import type { SESClient } from "@aws-sdk/client-ses";
-type SendProps = {
-    bcc?: string[];
-    cc?: string[];
-    from?: string;
-    html?: string;
-    subject?: string;
-    to?: string | string[];
-};
+import type { SendEmailCommandInput, SESClient } from "@aws-sdk/client-ses";
 export declare class AwsSesNamespace extends BaseNamespace {
     client: SESClient | null;
     config: AwsConfig | null;
     ensureInit: () => Promise<void>;
-    send: (props: SendProps) => Promise<any>;
+    send: (input: SendEmailCommandInput) => Promise<any>;
 }
-export {};

package/aws/ses/AwsSesNamespace.js

@@ -49,7 +49,7 @@ class AwsSesNamespace extends _class_1.BaseNamespace {
                 }
             }
         };
-        this.send = async (props) => {
+        this.send = async (input) => {
             await this.ensureInit();
             const { SendEmailCommand } = await Promise.resolve().then(() => __importStar(require("@aws-sdk/client-ses")));
             let response;

package/aws/ses/SimpleEmail.d.ts

@@ -27,7 +27,7 @@ export declare class SimpleEmail extends BaseClass {
     setBcc: (recipient: string | string[]) => this;
     setCc: (recipient: string | string[]) => this;
     setTo: (recipient: string | string[]) => this;
-    getEmailParams: () => {
+    getSendParam: () => {
         Destination: {
             BccAddresses: string[];
             CcAddresses: string[];

package/aws/ses/SimpleEmail.js

@@ -42,7 +42,7 @@ class SimpleEmail extends _class_1.BaseClass {
         this.setTo = (recipient) => {
             return this._setArray("to", recipient);
         };
-        this.getEmailParams = () => {
+        this.getSendParam = () => {
             // https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/ses-examples-sending-email.html
             const params = {
                 Destination: {

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@8ms/helpers",
 	"license": "UNLICENSED",
-	"version": "2.0.16",
+	"version": "2.0.18",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/8millionstories-organisation/8ms-helpers-ts.git"

package/util/getGzipCompressed.d.ts

@@ -2,4 +2,4 @@ import { type ZlibOptions } from "zlib";
 /**
  * Compress a given input using Gzip.
  */
-export declare const getGzipCompressed: (input: any, options?: ZlibOptions) => Promise<unknown>;
+export declare const getGzipCompressed: (input: any, options?: ZlibOptions) => Promise<string>;