@wowsql/sdk 3.7.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.
@@ -232,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;
@@ -382,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;
@@ -148,6 +163,17 @@ export declare class Table<T = any> {
      * 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
      */
@@ -156,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;
@@ -274,6 +317,34 @@ export declare class QueryBuilder<T = any> {
      * 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';

package/dist/index.js

@@ -100,6 +100,27 @@ class WowSQLClient {
         const response = await this.client.get('/health');
         return response.data;
     }
+    /**
+     * Get the underlying axios instance for advanced use cases
+     */
+    getHttpClient() {
+        return this.client;
+    }
+    /**
+     * Get the base URL for this client
+     */
+    getBaseUrl() {
+        return this.baseUrl;
+    }
+    /**
+     * Close the client and clean up resources.
+     * Cancels any pending requests.
+     */
+    close() {
+        // Nothing to explicitly close with axios, but clear defaults to prevent reuse
+        this.client.defaults.baseURL = '';
+        this.client.defaults.headers.common = {};
+    }
 }
 exports.WowSQLClient = WowSQLClient;
 // ==================== Table Class ====================
@@ -154,6 +175,31 @@ class Table {
     async insert(data) {
         return this.create(data);
     }
+    /**
+     * Insert multiple records at once
+     */
+    async bulkInsert(records) {
+        const promises = records.map(record => this.client.post(`/${this.tableName}`, record).then(r => r.data));
+        return Promise.all(promises);
+    }
+    /**
+     * Upsert a record — insert or update on conflict.
+     *
+     * @param data - Record data to upsert
+     * @param onConflict - Column to detect conflict on (default: 'id')
+     */
+    async upsert(data, onConflict = 'id') {
+        try {
+            return await this.create(data);
+        }
+        catch {
+            const id = data[onConflict];
+            if (id !== undefined) {
+                return await this.update(id, data);
+            }
+            throw new errors_1.WOWSQLError(`Upsert failed: no '${onConflict}' field in data for conflict resolution`);
+        }
+    }
     /**
      * Update a record by ID
      */
@@ -168,6 +214,34 @@ class Table {
         const response = await this.client.delete(`/${this.tableName}/${id}`);
         return response.data;
     }
+    // ==================== Convenience Shortcuts ====================
+    eq(column, value) {
+        return new QueryBuilder(this.client, this.tableName).eq(column, value);
+    }
+    neq(column, value) {
+        return new QueryBuilder(this.client, this.tableName).neq(column, value);
+    }
+    gt(column, value) {
+        return new QueryBuilder(this.client, this.tableName).gt(column, value);
+    }
+    gte(column, value) {
+        return new QueryBuilder(this.client, this.tableName).gte(column, value);
+    }
+    lt(column, value) {
+        return new QueryBuilder(this.client, this.tableName).lt(column, value);
+    }
+    lte(column, value) {
+        return new QueryBuilder(this.client, this.tableName).lte(column, value);
+    }
+    orderBy(column, direction) {
+        return new QueryBuilder(this.client, this.tableName).orderBy(column, direction);
+    }
+    async count() {
+        return new QueryBuilder(this.client, this.tableName).count();
+    }
+    async paginate(page = 1, perPage = 20) {
+        return new QueryBuilder(this.client, this.tableName).paginate(page, perPage);
+    }
 }
 exports.Table = Table;
 // ==================== Query Builder ====================
@@ -470,6 +544,94 @@ class QueryBuilder {
         const result = await this.limit(1).get();
         return result.data[0] || null;
     }
+    /**
+     * Get exactly one record. Throws if zero or multiple results.
+     */
+    async single() {
+        const result = await this.limit(2).get();
+        if (result.data.length === 0) {
+            throw new errors_1.WOWSQLError('No records found', 404);
+        }
+        if (result.data.length > 1) {
+            throw new errors_1.WOWSQLError('Multiple records found when expecting single result', 400);
+        }
+        return result.data[0];
+    }
+    /**
+     * Get record count matching current filters (uses COUNT(*) aggregate).
+     */
+    async count() {
+        const saved = { ...this.options };
+        this.options.select = ['COUNT(*) as count'];
+        this.options.group_by = undefined;
+        this.options.having = undefined;
+        this.options.order = undefined;
+        this.options.limit = undefined;
+        this.options.offset = undefined;
+        try {
+            const result = await this.get();
+            return result.data[0]?.count ?? 0;
+        }
+        finally {
+            this.options = saved;
+        }
+    }
+    /**
+     * Get sum of a column matching current filters.
+     */
+    async sum(column) {
+        const saved = { ...this.options };
+        this.options.select = [`SUM("${column}") as total`];
+        this.options.group_by = undefined;
+        this.options.having = undefined;
+        this.options.order = undefined;
+        this.options.limit = undefined;
+        this.options.offset = undefined;
+        try {
+            const result = await this.get();
+            return result.data[0]?.total ?? 0;
+        }
+        finally {
+            this.options = saved;
+        }
+    }
+    /**
+     * Get average of a column matching current filters.
+     */
+    async avg(column) {
+        const saved = { ...this.options };
+        this.options.select = [`AVG("${column}") as average`];
+        this.options.group_by = undefined;
+        this.options.having = undefined;
+        this.options.order = undefined;
+        this.options.limit = undefined;
+        this.options.offset = undefined;
+        try {
+            const result = await this.get();
+            return result.data[0]?.average ?? 0;
+        }
+        finally {
+            this.options = saved;
+        }
+    }
+    /**
+     * Paginate results. Returns data along with pagination metadata.
+     */
+    async paginate(page = 1, perPage = 20) {
+        this.options.limit = perPage;
+        this.options.offset = (page - 1) * perPage;
+        const result = await this.get();
+        const totalPages = Math.ceil(result.total / perPage);
+        return {
+            data: result.data,
+            page,
+            perPage,
+            total: result.total,
+            totalPages,
+            hasNext: page < totalPages,
+            hasPrev: page > 1,
+        };
+    }
 }
 exports.QueryBuilder = QueryBuilder;
 // ==================== Exports ====================