@pi-r/aws-v3 0.0.1

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2023 An Pham
+
+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,5 @@
+### @pi-r/aws-v3
+
+### LICENSE
+
+MIT

package/client/index.js

@@ -0,0 +1,285 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeBatchQuery = exports.executeQuery = exports.deleteObjectsV2 = exports.deleteObjects = exports.setBucketWebsite = exports.setBucketPolicy = exports.createBucketV2 = exports.createBucket = exports.validateDatabase = exports.validateStorage = exports.createDatabaseClient = exports.createStorageClient = void 0;
+const aws_1 = require("@pi-r/aws");
+const util_1 = require("@e-mc/cloud/util");
+const types_1 = require("@e-mc/types");
+const Module = require("@e-mc/module");
+const Cloud = require("@e-mc/cloud");
+function setCannedAcl(S3, client, Bucket, ACL, service = 'aws-v3', recursive) {
+    let Policy;
+    switch (ACL) {
+        case 1:
+            Policy = (0, aws_1.getBucketPublicReadPolicy)(Bucket);
+            break;
+        case 'private':
+            Policy = (0, aws_1.getPrivatePolicy)(Bucket);
+            break;
+        default:
+            Policy = (0, aws_1.getPublicReadPolicy)(Bucket, ACL === 'authenticated-read', ACL === 'public-read-write');
+            break;
+    }
+    return client.send(new S3.PutBucketPolicyCommand({ Bucket, Policy }))
+        .then(() => {
+        this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ['Grant ' + ACL, Bucket], '', { ...recursive ? Cloud.LOG_CLOUD_DELAYED : Cloud.LOG_CLOUD_COMMAND });
+    })
+        .catch((err) => {
+        if (!recursive && err instanceof Error) {
+            if (err.name === 'OperationAborted') {
+                setTimeout(() => setCannedAcl.call(this, S3, client, Bucket, ACL, service, true), 60000 /* TIME.m */);
+                this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, [`Grant ${ACL} (delayed)`, err.Endpoint || Bucket], err, { ...Cloud.LOG_CLOUD_DELAYED });
+            }
+            else {
+                this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ['Unable to grant ' + ACL, err.Endpoint || Bucket], err, { ...Cloud.LOG_CLOUD_WARN });
+            }
+        }
+    });
+}
+function sanitizeCredentials(credential) {
+    const result = credential.credentials || (credential.credentials = {});
+    for (const attr in credential) {
+        switch (attr) {
+            case 'accessKeyId':
+            case 'secretAccessKey':
+            case 'sessionToken':
+            case 'expiration':
+                if (typeof result !== 'function') {
+                    result[attr] = credential[attr];
+                }
+                delete credential[attr];
+                break;
+        }
+    }
+    return result;
+}
+const isNoSuchBucket = (err) => err instanceof Error && err.name === 'NoSuchBucket';
+function createStorageClient(credential, service = 'aws-v3', sdk = '@aws-sdk/client-s3') {
+    try {
+        sanitizeCredentials(credential);
+        const expiration = credential.credentials?.expiration;
+        if (expiration && !(expiration instanceof Date)) {
+            delete credential.expiration;
+        }
+        const AWS = require(sdk);
+        return [new AWS.S3Client(credential), AWS];
+    }
+    catch (err) {
+        this.checkPackage(err, sdk.split('/')[0], { passThrough: true });
+        throw err;
+    }
+}
+exports.createStorageClient = createStorageClient;
+function createDatabaseClient(credential) {
+    try {
+        const AWS = require('@aws-sdk/lib-dynamodb');
+        const { DynamoDBClient } = require('@aws-sdk/client-dynamodb');
+        return [AWS.DynamoDBDocumentClient.from(new DynamoDBClient(credential), credential.translateConfig), AWS];
+    }
+    catch (err) {
+        this.checkPackage(err, '@aws-sdk', { passThrough: true });
+        throw err;
+    }
+}
+exports.createDatabaseClient = createDatabaseClient;
+function validateStorage(credential) {
+    const credentials = sanitizeCredentials(credential);
+    if (credential.profile || !credentials && process.env.AWS_SDK_LOAD_CONFIG === '1') {
+        const { fromIni } = require('@aws-sdk/credential-provider-ini');
+        credential.credentials = fromIni({ profile: credential.profile });
+        return true;
+    }
+    return !!credentials && (typeof credentials === 'function' || (0, aws_1.isAccessDefined)(credentials) || (0, aws_1.isEnvDefined)());
+}
+exports.validateStorage = validateStorage;
+function validateDatabase(credential, data) {
+    return (0, aws_1.isDatabaseDefined)(credential, data) && validateStorage(credential);
+}
+exports.validateDatabase = validateDatabase;
+function createBucket(credential, Bucket, publicRead, service = 'aws-v3', sdk = '@aws-sdk/client-s3') {
+    return createBucketV2.call(this, credential, Bucket, publicRead ? 'public-read' : undefined, undefined, service, sdk);
+}
+exports.createBucket = createBucket;
+function createBucketV2(credential, Bucket, ACL, options, service = 'aws-v3', sdk = '@aws-sdk/client-s3') {
+    ACL = ACL === 1 ? 1 : (0, aws_1.checkBucketCannedACL)(ACL);
+    const [client, AWS] = createStorageClient.call(this, credential, service, sdk);
+    return client.send(new AWS.HeadBucketCommand({ Bucket }))
+        .then(async () => {
+        if (ACL) {
+            await setCannedAcl.call(this, AWS, client, Bucket, ACL, service);
+        }
+        return true;
+    })
+        .catch(() => {
+        const input = { ...options, Bucket };
+        const region = credential.region;
+        if (!input.CreateBucketConfiguration && typeof region === 'string' && region !== 'us-east-1') {
+            input.CreateBucketConfiguration = { LocationConstraint: region };
+        }
+        return client.send(new AWS.CreateBucketCommand(input))
+            .then(async () => {
+            this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Bucket created" /* VAL_CLOUD.CREATE_BUCKET */, Bucket], '', { ...Cloud.LOG_CLOUD_COMMAND });
+            if (ACL) {
+                await setCannedAcl.call(this, AWS, client, Bucket, ACL, service);
+            }
+            return true;
+        })
+            .catch(async (err) => {
+            switch (err instanceof Error && err.name) {
+                case 'BucketAlreadyExists':
+                case 'BucketAlreadyOwnedByYou':
+                    if (ACL) {
+                        await setCannedAcl.call(this, AWS, client, Bucket, ACL, service);
+                    }
+                    return true;
+                default:
+                    this.formatFail(64 /* LOG_TYPE.CLOUD */, service, ["Unable to create bucket" /* ERR_CLOUD.CREATE_BUCKET */, Bucket], err, { ...Cloud.LOG_CLOUD_FAIL });
+                    return false;
+            }
+        });
+    });
+}
+exports.createBucketV2 = createBucketV2;
+function setBucketPolicy(credential, Bucket, options, service = 'aws', sdk = 'aws-sdk/clients/s3') {
+    const [client, AWS] = createStorageClient.call(this, credential, service, sdk);
+    const policy = 'Policy' in options && !('ACL' in options);
+    options.Bucket = Bucket;
+    return (policy ? client.send(new AWS.PutBucketPolicyCommand(options)) : client.send(new AWS.PutBucketAclCommand(options)))
+        .then(() => {
+        this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, [policy ? "Bucket policy configured" /* VAL_CLOUD.POLICY_BUCKET */ : "Bucket ACL configured" /* VAL_CLOUD.ACL_BUCKET */, Bucket], '', { ...Cloud.LOG_CLOUD_COMMAND });
+        return true;
+    })
+        .catch(err => {
+        if (!isNoSuchBucket(err)) {
+            this.formatFail(64 /* LOG_TYPE.CLOUD */, service, ["Unable to update bucket policy" /* ERR_CLOUD.POLICY_BUCKET */, Bucket], err, { ...Cloud.LOG_CLOUD_FAIL, fatal: false });
+        }
+        return false;
+    });
+}
+exports.setBucketPolicy = setBucketPolicy;
+function setBucketWebsite(credential, Bucket, options, service = 'aws', sdk = 'aws-sdk/clients/s3') {
+    const [client, AWS] = createStorageClient.call(this, credential, service, sdk);
+    const WebsiteConfiguration = {};
+    if ((0, types_1.isString)(options.indexPage)) {
+        WebsiteConfiguration.IndexDocument = { Suffix: options.indexPage };
+    }
+    if ((0, types_1.isString)(options.errorPage)) {
+        WebsiteConfiguration.ErrorDocument = { Key: options.errorPage };
+    }
+    return client.send(new AWS.PutBucketWebsiteCommand({ Bucket, WebsiteConfiguration }))
+        .then(() => {
+        this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Bucket configured" /* VAL_CLOUD.CONFIGURE_BUCKET */, Bucket], WebsiteConfiguration, { ...Cloud.LOG_CLOUD_COMMAND });
+        return true;
+    })
+        .catch(err => {
+        if (!isNoSuchBucket(err)) {
+            this.formatFail(64 /* LOG_TYPE.CLOUD */, service, ["Unable to configure bucket" /* ERR_CLOUD.CONFIGURE_BUCKET */, Bucket], err, { ...Cloud.LOG_CLOUD_FAIL, fatal: false });
+        }
+        return false;
+    });
+}
+exports.setBucketWebsite = setBucketWebsite;
+function deleteObjects(credential, Bucket, service, sdk) {
+    return deleteObjectsV2.call(this, credential, Bucket, true, service, sdk);
+}
+exports.deleteObjects = deleteObjects;
+async function deleteObjectsV2(credential, Bucket, recursive = true, service = 'aws-v3', sdk = '@aws-sdk/client-s3') {
+    const [client, AWS] = createStorageClient.call(this, credential, service, sdk);
+    return client.send(new AWS.ListObjectsCommand({ Bucket }))
+        .then(({ Contents }) => {
+        if (Contents?.length) {
+            let Objects = Contents.map(data => ({ Key: data.Key }));
+            if (!recursive) {
+                Objects = Objects.filter(value => value.Key.indexOf('/') === -1);
+            }
+            return client.send(new AWS.DeleteObjectsCommand({ Bucket, Delete: { Objects } }))
+                .then(data => {
+                if ((0, types_1.isArray)(data.Deleted)) {
+                    const files = data.Deleted.length + ' files';
+                    this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["Bucket emptied" /* VAL_CLOUD.EMPTY_BUCKET */ + ` (${recursive ? 'recursive' : files})`, Bucket], recursive ? files : '', { ...Cloud.LOG_CLOUD_COMMAND });
+                }
+            })
+                .catch(err => {
+                this.formatFail(64 /* LOG_TYPE.CLOUD */, service, ["Unable to empty bucket" /* ERR_CLOUD.DELETE_BUCKET */, Bucket], err, { ...Cloud.LOG_CLOUD_FAIL, fatal: false });
+            });
+        }
+    })
+        .catch(err => {
+        if (!isNoSuchBucket(err)) {
+            this.formatFail(64 /* LOG_TYPE.CLOUD */, service, ["Unable to list bucket" /* ERR_CLOUD.LIST_BUCKET */, Bucket], err, { ...Cloud.LOG_CLOUD_FAIL, fatal: false });
+        }
+    });
+}
+exports.deleteObjectsV2 = deleteObjectsV2;
+async function executeQuery(credential, data, sessionKey) {
+    return (await executeBatchQuery.call(this, credential, [data], sessionKey))[0] || [];
+}
+exports.executeQuery = executeQuery;
+async function executeBatchQuery(credential, batch, sessionKey) {
+    const length = batch.length;
+    const result = new Array(length);
+    const caching = length > 0 && this.hasCache(batch[0].service, sessionKey);
+    const cacheValue = { value: this.valueOfKey(credential, 'cache'), sessionKey };
+    let client;
+    const createClient = () => client || (client = createDatabaseClient.call(this, length === 1 ? credential : { ...credential }));
+    const closeClient = () => client?.[0].destroy();
+    for (let i = 0; i < length; ++i) {
+        const item = batch[i];
+        const { service, table, id = '', query, partitionKey, key = partitionKey, limit = 0, update, ignoreCache } = item;
+        if (!table) {
+            closeClient();
+            throw (0, util_1.formatError)(item, "Missing database table" /* ERR_DB.TABLE */);
+        }
+        (0, aws_1.setDatabaseEndpoint)(credential);
+        const renewCache = ignoreCache === 0;
+        const getCache = (value) => {
+            if (ignoreCache === 1) {
+                return;
+            }
+            cacheValue.renewCache = renewCache;
+            return this.getQueryResult(service, credential, value, cacheValue);
+        };
+        let rows, queryString = caching && ignoreCache !== true || ignoreCache === false || ignoreCache === 1 || renewCache ? table + '_' : '';
+        if (key && (id || (0, types_1.isPlainObject)(key))) {
+            if (queryString) {
+                queryString += Module.asString(key, true) + id;
+                if (!update && (rows = getCache(queryString))) {
+                    result[i] = rows;
+                    continue;
+                }
+            }
+            const [db, AWS] = createClient();
+            const Key = (0, types_1.isPlainObject)(key) ? key : { [key]: id };
+            const command = { TableName: table, Key };
+            if (update) {
+                await db.send(new AWS.UpdateCommand({ ...command, ...update }));
+            }
+            const output = await db.send(new AWS.GetCommand(command));
+            if (output.Item) {
+                rows = [output.Item];
+            }
+        }
+        else if ((0, types_1.isPlainObject)(query)) {
+            if (queryString && (rows = getCache(queryString += Module.asString(query, true) + limit))) {
+                result[i] = rows;
+                continue;
+            }
+            query.TableName = table;
+            if (limit > 0) {
+                query.Limit = limit;
+            }
+            const [db, AWS] = createClient();
+            const output = await db.send(new AWS.QueryCommand(query));
+            if (output.Count && output.Items) {
+                rows = output.Items;
+            }
+        }
+        else {
+            closeClient();
+            throw (0, util_1.formatError)(item, "Missing database query" /* ERR_DB.QUERY */);
+        }
+        result[i] = this.setQueryResult(service, credential, queryString, rows, cacheValue);
+    }
+    closeClient();
+    return result;
+}
+exports.executeBatchQuery = executeBatchQuery;

