@shaivpidadi/trends-js 0.0.0-beta.4 → 0.0.0-beta.6

package/lib/errors/GoogleTrendsError.d.ts

@@ -0,0 +1,23 @@
+import { GoogleTrendsError } from '../types';
+export declare class RateLimitError extends Error implements GoogleTrendsError {
+    code: string;
+    statusCode: number;
+    constructor(message?: string);
+}
+export declare class InvalidRequestError extends Error implements GoogleTrendsError {
+    code: string;
+    statusCode: number;
+    constructor(message?: string);
+}
+export declare class NetworkError extends Error implements GoogleTrendsError {
+    code: string;
+    constructor(message?: string);
+}
+export declare class ParseError extends Error implements GoogleTrendsError {
+    code: string;
+    constructor(message?: string);
+}
+export declare class UnknownError extends Error implements GoogleTrendsError {
+    code: string;
+    constructor(message?: string);
+}

package/lib/errors/GoogleTrendsError.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownError = exports.ParseError = exports.NetworkError = exports.InvalidRequestError = exports.RateLimitError = void 0;
+class RateLimitError extends Error {
+    constructor(message = 'Rate limit exceeded') {
+        super(message);
+        this.code = 'RATE_LIMIT_EXCEEDED';
+        this.statusCode = 429;
+        this.name = 'RateLimitError';
+    }
+}
+exports.RateLimitError = RateLimitError;
+class InvalidRequestError extends Error {
+    constructor(message = 'Invalid request parameters') {
+        super(message);
+        this.code = 'INVALID_REQUEST';
+        this.statusCode = 400;
+        this.name = 'InvalidRequestError';
+    }
+}
+exports.InvalidRequestError = InvalidRequestError;
+class NetworkError extends Error {
+    constructor(message = 'Network request failed') {
+        super(message);
+        this.code = 'NETWORK_ERROR';
+        this.name = 'NetworkError';
+    }
+}
+exports.NetworkError = NetworkError;
+class ParseError extends Error {
+    constructor(message = 'Failed to parse response') {
+        super(message);
+        this.code = 'PARSE_ERROR';
+        this.name = 'ParseError';
+    }
+}
+exports.ParseError = ParseError;
+class UnknownError extends Error {
+    constructor(message = 'An unknown error occurred') {
+        super(message);
+        this.code = 'UNKNOWN_ERROR';
+        this.name = 'UnknownError';
+    }
+}
+exports.UnknownError = UnknownError;

package/lib/helpers/format.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractJsonFromResponse = void 0;
+const GoogleTrendsError_1 = require("../errors/GoogleTrendsError");
 // For future refrence and update: from google trends page rpc call response,
 // 0	"twitter down"	The main trending search term.
 // 1	null	Unused (reserved for future Google Trends data).
