LF-4765 Make types work for the routes

Author: Duncan-Brain

packages/api/src/controllers/irrigationPrescriptionController.ts

@@ -14,13 +14,14 @@
  */
 
 import { Response } from 'express';
-import { LiteFarmRequest, HttpError } from '../types.js';
+import { HttpError, ScopeCheckedLiteFarmRequest } from '../types.js';
 import ESciAddon from '../util/ensembleService.js';
 import { fakeIrrigationPrescriptions } from '../../tests/utils/ensembleUtils.js';
 import FarmAddonModel from '../models/farmAddonModel.js';
 import { AddonFunctions, IrrigationPrescription } from '../util/ensembleService.types.js';
+import { customError } from '../util/customErrors.js';
 
-interface IrrigationPrescriptionQueryParams {
+export interface IrrigationPrescriptionQueryParams {
   startTime?: string;
   endTime?: string;
   shouldSend?: string;
@@ -34,16 +35,29 @@ const PARTNER_ID_MAP: Record<string, Partial<AddonFunctions>> = {
 
 const irrigationPrescriptionController = {
   getPrescriptions() {
-    return async (req: LiteFarmRequest<IrrigationPrescriptionQueryParams>, res: Response) => {
+    return async (
+      req: ScopeCheckedLiteFarmRequest<IrrigationPrescriptionQueryParams>,
+      res: Response,
+    ) => {
       try {
         const { farm_id } = req.headers;
         const { startTime, endTime, shouldSend } = req.query;
+        if (
+          typeof startTime != 'string' ||
+          startTime != undefined ||
+          typeof endTime != 'string' ||
+          endTime != undefined ||
+          typeof shouldSend != 'string' ||
+          shouldSend != undefined
+        ) {
+          throw customError('Bad query param');
+        }
+
         const irrigationPrescriptions: IrrigationPrescription[] = [];
         const partnerErrors: unknown[] = [];
 
         if (shouldSend === 'true') {
           // Check for registered farm addons (only esci for now)
-          // @ts-expect-error - farm_id is guaranteed here by the checkScope middleware with single argument
           const farmAddonPartnerIds = await FarmAddonModel.getDistinctFarmAddonPartnerIds(farm_id);
 
           // Return empty array if no addons
@@ -62,7 +76,6 @@ const irrigationPrescriptionController = {
               }
 
               irrigationPrescriptions.push(
-                // @ts-expect-error - farm_id is guaranteed here by the checkScope middleware with single argument
                 ...(await addonPartner.getIrrigationPrescriptions(farm_id, startTime, endTime)),
               );
             } catch (error) {
@@ -78,7 +91,6 @@ const irrigationPrescriptionController = {
         } else {
           // Return data for dev purposes + QA
           const mockData = await fakeIrrigationPrescriptions({
-            // @ts-expect-error - farm_id is guaranteed here by the checkScope middleware with single argument
             farmId: farm_id,
             startTime,
             endTime,

packages/api/src/controllers/irrigationPrescriptionRequestController.ts

@@ -15,22 +15,22 @@
 
 import { Response } from 'express';
 import { getOrgLocationAndCropData, sendFieldAndCropDataToEsci } from '../util/ensembleService.js';
-import { LiteFarmRequest } from '../types.js';
+import { ScopeCheckedLiteFarmRequest } from '../types.js';
 
 interface HttpError extends Error {
   status?: number;
   code?: number; // LF custom error
 }
 
-interface InitiateFarmIrrigationPrescriptionQueryParams {
+export interface InitiateFarmIrrigationPrescriptionQueryParams {
   allOrgs?: string;
   shouldSend?: string;
 }
 
 const irrigationPrescriptionRequestController = {
   initiateFarmIrrigationPrescription() {
     return async (
-      req: LiteFarmRequest<InitiateFarmIrrigationPrescriptionQueryParams>,
+      req: ScopeCheckedLiteFarmRequest<InitiateFarmIrrigationPrescriptionQueryParams>,
       res: Response,
     ) => {
       const { farm_id } = req.headers;

packages/api/src/middleware/acl/checkScope.ts

@@ -65,21 +65,27 @@ const checkScope = (
       return next();
     }
 
-    // Consider making this a separate middleware with checkJwt
+    // Check auth
+    // NOTE: Consider making this a separate middleware with checkJwt
     if (!req.auth) {
       return res.status(400).send('No Auth provided');
     }
-
     const { user_id } = req.auth;
     if (!user_id || user_id === 'undefined') {
       return res.status(400).send('Missing user_id in auth');
     }
 
-    const { headers } = req;
-    const { farm_id } = headers; // these are the minimum props needed for most endpoints' authorization
+    // Check headers
+    if (!req.headers) {
+      return res.status(400).send('Missing headers');
+    }
+
+    const { farm_id } = req.headers; // these are the minimum props needed for most endpoints' authorization
 
-    if (!farm_id || farm_id === 'undefined')
+    if (!farm_id || farm_id === 'undefined') {
       return res.status(400).send('Missing farm_id in headers');
+    }
+
     try {
       const scopes = await getScopes(user_id, farm_id, { checkConsent });
 

packages/api/src/routes/irrigationPrescriptionRequestRoute.ts

@@ -15,14 +15,17 @@
 
 import express from 'express';
 import checkScope from '../middleware/acl/checkScope.js';
-import IrrigationPrescriptionRequestController from '../controllers/irrigationPrescriptionRequestController.js';
+import IrrigationPrescriptionRequestController, {
+  InitiateFarmIrrigationPrescriptionQueryParams,
+} from '../controllers/irrigationPrescriptionRequestController.js';
+import { ScopeCheckedLiteFarmRequest } from '../types.js';
 
 const router = express.Router();
 
-router.post(
-  '/',
-  checkScope(['get:smart_irrigation']),
-  IrrigationPrescriptionRequestController.initiateFarmIrrigationPrescription(),
-);
+router.post('/', checkScope(['get:smart_irrigation']), (req, res) => {
+  const typedReq =
+    req as ScopeCheckedLiteFarmRequest<InitiateFarmIrrigationPrescriptionQueryParams>;
+  IrrigationPrescriptionRequestController.initiateFarmIrrigationPrescription()(typedReq, res);
+});
 
 export default router;

packages/api/src/routes/irrigationPrescriptionRoute.ts

@@ -15,14 +15,16 @@
 
 import express from 'express';
 import checkScope from '../middleware/acl/checkScope.js';
-import IrrigationPrescriptionController from '../controllers/irrigationPrescriptionController.js';
+import IrrigationPrescriptionController, {
+  IrrigationPrescriptionQueryParams,
+} from '../controllers/irrigationPrescriptionController.js';
+import { ScopeCheckedLiteFarmRequest } from '../types.js';
 
 const router = express.Router();
 
-router.get(
-  '/',
-  checkScope(['get:smart_irrigation']),
-  IrrigationPrescriptionController.getPrescriptions(),
-);
+router.get('/', checkScope(['get:smart_irrigation']), (req, res) => {
+  const typedReq = req as ScopeCheckedLiteFarmRequest<IrrigationPrescriptionQueryParams>;
+  IrrigationPrescriptionController.getPrescriptions()(typedReq, res);
+});
 
 export default router;

packages/api/src/types.ts

@@ -13,24 +13,60 @@
  *  GNU General Public License for more details, see <https://www.gnu.org/licenses/>.
  */
 
-import { NextFunction, Request, Response } from 'express';
+import { Request } from 'express';
+import { Farm, Point, Role, Task, TaskType, User } from './models/types.js';
 
 export interface HttpError extends Error {
   status?: number;
   code?: number; // LF custom error
 }
 
-// TODO: Remove farm_id conditional and cast this in a checkScope() that takes the function and casts this to req
+/**
+ * For use with unchecked requests
+ *
+ * All possible shapes of a litefarm 'req' object
+ */
 export interface LiteFarmRequest<QueryParams = unknown>
   extends Request<unknown, unknown, unknown, QueryParams> {
+  auth?: {
+    user_id?: User['user_id'];
+    farm_id?: Farm['farm_id'];
+    sub?: User['user_id'];
+    email?: User['email'];
+    given_name?: User['first_name'];
+    family_name?: User['last_name'];
+    first_name?: User['first_name'];
+    language_preference?: string;
+  };
   headers: Request['headers'] & {
-    farm_id?: string;
+    user_id?: User['user_id'];
+    farm_id?: Farm['farm_id'];
+  };
+  role?: Role['role_id'];
+  isMinimized?: boolean;
+  isTextDocument?: boolean;
+  isNotMinimized?: boolean;
+  field?: { fieldId?: string | number; point?: Point };
+  file?: unknown;
+  checkTaskStatus?: {
+    complete_date?: Task['complete_date'];
+    abandon_date?: Task['abandon_date'];
+    assignee_user_id?: Task['assignee_user_id'];
+    task_translation_key?: TaskType['task_translation_key'];
   };
 }
 
-// Can be used to cast after checkScope() succeeds
-export type LiteFarmHandler<QueryParams = unknown> = (
-  req: LiteFarmRequest<QueryParams>,
-  res: Response,
-  next: NextFunction,
-) => void | Promise<void>;
+/**
+ * For use after checkScope() middleware.
+ *
+ * DO NOT add more required props unless it is auth related, make a new type
+ */
+
+export interface ScopeCheckedLiteFarmRequest<ReqQuery = unknown> extends LiteFarmRequest<ReqQuery> {
+  auth: {
+    user_id: User['user_id'];
+  };
+  headers: Request['headers'] & {
+    farm_id: string;
+  };
+}