@openlifelog/sdk 1.0.0

package/resources/goals.ts

@@ -0,0 +1,155 @@
+import type { HttpClient } from '../utils/http';
+import type {
+  UserGoal,
+  CreateUserGoalRequest,
+  UpdateUserGoalRequest,
+  DailyGoalProgress,
+  UserNutritionGoals,
+  CreateNutritionGoalsRequest,
+  UpdateNutritionGoalsRequest,
+  BulkCreateNutritionGoalsRequest,
+  CopyNutritionGoalsRequest,
+  DailyNutritionProgress,
+  ListNutritionGoalsHistoryParams,
+  ListResponse,
+} from '../types';
+
+/**
+ * Goals resource
+ * Handles user goals and nutrition goals
+ */
+export class GoalsResource {
+  constructor(private http: HttpClient) {}
+
+  /**
+   * Get active user goals
+   */
+  async list(): Promise<ListResponse<UserGoal>> {
+    const response = await this.http.get<ListResponse<UserGoal>>('/v1/goals');
+    return response.data;
+  }
+
+  /**
+   * Get goals effective on a specific date
+   */
+  async getByDate(date: string): Promise<ListResponse<UserGoal>> {
+    const response = await this.http.get<ListResponse<UserGoal>>(`/v1/goals/date/${date}`);
+    return response.data;
+  }
+
+  /**
+   * Create a new goal
+   */
+  async create(request: CreateUserGoalRequest): Promise<UserGoal> {
+    const response = await this.http.post<UserGoal>('/v1/goals', request);
+    return response.data;
+  }
+
+  /**
+   * Update a goal
+   */
+  async update(goalId: string, request: UpdateUserGoalRequest): Promise<UserGoal> {
+    const response = await this.http.put<UserGoal>(`/v1/goals/${goalId}`, request);
+    return response.data;
+  }
+
+  /**
+   * Delete a goal
+   */
+  async delete(goalId: string): Promise<void> {
+    await this.http.delete(`/v1/goals/${goalId}`);
+  }
+
+  /**
+   * Get today's goal progress
+   */
+  async getProgress(): Promise<DailyGoalProgress> {
+    const response = await this.http.get<DailyGoalProgress>('/v1/goals/progress');
+    return response.data;
+  }
+
+  /**
+   * Get goal progress for a specific date
+   */
+  async getProgressByDate(date: string): Promise<DailyGoalProgress> {
+    const response = await this.http.get<DailyGoalProgress>(`/v1/goals/progress/${date}`);
+    return response.data;
+  }
+
+  /**
+   * Get current nutrition goals
+   */
+  async getNutritionGoals(): Promise<UserNutritionGoals> {
+    const response = await this.http.get<UserNutritionGoals>('/v1/nutrition/goals');
+    return response.data;
+  }
+
+  /**
+   * Get nutrition goals for a specific date
+   */
+  async getNutritionGoalsByDate(date: string): Promise<UserNutritionGoals> {
+    const response = await this.http.get<UserNutritionGoals>(`/v1/nutrition/goals/date/${date}`);
+    return response.data;
+  }
+
+  /**
+   * Create nutrition goals
+   */
+  async createNutritionGoals(request: CreateNutritionGoalsRequest): Promise<UserNutritionGoals> {
+    const response = await this.http.post<UserNutritionGoals>('/v1/nutrition/goals', request);
+    return response.data;
+  }
+
+  /**
+   * Update nutrition goals for a specific date
+   */
+  async updateNutritionGoals(date: string, request: UpdateNutritionGoalsRequest): Promise<UserNutritionGoals> {
+    const response = await this.http.put<UserNutritionGoals>(`/v1/nutrition/goals/date/${date}`, request);
+    return response.data;
+  }
+
+  /**
+   * Delete nutrition goals for a specific date
+   */
+  async deleteNutritionGoals(date: string): Promise<void> {
+    await this.http.delete(`/v1/nutrition/goals/date/${date}`);
+  }
+
+  /**
+   * Bulk create nutrition goals for multiple dates
+   */
+  async bulkCreateNutritionGoals(request: BulkCreateNutritionGoalsRequest): Promise<void> {
+    await this.http.post('/v1/nutrition/goals/bulk', request);
+  }
+
+  /**
+   * Copy nutrition goals from one date to another
+   */
+  async copyNutritionGoals(request: CopyNutritionGoalsRequest): Promise<void> {
+    await this.http.post('/v1/nutrition/goals/copy', request);
+  }
+
+  /**
+   * Get nutrition goals history
+   */
+  async getNutritionGoalsHistory(params?: ListNutritionGoalsHistoryParams): Promise<ListResponse<UserNutritionGoals>> {
+    const response = await this.http.get<ListResponse<UserNutritionGoals>>('/v1/nutrition/goals/history', params);
+    return response.data;
+  }
+
+  /**
+   * Get today's nutrition progress toward goals
+   */
+  async getNutritionProgress(): Promise<DailyNutritionProgress> {
+    const response = await this.http.get<DailyNutritionProgress>('/v1/nutrition/progress/today');
+    return response.data;
+  }
+
+  /**
+   * Get nutrition progress for a specific date
+   */
+  async getNutritionProgressByDate(date: string): Promise<DailyNutritionProgress> {
+    const response = await this.http.get<DailyNutritionProgress>(`/v1/nutrition/progress/date/${date}`);
+    return response.data;
+  }
+}

