@forgebase/sdk 0.0.1

package/dist/esm/database/client/client.js

@@ -0,0 +1,805 @@
+/* eslint-disable prefer-const */
+import axios from 'axios';
+export class DatabaseSDK {
+    /**
+     * Create a new DatabaseSDK instance
+     * @param baseUrl The base URL for API requests
+     * @param axiosInstance Optional custom axios instance (e.g., from ForgebaseAuth)
+     * @param axiosConfig Optional axios configuration
+     * @param authInterceptors Optional auth interceptors to apply to the axios instance
+     */
+    constructor(options) {
+        let { baseUrl, axiosInstance, axiosConfig, authInterceptors } = options;
+        this.baseUrl = baseUrl.replace(/\/$/, ''); // Remove trailing slash if present
+        if (!axiosConfig) {
+            axiosConfig = {};
+        }
+        // Use the provided axios instance or create a new one
+        if (axiosInstance) {
+            this.axiosInstance = axiosInstance;
+        }
+        else {
+            this.axiosInstance = axios.create({
+                baseURL: this.baseUrl,
+                withCredentials: true,
+                ...axiosConfig,
+            });
+            // Apply auth interceptors if provided
+            if (authInterceptors) {
+                this.applyAuthInterceptors(authInterceptors);
+            }
+        }
+    }
+    /**
+     * Get the base URL used for API requests
+     * @returns The base URL string
+     */
+    getBaseUrl() {
+        return this.baseUrl;
+    }
+    /**
+     * Set a new base URL for API requests
+     * @param baseUrl The new base URL to use
+     */
+    setBaseUrl(baseUrl) {
+        this.baseUrl = baseUrl.replace(/\/$/, ''); // Remove trailing slash if present
+        // Update the axios instance baseURL if it was created by this class
+        if (this.axiosInstance.defaults.baseURL) {
+            this.axiosInstance.defaults.baseURL = this.baseUrl;
+        }
+    }
+    /**
+     * Get the axios instance used for API requests
+     * @returns The axios instance
+     */
+    getAxiosInstance() {
+        return this.axiosInstance;
+    }
+    /**
+     * Set a new axios instance for API requests
+     * @param axiosInstance The new axios instance to use
+     */
+    setAxiosInstance(axiosInstance) {
+        this.axiosInstance = axiosInstance;
+    }
+    /**
+     * Apply auth interceptors to the axios instance
+     * @param authInterceptors The auth interceptors to apply
+     */
+    applyAuthInterceptors(authInterceptors) {
+        // Add request interceptor
+        this.axiosInstance.interceptors.request.use(authInterceptors.request);
+        // Add response interceptors
+        this.axiosInstance.interceptors.response.use(authInterceptors.response.onFulfilled, authInterceptors.response.onRejected);
+    }
+    /**
+     * Fetches records from a specified table with filtering and pagination
+     * @param tableName The name of the table to query
+     * @param params Query parameters including filters and pagination
+     * @param options Query options
+     * @param axiosConfig Custom axios config for this specific request
+     * @returns Promise containing the fetched records
+     */
+    async getRecords(tableName, params = {}, options = { execute: true }, axiosConfig = {}) {
+        // If execute is false, return only the parameters
+        if (!options.execute) {
+            return { params: params };
+        }
+        const url = `/query/${tableName}`;
+        try {
+            const response = await this.axiosInstance.post(url, { query: params }, axiosConfig);
+            return {
+                records: response.data,
+                params: params,
+                message: 'Records fetched successfully',
+                error: undefined,
+            };
+        }
+        catch (error) {
+            if (axios.isAxiosError(error)) {
+                throw new Error(error.response?.data?.error || error.message);
+            }
+            throw error;
+        }
+    }
+    // private serializeQueryParams<T extends Record<string, any>>(
+    //   params: QueryParams<T>
+    // ): Record<string, string> {
+    //   const serialized: Record<string, string> = {};
+    //   // any param that is type of object should be serialized to JSON
+    //   Object.entries(params).forEach(([key, value]) => {
+    //     if (typeof value === 'object') {
+    //       serialized[key] = JSON.stringify(value);
+    //     } else {
+    //       serialized[key] = value.toString();
+    //     }
+    //   });
+    //   return serialized;
+    // }
+    /**
+     * Creates a new record in the specified table
+     * @param tableName The name of the table to create the record in
+     * @param data The data to create the record with
+     * @param axiosConfig Custom axios config for this specific request
+     * @returns Promise containing the created record
+     */
+    async createRecord(tableName, data, axiosConfig = {}) {
+        this.validateData(data);
+        try {
+            const response = await this.axiosInstance.post(`/create/${tableName}`, { data }, axiosConfig);
+            return {
+                records: [response.data],
+                message: 'Record created successfully',
+                error: undefined,
+            };
+        }
+        catch (error) {
+            if (axios.isAxiosError(error)) {
+                throw new Error(error.response?.data?.error || error.message);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Updates a record by ID in the specified table
+     * @param tableName The name of the table containing the record to update
+     * @param id The ID of the record to update
+     * @param data The data to update the record with
+     * @param axiosConfig Custom axios config for this specific request
+     * @returns Promise containing the updated record
+     */
+    async updateRecord(tableName, id, data, axiosConfig = {}) {
+        this.validateData(data);
+        try {
+            const response = await this.axiosInstance.put(`/update/${tableName}/${id}`, { data }, axiosConfig);
+            return {
+                records: [response.data],
+                message: 'Record updated successfully',
+                error: undefined,
+            };
+        }
+        catch (error) {
+            if (axios.isAxiosError(error)) {
+                throw new Error(error.response?.data?.error || error.message);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Updates records by Complex Query from the specified table
+     * @param tableName The name of the table containing the record to delete
+     * @param params Query parameters including filters and pagination
+     * @param options Query options
+     * @param data The data to update the record with
+     * @param axiosConfig Custom axios config for this specific request
+     * @returns Promise containing the result of the deletion
+     */
+    async advanceUpdateRecord(tableName, data, params = {}, options = { execute: true }, axiosConfig = {}) {
+        try {
+            if (!options.execute) {
+                return { params: params };
+            }
+            const response = await this.axiosInstance.post(`/update/${tableName}`, { query: params, data }, axiosConfig);
+            return {
+                message: 'Records updated successfully',
+                error: undefined,
+                records: response.data,
+            };
+        }
+        catch (error) {
+            if (axios.isAxiosError(error)) {
+                throw new Error(error.response?.data?.error || error.message);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Deletes a record by ID from the specified table
+     * @param tableName The name of the table containing the record to delete
+     * @param id The ID of the record to delete
+     * @param axiosConfig Custom axios config for this specific request
+     * @returns Promise containing the result of the deletion
+     */
+    async deleteRecord(tableName, id, axiosConfig = {}) {
+        try {
+            const response = await this.axiosInstance.post(`/del/${tableName}/${id}`, {}, axiosConfig);
+            return {
+                message: 'Record deleted successfully',
+                error: undefined,
+                records: response.data,
+            };
+        }
+        catch (error) {
+            if (axios.isAxiosError(error)) {
+                throw new Error(error.response?.data?.error || error.message);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Deletes records by Complex Query from the specified table
+     * @param tableName The name of the table containing the record to delete
+     * @param params Query parameters including filters and pagination
+     * @param options Query options
+     * @param axiosConfig Custom axios config for this specific request
+     * @returns Promise containing the result of the deletion
+     */
+    async advanceDeleteRecord(tableName, params = {}, options = { execute: true }, axiosConfig = {}) {
+        try {
+            if (!options.execute) {
+                return { params: params };
+            }
+            const response = await this.axiosInstance.post(`/del/${tableName}`, { query: params }, axiosConfig);
+            return {
+                message: 'Record deleted successfully',
+                error: undefined,
+                records: response.data,
+            };
+        }
+        catch (error) {
+            if (axios.isAxiosError(error)) {
+                throw new Error(error.response?.data?.error || error.message);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Helper method to create a query builder for fluent API usage
+     * @param tableName The name of the table to query
+     */
+    table(tableName) {
+        return new QueryBuilder(this, tableName);
+    }
+    /**
+     * Validates data object
+     */
+    validateData(data) {
+        if (typeof data !== 'object' || Object.keys(data).length === 0) {
+            throw new Error('Invalid data: must be a non-empty object');
+        }
+    }
+}
+/**
+ * Query builder class for more fluent API usage
+ */
+class QueryBuilder {
+    constructor(sdk, tableName) {
+        this.sdk = sdk;
+        this.tableName = tableName;
+        this.params = {};
+        this.ctes = new Map();
+    }
+    /**
+     * Add a recursive CTE
+     */
+    withRecursive(name, initialQuery, recursiveQuery, options = {}) {
+        if (!this.params.recursiveCtes) {
+            this.params.recursiveCtes = [];
+        }
+        this.params.recursiveCtes.push({
+            name,
+            isRecursive: true,
+            initialQuery,
+            recursiveQuery,
+            unionAll: options.unionAll,
+            columns: options.columns,
+            query: initialQuery, // for compatibility with non-recursive CTEs
+        });
+        return this;
+    }
+    /**
+     * Advanced window function
+     */
+    windowAdvanced(type, alias, config) {
+        if (!this.params.advancedWindows) {
+            this.params.advancedWindows = [];
+        }
+        this.params.advancedWindows.push({
+            type,
+            alias,
+            ...config,
+        });
+        return this;
+    }
+    /**
+     * Add a window function
+     */
+    window(type, alias, config = {}) {
+        if (!this.params.windowFunctions) {
+            this.params.windowFunctions = [];
+        }
+        this.params.windowFunctions.push({
+            type,
+            alias,
+            field: config.field,
+            partitionBy: config.partitionBy,
+            orderBy: config.orderBy,
+            frameClause: config.frameClause,
+        });
+        return this;
+    }
+    /**
+     * Add common window functions
+     */
+    rowNumber(alias, partitionBy, orderBy) {
+        return this.window('row_number', alias, { partitionBy, orderBy });
+    }
+    rank(alias, partitionBy, orderBy) {
+        return this.window('rank', alias, { partitionBy, orderBy });
+    }
+    lag(field, alias, partitionBy, orderBy) {
+        return this.window('lag', alias, { field, partitionBy, orderBy });
+    }
+    lead(field, alias, partitionBy, orderBy) {
+        return this.window('lead', alias, { field, partitionBy, orderBy });
+    }
+    /**
+     * Add a CTE (WITH clause)
+     */
+    with(name, queryOrCallback, columns) {
+        let query;
+        if (typeof queryOrCallback === 'function') {
+            query = new QueryBuilder(this.sdk, this.tableName);
+            queryOrCallback(query);
+        }
+        else {
+            query = queryOrCallback;
+        }
+        this.ctes.set(name, {
+            name,
+            query,
+            columns: columns || [],
+        });
+        if (!this.params.ctes) {
+            this.params.ctes = [];
+        }
+        this.params.ctes.push({ name, query, columns: columns || [] });
+        return this;
+    }
+    /**
+     * Transform the result set
+     */
+    transform(config) {
+        this.params.transforms = {
+            ...this.params.transforms,
+            ...config,
+        };
+        return this;
+    }
+    /**
+     * Pivot the result set
+     */
+    pivot(column, values, aggregate) {
+        return this.transform({
+            pivot: {
+                column,
+                values,
+                aggregate,
+            },
+        });
+    }
+    /**
+     * Compute new fields from existing ones
+     */
+    compute(computations) {
+        return this.transform({
+            compute: computations,
+        });
+    }
+    where(fieldOrConditions, operatorOrValue, value) {
+        if (typeof fieldOrConditions === 'object') {
+            this.params.filter = {
+                ...this.params.filter,
+                ...fieldOrConditions,
+            };
+        }
+        else {
+            if (arguments.length === 2) {
+                this.params.filter = {
+                    ...this.params.filter,
+                    [fieldOrConditions]: operatorOrValue,
+                };
+            }
+            else {
+                if (!this.params.whereRaw) {
+                    this.params.whereRaw = [];
+                }
+                this.params.whereRaw.push({
+                    field: fieldOrConditions,
+                    operator: operatorOrValue,
+                    value,
+                });
+            }
+        }
+        return this;
+    }
+    // Where between
+    whereBetween(field, range) {
+        if (!this.params.whereBetween) {
+            this.params.whereBetween = [];
+        }
+        this.params.whereBetween.push({
+            field,
+            operator: 'between',
+            value: range,
+        });
+        return this;
+    }
+    // Where in
+    whereIn(field, values) {
+        if (!this.params.whereIn) {
+            this.params.whereIn = {};
+        }
+        this.params.whereIn[field] = values;
+        return this;
+    }
+    // Where not in
+    whereNotIn(field, values) {
+        if (!this.params.whereNotIn) {
+            this.params.whereNotIn = {};
+        }
+        this.params.whereNotIn[field] = values;
+        return this;
+    }
+    // Where null
+    whereNull(field) {
+        if (!this.params.whereNull) {
+            this.params.whereNull = [];
+        }
+        this.params.whereNull.push(field);
+        return this;
+    }
+    // Where not null
+    whereNotNull(field) {
+        if (!this.params.whereNotNull) {
+            this.params.whereNotNull = [];
+        }
+        this.params.whereNotNull.push(field);
+        return this;
+    }
+    orderBy(fieldOrOptions, direction, nulls) {
+        if (!this.params.orderBy) {
+            this.params.orderBy = [];
+        }
+        if (typeof fieldOrOptions === 'string') {
+            direction = direction || 'asc';
+            this.params.orderBy.push({
+                field: fieldOrOptions,
+                direction,
+                nulls,
+            });
+        }
+        else {
+            this.params.orderBy.push(fieldOrOptions);
+        }
+        return this;
+    }
+    limit(limit) {
+        this.params.limit = limit;
+        return this;
+    }
+    offset(offset) {
+        this.params.offset = offset;
+        return this;
+    }
+    /**
+     * Start an OR where group
+     */
+    orWhere(callback) {
+        return this.whereGroup('OR', callback);
+    }
+    /**
+     * Start an AND where group
+     */
+    andWhere(callback) {
+        return this.whereGroup('AND', callback);
+    }
+    /**
+     * Create a where group with the specified operator
+     */
+    whereGroup(operator, callback) {
+        // Create a new builder for the group to collect clauses
+        const groupBuilder = new QueryBuilder(this.sdk, this.tableName);
+        // Execute the callback with the group builder to collect clauses
+        callback(groupBuilder);
+        // Create the where group with the collected clauses
+        const group = {
+            type: operator,
+            clauses: [],
+        };
+        // Add all whereRaw clauses to the group
+        if (groupBuilder.params.whereRaw &&
+            groupBuilder.params.whereRaw.length > 0) {
+            group.clauses.push(...groupBuilder.params.whereRaw);
+        }
+        // Add all where groups from the builder to our group
+        if (groupBuilder.params.whereGroups &&
+            groupBuilder.params.whereGroups.length > 0) {
+            group.clauses.push(...groupBuilder.params.whereGroups);
+        }
+        // Initialize the whereGroups array if it doesn't exist
+        if (!this.params.whereGroups) {
+            this.params.whereGroups = [];
+        }
+        // Add the group to whereGroups array
+        this.params.whereGroups.push(group);
+        return this;
+    }
+    /**
+     * Add a where exists clause using a subquery
+     * @param subqueryBuilder A function that returns a configured query builder for the subquery
+     * @returns The query builder instance
+     * @example
+     * db.table<User>("users")
+     *   .whereExists((subquery) =>
+     *     subquery.table("orders")
+     *       .where("orders.user_id", "=", "users.id")
+     *       .where("total", ">", 1000)
+     *   )
+     *   .execute();
+     */
+    whereExists(subqueryBuilder) {
+        if (!this.params.whereExists) {
+            this.params.whereExists = [];
+        }
+        // Create a new SDK instance for the subquery
+        const subquerySdk = new DatabaseSDK({ baseUrl: this.sdk.getBaseUrl() });
+        // Get the subquery builder
+        const subquery = subqueryBuilder(subquerySdk);
+        // Extract the table name and parameters
+        this.params.whereExists.push({
+            tableName: subquery.getTableName(),
+            params: subquery.getParams(),
+        });
+        return this;
+    }
+    /**
+     * Add a where exists clause with join conditions
+     * @param tableName The table to check for existence
+     * @param leftField The field from the main table
+     * @param rightField The field from the subquery table
+     * @param additionalConditions Additional conditions for the subquery
+     * @returns The query builder instance
+     * @example
+     * db.table<User>("users")
+     *   .whereExistsJoin("orders", "id", "user_id", (qb) =>
+     *     qb.where("total", ">", 1000)
+     *   )
+     *   .execute();
+     */
+    whereExistsJoin(tableName, leftField, rightField, additionalConditions) {
+        if (!this.params.whereExists) {
+            this.params.whereExists = [];
+        }
+        // Create a new SDK instance for the subquery
+        const subquerySdk = new DatabaseSDK({ baseUrl: this.sdk.getBaseUrl() });
+        // Build the subquery
+        const subQueryBuilder = subquerySdk.table(tableName);
+        // Apply additional conditions if provided
+        if (additionalConditions) {
+            additionalConditions(subQueryBuilder);
+        }
+        // Add the join condition
+        this.params.whereExists.push({
+            tableName,
+            params: subQueryBuilder.getParams(),
+            joinCondition: {
+                leftField: leftField,
+                operator: '=',
+                rightField,
+            },
+        });
+        return this;
+    }
+    // Helper methods for the whereExists functions
+    getTableName() {
+        return this.tableName;
+    }
+    getParams() {
+        return this.params;
+    }
+    // rawExpression method removed for security reasons
+    /**
+     * Group by clause
+     */
+    groupBy(...fields) {
+        if (!this.params.groupBy) {
+            this.params.groupBy = [];
+        }
+        this.params.groupBy.push(...fields);
+        return this;
+    }
+    /**
+     * Having clause for grouped queries
+     */
+    having(field, operator, value) {
+        if (!this.params.having) {
+            this.params.having = [];
+        }
+        this.params.having.push({ field, operator, value });
+        return this;
+    }
+    /**
+     * Add an aggregate function
+     */
+    aggregate(type, field, alias) {
+        if (!this.params.aggregates) {
+            this.params.aggregates = [];
+        }
+        this.params.aggregates.push({ type, field, alias });
+        return this;
+    }
+    /**
+     * Shorthand for count aggregate
+     */
+    count(field = '*', alias) {
+        return this.aggregate('count', field, alias);
+    }
+    /**
+     * Shorthand for sum aggregate
+     */
+    sum(field, alias) {
+        return this.aggregate('sum', field, alias);
+    }
+    /**
+     * Shorthand for average aggregate
+     */
+    avg(field, alias) {
+        return this.aggregate('avg', field, alias);
+    }
+    /**
+     * Shorthand for minimum aggregate
+     */
+    min(field, alias) {
+        return this.aggregate('min', field, alias);
+    }
+    /**
+     * Shorthand for maximum aggregate
+     */
+    max(field, alias) {
+        return this.aggregate('max', field, alias);
+    }
+    // Get query parameters without executing
+    async toParams() {
+        const response = await this.sdk.getRecords(this.tableName, this.params, {
+            execute: false,
+        });
+        return response.params;
+    }
+    /**
+     * Execute with transformations
+     * @param axiosConfig Optional axios config to be used for this request
+     * @returns Promise with the query results
+     */
+    async query(axiosConfig = {}) {
+        const response = await this.sdk.getRecords(this.tableName, this.params, { execute: true }, axiosConfig);
+        if (this.params.transforms && response.records) {
+            return this.applyTransformations(response);
+        }
+        return response;
+    }
+    /**
+     * Create a record in the table
+     * @param data The data to create
+     * @param axiosConfig Optional axios config to be used for this request
+     * @returns Promise with the created record
+     */
+    async create(data, axiosConfig = {}) {
+        return this.sdk.createRecord(this.tableName, data, axiosConfig);
+    }
+    /**
+     * Update a record by ID
+     * @param id The ID of the record to update
+     * @param data The data to update
+     * @param axiosConfig Optional axios config to be used for this request
+     * @returns Promise with the updated record
+     */
+    async update(id, data, axiosConfig = {}) {
+        return this.sdk.updateRecord(this.tableName, id, data, axiosConfig);
+    }
+    /**
+     * Update records by Complex query
+     * @param data The data to update
+     * @param axiosConfig Optional axios config to be used for this request
+     * @returns Promise with the deletion result
+     */
+    async advanceUpdate(data, axiosConfig = {}) {
+        return this.sdk.advanceUpdateRecord(this.tableName, data, this.params, { execute: true }, axiosConfig);
+    }
+    /**
+     * Delete a record by ID
+     * @param id The ID of the record to delete
+     * @param axiosConfig Optional axios config to be used for this request
+     * @returns Promise with the deletion result
+     */
+    async delete(id, axiosConfig = {}) {
+        return this.sdk.deleteRecord(this.tableName, id, axiosConfig);
+    }
+    /**
+     * Delete records by Complex query
+     * @param axiosConfig Optional axios config to be used for this request
+     * @returns Promise with the deletion result
+     */
+    async advanceDelete(axiosConfig = {}) {
+        return this.sdk.advanceDeleteRecord(this.tableName, this.params, { execute: true }, axiosConfig);
+    }
+    applyTransformations(response) {
+        let transformed = [...(response.records || [])];
+        const transforms = this.params.transforms;
+        // Apply computations
+        if (transforms.compute) {
+            transformed = transformed.map((row) => ({
+                ...row,
+                ...Object.entries(transforms.compute).reduce((acc, [key, fn]) => ({
+                    ...acc,
+                    [key]: fn(row),
+                }), {}),
+            }));
+        }
+        // Apply grouping
+        if (transforms.groupBy) {
+            transformed = this.groupResults(transformed, transforms.groupBy);
+        }
+        // Apply pivoting
+        if (transforms.pivot) {
+            transformed = this.pivotResults(transformed, transforms.pivot);
+        }
+        return {
+            ...response,
+            records: transformed,
+        };
+    }
+    groupResults(records, groupBy) {
+        // Implementation of grouping logic
+        return records;
+    }
+    pivotResults(records, pivot) {
+        // Implementation of pivot logic
+        return records;
+    }
+    /**
+     * Select specific fields from the table
+     * @param fields Fields to select
+     * @example
+     * db.table("users")
+     *   .select("id", "name", "email")
+     *   .execute();
+     */
+    select(...fields) {
+        if (!this.params.select) {
+            this.params.select = [];
+        }
+        this.params.select.push(...fields);
+        return this;
+    }
+}
+// Example usage functions
+// function demonstrateComplexQueries() {
+//   const db = new DatabaseSDK("https://api.example.com");
+//   // Complex grouped conditions
+//   db.table<User>("users")
+//     .where("status", "active")
+//     .andWhere((query) => {
+//       query.where("role", "admin").orWhere((subQuery) => {
+//         subQuery.where("role", "manager").where("department", "IT");
+//       });
+//     })
+//     .query();
+//   // Using exists with raw SQL
+//   db.table<Order>("orders")
+//     .whereExists(
+//       "SELECT 1 FROM order_items WHERE order_items.order_id = orders.id AND quantity > ?",
+//       [10]
+//     )
+//     .query();
+//   // Aggregations with grouping
+//   db.table<Order>("orders")
+//     .groupBy("customer_id", "status")
+//     .having("total_amount", ">", 1000)
+//     .sum("amount", "total_amount")
+//     .count("id", "order_count")
+//     .avg("amount", "average_amount")
+//     .query();
+//   // Raw expressions removed for security reasons
+// }
+//# sourceMappingURL=client.js.map