import axios from 'axios';
import { Pool } from 'pg';

interface TaskTrackerConfig {
    apiKey: string;
    workspaceId: string;
    apiUrl: string;
}

interface Task {
    id: string;
    title: string;
    description?: string;
    status: string;
    priority?: string;
    project_id?: string;
    assignee_id?: string;
    created_at: string;
    updated_at: string;
    completed_at?: string;
    due_date?: string;
}

class TaskTrackerSync {
    private config: TaskTrackerConfig;
    private db: Pool;

    constructor(config: TaskTrackerConfig, db: Pool) {
        this.config = config;
        this.db = db;
    }

    async syncTasks(since?: Date): Promise<number> {
        console.log('Fetching tasks from TaskTracker...');

        // Update sync state
        await this.db.query(
            `UPDATE tasktracker.sync_state
             SET status = 'syncing', last_error = NULL
             WHERE resource = 'tasks'`
        );

        try {
            // Fetch tasks from API
            const params: any = {
                workspace_id: this.config.workspaceId
            };

            if (since) {
                params.updated_since = since.toISOString();
            }

            const response = await axios.get(
                `${this.config.apiUrl}/tasks`,
                {
                    headers: {
                        'Authorization': `Bearer ${this.config.apiKey}`,
                        'Accept': 'application/json'
                    },
                    params
                }
            );

            const tasks: Task[] = response.data.tasks;

            console.log(`Fetched ${tasks.length} tasks`);

            // Upsert tasks into database
            let synced = 0;
            for (const task of tasks) {
                await this.db.query(`
                    INSERT INTO tasktracker.tasks (
                        id, title, description, status, priority,
                        project_id, assignee_id, created_at, updated_at,
                        completed_at, due_date, synced_at, sync_version
                    ) VALUES (
                        $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, NOW(), 1
                    )
                    ON CONFLICT (id) DO UPDATE SET
                        title = EXCLUDED.title,
                        description = EXCLUDED.description,
                        status = EXCLUDED.status,
                        priority = EXCLUDED.priority,
                        project_id = EXCLUDED.project_id,
                        assignee_id = EXCLUDED.assignee_id,
                        updated_at = EXCLUDED.updated_at,
                        completed_at = EXCLUDED.completed_at,
                        due_date = EXCLUDED.due_date,
                        synced_at = NOW(),
                        sync_version = tasktracker.tasks.sync_version + 1
                `, [
                    task.id,
                    task.title,
                    task.description,
                    task.status,
                    task.priority,
                    task.project_id,
                    task.assignee_id,
                    task.created_at,
                    task.updated_at,
                    task.completed_at,
                    task.due_date
                ]);

                synced++;
            }

            // Update sync state
            await this.db.query(`
                UPDATE tasktracker.sync_state
                SET status = 'idle',
                    last_sync_at = NOW(),
                    records_synced = records_synced + $1
                WHERE resource = 'tasks'
            `, [synced]);

            console.log(`Synced ${synced} tasks successfully`);

            return synced;

        } catch (error: any) {
            // Update error state
            await this.db.query(`
                UPDATE tasktracker.sync_state
                SET status = 'error',
                    sync_errors = sync_errors + 1,
                    last_error = $1
                WHERE resource = 'tasks'
            `, [error.message]);

            throw error;
        }
    }

    async syncProjects(): Promise<number> {
        // Similar implementation for projects
        return 0;
    }

    async syncUsers(): Promise<number> {
        // Similar implementation for users
        return 0;
    }

    async syncAll(): Promise<void> {
        await this.syncUsers();
        await this.syncProjects();
        await this.syncTasks();
    }
}

export default TaskTrackerSync;