package/resources/metrics.ts

@@ -0,0 +1,115 @@
+import type { HttpClient } from '../utils/http';
+import type {
+  Metric,
+  MetricEvent,
+  CreateMetricEventRequest,
+  UpdateMetricEventRequest,
+  BulkCreateMetricEventsRequest,
+  ListMetricEventsParams,
+  DailyMetricAggregate,
+  GetDailyMetricParams,
+  ListResponse,
+} from '../types';
+import { createPaginatedIterator, type PaginatedIterator } from '../utils/pagination';
+
+/**
+ * Metrics resource
+ * Handles metric tracking operations
+ */
+export class MetricsResource {
+  constructor(private http: HttpClient) {}
+
+  /**
+   * List available metrics
+   */
+  async list(): Promise<ListResponse<Metric>> {
+    const response = await this.http.get<ListResponse<Metric>>('/v1/metrics');
+    return response.data;
+  }
+
+  /**
+   * Get specific metric details
+   */
+  async get(metricId: string): Promise<Metric> {
+    const response = await this.http.get<Metric>(`/v1/metrics/${metricId}`);
+    return response.data;
+  }
+
+  /**
+   * Get metrics by category
+   */
+  async getByCategory(category: string): Promise<ListResponse<Metric>> {
+    const response = await this.http.get<ListResponse<Metric>>(`/v1/metrics/category/${category}`);
+    return response.data;
+  }
+
+  /**
+   * Get daily aggregated metric value
+   */
+  async getDailyMetric(metricKey: string, params?: GetDailyMetricParams): Promise<DailyMetricAggregate> {
+    const response = await this.http.get<DailyMetricAggregate>(`/v1/metrics/daily/${metricKey}`, params);
+    return response.data;
+  }
+
+  /**
+   * List metric events (data points)
+   */
+  async listEvents(params?: ListMetricEventsParams): Promise<ListResponse<MetricEvent>> {
+    const response = await this.http.get<ListResponse<MetricEvent>>('/v1/metric-events', params);
+    return response.data;
+  }
+
+  /**
+   * List metric events with automatic pagination
+   */
+  listEventsAutoPaginate(params?: ListMetricEventsParams): PaginatedIterator<MetricEvent> {
+    return createPaginatedIterator((cursor) =>
+      this.listEvents({ ...params, cursor })
+    );
+  }
+
+  /**
+   * Get specific metric event
+   */
+  async getEvent(eventId: string): Promise<MetricEvent> {
+    const response = await this.http.get<MetricEvent>(`/v1/metric-events/${eventId}`);
+    return response.data;
+  }
+
+  /**
+   * Log a metric value (convenience method)
+   */
+  async log(request: CreateMetricEventRequest): Promise<MetricEvent> {
+    const response = await this.http.post<MetricEvent>('/v1/metric-events', request);
+    return response.data;
+  }
+
+  /**
+   * Create a metric event
+   */
+  async createEvent(request: CreateMetricEventRequest): Promise<MetricEvent> {
+    return this.log(request);
+  }
+
+  /**
+   * Bulk create metric events
+   */
+  async bulkCreateEvents(request: BulkCreateMetricEventsRequest): Promise<void> {
+    await this.http.post('/v1/metric-events/bulk', request);
+  }
+
+  /**
+   * Update a metric event
+   */
+  async updateEvent(eventId: string, request: UpdateMetricEventRequest): Promise<MetricEvent> {
+    const response = await this.http.put<MetricEvent>(`/v1/metric-events/${eventId}`, request);
+    return response.data;
+  }
+
+  /**
+   * Delete a metric event
+   */
+  async deleteEvent(eventId: string): Promise<void> {
+    await this.http.delete(`/v1/metric-events/${eventId}`);
+  }
+}

