nocalendar 0.2.0

package/README.md

@@ -0,0 +1,65 @@
+# Nocal
+
+A lightweight nodejs calendar library. 
+
+## Features
+
+- Create, read, update, and delete calendar events
+- SQLite database persistence
+- ICS (iCalendar) export and import
+- RESTful API server
+- Basic and Bearer authentication support
+
+## Installation
+
+```bash
+npm install nocal2
+```
+
+## Usage
+
+```javascript
+const nocal = require('nocal2');
+
+const cal = nocal.load('./calendar.db');
+
+// Create an event
+const eventId = await cal.createEvent({
+  title: 'My Event',
+  description: 'Description',
+  startDate: '2023-10-01T10:00:00Z',
+  endDate: '2023-10-01T11:00:00Z',
+  rrule: 'FREQ=WEEKLY;BYDAY=MO'
+});
+
+// List events
+const events = await cal.listEvents();
+
+// Start API server
+const server = await cal.start(3000);
+```
+
+## API
+
+### Methods
+
+- `load(dbPath)`: Load or create a calendar database
+- `createEvent(eventData)`: Create a new event
+- `listEvents()`: Get all events
+- `updateEvent(id, updates)`: Update an event
+- `removeEvent(id)`: Delete an event
+- `exportIcs()`: Export events as ICS
+- `importIcs(icsContent)`: Import events from ICS
+- `start(port, callback)`: Start REST API server
+
+## API Endpoints
+
+- `GET /events`: List all events
+- `POST /events`: Create a new event
+- `PUT /events/:id`: Update an event
+- `DELETE /events/:id`: Delete an event
+- `GET /export`: Export as ICS
+
+## License
+
+MIT

package/index.js

