@webiny/api-file-manager 0.0.0-mt-1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Webiny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,17 @@
+# @webiny/api-file-manager
+[![](https://img.shields.io/npm/dw/@webiny/api-file-manager.svg)](https://www.npmjs.com/package/@webiny/api-file-manager) 
+[![](https://img.shields.io/npm/v/@webiny/api-file-manager.svg)](https://www.npmjs.com/package/@webiny/api-file-manager)
+[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
+
+The API for Webiny Admin's ([@webiny/admin](../app-admin)) File Manager.
+
+## Install
+```
+npm install --save @webiny/api-file-manager
+```
+
+Or if you prefer yarn: 
+```
+yarn add @webiny/api-file-manager
+```

package/handlers/download/index.d.ts

@@ -0,0 +1,3 @@
+import { HandlerPlugin } from "@webiny/handler/types";
+declare const _default: () => HandlerPlugin;
+export default _default;

package/handlers/download/index.js

@@ -0,0 +1,125 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _s = _interopRequireDefault(require("aws-sdk/clients/s3"));
+
+var _sanitizeFilename = _interopRequireDefault(require("sanitize-filename"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _utils = require("../utils");
+
+var _loaders = _interopRequireDefault(require("../transform/loaders"));
+
+const MAX_RETURN_CONTENT_LENGTH = 5000000; // ~4.77MB
+
+const DEFAULT_CACHE_MAX_AGE = 30758400; // 1 year
+
+/**
+ * Based on given path, extracts file key and additional options sent via query params.
+ * @param event
+ */
+
+const extractFilenameOptions = event => {
+  const path = (0, _sanitizeFilename.default)(event.pathParameters.path);
+  return {
+    filename: decodeURI(path),
+    options: event.queryStringParameters,
+    extension: _path.default.extname(path)
+  };
+};
+
+const getS3Object = async (event, s3, context) => {
+  const {
+    options,
+    filename,
+    extension
+  } = extractFilenameOptions(event);
+
+  for (let i = 0; i < _loaders.default.length; i++) {
+    const loader = _loaders.default[i];
+    const canProcess = loader.canProcess({
+      context,
+      s3,
+      options,
+      file: {
+        name: filename,
+        extension
+      }
+    });
+
+    if (canProcess) {
+      return loader.process({
+        context,
+        s3,
+        options,
+        file: {
+          name: filename,
+          extension
+        }
+      });
+    }
+  } // If no processors handled the file request, just return the S3 object by default.
+
+
+  const params = (0, _utils.getObjectParams)(filename);
+  return {
+    object: await s3.getObject(params).promise(),
+    params: params
+  };
+};
+
+var _default = () => ({
+  type: "handler",
+  name: "handler-download-file",
+
+  async handle(context) {
+    const event = context.invocationArgs;
+    const handler = (0, _utils.createHandler)(async event => {
+      const {
+        region
+      } = (0, _utils.getEnvironment)();
+      const s3 = new _s.default({
+        region
+      });
+      const {
+        params,
+        object
+      } = await getS3Object(event, s3, context);
+
+      if (object.ContentLength < MAX_RETURN_CONTENT_LENGTH) {
+        return {
+          data: object.Body,
+          headers: {
+            "Content-Type": object.ContentType,
+            "Cache-Control": "public, max-age=" + DEFAULT_CACHE_MAX_AGE
+          }
+        };
+      } // Lambda can return max 6MB of content, so if our object's size is larger, we are sending
+      // a 301 Redirect, redirecting the user to the public URL of the object in S3.
+
+
+      await s3.putObjectAcl({
+        Bucket: params.Bucket,
+        ACL: "public-read",
+        Key: params.Key
+      }).promise();
+      return {
+        statusCode: 301,
+        headers: {
+          Location: `https://${params.Bucket}.s3.amazonaws.com/${params.Key}`
+        }
+      };
+    });
+    return await handler(event);
+  }
+
+});
+
+exports.default = _default;

package/handlers/manage/index.d.ts

@@ -0,0 +1,3 @@
+import { HandlerPlugin } from "@webiny/handler/types";
+declare const _default: () => HandlerPlugin;
+export default _default;

package/handlers/manage/index.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _s = _interopRequireDefault(require("aws-sdk/clients/s3"));
+
+var _utils = require("../utils");
+
+var _managers = _interopRequireDefault(require("../transform/managers"));
+
+var _default = () => ({
+  type: "handler",
+  name: "handler-download-file",
+
+  async handle(context) {
+    const event = context.invocationArgs;
+    const handler = (0, _utils.createHandler)(async event => {
+      const keys = [];
+
+      for (let i = 0; i < event.Records.length; i++) {
+        const record = event.Records[i];
+
+        if (typeof record.s3.object.key === "string") {
+          keys.push(record.s3.object.key);
+        }
+      }
+
+      const {
+        region
+      } = (0, _utils.getEnvironment)();
+      const s3 = new _s.default({
+        region
+      });
+
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+
+        const extension = _path.default.extname(key);
+
+        for (let j = 0; j < _managers.default.length; j++) {
+          const manager = _managers.default[j];
+          const canProcess = manager.canProcess({
+            s3,
+            key,
+            extension
+          });
+
+          if (canProcess) {
+            await manager.process({
+              s3,
+              key,
+              extension
+            });
+          }
+        }
+      }
+    });
+    return await handler(event);
+  }
+
+});
+
+exports.default = _default;

package/handlers/transform/index.d.ts

@@ -0,0 +1,3 @@
+import { HandlerPlugin } from "@webiny/handler/types";
+declare const _default: () => HandlerPlugin;
+export default _default;

package/handlers/transform/index.js

@@ -0,0 +1,96 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _s = _interopRequireDefault(require("aws-sdk/clients/s3"));
+
+var _transformImage = _interopRequireDefault(require("./transformImage"));
+
+var _optimizeImage = _interopRequireDefault(require("./optimizeImage"));
+
+var _utils = require("../utils");
+
+var _utils2 = require("./utils");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var _default = () => ({
+  type: "handler",
+  name: "handler-download-file",
+
+  async handle(context) {
+    const event = context.invocationArgs;
+    const handler = (0, _utils.createHandler)(async ({
+      body: {
+        transformations,
+        key
+      }
+    }) => {
+      try {
+        const env = (0, _utils.getEnvironment)();
+        const s3 = new _s.default({
+          region: env.region
+        });
+        let optimizedImageObject;
+        const params = {
+          initial: (0, _utils.getObjectParams)(key),
+          optimized: (0, _utils.getObjectParams)((0, _utils2.getImageKey)({
+            key
+          })),
+          optimizedTransformed: (0, _utils.getObjectParams)((0, _utils2.getImageKey)({
+            key,
+            transformations
+          }))
+        }; // 1. Get optimized image.
+
+        try {
+          optimizedImageObject = await s3.getObject(params.optimized).promise();
+        } catch (e) {
+          // If not found, try to create it by loading the initially uploaded image.
+          optimizedImageObject = await s3.getObject(params.initial).promise();
+          await s3.putObject(_objectSpread(_objectSpread({}, params.optimized), {}, {
+            ContentType: optimizedImageObject.ContentType,
+            Body: await (0, _optimizeImage.default)(optimizedImageObject.Body, optimizedImageObject.ContentType)
+          })).promise();
+          optimizedImageObject = await s3.getObject(params.optimized).promise();
+        } // 2. If no transformations requested, just exit.
+
+
+        if (!transformations) {
+          return {
+            error: false,
+            message: ""
+          };
+        } // 3. If transformations requested, apply them in save it into the bucket.
+
+
+        await s3.putObject(_objectSpread(_objectSpread({}, params.optimizedTransformed), {}, {
+          ContentType: optimizedImageObject.ContentType,
+          Body: await (0, _transformImage.default)(optimizedImageObject.Body, transformations)
+        })).promise();
+        return {
+          error: false,
+          message: ""
+        };
+      } catch (e) {
+        return {
+          error: true,
+          message: e.message
+        };
+      }
+    });
+    return await handler(event);
+  }
+
+});
+
+exports.default = _default;

package/handlers/transform/loaders/imageLoader.d.ts

@@ -0,0 +1,13 @@
+declare const _default: {
+    canProcess: (opts: any) => boolean;
+    process({ s3, file, options, context }: {
+        s3: any;
+        file: any;
+        options: any;
+        context: any;
+    }): Promise<{
+        object: any;
+        params: any;
+    }>;
+};
+export default _default;

package/handlers/transform/loaders/imageLoader.js

@@ -0,0 +1,106 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _sanitizeImageTransformations = _interopRequireDefault(require("./sanitizeImageTransformations"));
+
+var _utils = require("../../utils");
+
+var _utils2 = require("../utils");
+
+// @ts-ignore
+const IMAGE_TRANSFORMER_FUNCTION = process.env.IMAGE_TRANSFORMER_FUNCTION;
+
+const callImageTransformerLambda = async ({
+  key,
+  transformations,
+  context
+}) => {
+  return await context.handlerClient.invoke({
+    name: IMAGE_TRANSFORMER_FUNCTION,
+    payload: {
+      body: {
+        key,
+        transformations
+      }
+    }
+  });
+};
+
+var _default = {
+  canProcess: opts => {
+    return _utils2.SUPPORTED_IMAGES.includes(opts.file.extension);
+  },
+
+  async process({
+    s3,
+    file,
+    options,
+    context
+  }) {
+    // Loaders must return {object, params} object.
+    let objectParams;
+    const transformations = (0, _sanitizeImageTransformations.default)(options);
+
+    if (transformations && _utils2.SUPPORTED_TRANSFORMABLE_IMAGES.includes(file.extension)) {
+      objectParams = (0, _utils.getObjectParams)((0, _utils2.getImageKey)({
+        key: file.name,
+        transformations
+      }));
+
+      try {
+        return {
+          object: await s3.getObject(objectParams).promise(),
+          params: objectParams
+        };
+      } catch (e) {
+        const imageTransformerLambdaResponse = await callImageTransformerLambda({
+          key: file.name,
+          transformations,
+          context
+        });
+
+        if (imageTransformerLambdaResponse.error) {
+          throw Error(imageTransformerLambdaResponse.message);
+        }
+
+        return {
+          object: await s3.getObject(objectParams).promise(),
+          params: objectParams
+        };
+      }
+    }
+
+    objectParams = (0, _utils.getObjectParams)((0, _utils2.getImageKey)({
+      key: file.name
+    }));
+
+    try {
+      return {
+        object: await s3.getObject(objectParams).promise(),
+        params: objectParams
+      };
+    } catch (e) {
+      const imageTransformerLambdaResponse = await callImageTransformerLambda({
+        key: file.name,
+        context
+      });
+
+      if (imageTransformerLambdaResponse.error) {
+        throw Error(imageTransformerLambdaResponse.message);
+      }
+
+      return {
+        object: await s3.getObject(objectParams).promise(),
+        params: objectParams
+      };
+    }
+  }
+
+};
+exports.default = _default;

package/handlers/transform/loaders/index.d.ts

@@ -0,0 +1,13 @@
+declare const _default: {
+    canProcess: (opts: any) => boolean;
+    process({ s3, file, options, context }: {
+        s3: any;
+        file: any;
+        options: any;
+        context: any;
+    }): Promise<{
+        object: any;
+        params: any;
+    }>;
+}[];
+export default _default;

package/handlers/transform/loaders/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _imageLoader = _interopRequireDefault(require("./imageLoader"));
+
+var _default = [_imageLoader.default];
+exports.default = _default;

package/handlers/transform/loaders/sanitizeImageTransformations.d.ts

@@ -0,0 +1,7 @@
+declare const _default: (args: any) => {
+    [key: string]: any;
+};
+/**
+ * Takes only allowed transformations into consideration, and discards the rest.
+ */
+export default _default;

package/handlers/transform/loaders/sanitizeImageTransformations.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const SUPPORTED_IMAGE_RESIZE_WIDTHS = [100, 300, 500, 750, 1000, 1500, 2500];
+/**
+ * Takes only allowed transformations into consideration, and discards the rest.
+ */
+
+var _default = args => {
+  const transformations = {};
+
+  if (args) {
+    const width = parseInt(args.width);
+
+    if (width > 0) {
+      transformations.width = SUPPORTED_IMAGE_RESIZE_WIDTHS[0];
+      let i = SUPPORTED_IMAGE_RESIZE_WIDTHS.length;
+
+      while (i >= 0) {
+        if (width === SUPPORTED_IMAGE_RESIZE_WIDTHS[i]) {
+          transformations.width = SUPPORTED_IMAGE_RESIZE_WIDTHS[i];
+          break;
+        }
+
+        if (width > SUPPORTED_IMAGE_RESIZE_WIDTHS[i]) {
+          // Use next larger width. If there isn't any, use current.
+          transformations.width = SUPPORTED_IMAGE_RESIZE_WIDTHS[i + 1];
+
+          if (!transformations.width) {
+            transformations.width = SUPPORTED_IMAGE_RESIZE_WIDTHS[i];
+          }
+
+          break;
+        }
+
+        i--;
+      }
+    }
+  }
+
+  if (Object.keys(transformations).length > 0) {
+    return transformations;
+  }
+
+  return null;
+};
+
+exports.default = _default;

package/handlers/transform/managers/imageManager.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    canProcess: (opts: any) => boolean;
+    process({ s3, key, extension }: {
+        s3: any;
+        key: any;
+        extension: any;
+    }): Promise<void>;
+};
+export default _default;

package/handlers/transform/managers/imageManager.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _utils = require("../../utils");
+
+var _utils2 = require("../utils");
+
+var _default = {
+  canProcess: opts => {
+    const {
+      key,
+      extension
+    } = opts;
+
+    if (!_utils2.SUPPORTED_IMAGES.includes(extension)) {
+      return false;
+    }
+
+    if (key.startsWith(_utils2.OPTIMIZED_IMAGE_PREFIX || key.startsWith(_utils2.OPTIMIZED_TRANSFORMED_IMAGE_PREFIX))) {
+      return false;
+    }
+
+    return true;
+  },
+
+  async process({
+    s3,
+    key,
+    extension
+  }) {
+    // 1. Get optimized image's key.
+    await s3.deleteObject((0, _utils.getObjectParams)((0, _utils2.getImageKey)({
+      key
+    }))).promise(); // 2. Search for all transformed images and delete those too.
+
+    if (_utils2.SUPPORTED_TRANSFORMABLE_IMAGES.includes(extension)) {
+      const env = (0, _utils.getEnvironment)();
+      const imagesList = await s3.listObjects({
+        Bucket: env.bucket,
+        Prefix: (0, _utils2.getOptimizedTransformedImageKeyPrefix)(key)
+      }).promise();
+
+      for (let i = 0; i < imagesList.Contents.length; i++) {
+        const imageObject = imagesList.Contents[i];
+        await s3.deleteObject((0, _utils.getObjectParams)(imageObject.Key)).promise();
+      }
+    }
+  }
+
+};
+exports.default = _default;

package/handlers/transform/managers/index.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    canProcess: (opts: any) => boolean;
+    process({ s3, key, extension }: {
+        s3: any;
+        key: any;
+        extension: any;
+    }): Promise<void>;
+}[];
+export default _default;

package/handlers/transform/managers/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _imageManager = _interopRequireDefault(require("./imageManager"));
+
+var _default = [_imageManager.default];
+exports.default = _default;

package/handlers/transform/optimizeImage.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (buffer: any, type: any) => Promise<any>;
+export default _default;