@wowsql/sdk 3.4.0

package/dist/index.js

@@ -0,0 +1,264 @@
+"use strict";
+/**
+ * WowSQL TypeScript SDK
+ * Official client library for WowSQL REST API v2
+ *
+ * @version 2.0.0
+ * @license MIT
+ * @see https://github.com/wowsql/wowsql
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryBuilder = exports.Table = exports.WowSQLClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const errors_1 = require("./errors");
+// ==================== Main Client ====================
+class WowSQLClient {
+    constructor(config) {
+        // Build base URL
+        const protocol = config.secure !== false ? 'https' : 'http';
+        if (config.projectUrl.startsWith('http://') || config.projectUrl.startsWith('https://')) {
+            this.baseUrl = config.projectUrl;
+        }
+        else {
+            const domain = config.baseDomain || 'wowsql.com';
+            // If it already contains the base domain, don't append it again
+            if (config.projectUrl.includes(`.${domain}`) || config.projectUrl.endsWith(domain)) {
+                this.baseUrl = `${protocol}://${config.projectUrl}`;
+            }
+            else {
+                // Just a project slug, append domain
+                this.baseUrl = `${protocol}://${config.projectUrl}.${domain}`;
+            }
+        }
+        // Create axios instance
+        this.client = axios_1.default.create({
+            baseURL: `${this.baseUrl}/api/v2`,
+            headers: {
+                'Authorization': `Bearer ${config.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            timeout: config.timeout || 30000,
+        });
+        // Add error interceptor
+        this.client.interceptors.response.use((response) => response, (error) => {
+            if (error.response) {
+                const errorData = error.response.data;
+                const errorMessage = errorData?.detail || errorData?.message || error.message;
+                throw new errors_1.WOWSQLError(errorMessage, error.response.status, errorData);
+            }
+            throw new errors_1.WOWSQLError(error.message);
+        });
+    }
+    /**
+     * Get a table interface for fluent API
+     */
+    table(tableName) {
+        return new Table(this.client, tableName);
+    }
+    /**
+     * List all tables in the database
+     */
+    async listTables() {
+        const response = await this.client.get('/tables');
+        return response.data.tables;
+    }
+    /**
+     * Get table schema
+     */
+    async getTableSchema(tableName) {
+        const response = await this.client.get(`/tables/${tableName}/schema`);
+        return response.data;
+    }
+    /**
+     * Execute raw SQL query (read-only for safety)
+     */
+    async query(sql) {
+        const response = await this.client.post('/query', { sql });
+        return response.data.results || response.data;
+    }
+    /**
+     * Health check
+     */
+    async health() {
+        const response = await this.client.get('/health');
+        return response.data;
+    }
+}
+exports.WowSQLClient = WowSQLClient;
+// ==================== Table Class ====================
+class Table {
+    constructor(client, tableName) {
+        this.client = client;
+        this.tableName = tableName;
+    }
+    /**
+     * Query records with filters and pagination
+     *
+     * @example
+     * const users = await client.table('users')
+     *   .select(['id', 'name', 'email'])
+     *   .filter({ column: 'age', operator: 'gt', value: 18 })
+     *   .order('created_at', 'desc')
+     *   .limit(10)
+     *   .get();
+     */
+    select(columns) {
+        return new QueryBuilder(this.client, this.tableName).select(columns);
+    }
+    /**
+     * Query with filter
+     */
+    filter(filter) {
+        return new QueryBuilder(this.client, this.tableName).filter(filter);
+    }
+    /**
+     * Get all records (with optional limit)
+     */
+    async get(options) {
+        return new QueryBuilder(this.client, this.tableName).get(options);
+    }
+    /**
+     * Get a single record by ID
+     */
+    async getById(id) {
+        const response = await this.client.get(`/${this.tableName}/${id}`);
+        return response.data;
+    }
+    /**
+     * Create a new record
+     */
+    async create(data) {
+        const response = await this.client.post(`/${this.tableName}`, data);
+        return response.data;
+    }
+    /**
+     * Update a record by ID
+     */
+    async update(id, data) {
+        const response = await this.client.patch(`/${this.tableName}/${id}`, data);
+        return response.data;
+    }
+    /**
+     * Delete a record by ID
+     */
+    async delete(id) {
+        const response = await this.client.delete(`/${this.tableName}/${id}`);
+        return response.data;
+    }
+}
+exports.Table = Table;
+// ==================== Query Builder ====================
+class QueryBuilder {
+    constructor(client, tableName) {
+        this.client = client;
+        this.tableName = tableName;
+        this.options = {};
+    }
+    /**
+     * Select specific columns
+     */
+    select(columns) {
+        this.options.select = Array.isArray(columns) ? columns.join(',') : columns;
+        return this;
+    }
+    /**
+     * Add filter condition
+     */
+    filter(filter) {
+        if (!this.options.filter) {
+            this.options.filter = [];
+        }
+        if (Array.isArray(this.options.filter)) {
+            this.options.filter.push(filter);
+        }
+        else {
+            this.options.filter = [this.options.filter, filter];
+        }
+        return this;
+    }
+    /**
+     * Order by column
+     */
+    order(column, direction = 'asc') {
+        this.options.order = column;
+        this.options.orderDirection = direction;
+        return this;
+    }
+    /**
+     * Limit number of results
+     */
+    limit(limit) {
+        this.options.limit = limit;
+        return this;
+    }
+    /**
+     * Skip records (pagination)
+     */
+    offset(offset) {
+        this.options.offset = offset;
+        return this;
+    }
+    /**
+     * Execute query
+     */
+    async get(additionalOptions) {
+        const finalOptions = { ...this.options, ...additionalOptions };
+        // Build query parameters
+        const params = {};
+        if (finalOptions.select) {
+            params.select = finalOptions.select;
+        }
+        if (finalOptions.filter) {
+            const filters = Array.isArray(finalOptions.filter)
+                ? finalOptions.filter
+                : [finalOptions.filter];
+            params.filter = filters
+                .map((f) => `${f.column}.${f.operator}.${f.value}`)
+                .join(',');
+        }
+        if (finalOptions.order) {
+            params.order = finalOptions.order;
+            params.order_direction = finalOptions.orderDirection || 'asc';
+        }
+        if (finalOptions.limit !== undefined) {
+            params.limit = finalOptions.limit;
+        }
+        if (finalOptions.offset !== undefined) {
+            params.offset = finalOptions.offset;
+        }
+        const response = await this.client.get(`/${this.tableName}`, { params });
+        return response.data;
+    }
+    /**
+     * Get first record
+     */
+    async first() {
+        const result = await this.limit(1).get();
+        return result.data[0] || null;
+    }
+}
+exports.QueryBuilder = QueryBuilder;
+// ==================== Exports ====================
+// Re-export storage SDK
+__exportStar(require("./storage"), exports);
+__exportStar(require("./auth"), exports);
+__exportStar(require("./schema"), exports);
+__exportStar(require("./errors"), exports);
+exports.default = WowSQLClient;

