Use deno lint and AI to clean and optimize the code

[jduan00]

1. Use deno lint to clean up typescript code: https://www.perplexity.ai/search/8ee4209b-f3d2-429e-8f5e-4c20f47c41c4
2. Use AI to optimize code

[jduan00]

Example:

% deno lint model.ts
error[no-explicit-any]: `any` type is not allowed
  --> /Users/jduan/UnixStuff/devel/whereis-api-v0/main/model.ts:34:53
   | 
34 |     public static initialize(record: Record<string, any>): void {
   |                                                     ^^^
   = hint: Use a specific type other than `any`

  docs: https://docs.deno.com/lint/rules/no-explicit-any

https://docs.deno.com/lint/rules/no-explicit-any

[samshdn]

yes, we can use deno lint /.ts to optimize the code.

all the code has been updated.

[jduan00]

Here is the file changed with claude-3-7-sonnet-latest, using prompt "review and optimize the typescript code"

main/model.ts

model.zip

[jduan00]

AI code refactoring examples

Orginal code in model.ts

/**
   * Parses a tracking ID string into a TrackingID object or returns an error code.
   * @param {string} strTrackingID - The tracking ID string to parse (e.g., "fdx-123456789012").
   * @returns [string, TrackingID] An array containing an error code (if any) and the parsed TrackingID object (or undefined).
   */
  static parse(strTrackingID: string): TrackingID {
    const array = strTrackingID.split("-");
    if ("" == strTrackingID.trim()) {
      throw new UserError("400-01");
    } else if (array.length != 2) {
      throw new UserError("400-05");
    } else {
      const operator: string = array[0];
      const trackingNum: string = array[1];
      if (!this.operators.includes(operator)) {
        throw new UserError("400-04");
      }
      if ("fdx" == operator) {
        this.checkFedExTrackingNum(trackingNum);
      }
      if ("sfex" == operator) {
        this.checkSFTrackingNum(trackingNum);
      }
      return new TrackingID(operator, trackingNum);
    }
  }

VSCode with Github copilot

/**
   * Parses a tracking ID string into a TrackingID object or returns an error code.
   * @param {string} strTrackingID - The tracking ID string to parse (e.g., "fdx-123456789012").
   * @returns [string, TrackingID] An array containing an error code (if any) and the parsed TrackingID object (or undefined).
   */
  static parse(strTrackingID: string): [string, TrackingID | undefined] {
    const NO_ERROR = "NO_ERROR";
    const array = strTrackingID.split("-");
    
    if (strTrackingID == null || strTrackingID.trim() === "") {
      return ["400-01", undefined];
    } else if (!Array.isArray(array) || array.length !== 2 || array.some(item => typeof item !== "string" || item.trim() === "")) {
      return ["400-05", undefined];
    } else {
      const operator: string = array[0];
      const trackingNum: string = array[1];
      if (!this.operators.includes(operator.toLowerCase())) {
        return ["400-04", undefined];
      }
      
      if (operator === "fdx") {
        const errorCode = this.checkFedExTrackingNum(trackingNum);
        if (errorCode != undefined) {
          return [errorCode, undefined];
        }
      }
      
      if (operator === "sfex") {
        const errorCode = this.checkSFTrackingNum(trackingNum);
        if (errorCode != undefined) {
          return [errorCode, undefined];
        }
      }
      
      return [NO_ERROR, new TrackingID(operator, trackingNum)];
    }
  }

Zed with Claude 3.5

  /**
   * Parses a tracking ID string into a TrackingID object or returns an error code.
   * @param {string} strTrackingID - The tracking ID string to parse (e.g., "fdx-123456789012").
   * @returns [string, TrackingID] An array containing an error code (if any) and the parsed TrackingID object (or undefined).
   */
  static parse(strTrackingID: string): [string, TrackingID | undefined] {
    if (strTrackingID.trim() === "") {
      return ["400-01", undefined];
    }

    const array = strTrackingID.split("-");
    if (array.length !== 2) {
      return ["400-05", undefined];
    }

    const [operator, trackingNum] = array;

    if (!this.operators.includes(operator)) {
      return ["400-04", undefined];
    }

    // Currently only support two operators
    const validationMap = {
      "fdx": this.checkFedExTrackingNum,
      "sfex": this.checkSFTrackingNum
    };

    const validateTrackingNum = validationMap[operator as keyof typeof validationMap];
    const errorCode = validateTrackingNum(trackingNum);

    if (errorCode) {
      return [errorCode, undefined];
    }

    return ["", new TrackingID(operator, trackingNum)];
  }

[jduan00]

Claude 3.7. Cleaner.

Here's a refactored version of the parse method:

/**
 * Parses a tracking ID string into a TrackingID object.
 * @param {string} strTrackingID - The tracking ID string to parse (e.g., "fdx-123456789012").
 * @returns {TrackingID} The parsed TrackingID object.
 * @throws {UserError} If the tracking ID format is invalid.
 */
static parse(strTrackingID: string): TrackingID {
  // Check for empty tracking ID
  if (!strTrackingID?.trim()) {
    throw new UserError("400-01");
  }
  
  const array = strTrackingID.split("-");
  
  // Check for correct format (operatorCode-trackingNum)
  if (array.length !== 2) {
    throw new UserError("400-05");
  }
  
  const [operator, trackingNum] = array;
  
  // Validate operator
  if (!this.operators.includes(operator)) {
    throw new UserError("400-04");
  }
  
  // Validate tracking number based on operator
  switch (operator) {
    case "fdx":
      this.checkFedExTrackingNum(trackingNum);
      break;
    case "sfex":
      this.checkSFTrackingNum(trackingNum);
      break;
  }
  
  return new TrackingID(operator, trackingNum);
}

Improvements made:

1. Fixed the JSDoc return type to match the actual return type (TrackingID, not [string, TrackingID])
2. Added proper error documentation in the JSDoc
3. Added null/undefined check with optional chaining for strTrackingID
4. Used array destructuring for cleaner code
5. Replaced multiple if-else statements with a switch statement for operator validation
6. Used strict equality operator (!== instead of !=)
7. Removed redundant else statements by using early returns (via throws)
8. Improved code readability with better spacing and organization
9. Used consistent comparison style (condition on the left)

[jduan00]

Claude 3.7 -- further improvements

Here's a refactored version of your parse method using an object literal approach instead of switch-case:

/**
 * Parses a tracking ID string into a TrackingID object.
 * @param {string} strTrackingID - The tracking ID string to parse (e.g., "fdx-123456789012").
 * @returns {TrackingID} The parsed TrackingID object.
 * @throws {UserError} If the tracking ID format is invalid.
 */
static parse(strTrackingID: string): TrackingID {
  // Check for empty tracking ID
  if (!strTrackingID?.trim()) {
    throw new UserError("400-01");
  }
  
  const array = strTrackingID.split("-");
  
  // Check for correct format (operator-number)
  if (array.length !== 2) {
    throw new UserError("400-05");
  }
  
  const [operator, trackingNum] = array;
  
  // Validate operator
  if (!this.operators.includes(operator)) {
    throw new UserError("400-04");
  }
  
  // Validate tracking number based on operator using object literal
  const trackingValidators: Record<string, (trackingNum: string) => void> = {
    "fdx":  this.checkFedExTrackingNum,
    "sfex": this.checkSFTrackingNum
  };
  
  // Call the appropriate validator if it exists
  if (trackingValidators[operator]) {
    trackingValidators[operator].call(this, trackingNum);
  }
  
  return new TrackingID(operator, trackingNum);
}

This approach:

1. Uses an object literal (trackingValidators) to map operators to their respective validation functions
2. Eliminates the need for switch-case statements and break keywords
3. Makes it easy to add new operators and their validation functions in the future
4. Uses the call() method to ensure the validation functions have the correct this context
5. Only calls the validator if one exists for the given operator

The code is now more maintainable and follows a more declarative pattern.