Comment implémenter un LRS xAPI avec Node.js en 2026

mkdir lrs-xapi && cd lrs-xapi
npm init -y
npm i express @types/express cors helmet prisma @prisma/client
npm i -D typescript ts-node nodemon @types/node @types/cors @types/helmet tsconfig-paths
npx tsc --init --target es2022 --module commonjs --lib es2022,dom --outDir dist --rootDir src --strict --esModuleInterop --skipLibCheck
echo '{"compilerOptions": {"baseUrl": "./", "paths": {"@/*": ["src/*"]}}}' >> tsconfig.json
mkdir src
npx prisma init --datasource-provider sqlite

generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "sqlite"
  url      = "file:./dev.db"
}

model Statement {
  id        String   @id @default(cuid())
  statement Json     // JSON-LD complet xAPI
  timestamp DateTime @default(now())
  actorHash String   @index // Hash de l'actor pour queries
  verbId    String   @index // ID du verbe
  objectId  String   @index // ID de l'objet

  @@index([timestamp(sort: Desc)])
  @@map("statements")
}

import { Statement, Agent, Activity, Verb, Result } from './xapi-interfaces';

export interface XAPIStatement extends Statement {
  timestamp?: string;
  stored?: string;
  id?: string;
  authority?: Agent;
  version: '1.0.3';
}

export interface StatementRequest {
  statements: XAPIStatement[];
}

export type VoidReturn = { void: boolean };

export const validateStatement = (stmt: any): stmt is XAPIStatement => {
  return stmt.actor && stmt.verb && stmt.object && stmt.version === '1.0.3';
};

import express from 'express';
import cors from 'cors';
import helmet from 'helmet';
import { PrismaClient } from '@prisma/client';
import { validateStatement, XAPIStatement, StatementRequest } from './types/xapi';
import crypto from 'crypto';

const app = express();
const prisma = new PrismaClient();

app.use(helmet());
app.use(cors({ origin: '*' }));
app.use(express.json({ limit: '10mb' }));

const computeHash = (str: string) => crypto.createHash('sha256').update(str).digest('hex');

// Endpoint /about
app.get('/about', (req, res) => {
  res.json({
    version: ['1.0.3'],
    extensions: false,
    statementFormat: true
  });
});

// POST /statements
app.post('/statements', async (req: express.Request, res: express.Response<{ id: string[] } | { void: boolean }>) => {
  const { statements }: StatementRequest = req.body;
  if (!Array.isArray(statements)) return res.status(400).json({ error: 'Array of statements required' });

  const ids: string[] = [];
  for (const stmt of statements) {
    if (!validateStatement(stmt)) return res.status(400).json({ error: 'Invalid statement' });

    const actorStr = JSON.stringify(stmt.actor);
    const actorHash = computeHash(actorStr);
    const verbId = stmt.verb.id;
    const objectId = typeof stmt.object === 'object' ? stmt.object.id : JSON.stringify(stmt.object);

    const stored = await prisma.statement.create({
      data: {
        statement: stmt as any,
        actorHash,
        verbId,
        objectId
      }
    });
    ids.push(stored.id);
  }
  res.status(200).json({ id: ids });
});

const PORT = 3000;
app.listen(PORT, () => console.log(`LRS xAPI sur http://localhost:${PORT}`));

// Ajoutez à server.ts après POST /statements

// GET /statements
app.get('/statements', async (req: express.Request, res) => {
  const { limit = 10, since, until, agent, verb, activity } = req.query;
  const take = parseInt(limit as string) || 10;
  const skip = parseInt((req.query.ascending ? 0 : take * parseInt((req.query.page || '1') as string)) as string);

  const where: any = {};
  if (agent) where.actorHash = computeHash(JSON.stringify({ mbox: agent }));
  if (verb) where.verbId = verb as string;
  if (activity) where.objectId = activity as string;
  if (since) where.timestamp = { gte: new Date(since as string) };
  if (until) where.timestamp = { ...where.timestamp, lte: new Date(until as string) };

  const [statements, more] = await Promise.all([
    prisma.statement.findMany({
      where,
      take,
      skip,
      orderBy: { timestamp: 'desc' }
    }),
    prisma.statement.count({ where }) > skip + take
  ]);

  res.json({
    statements: statements.map(s => s.statement),
    more: more
  });
});

<!DOCTYPE html>
<html>
<head><title>Test xAPI</title></head>
<body>
  <button onclick="sendStatement()">Envoyer Statement</button>
  <pre id="log"></pre>
  <script>
    async function sendStatement() {
      const stmt = {
        actor: { mbox: 'mailto:learner@example.com' },
        verb: { id: 'http://adlnet.gov/expapi/verbs/completed', display: { 'en-US': 'completed' } },
        object: { id: 'https://example.com/quiz1', definition: { name: { 'en-US': 'Quiz Math' } } },
        result: { score: { scaled: 0.9 } },
        timestamp: new Date().toISOString(),
        version: '1.0.3'
      };

      const res = await fetch('http://localhost:3000/statements', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ statements: [stmt] })
      });
      document.getElementById('log')!.textContent = JSON.stringify(await res.json(), null, 2);
    }
  </script>
</body>
</html>

{
  "scripts": {
    "dev": "nodemon --exec ts-node src/server.ts",
    "build": "tsc",
    "start": "node dist/server.js",
    "db:migrate": "prisma migrate dev",
    "db:push": "prisma db push",
    "db:studio": "prisma studio"
  }
}