@@ -0,0 +1,282 @@
+const Database = require('./src/database');
+const { v4: uuidv4, validate: uuidValidate } = require('uuid');
+const ICAL = require('ical.js');
+const bcrypt = require('bcrypt');
+
+class Nocal {
+  constructor(dbPath) {
+    this.db = new Database(dbPath);
+  }
+
+  static load(dbPath) {
+    return new Nocal(dbPath);
+  }
+
+  async createEvent(eventData) {
+    const event = {
+      id: uuidv4(),
+      title: eventData.title,
+      description: eventData.description || '',
+      startDate: eventData.startDate,
+      endDate: eventData.endDate,
+      rrule: eventData.rrule || null
+    };
+    await this.db.createEvent(event);
+    return event.id;
+  }
+
+  async listEvents() {
+    const events = await this.db.getEvents();
+    // For now, return raw events. Later expand recurring.
+    return events;
+  }
+
+  async removeEvent(eventId) {
+    const result = await this.db.deleteEvent(eventId);
+    return result.changes > 0;
+  }
+
+  async updateEvent(eventId, updates) {
+    const result = await this.db.updateEvent(eventId, updates);
+    return result.changes > 0;
+  }
+
+  async exportIcs() {
+    const events = await this.listEvents();
+    const cal = new ICAL.Component(['vcalendar', [], []]);
+    cal.updatePropertyWithValue('version', '2.0');
+    cal.updatePropertyWithValue('prodid', '-//Nocal//Calendar//EN');
+
+    events.forEach(event => {
+      const vevent = new ICAL.Component('vevent');
+      vevent.updatePropertyWithValue('uid', event.id);
+      vevent.updatePropertyWithValue('summary', event.title);
+      if (event.description) vevent.updatePropertyWithValue('description', event.description);
+      vevent.updatePropertyWithValue('dtstart', ICAL.Time.fromDateTimeString(event.start_date));
+      vevent.updatePropertyWithValue('dtend', ICAL.Time.fromDateTimeString(event.end_date));
+      if (event.rrule) {
+        // Parse RRULE
+        const rrule = ICAL.Recur.fromString(event.rrule);
+        vevent.updatePropertyWithValue('rrule', rrule);
+      }
+      cal.addSubcomponent(vevent);
+    });
+
+    return cal.toString();
+  }
+
+  async importIcs(content) {
+    const jcal = ICAL.parse(content);
+    const cal = new ICAL.Component(jcal);
+    const vevents = cal.getAllSubcomponents('vevent');
+
+    for (const vevent of vevents) {
+      const uid = vevent.getFirstPropertyValue('uid');
+      const summary = vevent.getFirstPropertyValue('summary');
+      const description = vevent.getFirstPropertyValue('description');
+      const dtstart = vevent.getFirstPropertyValue('dtstart');
+      const dtend = vevent.getFirstPropertyValue('dtend');
+      const rrule = vevent.getFirstPropertyValue('rrule');
+
+      const eventData = {
+        title: summary,
+        description: description || '',
+        startDate: dtstart.toString(),
+        endDate: dtend.toString(),
+        rrule: rrule ? rrule.toString() : null
+      };
+
+      await this.createEvent(eventData);
+    }
+  }
+
+  async start(port = 3000, hostOrCallback = 'localhost', optionsOrCallback = null) {
+    let host = 'localhost';
+    let options = {};
+    let callback = null;
+
+    if (typeof hostOrCallback === 'function') {
+      callback = hostOrCallback;
+    } else if (typeof hostOrCallback === 'string') {
+      host = hostOrCallback;
+    } else if (typeof hostOrCallback === 'object') {
+      options = hostOrCallback;
+    }
+
+    if (typeof optionsOrCallback === 'function') {
+      callback = optionsOrCallback;
+    } else if (typeof optionsOrCallback === 'object' && optionsOrCallback !== null) {
+      options = optionsOrCallback;
+    }
+
+    // Hash password for basic auth
+    if (options.auth && options.auth.type === 'basic') {
+      if (!options.auth.password.startsWith('$2')) {
+        options.auth.hashedPassword = await bcrypt.hash(options.auth.password, 10);
+      } else {
+        options.auth.hashedPassword = options.auth.password;
+      }
+    }
+
+    // Auth options: { auth: { type: 'basic', username: 'user', password: 'pass' } } or { type: 'bearer', token: 'token' }
+    const http = require('http');
+    const https = require('https');
+    const MAX_PAYLOAD_SIZE = 10 * 1024; // 10kb
+
+    const serverModule = options.ssl ? https : http;
+    const server = serverModule.createServer(options.ssl || {}, async (req, res) => {
+      // Auth check
+      if (options.auth) {
+        const authHeader = req.headers.authorization;
+        let authorized = false;
+
+        if (options.auth.type === 'basic') {
+          if (authHeader && authHeader.startsWith('Basic ')) {
+            const base64Credentials = authHeader.split(' ')[1];
+            const credentials = Buffer.from(base64Credentials, 'base64').toString('ascii');
+            const [username, password] = credentials.split(':');
+            if (username === options.auth.username && await bcrypt.compare(password, options.auth.hashedPassword)) {
+              authorized = true;
+            }
+          }
+        } else if (options.auth.type === 'bearer') {
+          if (authHeader && authHeader.startsWith('Bearer ') && authHeader.split(' ')[1] === options.auth.token) {
+            authorized = true;
+          }
+        }
+
+        if (!authorized) {
+          res.writeHead(401, { 'WWW-Authenticate': options.auth.type === 'basic' ? 'Basic realm="Nocal API"' : 'Bearer' });
+          res.end(JSON.stringify({ error: 'Unauthorized' }));
+          return;
+        }
+      }
+
+      const parsedUrl = new URL(req.url, 'http://dummy');
+      const method = req.method;
+      const path = parsedUrl.pathname;
+
+      res.setHeader('Content-Type', 'application/json');
+
+      // Validate event ID for routes that use it
+      let eventId = null;
+      if (path.startsWith('/events/')) {
+        const parts = path.split('/');
+        if (parts.length === 3 && parts[1] === 'events') {
+          eventId = parts[2];
+          if (!eventId || !uuidValidate(eventId)) {
+            res.writeHead(400);
+            res.end(JSON.stringify({ error: 'Invalid event ID' }));
+            return;
+          }
+        }
+      }
+
+      if (path === '/events' && method === 'GET') {
+        try {
+          const events = await this.listEvents();
+          res.writeHead(200);
+          res.end(JSON.stringify(events));
+        } catch (err) {
+          res.writeHead(500);
+          res.end(JSON.stringify({ error: 'Internal server error' }));
+        }
+      } else if (path === '/events' && method === 'POST') {
+        let body = '';
+        let bodySize = 0;
+        req.on('data', chunk => {
+          bodySize += chunk.length;
+          if (bodySize > MAX_PAYLOAD_SIZE) {
+            res.writeHead(413);
+            res.end(JSON.stringify({ error: 'Payload too large' }));
+            req.destroy();
+            return;
+          }
+          body += chunk;
+        });
+        req.on('end', async () => {
+          try {
+            const eventData = JSON.parse(body);
+            if (!eventData.title || !eventData.startDate || !eventData.endDate) {
+              res.writeHead(400);
+              res.end(JSON.stringify({ error: 'Missing required fields: title, startDate, endDate' }));
+              return;
+            }
+            const id = await this.createEvent(eventData);
+            res.writeHead(201);
+            res.end(JSON.stringify({ id }));
+          } catch (err) {
+            res.writeHead(400);
+            res.end(JSON.stringify({ error: 'Invalid JSON or data' }));
+          }
+        });
+      } else if (path.startsWith('/events/') && method === 'PUT') {
+        let body = '';
+        let bodySize = 0;
+        req.on('data', chunk => {
+          bodySize += chunk.length;
+          if (bodySize > MAX_PAYLOAD_SIZE) {
+            res.writeHead(413);
+            res.end(JSON.stringify({ error: 'Payload too large' }));
+            req.destroy();
+            return;
+          }
+          body += chunk;
+        });
+        req.on('end', async () => {
+          try {
+            const updates = JSON.parse(body);
+            delete updates.id; // Prevent updating id
+            const success = await this.updateEvent(eventId, updates);
+            if (success) {
+              res.writeHead(200);
+              res.end(JSON.stringify({ message: 'Updated' }));
+            } else {
+              res.writeHead(404);
+              res.end(JSON.stringify({ error: 'Event not found' }));
+            }
+          } catch (err) {
+            res.writeHead(400);
+            res.end(JSON.stringify({ error: 'Invalid JSON or data' }));
+          }
+        });
+      } else if (path.startsWith('/events/') && method === 'DELETE') {
+        try {
+          const success = await this.removeEvent(eventId);
+          if (success) {
+            res.writeHead(200);
+            res.end(JSON.stringify({ message: 'Deleted' }));
+          } else {
+            res.writeHead(404);
+            res.end(JSON.stringify({ error: 'Event not found' }));
+          }
+        } catch (err) {
+          res.writeHead(500);
+          res.end(JSON.stringify({ error: 'Internal server error' }));
+        }
+      } else if (path === '/export' && method === 'GET') {
+        try {
+          const ics = await this.exportIcs();
+          res.setHeader('Content-Type', 'text/calendar');
+          res.writeHead(200);
+          res.end(ics);
+        } catch (err) {
+          res.writeHead(500);
+          res.end(JSON.stringify({ error: 'Internal server error' }));
+        }
+      } else {
+        res.writeHead(404);
+        res.end(JSON.stringify({ error: 'Not found' }));
+      }
+    });
+
+    server.listen(port, host, () => {
+      console.log(`Nocal API listening on http://${host}:${port}`);
+      if (callback) callback();
+    });
+
+    return server;
+  }
+}
+
+module.exports = { load: Nocal.load };

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "nocalendar",
+  "version": "0.2.0",
+  "description": "A lightweight nodejs calendar library. ",
+  "main": "index.js",
+  "scripts": {
+    "test": "node test.js"
+  },
+  "keywords": [
+    "calendar",
+    "ics",
+    "sqlite",
+    "nodejs",
+    "nocal",
+    "nocal2"
+  ],
+  "author": "little codex",
+  "license": "MIT",
+  "dependencies": {
+    "ical.js": "^1.5.0",
+    "uuid": "^9.0.1",
+    "bcrypt": "^5.1.1"
+  }
+}

