@eeplatform/basic-edu 1.10.2 → 1.10.4

package/dist/index.mjs

@@ -2043,7 +2043,6 @@ var schemaSubject = Joi3.object({
   curriculum: Joi3.string().hex().required(),
   curriculumName: Joi3.string().required(),
   effectiveSchoolYear: Joi3.array().items(Joi3.number().integer().min(1900)).optional(),
-  educationLevel: Joi3.string().required(),
   gradeLevel: Joi3.string().required(),
   program: Joi3.string().hex().optional().allow("", null),
   programName: Joi3.string().optional().allow("", null),
@@ -2065,7 +2064,6 @@ var schemaSubjectAdd = Joi3.object({
   curriculum: Joi3.string().hex().required(),
   curriculumName: Joi3.string().required(),
   effectiveSchoolYear: Joi3.array().items(Joi3.number().integer().min(1900)).optional(),
-  educationLevel: Joi3.string().required(),
   gradeLevel: Joi3.array().items(Joi3.string()).required(),
   program: Joi3.string().hex().optional().allow("", null),
   programName: Joi3.string().optional().allow("", null),
@@ -2117,7 +2115,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 ?? "",
@@ -2575,7 +2572,6 @@ function useSubjectService() {
             curriculum: value.curriculum,
             curriculumName: value.curriculumName,
             effectiveSchoolYear: value.effectiveSchoolYear,
-            educationLevel: value.educationLevel,
             gradeLevel,
             subjectCode: value.subjectCode,
             subjectName: value.subjectName,
@@ -2644,7 +2640,6 @@ function useSubjectController() {
       id: Joi4.string().hex().required(),
       value: Joi4.object({
         curriculum: Joi4.string().hex().optional(),
-        educationLevel: Joi4.string().optional(),
         gradeLevel: Joi4.string().optional(),
         subjectCode: Joi4.string().optional(),
         subjectName: Joi4.string().optional(),
@@ -35337,8 +35332,6 @@ var schemaGradeLevel = Joi17.object({
   school: Joi17.string().hex().optional(),
   educationLevel: Joi17.string().required(),
   gradeLevel: Joi17.string().required(),
-  tracks: Joi17.array().items(Joi17.string()).optional(),
-  trackStrands: Joi17.array().items(Joi17.string()).optional(),
   teachingStyle: Joi17.string().required(),
   maxNumberOfLearners: Joi17.number().required(),
   minNumberOfLearners: Joi17.number().required(),
@@ -35382,8 +35375,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,
@@ -39445,7 +39436,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"
         }
@@ -39929,6 +39920,13 @@ function modelSectionStudent(value) {
       throw new Error("Invalid school ID.");
     }
   }
+  if (value.student && typeof value.student === "string") {
+    try {
+      value.student = new ObjectId31(value.student);
+    } catch (error2) {
+      throw new Error("Invalid student ID.");
+    }
+  }
   return {
     _id: value._id,
     lrn: value.lrn,
@@ -40106,14 +40104,6 @@ function useSectionStudentRepo() {
   async function getStudent(options) {
     const query = {};
     const cacheKeyOptions = { tag: "getStudent" };
-    if (options.learner) {
-      try {
-        query.learner = new ObjectId32(options.learner);
-        cacheKeyOptions.learner = String(options.learner);
-      } catch (error) {
-        throw new BadRequestError51("Invalid learner ID.");
-      }
-    }
     if (options.schoolYear) {
       query.schoolYear = options.schoolYear;
       cacheKeyOptions.schoolYear = options.schoolYear;
@@ -40185,7 +40175,6 @@ var schemaSectionSubject = Joi34.object({
   section: Joi34.string().hex().required(),
   sectionName: Joi34.string().required(),
   gradeLevel: Joi34.string().required(),
-  educationLevel: Joi34.string().required(),
   schoolYear: Joi34.string().required(),
   subjectCode: Joi34.string().required(),
   subjectName: Joi34.string().required(),
@@ -40258,7 +40247,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,
@@ -42423,7 +42411,6 @@ import { BadRequestError as BadRequestError61, logger as logger36 } from "@eepla
 import Joi41 from "joi";
 import { ObjectId as ObjectId39 } from "mongodb";
 var schemaPersonnel = Joi41.object({
-  _id: Joi41.string().hex().optional().allow("", null),
   school: Joi41.string().hex().required(),
   schoolName: Joi41.string().optional().allow("", null),
   firstName: Joi41.string().required(),
@@ -42433,11 +42420,7 @@ var schemaPersonnel = Joi41.object({
   title: Joi41.string().optional().allow("", null),
   classification: Joi41.string().required(),
   specializations: Joi41.array().items(Joi41.string()).optional(),
-  gradeLevels: Joi41.array().items(Joi41.string()).optional(),
-  status: Joi41.string().optional().allow("", null),
-  createdAt: Joi41.date().optional().allow("", null),
-  updatedAt: Joi41.date().optional().allow("", null),
-  deletedAt: Joi41.date().optional().allow("", null)
+  gradeLevels: Joi41.array().items(Joi41.string()).optional()
 });
 function MPersonnel(value) {
   const { error } = schemaPersonnel.validate(value);
@@ -43104,22 +43087,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 InternalServerError21("Required section ID is missing.");
         }
-        sectionsGenerated++;
         const skip = totalStudentsProcessed;
         const learners = await getLeanerByGradeLevel(
           {
@@ -43149,24 +43132,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({
@@ -43180,35 +43163,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++;
           }
         }
       }
@@ -43241,7 +43223,7 @@ function useSectionService() {
             school: value.school,
             schoolYear: value.schoolYear
           });
-          if (existingLoad) {
+          if (existingLoad && existingLoad.length) {
             teachingLoadsSkipped++;
             continue;
           }
@@ -46169,6 +46151,1138 @@ function useKindergartenDomainController() {
   };
 }
 
+// src/resources/track/track.model.ts
+import { BadRequestError as BadRequestError80 } from "@eeplatform/nodejs-utils";
+import Joi52 from "joi";
+import { ObjectId as ObjectId48 } from "mongodb";
+var schemaTrack = Joi52.object({
+  name: Joi52.string().max(100).required(),
+  school: Joi52.string().hex().required()
+});
+function modelTrack(value) {
+  const { error } = schemaTrack.validate(value);
+  if (error) {
+    throw new BadRequestError80(`Invalid track data: ${error.message}`);
+  }
+  if (value._id && typeof value._id === "string") {
+    try {
+      value._id = new ObjectId48(value._id);
+    } catch (error2) {
+      throw new Error("Invalid _id.");
+    }
+  }
+  if (value.school && typeof value.school === "string") {
+    try {
+      value.school = new ObjectId48(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
+import {
+  AppError as AppError31,
+  BadRequestError as BadRequestError81,
+  InternalServerError as InternalServerError26,
+  logger as logger45,
+  makeCacheKey as makeCacheKey26,
+  paginate as paginate25,
+  useAtlas as useAtlas38,
+  useCache as useCache26
+} from "@eeplatform/nodejs-utils";
+import { ObjectId as ObjectId49 } from "mongodb";
+function useTrackRepo() {
+  const db = useAtlas38.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 } = useCache26(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(() => {
+      logger45.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      logger45.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) {
+      logger45.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof AppError31) {
+        throw error;
+      } else {
+        const isDuplicated = error.message.includes("duplicate");
+        if (isDuplicated) {
+          throw new BadRequestError81("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 ObjectId49(school);
+      } catch (error) {
+        throw new BadRequestError81("Invalid school ID.");
+      }
+      cacheKeyOptions.school = school;
+    }
+    const cacheKey = makeCacheKey26(namespace_collection, cacheKeyOptions);
+    logger45.log({
+      level: "info",
+      message: `Cache key for getAll tracks: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        logger45.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 = paginate25(items, total, page, limit);
+      setCache(cacheKey, result, 300).then(() => {
+        logger45.log({
+          level: "info",
+          message: `Cache set for getAll tracks: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger45.log({
+          level: "error",
+          message: `Failed to set cache for getAll tracks: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof AppError31) {
+        throw error;
+      } else {
+        throw new InternalServerError26("Failed to get tracks.");
+      }
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new ObjectId49(_id);
+    } catch (error) {
+      throw new BadRequestError81(namespace_collection + " Invalid ID.");
+    }
+    const cacheKey = makeCacheKey26(namespace_collection, {
+      _id: _id.toString()
+    });
+    logger45.log({
+      level: "info",
+      message: `Cache key for getById track: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        logger45.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 BadRequestError81("track not found.");
+      }
+      setCache(cacheKey, result, 300).then(() => {
+        logger45.log({
+          level: "info",
+          message: `Cache set for getById track: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger45.log({
+          level: "error",
+          message: `Failed to set cache for getById track: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof AppError31) {
+        throw error;
+      } else {
+        throw new InternalServerError26("Failed to get track.");
+      }
+    }
+  }
+  async function getBySchool(school) {
+    try {
+      school = new ObjectId49(school);
+    } catch (error) {
+      throw new BadRequestError81("Invalid school ID.");
+    }
+    const cacheKey = makeCacheKey26(namespace_collection, {
+      school: school.toString()
+    });
+    logger45.log({
+      level: "info",
+      message: `Cache key for track by school: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        logger45.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(() => {
+        logger45.log({
+          level: "info",
+          message: `Cache set for track by school: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger45.log({
+          level: "error",
+          message: `Failed to set cache for track by school: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof AppError31) {
+        throw error;
+      } else {
+        throw new InternalServerError26("Failed to get track.");
+      }
+    }
+  }
+  async function updateFieldById({ _id, field, value } = {}, session) {
+    const allowedFields = ["title", "status"];
+    if (!allowedFields.includes(field)) {
+      throw new BadRequestError81(
+        `Field "${field}" is not allowed to be updated.`
+      );
+    }
+    try {
+      _id = new ObjectId49(_id);
+    } catch (error) {
+      throw new BadRequestError81(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 InternalServerError26(`Failed to update track ${field}.`);
+    }
+  }
+  async function updateById(_id, value, session) {
+    const { error } = schemaTrack.validate(value);
+    if (error) {
+      throw new BadRequestError81(`Invalid track data: ${error.message}`);
+    }
+    try {
+      _id = new ObjectId49(_id);
+    } catch (error2) {
+      throw new BadRequestError81(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 InternalServerError26("Failed to update track.");
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new ObjectId49(_id);
+    } catch (error) {
+      throw new BadRequestError81(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 InternalServerError26("Failed to delete track.");
+    }
+  }
+  return {
+    createIndexes,
+    add,
+    getAll,
+    getById,
+    getBySchool,
+    updateFieldById,
+    updateById,
+    deleteById
+  };
+}
+
+// src/resources/track/track.service.ts
+import { AppError as AppError33, BadRequestError as BadRequestError84, useAtlas as useAtlas40 } from "@eeplatform/nodejs-utils";
+
+// src/resources/strand/strand.repository.ts
+import {
+  AppError as AppError32,
+  BadRequestError as BadRequestError83,
+  InternalServerError as InternalServerError27,
+  logger as logger46,
+  makeCacheKey as makeCacheKey27,
+  paginate as paginate26,
+  useAtlas as useAtlas39,
+  useCache as useCache27
+} from "@eeplatform/nodejs-utils";
+
+// src/resources/strand/strand.model.ts
+import { BadRequestError as BadRequestError82 } from "@eeplatform/nodejs-utils";
+import Joi53 from "joi";
+import { ObjectId as ObjectId50 } from "mongodb";
+var schemaStrand = Joi53.object({
+  track: Joi53.string().hex().required(),
+  trackName: Joi53.string().max(100).optional().allow(null, ""),
+  name: Joi53.string().max(100).required(),
+  school: Joi53.string().hex().required()
+});
+function modelStrand(value) {
+  const { error } = schemaStrand.validate(value);
+  if (error) {
+    throw new BadRequestError82(`Invalid strand data: ${error.message}`);
+  }
+  if (value._id && typeof value._id === "string") {
+    try {
+      value._id = new ObjectId50(value._id);
+    } catch (error2) {
+      throw new Error("Invalid _id.");
+    }
+  }
+  if (value.school && typeof value.school === "string") {
+    try {
+      value.school = new ObjectId50(value.school);
+    } catch (error2) {
+      throw new Error("Invalid school.");
+    }
+  }
+  if (value.track && typeof value.track === "string") {
+    try {
+      value.track = new ObjectId50(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
+import { ObjectId as ObjectId51 } from "mongodb";
+function useStrandRepo() {
+  const db = useAtlas39.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 } = useCache27(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(() => {
+      logger46.log({
+        level: "info",
+        message: `Cache namespace cleared for ${namespace_collection}`
+      });
+    }).catch((err) => {
+      logger46.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) {
+      logger46.log({
+        level: "error",
+        message: error.message
+      });
+      if (error instanceof AppError32) {
+        throw error;
+      } else {
+        const isDuplicated = error.message.includes("duplicate");
+        if (isDuplicated) {
+          throw new BadRequestError83("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 ObjectId51(school);
+      } catch (error) {
+        throw new BadRequestError83("Invalid school ID.");
+      }
+      cacheKeyOptions.school = school;
+    }
+    const cacheKey = makeCacheKey27(namespace_collection, cacheKeyOptions);
+    logger46.log({
+      level: "info",
+      message: `Cache key for getAll strands: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        logger46.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 = paginate26(items, total, page, limit);
+      setCache(cacheKey, result, 300).then(() => {
+        logger46.log({
+          level: "info",
+          message: `Cache set for getAll strands: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger46.log({
+          level: "error",
+          message: `Failed to set cache for getAll strands: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof AppError32) {
+        throw error;
+      } else {
+        throw new InternalServerError27("Failed to get strands.");
+      }
+    }
+  }
+  async function getById(_id) {
+    try {
+      _id = new ObjectId51(_id);
+    } catch (error) {
+      throw new BadRequestError83(namespace_collection + " Invalid ID.");
+    }
+    const cacheKey = makeCacheKey27(namespace_collection, {
+      _id: _id.toString()
+    });
+    logger46.log({
+      level: "info",
+      message: `Cache key for getById strand: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        logger46.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 BadRequestError83("strand not found.");
+      }
+      setCache(cacheKey, result, 300).then(() => {
+        logger46.log({
+          level: "info",
+          message: `Cache set for getById strand: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger46.log({
+          level: "error",
+          message: `Failed to set cache for getById strand: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof AppError32) {
+        throw error;
+      } else {
+        throw new InternalServerError27("Failed to get strand.");
+      }
+    }
+  }
+  async function getBySchool(school) {
+    try {
+      school = new ObjectId51(school);
+    } catch (error) {
+      throw new BadRequestError83("Invalid school ID.");
+    }
+    const cacheKey = makeCacheKey27(namespace_collection, {
+      school: school.toString()
+    });
+    logger46.log({
+      level: "info",
+      message: `Cache key for strand by school: ${cacheKey}`
+    });
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        logger46.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(() => {
+        logger46.log({
+          level: "info",
+          message: `Cache set for strand by school: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger46.log({
+          level: "error",
+          message: `Failed to set cache for strand by school: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof AppError32) {
+        throw error;
+      } else {
+        throw new InternalServerError27("Failed to get strand.");
+      }
+    }
+  }
+  async function updateFieldById({ _id, field, value } = {}, session) {
+    const allowedFields = ["title", "status"];
+    if (!allowedFields.includes(field)) {
+      throw new BadRequestError83(
+        `Field "${field}" is not allowed to be updated.`
+      );
+    }
+    try {
+      _id = new ObjectId51(_id);
+    } catch (error) {
+      throw new BadRequestError83(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 InternalServerError27(`Failed to update strand ${field}.`);
+    }
+  }
+  async function updateById(_id, value, session) {
+    const { error } = schemaStrand.validate(value);
+    if (error) {
+      throw new BadRequestError83(`Invalid strand data: ${error.message}`);
+    }
+    try {
+      _id = new ObjectId51(_id);
+    } catch (error2) {
+      throw new BadRequestError83(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 InternalServerError27("Failed to update strand.");
+    }
+  }
+  async function deleteById(_id, session) {
+    try {
+      _id = new ObjectId51(_id);
+    } catch (error) {
+      throw new BadRequestError83(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 InternalServerError27("Failed to delete strand.");
+    }
+  }
+  async function countByTrack(track) {
+    const query = { status: { $ne: "deleted" } };
+    const cacheKeyOptions = { tag: "countByTrack" };
+    try {
+      query.track = new ObjectId51(track);
+      cacheKeyOptions.track = track;
+    } catch (error) {
+      throw new BadRequestError83("Invalid track ID.");
+    }
+    const cacheKey = makeCacheKey27(namespace_collection, cacheKeyOptions);
+    try {
+      const cached = await getCache(cacheKey);
+      if (cached) {
+        logger46.log({
+          level: "info",
+          message: `Cache hit for getById strand: ${cacheKey}`
+        });
+        return cached;
+      }
+      const result = await collection.countDocuments(query);
+      setCache(cacheKey, result, 300).then(() => {
+        logger46.log({
+          level: "info",
+          message: `Cache set for strand by id: ${cacheKey}`
+        });
+      }).catch((err) => {
+        logger46.log({
+          level: "error",
+          message: `Failed to set cache for strand by id: ${err.message}`
+        });
+      });
+      return result;
+    } catch (error) {
+      if (error instanceof AppError32) {
+        throw error;
+      } else {
+        throw new InternalServerError27("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 = useAtlas40.getClient()?.startSession();
+    if (!session) {
+      throw new Error("Failed to start database session.");
+    }
+    try {
+      session.startTransaction();
+      const track = await getById(id);
+      if (!track) {
+        throw new BadRequestError84("track not found.");
+      }
+      const usageCount = await countByTrack(id);
+      if (usageCount > 0) {
+        throw new BadRequestError84(
+          "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 AppError33) {
+        throw error;
+      } else {
+        throw new AppError33("Failed to delete track.", 500);
+      }
+    } finally {
+      await session.endSession();
+    }
+  }
+  return {
+    deleteById
+  };
+}
+
+// src/resources/track/track.controller.ts
+import { BadRequestError as BadRequestError85 } from "@eeplatform/nodejs-utils";
+import Joi54 from "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 BadRequestError85(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 = Joi54.object({
+      page: Joi54.number().min(1).optional().allow("", null),
+      limit: Joi54.number().min(1).optional().allow("", null),
+      search: Joi54.string().optional().allow("", null),
+      status: Joi54.string().optional().allow("", null),
+      school: Joi54.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 BadRequestError85("Invalid page number."));
+      return;
+    }
+    const isLimitNumber = isFinite(limit);
+    if (!isLimitNumber) {
+      next(new BadRequestError85("Invalid limit number."));
+      return;
+    }
+    if (error) {
+      next(new BadRequestError85(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 = Joi54.object({
+      id: Joi54.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new BadRequestError85(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 = Joi54.object({
+      school: Joi54.string().hex().required()
+    });
+    const { error } = validation.validate({ school });
+    if (error) {
+      next(new BadRequestError85(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 = Joi54.object({
+      _id: Joi54.string().hex().required(),
+      field: Joi54.string().valid("name").required(),
+      value: Joi54.alternatives().try(Joi54.string(), Joi54.array(), Joi54.object()).required()
+    });
+    const { error } = validation.validate({ _id, field, value });
+    if (error) {
+      next(new BadRequestError85(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 = Joi54.object({
+      id: Joi54.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new BadRequestError85(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
+import { BadRequestError as BadRequestError86 } from "@eeplatform/nodejs-utils";
+import Joi55 from "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 BadRequestError86(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 = Joi55.object({
+      page: Joi55.number().min(1).optional().allow("", null),
+      limit: Joi55.number().min(1).optional().allow("", null),
+      search: Joi55.string().optional().allow("", null),
+      status: Joi55.string().optional().allow("", null),
+      school: Joi55.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 BadRequestError86("Invalid page number."));
+      return;
+    }
+    const isLimitNumber = isFinite(limit);
+    if (!isLimitNumber) {
+      next(new BadRequestError86("Invalid limit number."));
+      return;
+    }
+    if (error) {
+      next(new BadRequestError86(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 = Joi55.object({
+      id: Joi55.string().hex().required()
+    });
+    const { error } = validation.validate({ id });
+    if (error) {
+      next(new BadRequestError86(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 = Joi55.object({
+      school: Joi55.string().hex().required()
+    });
+    const { error } = validation.validate({ school });
+    if (error) {
+      next(new BadRequestError86(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 = Joi55.object({
+      _id: Joi55.string().hex().required(),
+      field: Joi55.string().valid("title", "status").required(),
+      value: Joi55.alternatives().try(Joi55.string(), Joi55.array(), Joi55.object()).required()
+    });
+    const { error } = validation.validate({ _id, field, value });
+    if (error) {
+      next(new BadRequestError86(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 = Joi55.object({
+      _id: Joi55.string().hex().required()
+    });
+    const { error } = validation.validate({ _id });
+    if (error) {
+      next(new BadRequestError86(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
 import * as dotenv from "dotenv";
 dotenv.config();
@@ -46195,9 +47309,11 @@ export {
   modelSectionPreset,
   modelSectionStudent,
   modelSectionSubject,
+  modelStrand,
   modelSubject,
   modelTeachingLoad,
   modelTeachingLoadSlot,
+  modelTrack,
   schemaAsset,
   schemaAssetUpdateOption,
   schemaBasicEduCount,
@@ -46227,10 +47343,12 @@ export {
   schemaSectionSubject,
   schemaSectionSubjectSetup,
   schemaStockCard,
+  schemaStrand,
   schemaSubject,
   schemaSubjectAdd,
   schemaTeachingLoad,
   schemaTeachingLoadSlot,
+  schemaTrack,
   schemaUpdateOptions,
   schemaUpdateStatus,
   statusesProgramScreening,
@@ -46286,13 +47404,18 @@ export {
   useStockCardController,
   useStockCardRepository,
   useStockCardService,
+  useStrandController,
+  useStrandRepo,
   useSubjectController,
   useSubjectRepo,
   useSubjectService,
   useTeachingLoadController,
   useTeachingLoadRepo,
   useTeachingLoadSlotController,
-  useTeachingLoadSlotRepo
+  useTeachingLoadSlotRepo,
+  useTrackController,
+  useTrackRepo,
+  useTrackService
 };
 /*! Bundled license information: