chore(release): publish new version

- @standardnotes/scheduler-server@1.9.1

packages/auth/CHANGELOG.md

@@ -3,6 +3,12 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.11.31](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.11.30...@standardnotes/auth-server@1.11.31) (2022-07-25)
+
+### Bug Fixes
+
+* **auth:** marking predicate verification result if user is not existing ([40996f9](https://github.com/standardnotes/server/commit/40996f9d485686f92ee57fe6337102d94378b39b))
+
 ## [1.11.30](https://github.com/standardnotes/server/compare/@standardnotes/auth-server@1.11.29...@standardnotes/auth-server@1.11.30) (2022-07-25)
 
 **Note:** Version bump only for package @standardnotes/auth-server

packages/auth/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@standardnotes/auth-server",
-  "version": "1.11.30",
+  "version": "1.11.31",
   "engines": {
     "node": ">=16.0.0 <17.0.0"
   },

packages/auth/src/Domain/Handler/PredicateVerificationRequestedEventHandler.spec.ts

@@ -96,7 +96,7 @@ describe('PredicateVerificationRequestedEventHandler', () => {
     expect(domainEventPublisher.publish).toHaveBeenCalled()
   })
 
-  it('should not verify a predicate if user is missing', async () => {
+  it('should mark a predicate verification with undetermined result if user is missing', async () => {
     event.meta = {
       correlation: {
         userIdentifier: 'test@test.te',
@@ -110,6 +110,6 @@ describe('PredicateVerificationRequestedEventHandler', () => {
     await createHandler().handle(event)
 
     expect(verifyPredicate.execute).not.toHaveBeenCalled()
-    expect(domainEventPublisher.publish).not.toHaveBeenCalled()
+    expect(domainEventPublisher.publish).toHaveBeenCalled()
   })
 })

packages/auth/src/Domain/Handler/PredicateVerificationRequestedEventHandler.ts

@@ -3,6 +3,7 @@ import {
   DomainEventPublisherInterface,
   PredicateVerificationRequestedEvent,
 } from '@standardnotes/domain-events'
+import { PredicateVerificationResult } from '@standardnotes/predicates'
 import { inject, injectable } from 'inversify'
 import { Logger } from 'winston'
 
@@ -28,7 +29,13 @@ export class PredicateVerificationRequestedEventHandler implements DomainEventHa
     if (event.meta.correlation.userIdentifierType === 'email') {
       const user = await this.userRepository.findOneByEmail(event.meta.correlation.userIdentifier)
       if (user === null) {
-        this.logger.warn(`Could not find user ${event.meta.correlation.userIdentifier} for predicate verification`)
+        await this.domainEventPublisher.publish(
+          this.domainEventFactory.createPredicateVerifiedEvent({
+            predicate: event.payload.predicate,
+            predicateVerificationResult: PredicateVerificationResult.CouldNotBeDetermined,
+            userUuid,
+          }),
+        )
 
         return
       }

packages/scheduler/CHANGELOG.md

@@ -3,6 +3,18 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [1.9.1](https://github.com/standardnotes/server/compare/@standardnotes/scheduler-server@1.9.0...@standardnotes/scheduler-server@1.9.1) (2022-07-26)
+
+### Bug Fixes
+
+* **scheduler:** eliminate read/write concurrency hazzard while updating predicate status ([4ab0d24](https://github.com/standardnotes/server/commit/4ab0d24d24b62babf5d0e36fbcb3a6364abb71bc))
+
+# [1.9.0](https://github.com/standardnotes/server/compare/@standardnotes/scheduler-server@1.8.2...@standardnotes/scheduler-server@1.9.0) (2022-07-25)
+
+### Features
+
+* **scheduler:** add job interpreting logs ([bf12687](https://github.com/standardnotes/server/commit/bf12687f63738a6eac46ab1778826de5d076e4ab))
+
 ## [1.8.2](https://github.com/standardnotes/server/compare/@standardnotes/scheduler-server@1.8.1...@standardnotes/scheduler-server@1.8.2) (2022-07-25)
 
 **Note:** Version bump only for package @standardnotes/scheduler-server

packages/scheduler/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@standardnotes/scheduler-server",
-  "version": "1.8.2",
+  "version": "1.9.1",
   "engines": {
     "node": ">=16.0.0 <17.0.0"
   },

packages/scheduler/src/Domain/Job/JobDoneInterpreter.spec.ts

@@ -6,6 +6,7 @@ import {
 } from '@standardnotes/domain-events'
 import { PredicateName } from '@standardnotes/predicates'
 import 'reflect-metadata'
+import { Logger } from 'winston'
 import { DomainEventFactoryInterface } from '../Event/DomainEventFactoryInterface'
 import { Predicate } from '../Predicate/Predicate'
 import { PredicateRepositoryInterface } from '../Predicate/PredicateRepositoryInterface'
@@ -23,9 +24,10 @@ describe('JobDoneInterpreter', () => {
   let domainEventFactory: DomainEventFactoryInterface
   let domainEventPublisher: DomainEventPublisherInterface
   let job: Job
+  let logger: Logger
 
   const createInterpreter = () =>
-    new JobDoneInterpreter(jobRepository, predicateRepository, domainEventFactory, domainEventPublisher)
+    new JobDoneInterpreter(jobRepository, predicateRepository, domainEventFactory, domainEventPublisher, logger)
 
   beforeEach(() => {
     job = {} as jest.Mocked<Job>
@@ -49,6 +51,10 @@ describe('JobDoneInterpreter', () => {
 
     domainEventPublisher = {} as jest.Mocked<DomainEventPublisherInterface>
     domainEventPublisher.publish = jest.fn()
+
+    logger = {} as jest.Mocked<Logger>
+    logger.info = jest.fn()
+    logger.warn = jest.fn()
   })
 
   it('should do nothing if job is not found', async () => {

packages/scheduler/src/Domain/Job/JobDoneInterpreter.ts

@@ -2,6 +2,7 @@ import { EmailMessageIdentifier } from '@standardnotes/common'
 import { DomainEventPublisherInterface } from '@standardnotes/domain-events'
 import { PredicateName } from '@standardnotes/predicates'
 import { inject, injectable } from 'inversify'
+import { Logger } from 'winston'
 
 import TYPES from '../../Bootstrap/Types'
 import { DomainEventFactoryInterface } from '../Event/DomainEventFactoryInterface'
@@ -20,6 +21,7 @@ export class JobDoneInterpreter implements JobDoneInterpreterInterface {
     @inject(TYPES.PredicateRepository) private predicateRepository: PredicateRepositoryInterface,
     @inject(TYPES.DomainEventFactory) private domainEventFactory: DomainEventFactoryInterface,
     @inject(TYPES.DomainEventPublisher) private domainEventPublisher: DomainEventPublisherInterface,
+    @inject(TYPES.Logger) private logger: Logger,
   ) {}
 
   async interpret(jobUuid: string): Promise<void> {
@@ -29,14 +31,18 @@ export class JobDoneInterpreter implements JobDoneInterpreterInterface {
       return
     }
 
+    this.logger.info(`[${jobUuid}]${job.name}: Interpreting job as done.`)
+
     if (!(await this.predicatesAreFulfilled(job))) {
+      this.logger.info(`[${jobUuid}]${job.name}: predicates are not fulfilled.`)
+
       return
     }
 
     switch (job.name) {
       case JobName.ENCOURAGE_EMAIL_BACKUPS:
         if (job.userIdentifierType === 'email') {
-          await this.requestEmailBackupEncouragementEmail(job.userIdentifier)
+          await this.requestEmailBackupEncouragementEmail(job)
         }
         return
       case JobName.ENCOURAGE_SUBSCRIPTION_PURCHASING:
@@ -46,28 +52,32 @@ export class JobDoneInterpreter implements JobDoneInterpreterInterface {
         return
       case JobName.EXIT_INTERVIEW:
         if (job.userIdentifierType === 'email') {
-          await this.requestExitInterviewEmail(job.userIdentifier)
+          await this.requestExitInterviewEmail(job)
         }
         return
       case JobName.APPLY_SUBSCRIPTION_DISCOUNT:
         if (job.userIdentifierType === 'email' && job.userIdentifier.includes('@standardnotes.com')) {
-          await this.requestDiscountApply(job.userIdentifier)
+          await this.requestDiscountApply(job)
         }
         return
       case JobName.WITHDRAW_SUBSCRIPTION_DISCOUNT:
         if (job.userIdentifierType === 'email' && job.userIdentifier.includes('@standardnotes.com')) {
-          await this.requestDiscountWithdraw(job.userIdentifier)
+          await this.requestDiscountWithdraw(job)
         }
         return
       default:
+        this.logger.warn(`[${jobUuid}]${job.name}: job is not interpretable.`)
+
         return
     }
   }
 
-  private async requestEmailBackupEncouragementEmail(userEmail: string): Promise<void> {
+  private async requestEmailBackupEncouragementEmail(job: Job): Promise<void> {
+    this.logger.info(`[${job.uuid}]${job.name}: requesting email backup encouragement email.`)
+
     await this.domainEventPublisher.publish(
       this.domainEventFactory.createEmailMessageRequestedEvent({
-        userEmail,
+        userEmail: job.userIdentifier,
         messageIdentifier: EmailMessageIdentifier.ENCOURAGE_EMAIL_BACKUPS,
         context: {},
       }),
@@ -75,6 +85,8 @@ export class JobDoneInterpreter implements JobDoneInterpreterInterface {
   }
 
   private async requestSubscriptionPurchaseEncouragementEmail(job: Job): Promise<void> {
+    this.logger.info(`[${job.uuid}]${job.name}: requesting subscription purchase encouragement email.`)
+
     await this.domainEventPublisher.publish(
       this.domainEventFactory.createEmailMessageRequestedEvent({
         userEmail: job.userIdentifier,
@@ -86,29 +98,35 @@ export class JobDoneInterpreter implements JobDoneInterpreterInterface {
     )
   }
 
-  private async requestExitInterviewEmail(userEmail: string): Promise<void> {
+  private async requestExitInterviewEmail(job: Job): Promise<void> {
+    this.logger.info(`[${job.uuid}]${job.name}: requesting exit interview email.`)
+
     await this.domainEventPublisher.publish(
       this.domainEventFactory.createEmailMessageRequestedEvent({
-        userEmail,
+        userEmail: job.userIdentifier,
         messageIdentifier: EmailMessageIdentifier.EXIT_INTERVIEW,
         context: {},
       }),
     )
   }
 
-  private async requestDiscountApply(userEmail: string): Promise<void> {
+  private async requestDiscountApply(job: Job): Promise<void> {
+    this.logger.info(`[${job.uuid}]${job.name}: requesting discount applying.`)
+
     await this.domainEventPublisher.publish(
       this.domainEventFactory.createDiscountApplyRequestedEvent({
-        userEmail,
+        userEmail: job.userIdentifier,
         discountCode: 'econ-10',
       }),
     )
   }
 
-  private async requestDiscountWithdraw(userEmail: string): Promise<void> {
+  private async requestDiscountWithdraw(job: Job): Promise<void> {
+    this.logger.info(`[${job.uuid}]${job.name}: requesting discount withdraw.`)
+
     await this.domainEventPublisher.publish(
       this.domainEventFactory.createDiscountWithdrawRequestedEvent({
-        userEmail,
+        userEmail: job.userIdentifier,
         discountCode: 'econ-10',
       }),
     )

packages/scheduler/src/Domain/UseCase/UpdatePredicateStatus/UpdatePredicateStatus.spec.ts

@@ -1,8 +1,7 @@
-import { PredicateAuthority, PredicateName, PredicateVerificationResult } from '@standardnotes/predicates'
 import 'reflect-metadata'
 
-import { JobDoneInterpreterInterface } from '../../Job/JobDoneInterpreterInterface'
-import { JobRepositoryInterface } from '../../Job/JobRepositoryInterface'
+import { PredicateAuthority, PredicateName, PredicateVerificationResult } from '@standardnotes/predicates'
+
 import { Predicate } from '../../Predicate/Predicate'
 import { PredicateRepositoryInterface } from '../../Predicate/PredicateRepositoryInterface'
 import { PredicateStatus } from '../../Predicate/PredicateStatus'
@@ -11,12 +10,10 @@ import { UpdatePredicateStatus } from './UpdatePredicateStatus'
 
 describe('UpdatePredicateStatus', () => {
   let predicateRepository: PredicateRepositoryInterface
-  let jobRepository: JobRepositoryInterface
-  let jobDoneInterpreter: JobDoneInterpreterInterface
   let predicateComplete: Predicate
   let predicateIncomplete: Predicate
 
-  const createUseCase = () => new UpdatePredicateStatus(predicateRepository, jobRepository, jobDoneInterpreter)
+  const createUseCase = () => new UpdatePredicateStatus(predicateRepository)
 
   beforeEach(() => {
     predicateComplete = {
@@ -33,15 +30,9 @@ describe('UpdatePredicateStatus', () => {
     predicateRepository = {} as jest.Mocked<PredicateRepositoryInterface>
     predicateRepository.findByJobUuid = jest.fn().mockReturnValue([predicateComplete, predicateIncomplete])
     predicateRepository.save = jest.fn()
-
-    jobRepository = {} as jest.Mocked<JobRepositoryInterface>
-    jobRepository.markJobAsDone = jest.fn()
-
-    jobDoneInterpreter = {} as jest.Mocked<JobDoneInterpreterInterface>
-    jobDoneInterpreter.interpret = jest.fn()
   })
 
-  it('should mark a predicate as complete and update job as done', async () => {
+  it('should mark a predicate as complete', async () => {
     expect(
       await createUseCase().execute({
         predicate: { name: PredicateName.EmailBackupsEnabled, jobUuid: '1-2-3', authority: PredicateAuthority.Auth },
@@ -49,7 +40,6 @@ describe('UpdatePredicateStatus', () => {
       }),
     ).toEqual({
       success: true,
-      allPredicatesChecked: true,
     })
 
     expect(predicateRepository.save).toHaveBeenCalledWith({
@@ -57,37 +47,5 @@ describe('UpdatePredicateStatus', () => {
       name: 'email-backups-enabled',
       status: 'denied',
     })
-
-    expect(jobRepository.markJobAsDone).toHaveBeenCalled()
-    expect(jobDoneInterpreter.interpret).toHaveBeenCalled()
-  })
-
-  it('should mark a predicate as complete and not update job as done if there are still incomplete predicates', async () => {
-    predicateRepository.findByJobUuid = jest
-      .fn()
-      .mockReturnValue([
-        predicateComplete,
-        predicateIncomplete,
-        { uuid: '3-4-5', status: PredicateStatus.Pending } as jest.Mocked<Predicate>,
-      ])
-
-    expect(
-      await createUseCase().execute({
-        predicate: { name: PredicateName.EmailBackupsEnabled, jobUuid: '1-2-3', authority: PredicateAuthority.Auth },
-        predicateVerificationResult: PredicateVerificationResult.Denied,
-      }),
-    ).toEqual({
-      success: true,
-      allPredicatesChecked: false,
-    })
-
-    expect(predicateRepository.save).toHaveBeenCalledWith({
-      uuid: '2-3-4',
-      name: 'email-backups-enabled',
-      status: 'denied',
-    })
-
-    expect(jobRepository.markJobAsDone).not.toHaveBeenCalled()
-    expect(jobDoneInterpreter.interpret).not.toHaveBeenCalled()
   })
 })

packages/scheduler/src/Domain/UseCase/UpdatePredicateStatus/UpdatePredicateStatus.ts

@@ -1,8 +1,6 @@
 import { inject, injectable } from 'inversify'
 
 import TYPES from '../../../Bootstrap/Types'
-import { JobDoneInterpreterInterface } from '../../Job/JobDoneInterpreterInterface'
-import { JobRepositoryInterface } from '../../Job/JobRepositoryInterface'
 import { PredicateRepositoryInterface } from '../../Predicate/PredicateRepositoryInterface'
 import { PredicateStatus } from '../../Predicate/PredicateStatus'
 import { UseCaseInterface } from '../UseCaseInterface'
@@ -12,35 +10,20 @@ import { UpdatePredicateStatusResponse } from './UpdatePredicateStatusResponse'
 
 @injectable()
 export class UpdatePredicateStatus implements UseCaseInterface {
-  constructor(
-    @inject(TYPES.PredicateRepository) private predicateRepository: PredicateRepositoryInterface,
-    @inject(TYPES.JobRepository) private jobRepository: JobRepositoryInterface,
-    @inject(TYPES.JobDoneInterpreter) private jobDoneInterpreter: JobDoneInterpreterInterface,
-  ) {}
+  constructor(@inject(TYPES.PredicateRepository) private predicateRepository: PredicateRepositoryInterface) {}
 
   async execute(dto: UpdatePredicateStatusDTO): Promise<UpdatePredicateStatusResponse> {
     const predicates = await this.predicateRepository.findByJobUuid(dto.predicate.jobUuid)
 
-    let allPredicatesChecked = true
     for (const predicate of predicates) {
       if (predicate.name === dto.predicate.name) {
         predicate.status = dto.predicateVerificationResult as unknown as PredicateStatus
         await this.predicateRepository.save(predicate)
       }
-      if (predicate.status === PredicateStatus.Pending) {
-        allPredicatesChecked = false
-      }
-    }
-
-    if (allPredicatesChecked) {
-      await this.jobDoneInterpreter.interpret(dto.predicate.jobUuid)
-
-      await this.jobRepository.markJobAsDone(dto.predicate.jobUuid)
     }
 
     return {
       success: true,
-      allPredicatesChecked,
     }
   }
 }

packages/scheduler/src/Domain/UseCase/UpdatePredicateStatus/UpdatePredicateStatusResponse.ts

@@ -1,6 +1,3 @@
-export type UpdatePredicateStatusResponse =
-  | {
-      success: true
-      allPredicatesChecked: boolean
-    }
-  | { success: false }
+export type UpdatePredicateStatusResponse = {
+  success: boolean
+}