Skip to main content

​
Overview

The @timeback/powerpath package provides a client for the PowerPath API, enabling:
  • Assessments: Create tests, attempts, and submit responses
  • Placement Tests: Determine appropriate grade level
  • Screening: Session management and test assignment
  • Lesson Plans: Course progress and lesson plan operations
  • Test Assignments: CRUD operations for test assignments

​
Installation

npm install @timeback/powerpath

​
Quick Start

import { PowerPathClient } from '@timeback/powerpath'

const client = new PowerPathClient({
	env: 'staging',
	auth: {
		clientId: process.env.POWERPATH_CLIENT_ID!,
		clientSecret: process.env.POWERPATH_CLIENT_SECRET!,
	},
})

const level = await client.placement.getCurrentLevel({ student: 'student-123', subject: 'Math' })

​
Client Structure

const client = new PowerPathClient(options)

client.assessments // Tests, attempts, and responses
client.lessonPlans // Course lesson plans and progress
client.placement // Placement testing
client.screening // MAP test sessions
client.syllabus // Course structure
client.testAssignments // Test assignment CRUD

​
Typed Responses

All methods return typed responses: 
import type { ExternalTestCreateResponse, GetNextPlacementTestResponse } from '@timeback/powerpath'

const test: ExternalTestCreateResponse = await client.assessments.createExternalTestOut({
	courseId: 'course-123',
	lessonType: 'test-out',
	toolProvider: 'mastery-track',
	grades: [3],
	xp: 10,
	resourceMetadata: { subject: 'Math' },
})
console.log(test.lessonId, test.resourceId)

const next: GetNextPlacementTestResponse = await client.placement.getNextPlacementTest({
	student: 'student-123',
	subject: 'Math',
})
console.log(`${next.availableTests} tests available, next: ${next.lesson}`)

​
Assessments

Create and manage assessments, attempts, and responses.

​
Create Tests

client.assessments.createInternalTest({ studentId, subject, gradeLevel })
client.assessments.createExternalTestOut({
	courseId,
	lessonType,
	toolProvider,
	grades,
	xp,
	resourceMetadata,
})
client.assessments.createExternalPlacementTest({ studentId, subject })

​
Manage Attempts

client.assessments.createNewAttempt({ studentId, testId })
client.assessments.getAttempts({ studentId, testId })
client.assessments.resetAttempt({ attemptId })

​
Questions and Responses

client.assessments.getNextQuestion({ attemptId })
client.assessments.updateStudentQuestionResponse({ attemptId, questionId, response })
client.assessments.finalStudentAssessmentResponse({ attemptId })
client.assessments.getAssessmentProgress({ studentId, testId })

​
Placement

Manage placement testing and determine appropriate grade levels. All query methods take { student, subject }: 
client.placement.getCurrentLevel({ student, subject })
client.placement.getAllPlacementTests({ student, subject })
client.placement.getNextPlacementTest({ student, subject })
client.placement.getSubjectProgress({ student, subject })
client.placement.resetUserPlacement({ student, subject })
MethodReturnsDescription
getCurrentLevel()PlacementLevelCurrent placement grade level
getAllPlacementTests()PlacementTest[]All placement tests for student
getNextPlacementTest()PlacementTestNext recommended test
getSubjectProgress()SubjectProgressProgress in subject
resetUserPlacement()voidReset placement to start over

​
Screening

Manage screening sessions and results. 
client.screening.getResults(userId)
client.screening.getSession(userId)
client.screening.resetSession({ userId })
client.screening.assignTest({ userId, subject })

​
Lesson Plans

Manage lesson plans and course progress. 
client.lessonPlans.get(courseId, userId)
client.lessonPlans.create({ courseId, userId, classId? })
client.lessonPlans.getCourseProgress(courseId, studentId)
client.lessonPlans.getTree(lessonPlanId)
client.lessonPlans.getStructure(lessonPlanId)
client.lessonPlans.listOperations(lessonPlanId)
client.lessonPlans.createOperations(lessonPlanId, { operation: [{ type: 'set-skipped', payload: { target: { type: 'resource', id: itemId }, value: true } }] })
client.lessonPlans.sync(lessonPlanId)
client.lessonPlans.recreate(lessonPlanId)
client.lessonPlans.deleteAll(courseId)

​
Syllabus

client.syllabus.get(courseSourcedId)

​
Test Assignments

CRUD operations for test assignments. 
client.testAssignments.list({ studentId })
client.testAssignments.create({ studentId, testId, dueDate })
client.testAssignments.get(assignmentId)
client.testAssignments.update(assignmentId, { status })
client.testAssignments.delete(assignmentId)
client.testAssignments.bulk({ assignments: [{ studentId, testId }] })

​
Error Handling

import { NotFoundError, PowerPathError } from '@timeback/powerpath/errors'

try {
	await client.testAssignments.get('missing-id')
} catch (error) {
	if (error instanceof NotFoundError) {
		console.log('Assignment not found')
	} else if (error instanceof PowerPathError) {
		console.log(error.statusCode)
		console.log(error.message)
	}
}

​
SDK Integration

When using the full SDK: 
import { createTimeback } from '@timeback/sdk'

const timeback = await createTimeback({
	/* ... */
})

const level = await timeback.api.powerpath.placement.getCurrentLevel({
	student: 'student-123',
	subject: 'Math',
})

​
Next Steps

QTI

Standard assessments

Caliper

Track learning events

Types

PowerPath type definitions