@wowsql/sdk 3.6.0 → 3.8.0

package/dist/auth.d.ts

@@ -1,3 +1,5 @@
+import { WOWSQLError } from './errors';
+export { WOWSQLError };
 export interface ProjectAuthClientConfig {
     /** Project slug or full URL (e.g., `myproject` or `https://myproject.wowsql.com`) */
     projectUrl: string;
@@ -7,6 +9,8 @@ export interface ProjectAuthClientConfig {
     secure?: boolean;
     /** Request timeout in milliseconds */
     timeout?: number;
+    /** Verify SSL certificates (default: true). Set to false for self-signed certs in dev. */
+    verifySsl?: boolean;
     /**
      * Unified API key - Anonymous Key (wowsql_anon_...) for client-side,
      * or Service Role Key (wowsql_service_...) for server-side.
@@ -146,6 +150,74 @@ export declare class ProjectAuthClient {
         success: boolean;
         message: string;
     }>;
+    /**
+     * Send OTP code to user's email.
+     *
+     * Supports login, signup, and password_reset purposes.
+     *
+     * @param email - User's email address
+     * @param purpose - Purpose of OTP - 'login', 'signup', or 'password_reset' (default: 'login')
+     * @returns Object with success status and message
+     */
+    sendOtp(email: string, purpose?: 'login' | 'signup' | 'password_reset'): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Verify OTP and complete authentication.
+     *
+     * For signup: Creates new user if doesn't exist
+     * For login: Authenticates existing user
+     * For password_reset: Updates password if newPassword provided
+     *
+     * @param email - User's email address
+     * @param otp - 6-digit OTP code
+     * @param purpose - Purpose of OTP - 'login', 'signup', or 'password_reset' (default: 'login')
+     * @param newPassword - Required for password_reset purpose, new password (minimum 8 characters)
+     * @returns AuthResponse with session tokens and user info (for login/signup) or success message (for password_reset)
+     */
+    verifyOtp(email: string, otp: string, purpose?: 'login' | 'signup' | 'password_reset', newPassword?: string): Promise<AuthResponse | {
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Send magic link to user's email.
+     *
+     * Supports login, signup, and email_verification purposes.
+     *
+     * @param email - User's email address
+     * @param purpose - Purpose of magic link - 'login', 'signup', or 'email_verification' (default: 'login')
+     * @returns Object with success status and message
+     */
+    sendMagicLink(email: string, purpose?: 'login' | 'signup' | 'email_verification'): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Verify email using token (from magic link or OTP verification).
+     *
+     * Marks email as verified and sends welcome email.
+     *
+     * @param token - Verification token from email
+     * @returns Object with success status, message, and user info
+     */
+    verifyEmail(token: string): Promise<{
+        success: boolean;
+        message: string;
+        user?: AuthUser;
+    }>;
+    /**
+     * Resend verification email.
+     *
+     * Always returns success to prevent email enumeration.
+     *
+     * @param email - User's email address
+     * @returns Object with success status and message
+     */
+    resendVerification(email: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
     /**
      * Get the current session tokens.
      */
@@ -164,6 +236,48 @@ export declare class ProjectAuthClient {
      * Clear all stored tokens.
      */
     clearSession(): void;
+    /**
+     * Log out the current user. Invalidates the session on the server.
+     *
+     * @param accessToken - Optional access token override (uses stored token if not provided)
+     * @returns Object with success status and message
+     */
+    logout(accessToken?: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Refresh the access token using a refresh token.
+     *
+     * @param refreshToken - Optional refresh token override (uses stored token if not provided)
+     * @returns AuthResponse with new session tokens
+     */
+    refreshSession(refreshToken?: string): Promise<AuthResponse>;
+    /**
+     * Change the current user's password.
+     *
+     * @param currentPassword - Current password for verification
+     * @param newPassword - New password (minimum 8 characters)
+     * @param accessToken - Optional access token override
+     * @returns Object with success status and message
+     */
+    changePassword(currentPassword: string, newPassword: string, accessToken?: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Update the current user's profile.
+     *
+     * @param updates - Fields to update
+     * @param accessToken - Optional access token override
+     * @returns Updated AuthUser
+     */
+    updateUser(updates: {
+        fullName?: string;
+        avatarUrl?: string;
+        username?: string;
+        userMetadata?: Record<string, any>;
+    }, accessToken?: string): Promise<AuthUser>;
     private persistSession;
     private toWowError;
 }

package/dist/auth.js

@@ -3,9 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProjectAuthClient = void 0;
+exports.ProjectAuthClient = exports.WOWSQLError = void 0;
 const axios_1 = __importDefault(require("axios"));
 const errors_1 = require("./errors");
+Object.defineProperty(exports, "WOWSQLError", { enumerable: true, get: function () { return errors_1.WOWSQLError; } });
 class MemoryAuthTokenStorage {
     constructor() {
         this.accessToken = null;
@@ -216,6 +217,145 @@ class ProjectAuthClient {
             throw this.toWowError(error);
         }
     }
+    /**
+     * Send OTP code to user's email.
+     *
+     * Supports login, signup, and password_reset purposes.
+     *
+     * @param email - User's email address
+     * @param purpose - Purpose of OTP - 'login', 'signup', or 'password_reset' (default: 'login')
+     * @returns Object with success status and message
+     */
+    async sendOtp(email, purpose = 'login') {
+        if (!['login', 'signup', 'password_reset'].includes(purpose)) {
+            throw new errors_1.WOWSQLError("Purpose must be 'login', 'signup', or 'password_reset'");
+        }
+        try {
+            const response = await this.client.post('/otp/send', {
+                email,
+                purpose
+            });
+            return {
+                success: response.data.success ?? true,
+                message: response.data.message ?? 'If that email exists, an OTP code has been sent'
+            };
+        }
+        catch (error) {
+            throw this.toWowError(error);
+        }
+    }
+    /**
+     * Verify OTP and complete authentication.
+     *
+     * For signup: Creates new user if doesn't exist
+     * For login: Authenticates existing user
+     * For password_reset: Updates password if newPassword provided
+     *
+     * @param email - User's email address
+     * @param otp - 6-digit OTP code
+     * @param purpose - Purpose of OTP - 'login', 'signup', or 'password_reset' (default: 'login')
+     * @param newPassword - Required for password_reset purpose, new password (minimum 8 characters)
+     * @returns AuthResponse with session tokens and user info (for login/signup) or success message (for password_reset)
+     */
+    async verifyOtp(email, otp, purpose = 'login', newPassword) {
+        if (!['login', 'signup', 'password_reset'].includes(purpose)) {
+            throw new errors_1.WOWSQLError("Purpose must be 'login', 'signup', or 'password_reset'");
+        }
+        if (purpose === 'password_reset' && !newPassword) {
+            throw new errors_1.WOWSQLError("newPassword is required for password_reset purpose");
+        }
+        try {
+            const payload = {
+                email,
+                otp,
+                purpose
+            };
+            if (newPassword) {
+                payload.new_password = newPassword;
+            }
+            const response = await this.client.post('/otp/verify', payload);
+            if (purpose === 'password_reset') {
+                return {
+                    success: response.data.success ?? true,
+                    message: response.data.message ?? 'Password reset successfully! You can now login with your new password'
+                };
+            }
+            const session = this.persistSession(response.data);
+            const user = response.data.user ? mapUser(response.data.user) : undefined;
+            return { user, session };
+        }
+        catch (error) {
+            throw this.toWowError(error);
+        }
+    }
+    /**
+     * Send magic link to user's email.
+     *
+     * Supports login, signup, and email_verification purposes.
+     *
+     * @param email - User's email address
+     * @param purpose - Purpose of magic link - 'login', 'signup', or 'email_verification' (default: 'login')
+     * @returns Object with success status and message
+     */
+    async sendMagicLink(email, purpose = 'login') {
+        if (!['login', 'signup', 'email_verification'].includes(purpose)) {
+            throw new errors_1.WOWSQLError("Purpose must be 'login', 'signup', or 'email_verification'");
+        }
+        try {
+            const response = await this.client.post('/magic-link/send', {
+                email,
+                purpose
+            });
+            return {
+                success: response.data.success ?? true,
+                message: response.data.message ?? 'If that email exists, a magic link has been sent'
+            };
+        }
+        catch (error) {
+            throw this.toWowError(error);
+        }
+    }
+    /**
+     * Verify email using token (from magic link or OTP verification).
+     *
+     * Marks email as verified and sends welcome email.
+     *
+     * @param token - Verification token from email
+     * @returns Object with success status, message, and user info
+     */
+    async verifyEmail(token) {
+        try {
+            const response = await this.client.post('/verify-email', { token });
+            return {
+                success: response.data.success ?? true,
+                message: response.data.message ?? 'Email verified successfully!',
+                user: response.data.user ? mapUser(response.data.user) : undefined
+            };
+        }
+        catch (error) {
+            throw this.toWowError(error);
+        }
+    }
+    /**
+     * Resend verification email.
+     *
+     * Always returns success to prevent email enumeration.
+     *
+     * @param email - User's email address
+     * @returns Object with success status and message
+     */
+    async resendVerification(email) {
+        try {
+            const response = await this.client.post('/resend-verification', { email });
+            return {
+                success: response.data.success ?? true,
+                message: response.data.message ?? 'If that email exists, a verification email has been sent'
+            };
+        }
+        catch (error) {
+            throw this.toWowError(error);
+        }
+    }
     /**
      * Get the current session tokens.
      */
@@ -243,6 +383,111 @@ class ProjectAuthClient {
         this.storage.setAccessToken(null);
         this.storage.setRefreshToken(null);
     }
+    /**
+     * Log out the current user. Invalidates the session on the server.
+     *
+     * @param accessToken - Optional access token override (uses stored token if not provided)
+     * @returns Object with success status and message
+     */
+    async logout(accessToken) {
+        const token = accessToken || this.accessToken || this.storage.getAccessToken();
+        if (!token) {
+            throw new errors_1.WOWSQLError('Access token is required. Please sign in first.');
+        }
+        try {
+            const response = await this.client.post('/logout', {}, { headers: { Authorization: `Bearer ${token}` } });
+            this.clearSession();
+            return {
+                success: response.data.success ?? true,
+                message: response.data.message ?? 'Logged out successfully',
+            };
+        }
+        catch (error) {
+            this.clearSession();
+            throw this.toWowError(error);
+        }
+    }
+    /**
+     * Refresh the access token using a refresh token.
+     *
+     * @param refreshToken - Optional refresh token override (uses stored token if not provided)
+     * @returns AuthResponse with new session tokens
+     */
+    async refreshSession(refreshToken) {
+        const token = refreshToken || this.refreshToken || this.storage.getRefreshToken();
+        if (!token) {
+            throw new errors_1.WOWSQLError('Refresh token is required');
+        }
+        try {
+            const response = await this.client.post('/token/refresh', {
+                refresh_token: token,
+            });
+            const session = this.persistSession(response.data);
+            const user = response.data.user ? mapUser(response.data.user) : undefined;
+            return { user, session };
+        }
+        catch (error) {
+            throw this.toWowError(error);
+        }
+    }
+    /**
+     * Change the current user's password.
+     *
+     * @param currentPassword - Current password for verification
+     * @param newPassword - New password (minimum 8 characters)
+     * @param accessToken - Optional access token override
+     * @returns Object with success status and message
+     */
+    async changePassword(currentPassword, newPassword, accessToken) {
+        const token = accessToken || this.accessToken || this.storage.getAccessToken();
+        if (!token) {
+            throw new errors_1.WOWSQLError('Access token is required. Please sign in first.');
+        }
+        try {
+            const response = await this.client.post('/change-password', {
+                current_password: currentPassword,
+                new_password: newPassword,
+            }, { headers: { Authorization: `Bearer ${token}` } });
+            return {
+                success: response.data.success ?? true,
+                message: response.data.message ?? 'Password changed successfully',
+            };
+        }
+        catch (error) {
+            throw this.toWowError(error);
+        }
+    }
+    /**
+     * Update the current user's profile.
+     *
+     * @param updates - Fields to update
+     * @param accessToken - Optional access token override
+     * @returns Updated AuthUser
+     */
+    async updateUser(updates, accessToken) {
+        const token = accessToken || this.accessToken || this.storage.getAccessToken();
+        if (!token) {
+            throw new errors_1.WOWSQLError('Access token is required. Please sign in first.');
+        }
+        try {
+            const body = {};
+            if (updates.fullName !== undefined)
+                body.full_name = updates.fullName;
+            if (updates.avatarUrl !== undefined)
+                body.avatar_url = updates.avatarUrl;
+            if (updates.username !== undefined)
+                body.username = updates.username;
+            if (updates.userMetadata !== undefined)
+                body.user_metadata = updates.userMetadata;
+            const response = await this.client.patch('/me', body, {
+                headers: { Authorization: `Bearer ${token}` },
+            });
+            return mapUser(response.data);
+        }
+        catch (error) {
+            throw this.toWowError(error);
+        }
+    }
     persistSession(raw) {
         const session = mapSession(raw);
         this.accessToken = session.accessToken;

package/dist/errors.d.ts

@@ -3,3 +3,12 @@ export declare class WOWSQLError extends Error {
     response?: any | undefined;
     constructor(message: string, statusCode?: number | undefined, response?: any | undefined);
 }
+export declare class SchemaPermissionError extends WOWSQLError {
+    constructor(message?: string, statusCode?: number, response?: any);
+}
+export declare class StorageError extends WOWSQLError {
+    constructor(message: string, statusCode?: number, response?: any);
+}
+export declare class StorageLimitExceededError extends StorageError {
+    constructor(message?: string, statusCode?: number, response?: any);
+}

package/dist/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WOWSQLError = void 0;
+exports.StorageLimitExceededError = exports.StorageError = exports.SchemaPermissionError = exports.WOWSQLError = void 0;
 class WOWSQLError extends Error {
     constructor(message, statusCode, response) {
         super(message);
@@ -10,3 +10,24 @@ class WOWSQLError extends Error {
     }
 }
 exports.WOWSQLError = WOWSQLError;
+class SchemaPermissionError extends WOWSQLError {
+    constructor(message = 'Schema operations require a SERVICE ROLE key. You are using an anonymous key which cannot modify database schema.', statusCode = 403, response) {
+        super(message, statusCode, response);
+        this.name = 'SchemaPermissionError';
+    }
+}
+exports.SchemaPermissionError = SchemaPermissionError;
+class StorageError extends WOWSQLError {
+    constructor(message, statusCode, response) {
+        super(message, statusCode, response);
+        this.name = 'StorageError';
+    }
+}
+exports.StorageError = StorageError;
+class StorageLimitExceededError extends StorageError {
+    constructor(message = 'Storage limit exceeded', statusCode = 413, response) {
+        super(message, statusCode, response);
+        this.name = 'StorageLimitExceededError';
+    }
+}
+exports.StorageLimitExceededError = StorageLimitExceededError;

package/dist/index.d.ts

@@ -18,6 +18,8 @@ export interface WowSQLConfig {
     secure?: boolean;
     /** Request timeout in milliseconds (default: 30000) */
     timeout?: number;
+    /** Verify SSL certificates (default: true). Set to false for self-signed certs in dev. */
+    verifySsl?: boolean;
 }
 export interface QueryOptions {
     /** Columns to select (comma-separated or array) - can include expressions like "COUNT(*)", "DATE(created_at) as date" */
@@ -111,6 +113,19 @@ export declare class WowSQLClient {
         status: string;
         timestamp: string;
     }>;
+    /**
+     * Get the underlying axios instance for advanced use cases
+     */
+    getHttpClient(): AxiosInstance;
+    /**
+     * Get the base URL for this client
+     */
+    getBaseUrl(): string;
+    /**
+     * Close the client and clean up resources.
+     * Cancels any pending requests.
+     */
+    close(): void;
 }
 export declare class Table<T = any> {
     private client;
@@ -144,6 +159,21 @@ export declare class Table<T = any> {
      * Create a new record
      */
     create(data: Partial<T>): Promise<CreateResponse>;
+    /**
+     * Insert a new record (alias for create)
+     */
+    insert(data: Partial<T>): Promise<CreateResponse>;
+    /**
+     * Insert multiple records at once
+     */
+    bulkInsert(records: Partial<T>[]): Promise<CreateResponse[]>;
+    /**
+     * Upsert a record — insert or update on conflict.
+     *
+     * @param data - Record data to upsert
+     * @param onConflict - Column to detect conflict on (default: 'id')
+     */
+    upsert(data: Partial<T>, onConflict?: string): Promise<CreateResponse | UpdateResponse>;
     /**
      * Update a record by ID
      */
@@ -152,6 +182,23 @@ export declare class Table<T = any> {
      * Delete a record by ID
      */
     delete(id: string | number): Promise<DeleteResponse>;
+    eq(column: string, value: any): QueryBuilder<T>;
+    neq(column: string, value: any): QueryBuilder<T>;
+    gt(column: string, value: any): QueryBuilder<T>;
+    gte(column: string, value: any): QueryBuilder<T>;
+    lt(column: string, value: any): QueryBuilder<T>;
+    lte(column: string, value: any): QueryBuilder<T>;
+    orderBy(column: string | OrderByItem[], direction?: 'asc' | 'desc'): QueryBuilder<T>;
+    count(): Promise<number>;
+    paginate(page?: number, perPage?: number): Promise<{
+        data: T[];
+        page: number;
+        perPage: number;
+        total: number;
+        totalPages: number;
+        hasNext: boolean;
+        hasPrev: boolean;
+    }>;
 }
 export declare class QueryBuilder<T = any> {
     private client;
@@ -202,14 +249,102 @@ export declare class QueryBuilder<T = any> {
      * Skip records (pagination)
      */
     offset(offset: number): this;
+    /**
+     * Filter where column equals value
+     */
+    eq(column: string, value: any): this;
+    /**
+     * Filter where column does not equal value
+     */
+    neq(column: string, value: any): this;
+    /**
+     * Filter where column is greater than value
+     */
+    gt(column: string, value: any): this;
+    /**
+     * Filter where column is greater than or equal to value
+     */
+    gte(column: string, value: any): this;
+    /**
+     * Filter where column is less than value
+     */
+    lt(column: string, value: any): this;
+    /**
+     * Filter where column is less than or equal to value
+     */
+    lte(column: string, value: any): this;
+    /**
+     * Filter where column matches pattern (SQL LIKE)
+     */
+    like(column: string, value: string): this;
+    /**
+     * Filter where column IS NULL
+     */
+    isNull(column: string): this;
+    /**
+     * Filter where column IS NOT NULL
+     */
+    isNotNull(column: string): this;
+    /**
+     * Filter where column is in list of values
+     */
+    in(column: string, values: any[]): this;
+    /**
+     * Filter where column is not in list of values
+     */
+    notIn(column: string, values: any[]): this;
+    /**
+     * Filter where column is between min and max values
+     */
+    between(column: string, minValue: any, maxValue: any): this;
+    /**
+     * Filter where column is not between min and max values
+     */
+    notBetween(column: string, minValue: any, maxValue: any): this;
+    /**
+     * Add an OR filter condition
+     */
+    or(column: string, operator: FilterExpression['operator'], value: any): this;
     /**
      * Execute query - uses POST /{table}/query for advanced features, GET for simple queries
      */
     get(additionalOptions?: QueryOptions): Promise<QueryResponse<T>>;
+    /**
+     * Execute the query (alias for get)
+     */
+    execute(additionalOptions?: QueryOptions): Promise<QueryResponse<T>>;
     /**
      * Get first record
      */
     first(): Promise<T | null>;
+    /**
+     * Get exactly one record. Throws if zero or multiple results.
+     */
+    single(): Promise<T>;
+    /**
+     * Get record count matching current filters (uses COUNT(*) aggregate).
+     */
+    count(): Promise<number>;
+    /**
+     * Get sum of a column matching current filters.
+     */
+    sum(column: string): Promise<number>;
+    /**
+     * Get average of a column matching current filters.
+     */
+    avg(column: string): Promise<number>;
+    /**
+     * Paginate results. Returns data along with pagination metadata.
+     */
+    paginate(page?: number, perPage?: number): Promise<{
+        data: T[];
+        page: number;
+        perPage: number;
+        total: number;
+        totalPages: number;
+        hasNext: boolean;
+        hasPrev: boolean;
+    }>;
 }
 export * from './storage';
 export * from './auth';