// CLI entry point
if (require.main === module) {
    const config: TaskTrackerConfig = {
        apiKey: process.env.TASKTRACKER_API_KEY || '',
        workspaceId: process.env.TASKTRACKER_WORKSPACE_ID || '',
        apiUrl: process.env.TASKTRACKER_API_URL || 'https://api.tasktracker.com/v1'
    };

    const db = new Pool({
        host: process.env.POSTGRES_HOST || 'localhost',
        port: parseInt(process.env.POSTGRES_PORT || '5432'),
        database: process.env.POSTGRES_DB || 'nself',
        user: process.env.POSTGRES_USER || 'postgres',
        password: process.env.POSTGRES_PASSWORD
    });

    const sync = new TaskTrackerSync(config, db);

    sync.syncAll()
        .then(() => {
            console.log('Sync completed successfully');
            process.exit(0);
        })
        .catch((error) => {
            console.error('Sync failed:', error.message);
            process.exit(1);
        })
        .finally(() => {
            db.end();
        });
}

import { describe, it, expect, beforeAll, afterAll } from '@jest/globals';
import { Pool } from 'pg';
import TaskTrackerSync from '../src/sync';

describe('TaskTracker Sync', () => {
    let db: Pool;
    let sync: TaskTrackerSync;

    beforeAll(async () => {
        db = new Pool({
            host: 'localhost',
            port: 5432,
            database: 'test_nself',
            user: 'postgres',
            password: 'test'
        });

        // Apply schema
        const schema = require('fs').readFileSync('schema/schema.sql', 'utf8');
        await db.query(schema);

        sync = new TaskTrackerSync({
            apiKey: 'test_key',
            workspaceId: 'test_workspace',
            apiUrl: 'http://localhost:3000'
        }, db);
    });

    afterAll(async () => {
        await db.end();
    });

    it('should sync tasks', async () => {
        const count = await sync.syncTasks();
        expect(count).toBeGreaterThanOrEqual(0);
    });

    it('should handle sync errors', async () => {
        // Test error handling
    });
});

import axios, { AxiosInstance, AxiosRequestConfig } from 'axios';

interface ClientConfig {
    apiKey: string;
    apiUrl: string;
    timeout?: number;
    retries?: number;
}

class APIClient {
    private client: AxiosInstance;
    private config: ClientConfig;

    constructor(config: ClientConfig) {
        this.config = {
            timeout: 30000,
            retries: 3,
            ...config
        };

        this.client = axios.create({
            baseURL: config.apiUrl,
            timeout: this.config.timeout,
            headers: {
                'Authorization': `Bearer ${config.apiKey}`,
                'Accept': 'application/json',
                'User-Agent': 'nself-plugin/1.0'
            }
        });

        // Add retry interceptor
        this.client.interceptors.response.use(
            response => response,
            async error => {
                const config = error.config;

                if (!config || !config.retries) {
                    config.retries = 0;
                }

                if (config.retries < this.config.retries!) {
                    config.retries++;

                    // Exponential backoff
                    const delay = Math.pow(2, config.retries) * 1000;
                    await new Promise(resolve => setTimeout(resolve, delay));

                    return this.client(config);
                }

                return Promise.reject(error);
            }
        );
    }

    async get<T>(path: string, params?: any): Promise<T> {
        const response = await this.client.get(path, { params });
        return response.data;
    }

    async post<T>(path: string, data?: any): Promise<T> {
        const response = await this.client.post(path, data);
        return response.data;
    }

    async paginate<T>(
        path: string,
        params?: any,
        pageKey: string = 'page'
    ): Promise<T[]> {
        const results: T[] = [];
        let page = 1;
        let hasMore = true;

        while (hasMore) {
            const response: any = await this.get(path, {
                ...params,
                [pageKey]: page
            });

            results.push(...response.data);
            hasMore = response.has_more || false;
            page++;
        }

        return results;
    }
}

export default APIClient;

class DataSync {
    async fullSync(): Promise<void> {
        console.log('Performing full sync...');

        // Clear existing data (optional)
        await this.db.query('TRUNCATE stripe.customers CASCADE');

        // Fetch all data
        const customers = await this.client.paginate('/customers');

        // Insert all records
        for (const customer of customers) {
            await this.insertCustomer(customer);
        }
    }

    async incrementalSync(since: Date): Promise<void> {
        console.log(`Performing incremental sync since ${since}...`);

        // Fetch only updated records
        const customers = await this.client.get('/customers', {
            updated_since: since.toISOString()
        });

        // Upsert records
        for (const customer of customers.data) {
            await this.upsertCustomer(customer);
        }
    }

