@speakableio/core 0.1.0 → 0.1.2

package/dist/index.mjs

@@ -1,36 +1,290 @@
 // src/providers/SpeakableProvider.tsx
 import { createContext, useContext, useEffect, useState } from "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: 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
+import dayjs from "dayjs";
+var checkAssignmentAvailability = (scheduledTime) => {
+  if (!scheduledTime) return true;
+  const scheduledDate = typeof scheduledTime === "string" ? dayjs(scheduledTime) : dayjs(scheduledTime.toDate());
+  if (!scheduledDate.isValid()) return true;
+  return dayjs().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: 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
 import { useQuery } from "@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 useQuery({
-    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 import("firebase/firestore") : await import("@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] = useState(null);
+  const [speakableApi, setSpeakableApi] = useState(null);
   useEffect(() => {
     createFsClient(db, platform).then((repos) => {
-      setFs(repos);
+      setSpeakableApi(repos);
     });
   }, [db, platform]);
-  if (!fs) return null;
+  if (!speakableApi) return null;
   return /* @__PURE__ */ jsx(
     FsCtx.Provider,
     {
       value: {
-        fs,
+        speakableApi,
         queryClient
       },
       children
     }
   );
 }
-function useFs() {
+function useSpeakableApi() {
   const ctx = useContext(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;
 }
 export {
@@ -82,5 +340,5 @@ export {
   createAssignmentRepo,
   createFsClient,
   useAssignment,
-  useFs
+  useSpeakableApi
 };

package/package.json

@@ -1,12 +1,18 @@
 {
   "name": "@speakableio/core",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Speakable-io/speakable-core.git"
   },
-  "main": "dist/index.cjs",
-  "module": "dist/index.js",
+  "scripts": {
+    "build": "tsup src/index.ts --dts --format esm,cjs --splitting",
+    "dev": "tsup src/index.ts --watch --dts --format esm,cjs --out-dir dist",
+    "test": "vitest"
+  },
+  "react-native": "dist/index.js",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
   "devDependencies": {
     "react": "^18.2.0",
     "@types/react": "^18",
@@ -36,22 +42,26 @@
     "@tanstack/react-query": "^5.54.1"
   },
   "exports": {
-    ".": "./dist/index.js"
+    ".": {
+      "react-native": "./dist/index.js",
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs"
+    }
   },
   "bugs": {
     "url": "https://github.com/Speakable-io/speakable-core/issues"
   },
   "description": "Shared data layer for Speakable web & mobile",
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "homepage": "https://github.com/Speakable-io/speakable-core#readme",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "restricted"
   },
-  "scripts": {
-    "build": "tsup src/index.ts --dts --format esm,cjs --splitting",
-    "dev":   "tsup src/index.ts --watch --dts --format esm,cjs --out-dir dist",
-    "test": "vitest"
-  },  
-  "types": "dist/index.d.ts"
+  "types": "dist/index.d.ts",
+  "dependencies": {
+    "dayjs": "^1.11.13"
+  }
 }