@@ -20,33 +21,59 @@ const extractJsonFromResponse = (text) => {
     try {
         const parsedResponse = JSON.parse(cleanedText);
         if (!Array.isArray(parsedResponse) || parsedResponse.length === 0) {
-            return null;
+            throw new GoogleTrendsError_1.ParseError('Invalid response format: empty array');
         }
         const nestedJsonString = parsedResponse[0][2];
         if (!nestedJsonString) {
-            return null;
+            throw new GoogleTrendsError_1.ParseError('Invalid response format: missing nested JSON');
         }
         const data = JSON.parse(nestedJsonString);
         if (!data || !Array.isArray(data) || data.length < 2) {
-            return null;
+            throw new GoogleTrendsError_1.ParseError('Invalid response format: missing data array');
         }
         return updateResponseObject(data[1]);
     }
     catch (e) {
-        console.error('Failed to parse response:', e);
-        return null;
+        if (e instanceof GoogleTrendsError_1.ParseError) {
+            throw e;
+        }
+        throw new GoogleTrendsError_1.ParseError('Failed to parse response');
     }
 };
 exports.extractJsonFromResponse = extractJsonFromResponse;
 const updateResponseObject = (data) => {
     if (!Array.isArray(data)) {
-        return null;
+        throw new GoogleTrendsError_1.ParseError('Invalid data format: expected array');
     }
-    const allTrendingStories = data;
+    const allTrendingStories = [];
     const summary = [];
     data.forEach((item) => {
-        if (Array.isArray(item) && typeof item[0] === 'string') {
-            summary.push(item[0]); // First element is usually the trending keyword
+        if (Array.isArray(item)) {
+            const story = {
+                title: String(item[0] || ''),
+                traffic: String(item[6] || '0'),
+                articles: Array.isArray(item[9]) ? item[9].map((article) => ({
+                    title: String(article[0] || ''),
+                    url: String(article[1] || ''),
+                    source: String(article[2] || ''),
+                    time: String(article[3] || ''),
+                    snippet: String(article[4] || '')
+                })) : [],
+                shareUrl: String(item[12] || '')
+            };
+            if (item[1]) {
+                story.image = {
+                    newsUrl: String(item[1][0] || ''),
+                    source: String(item[1][1] || ''),
+                    imageUrl: String(item[1][2] || '')
+                };
+            }
+            allTrendingStories.push(story);
+            summary.push({
+                title: story.title,
+                traffic: story.traffic,
+                articles: story.articles
+            });
         }
     });
     return { allTrendingStories, summary };

package/lib/helpers/googleTrendsAPI.d.ts

@@ -1,8 +1,24 @@
-import { DailyTrendingTopics, DailyTrendingTopicsOptions, RealTimeTrendsOptions, ExploreOptions, ExploreResponse, InterestByRegionOptions, InterestByRegionResponse } from '../types/index';
+import { DailyTrendingTopics, DailyTrendingTopicsOptions, RealTimeTrendsOptions, ExploreOptions, ExploreResponse, InterestByRegionOptions, InterestByRegionResponse, GoogleTrendsResponse } from '../types/index';
 export declare class GoogleTrendsApi {
-    autocomplete(keyword: string, hl?: string): Promise<string[]>;
-    dailyTrends({ geo, lang }: DailyTrendingTopicsOptions): Promise<DailyTrendingTopics>;
-    realTimeTrends({ geo, trendingHours }: RealTimeTrendsOptions): Promise<DailyTrendingTopics>;
+    /**
+     * Get autocomplete suggestions for a keyword
+     * @param keyword - The keyword to get suggestions for
+     * @param hl - Language code (default: 'en-US')
+     * @returns Promise with array of suggestion strings
+     */
+    autocomplete(keyword: string, hl?: string): Promise<GoogleTrendsResponse<string[]>>;
+    /**
+     * Get daily trending topics
+     * @param options - Options for daily trends request
+     * @returns Promise with trending topics data
+     */
+    dailyTrends({ geo, lang }: DailyTrendingTopicsOptions): Promise<GoogleTrendsResponse<DailyTrendingTopics>>;
+    /**
+     * Get real-time trending topics
+     * @param options - Options for real-time trends request
+     * @returns Promise with trending topics data
+     */
+    realTimeTrends({ geo, trendingHours }: RealTimeTrendsOptions): Promise<GoogleTrendsResponse<DailyTrendingTopics>>;
     explore({ keyword, geo, time, category, property, hl, }: ExploreOptions): Promise<ExploreResponse>;
     interestByRegion({ keyword, startTime, endTime, geo, resolution, hl, timezone, category }: InterestByRegionOptions): Promise<InterestByRegionResponse>;
 }

package/lib/helpers/googleTrendsAPI.js

@@ -13,11 +13,18 @@ exports.GoogleTrendsApi = void 0;
 const request_1 = require("./request");
 const format_1 = require("./format");
 const constants_1 = require("../constants");
+const GoogleTrendsError_1 = require("../errors/GoogleTrendsError");
 class GoogleTrendsApi {
+    /**
+     * Get autocomplete suggestions for a keyword
+     * @param keyword - The keyword to get suggestions for
+     * @param hl - Language code (default: 'en-US')
+     * @returns Promise with array of suggestion strings
+     */
     autocomplete(keyword, hl = 'en-US') {
         return __awaiter(this, void 0, void 0, function* () {
             if (!keyword) {
-                return [];
+                return { data: [] };
             }
             const options = Object.assign(Object.assign({}, constants_1.GOOGLE_TRENDS_MAPPER["autocomplete" /* GoogleTrendsEndpoints.autocomplete */]), { qs: {
                     hl,
@@ -28,69 +35,73 @@ class GoogleTrendsApi {
                 const text = yield response.text();
                 // Remove the first 5 characters (JSONP wrapper) and parse
                 const data = JSON.parse(text.slice(5));
-                return data.default.topics.map((topic) => topic.title);
+                return { data: data.default.topics.map((topic) => topic.title) };
             }
             catch (error) {
-                console.error('Autocomplete request failed:', error);
-                return [];
+                if (error instanceof Error) {
+                    return { error: new GoogleTrendsError_1.NetworkError(error.message) };
+                }
+                return { error: new GoogleTrendsError_1.UnknownError() };
             }
         });
     }
+    /**
+     * Get daily trending topics
+     * @param options - Options for daily trends request
+     * @returns Promise with trending topics data
+     */
     dailyTrends({ geo = 'US', lang = 'en' }) {
         return __awaiter(this, void 0, void 0, function* () {
             const defaultOptions = constants_1.GOOGLE_TRENDS_MAPPER["dailyTrends" /* GoogleTrendsEndpoints.dailyTrends */];
             const options = Object.assign(Object.assign({}, defaultOptions), { body: new URLSearchParams({
                     'f.req': `[[["i0OFE","[null,null,\\"${geo}\\",0,\\"${lang}\\",24,1]",null,"generic"]]]`,
-                }).toString() });
+                }).toString(), contentType: 'form' });
             try {
                 const response = yield (0, request_1.request)(options.url, options);
                 const text = yield response.text();
                 const trendingTopics = (0, format_1.extractJsonFromResponse)(text);
                 if (!trendingTopics) {
-                    return {
-                        allTrendingStories: [],
-                        summary: [],
-                    };
+                    return { error: new GoogleTrendsError_1.ParseError() };
                 }
-                return trendingTopics;
+                return { data: trendingTopics };
             }
             catch (error) {
-                console.error(error);
-                return {
-                    allTrendingStories: [],
-                    summary: [],
-                };
+                if (error instanceof Error) {
+                    return { error: new GoogleTrendsError_1.NetworkError(error.message) };
+                }
+                return { error: new GoogleTrendsError_1.UnknownError() };
             }
         });
     }
+    /**
+     * Get real-time trending topics
+     * @param options - Options for real-time trends request
+     * @returns Promise with trending topics data
+     */
     realTimeTrends({ geo = 'US', trendingHours = 4 }) {
         return __awaiter(this, void 0, void 0, function* () {
             const defaultOptions = constants_1.GOOGLE_TRENDS_MAPPER["dailyTrends" /* GoogleTrendsEndpoints.dailyTrends */];
             const options = Object.assign(Object.assign({}, defaultOptions), { body: new URLSearchParams({
                     'f.req': `[[["i0OFE","[null,null,\\"${geo}\\",0,\\"en\\",${trendingHours},1]",null,"generic"]]]`,
-                }).toString() });
+                }).toString(), contentType: 'form' });
             try {
                 const response = yield (0, request_1.request)(options.url, options);
                 const text = yield response.text();
                 const trendingTopics = (0, format_1.extractJsonFromResponse)(text);
                 if (!trendingTopics) {
-                    return {
-                        allTrendingStories: [],
-                        summary: [],
-                    };
+                    return { error: new GoogleTrendsError_1.ParseError() };
                 }
-                return trendingTopics;
+                return { data: trendingTopics };
             }
             catch (error) {
-                console.error(error);
-                return {
-                    allTrendingStories: [],
-                    summary: [],
-                };
+                if (error instanceof Error) {
+                    return { error: new GoogleTrendsError_1.NetworkError(error.message) };
+                }
+                return { error: new GoogleTrendsError_1.UnknownError() };
             }
         });
     }