package/resources/programs.ts

@@ -0,0 +1,123 @@
+import type { HttpClient } from '../utils/http';
+import type {
+  Program,
+  CreateProgramRequest,
+  UpdateProgramRequest,
+  EnrollInProgramRequest,
+  ProgramEnrollment,
+  UpdateEnrollmentRequest,
+  EnrollmentProgress,
+  CurrentWeekSchedule,
+  ListResponse,
+  ListParams,
+} from '../types';
+
+/**
+ * Programs resource
+ * Handles training program operations
+ */
+export class ProgramsResource {
+  constructor(private http: HttpClient) {}
+
+  /**
+   * List user's programs and enrollments
+   */
+  async list(params?: ListParams): Promise<ListResponse<Program>> {
+    const response = await this.http.get<ListResponse<Program>>('/v1/programs', params);
+    return response.data;
+  }
+
+  /**
+   * List available program templates
+   */
+  async listTemplates(params?: ListParams): Promise<ListResponse<Program>> {
+    const response = await this.http.get<ListResponse<Program>>('/v1/programs/templates', params);
+    return response.data;
+  }
+
+  /**
+   * Create a new program
+   */
+  async create(request: CreateProgramRequest): Promise<Program> {
+    const response = await this.http.post<Program>('/v1/programs', request);
+    return response.data;
+  }
+
+  /**
+   * Get specific program details
+   */
+  async get(programId: string): Promise<Program> {
+    const response = await this.http.get<Program>(`/v1/programs/${programId}`);
+    return response.data;
+  }
+
+  /**
+   * Update a program
+   */
+  async update(programId: string, request: UpdateProgramRequest): Promise<Program> {
+    const response = await this.http.put<Program>(`/v1/programs/${programId}`, request);
+    return response.data;
+  }
+
+  /**
+   * Delete a program
+   */
+  async delete(programId: string): Promise<void> {
+    await this.http.delete(`/v1/programs/${programId}`);
+  }
+
+  /**
+   * Enroll in a program
+   */
+  async enroll(programId: string, request: EnrollInProgramRequest): Promise<ProgramEnrollment> {
+    const response = await this.http.post<ProgramEnrollment>(`/v1/programs/${programId}/enroll`, request);
+    return response.data;
+  }
+
+  /**
+   * List program enrollments
+   */
+  async listEnrollments(params?: ListParams): Promise<ListResponse<ProgramEnrollment>> {
+    const response = await this.http.get<ListResponse<ProgramEnrollment>>('/v1/enrollments', params);
+    return response.data;
+  }
+
+  /**
+   * Get enrollment details
+   */
+  async getEnrollment(enrollmentId: string): Promise<ProgramEnrollment> {
+    const response = await this.http.get<ProgramEnrollment>(`/v1/enrollments/${enrollmentId}`);
+    return response.data;
+  }
+
+  /**
+   * Update enrollment (pause, resume, etc.)
+   */
+  async updateEnrollment(enrollmentId: string, request: UpdateEnrollmentRequest): Promise<ProgramEnrollment> {
+    const response = await this.http.put<ProgramEnrollment>(`/v1/enrollments/${enrollmentId}`, request);
+    return response.data;
+  }
+
+  /**
+   * Unenroll from a program
+   */
+  async unenroll(enrollmentId: string): Promise<void> {
+    await this.http.delete(`/v1/enrollments/${enrollmentId}`);
+  }
+
+  /**
+   * Get enrollment progress
+   */
+  async getEnrollmentProgress(enrollmentId: string): Promise<EnrollmentProgress> {
+    const response = await this.http.get<EnrollmentProgress>(`/v1/enrollments/${enrollmentId}/progress`);
+    return response.data;
+  }
+
+  /**
+   * Get current week schedule for enrollment
+   */
+  async getCurrentWeek(enrollmentId: string): Promise<CurrentWeekSchedule> {
+    const response = await this.http.get<CurrentWeekSchedule>(`/v1/enrollments/${enrollmentId}/current-week`);
+    return response.data;
+  }
+}