package/dist/schema.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Schema management client for WowSQL.
+ * Requires SERVICE ROLE key.
+ */
+export interface ColumnDefinition {
+    name: string;
+    type: string;
+    auto_increment?: boolean;
+    unique?: boolean;
+    nullable?: boolean;
+    default?: string;
+}
+export interface CreateTableOptions {
+    tableName: string;
+    columns: ColumnDefinition[];
+    primaryKey?: string;
+    indexes?: string[];
+}
+export interface AlterTableOptions {
+    tableName: string;
+    operation: 'add_column' | 'drop_column' | 'modify_column' | 'rename_column';
+    columnName?: string;
+    columnType?: string;
+    newColumnName?: string;
+    nullable?: boolean;
+    default?: string;
+}
+export declare class WowSQLSchema {
+    private baseUrl;
+    private serviceKey;
+    /**
+     * Initialize schema client.
+     *
+     * ⚠️ IMPORTANT: Requires SERVICE ROLE key, not anonymous key!
+     *
+     * @param projectUrl - Project URL (e.g., "https://myproject.wowsql.com")
+     * @param serviceKey - SERVICE ROLE key (not anonymous key!)
+     */
+    constructor(projectUrl: string, serviceKey: string);
+    /**
+     * Create a new table.
+     */
+    createTable(options: CreateTableOptions): Promise<any>;
+    /**
+     * Alter an existing table.
+     */
+    alterTable(options: AlterTableOptions): Promise<any>;
+    /**
+     * Drop a table.
+     *
+     * ⚠️ WARNING: This operation cannot be undone!
+     */
+    dropTable(tableName: string, cascade?: boolean): Promise<any>;
+    /**
+     * Execute raw SQL for schema operations.
+     */
+    executeSQL(sql: string): Promise<any>;
+}