package/src/database.js

@@ -0,0 +1,64 @@
+const { DatabaseSync } = require('node:sqlite');
+
+class Database {
+  constructor(dbPath) {
+    this.db = new DatabaseSync(dbPath);
+    this.init();
+  }
+
+  init() {
+    const sql = `
+      CREATE TABLE IF NOT EXISTS events (
+        id TEXT PRIMARY KEY,
+        title TEXT NOT NULL,
+        description TEXT,
+        start_date TEXT NOT NULL,
+        end_date TEXT NOT NULL,
+        rrule TEXT,
+        created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+        updated_at TEXT DEFAULT CURRENT_TIMESTAMP
+      );
+    `;
+    this.db.exec(sql);
+  }
+
+  // Methods for CRUD
+  createEvent(event) {
+    const sql = `
+      INSERT INTO events (id, title, description, start_date, end_date, rrule)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `;
+    const stmt = this.db.prepare(sql);
+    stmt.run(event.id, event.title, event.description, event.startDate, event.endDate, event.rrule);
+    return { id: event.id };
+  }
+
+  getEvents() {
+    const sql = 'SELECT * FROM events';
+    const stmt = this.db.prepare(sql);
+    return stmt.all();
+  }
+
+  updateEvent(id, updates) {
+    const fields = Object.keys(updates).map(key => `${key} = ?`).join(', ');
+    const values = Object.values(updates);
+    values.push(id);
+    const sql = `UPDATE events SET ${fields}, updated_at = CURRENT_TIMESTAMP WHERE id = ?`;
+    const stmt = this.db.prepare(sql);
+    const result = stmt.run(...values);
+    return { changes: result.changes };
+  }
+
+  deleteEvent(id) {
+    const sql = 'DELETE FROM events WHERE id = ?';
+    const stmt = this.db.prepare(sql);
+    const result = stmt.run(id);
+    return { changes: result.changes };
+  }
+
+  close() {
+    this.db.close();
+  }
+}
+
+module.exports = Database;

package/test.js

