feat: Add FASTER support

package.json

@@ -75,6 +75,7 @@
     "eslint-config-prettier": "^9.0.0",
     "eslint-plugin-prettier": "^5.0.0",
     "jest": "^29.5.0",
+    "jest-extended": "^7.0.0",
     "jest-mock": "^29.7.0",
     "prettier": "^3.0.0",
     "source-map-support": "^0.5.21",
@@ -100,7 +101,13 @@
       "**/*.(t|j)s"
     ],
     "coverageDirectory": "../coverage",
-    "testEnvironment": "node"
+    "testEnvironment": "node",
+    "setupFilesAfterEnv": [
+      "jest-extended/all"
+    ],
+    "moduleNameMapper": {
+      "^src/(.*)$": "<rootDir>/$1"
+    }
   },
   "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
 }

src/app.controller.spec.ts

@@ -15,8 +15,8 @@ describe('AppController', () => {
   });
 
   describe('root', () => {
-    it('should return "Hello World!"', () => {
-      expect(appController.getHello()).toBe('Hello World!');
+    it('should return "ok"', () => {
+      expect(appController.getId({} as any)).toBe('ok');
     });
   });
 });

src/app.module.ts

@@ -23,6 +23,7 @@ import { RedisService } from './services/redis.service';
 import { AiSkillsModule } from './aiskills/aiskills.module';
 import { CourseModule} from './courses/course.module';
 import { EnrollmentModule } from './enrollment/enrollment.module';
