feat: updated rules checks

BREAKING CHANGE: for propertyType add

Author: kvernon

README.md

@@ -86,12 +86,12 @@ Once a feature's PR is merged, the pipeline will run checks and publish.
   - What would the transition look like in code?
 - TODO: Cash flow ramp (0 - 3 months depending on rehab, conventional, or existing tenant)
   - Transition would be around Hard Money vs Conventional
-- TODO: delay 1st mortgage payment
-- TODO: figure out 1031 exchange
 
 ## Missing features
 
-1. apartments (passive investor)
+1. delay 1st mortgage payment
+2. implement hold rules
+3. apartments (passive investor)
 
 ## Future
 
@@ -159,8 +159,8 @@ const options: ISimulateOptions = {
 
 const actual = simulate(options);
 
-//Finally, to review your results, you can use the user's getSummariesAnnual.
-const lastYear = actual.user.getSummariesAnnual(
+//Finally, to review your results, you can use the ledgerCollection's getSummariesAnnual.
+const lastYear = actual.user.ledgerCollection.getSummariesAnnual(
   actual.endDate.getUTCFullYear()
 );
 ```

src/rules/get-rules.ts

@@ -7,5 +7,5 @@ export function getRules<E extends PurchaseRuleTypes | HoldRuleTypes>(goals: IRu
   if (!goals || goals.length === 0) {
     return [];
   }
-  return goals.map((g: IRule<E>) => new RuleEvaluation<E>(g.value, g.type));
+  return goals.map((g: IRule<E>) => new RuleEvaluation<E>(g.value, g.type, g.propertyType));
 }

src/rules/i-rule.ts

@@ -1,4 +1,7 @@
+import { PropertyType } from '../account/property-type';
+
 export interface IRule<E> {
   type: E;
   value: number;
+  propertyType: PropertyType;
 }

src/rules/rule-evaluation.ts

@@ -2,19 +2,22 @@ import { PurchaseRuleTypes } from './purchase-rule-types';
 import { HoldRuleTypes } from './hold-rule-types';
 import { AtLeastOrMore, NoMoreThan } from './eval-types';
 import { IRule } from './i-rule';
+import { PropertyType } from '../account/property-type';
 
 export interface IRuleEvaluation<E extends PurchaseRuleTypes | HoldRuleTypes> extends IRule<E> {
   evaluate(dataValue: number): boolean;
 }
 
 export class RuleEvaluation<E extends PurchaseRuleTypes | HoldRuleTypes> implements IRuleEvaluation<E> {
-  constructor(value: number, type: E) {
+  constructor(value: number, type: E, propertyType: PropertyType) {
     this.value = value;
     this.type = type;
+    this.propertyType = propertyType;
   }
 
   type: E;
   value: number;
+  propertyType: PropertyType;
 
   evaluate(dataValue: number): boolean {
     if (!this.type || this.type.toString().indexOf('none') !== -1) {

src/time/movement.ts

@@ -8,6 +8,11 @@ import { LedgerItemType } from '../ledger/ledger-item-type';
 import { LedgerItem } from '../ledger/ledger-item';
 import propertySort from '../properties/property-sort';
 import { cloneDateUtc } from '../utils/data-clone-date';
+import { ensureArray } from '../utils/ensure';
+import { ILoanSetting } from '../account/i-loan-settings';
+import { PropertyType } from '../account/property-type';
+import { IRuleEvaluation } from '../rules/rule-evaluation';
+import { PurchaseRuleTypes } from '../rules/purchase-rule-types';
 
 export interface ILoopOptions {
   /**
@@ -49,6 +54,15 @@ export function loop(options: ILoopOptions, user: IUser): ITimeline {
     options.startDate = cloneDateUtc(setupDate);
   }
 
+  ensureArray<ILoanSetting>(user.loanSettings, {
+    predicate: (item) => item.propertyType === PropertyType.SingleFamily,
+    message: 'no single family loan settings for user: loanSettings',
+  });
+  ensureArray<IRuleEvaluation<PurchaseRuleTypes>>(user.purchaseRules, {
+    predicate: (item) => item.propertyType === PropertyType.SingleFamily,
+    message: 'no single family purchase rules for user: purchaseRules',
+  });
+
   let today = cloneDateUtc(options.startDate);
 
   const result: ITimeline = {

src/time/simulate.ts

@@ -88,7 +88,7 @@ export function simulate(options: ISimulateOptions): ITimeline {
   user.monthlySavedAmount = options.monthlySavedAmount;
   user.monthlyIncomeAmountGoal = options.monthlyIncomeAmountGoal;
   user.loanSettings = options.loanSettings;
-  user.purchaseRules = (options.purchaseRules || []).map((r) => new RuleEvaluation(r.value, r.type));
+  user.purchaseRules = (options.purchaseRules || []).map((r) => new RuleEvaluation(r.value, r.type, r.propertyType));
 
   return loop(
     {

src/utils/ensure.ts

@@ -0,0 +1,20 @@
+export type EnsureArrayPredicate<T> = (item: T, index?: number) => boolean;
+
+export function ensureArray<T>(array?: T[], options?: { predicate?: EnsureArrayPredicate<T>; message?: string }): void {
+  const message = 'array is invalid';
+  if (!options) {
+    options = { message };
+  }
+
+  if (!options.message) {
+    options.message = message;
+  }
+
+  if (!array || array.length === 0) {
+    throw new Error(options.message);
+  }
+
+  if (options.predicate && array.filter(options.predicate).length === 0) {
+    throw new Error(options.message);
+  }
+}

src/utils/index.ts

@@ -2,3 +2,4 @@ export * from './data-are-same-date';
 export * from './data-clone-date';
 export * from './data-number';
 export * from './data-property-entity';
+export * from './ensure';

tests/accounts/user.spec.ts

@@ -140,6 +140,45 @@ describe('User unit tests', () => {
     });
   });
 
+  describe('and getCashFlowMonth', () => {
+    test('should match', () => {
+      const date = new Date();
+
+      const expected = 500;
+
+      ledgerCollection.getCashFlowMonth.mockReturnValueOnce(expected);
+
+      expect(instance.getCashFlowMonth(date)).toEqual(expected);
+      expect(ledgerCollection.getCashFlowMonth).toBeCalledWith(date);
+    });
+  });
+
+  describe('and metMonthlyGoal', () => {
+    test('should be true', () => {
+      const date = new Date();
+
+      const expected = 500;
+
+      ledgerCollection.getCashFlowMonth.mockReturnValueOnce(expected);
+      instance.monthlyIncomeAmountGoal = 500;
+
+      expect(instance.metMonthlyGoal(date)).toBeTruthy();
+      expect(ledgerCollection.getCashFlowMonth).toBeCalledWith(date);
+    });
+
+    test('should be false', () => {
+      const date = new Date();
+
+      const expected = 499;
+
+      ledgerCollection.getCashFlowMonth.mockReturnValueOnce(expected);
+      instance.monthlyIncomeAmountGoal = 500;
+
+      expect(instance.metMonthlyGoal(date)).toBeFalsy();
+      expect(ledgerCollection.getCashFlowMonth).toBeCalledWith(date);
+    });
+  });
+
   describe('and getSummaryAnnual', () => {
     test('should match', () => {
       const year = chance.integer();

tests/calculations/can-invest-by-user.spec.ts

@@ -5,6 +5,7 @@ import { UserInvestResult } from '../../src/investments/user-invest-result';
 import { RentalSingleFamily } from '../../src/properties/rental-single-family';
 import { PurchaseRuleTypes } from '../../src/rules/purchase-rule-types';
 import { IUserInvestorCheck } from '../../src/account/i-user-investor-check';
+import { PropertyType } from '../../src/account/property-type';
 
 describe('and canInvestByUser', () => {
   let instance: RentalSingleFamily;
@@ -98,11 +99,13 @@ describe('and canInvestByUser', () => {
         purchaseRules: [
           {
             type: PurchaseRuleTypes.minAskingPrice,
+            propertyType: PropertyType.SingleFamily,
             value: 50000,
             evaluate: jest.fn().mockReturnValue(false),
           },
           {
             type: PurchaseRuleTypes.maxEstimatedOutOfPocket,
+            propertyType: PropertyType.SingleFamily,
             value: 50000,
             evaluate: jest.fn().mockReturnValue(false),
           },
@@ -130,11 +133,13 @@ describe('and canInvestByUser', () => {
         purchaseRules: [
           {
             type: PurchaseRuleTypes.minAfterRepairPrice,
+            propertyType: PropertyType.SingleFamily,
             value: 50000,
             evaluate: jest.fn().mockReturnValue(false),
           },
           {
             type: PurchaseRuleTypes.maxEstimatedOutOfPocket,
+            propertyType: PropertyType.SingleFamily,
             value: 50000,
             evaluate: jest.fn().mockReturnValue(false),
           },