@openlifelog/sdk 1.0.0

package/index.ts

@@ -0,0 +1,49 @@
+/**
+ * OpenLifeLog TypeScript SDK
+ *
+ * A comprehensive TypeScript SDK for the OpenLifeLog API - the complete
+ * fitness and nutrition tracking platform.
+ *
+ * @packageDocumentation
+ */
+
+// Main client
+export { OpenLifeLog } from './client';
+
+// Configuration
+export type { OpenLifeLogConfig } from './config';
+
+// All types
+export * from './types';
+
+// Constants (metrics, etc.)
+export * from './constants/metrics';
+
+// Utilities (for advanced usage)
+export {
+  // Errors
+  OpenLifeLogError,
+  AuthenticationError,
+  AuthorizationError,
+  NotFoundError,
+  ValidationError,
+  RateLimitError,
+  ServerError,
+  NetworkError,
+  TimeoutError,
+  UnitConversionError,
+  // Unit conversion
+  WeightConverter,
+  DistanceConverter,
+  HeightConverter,
+  UnitConverter,
+  createUnitConverter,
+  // Pagination
+  PaginatedIterator,
+  createPaginatedIterator,
+  fetchAllPages,
+  hasMorePages,
+} from './utils';
+
+// Default export
+export { OpenLifeLog as default } from './client';

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@openlifelog/sdk",
+  "version": "1.0.0",
+  "description": "TypeScript SDK for the OpenLifeLog API - A comprehensive fitness and nutrition tracking platform",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup index.ts --format cjs,esm --dts",
+    "dev": "tsup index.ts --format cjs,esm --dts --watch",
+    "test": "jest",
+    "lint": "eslint . --ext .ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "openlifelog",
+    "fitness",
+    "nutrition",
+    "workout",
+    "tracking",
+    "health",
+    "sdk",
+    "typescript",
+    "api-client"
+  ],
+  "author": "OpenLifeLog",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kukicado/openlifelog.git",
+    "directory": "src/sdk/typescript"
+  },
+  "bugs": {
+    "url": "https://github.com/kukicado/openlifelog/issues"
+  },
+  "homepage": "https://github.com/kukicado/openlifelog#readme",
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0"
+  },
+  "dependencies": {},
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/resources/ai.ts

@@ -0,0 +1,26 @@
+import type { HttpClient } from '../utils/http';
+import type { FoodInsightsResponse, GetFoodInsightsParams } from '../types';
+
+/**
+ * AI resource
+ * Handles AI-powered insights and recommendations
+ */
+export class AIResource {
+  constructor(private http: HttpClient) {}
+
+  /**
+   * Get AI-generated nutrition insights
+   *
+   * @example
+   * ```typescript
+   * const insights = await client.ai.getFoodInsights({
+   *   startDate: '2024-01-01',
+   *   endDate: '2024-01-15'
+   * });
+   * ```
+   */
+  async getFoodInsights(params?: GetFoodInsightsParams): Promise<FoodInsightsResponse> {
+    const response = await this.http.get<FoodInsightsResponse>('/v1/ai/food-insights', params);
+    return response.data;
+  }
+}

package/resources/auth.ts

@@ -0,0 +1,98 @@
+import type { HttpClient } from '../utils/http';
+import type {
+  SignupRequest,
+  LoginRequest,
+  AuthResponse,
+  PasswordResetRequest,
+  PasswordResetConfirm,
+} from '../types';
+
+/**
+ * Authentication resource
+ * Handles user authentication operations
+ */
+export class AuthResource {
+  constructor(private http: HttpClient) {}
+
+  /**
+   * Sign up a new user
+   *
+   * @example
+   * ```typescript
+   * const { token, user } = await client.auth.signup({
+   *   name: 'John Doe',
+   *   email: 'john@example.com',
+   *   password: 'securePassword123'
+   * });
+   * ```
+   */
+  async signup(request: SignupRequest): Promise<AuthResponse> {
+    const response = await this.http.post<AuthResponse>('/v1/auth/signup', request);
+
+    // Automatically set the API key after successful signup
+    this.http.setApiKey(response.data.token);
+
+    return response.data;
+  }
+
+  /**
+   * Log in an existing user
+   *
+   * @example
+   * ```typescript
+   * const { token, user } = await client.auth.login({
+   *   email: 'john@example.com',
+   *   password: 'securePassword123'
+   * });
+   * ```
+   */
+  async login(request: LoginRequest): Promise<AuthResponse> {
+    const response = await this.http.post<AuthResponse>('/v1/auth/login', request);
+
+    // Automatically set the API key after successful login
+    this.http.setApiKey(response.data.token);
+
+    return response.data;
+  }
+
+  /**
+   * Request a password reset
+   *
+   * @example
+   * ```typescript
+   * await client.auth.requestPasswordReset({
+   *   email: 'john@example.com'
+   * });
+   * ```
+   */
+  async requestPasswordReset(request: PasswordResetRequest): Promise<void> {
+    await this.http.post('/v1/auth/password-reset/request', request);
+  }
+
+  /**
+   * Confirm password reset with token
+   *
+   * @example
+   * ```typescript
+   * await client.auth.confirmPasswordReset({
+   *   token: 'reset-token-from-email',
+   *   newPassword: 'newSecurePassword123'
+   * });
+   * ```
+   */
+  async confirmPasswordReset(request: PasswordResetConfirm): Promise<void> {
+    await this.http.post('/v1/auth/password-reset/confirm', request);
+  }
+
+  /**
+   * Log out the current user (clears the API key)
+   *
+   * @example
+   * ```typescript
+   * client.auth.logout();
+   * ```
+   */
+  logout(): void {
+    this.http.setApiKey('');
+  }
+}

