dce-reactkit 3.0.0-beta.24 → 3.0.0-beta.28

package/src/helpers/genRouteHandler.ts

@@ -0,0 +1,326 @@
+// Import caccl functions
+import { cacclGetLaunchInfo } from '../server/initServer';
+
+// Import shared types
+import ReactKitErrorCode from '../types/ReactKitErrorCode';
+import ParamType from '../types/ParamType';
+
+// Import helpers
+import handleError from './handleError';
+import handleSuccess from './handleSuccess';
+
+/**
+ * Generate an express API route handler
+ * @author Gabe Abrams
+ * @param opts object containing all arguments
+ * @param opts.paramTypes map containing the types for each parameter that is
+ *   included in the request (map: param name => type)
+ * @param opts.handler function that processes the request
+ * @returns express route handler that takes the following arguments:
+ *   params (map: param name => value), handleSuccess (function for handling
+ *   successful requests), handleError (function for handling failed requests),
+ *   req (express request object), res (express response object)
+ */
+const genRouteHandler = (
+  opts: {
+    paramTypes: {
+      [k: string]: ParamType
+    },
+    handler: (
+      opts: {
+        params: {
+          [k: string]: any
+        },
+        handleSuccess: (body: any) => void,
+        handleError: (error: any) => void,
+        req: any,
+        res: any,
+      },
+    ) => void,
+  },
+) => {
+  // Return a route handler
+  return async (req: any, res: any) => {
+    // Output params
+    const output: { [k in string]: any } = {};
+
+    /*----------------------------------------*/
+    /*              Parse Params              */
+    /*----------------------------------------*/
+
+    // Process items one by one
+    const paramList = Object.entries(opts.paramTypes);
+    for (let i = 0; i < paramList.length; i++) {
+      const [name, type] = paramList[i];
+
+      // Find the value as a string
+      const value = (
+        req.params[name]
+        || req.query[name]
+        || req.body[name]
+      );
+
+      // Parse
+      if (type === ParamType.Boolean || type === ParamType.BooleanOptional) {
+        // Boolean
+
+        // Handle case where value doesn't exist
+        if (value === undefined) {
+          if (type === ParamType.BooleanOptional) {
+            output[name] = undefined;
+          } else {
+            return handleError(
+              res,
+              {
+                message: `Parameter ${name} is required, but it was not included.`,
+                code: ReactKitErrorCode.MissingParameter,
+                status: 422,
+              },
+            );
+          }
+        } else {
+          // Value exists
+
+          // Simplify value
+          const simpleVal = (
+            String(value)
+              .trim()
+              .toLowerCase()
+          );
+
+          // Parse
+          output[name] = (
+            [
+              'true',
+              'yes',
+              'y',
+              '1',
+              't',
+            ].indexOf(simpleVal) >= 0
+          );
+        }
+      } else if (type === ParamType.Float || type === ParamType.FloatOptional) {
+        // Float
+
+        // Handle case where value doesn't exist
+        if (value === undefined) {
+          if (type === ParamType.FloatOptional) {
+            output[name] = undefined;
+          } else {
+            return handleError(
+              res,
+              {
+                message: `Parameter ${name} is required, but it was not included.`,
+                code: ReactKitErrorCode.MissingParameter,
+                status: 422,
+              },
+            );
+          }
+        } else if (!Number.isNaN(Number.parseFloat(String(value)))) {
+          // Value is a number
+          output[name] = Number.parseFloat(String(value));
+        } else {
+          // Issue!
+          return handleError(
+            res,
+            {
+              message: `Request data was malformed: ${name} was not a valid float.`,
+              code: ReactKitErrorCode.InvalidParameter,
+              status: 422,
+            },
+          );
+        }
+      } else if (type === ParamType.Int || type === ParamType.IntOptional) {
+        // Int
+
+        // Handle case where value doesn't exist
+        if (value === undefined) {
+          if (type === ParamType.IntOptional) {
+            output[name] = undefined;
+          } else {
+            return handleError(
+              res,
+              {
+                message: `Parameter ${name} is required, but it was not included.`,
+                code: ReactKitErrorCode.MissingParameter,
+                status: 422,
+              },
+            );
+          }
+        } else if (!Number.isNaN(Number.parseInt(String(value), 10))) {
+          // Value is a number
+          output[name] = Number.parseInt(String(value), 10);
+        } else {
+          // Issue!
+          return handleError(
+            res,
+            {
+              message: `Request data was malformed: ${name} was not a valid int.`,
+              code: ReactKitErrorCode.InvalidParameter,
+              status: 422,
+            },
+          );
+        }
+      } else if (type === ParamType.JSON || type === ParamType.JSONOptional) {
+        // Stringified JSON
+
+        // Handle case where value doesn't exist
+        if (value === undefined) {
+          if (type === ParamType.JSONOptional) {
+            output[name] = undefined;
+          } else {
+            return handleError(
+              res,
+              {
+                message: `Parameter ${name} is required, but it was not included.`,
+                code: ReactKitErrorCode.MissingParameter,
+                status: 422,
+              },
+            );
+          }
+        } else {
+          // Value exists
+
+          // Parse
+          try {
+            output[name] = JSON.parse(String(value));
+          } catch (err) {
+            return handleError(
+              res,
+              {
+                message: `Request data was malformed: ${name} was not a valid JSON payload.`,
+                code: ReactKitErrorCode.InvalidParameter,
+                status: 422,
+              },
+            );
+          }
+        }
+      } else if (type === ParamType.String || type === ParamType.StringOptional) {
+        // String
+
+        // Handle case where value doesn't exist
+        if (value === undefined) {
+          if (type === ParamType.StringOptional) {
+            output[name] = undefined;
+          } else {
+            return handleError(
+              res,
+              {
+                message: `Parameter ${name} is required, but it was not included.`,
+                code: ReactKitErrorCode.MissingParameter,
+                status: 422,
+              },
+            );
+          }
+        } else {
+          // Value exists
+
+          // Leave as is
+          output[name] = value;
+        }
+      } else {
+        // No valid data type
+        return handleError(
+          res,
+          {
+            message: `An internal error occurred: we could not determine the type of ${name}.`,
+            code: ReactKitErrorCode.InvalidParameter,
+            status: 422,
+          },
+        );
+      }
+    }
+
+    /*----------------------------------------*/
+    /*               Launch Info              */
+    /*----------------------------------------*/
+
+    // Get launch info
+    const { launched, launchInfo } = cacclGetLaunchInfo(req);
+    if (!launched || !launchInfo) {
+      return handleError(
+        res,
+        {
+          message: 'Your session has expired. Please refresh the page and try again.',
+          code: ReactKitErrorCode.SessionExpired,
+          status: 440,
+        },
+      );
+    }
+
+    // Error if user info cannot be found
+    if (
+      !launchInfo.userId
+      || !launchInfo.userFirstName
+      || !launchInfo.userLastName
+      || (
+        launchInfo.notInCourse
+        && !launchInfo.isAdmin
+      )
+      || (
+        !launchInfo.isTTM
+        && !launchInfo.isLearner
+        && !launchInfo.isAdmin
+      )
+    ) {
+      return handleError(
+        res,
+        {
+          message: 'Your session was invalid. Please refresh the page and try again.',
+          code: ReactKitErrorCode.SessionExpired,
+          status: 440,
+        },
+      );
+    }
+
+    // Add launch info to output
+    output.userId = launchInfo.userId;
+    output.userFirstName = launchInfo.userFirstName;
+    output.userLastName = launchInfo.userLastName;
+    output.isLearner = !!launchInfo.isLearner;
+    output.isTTM = !!launchInfo.isTTM;
+    output.isAdmin = !!launchInfo.isAdmin;
+    output.isWatchingInPrivate = !!(req.session.isWatchingInPrivate);
+
+    /*----------------------------------------*/
+    /*       Require Course Consistency       */
+    /*----------------------------------------*/
+
+    // Make sure the user actually launched from the appropriate course
+    if (
+      output.courseId
+      && launchInfo.courseId
+      && output.courseId !== launchInfo.courseId
+      && !output.isTTM
+      && !output.isAdmin
+    ) {
+      // Course of interest is not the launch course
+      return handleError(
+        res,
+        {
+          message: 'You switched sessions by opening Immersive Classroom in another tab. Please refresh the page and try again.',
+          code: ReactKitErrorCode.WrongCourse,
+          status: 401,
+        },
+      );
+    }
+
+    /*------------------------------------------------------------------------*/
+    /*                              Call handler                              */
+    /*------------------------------------------------------------------------*/
+
+    opts.handler({
+      params: output,
+      handleSuccess: (body: any) => {
+        return handleSuccess(res, body);
+      },
+      handleError: (error: any) => {
+        return handleError(res, error);
+      },
+      req,
+      res,
+    });
+  };
+};
+
+export default genRouteHandler;