    async sync(): Promise<void> {
        // Get last sync time
        const result = await this.db.query(
            'SELECT last_sync_at FROM stripe.sync_state WHERE resource = $1',
            ['customers']
        );

        const lastSync = result.rows[0]?.last_sync_at;

        if (!lastSync) {
            // First sync - do full
            await this.fullSync();
        } else {
            // Subsequent syncs - incremental
            await this.incrementalSync(new Date(lastSync));
        }

        // Update sync time
        await this.db.query(
            'UPDATE stripe.sync_state SET last_sync_at = NOW() WHERE resource = $1',
            ['customers']
        );
    }
}

class RateLimiter {
    private requests: number = 0;
    private resetTime: number = Date.now();
    private limit: number;
    private window: number;

    constructor(limit: number = 100, window: number = 60000) {
        this.limit = limit;
        this.window = window;
    }

    async checkLimit(): Promise<void> {
        const now = Date.now();

        // Reset counter if window expired
        if (now - this.resetTime > this.window) {
            this.requests = 0;
            this.resetTime = now;
        }

        // Wait if limit reached
        if (this.requests >= this.limit) {
            const waitTime = this.window - (now - this.resetTime);
            console.log(`Rate limit reached. Waiting ${waitTime}ms...`);
            await new Promise(resolve => setTimeout(resolve, waitTime));

            this.requests = 0;
            this.resetTime = Date.now();
        }

        this.requests++;
    }

    async execute<T>(fn: () => Promise<T>): Promise<T> {
        await this.checkLimit();
        return fn();
    }
}

// Usage
const limiter = new RateLimiter(100, 60000); // 100 req/min

for (const item of items) {
    await limiter.execute(async () => {
        return this.client.get(`/items/${item.id}`);
    });
}

class SyncManager {
    async syncWithRecovery(): Promise<void> {
        // Save checkpoint before sync
        const checkpoint = await this.createCheckpoint();

        try {
            await this.sync();

            // Mark checkpoint as successful
            await this.markCheckpointSuccess(checkpoint);

        } catch (error) {
            console.error('Sync failed:', error);

            // Save error details
            await this.db.query(
                'UPDATE stripe.sync_state SET last_error = $1, sync_errors = sync_errors + 1',
                [error.message]
            );

            // Rollback to checkpoint
            await this.rollbackToCheckpoint(checkpoint);

            throw error;
        }
    }

    async createCheckpoint(): Promise<string> {
        const checkpointId = `checkpoint_${Date.now()}`;

        // Save current state
        await this.db.query(
            'INSERT INTO stripe.checkpoints (id, created_at, state) VALUES ($1, NOW(), $2)',
            [checkpointId, JSON.stringify(await this.getState())]
        );

        return checkpointId;
    }

    async rollbackToCheckpoint(checkpointId: string): Promise<void> {
        // Restore state from checkpoint
        const result = await this.db.query(
            'SELECT state FROM stripe.checkpoints WHERE id = $1',
            [checkpointId]
        );

        if (result.rows.length > 0) {
            const state = JSON.parse(result.rows[0].state);
            await this.restoreState(state);
        }
    }
}

import cron from 'node-cron';

class SyncScheduler {
    private tasks: Map<string, cron.ScheduledTask> = new Map();

    scheduleSync(resource: string, schedule: string): void {
        // Cancel existing task
        this.cancelSync(resource);

        // Schedule new task
        const task = cron.schedule(schedule, async () => {
            console.log(`Running scheduled sync for ${resource}...`);

            try {
                await this.sync(resource);
            } catch (error) {
                console.error(`Scheduled sync failed for ${resource}:`, error);
            }
        });

        this.tasks.set(resource, task);
        console.log(`Scheduled ${resource} sync: ${schedule}`);
    }

    cancelSync(resource: string): void {
        const task = this.tasks.get(resource);
        if (task) {
            task.stop();
            this.tasks.delete(resource);
        }
    }

