@bantr-sports/sdk 12.4.6 → 12.7.0

package/api-type/src/modules/auth/auth.factory.d.ts

@@ -0,0 +1,4 @@
+import { AuthService } from './auth.service';
+export declare class AuthFactory {
+    static createInstance(): AuthService;
+}

package/api-type/src/modules/auth/auth.schema.d.ts

@@ -0,0 +1,421 @@
+import { z } from 'zod';
+export declare const passwordSchema: z.ZodString;
+export declare const authSetPasswordInputSchema: z.ZodEffects<z.ZodObject<{
+    newPassword: z.ZodString;
+    confirmPassword: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    newPassword: string;
+    confirmPassword: string;
+}, {
+    newPassword: string;
+    confirmPassword: string;
+}>, {
+    newPassword: string;
+    confirmPassword: string;
+}, {
+    newPassword: string;
+    confirmPassword: string;
+}>;
+export type authSetPasswordInputSchema = z.infer<typeof authSetPasswordInputSchema>;
+export declare const authLoginInputSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+    inviteToken: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    password: string;
+    inviteToken?: string | undefined;
+}, {
+    email: string;
+    password: string;
+    inviteToken?: string | undefined;
+}>;
+export type authLoginInputSchema = z.infer<typeof authLoginInputSchema>;
+export declare const authRegisterInputSchemaBase: z.ZodObject<{
+    firstName: z.ZodString;
+    lastName: z.ZodString;
+    email: z.ZodString;
+    phone: z.ZodString;
+    zipCode: z.ZodOptional<z.ZodString>;
+    birthday: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    gender: z.ZodEnum<["MALE", "FEMALE", "PREFER_NOT_TO_SAY"]>;
+    password: z.ZodString;
+    confirmPassword: z.ZodString;
+    avatar: z.ZodString;
+    address: z.ZodObject<{
+        id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        location: z.ZodNullable<z.ZodObject<{
+            type: z.ZodLiteral<"Point">;
+            coordinates: z.ZodObject<{
+                lat: z.ZodNumber;
+                lng: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                lng: number;
+                lat: number;
+            }, {
+                lng: number;
+                lat: number;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            type: "Point";
+            coordinates: {
+                lng: number;
+                lat: number;
+            };
+        }, {
+            type: "Point";
+            coordinates: {
+                lng: number;
+                lat: number;
+            };
+        }>>;
+        country: z.ZodString;
+        countryAlias: z.ZodString;
+        state: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        stateAlias: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        city: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        neighborhood: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        street: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        postalCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        streetNumber: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        complement: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        reference: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        formattedAddress: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        location: {
+            type: "Point";
+            coordinates: {
+                lng: number;
+                lat: number;
+            };
+        } | null;
+        country: string;
+        countryAlias: string;
+        id?: number | null | undefined;
+        city?: string | null | undefined;
+        street?: string | null | undefined;
+        state?: string | null | undefined;
+        stateAlias?: string | null | undefined;
+        neighborhood?: string | null | undefined;
+        postalCode?: string | null | undefined;
+        streetNumber?: string | null | undefined;
+        complement?: string | null | undefined;
+        reference?: string | null | undefined;
+        formattedAddress?: string | null | undefined;
+    }, {
+        location: {
+            type: "Point";
+            coordinates: {
+                lng: number;
+                lat: number;
+            };
+        } | null;
+        country: string;
+        countryAlias: string;
+        id?: number | null | undefined;
+        city?: string | null | undefined;
+        street?: string | null | undefined;
+        state?: string | null | undefined;
+        stateAlias?: string | null | undefined;
+        neighborhood?: string | null | undefined;
+        postalCode?: string | null | undefined;
+        streetNumber?: string | null | undefined;
+        complement?: string | null | undefined;
+        reference?: string | null | undefined;
+        formattedAddress?: string | null | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    firstName: string;
+    lastName: string;
+    avatar: string;
+    birthday: string;
+    email: string;
+    password: string;
+    gender: "MALE" | "FEMALE" | "PREFER_NOT_TO_SAY";
+    address: {
+        location: {
+            type: "Point";
+            coordinates: {
+                lng: number;
+                lat: number;
+            };
+        } | null;
+        country: string;
+        countryAlias: string;
+        id?: number | null | undefined;
+        city?: string | null | undefined;
+        street?: string | null | undefined;
+        state?: string | null | undefined;
+        stateAlias?: string | null | undefined;
+        neighborhood?: string | null | undefined;
+        postalCode?: string | null | undefined;
+        streetNumber?: string | null | undefined;
+        complement?: string | null | undefined;
+        reference?: string | null | undefined;
+        formattedAddress?: string | null | undefined;
+    };
+    phone: string;
+    confirmPassword: string;
+    zipCode?: string | undefined;
+}, {
+    firstName: string;
+    lastName: string;
+    avatar: string;
+    birthday: string;
+    email: string;
+    password: string;
+    gender: "MALE" | "FEMALE" | "PREFER_NOT_TO_SAY";
+    address: {
+        location: {
+            type: "Point";
+            coordinates: {
+                lng: number;
+                lat: number;
+            };
+        } | null;
+        country: string;
+        countryAlias: string;
+        id?: number | null | undefined;
+        city?: string | null | undefined;
+        street?: string | null | undefined;
+        state?: string | null | undefined;
+        stateAlias?: string | null | undefined;
+        neighborhood?: string | null | undefined;
+        postalCode?: string | null | undefined;
+        streetNumber?: string | null | undefined;
+        complement?: string | null | undefined;
+        reference?: string | null | undefined;
+        formattedAddress?: string | null | undefined;
+    };
+    phone: string;
+    confirmPassword: string;
+    zipCode?: string | undefined;
+}>;
+export type authRegisterInputSchemaBase = z.infer<typeof authRegisterInputSchemaBase>;
+export declare const authRegisterInputSchema: z.ZodEffects<z.ZodObject<{
+    firstName: z.ZodString;
+    lastName: z.ZodString;
+    email: z.ZodString;
+    phone: z.ZodString;
+    zipCode: z.ZodOptional<z.ZodString>;
+    birthday: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    gender: z.ZodEnum<["MALE", "FEMALE", "PREFER_NOT_TO_SAY"]>;
+    password: z.ZodString;
+    confirmPassword: z.ZodString;
+    avatar: z.ZodString;
+    address: z.ZodObject<{
+        id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        location: z.ZodNullable<z.ZodObject<{
+            type: z.ZodLiteral<"Point">;
+            coordinates: z.ZodObject<{
+                lat: z.ZodNumber;
+                lng: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                lng: number;
+                lat: number;
+            }, {
+                lng: number;
+                lat: number;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            type: "Point";
+            coordinates: {
+                lng: number;
+                lat: number;
+            };
+        }, {
+            type: "Point";
+            coordinates: {
+                lng: number;
+                lat: number;
+            };
+        }>>;
+        country: z.ZodString;
+        countryAlias: z.ZodString;
+        state: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        stateAlias: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        city: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        neighborhood: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        street: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        postalCode: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        streetNumber: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        complement: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        reference: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        formattedAddress: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        location: {
+            type: "Point";
+            coordinates: {
+                lng: number;
+                lat: number;
+            };
+        } | null;
+        country: string;
+        countryAlias: string;
+        id?: number | null | undefined;
+        city?: string | null | undefined;
+        street?: string | null | undefined;
+        state?: string | null | undefined;
+        stateAlias?: string | null | undefined;
+        neighborhood?: string | null | undefined;
+        postalCode?: string | null | undefined;
+        streetNumber?: string | null | undefined;
+        complement?: string | null | undefined;
+        reference?: string | null | undefined;
+        formattedAddress?: string | null | undefined;
+    }, {
+        location: {
+            type: "Point";
+            coordinates: {
+                lng: number;
+                lat: number;
+            };
+        } | null;
+        country: string;
+        countryAlias: string;
+        id?: number | null | undefined;
+        city?: string | null | undefined;
+        street?: string | null | undefined;
+        state?: string | null | undefined;
+        stateAlias?: string | null | undefined;
+        neighborhood?: string | null | undefined;
+        postalCode?: string | null | undefined;
+        streetNumber?: string | null | undefined;
+        complement?: string | null | undefined;
+        reference?: string | null | undefined;
+        formattedAddress?: string | null | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    firstName: string;
+    lastName: string;
+    avatar: string;
+    birthday: string;
+    email: string;
+    password: string;
+    gender: "MALE" | "FEMALE" | "PREFER_NOT_TO_SAY";
+    address: {
+        location: {
+            type: "Point";
+            coordinates: {
+                lng: number;
+                lat: number;
+            };
+        } | null;
+        country: string;
+        countryAlias: string;
+        id?: number | null | undefined;
+        city?: string | null | undefined;
+        street?: string | null | undefined;
+        state?: string | null | undefined;
+        stateAlias?: string | null | undefined;
+        neighborhood?: string | null | undefined;
+        postalCode?: string | null | undefined;
+        streetNumber?: string | null | undefined;
+        complement?: string | null | undefined;
+        reference?: string | null | undefined;
+        formattedAddress?: string | null | undefined;
+    };
+    phone: string;
+    confirmPassword: string;
+    zipCode?: string | undefined;
+}, {
+    firstName: string;
+    lastName: string;
+    avatar: string;
+    birthday: string;
+    email: string;
+    password: string;
+    gender: "MALE" | "FEMALE" | "PREFER_NOT_TO_SAY";
+    address: {
+        location: {
+            type: "Point";
+            coordinates: {
+                lng: number;
+                lat: number;
+            };
+        } | null;
+        country: string;
+        countryAlias: string;
+        id?: number | null | undefined;
+        city?: string | null | undefined;
+        street?: string | null | undefined;
+        state?: string | null | undefined;
+        stateAlias?: string | null | undefined;
+        neighborhood?: string | null | undefined;
+        postalCode?: string | null | undefined;
+        streetNumber?: string | null | undefined;
+        complement?: string | null | undefined;
+        reference?: string | null | undefined;
+        formattedAddress?: string | null | undefined;
+    };
+    phone: string;
+    confirmPassword: string;
+    zipCode?: string | undefined;
+}>, {
+    firstName: string;
+    lastName: string;
+    avatar: string;
+    birthday: string;
+    email: string;
+    password: string;
+    gender: "MALE" | "FEMALE" | "PREFER_NOT_TO_SAY";
+    address: {
+        location: {
+            type: "Point";
+            coordinates: {
+                lng: number;
+                lat: number;
+            };
+        } | null;
+        country: string;
+        countryAlias: string;
+        id?: number | null | undefined;
+        city?: string | null | undefined;
+        street?: string | null | undefined;
+        state?: string | null | undefined;
+        stateAlias?: string | null | undefined;
+        neighborhood?: string | null | undefined;
+        postalCode?: string | null | undefined;
+        streetNumber?: string | null | undefined;
+        complement?: string | null | undefined;
+        reference?: string | null | undefined;
+        formattedAddress?: string | null | undefined;
+    };
+    phone: string;
+    confirmPassword: string;
+    zipCode?: string | undefined;
+}, {
+    firstName: string;
+    lastName: string;
+    avatar: string;
+    birthday: string;
+    email: string;
+    password: string;
+    gender: "MALE" | "FEMALE" | "PREFER_NOT_TO_SAY";
+    address: {
+        location: {
+            type: "Point";
+            coordinates: {
+                lng: number;
+                lat: number;
+            };
+        } | null;
+        country: string;
+        countryAlias: string;
+        id?: number | null | undefined;
+        city?: string | null | undefined;
+        street?: string | null | undefined;
+        state?: string | null | undefined;
+        stateAlias?: string | null | undefined;
+        neighborhood?: string | null | undefined;
+        postalCode?: string | null | undefined;
+        streetNumber?: string | null | undefined;
+        complement?: string | null | undefined;
+        reference?: string | null | undefined;
+        formattedAddress?: string | null | undefined;
+    };
+    phone: string;
+    confirmPassword: string;
+    zipCode?: string | undefined;
+}>;
+export type authRegisterInputSchema = z.infer<typeof authRegisterInputSchema>;

package/api-type/src/modules/auth/auth.service.d.ts

@@ -0,0 +1,49 @@
+import { Member } from '../../models/member';
+import { RefreshToken } from '../../models/refresh_token';
+import { authLoginInputSchema, authSetPasswordInputSchema, authRegisterInputSchema } from './auth.schema';
+import Store from '../../utils/store';
+import Email from '../../emails/email';
+export interface AutoLoginResult {
+    success: boolean;
+    member: {
+        id: number;
+        email: string;
+        firstName: string | null;
+        lastName: string | null;
+        avatar?: string | null;
+    };
+}
+export interface SetPasswordResult {
+    success: boolean;
+    message: string;
+    accessToken: string;
+    refreshToken: string;
+}
+export declare class AuthService {
+    private readonly MemberModel;
+    private readonly RefreshTokenModel;
+    private readonly Store;
+    private readonly Email;
+    private readonly url;
+    constructor(MemberModel: typeof Member, RefreshTokenModel: typeof RefreshToken, Store: Store, Email: Email);
+    loginMember(input: authLoginInputSchema): Promise<{
+        success: boolean;
+        accessToken: string;
+        refreshToken: string;
+        user: import("../../types/auth").MemberAuthResponse;
+    }>;
+    autoLoginWithJwt(userId: number): Promise<AutoLoginResult>;
+    registerMember(input: authRegisterInputSchema): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    setPassword(input: authSetPasswordInputSchema, userId: number): Promise<SetPasswordResult>;
+    createVerificationLink(email: string, unhashedVerificationToken: string): Promise<string>;
+    generateWelcomeEmail(email: string, unhashedVerificationToken: string): Promise<void>;
+    private signAccessToken;
+    private signRefreshToken;
+    generateResetPasswordToken(userId: number, email: string, inviteToken?: string): string;
+    generateResetPasswordUrl(userId: number, email: string, inviteToken?: string): string;
+    private checkPassword;
+    private hashPassword;
+}

package/api-type/src/modules/auth/index.d.ts

@@ -0,0 +1,3 @@
+export { AuthService } from './auth.service';
+export { AuthFactory } from './auth.factory';
+export { authSetPasswordInputSchema as setPasswordInputSchema, authLoginInputSchema as loginInputSchema, authRegisterInputSchema as registerInputSchema, type authSetPasswordInputSchema as SetPasswordInput, type authLoginInputSchema as LoginInput, type authRegisterInputSchema as RegisterInput, } from './auth.schema';

package/api-type/src/modules/calendar/calendar-diagnostics.d.ts

@@ -0,0 +1,10 @@
+import { OAuth2Client } from 'google-auth-library';
+/**
+ * Diagnostic utility to verify calendar access token has correct scopes and belongs to expected account
+ * This helps debug persistent 401 errors by showing exactly what's wrong with the token
+ */
+export declare function assertCalendarScopeAndAccount(oAuth2Client: OAuth2Client, expectedEmail?: string): Promise<{
+    email: string | null | undefined;
+    aud: string | undefined;
+    scopes: string[];
+}>;

package/api-type/src/modules/calendar/calendar-fetch-client.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Google Calendar Fetch Client
+ *
+ * Direct fetch()-based implementation that bypasses googleapis library.
+ * Uses OAuth2Client for automatic token refresh management.
+ *
+ * Why this approach:
+ * - googleapis v166 has a bug where OAuth2Client credentials aren't properly used
+ * - Direct fetch() calls work perfectly with Authorization header
+ * - OAuth2Client.getAccessToken() handles token refresh automatically
+ * - Simpler, more transparent, and more reliable
+ */
+import { OAuth2Client } from 'google-auth-library';
+interface CalendarEvent {
+    summary?: string;
+    description?: string;
+    location?: string;
+    start?: {
+        dateTime?: string;
+        date?: string;
+        timeZone?: string;
+    };
+    end?: {
+        dateTime?: string;
+        date?: string;
+        timeZone?: string;
+    };
+    recurrence?: string[];
+    attendees?: Array<{
+        email: string;
+        displayName?: string;
+        responseStatus?: string;
+    }>;
+    reminders?: {
+        useDefault?: boolean;
+        overrides?: Array<{
+            method: string;
+            minutes: number;
+        }>;
+    };
+    conferenceData?: any;
+    [key: string]: any;
+}
+interface CalendarListParams {
+    maxResults?: number;
+    timeMin?: string;
+    timeMax?: string;
+    singleEvents?: boolean;
+    orderBy?: string;
+    [key: string]: any;
+}
+export declare class GoogleCalendarFetchClient {
+    private oauth2Client;
+    private readonly baseUrl;
+    constructor(oauth2Client: OAuth2Client);
+    /**
+     * Get a fresh access token (automatically refreshes if expired)
+     */
+    private getAccessToken;
+    /**
+     * Make a request to the Calendar API
+     */
+    private request;
+    /**
+     * Insert a new event
+     */
+    insertEvent(calendarId: string, event: CalendarEvent, params?: {
+        sendUpdates?: 'all' | 'externalOnly' | 'none';
+    }): Promise<CalendarEvent>;
+    /**
+     * Update an existing event (full replacement)
+     */
+    updateEvent(calendarId: string, eventId: string, event: CalendarEvent, params?: {
+        sendUpdates?: 'all' | 'externalOnly' | 'none';
+    }): Promise<CalendarEvent>;
+    /**
+     * Patch an existing event (partial update)
+     */
+    patchEvent(calendarId: string, eventId: string, event: Partial<CalendarEvent>, params?: {
+        sendUpdates?: 'all' | 'externalOnly' | 'none';
+    }): Promise<CalendarEvent>;
+    /**
+     * Delete an event
+     */
+    deleteEvent(calendarId: string, eventId: string, params?: {
+        sendUpdates?: 'all' | 'externalOnly' | 'none';
+    }): Promise<void>;
+    /**
+     * Get a single event
+     */
+    getEvent(calendarId: string, eventId: string): Promise<CalendarEvent>;
+    /**
+     * List events
+     */
+    listEvents(calendarId: string, params?: CalendarListParams): Promise<{
+        items: CalendarEvent[];
+        [key: string]: any;
+    }>;
+    /**
+     * Get the underlying OAuth2Client (for compatibility with existing code)
+     */
+    getOAuth2Client(): OAuth2Client;
+}
+export interface CalendarClientResult {
+    calendar: GoogleCalendarFetchClient;
+    oauth2Client: OAuth2Client;
+}
+export {};

package/api-type/src/modules/calendar/calendar-permissions.factory.d.ts

@@ -0,0 +1,9 @@
+import { CalendarPermissionsService } from './calendar-permissions.service';
+/**
+ * Factory for creating CalendarPermissionsService instances
+ * This is separate from OauthFactory which handles the oauth table for user session authentication
+ * Calendar functionality uses calendar_permissions table
+ */
+export declare class CalendarPermissionsFactory {
+    static createInstance(): CalendarPermissionsService;
+}

package/api-type/src/modules/calendar/calendar-permissions.service.d.ts

@@ -0,0 +1,74 @@
+import { OAuth2Client, OAuth2ClientOptions } from 'google-auth-library';
+import { CalendarPermissions } from '../../models/calendar_permissions';
+import { CalendarClientResult } from './calendar-fetch-client';
+/**
+ * Service for managing Google Calendar permissions using calendar_permissions table
+ * This is separate from OauthFactory which handles the oauth table for user session authentication
+ */
+export declare class CalendarPermissionsService {
+    private googleClient;
+    private googleOptions;
+    constructor(googleOauthOptions: OAuth2ClientOptions);
+    /**
+     * Get the OAuth2Client instance for making Google Calendar API calls
+     */
+    getClient(): OAuth2Client;
+    /**
+     * Generate Google Calendar authorization URL
+     */
+    generateCalendarAuthUrl(userId?: number, forceConsent?: boolean): string;
+    /**
+     * Verify Google Calendar OAuth callback code and return tokens
+     */
+    verifyCalendarToken(code: string): Promise<{
+        tokens: {
+            access_token: string;
+            refresh_token?: string | null;
+        };
+        payload: {
+            id: string;
+            email: string;
+            name?: string;
+            picture?: string;
+        };
+    }>;
+    /**
+     * Check if user has active calendar permissions
+     */
+    hasCalendarOAuth(memberId: number): Promise<boolean>;
+    /**
+     * Check if user needs to upgrade from legacy broad calendar scope to calendar.events
+     * Returns true if user has the old broad scope but not the new narrow scope
+     */
+    needsScopeUpgrade(memberId: number): Promise<boolean>;
+    /**
+     * Mark calendar permissions as requiring reauth (sets status to EXPIRED)
+     * This is called when token validation fails or diagnostics show the token is invalid
+     */
+    markRequiresReauth(memberId: number, reason?: string): Promise<void>;
+    /**
+     * Save calendar OAuth tokens to calendar_permissions table
+     */
+    upsertCalendarOAuth(payload: {
+        id: string;
+        email: string;
+        name?: string;
+        picture?: string;
+    }, memberId: number, accessToken: string, refreshToken?: string | null): Promise<void>;
+    /**
+     * Get calendar permissions for a user from calendar_permissions table
+     * Uses calendar_permissions table, NOT oauth table (which is for user session auth)
+     */
+    getCalendarPermissions(memberId: number, provider?: string): Promise<CalendarPermissions | null>;
+    /**
+     * Refresh access token using refresh_token from calendar_permissions table
+     */
+    refreshAccessToken(memberId: number, provider?: string): Promise<string>;
+    /**
+     * Create a Google Calendar API client with credentials from calendar_permissions table
+     * If accessToken is missing but refreshToken exists, attempts to refresh first
+     *
+     * Returns a fetch-based calendar client that bypasses googleapis library bug
+     */
+    createCalendarClient(memberId: number, provider?: string): Promise<CalendarClientResult>;
+}