@apiverve/wordsearch 1.1.14 → 1.2.2

package/index.d.ts

@@ -1,51 +1,63 @@
-declare module '@apiverve/wordsearch' {
-  export interface wordsearchOptions {
-    api_key: string;
-    secure?: boolean;
-  }
-
-  export interface wordsearchResponse {
-    status: string;
-    error: string | null;
-    data: WordSearchGeneratorData;
-    code?: number;
-  }
-
+declare module '@apiverve/wordsearch' {
+  export interface wordsearchOptions {
+    api_key: string;
+    secure?: boolean;
+  }
+
+  /**
+   * Describes fields the current plan does not unlock. Locked fields arrive as null
+   * in `data`; `locked_fields` names them, using dot paths for nested fields.
+   * Absent when the plan unlocks everything.
+   */
+  export interface PremiumInfo {
+    message: string;
+    upgrade_url: string;
+    locked_fields: string[];
+  }
+
+  export interface wordsearchResponse {
+    status: string;
+    error: string | null;
+    data: WordSearchGeneratorData;
+    code?: number;
+    premium?: PremiumInfo;
+  }
+
 
   interface WordSearchGeneratorData {
-      grid:          Array<string[]>;
+      grid:          Array<(null | string)[]>;
       words:         Word[];
-      wordCount:     number;
-      size:          number;
-      difficulty:    string;
-      html:          string;
+      wordCount:     number | null;
+      size:          number | null;
+      difficulty:    null | string;
+      html:          null | string;
       image:         Image;
       solutionImage: Image;
   }
   
   interface Image {
-      imageName:   string;
-      format:      string;
-      downloadURL: string;
-      expires:     number;
+      imageName:   null | string;
+      format:      null | string;
+      downloadURL: null | string;
+      expires:     number | null;
   }
   
   interface Word {
-      word:      string;
+      word:      null | string;
       start:     Start;
-      direction: string;
+      direction: null | string;
   }
   
   interface Start {
-      row: number;
-      col: number;
+      row: number | null;
+      col: number | null;
   }
 
-  export default class wordsearchWrapper {
-    constructor(options: wordsearchOptions);
-
-    execute(callback: (error: any, data: wordsearchResponse | null) => void): Promise<wordsearchResponse>;
-    execute(query: Record<string, any>, callback: (error: any, data: wordsearchResponse | null) => void): Promise<wordsearchResponse>;
-    execute(query?: Record<string, any>): Promise<wordsearchResponse>;
-  }
-}
+  export default class wordsearchWrapper {
+    constructor(options: wordsearchOptions);
+
+    execute(callback: (error: any, data: wordsearchResponse | null) => void): Promise<wordsearchResponse>;
+    execute(query: Record<string, any>, callback: (error: any, data: wordsearchResponse | null) => void): Promise<wordsearchResponse>;
+    execute(query?: Record<string, any>): Promise<wordsearchResponse>;
+  }
+}

package/index.js