    cancelAll(): void {
        for (const [resource, task] of this.tasks) {
            task.stop();
        }
        this.tasks.clear();
    }
}

// Usage
const scheduler = new SyncScheduler();

// Sync every hour
scheduler.scheduleSync('customers', '0 * * * *');

// Sync every 15 minutes
scheduler.scheduleSync('subscriptions', '*/15 * * * *');

// Sync daily at midnight
scheduler.scheduleSync('invoices', '0 0 * * *');

enum ConflictResolution {
    REMOTE_WINS = 'remote_wins',
    LOCAL_WINS = 'local_wins',
    NEWEST_WINS = 'newest_wins',
    MANUAL = 'manual'
}

class ConflictResolver {
    async resolveConflict(
        local: any,
        remote: any,
        strategy: ConflictResolution
    ): Promise<any> {
        switch (strategy) {
            case ConflictResolution.REMOTE_WINS:
                return remote;

            case ConflictResolution.LOCAL_WINS:
                return local;

            case ConflictResolution.NEWEST_WINS:
                const localTime = new Date(local.updated_at).getTime();
                const remoteTime = new Date(remote.updated_at).getTime();
                return remoteTime > localTime ? remote : local;

            case ConflictResolution.MANUAL:
                // Log conflict for manual resolution
                await this.logConflict(local, remote);
                return null;

            default:
                return remote;
        }
    }

    async logConflict(local: any, remote: any): Promise<void> {
        await this.db.query(`
            INSERT INTO stripe.conflicts (
                resource_type,
                resource_id,
                local_data,
                remote_data,
                created_at
            ) VALUES ($1, $2, $3, $4, NOW())
        `, [
            'customer',
            local.id,
            JSON.stringify(local),
            JSON.stringify(remote)
        ]);
    }
}

class WebhookManager {
    async registerWebhook(): Promise<void> {
        const webhookUrl = this.getWebhookUrl();

        console.log(`Registering webhook at ${webhookUrl}...`);

        try {
            const response = await this.client.post('/webhooks', {
                url: webhookUrl,
                enabled_events: [
                    'customer.created',
                    'customer.updated',
                    'customer.deleted',
                    'subscription.*',
                    'invoice.*'
                ],
                description: 'nself-stripe webhook'
            });

            const webhookSecret = response.secret;

            console.log('Webhook registered successfully');
            console.log(`Webhook ID: ${response.id}`);
            console.log(`Add to .env: STRIPE_WEBHOOK_SECRET=${webhookSecret}`);

        } catch (error) {
            console.error('Failed to register webhook:', error);
            throw error;
        }
    }

    getWebhookUrl(): string {
        const domain = process.env.BASE_DOMAIN || 'localhost';
        const path = process.env.STRIPE_WEBHOOK_PATH || '/webhooks/stripe';

        return `https://api.${domain}${path}`;
    }
}

import crypto from 'crypto';

class WebhookVerifier {
    verifySignature(
        payload: string,
        signature: string,
        secret: string
    ): boolean {
        // Extract timestamp and signatures
        const parts = signature.split(',');
        const timestamp = parts.find(p => p.startsWith('t='))?.slice(2);
        const sigs = parts.filter(p => p.startsWith('v1='));

        if (!timestamp || sigs.length === 0) {
            return false;
        }

        // Compute expected signature
        const signedPayload = `${timestamp}.${payload}`;
        const expected = crypto
            .createHmac('sha256', secret)
            .update(signedPayload, 'utf8')
            .digest('hex');

        // Check if any signature matches
        return sigs.some(sig => {
            const actual = sig.slice(3);
            return crypto.timingSafeEqual(
                Buffer.from(expected),
                Buffer.from(actual)
            );
        });
    }

    checkTimestamp(signature: string, tolerance: number = 300): boolean {
        const parts = signature.split(',');
        const timestamp = parts.find(p => p.startsWith('t='))?.slice(2);

        if (!timestamp) {
            return false;
        }

        const now = Math.floor(Date.now() / 1000);
        const diff = now - parseInt(timestamp);

        return diff <= tolerance;
    }
}

