@programisto/edrm-exams 0.2.13 → 0.3.0

package/dist/modules/edrm-exams/listeners/correct.listener.js

@@ -48,16 +48,49 @@ async function correctTest(options) {
             }, true);
             console.log('Correction result:', { scoreResponse });
             const parsedResult = JSON.parse(scoreResponse);
-            finalscore += parsedResult.score;
-            dbResponse.score = parsedResult.score;
+            // Valider le score retourné par l'IA
+            let validScore = 0;
+            if (parsedResult.score !== undefined && parsedResult.score !== null) {
+                const score = parseFloat(parsedResult.score.toString());
+                if (!isNaN(score) && isFinite(score) && score >= 0) {
+                    validScore = score;
+                }
+                else {
+                    console.warn('Invalid score returned by AI:', parsedResult.score);
+                }
+            }
+            finalscore += validScore;
+            dbResponse.score = validScore;
             dbResponse.comment = parsedResult.comment || '';
         }
+        // S'assurer que finalscore est un nombre valide
+        if (isNaN(finalscore) || !isFinite(finalscore)) {
+            console.warn('Invalid finalscore calculated, setting to 0:', finalscore);
+            finalscore = 0;
+        }
+        // S'assurer que maxScore est un nombre valide
+        if (isNaN(maxScore) || !isFinite(maxScore)) {
+            console.warn('Invalid maxScore calculated, setting to 0:', maxScore);
+            maxScore = 0;
+        }
         // Mettre à jour le score final et l'état
         result.score = finalscore;
         result.state = TestState.Finish;
         // Forcer la sauvegarde des sous-documents responses
         result.markModified('responses');
