@eeplatform/basic-edu 1.10.2 → 1.10.4

package/dist/index.js

@@ -1365,9 +1365,11 @@ __export(src_exports, {
   modelSectionPreset: () => modelSectionPreset,
   modelSectionStudent: () => modelSectionStudent,
   modelSectionSubject: () => modelSectionSubject,
+  modelStrand: () => modelStrand,
   modelSubject: () => modelSubject,
   modelTeachingLoad: () => modelTeachingLoad,
   modelTeachingLoadSlot: () => modelTeachingLoadSlot,
+  modelTrack: () => modelTrack,
   schemaAsset: () => schemaAsset,
   schemaAssetUpdateOption: () => schemaAssetUpdateOption,
   schemaBasicEduCount: () => schemaBasicEduCount,
@@ -1397,10 +1399,12 @@ __export(src_exports, {
   schemaSectionSubject: () => schemaSectionSubject,
   schemaSectionSubjectSetup: () => schemaSectionSubjectSetup,
   schemaStockCard: () => schemaStockCard,
+  schemaStrand: () => schemaStrand,
   schemaSubject: () => schemaSubject,
   schemaSubjectAdd: () => schemaSubjectAdd,
   schemaTeachingLoad: () => schemaTeachingLoad,
   schemaTeachingLoadSlot: () => schemaTeachingLoadSlot,
+  schemaTrack: () => schemaTrack,
   schemaUpdateOptions: () => schemaUpdateOptions,
   schemaUpdateStatus: () => schemaUpdateStatus,
   statusesProgramScreening: () => statusesProgramScreening,
@@ -1456,13 +1460,18 @@ __export(src_exports, {
   useStockCardController: () => useStockCardController,
   useStockCardRepository: () => useStockCardRepository,
   useStockCardService: () => useStockCardService,
+  useStrandController: () => useStrandController,
+  useStrandRepo: () => useStrandRepo,
   useSubjectController: () => useSubjectController,
   useSubjectRepo: () => useSubjectRepo,
   useSubjectService: () => useSubjectService,
   useTeachingLoadController: () => useTeachingLoadController,
   useTeachingLoadRepo: () => useTeachingLoadRepo,
   useTeachingLoadSlotController: () => useTeachingLoadSlotController,
-  useTeachingLoadSlotRepo: () => useTeachingLoadSlotRepo
+  useTeachingLoadSlotRepo: () => useTeachingLoadSlotRepo,
+  useTrackController: () => useTrackController,
+  useTrackRepo: () => useTrackRepo,
+  useTrackService: () => useTrackService
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -2159,7 +2168,6 @@ var schemaSubject = import_joi3.default.object({
   curriculum: import_joi3.default.string().hex().required(),
   curriculumName: import_joi3.default.string().required(),
   effectiveSchoolYear: import_joi3.default.array().items(import_joi3.default.number().integer().min(1900)).optional(),
-  educationLevel: import_joi3.default.string().required(),
   gradeLevel: import_joi3.default.string().required(),
   program: import_joi3.default.string().hex().optional().allow("", null),
   programName: import_joi3.default.string().optional().allow("", null),
@@ -2181,7 +2189,6 @@ var schemaSubjectAdd = import_joi3.default.object({
   curriculum: import_joi3.default.string().hex().required(),
   curriculumName: import_joi3.default.string().required(),
   effectiveSchoolYear: import_joi3.default.array().items(import_joi3.default.number().integer().min(1900)).optional(),
-  educationLevel: import_joi3.default.string().required(),
   gradeLevel: import_joi3.default.array().items(import_joi3.default.string()).required(),
   program: import_joi3.default.string().hex().optional().allow("", null),
   programName: import_joi3.default.string().optional().allow("", null),
@@ -2233,7 +2240,6 @@ function modelSubject(value) {
     curriculum: value.curriculum,
     curriculumName: value.curriculumName ?? "",
     effectiveSchoolYear: value.effectiveSchoolYear ?? [],
-    educationLevel: value.educationLevel ?? "",
     gradeLevel: value.gradeLevel ?? "",
     program: value.program,
     programName: value.programName ?? "",
@@ -2678,7 +2684,6 @@ function useSubjectService() {
             curriculum: value.curriculum,
             curriculumName: value.curriculumName,
             effectiveSchoolYear: value.effectiveSchoolYear,
-            educationLevel: value.educationLevel,
             gradeLevel,
             subjectCode: value.subjectCode,
             subjectName: value.subjectName,
@@ -2747,7 +2752,6 @@ function useSubjectController() {
       id: import_joi4.default.string().hex().required(),
       value: import_joi4.default.object({
         curriculum: import_joi4.default.string().hex().optional(),
-        educationLevel: import_joi4.default.string().optional(),
         gradeLevel: import_joi4.default.string().optional(),
         subjectCode: import_joi4.default.string().optional(),
         subjectName: import_joi4.default.string().optional(),
@@ -35377,8 +35381,6 @@ var schemaGradeLevel = import_joi17.default.object({
   school: import_joi17.default.string().hex().optional(),
   educationLevel: import_joi17.default.string().required(),
   gradeLevel: import_joi17.default.string().required(),
-  tracks: import_joi17.default.array().items(import_joi17.default.string()).optional(),
-  trackStrands: import_joi17.default.array().items(import_joi17.default.string()).optional(),
   teachingStyle: import_joi17.default.string().required(),
   maxNumberOfLearners: import_joi17.default.number().required(),
   minNumberOfLearners: import_joi17.default.number().required(),
@@ -35422,8 +35424,6 @@ function MGradeLevel(value) {
     school: value.school ?? void 0,
     educationLevel: value.educationLevel ?? "",
     gradeLevel: value.gradeLevel ?? "",
-    tracks: value.tracks ?? [],
-    trackStrands: value.trackStrands ?? [],
     teachingStyle: value.teachingStyle ?? "",
     maxNumberOfLearners: value.maxNumberOfLearners ?? 0,
     minNumberOfLearners: value.minNumberOfLearners ?? 0,
@@ -39413,7 +39413,7 @@ function useSectionRepo() {
         { key: { createdAt: 1 } },
         { key: { name: "text", schoolYear: "text", gradeLevel: "text" } },
         {
-          key: { school: 1, teacher: 1, schoolYear: 1, status: 1 },
+          key: { name: 1, school: 1, gradeLevel: 1, schoolYear: 1, status: 1 },
           unique: true,
           name: "unique_section"
         }
@@ -39883,6 +39883,13 @@ function modelSectionStudent(value) {
       throw new Error("Invalid school ID.");
     }
   }
+  if (value.student && typeof value.student === "string") {
+    try {
+      value.student = new import_mongodb31.ObjectId(value.student);
+    } catch (error2) {
+      throw new Error("Invalid student ID.");
+    }
+  }
   return {
     _id: value._id,
     lrn: value.lrn,
@@ -40060,14 +40067,6 @@ function useSectionStudentRepo() {
   async function getStudent(options) {
     const query = {};
     const cacheKeyOptions = { tag: "getStudent" };
-    if (options.learner) {
-      try {
-        query.learner = new import_mongodb32.ObjectId(options.learner);
-        cacheKeyOptions.learner = String(options.learner);
-      } catch (error) {
-        throw new import_nodejs_utils54.BadRequestError("Invalid learner ID.");
-      }
-    }
     if (options.schoolYear) {
       query.schoolYear = options.schoolYear;
       cacheKeyOptions.schoolYear = options.schoolYear;
@@ -40139,7 +40138,6 @@ var schemaSectionSubject = import_joi34.default.object({
   section: import_joi34.default.string().hex().required(),
   sectionName: import_joi34.default.string().required(),
   gradeLevel: import_joi34.default.string().required(),
-  educationLevel: import_joi34.default.string().required(),
   schoolYear: import_joi34.default.string().required(),
   subjectCode: import_joi34.default.string().required(),
   subjectName: import_joi34.default.string().required(),
@@ -40212,7 +40210,6 @@ function modelSectionSubject(value) {
     section: value.section,
     sectionName: value.sectionName,
     gradeLevel: value.gradeLevel,
-    educationLevel: value.educationLevel,
     schoolYear: value.schoolYear,
     subjectCode: value.subjectCode,
     subjectName: value.subjectName,
@@ -42350,7 +42347,6 @@ var import_nodejs_utils66 = require("@eeplatform/nodejs-utils");
 var import_joi41 = __toESM(require("joi"));
 var import_mongodb39 = require("mongodb");
 var schemaPersonnel = import_joi41.default.object({
-  _id: import_joi41.default.string().hex().optional().allow("", null),
   school: import_joi41.default.string().hex().required(),
   schoolName: import_joi41.default.string().optional().allow("", null),
   firstName: import_joi41.default.string().required(),
@@ -42360,11 +42356,7 @@ var schemaPersonnel = import_joi41.default.object({
   title: import_joi41.default.string().optional().allow("", null),
   classification: import_joi41.default.string().required(),
   specializations: import_joi41.default.array().items(import_joi41.default.string()).optional(),
-  gradeLevels: import_joi41.default.array().items(import_joi41.default.string()).optional(),
-  status: import_joi41.default.string().optional().allow("", null),
-  createdAt: import_joi41.default.date().optional().allow("", null),
-  updatedAt: import_joi41.default.date().optional().allow("", null),
-  deletedAt: import_joi41.default.date().optional().allow("", null)
+  gradeLevels: import_joi41.default.array().items(import_joi41.default.string()).optional()
 });
 function MPersonnel(value) {
   const { error } = schemaPersonnel.validate(value);
@@ -43022,22 +43014,22 @@ function useSectionService() {
         if (existingSection) {
           sectionId = existingSection._id?.toString() || "";
           sectionsSkipped++;
-          continue;
+        } else {
+          sectionId = await createSection(
+            {
+              school: value.school,
+              schoolYear: value.schoolYear,
+              gradeLevel: value.gradeLevel,
+              name: sectionName,
+              students: size
+            },
+            session
+          );
+          sectionsGenerated++;
         }
-        sectionId = await createSection(
-          {
-            school: value.school,
-            schoolYear: value.schoolYear,
-            gradeLevel: value.gradeLevel,
-            name: sectionName,
-            students: size
-          },
-          session
-        );
         if (!sectionId) {
           throw new import_nodejs_utils69.InternalServerError("Required section ID is missing.");
         }
-        sectionsGenerated++;
         const skip = totalStudentsProcessed;
         const learners = await getLeanerByGradeLevel(
           {
@@ -43067,24 +43059,24 @@ function useSectionService() {
           });
           if (existingStudent) {
             studentSkipped++;
-            continue;
+          } else {
+            await assignStudent(
+              {
+                section: sectionId,
+                lrn: student.learnerInfo.lrn,
+                student: student._id?.toString(),
+                studentName: `${student.learnerInfo.firstName} ${student.learnerInfo.lastName}`,
+                school: value.school,
+                schoolName: schoolData.name,
+                gradeLevel: value.gradeLevel,
+                educationLevel: gradeLevelData.educationLevel,
+                schoolYear: value.schoolYear,
+                status: "active"
+              },
+              session
+            );
+            studentCreated++;
           }
-          await assignStudent(
-            {
-              section: sectionId,
-              lrn: student.learnerInfo.lrn,
-              student: student._id?.toString(),
-              studentName: `${student.learnerInfo.firstName} ${student.learnerInfo.lastName}`,
-              school: value.school,
-              schoolName: schoolData.name,
-              gradeLevel: value.gradeLevel,
-              educationLevel: gradeLevelData.educationLevel,
-              schoolYear: value.schoolYear,
-              status: "active"
-            },
-            session
-          );
-          studentCreated++;
         }
         if (value.gradeLevel !== "kindergarten") {
           const curriculumSubjects = await getAllCurriculumSubjects({
@@ -43098,35 +43090,34 @@ function useSectionService() {
               subjectCode: curriculumSubject.subjectCode,
               schoolYear: value.schoolYear
             });
-            if (existingSectionSubject) {
+            if (existingSectionSubject && existingSectionSubject.length) {
               subjectsSkipped++;
-              continue;
+            } else {
+              await addSectionSubject(
+                {
+                  curriculum: curriculumSubject.curriculum.toString(),
+                  school: value.school,
+                  schoolName: schoolData.name,
+                  gradeLevel: value.gradeLevel,
+                  schoolYear: value.schoolYear,
+                  section: sectionId,
+                  sectionName,
+                  subjectCode: curriculumSubject.subjectCode,
+                  subjectName: curriculumSubject.subjectName,
+                  teacher: "",
+                  teacherName: "",
+                  schedule: "",
+                  daysOfWeek: [],
+                  classroom: "",
+                  classroomName: "",
+                  sessionDuration: curriculumSubject.sessionDuration,
+                  sessionFrequency: curriculumSubject.sessionFrequency,
+                  status: "draft"
+                },
+                session
+              );
+              subjectsAssigned++;
             }
-            await addSectionSubject(
-              {
-                curriculum: curriculumSubject.curriculum.toString(),
-                school: value.school,
-                schoolName: schoolData.name,
-                gradeLevel: value.gradeLevel,
-                educationLevel: gradeLevelData.educationLevel,
-                schoolYear: value.schoolYear,
-                section: sectionId,
-                sectionName,
-                subjectCode: curriculumSubject.subjectCode,
-                subjectName: curriculumSubject.subjectName,
-                teacher: "",
-                teacherName: "",
-                schedule: "",
-                daysOfWeek: [],
-                classroom: "",
-                classroomName: "",
-                sessionDuration: curriculumSubject.sessionDuration,
-                sessionFrequency: curriculumSubject.sessionFrequency,
-                status: "draft"
-              },
-              session
-            );
-            subjectsAssigned++;
           }
         }
       }
@@ -43159,7 +43150,7 @@ function useSectionService() {
             school: value.school,
             schoolYear: value.schoolYear
           });
-          if (existingLoad) {
+          if (existingLoad && existingLoad.length) {
             teachingLoadsSkipped++;
             continue;
           }
@@ -46047,6 +46038,1120 @@ function useKindergartenDomainController() {
   };
 }
 
+// src/resources/track/track.model.ts
+var import_nodejs_utils86 = require("@eeplatform/nodejs-utils");
+var import_joi52 = __toESM(require("joi"));
+var import_mongodb48 = require("mongodb");
+var schemaTrack = import_joi52.default.object({
+  name: import_joi52.default.string().max(100).required(),
+  school: import_joi52.default.string().hex().required()
+});
+function modelTrack(value) {
+  const { error } = schemaTrack.validate(value);
+  if (error) {
+    throw new import_nodejs_utils86.BadRequestError(`Invalid track data: ${error.message}`);
+  }
+  if (value._id && typeof value._id === "string") {
+    try {
+      value._id = new import_mongodb48.ObjectId(value._id);
+    } catch (error2) {
+      throw new Error("Invalid _id.");
+    }
+  }
+  if (value.school && typeof value.school === "string") {
+    try {
+      value.school = new import_mongodb48.ObjectId(value.school);
+    } catch (error2) {
+      throw new Error("Invalid school.");
+    }
+  }
+  return {
+    _id: value._id,
+    name: value.name,
+    school: value.school,
+    status: value.status ?? "active",
+    createdAt: value.createdAt ?? /* @__PURE__ */ new Date(),
+    updatedAt: value.updatedAt ?? "",
+    deletedAt: value.deletedAt ?? ""
+  };
+}
+
+// src/resources/track/track.repository.ts
+var import_nodejs_utils87 = require("@eeplatform/nodejs-utils");
+var import_mongodb49 = require("mongodb");
+function useTrackRepo() {
+  const db = import_nodejs_utils87.useAtlas.getDb();
+  if (!db) {
+    throw new Error("Unable to connect to server.");
+  }
+  const namespace_collection = "deped.school.tracks";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_nodejs_utils87.useCache)(namespace_collection);
+  async function createIndexes() {
+    try {
+      await collection.createIndexes([
+        { key: { school: 1 } },
+        { key: { name: "text" } },
+        {
+          key: { name: 1, school: 1, status: 1 },
+          unique: true,
+          name: "unique_track"
+        }
+      ]);
+    } catch (error) {
+      throw new Error("Failed to create index on tracks.");
+    }
+  }
+  function delCachedData() {
+    delNamespace().then(() => {
+      import_nodejs_utils87.logger.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      import_nodejs_utils87.logger.log({
+        level: "error",
+        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+      });
+    });
+  }
+  async function add(value, session) {
+    try {
+      value = modelTrack(value);
+      const res = await collection.insertOne(value, { session });
+      delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      import_nodejs_utils87.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils87.AppError) {
+        throw error;
+      } else {
+        const isDuplicated = error.message.includes("duplicate");
+        if (isDuplicated) {
+          throw new import_nodejs_utils87.BadRequestError("track already exists.");
+        }
+        throw new Error("Failed to create track.");
+      }
+    }
+  }
+  async function getAll({
+    search = "",
+    page = 1,
+    limit = 10,
+    sort = {},
+    status = "active",
+    school = ""
+  } = {}) {
+    page = page > 0 ? page - 1 : 0;
+    const query = {
+      deletedAt: { $in: ["", null] },
+      status
+    };
+    sort = Object.keys(sort).length > 0 ? sort : { _id: 1 };
+    const cacheKeyOptions = {
+      status,
+      page,
+      limit,
+      sort: JSON.stringify(sort)
+    };
+    if (search) {
+      query.$text = { $search: search };
+      cacheKeyOptions.search = search;
+    }
+    if (school) {
+      try {
+        query.school = new import_mongodb49.ObjectId(school);
+      } catch (error) {
+        throw new import_nodejs_utils87.BadRequestError("Invalid school ID.");
+      }
+      cacheKeyOptions.school = school;
+    }
+    const cacheKey = (0, import_nodejs_utils87.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    import_nodejs_utils87.logger.log({
+      level: "info",
+      message: `Cache key for getAll tracks: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils87.logger.log({
+          level: "info",
+          message: `Cache hit for getAll tracks: ${cacheKey}`
+        });
+        return cached;
+      }
+      const items = await collection.aggregate([
+        { $match: query },
+        { $sort: sort },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const total = await collection.countDocuments(query);
+      const result = (0, import_nodejs_utils87.paginate)(items, total, page, limit);
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils87.logger.log({
+          level: "info",
+          message: `Cache set for getAll tracks: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils87.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll tracks: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils87.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils87.InternalServerError("Failed to get tracks.");
+      }
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new import_mongodb49.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils87.BadRequestError(namespace_collection + " Invalid ID.");
+    }
+    const cacheKey = (0, import_nodejs_utils87.makeCacheKey)(namespace_collection, {
+      _id: _id.toString()
+    });
+    import_nodejs_utils87.logger.log({
+      level: "info",
+      message: `Cache key for getById track: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils87.logger.log({
+          level: "info",
+          message: `Cache hit for getById track: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne({
+        _id,
+        deletedAt: { $in: ["", null] }
+      });
+      if (!result) {
+        throw new import_nodejs_utils87.BadRequestError("track not found.");
+      }
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils87.logger.log({
+          level: "info",
+          message: `Cache set for getById track: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils87.logger.log({
+          level: "error",
+          message: `Failed to set cache for getById track: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils87.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils87.InternalServerError("Failed to get track.");
+      }
+    }
+  }
+  async function getBySchool(school) {
+    try {
+      school = new import_mongodb49.ObjectId(school);
+    } catch (error) {
+      throw new import_nodejs_utils87.BadRequestError("Invalid school ID.");
+    }
+    const cacheKey = (0, import_nodejs_utils87.makeCacheKey)(namespace_collection, {
+      school: school.toString()
+    });
+    import_nodejs_utils87.logger.log({
+      level: "info",
+      message: `Cache key for track by school: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils87.logger.log({
+          level: "info",
+          message: `Cache hit for track by school: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.find({
+        school,
+        deletedAt: { $in: ["", null] }
+      }).toArray();
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils87.logger.log({
+          level: "info",
+          message: `Cache set for track by school: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils87.logger.log({
+          level: "error",
+          message: `Failed to set cache for track by school: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils87.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils87.InternalServerError("Failed to get track.");
+      }
+    }
+  }
+  async function updateFieldById({ _id, field, value } = {}, session) {
+    const allowedFields = ["title", "status"];
+    if (!allowedFields.includes(field)) {
+      throw new import_nodejs_utils87.BadRequestError(
+        `Field "${field}" is not allowed to be updated.`
+      );
+    }
+    try {
+      _id = new import_mongodb49.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils87.BadRequestError(namespace_collection + " Invalid ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id, deletedAt: { $in: ["", null] } },
+        { $set: { [field]: value, updatedAt: (/* @__PURE__ */ new Date()).toISOString() } },
+        { session }
+      );
+      delCachedData();
+      return `Successfully updated track ${field}.`;
+    } catch (error) {
+      throw new import_nodejs_utils87.InternalServerError(`Failed to update track ${field}.`);
+    }
+  }
+  async function updateById(_id, value, session) {
+    const { error } = schemaTrack.validate(value);
+    if (error) {
+      throw new import_nodejs_utils87.BadRequestError(`Invalid track data: ${error.message}`);
+    }
+    try {
+      _id = new import_mongodb49.ObjectId(_id);
+    } catch (error2) {
+      throw new import_nodejs_utils87.BadRequestError(namespace_collection + " Invalid ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id },
+        { $set: { ...value, updatedAt: (/* @__PURE__ */ new Date()).toISOString() } },
+        { session }
+      );
+      delCachedData();
+      return `Successfully updated track.`;
+    } catch (error2) {
+      throw new import_nodejs_utils87.InternalServerError("Failed to update track.");
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new import_mongodb49.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils87.BadRequestError(namespace_collection + " Invalid ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id },
+        { $set: { status: "deleted", deletedAt: /* @__PURE__ */ new Date() } },
+        { session }
+      );
+      delCachedData();
+      return "Successfully deleted track.";
+    } catch (error) {
+      throw new import_nodejs_utils87.InternalServerError("Failed to delete track.");
+    }
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getById,
+    getBySchool,
+    updateFieldById,
+    updateById,
+    deleteById
+  };
+}
+
+// src/resources/track/track.service.ts
+var import_nodejs_utils90 = require("@eeplatform/nodejs-utils");
+
+// src/resources/strand/strand.repository.ts
+var import_nodejs_utils89 = require("@eeplatform/nodejs-utils");
+
+// src/resources/strand/strand.model.ts
+var import_nodejs_utils88 = require("@eeplatform/nodejs-utils");
+var import_joi53 = __toESM(require("joi"));
+var import_mongodb50 = require("mongodb");
+var schemaStrand = import_joi53.default.object({
+  track: import_joi53.default.string().hex().required(),
+  trackName: import_joi53.default.string().max(100).optional().allow(null, ""),
+  name: import_joi53.default.string().max(100).required(),
+  school: import_joi53.default.string().hex().required()
+});
+function modelStrand(value) {
+  const { error } = schemaStrand.validate(value);
+  if (error) {
+    throw new import_nodejs_utils88.BadRequestError(`Invalid strand data: ${error.message}`);
+  }
+  if (value._id && typeof value._id === "string") {
+    try {
+      value._id = new import_mongodb50.ObjectId(value._id);
+    } catch (error2) {
+      throw new Error("Invalid _id.");
+    }
+  }
+  if (value.school && typeof value.school === "string") {
+    try {
+      value.school = new import_mongodb50.ObjectId(value.school);
+    } catch (error2) {
+      throw new Error("Invalid school.");
+    }
+  }
+  if (value.track && typeof value.track === "string") {
+    try {
+      value.track = new import_mongodb50.ObjectId(value.track);
+    } catch (error2) {
+      throw new Error("Invalid track.");
+    }
+  }
+  return {
+    _id: value._id,
+    track: value.track,
+    trackName: value.trackName ?? "",
+    name: value.name,
+    school: value.school,
+    status: value.status ?? "active",
+    createdAt: value.createdAt ?? /* @__PURE__ */ new Date(),
+    updatedAt: value.updatedAt ?? "",
+    deletedAt: value.deletedAt ?? ""
+  };
+}
+
+// src/resources/strand/strand.repository.ts
+var import_mongodb51 = require("mongodb");
+function useStrandRepo() {
+  const db = import_nodejs_utils89.useAtlas.getDb();
+  if (!db) {
+    throw new Error("Unable to connect to server.");
+  }
+  const namespace_collection = "deped.school.strands";
+  const collection = db.collection(namespace_collection);
+  const { getCache, setCache, delNamespace } = (0, import_nodejs_utils89.useCache)(namespace_collection);
+  async function createIndexes() {
+    try {
+      await collection.createIndexes([
+        { key: { school: 1 } },
+        { key: { strand: 1 } },
+        { key: { name: "text", strand: "text" } },
+        {
+          key: { name: 1, strand: 1, school: 1, status: 1 },
+          unique: true,
+          name: "unique_strand"
+        }
+      ]);
+    } catch (error) {
+      throw new Error("Failed to create index on strands.");
+    }
+  }
+  function delCachedData() {
+    delNamespace().then(() => {
+      import_nodejs_utils89.logger.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      import_nodejs_utils89.logger.log({
+        level: "error",
+        message: `Failed to clear cache namespace for ${namespace_collection}: ${err.message}`
+      });
+    });
+  }
+  async function add(value, session) {
+    try {
+      value = modelStrand(value);
+      const res = await collection.insertOne(value, { session });
+      delCachedData();
+      return res.insertedId;
+    } catch (error) {
+      import_nodejs_utils89.logger.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof import_nodejs_utils89.AppError) {
+        throw error;
+      } else {
+        const isDuplicated = error.message.includes("duplicate");
+        if (isDuplicated) {
+          throw new import_nodejs_utils89.BadRequestError("Strand already exists.");
+        }
+        throw new Error("Failed to create strand.");
+      }
+    }
+  }
+  async function getAll({
+    search = "",
+    page = 1,
+    limit = 10,
+    sort = {},
+    status = "active",
+    school = ""
+  } = {}) {
+    page = page > 0 ? page - 1 : 0;
+    const query = {
+      deletedAt: { $in: ["", null] },
+      status
+    };
+    sort = Object.keys(sort).length > 0 ? sort : { _id: 1 };
+    const cacheKeyOptions = {
+      status,
+      page,
+      limit,
+      sort: JSON.stringify(sort)
+    };
+    if (search) {
+      query.$text = { $search: search };
+      cacheKeyOptions.search = search;
+    }
+    if (school) {
+      try {
+        query.school = new import_mongodb51.ObjectId(school);
+      } catch (error) {
+        throw new import_nodejs_utils89.BadRequestError("Invalid school ID.");
+      }
+      cacheKeyOptions.school = school;
+    }
+    const cacheKey = (0, import_nodejs_utils89.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    import_nodejs_utils89.logger.log({
+      level: "info",
+      message: `Cache key for getAll strands: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils89.logger.log({
+          level: "info",
+          message: `Cache hit for getAll strands: ${cacheKey}`
+        });
+        return cached;
+      }
+      const items = await collection.aggregate([
+        { $match: query },
+        { $sort: sort },
+        { $skip: page * limit },
+        { $limit: limit }
+      ]).toArray();
+      const total = await collection.countDocuments(query);
+      const result = (0, import_nodejs_utils89.paginate)(items, total, page, limit);
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils89.logger.log({
+          level: "info",
+          message: `Cache set for getAll strands: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils89.logger.log({
+          level: "error",
+          message: `Failed to set cache for getAll strands: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils89.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils89.InternalServerError("Failed to get strands.");
+      }
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new import_mongodb51.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils89.BadRequestError(namespace_collection + " Invalid ID.");
+    }
+    const cacheKey = (0, import_nodejs_utils89.makeCacheKey)(namespace_collection, {
+      _id: _id.toString()
+    });
+    import_nodejs_utils89.logger.log({
+      level: "info",
+      message: `Cache key for getById strand: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils89.logger.log({
+          level: "info",
+          message: `Cache hit for getById strand: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.findOne({
+        _id,
+        deletedAt: { $in: ["", null] }
+      });
+      if (!result) {
+        throw new import_nodejs_utils89.BadRequestError("strand not found.");
+      }
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils89.logger.log({
+          level: "info",
+          message: `Cache set for getById strand: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils89.logger.log({
+          level: "error",
+          message: `Failed to set cache for getById strand: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils89.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils89.InternalServerError("Failed to get strand.");
+      }
+    }
+  }
+  async function getBySchool(school) {
+    try {
+      school = new import_mongodb51.ObjectId(school);
+    } catch (error) {
+      throw new import_nodejs_utils89.BadRequestError("Invalid school ID.");
+    }
+    const cacheKey = (0, import_nodejs_utils89.makeCacheKey)(namespace_collection, {
+      school: school.toString()
+    });
+    import_nodejs_utils89.logger.log({
+      level: "info",
+      message: `Cache key for strand by school: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils89.logger.log({
+          level: "info",
+          message: `Cache hit for strand by school: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.find({
+        school,
+        deletedAt: { $in: ["", null] }
+      }).toArray();
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils89.logger.log({
+          level: "info",
+          message: `Cache set for strand by school: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils89.logger.log({
+          level: "error",
+          message: `Failed to set cache for strand by school: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils89.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils89.InternalServerError("Failed to get strand.");
+      }
+    }
+  }
+  async function updateFieldById({ _id, field, value } = {}, session) {
+    const allowedFields = ["title", "status"];
+    if (!allowedFields.includes(field)) {
+      throw new import_nodejs_utils89.BadRequestError(
+        `Field "${field}" is not allowed to be updated.`
+      );
+    }
+    try {
+      _id = new import_mongodb51.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils89.BadRequestError(namespace_collection + " Invalid ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id, deletedAt: { $in: ["", null] } },
+        { $set: { [field]: value, updatedAt: (/* @__PURE__ */ new Date()).toISOString() } },
+        { session }
+      );
+      delCachedData();
+      return `Successfully updated strand ${field}.`;
+    } catch (error) {
+      throw new import_nodejs_utils89.InternalServerError(`Failed to update strand ${field}.`);
+    }
+  }
+  async function updateById(_id, value, session) {
+    const { error } = schemaStrand.validate(value);
+    if (error) {
+      throw new import_nodejs_utils89.BadRequestError(`Invalid strand data: ${error.message}`);
+    }
+    try {
+      _id = new import_mongodb51.ObjectId(_id);
+    } catch (error2) {
+      throw new import_nodejs_utils89.BadRequestError(namespace_collection + " Invalid ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id },
+        { $set: { ...value, updatedAt: (/* @__PURE__ */ new Date()).toISOString() } },
+        { session }
+      );
+      delCachedData();
+      return `Successfully updated strand.`;
+    } catch (error2) {
+      throw new import_nodejs_utils89.InternalServerError("Failed to update strand.");
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new import_mongodb51.ObjectId(_id);
+    } catch (error) {
+      throw new import_nodejs_utils89.BadRequestError(namespace_collection + " Invalid ID.");
+    }
+    try {
+      await collection.updateOne(
+        { _id },
+        { $set: { status: "deleted", deletedAt: (/* @__PURE__ */ new Date()).toISOString() } },
+        { session }
+      );
+      delCachedData();
+      return "Successfully deleted strand.";
+    } catch (error) {
+      throw new import_nodejs_utils89.InternalServerError("Failed to delete strand.");
+    }
+  }
+  async function countByTrack(track) {
+    const query = { status: { $ne: "deleted" } };
+    const cacheKeyOptions = { tag: "countByTrack" };
+    try {
+      query.track = new import_mongodb51.ObjectId(track);
+      cacheKeyOptions.track = track;
+    } catch (error) {
+      throw new import_nodejs_utils89.BadRequestError("Invalid track ID.");
+    }
+    const cacheKey = (0, import_nodejs_utils89.makeCacheKey)(namespace_collection, cacheKeyOptions);
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        import_nodejs_utils89.logger.log({
+          level: "info",
+          message: `Cache hit for getById strand: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.countDocuments(query);
+      setCache(cacheKey, result, 300).then(() => {
+        import_nodejs_utils89.logger.log({
+          level: "info",
+          message: `Cache set for strand by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        import_nodejs_utils89.logger.log({
+          level: "error",
+          message: `Failed to set cache for strand by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof import_nodejs_utils89.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils89.InternalServerError("Failed to get strand.");
+      }
+    }
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getById,
+    getBySchool,
+    updateFieldById,
+    updateById,
+    deleteById,
+    countByTrack
+  };
+}
+
+// src/resources/track/track.service.ts
+function useTrackService() {
+  const { add: _add, deleteById: _deleteById, getById } = useTrackRepo();
+  const { countByTrack } = useStrandRepo();
+  async function deleteById(id) {
+    const session = import_nodejs_utils90.useAtlas.getClient()?.startSession();
+    if (!session) {
+      throw new Error("Failed to start database session.");
+    }
+    try {
+      session.startTransaction();
+      const track = await getById(id);
+      if (!track) {
+        throw new import_nodejs_utils90.BadRequestError("track not found.");
+      }
+      const usageCount = await countByTrack(id);
+      if (usageCount > 0) {
+        throw new import_nodejs_utils90.BadRequestError(
+          "Cannot delete track as it is currently in use."
+        );
+      }
+      const message = await _deleteById(id, session);
+      await session.commitTransaction();
+      return message;
+    } catch (error) {
+      await session.abortTransaction();
+      if (error instanceof import_nodejs_utils90.AppError) {
+        throw error;
+      } else {
+        throw new import_nodejs_utils90.AppError("Failed to delete track.", 500);
+      }
+    } finally {
+      await session.endSession();
+    }
+  }
+  return {
+    deleteById
+  };
+}
+
+// src/resources/track/track.controller.ts
+var import_nodejs_utils91 = require("@eeplatform/nodejs-utils");
+var import_joi54 = __toESM(require("joi"));
+function useTrackController() {
+  const {
+    add: _add,
+    getAll: _getAll,
+    getById: _getById,
+    getBySchool: _getBySchool,
+    updateFieldById: _updateFieldById
+  } = useTrackRepo();
+  async function add(req, res, next) {
+    const value = req.body;
+    const { error } = schemaTrack.validate(value);
+    if (error) {
+      next(new import_nodejs_utils91.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _add(value);
+      res.json({
+        message: "Successfully created track.",
+        data
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getAll(req, res, next) {
+    const query = req.query;
+    const validation = import_joi54.default.object({
+      page: import_joi54.default.number().min(1).optional().allow("", null),
+      limit: import_joi54.default.number().min(1).optional().allow("", null),
+      search: import_joi54.default.string().optional().allow("", null),
+      status: import_joi54.default.string().optional().allow("", null),
+      school: import_joi54.default.string().hex().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    const page = typeof req.query.page === "string" ? Number(req.query.page) : 1;
+    const limit = typeof req.query.limit === "string" ? Number(req.query.limit) : 10;
+    const search = req.query.search ?? "";
+    const status = req.query.status ?? "active";
+    const school = req.query.school ?? "";
+    const isPageNumber = isFinite(page);
+    if (!isPageNumber) {
+      next(new import_nodejs_utils91.BadRequestError("Invalid page number."));
+      return;
+    }
+    const isLimitNumber = isFinite(limit);
+    if (!isLimitNumber) {
+      next(new import_nodejs_utils91.BadRequestError("Invalid limit number."));
+      return;
+    }
+    if (error) {
+      next(new import_nodejs_utils91.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getAll({
+        page,
+        limit,
+        search,
+        status,
+        school
+      });
+      res.json(data);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi54.default.object({
+      id: import_joi54.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_nodejs_utils91.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getById(id);
+      res.json({
+        message: "Successfully retrieved kindergarten domain.",
+        data
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getBySchool(req, res, next) {
+    const school = req.params.school;
+    const validation = import_joi54.default.object({
+      school: import_joi54.default.string().hex().required()
+    });
+    const { error } = validation.validate({ school });
+    if (error) {
+      next(new import_nodejs_utils91.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getBySchool(school);
+      res.json({
+        message: "Successfully retrieved kindergarten domains.",
+        data
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateField(req, res, next) {
+    const _id = req.params.id;
+    const { field, value } = req.body;
+    const validation = import_joi54.default.object({
+      _id: import_joi54.default.string().hex().required(),
+      field: import_joi54.default.string().valid("name").required(),
+      value: import_joi54.default.alternatives().try(import_joi54.default.string(), import_joi54.default.array(), import_joi54.default.object()).required()
+    });
+    const { error } = validation.validate({ _id, field, value });
+    if (error) {
+      next(new import_nodejs_utils91.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _updateFieldById({ _id, field, value });
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  const { deleteById: _deleteById } = useTrackService();
+  async function deleteById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi54.default.object({
+      id: import_joi54.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_nodejs_utils91.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _deleteById(id);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    add,
+    getAll,
+    getById,
+    getBySchool,
+    updateField,
+    deleteById
+  };
+}
+
+// src/resources/strand/strand.controller.ts
+var import_nodejs_utils92 = require("@eeplatform/nodejs-utils");
+var import_joi55 = __toESM(require("joi"));
+function useStrandController() {
+  const {
+    add: _add,
+    getAll: _getAll,
+    getById: _getById,
+    getBySchool: _getBySchool,
+    updateFieldById: _updateFieldById,
+    deleteById: _deleteById
+  } = useStrandRepo();
+  async function add(req, res, next) {
+    const value = req.body;
+    const { error } = schemaStrand.validate(value);
+    if (error) {
+      next(new import_nodejs_utils92.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _add(value);
+      res.json({
+        message: "Successfully created kindergarten domain.",
+        data
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getAll(req, res, next) {
+    const query = req.query;
+    const validation = import_joi55.default.object({
+      page: import_joi55.default.number().min(1).optional().allow("", null),
+      limit: import_joi55.default.number().min(1).optional().allow("", null),
+      search: import_joi55.default.string().optional().allow("", null),
+      status: import_joi55.default.string().optional().allow("", null),
+      school: import_joi55.default.string().hex().optional().allow("", null)
+    });
+    const { error } = validation.validate(query);
+    const page = typeof req.query.page === "string" ? Number(req.query.page) : 1;
+    const limit = typeof req.query.limit === "string" ? Number(req.query.limit) : 10;
+    const search = req.query.search ?? "";
+    const status = req.query.status ?? "active";
+    const school = req.query.school ?? "";
+    const isPageNumber = isFinite(page);
+    if (!isPageNumber) {
+      next(new import_nodejs_utils92.BadRequestError("Invalid page number."));
+      return;
+    }
+    const isLimitNumber = isFinite(limit);
+    if (!isLimitNumber) {
+      next(new import_nodejs_utils92.BadRequestError("Invalid limit number."));
+      return;
+    }
+    if (error) {
+      next(new import_nodejs_utils92.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getAll({
+        page,
+        limit,
+        search,
+        status,
+        school
+      });
+      res.json(data);
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getById(req, res, next) {
+    const id = req.params.id;
+    const validation = import_joi55.default.object({
+      id: import_joi55.default.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new import_nodejs_utils92.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getById(id);
+      res.json({
+        message: "Successfully retrieved kindergarten domain.",
+        data
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function getBySchool(req, res, next) {
+    const school = req.params.school;
+    const validation = import_joi55.default.object({
+      school: import_joi55.default.string().hex().required()
+    });
+    const { error } = validation.validate({ school });
+    if (error) {
+      next(new import_nodejs_utils92.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const data = await _getBySchool(school);
+      res.json({
+        message: "Successfully retrieved strand.",
+        data
+      });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function updateField(req, res, next) {
+    const _id = req.params.id;
+    const { field, value } = req.body;
+    const validation = import_joi55.default.object({
+      _id: import_joi55.default.string().hex().required(),
+      field: import_joi55.default.string().valid("title", "status").required(),
+      value: import_joi55.default.alternatives().try(import_joi55.default.string(), import_joi55.default.array(), import_joi55.default.object()).required()
+    });
+    const { error } = validation.validate({ _id, field, value });
+    if (error) {
+      next(new import_nodejs_utils92.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _updateFieldById({ _id, field, value });
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  async function deleteById(req, res, next) {
+    const _id = req.params.id;
+    const validation = import_joi55.default.object({
+      _id: import_joi55.default.string().hex().required()
+    });
+    const { error } = validation.validate({ _id });
+    if (error) {
+      next(new import_nodejs_utils92.BadRequestError(error.message));
+      return;
+    }
+    try {
+      const message = await _deleteById(_id);
+      res.json({ message });
+      return;
+    } catch (error2) {
+      next(error2);
+    }
+  }
+  return {
+    add,
+    getAll,
+    getById,
+    getBySchool,
+    updateField,
+    deleteById
+  };
+}
+
 // src/config.ts
 var dotenv = __toESM(require("dotenv"));
 dotenv.config();
@@ -46074,9 +47179,11 @@ dotenv.config();
   modelSectionPreset,
   modelSectionStudent,
   modelSectionSubject,
+  modelStrand,
   modelSubject,
   modelTeachingLoad,
   modelTeachingLoadSlot,
+  modelTrack,
   schemaAsset,
   schemaAssetUpdateOption,
   schemaBasicEduCount,
@@ -46106,10 +47213,12 @@ dotenv.config();
   schemaSectionSubject,
   schemaSectionSubjectSetup,
   schemaStockCard,
+  schemaStrand,
   schemaSubject,
   schemaSubjectAdd,
   schemaTeachingLoad,
   schemaTeachingLoadSlot,
+  schemaTrack,
   schemaUpdateOptions,
   schemaUpdateStatus,
   statusesProgramScreening,
@@ -46165,13 +47274,18 @@ dotenv.config();
   useStockCardController,
   useStockCardRepository,
   useStockCardService,
+  useStrandController,
+  useStrandRepo,
   useSubjectController,
   useSubjectRepo,
   useSubjectService,
   useTeachingLoadController,
   useTeachingLoadRepo,
   useTeachingLoadSlotController,
-  useTeachingLoadSlotRepo
+  useTeachingLoadSlotRepo,
+  useTrackController,
+  useTrackRepo,
+  useTrackService
 });
 /*! Bundled license information: