@openstax/ts-utils 1.9.1 → 1.12.0

package/dist/cjs/config/envConfig.d.ts

@@ -1,4 +1,4 @@
-import { ConfigValueProvider } from '.';
+import type { ConfigValueProvider } from '.';
 /**
  * A list of environment variables that were requested at build time. Used by webpack to
  * capture build-time environment variables values.
@@ -21,4 +21,4 @@ export declare const ENV_BUILD_CONFIGS: string[];
  *
  * @example const config = { configValue: envConfig('environment_variable_name') };
  */
-export declare const envConfig: (name: string, type?: 'build' | 'runtime', defaultValue?: ConfigValueProvider<string> | undefined) => ConfigValueProvider<string>;
+export declare const envConfig: (name: string, type?: "build" | "runtime" | undefined, defaultValue?: ConfigValueProvider<string> | undefined) => ConfigValueProvider<string>;

package/dist/cjs/config/envConfig.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.envConfig = exports.ENV_BUILD_CONFIGS = void 0;
-const _1 = require(".");
+const resolveConfigValue_1 = require("./resolveConfigValue");
 /**
  * A list of environment variables that were requested at build time. Used by webpack to
  * capture build-time environment variables values.
@@ -24,7 +24,12 @@ exports.ENV_BUILD_CONFIGS = [];
  *
  * @example const config = { configValue: envConfig('environment_variable_name') };
  */
