npm - @vue-skuilder/express - Versions diffs - 0.1.1 - Mend

@vue-skuilder/express 0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (78) hide show

package/.env.development +9 -0
package/.prettierignore +4 -0
package/.prettierrc +8 -0
package/.vscode/launch.json +20 -0
package/assets/classroomDesignDoc.js +24 -0
package/assets/courseValidateDocUpdate.js +56 -0
package/assets/get-tagsDesignDoc.json +9 -0
package/babel.config.js +6 -0
package/dist/app.d.ts +6 -0
package/dist/app.d.ts.map +1 -0
package/dist/app.js +194 -0
package/dist/app.js.map +1 -0
package/dist/attachment-preprocessing/index.d.ts +11 -0
package/dist/attachment-preprocessing/index.d.ts.map +1 -0
package/dist/attachment-preprocessing/index.js +146 -0
package/dist/attachment-preprocessing/index.js.map +1 -0
package/dist/attachment-preprocessing/normalize.d.ts +7 -0
package/dist/attachment-preprocessing/normalize.d.ts.map +1 -0
package/dist/attachment-preprocessing/normalize.js +90 -0
package/dist/attachment-preprocessing/normalize.js.map +1 -0
package/dist/client-requests/classroom-requests.d.ts +26 -0
package/dist/client-requests/classroom-requests.d.ts.map +1 -0
package/dist/client-requests/classroom-requests.js +171 -0
package/dist/client-requests/classroom-requests.js.map +1 -0
package/dist/client-requests/course-requests.d.ts +10 -0
package/dist/client-requests/course-requests.d.ts.map +1 -0
package/dist/client-requests/course-requests.js +135 -0
package/dist/client-requests/course-requests.js.map +1 -0
package/dist/client.d.ts +31 -0
package/dist/client.d.ts.map +1 -0
package/dist/client.js +70 -0
package/dist/client.js.map +1 -0
package/dist/couchdb/authentication.d.ts +4 -0
package/dist/couchdb/authentication.d.ts.map +1 -0
package/dist/couchdb/authentication.js +64 -0
package/dist/couchdb/authentication.js.map +1 -0
package/dist/couchdb/index.d.ts +18 -0
package/dist/couchdb/index.d.ts.map +1 -0
package/dist/couchdb/index.js +52 -0
package/dist/couchdb/index.js.map +1 -0
package/dist/design-docs.d.ts +63 -0
package/dist/design-docs.d.ts.map +1 -0
package/dist/design-docs.js +90 -0
package/dist/design-docs.js.map +1 -0
package/dist/logger.d.ts +3 -0
package/dist/logger.d.ts.map +1 -0
package/dist/logger.js +62 -0
package/dist/logger.js.map +1 -0
package/dist/routes/logs.d.ts +3 -0
package/dist/routes/logs.d.ts.map +1 -0
package/dist/routes/logs.js +274 -0
package/dist/routes/logs.js.map +1 -0
package/dist/utils/env.d.ts +10 -0
package/dist/utils/env.d.ts.map +1 -0
package/dist/utils/env.js +38 -0
package/dist/utils/env.js.map +1 -0
package/dist/utils/processQueue.d.ts +39 -0
package/dist/utils/processQueue.d.ts.map +1 -0
package/dist/utils/processQueue.js +175 -0
package/dist/utils/processQueue.js.map +1 -0
package/eslint.config.js +19 -0
package/jest.config.ts +24 -0
package/package.json +74 -0
package/src/app.ts +246 -0
package/src/attachment-preprocessing/index.ts +204 -0
package/src/attachment-preprocessing/normalize.ts +123 -0
package/src/client-requests/classroom-requests.ts +234 -0
package/src/client-requests/course-requests.ts +188 -0
package/src/client.ts +97 -0
package/src/couchdb/authentication.ts +85 -0
package/src/couchdb/index.ts +76 -0
package/src/design-docs.ts +107 -0
package/src/logger.ts +75 -0
package/src/routes/logs.ts +289 -0
package/src/utils/env.ts +51 -0
package/src/utils/processQueue.ts +218 -0
package/test/client.test.ts +144 -0
package/tsconfig.json +27 -0

