PowerPath

npm install @timeback/powerpath

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' })

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

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}`)

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

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

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

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 })

client.screening.getResults(userId)
client.screening.getSession(userId)
client.screening.resetSession({ userId })
client.screening.assignTest({ userId, subject })

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)

client.syllabus.get(courseSourcedId)

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 }] })

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)
	}
}

import { createTimeback } from '@timeback/sdk'

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

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