@@ -0,0 +1,138 @@
+const nocal = require('./index');
+
+async function test() {
+  const cal = nocal.load('./test.db');
+
+  console.log('Testing createEvent...');
+  const id = await cal.createEvent({
+    title: 'My Event',
+    description: 'My personal event',
+    startDate: '2023-10-01T10:00:00Z',
+    endDate: '2023-10-01T11:00:00Z',
+    rrule: 'FREQ=WEEKLY;BYDAY=MO'
+  });
+  console.log('Created event:', id);
+
+  console.log('Testing listEvents...');
+  let events = await cal.listEvents();
+  console.log('Events count:', events.length);
+
+  console.log('Testing updateEvent...');
+  const updated = await cal.updateEvent(id, { title: 'Updated Event', description: 'Updated description' });
+  console.log('Update result:', updated);
+
+  console.log('Testing listEvents after update...');
+  events = await cal.listEvents();
+  console.log('First event title:', events[0].title);
+
+  console.log('Testing exportIcs...');
+  const ics = await cal.exportIcs();
+  console.log('ICS exported, length:', ics.length);
+
+  console.log('Testing importIcs...');
+  // Create a simple ICS content for import
+  const icsImport = `BEGIN:VCALENDAR
+VERSION:2.0
+BEGIN:VEVENT
+UID:test-import-123
+SUMMARY:Imported Event
+DESCRIPTION:Test import
+DTSTART:20231002T120000Z
+DTEND:20231002T130000Z
+END:VEVENT
+END:VCALENDAR`;
+  await cal.importIcs(icsImport);
+  console.log('ICS imported');
+
+  console.log('Testing listEvents after import...');
+  events = await cal.listEvents();
+  console.log('Events count after import:', events.length);
+
+  console.log('Testing removeEvent...');
+  const removed = await cal.removeEvent(id);
+  console.log('Remove result:', removed);
+
+  console.log('Testing listEvents after remove...');
+  events = await cal.listEvents();
+  console.log('Events count after remove:', events.length);
+
+  console.log('Testing start API...');
+  const server = await cal.start(3000, () => {
+    console.log('API started for testing');
+  });
+
+  // Wait a bit for server to start
+  await new Promise(resolve => setTimeout(resolve, 100));
+
+  // Test API endpoints
+  const http = require('http');
+
+  // Helper function to make request
+  function makeRequest(options, data = null) {
+    return new Promise((resolve, reject) => {
+      const req = http.request(options, (res) => {
+        let body = '';
+        res.on('data', chunk => body += chunk);
+        res.on('end', () => {
+          try {
+            const json = JSON.parse(body);
+            resolve({ status: res.statusCode, data: json });
+          } catch (e) {
+            resolve({ status: res.statusCode, data: body });
+          }
+        });
+      });
+      req.on('error', reject);
+      if (data) {
+        req.write(JSON.stringify(data));
+      }
+      req.end();
+    });
+  }
+
+  // Test GET /events
+  console.log('Testing GET /events...');
+  let response = await makeRequest({ hostname: 'localhost', port: 3000, path: '/events', method: 'GET' });
+  console.log('GET /events status:', response.status, 'events:', response.data.length);
+
+  // Test POST /events
+  console.log('Testing POST /events...');
+  response = await makeRequest({
+    hostname: 'localhost', port: 3000, path: '/events', method: 'POST',
+    headers: { 'Content-Type': 'application/json' }
+  }, {
+    title: 'API Test Event',
+    description: 'Created via API',
+    startDate: '2023-10-03T14:00:00Z',
+    endDate: '2023-10-03T15:00:00Z'
+  });
+  console.log('POST /events status:', response.status, 'id:', response.data.id);
+  const apiEventId = response.data.id;
+
+  // Test PUT /events/:id
+  console.log('Testing PUT /events/:id...');
+  response = await makeRequest({
+    hostname: 'localhost', port: 3000, path: `/events/${apiEventId}`, method: 'PUT',
+    headers: { 'Content-Type': 'application/json' }
+  }, { title: 'Updated via API' });
+  console.log('PUT /events/:id status:', response.status);
+
+  // Test GET /export
+  console.log('Testing GET /export...');
+  response = await makeRequest({ hostname: 'localhost', port: 3000, path: '/export', method: 'GET' });
+  console.log('GET /export status:', response.status, 'ICS length:', response.data.length);
+
+  // Test DELETE /events/:id
+  console.log('Testing DELETE /events/:id...');
+  response = await makeRequest({ hostname: 'localhost', port: 3000, path: `/events/${apiEventId}`, method: 'DELETE' });
+  console.log('DELETE /events/:id status:', response.status);
+
+  // Close server
+  server.close(() => {
+    console.log('API server closed');
+  });
+
+  console.log('All tests completed successfully!');
+}
+
+test().catch(console.error);