Add initial implementation of Policy Request Library with README,...

Add initial implementation of Policy Request Library with README, configuration files, and utility functions

.gitignore

+# Dependencies
+node_modules/
+
+# Build output
+dist/
+*.tsbuildinfo
+
+# Logs
+*.log
+npm-debug.log*
+
+# OS
+.DS_Store
+Thumbs.db
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# Testing
+coverage/
+.nyc_output/
+
+# Environment
+.env
+.env.local
\ No newline at end of file

.npmignore

+# Source files
+src/
+tsconfig.json
+
+# Tests
+*.test.ts
+__tests__/
+
+# Development
+.vscode/
+.idea/
+
+# Git
+.git/
+.gitignore
+
+# CI/CD
+.github/
\ No newline at end of file

README.md

-# iaam-libs
+```markdown
+# Policy Request Library
 
+Utility library for creating and encoding policy requests for API headers in React Native applications.
+
+## Installation
+
+### From GitHub
+
+```bash
+npm install git+https://git.igridproject.info/iaam/iaam-libs.git
+
+# With specific version/tag
+npm install git+https://git.igridproject.info/iaam/iaam-libs.git#v1.0.0
+
+# With yarn
+yarn add https://git.igridproject.info/iaam/iaam-libs.git
+```
+
+### From package.json
+
+```json
+{
+  "dependencies": {
+    "iaam-libs": "git+https://git.igridproject.info/iaam/iaam-libs.git"
+  }
+}
+```
\ No newline at end of file

package.json

+{
+  "name": "iaam-libs",
+  "version": "1.0.0",
+  "description": "Policy request utility for encoding and sending via API headers",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build",
+    "test": "jest"
+  },
+  "keywords": [
+    "policy",
+    "request",
+    "base64",
+    "headers",
+    "react-native"
+  ],
+  "author": "DSS@NECTEC",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://git.igridproject.info/iaam/iaam-libs.git"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "axios": "^1.13.2",
+    "base-64": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/base-64": "^1.0.0",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "react-native": ">=0.60.0"
+  },
+  "peerDependenciesMeta": {
+    "react-native": {
+      "optional": true
+    }
+  }
+}

src/index.ts

+import { encode as base64Encode, decode as base64Decode } from 'base-64';
+import axios from 'axios';
+
+/**
+ * Resource Parameter Structure
+ */
+export interface ResourceParam {
+    path?: string;
+    [key: string]: any;
+}
+
+/**
+ * Resource Structure
+ */
+export interface Resource {
+    type?: string;
+    name?: string;
+    param?: ResourceParam;
+    [key: string]: any;
+}
+
+/**
+ * Subject Structure
+ */
+export interface Subject {
+    [key: string]: any;
+}
+
+/**
+ * Environment Structure
+ */
+export interface Environment {
+    [key: string]: any;
+}
+
+/**
+ * Policy Request Configuration
+ */
+export interface PolicyConfig {
+    subject?: Subject;
+    resource?: Resource;
+    action?: string;
+    environment?: Environment;
+}
+
+/**
+ * Policy Request Data Structure
+ */
+export interface PolicyRequestData {
+    subject: Subject;
+    resource: Resource;
+    action: string;
+    environment: Environment;
+}
+
+async function getPublicIP(): Promise<string> {
+    try {
+        const response = await axios.get("https://api.ipify.org/?format=json");
+        const ip = response.data?.ip;
+        if (!ip) {
+            throw new Error("IP address not found in response");
+        }
+        return ip;
+    } catch (error) {
+        // Do not throw here to avoid breaking callers that expect a string.
+        // Log the error and return empty string as a safe fallback.
+        console.error('getPublicIP error:', error);
+        return '';
+    }
+}
+
+/**
+ * Policy Request Utility Functions
+ */
+export class PolicyRequest {
+    /**
+     * Create policy request and encode to Base64
+     * @param config - Policy configuration object
+     * @returns Base64 encoded string
+     */
+    static create(config: PolicyConfig = {}): string {
+        const data: PolicyRequestData = {
+            subject: config.subject || {},
+            resource: {
+                type: config.resource?.type || 'API',
+                name: config.resource?.name || '',
+                param: {
+                    path: config.resource?.param?.path || '',
+                    ...config.resource?.param,
+                },
+                ...config.resource,
+            },
+            action: config.action || '',
+            environment: config.environment || {},
+        };
+
+        const jsonString = JSON.stringify(data);
+        return base64Encode(jsonString);
+    }
+
+    /**
+     * Create policy request headers
+     * @param config - Policy configuration object
+     * @param headerKey - Custom header key name (default: 'X-Policy-Request')
+     * @returns Headers object
+     */
+    static async createHeaders(
+        clientName: string,
+        url: string,
+        method: string,
+        subject: Subject = {},
+        ipVerify: Boolean = false,
+        headerKey: string = 'X-Policy-Request'
+    ): Promise<Record<string, string>> {
+        let environment: any = {
+            "resource": {
+                "type": "WEB",
+                "name": clientName,
+                "timestamp": new Date(),
+            }
+        }
+
+        if (ipVerify) {
+            environment["public_ip"] = await getPublicIP();
+        }
+        const policyConfig = {
+            subject: subject,
+            resource: {
+                "type": "API",
+                "name": "",
+                "param": {
+                    "path": new URL(url).pathname
+                }
+            },
+            action: method,
+            environment: environment
+        }
+        const encodedPolicy = PolicyRequest.create(policyConfig);
+        return {
+            [headerKey]: encodedPolicy,
+        };
+    }
+
+    /**
+     * Decode Base64 policy request back to object
+     * @param base64String - Base64 encoded policy request
+     * @returns Decoded policy data
+     */
+    static decode(base64String: string): PolicyRequestData {
+        try {
+            const decoded = base64Decode(base64String);
+            return JSON.parse(decoded);
+        } catch (error) {
+            throw new Error(
+                `Invalid policy request format: ${error instanceof Error ? error.message : 'Unknown error'}`
+            );
+        }
+    }
+
+    /**
+     * Validate policy request format
+     * @param data - Policy data to validate
+     * @returns true if valid, false otherwise
+     */
+    static validate(data: any): boolean {
+        if (!data || typeof data !== 'object') {
+            return false;
+        }
+
+        // Check required fields exist
+        if (!('subject' in data) || !('resource' in data) || !('action' in data) || !('environment' in data)) {
+            return false;
+        }
+
+        // Check subject and environment are objects
+        if (typeof data.subject !== 'object' || typeof data.environment !== 'object') {
+            return false;
+        }
+
+        // Check resource structure
+        if (typeof data.resource !== 'object') {
+            return false;
+        }
+
+        // Check action is string
+        if (typeof data.action !== 'string') {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Create policy request with validation
+     * @param config - Policy configuration object
+     * @returns Base64 encoded string
+     * @throws Error if validation fails
+     */
+    static createSafe(config: PolicyConfig = {}): string {
+        const data: PolicyRequestData = {
+            subject: config.subject || {},
+            resource: {
+                type: config.resource?.type || '',
+                name: config.resource?.name || '',
+                param: {
+                    path: config.resource?.param?.path || '',
+                    ...config.resource?.param,
+                },
+                ...config.resource,
+            },
+            action: config.action || '',
+            environment: config.environment || {},
+        };
+
+        if (!PolicyRequest.validate(data)) {
+            throw new Error('Invalid policy request data');
+        }
+
+        const jsonString = JSON.stringify(data);
+        return base64Encode(jsonString);
+    }
+}
+
+// Default export
+export default PolicyRequest;
\ No newline at end of file

tsconfig.json

+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}