@aurora-interactive/sensei-productivity 1.8.0 → 1.9.0

package/rest-api/index.js

@@ -1,8 +1,11 @@
-import Fastify from 'fastify';
-import oasFastify from '@aurora-interactive/oas-fastify';
-import { prisma } from './lib/prisma.js';
-import { load as yamlLoad } from 'js-yaml';
-import { readFileSync } from 'node:fs';
+import Fastify from "fastify";
+import oasFastify from "@aurora-interactive/oas-fastify";
+import { prisma } from "./lib/prisma.js";
+import { load as yamlLoad } from "js-yaml";
+import { readFileSync } from "node:fs";
+import { createServer } from "node:http";
+import { Server } from "socket.io";
+import express from "express";
 
 import * as UserFuctions from "./routes/UserFunctions.js";
 import * as SchoolFunctions from "./routes/SchoolFunctions.js";
@@ -14,7 +17,11 @@ import * as FriendFunctions from "./routes/FriendFunctions.js";
 const spec = yamlLoad(readFileSync("./api-spec.yaml"));
 
 // workaround for fastify spec -> route registrar
-spec.$id = '$';
+spec.$id = "$";
+
+const app = express();
+const server = createServer(app);
+const io = new Server(server);
 
 const fastify = Fastify({
   logger: false
@@ -29,6 +36,7 @@ const handler = {
   deleteUser: UserFuctions.deleteUserHandler,
   listSchools: SchoolFunctions.listSchoolsHandler,
   getSchoolById: SchoolFunctions.getSchoolByIdHandler,
+  getTopSchools: SchoolFunctions.getTopSchoolsHandler,
   listCategories: CategoryFunctions.listCategoriesHandler,
   createCategory: CategoryFunctions.createCategoryHandler,
   updateCategory: CategoryFunctions.updateCategoryHandler,
@@ -58,6 +66,26 @@ fastify.register(oasFastify, { spec, handler });
 
 fastify.prisma = prisma;
 
+io.on('connection', (socket) => {
+  socket.send("Hey! You are now receiving real-time messaging events for Sensei Productivity. Glad to have you in :P");
+
+  socket.on("loginAs", username => {
+    if (typeof username !== "string") {
+      socket.send("The username which was provided is not a string");
+      return;
+    }
+
+    socket.join(username);
+    socket.send(`Successfully logged in as ${username}`);
+  })
+});
+
+server.listen(7654, "0.0.0.0", () => {
+  console.log('Websocket messaging running at http://0.0.0.0:7654');
+});
+
+fastify.socketio = io;
+
 try {
   await fastify.listen({ host: "0.0.0.0", port: 3000 })
 } catch (err) {

package/rest-api/lib/users.js

@@ -32,4 +32,41 @@ export async function areUsersFriends(prisma, userId, targetPotentialFriendId) {
     }
 
     return true;
+}
+
+export async function friendsOfUserById(prisma, userId) {
+    return await prisma.Friend_Requests.findMany({
+        where: {
+            OR: [
+                { initiator_user_id: userId, status: "accepted" },
+                { target_user_id: userId, status: "accepted" }
+            ]
+        },
+        select: {
+            users_Friend_Requests_initiator_user_idTousers: {
+                select: {
+                    user_id: true,
+                    first_name: true,
+                    last_name: true,
+                    username: true,
+                    email: true,
+                    school: {
+                        select: { school_id: true, school_name: true }
+                    }
+                }
+            },
+            users_Friend_Requests_target_user_idTousers: {
+                select: {
+                    user_id: true,
+                    first_name: true,
+                    last_name: true,
+                    username: true,
+                    email: true,
+                    school: {
+                        select: { school_id: true, school_name: true }
+                    }
+                }
+            }
+        }
+    });
 }

package/rest-api/routes/ActivityPostFunctions.js

@@ -39,6 +39,7 @@ export async function getUserPostsHandler(request, reply, fastify) {
             user_id: true
         }
     });
+
     if (targetExistsCheck === null) {
         reply.status(404);
         return;
@@ -160,7 +161,7 @@ export async function getFeedHandler(request, reply, fastify) {
         categoryName: post.Category.category_name,
         activityId: post.User_Activity.activity_id,
         likes: await getLikesForPost(post.post_id, fastify.prisma),
-        likedByCurrentUser: userHasAlreadyLikedPost(post.post_id, userInfo.user_id, fastify.prisma)
+        likedByCurrentUser: await userHasAlreadyLikedPost(post.post_id, userInfo.user_id, fastify.prisma)
     })));
 }
 
