@terzogenito/json-utils 1.0.9 → 1.0.11

package/README.md

@@ -3,6 +3,19 @@
 ## Overview
 This module provides various functions for reading, validating, and processing JSON files and URL content.
 
+## Installation
+```bash
+npm install @terzogenito/json-utils
+```
+
+## Quick Start
+```javascript
+import jsonUtils from '@terzogenito/json-utils';
+
+const jsonAttributes = jsonUtils.getAttributes(jsonData);
+console.log(jsonAttributes);
+```
+
 ## Function List
 
 ### 1. `getData(path)`
@@ -182,9 +195,243 @@ app.getJSON("https://api.example.com/data", jsonData => {
 });
 ```
 
-## Installation
-```bash
-npm install @terzogenito/json-utils
+### 13. getAttributes(jsonObject)
+```javascript
+const dataJSON = app.readJSON(data);
+const attributes = app.getAttributes(dataJSON);
+// Output: ['name', 'age', 'isActive', 'address', 'hobbies']
+```
+
+**Description**: Extracts all attribute/keys from a JSON object and returns them as an array.
+
+**Parameters**:
+- jsonObject (Object|String): JSON object or JSON string
+
+Returns: Array of attribute names
+
+### 14. getMeta(jsonObject)
+```javascript
+const meta = app.getMeta(dataJSON);
+// Output: {"name": "string", "age": "integer", "isActive": "boolean"}
+```
+
+**Description**: Generates metadata showing attribute names and their data types.
+
+**Parameters**:
+- jsonObject (Object|String): JSON object or JSON string
+
+Returns: Object with attribute names as keys and data types as values
+
+Data Types Identified:
+- string, integer, float, boolean, array, object, null, date
+
+### 15. getMetaDetail(jsonObject)
+```javascript
+const metaDetail = app.getMetaDetail(dataJSON);
+// Output: Detailed metadata including nested structures
+```
+
+**Description**: Generates comprehensive metadata including nested attributes, data types, paths, and structural information.
+
+**Parameters**:
+- jsonObject (Object|String): JSON object or JSON string
+
+Returns: Object with detailed metadata for each attribute
+
+Metadata Includes:
+- type: Data type
+- isRequired: Whether attribute exists
+- path: Full path to attribute
+- children: Nested attributes (for objects)
+- length: Array length (for arrays)
+- elementType: Type of array elements
+
+### 16. getMetaCompact(jsonObject)
+```javascript
+const metaCompact = app.getMetaCompact(dataJSON);
+// Output: Compact metadata format
+```
+
+**Description**: Creates a compact metadata representation showing the structure hierarchy.
+
+**Parameters**:
+- jsonObject (Object|String): JSON object or JSON string
+
+Returns: Compact representation of JSON structure
+
+Format Examples:
+- "array[string]": Array of strings
+- "array[object]": Array of objects
+- Nested objects shown as nested objects
+
+### 17. getPartial(jsonObject, attributes)
+```javascript
+const partial = app.getPartial(dataJSON, ["name", "age"]);
+// Output: {"name": "John", "age": 30}
+```
+
+**Description**: Extracts specific attributes from a JSON object.
+
+**Parameters**:
+- jsonObject (Object|String): JSON object or JSON string
+- attributes (Array|String|Object): Attributes to extract
+
+attribute Parameter Types:
+- Array: List of attribute names to extract
+```javascript
+app.getPartial(data, ["name", "age"])
+```
+- String: Single attribute name
+```javascript
+app.getPartial(data, "name")
+```
+- Object: Mapping of new names to original attributes
+```javascript
+app.getPartial(data, {"fullName": "name", "yearsOld": "age"})
+```
+
+Returns: Object containing only the specified attributes
+
+### 18. getPartialDeep(jsonObject, attributePaths)
+```javascript
+const deepPartial = app.getPartialDeep(dataJSON, ["name", "address.city", "hobbies.length"]);
+// Output: {"name": "John", "city": "Jakarta", "length": 2}
+```
+
+**Description**: Extracts attributes using nested paths (dot notation).
+
+**Parameters**:
+- jsonObject (Object|String): JSON object or JSON string
+- attributePaths (Array|Object): Paths to extract
+
+attributePaths Parameter Types:
+- Array: List of dot-notated paths
+```javascript
+app.getPartialDeep(data, ["user.profile.name", "user.contact.email"])
+```
+- Object: Mapping of new names to paths
+```javascript
+app.getPartialDeep(data, {"userName": "user.profile.name", "userEmail": "user.contact.email"})
+```
+
+Returns: Object with extracted values (uses last path segment as key for array input)
+
+### 19. getPartialWithDefaults(jsonObject, attributesConfig)
+```javascript
+const partialWithDefaults = app.getPartialWithDefaults(dataJSON, {
+    "name": "name",
+    "status": {
+        path: "isActive",
+        transform: (val) => val ? "Active" : "Inactive"
+    },
+    "email": {
+        path: "contact.email",
+        default: "no-email@example.com"
+    }
+});
+```
+
+**Description**: Extracts attributes with advanced configuration including default values and transformations.
+
+**Parameters**:
+- jsonObject (Object|String): JSON object or JSON string
+- attributesConfig (Object): Configuration object
+
+Configuration Options:
+- String: Simple path extraction
+```javascript
+"name": "user.fullName"
+```
+- Object: Advanced configuration
+```javascript
+"formattedAge": {
+    path: "age", // Required: Path to attribute
+    default: 0, // Optional: Default value if path doesn't exist
+    transform: (val) => ${val} years old // Optional: Transformation function
+}
+```
+
+Returns: Object with extracted and processed values
+
+### 20. excludeAttributes(jsonObject, attributesToExclude)
+```javascript
+const filtered = app.excludeAttributes(dataJSON, ["isActive", "address"]);
+// Output: {"name": "John", "age": 30, "hobbies": ["reading", "coding"]}
+```
+
+**Description**: Creates a new JSON object excluding specified attributes.
+
+**Parameters**:
+- jsonObject (Object|String): JSON object or JSON string
+- attributesToExclude (Array|String): Attributes to remove
+
+attributesToExclude Parameter Types:
+- Array: List of attribute names to exclude
+```javascript
+app.excludeAttributes(data, ["password", "secretKey"])
+```
+- String: Single attribute name to exclude
+```javascript
+app.excludeAttributes(data, "password")
+```
+
+Returns: New object without the excluded attributes
+
+### 21. getAttributeValue(jsonObject, attributeName, defaultValue)
+```javascript
+const name = app.getAttributeValue(dataJSON, "name");
+const email = app.getAttributeValue(dataJSON, "email", "default@email.com");
+```
+
+**Description**: Gets the value of a specific attribute with optional default value.
+
+**Parameters**:
+- jsonObject (Object|String): JSON object or JSON string
+- attributeName (String): Name of the attribute to retrieve
+- defaultValue (Any, optional): Default value if attribute doesn't exist
+
+Returns: Attribute value or default value
+
+Advanced Usage Examples
+```javascript
+const app = require('./index');
+
+// Get all attributes from JSON
+const data = await app.getData('./data.json');
+const jsonData = app.readJSON(data);
+const attributes = app.getAttributes(jsonData);
+
+// Get metadata information
+const meta = app.getMeta(jsonData);
+const metaDetail = app.getMetaDetail(jsonData);
+
+// Extract specific data
+const userInfo = app.getPartial(jsonData, ["name", "email", "phone"]);
+const nestedData = app.getPartialDeep(jsonData, ["user.profile.name", "user.contact.email"]);
+
+// Extract with transformations and defaults
+const processedData = app.getPartialWithDefaults(jsonData, {
+    "fullName": "user.name",
+    "ageFormatted": {
+        path: "user.age",
+        transform: (age) => ${age} years old
+    },
+    "country": {
+        path: "user.address.country",
+        default: "Unknown"
+    }
+});
+
+// Exclude sensitive information
+const safeData = app.excludeAttributes(jsonData, ["password", "ssn", "creditCard"]);
+
+// Analyze complex nested structures
+const complexMeta = app.getMetaDetail(complexJSON);
+console.log(complexMeta.user?.children?.contact?.children?.email?.type); // "string"
+
+// Get single attribute value
+const userName = app.getAttributeValue(jsonData, "name");
+const userEmail = app.getAttributeValue(jsonData, "email", "no-email@example.com");
 ```
 
 ## Requirements