package/resources/exercises.ts

@@ -0,0 +1,112 @@
+import type { HttpClient } from '../utils/http';
+import type {
+  Exercise,
+  CreateExerciseRequest,
+  UpdateExerciseRequest,
+  ListExercisesParams,
+  ListResponse,
+  CountResponse,
+} from '../types';
+import { createPaginatedIterator, type PaginatedIterator } from '../utils/pagination';
+
+/**
+ * Exercises resource
+ * Handles exercise database operations
+ */
+export class ExercisesResource {
+  constructor(private http: HttpClient) {}
+
+  /**
+   * List exercises with filtering
+   *
+   * @example
+   * ```typescript
+   * const { data } = await client.exercises.list({
+   *   category: 'strength',
+   *   muscleGroup: 'chest'
+   * });
+   * ```
+   */
+  async list(params?: ListExercisesParams): Promise<ListResponse<Exercise>> {
+    const response = await this.http.get<ListResponse<Exercise>>('/v1/exercises', params);
+    return response.data;
+  }
+
+  /**
+   * List exercises with automatic pagination
+   */
+  listAutoPaginate(params?: ListExercisesParams): PaginatedIterator<Exercise> {
+    return createPaginatedIterator((cursor) =>
+      this.list({ ...params, cursor })
+    );
+  }
+
+  /**
+   * Get total count of exercises
+   */
+  async count(): Promise<CountResponse> {
+    const response = await this.http.get<CountResponse>('/v1/exercises/count');
+    return response.data;
+  }
+
+  /**
+   * Search exercises by name
+   */
+  async search(params: { q: string; limit?: number; cursor?: string }): Promise<ListResponse<Exercise>> {
+    const response = await this.http.get<ListResponse<Exercise>>('/v1/exercises/search', params);
+    return response.data;
+  }
+
+  /**
+   * Get specific exercise by ID
+   */
+  async get(exerciseId: string): Promise<Exercise> {
+    const response = await this.http.get<Exercise>(`/v1/exercises/${exerciseId}`);
+    return response.data;
+  }
+
+  /**
+   * Create a new exercise
+   */
+  async create(request: CreateExerciseRequest): Promise<Exercise> {
+    const response = await this.http.post<Exercise>('/v1/exercises', request);
+    return response.data;
+  }
+
+  /**
+   * Update an existing exercise
+   */
+  async update(exerciseId: string, request: UpdateExerciseRequest): Promise<Exercise> {
+    const response = await this.http.put<Exercise>(`/v1/exercises/${exerciseId}`, request);
+    return response.data;
+  }
+
+  /**
+   * Delete an exercise
+   */
+  async delete(exerciseId: string): Promise<void> {
+    await this.http.delete(`/v1/exercises/${exerciseId}`);
+  }
+
+  /**
+   * Get favorite exercises
+   */
+  async getFavorites(params?: ListExercisesParams): Promise<ListResponse<Exercise>> {
+    const response = await this.http.get<ListResponse<Exercise>>('/v1/exercises/favorites', params);
+    return response.data;
+  }
+
+  /**
+   * Add exercise to favorites
+   */
+  async addToFavorites(exerciseId: string): Promise<void> {
+    await this.http.post(`/v1/exercises/${exerciseId}/favorite`);
+  }
+
+  /**
+   * Remove exercise from favorites
+   */
+  async removeFromFavorites(exerciseId: string): Promise<void> {
+    await this.http.delete(`/v1/exercises/${exerciseId}/favorite`);
+  }
+}

