apikeyscreator 1.0.0

package/src/routes/apiKeys.js

@@ -0,0 +1,143 @@
+import express from 'express';
+import { db } from '../utils/db.js';
+
+export const apiKeysRoutes = express.Router();
+
+// List all API keys for user
+apiKeysRoutes.get('/', (req, res) => {
+  const keys = db.keys.findByUserId(req.user.userId);
+
+  return res.json({
+    message: 'API keys retrieved successfully',
+    count: keys.length,
+    keys: keys.map(k => ({
+      id: k.id,
+      name: k.name,
+      key: k.key.substring(0, 10) + '...' + k.key.substring(k.key.length - 4),
+      fullKey: k.key,
+      active: k.active,
+      createdAt: k.createdAt,
+      lastUsed: k.lastUsed,
+    })),
+  });
+});
+
+// Get single API key
+apiKeysRoutes.get('/:id', (req, res) => {
+  const keyId = req.params.id;
+
+  const key = db.keys.findById(req.user.userId, keyId);
+  if (!key) {
+    return res.status(404).json({ error: 'API key not found' });
+  }
+
+  return res.json({
+    message: 'API key retrieved successfully',
+    key: {
+      id: key.id,
+      name: key.name,
+      key: key.key.substring(0, 10) + '...' + key.key.substring(key.key.length - 4),
+      fullKey: key.key,
+      active: key.active,
+      createdAt: key.createdAt,
+      lastUsed: key.lastUsed,
+    },
+  });
+});
+
+// Create new API key
+apiKeysRoutes.post('/', async (req, res) => {
+  try {
+    const { name } = req.body;
+
+    if (!name) {
+      return res.status(400).json({
+        error: 'Key name is required'
+      });
+    }
+
+    const newKey = db.keys.create(req.user.userId, name);
+
+    return res.status(201).json({
+      message: 'API key created successfully',
+      key: {
+        id: newKey.id,
+        name: newKey.name,
+        key: newKey.key,
+        active: newKey.active,
+        createdAt: newKey.createdAt,
+      },
+    });
+  } catch (error) {
+    return res.status(500).json({
+      error: error.message
+    });
+  }
+});
+
+// Update API key (name, status)
+apiKeysRoutes.put('/:id', async (req, res) => {
+  try {
+    const keyId = req.params.id;
+    const { name, active } = req.body;
+
+    const key = db.keys.findById(req.user.userId, keyId);
+    if (!key) {
+      return res.status(404).json({ error: 'API key not found' });
+    }
+
+    const updates = {};
+    if (name !== undefined) updates.name = name;
+    if (active !== undefined) updates.active = active;
+
+    const updatedKey = db.keys.update(req.user.userId, keyId, updates);
+
+    return res.json({
+      message: 'API key updated successfully',
+      key: {
+        id: updatedKey.id,
+        name: updatedKey.name,
+        key: updatedKey.key.substring(0, 10) + '...' + updatedKey.key.substring(updatedKey.key.length - 4),
+        active: updatedKey.active,
+        createdAt: updatedKey.createdAt,
+        lastUsed: updatedKey.lastUsed,
+      },
+    });
+  } catch (error) {
+    return res.status(500).json({
+      error: error.message
+    });
+  }
+});
+
+// Delete API key
+apiKeysRoutes.delete('/:id', (req, res) => {
+  const keyId = req.params.id;
+
+  const key = db.keys.findById(req.user.userId, keyId);
+  if (!key) {
+    return res.status(404).json({ error: 'API key not found' });
+  }
+
+  db.keys.delete(req.user.userId, keyId);
+
+  return res.json({
+    message: 'API key deleted successfully',
+  });
+});
+
+// Record key usage
+apiKeysRoutes.post('/:id/usage', (req, res) => {
+  const keyId = req.params.id;
+
+  const key = db.keys.findById(req.user.userId, keyId);
+  if (!key) {
+    return res.status(404).json({ error: 'API key not found' });
+  }
+
+  db.keys.recordUsage(req.user.userId, keyId);
+
+  return res.json({
+    message: 'API key usage recorded',
+  });
+});

