fix: resolve CastError by making ApiKey model NeDB-compatible

backend/db.js

@@ -9,12 +9,14 @@ const db = {
   users: new Datastore({ filename: path.join(dbDir, 'users.db'), autoload: true }),
   sessions: new Datastore({ filename: path.join(dbDir, 'sessions.db'), autoload: true }),
   messages: new Datastore({ filename: path.join(dbDir, 'messages.db'), autoload: true }),
-  announcements: new Datastore({ filename: path.join(dbDir, 'announcements.db'), autoload: true })
+  announcements: new Datastore({ filename: path.join(dbDir, 'announcements.db'), autoload: true }),
+  apikeys: new Datastore({ filename: path.join(dbDir, 'apikeys.db'), autoload: true })
 };
 
 // Ensure indices
 db.users.ensureIndex({ fieldName: 'email', unique: true });
 db.users.ensureIndex({ fieldName: 'githubId', unique: true, sparse: true });
+db.apikeys.ensureIndex({ fieldName: 'key', unique: true });
 
 const connectDB = async () => {
   console.log('Neural Archive: Local NeDB Interface ACTIVE ✅');

backend/models/ApiKey.js

@@ -1,39 +1,77 @@
-const mongoose = require('mongoose');
+const { db } = require('../db');
 const crypto = require('crypto');
 
-const apiKeySchema = new mongoose.Schema({
-  key: {
-    type: String,
-    required: true,
-    unique: true,
-    index: true
-  },
-  userId: {
-    type: mongoose.Schema.Types.ObjectId,
-    ref: 'User',
-    required: true
-  },
-  name: {
-    type: String,
-    default: 'Default Key'
-  },
-  isActive: {
-    type: Boolean,
-    default: true
-  },
-  lastUsed: {
-    type: Date
-  },
-  createdAt: {
-    type: Date,
-    default: Date.now
-  }
-});
-
-// Function to generate a new key
-apiKeySchema.statics.generateKey = function() {
-  const token = crypto.randomBytes(24).toString('hex');
-  return `sk-cdx-${token}`;
-};
-
-module.exports = mongoose.model('ApiKey', apiKeySchema);
+class ApiKey {
+  constructor(keyData) {
+    Object.assign(this, keyData);
+    this.id = keyData._id;
+  }
+
+  static async find(query) {
+    return new Promise((resolve, reject) => {
+      db.apikeys.find(query, (err, docs) => {
+        if (err) reject(err);
+        else resolve(docs.map(doc => new ApiKey(doc)));
+      });
+    });
+  }
+
+  static async findOne(query) {
+    return new Promise((resolve, reject) => {
+      db.apikeys.findOne(query, (err, doc) => {
+        if (err) reject(err);
+        else resolve(doc ? new ApiKey(doc) : null);
+      });
+    });
+  }
+
+  static async findById(id) {
+    return new Promise((resolve, reject) => {
+      db.apikeys.findOne({ _id: id }, (err, doc) => {
+        if (err) reject(err);
+        else resolve(doc ? new ApiKey(doc) : null);
+      });
+    });
+  }
+
+  static async create(keyData) {
+    keyData.isActive = keyData.isActive !== undefined ? keyData.isActive : true;
+    keyData.createdAt = keyData.createdAt || new Date();
+    keyData.lastUsed = keyData.lastUsed || null;
+
+    return new Promise((resolve, reject) => {
+      db.apikeys.insert(keyData, (err, newDoc) => {
+        if (err) reject(err);
+        else resolve(new ApiKey(newDoc));
+      });
+    });
+  }
+
+  static generateKey() {
+    const token = crypto.randomBytes(24).toString('hex');
+    return `sk-cdx-${token}`;
+  }
+
+  async save() {
+    return new Promise((resolve, reject) => {
+      const data = { ...this };
+      const id = data._id;
+      delete data._id;
+      db.apikeys.update({ _id: id }, { $set: data }, (err) => {
+        if (err) reject(err);
+        else resolve(this);
+      });
+    });
+  }
+
+  async deleteOne() {
+    return new Promise((resolve, reject) => {
+      db.apikeys.remove({ _id: this._id }, {}, (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  }
+}
+
+module.exports = ApiKey;