-    explore({ keyword, geo = 'US', time = 'today 12-m', category = 0, property = '', hl = 'en-US', }) {
+    explore({ keyword, geo = 'US', time = 'now 1-d', category = 0, property = '', hl = 'en-US', }) {
         return __awaiter(this, void 0, void 0, function* () {
             const options = Object.assign(Object.assign({}, constants_1.GOOGLE_TRENDS_MAPPER["explore" /* GoogleTrendsEndpoints.explore */]), { qs: {
                     hl,
@@ -106,7 +117,7 @@ class GoogleTrendsApi {
                         category,
                         property,
                     }),
-                } });
+                }, contentType: 'form' });
             try {
                 const response = yield (0, request_1.request)(options.url, options);
                 const text = yield response.text();

package/lib/helpers/request.d.ts

@@ -1,5 +1,9 @@
 export declare const request: (url: string, options: {
     method?: string;
     qs?: Record<string, any>;
-    body?: string;
-}) => Promise<Response>;
+    body?: string | Record<string, any>;
+    headers?: Record<string, string>;
+    contentType?: 'json' | 'form';
+}) => Promise<{
+    text: () => Promise<string>;
+}>;

package/lib/helpers/request.js

@@ -16,46 +16,53 @@ exports.request = void 0;
 const https_1 = __importDefault(require("https"));
 const querystring_1 = __importDefault(require("querystring"));
 let cookieVal;