-        const scorePercentage = Math.ceil((finalscore / maxScore) * 100);
+        // Calculer le pourcentage de score en évitant la division par zéro
+        let scorePercentage = 0;
+        if (maxScore > 0) {
+            scorePercentage = Math.ceil((finalscore / maxScore) * 100);
+        }
+        else if (finalscore > 0) {
+            // Si maxScore est 0 mais qu'il y a un score, on met 100%
+            scorePercentage = 100;
+        }
+        // S'assurer que le score est un nombre valide
+        if (isNaN(scorePercentage) || !isFinite(scorePercentage)) {
+            scorePercentage = 0;
+        }
         // Sauvegarder les modifications avec findByIdAndUpdate pour éviter les conflits de version
         await TestResult.findByIdAndUpdate(result._id, {
             $set: {

package/dist/modules/edrm-exams/models/test-job.model.d.ts

@@ -0,0 +1,7 @@
+import { EnduranceSchema } from '@programisto/endurance-core';
+declare class TestJob extends EnduranceSchema {
+    name: string;
+    static getModel(): import("@typegoose/typegoose").ReturnModelType<typeof TestJob, import("@typegoose/typegoose/lib/types").BeAnObject>;
+}
+declare const TestJobModel: import("@typegoose/typegoose").ReturnModelType<typeof TestJob, import("@typegoose/typegoose/lib/types").BeAnObject>;
+export default TestJobModel;

package/dist/modules/edrm-exams/models/test-job.model.js

@@ -0,0 +1,29 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { EnduranceSchema, EnduranceModelType } from '@programisto/endurance-core';
+let TestJob = class TestJob extends EnduranceSchema {
+    name;
+    static getModel() {
+        return TestJobModel;
+    }
+};
+__decorate([
+    EnduranceModelType.prop({ required: true }),
+    __metadata("design:type", String)
+], TestJob.prototype, "name", void 0);
+TestJob = __decorate([
+    EnduranceModelType.modelOptions({
+        options: {
+            allowMixed: EnduranceModelType.Severity.ALLOW
+        }
+    })
+], TestJob);
+const TestJobModel = EnduranceModelType.getModelForClass(TestJob);
+export default TestJobModel;

package/dist/modules/edrm-exams/models/test.model.d.ts

@@ -2,19 +2,13 @@ import { EnduranceSchema } from '@programisto/endurance-core';
 import Company from './company.model.js';
 import TestQuestion from './test-question.model.js';
 import TestCategory from './test-category.models.js';
+import TestJob from './test-job.model.js';
 import User from './user.model.js';
 declare enum TestState {
     Draft = "draft",
     Published = "published",
     Archived = "archived"
 }
-declare enum JobType {
-    FrontEnd = "front-end",
-    BackEnd = "back-end",
-    Fullstack = "fullstack",
-    DevOps = "devops",
-    Data = "data"
-}
 declare enum SeniorityLevel {
     Student = "student",
     Junior = "junior",
@@ -44,9 +38,10 @@ declare class Test extends EnduranceSchema {
     duration?: number;
     passingScore?: number;
     categories?: TestCategoryWithExpertise[];
-    targetJob: JobType;
+    targetJob: typeof TestJob;
     seniorityLevel: SeniorityLevel;
     static getModel(): import("@typegoose/typegoose").ReturnModelType<typeof Test, import("@typegoose/typegoose/lib/types.js").BeAnObject>;
+    migrateTargetJob(): Promise<void>;
 }
 declare const TestModel: import("@typegoose/typegoose").ReturnModelType<typeof Test, import("@typegoose/typegoose/lib/types.js").BeAnObject>;
 export default TestModel;

package/dist/modules/edrm-exams/models/test.model.js

@@ -9,6 +9,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import { EnduranceSchema, EnduranceModelType } from '@programisto/endurance-core';
 import Company from './company.model.js';
+import TestJob from './test-job.model.js';
 import User from './user.model.js';
 var TestState;
 (function (TestState) {
@@ -19,19 +20,6 @@ var TestState;
     // eslint-disable-next-line no-unused-vars
     TestState["Archived"] = "archived";
 })(TestState || (TestState = {}));
-var JobType;
-(function (JobType) {
-    // eslint-disable-next-line no-unused-vars
-    JobType["FrontEnd"] = "front-end";
-    // eslint-disable-next-line no-unused-vars
-    JobType["BackEnd"] = "back-end";
-    // eslint-disable-next-line no-unused-vars
-    JobType["Fullstack"] = "fullstack";
-    // eslint-disable-next-line no-unused-vars
-    JobType["DevOps"] = "devops";
-    // eslint-disable-next-line no-unused-vars
-    JobType["Data"] = "data";
-})(JobType || (JobType = {}));
 var SeniorityLevel;
 (function (SeniorityLevel) {
     // eslint-disable-next-line no-unused-vars
@@ -67,6 +55,28 @@ let Test = class Test extends EnduranceSchema {
     static getModel() {
         return TestModel;
     }
+    // Méthode pour migrer automatiquement les anciennes données
+    async migrateTargetJob() {
+        const testData = this;
+        // Si targetJob est une string (ancien format), on la migre
+        if (typeof testData.targetJob === 'string') {
+            try {
+                // Chercher si le job existe déjà
+                let jobType = await TestJob.findOne({ name: testData.targetJob });
+                // Si pas trouvé, on le crée
+                if (!jobType) {
+                    jobType = new TestJob({ name: testData.targetJob });
+                    await jobType.save();
+                }
+                // Mettre à jour la référence
+                this.targetJob = jobType._id;
+                await this.save();
+            }
+            catch (error) {
+                console.error('Erreur lors de la migration du targetJob:', error);
+            }
+        }
+    }
 };
 __decorate([
     EnduranceModelType.prop({ required: true }),
@@ -105,8 +115,8 @@ __decorate([
     __metadata("design:type", Array)
 ], Test.prototype, "categories", void 0);
 __decorate([
-    EnduranceModelType.prop({ required: true, enum: JobType }),
-    __metadata("design:type", String)
+    EnduranceModelType.prop({ ref: () => TestJob, required: true }),
+    __metadata("design:type", Object)
 ], Test.prototype, "targetJob", void 0);
 __decorate([
     EnduranceModelType.prop({ required: true, enum: SeniorityLevel }),

package/dist/modules/edrm-exams/routes/exams-candidate.router.js

@@ -3,7 +3,26 @@ import CandidateModel from '../models/candidate.model.js';
 import ContactModel from '../models/contact.model.js';
 import TestResult from '../models/test-result.model.js';
 import Test from '../models/test.model.js';
+import TestJob from '../models/test-job.model.js';
 import jwt from 'jsonwebtoken';
+// Fonction utilitaire pour récupérer le nom du job
+async function getJobName(targetJob) {
+    // Si c'est déjà une string (ancien format), on la retourne directement
+    if (typeof targetJob === 'string') {
+        return targetJob;
+    }
+    // Si c'est un ObjectId, on récupère le job
+    if (targetJob && typeof targetJob === 'object' && targetJob._id) {
+        const job = await TestJob.findById(targetJob._id);
+        return job ? job.name : 'Job inconnu';
+    }
+    // Si c'est juste un ObjectId
+    if (targetJob && typeof targetJob === 'object' && targetJob.toString) {
+        const job = await TestJob.findById(targetJob);
+        return job ? job.name : 'Job inconnu';
+    }
+    return 'Job inconnu';
+}
 class CandidateRouter extends EnduranceRouter {
     constructor() {
         super(EnduranceAuthMiddleware.getInstance());
@@ -383,7 +402,7 @@ class CandidateRouter extends EnduranceRouter {
                 const categoriesDocs = await TestCategory.find({ _id: { $in: allCategoryIds } }).lean();
                 const categoriesMap = new Map(categoriesDocs.map(cat => [cat._id.toString(), cat.name]));
                 // Combiner les résultats avec les informations des tests et des catégories
-                const resultsWithTests = results.map(result => {
+                const resultsWithTests = await Promise.all(results.map(async (result) => {
                     const test = testsMap.get(result.testId.toString());
                     let categoriesWithNames = [];
                     if (test && test.categories) {
@@ -398,13 +417,13 @@ class CandidateRouter extends EnduranceRouter {
                             ? {
                                 title: test.title,
                                 description: test.description,
-                                targetJob: test.targetJob,
+                                targetJob: await getJobName(test.targetJob),
                                 seniorityLevel: test.seniorityLevel,
                                 categories: categoriesWithNames
                             }
                             : null
                     };
-                });
+                }));
                 const totalPages = Math.ceil(total / limit);
                 return res.json({
                     data: resultsWithTests,

package/dist/modules/edrm-exams/routes/exams.router.js

@@ -3,9 +3,34 @@ import Test from '../models/test.model.js';
 import TestQuestion from '../models/test-question.model.js';
 import TestResult from '../models/test-result.model.js';
 import TestCategory from '../models/test-category.models.js';
+import TestJob from '../models/test-job.model.js';
 import Candidate from '../models/candidate.model.js';
 import ContactModel from '../models/contact.model.js';
 import { generateLiveMessage, generateLiveMessageAssistant } from '../lib/openai.js';
+// Fonction utilitaire pour récupérer le nom du job
+async function getJobName(targetJob) {
+    // Si c'est déjà une string (ancien format), on la retourne directement
+    if (typeof targetJob === 'string') {
+        return targetJob;
+    }
+    // Si c'est un ObjectId, on récupère le job
+    if (targetJob && typeof targetJob === 'object' && targetJob._id) {
+        const job = await TestJob.findById(targetJob._id);
+        return job ? job.name : 'Job inconnu';
+    }
+    // Si c'est juste un ObjectId
+    if (targetJob && typeof targetJob === 'object' && targetJob.toString) {
+        const job = await TestJob.findById(targetJob);
+        return job ? job.name : 'Job inconnu';
+    }
+    return 'Job inconnu';
+}
+// Fonction pour migrer automatiquement un test si nécessaire
+async function migrateTestIfNeeded(test) {
+    if (typeof test.targetJob === 'string') {
+        await test.migrateTargetJob();
+    }
+}
 class ExamsRouter extends EnduranceRouter {
     constructor() {
         super(EnduranceAuthMiddleware.getInstance());
@@ -20,8 +45,9 @@ class ExamsRouter extends EnduranceRouter {
             // Récupérer les questions existantes pour éviter les doublons
             const otherQuestionsIds = test.questions.map(question => question.questionId);
             const otherQuestions = await TestQuestion.find({ _id: { $in: otherQuestionsIds } });
+            const jobName = await getJobName(test.targetJob);
             const questionParams = {
-                job: test.targetJob,
+                job: jobName,
                 seniority: test.seniorityLevel,
                 category: categoryDoc.name,
                 questionType: ['MCQ', 'free question', 'exercice'][Math.floor(Math.random() * 3)],
@@ -98,6 +124,78 @@ class ExamsRouter extends EnduranceRouter {
                 res.status(500).json({ message: 'Internal server error' });
             }
         });
+        // Créer un job type
+        this.post('/jobs', authenticatedOptions, async (req, res) => {
+            const { name } = req.body;
+            if (!name) {
+                return res.status(400).json({ message: 'Error, name is required' });
+            }
+            try {
+                const newJob = new TestJob({ name });
+                await newJob.save();
+                res.status(201).json({ message: 'job created with success', job: newJob });
+            }
+            catch (err) {
+                console.error('error when creating job : ', err);
+                res.status(500).json({ message: 'Internal server error' });
+            }
+        });
+        // Lister tous les jobs
+        this.get('/jobs', authenticatedOptions, async (req, res) => {
+            try {
+                const jobs = await TestJob.find();
+                res.status(200).json({ array: jobs });
+            }
+            catch (err) {
+                console.error('error when getting jobs : ', err);
+                res.status(500).json({ message: 'Internal server error' });
+            }
+        });
+        // Obtenir un job par son ID
+        this.get('/jobs/:id', authenticatedOptions, async (req, res) => {
+            const { id } = req.params;
+            try {
+                const job = await TestJob.findById(id);
+                if (!job) {
+                    return res.status(404).json({ message: 'no job founded with this id' });
+                }
+                res.status(200).json({ array: job });
+            }
+            catch (err) {
+                console.error('error when getting job : ', err);
+                res.status(500).json({ message: 'Internal server error' });
+            }
+        });
+        // Migrer tous les tests avec l'ancien format targetJob
+        this.post('/migrate-targetjobs', authenticatedOptions, async (req, res) => {
+            try {
+                const tests = await Test.find();
+                let migratedCount = 0;
+                let errorCount = 0;
+                for (const test of tests) {
+                    try {
+                        // Vérifier si le test a besoin de migration
+                        if (typeof test.targetJob === 'string') {
+                            await test.migrateTargetJob();
+                            migratedCount++;
+                        }
+                    }
+                    catch (error) {
+                        console.error(`Erreur lors de la migration du test ${test._id}:`, error);
+                        errorCount++;
+                    }
+                }
+                res.status(200).json({
+                    message: `Migration terminée. ${migratedCount} tests migrés, ${errorCount} erreurs.`,
+                    migratedCount,
+                    errorCount
+                });
+            }
+            catch (err) {
+                console.error('Erreur lors de la migration :', err);
+                res.status(500).json({ message: 'Erreur interne du serveur' });
+            }
+        });
         // Créer un test
         this.post('/test', authenticatedOptions, async (req, res) => {
             const { title, description, targetJob, seniorityLevel, categories, state = 'draft' } = req.body;
@@ -108,6 +206,19 @@ class ExamsRouter extends EnduranceRouter {
             try {
                 const companyId = user?.companyId;
                 const userId = user?._id;
+                // Traiter le targetJob - si c'est une string, on cherche ou crée le TestJob
+                let targetJobId;
+                if (typeof targetJob === 'string') {
+                    let existingJob = await TestJob.findOne({ name: targetJob });
+                    if (!existingJob) {
+                        existingJob = new TestJob({ name: targetJob });
+                        await existingJob.save();
+                    }
+                    targetJobId = existingJob._id;
+                }
+                else {
+                    targetJobId = targetJob;
+                }
                 const processedCategories = await Promise.all(categories?.map(async (category) => {
                     let existingCategory = await TestCategory.findOne({ name: category.name });
                     if (!existingCategory) {
@@ -123,7 +234,7 @@ class ExamsRouter extends EnduranceRouter {
                     userId,
                     title,
                     description,
-                    targetJob,
+                    targetJob: targetJobId,
                     seniorityLevel,
                     state,
                     categories: processedCategories
@@ -149,8 +260,20 @@ class ExamsRouter extends EnduranceRouter {
                     test.title = title;
                 if (description)
                     test.description = description;
-                if (targetJob)
-                    test.targetJob = targetJob;
+                if (targetJob) {
+                    // Traiter le targetJob - si c'est une string, on cherche ou crée le TestJob
+                    if (typeof targetJob === 'string') {
+                        let existingJob = await TestJob.findOne({ name: targetJob });
+                        if (!existingJob) {
+                            existingJob = new TestJob({ name: targetJob });
+                            await existingJob.save();
+                        }
+                        test.targetJob = existingJob._id;
+                    }
+                    else {
+                        test.targetJob = targetJob;
+                    }
+                }
                 if (seniorityLevel)
                     test.seniorityLevel = seniorityLevel;
                 if (state)
@@ -204,6 +327,8 @@ class ExamsRouter extends EnduranceRouter {
                 if (!test) {
                     return res.status(404).json({ message: 'no test founded with this id' });
                 }
+                // Migration automatique si nécessaire
+                await migrateTestIfNeeded(test);
                 const questions = [];
                 for (const questionRef of test.questions) {
                     console.log(questionRef);
@@ -213,7 +338,10 @@ class ExamsRouter extends EnduranceRouter {
                         questions.push(question);
                     }
                 }
-                res.status(200).json({ test, questions });
+                // Récupérer le nom du job pour l'affichage
+                const testObj = test.toObject();
+                testObj.targetJobName = await getJobName(testObj.targetJob);
+                res.status(200).json({ test: testObj, questions });
             }
             catch (err) {
                 console.error('error when geting test : ', err);
@@ -236,7 +364,15 @@ class ExamsRouter extends EnduranceRouter {
                 const query = {};
                 // Filtres
                 if (targetJob !== 'all') {
-                    query.targetJob = targetJob;
+                    // Si on filtre par targetJob, on cherche d'abord le TestJob correspondant
+                    const jobType = await TestJob.findOne({ name: targetJob });
+                    if (jobType) {
+                        query.targetJob = jobType._id;
+                    }
+                    else {
+                        // Si le job n'existe pas, on ne retourne aucun résultat
+                        query.targetJob = null;
+                    }
                 }
                 if (seniorityLevel !== 'all') {
                     query.seniorityLevel = seniorityLevel;
@@ -246,10 +382,13 @@ class ExamsRouter extends EnduranceRouter {
                 }
                 // Recherche sur testName et targetJob
                 if (search) {
+                    // Pour la recherche sur targetJob, on cherche d'abord les jobs qui correspondent
+                    const matchingJobs = await TestJob.find({ name: { $regex: search, $options: 'i' } });
+                    const jobIds = matchingJobs.map(job => job._id);
                     query.$or = [
                         { title: { $regex: search, $options: 'i' } },
                         { description: { $regex: search, $options: 'i' } },
-                        { targetJob: { $regex: search, $options: 'i' } },
+                        { targetJob: { $in: jobIds } },
                         { seniorityLevel: { $regex: search, $options: 'i' } }
                     ];
                 }
@@ -267,9 +406,13 @@ class ExamsRouter extends EnduranceRouter {
                         .exec(),
                     Test.countDocuments(query)
                 ]);
-                // Récupérer les noms des catégories pour chaque test
+                // Récupérer les noms des catégories et des jobs pour chaque test
                 const testsWithCategories = await Promise.all(tests.map(async (test) => {
+                    // Migration automatique si nécessaire
+                    await migrateTestIfNeeded(test);
                     const testObj = test.toObject();
+                    // Récupérer le nom du job
+                    testObj.targetJobName = await getJobName(testObj.targetJob);
                     if (testObj.categories && testObj.categories.length > 0) {
                         const categoriesWithNames = await Promise.all(testObj.categories.map(async (category) => {
                             const categoryDoc = await TestCategory.findById(category.categoryId);
@@ -478,8 +621,9 @@ class ExamsRouter extends EnduranceRouter {
                 }
                 const otherQuestionsIds = test.questions.map(question => question.questionId);
                 const otherQuestions = await TestQuestion.find({ _id: { $in: otherQuestionsIds } });
+                const jobName = await getJobName(test.targetJob);
                 const generatedQuestion = await generateLiveMessageAssistant(process.env.OPENAI_ASSISTANT_ID_CREATE_QUESTION || '', 'createQuestion', {
-                    job: test.targetJob,
+                    job: jobName,
                     seniority: test.seniorityLevel,
                     questionType,
                     category,

package/dist/modules/edrm-exams/routes/result.router.js

@@ -2,6 +2,25 @@ import { EnduranceRouter, EnduranceAuthMiddleware, enduranceEmitter, enduranceEv
 import CandidateModel from '../models/candidate.model.js';
 import TestResult, { TestState } from '../models/test-result.model.js';
 import Test from '../models/test.model.js';
+import TestJob from '../models/test-job.model.js';
+// Fonction utilitaire pour récupérer le nom du job
+async function getJobName(targetJob) {
+    // Si c'est déjà une string (ancien format), on la retourne directement
+    if (typeof targetJob === 'string') {
+        return targetJob;
+    }
+    // Si c'est un ObjectId, on récupère le job
+    if (targetJob && typeof targetJob === 'object' && targetJob._id) {
+        const job = await TestJob.findById(targetJob._id);
+        return job ? job.name : 'Job inconnu';
+    }
+    // Si c'est juste un ObjectId
+    if (targetJob && typeof targetJob === 'object' && targetJob.toString) {
+        const job = await TestJob.findById(targetJob);
+        return job ? job.name : 'Job inconnu';
+    }
+    return 'Job inconnu';
+}
 class ResultRouter extends EnduranceRouter {
     constructor() {
         super(EnduranceAuthMiddleware.getInstance());
@@ -81,7 +100,7 @@ class ResultRouter extends EnduranceRouter {
                             ? {
                                 title: test.title,
                                 description: test.description,
-                                targetJob: test.targetJob,
+                                targetJob: await getJobName(test.targetJob),
                                 seniorityLevel: test.seniorityLevel,
                                 categories: categoriesWithNames
                             }
@@ -129,11 +148,14 @@ class ResultRouter extends EnduranceRouter {
                 const questions = await TestQuestion.find({ _id: { $in: (test.questions || []).map((q) => q.questionId) } }).lean();
                 const maxTime = questions.reduce((sum, q) => sum + (q.time || 0), 0);
                 const numberOfQuestions = questions.length;
+                // Récupérer le nom du job
+                const targetJobName = await getJobName(test.targetJob);
                 // Construire la réponse sans les questions
                 const { questions: _questions, // on retire les questions
                 ...testWithoutQuestions } = test;
                 return res.json({
                     ...testWithoutQuestions,
+                    targetJobName,
                     categories: categoriesWithNames,
                     maxTime,
                     numberOfQuestions
@@ -312,18 +334,25 @@ class ResultRouter extends EnduranceRouter {
                     score: 0,
                     comment: ''
                 });
+                // Marquer explicitement le champ responses comme modifié
+                result.markModified('responses');
+                console.log('Avant sauvegarde - Responses:', result.responses);
                 // Vérifier si c'était la dernière question
                 const totalQuestions = test.questions.length;
                 const answeredQuestions = result.responses.length;
                 if (answeredQuestions === totalQuestions) {
                     result.state = TestState.Finish;
-                    // Déclencher la correction automatique
-                    await enduranceEmitter.emit(enduranceEventTypes.CORRECT_TEST, result);
                 }
                 else {
                     result.state = TestState.InProgress;
                 }
-                await result.save();
+                // Sauvegarder d'abord la réponse
+                const savedResult = await result.save();
+                console.log('Après sauvegarde - Responses:', savedResult.responses);
+                // Déclencher la correction automatique seulement après la sauvegarde
+                if (answeredQuestions === totalQuestions) {
+                    await enduranceEmitter.emit(enduranceEventTypes.CORRECT_TEST, savedResult);
+                }
                 return res.status(200).json({
                     message: 'Réponse enregistrée',
                     response,

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@programisto/edrm-exams",
-  "version": "0.2.13",
+  "version": "0.3.0",
   "publishConfig": {
     "access": "public"
   },