@speakableio/core 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,36 +1,290 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } }// src/providers/SpeakableProvider.tsx
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/providers/SpeakableProvider.tsx
 var _react = require('react');
 
+// src/utils/error-handler.ts
+var ServiceError = class extends Error {
+  constructor(message, originalError, code) {
+    super(message);
+    this.originalError = originalError;
+    this.code = code;
+    this.name = "ServiceError";
+  }
+};
+function withErrorHandler(fn, serviceName) {
+  return async (...args) => {
+    try {
+      return await fn(...args);
+    } catch (error) {
+      if (error instanceof Error && "code" in error) {
+        const firebaseError = error;
+        throw new ServiceError(
+          `Error in ${serviceName}: ${firebaseError.message}`,
+          error,
+          firebaseError.code
+        );
+      }
+      if (error instanceof Error) {
+        throw new ServiceError(`Error in ${serviceName}: ${error.message}`, error);
+      }
+      throw new ServiceError(`Unknown error in ${serviceName}`, error);
+    }
+  };
+}
+
+// src/lib/firebase/api.ts
+var FirebaseAPI = class _FirebaseAPI {
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  constructor() {
+    this.config = null;
+  }
+  static getInstance() {
+    if (!_FirebaseAPI.instance) {
+      _FirebaseAPI.instance = new _FirebaseAPI();
+    }
+    return _FirebaseAPI.instance;
+  }
+  initialize(config) {
+    this.config = config;
+  }
+  get db() {
+    if (!this.config) throw new Error("FirebaseAPI not initialized");
+    return this.config.db;
+  }
+  get helpers() {
+    if (!this.config) throw new Error("FirebaseAPI not initialized");
+    return this.config.helpers;
+  }
+  accessQueryConstraints() {
+    const { query, orderBy, limit, startAt, startAfter, endAt, endBefore } = this.helpers;
+    return {
+      query,
+      orderBy,
+      limit,
+      startAt,
+      startAfter,
+      endAt,
+      endBefore
+    };
+  }
+  async getDoc(path) {
+    const { getDoc, doc } = this.helpers;
+    const docRef = doc(this.db, path);
+    const docSnap = await getDoc(docRef);
+    return {
+      id: docSnap.id,
+      data: docSnap.exists() ? docSnap.data() : null
+    };
+  }
+  async getDocs(path, ...queryConstraints) {
+    const { getDocs, query, collection } = this.helpers;
+    const collectionRef = collection(this.db, path);
+    const q = queryConstraints.length > 0 ? query(collectionRef, ...queryConstraints) : collectionRef;
+    const querySnapshot = await getDocs(q);
+    const data = querySnapshot.docs.map((doc) => ({
+      id: doc.id,
+      data: doc.data()
+    }));
+    return {
+      data,
+      querySnapshot
+    };
+  }
+  async addDoc(path, data) {
+    const { addDoc, collection } = this.helpers;
+    const collectionRef = collection(this.db, path);
+    const docRef = await addDoc(collectionRef, data);
+    return docRef.id;
+  }
+  async setDoc(path, data) {
+    const { setDoc, doc } = this.helpers;
+    const docRef = doc(this.db, path);
+    await setDoc(docRef, data);
+  }
+  async updateDoc(path, data) {
+    const { updateDoc, doc } = this.helpers;
+    const docRef = doc(this.db, path);
+    await updateDoc(docRef, data);
+  }
+  async deleteDoc(path) {
+    const { deleteDoc, doc } = this.helpers;
+    const docRef = doc(this.db, path);
+    await deleteDoc(docRef);
+  }
+  async runTransaction(updateFunction) {
+    const { runTransaction } = this.helpers;
+    return runTransaction(this.db, updateFunction);
+  }
+  async runBatch(operations) {
+    const { writeBatch } = this.helpers;
+    const batch = writeBatch(this.db);
+    await Promise.all(operations.map((op) => op()));
+    await batch.commit();
+  }
+};
+var api = FirebaseAPI.getInstance();
+
+// src/domains/assignment/assignment.constants.ts
+var ASSIGNMENT_ANALYTICS_TYPES = [
+  "macro" /* Macro */,
+  "gradebook" /* Gradebook */,
+  "cards" /* Cards */,
+  "student" /* Student */,
+  "student_summary" /* StudentSummary */
+];
+var ASSIGNMENTS_COLLECTION = "assignments";
+var ANALYTICS_SUBCOLLECTION = "analytics";
+var SCORES_SUBCOLLECTION = "scores";
+var refsAssignmentFiresotre = {
+  allAssignments: () => ASSIGNMENTS_COLLECTION,
+  assignment: (id) => `${ASSIGNMENTS_COLLECTION}/${id}`,
+  assignmentAllAnalytics: (id) => `${ASSIGNMENTS_COLLECTION}/${id}/${ANALYTICS_SUBCOLLECTION}`,
+  assignmentAnalytics: (id, type) => `${ASSIGNMENTS_COLLECTION}/${id}/${ANALYTICS_SUBCOLLECTION}/${type}`,
+  assignmentScores: (id, userId) => `${ASSIGNMENTS_COLLECTION}/${id}/${SCORES_SUBCOLLECTION}/${userId}`
+};
+
+// src/domains/assignment/services/get-assignments-score.service.ts
+var _getAssignmentScores = async ({
+  assignmentId,
+  analyticType = "macro" /* Macro */,
+  studentId,
+  currentUserId
+}) => {
+  if (analyticType === "student" /* Student */) {
+    const path = refsAssignmentFiresotre.assignmentScores(assignmentId, currentUserId);
+    const response = await api.getDoc(path);
+    return { scores: response.data, id: assignmentId };
+  }
+  if (analyticType === "student_summary" /* StudentSummary */ && studentId) {
+    const path = refsAssignmentFiresotre.assignmentScores(assignmentId, studentId);
+    const response = await api.getDoc(path);
+    return { scores: response.data, id: assignmentId };
+  }
+  if (analyticType !== "all" /* All */ && ASSIGNMENT_ANALYTICS_TYPES.includes(analyticType)) {
+    const ref = refsAssignmentFiresotre.assignmentAnalytics(assignmentId, analyticType);
+    const docData = await api.getDoc(ref);
+    return { scores: docData.data, id: assignmentId };
+  } else if (analyticType === "all" /* All */) {
+    const ref = refsAssignmentFiresotre.assignmentAllAnalytics(assignmentId);
+    const response = await api.getDocs(ref);
+    const data = response.data.reduce((acc, curr) => {
+      acc[curr.id] = curr;
+      return acc;
+    }, {});
+    return { scores: data, id: assignmentId };
+  }
+};
+var getAssignmentScores = withErrorHandler(_getAssignmentScores, "getAssignmentScores");
+
+// src/domains/assignment/services/attach-score-assignment.service.ts
+var _attachScoresAssignment = async ({
+  assignments,
+  analyticType,
+  studentId,
+  currentUserId
+}) => {
+  const scoresPromises = assignments.map((a) => {
+    return getAssignmentScores({
+      assignmentId: a.id,
+      analyticType,
+      studentId,
+      currentUserId
+    });
+  });
+  const scores = await Promise.all(scoresPromises);
+  const scoresObject = scores.reduce((acc, curr) => {
+    acc[curr.id] = curr.scores;
+    return acc;
+  }, {});
+  const assignmentsWithScores = assignments.map((a) => {
+    return {
+      ...a,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      scores: _nullishCoalesce(scoresObject[a.id], () => ( null))
+    };
+  });
+  return assignmentsWithScores;
+};
+var attachScoresAssignment = withErrorHandler(
+  _attachScoresAssignment,
+  "attachScoresAssignment"
+);
+
+// src/domains/assignment/services/get-all-assignment.service.ts
+async function _getAllAssignments() {
+  const path = refsAssignmentFiresotre.allAssignments();
+  const response = await api.getDocs(path);
+  return response.data;
+}
+var getAllAssignments = withErrorHandler(_getAllAssignments, "getAllAssignments");
+
+// src/domains/assignment/utils/check-assignment-availability.ts
+var _dayjs = require('dayjs'); var _dayjs2 = _interopRequireDefault(_dayjs);
+var checkAssignmentAvailability = (scheduledTime) => {
+  if (!scheduledTime) return true;
+  const scheduledDate = typeof scheduledTime === "string" ? _dayjs2.default.call(void 0, scheduledTime) : _dayjs2.default.call(void 0, scheduledTime.toDate());
+  if (!scheduledDate.isValid()) return true;
+  return _dayjs2.default.call(void 0, ).isAfter(scheduledDate);
+};
+
+// src/domains/assignment/services/get-assignment.service.ts
+async function _getAssignment(params) {
+  const path = refsAssignmentFiresotre.assignment(params.assignmentId);
+  const response = await api.getDoc(path);
+  if (!response.data) return null;
+  const assignment = response.data;
+  const isAvailable = checkAssignmentAvailability(assignment.scheduledTime);
+  const assignmentWithId = {
+    ...assignment,
+    isAvailable,
+    id: params.assignmentId,
+    scheduledTime: _nullishCoalesce(assignment.scheduledTime, () => ( null))
+  };
+  if (params.analyticType) {
+    const assignmentsWithScores = await attachScoresAssignment({
+      assignments: [assignmentWithId],
+      analyticType: params.analyticType,
+      currentUserId: params.currentUserId
+    });
+    return assignmentsWithScores.length > 0 ? assignmentsWithScores[0] : assignmentWithId;
+  }
+  return assignmentWithId;
+}
+var getAssignment = withErrorHandler(_getAssignment, "getAssignment");
+
 // src/domains/assignment/assignment.repo.ts