package/src/helpers/handleError.ts

@@ -0,0 +1,65 @@
+// Import shared types
+import ReactKitErrorCode from '../types/ReactKitErrorCode';
+
+/**
+ * Handle an error and respond to the client
+ * @author Gabe Abrams
+ * @param res express response
+ * @param error error info
+ * @param opts.err the error to send to the client
+ *   or the error message
+ * @param [opts.code] an error code (only used if err.code is not
+ *   included)
+ * @param [opts.status=500] the https status code to use
+ *   defined)
+ */
+const handleError = (
+  res: any,
+  error: (
+    | {
+      message: any,
+      code?: string,
+      status?: number,
+    }
+    | Error
+    | string
+    | any
+  ),
+): undefined => {
+  // Get the error message
+  let message;
+  if (error && (error as any).message) {
+    message = (error.message || 'An unknown error occurred.');
+  } else if (typeof error === 'string') {
+    message = (
+      error.trim().length > 0
+        ? error
+        : 'An unknown error occurred.'
+    );
+  } else {
+    message = 'An unknown error occurred.';
+  }
+
+  // Get the error code
+  const code = (error.code || ReactKitErrorCode.NoCode);
+
+  // Get the status code
+  const status = (error.status || 500);
+
+  // Respond to user
+  res
+    // Set the http status code
+    .status(status)
+    // Send a JSON response
+    .json({
+      // Error message
+      message,
+      // Error code
+      code,
+      // Success = false flag so client can detect server-side errors
+      success: false,
+    });
+  return undefined;
+};
+
+export default handleError;