-const envConfig = (name, type = 'build', defaultValue) => {
+const envConfig = (name, type, defaultValue) => {
+    // this doesn't use a default parameter value because of a:
+    //   "Regular parameters should not come after default parameters."
+    // error that occurs when the defaultValue optional default of `undefined`
+    // gets optimized out, causing a problem in cloudfront functions.
+    type !== null && type !== void 0 ? type : (type = 'build');
     if (type === 'build') {
         exports.ENV_BUILD_CONFIGS.push(name);
     }
@@ -33,17 +38,19 @@ const envConfig = (name, type = 'build', defaultValue) => {
         // @ts-ignore - hack to get around the way webpack/define works
         // - https://github.com/webpack/webpack/issues/14800
         // - https://github.com/webpack/webpack/issues/5392
-        const envs = { ...process.env, ...(typeof __PROCESS_ENV !== 'undefined' ? __PROCESS_ENV : {}) };
-        if (envs[name] === undefined) {
+        // also, spread operator not supported in cloudfront functions
+        const envs = Object.assign({}, process.env, typeof __PROCESS_ENV !== 'undefined' ? __PROCESS_ENV : {});
+        const value = envs[name];
+        if (value === undefined) {
             if (defaultValue === undefined) {
                 throw new Error(`expected to find environment variable with name: ${name}`);
             }
             else {
-                return (0, _1.resolveConfigValue)(defaultValue);
+                return (0, resolveConfigValue_1.resolveConfigValue)(defaultValue);
             }
         }
         else {
-            return envs[name];
+            return value;
         }
     };
 };

package/dist/cjs/config/resolveConfigValue.d.ts

@@ -1,4 +1,4 @@
-import { ConfigValueProvider } from '.';
+import type { ConfigValueProvider } from '.';
 /**
  * resolves a config value into a string, to be used inside of things that are provided configurations
  */

package/dist/cjs/errors/index.js

@@ -1,4 +1,6 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionExpiredError = exports.NotFoundError = exports.UnauthorizedError = exports.InvalidRequestError = exports.isAppError = void 0;
 /*
  * if code is split into multiple bundles, sometimes each bundle
  * will get its own definition of this module and then instanceof checks
@@ -11,10 +13,8 @@
  *   error instanceof InvalidRequestError
  *
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SessionExpiredError = exports.NotFoundError = exports.UnauthorizedError = exports.InvalidRequestError = exports.isAppError = void 0;
-const errorIsType = ({ TYPE }) => (e) => e instanceof Error
-    && e.constructor.TYPE === TYPE;
+const errorIsType = (t) => (e) => e instanceof Error
+    && e.constructor.TYPE === t.TYPE;
 /**
  * Returns true if the error is defined in this library
  */

package/dist/cjs/services/authProvider/browser.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.browserAuthProvider = void 0;
+const lodash_1 = require("lodash");
 const __1 = require("../..");
 const config_1 = require("../../config");
+const errors_1 = require("../../errors");
 const guards_1 = require("../../guards");
 const helpers_1 = require("../../routing/helpers");
 const embeddedAuthProvider_1 = require("./utils/embeddedAuthProvider");
@@ -12,14 +14,14 @@ const browserAuthProvider = ({ window, configSpace }) => (configProvider) => {
     const accountsBase = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.accountsBase));
     const queryString = window.location.search;
     const queryKey = 'auth';
-    const authQuery = new URLSearchParams(queryString).get(queryKey);
+    const urlSearchParams = new URLSearchParams(queryString);
+    const authQuery = urlSearchParams.get(queryKey);
     const referrer = window.document.referrer ? new URL(window.document.referrer) : undefined;
     const isEmbedded = window.parent !== window;
     const trustedParent = isEmbedded && referrer && referrer.hostname.match(/^(openstax\.org|((.*)(\.openstax\.org|local|localhost)))$/) ? referrer : undefined;
-    const { embeddedQueryValue, getAuthorizedEmbedUrl } = (0, embeddedAuthProvider_1.embeddedAuthProvider)(() => getUserData(), { queryKey, window });
-    let userData = {
-        token: [null, embeddedQueryValue].includes(authQuery) ? null : authQuery
-    };
+    const { embeddedQueryKey, embeddedQueryValue, getAuthorizedEmbedUrl } = (0, embeddedAuthProvider_1.embeddedAuthProvider)(() => getUserData(), { authQuery: { key: queryKey, value: authQuery }, window });
+    const embeddedQuery = urlSearchParams.get(embeddedQueryKey);
+    let userData = { token: authQuery };
     const getAuthToken = async () => {
         return (await getUserData()).token;
     };
@@ -35,6 +37,12 @@ const browserAuthProvider = ({ window, configSpace }) => (configProvider) => {
         if (authQuery) {
             url.searchParams.set(queryKey, authQuery);
         }
+        else if (embeddedQuery) {
+            url.searchParams.set(queryKey, 'embedded');
+        }
+        if (embeddedQuery) {
+            url.searchParams.set(embeddedQueryKey, embeddedQuery);
+        }
         return url.href;
     };
     // *note* that this does not actually prevent cookies from being sent on same-origin
@@ -86,10 +94,23 @@ const browserAuthProvider = ({ window, configSpace }) => (configProvider) => {
         throw new Error(`Error response from Accounts ${response.status}: ${message}`);
     };
     const getUserData = (0, __1.once)(async () => {
-        userData = authQuery === embeddedQueryValue
-            ? await getParentWindowUser()
-            : await getFetchUser();
-        return userData;
+        // For backwards compatibility
+        if (authQuery === 'embedded') {
+            return getParentWindowUser();
+        }
+        // getFetchUser() will throw here if authQuery is not set
+        if (embeddedQuery !== embeddedQueryValue) {
+            return getFetchUser();
+        }
+        const userDataFromParentWindow = await getParentWindowUser();
+        if (!authQuery) {
+            return userDataFromParentWindow;
+        }
+        const userDataFromAuthQuery = await getFetchUser();
+        if ((0, lodash_1.isEqual)(userDataFromAuthQuery, userDataFromParentWindow)) {
+            return userDataFromAuthQuery;
+        }
+        throw new errors_1.UnauthorizedError();
     });
     const getUser = async () => {
         return (await getUserData()).user;

package/dist/cjs/services/authProvider/decryption.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decryptionAuthProvider = void 0;
 const resolveConfigValue_1 = require("../../config/resolveConfigValue");
+const errors_1 = require("../../errors");
 const guards_1 = require("../../guards");
 const helpers_1 = require("../../misc/helpers");
 const decryptAndVerify_1 = require("./utils/decryptAndVerify");
@@ -25,7 +26,11 @@ const decryptionAuthProvider = (initializer) => (configProvider) => {
             if (!token) {
                 return undefined;
             }
-            return (0, decryptAndVerify_1.decryptAndVerify)(token, await encryptionPrivateKey(), await signaturePublicKey());
+            const result = (0, decryptAndVerify_1.decryptAndVerify)(token, await encryptionPrivateKey(), await signaturePublicKey());
+            if ('error' in result && result.error == 'expired token') {
+                throw new errors_1.SessionExpiredError();
+            }
+            return 'user' in result ? result.user : undefined;
         };
         return {
             getAuthorizedFetchConfig,

package/dist/cjs/services/authProvider/utils/decryptAndVerify.d.ts

@@ -1,11 +1,27 @@
-import { User } from '..';
+/// <reference types="node" />
+import type { User } from '..';
+export declare const decryptJwe: (jwe: string, encryptionPrivateKey: Buffer | string) => string | undefined;
+declare type MaybeAccountsSSOToken = {
+    iss?: string;
+    sub?: User | string;
+    aud?: string;
+    exp?: number;
+    nbf?: number;
+    iat?: number;
+    jti?: string;
+};
+export declare const verifyJws: (jws: string, signaturePublicKey: Buffer | string) => MaybeAccountsSSOToken | undefined;
 /**
  * Decrypts and verifies a SSO cookie.
  *
  * @param token the encrypted token
  * @param encryptionPrivateKey the private key used to encrypt the token
  * @param signaturePublicKey the public key used to verify the decrypted token
- * @throws SessionExpiredError if the token is expired
- * @returns User (success) or undefined (failure)
+ * @returns {user: User} (success) or {error: string} (failure)
  */
-export declare const decryptAndVerify: (token: string, encryptionPrivateKey: string, signaturePublicKey: string) => User | undefined;
+export declare const decryptAndVerify: (token: string, encryptionPrivateKey: string, signaturePublicKey: string) => {
+    user: User;
+} | {
+    error: string;
+};
+export {};

package/dist/cjs/services/authProvider/utils/decryptAndVerify.js

@@ -1,79 +1,91 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.decryptAndVerify = void 0;
-const crypto = __importStar(require("crypto"));
-const util_1 = require("util");
-const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
-const errors_1 = require("../../../errors");
+exports.decryptAndVerify = exports.verifyJws = exports.decryptJwe = void 0;
+const crypto_1 = require("crypto");
 const guards_1 = require("../../../guards");
-const decrypt = (input, key) => {
-    const splitInput = input.split('.');
-    const aad = new util_1.TextEncoder().encode(splitInput[0]);
-    const iv = Buffer.from(splitInput[2], 'base64');
-    const cipherText = Buffer.from(splitInput[3], 'base64');
-    const tag = Buffer.from(splitInput[4], 'base64');
-    const decipher = crypto.createDecipheriv('aes-256-gcm', Buffer.from(key), iv, { authTagLength: 16 });
+const decryptJwe = (jwe, encryptionPrivateKey) => {
+    const jweParts = jwe.split('.', 6);
+    if (jweParts.length !== 5 || jweParts[1]) {
+        return undefined;
+    } // Invalid/unsupported JWE
+    const header = JSON.parse(Buffer.from(jweParts[0], 'base64url').toString());
+    if (header.alg !== 'dir' || header.enc !== 'A256GCM') {
+        // Unsupported signature/encryption algorithm
+        return undefined;
+    }
+    const aad = Buffer.from(jweParts[0]);
+    const iv = Buffer.from(jweParts[2], 'base64url');
+    const cipherText = Buffer.from(jweParts[3], 'base64url');
+    const authTag = Buffer.from(jweParts[4], 'base64url');
+    // Verify token signature and decrypt
+    const decipher = (0, crypto_1.createDecipheriv)('aes-256-gcm', encryptionPrivateKey, iv, { authTagLength: 16 });
     decipher.setAAD(aad, { plaintextLength: cipherText.length });
-    decipher.setAuthTag(tag);
-    const result = Buffer.concat([
-        decipher.update(cipherText),
-        decipher.final(),
-    ]);
-    return result.toString('utf-8');
+    try {
+        decipher.setAuthTag(authTag);
+        return `${decipher.update(cipherText)}${decipher.final()}`;
+    }
+    catch (error) {
+        // Invalid cipherText or authTag
+        return undefined;
+    }
+};
+exports.decryptJwe = decryptJwe;
+const issuer = 'OpenStax Accounts';
+const audience = 'OpenStax';
+const clockTolerance = 300; // 5 minutes
+const verifyJws = (jws, signaturePublicKey) => {
+    const jwsParts = jws.split('.', 4);
+    if (jwsParts.length !== 3) {
+        return undefined;
+    } // Invalid JWS
+    const header = JSON.parse(Buffer.from(jwsParts[0], 'base64url').toString());
+    if (header.alg !== 'RS256' || header.typ !== 'JWT') {
+        return undefined;
+    } // Unsupported JWS
+    const signedContent = Buffer.from(`${jwsParts[0]}.${jwsParts[1]}`);
+    const signature = Buffer.from(jwsParts[2], 'base64url');
+    if (!(0, crypto_1.verify)('RSA-SHA256', signedContent, signaturePublicKey, signature)) {
+        return undefined;
+    }
+    const payload = Buffer.from(jwsParts[1], 'base64url').toString();
+    try {
+        return JSON.parse(payload);
+    }
+    catch (error) {
+        return undefined;
+    }
 };
+exports.verifyJws = verifyJws;
 /**
  * Decrypts and verifies a SSO cookie.
  *
  * @param token the encrypted token
  * @param encryptionPrivateKey the private key used to encrypt the token
  * @param signaturePublicKey the public key used to verify the decrypted token
- * @throws SessionExpiredError if the token is expired
- * @returns User (success) or undefined (failure)
+ * @returns {user: User} (success) or {error: string} (failure)
  */
 const decryptAndVerify = (token, encryptionPrivateKey, signaturePublicKey) => {
-    try {
-        // Decrypt SSO cookie
-        const plaintext = decrypt(token, encryptionPrivateKey);
-        const payload = jsonwebtoken_1.default.verify(plaintext, signaturePublicKey, {
-            clockTolerance: 300 // 5 minutes
-        });
-        if (!(0, guards_1.isPlainObject)(payload) || !(0, guards_1.isPlainObject)(payload.sub) || !payload.sub.uuid) {
-            return undefined;
-        }
-        // TS is confused because the library types the `sub` as a string
-        return payload.sub;
+    const timestamp = Math.floor(Date.now() / 1000);
+    const jws = (0, exports.decryptJwe)(token, encryptionPrivateKey);
+    if (!jws) {
+        return { error: 'invalid token' };
     }
-    catch (err) {
-        if (err instanceof jsonwebtoken_1.default.TokenExpiredError) {
-            throw new errors_1.SessionExpiredError();
-        }
-        return undefined;
+    const payload = (0, exports.verifyJws)(jws, signaturePublicKey);
+    // Ensure payload contains all the claims we expect
+    // Normally "sub" would be a string but Accounts uses an object for it instead
+    if (!(0, guards_1.isPlainObject)(payload) ||
+        !(0, guards_1.isPlainObject)(payload.sub) || !payload.sub.uuid ||
+        payload.iss !== issuer ||
+        payload.aud !== audience ||
+        !payload.exp ||
+        !payload.nbf || payload.nbf > timestamp + clockTolerance ||
+        !payload.iat || payload.iat > timestamp + clockTolerance ||
+        !payload.jti) {
+        return { error: 'invalid token' };
+    }
+    if (payload.exp < timestamp - clockTolerance) {
+        return { error: 'expired token' };
     }
+    return { user: payload.sub };
 };
 exports.decryptAndVerify = decryptAndVerify;

package/dist/cjs/services/authProvider/utils/embeddedAuthProvider.d.ts

@@ -9,10 +9,14 @@ export declare enum PostMessageTypes {
     ReceiveUser = "receive-user",
     RequestUser = "request-user"
 }
-export declare const embeddedAuthProvider: (getUserData: UserDataLoader, { queryKey, window }: {
-    queryKey?: string | undefined;
+export declare const embeddedAuthProvider: (getUserData: UserDataLoader, { authQuery, window }: {
+    authQuery?: {
+        key: string;
+        value: string | null;
+    } | undefined;
     window: Window;
 }) => {
+    embeddedQueryKey: string;
     embeddedQueryValue: string;
     getAuthorizedEmbedUrl: (urlString: string, extraParams?: {
         [key: string]: string;

package/dist/cjs/services/authProvider/utils/embeddedAuthProvider.js

@@ -10,9 +10,10 @@ var PostMessageTypes;
     PostMessageTypes["ReceiveUser"] = "receive-user";
     PostMessageTypes["RequestUser"] = "request-user";
 })(PostMessageTypes = exports.PostMessageTypes || (exports.PostMessageTypes = {}));
-const embeddedAuthProvider = (getUserData, { queryKey = 'auth', window }) => {
+const embeddedAuthProvider = (getUserData, { authQuery, window }) => {
     const trustedEmbeds = new Set();
-    const embeddedQueryValue = 'embedded';
+    const embeddedQueryKey = 'embedded';
+    const embeddedQueryValue = 'true';
     const messageHandler = event => {
         if (event.data.type === PostMessageTypes.RequestUser && trustedEmbeds.has(event.origin)) {
             getUserData().then(data => {
@@ -25,10 +26,16 @@ const embeddedAuthProvider = (getUserData, { queryKey = 'auth', window }) => {
         const url = new URL(urlString);
         trustedEmbeds.add(url.origin);
         const params = query_string_1.default.parse(url.search);
-        url.search = query_string_1.default.stringify({ ...params, ...extraParams, [queryKey]: embeddedQueryValue });
+        url.search = query_string_1.default.stringify({
+            ...params,
+            ...extraParams,
+            ...(authQuery && authQuery.value ? { [authQuery.key]: authQuery.value } : {}),
+            [embeddedQueryKey]: embeddedQueryValue
+        });
         return url.href;
     };
     return {
+        embeddedQueryKey,
         embeddedQueryValue,
         getAuthorizedEmbedUrl,
         unmount: () => {

package/dist/cjs/services/exercisesGateway/index.js

@@ -51,7 +51,8 @@ const exercisesGateway = (initializer) => (configProvider) => {
             question.collaborator_solutions = [
                 { solution_type: 'detailed', images: [], content_html: defaultHint }
             ];
-            for (const [index, answer] of question.answers.entries()) {
+            for (let index = 0; index < question.answers.length; index++) {
+                const answer = question.answers[index];
                 answer.correctness = defaultCorrectIndex === index ? '1.0' : '0.0';
                 answer.feedback_html = defaultCorrectIndex === index ? 'This is the good one!' : defaultHint;
             }

package/dist/cjs/services/fileServer/index.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+export declare type FileValue = {
+    dataType: 'file';
+    mimeType: string;
+    path: string;
+    label: string;
+};
+export declare type FolderValue = {
+    dataType: 'folder';
+    files: FileValue[];
+};
+export declare const isFileValue: (thing: any) => thing is FileValue;
+export declare const isFolderValue: (thing: any) => thing is FolderValue;
+export interface FileServerAdapter {
+    getFileContent: (source: FileValue) => Promise<Buffer>;
+}
+export declare const isFileOrFolder: (thing: any) => thing is FileValue | FolderValue;

package/dist/cjs/services/fileServer/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFileOrFolder = exports.isFolderValue = exports.isFileValue = void 0;
+const guards_1 = require("../../guards");
+const isFileValue = (thing) => (0, guards_1.isPlainObject)(thing)
+    && Object.keys(thing).every(key => ['dataType', 'path', 'label', 'mimeType'].includes(key))
+    && thing.dataType === 'file'
+    && typeof thing.mimeType === 'string'
+    && typeof thing.path === 'string'
+    && typeof thing.label === 'string';
+exports.isFileValue = isFileValue;
+const isFolderValue = (thing) => (0, guards_1.isPlainObject)(thing)
+    && Object.keys(thing).every(key => ['dataType', 'files'].includes(key))
+    && thing.dataType === 'folder'
+    && thing.files instanceof Array
+    && thing.files.every(exports.isFileValue);
+exports.isFolderValue = isFolderValue;
+const isFileOrFolder = (thing) => (0, exports.isFileValue)(thing) || (0, exports.isFolderValue)(thing);
+exports.isFileOrFolder = isFileOrFolder;

package/dist/cjs/services/fileServer/localFileServer.d.ts

@@ -0,0 +1,13 @@
+import { ConfigProviderForConfig } from '../../config';
+import { FileServerAdapter } from '.';
+export declare type Config = {
+    storagePrefix: string;
+};
+interface Initializer<C> {
+    dataDir: string;
+    configSpace?: C;
+}
+export declare const localFileServer: <C extends string = "local">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
+    storagePrefix: import("../../config").ConfigValueProvider<string>;
+}; }) => FileServerAdapter;
+export {};

package/dist/cjs/services/fileServer/localFileServer.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.localFileServer = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../../config");
+const guards_1 = require("../../guards");
+const localFileServer = (initializer) => (configProvider) => {
+    const config = configProvider[(0, guards_1.ifDefined)(initializer.configSpace, 'local')];
+    const storagePrefix = (0, config_1.resolveConfigValue)(config.storagePrefix);
+    const fileDir = storagePrefix.then((prefix) => path_1.default.join(initializer.dataDir, prefix));
+    const getFileContent = async (source) => {
+        const filePath = path_1.default.join(await fileDir, source.path);
+        return fs_1.default.promises.readFile(filePath);
+    };
+    return {
+        getFileContent,
+    };
+};
+exports.localFileServer = localFileServer;

package/dist/cjs/services/fileServer/s3FileServer.d.ts

@@ -0,0 +1,16 @@
+import { S3Client } from '@aws-sdk/client-s3';
+import { ConfigProviderForConfig } from '../../config';
+import { FileServerAdapter } from '.';
+export declare type Config = {
+    bucketName: string;
+    bucketRegion: string;
+};
+interface Initializer<C> {
+    configSpace?: C;
+    s3Client?: typeof S3Client;
+}
+export declare const s3FileServer: <C extends string = "deployed">(initializer: Initializer<C>) => (configProvider: { [key in C]: {
+    bucketName: import("../../config").ConfigValueProvider<string>;
+    bucketRegion: import("../../config").ConfigValueProvider<string>;
+}; }) => FileServerAdapter;
+export {};

package/dist/cjs/services/fileServer/s3FileServer.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.s3FileServer = void 0;
+const client_s3_1 = require("@aws-sdk/client-s3");
+const __1 = require("../..");
+const assertions_1 = require("../../assertions");
+const config_1 = require("../../config");
+const guards_1 = require("../../guards");
+const s3FileServer = (initializer) => (configProvider) => {
+    const config = configProvider[(0, guards_1.ifDefined)(initializer.configSpace, 'deployed')];
+    const bucketName = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.bucketName));
+    const bucketRegion = (0, __1.once)(() => (0, config_1.resolveConfigValue)(config.bucketRegion));
+    const client = (0, guards_1.ifDefined)(initializer.s3Client, client_s3_1.S3Client);
+    const s3Service = (0, __1.once)(async () => new client({ apiVersion: '2012-08-10', region: await bucketRegion() }));
+    const getFileContent = async (source) => {
+        const bucket = await bucketName();
+        const command = new client_s3_1.GetObjectCommand({ Bucket: bucket, Key: source.path });
+        const response = await (await s3Service()).send(command);
+        return Buffer.from(await (0, assertions_1.assertDefined)(response.Body, new Error('Invalid Response from s3')).transformToByteArray());
+    };
+    return {
+        getFileContent,
+    };
+};
+exports.s3FileServer = s3FileServer;