dce-reactkit 3.12.1-beta-cross-server.8 → 4.0.0-beta-date-and-time.1

package/src/helpers/handleError.ts

@@ -1,65 +0,0 @@
-// 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

@@ -1,18 +0,0 @@
-/**
- * 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/parseUserAgent.ts

@@ -1,108 +0,0 @@
-/**
- * Perform a rudimentary parsing of the user's browser agent string
- * @author Gabe Abrams
- * @param userAgent the user's browser agent
- * @returns user info
- */
-const parseUserAgent = (userAgent: string) => {
-  /* ------------- Browser ------------ */
-
-  let browser: { name: string, version: string } = {
-    name: 'Unknown',
-    version: 'Unknown',
-  };
-
-  // Parse user agent
-  let verOffset: number;
-  let nameOffset: number;
-  if ((verOffset = userAgent.indexOf('Opera')) !== -1) {
-    // In Opera, the true version is after 'Opera' or after 'Version'
-    browser = {
-      name: 'Opera',
-      version: userAgent.substring(verOffset + 6),
-    };
-    if ((verOffset = userAgent.indexOf('Version')) !== -1) {
-      browser.version = userAgent.substring(verOffset + 8);
-    }
-  } else if ((verOffset = userAgent.indexOf('MSIE')) !== -1) {
-    // In MSIE, the true version is after 'MSIE' in userAgent
-    browser = {
-      name: 'Internet Explorer',
-      version: userAgent.substring(verOffset + 5),
-    };
-  } else if ((verOffset = userAgent.indexOf('Chrome')) !== -1) {
-    // In Chrome, the true version is after 'Chrome'
-    browser = {
-      name: 'Chrome',
-      version: userAgent.substring(verOffset + 7),
-    };
-  } else if ((verOffset = userAgent.indexOf('Safari')) !== -1) {
-    // In Safari, the true version is after 'Safari' or after 'Version'
-    browser = {
-      name: 'Safari',
-      version: userAgent.substring(verOffset + 7),
-    };
-    if ((verOffset = userAgent.indexOf('Version')) !== -1) {
-      browser.version = userAgent.substring(verOffset + 8);
-    }
-  } else if ((verOffset = userAgent.indexOf('Firefox')) != -1) {
-    // In Firefox, the true version is after 'Firefox'
-    browser = {
-      name: 'Firefox',
-      version: userAgent.substring(verOffset + 8),
-    };
-  } else if (
-    (nameOffset = userAgent.lastIndexOf(' ') + 1)
-    < (verOffset = userAgent.lastIndexOf('/'))
-  ) {
-    browser = {
-      name: userAgent.substring(nameOffset, verOffset),
-      version: userAgent.substring(verOffset + 1),
-    };
-  }
-
-  // Postprocess version
-  // trim the fullVersion string at semicolon/space if present
-  let ix: number;
-  if ((ix = browser.version.indexOf(';')) !== -1) {
-    browser.version = browser.version.substring(0, ix);
-  }
-  if ((ix = browser.version.indexOf(' ')) !== -1) {
-    browser.version = browser.version.substring(0, ix);
-  }
-
-  /* ------------- Device ------------- */
-
-  // Detect os
-  let os = 'Unknown';
-  if (userAgent.includes('Linux')) {
-    os = 'Linux';
-  } else if (userAgent.includes('like Mac')) {
-    os = 'iOS';
-  } else if (userAgent.includes('Mac')) {
-    os = 'Mac';
-  } else if (userAgent.includes('Android')) {
-    os = 'Android';
-  } else if (userAgent.includes('Win')) {
-    os = 'Win';
-  }
-
-  // Check if mobile
-  const isMobile = !!userAgent.match(/(iPhone|iPod|iPad|Android|BlackBerry)/);
-
-  // Device
-  const device = {
-    isMobile,
-    os,
-  };
-
-  /* ------------- Finish ------------- */
-  
-  // Return info
-  return {
-    browser,
-    device,
-  };
-};
-
-export default parseUserAgent;

package/src/helpers/visitEndpointOnAnotherServer/index.ts