package/resources/sessions.ts

@@ -0,0 +1,142 @@
+import type { HttpClient } from '../utils/http';
+import type {
+  WorkoutSession,
+  CreateWorkoutSessionRequest,
+  UpdateWorkoutSessionRequest,
+  ListWorkoutSessionsParams,
+  ExerciseHistory,
+  PersonalRecord,
+  PersonalRecordHistory,
+  ListResponse,
+  AddExerciseItem,
+} from '../types';
+import { createPaginatedIterator, type PaginatedIterator } from '../utils/pagination';
+
+/**
+ * Workout Sessions resource
+ * Handles workout performance tracking
+ */
+export class SessionsResource {
+  constructor(private http: HttpClient) {}
+
+  /**
+   * List workout sessions with filtering
+   */
+  async list(params?: ListWorkoutSessionsParams): Promise<ListResponse<WorkoutSession>> {
+    const response = await this.http.get<ListResponse<WorkoutSession>>('/v1/workout-sessions', params);
+    return response.data;
+  }
+
+  /**
+   * List sessions with automatic pagination
+   */
+  listAutoPaginate(params?: ListWorkoutSessionsParams): PaginatedIterator<WorkoutSession> {
+    return createPaginatedIterator((cursor) =>
+      this.list({ ...params, cursor })
+    );
+  }
+
+  /**
+   * Create a new workout session
+   */
+  async create(request: CreateWorkoutSessionRequest): Promise<WorkoutSession> {
+    const response = await this.http.post<WorkoutSession>('/v1/workout-sessions', request);
+    return response.data;
+  }
+
+  /**
+   * Start a workout session (convenience method)
+   */
+  async start(request: Omit<CreateWorkoutSessionRequest, 'status'>): Promise<WorkoutSession> {
+    return this.create({ ...request, status: 'in_progress' });
+  }
+
+  /**
+   * Get specific session with all exercise data
+   */
+  async get(sessionId: string): Promise<WorkoutSession> {
+    const response = await this.http.get<WorkoutSession>(`/v1/workout-sessions/${sessionId}`);
+    return response.data;
+  }
+
+  /**
+   * Update a workout session
+   */
+  async update(sessionId: string, request: UpdateWorkoutSessionRequest): Promise<WorkoutSession> {
+    const response = await this.http.patch<WorkoutSession>(`/v1/workout-sessions/${sessionId}`, request);
+    return response.data;
+  }
+
+  /**
+   * Complete a workout session (convenience method)
+   */
+  async complete(sessionId: string, notes?: string): Promise<WorkoutSession> {
+    return this.update(sessionId, {
+      status: 'completed',
+      completedAt: new Date().toISOString(),
+      ...(notes && { notes }),
+    });
+  }
+
+  /**
+   * Add exercises to a session (convenience method)
+   *
+   * @example
+   * ```typescript
+   * await client.sessions.addExercises('session-123', [
+   *   { exerciseId: 'ex-1', targetSets: 3 },
+   *   { exerciseId: 'ex-2', targetSets: 4, notes: 'Focus on form' }
+   * ]);
+   * ```
+   */
+  async addExercises(sessionId: string, exercises: AddExerciseItem[]): Promise<WorkoutSession> {
+    return this.update(sessionId, { addExercises: exercises });
+  }
+
+  /**
+   * Delete a workout session
+   */
+  async delete(sessionId: string): Promise<void> {
+    await this.http.delete(`/v1/workout-sessions/${sessionId}`);
+  }
+
+  /**
+   * Get all sessions for a specific workout
+   */
+  async getSessionsByWorkout(workoutId: string, params?: ListWorkoutSessionsParams): Promise<ListResponse<WorkoutSession>> {
+    const response = await this.http.get<ListResponse<WorkoutSession>>(`/v1/workouts/${workoutId}/sessions`, params);
+    return response.data;
+  }
+
+  /**
+   * Get exercise performance history across sessions
+   */
+  async getExerciseHistory(exerciseId: string): Promise<ExerciseHistory> {
+    const response = await this.http.get<ExerciseHistory>(`/v1/exercises/${exerciseId}/history`);
+    return response.data;
+  }
+
+  /**
+   * Get user's personal records
+   */
+  async getPersonalRecords(): Promise<ListResponse<PersonalRecord>> {
+    const response = await this.http.get<ListResponse<PersonalRecord>>('/v1/personal-records');
+    return response.data;
+  }
+
+  /**
+   * Get personal records for a specific exercise
+   */
+  async getExercisePersonalRecords(exerciseId: string): Promise<ListResponse<PersonalRecord>> {
+    const response = await this.http.get<ListResponse<PersonalRecord>>(`/v1/exercises/${exerciseId}/personal-records`);
+    return response.data;
+  }
+
+  /**
+   * Get personal record progression history for an exercise
+   */
+  async getPersonalRecordHistory(exerciseId: string): Promise<ListResponse<PersonalRecordHistory>> {
+    const response = await this.http.get<ListResponse<PersonalRecordHistory>>(`/v1/exercises/${exerciseId}/personal-records/history`);
+    return response.data;
+  }
+}