interface WebhookEvent {
    id: string;
    type: string;
    data: {
        object: any;
        previous_attributes?: any;
    };
    created: number;
}

class WebhookProcessor {
    async processEvent(event: WebhookEvent): Promise<void> {
        console.log(`Processing event: ${event.type} (${event.id})`);

        // Log event for audit trail
        await this.logEvent(event);

        // Route to handler
        switch (event.type) {
            case 'customer.created':
                await this.handleCustomerCreated(event);
                break;

            case 'customer.updated':
                await this.handleCustomerUpdated(event);
                break;

            case 'customer.deleted':
                await this.handleCustomerDeleted(event);
                break;

            case 'subscription.created':
            case 'subscription.updated':
                await this.handleSubscriptionUpdated(event);
                break;

            default:
                console.log(`Unhandled event type: ${event.type}`);
        }
    }

    async handleCustomerCreated(event: WebhookEvent): Promise<void> {
        const customer = event.data.object;

        await this.db.query(`
            INSERT INTO stripe.customers (
                id, email, name, description, created, synced_at
            ) VALUES ($1, $2, $3, $4, to_timestamp($5), NOW())
            ON CONFLICT (id) DO NOTHING
        `, [
            customer.id,
            customer.email,
            customer.name,
            customer.description,
            customer.created
        ]);

        console.log(`Customer created: ${customer.id}`);
    }

    async handleCustomerUpdated(event: WebhookEvent): Promise<void> {
        const customer = event.data.object;

        await this.db.query(`
            UPDATE stripe.customers
            SET email = $2,
                name = $3,
                description = $4,
                synced_at = NOW(),
                sync_version = sync_version + 1
            WHERE id = $1
        `, [
            customer.id,
            customer.email,
            customer.name,
            customer.description
        ]);

        console.log(`Customer updated: ${customer.id}`);
    }

    async handleCustomerDeleted(event: WebhookEvent): Promise<void> {
        const customer = event.data.object;

        await this.db.query(`
            UPDATE stripe.customers
            SET is_deleted = true,
                synced_at = NOW()
            WHERE id = $1
        `, [customer.id]);

        console.log(`Customer deleted: ${customer.id}`);
    }

    async logEvent(event: WebhookEvent): Promise<void> {
        await this.db.query(`
            INSERT INTO stripe.events (
                id, type, data, created_at, processed_at
            ) VALUES ($1, $2, $3, to_timestamp($4), NOW())
            ON CONFLICT (id) DO NOTHING
        `, [
            event.id,
            event.type,
            JSON.stringify(event.data),
            event.created
        ]);
    }
}

class IdempotencyManager {
    async isProcessed(eventId: string): Promise<boolean> {
        const result = await this.db.query(
            'SELECT id FROM stripe.events WHERE id = $1',
            [eventId]
        );

        return result.rows.length > 0;
    }

    async processOnce(
        eventId: string,
        handler: () => Promise<void>
    ): Promise<void> {
        // Check if already processed
        if (await this.isProcessed(eventId)) {
            console.log(`Event ${eventId} already processed, skipping`);
            return;
        }

        // Process with transaction
        const client = await this.db.connect();

        try {
            await client.query('BEGIN');

            // Execute handler
            await handler();

            // Mark as processed
            await client.query(
                'INSERT INTO stripe.events (id, processed_at) VALUES ($1, NOW()) ON CONFLICT DO NOTHING',
                [eventId]
            );

            await client.query('COMMIT');

        } catch (error) {
            await client.query('ROLLBACK');
            throw error;

        } finally {
            client.release();
        }
    }
}

class WebhookErrorHandler {
    async handleError(
        event: WebhookEvent,
        error: Error
    ): Promise<void> {
        console.error(`Error processing event ${event.id}:`, error);

        // Log error
        await this.db.query(`
            INSERT INTO stripe.webhook_errors (
                event_id,
                event_type,
                error_message,
                error_stack,
                created_at,
                retry_count
            ) VALUES ($1, $2, $3, $4, NOW(), 0)
            ON CONFLICT (event_id) DO UPDATE SET
                retry_count = stripe.webhook_errors.retry_count + 1,
                last_retry_at = NOW()
        `, [
            event.id,
            event.type,
            error.message,
            error.stack
        ]);

        // Queue for retry if transient error
        if (this.isTransientError(error)) {
            await this.queueRetry(event);
        }
    }