package/src/routes/logs.ts ADDED Viewed

@@ -0,0 +1,289 @@
+import express, { Request, Response } from 'express';
+import { promises as fs } from 'fs';
+import path from 'path';
+import rateLimit from 'express-rate-limit';
+import logger from '../logger.js';
+import process from 'process';
+const router = express.Router();
+// Rate limiting middleware for logs routes
+const logsRateLimit = rateLimit({
+  windowMs: 15 * 60 * 1000, // 15 minutes
+  max: 20, // Limit each IP to 20 requests per windowMs
+  message: {
+    error: 'Too many log requests from this IP, please try again later.'
+  },
+  standardHeaders: true, // Return rate limit info in the `RateLimit-*` headers
+  legacyHeaders: false, // Disable the `X-RateLimit-*` headers
+});
+// Apply rate limiting to all routes in this router
+router.use(logsRateLimit);
+// Get list of available log files
+router.get('/', (_req: Request, res: Response) => {
+  void (async () => {
+  // [ ] add an auth mechanism. Below fcn is based on
+  //     the CouchDB auth mechanism, forwarded from the web-app (not direct-access of server).
+  //
+  // const auth = await requestIsAdminAuthenticated(req);
+  // if (!auth) {
+  //   res.status(401).json({ error: 'Unauthorized' });
+  //   return;
+  // }
+  try {
+    const logsDir = path.join(process.cwd(), 'logs');
+    const files = await fs.readdir(logsDir);
+    // Create HTML content
+    const html = `
+          <!DOCTYPE html>
+          <html>
+            <head>
+              <title>Log Files</title>
+              <style>
+                body {
+                  font-family: Arial, sans-serif;
+                  margin: 20px;
+                }
+                h1 {
+                  color: #333;
+                }
+                .log-list {
+                  list-style: none;
+                  padding: 0;
+                }
+                .log-list li {
+                  margin: 10px 0;
+                }
+                .log-list a {
+                  color: #0066cc;
+                  text-decoration: none;
+                  padding: 5px;
+                }
+                .log-list a:hover {
+                  text-decoration: underline;
+                }
+              </style>
+            </head>
+            <body>
+              <h1>Available Log Files</h1>
+              <ul class="log-list">
+                ${files
+                  .map(
+                    (file) => `
+                  <li>
+                    <a href="/logs/${file}">${file}</a>
+                  </li>
+                `
+                  )
+                  .join('')}
+              </ul>
+            </body>
+          </html>
+        `;
+    res.type('html').send(html);
+  } catch (error) {
+    logger.error('Error reading logs directory:', error);
+    res.status(500).json({ error: 'Failed to retrieve log files' });
+  }
+  })();
+});
+router.get('/:filename', (req: Request, res: Response) => {
+  void (async () => {
+  try {
+    const filename = req.params.filename;
+    // Sanitize filename to prevent directory traversal
+    if (filename.includes('..') || !filename.match(/^[a-zA-Z0-9-_.]+$/)) {
+      res.status(400).send('<h1>Error</h1><p>Invalid filename</p>');
+      return;
+    }
+    const logPath = path.join(process.cwd(), 'logs', filename);
+    const content = (await fs.readFile(logPath, 'utf-8')).toString();
+    // Parse log lines
+    const lines = content
+      .split('\n')
+      .filter((line) => line.trim())
+      .map((line) => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return line;
+        }
+      });
+    const html = `
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <title>Log Viewer - ${filename}</title>
+          <style>
+            body {
+              font-family: Arial, sans-serif;
+              margin: 20px;
+              max-width: 1200px;
+              margin: 0 auto;
+              padding: 20px;
+            }
+            .header {
+              display: flex;
+              justify-content: space-between;
+              align-items: center;
+              margin-bottom: 20px;
+            }
+            .nav-links {
+              margin-bottom: 20px;
+            }
+            .nav-links a {
+              color: #0066cc;
+              text-decoration: none;
+              margin-right: 15px;
+            }
+            .nav-links a:hover {
+              text-decoration: underline;
+            }
+            .filters {
+              margin-bottom: 20px;
+              padding: 10px;
+              background-color: #f5f5f5;
+              border-radius: 4px;
+            }
+            .filters input, .filters select {
+              margin: 5px;
+              padding: 5px;
+            }
+            .log-entry {
+              padding: 8px;
+              border-bottom: 1px solid #eee;
+              font-family: monospace;
+              white-space: pre-wrap;
+            }
+            .log-entry:nth-child(odd) {
+              background-color: #f9f9f9;
+            }
+            .error { color: #d32f2f; }
+            .warn { color: #ff9800; }
+            .info { color: #2196f3; }
+            .debug { color: #4caf50; }
+          </style>
+          <script>
+            function filterLogs() {
+              const search = document.getElementById('search').value.toLowerCase();
+              const level = document.getElementById('level').value;
+              const entries = document.getElementsByClassName('log-entry');
+              Array.from(entries).forEach(entry => {
+                const text = entry.textContent.toLowerCase();
+                const matchesSearch = !search || text.includes(search);
+                const matchesLevel = !level || text.includes('"level":"' + level + '"');
+                entry.style.display = (matchesSearch && matchesLevel) ? 'block' : 'none';
+              });
+            }
+          </script>
+        </head>
+        <body>
+          <div class="header">
+            <h1>Log Viewer - ${filename}</h1>
+            <div class="nav-links">
+              <a href="/logs">← Back to Log List</a>
+              <a href="/logs/${filename}/raw">View Raw Log →</a>
+            </div>
+          </div>
+          <div class="filters">
+            <input
+              type="text"
+              id="search"
+              placeholder="Search logs..."
+              oninput="filterLogs()"
+            >
+            <select id="level" onchange="filterLogs()">
+              <option value="">All Levels</option>
+              <option value="error">Error</option>
+              <option value="warn">Warn</option>
+              <option value="info">Info</option>
+              <option value="debug">Debug</option>
+            </select>
+          </div>
+          <div class="log-content">
+            ${lines
+              .map((line) => {
+                let levelClass = '';
+                if (typeof line === 'object' && line.level) {
+                  levelClass = line.level.toLowerCase();
+                }
+                return `<div class="log-entry ${levelClass}">
+                ${
+                  typeof line === 'object'
+                    ? JSON.stringify(line, null, 2)
+                    : line
+                }
+              </div>`;
+              })
+              .join('')}
+          </div>
+        </body>
+      </html>
+    `;
+    res.type('html').send(html);
+  } catch (error) {
+    logger.error(`Error reading log file ${req.params.filename}:`, error);
+    res.status(500).send('<h1>Error</h1><p>Failed to retrieve log file</p>');
+  }
+  })();
+});
+// Get contents of specific log file
+router.get('/:filename/raw', (req: Request, res: Response) => {
+  void (async () => {
+  // const auth = await requestIsAdminAuthenticated(req);
+  // if (!auth) {
+  //   res.status(401).json({ error: 'Unauthorized' });
+  //   return;
+  // }
+  try {
+    const filename = req.params.filename;
+    // Sanitize filename to prevent directory traversal
+    if (filename.includes('..') || !filename.match(/^[a-zA-Z0-9-_.]+$/)) {
+      res.status(400).json({ error: 'Invalid filename' });
+      return;
+    }
+    const logPath = path.join(process.cwd(), 'logs', filename);
+    const content = (await fs.readFile(logPath, 'utf-8')).toString();
+    // If the client requests JSON format
+    if (req.headers.accept === 'application/json') {
+      const lines = content
+        .split('\n')
+        .filter((line) => line.trim())
+        .map((line) => {
+          try {
+            return JSON.parse(line);
+          } catch {
+            return line;
+          }
+        });
+      res.json(lines);
+    } else {
+      // Return plain text by default
+      res.type('text/plain').send(content);
+    }
+  } catch (error) {
+    logger.error(`Error reading log file ${req.params.filename}:`, error);
+    res.status(500).json({ error: 'Failed to retrieve log file' });
+  }
+  })();
+});
+export default router;

