@gymspace/sdk 1.9.1 → 1.9.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gymspace/sdk",
-  "version": "1.9.1",
+  "version": "1.9.4",
   "description": "GymSpace TypeScript SDK for API integration",
   "author": "GymSpace Team",
   "license": "MIT",

package/src/client.ts

@@ -18,7 +18,14 @@ export class ApiClient {
   private axiosInstance: AxiosInstance;
   private config: GymSpaceConfig;
   private refreshToken: string | null = null;
+  private rememberMe: boolean | null = null;
   private onTokenRefreshed?: (accessToken: string, refreshToken?: string) => void;
+  private onAuthFailure?: (error: AuthenticationError) => void;
+  private isRefreshing = false;
+  private failedRequestsQueue: Array<{
+    resolve: (token: string) => void;
+    reject: (error: Error) => void;
+  }> = [];
 
   public getAccessToken(): string | null {
     return this.config.apiKey || null;
@@ -109,6 +116,104 @@ export class ApiClient {
         return response;
       },
       async (error: AxiosError) => {
+        // Handle 401 with automatic token refresh
+        if (error.response?.status === 401) {
+          const originalRequest = error.config;
+
+          // Skip auth requests (login, refresh endpoints)
+          if ((originalRequest as any)?.skipAuth) {
+            throw this.handleError(error);
+          }
+
+          // If already refreshing, queue this request
+          if (this.isRefreshing && this.refreshToken) {
+            return new Promise((resolve, reject) => {
+              this.failedRequestsQueue.push({
+                resolve: (token: string) => {
+                  // Retry with new token
+                  if (originalRequest) {
+                    originalRequest.headers['Authorization'] = `Bearer ${token}`;
+                    this.axiosInstance.request(originalRequest).then(resolve).catch(reject);
+                  } else {
+                    reject(error);
+                  }
+                },
+                reject: (err: Error) => {
+                  reject(err);
+                },
+              });
+            });
+          }
+
+          // Start refresh process
+          if (this.refreshToken) {
+            this.isRefreshing = true;
+
+            try {
+              console.log('Access token expired, attempting refresh...');
+
+              // Call the member refresh endpoint directly
+              const response = await axios.post(
+                `${this.config.baseURL}/auth/members/refresh`,
+                { refresh_token: this.refreshToken },
+                { headers: { 'Content-Type': 'application/json' } },
+              );
+
+              const { accessToken: newAccessToken, refreshToken: newRefreshToken } = response.data;
+
+              console.log('Token refresh successful');
+
+              // Update SDK state
+              this.setAuthToken(newAccessToken);
+              if (newRefreshToken) {
+                this.setRefreshToken(newRefreshToken);
+              }
+
+              // Notify listeners
+              if (this.onTokenRefreshed) {
+                this.onTokenRefreshed(newAccessToken, newRefreshToken);
+              }
+
+              // Process queued requests
+              this.failedRequestsQueue.forEach((request) => {
+                request.resolve(newAccessToken);
+              });
+              this.failedRequestsQueue = [];
+
+              // Retry original request
+              if (originalRequest) {
+                originalRequest.headers['Authorization'] = `Bearer ${newAccessToken}`;
+                return this.axiosInstance.request(originalRequest);
+              }
+
+              throw error;
+            } catch (refreshError: any) {
+              console.error('Token refresh failed:', refreshError.message);
+
+              // Reject queued requests
+              this.failedRequestsQueue.forEach((request) => {
+                request.reject(refreshError);
+              });
+              this.failedRequestsQueue = [];
+
+              // Clear auth on refresh failure
+              this.clearAuth();
+
+              const authError = new AuthenticationError(
+                refreshError.response?.data?.message || 'Token refresh failed',
+              );
+
+              if (this.onAuthFailure) {
+                this.onAuthFailure(authError);
+              }
+
+              throw authError;
+            } finally {
+              this.isRefreshing = false;
+            }
+          }
+        }
+
         throw this.handleError(error);
       },
     );
@@ -167,6 +272,10 @@ export class ApiClient {
       headers['X-Gym-Id'] = options.gymId;
     }
 
+    if (options?.gymContextMode) {
+      headers['X-Gym-Context-Mode'] = options.gymContextMode;
+    }
+
     return { headers };
   }
 