    isTransientError(error: Error): boolean {
        // Network errors, timeouts, rate limits
        return error.message.includes('ECONNREFUSED') ||
               error.message.includes('timeout') ||
               error.message.includes('rate limit');
    }

    async queueRetry(event: WebhookEvent): Promise<void> {
        await this.db.query(`
            INSERT INTO stripe.webhook_retry_queue (
                event_id,
                event_data,
                scheduled_at
            ) VALUES ($1, $2, NOW() + INTERVAL '5 minutes')
        `, [
            event.id,
            JSON.stringify(event)
        ]);
    }
}

// tests/unit/sync.test.ts
import { describe, it, expect, jest, beforeEach } from '@jest/globals';
import TaskTrackerSync from '../../src/sync';
import APIClient from '../../src/client';

// Mock dependencies
jest.mock('../../src/client');

describe('TaskTrackerSync', () => {
    let sync: TaskTrackerSync;
    let mockClient: jest.Mocked<APIClient>;
    let mockDb: any;

    beforeEach(() => {
        mockClient = new APIClient({
            apiKey: 'test',
            apiUrl: 'http://test'
        }) as jest.Mocked<APIClient>;

        mockDb = {
            query: jest.fn()
        };

        sync = new TaskTrackerSync(
            { apiKey: 'test', workspaceId: 'test', apiUrl: 'http://test' },
            mockDb
        );
    });

    describe('syncTasks', () => {
        it('should fetch and sync tasks', async () => {
            // Mock API response
            mockClient.get = jest.fn().mockResolvedValue({
                tasks: [
                    {
                        id: 'task_1',
                        title: 'Test Task',
                        status: 'todo',
                        created_at: '2024-01-01T00:00:00Z',
                        updated_at: '2024-01-01T00:00:00Z'
                    }
                ]
            });

            mockDb.query.mockResolvedValue({ rows: [] });

            const count = await sync.syncTasks();

            expect(count).toBe(1);
            expect(mockDb.query).toHaveBeenCalled();
        });

        it('should handle API errors', async () => {
            mockClient.get = jest.fn().mockRejectedValue(
                new Error('API error')
            );

            await expect(sync.syncTasks()).rejects.toThrow('API error');
        });

        it('should handle incremental sync', async () => {
            const since = new Date('2024-01-01');

            mockClient.get = jest.fn().mockResolvedValue({
                tasks: []
            });

            await sync.syncTasks(since);

            expect(mockClient.get).toHaveBeenCalledWith(
                expect.anything(),
                expect.objectContaining({
                    updated_since: since.toISOString()
                })
            );
        });
    });
});

// tests/integration/e2e.test.ts
import { describe, it, expect, beforeAll, afterAll } from '@jest/globals';
import { Pool } from 'pg';
import { exec } from 'child_process';
import { promisify } from 'util';

const execAsync = promisify(exec);

describe('TaskTracker Plugin E2E', () => {
    let db: Pool;

    beforeAll(async () => {
        // Setup test database
        db = new Pool({
            host: 'localhost',
            port: 5432,
            database: 'test_nself',
            user: 'postgres',
            password: 'test'
        });

        // Apply schema
        await execAsync('psql test_nself < schema/schema.sql');
    });

    afterAll(async () => {
        // Cleanup
        await db.end();
    });

    it('should install plugin', async () => {
        const { stdout } = await execAsync('nself plugin install .');
        expect(stdout).toContain('installed successfully');
    });

    it('should apply schema', async () => {
        await execAsync('nself tasktracker schema apply');

        const result = await db.query(`
            SELECT table_name
            FROM information_schema.tables
            WHERE table_schema = 'tasktracker'
        `);

        expect(result.rows.length).toBeGreaterThan(0);
    });

    it('should sync data', async () => {
        const { stdout } = await execAsync('nself tasktracker sync');
        expect(stdout).toContain('Synced');

        const result = await db.query('SELECT COUNT(*) FROM tasktracker.tasks');
        expect(parseInt(result.rows[0].count)).toBeGreaterThan(0);
    });

    it('should check data integrity', async () => {
        const { stdout } = await execAsync('nself tasktracker check');
        expect(stdout).toContain('✓');
    });
});