package/src/routes/auth.js

@@ -0,0 +1,96 @@
+import express from 'express';
+import bcrypt from 'bcryptjs';
+import { db } from '../utils/db.js';
+import { generateToken } from '../utils/jwt.js';
+
+export const authRoutes = express.Router();
+
+// Register
+authRoutes.post('/register', async (req, res) => {
+  try {
+    const { email, password } = req.body;
+
+    if (!email || !password) {
+      return res.status(400).json({
+        error: 'Email and password are required'
+      });
+    }
+
+    const existingUser = db.users.findByEmail(email);
+    if (existingUser) {
+      return res.status(409).json({
+        error: 'User already exists'
+      });
+    }
+
+    const hashedPassword = await bcrypt.hash(password, 10);
+    const user = db.users.create(email, hashedPassword);
+
+    const token = generateToken(user.id, user.email);
+
+    return res.status(201).json({
+      message: 'User registered successfully',
+      user: { id: user.id, email: user.email },
+      token,
+    });
+  } catch (error) {
+    return res.status(500).json({
+      error: error.message
+    });
+  }
+});
+
+// Login
+authRoutes.post('/login', async (req, res) => {
+  try {
+    const { email, password } = req.body;
+
+    if (!email || !password) {
+      return res.status(400).json({
+        error: 'Email and password are required'
+      });
+    }
+
+    const user = db.users.findByEmail(email);
+    if (!user) {
+      return res.status(401).json({
+        error: 'Invalid email or password'
+      });
+    }
+
+    const isPasswordValid = await bcrypt.compare(password, user.password);
+    if (!isPasswordValid) {
+      return res.status(401).json({
+        error: 'Invalid email or password'
+      });
+    }
+
+    const token = generateToken(user.id, user.email);
+
+    return res.json({
+      message: 'Login successful',
+      user: { id: user.id, email: user.email },
+      token,
+    });
+  } catch (error) {
+    return res.status(500).json({
+      error: error.message
+    });
+  }
+});
+
+// Get current user
+authRoutes.get('/me', (req, res) => {
+  const token = req.headers['authorization']?.split(' ')[1];
+  
+  if (!token) {
+    return res.status(401).json({ error: 'Missing authorization token' });
+  }
+
+  const user = db.users.findByEmail(req.query.email);
+  
+  return res.json({
+    message: 'User retrieved successfully',
+    user: user ? { id: user.id, email: user.email } : null,
+  });
+});

package/src/server.js

@@ -0,0 +1,41 @@
+import express from 'express';
+import cors from 'cors';
+import { authMiddleware } from './middleware/auth.js';
+import { apiKeysRoutes } from './routes/apiKeys.js';
+import { authRoutes } from './routes/auth.js';
+
+const app = express();
+
+app.use(express.json());
+app.use(cors());
+
+// Health check
+app.get('/', (req, res) => {
+  res.json({ message: 'API Keys Creator System running' });
+});
+
+// Public auth routes
+app.use('/auth', authRoutes);
+
+// Protected API routes
+app.use('/api/keys', authMiddleware, apiKeysRoutes);
+
+// Error handling
+app.use((err, req, res, next) => {
+  console.error('Error:', err);
+  res.status(err.status || 500).json({
+    error: err.message || 'Internal Server Error',
+    code: err.code || 'INTERNAL_ERROR'
+  });
+});
+
+// 404 handler
+app.use((req, res) => {
+  res.status(404).json({ error: 'Not Found' });
+});
+
+const PORT = process.env.PORT || 3000;
+
+app.listen(PORT, () => {
+  console.log(`✓ API Keys Creator System running on http://localhost:${PORT}`);
+});

package/src/utils/db.js