package/dist/schema.js

@@ -0,0 +1,116 @@
+"use strict";
+/**
+ * Schema management client for WowSQL.
+ * Requires SERVICE ROLE key.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WowSQLSchema = void 0;
+class WowSQLSchema {
+    /**
+     * Initialize schema client.
+     *
+     * ⚠️ IMPORTANT: Requires SERVICE ROLE key, not anonymous key!
+     *
+     * @param projectUrl - Project URL (e.g., "https://myproject.wowsql.com")
+     * @param serviceKey - SERVICE ROLE key (not anonymous key!)
+     */
+    constructor(projectUrl, serviceKey) {
+        this.baseUrl = projectUrl.replace(/\/$/, '');
+        this.serviceKey = serviceKey;
+    }
+    /**
+     * Create a new table.
+     */
+    async createTable(options) {
+        const url = `${this.baseUrl}/api/v2/schema/tables`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.serviceKey}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                table_name: options.tableName,
+                columns: options.columns,
+                primary_key: options.primaryKey,
+                indexes: options.indexes
+            })
+        });
+        if (response.status === 403) {
+            throw new Error('Schema operations require a SERVICE ROLE key. ' +
+                'You are using an anonymous key which cannot modify database schema.');
+        }
+        if (!response.ok) {
+            const error = await response.json();
+            throw new Error(`Failed to create table: ${error.detail || response.statusText}`);
+        }
+        return response.json();
+    }
+    /**
+     * Alter an existing table.
+     */
+    async alterTable(options) {
+        const url = `${this.baseUrl}/api/v2/schema/tables/${options.tableName}`;
+        const response = await fetch(url, {
+            method: 'PATCH',
+            headers: {
+                'Authorization': `Bearer ${this.serviceKey}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(options)
+        });
+        if (response.status === 403) {
+            throw new Error('Schema operations require a SERVICE ROLE key.');
+        }
+        if (!response.ok) {
+            const error = await response.json();
+            throw new Error(`Failed to alter table: ${error.detail || response.statusText}`);
+        }
+        return response.json();
+    }
+    /**
+     * Drop a table.
+     *
+     * ⚠️ WARNING: This operation cannot be undone!
+     */
+    async dropTable(tableName, cascade = false) {
+        const url = `${this.baseUrl}/api/v2/schema/tables/${tableName}?cascade=${cascade}`;
+        const response = await fetch(url, {
+            method: 'DELETE',
+            headers: {
+                'Authorization': `Bearer ${this.serviceKey}`
+            }
+        });
+        if (response.status === 403) {
+            throw new Error('Schema operations require a SERVICE ROLE key.');
+        }
+        if (!response.ok) {
+            const error = await response.json();
+            throw new Error(`Failed to drop table: ${error.detail || response.statusText}`);
+        }
+        return response.json();
+    }
+    /**
+     * Execute raw SQL for schema operations.
+     */
+    async executeSQL(sql) {
+        const url = `${this.baseUrl}/api/v2/schema/execute`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.serviceKey}`,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({ sql })
+        });
+        if (response.status === 403) {
+            throw new Error('Schema operations require a SERVICE ROLE key.');
+        }
+        if (!response.ok) {
+            const error = await response.json();
+            throw new Error(`Failed to execute SQL: ${error.detail || response.statusText}`);
+        }
+        return response.json();
+    }
+}
+exports.WowSQLSchema = WowSQLSchema;