@@ -209,7 +210,7 @@ export async function getPostByIdHandler(request, reply, fastify) {
         postStatus: post.post_status,
         caption: post.caption,
         likes: await getLikesForPost(post.post_id, fastify.prisma),
-        likedByCurrentUser: userHasAlreadyLikedPost(post.post_id, userInfo.user_id, fastify.prisma)
+        likedByCurrentUser: await userHasAlreadyLikedPost(post.post_id, userInfo.user_id, fastify.prisma)
     };
 }
 

package/rest-api/routes/FriendFunctions.js

@@ -1,4 +1,4 @@
-import { getUserAuthInfo, areUsersFriends } from "../lib/users.js";
+import { getUserAuthInfo, areUsersFriends, friendsOfUserById } from "../lib/users.js";
 
 export async function listFriendsHandler(request, reply, fastify) {
     const accessToken = (request.headers.authorization ?? "").substring(7);
@@ -22,40 +22,7 @@ export async function listFriendsHandler(request, reply, fastify) {
         return;
     }
 
-    const friendsList = await fastify.prisma.Friend_Requests.findMany({
-        where: {
-            OR: [
-                { initiator_user_id: request.params.id, status: "accepted" },
-                { target_user_id: request.params.id, status: "accepted" }
-            ]
-        },
-        select: {
-            users_Friend_Requests_initiator_user_idTousers: {
-                select: {
-                    user_id: true,
-                    first_name: true,
-                    last_name: true,
-                    username: true,
-                    email: true,
-                    school: {
-                        select: { school_id: true, school_name: true }
-                    }
-                }
-            },
-            users_Friend_Requests_target_user_idTousers: {
-                select: {
-                    user_id: true,
-                    first_name: true,
-                    last_name: true,
-                    username: true,
-                    email: true,
-                    school: {
-                        select: { school_id: true, school_name: true }
-                    }
-                }
-            }
-        }
-    });
+    const friendsList = await friendsOfUserById(fastify.prisma, request.params.id);
 
     return friendsList.map(friendEntry => {
         // determine which side of the relationship is the friend (not the current user)

package/rest-api/routes/SchoolFunctions.js

@@ -48,4 +48,54 @@ export async function getSchoolByIdHandler(request, reply, fastify) {
         schoolNameShorthand: school.school_name_shorthand,
         userCount: school._count.users
     };
+}
+
+// authored with help from Claude
+export async function getTopSchoolsHandler(request, reply, fastify) {
+    if (typeof request.headers.authorization !== "string") {
+        reply.status(401);
+        return;
+    }
+    const accessToken = request.headers.authorization.substring(7);
+    const user = await fastify.prisma.users.findFirst({
+        select: { user_id: true },
+        where: { access_token: accessToken }
+    });
+    if (user === null) {
+        reply.status(401);
+        return;
+    }
+
+    const limit = request.query.limit ?? 10;
+
+    const schools = await fastify.prisma.school.findMany({
+        select: {
+            school_name: true,
+            school_name_shorthand: true,
+            users: {
+                select: {
+                    User_Activity_Posts: {
+                        select: {
+                            Category: {
+                                select: { category_weight: true }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        take: limit
+    });
+
+    const ranked = schools.map(school => {
+        const points = school.users.flatMap(u => u.User_Activity_Posts)
+            .reduce((sum, post) => sum + post.Category.category_weight, 0);
+        return {
+            schoolName: school.school_name,
+            schoolNameShorthand: school.school_name_shorthand,
+            points
+        };
+    }).sort((a, b) => b.points - a.points);
+
+    return ranked;
 }

package/rest-api/routes/UserActivityFunctions.js

@@ -1,4 +1,4 @@
-import { getUserAuthInfo, areUsersFriends } from "../lib/users.js";
+import { getUserAuthInfo, areUsersFriends, friendsOfUserById } from "../lib/users.js";
 
 export async function getUserActivitiesHandler(request, reply, fastify) {
     const accessToken = (request.headers.authorization ?? "").substring(7);
@@ -205,6 +205,31 @@ export async function updateActivityHandler(request, reply, fastify) {
         return;
     }
 
+    if (currentActivity.activity_status === "active" && request.body.activityStatus === "completed") {
+        await fastify.prisma.User_Activity_Posts.create({
+            data: {
+                post_status: "public",
+                caption: currentActivity.details,
+                users: {
+                    connect: { user_id: userInfo.user_id }
+                },
+                Category: {
+                    connect: { category_name: currentActivity.category_name }
+                },
+                User_Activity: {
+                    connect: { activity_id: request.params.id }
+                }
+            }
+        });
+
+        currentActivity.user_id = Number(currentActivity.user_id);
+        const friends = await friendsOfUserById(fastify.prisma, userInfo.user_id);
+        for (const friendObj of friends) {
+            const friend = (friendObj.users_Friend_Requests_initiator_user_idTousers.user_id === userInfo.user_id ? friendObj.users_Friend_Requests_target_user_idTousers : friendObj.users_Friend_Requests_initiator_user_idTousers).username;
+            fastify.socketio.to(friend).emit("userPost", currentActivity); // instantly propagate the post to all the user's friend for the post feed
+        }
+    }
+
     const targetActivityStatus = request.body.activityStatus ?? currentActivity.activity_status;
     const targetActivityDeadline = request.body.activityDeadline ?? currentActivity.activity_deadline;
     const targetDetails = request.body.details ?? currentActivity.details;

package/src/funcs/schools-leaderboard.ts

@@ -0,0 +1,184 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { SenseiProductivityCore } from "../core.js";
+import { encodeFormQuery } from "../lib/encodings.js";
+import * as M from "../lib/matchers.js";
+import { compactMap } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { RequestOptions } from "../lib/sdks.js";
+import { extractSecurity, resolveGlobalSecurity } from "../lib/security.js";
+import { pathToFunc } from "../lib/url.js";
+import {
+  ConnectionError,
+  InvalidRequestError,
+  RequestAbortedError,
+  RequestTimeoutError,
+  UnexpectedClientError,
+} from "../models/errors/http-client-errors.js";
+import { ResponseValidationError } from "../models/errors/response-validation-error.js";
+import { SDKValidationError } from "../models/errors/sdk-validation-error.js";
+import { SenseiProductivityError } from "../models/errors/sensei-productivity-error.js";
+import * as operations from "../models/operations/index.js";
+import { APICall, APIPromise } from "../types/async.js";
+import { Result } from "../types/fp.js";
+import * as types$ from "../types/primitives.js";
+
+/**
+ * Get the top 10 schools (by points) in order
+ */
+export function schoolsLeaderboard(
+  client: SenseiProductivityCore,
+  request?: operations.GetTopSchoolsRequest | undefined,
+  options?: RequestOptions,
+): APIPromise<
+  Result<
+    Array<operations.GetTopSchoolsResponse> | undefined,
+    | SenseiProductivityError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >
+> {
+  return new APIPromise($do(
+    client,
+    request,
+    options,
+  ));
+}
+
+async function $do(
+  client: SenseiProductivityCore,
+  request?: operations.GetTopSchoolsRequest | undefined,
+  options?: RequestOptions,
+): Promise<
+  [
+    Result<
+      Array<operations.GetTopSchoolsResponse> | undefined,
+      | SenseiProductivityError
+      | ResponseValidationError
+      | ConnectionError
+      | RequestAbortedError
+      | RequestTimeoutError
+      | InvalidRequestError
+      | UnexpectedClientError
+      | SDKValidationError
+    >,
+    APICall,
+  ]
+> {
+  const parsed = safeParse(
+    request,
+    (value) =>
+      z.parse(
+        z.optional(operations.GetTopSchoolsRequest$outboundSchema),
+        value,
+      ),
+    "Input validation failed",
+  );
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = null;
+
+  const path = pathToFunc("/api/v1/schools/leaderboard")();
+
+  const query = encodeFormQuery({
+    "limit": payload?.limit,
+  });
+
+  const headers = new Headers(compactMap({
+    Accept: "application/json",
+  }));
+
+  const secConfig = await extractSecurity(client._options.bearerAuth);
+  const securityInput = secConfig == null ? {} : { bearerAuth: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "getTopSchools",
+    oAuth2Scopes: null,
+
+    resolvedSecurity: requestSecurity,
+
+    securitySource: client._options.bearerAuth,
+    retryConfig: options?.retries
+      || client._options.retryConfig
+      || {
+        strategy: "backoff",
+        backoff: {
+          initialInterval: 1000,
+          maxInterval: 60000,
+          exponent: 1.3,
+          maxElapsedTime: 3600000,
+        },
+        retryConnectionErrors: true,
+      }
+      || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "5XX"],
+  };
+
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "GET",
+    baseURL: options?.serverURL,
+    path: path,
+    headers: headers,
+    query: query,
+    body: body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1,
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["429", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes,
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+
+  const [result] = await M.match<
+    Array<operations.GetTopSchoolsResponse> | undefined,
+    | SenseiProductivityError
+    | ResponseValidationError
+    | ConnectionError
+    | RequestAbortedError
+    | RequestTimeoutError
+    | InvalidRequestError
+    | UnexpectedClientError
+    | SDKValidationError
+  >(
+    M.json(
+      200,
+      types$.optional(z.array(operations.GetTopSchoolsResponse$inboundSchema)),
+    ),
+    M.nil(
+      401,
+      types$.optional(z.array(operations.GetTopSchoolsResponse$inboundSchema)),
+    ),
+    M.fail(429),
+    M.fail("5XX"),
+  )(response, req);
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+
+  return [result, { status: "complete", request: req, response }];
+}

package/src/lib/config.ts

@@ -61,8 +61,8 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "1.8.0",
-  sdkVersion: "1.8.0",
-  genVersion: "2.869.3",
+  sdkVersion: "1.9.0",
+  genVersion: "2.879.6",
   userAgent:
-    "speakeasy-sdk/typescript 1.8.0 2.869.3 1.8.0 @aurora-interactive/sensei-productivity",
+    "speakeasy-sdk/typescript 1.9.0 2.879.6 1.8.0 @aurora-interactive/sensei-productivity",
 } as const;

package/src/lib/encodings.ts

@@ -479,6 +479,23 @@ export const encodeSpaceDelimitedQuery = queryEncoder(encodeSpaceDelimited);
 export const encodePipeDelimitedQuery = queryEncoder(encodePipeDelimited);
 export const encodeDeepObjectQuery = queryEncoder(encodeDeepObject);
 
+function isBlobLike(val: unknown): val is Blob {
+  if (val instanceof Blob) {
+    return true;
+  }
+
+  if (typeof val !== "object" || val == null || !(Symbol.toStringTag in val)) {
+    return false;
+  }
+
+  const tag = val[Symbol.toStringTag];
+  if (tag !== "Blob" && tag !== "File") {
+    return false;
+  }
+
+  return "stream" in val && typeof val.stream === "function";
+}
+
 export function appendForm(
   fd: FormData,
   key: string,
@@ -487,10 +504,12 @@ export function appendForm(
 ): void {
   if (value == null) {
     return;
-  } else if (value instanceof Blob && fileName) {
-    fd.append(key, value, fileName);
-  } else if (value instanceof Blob) {
-    fd.append(key, value);
+  } else if (isBlobLike(value)) {
+    if (fileName) {
+      fd.append(key, value as Blob, fileName);
+    } else {
+      fd.append(key, value as Blob);
+    }
   } else if (Array.isArray(value)) {
     value.forEach((v) => {
       appendForm(fd, key, v);

package/src/lib/security.ts

@@ -240,8 +240,9 @@ function applyBearer(
 
 export function resolveGlobalSecurity(
   security: Partial<models.Security> | null | undefined,
+  allowedFields?: number[],
 ): SecurityState | null {
-  return resolveSecurity(
+  let inputs: SecurityInput[][] = [
     [
       {
         fieldName: "Authorization",
@@ -249,7 +250,18 @@ export function resolveGlobalSecurity(
         value: security?.bearerAuth ?? env().SENSEIPRODUCTIVITY_BEARER_AUTH,
       },
     ],
-  );
+  ];
+
+  if (allowedFields) {
+    inputs = allowedFields.map((i) => {
+      if (i < 0 || i >= inputs.length) {
+        throw new RangeError(`invalid allowedFields index ${i}`);
+      }
+      return inputs[i]!;
+    });
+  }
+
+  return resolveSecurity(...inputs);
 }
 
 export async function extractSecurity<

package/src/models/operations/get-top-schools.ts

@@ -0,0 +1,60 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v4-mini";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import * as types from "../../types/primitives.js";
+import { SDKValidationError } from "../errors/sdk-validation-error.js";
+
+export type GetTopSchoolsRequest = {
+  limit?: number | undefined;
+};
+
+export type GetTopSchoolsResponse = {
+  schoolName: string;
+  schoolNameShorthand: string;
+  points: number;
+};
+
+/** @internal */
+export type GetTopSchoolsRequest$Outbound = {
+  limit: number;
+};
+
+/** @internal */
+export const GetTopSchoolsRequest$outboundSchema: z.ZodMiniType<
+  GetTopSchoolsRequest$Outbound,
+  GetTopSchoolsRequest
+> = z.object({
+  limit: z._default(z.int(), 5),
+});
+
+export function getTopSchoolsRequestToJSON(
+  getTopSchoolsRequest: GetTopSchoolsRequest,
+): string {
+  return JSON.stringify(
+    GetTopSchoolsRequest$outboundSchema.parse(getTopSchoolsRequest),
+  );
+}
+
+/** @internal */
+export const GetTopSchoolsResponse$inboundSchema: z.ZodMiniType<
+  GetTopSchoolsResponse,
+  unknown
+> = z.object({
+  schoolName: types.string(),
+  schoolNameShorthand: types.string(),
+  points: types.number(),
+});
+
+export function getTopSchoolsResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetTopSchoolsResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetTopSchoolsResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetTopSchoolsResponse' from JSON`,
+  );
+}

package/src/models/operations/index.ts

@@ -14,6 +14,7 @@ export * from "./get-current-user.js";
 export * from "./get-feed.js";
 export * from "./get-post-by-id.js";
 export * from "./get-school-by-id.js";
+export * from "./get-top-schools.js";
 export * from "./get-user-activities.js";
 export * from "./get-user-by-id.js";
 export * from "./get-user-posts.js";

package/src/sdk/schools.ts

@@ -4,6 +4,7 @@
 
 import { schoolsGetAll } from "../funcs/schools-get-all.js";
 import { schoolsGet } from "../funcs/schools-get.js";
+import { schoolsLeaderboard } from "../funcs/schools-leaderboard.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import * as operations from "../models/operations/index.js";
 import { unwrapAsync } from "../types/fp.js";
@@ -21,6 +22,20 @@ export class Schools extends ClientSDK {
     ));
   }
 
+  /**
+   * Get the top 10 schools (by points) in order
+   */
+  async leaderboard(
+    request?: operations.GetTopSchoolsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<Array<operations.GetTopSchoolsResponse> | undefined> {
+    return unwrapAsync(schoolsLeaderboard(
+      this,
+      request,
+      options,
+    ));
+  }
+
   /**
    * Get a school's details by ID
    */