@8ms/helpers 2.3.5 → 2.3.6

package/aws/s3/server/AwsS3Namespace.js

@@ -1,364 +0,0 @@
-import { BaseNamespace } from "../../../_class";
-import { isResponse200 } from "../../server";
-import { getFolder, getStringFromStream } from "../../../string";
-import { getBrotliCompressed, getBrotliDecompressed, getGzipCompressed, getGzipDecompressed } from "../../../util/server";
-import { readFileDefault } from "./";
-import cloneDeep from "lodash/cloneDeep";
-import { getToday, getYmdHisString } from "../../../date";
-import get from "axios";
-export class AwsS3Namespace extends BaseNamespace {
-    ensureInit = async () => {
-        if (!this.client) {
-            try {
-                const { S3Client } = await import("@aws-sdk/client-s3");
-                this.client = new S3Client(this.config);
-            }
-            catch (e) {
-                throw new Error("AWS S3 Client not installed");
-            }
-        }
-    };
-    copy = async (fromBucket, fromKey, toBucket, toKey) => {
-        await this.ensureInit();
-        const { CopyObjectCommand } = await import("@aws-sdk/client-s3");
-        await this.client.send(new CopyObjectCommand({
-            Bucket: toBucket,
-            CopySource: encodeURIComponent(`${fromBucket}/${fromKey}`),
-            Key: toKey,
-        }));
-    };
-    deleteFile = async (bucket, key) => {
-        await this.ensureInit();
-        const { DeleteObjectCommand } = await import("@aws-sdk/client-s3");
-        await this.client.send(new DeleteObjectCommand({
-            Bucket: bucket,
-            Key: key,
-        }));
-    };
-    deleteFiles = async (bucket, keys) => {
-        await this.ensureInit();
-        const { DeleteObjectsCommand } = await import("@aws-sdk/client-s3");
-        await this.client.send(new DeleteObjectsCommand({
-            Bucket: bucket,
-            Delete: {
-                Objects: keys.map(key => ({
-                    Key: key,
-                })),
-            },
-        }));
-    };
-    deleteFolder = async (bucket, folder) => {
-        await this.ensureInit();
-        const { ListObjectsV2Command, DeleteObjectsCommand } = await import("@aws-sdk/client-s3");
-        const cleanFolder = getFolder(folder);
-        // Get a list of all files to be deleted
-        const apiResponse = await this.client.send(new ListObjectsV2Command({
-            Bucket: bucket,
-            Prefix: ("" === cleanFolder ? "" : cleanFolder + "/"),
-        }));
-        // No files to be deleted
-        if (apiResponse.Contents.length === 0) {
-            return;
-        }
-        // Map each of the files
-        const keys = apiResponse.Contents.map(file => ({ Key: file.Key }));
-        // Delete the files
-        await this.client.send(new DeleteObjectsCommand({
-            Bucket: bucket,
-            Delete: {
-                Objects: keys,
-            },
-        }));
-        // If we didn't get all files, run it again
-        if (apiResponse.IsTruncated) {
-            await this.deleteFolder(bucket, folder);
-        }
-    };
-    /**
-     * List the files in the given bucket and option folder
-     */
-    listFiles = async (bucket, folder = "") => {
-        await this.ensureInit();
-        const { ListObjectsV2Command } = await import("@aws-sdk/client-s3");
-        const cleanFolder = getFolder(folder);
-        let response = [];
-        let valid = [];
-        const apiResponse = await this.client.send(new ListObjectsV2Command({
-            Bucket: bucket,
-            Delimiter: "/",
-            Prefix: ("" === cleanFolder ? "" : cleanFolder + "/"),
-        }));
-        // Ensure the data exists
-        if (undefined !== apiResponse["Contents"]) {
-            // Return an array of files
-            valid = apiResponse["Contents"].filter(content => {
-                const keyExploded = content["Key"].split("/");
-                return keyExploded[keyExploded.length - 1].indexOf(".") > -1;
-            });
-            if (valid.length) {
-                response = valid.map(entry => entry["Key"]);
-            }
-        }
-        return response;
-    };
-    /**
-     * Fetch all the files within a given directory recursively
-     */
-    filesIteratively = async (bucket, folder) => {
-        await this.ensureInit();
-        const response = await this.iterateFolders(bucket, folder);
-        return response;
-    };
-    /**
-     * Sub function
-     */
-    iterateFolders = async (bucket, folder) => {
-        let response = [];
-        const folders = await this.listFolders(bucket, folder);
-        for (let i = 0; i < folders.length; i++) {
-            const subFolderFiles = await this.listFolders(bucket, `${folder}/${folders[i]}`);
-            const files = await this.listFiles(bucket, `${folder}/${folders[i]}`);
-            response = [
-                ...response,
-                ...files,
-                ...subFolderFiles,
-            ];
-        }
-        return response;
-    };
-    /**
-     * List the files in the given bucket and option folder.
-     */
-    listFolders = async (bucket, folder) => {
-        await this.ensureInit();
-        const { ListObjectsV2Command } = await import("@aws-sdk/client-s3");
-        const cleanFolder = getFolder(folder);
-        let response = [];
-        const apiResponse = await this.client.send(new ListObjectsV2Command({
-            Bucket: bucket,
-            Delimiter: "/",
-            Prefix: ("" === cleanFolder ? "" : cleanFolder + "/"),
-        }));
-        // Ensure the data exists
-        if (undefined !== apiResponse["CommonPrefixes"]) {
-            // Return an array of folders removing the trailing folder
-            response = apiResponse["CommonPrefixes"].map(prefix => {
-                // Remove the trailing slash then split by slash
-                const fileFolders = prefix.Prefix.slice(0, -1)
-                    .split("/");
-                // Return the last folder without a trailing slash
-                return fileFolders[fileFolders.length - 1];
-            });
-        }
-        return response;
-    };
-    move = async (fromBucket, fromKey, toBucket, toKey) => {
-        await this.ensureInit();
-        const { CopyObjectCommand, DeleteObjectCommand } = await import("@aws-sdk/client-s3");
-        await this.client.send(new CopyObjectCommand({
-            Bucket: toBucket,
-            CopySource: encodeURIComponent(`${fromBucket}/${fromKey}`),
-            Key: toKey,
-        }));
-        await this.client.send(new DeleteObjectCommand({
-            Bucket: fromBucket,
-            Key: fromKey,
-        }));
-    };
-    readBrotli = async (bucket, key, brotliOptions = {}, awsS3Options = {}) => {
-        await this.ensureInit();
-        const apiResponse = await this.readFile(bucket, key, awsS3Options);
-        // Cache exists and is still within our caching timeframe
-        if (undefined !== apiResponse.body) {
-            apiResponse.body = await getBrotliDecompressed(apiResponse.body, brotliOptions);
-        }
-        return apiResponse;
-    };
-    readJsonBrotli = async (bucket, key, brotliOptions = {}, awsS3Options = {}) => {
-        await this.ensureInit();
-        const apiResponse = await this.readFile(bucket, key, awsS3Options);
-        if (undefined !== apiResponse.body) {
-            apiResponse.body = await getBrotliDecompressed(apiResponse.body, brotliOptions);
-            apiResponse.body = JSON.parse(apiResponse.body) || null;
-        }
-        return apiResponse;
-    };
-    readBuffer = async (bucket, key) => {
-        await this.ensureInit();
-        const { GetObjectCommand } = await import("@aws-sdk/client-s3");
-        let response = {
-            ...readFileDefault,
-            buffer: undefined,
-        };
-        const apiResponse = await this.client.send(new GetObjectCommand({
-            Bucket: bucket,
-            Key: key,
-        }));
-        if (isResponse200(apiResponse)) {
-            const chunks = [];
-            // Store the response
-            response.buffer = await new Promise((resolve, reject) => {
-                // @ts-ignore
-                apiResponse.Body.on("data", (chunk) => chunks.push(chunk));
-                // @ts-ignore
-                apiResponse.Body.on("error", (err) => reject(err));
-                // @ts-ignore
-                apiResponse.Body.on("end", () => resolve(Buffer.concat(chunks)));
-            });
-        }
-        else {
-            throw new Error("Error reading file.");
-        }
-        return response;
-    };
-    fileExists = async (bucket, key) => {
-        await this.ensureInit();
-        let response = false;
-        try {
-            const { HeadObjectCommand } = await import("@aws-sdk/client-s3");
-            // Fetch from S3
-            const apiResponse = await this.client.send(new HeadObjectCommand({
-                Bucket: bucket,
-                Key: key,
-            }));
-            // If the status is 200 then it does exist
-            response = isResponse200(apiResponse);
-        }
-        catch (exception) {
-            response = false;
-        }
-        return response;
-    };
-    readFile = async (bucket, key, options = {}) => {
-        await this.ensureInit();
-        let response = cloneDeep(readFileDefault);
-        const today = getToday();
-        const midnight = getToday(true);
-        try {
-            response.now = today.toUnixInteger();
-            const { GetObjectCommand } = await import("@aws-sdk/client-s3");
-            //console.log('GetObjectCommand', GetObjectCommand);
-            const apiResponse = await this.client.send(new GetObjectCommand({
-                Bucket: bucket,
-                Key: key,
-                ...options,
-            }));
-            //console.log('apiResponse', apiResponse);
-            if (isResponse200(apiResponse)) {
-                // Convert the date to unix
-                response.modified = getYmdHisString(apiResponse.LastModified);
-                // Convert stream into a string
-                response.body = await getStringFromStream(apiResponse.Body);
-            }
-        }
-        catch (error) {
-            response.body = null;
-            response.error = error;
-        }
-        return response;
-    };
-    readJson = async (bucket, key) => {
-        await this.ensureInit();
-        const apiResponse = await this.readFile(bucket, key);
-        apiResponse.body = JSON.parse(apiResponse.body) || null;
-        return apiResponse;
-    };
-    readJsonGzip = async (bucket, key, gzipOptions = {}, awsS3Options = {}) => {
-        await this.ensureInit();
-        const apiResponse = await this.readFile(bucket, key, awsS3Options);
-        if (undefined !== apiResponse.body) {
-            apiResponse.body = await getGzipDecompressed(apiResponse.body, gzipOptions);
-            apiResponse.body = JSON.parse(apiResponse.body) || null;
-        }
-        return apiResponse;
-    };
-    readGzip = async (bucket, key, gzipOptions = {}, awsS3Options = {}) => {
-        await this.ensureInit();
-        const apiResponse = await this.readFile(bucket, key, awsS3Options);
-        if (undefined !== apiResponse.body) {
-            apiResponse.body = await getGzipDecompressed(apiResponse.body, gzipOptions);
-        }
-        return apiResponse;
-    };
-    writeBrotli = async (bucket, key, data, brotliOptions = {}, awsS3Options = {}) => {
-        await this.ensureInit();
-        let finalData = data;
-        finalData = await getBrotliCompressed(finalData, brotliOptions);
-        const apiResponse = await this.writeFile(bucket, key, finalData, awsS3Options);
-        return apiResponse;
-    };
-    writeFile = async (bucket, key, data, options = {}) => {
-        await this.ensureInit();
-        const { PutObjectCommand } = await import("@aws-sdk/client-s3");
-        const apiResponse = await this.client.send(new PutObjectCommand({
-            Bucket: bucket,
-            Body: data,
-            Key: key,
-            ...options,
-        }));
-        return apiResponse;
-    };
-    writeJson = async (bucket, key, data, options = {}) => {
-        await this.ensureInit();
-        const apiResponse = await this.writeFile(bucket, key, JSON.stringify(data), options);
-        return apiResponse;
-    };
-    writeJsonGzip = async (bucket, key, data, gzipOptions = {}, awsS3Options = {}) => {
-        await this.ensureInit();
-        let finalData = JSON.stringify(data);
-        finalData = await getGzipCompressed(finalData, gzipOptions);
-        const apiResponse = await this.writeFile(bucket, key, finalData, awsS3Options);
-        return apiResponse;
-    };
-    writeGzip = async (bucket, key, data, gzipOptions = {}, awsS3Options = {}) => {
-        await this.ensureInit();
-        let finalData = data;
-        finalData = await getGzipCompressed(finalData, gzipOptions);
-        const apiResponse = await this.writeFile(bucket, key, finalData, awsS3Options);
-        return apiResponse;
-    };
-    /**
-     * Get a presigned post URL so we can upload directly to S3 via frontend.
-     */
-    presignedPost = async (props) => {
-        await this.ensureInit();
-        return new Promise(async (resolve, reject) => {
-            let response = null;
-            const formData = new FormData();
-            Object.entries({ fields: props.fields, file: props.file })
-                .forEach(([key, value]) => {
-                formData.append(key, value);
-            });
-            const upload = await fetch(props.url, {
-                method: "POST",
-                body: formData,
-            });
-            // Uploaded to S3
-            if (upload.ok) {
-                response = `https://${props.bucket}.s3.${this.config.region}.amazonaws.com/${props.key}`;
-                resolve(response);
-            }
-            // Failed to upload to S3
-            else {
-                response = null;
-                reject(response);
-            }
-        });
-    };
-    /**
-     * Download a file and write to S3.
-     */
-    urlContents = async (bucket, key, url) => {
-        await this.ensureInit();
-        return get(url, {
-            responseType: "arraybuffer",
-            responseEncoding: "binary",
-        })
-            .then(async (response) => {
-            await this.writeFile(bucket, response.data, key, {
-                ContentType: response.headers["content-type"],
-                ContentLength: response.headers["content-length"],
-            });
-        });
-    };
-}