package/download/index.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = require("../client");
+const util_1 = require("@e-mc/cloud/util");
+const types_1 = require("@e-mc/types");
+const Module = require("@e-mc/module");
+const Cloud = require("@e-mc/cloud");
+function download(config, service = 'aws-v3', sdk = '@aws-sdk/client-s3') {
+    const [client, AWS] = client_1.createStorageClient.call(this, config, service, sdk);
+    return (data, callback) => {
+        const { bucket: Bucket, download: target } = data;
+        const Key = target.filename;
+        if (!Bucket || !Key) {
+            callback((0, types_1.errorValue)('Missing property', !Bucket ? 'Bucket' : 'Key'));
+            return;
+        }
+        const location = Module.joinPath(Bucket, Key);
+        let input = { Bucket, Key, VersionId: target.versionId };
+        // @ts-ignore
+        client
+            .send(new AWS.GetObjectCommand(input), { abortSignal: this.signal })
+            .then(result => {
+            (0, util_1.readableAsBuffer)(result.Body).then(buffer => callback(null, buffer)).catch(err => callback(err));
+            const deleteObject = target.deleteObject;
+            if (deleteObject) {
+                if ((0, types_1.isPlainObject)(deleteObject)) {
+                    input = Object.assign(deleteObject, input);
+                }
+                client.send(new AWS.DeleteObjectCommand(input))
+                    .then(() => this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, "Delete success" /* VAL_CLOUD.DELETE_FILE */, location, { ...Cloud.LOG_CLOUD_DELETE }))
+                    .catch(err => this.formatFail(64 /* LOG_TYPE.CLOUD */, service, ["Delete failed" /* ERR_CLOUD.DELETE_FAIL */, location], err, { ...Cloud.LOG_CLOUD_FAIL, fatal: !!target.active }));
+            }
+        })
+            .catch(err => callback(err));
+    };
+}
+
+module.exports = download;

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@pi-r/aws-v3",
+  "version": "0.0.1",
+  "description": "AWS V3 cloud functions for E-mc.",
+  "main": "client/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anpham6/pi-r.git",
+    "directory": "src/cloud/aws-v3"
+  },
+  "keywords": [
+    "squared",
+    "e-mc",
+    "squared-functions"
+  ],
+  "author": "An Pham <anpham6@gmail.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/anpham6/pi-r#readme",
+  "dependencies": {
+    "@e-mc/cloud": "^0.4.0",
+    "@e-mc/module": "^0.4.0",
+    "@e-mc/types": "^0.4.0",
+    "@pi-r/aws": "^0.0.1",
+    "@aws-sdk/client-dynamodb": "^3.293.0",
+    "@aws-sdk/client-s3": "^3.293.0",
+    "@aws-sdk/lib-dynamodb": "^3.293.0"
+  }
+}