@@ -0,0 +1,137 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const USERS_DB = path.join(__dirname, '../data/users.json');
+const KEYS_DB = path.join(__dirname, '../data/keys.json');
+
+const ensureDir = () => {
+  const dir = path.dirname(USERS_DB);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+};
+
+const ensureFile = (filepath, defaultContent = {}) => {
+  ensureDir();
+  if (!fs.existsSync(filepath)) {
+    fs.writeFileSync(filepath, JSON.stringify(defaultContent, null, 2));
+  }
+};
+
+export const db = {
+  users: {
+    readAll: () => {
+      ensureFile(USERS_DB, {});
+      const data = fs.readFileSync(USERS_DB, 'utf-8');
+      return JSON.parse(data);
+    },
+    
+    write: (users) => {
+      ensureFile(USERS_DB, {});
+      fs.writeFileSync(USERS_DB, JSON.stringify(users, null, 2));
+    },
+    
+    findByEmail: (email) => {
+      const users = db.users.readAll();
+      return users[email];
+    },
+    
+    create: (email, hashedPassword) => {
+      const users = db.users.readAll();
+      const userId = Date.now().toString();
+      users[email] = {
+        id: userId,
+        email,
+        password: hashedPassword,
+        createdAt: new Date().toISOString(),
+      };
+      db.users.write(users);
+      return users[email];
+    },
+  },
+  
+  keys: {
+    readAll: () => {
+      ensureFile(KEYS_DB, {});
+      const data = fs.readFileSync(KEYS_DB, 'utf-8');
+      return JSON.parse(data);
+    },
+    
+    write: (keys) => {
+      ensureFile(KEYS_DB, {});
+      fs.writeFileSync(KEYS_DB, JSON.stringify(keys, null, 2));
+    },
+    
+    create: (userId, keyName) => {
+      const keys = db.keys.readAll();
+      const keyId = Date.now().toString();
+      
+      if (!keys[userId]) {
+        keys[userId] = [];
+      }
+      
+      const newKey = {
+        id: keyId,
+        name: keyName,
+        key: `sk_${Math.random().toString(36).substr(2, 32)}`,
+        createdAt: new Date().toISOString(),
+        lastUsed: null,
+        active: true,
+      };
+      
+      keys[userId].push(newKey);
+      db.keys.write(keys);
+      
+      return newKey;
+    },
+    
+    findByUserId: (userId) => {
+      const keys = db.keys.readAll();
+      return keys[userId] || [];
+    },
+    
+    findById: (userId, keyId) => {
+      const userKeys = db.keys.findByUserId(userId);
+      return userKeys.find(k => k.id === keyId);
+    },
+    
+    update: (userId, keyId, updates) => {
+      const keys = db.keys.readAll();
+      if (!keys[userId]) return null;
+      
+      const keyIndex = keys[userId].findIndex(k => k.id === keyId);
+      if (keyIndex === -1) return null;
+      
+      keys[userId][keyIndex] = {
+        ...keys[userId][keyIndex],
+        ...updates,
+      };
+      
+      db.keys.write(keys);
+      return keys[userId][keyIndex];
+    },
+    
+    delete: (userId, keyId) => {
+      const keys = db.keys.readAll();
+      if (!keys[userId]) return false;
+      
+      const initialLength = keys[userId].length;
+      keys[userId] = keys[userId].filter(k => k.id !== keyId);
+      
+      if (keys[userId].length < initialLength) {
+        db.keys.write(keys);
+        return true;
+      }
+      
+      return false;
+    },
+    
+    recordUsage: (userId, keyId) => {
+      return db.keys.update(userId, keyId, {
+        lastUsed: new Date().toISOString(),
+      });
+    },
+  },
+};

package/src/utils/jwt.js

@@ -0,0 +1,24 @@
+import jwt from 'jsonwebtoken';
+
+const JWT_SECRET = process.env.JWT_SECRET || 'your-secret-key-change-in-production';
+const TOKEN_EXPIRY = '24h';
+
+export const generateToken = (userId, email) => {
+  return jwt.sign(
+    { userId, email },
+    JWT_SECRET,
+    { expiresIn: TOKEN_EXPIRY }
+  );
+};
+
+export const verifyToken = (token) => {
+  try {
+    return jwt.verify(token, JWT_SECRET);
+  } catch (error) {
+    return null;
+  }
+};
+
+export const generateApiKey = () => {
+  return `sk_${Math.random().toString(36).substr(2, 48)}`;
+};

