feat(backend): Add a UserAnalytics with custom range (This is so cool)

Author: omardoescode

analytics/Dockerfile

@@ -0,0 +1,9 @@
+FROM maven:3.9.4-eclipse-temurin-21 AS builder
+WORKDIR /build
+COPY pom.xml .
+COPY src ./src
+RUN mvn -e -DskipTests clean package
+
+FROM flink:1.20.0
+WORKDIR /opt/flink/usrlib
+COPY --from=builder /build/target/*.jar /opt/flink/usrlib/

backend/src/analytics/db.ts

@@ -0,0 +1,22 @@
+import { User } from "@/auth/validation";
+import { PoolClient } from "pg";
+import { UserAnalytics } from "./types";
+import { WindowSchemaType } from "./validation";
+
+const getUserAnalytics = async (
+  client: PoolClient,
+  user_id: User["user_id"],
+  window: WindowSchemaType
+): Promise<UserAnalytics> => {
+  const { count, unit } = window.interval;
+  const interval = `${count} ${unit}`;
+  const data = await client.query({
+    text: `select lang_durations, machine_durations, editor_durations, project_durations, activity_durations from user_analytics_aggregate_period($1, $2, $3::interval)`,
+    values: [user_id, window.start, interval],
+  });
+  console.log(data.rows[0]);
+  return data.rows[0];
+};
+const db = { getUserAnalytics };
+
+export default db;

backend/src/analytics/service.ts

@@ -0,0 +1,21 @@
+import { User } from "@/auth/validation";
+import pool from "@/pool";
+import { UserAnalytics } from "./types";
+import { WindowSchemaType } from "./validation";
+import db from "./db";
+
+const getUserAnalytics = async (
+  user_id: User["user_id"],
+  window: WindowSchemaType
+): Promise<UserAnalytics> => {
+  const client = await pool.connect();
+
+  try {
+    const data = await db.getUserAnalytics(client, user_id, window);
+    return data;
+  } finally {
+    client.release();
+  }
+};
+
+export { getUserAnalytics };

backend/src/analytics/types.ts

@@ -0,0 +1,13 @@
+import Prettify from "@/utils/prettify";
+
+type Duration<Key extends string = string> = {
+  [K in Key]: number;
+};
+
+export type UserAnalytics = Prettify<{
+  lang_durations: Duration;
+  project_durations: Duration;
+  editor_durations: Duration;
+  activity_durations: Duration;
+  machine_durations: Duration;
+}>;

backend/src/analytics/validation.ts

@@ -0,0 +1,12 @@
+import { z } from "zod";
+
+export const WindowSchema = z.object({
+  start: z.iso.date().transform((x) => new Date(x)),
+  interval: z.object({
+    unit: z.enum(["day", "week", "month", "year"]),
+    count: z.number().int().positive(),
+  }),
+});
+
+export type WindowSchemaType = z.infer<typeof WindowSchema>;
+export type WindowSchemaInputType = z.input<typeof WindowSchema>;

backend/src/api/middleware.ts

@@ -4,7 +4,7 @@ import { AppResponse, errToResponse } from "@/utils/responses";
 import { getContext } from "@getcronit/pylon";
 import { ApiKey, ApiKeySchema } from "./validation";
 import { getUserByApi } from "./db";
-import { AppError } from "@/utils/error";
+import { AppError, InternalServerError } from "@/utils/error";
 import { InvalidApi } from "./errors";
 import pool from "@/pool";
 
@@ -24,6 +24,11 @@ export function withApi<TArgs extends unknown[], TReturn>(
     client.release();
     if (user instanceof AppError) return errToResponse(user); // NOTE: ! this doens't feel right?
 
-    return await fn(user, parsed.data, ...args);
+    try {
+      return await fn(user, parsed.data, ...args);
+    } catch (err) {
+      console.error(err);
+      return errToResponse(new InternalServerError());
+    }
   };
 }

backend/src/api/service.ts

@@ -46,6 +46,7 @@ const setApiMetadata = async (
   const client = await pool.connect();
   try {
     await client.query("begin transaction");
+    console.log(`setting ${api_key}`);
     const res = await db.setAPIMetadata(
       client,
       api_key,

backend/src/auth/middleware.ts

@@ -3,32 +3,33 @@ import { AppResponse, errToResponse } from "@/utils/responses";
 import { User, UserSchema } from "./validation";
 import { getContext } from "@getcronit/pylon";
 import { InvalidToken, UnauthorizedUser } from "./errors";
+import { InternalServerError } from "@/utils/error";
 
-type Tail<T extends unknown[]> = T extends [unknown, ...infer R] ? R : never;
-
-export function authorized<T>(
-  fn: (user: User, ...args) => Promise<AppResponse<T>>
-) {
-  return async (
-    ...args: Tail<Parameters<typeof fn>>
-  ): Promise<ReturnType<typeof fn>> => {
+export function authorized<TArgs extends unknown[], TReturn>(
+  fn: (user: User, ...args: TArgs) => Promise<AppResponse<TReturn>>
+): (...args: TArgs) => Promise<AppResponse<TReturn>> {
+  return async (...args: TArgs): Promise<AppResponse<TReturn>> => {
     const ctx = getContext();
     const authorization = ctx.req.header("Authorization");
     if (!authorization) return errToResponse(new UnauthorizedUser());
 
-    const sliced = authorization.split(" ");
-    if (sliced.length !== 2 || sliced[0] !== "Bearer")
+    const [scheme, token] = authorization.split(" ");
+    if (scheme !== "Bearer" || !token)
       return errToResponse(new UnauthorizedUser());
 
-    const token = sliced[1];
+    let user: User;
     try {
       const payload = await verifyToken(token);
-      const data = UserSchema.parse(payload);
-      // Spread user into original fn
-      return await fn(data, ...args);
+      user = UserSchema.parse(payload);
+    } catch (_err) {
+      return errToResponse(new InvalidToken());
+    }
+
+    try {
+      return await fn(user, ...args);
     } catch (err) {
       console.error(err);
-      return errToResponse(new InvalidToken());
+      return errToResponse(new InternalServerError());
     }
   };
 }

backend/src/index.ts

@@ -18,10 +18,35 @@ import {
   ProjectSessionSchema,
 } from "./heartbeat/validation";
 import * as heartbeat from "./heartbeat/service";
+import * as analytics from "./analytics/service";
+import {
+  WindowSchema,
+  WindowSchemaInputType,
+  WindowSchemaType,
+} from "./analytics/validation";
+import { UserAnalytics } from "./analytics/types";
 
 export const graphql = {
   Query: {
-    hello: authorized(async (user) => SuccessResponse({ ...user })),
+    UserAnaltyics: authorized(
+      async (
+        user,
+        window: WindowSchemaInputType
+      ): Promise<AppResponse<UserAnalytics>> => {
+        // validate first
+        const parsed_window = WindowSchema.safeParse(window);
+        if (parsed_window.error) {
+          return ErrorResponse(
+            parsed_window.error.issues.map((x) => x.message)
+          );
+        }
+        const data = await analytics.getUserAnalytics(
+          user.user_id,
+          parsed_window.data
+        );
+        return SuccessResponse<UserAnalytics>(data);
+      }
+    ),
   },
   Mutation: {
     async login(

backend/src/utils/error.ts

@@ -23,3 +23,9 @@ export class AppError extends Error {
     Error.captureStackTrace?.(this, this.constructor);
   }
 }
+
+export class InternalServerError extends AppError {
+  constructor() {
+    super("Internal Server Error");
+  }
+}