package/resources/food-logs.ts

@@ -0,0 +1,132 @@
+import type { HttpClient } from '../utils/http';
+import type {
+  FoodLog,
+  CreateFoodLogRequest,
+  UpdateFoodLogRequest,
+  QuickEntryFoodLogRequest,
+  ListFoodLogsParams,
+  DailyNutritionSummary,
+  GetDailySummaryParams,
+} from '../types';
+
+/**
+ * Food Logs resource
+ * Handles food logging and nutrition tracking
+ */
+export class FoodLogsResource {
+  constructor(private http: HttpClient) {}
+
+  /**
+   * List food log entries with filtering
+   *
+   * @example
+   * ```typescript
+   * const logs = await client.foodLogs.list({
+   *   date: '2024-01-15',
+   *   mealType: 'lunch'
+   * });
+   * ```
+   */
+  async list(params?: ListFoodLogsParams): Promise<FoodLog[]> {
+    const response = await this.http.get<FoodLog[]>('/v1/food-logs', params);
+    return response.data;
+  }
+
+  /**
+   * Get daily nutrition summary
+   *
+   * @example
+   * ```typescript
+   * const summary = await client.foodLogs.getDailySummary({
+   *   date: '2024-01-15'
+   * });
+   * console.log(`Total calories: ${summary.totalCalories}`);
+   * ```
+   */
+  async getDailySummary(params?: GetDailySummaryParams): Promise<DailyNutritionSummary> {
+    const response = await this.http.get<DailyNutritionSummary>('/v1/food-logs/summary', params);
+    return response.data;
+  }
+
+  /**
+   * Get specific food log entry
+   *
+   * @example
+   * ```typescript
+   * const log = await client.foodLogs.get('log-id');
+   * ```
+   */
+  async get(logId: string): Promise<FoodLog> {
+    const response = await this.http.get<FoodLog>(`/v1/food-logs/${logId}`);
+    return response.data;
+  }
+
+  /**
+   * Create a food log entry
+   *
+   * @example
+   * ```typescript
+   * const log = await client.foodLogs.create({
+   *   foodId: 'food-uuid',
+   *   name: 'Chicken Breast',
+   *   servingSizeName: 'breast (200g)',
+   *   quantity: 1.5,
+   *   unitGrams: 200,
+   *   mealType: 'lunch',
+   *   notes: 'Grilled with olive oil'
+   * });
+   * ```
+   */
+  async create(request: CreateFoodLogRequest): Promise<FoodLog> {
+    const response = await this.http.post<FoodLog>('/v1/food-logs', request);
+    return response.data;
+  }
+
+  /**
+   * Quick entry food log with just name and nutrients
+   * Creates a food log entry without creating a food (one-off entry)
+   *
+   * @example
+   * ```typescript
+   * const log = await client.foodLogs.quickEntry({
+   *   name: 'Homemade Salad',
+   *   protein: 15,
+   *   carbohydrates: 20,
+   *   fat: 10,
+   *   mealType: 'lunch'
+   * });
+   * ```
+   */
+  async quickEntry(request: QuickEntryFoodLogRequest): Promise<FoodLog> {
+    const response = await this.http.post<FoodLog>('/v1/food-logs-quick-entry', request);
+    return response.data;
+  }
+
+  /**
+   * Update a food log entry
+   *
+   * @example
+   * ```typescript
+   * const log = await client.foodLogs.update('log-id', {
+   *   quantity: 2,
+   *   notes: 'Updated portion size'
+   * });
+   * ```
+   */
+  async update(logId: string, request: UpdateFoodLogRequest): Promise<FoodLog> {
+    const response = await this.http.put<FoodLog>(`/v1/food-logs/${logId}`, request);
+    return response.data;
+  }
+
+  /**
+   * Delete a food log entry
+   *
+   * @example
+   * ```typescript
+   * await client.foodLogs.delete('log-id');
+   * ```
+   */
+  async delete(logId: string): Promise<void> {
+    await this.http.delete(`/v1/food-logs/${logId}`);
+  }
+}

package/resources/foods.ts