@@ -228,6 +337,20 @@ export class ApiClient {
     return this.refreshToken;
   }
 
+  /**
+   * Set rememberMe preference from login response
+   */
+  setRememberMe(value: boolean): void {
+    this.rememberMe = value;
+  }
+
+  /**
+   * Get rememberMe preference
+   */
+  getRememberMe(): boolean | null {
+    return this.rememberMe;
+  }
+
   /**
    * Set callback for when tokens are refreshed by backend
    */
@@ -242,6 +365,13 @@ export class ApiClient {
     return this.onTokenRefreshed;
   }
 
+  /**
+   * Set callback for when authentication fails irrecoverably
+   */
+  setOnAuthFailure(callback: (error: AuthenticationError) => void): void {
+    this.onAuthFailure = callback;
+  }
+
   setGymId(gymId: string): void {
     this.axiosInstance.defaults.headers.common['X-Gym-Id'] = gymId;
   }
@@ -249,6 +379,7 @@ export class ApiClient {
   clearAuth(): void {
     delete this.config.apiKey;
     this.refreshToken = null;
+    this.rememberMe = null;
     delete this.axiosInstance.defaults.headers.common['Authorization'];
     delete this.axiosInstance.defaults.headers.common['X-Gym-Id'];
   }
@@ -256,4 +387,40 @@ export class ApiClient {
   getBaseUrl(): string {
     return this.config.baseURL;
   }
+
+  /**
+   * Get config for creating scoped SDK instances
+   * Exposes minimal config needed without exposing internal structure
+   */
+  getConfigForScoped(): {
+    baseURL: string;
+    apiKey?: string;
+    refreshToken?: string;
+    headers?: Record<string, string>;
+  } {
+    return {
+      baseURL: this.config.baseURL,
+      apiKey: this.config.apiKey,
+      refreshToken: this.refreshToken,
+      headers: this.config.headers,
+    };
+  }
+
+  /**
+   * Get axios instance defaults for scoped SDK
+   */
+  getAxiosDefaults(): Record<string, unknown> {
+    return { ...this.axiosInstance.defaults.headers.common };
+  }
+
+  /**
+   * Set common headers on axios instance (for scoped SDK setup)
+   */
+  setCommonHeaders(headers: Record<string, string>): void {
+    Object.entries(headers).forEach(([key, value]) => {
+      if (value !== undefined) {
+        this.axiosInstance.defaults.headers.common[key] = value;
+      }
+    });
+  }
 }

package/src/models/auth.ts

@@ -15,6 +15,7 @@ export interface RegisterOwnerDto {
 export interface LoginDto {
   email: string;
   password: string;
+  rememberMe?: boolean;
 }
 
 export interface LoginResponseDto {
@@ -119,9 +120,7 @@ export interface CollaboratorRoleDto {
   gymName: string;
 }
 
-export interface CurrentSessionResponse {
-  accessToken: string;
-  refreshToken?: string;
+export interface CurrentSessionBase {
   user: {
     id: string;
     email: string;
@@ -178,4 +177,16 @@ export interface CurrentSessionResponse {
   permissions: string[];
   collaborator?: CollaboratorRoleDto;
   isAuthenticated: boolean;
-}
+}
+
+export type CurrentSessionResponse = CurrentSessionBase & {
+  access_token: string;
+  refresh_token?: string;
+  accessToken?: string;
+  refreshToken?: string;
+};
+
+export type CurrentSessionResponseLegacy = CurrentSessionBase & {
+  accessToken: string;
+  refreshToken?: string;
+};

package/src/models/clients.ts

@@ -77,6 +77,8 @@ export interface Client {
   medicalConditions?: string;
   createdAt: string;
   updatedAt: string;
+  pinSet?: boolean;
+  lastLoginAt?: string;
   contracts?: Array<{
     id: string;
     status: string;

package/src/models/contracts.ts

@@ -1,4 +1,4 @@
-import { ContractStatus, CancellationReason, SuspensionType } from '@gymspace/shared';
+import { ContractStatus, ContractInstallmentStatus, CancellationReason, SuspensionType } from '@gymspace/shared';
 import { PaginationQueryDto } from '../types';
 
 export interface CreateContractDto {
@@ -12,6 +12,19 @@ export interface CreateContractDto {
   customPrice?: number;
   receiptIds?: string[];
   metadata?: Record<string, any>;
+  paymentPlan?: ContractPaymentPlanInput;
+}
+
+export interface ContractInstallmentScheduleDto {
+  dueDate: string;
+  amount: number;
+}
+
+export interface ContractPaymentPlanInput {
+  installmentsCount?: number;
+  downPaymentAmount?: number;
+  firstDueDate?: string;
+  schedule?: ContractInstallmentScheduleDto[];
 }
 
 export interface RenewContractDto {
@@ -93,6 +106,7 @@ export interface Contract {
   contractDocumentId?: string | null;
   paymentReceiptIds?: string[] | null;
   receiptIds?: string[];
+  accessGymIds?: string[];
   metadata?: Record<string, any>;
   createdByUserId?: string;
   updatedByUserId?: string | null;
@@ -156,6 +170,76 @@ export interface Contract {
   };
 }
 
+export interface ContractInstallment {
+  id: string;
+  contractId: string;
+  paymentPlanId: string;
+  installmentNumber: number;
+  dueDate: string;
+  amount: string;
+  paidAmount: string;
+  status: ContractInstallmentStatus;
+  paidAt?: string | null;
+  lastReminderAt?: string | null;
+  createdAt: string;
+  updatedAt: string;
+  deletedAt?: string | null;
+}
+
+export interface ContractPayment {
+  id: string;
+  contractId: string;
+  installmentId?: string | null;
+  paymentMethodId: string;
+  amount: string;
+  paidAt: string;
+  receiptIds?: string[];
+  notes?: string | null;
+  createdByUserId: string;
+  createdAt: string;
+  updatedAt: string;
+  deletedAt?: string | null;
+  paymentMethod?: {
+    id: string;
+    name: string;
+  };
+  installment?: {
+    id: string;
+    installmentNumber: number;
+    dueDate: string;
+  };
+}
+
+export interface ContractInstallmentsResponse {
+  contractId: string;
+  totalAmount: number;
+  totalPaid: number;
+  outstandingAmount: number;
+  nextDueDate?: string | null;
+  installments: ContractInstallment[];
+}
+
+export interface ContractPaymentsResponse {
+  contractId: string;
+  totalPaid: number;
+  payments: ContractPayment[];
+}
+
+export interface RegisterContractPaymentDto {
+  amount: number;
+  paymentMethodId: string;
+  paidAt?: string;
+  receiptIds?: string[];
+  notes?: string;
+  installmentId?: string;
+  applyMode?: 'oldest_due' | 'installment';
+}
+
+export interface RegisterContractPaymentResponse {
+  success: boolean;
+  payments: ContractPayment[];
+}
+
 export interface GetContractsParams extends PaginationQueryDto {
   status?: ContractStatus;
   clientName?: string;

package/src/models/credits.ts

@@ -1,8 +1,4 @@
-// Feature Types
-export enum FeatureType {
-  AI_GENERATION = 'ai_generation',
-  BULK_WHATSAPP = 'bulk_whatsapp',
-}
+import { FeatureType } from '@gymspace/shared';
 
 // Credit Account Models
 export interface CreditAccount {

package/src/models/dashboard.ts

@@ -29,12 +29,22 @@ export interface SalesRevenue {
 
 export interface Debts {
   totalDebt: number;
+  salesDebt?: number;
+  contractsDebt?: number;
   clientsWithDebt: number;
   averageDebt: number;
   startDate: string;
   endDate: string;
 }
 
+export interface Collections {
+  totalCollected: number;
+  salesCollected: number;
+  contractsCollected: number;
+  startDate: string;
+  endDate: string;
+}
+
 export interface CheckIns {
   totalCheckIns: number;
   uniqueClients: number;

package/src/models/gyms.ts

@@ -1,3 +1,5 @@
+import type { TemplateCode } from '@gymspace/shared';
+
 export interface CreateGymDto {
   name: string;
   description?: string;
@@ -59,6 +61,15 @@ export interface ContractSettings {
   expiringSoonDays?: number;
   gracePeriodDays?: number;
   enableExpirationNotifications?: boolean;
+  installmentsEnabled?: boolean;
+  defaultInstallmentsCount?: number;
+  defaultDownPaymentAmount?: number;
+  allowContractInstallmentOverride?: boolean;
+  allowReminderOverride?: boolean;
+  reminderDaysBeforeDue?: number[];
+  reminderDaysAfterDue?: number[];
+  reminderTemplateCode?: TemplateCode;
+  debtAccessPolicy?: 'allow_always' | 'block_overdue';
 }
 
 /**
@@ -77,6 +88,15 @@ export interface UpdateGymContractSettingsDto {
   expiringSoonDays?: number;
   gracePeriodDays?: number;
   enableExpirationNotifications?: boolean;
+  installmentsEnabled?: boolean;
+  defaultInstallmentsCount?: number;
+  defaultDownPaymentAmount?: number;
+  allowContractInstallmentOverride?: boolean;
+  allowReminderOverride?: boolean;
+  reminderDaysBeforeDue?: number[];
+  reminderDaysAfterDue?: number[];
+  reminderTemplateCode?: TemplateCode;
+  debtAccessPolicy?: 'allow_always' | 'block_overdue';
 }
 
 export interface Gym {

package/src/models/index.ts

@@ -9,6 +9,7 @@ export type {
 export * from './gyms';
 // collaborators types are in @gymspace/shared
 export * from './clients';
+export * from './members';
 export * from './membership-plans';
 export * from './contracts';
 export * from './dashboard';

package/src/models/members.ts

@@ -0,0 +1,133 @@
+// Member invite types
+export interface CreateMemberInviteDto {
+  sendWhatsApp?: boolean;
+  customMessage?: string;
+  expiresInHours?: number;
+}
+
+export interface MemberInvite {
+  id: string;
+  token: string;
+  code: string;
+  status: 'pending' | 'used' | 'expired';
+  expiresAt: string;
+  usedAt?: string;
+  createdAt: string;
+}
+
+export interface MemberInviteResponse {
+  invite: MemberInvite;
+  whatsappSent?: boolean;
+}
+
+export interface MemberInviteValidationResponse {
+  valid: boolean;
+  status: 'pending' | 'used' | 'expired';
+  gym: {
+    name: string;
+    logo?: string;
+    address?: string;
+    slug: string;
+  };
+  client: {
+    email: string;
+    name: string;
+  };
+  invite: {
+    id: string;
+    expiresAt: string;
+    status: 'pending' | 'used' | 'expired';
+  };
+}
+
+// Member auth types
+export interface MemberPinLoginDto {
+  identifier: string;
+  identifierType: 'phone' | 'email' | 'document';
+  documentType?: string;
+  pin: string;
+  gymSlug?: string;
+  gymId?: string;
+  rememberMe?: boolean;
+}
+
+export interface SetPinDto {
+  token: string;
+  pin: string;
+  pinConfirm: string;
+}
+
+export interface MemberLoginResponse {
+  accessToken: string;
+  refreshToken: string;
+  member: MemberProfile;
+}
+
+// Member profile types
+export interface MemberProfile {
+  id: string;
+  gymId: string;
+  clientNumber: string;
+  name: string;
+  phone?: string;
+  email?: string;
+  documentValue?: string;
+  documentType?: string;
+  status: 'active' | 'inactive';
+  pinSet: boolean;
+  lastLoginAt?: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+// Membership types
+export interface MemberMembership {
+  contract: {
+    id: string;
+    status: string;
+    startDate: string;
+    endDate: string;
+  };
+  plan: {
+    id: string;
+    name: string;
+    description?: string;
+  };
+  status: 'active' | 'inactive' | 'suspended' | 'cancelled';
+  daysRemaining: number;
+  checkInsRemaining?: number;
+}
+
+// Check-in types
+export interface MemberCheckIn {
+  id: string;
+  timestamp: string;
+  createdAt: string;
+  contract?: {
+    id: string;
+    planName: string;
+  };
+}
+
+// QR code types
+export interface QrTokenResponse {
+  qrToken: string;
+  expiresAt: string;
+}
+
+// Self check-in types
+export interface CheckInResponse {
+  success: boolean;
+  message: string;
+  checkIn: {
+    id: string;
+    gymClientId: string;
+    gymId: string;
+    timestamp: string;
+    createdAt: string;
+  };
+}
+
+export interface CheckInDto {
+  qrToken: string;
+}

package/src/models/membership-plans.ts

@@ -12,6 +12,7 @@ export interface CreateMembershipPlanDto {
   features?: string[];
   status?: 'active' | 'inactive' | 'archived';
   assetsIds?: string[];
+  allowAccessToGymIds?: string[];
 }
 
 export interface UpdateMembershipPlanDto {
@@ -29,6 +30,7 @@ export interface UpdateMembershipPlanDto {
   status?: 'active' | 'inactive' | 'archived';
   isActive?: boolean;
   assetsIds?: string[];
+  allowAccessToGymIds?: string[];
 }
 
 export interface MembershipPlan {
@@ -55,6 +57,7 @@ export interface MembershipPlan {
   status: 'active' | 'inactive' | 'archived';
   isActive: boolean;
   assetsIds?: string[];
+  allowAccessToGymIds?: string[];
   createdAt: string;
   updatedAt: string;
   _count?: {

package/src/resources/auth.ts

@@ -18,6 +18,7 @@ import {
   ResendResetCodeDto,
   ResendResetCodeResponseDto,
 } from '../models/auth';
+import { MemberPinLoginDto, SetPinDto, MemberLoginResponse } from '../models/members';
 import { SubscriptionPlan } from '../models/subscriptions';
 import { RequestOptions } from '../types';
 import { BaseResource } from './base';
@@ -29,8 +30,16 @@ export class AuthResource extends BaseResource {
     return this.client.post(`${this.basePath}/register/owner`, data, options);
   }
 
-  async login(data: LoginDto, options?: RequestOptions): Promise<LoginResponseDto> {
-    return this.client.post<LoginResponseDto>(`${this.basePath}/login`, data, options);
+  async login(
+    data: LoginDto,
+    options?: RequestOptions,
+    rememberMe?: boolean,
+  ): Promise<LoginResponseDto> {
+    return this.client.post<LoginResponseDto>(
+      `${this.basePath}/login`,
+      { ...data, rememberMe },
+      options,
+    );
   }
 
   async refreshToken(refreshToken: string, options?: RequestOptions): Promise<LoginResponseDto> {
@@ -137,4 +146,49 @@ export class AuthResource extends BaseResource {
       options,
     );
   }
+
+  /**
+   * Member login with PIN
+   * POST /auth/members/pin/login
+   */
+  async memberPinLogin(
+    data: MemberPinLoginDto,
+    options?: RequestOptions,
+  ): Promise<MemberLoginResponse> {
+    return this.client.post<MemberLoginResponse>(
+      `${this.basePath}/members/pin/login`,
+      data,
+      options,
+    );
+  }
+
+  /**
+   * Consume member invite and set initial PIN
+   * POST /auth/members/invite/consume
+   */
+  async consumeMemberInvite(
+    data: SetPinDto,
+    options?: RequestOptions,
+  ): Promise<{ success: boolean; message: string; gymSlug?: string }> {
+    return this.client.post<{ success: boolean; message: string; gymSlug?: string }>(
+      `${this.basePath}/members/invite/consume`,
+      data,
+      options,
+    );
+  }
+
+  /**
+   * Refresh member access token
+   * POST /auth/members/refresh
+   */
+  async refreshMemberToken(
+    refreshToken: string,
+    options?: RequestOptions,
+  ): Promise<MemberLoginResponse> {
+    return this.client.post<MemberLoginResponse>(
+      `${this.basePath}/members/refresh`,
+      { refresh_token: refreshToken },
+      options,
+    );
+  }
 }