package/src/utils/env.ts ADDED Viewed

@@ -0,0 +1,51 @@
+import dotenv from 'dotenv';
+import process from 'process';
+import { initializeDataLayer } from '@vue-skuilder/db';
+import logger from '../logger.js';
+dotenv.config({
+  path:
+    process.argv && process.argv.length == 3
+      ? process.argv[2]
+      : '.env.development',
+});
+type Env = {
+  COUCHDB_SERVER: string;
+  COUCHDB_PROTOCOL: string;
+  COUCHDB_ADMIN: string;
+  COUCHDB_PASSWORD: string;
+  VERSION: string;
+};
+function getVar(name: string): string {
+  if (process.env[name]) {
+    return process.env[name];
+  } else {
+    throw new Error(`${name} not defined in environment`);
+  }
+}
+const env: Env = {
+  COUCHDB_SERVER: getVar('COUCHDB_SERVER'),
+  COUCHDB_PROTOCOL: getVar('COUCHDB_PROTOCOL'),
+  COUCHDB_ADMIN: getVar('COUCHDB_ADMIN'),
+  COUCHDB_PASSWORD: getVar('COUCHDB_PASSWORD'),
+  VERSION: getVar('VERSION'),
+};
+initializeDataLayer({
+  type: 'pouch',
+  options: {
+    COUCHDB_PASSWORD: env.COUCHDB_PASSWORD,
+    COUCHDB_USERNAME: env.COUCHDB_ADMIN,
+    COUCHDB_SERVER_PROTOCOL: env.COUCHDB_PROTOCOL,
+    COUCHDB_SERVER_URL: env.COUCHDB_SERVER,
+  },
+}).catch((e) => {
+  logger.error('Error initializing data layer:', e);
+  process.exit(1);
+});
+export default env;

