@soilsidekick/sdk 1.2.0 → 2.0.0

package/sdks/dist/test-sdk.js

@@ -0,0 +1,366 @@
+"use strict";
+/**
+ * SoilSidekick Pro SDK Test Script
+ *
+ * This script validates SDK functionality including:
+ * - Authentication with API keys
+ * - Rate limiting headers
+ * - Tier-based feature access
+ * - Error handling
+ *
+ * Usage:
+ *   npx ts-node sdks/test-sdk.ts <API_KEY>
+ *
+ * Or with environment variable:
+ *   SOILSIDEKICK_API_KEY=ss_prod_xxx npx ts-node sdks/test-sdk.ts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ENDPOINT_TESTS = void 0;
+exports.runTestSuite = runTestSuite;
+exports.testEndpoint = testEndpoint;
+const BASE_URL = 'https://wzgnxkoeqzvueypwzvyn.supabase.co/functions/v1';
+// Test configurations by tier
+const ENDPOINT_TESTS = [
+    // Free tier endpoints
+    {
+        endpoint: '/get-soil-data',
+        method: 'POST',
+        body: { county_fips: '12086' }, // Miami-Dade
+        tierRequired: 'free',
+    },
+    {
+        endpoint: '/county-lookup',
+        method: 'POST',
+        body: { term: 'Miami' },
+        tierRequired: 'free',
+    },
+    // Starter tier endpoints
+    {
+        endpoint: '/territorial-water-quality',
+        method: 'POST',
+        body: { county_fips: '12086' },
+        tierRequired: 'starter',
+    },
+    {
+        endpoint: '/territorial-water-analytics',
+        method: 'POST',
+        body: { territory_type: 'state' },
+        tierRequired: 'starter',
+    },
+    {
+        endpoint: '/multi-parameter-planting-calendar',
+        method: 'POST',
+        body: { county_fips: '12086', crop_type: 'tomato' },
+        tierRequired: 'starter',
+    },
+    {
+        endpoint: '/live-agricultural-data',
+        method: 'POST',
+        body: {
+            county_fips: '12086',
+            data_types: ['weather', 'soil'],
+            state_code: 'FL',
+            county_name: 'Miami-Dade'
+        },
+        tierRequired: 'starter',
+    },
+    {
+        endpoint: '/environmental-impact-engine',
+        method: 'POST',
+        body: {
+            analysis_id: '00000000-0000-0000-0000-000000000000',
+            county_fips: '12086',
+            soil_data: { ph_level: 6.5, organic_matter: 3.2 }
+        },
+        tierRequired: 'starter',
+    },
+    // Pro tier endpoints
+    {
+        endpoint: '/alpha-earth-environmental-enhancement',
+        method: 'POST',
+        body: { latitude: 25.7617, longitude: -80.1918 },
+        tierRequired: 'pro',
+    },
+    {
+        endpoint: '/agricultural-intelligence',
+        method: 'POST',
+        body: { county_fips: '12086', analysis_type: 'crop_recommendation' },
+        tierRequired: 'pro',
+    },
+    {
+        endpoint: '/seasonal-planning-assistant',
+        method: 'POST',
+        body: {
+            location: { county_fips: '12086', state_code: 'FL' },
+            planningType: 'spring_planting'
+        },
+        tierRequired: 'pro',
+    },
+    {
+        endpoint: '/smart-report-summary',
+        method: 'POST',
+        body: {
+            reportType: 'soil',
+            reportData: { ph_level: 6.5, organic_matter: 3.2 }
+        },
+        tierRequired: 'pro',
+    },
+    {
+        endpoint: '/carbon-credit-calculator',
+        method: 'POST',
+        body: {
+            field_name: 'Test Field',
+            field_size_acres: 100
+        },
+        tierRequired: 'pro',
+    },
+    {
+        endpoint: '/leafengines-query',
+        method: 'POST',
+        body: {
+            location: { county_fips: '12086' },
+            plant: { common_name: 'Tomato' }
+        },
+        tierRequired: 'pro',
+        useXApiKey: true, // This endpoint uses x-api-key header
+    },
+    // Enterprise tier endpoints
+    {
+        endpoint: '/visual-crop-analysis',
+        method: 'POST',
+        body: {
+            image: 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==',
+            analysis_type: 'crop_health'
+        },
+        tierRequired: 'enterprise',
+    },
+];
+exports.ENDPOINT_TESTS = ENDPOINT_TESTS;
+async function testEndpoint(apiKey, config) {
+    const startTime = Date.now();
+    try {
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        // Some endpoints use x-api-key, others use Authorization Bearer
+        if (config.useXApiKey) {
+            headers['x-api-key'] = apiKey;
+        }
+        else {
+            headers['Authorization'] = `Bearer ${apiKey}`;
+        }
+        const response = await fetch(`${BASE_URL}${config.endpoint}`, {
+            method: config.method,
+            headers,
+            body: JSON.stringify(config.body),
+        });
+        const responseTime = Date.now() - startTime;
+        // Extract rate limit headers
+        const rateLimitHeaders = {
+            limit: response.headers.get('X-RateLimit-Limit') || undefined,
+            remaining: response.headers.get('X-RateLimit-Remaining') || undefined,
+            reset: response.headers.get('X-RateLimit-Reset') || undefined,
+        };
+        // Determine test result
+        let status = 'fail';
+        let error;
+        if (response.ok) {
+            status = 'pass';
+        }
+        else if (response.status === 401) {
+            error = 'Authentication failed - check API key';
+        }
+        else if (response.status === 403) {
+            // Tier restriction is expected for higher tiers
+            status = 'skip';
+            error = `Tier restriction - requires ${config.tierRequired} tier`;
+        }
+        else if (response.status === 429) {
+            error = 'Rate limited';
+        }
+        else {
+            const errorBody = await response.text();
+            error = `HTTP ${response.status}: ${errorBody.substring(0, 200)}`;
+        }
+        return {
+            endpoint: config.endpoint,
+            status,
+            statusCode: response.status,
+            rateLimitHeaders,
+            responseTime,
+            error,
+            tierRequired: config.tierRequired,
+        };
+    }
+    catch (err) {
+        return {
+            endpoint: config.endpoint,
+            status: 'fail',
+            responseTime: Date.now() - startTime,
+            error: err instanceof Error ? err.message : 'Unknown error',
+            tierRequired: config.tierRequired,
+        };
+    }
+}
+async function testRateLimiting(apiKey) {
+    console.log('\n🔄 Testing Rate Limiting...');
+    const results = [];
+    // Make rapid requests to test rate limiting
+    const rapidRequests = 5;
+    for (let i = 0; i < rapidRequests; i++) {
+        const result = await testEndpoint(apiKey, ENDPOINT_TESTS[0]); // Use free tier endpoint
+        results.push({
+            ...result,
+            endpoint: `/get-soil-data (request ${i + 1}/${rapidRequests})`,
+        });
+        // Log rate limit headers
+        if (result.rateLimitHeaders?.remaining) {
+            console.log(`  Request ${i + 1}: Remaining: ${result.rateLimitHeaders.remaining}`);
+        }
+        // Small delay to avoid overwhelming
+        await new Promise(r => setTimeout(r, 100));
+    }
+    return results;
+}
+async function testAuthenticationFailure() {
+    console.log('\n🔐 Testing Authentication Failure...');
+    const startTime = Date.now();
+    const response = await fetch(`${BASE_URL}/get-soil-data`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': 'Bearer invalid_api_key_12345',
+        },
+        body: JSON.stringify({ county_fips: '12086' }),
+    });
+    const passed = response.status === 401;
+    return {
+        endpoint: '/get-soil-data (invalid key)',
+        status: passed ? 'pass' : 'fail',
+        statusCode: response.status,
+        responseTime: Date.now() - startTime,
+        error: passed ? undefined : `Expected 401, got ${response.status}`,
+    };
+}
+async function testMissingAuthentication() {
+    console.log('\n🔐 Testing Missing Authentication...');
+    const startTime = Date.now();
+    const response = await fetch(`${BASE_URL}/get-soil-data`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ county_fips: '12086' }),
+    });
+    const passed = response.status === 401;
+    return {
+        endpoint: '/get-soil-data (no auth)',
+        status: passed ? 'pass' : 'fail',
+        statusCode: response.status,
+        responseTime: Date.now() - startTime,
+        error: passed ? undefined : `Expected 401, got ${response.status}`,
+    };
+}
+async function runTestSuite(apiKey) {
+    console.log('═'.repeat(60));
+    console.log('🧪 SoilSidekick Pro SDK Test Suite');
+    console.log('═'.repeat(60));
+    console.log(`\n📍 Base URL: ${BASE_URL}`);
+    console.log(`🔑 API Key: ${apiKey.substring(0, 12)}...${apiKey.slice(-4)}`);
+    const results = [];
+    // Test authentication failure scenarios
+    results.push(await testAuthenticationFailure());
+    results.push(await testMissingAuthentication());
+    // Test all endpoints
+    console.log('\n📋 Testing Endpoints by Tier...');
+    const tierGroups = {
+        free: ENDPOINT_TESTS.filter(t => t.tierRequired === 'free'),
+        starter: ENDPOINT_TESTS.filter(t => t.tierRequired === 'starter'),
+        pro: ENDPOINT_TESTS.filter(t => t.tierRequired === 'pro'),
+        enterprise: ENDPOINT_TESTS.filter(t => t.tierRequired === 'enterprise'),
+    };
+    for (const [tier, tests] of Object.entries(tierGroups)) {
+        console.log(`\n  [${tier.toUpperCase()} TIER]`);
+        for (const test of tests) {
+            const result = await testEndpoint(apiKey, test);
+            results.push(result);
+            const statusIcon = result.status === 'pass' ? '✅' : result.status === 'skip' ? '⏭️' : '❌';
+            console.log(`    ${statusIcon} ${test.endpoint} (${result.responseTime}ms)`);
+            if (result.error && result.status === 'fail') {
+                console.log(`       └─ ${result.error}`);
+            }
+            // Small delay between requests
+            await new Promise(r => setTimeout(r, 200));
+        }
+    }
+    // Test rate limiting
+    const rateLimitResults = await testRateLimiting(apiKey);
+    results.push(...rateLimitResults);
+    // Calculate summary
+    const summary = {
+        passed: results.filter(r => r.status === 'pass').length,
+        failed: results.filter(r => r.status === 'fail').length,
+        skipped: results.filter(r => r.status === 'skip').length,
+    };
+    return {
+        name: 'SoilSidekick Pro SDK Tests',
+        results,
+        summary,
+    };
+}
+function printSummary(suite) {
+    console.log('\n' + '═'.repeat(60));
+    console.log('📊 Test Summary');
+    console.log('═'.repeat(60));
+    console.log(`\n  ✅ Passed:  ${suite.summary.passed}`);
+    console.log(`  ❌ Failed:  ${suite.summary.failed}`);
+    console.log(`  ⏭️  Skipped: ${suite.summary.skipped}`);
+    console.log(`  📝 Total:   ${suite.results.length}`);
+    // List failed tests
+    const failed = suite.results.filter(r => r.status === 'fail');
+    if (failed.length > 0) {
+        console.log('\n  Failed Tests:');
+        for (const test of failed) {
+            console.log(`    - ${test.endpoint}: ${test.error}`);
+        }
+    }
+    // Print rate limit info from last successful request
+    const lastWithRateLimit = suite.results
+        .filter(r => r.rateLimitHeaders?.limit)
+        .pop();
+    if (lastWithRateLimit?.rateLimitHeaders) {
+        console.log('\n  Rate Limit Status:');
+        console.log(`    Limit:     ${lastWithRateLimit.rateLimitHeaders.limit}`);
+        console.log(`    Remaining: ${lastWithRateLimit.rateLimitHeaders.remaining}`);
+        console.log(`    Reset:     ${lastWithRateLimit.rateLimitHeaders.reset}`);
+    }
+    console.log('\n' + '═'.repeat(60));
+    // Exit code based on failures
+    const exitCode = suite.summary.failed > 0 ? 1 : 0;
+    console.log(`\n${exitCode === 0 ? '✅ All tests passed!' : '❌ Some tests failed.'}\n`);
+    return exitCode;
+}
+// CLI entry point
+async function main() {
+    const apiKey = process.argv[2] || process.env.SOILSIDEKICK_API_KEY;
+    if (!apiKey) {
+        console.error('❌ Error: API key required');
+        console.error('\nUsage:');
+        console.error('  npx ts-node sdks/test-sdk.ts <API_KEY>');
+        console.error('  SOILSIDEKICK_API_KEY=xxx npx ts-node sdks/test-sdk.ts');
+        process.exit(1);
+    }
+    try {
+        const suite = await runTestSuite(apiKey);
+        const exitCode = printSummary(suite);
+        process.exit(exitCode);
+    }
+    catch (error) {
+        console.error('❌ Test suite failed:', error);
+        process.exit(1);
+    }
+}
+// Run if executed directly
+if (typeof require !== 'undefined' && require.main === module) {
+    main();
+}

package/sdks/dist/types.d.ts

@@ -0,0 +1,162 @@
+/**
+ * LeafEngines SDK v2.0 - Sensor Types
+ *
+ * Core type definitions for Skyline Instruments sensor integration
+ */
+export type DeviceType = 'mmwave_radar' | 'quantum_rf' | 'precision_timing';
+export type DeviceStatus = 'active' | 'inactive' | 'error' | 'maintenance';
+export interface SensorDevice {
+    id: string;
+    deviceId: string;
+    deviceType: DeviceType;
+    farmId?: string;
+    firmwareVersion: string;
+    status: DeviceStatus;
+    batteryLevel?: number;
+    signalStrength?: number;
+    lastSeenAt: Date;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface RegisterDeviceParams {
+    deviceId: string;
+    deviceType: DeviceType;
+    farmId?: string;
+    firmwareVersion: string;
+}
+export interface UpdateDeviceParams {
+    farmId?: string;
+    firmwareVersion?: string;
+    status?: DeviceStatus;
+}
+export interface SensorReading {
+    id: string;
+    deviceId: string;
+    timestamp: Date;
+    metric: string;
+    value: number;
+    unit: string;
+    confidence?: number;
+    receivedAt: Date;
+}
+export interface SensorReadingData {
+    metric: string;
+    value: number;
+    unit: string;
+    confidence?: number;
+    timestamp: Date;
+}
+export interface SensorReadingPayload {
+    deviceId: string;
+    deviceType: DeviceType;
+    timestamp: Date;
+    readings: SensorReadingData[];
+    metadata: {
+        firmwareVersion: string;
+        batteryLevel?: number;
+        signalStrength?: number;
+    };
+}
+export interface IngestionResponse {
+    ingestionId: string;
+    queuedAt: Date;
+    processedReadings: number;
+    estimatedProcessingMs: number;
+    status: 'success' | 'partial' | 'failed';
+}
+export interface ReadingsQueryParams {
+    deviceId?: string;
+    metric?: string;
+    startTime: Date;
+    endTime: Date;
+    limit?: number;
+    offset?: number;
+    order?: 'asc' | 'desc';
+}
+export interface ReadingsAggregation {
+    deviceId: string;
+    metric: string;
+    startTime: Date;
+    endTime: Date;
+    count: number;
+    avg?: number;
+    min?: number;
+    max?: number;
+    sum?: number;
+    interval: string;
+}
+export type AlertSeverity = 'info' | 'warning' | 'critical';
+export type AlertType = 'heat_stress' | 'equipment_malfunction' | 'battery_low' | 'signal_lost' | 'anomaly_detected' | 'threshold_exceeded' | 'environmental_hazard';
+export interface SensorAlert {
+    id: string;
+    deviceId: string;
+    alertType: AlertType;
+    severity: AlertSeverity;
+    message: string;
+    details?: Record<string, any>;
+    acknowledged: boolean;
+    acknowledgedBy?: string;
+    acknowledgedAt?: Date;
+    timestamp: Date;
+    createdAt: Date;
+}
+export interface AlertsQueryParams {
+    deviceId?: string;
+    alertType?: AlertType;
+    severity?: AlertSeverity;
+    acknowledged?: boolean;
+    startTime?: Date;
+    endTime?: Date;
+    limit?: number;
+}
+export interface AlertSubscription {
+    severity?: AlertSeverity[];
+    deviceId?: string;
+    alertType?: AlertType;
+}
+export interface MQTTConfig {
+    host: string;
+    port: number;
+    protocol: 'mqtts' | 'wss';
+    username: string;
+    password: string;
+    reconnectPeriod?: number;
+    connectTimeout?: number;
+}
+export interface MQTTPublishOptions {
+    qos?: 0 | 1 | 2;
+    retain?: boolean;
+}
+export type ConnectionStatus = 'connecting' | 'connected' | 'disconnected' | 'error';
+export interface APIResponse<T> {
+    data: T;
+    meta?: {
+        total?: number;
+        limit?: number;
+        offset?: number;
+    };
+}
+export interface APIError {
+    code: string;
+    message: string;
+    details?: Record<string, any>;
+}
+export interface Subscription {
+    unsubscribe(): void;
+    isActive(): boolean;
+}
+export type MessageHandler<T> = (message: T) => void;
+export interface ClientConfig {
+    apiKey: string;
+    projectRef: string;
+    baseUrl?: string;
+    environment?: 'production' | 'sandbox';
+    timeout?: number;
+}
+export interface RequestOptions {
+    method: 'GET' | 'POST' | 'PATCH' | 'DELETE';
+    endpoint: string;
+    body?: any;
+    params?: Record<string, any>;
+    headers?: Record<string, string>;
+}

package/sdks/dist/types.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * LeafEngines SDK v2.0 - Sensor Types
+ *
+ * Core type definitions for Skyline Instruments sensor integration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/sdks/generate-sdk.sh

@@ -0,0 +1,169 @@
+#!/bin/bash
+
+# SoilSidekick Pro SDK Generator
+# Usage: ./generate-sdk.sh [language] [version]
+# Languages: typescript, python, go, ruby, java, php, all
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SPEC_FILE="$SCRIPT_DIR/../openapi-spec.yaml"
+OUTPUT_DIR="$SCRIPT_DIR/generated"
+VERSION="${2:-1.2.0}"
+LANGUAGE="${1:-all}"
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+echo "═══════════════════════════════════════════════════════════"
+echo "  SoilSidekick Pro SDK Generator v${VERSION}"
+echo "═══════════════════════════════════════════════════════════"
+
+# Check for openapi-generator-cli
+if ! command -v openapi-generator-cli &> /dev/null; then
+    echo -e "${YELLOW}Installing openapi-generator-cli...${NC}"
+    npm install -g @openapitools/openapi-generator-cli
+fi
+
+# Validate spec first
+echo -e "\n${YELLOW}Validating OpenAPI specification...${NC}"
+openapi-generator-cli validate -i "$SPEC_FILE"
+echo -e "${GREEN}✓ Specification is valid${NC}"
+
+# Create output directories
+mkdir -p "$OUTPUT_DIR"
+
+generate_typescript() {
+    echo -e "\n${YELLOW}Generating TypeScript SDK...${NC}"
+    openapi-generator-cli generate \
+        -i "$SPEC_FILE" \
+        -g typescript-fetch \
+        -o "$OUTPUT_DIR/typescript" \
+        --additional-properties=npmName=@soilsidekick/sdk,npmVersion=$VERSION,supportsES6=true,typescriptThreePlus=true \
+        --skip-validate-spec
+    
+    # Create tsconfig for the generated SDK
+    cat > "$OUTPUT_DIR/typescript/tsconfig.json" << 'EOF'
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}
+EOF
+    echo -e "${GREEN}✓ TypeScript SDK generated at $OUTPUT_DIR/typescript${NC}"
+}
+
+generate_python() {
+    echo -e "\n${YELLOW}Generating Python SDK...${NC}"
+    openapi-generator-cli generate \
+        -i "$SPEC_FILE" \
+        -g python \
+        -o "$OUTPUT_DIR/python" \
+        --additional-properties=packageName=soilsidekick,packageVersion=$VERSION,projectName=soilsidekick-sdk \
+        --skip-validate-spec
+    echo -e "${GREEN}✓ Python SDK generated at $OUTPUT_DIR/python${NC}"
+}
+
+generate_go() {
+    echo -e "\n${YELLOW}Generating Go SDK...${NC}"
+    openapi-generator-cli generate \
+        -i "$SPEC_FILE" \
+        -g go \
+        -o "$OUTPUT_DIR/go" \
+        --additional-properties=packageName=soilsidekick,packageVersion=$VERSION,isGoSubmodule=true \
+        --skip-validate-spec
+    echo -e "${GREEN}✓ Go SDK generated at $OUTPUT_DIR/go${NC}"
+}
+
+generate_ruby() {
+    echo -e "\n${YELLOW}Generating Ruby SDK...${NC}"
+    openapi-generator-cli generate \
+        -i "$SPEC_FILE" \
+        -g ruby \
+        -o "$OUTPUT_DIR/ruby" \
+        --additional-properties=gemName=soilsidekick,gemVersion=$VERSION,moduleName=SoilSidekick \
+        --skip-validate-spec
+    echo -e "${GREEN}✓ Ruby SDK generated at $OUTPUT_DIR/ruby${NC}"
+}
+
+generate_java() {
+    echo -e "\n${YELLOW}Generating Java SDK...${NC}"
+    openapi-generator-cli generate \
+        -i "$SPEC_FILE" \
+        -g java \
+        -o "$OUTPUT_DIR/java" \
+        --additional-properties=artifactId=soilsidekick-sdk,groupId=com.soilsidekick,artifactVersion=$VERSION,library=native \
+        --skip-validate-spec
+    echo -e "${GREEN}✓ Java SDK generated at $OUTPUT_DIR/java${NC}"
+}
+
+generate_php() {
+    echo -e "\n${YELLOW}Generating PHP SDK...${NC}"
+    openapi-generator-cli generate \
+        -i "$SPEC_FILE" \
+        -g php \
+        -o "$OUTPUT_DIR/php" \
+        --additional-properties=packageName=SoilSidekick,invokerPackage=SoilSidekick,artifactVersion=$VERSION \
+        --skip-validate-spec
+    echo -e "${GREEN}✓ PHP SDK generated at $OUTPUT_DIR/php${NC}"
+}
+
+# Generate based on language argument
+case $LANGUAGE in
+    typescript|ts)
+        generate_typescript
+        ;;
+    python|py)
+        generate_python
+        ;;
+    go)
+        generate_go
+        ;;
+    ruby|rb)
+        generate_ruby
+        ;;
+    java)
+        generate_java
+        ;;
+    php)
+        generate_php
+        ;;
+    all)
+        generate_typescript
+        generate_python
+        generate_go
+        generate_ruby
+        generate_java
+        generate_php
+        ;;
+    *)
+        echo -e "${RED}Unknown language: $LANGUAGE${NC}"
+        echo "Supported: typescript, python, go, ruby, java, php, all"
+        exit 1
+        ;;
+esac
+
+echo -e "\n═══════════════════════════════════════════════════════════"
+echo -e "${GREEN}SDK generation complete!${NC}"
+echo "═══════════════════════════════════════════════════════════"
+echo ""
+echo "Generated SDKs are in: $OUTPUT_DIR"
+echo ""
+echo "Next steps:"
+echo "  1. cd $OUTPUT_DIR/<language>"
+echo "  2. Follow the README.md for installation"
+echo "  3. Run tests: npm run test (from sdks directory)"