package/src/helpers/handleSuccess.ts

@@ -0,0 +1,18 @@
+/**
+ * Send successful API response
+ * @author Gabe Abrams
+ * @param res express response
+ * @param body the body of the response to send to the client
+ */
+const handleSuccess = (res: any, body: any): undefined => {
+  // Send a http 200 json response
+  res.json({
+    // Include the body as a parameter
+    body,
+    // Success = true flag so client can detect successful responses
+    success: true,
+  });
+  return undefined;
+};
+
+export default handleSuccess;

package/src/helpers/visitServerEndpoint.tsx

@@ -0,0 +1,110 @@
+// Import custom error
+import ErrorWithCode from '../errors/ErrorWithCode';
+import ReactKitErrorCode from '../types/ReactKitErrorCode';
+
+// Import helpers from app wrapper
+import { cacclSendRequest } from '../components/AppWrapper';
+
+/*------------------------------------------------------------------------*/
+/*                                Listener                                */
+/*------------------------------------------------------------------------*/
+
+// Handler for session expiry
+let sessionExpiryHandler: () => void;
+
+// Keep track of whether or not session expiry has already been handled
+let sessionAlreadyExpired = false;
+
+/**
+ * Set the session expiry handler
+ * @author Gabe Abrams
+ * @param handler new handler to use when session expires
+ */
+export const setSessionExpiryHandler = (handler: () => void) => {
+  sessionExpiryHandler = handler;
+};
+
+/*------------------------------------------------------------------------*/
+/*                                  Main                                  */
+/*------------------------------------------------------------------------*/
+
+/**
+ * Visit an endpoint on the server [for client only]
+ * @author Gabe Abrams
+ * @param opts object containing all arguments
+ * @param opts.path - the path of the server endpoint
+ * @param [opts.method=GET] - the method of the endpoint
+ * @param [opts.params] - query/body parameters to include
+ * @returns response from server
+ */
+const visitServerEndpoint = async (
+  opts: {
+    path: string,
+    method?: ('GET' | 'POST' | 'DELETE' | 'PUT'),
+    params?: { [key in string]: any },
+  },
+): Promise<any> => {
+  // Send the request
+  const response = await cacclSendRequest({
+    path: opts.path,
+    method: opts.method ?? 'GET',
+    params: opts.params,
+  });
+
+  // Check for failure
+  if (!response || !response.body) {
+    throw new ErrorWithCode(
+      'We didn\'t get a response from the server. Please check your internet connection.',
+      ReactKitErrorCode.NoResponse,
+    );
+  }
+  if (!response.body.success) {
+    // Session expired
+    if (response.body.code === ReactKitErrorCode.SessionExpired) {
+      // Skip notice if session was already expired
+      if (sessionAlreadyExpired) {
+        // Never return (browser is already reloading)
+        await new Promise<{ [key in string]: any }>(() => {
+          // Promise that never returns
+        });
+      }
+      sessionAlreadyExpired = true;
+
+      // Show session expiration message
+      if (sessionExpiryHandler) {
+        // Use handler
+        sessionExpiryHandler();
+      } else {
+        // Fallback to alert
+
+        // eslint-disable-next-line no-alert
+        alert('Your session has expired. Please start over.');
+      }
+
+      // Never return (don't continue execution)
+      await new Promise<{ [key in string]: any }>(() => {
+        // Promise that never returns
+      });
+    }
+
+    // Other errors
+    throw new ErrorWithCode(
+      (
+        response.body.message
+        || 'An unknown error occurred. Please contact an admin.'
+      ),
+      (
+        response.body.code
+        || ReactKitErrorCode.NoCode
+      ),
+    );
+  }
+
+  // Success! Extract the body
+  const { body } = response.body;
+
+  // Return
+  return body;
+};
+
+export default visitServerEndpoint;