package/src/utils/processQueue.ts ADDED Viewed

@@ -0,0 +1,218 @@
+import { IServerRequest } from '@vue-skuilder/common';
+import logger from '../logger.js';
+export interface Result {
+  status: 'ok' | 'awaiting' | 'warning' | 'error';
+  ok: boolean;
+  error?: unknown;
+}
+interface ProcessingFunction<T> {
+  (data: T): Promise<Result>;
+}
+interface LabelledRequest<R> {
+  id: number;
+  request: R;
+}
+interface FailedRequest<R> extends LabelledRequest<R> {
+  result: Result | null;
+  error: unknown;
+}
+interface CompletedRequest<R> extends LabelledRequest<R> {
+  result: Result;
+}
+/**
+ * This queue executes async prcesses sequentially, waiting
+ * for each to complete before launching the next.
+ */
+export default class AsyncProcessQueue<
+  T extends IServerRequest,
+  R extends Result
+> {
+  private processRequest: ProcessingFunction<T>;
+  private queue: LabelledRequest<T>[] = [];
+  private errors: FailedRequest<T>[] = [];
+  private completed: CompletedRequest<T>[] = [];
+  private processing = false;
+  private nextID = 0;
+  /**
+   * Returns 'complete' if the job is complete, 'error' if the
+   * job failed, and the job's position in queue if not yet
+   * completed.
+   *
+   * @param jobID The jobID returned by addRequest
+   */
+  public jobStatus(jobID: number): 'complete' | 'error' | number {
+    let ret: 'complete' | 'error' | number = -1; // Default to -1 if job not found
+    this.queue.forEach((req) => {
+      if (req.id === jobID) {
+        ret = this.queue.indexOf(req);
+      }
+    });
+    this.completed.forEach((req) => {
+      if (req.id === jobID) {
+        ret = 'complete';
+      }
+    });
+    this.errors.forEach((req) => {
+      if (req.id === jobID) {
+        ret = 'error';
+      }
+    });
+    return ret;
+  }
+  private async recurseGetResult(jobID: number, depth: number): Promise<R> {
+    // polling intervals in milliseconds
+    logger.info(`Checking job status of job ${jobID}...`);
+    const intervals = [100, 200, 400, 800, 1000, 2000, 3000, 5000];
+    depth = Math.min(depth, intervals.length - 1);
+    let status: 'complete' | 'error' | number;
+    const p = new Promise((resolve, reject) => {
+      setTimeout(
+        () => {
+          status = this.jobStatus(jobID);
+          if (status === 'complete' || status === 'error') {
+            resolve(null);
+          } else {
+            reject();
+          }
+        },
+        intervals[depth]
+      );
+    });
+    return p
+      .then(() => {
+        return this.getResult(jobID);
+      })
+      .catch(() => {
+        return this.recurseGetResult(jobID, depth + 1);
+      });
+  }
+  public async getResult(jobID: number, _depth = 0): Promise<R> {
+    const status = this.jobStatus(jobID);
+    if (status === 'complete') {
+      const res = this.completed.find((val) => {
+        return val.id === jobID;
+      });
+      if (res) {
+        return res.result as R;
+      } else {
+        return {
+          error: 'No result found',
+          ok: false,
+          status: 'error',
+        } as R;
+      }
+    } else if (status === 'error') {
+      const res = this.errors.find((val) => {
+        return val.id === jobID;
+      });
+      if (!res) {
+        return {
+          error: 'Job failed - no error log found',
+          ok: false,
+          status: 'error',
+        } as R;
+      }
+      if (res.result) {
+        return res.result as R;
+      } else {
+        // result is null b/c of an uncaugth exception
+        return {
+          error: res.error,
+          ok: false,
+          status: 'error',
+        } as R;
+      }
+    } else {
+      return this.recurseGetResult(jobID, 0);
+    }
+  }
+  public addRequest(req: T): number {
+    const id: number = this.nextID++;
+    this.queue.push({
+      id: id,
+      request: req,
+    });
+    if (!this.processing) {
+      void this.process();
+    }
+    return id;
+  }
+  /**
+   *
+   */
+  constructor(processingFcn: ProcessingFunction<T>) {
+    this.processRequest = processingFcn;
+  }
+  private async process() {
+    this.processing = true;
+    while (this.queue.length > 0) {
+      const req = this.queue[0];
+      logger.info(`Processing ${req.id}`);
+      try {
+        const result = await this.processRequest(req.request);
+        if (result.ok) {
+          this.completed.push({
+            id: req.id,
+            request: req.request,
+            result: result,
+          });
+        } else {
+          if (result) {
+            this.errors.push({
+              id: req.id,
+              request: req.request,
+              result: result,
+              error: result.error,
+            });
+          } else {
+            this.errors.push({
+              id: req.id,
+              request: req.request,
+              error: 'error',
+              result: null,
+            });
+          }
+        }
+      } catch (e) {
+        this.errors.push({
+          id: req.id,
+          request: req.request,
+          result: null,
+          error: e,
+        });
+      } finally {
+        // remove the completed (or errored)
+        // request from the queue
+        this.queue.shift();
+      }
+    }
+    this.processing = false;
+  }
+}