package/aws/s3/server/awsS3.d.ts

@@ -1,13 +0,0 @@
-import { AwsS3Namespace } from "./AwsS3Namespace";
-import { AwsConfig } from "../../server";
-export declare const awsS3Client: (key?: string, config?: AwsConfig, vaultId?: string, itemId?: string) => Promise<AwsS3Namespace>;
-export type Modified = {
-    now: number;
-    modified: string;
-};
-export type ReadFileResponse = Modified & {
-    body: any;
-    error: any;
-};
-export declare const readFileDefault: ReadFileResponse;
-export { payloadSchema, PayloadSchemaType } from "./payload";

package/aws/s3/server/awsS3.js

@@ -1,20 +0,0 @@
-import { AwsS3Namespace } from "./AwsS3Namespace";
-import { getConfig } from "../../server";
-import { defaultDateTime } from "../../../date";
-const awsS3Namespaces = new Map();
-export const awsS3Client = async (key = "default", config, vaultId, itemId) => {
-    if (awsS3Namespaces.has(key)) {
-        return awsS3Namespaces.get(key);
-    }
-    const instanceConfig = await getConfig(key, config, vaultId, itemId);
-    const namespace = new AwsS3Namespace(key, instanceConfig);
-    awsS3Namespaces.set(key, namespace);
-    return namespace;
-};
-export const readFileDefault = {
-    body: undefined,
-    now: undefined,
-    error: undefined,
-    modified: defaultDateTime,
-};
-export { payloadSchema } from "./payload";