-function rereq(options) {
+function rereq(options, body) {
     return new Promise((resolve, reject) => {
         const req = https_1.default.request(options, (res) => {
             let chunk = '';
-            res.on('data', (data) => {
-                chunk += data;
-            });
-            res.on('end', () => {
-                resolve(chunk.toString());
-            });
-        });
-        req.on('error', (e) => {
-            reject(e);
+            res.on('data', (data) => { chunk += data; });
+            res.on('end', () => resolve(chunk));
         });
+        req.on('error', reject);
+        if (body)
+            req.write(body);
         req.end();
     });
 }
 const request = (url, options) => __awaiter(void 0, void 0, void 0, function* () {
     const parsedUrl = new URL(url);
+    const method = options.method || 'POST';
+    // Prepare body
+    let bodyString = '';
+    const contentType = options.contentType || 'json';
+    if (typeof options.body === 'string') {
+        bodyString = options.body;
+    }
+    else if (contentType === 'form') {
+        bodyString = querystring_1.default.stringify(options.body || {});
+    }
+    else if (options.body) {
+        bodyString = JSON.stringify(options.body);
+    }
     const requestOptions = {
-        host: parsedUrl.host,
-        method: options.method || 'POST',
+        hostname: parsedUrl.hostname,
+        port: parsedUrl.port || 443,
         path: `${parsedUrl.pathname}${options.qs ? '?' + querystring_1.default.stringify(options.qs) : ''}`,
-        headers: {}
+        method,
+        headers: Object.assign(Object.assign(Object.assign(Object.assign({}, (options.headers || {})), (contentType === 'form'
+            ? { 'Content-Type': 'application/x-www-form-urlencoded' }
+            : { 'Content-Type': 'application/json' })), (bodyString ? { 'Content-Length': Buffer.byteLength(bodyString).toString() } : {})), (cookieVal ? { cookie: cookieVal } : {}))
     };
-    if (cookieVal) {
-        requestOptions.headers = { 'cookie': cookieVal };
-    }
     const response = yield new Promise((resolve, reject) => {
         const req = https_1.default.request(requestOptions, (res) => {
             let chunk = '';
-            res.on('data', (data) => {
-                chunk += data;
-            });
+            res.on('data', (data) => { chunk += data; });
             res.on('end', () => __awaiter(void 0, void 0, void 0, function* () {
                 if (res.statusCode === 429 && res.headers['set-cookie']) {
                     cookieVal = res.headers['set-cookie'][0].split(';')[0];
-                    requestOptions.headers = { 'cookie': cookieVal };
+                    requestOptions.headers['cookie'] = cookieVal;
                     try {
-                        const retryResponse = yield rereq(requestOptions);
+                        const retryResponse = yield rereq(requestOptions, bodyString);
                         resolve(retryResponse);
                     }
                     catch (err) {
@@ -63,16 +70,13 @@ const request = (url, options) => __awaiter(void 0, void 0, void 0, function* ()
                     }
                 }
                 else {
-                    resolve(chunk.toString());
+                    resolve(chunk);
                 }
             }));
         });
-        if (options.body) {
-            req.write(options.body);
-        }
-        req.on('error', (e) => {
-            reject(e);
-        });
+        req.on('error', reject);
+        if (bodyString)
+            req.write(bodyString);
         req.end();
     });
     return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shaivpidadi/trends-js",
-  "version": "0.0.0-beta.4",
+  "version": "0.0.0-beta.6",
   "description": "Google Trends API for Node.js",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",