@lucidcms/plugin-s3/dist/index.js

The official S3 plugin for Lucid

// src/clients/s3-client.ts
import { S3Client } from "@aws-sdk/client-s3";
var s3Client = null;
var getS3Client = (pluginOptions) => {
  if (!s3Client) {
    s3Client = new S3Client(pluginOptions.clientConfig);
  }
  return s3Client;
};
var s3_client_default = getS3Client;

// src/translations/en-gb.json
var en_gb_default = {
  object_body_undefined: "The object get request Body is undefined.",
  object_missing_metadata: "An error occurred while fetching the object metadata."
};

// src/translations/index.ts
var selectedLang = en_gb_default;
var T = (key, data) => {
  const translation = selectedLang[key];
  if (!translation) {
    return key;
  }
  if (!data) {
    return translation;
  }
  return translation.replace(
    /\{\{(\w+)\}\}/g,
    (_, p1) => data[p1]
  );
};
var translations_default = T;

// src/services/steam.ts
import { GetObjectCommand } from "@aws-sdk/client-s3";
var steam_default = (client, pluginOptions) => {
  const stream = async (key) => {
    try {
      const command = new GetObjectCommand({
        Bucket: pluginOptions.bucket,
        Key: key
      });
      const response = await client.send(command);
      if (response.Body === void 0) {
        return {
          error: {
            message: translations_default("object_body_undefined")
          },
          data: void 0
        };
      }
      return {
        error: void 0,
        data: {
          contentLength: response.ContentLength,
          contentType: response.ContentType,
          body: response.Body
        }
      };
    } catch (e) {
      const error = e;
      return {
        error: {
          message: error.message
        },
        data: void 0
      };
    }
  };
  return stream;
};

// src/services/delete-single.ts
import { DeleteObjectCommand } from "@aws-sdk/client-s3";
var delete_single_default = (client, pluginOptions) => {
  const deletSingle = async (key) => {
    try {
      const command = new DeleteObjectCommand({
        Bucket: pluginOptions.bucket,
        Key: key
      });
      await client.send(command);
      return {
        error: void 0,
        data: void 0
      };
    } catch (e) {
      const error = e;
      return {
        error: {
          message: error.message
        },
        data: void 0
      };
    }
  };
  return deletSingle;
};

// src/services/delete-multiple.ts
import { DeleteObjectsCommand } from "@aws-sdk/client-s3";
var delete_multiple_default = (client, pluginOptions) => {
  const deleteMultiple = async (keys) => {
    try {
      const command = new DeleteObjectsCommand({
        Bucket: pluginOptions.bucket,
        Delete: {
          Objects: keys.map((k) => ({
            Key: k
          }))
        }
      });
      await client.send(command);
      return {
        error: void 0,
        data: void 0
      };
    } catch (e) {
      const error = e;
      return {
        error: {
          message: error.message
        },
        data: void 0
      };
    }
  };
  return deleteMultiple;
};

// src/services/upload-single.ts
import { PutObjectCommand } from "@aws-sdk/client-s3";
var upload_single_default = (client, pluginOptions) => {
  const uploadSingle = async (props) => {
    try {
      const command = new PutObjectCommand({
        Bucket: pluginOptions.bucket,
        Key: props.key,
        Body: props.data,
        ContentType: props.meta.mimeType,
        Metadata: {
          width: props.meta.width?.toString() || "",
          height: props.meta.height?.toString() || "",
          extension: props.meta.extension || ""
        }
      });
      const response = await client.send(command);
      return {
        error: void 0,
        data: {
          etag: response.ETag?.replace(/"/g, "")
        }
      };
    } catch (e) {
      const error = e;
      return {
        error: {
          message: error.message
        },
        data: void 0
      };
    }
  };
  return uploadSingle;
};

// src/services/get-presigned-url.ts
import { PutObjectCommand as PutObjectCommand2 } from "@aws-sdk/client-s3";
import { getSignedUrl } from "@aws-sdk/s3-request-presigner";

// src/constants.ts
var PLUGIN_KEY = "plugin-s3";
var LUCID_VERSION = "0.x.x";
var PRESIGNED_URL_EXPIRY = 3600;

// src/services/get-presigned-url.ts
var get_presigned_url_default = (client, pluginOptions) => {
  const getPresignedUrl = async (key, meta) => {
    try {
      const command = new PutObjectCommand2({
        Bucket: pluginOptions.bucket,
        Key: key,
        ContentType: meta.mimeType,
        Metadata: {
          extension: meta.extension || ""
        }
      });
      const response = await getSignedUrl(client, command, {
        expiresIn: PRESIGNED_URL_EXPIRY
      });
      return {
        error: void 0,
        data: {
          url: response
        }
      };
    } catch (e) {
      const error = e;
      return {
        error: {
          message: error.message
        },
        data: void 0
      };
    }
  };
  return getPresignedUrl;
};

// src/services/get-metadata.ts
import { HeadObjectCommand } from "@aws-sdk/client-s3";
var get_metadata_default = (client, pluginOptions) => {
  const getMetadata = async (key) => {
    try {
      const command = new HeadObjectCommand({
        Bucket: pluginOptions.bucket,
        Key: key
      });
      const response = await client.send(command);
      if (response.ContentLength === void 0) {
        return {
          error: {
            message: translations_default("object_missing_metadata")
          },
          data: void 0
        };
      }
      return {
        error: void 0,
        data: {
          size: response.ContentLength,
          mimeType: response.ContentType || null,
          etag: response.ETag || null
        }
      };
    } catch (e) {
      const error = e;
      return {
        error: {
          message: error.message
        },
        data: void 0
      };
    }
  };
  return getMetadata;
};

// src/plugin.ts
var plugin = async (config, pluginOptions) => {
  const client = s3_client_default(pluginOptions);
  config.media = {
    ...config.media,
    strategy: {
      getPresignedUrl: get_presigned_url_default(client, pluginOptions),
      getMeta: get_metadata_default(client, pluginOptions),
      stream: steam_default(client, pluginOptions),
      uploadSingle: upload_single_default(client, pluginOptions),
      deleteSingle: delete_single_default(client, pluginOptions),
      deleteMultiple: delete_multiple_default(client, pluginOptions)
    }
  };
  return {
    key: PLUGIN_KEY,
    lucid: LUCID_VERSION,
    config
  };
};
var plugin_default = plugin;

// src/index.ts
var lucidS3Plugin = (pluginOptions) => (config) => plugin_default(config, pluginOptions);
var src_default = lucidS3Plugin;
export {
  src_default as default
};
//# sourceMappingURL=index.js.map