package/upload/index.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fs = require("fs");
+const stream = require("stream");
+const client_1 = require("../client");
+const util_1 = require("@e-mc/cloud/util");
+const aws_1 = require("@pi-r/aws");
+const types_1 = require("@e-mc/types");
+const Module = require("@e-mc/module");
+const Cloud = require("@e-mc/cloud");
+const BUCKET_SESSION = new Set();
+const BUCKET_RESPONSE = {};
+function upload(credential, service = 'aws-v3', sdk = '@aws-sdk/client-s3') {
+    const [client, AWS] = client_1.createStorageClient.call(this, credential, service, sdk);
+    return async (data, callback) => {
+        var _a;
+        const { bucket: Bucket, localUri } = data;
+        const { pathname = '', fileGroup, contentType, metadata, endpoint, active, publicRead, acl, admin = {}, overwrite, options } = data.upload;
+        let filename = data.upload.filename || path.basename(localUri), bucketKey;
+        const cleanup = () => {
+            BUCKET_SESSION.delete(service + Bucket);
+            if (bucketKey && bucketKey in BUCKET_RESPONSE) {
+                delete BUCKET_RESPONSE[bucketKey];
+            }
+        };
+        const errorResponse = (err) => {
+            cleanup();
+            callback(err);
+            return false;
+        };
+        if (!BUCKET_SESSION.has(service + Bucket)) {
+            const bucketAcl = admin.publicRead ? 'public-read' : admin.acl;
+            const response = BUCKET_RESPONSE[_a = bucketKey = (0, aws_1.getBucketKey)(credential, Bucket, bucketAcl, service, sdk)] || (BUCKET_RESPONSE[_a] = client_1.createBucketV2.call(this, credential, Bucket, bucketAcl, admin.configBucket?.create, service, sdk));
+            if (!await response) {
+                errorResponse(null);
+                return;
+            }
+            BUCKET_SESSION.add(service + Bucket);
+        }
+        if (!overwrite) {
+            const current = filename;
+            const next = (0, util_1.generateFilename)(filename);
+            let i = 0, exists;
+            do {
+                if (i > 0) {
+                    [filename, exists] = next(i);
+                    if (!exists) {
+                        break;
+                    }
+                }
+                exists = await client.send(new AWS.HeadObjectCommand({ Bucket, Key: pathname ? Module.joinPath(pathname, filename) : filename }))
+                    .then(() => true)
+                    .catch(err => {
+                    if (err instanceof Error && err.name !== 'NotFound') {
+                        filename = (0, types_1.generateUUID)() + path.extname(current);
+                        return true;
+                    }
+                    return false;
+                });
+            } while (exists && ++i);
+            if (i > 0) {
+                this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, ["File renamed" /* VAL_CLOUD.RENAME_FILE */, current], filename, { ...Cloud.LOG_CLOUD_WARN });
+            }
+        }
+        if (pathname) {
+            await client.send(new AWS.PutObjectCommand({ Bucket, Key: pathname, Body: Buffer.from(''), ContentLength: 0 })).catch(() => { });
+        }
+        const Key = [filename];
+        const Body = [data.buffer];
+        const ContentType = [contentType];
+        const addLog = (err) => err instanceof Error && this.addLog(this.statusType.WARN, err.message, service + ': ' + Bucket);
+        if (fileGroup) {
+            for (const [content, ext, localFile] of fileGroup) {
+                try {
+                    Body.push(typeof content === 'string' ? fs.readFileSync(content) : content);
+                    Key.push(ext === '.map' && localFile ? path.basename(localFile) : filename + ext);
+                }
+                catch (err) {
+                    addLog(err);
+                }
+            }
+        }
+        for (let i = 0; i < Key.length; ++i) {
+            const first = i === 0;
+            if (this.aborted) {
+                if (first) {
+                    errorResponse((0, types_1.createAbortError)());
+                }
+                return;
+            }
+            const objectKey = Module.joinPath(pathname, Key[i]);
+            let params;
+            try {
+                params = { ...options, Bucket, Key: pathname + Key[i], Body: stream.Readable.from(Body[i]) };
+                const readable = publicRead || active && publicRead !== false && !acl;
+                if (first) {
+                    params.ContentType || (params.ContentType = ContentType[i]);
+                    if (readable) {
+                        params.ACL = 'public-read';
+                    }
+                    else if (acl) {
+                        params.ACL = acl;
+                    }
+                    if (metadata) {
+                        params.Metadata = metadata;
+                    }
+                }
+                else {
+                    params.ContentType = ContentType[i];
+                    if (!params.ACL) {
+                        if (readable) {
+                            params.ACL = 'public-read';
+                        }
+                        else if (acl) {
+                            params.ACL = acl;
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                if (first) {
+                    errorResponse(err);
+                    return;
+                }
+                if (err instanceof Error) {
+                    this.addLog(this.statusType.WARN, err.message, service + ': ' + Bucket);
+                }
+                continue;
+            }
+            // @ts-ignore
+            client.send(new AWS.PutObjectCommand(params), { abortSignal: this.signal })
+                .then(() => {
+                const url = endpoint ? Module.joinPath(endpoint, objectKey) : Module.joinPath(`https://${Bucket}.s3.${!credential.region || credential.region === 'us-east-1' ? 'us-east-1.' : ''}amazonaws.com`, objectKey);
+                if (first) {
+                    cleanup();
+                    callback(null, url);
+                }
+                this.formatMessage(64 /* LOG_TYPE.CLOUD */, service, "Upload success" /* VAL_CLOUD.UPLOAD_FILE */, url, { ...Cloud.LOG_CLOUD_UPLOAD });
+            })
+                .catch(err => {
+                if (first) {
+                    errorResponse(err);
+                }
+                else {
+                    addLog(err);
+                }
+            });
+        }
+    };
+}
+
+module.exports = upload;