@openstax/ts-utils 1.31.1 → 1.32.0

package/dist/esm/services/apiGateway/index.d.ts

@@ -38,7 +38,7 @@ export type ApiClientResponse<Ro> = Ro extends any ? {
 } : never;
 export type ExpandRoute<T> = T extends ((...args: infer A) => infer R) & {
     renderUrl: (...args: infer Ar) => Promise<string>;
-} ? ((...args: A) => R) & {
+} ? (...args: A) => R & {
     renderUrl: (...args: Ar) => Promise<string>;
 } : never;
 export type MapRoutesToClient<Ru> = [Ru] extends [AnyRoute<Ru>] ? {

package/dist/esm/services/authProvider/browser.d.ts

@@ -1,6 +1,6 @@
 import { ConfigProviderForConfig } from '../../config';
 import { FetchConfig, GenericFetch } from '../../fetch';
-import { User } from '.';
+import { ApiUser, User } from '.';
 type Config = {
     accountsBase: string;
 };
@@ -26,7 +26,7 @@ export interface Window {
     addEventListener: (event: 'message', callback: EventHandler) => void;
     removeEventListener: (event: 'message', callback: EventHandler) => void;
 }
-export type UpdatableUserFields = Partial<Pick<User, 'consent_preferences' | 'first_name' | 'last_name'>>;
+export type UpdatableUserFields = Partial<Pick<ApiUser, 'consent_preferences' | 'first_name' | 'last_name'>>;
 export declare const browserAuthProvider: <C extends string = "auth">({ window, configSpace }: Initializer<C>) => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => {
     /**
      * gets the authentication token
@@ -65,7 +65,7 @@ export declare const browserAuthProvider: <C extends string = "auth">({ window,
      * updates user settings, for example the cookie consent preferences
      */
     updateUser: (updates: UpdatableUserFields) => Promise<{
-        user: User;
+        user: ApiUser;
         token: string | null;
     }>;
 };

package/dist/esm/services/authProvider/decryption.d.ts

@@ -1,15 +1,19 @@
 import type { ConfigProviderForConfig } from '../../config';
-import { AuthProvider, CookieAuthProvider } from '.';
+import { GenericFetch } from '../../fetch';
+import { ApiUser, AuthProvider, CookieAuthProvider } from '.';
 type Config = {
+    accountsBase: string;
     cookieName: string;
     encryptionPrivateKey: string;
     signaturePublicKey: string;
 };
 interface Initializer<C> {
     configSpace?: C;
+    fetch: GenericFetch;
 }
 export type DecryptionAuthProvider = AuthProvider & {
     getTokenExpiration: (tokenString?: string) => Promise<number | null | undefined>;
+    loadUserData: () => Promise<ApiUser | undefined>;
 };
 export declare const decryptionAuthProvider: <C extends string = "decryption">(initializer: Initializer<C>) => (configProvider: { [_key in C]: ConfigProviderForConfig<Config>; }) => CookieAuthProvider<DecryptionAuthProvider>;
 export {};

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

@@ -3,14 +3,17 @@ import { SessionExpiredError } from '../../errors';
 import { ifDefined } from '../../guards';
 import { once } from '../../misc/helpers';
 import { decryptAndVerify } from './utils/decryptAndVerify';
+import { loadUserData } from './utils/userSubrequest';
 import { getAuthTokenOrCookie } from '.';
 export const decryptionAuthProvider = (initializer) => (configProvider) => {
     const config = configProvider[ifDefined(initializer.configSpace, 'decryption')];
+    const accountsBase = once(() => resolveConfigValue(config.accountsBase));
     const cookieName = once(() => resolveConfigValue(config.cookieName));
     const encryptionPrivateKey = once(() => resolveConfigValue(config.encryptionPrivateKey));
     const signaturePublicKey = once(() => resolveConfigValue(config.signaturePublicKey));
     return ({ request, logger }) => {
         let user;
+        let userData;
         const getAuthToken = async () => getAuthTokenOrCookie(request, await cookieName())[0];
         const getAuthorizedFetchConfig = async () => {
             const [token, headers] = getAuthTokenOrCookie(request, await cookieName());
@@ -19,40 +22,47 @@ export const decryptionAuthProvider = (initializer) => (configProvider) => {
             }
             return { headers };
         };
-        const getPayload = async (tokenString) => {
+        const getDecryptedPayload = async (tokenString) => {
             const token = tokenString !== null && tokenString !== void 0 ? tokenString : await getAuthToken();
             if (!token) {
                 return undefined;
             }
             return decryptAndVerify(token, await encryptionPrivateKey(), await signaturePublicKey());
         };
-        const loadUser = async () => {
-            const result = await getPayload();
-            if (!result) {
-                return undefined;
-            }
-            if ('error' in result && result.error == 'expired token') {
-                throw new SessionExpiredError();
-            }
-            if ('user' in result) {
-                logger.setContext({ user: result.user.uuid });
-                return result.user;
+        const getUser = async () => {
+            if (!user) {
+                const result = await getDecryptedPayload();
+                if (!result) {
+                    return undefined;
+                }
+                if ('error' in result && result.error == 'expired token') {
+                    throw new SessionExpiredError();
+                }
+                if ('user' in result) {
+                    logger.setContext({ user: result.user.uuid });
+                    user = result.user;
+                }
             }
-            return undefined;
+            return user;
         };
         return {
             getAuthToken,
             getAuthorizedFetchConfig,
             getTokenExpiration: async (tokenString) => {
                 var _a;
-                const payload = await getPayload(tokenString);
+                const payload = await getDecryptedPayload(tokenString);
                 return payload ? ((_a = payload.exp) !== null && _a !== void 0 ? _a : null) : undefined;
             },
-            getUser: async () => {
-                if (!user) {
-                    user = await loadUser();
+            getUser,
+            loadUserData: async () => {
+                if (!userData) {
+                    const token = await getAuthToken();
+                    if (!token) {
+                        return undefined;
+                    }
+                    userData = await loadUserData(initializer.fetch, await accountsBase(), await cookieName(), token);
                 }
-                return user;
+                return userData;
             },
         };
     };

package/dist/esm/services/authProvider/index.d.ts

@@ -10,14 +10,14 @@ export type ConsentPreferences = {
 export type TokenUser = {
     id: number;
     name: string;
+    uuid: string;
+    faculty_status: string;
+    is_admin: boolean;
+};
+export type ApiUser = TokenUser & {
     first_name: string;
     last_name: string;
     full_name: string;
-    uuid: string;
-    faculty_status: string;
-    is_administrator: boolean;
-} & Partial<ConsentPreferences>;
-export interface ApiUser extends TokenUser {
     contact_infos: Array<{
         type: string;
         value: string;
@@ -34,7 +34,7 @@ export interface ApiUser extends TokenUser {
     self_reported_role: string;
     signed_contract_names: string[];
     using_openstax: boolean;
-}
+} & Partial<ConsentPreferences>;
 export type User = TokenUser | ApiUser;
 export type AuthProvider = {
     getAuthToken: () => Promise<string | null>;

package/dist/esm/services/authProvider/subrequest.d.ts

@@ -2,8 +2,8 @@ import { ConfigProviderForConfig } from '../../config';
 import { GenericFetch } from '../../fetch';
 import { CookieAuthProvider } from '.';
 type Config = {
-    cookieName: string;
     accountsBase: string;
+    cookieName: string;
 };
 interface Initializer<C> {
     configSpace?: C;

package/dist/esm/services/authProvider/subrequest.js

@@ -1,7 +1,7 @@
-import cookie from 'cookie';
 import { once } from '../..';
 import { resolveConfigValue } from '../../config';
 import { ifDefined } from '../../guards';
+import { loadUserData } from './utils/userSubrequest';
 import { getAuthTokenOrCookie } from '.';
 export const subrequestAuthProvider = (initializer) => (configProvider) => {
     const config = configProvider[ifDefined(initializer.configSpace, 'subrequest')];
@@ -23,9 +23,7 @@ export const subrequestAuthProvider = (initializer) => (configProvider) => {
             if (!token) {
                 return undefined;
             }
-            const headers = { cookie: cookie.serialize(resolvedCookieName, token) };
-            const user = await initializer.fetch((await accountsBase()).replace(/\/+$/, '') + '/api/user', { headers })
-                .then(response => response.json());
+            const user = await loadUserData(initializer.fetch, await accountsBase(), resolvedCookieName, token);
             if (user) {
                 logger.setContext({ user: user.uuid });
             }

package/dist/esm/services/authProvider/utils/userSubrequest.d.ts

@@ -0,0 +1,3 @@
+import { ApiUser } from '..';
+import { GenericFetch } from '../../../fetch';
+export declare const loadUserData: (fetch: GenericFetch, accountsBase: string, cookieName: string, token: string) => Promise<ApiUser | undefined>;

package/dist/esm/services/authProvider/utils/userSubrequest.js

@@ -0,0 +1,6 @@
+import cookie from 'cookie';
+export const loadUserData = (fetch, accountsBase, cookieName, token) => {
+    const headers = { cookie: cookie.serialize(cookieName, token) };
+    return fetch(accountsBase.replace(/\/+$/, '') + '/api/user', { headers })
+        .then(response => response.json());
+};

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

@@ -14,16 +14,5 @@ export interface FileServerAdapter {
     putFileContent: (source: FileValue, content: string) => Promise<FileValue>;
     getSignedViewerUrl: (source: FileValue) => Promise<string>;
     getFileContent: (source: FileValue) => Promise<Buffer>;
-    getSignedFileUploadConfig: () => Promise<{
-        url: string;
-        payload: {
-            [key: string]: string;
-        };
-    }>;
-    copyFileTo: (source: FileValue, destinationPath: string) => Promise<FileValue>;
-    copyFileToDirectory: (source: FileValue, destinationDirectory: string) => Promise<FileValue>;
-    isTemporaryUpload: (source: FileValue) => boolean;
-    getFileChecksum: (source: FileValue) => Promise<string>;
-    filesEqual: (sourceA: FileValue, sourceB: FileValue) => Promise<boolean>;
 }
 export declare const isFileOrFolder: (thing: any) => thing is FileValue | FolderValue;

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

@@ -1,18 +1,16 @@
 /* cspell:ignore originalname */
-import crypto from 'crypto';
 import fs from 'fs';
 import https from 'https';
 import path from 'path';
 import cors from 'cors';
 import express from 'express';
 import multer from 'multer';
-import { v4 as uuid } from 'uuid';
 import { assertString } from '../../assertions';
 import { resolveConfigValue } from '../../config';
 import { ifDefined } from '../../guards';
-import { memoize } from '../../misc/helpers';
+import { once } from '../../misc/helpers';
 /* istanbul ignore next */
-const startServer = memoize((port, uploadDir) => {
+const startServer = once((port, uploadDir) => {
     // TODO - re-evaluate the `preservePath` behavior to match whatever s3 does
     const upload = multer({ dest: uploadDir, preservePath: true });
     const fileServerApp = express();
@@ -68,54 +66,9 @@ export const localFileServer = (initializer) => (configProvider) => {
         await fs.promises.writeFile(filePath, content);
         return source;
     };
-    const getSignedFileUploadConfig = async () => {
-        const prefix = 'uploads/' + uuid();
-        return {
-            url: `https://${await host}:${await port}/`,
-            payload: {
-                key: prefix + '/${filename}',
-            }
-        };
-    };
-    const copyFileTo = async (source, destinationPath) => {
-        const sourcePath = path.join(await fileDir, source.path);
-        const destPath = path.join(await fileDir, destinationPath);
-        const destDirectory = path.dirname(destPath);
-        await fs.promises.mkdir(destDirectory, { recursive: true });
-        await fs.promises.copyFile(sourcePath, destPath);
-        return {
-            ...source,
-            path: destinationPath
-        };
-    };
-    const copyFileToDirectory = async (source, destination) => {
-        const destinationPath = path.join(destination, source.label);
-        return copyFileTo(source, destinationPath);
-    };
-    const isTemporaryUpload = (source) => {
-        return source.path.indexOf('uploads/') === 0;
-    };
-    const getFileChecksum = async (source) => {
-        const filePath = path.join(await fileDir, source.path);
-        const fileContent = await fs.promises.readFile(filePath);
-        return crypto.createHash('md5').update(fileContent).digest('hex');
-    };
-    const filesEqual = async (sourceA, sourceB) => {
-        const [aSum, bSum] = await Promise.all([
-            getFileChecksum(sourceA),
-            getFileChecksum(sourceB)
-        ]);
-        return aSum === bSum;
-    };
     return {
         getSignedViewerUrl,
         getFileContent,
         putFileContent,
-        getSignedFileUploadConfig,
-        copyFileTo,
-        copyFileToDirectory,
-        isTemporaryUpload,
-        getFileChecksum,
-        filesEqual,
     };
 };

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

@@ -1,9 +1,6 @@
 /* cspell:ignore presigner */
-import { CopyObjectCommand, GetObjectCommand, HeadObjectCommand, PutObjectCommand, S3Client } from '@aws-sdk/client-s3';
-import { createPresignedPost } from '@aws-sdk/s3-presigned-post';
+import { GetObjectCommand, PutObjectCommand, S3Client } from '@aws-sdk/client-s3';
 import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
-import path from 'path';
-import { v4 as uuid } from 'uuid';
 import { once } from '../..';
 import { assertDefined } from '../../assertions';
 import { resolveConfigValue } from '../../config';
@@ -44,73 +41,9 @@ export const s3FileServer = (initializer) => (configProvider) => {
         await (await s3Service()).send(command);
         return source;
     };
-    /*
-     * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/modules/_aws_sdk_s3_presigned_post.html
-     * https://docs.aws.amazon.com/AmazonS3/latest/userguide/HTTPPOSTExamples.html
-     * https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-post-example.html
-     */
-    const getSignedFileUploadConfig = async () => {
-        const prefix = 'uploads/' + uuid();
-        const bucket = (await bucketName());
-        const Conditions = [
-            { acl: 'private' },
-            { bucket },
-            ['starts-with', '$key', prefix]
-        ];
-        const defaultFields = {
-            acl: 'private',
-        };
-        const { url, fields } = await createPresignedPost(await s3Service(), {
-            Bucket: bucket,
-            Key: prefix + '/${filename}',
-            Conditions,
-            Fields: defaultFields,
-            Expires: 3600, // 1 hour 
-        });
-        return {
-            url, payload: fields
-        };
-    };
-    const copyFileTo = async (source, destinationPath) => {
-        const bucket = (await bucketName());
-        const destinationPathWithoutLeadingSlash = destinationPath.replace(/^\//, '');
-        const command = new CopyObjectCommand({
-            Bucket: bucket,
-            Key: destinationPathWithoutLeadingSlash,
-            CopySource: path.join(bucket, source.path),
-        });
-        await (await s3Service()).send(command);
-        return {
-            ...source,
-            path: destinationPathWithoutLeadingSlash
-        };
-    };
-    const copyFileToDirectory = async (source, destination) => {
-        const destinationPath = path.join(destination, source.label);
-        return copyFileTo(source, destinationPath);
-    };
-    const isTemporaryUpload = (source) => {
-        return source.path.indexOf('uploads/') === 0;
-    };
-    const getFileChecksum = async (source) => {
-        const bucket = (await bucketName());
-        const command = new HeadObjectCommand({ Bucket: bucket, Key: source.path });
-        const response = await (await s3Service()).send(command);
-        return assertDefined(response.ETag);
-    };
-    const filesEqual = async (sourceA, sourceB) => {
-        const [aSum, bSum] = await Promise.all([getFileChecksum(sourceA), getFileChecksum(sourceB)]);
-        return aSum === bSum;
-    };
     return {
         getFileContent,
         putFileContent,
         getSignedViewerUrl,
-        getSignedFileUploadConfig,
-        copyFileTo,
-        copyFileToDirectory,
-        isTemporaryUpload,
-        getFileChecksum,
-        filesEqual,
     };
 };

package/dist/esm/services/searchProvider/openSearch.js

@@ -29,6 +29,7 @@ export const openSearchService = (initializer = {}) => (configProvider) => {
         sniffOnConnectionFault: true,
         sniffOnStart: true,
         resurrectStrategy: 'ping',
+        agent: { keepAlive: false },
         node: await resolveConfigValue(config.node),
     }));
     return (indexConfig) => {