package/resources/users.ts

@@ -0,0 +1,132 @@
+import type { HttpClient } from '../utils/http';
+import type {
+  User,
+  UserPreferences,
+  UpdateUserRequest,
+  UpdatePreferencesRequest,
+  ListResponse,
+  ListParams,
+} from '../types';
+import { createPaginatedIterator, type PaginatedIterator } from '../utils/pagination';
+
+/**
+ * Users resource
+ * Handles user profile and preferences operations
+ */
+export class UsersResource {
+  constructor(private http: HttpClient) {}
+
+  /**
+   * Get current authenticated user
+   *
+   * @example
+   * ```typescript
+   * const user = await client.users.me();
+   * console.log(user.name, user.email);
+   * ```
+   */
+  async me(): Promise<User> {
+    const response = await this.http.get<User>('/v1/users/me');
+    return response.data;
+  }
+
+  /**
+   * Update current user profile
+   *
+   * @example
+   * ```typescript
+   * const user = await client.users.update({
+   *   name: 'Updated Name',
+   *   isOnboarded: true
+   * });
+   * ```
+   */
+  async update(request: UpdateUserRequest): Promise<User> {
+    const response = await this.http.patch<User>('/v1/users/me', request);
+    return response.data;
+  }
+
+  /**
+   * Get user preferences
+   *
+   * @example
+   * ```typescript
+   * const prefs = await client.users.getPreferences();
+   * console.log(prefs.measurementSystem); // 'metric' or 'imperial'
+   * ```
+   */
+  async getPreferences(): Promise<UserPreferences> {
+    const response = await this.http.get<UserPreferences>('/v1/users/me/preferences');
+    return response.data;
+  }
+
+  /**
+   * Update user preferences
+   *
+   * @example
+   * ```typescript
+   * const prefs = await client.users.updatePreferences({
+   *   measurementSystem: 'imperial'
+   * });
+   * ```
+   */
+  async updatePreferences(request: UpdatePreferencesRequest): Promise<UserPreferences> {
+    const response = await this.http.patch<UserPreferences>('/v1/users/me/preferences', request);
+    return response.data;
+  }
+
+  /**
+   * List all users (for admin/public lists)
+   *
+   * @example
+   * ```typescript
+   * const { data, pageInfo } = await client.users.list({ limit: 20 });
+   * ```
+   */
+  async list(params?: ListParams): Promise<ListResponse<User>> {
+    const response = await this.http.get<ListResponse<User>>('/v1/users', params);
+    return response.data;
+  }
+
+  /**
+   * Search for users by name or email
+   *
+   * @example
+   * ```typescript
+   * const { data, pageInfo } = await client.users.search({ q: 'john' });
+   * ```
+   */
+  async search(params: { q: string; limit?: number; cursor?: string }): Promise<ListResponse<User>> {
+    const response = await this.http.get<ListResponse<User>>('/v1/users/search', params);
+    return response.data;
+  }
+
+  /**
+   * List all users with automatic pagination
+   *
+   * @example
+   * ```typescript
+   * for await (const user of client.users.listAutoPaginate({ limit: 100 })) {
+   *   console.log(user.name);
+   * }
+   * ```
+   */
+  listAutoPaginate(params?: ListParams): PaginatedIterator<User> {
+    return createPaginatedIterator((cursor) =>
+      this.list({ ...params, cursor })
+    );
+  }
+
+  /**
+   * Get specific user by ID
+   *
+   * @example
+   * ```typescript
+   * const user = await client.users.get('user-id');
+   * ```
+   */
+  async get(userId: string): Promise<User> {
+    const response = await this.http.get<User>(`/v1/users/${userId}`);
+    return response.data;
+  }
+}