import nock from 'nock';

describe('API Client', () => {
    beforeEach(() => {
        nock.cleanAll();
    });

    it('should fetch tasks from API', async () => {
        // Mock API response
        nock('https://api.tasktracker.com')
            .get('/v1/tasks')
            .query({ workspace_id: 'test' })
            .reply(200, {
                tasks: [
                    { id: 'task_1', title: 'Test Task' }
                ]
            });

        const client = new APIClient({
            apiKey: 'test',
            apiUrl: 'https://api.tasktracker.com/v1'
        });

        const response = await client.get('/tasks', {
            workspace_id: 'test'
        });

        expect(response.tasks).toHaveLength(1);
    });

    it('should handle rate limiting', async () => {
        // Mock rate limit error
        nock('https://api.tasktracker.com')
            .get('/v1/tasks')
            .reply(429, { error: 'Rate limit exceeded' });

        // Then success
        nock('https://api.tasktracker.com')
            .get('/v1/tasks')
            .reply(200, { tasks: [] });

        const client = new APIClient({
            apiKey: 'test',
            apiUrl: 'https://api.tasktracker.com/v1'
        });

        const response = await client.get('/tasks');

        expect(response.tasks).toBeDefined();
    });
});

// Example: Deprecate old config, support new
const apiKey = process.env.TASKTRACKER_API_KEY ||
               process.env.TASKTRACKER_TOKEN; // Old name

if (process.env.TASKTRACKER_TOKEN) {
    console.warn('TASKTRACKER_TOKEN is deprecated, use TASKTRACKER_API_KEY');
}

// Example: Enforce database restrictions
class SecureDBClient {
    private allowedSchemas: string[];

    constructor(allowedSchemas: string[]) {
        this.allowedSchemas = allowedSchemas;
    }

    async query(sql: string): Promise<any> {
        // Parse and validate query
        if (!this.isQueryAllowed(sql)) {
            throw new Error('Query accesses restricted schema');
        }

        return this.db.query(sql);
    }

    isQueryAllowed(sql: string): boolean {
        // Check if query only accesses allowed schemas
        const schemas = this.extractSchemas(sql);

        return schemas.every(schema =>
            this.allowedSchemas.includes(schema)
        );
    }
}

// ❌ Bad: Individual inserts
for (const item of items) {
    await db.query('INSERT INTO ...', [item]);
}

// ✅ Good: Batch insert
const values = items.map(item => [item.id, item.name]);
await db.query('INSERT INTO ... VALUES ?', [values]);

// ✅ Good: Use connection pool
const pool = new Pool({ max: 10 });

const limiter = new RateLimiter(100, 60000); // 100/min

for await (const page of paginate('/items')) {
    await processBatch(page);
}

class PluginError extends Error {
    constructor(
        message: string,
        public code: string,
        public details?: any
    ) {
        super(message);
        this.name = 'PluginError';
    }
}

// Usage
throw new PluginError(
    'Failed to sync tasks',
    'SYNC_FAILED',
    { resource: 'tasks', count: 0 }
);

import winston from 'winston';

const logger = winston.createLogger({
    level: process.env.LOG_LEVEL || 'info',
    format: winston.format.combine(
        winston.format.timestamp(),
        winston.format.json()
    ),
    transports: [
        new winston.transports.File({
            filename: 'logs/plugin.log'
        }),
        new winston.transports.Console({
            format: winston.format.simple()
        })
    ]
});

// Usage
logger.info('Sync started', { resource: 'tasks' });
logger.error('Sync failed', { error: error.message });