feat: complete day 3

day3/app.js

@@ -1,11 +1,14 @@
-var createError = require('http-errors');
+var createError = require("http-errors");
-var express = require('express');
+var express = require("express");
-var path = require('path');
+var path = require("path");
-var cookieParser = require('cookie-parser');
+var cookieParser = require("cookie-parser");
-var logger = require('morgan');
+var logger = require("morgan");
 
-var indexRouter = require('./routes/index');
+var indexRouter = require("./routes/index");
-var usersRouter = require('./routes/users');
+var usersRouter = require("./routes/users");
+var variablesRouter = require("./routes/variables");
+var rulesRouter = require("./routes/rules");
+var evaluationRouter = require("./routes/evaluation");
 
 const db = require("./models");
 var cors = require("cors");
@@ -13,17 +16,20 @@ var cors = require("cors");
 var app = express();
 app.set("db", db);
 // view engine setup
-app.set('views', path.join(__dirname, 'views'));
+app.set("views", path.join(__dirname, "views"));
-app.set('view engine', 'jade');
+app.set("view engine", "jade");
 app.use(cors());
-app.use(logger('dev'));
+app.use(logger("dev"));
 app.use(express.json());
 app.use(express.urlencoded({ extended: false }));
 app.use(cookieParser());
-app.use(express.static(path.join(__dirname, 'public')));
+app.use(express.static(path.join(__dirname, "public")));
 