package/test/client.test.ts ADDED Viewed

@@ -0,0 +1,144 @@
+import { ChildProcess, exec } from 'child_process';
+import { CourseConfig } from '../../vue/src/server/types';
+import Client from '../src/client';
+import env from '../src/utils/env';
+import { DataShapeName } from '../../vue/src/enums/DataShapeNames';
+import { abort } from 'process';
+let serverProcess: ChildProcess;
+const client: Client = new Client('http://localhost:3000');
+const credentials = {
+  username: env.COUCHDB_ADMIN,
+  password: env.COUCHDB_PASSWORD,
+};
+beforeAll(async () => {
+  serverProcess = exec('yarn serve');
+  if (!serverProcess || !serverProcess.stdout) {
+    abort();
+  }
+  serverProcess.stdout.on('data', (data) => {
+    console.log(data);
+  });
+  console.log('Server starting...');
+  const checkServerReady = async () => {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error('Server did not start within 30 seconds'));
+      }, 10000);
+      const interval = setInterval(async () => {
+        try {
+          const response = await client.getVersion();
+          if (response) {
+            clearTimeout(timeout);
+            clearInterval(interval);
+            resolve(true);
+          }
+        } catch (error) {
+          // Server not ready yet
+          console.log('Server not ready yet');
+        }
+      }, 1000);
+    });
+  };
+  return await checkServerReady();
+}, 10_000);
+test('getVersion', async () => {
+  const version = await client.getVersion();
+  expect(version).toBe(env.VERSION);
+});
+test('Course Methods', async () => {
+  const testCourse: CourseConfig = createTestCourse();
+  // assert non-existence of test course
+  const courses = await client.getCourses();
+  expect(courses.find((c) => c.split(' - ')[1] === testCourse.name)).toBeUndefined();
+  console.log(`test course not found`);
+  // create test course
+  const createResp = await client.createCourse(testCourse, credentials);
+  expect(createResp.data?.ok).toBe(true);
+  expect(createResp.data?.courseID).not.toBe('');
+  console.log(`created test course`);
+  const courseID = createResp.data!.courseID;
+  // assert existence of test course
+  const courses2 = await client.getCourses();
+  expect(courses2.find((c) => c.split(' - ')[1] === testCourse.name)).toBeDefined();
+  expect(courses2.find((c) => c.split(' - ')[0] === courseID)).toBeDefined();
+  console.log(`found test course`);
+  // delete test course
+  const crsClient = client.getCourseClient(courseID);
+  await crsClient.deleteCourse(credentials);
+  console.log(`requested test course deletion`);
+  // assert non-existence of test course
+  const courses3 = await client.getCourses();
+  expect(courses3.find((c) => c.split(' - ')[0] === courseID)).toBeUndefined();
+  console.log(`test course deleted`);
+});
+// test('createNote', async () => {
+//   const crs = createTestCourse();
+//   const createResp = await client.createCourse(crs, credentials);
+//   const crsClient = client.getCourseClient(createResp.data!.courseID);
+//   const cfg = await crsClient.getConfig();
+//   for (const k in crs) {
+//     expect(cfg[k]).toEqual(crs[k]);
+//   }
+//   // expect(cfg).toEqual(crs);
+//   await crsClient.addData({
+//     author: 'test-author',
+//     data: 'this is a test',
+//     tags: ['test-tag'],
+//     courseID: crsClient.id,
+//     codeCourse: 'test-code-course-id',
+//     shape: {
+//       fields: [],
+//       name: DataShapeName.Blanks,
+//     },
+//   });
+// });
+afterAll(async () => {
+  if (!serverProcess || !serverProcess.stdin || !serverProcess.stdout || !serverProcess.stderr) {
+    return;
+  }
+  // see https://stackoverflow.com/questions/54562879/jest-open-handle-when-using-node-exec/75830272#75830272
+  serverProcess.stdin.destroy();
+  serverProcess.stdout.destroy();
+  serverProcess.stderr.destroy();
+  serverProcess.kill();
+  serverProcess.unref();
+});
+/**
+ * @returns a course config with a randomized name
+ */
+function createTestCourse(): CourseConfig {
+  const salt = Math.random();
+  const name = 'test-course-' + salt;
+  const testCourse: CourseConfig = {
+    name,
+    description: 'test-course',
+    admins: ['test-admin'],
+    creator: 'test-creator',
+    dataShapes: [],
+    questionTypes: [],
+    deleted: false,
+    moderators: [],
+    public: true,
+  };
+  return testCourse;
+}