-var createAssignmentRepo = (db, h) => {
-  const { doc, collection, getDoc, getDocs } = h;
+var createAssignmentRepo = () => {
   return {
-    async get(id) {
-      const snap = await getDoc(doc(db, `assignments/${id}`));
-      if (!snap.exists()) return null;
-      const data = snap.data();
-      return { id, ...data };
-    },
-    async list() {
-      const col = collection(db, "assignments");
-      const snap = await getDocs(col);
-      return snap.docs.map((d) => ({ id: d.id, ...d.data() }));
-    }
+    getAssignment,
+    attachScoresAssignment,
+    getAssignmentScores,
+    getAllAssignments
   };
 };
 
-// src/domains/assignment/hooks.ts
+// src/domains/assignment/assignment.hooks.ts
 var _reactquery = require('@tanstack/react-query');
 var assignmentQueryKeys = {
   all: ["assignments"],
   byId: (id) => [...assignmentQueryKeys.all, id],
   list: () => [...assignmentQueryKeys.all, "list"]
 };
-function useAssignment(id) {
-  const { fs } = useFs();
+function useAssignment({
+  assignmentId,
+  enabled = true,
+  analyticType,
+  userId
+}) {
+  const { speakableApi } = useSpeakableApi();
   return _reactquery.useQuery.call(void 0, {
-    queryKey: assignmentQueryKeys.byId(id),
-    queryFn: () => fs.assignmentRepo.get(id)
+    queryKey: assignmentQueryKeys.byId(assignmentId),
+    queryFn: () => speakableApi.assignmentRepo.getAssignment({
+      assignmentId,
+      analyticType,
+      currentUserId: userId
+    }),
+    enabled
   });
 }
 
@@ -38,8 +292,12 @@ function useAssignment(id) {
 async function createFsClient(db, platform) {
   const dbAsFirestore = db;
   const helpers = platform === "web" ? await Promise.resolve().then(() => _interopRequireWildcard(require("firebase/firestore"))) : await Promise.resolve().then(() => _interopRequireWildcard(require("@react-native-firebase/firestore")));
+  api.initialize({
+    db: dbAsFirestore,
+    helpers
+  });
   return {
-    assignmentRepo: createAssignmentRepo(dbAsFirestore, helpers)
+    assignmentRepo: createAssignmentRepo()
   };
 }
 
@@ -52,27 +310,27 @@ function SpeakableProvider({
   children,
   queryClient
 }) {
-  const [fs, setFs] = _react.useState.call(void 0, null);
+  const [speakableApi, setSpeakableApi] = _react.useState.call(void 0, null);
   _react.useEffect.call(void 0, () => {
     createFsClient(db, platform).then((repos) => {
-      setFs(repos);
+      setSpeakableApi(repos);
     });
   }, [db, platform]);
-  if (!fs) return null;
+  if (!speakableApi) return null;
   return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, 
     FsCtx.Provider,
     {
       value: {
-        fs,
+        speakableApi,
         queryClient
       },
       children
     }
   );
 }
-function useFs() {
+function useSpeakableApi() {
   const ctx = _react.useContext.call(void 0, FsCtx);
-  if (!ctx) throw new Error("useFs must be used within a SpeakableProvider");
+  if (!ctx) throw new Error("useSpeakableApi must be used within a SpeakableProvider");
   return ctx;
 }
 
@@ -83,4 +341,4 @@ function useFs() {
 
 
 
-exports.FsCtx = FsCtx; exports.SpeakableProvider = SpeakableProvider; exports.assignmentQueryKeys = assignmentQueryKeys; exports.createAssignmentRepo = createAssignmentRepo; exports.createFsClient = createFsClient; exports.useAssignment = useAssignment; exports.useFs = useFs;
+exports.FsCtx = FsCtx; exports.SpeakableProvider = SpeakableProvider; exports.assignmentQueryKeys = assignmentQueryKeys; exports.createAssignmentRepo = createAssignmentRepo; exports.createFsClient = createFsClient; exports.useAssignment = useAssignment; exports.useSpeakableApi = useSpeakableApi;