@@ -1,152 +0,0 @@
-// Import data signer
-import { signRequest } from '../dataSigner';
-
-// Import shared types
-import ErrorWithCode from '../../errors/ErrorWithCode';
-import ReactKitErrorCode from '../../types/ReactKitErrorCode';
-import sendServerToServerRequest from './sendServerToServerRequest';
-
-/*------------------------------------------------------------------------*/
-/* ----------------------------- Credentials ---------------------------- */
-/*------------------------------------------------------------------------*/
-
-/*
-REACTKIT_CROSS_SERVER_CREDENTIALS format:
-|host:key:secret||host:key:secret|...
-*/
-
-const credentials: {
-  host: string,
-  key: string,
-  secret: string,
-}[] = (
-  (process.env.REACTKIT_CROSS_SERVER_CREDENTIALS ?? '')
-    // Replace multiple | with a single one
-    .replace(/\|+/g, '|')
-    // Split by |
-    .split('|')
-    // Remove empty strings
-    .filter((str) => {
-      return str.trim().length > 0;
-    })
-    // Process each credential
-    .map((str) => {
-      // Split by :
-      const parts = str.split(':');
-
-      // Check for errors
-      if (parts.length !== 3) {
-        throw new ErrorWithCode(
-          'Invalid REACTKIT_CROSS_SERVER_CREDENTIALS format. Each credential must be in the format |host:key:secret|',
-          ReactKitErrorCode.InvalidCrossServerCredentialsFormat,
-        );
-      }
-
-      // Return the credential
-      return {
-        host: parts[0].trim(),
-        key: parts[1].trim(),
-        secret: parts[2].trim(),
-      };
-    })
-);
-
-/*------------------------------------------------------------------------*/
-/* ------------------------------- Helpers ------------------------------ */
-/*------------------------------------------------------------------------*/
-
-/**
- * Get the credential to use for the request to another server
- * @author Gabe Abrams
- * @param host the host of the other server
- * @return the credential to use
- */
-const getCrossServerCredential = (host: string) => {
-  // Find the credential
-  const credential = credentials.find((cred) => {
-    return cred.host.toLowerCase() === host.toLowerCase();
-  });
-  if (!credential) {
-    throw new ErrorWithCode(
-      'Cannot send cross-server signed request there was no credential that matched the host that the request is being sent to.',
-      ReactKitErrorCode.CrossServerNoCredentialsToSignWith,
-    );
-  }
-
-  // Return credential
-  return credential;
-};
-
-/*------------------------------------------------------------------------*/
-/* -------------------------------- Main -------------------------------- */
-/*------------------------------------------------------------------------*/
-
-/**
- * Visit an endpoint on another server
- * @author Gabe Abrams
- * @param opts object containing all arguments
- * @param opts.method the method of the endpoint
- * @param opts.path the path of the other server's endpoint
- * @param opts.host the host of the other server
- * @param [opts.params={}] query/body parameters to include
- * @param [opts.responseType=JSON] the response type from the other server
- */
-const visitEndpointOnAnotherServer = async (
-  opts: {
-    method: 'GET' | 'POST' | 'DELETE' | 'PUT',
-    path: string,
-    host: string,
-    params?: { [key in string]: any },
-    responseType?: 'JSON' | 'Text',
-  },
-): Promise<any> => {
-  // Get cross-server credential
-  const credential = getCrossServerCredential(opts.host);
-
-  // Sign the request, get new params
-  const augmentedParams = await signRequest({
-    method: opts.method,
-    path: opts.path,
-    params: opts.params ?? {},
-    key: credential.key,
-    secret: credential.secret,
-  });
-
-  // Send the request
-  const response = await sendServerToServerRequest({
-    path: opts.path,
-    host: opts.host,
-    method: opts.method,
-    params: augmentedParams,
-    responseType: opts.responseType,
-  });
-
-  // Check for failure
-  if (!response || !response.body) {
-    throw new ErrorWithCode(
-      'We didn\'t get a response from the other server. Please check the network between the two connection.',
-      ReactKitErrorCode.NoResponse,
-    );
-  }
-  if (!response.body.success) {
-    // 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 visitEndpointOnAnotherServer;

package/src/helpers/visitEndpointOnAnotherServer/sendServerToServerRequest.ts

@@ -1,162 +0,0 @@
-// Import libs
-import qs from 'qs';
-
-// Import shared types
-import ReactKitErrorCode from '../../types/ReactKitErrorCode';
-
-// Import custom error
-import ErrorWithCode from '../../errors/ErrorWithCode';
-
-/**
- * Sends and retries an http request
- * @author Gabriel Abrams
- * @param opts object containing all arguments
- * @param opts.path path to send request to
- * @param [opts.host] host to send request to
- * @param [opts.method=GET] http method to use
- * @param [opts.params] body/data to include in the request
- * @param [opts.responseType=JSON] expected response type
- * @returns { body, status, headers } on success
- */
-const sendServerToServerRequest = async (
-  opts: {
-    path: string,
-    host?: string,
-    method?: ('GET' | 'POST' | 'PUT' | 'DELETE'),
-    params?: { [k in string]: any },
-    responseType?: 'Text' | 'JSON',
-  },
-): Promise<{
-  body: any,
-  status: number,
-  headers: { [k in string]: any },
-}> => {
-  // Process method
-  const method: ('GET' | 'POST' | 'PUT' | 'DELETE') = (opts.method || 'GET');
-
-  // Encode objects within params
-  let params: {
-    [k in string]: any
-  } | undefined;
-  if (opts.params) {
-    params = {};
-    Object.entries(opts.params).forEach(([key, val]) => {
-      if (typeof val === 'object' && !Array.isArray(val)) {
-        (params as any)[key] = JSON.stringify(val);
-      } else {
-        (params as any)[key] = val;
-      }
-    });
-  }
-
-  // Stringify parameters
-  const stringifiedParams = qs.stringify(params || {}, {
-    encodeValuesOnly: true,
-    arrayFormat: 'brackets',
-  });
-
-  // Create url (include query if GET)
-  const query = (method === 'GET' ? `?${stringifiedParams}` : '');
-  let url;
-  if (!opts.host) {
-    // No host included at all. Just send to a path
-    url = `${opts.path}${query}`;
-  } else {
-    url = `https://${opts.host}${opts.path}${query}`;
-  }
-
-  // Update headers
-  const headers: {
-    [k: string]: any,
-  } = {};
-  let data: string | null | { [k: string]: any } | undefined = null;
-  if (!headers['Content-Type']) {
-    // Form encoded
-    headers['Content-Type'] = 'application/x-www-form-urlencoded';
-    // Add data if applicable
-    data = (method !== 'GET' ? stringifiedParams : null);
-  } else {
-    // JSON encode
-    data = params;
-  }
-
-  // Encode data
-  let encodedData: URLSearchParams | string | undefined;
-  if (data) {
-    if (headers['Content-Type'] === 'application/x-www-form-urlencoded') {
-      encodedData = new URLSearchParams(params);
-    } else {
-      encodedData = JSON.stringify(data);
-    }
-  }
-
-  // Send request
-  try {
-    const response = await fetch(
-      url,
-      {
-        method,
-        mode: 'cors',
-        headers: headers ?? {},
-        body: (
-          (method !== 'GET' && encodedData)
-            ? encodedData
-            : undefined
-        ),
-        redirect: 'follow',
-      },
-    );
-
-    // Get headers map
-    const responseHeaders: {
-      [k in string]: string
-    } = {};
-    response.headers.forEach((value, key) => {
-      responseHeaders[key] = value;
-    });
-
-    // Process response based on responseType
-    try {
-      // Parse response
-      let responseBody: any;
-      if (
-        opts.responseType
-        && opts.responseType === 'Text'
-      ) {
-        // Response type is text
-        responseBody = await response.text();
-      } else {
-        // Response type is JSON
-        responseBody = await response.json();
-      }
-
-      // Return response
-      return {
-        body: responseBody,
-        status: response.status,
-        headers: responseHeaders,
-      };
-    } catch (err) {
-      throw new ErrorWithCode(
-        `Failed to parse response as ${opts.responseType}: ${(err as any)?.message}`,
-        ReactKitErrorCode.ResponseParseError,
-      );
-    }
-  } catch (err) {
-    // Self-signed certificate error:
-    if ((err as any)?.message?.includes('self signed certificate')) {
-      throw new ErrorWithCode(
-        'We refused to send a request because the receiver has self-signed certificates.',
-        ReactKitErrorCode.SelfSigned,
-      );
-    }
-
-    // No tries left
-    throw new ErrorWithCode(
-      `We encountered an error when trying to send a network request. If this issue persists, contact an admin. Error: ${(err as any)?.message}`,
-      ReactKitErrorCode.NotConnected,
-    );
-  }
-};
-
-export default sendServerToServerRequest;

package/src/server/initCrossServerCredentialCollection.ts

@@ -1,16 +0,0 @@
-/**
- * Initialize a cross-server credential collection given the dce-mango Collection class
- * @author Gabe Abrams
- * @param Collection the Collection class from dce-mango
- * @returns initialized logCollection
- */
-const initCrossServerCredentialCollection = (Collection: any) => {
-  return new Collection(
-    'CrossServerCredential',
-    {
-      uniqueIndexKey: 'key',
-    },
-  );
-};
-
-export default initCrossServerCredentialCollection;

package/src/server/initLogCollection.ts

@@ -1,27 +0,0 @@
-/**
- * Initialize a log collection given the dce-mango Collection class
- * @author Gabe Abrams
- * @param Collection the Collection class from dce-mango
- * @returns initialized logCollection
- */
-const initLogCollection = (Collection: any) => {
-  return new Collection(
-    'Log',
-    {
-      uniqueIndexKey: 'id',
-      indexKeys: [
-        'courseId',
-        'context',
-        'subcontext',
-        'tags',
-        'year',
-        'month',
-        'day',
-        'hour',
-        'type',
-      ],
-    },
-  );
-};
-
-export default initLogCollection;