package/test.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+
+const BASE_URL = 'http://localhost:3000';
+
+async function test() {
+  try {
+    console.log('🧪 Testing API Keys Creator System\n');
+
+    // Test 1: Health check
+    console.log('1. Testing health check...');
+    let res = await fetch(`${BASE_URL}/`);
+    let data = await res.json();
+    console.log(`   ✓ ${data.message}\n`);
+
+    // Test 2: Register
+    console.log('2. Testing registration...');
+    res = await fetch(`${BASE_URL}/auth/register`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        email: 'test@example.com',
+        password: 'testpass123'
+      })
+    });
+    data = await res.json();
+    if (!res.ok) {
+      console.log(`   ✓ Registration (second attempt) - ${data.error}\n`);
+    } else {
+      console.log(`   ✓ User registered: ${data.user.email}`);
+      console.log(`   ✓ Token: ${data.token.substring(0, 30)}...\n`);
+    }
+
+    // Test 3: Login
+    console.log('3. Testing login...');
+    res = await fetch(`${BASE_URL}/auth/login`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        email: 'test@example.com',
+        password: 'testpass123'
+      })
+    });
+    data = await res.json();
+    const token = data.token;
+    console.log(`   ✓ Login successful`);
+    console.log(`   ✓ Token: ${token.substring(0, 30)}...\n`);
+
+    // Test 4: Create API Key
+    console.log('4. Testing API key creation...');
+    res = await fetch(`${BASE_URL}/api/keys`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${token}`
+      },
+      body: JSON.stringify({ name: 'Test Key' })
+    });
+    data = await res.json();
+    const keyId = data.key.id;
+    console.log(`   ✓ API Key created: ${data.key.name}`);
+    console.log(`   ✓ Key: ${data.key.key}\n`);
+
+    // Test 5: List API Keys
+    console.log('5. Testing list API keys...');
+    res = await fetch(`${BASE_URL}/api/keys`, {
+      headers: { 'Authorization': `Bearer ${token}` }
+    });
+    data = await res.json();
+    console.log(`   ✓ Found ${data.count} key(s)\n`);
+
+    // Test 6: Get single key
+    console.log('6. Testing get single key...');
+    res = await fetch(`${BASE_URL}/api/keys/${keyId}`, {
+      headers: { 'Authorization': `Bearer ${token}` }
+    });
+    data = await res.json();
+    console.log(`   ✓ Retrieved: ${data.key.name}\n`);
+
+    // Test 7: Update key
+    console.log('7. Testing update key...');
+    res = await fetch(`${BASE_URL}/api/keys/${keyId}`, {
+      method: 'PUT',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${token}`
+      },
+      body: JSON.stringify({ name: 'Updated Test Key', active: false })
+    });
+    data = await res.json();
+    console.log(`   ✓ Updated: ${data.key.name} (active: ${data.key.active})\n`);
+
+    // Test 8: Record usage
+    console.log('8. Testing record usage...');
+    res = await fetch(`${BASE_URL}/api/keys/${keyId}/usage`, {
+      method: 'POST',
+      headers: { 'Authorization': `Bearer ${token}` }
+    });
+    data = await res.json();
+    console.log(`   ✓ ${data.message}\n`);
+
+    // Test 9: Delete key
+    console.log('9. Testing delete key...');
+    res = await fetch(`${BASE_URL}/api/keys/${keyId}`, {
+      method: 'DELETE',
+      headers: { 'Authorization': `Bearer ${token}` }
+    });
+    data = await res.json();
+    console.log(`   ✓ ${data.message}\n`);
+
+    console.log('✅ All tests passed!');
+    process.exit(0);
+  } catch (error) {
+    console.error('❌ Test failed:', error.message);
+    process.exit(1);
+  }
+}
+
+test();