-app.use('/', indexRouter);
+app.use("/", indexRouter);
-app.use('/users', usersRouter);
+app.use("/users", usersRouter);
+app.use("/api/v1/variables", variablesRouter);
+app.use("/api/v1/rules", rulesRouter);
+app.use("/api/v1/evaluation", evaluationRouter);
 
 // catch 404 and forward to error handler
 app.use(function (req, res, next) {
@@ -34,11 +40,11 @@ app.use(function (req, res, next) {
 app.use(function (err, req, res, next) {
   // set locals, only providing error in development
   res.locals.message = err.message;
-  res.locals.error = req.app.get('env') === 'development' ? err : {};
+  res.locals.error = req.app.get("env") === "development" ? err : {};
 
   // render the error page
   res.status(err.status || 500);
-  res.render('error');
+  res.render("error");
 });
 
 module.exports = app;

day3/models/index.js

@@ -1,4 +1,4 @@
-'use strict';
+"use strict";
 /*Powered By: Manaknightdigital Inc. https://manaknightdigital.com/ Year: 2020*/
 /**
  * Sequelize File
@@ -8,49 +8,63 @@
  * @author Ryan Wong
  *
  */
-const fs = require('fs');
+const fs = require("fs");
-const path = require('path');
+const path = require("path");
-let Sequelize = require('sequelize');
+let Sequelize = require("sequelize");
 const basename = path.basename(__filename);
-const { DataTypes } = require('sequelize');
+const { DataTypes } = require("sequelize");
 const config = {
-  DB_DATABASE: 'mysql',
+  DB_DATABASE: "mysql",
-  DB_USERNAME: 'root',
+  DB_USERNAME: "root",
-  DB_PASSWORD: 'root',
+  DB_PASSWORD: process.env.DB_PASSWORD || "root",
-  DB_ADAPTER: 'mysql',
+  DB_ADAPTER: "mysql",
-  DB_NAME: 'day_1',
+  DB_NAME: "day_3",
-  DB_HOSTNAME: 'localhost',
+  DB_HOSTNAME: "localhost",
   DB_PORT: 3306,
 };
 
 let db = {};
 
-let sequelize = new Sequelize(config.DB_DATABASE, config.DB_USERNAME, config.DB_PASSWORD, {
+let sequelize = new Sequelize(
-  dialect: config.DB_ADAPTER,
+  config.DB_NAME,
-  username: config.DB_USERNAME,
+  config.DB_USERNAME,
-  password: config.DB_PASSWORD,
+  config.DB_PASSWORD,
-  database: config.DB_NAME,
+  {
-  host: config.DB_HOSTNAME,
+    dialect: config.DB_ADAPTER,
-  port: config.DB_PORT,
+    username: config.DB_USERNAME,
-  logging: console.log,
+    password: config.DB_PASSWORD,
-  timezone: '-04:00',
+    database: config.DB_NAME,
-  pool: {
+    host: config.DB_HOSTNAME,
-    maxConnections: 1,
+    port: config.DB_PORT,
-    minConnections: 0,
+    logging: console.log,
-    maxIdleTime: 100,
+    timezone: "-04:00",
-  },
+    pool: {
-  define: {
+      maxConnections: 1,
-    timestamps: false,
+      minConnections: 0,
-    underscoredAll: true,
+      maxIdleTime: 100,
-    underscored: true,
+    },
-  },
+    define: {
-});
+      timestamps: false,
+      underscoredAll: true,
+      underscored: true,
+    },
+  }
+);
 
-// sequelize.sync({ force: true });
+sequelize
+  .sync()
+  .then(() => {
+    console.log("All tables synced successfully.");
+  })
+  .catch((err) => {
+    console.error("Failed to sync tables:", err);
+  });
 
 fs.readdirSync(__dirname)
   .filter((file) => {
-    return file.indexOf('.') !== 0 && file !== basename && file.slice(-3) === '.js';
+    return (
+      file.indexOf(".") !== 0 && file !== basename && file.slice(-3) === ".js"
+    );
   })
   .forEach((file) => {
     var model = require(path.join(__dirname, file))(sequelize, DataTypes);
@@ -66,4 +80,4 @@ Object.keys(db).forEach((modelName) => {
 db.sequelize = sequelize;
 db.Sequelize = Sequelize;
 
-module.exports = db;
+module.exports = db;

day3/models/rules.js

@@ -10,19 +10,15 @@ module.exports = (sequelize, DataTypes) => {
       name: DataTypes.STRING,
       condition: DataTypes.STRING,
       action: DataTypes.STRING,
-      created_at: DataTypes.DATEONLY,
-      updated_at: DataTypes.DATE,
     },
     {
       timestamps: true,
       freezeTableName: true,
       tableName: "rules",
-    },
+      createdAt: "created_at",
-    {
+      updatedAt: "updated_at",
-      underscoredAll: false,
-      underscored: false,
     }
   );
 
   return rules;
-};
+};

day3/models/variables.js

@@ -1,5 +1,5 @@
 module.exports = (sequelize, DataTypes) => {
-  const rules = sequelize.define(
+  const variables = sequelize.define(
     "variables",
     {
       id: {
@@ -9,19 +9,15 @@ module.exports = (sequelize, DataTypes) => {
       },
       name: DataTypes.STRING,
       type: DataTypes.STRING,
-      created_at: DataTypes.DATEONLY,
-      updated_at: DataTypes.DATE,
     },
     {
       timestamps: true,
       freezeTableName: true,
       tableName: "variables",
-    },
+      createdAt: "created_at",
-    {
+      updatedAt: "updated_at",
-      underscoredAll: false,
-      underscored: false,
     }
   );
 
-  return rules;
+  return variables;
-};
+};

day3/package.json

@@ -3,7 +3,8 @@
   "version": "0.0.0",
   "private": true,
   "scripts": {
-    "start": "node ./bin/www"
+    "start": "node ./bin/www",
+    "dev": "node --watch  --env-file=.env  ./bin/www"
   },
   "dependencies": {
     "cookie-parser": "~1.4.4",

day3/routes/evaluation.js

@@ -0,0 +1,89 @@
+const express = require("express");
+const router = express.Router();
+const db = require("../models");
+
+// Helper to cast value to type
+function castToType(value, type) {
+  if (type === "INTEGER") return parseInt(value, 10);
+  if (type === "FLOAT") return parseFloat(value);
+  if (type === "STRING") return String(value);
+  return value;
+}
+
+// Helper to safely evaluate condition
+function safeEval(condition, context) {
+  // Only allow access to context variables
+  return Function(
+    ...Object.keys(context),
+    `return (${condition});`
+  )(...Object.values(context));
+}
+
+router.get("/", async (req, res) => {
+  try {
+    const { variable } = req.query;
+    if (!variable) {
+      return res
+        .status(400)
+        .json({ success: false, error: "Missing variable parameter" });
+    }
+    // Decode base64
+    let decoded;
+    try {
+      decoded = Buffer.from(variable, "base64").toString("utf-8");
+    } catch (e) {
+      return res
+        .status(400)
+        .json({ success: false, error: "Invalid base64 encoding" });
+    }
+    let payload;
+    try {
+      payload = JSON.parse(decoded);
+    } catch (e) {
+      return res
+        .status(400)
+        .json({ success: false, error: "Invalid JSON in variable payload" });
+    }
+
+    // Fetch all variables and rules
+    const [dbVariables, rules] = await Promise.all([
+      db.variables.findAll(),
+      db.rules.findAll(),
+    ]);
+
+    // Build a map of variable types
+    const variableTypeMap = {};
+    dbVariables.forEach((v) => {
+      variableTypeMap[v.name] = v.type;
+    });
+
+    // Prepare context for evaluation: only include variables that exist in db
+    const context = {};
+    for (const [key, value] of Object.entries(payload)) {
+      if (variableTypeMap[key]) {
+        context[key] = castToType(value, variableTypeMap[key]);
+      }
+    }
+
+    // Evaluate each rule
+    const results = [];
+    for (const rule of rules) {
+      let passed = false;
+      try {
+        passed = safeEval(rule.condition, context);
+      } catch (e) {
+        // Ignore rules with invalid conditions or missing variables
+        continue;
+      }
+      if (passed) {
+        results.push({ rule_id: rule.id, result: rule.action });
+      }
+    }
+
+    return res.json({ success: true, data: results });
+  } catch (err) {
+    return res.status(500).json({ success: false, error: err.message });
+  }
+});
+
+module.exports = router;

day3/routes/rules.js

@@ -0,0 +1,60 @@
+const express = require("express");
+const router = express.Router();
+const db = require("../models");
+const { Op } = require("sequelize");
+
+router.get("/", async (req, res) => {
+  try {
+    const rules = await db.rules.findAll();
+    res.json({ success: true, data: rules });
+  } catch (err) {
+    res.status(500).json({ success: false, error: err.message });
+  }
+});
+
+router.get("/:id", async (req, res) => {
+  try {
+    const rule = await db.rules.findByPk(req.params.id);
+    if (!rule)
+      return res.status(404).json({ success: false, error: "Rule not found" });
+    res.json({ success: true, data: rule });
+  } catch (err) {
+    res.status(500).json({ success: false, error: err.message });
+  }
+});
+
+router.post("/:id", async (req, res) => {
+  try {
+    const rule = await db.rules.create(req.body);
+    res.status(201).json({ success: true, data: rule });
+  } catch (err) {
+    res.status(400).json({ success: false, error: err.message });
+  }
+});
+
+router.put("/:id", async (req, res) => {
+  try {
+    const [updated] = await db.rules.update(req.body, {
+      where: { id: req.params.id },
+    });
+    if (!updated)
+      return res.status(404).json({ success: false, error: "Rule not found" });
+    const rule = await db.rules.findByPk(req.params.id);
+    res.json({ success: true, data: rule });
+  } catch (err) {
+    res.status(400).json({ success: false, error: err.message });
+  }
+});
+
+router.delete("/:id", async (req, res) => {
+  try {
+    const deleted = await db.rules.destroy({ where: { id: req.params.id } });
+    if (!deleted)
+      return res.status(404).json({ success: false, error: "Rule not found" });
+    res.json({ success: true, data: { message: "Rule deleted" } });
+  } catch (err) {
+    res.status(500).json({ success: false, error: err.message });
+  }
+});
+
+module.exports = router;

day3/routes/variables.js

@@ -0,0 +1,68 @@
+const express = require("express");
+const router = express.Router();
+const db = require("../models");
+const { Op } = require("sequelize");
+
+router.get("/", async (req, res) => {
+  try {
+    const variables = await db.variables.findAll();
+    res.json({ success: true, data: variables });
+  } catch (err) {
+    res.status(500).json({ success: false, error: err.message });
+  }
+});
+
+router.get("/:id", async (req, res) => {
+  try {
+    const variable = await db.variables.findByPk(req.params.id);
+    if (!variable)
+      return res
+        .status(404)
+        .json({ success: false, error: "Variable not found" });
+    res.json({ success: true, data: variable });
+  } catch (err) {
+    res.status(500).json({ success: false, error: err.message });
+  }
+});
+
+router.post("/:id", async (req, res) => {
+  try {
+    const variable = await db.variables.create(req.body);
+    res.status(201).json({ success: true, data: variable });
+  } catch (err) {
+    res.status(400).json({ success: false, error: err.message });
+  }
+});
+
+router.put("/:id", async (req, res) => {
+  try {
+    const [updated] = await db.variables.update(req.body, {
+      where: { id: req.params.id },
+    });
+    if (!updated)
+      return res
+        .status(404)
+        .json({ success: false, error: "Variable not found" });
+    const variable = await db.variables.findByPk(req.params.id);
+    res.json({ success: true, data: variable });
+  } catch (err) {
+    res.status(400).json({ success: false, error: err.message });
+  }
+});
+
+router.delete("/:id", async (req, res) => {
+  try {
+    const deleted = await db.variables.destroy({
+      where: { id: req.params.id },
+    });
+    if (!deleted)
+      return res
+        .status(404)
+        .json({ success: false, error: "Variable not found" });
+    res.json({ success: true, data: { message: "Variable deleted" } });
+  } catch (err) {
+    res.status(500).json({ success: false, error: err.message });
+  }
+});
+
+module.exports = router;