+import { FasterModule } from './faster/faster.module';
 
 @Module({
   imports: [
@@ -42,6 +43,7 @@ import { EnrollmentModule } from './enrollment/enrollment.module';
     SisModule,
     AiSkillsModule,
     CourseModule,
+    FasterModule,
 
     TypeOrmModule.forRootAsync({
       imports: [ConfigModule],
@@ -87,6 +89,10 @@ import { EnrollmentModule } from './enrollment/enrollment.module';
         path: 'aiskills',
         module: AiSkillsModule,
       },
+      {
+        path: 'faster',
+        module: FasterModule,
+      },
     ]),
   ],
   providers: [

src/connection/connection.controller.spec.ts

@@ -1,12 +1,26 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { ConnectionController } from './connection.controller';
+import { ConnectionService } from './connection.service';
+import { ConfigService } from '@nestjs/config';
+import { EventsGateway } from '../events/events.gateway';
+import { SisService } from '../sis/sis.service';
+import { AcaPyService } from '../services/acapy.service';
+import { WorkflowService } from '../workflow/workflow.service';
 
 describe('ConnectionController', () => {
   let controller: ConnectionController;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       controllers: [ConnectionController],
+      providers: [
+        ConnectionService,
+        { provide: ConfigService, useValue: { get: jest.fn() } },
+        { provide: EventsGateway, useValue: { server: { emit: jest.fn() } } },
+        { provide: SisService, useValue: { getStudentId: jest.fn() } },
+        { provide: AcaPyService, useValue: { createConnection: jest.fn() } },
+        { provide: WorkflowService, useValue: { updateWorkflow: jest.fn() } },
+      ],
     }).compile();
 
     controller = module.get<ConnectionController>(ConnectionController);

src/connection/connection.service.spec.ts

@@ -1,12 +1,24 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { ConnectionService } from './connection.service';
+import { ConfigService } from '@nestjs/config';
+import { EventsGateway } from '../events/events.gateway';
+import { SisService } from '../sis/sis.service';
+import { AcaPyService } from '../services/acapy.service';
+import { WorkflowService } from '../workflow/workflow.service';
 
 describe('ConnectionService', () => {
   let service: ConnectionService;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
-      providers: [ConnectionService],
+      providers: [
+        ConnectionService,
+        { provide: ConfigService, useValue: { get: jest.fn() } },
+        { provide: EventsGateway, useValue: { server: { emit: jest.fn() } } },
+        { provide: SisService, useValue: { getStudentId: jest.fn() } },
+        { provide: AcaPyService, useValue: { createConnection: jest.fn() } },
+        { provide: WorkflowService, useValue: { updateWorkflow: jest.fn() } },
+      ],
     }).compile();
 
     service = module.get<ConnectionService>(ConnectionService);

src/credential/credential.controller.spec.ts

@@ -1,12 +1,30 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { CredentialController } from './credential.controller';
+import { CredentialService } from './credential.service';
+import { ConfigService } from '@nestjs/config';
+import { EventsGateway } from '../events/events.gateway';
+import { MetadataService } from '../metadata/metadata.service';
+import { ConnectionService } from '../connection/connection.service';
+import { AcaPyService } from '../services/acapy.service';
+import { WorkflowService } from '../workflow/workflow.service';
+import { SisService } from '../sis/sis.service';
 
 describe('CredentialController', () => {
   let controller: CredentialController;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
       controllers: [CredentialController],
+      providers: [
+        CredentialService,
+        { provide: ConfigService, useValue: { get: jest.fn() } },
+        { provide: EventsGateway, useValue: { server: { emit: jest.fn() } } },
+        { provide: MetadataService, useValue: { getCredentialTemplate: jest.fn() } },
+        { provide: ConnectionService, useValue: { getConnection: jest.fn() } },
+        { provide: AcaPyService, useValue: { issueCredential: jest.fn() } },
+        { provide: WorkflowService, useValue: { updateWorkflow: jest.fn() } },
+        { provide: SisService, useValue: { getStudentId: jest.fn() } },
+      ],
     }).compile();
 
     controller = module.get<CredentialController>(CredentialController);

src/credential/credential.service.spec.ts

@@ -1,12 +1,22 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { CredentialService } from './credential.service';
+import { MetadataService } from '../metadata/metadata.service';
+import { AcaPyService } from '../services/acapy.service';
+import { EventsGateway } from '../events/events.gateway';
+import { WorkflowService } from '../workflow/workflow.service';
 
 describe('CredentialService', () => {
   let service: CredentialService;
 
   beforeEach(async () => {
     const module: TestingModule = await Test.createTestingModule({
-      providers: [CredentialService],
+      providers: [
+        CredentialService,
+        { provide: MetadataService, useValue: { getCredentialTemplate: jest.fn() } },
+        { provide: AcaPyService, useValue: { issueCredential: jest.fn() } },
+        { provide: EventsGateway, useValue: { server: { emit: jest.fn() } } },
+        { provide: WorkflowService, useValue: { updateWorkflow: jest.fn() } },
+      ],
     }).compile();
 
     service = module.get<CredentialService>(CredentialService);

src/enrollment/enrollment.service.ts

@@ -46,6 +46,19 @@ export class EnrollmentService {
     return await this.enrollmentRepository.findOneBy({enrollment_id: id });
   }
 
+  async findByStudentNumber(studentNumber: string): Promise<Enrollment | null> {
+    return await this.enrollmentRepository.findOneBy({ student_number: studentNumber });
+  }
+
+  async findRecentByStudentNumbers(studentNumbers: string[], since?: Date): Promise<Enrollment[]> {
+    const qb = this.enrollmentRepository.createQueryBuilder('enrollment')
+      .where('enrollment.student_number IN (:...studentNumbers)', { studentNumbers });
+    if (since) {
+      qb.andWhere('enrollment.created_at >= :since', { since });
+    }
+    return await qb.getMany();
+  }
+
   async update(id: string, updateEnrollmentDto: UpdateEnrollmentDto) {
     return await this.enrollmentRepository.update(id, { enrollment_status: updateEnrollmentDto.enrollment_status });
   }

src/faster/__tests__/faster-export.service.spec.ts

@@ -0,0 +1,150 @@
+import { FasterExportService } from '../services/faster-export.service';
+import { Enrollment } from 'src/enrollment/entities/enrollment.entity';
+import { FasterError, FasterErrorCode } from '../interfaces/faster-request.interface';
+import * as fs from 'fs';
+
+jest.mock('fs');
+
+const mockedFs = fs as jest.Mocked<typeof fs>;
+
+function makeEnrollment(overrides: Partial<Enrollment> = {}): Enrollment {
+  const e = new Enrollment();
+  e.enrollment_id = 'conn-123';
+  e.student_number = '202500789';
+  e.student_full_name = 'Emily Carter';
+  e.student_birth_date = '2005-07-09';
+  e.student_address = '321 Student Housing, Laramie, WY 82071';
+  e.student_phone = '(307) 555-2233';
+  e.student_email = 'emily.carter@uwyo.edu';
+  e.student_ssn = '123456789';
+  e.student_sex = 'F';
+  e.school_name = 'University of Wyoming';
+  e.school_address = '1000 E University Ave';
+  e.graduation_date = '2029-05-15';
+  e.gpa = '3.65';
+  e.enrollment_status = 'started';
+  e.grade_level = '10';
+  e.terms = [
+    {
+      termYear: '2024',
+      termSeason: 'Fall',
+      courses: [
+        { courseCode: 'ENG 101', courseTitle: 'English I', creditEarned: '3', grade: 'A' },
+      ],
+    },
+  ] as any;
+  e.student_info = {} as any;
+  e.transcript = {} as any;
+  e.created_at = new Date();
+  Object.assign(e, overrides);
+  return e;
+}
+
+describe('FasterExportService', () => {
+  let service: FasterExportService;
+  let mockConfigService: { get: jest.Mock };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockConfigService = {
+      get: jest.fn((key: string, defaultVal?: string) => {
+        if (key === 'FASTER_OUTPUT_DIR') return '/tmp/faster-test';
+        return defaultVal;
+      }),
+    };
+    service = new FasterExportService(mockConfigService as any);
+    mockedFs.existsSync.mockReturnValue(true);
+    mockedFs.writeFileSync.mockImplementation(() => {});
+  });
+
+  describe('exportBatch()', () => {
+    it('writes a file containing records for all enrollments', () => {
+      const enrollments = [makeEnrollment(), makeEnrollment({ student_number: '202500456' })];
+
+      const result = service.exportBatch(enrollments, 'request.txt');
+
+      expect(mockedFs.writeFileSync).toHaveBeenCalledTimes(1);
+      const writtenContent = mockedFs.writeFileSync.mock.calls[0][1] as string;
+      // Each enrollment: S00 + S01 + 1 course (S03) + S05 = 4 lines, x2 = 8 lines
+      const lines = writtenContent.trim().split('\n');
+      expect(lines.length).toBe(8);
+      expect(result).toContain('FASTER_request_');
+      expect(result).toContain('.txt');
+    });
+
+    it('writes batch of 1 for single enrollment', () => {
+      const result = service.exportBatch([makeEnrollment()], 'single.txt');
+
+      expect(mockedFs.writeFileSync).toHaveBeenCalledTimes(1);
+      const writtenContent = mockedFs.writeFileSync.mock.calls[0][1] as string;
+      const lines = writtenContent.trim().split('\n');
+      expect(lines.length).toBe(4); // S00 + S01 + S03 + S05
+      expect(result).toContain('FASTER_single_');
+    });
+
+    it('creates output directory if it does not exist', () => {
+      mockedFs.existsSync.mockReturnValue(false);
+
+      service.exportBatch([makeEnrollment()], 'test.txt');
+
+      expect(mockedFs.mkdirSync).toHaveBeenCalledWith('/tmp/faster-test', { recursive: true });
+    });
+
+    it('throws when writeFileSync fails', () => {
+      mockedFs.writeFileSync.mockImplementation(() => {
+        throw new Error('disk full');
+      });
+
+      expect(() => service.exportBatch([makeEnrollment()], 'fail.txt')).toThrow('disk full');
+    });
+  });
+
+  describe('writeErrorFile()', () => {
+    it('writes error records in correct format', () => {
+      const errors: FasterError[] = [
+        {
+          code: FasterErrorCode.CONNECTION_NOT_FOUND,
+          message: 'No active connection',
+          studentNumber: '202500789',
+          timestamp: '2026-03-02T12:00:00Z',
+        },
+        {
+          code: FasterErrorCode.INVALID_RECORD_TYPE,
+          message: 'Bad record type',
+          studentNumber: '',
+          timestamp: '2026-03-02T12:00:01Z',
+        },
+      ];
+
+      const result = service.writeErrorFile(errors, 'request.txt');
+
+      expect(mockedFs.writeFileSync).toHaveBeenCalledTimes(1);
+      const writtenContent = mockedFs.writeFileSync.mock.calls[0][1] as string;
+      const lines = writtenContent.trim().split('\n');
+      expect(lines.length).toBe(2);
+      expect(lines[0].substring(0, 3)).toBe('ERR');
+      expect(result).toContain('FASTER_ERR_request_');
+    });
+
+    it('returns null when there are no errors', () => {
+      const result = service.writeErrorFile([], 'no-errors.txt');
+
+      expect(result).toBeNull();
+      expect(mockedFs.writeFileSync).not.toHaveBeenCalled();
+    });
+
+    it('uses correct naming convention', () => {
+      const errors: FasterError[] = [{
+        code: FasterErrorCode.INVALID_REQUEST,
+        message: 'Empty file',
+        studentNumber: '',
+        timestamp: '2026-03-02T12:00:00Z',
+      }];
+
+      const result = service.writeErrorFile(errors, 'input_batch.txt');
+
+      expect(result).toContain('FASTER_ERR_input_batch_');
+      expect(result).toEndWith('.txt');
+    });
+  });
+});