@@ -0,0 +1,185 @@
+import type { HttpClient } from '../utils/http';
+import type {
+  Food,
+  CreateFoodRequest,
+  UpdateFoodRequest,
+  ListFoodsParams,
+  ListResponse,
+  CountResponse,
+} from '../types';
+import { createPaginatedIterator, type PaginatedIterator } from '../utils/pagination';
+
+/**
+ * Foods resource
+ * Handles food database operations
+ */
+export class FoodsResource {
+  constructor(private http: HttpClient) {}
+
+  /**
+   * List foods with pagination and search
+   *
+   * @example
+   * ```typescript
+   * const { data, pageInfo } = await client.foods.list({
+   *   limit: 20,
+   *   search: 'chicken'
+   * });
+   * ```
+   */
+  async list(params?: ListFoodsParams): Promise<ListResponse<Food>> {
+    const response = await this.http.get<ListResponse<Food>>('/v1/foods', params);
+    return response.data;
+  }
+
+  /**
+   * List foods with automatic pagination
+   *
+   * @example
+   * ```typescript
+   * for await (const food of client.foods.listAutoPaginate({ limit: 100 })) {
+   *   console.log(food.name);
+   * }
+   * ```
+   */
+  listAutoPaginate(params?: ListFoodsParams): PaginatedIterator<Food> {
+    return createPaginatedIterator((cursor) =>
+      this.list({ ...params, cursor })
+    );
+  }
+
+  /**
+   * Get total count of foods
+   *
+   * @example
+   * ```typescript
+   * const { count } = await client.foods.count();
+   * console.log(`Database has ${count} foods`);
+   * ```
+   */
+  async count(): Promise<CountResponse> {
+    const response = await this.http.get<CountResponse>('/v1/foods/count');
+    return response.data;
+  }
+
+  /**
+   * Search foods by name or brand
+   *
+   * @example
+   * ```typescript
+   * const { data } = await client.foods.search({
+   *   q: 'chicken breast',
+   *   limit: 10
+   * });
+   * ```
+   */
+  async search(params: { q: string; limit?: number; cursor?: string }): Promise<ListResponse<Food>> {
+    const response = await this.http.get<ListResponse<Food>>('/v1/foods/search', params);
+    return response.data;
+  }
+
+  /**
+   * Get specific food by ID
+   *
+   * @example
+   * ```typescript
+   * const food = await client.foods.get('food-id');
+   * console.log(food.nutrients);
+   * ```
+   */
+  async get(foodId: string): Promise<Food> {
+    const response = await this.http.get<Food>(`/v1/foods/${foodId}`);
+    return response.data;
+  }
+
+  /**
+   * Create a new food item
+   *
+   * @example
+   * ```typescript
+   * const food = await client.foods.create({
+   *   name: 'Custom Protein Shake',
+   *   type: 'beverage',
+   *   nutrients: {
+   *     calories: 300,
+   *     protein: 40,
+   *     carbohydrates: 20,
+   *     fat: 5
+   *   },
+   *   servingSizes: [{
+   *     name: '1 serving',
+   *     grams: 300,
+   *     isDefault: true
+   *   }]
+   * });
+   * ```
+   */
+  async create(request: CreateFoodRequest): Promise<Food> {
+    const response = await this.http.post<Food>('/v1/foods', request);
+    return response.data;
+  }
+
+  /**
+   * Update an existing food item
+   *
+   * @example
+   * ```typescript
+   * const food = await client.foods.update('food-id', {
+   *   description: 'Updated description'
+   * });
+   * ```
+   */
+  async update(foodId: string, request: UpdateFoodRequest): Promise<Food> {
+    const response = await this.http.put<Food>(`/v1/foods/${foodId}`, request);
+    return response.data;
+  }
+
+  /**
+   * Delete a food item
+   *
+   * @example
+   * ```typescript
+   * await client.foods.delete('food-id');
+   * ```
+   */
+  async delete(foodId: string): Promise<void> {
+    await this.http.delete(`/v1/foods/${foodId}`);
+  }
+
+  /**
+   * Get favorite foods
+   *
+   * @example
+   * ```typescript
+   * const { data } = await client.foods.getFavorites();
+   * ```
+   */
+  async getFavorites(params?: ListFoodsParams): Promise<ListResponse<Food>> {
+    const response = await this.http.get<ListResponse<Food>>('/v1/foods/favorites', params);
+    return response.data;
+  }
+
+  /**
+   * Add food to favorites
+   *
+   * @example
+   * ```typescript
+   * await client.foods.addToFavorites('food-id');
+   * ```
+   */
+  async addToFavorites(foodId: string): Promise<void> {
+    await this.http.post(`/v1/foods/${foodId}/favorite`);
+  }
+
+  /**
+   * Remove food from favorites
+   *
+   * @example
+   * ```typescript
+   * await client.foods.removeFromFavorites('food-id');
+   * ```
+   */
+  async removeFromFavorites(foodId: string): Promise<void> {
+    await this.http.delete(`/v1/foods/${foodId}/favorite`);
+  }
+}