package/src/index.ts

@@ -19,6 +19,10 @@ import padZerosLeft from './helpers/padZerosLeft';
 import roundToNumDecimals from './helpers/roundToNumDecimals';
 import sum from './helpers/sum';
 import waitMs from './helpers/waitMs';
+import visitServerEndpoint from './helpers/visitServerEndpoint';
+import genRouteHandler from './helpers/genRouteHandler';
+import handleError from './helpers/handleError';
+import handleSuccess from './helpers/handleSuccess';
 
 // Import types
 import ModalButtonType from './types/ModalButtonType';
@@ -26,6 +30,7 @@ import ModalSize from './types/ModalSize';
 import ModalType from './types/ModalType';
 import ReactKitErrorCode from './types/ReactKitErrorCode';
 import Variant from './types/Variant';
+import ParamType from './types/ParamType';
 
 // Export each item
 export {
@@ -52,10 +57,18 @@ export {
   roundToNumDecimals,
   sum,
   waitMs,
+  // Client helpers
+  visitServerEndpoint,
+  // Server helpers
+  genRouteHandler,
+  handleError,
+  handleSuccess,
   // Types
   ModalButtonType,
   ModalSize,
   ModalType,
   ReactKitErrorCode,
   Variant,
+  // Server types
+  ParamType,
 };

package/src/server/initServer.ts

@@ -0,0 +1,53 @@
+// Import custom error
+import ErrorWithCode from '../errors/ErrorWithCode';
+import ReactKitErrorCode from '../types/ReactKitErrorCode';
+
+// Types
+type GetLaunchInfoFunction = (req: any) => {
+  launched: boolean,
+  launchInfo?: any,
+};
+
+// Stored copy of caccl functions
+let _cacclGetLaunchInfo: GetLaunchInfoFunction;
+
+/*------------------------------------------------------------------------*/
+/*                                 Helpers                                */
+/*------------------------------------------------------------------------*/
+
+/**
+ * Get launch info via CACCL
+ * @author Gabe Abrams
+ * @param req express request object
+ * @returns object { launched, launchInfo }
+ */
+export const cacclGetLaunchInfo: GetLaunchInfoFunction = (req: any) => {
+  if (!_cacclGetLaunchInfo) {
+    throw new ErrorWithCode(
+      'Could not get launch info because server was not initialized with dce-reactkit\'s initServer function',
+      ReactKitErrorCode.NoCACCLGetLaunchInfoFunction,
+    );
+  }
+
+  return _cacclGetLaunchInfo(req);
+};
+
+/*------------------------------------------------------------------------*/
+/*                                  Main                                  */
+/*------------------------------------------------------------------------*/
+
+/**
+ * Prepare dce-reactkit to run on the server
+ * @author Gabe Abrams
+ * @param opts object containing all arguments
+ * @param opts.getLaunchInfo CACCL LTI's get launch info function
+ */
+const initServer = (
+  opts: {
+    getLaunchInfo: GetLaunchInfoFunction,
+  },
+) => {
+  _cacclGetLaunchInfo = opts.getLaunchInfo;
+};
+
+export default initServer;

package/src/types/ParamType.tsx

@@ -0,0 +1,18 @@
+/**
+ * Server-side API param types
+ * @author Gabe Abrams
+ */
+enum ParamType {
+  Boolean = 'boolean', // Boolean
+  BooleanOptional = 'boolean-optional', // Optional boolean
+  Float = 'float', // Float Number
+  FloatOptional = 'float-optional', // Optional Float Number
+  Int = 'int', // Integer Number
+  IntOptional = 'int-optional', // Optional Integer Number
+  JSON = 'json', // JSONified object
+  JSONOptional = 'json-optional', // Optional JSONified object
+  String = 'string', // String
+  StringOptional = 'string-optional', // Optional string
+}
+
+export default ParamType;

package/src/types/ReactKitErrorCode.tsx

@@ -1,4 +1,4 @@
-// Highest error code = DRK2
+// Highest error code = DRK8
 
 /**
  * List of error codes built into the react kit
@@ -11,6 +11,8 @@ enum ReactKitErrorCode {
   MissingParameter = 'DRK4',
   InvalidParameter = 'DRK5',
   WrongCourse = 'DRK6',
+  NoCACCLSendRequestFunction = 'DRK7',
+  NoCACCLGetLaunchInfoFunction = 'DRK8',
 }
 
 export default ReactKitErrorCode;