@@ -1,209 +1,209 @@
-const axios = require('axios');
-
-class wordsearchWrapper {
-
-    constructor(options) {
-        if (!options || typeof options !== 'object') {
-            throw new Error('Options object must be provided. See documentation: https://docs.apiverve.com/ref/wordsearch');
-        }
-
-        const { api_key, secure = true } = options;
-
-        if (!api_key || typeof api_key !== 'string') {
-            throw new Error('API key must be provided as a non-empty string. Get your API key at: https://apiverve.com');
-        }
-
-        // Validate API key format (GUID, prefixed keys like apv_xxx, or alphanumeric)
-        const apiKeyPattern = /^[a-zA-Z0-9_-]+$/;
-        if (!apiKeyPattern.test(api_key)) {
-            throw new Error('Invalid API key format. API key must be alphanumeric and may contain hyphens and underscores. Get your API key at: https://apiverve.com');
-        }
-
-        if (typeof secure !== 'boolean') {
-            throw new Error('Secure parameter must be a boolean value.');
-        }
-
-        this.APIKey = api_key;
-        this.IsSecure = secure;
-
-        // secure is deprecated, all requests must be made over HTTPS
-        this.baseURL = 'https://api.apiverve.com/v1/wordsearch';
-
-        // Validation rules for parameters (generated from schema)
-        this.validationRules = {"words":{"type":"array","required":true},"size":{"type":"integer","required":false,"min":10,"max":30,"default":15},"difficulty":{"type":"string","required":false,"default":"medium"}};
-    }
-
-    /**
-     * Validate query parameters against schema rules
-     * @param {Object} query - The query parameters to validate
-     * @throws {Error} - If validation fails
-     */
-    validateParams(query) {
-        const errors = [];
-
-        for (const [paramName, rules] of Object.entries(this.validationRules)) {
-            const value = query[paramName];
-
-            // Check required
-            if (rules.required && (value === undefined || value === null || value === '')) {
-                errors.push(`Required parameter [${paramName}] is missing.`);
-                continue;
-            }
-
-            // Skip validation if value is not provided and not required
-            if (value === undefined || value === null) {
-                continue;
-            }
-
-            // Type validation
-            if (rules.type === 'integer' || rules.type === 'number') {
-                const numValue = Number(value);
-                if (isNaN(numValue)) {
-                    errors.push(`Parameter [${paramName}] must be a valid ${rules.type}.`);
-                    continue;
-                }
-
-                if (rules.type === 'integer' && !Number.isInteger(numValue)) {
-                    errors.push(`Parameter [${paramName}] must be an integer.`);
-                    continue;
-                }
-
-                // Min/max validation for numbers
-                if (rules.min !== undefined && numValue < rules.min) {
-                    errors.push(`Parameter [${paramName}] must be at least ${rules.min}.`);
-                }
-                if (rules.max !== undefined && numValue > rules.max) {
-                    errors.push(`Parameter [${paramName}] must be at most ${rules.max}.`);
-                }
-            } else if (rules.type === 'string') {
-                if (typeof value !== 'string') {
-                    errors.push(`Parameter [${paramName}] must be a string.`);
-                    continue;
-                }
-
-                // Length validation for strings
-                if (rules.minLength !== undefined && value.length < rules.minLength) {
-                    errors.push(`Parameter [${paramName}] must be at least ${rules.minLength} characters.`);
-                }
-                if (rules.maxLength !== undefined && value.length > rules.maxLength) {
-                    errors.push(`Parameter [${paramName}] must be at most ${rules.maxLength} characters.`);
-                }
-
-                // Format validation
-                if (rules.format) {
-                    const formatPatterns = {
-                        'email': /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
-                        'url': /^https?:\/\/.+/i,
-                        'ip': /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$|^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/,
-                        'date': /^\d{4}-\d{2}-\d{2}$/,
-                        'hexColor': /^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/
-                    };
-
-                    if (formatPatterns[rules.format] && !formatPatterns[rules.format].test(value)) {
-                        errors.push(`Parameter [${paramName}] must be a valid ${rules.format}.`);
-                    }
-                }
-            } else if (rules.type === 'boolean') {
-                if (typeof value !== 'boolean' && value !== 'true' && value !== 'false') {
-                    errors.push(`Parameter [${paramName}] must be a boolean.`);
-                }
-            } else if (rules.type === 'array') {
-                if (!Array.isArray(value)) {
-                    errors.push(`Parameter [${paramName}] must be an array.`);
-                }
-            }
-
-            // Enum validation
-            if (rules.enum && Array.isArray(rules.enum)) {
-                if (!rules.enum.includes(value)) {
-                    errors.push(`Parameter [${paramName}] must be one of: ${rules.enum.join(', ')}.`);
-                }
-            }
-        }
-
-        if (errors.length > 0) {
-            throw new Error(`Validation failed: ${errors.join(' ')} See documentation: https://docs.apiverve.com/ref/wordsearch`);
-        }
-    }
-
-    async execute(query, callback) {
-        // Handle different argument patterns
-        if(arguments.length === 0) {
-            // execute() - no args
-            query = {};
-            callback = null;
-        } else if(arguments.length === 1) {
-            if (typeof query === 'function') {
-                // execute(callback)
-                callback = query;
-                query = {};
-            } else {
-                // execute(query)
-                callback = null;
-            }
-        } else {
-            // execute(query, callback)
-            if (!query || typeof query !== 'object') {
-                throw new Error('Query parameters must be provided as an object.');
-            }
-        }
-
-        // Validate parameters against schema rules
-        this.validateParams(query);
-
-        const method = 'POST';
-        const url = method === 'POST' ? this.baseURL : this.constructURL(query);
-
-        try {
-            const response = await axios({
-                method,
-                url,
-                headers: {
-                    'Content-Type': 'application/json',
-                    'x-api-key': this.APIKey,
-                    'auth-mode': 'npm-package'
-                },
-                data: method === 'POST' ? query : undefined
-            });
-
-            const data = response.data;
-            if (callback) callback(null, data);
-            return data;
-        } catch (error) {
-            let apiError;
-
-            if (error.response && error.response.data) {
-                apiError = error.response.data;
-            } else if (error.message) {
-                apiError = { error: error.message, status: 'error' };
-            } else {
-                apiError = { error: 'An unknown error occurred', status: 'error' };
-            }
-
-            if (callback) {
-                callback(apiError, null);
-                return; // Don't throw if callback is provided
-            }
-
-            throw apiError;
-        }
-    }
-
-    constructURL(query) {
-        let url = this.baseURL;
-
-        if(query && typeof query === 'object')
-        {
-            if (Object.keys(query).length > 0) {
-                const queryString = Object.keys(query)
-                    .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(query[key])}`)
-                    .join('&');
-                url += `?${queryString}`;
-            }
-        }
-        return url;
-    }
-
-}
-
-module.exports = wordsearchWrapper;
+const axios = require('axios');
+
+class wordsearchWrapper {
+
+    constructor(options) {
+        if (!options || typeof options !== 'object') {
+            throw new Error('Options object must be provided. See documentation: https://docs.apiverve.com/ref/wordsearch');
+        }
+
+        const { api_key, secure = true } = options;
+
+        if (!api_key || typeof api_key !== 'string') {
+            throw new Error('API key must be provided as a non-empty string. Get your API key at: https://apiverve.com');
+        }
+
+        // Validate API key format (GUID, prefixed keys like apv_xxx, or alphanumeric)
+        const apiKeyPattern = /^[a-zA-Z0-9_-]+$/;
+        if (!apiKeyPattern.test(api_key)) {
+            throw new Error('Invalid API key format. API key must be alphanumeric and may contain hyphens and underscores. Get your API key at: https://apiverve.com');
+        }
+
+        if (typeof secure !== 'boolean') {
+            throw new Error('Secure parameter must be a boolean value.');
+        }
+
+        this.APIKey = api_key;
+        this.IsSecure = secure;
+
+        // secure is deprecated, all requests must be made over HTTPS
+        this.baseURL = 'https://api.apiverve.com/v1/wordsearch';
+
+        // Validation rules for parameters (generated from schema)
+        this.validationRules = {"words":{"type":"array","required":true},"size":{"type":"integer","required":false,"min":10,"max":30,"default":15},"difficulty":{"type":"string","required":false,"default":"medium"},"image":{"type":"boolean","required":false,"default":false},"solutionImage":{"type":"boolean","required":false,"default":false}};
+    }
+
+    /**
+     * Validate query parameters against schema rules
+     * @param {Object} query - The query parameters to validate
+     * @throws {Error} - If validation fails
+     */
+    validateParams(query) {
+        const errors = [];
+
+        for (const [paramName, rules] of Object.entries(this.validationRules)) {
+            const value = query[paramName];
+
+            // Check required
+            if (rules.required && (value === undefined || value === null || value === '')) {
+                errors.push(`Required parameter [${paramName}] is missing.`);
+                continue;
+            }
+
+            // Skip validation if value is not provided and not required
+            if (value === undefined || value === null) {
+                continue;
+            }
+
+            // Type validation
+            if (rules.type === 'integer' || rules.type === 'number') {
+                const numValue = Number(value);
+                if (isNaN(numValue)) {
+                    errors.push(`Parameter [${paramName}] must be a valid ${rules.type}.`);
+                    continue;
+                }
+
+                if (rules.type === 'integer' && !Number.isInteger(numValue)) {
+                    errors.push(`Parameter [${paramName}] must be an integer.`);
+                    continue;
+                }
+
+                // Min/max validation for numbers
+                if (rules.min !== undefined && numValue < rules.min) {
+                    errors.push(`Parameter [${paramName}] must be at least ${rules.min}.`);
+                }
+                if (rules.max !== undefined && numValue > rules.max) {
+                    errors.push(`Parameter [${paramName}] must be at most ${rules.max}.`);
+                }
+            } else if (rules.type === 'string') {
+                if (typeof value !== 'string') {
+                    errors.push(`Parameter [${paramName}] must be a string.`);
+                    continue;
+                }
+
+                // Length validation for strings
+                if (rules.minLength !== undefined && value.length < rules.minLength) {
+                    errors.push(`Parameter [${paramName}] must be at least ${rules.minLength} characters.`);
+                }
+                if (rules.maxLength !== undefined && value.length > rules.maxLength) {
+                    errors.push(`Parameter [${paramName}] must be at most ${rules.maxLength} characters.`);
+                }
+
+                // Format validation
+                if (rules.format) {
+                    const formatPatterns = {
+                        'email': /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+                        'url': /^https?:\/\/.+/i,
+                        'ip': /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$|^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/,
+                        'date': /^\d{4}-\d{2}-\d{2}$/,
+                        'hexColor': /^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/
+                    };
+
+                    if (formatPatterns[rules.format] && !formatPatterns[rules.format].test(value)) {
+                        errors.push(`Parameter [${paramName}] must be a valid ${rules.format}.`);
+                    }
+                }
+            } else if (rules.type === 'boolean') {
+                if (typeof value !== 'boolean' && value !== 'true' && value !== 'false') {
+                    errors.push(`Parameter [${paramName}] must be a boolean.`);
+                }
+            } else if (rules.type === 'array') {
+                if (!Array.isArray(value)) {
+                    errors.push(`Parameter [${paramName}] must be an array.`);
+                }
+            }
+
+            // Enum validation
+            if (rules.enum && Array.isArray(rules.enum)) {
+                if (!rules.enum.includes(value)) {
+                    errors.push(`Parameter [${paramName}] must be one of: ${rules.enum.join(', ')}.`);
+                }
+            }
+        }
+
+        if (errors.length > 0) {
+            throw new Error(`Validation failed: ${errors.join(' ')} See documentation: https://docs.apiverve.com/ref/wordsearch`);
+        }
+    }
+
+    async execute(query, callback) {
+        // Handle different argument patterns
+        if(arguments.length === 0) {
+            // execute() - no args
+            query = {};
+            callback = null;
+        } else if(arguments.length === 1) {
+            if (typeof query === 'function') {
+                // execute(callback)
+                callback = query;
+                query = {};
+            } else {
+                // execute(query)
+                callback = null;
+            }
+        } else {
+            // execute(query, callback)
+            if (!query || typeof query !== 'object') {
+                throw new Error('Query parameters must be provided as an object.');
+            }
+        }
+
+        // Validate parameters against schema rules
+        this.validateParams(query);
+
+        const method = 'POST';
+        const url = method === 'POST' ? this.baseURL : this.constructURL(query);
+
+        try {
+            const response = await axios({
+                method,
+                url,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-api-key': this.APIKey,
+                    'auth-mode': 'npm-package'
+                },
+                data: method === 'POST' ? query : undefined
+            });
+
+            const data = response.data;
+            if (callback) callback(null, data);
+            return data;
+        } catch (error) {
+            let apiError;
+
+            if (error.response && error.response.data) {
+                apiError = error.response.data;
+            } else if (error.message) {
+                apiError = { error: error.message, status: 'error' };
+            } else {
+                apiError = { error: 'An unknown error occurred', status: 'error' };
+            }
+
+            if (callback) {
+                callback(apiError, null);
+                return; // Don't throw if callback is provided
+            }
+
+            throw apiError;
+        }
+    }
+
+    constructURL(query) {
+        let url = this.baseURL;
+
+        if(query && typeof query === 'object')
+        {
+            if (Object.keys(query).length > 0) {
+                const queryString = Object.keys(query)
+                    .map(key => `${encodeURIComponent(key)}=${encodeURIComponent(query[key])}`)
+                    .join('&');
+                url += `?${queryString}`;
+            }
+        }
+        return url;
+    }
+
+}
+
+module.exports = wordsearchWrapper;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@apiverve/wordsearch",
-  "version": "1.1.14",
-  "description": "Word Search Generator creates customizable word search puzzles with configurable grid size, word placement, and difficulty levels.",
+  "version": "1.2.2",
+  "description": "Word Search Generator is a word search API that creates customizable word search puzzles with configurable grid size, word placement, and difficulty levels.",
   "main": "index.js",
   "types": "index.d.ts",
   "sideEffects": false,
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=18.0.0"
   },
   "files": [
     "index.js",
@@ -23,7 +23,7 @@
     "directory": "npm"
   },
   "keywords": [
-    ""
+    "word search api", "wordsearch api", "word search generator api", "word search", "word search maker"
   ],
   "author": {
     "name": "APIVerve",
@@ -34,15 +34,14 @@
   "bugs": {
     "url": "https://github.com/apiverve/wordsearch-api/issues"
   },
-  "homepage": "https://apiverve.com/marketplace/wordsearch?utm_source=npm&utm_medium=homepage",
+  "homepage": "https://apiverve.com/marketplace/wordsearch?utm_source=npm&utm_medium=referral&utm_content=homepage",
   "devDependencies": {
     "mocha": "^11.0.1",
     "chai": "^5.1.2",
     "dotenv": "^16.4.7"
   },
   "dependencies": {
-    "node-fetch": "^3.3.2",
-    "promise": "^8.3.0",
-    "axios": "1.13.2"
+    "axios": "1.13.2",
+    "form-data": "^4.0.1"
   }
 }