package/index.js

@@ -132,6 +132,394 @@ function beautify(jsonObject, indent) {
   }
 }
 
+function getAttributes(jsonObject) {
+  try {
+    if (typeof jsonObject === 'string') {
+      jsonObject = JSON.parse(jsonObject);
+    }
+
+    if (typeof jsonObject !== 'object' || jsonObject === null) {
+      return [];
+    }
+
+    return Object.keys(jsonObject);
+  } catch (error) {
+    return [];
+  }
+}
+
+function getMeta(jsonObject) {
+  try {
+    if (typeof jsonObject === 'string') {
+      jsonObject = JSON.parse(jsonObject);
+    }
+
+    if (typeof jsonObject !== 'object' || jsonObject === null) {
+      return {};
+    }
+    
+    const meta = {};
+
+    for (const [key, value] of Object.entries(jsonObject)) {
+      let type = typeof value;
+
+      if (type === 'object') {
+        if (value === null) {
+          type = 'null';
+        } else if (Array.isArray(value)) {
+          type = 'array';
+        } else if (value instanceof Date) {
+          type = 'date';
+        } else {
+          type = 'object';
+        }
+      } else if (type === 'number') {
+        type = Number.isInteger(value) ? 'integer' : 'float';
+      }
+      
+      meta[key] = type;
+    }
+    
+    return meta;
+  } catch (error) {
+    return {};
+  }
+}
+
+function getMetaDetail(jsonObject) {
+  try {
+    if (typeof jsonObject === 'string') {
+      jsonObject = JSON.parse(jsonObject);
+    }
+
+    if (typeof jsonObject !== 'object' || jsonObject === null) {
+      return {};
+    }
+
+    function getNestedMeta(obj, path = '') {
+      const meta = {};
+      
+      for (const [key, value] of Object.entries(obj)) {
+        const currentPath = path ? `${path}.${key}` : key;
+        const attributeMeta = {};
+
+        let type = typeof value;
+
+        if (value === null) {
+          type = 'null';
+          attributeMeta.type = type;
+          attributeMeta.isRequired = false;
+          attributeMeta.path = currentPath;
+        } else if (Array.isArray(value)) {
+          type = 'array';
+          attributeMeta.type = type;
+          attributeMeta.length = value.length;
+          attributeMeta.isRequired = true;
+          attributeMeta.path = currentPath;
+
+          if (value.length > 0) {
+            const firstElement = value[0];
+            const elementType = typeof firstElement;
+            
+            if (elementType === 'object' && firstElement !== null) {
+              if (Array.isArray(firstElement)) {
+                attributeMeta.elementType = 'array';
+              } else {
+                attributeMeta.elementType = 'object';
+                attributeMeta.children = getNestedMeta(firstElement, `${currentPath}[0]`);
+              }
+            } else {
+              attributeMeta.elementType = elementType;
+            }
+          } else {
+            attributeMeta.elementType = 'unknown';
+          }
+        } else if (value instanceof Date) {
+          type = 'date';
+          attributeMeta.type = type;
+          attributeMeta.isRequired = true;
+          attributeMeta.path = currentPath;
+        } else if (type === 'object') {
+          type = 'object';
+          attributeMeta.type = type;
+          attributeMeta.isRequired = true;
+          attributeMeta.path = currentPath;
+          attributeMeta.keysCount = Object.keys(value).length;
+
+          attributeMeta.children = getNestedMeta(value, currentPath);
+        } else {
+          attributeMeta.type = type;
+          attributeMeta.isRequired = true;
+          attributeMeta.path = currentPath;
+
+          if (type === 'number') {
+            attributeMeta.numberType = Number.isInteger(value) ? 'integer' : 'float';
+          }
+        }
+
+        meta[key] = attributeMeta;
+      }
+      
+      return meta;
+    }
+    
+    return getNestedMeta(jsonObject);
+  } catch (error) {
+    console.error('Error in getMetaDetail:', error);
+    return {};
+  }
+}
+
+function getMetaCompact(jsonObject) {
+  try {
+    if (typeof jsonObject === 'string') {
+      jsonObject = JSON.parse(jsonObject);
+    }
+
+    if (typeof jsonObject !== 'object' || jsonObject === null) {
+      return {};
+    }
+
+    function getCompactMeta(obj) {
+      const meta = {};
+      
+      for (const [key, value] of Object.entries(obj)) {
+        let type = typeof value;
+        
+        if (value === null) {
+          meta[key] = 'null';
+        } else if (Array.isArray(value)) {
+          if (value.length > 0) {
+            const firstElement = value[0];
+            const elementType = typeof firstElement;
+            if (elementType === 'object' && firstElement !== null) {
+              meta[key] = `array[${Array.isArray(firstElement) ? 'array' : 'object'}]`;
+            } else {
+              meta[key] = `array[${elementType}]`;
+            }
+          } else {
+            meta[key] = 'array[]';
+          }
+        } else if (value instanceof Date) {
+          meta[key] = 'date';
+        } else if (type === 'object') {
+          meta[key] = getCompactMeta(value);
+        } else if (type === 'number') {
+          meta[key] = Number.isInteger(value) ? 'integer' : 'float';
+        } else {
+          meta[key] = type;
+        }
+      }
+      
+      return meta;
+    }
+    
+    return getCompactMeta(jsonObject);
+  } catch (error) {
+    console.error('Error in getMetaCompact:', error);
+    return {};
+  }
+}
+
+function getPartial(jsonObject, attributes) {
+  try {
+    if (typeof jsonObject === 'string') {
+      jsonObject = JSON.parse(jsonObject);
+    }
+
+    if (typeof jsonObject !== 'object' || jsonObject === null) {
+      return {};
+    }
+    
+    const result = {};
+
+    if (Array.isArray(attributes)) {
+      for (const attr of attributes) {
+        if (attr in jsonObject) {
+          result[attr] = jsonObject[attr];
+        }
+      }
+    }
+    else if (typeof attributes === 'string') {
+      if (attributes in jsonObject) {
+        result[attributes] = jsonObject[attributes];
+      }
+    }
+    else if (typeof attributes === 'object' && attributes !== null) {
+      for (const [newKey, originalKey] of Object.entries(attributes)) {
+        if (originalKey in jsonObject) {
+          result[newKey] = jsonObject[originalKey];
+        }
+      }
+    }
+    
+    return result;
+  } catch (error) {
+    console.error('Error in getPartial:', error);
+    return {};
+  }
+}
+
+function getPartialDeep(jsonObject, attributePaths) {
+  try {
+    if (typeof jsonObject === 'string') {
+      jsonObject = JSON.parse(jsonObject);
+    }
+
+    if (typeof jsonObject !== 'object' || jsonObject === null) {
+      return {};
+    }
+    
+    const result = {};
+
+    function getValueFromPath(obj, path) {
+      const parts = path.split('.');
+      let current = obj;
+      
+      for (const part of parts) {
+        if (current && typeof current === 'object' && part in current) {
+          current = current[part];
+        } else {
+          return undefined;
+        }
+      }
+      
+      return current;
+    }
+
+    if (Array.isArray(attributePaths)) {
+      for (const path of attributePaths) {
+        const value = getValueFromPath(jsonObject, path);
+        if (value !== undefined) {
+          const key = path.split('.').pop();
+          result[key] = value;
+        }
+      }
+    }
+    else if (typeof attributePaths === 'object' && attributePaths !== null) {
+      for (const [newKey, path] of Object.entries(attributePaths)) {
+        const value = getValueFromPath(jsonObject, path);
+        if (value !== undefined) {
+          result[newKey] = value;
+        }
+      }
+    }
+    
+    return result;
+  } catch (error) {
+    console.error('Error in getPartialDeep:', error);
+    return {};
+  }
+}
+
+function getPartialWithDefaults(jsonObject, attributesConfig) {
+  try {
+    if (typeof jsonObject === 'string') {
+      jsonObject = JSON.parse(jsonObject);
+    }
+
+    if (typeof jsonObject !== 'object' || jsonObject === null) {
+      return {};
+    }
+    
+    const result = {};
+
+    function getValueFromPath(obj, path, defaultValue) {
+      const parts = path.split('.');
+      let current = obj;
+      
+      for (const part of parts) {
+        if (current && typeof current === 'object' && part in current) {
+          current = current[part];
+        } else {
+          return defaultValue;
+        }
+      }
+      
+      return current;
+    }
+
+    for (const [outputKey, config] of Object.entries(attributesConfig)) {
+      if (typeof config === 'string') {
+        result[outputKey] = getValueFromPath(jsonObject, config, undefined);
+      } else if (typeof config === 'object' && config !== null) {
+        const path = config.path || outputKey;
+        const defaultValue = config.default;
+        let value = getValueFromPath(jsonObject, path, defaultValue);
+
+        if (config.transform && typeof config.transform === 'function') {
+          value = config.transform(value);
+        }
+        
+        result[outputKey] = value;
+      }
+    }
+    
+    return result;
+  } catch (error) {
+    console.error('Error in getPartialWithDefaults:', error);
+    return {};
+  }
+}
+
+function excludeAttributes(jsonObject, attributesToExclude) {
+  try {
+    if (typeof jsonObject === 'string') {
+      jsonObject = JSON.parse(jsonObject);
+    }
+
+    if (typeof jsonObject !== 'object' || jsonObject === null) {
+      return {};
+    }
+    
+    const result = { ...jsonObject };
+
+    if (Array.isArray(attributesToExclude)) {
+      for (const attr of attributesToExclude) {
+        delete result[attr];
+      }
+    }
+    else if (typeof attributesToExclude === 'string') {
+      delete result[attributesToExclude];
+    }
+    
+    return result;
+  } catch (error) {
+    console.error('Error in excludeAttributes:', error);
+    return {};
+  }
+}
+
+function getSize(jsonObject) {
+  try {
+    const jsonString = typeof jsonObject === 'string' 
+      ? jsonObject 
+      : JSON.stringify(jsonObject);
+    return new Blob([jsonString]).size;
+  } catch (error) {
+    console.error('Error in getSize:', error);
+    return 0;
+  }
+}
+
+function sortBy(array, key, ascending = true) {
+  try {
+    if (!Array.isArray(array)) return array;
+    
+    return [...array].sort((a, b) => {
+      const aValue = typeof key === 'function' ? key(a) : a[key];
+      const bValue = typeof key === 'function' ? key(b) : b[key];
+      
+      if (aValue < bValue) return ascending ? -1 : 1;
+      if (aValue > bValue) return ascending ? 1 : -1;
+      return 0;
+    });
+  } catch (error) {
+    console.error('Error in sortBy:', error);
+    return array;
+  }
+}
+
 module.exports = {
   getString,
   getFile,
@@ -146,4 +534,14 @@ module.exports = {
   getJSON,
   beautifyJSON,
   beautify,
-};
+  getAttributes,
+  getMeta,
+  getMetaDetail,
+  getMetaCompact,
+  getPartial,
+  getPartialDeep,
+  getPartialWithDefaults,
+  excludeAttributes,
+  getSize,
+  sortBy
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@terzogenito/json-utils",
-  "version": "1.0.9",
-  "description": "Check JSON Format",
+  "version": "1.0.11",
+  "description": "JSON data utilities",
   "main": "index.js",
   "files": [
     "index.js"
@@ -19,10 +19,17 @@
   "keywords": [
     "nodejs",
     "module",
+    "utils",
+    "tools",
     "json",
     "check",
-    "utils"
+    "beautify",
+    "analysis"
   ],
   "author": "Terzogenito",
-  "license": "MIT"
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/terzogenito/json-utils.git"
+  }
 }