@strong-together/shared 1.0.5

package/dist/index.mjs

@@ -0,0 +1,559 @@
+// src/modules/aerobics/aerobics.schemas.ts
+import z from "zod";
+var addAerobicInput = z.object({
+  durationMins: z.number(),
+  durationSec: z.number(),
+  type: z.string()
+});
+var addAerobicsRequest = z.object({
+  body: z.object({
+    tz: z.string(),
+    record: addAerobicInput
+  })
+});
+var getAerobicsRequest = z.object({
+  query: z.object({
+    tz: z.string().optional()
+  })
+});
+var aerobicsDailyRecordSchema = z.object({
+  type: z.string(),
+  duration_sec: z.number(),
+  duration_mins: z.number()
+});
+var aerobicsWeeklyRecordSchema = aerobicsDailyRecordSchema.extend({
+  workout_time_utc: z.string()
+});
+var weeklyDataSchema = z.object({
+  records: z.array(aerobicsWeeklyRecordSchema),
+  total_duration_sec: z.number(),
+  total_duration_mins: z.number()
+});
+var userAerobicsResponseSchema = z.object({
+  daily: z.record(z.string(), z.array(aerobicsDailyRecordSchema)),
+  weekly: z.record(z.string(), weeklyDataSchema)
+});
+
+// src/modules/analytics/analytics.schemas.ts
+import { z as z2 } from "zod";
+var workoutRmRecordSchema = z2.object({
+  exercise: z2.string(),
+  pr_weight: z2.number().nullable(),
+  pr_reps: z2.number().nullable(),
+  max_1rm: z2.number()
+});
+var adherenceExerciseStatsSchema = z2.object({
+  planned: z2.number(),
+  actual: z2.number(),
+  adherence_pct: z2.number().nullable()
+});
+var getAnalyticsResponseSchema = z2.object({
+  _1RM: z2.record(z2.string(), workoutRmRecordSchema),
+  goals: z2.record(z2.string(), z2.record(z2.string(), adherenceExerciseStatsSchema))
+});
+
+// src/modules/auth/password/password.schemas.ts
+import { z as z3 } from "zod";
+var sendChangePassEmailRequest = z3.object({
+  body: z3.object({ identifier: z3.string() })
+});
+var resetPasswordRequest = z3.object({
+  body: z3.object({
+    newPassword: z3.string().min(8, "Password must be at least 8 characters long")
+  }),
+  query: z3.object({
+    token: z3.string().optional()
+  })
+});
+var resetPasswordResponseSchema = z3.object({
+  ok: z3.boolean()
+});
+
+// src/modules/auth/session/session.schemas.ts
+import { z as z4 } from "zod";
+var loginRequest = z4.object({
+  body: z4.object({
+    identifier: z4.string().min(3).refine(
+      (val) => {
+        const isEmail = z4.string().email().safeParse(val).success;
+        const isUsername = /^[a-zA-Z0-9_]{3,20}$/.test(val);
+        return isEmail || isUsername;
+      },
+      {
+        message: "Must be a valid email or username"
+      }
+    ),
+    password: z4.string().min(1, "Username and password are required")
+  })
+});
+var loginResponseSchema = z4.object({
+  message: z4.string(),
+  user: z4.string(),
+  accessToken: z4.string(),
+  refreshToken: z4.string()
+});
+var logoutResponseSchema = z4.object({
+  message: z4.string()
+});
+var refreshTokenResponseSchema = z4.object({
+  message: z4.string(),
+  accessToken: z4.string(),
+  refreshToken: z4.string(),
+  userId: z4.string()
+});
+
+// src/modules/auth/verification/verification.schemas.ts
+import z5 from "zod";
+var verifyAccountRequest = z5.object({
+  query: z5.object({
+    token: z5.string().optional()
+  })
+});
+var sendVerificationMailRequest = z5.object({
+  body: z5.object({ email: z5.string().trim().email("Invalid email") })
+});
+var changeEmailAndVerifyRequest = z5.object({
+  body: z5.object({ username: z5.string(), password: z5.string(), newEmail: z5.string().trim().email("Invalid email") })
+});
+var checkUserVerifyRequest = z5.object({
+  query: z5.object({ username: z5.string() })
+});
+
+// src/modules/bootstrap/bootstrap.schemas.ts
+import { z as z10 } from "zod";
+
+// src/modules/messages/messages.schemas.ts
+import { z as z6 } from "zod";
+var getAllMessagesRequest = z6.object({
+  query: z6.object({
+    tz: z6.string()
+  })
+});
+var allUserMessageSchema = z6.object({
+  id: z6.string(),
+  subject: z6.string(),
+  msg: z6.string(),
+  sent_at: z6.string(),
+  is_read: z6.boolean(),
+  sender_full_name: z6.string(),
+  sender_profile_image_url: z6.string().nullable()
+});
+var getAllUserMessagesResponseSchema = z6.object({
+  messages: z6.array(allUserMessageSchema)
+});
+var markMessageAsReadRequest = z6.object({
+  params: z6.object({
+    id: z6.string()
+    // MSG ID
+  })
+});
+var messageAsReadSchema = z6.object({
+  id: z6.string(),
+  is_read: z6.boolean()
+});
+var markMessageAsReadResponseSchema = messageAsReadSchema;
+var deleteMessageRequest = z6.object({
+  params: z6.object({
+    id: z6.string()
+    // MSG ID
+  })
+});
+var deletedMessageSchema = z6.object({
+  id: z6.string()
+});
+var deleteMessageResponseSchema = deletedMessageSchema;
+
+// src/modules/user/update/update.schemas.ts
+import { z as z7 } from "zod";
+var updateUserRequest = z7.object({
+  body: z7.object({
+    username: z7.string().trim().min(3, "Username must be at least 3 characters").max(15, "Username must be at most 15 characters").regex(/^[a-zA-Z0-9_]+$/, "Username may contain letters, numbers, and underscore only"),
+    fullName: z7.string().trim().min(1, "Full name is required").max(20, "Full name is too long").regex(/^[a-zA-Z\s]+$/, "Full name may contain letters and spaces only"),
+    email: z7.string().trim().toLowerCase().email("Invalid email format")
+  }).partial()
+});
+var deleteProfilePicRequest = z7.object({
+  body: z7.object({
+    path: z7.string()
+  })
+});
+var userDataSchema = z7.object({
+  id: z7.string(),
+  username: z7.string(),
+  email: z7.string().nullable(),
+  name: z7.string(),
+  gender: z7.string(),
+  created_at: z7.string(),
+  profile_image_url: z7.string().nullable(),
+  push_token: z7.string().nullable(),
+  role: z7.string(),
+  is_first_login: z7.boolean(),
+  token_version: z7.number(),
+  is_verified: z7.boolean(),
+  auth_provider: z7.string()
+});
+var userDataResponseSchema = z7.object({
+  user_data: userDataSchema
+});
+var getAuthenticatedUserByIdResponseSchema = userDataSchema;
+var updateAuthenticatedUserResponseSchema = z7.object({
+  message: z7.string(),
+  emailChanged: z7.boolean(),
+  user: userDataSchema
+});
+var setProfilePicAndUpdateDBResponseSchema = z7.object({
+  path: z7.string(),
+  url: z7.string(),
+  message: z7.string()
+});
+
+// src/modules/workout/plan/plan.schemas.ts
+import { z as z8 } from "zod";
+var workoutExerciseSchema = z8.object({
+  id: z8.number(),
+  sets: z8.array(z8.number()),
+  order_index: z8.number()
+});
+var exerciseInPlanSchema = z8.object({
+  id: z8.number(),
+  sets: z8.array(z8.number()),
+  is_active: z8.boolean(),
+  targetmuscle: z8.string(),
+  specifictargetmuscle: z8.string(),
+  exercise: z8.string(),
+  workoutsplit: z8.string()
+});
+var workoutSplitSchema = z8.object({
+  id: z8.number(),
+  workout_id: z8.number(),
+  name: z8.string(),
+  created_at: z8.string(),
+  muscle_group: z8.string().nullable(),
+  is_active: z8.boolean(),
+  exercisetoworkoutsplit: z8.array(exerciseInPlanSchema)
+});
+var wholeUserWorkoutPlanSchema = z8.object({
+  id: z8.number(),
+  name: z8.string(),
+  numberofsplits: z8.number(),
+  created_at: z8.string(),
+  is_deleted: z8.boolean(),
+  level: z8.string(),
+  user_id: z8.string(),
+  trainer_id: z8.string(),
+  is_active: z8.boolean(),
+  updated_at: z8.string(),
+  workoutsplits: z8.array(workoutSplitSchema).nullable()
+});
+var workoutSplitsMapItemSchema = z8.object({
+  id: z8.number(),
+  name: z8.string(),
+  sets: z8.array(z8.number()),
+  order_index: z8.number(),
+  targetmuscle: z8.string(),
+  specifictargetmuscle: z8.string()
+});
+var workoutSplitsMapSchema = z8.record(z8.string(), z8.array(workoutSplitsMapItemSchema));
+var addWorkoutSplitPayloadSchema = z8.record(
+  z8.string(),
+  z8.array(workoutExerciseSchema).min(1, "Each split must include at least one exercise")
+);
+var addWorkoutRequest = z8.object({
+  body: z8.object({
+    workoutData: addWorkoutSplitPayloadSchema,
+    workoutName: z8.string().optional(),
+    tz: z8.string()
+  })
+});
+var addWorkoutResponseSchema = z8.object({
+  message: z8.string(),
+  workoutPlan: wholeUserWorkoutPlanSchema,
+  workoutPlanForEditWorkout: workoutSplitsMapSchema
+});
+var getWholeWorkoutPlanRequest = z8.object({
+  query: z8.object({
+    tz: z8.string().optional()
+  })
+});
+var getWholeUserWorkoutPlanResponseSchema = z8.object({
+  workoutPlan: wholeUserWorkoutPlanSchema.nullable(),
+  workoutPlanForEditWorkout: workoutSplitsMapSchema.nullable()
+});
+
+// src/modules/workout/tracking/tracking.schemas.ts
+import { z as z9 } from "zod";
+var finishedExerciseEntry = z9.object({
+  exercisetosplit_id: z9.number(),
+  weight: z9.array(z9.number()),
+  reps: z9.array(z9.number()),
+  notes: z9.string().optional().nullable()
+});
+var exerciseMetadataSchema = z9.object({
+  targetmuscle: z9.string(),
+  specifictargetmuscle: z9.string()
+});
+var exerciseTrackingPrMaxSchema = z9.object({
+  exercise: z9.string(),
+  weight: z9.number(),
+  reps: z9.number(),
+  workout_time_utc: z9.string()
+});
+var exerciseTrackingAnalysisSchema = z9.object({
+  unique_days: z9.number(),
+  most_frequent_split: z9.string().nullable(),
+  most_frequent_split_days: z9.number().nullable(),
+  lastWorkoutDate: z9.string().nullable(),
+  splitDaysByName: z9.record(z9.string(), z9.number()),
+  prs: z9.object({
+    pr_max: exerciseTrackingPrMaxSchema.nullable()
+  })
+});
+var trackingMapItemSchema = z9.object({
+  id: z9.number(),
+  exercisetosplit_id: z9.number(),
+  weight: z9.array(z9.number()),
+  reps: z9.array(z9.number()),
+  notes: z9.string().nullable(),
+  exercise_id: z9.number(),
+  workoutsplit_id: z9.number(),
+  splitname: z9.string(),
+  exercise: z9.string(),
+  workoutdate: z9.string(),
+  order_index: z9.number(),
+  exercisetoworkoutsplit: z9.object({
+    sets: z9.array(z9.number()),
+    exercises: exerciseMetadataSchema
+  })
+});
+var trackingByDateItemSchema = trackingMapItemSchema.omit({ workoutdate: true });
+var trackingBySplitNameItemSchema = trackingMapItemSchema.omit({ splitname: true });
+var exerciseTrackingAndStatsSchema = z9.object({
+  exerciseTrackingAnalysis: exerciseTrackingAnalysisSchema,
+  exerciseTrackingMaps: z9.object({
+    byDate: z9.record(z9.string(), z9.array(trackingByDateItemSchema)),
+    byETSId: z9.record(z9.string(), z9.array(trackingMapItemSchema)),
+    bySplitName: z9.record(z9.string(), z9.array(trackingBySplitNameItemSchema))
+  })
+});
+var finishWorkoutRequest = z9.object({
+  body: z9.object({
+    workout: z9.array(finishedExerciseEntry),
+    tz: z9.string().optional(),
+    workout_start_utc: z9.string().datetime("workout_start_utc must be a valid ISO datetime"),
+    workout_end_utc: z9.string().datetime("workout_end_utc must be a valid ISO datetime").optional().nullable()
+  })
+});
+var finishUserWorkoutResponseSchema = exerciseTrackingAndStatsSchema;
+var getExerciseTrackingRequest = z9.object({
+  query: z9.object({
+    tz: z9.string().optional()
+  })
+});
+var getExerciseTrackingResponseSchema = exerciseTrackingAndStatsSchema;
+
+// src/modules/bootstrap/bootstrap.schemas.ts
+var bootstrapRequest = z10.object({
+  query: z10.object({
+    tz: z10.string().optional()
+  })
+});
+var bootstrapResponseSchema = z10.object({
+  user: userDataSchema,
+  workout: getWholeUserWorkoutPlanResponseSchema,
+  tracking: exerciseTrackingAndStatsSchema,
+  messages: getAllUserMessagesResponseSchema,
+  aerobics: userAerobicsResponseSchema
+});
+
+// src/modules/exercises/exercises.schemas.ts
+import { z as z11 } from "zod";
+var getAllExercisesResponseSchema = z11.record(
+  z11.string(),
+  z11.array(
+    z11.object({
+      id: z11.number(),
+      name: z11.string(),
+      specificTargetMuscle: z11.string()
+    })
+  )
+);
+
+// src/modules/oauth/apple/apple.schemas.ts
+import { z as z12 } from "zod";
+var appleNameInput = z12.object({
+  givenName: z12.string().nullable(),
+  familyName: z12.string().nullable()
+});
+var appleOAuthRequest = z12.object({
+  body: z12.object({
+    idToken: z12.string({
+      required_error: "Missing or invalid Apple identityToken",
+      invalid_type_error: "Missing or invalid Apple identityToken"
+    }),
+    rawNonce: z12.string(),
+    name: appleNameInput.optional(),
+    email: z12.string().email().nullable()
+  })
+});
+
+// src/modules/oauth/google/google.schemas.ts
+import { z as z13 } from "zod";
+var googleOAuthRequest = z13.object({
+  body: z13.object({
+    idToken: z13.string().optional()
+  })
+});
+
+// src/modules/oauth/oauth.schemas.ts
+import { z as z14 } from "zod";
+var oAuthLoginResponseSchema = z14.object({
+  message: z14.string(),
+  user: z14.string(),
+  accessToken: z14.string(),
+  refreshToken: z14.string().nullable(),
+  missingFields: z14.array(z14.string()).nullable()
+});
+var proceedLoginResponseSchema = loginResponseSchema;
+
+// src/modules/user/create/create.schemas.ts
+import { z as z15 } from "zod";
+var createUserRequest = z15.object({
+  body: z15.object({
+    username: z15.string().trim().min(3, "Username must be at least 3 characters").max(15, "Username must be at most 15 characters").regex(/^[a-zA-Z0-9_]+$/, "Username may contain letters, numbers, and underscore only"),
+    fullName: z15.preprocess(
+      // Map "", null, undefined -> "User"
+      (val) => {
+        if (val == null) return "User";
+        if (typeof val === "string" && val.trim() === "") return "User";
+        return val;
+      },
+      z15.string().trim().max(20, "Full name is too long").regex(/^[a-zA-Z\s]+$/, "Full name may contain letters and spaces only")
+    ),
+    email: z15.string().trim().toLowerCase().email("Invalid email format"),
+    password: z15.string().min(8, "Password must be at least 8 characters long"),
+    gender: z15.preprocess(
+      (val) => val === "" || val == null ? "Unknown" : val,
+      z15.enum(["Male", "Female", "Other", "Unknown"])
+    )
+  })
+});
+var createUserUserSchema = z15.object({
+  id: z15.string(),
+  username: z15.string(),
+  name: z15.string(),
+  email: z15.string().nullable(),
+  gender: z15.string(),
+  role: z15.string(),
+  created_at: z15.string()
+});
+var createUserResponseSchema = z15.object({
+  message: z15.string(),
+  user: createUserUserSchema
+});
+
+// src/modules/user/push-tokens/push-tokens.schemas.ts
+import { z as z16 } from "zod";
+var saveUserPushTokenRequest = z16.object({
+  body: z16.object({
+    token: z16.string()
+  })
+});
+
+// src/modules/video-analysis/video-analysis.schemas.ts
+import { z as z17 } from "zod";
+var getPresignedUrlS3Request = z17.object({
+  body: z17.object({
+    exercise: z17.string(),
+    fileType: z17.string(),
+    jobId: z17.string()
+  })
+});
+var getPresignedUrlFromS3ResponseSchema = z17.object({
+  uploadUrl: z17.string(),
+  fileKey: z17.string(),
+  requestId: z17.string()
+});
+
+// src/modules/web-sockets/web-sockets.schemas.ts
+import { z as z18 } from "zod";
+var generateTicketRequest = z18.object({
+  body: z18.object({
+    username: z18.string()
+  })
+});
+var generateTicketResponseSchema = z18.object({
+  ticket: z18.string()
+});
+export {
+  addAerobicsRequest,
+  addWorkoutRequest,
+  addWorkoutResponseSchema,
+  adherenceExerciseStatsSchema,
+  aerobicsDailyRecordSchema,
+  aerobicsWeeklyRecordSchema,
+  allUserMessageSchema,
+  appleOAuthRequest,
+  bootstrapRequest,
+  bootstrapResponseSchema,
+  changeEmailAndVerifyRequest,
+  checkUserVerifyRequest,
+  createUserRequest,
+  createUserResponseSchema,
+  createUserUserSchema,
+  deleteMessageRequest,
+  deleteMessageResponseSchema,
+  deleteProfilePicRequest,
+  deletedMessageSchema,
+  exerciseInPlanSchema,
+  exerciseMetadataSchema,
+  exerciseTrackingAnalysisSchema,
+  exerciseTrackingAndStatsSchema,
+  exerciseTrackingPrMaxSchema,
+  finishUserWorkoutResponseSchema,
+  finishWorkoutRequest,
+  generateTicketRequest,
+  generateTicketResponseSchema,
+  getAerobicsRequest,
+  getAllExercisesResponseSchema,
+  getAllMessagesRequest,
+  getAllUserMessagesResponseSchema,
+  getAnalyticsResponseSchema,
+  getAuthenticatedUserByIdResponseSchema,
+  getExerciseTrackingRequest,
+  getExerciseTrackingResponseSchema,
+  getPresignedUrlFromS3ResponseSchema,
+  getPresignedUrlS3Request,
+  getWholeUserWorkoutPlanResponseSchema,
+  getWholeWorkoutPlanRequest,
+  googleOAuthRequest,
+  loginRequest,
+  loginResponseSchema,
+  logoutResponseSchema,
+  markMessageAsReadRequest,
+  markMessageAsReadResponseSchema,
+  messageAsReadSchema,
+  oAuthLoginResponseSchema,
+  proceedLoginResponseSchema,
+  refreshTokenResponseSchema,
+  resetPasswordRequest,
+  resetPasswordResponseSchema,
+  saveUserPushTokenRequest,
+  sendChangePassEmailRequest,
+  sendVerificationMailRequest,
+  setProfilePicAndUpdateDBResponseSchema,
+  trackingByDateItemSchema,
+  trackingBySplitNameItemSchema,
+  trackingMapItemSchema,
+  updateAuthenticatedUserResponseSchema,
+  updateUserRequest,
+  userAerobicsResponseSchema,
+  userDataResponseSchema,
+  userDataSchema,
+  verifyAccountRequest,
+  weeklyDataSchema,
+  wholeUserWorkoutPlanSchema,
+  workoutRmRecordSchema,
+  workoutSplitSchema,
+  workoutSplitsMapItemSchema,
+  workoutSplitsMapSchema
+};

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@strong-together/shared",
+  "version": "1.0.5",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --watch --dts"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "zod": "^3.25.76"
+  }
+}