package/aws/s3/server/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./awsS3";
-export * from "./AwsS3Namespace";
-export * from "./payload";

package/aws/s3/server/index.js

@@ -1,3 +0,0 @@
-export * from "./awsS3";
-export * from "./AwsS3Namespace";
-export * from "./payload";

package/aws/s3/server/payload.d.ts

@@ -1,42 +0,0 @@
-import { z } from "zod/v4";
-/**
- * https://docs.aws.amazon.com/AmazonS3/latest/userguide/notification-content-structure.html
- */
-export declare const payloadSchema: z.ZodObject<{
-    Records: z.ZodArray<z.ZodObject<{
-        eventVersion: z.ZodString;
-        eventSource: z.ZodString;
-        awsRegion: z.ZodString;
-        eventTime: z.ZodString;
-        eventName: z.ZodString;
-        userIdentity: z.ZodObject<{
-            principalId: z.ZodString;
-        }, z.core.$strip>;
-        requestParameters: z.ZodObject<{
-            sourceIPAddress: z.ZodString;
-        }, z.core.$strip>;
-        responseElements: z.ZodObject<{
-            "x-amz-request-id": z.ZodString;
-            "x-amz-id-2": z.ZodString;
-        }, z.core.$strip>;
-        s3: z.ZodObject<{
-            s3SchemaVersion: z.ZodString;
-            configurationId: z.ZodString;
-            bucket: z.ZodObject<{
-                name: z.ZodString;
-                ownerIdentity: z.ZodObject<{
-                    principalId: z.ZodString;
-                }, z.core.$strip>;
-                arn: z.ZodString;
-            }, z.core.$strip>;
-            object: z.ZodObject<{
-                key: z.ZodString;
-                size: z.ZodString;
-                eTag: z.ZodString;
-                versionId: z.ZodOptional<z.ZodString>;
-                sequencer: z.ZodString;
-            }, z.core.$strip>;
-        }, z.core.$strip>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type PayloadSchemaType = z.infer<typeof payloadSchema>;

package/aws/s3/server/payload.js

@@ -1,43 +0,0 @@
-import { z } from "zod/v4";
-/**
- * https://docs.aws.amazon.com/AmazonS3/latest/userguide/notification-content-structure.html
- */
-export const payloadSchema = z.object({
-    Records: z.object({
-        eventVersion: z.string(),
-        eventSource: z.string(),
-        awsRegion: z.string(),
-        eventTime: z.string(),
-        eventName: z.string(),
-        userIdentity: z.object({
-            principalId: z.string(),
-        }),
-        requestParameters: z.object({
-            sourceIPAddress: z.string(),
-        }),
-        responseElements: z.object({
-            "x-amz-request-id": z.string(),
-            "x-amz-id-2": z.string(),
-        }),
-        s3: z.object({
-            s3SchemaVersion: z.string(),
-            configurationId: z.string(),
-            bucket: z.object({
-                name: z.string(),
-                ownerIdentity: z.object({
-                    principalId: z.string(),
-                }),
-                arn: z.string(),
-            }),
-            object: z.object({
-                key: z.string(),
-                size: z.string(),
-                eTag: z.string(),
-                versionId: z.string()
-                    .optional(),
-                sequencer: z.string(),
-            })
-        }),
-    })
-        .array(),
-});

package/aws/server/aws.d.ts

@@ -1,9 +0,0 @@
-export type AwsConfig = {
-    region: string;
-    credentials: {
-        accessKeyId: string;
-        secretAccessKey: string;
-    };
-};
-export declare const getConfig: (key: any, config?: AwsConfig, vaultId?: string, itemId?: string) => Promise<AwsConfig>;
-export { isResponse200 } from "./isResponse200";

package/aws/server/aws.js

@@ -1,29 +0,0 @@
-import { onePasswordClient } from "../../onePassword/server";
-export const getConfig = async (key, config, vaultId, itemId) => {
-    let response;
-    if (config) {
-        response = config;
-    }
-    else if (vaultId && itemId) {
-        response = await (await onePasswordClient())
-            .getJsonNote(vaultId, itemId);
-    }
-    else if (process.env.AWS_VAULT_ID && process.env.AWS_ITEM_ID) {
-        response = await (await onePasswordClient())
-            .getJsonNote(process.env.AWS_VAULT_ID, process.env.AWS_ITEM_ID);
-    }
-    else if (process.env.AWS_ACCESS_KEY_ID && process.env.AWS_REGION && process.env.AWS_SECRET_ACCESS_KEY) {
-        response = {
-            region: process.env.AWS_REGION,
-            credentials: {
-                accessKeyId: process.env.AWS_ACCESS_KEY_ID,
-                secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
-            }
-        };
-    }
-    else {
-        throw new Error(`Config required for namespace '${key}'`);
-    }
-    return response;
-};
-export { isResponse200 } from "./isResponse200";

package/aws/server/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./aws";
-export * from "./isResponse200";

package/aws/server/index.js

@@ -1,2 +0,0 @@
-export * from "./aws";
-export * from "./isResponse200";

package/aws/server/isResponse200.d.ts

@@ -1,4 +0,0 @@
-/**
- * Was the API response a 200?
- */
-export declare const isResponse200: (apiResponse: any) => boolean;

package/aws/server/isResponse200.js

@@ -1,12 +0,0 @@
-import { defaultTo } from "../../util";
-/**
- * Was the API response a 200?
- */
-export const isResponse200 = (apiResponse) => {
-    let response = false;
-    const responseCode = defaultTo(apiResponse, ["$metadata", "httpStatusCode"], 0);
-    if (200 === responseCode) {
-        response = true;
-    }
-    return response;
-};

package/aws/ses/server/AwsSesNamespace.d.ts

@@ -1,9 +0,0 @@
-import { BaseNamespace } from "../../../_class";
-import { AwsConfig } from "../../server";
-import { SendEmailCommandInput, SendRawEmailCommandInput, SESClient } from "@aws-sdk/client-ses";
-export declare class AwsSesNamespace extends BaseNamespace {
-    client: SESClient;
-    config: AwsConfig;
-    ensureInit: () => Promise<void>;
-    send: (input: SendEmailCommandInput | SendRawEmailCommandInput) => Promise<any>;
-}

package/aws/ses/server/AwsSesNamespace.js

@@ -1,41 +0,0 @@
-import { BaseNamespace } from "../../../_class";
-export class AwsSesNamespace extends BaseNamespace {
-    ensureInit = async () => {
-        if (!this.client) {
-            try {
-                const { SESClient } = await import("@aws-sdk/client-ses");
-                this.client = new SESClient(this.config);
-            }
-            catch (e) {
-                throw new Error("AWS SES Client not installed");
-            }
-        }
-    };
-    send = async (input) => {
-        await this.ensureInit();
-        let response;
-        // For a simple message
-        if (input?.Message?.Body?.Html?.Data) {
-            try {
-                const { SendEmailCommand } = await import("@aws-sdk/client-ses");
-                const command = new SendEmailCommand(input);
-                response = await this.client.send(command);
-            }
-            catch (exception) {
-                response = exception;
-            }
-        }
-        // For a message with attachments
-        else {
-            try {
-                const { SendRawEmailCommand } = await import("@aws-sdk/client-ses");
-                const command = new SendRawEmailCommand(input);
-                response = await this.client.send(command);
-            }
-            catch (exception) {
-                response = exception;
-            }
-        }
-        return response;
-    };
-}