@canmingir/link-express 1.6.0

package/src/platform.js

@@ -0,0 +1,46 @@
+const fs = require("fs");
+const authorization = require("./authorization");
+const error = require("./error");
+
+let _express;
+let _postgres;
+let _dynamodb;
+
+function init(config = {}) {
+  return new Promise((resolve, reject) => {
+    try {
+      require.extensions[".md"] = function (module, filename) {
+        module.exports = fs.readFileSync(filename, "utf8").trim();
+      };
+
+      const { postgres, dynamodb } = require("./config").init(config);
+
+      _express = require("./express");
+
+      if (postgres) {
+        _postgres = require("./postgres");
+      }
+
+      if (dynamodb) {
+        _dynamodb = require("./dynamodb");
+      }
+
+      resolve();
+    } catch (err) {
+      reject(err);
+    }
+  });
+}
+
+module.exports = {
+  init,
+  express: () => _express,
+  module: () => ({
+    Postgres: _postgres,
+    DynamoDB: _dynamodb,
+    Kafka: {},
+  }),
+  require: (pkg) => require(pkg),
+  authorization,
+  error,
+};

package/src/postgres.js

@@ -0,0 +1,211 @@
+const { Sequelize, Model } = require("sequelize");
+const config = require("./config");
+const path = require("path");
+const fs = require("fs");
+
+const {
+  postgres: { uri, debug = false, sync },
+  project,
+} = config();
+
+const originalDestroy = Model.prototype.destroy;
+
+Model.prototype.destroy = function (options = {}) {
+  return originalDestroy.call(this, {
+    ...options,
+    individualHooks: true,
+  });
+};
+
+const sequelize = new Sequelize(process.env.PG || uri, {
+  logging: debug && console.log,
+  define: {
+    freezeTableName: true,
+    underscored: true,
+    timestamps: false,
+    paranoid: false,
+  },
+});
+
+const seed = async () => {
+  const currentWorkingDirectory = process.cwd();
+  const baseDir = path.join(currentWorkingDirectory, "src", "models");
+  const seedDir = path.join(currentWorkingDirectory, "src", "seeds");
+
+  if (!fs.existsSync(seedDir)) {
+    console.error(`[NUC] Seed directory not found at path: ${seedDir}`);
+    return;
+  }
+
+  if (!fs.existsSync(baseDir)) {
+    console.error(`[NUC] Model directory not found at path: ${baseDir}`);
+    return;
+  }
+
+  let transaction = await sequelize.transaction();
+
+  try {
+    if (project) {
+      const Organization = require("./models/Organization");
+      const { seed: companiesSeed } = require("./seeds/Organization.json");
+
+      await Organization.bulkCreate(companiesSeed, {
+        transaction,
+        validate: true,
+      });
+      console.log(`[NUC] Loading internal seed data for Organization`);
+
+      if (fs.existsSync(path.join(seedDir, "Organization.json"))) {
+        const seedData = require(path.join(seedDir, "Organization.json"));
+        const seed = seedData["seed"];
+        await Organization.bulkCreate(seed, {
+          transaction,
+          validate: true,
+        });
+        console.log(`[NUC] Loading seed data for Organization`);
+      }
+
+      const Project = require("./models/Project");
+      const { seed: projectSeed } = require("./seeds/Project.json");
+
+      try {
+        const { seed: extProjectSeed } = require(path.join(
+          seedDir,
+          "Project.json"
+        ));
+        if (extProjectSeed) {
+          projectSeed.push(...extProjectSeed);
+        }
+        console.log(
+          `[NUC] Loading internal${
+            extProjectSeed ? " and external" : ""
+          } seed data for Project`
+        );
+      } catch (error) {
+        console.log(`[NUC] Loading internal seed data for Project`);
+      }
+
+      await Project.bulkCreate(projectSeed, {
+        transaction,
+        validate: true,
+      });
+    }
+
+    const fileNames = fs
+      .readdirSync(baseDir)
+      .filter(
+        (fileName) =>
+          path.extname(fileName) === ".js" &&
+          !["index.js", "models.js"].includes(fileName)
+      );
+
+    const fileSequences = fileNames
+      .map((fileName) => {
+        const seedName = fileName.split(".")[0];
+        const seederPath = path.join(seedDir, `${seedName}.json`);
+
+        if (fs.existsSync(seederPath)) {
+          const seedData = require(seederPath);
+          return { sequence: seedData.sequence, fileName };
+        }
+        return null;
+      })
+      .filter(Boolean)
+      .sort((a, b) => a.sequence - b.sequence);
+
+    for (const { fileName } of fileSequences) {
+      const seedName = fileName.split(".")[0];
+      const seederPath = path.join(seedDir, `${seedName}.json`);
+      const filePath = path.join(baseDir, fileName);
+
+      try {
+        const model = require(filePath);
+        const seedData = require(seederPath);
+        const seed = seedData["seed"];
+
+        console.log(`[NUC] Loading seed data for ${fileName}`);
+        await model.bulkCreate(seed, {
+          transaction,
+          validate: true,
+        });
+      } catch (error) {
+        console.error(`[NUC] Error loading seed data for ${fileName}:`, error);
+        throw error;
+      }
+    }
+
+    if (project) {
+      const Permission = require("./models/Permission");
+      const { seed: permissionsSeed } = require("./seeds/Permission.json");
+      try {
+        const { seed: extPermissionsSeed } = require(path.join(
+          seedDir,
+          "Permission.json"
+        ));
+        if (extPermissionsSeed) {
+          permissionsSeed.push(...extPermissionsSeed);
+        }
+        console.log(
+          `[NUC] Loading internal${
+            extPermissionsSeed ? " and external" : ""
+          } seed data for Permission`
+        );
+      } catch (error) {
+        console.log(`[NUC] Loading internal seed data for Permission`);
+      }
+
+      await Permission.bulkCreate(permissionsSeed, {
+        transaction,
+        validate: true,
+      });
+
+      const Settings = require("./models/Settings");
+      const { seed: settingsSeed } = require("./seeds/Settings.json");
+
+      try {
+        const { seed: extSettingsSeed } = require(path.join(
+          seedDir,
+          "Settings.json"
+        ));
+        if (extSettingsSeed) {
+          settingsSeed.push(...extSettingsSeed);
+        }
+        console.log(
+          `[NUC] Loading internal${
+            extSettingsSeed ? " and external" : ""
+          } seed data for Settings`
+        );
+      } catch (error) {
+        console.log(`[NUC] Loading internal seed data for Settings`);
+      }
+
+      await Settings.bulkCreate(settingsSeed, {
+        transaction,
+        validate: true,
+      });
+    }
+
+    await transaction.commit();
+  } catch (error) {
+    if (transaction && !transaction.finished) {
+      await transaction.rollback();
+    }
+    console.error("[NUC] Error during seed operation:", error);
+    throw error;
+  }
+};
+
+const associateModels = async () => {
+  const models = require("./models");
+  await models.init();
+};
+
+if (sync) {
+  setImmediate(async () => {
+    project && (await associateModels());
+    await sequelize.sync({ force: true });
+    await seed();
+  });
+}
+
+module.exports = { sequelize };

package/src/routes/index.js

@@ -0,0 +1,15 @@
+const metrics = require("./metrics");
+const permissions = require("./permissions");
+const oauth = require("./oauth");
+const organizations = require("./organizations");
+const projects = require("./projects");
+const settings = require("./settings");
+
+module.exports = {
+  metrics,
+  permissions,
+  oauth,
+  organizations,
+  projects,
+  settings,
+};

package/src/routes/metrics.js

@@ -0,0 +1,12 @@
+const express = require("express");
+const router = express.Router();
+const os = require("os");
+
+router.get("/", (req, res) => {
+  res.json({
+    free: os.freemem(),
+    total: os.totalmem(),
+  });
+});
+
+module.exports = router;

package/src/routes/oauth.js

@@ -0,0 +1,100 @@
+const Joi = require("joi");
+const router = require("express").Router();
+const jwt = require("jsonwebtoken");
+const axios = require("axios");
+const config = require("../config");
+const { AuthenticationError } = require("../error");
+const Permission = require("../models/Permission");
+const { project } = config();
+
+router.post("/", async (req, res) => {
+  let { appId, projectId, code, refreshToken, redirectUri } = Joi.attempt(
+    req.body,
+    Joi.object({
+      appId: Joi.string().required(),
+      projectId: Joi.string().optional(),
+      code: Joi.string().optional(),
+      refreshToken: Joi.string().optional(),
+      redirectUri: Joi.string().optional(),
+    })
+      .required()
+      .options({ stripUnknown: true })
+  );
+  if (!code && !refreshToken) {
+    return res.status(400).send("Missing OAuth Code and Refresh Token");
+  }
+  if (code && redirectUri) {
+    const params = new URLSearchParams();
+    params.append("client_id", project.oauth.clientId);
+    params.append("client_secret", process.env.OAUTH_CLIENT_SECRET);
+    params.append("code", code);
+    params.append("redirect_uri", redirectUri);
+    params.append("grant_type", "authorization_code");
+    const { data } = await axios.post(
+      project.oauth.tokenUrl,
+      params.toString(),
+      {
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      }
+    );
+
+    const urlParams = new URLSearchParams(data);
+
+    if (urlParams.get("error")) {
+      throw new AuthenticationError(urlParams.get("error_description"));
+    }
+
+    refreshToken = urlParams.get("access_token");
+  }
+
+  const { data } = await axios.get(project.oauth.userUrl, {
+    headers: {
+      Authorization: `Bearer ${refreshToken}`,
+    },
+  });
+
+  const userId = data[project.oauth.jwt.identifier].toString();
+
+  let accessToken;
+
+  if (projectId) {
+    const permissions = await Permission.findAll({
+      where: { userId, projectId, appId },
+    });
+
+    if (!permissions.length) {
+      accessToken = jwt.sign(
+        { sub: userId, iss: "nuc", aid: appId },
+        process.env.JWT_SECRET,
+        {
+          expiresIn: "12h",
+        }
+      );
+    } else {
+      accessToken = jwt.sign(
+        {
+          sub: userId,
+          iss: "nuc",
+          aud: projectId,
+          oid: permissions[0].organizationId,
+          aid: appId,
+          rls: permissions.map((permission) => permission.role),
+        },
+        process.env.JWT_SECRET,
+        { expiresIn: "12h" }
+      );
+    }
+  } else {
+    accessToken = jwt.sign(
+      { sub: userId, iss: "nuc", aid: appId },
+      process.env.JWT_SECRET,
+      {
+        expiresIn: "12h",
+      }
+    );
+  }
+
+  res.status(200).json({ accessToken, refreshToken });
+});
+
+module.exports = router;

package/src/routes/organizations.js

@@ -0,0 +1,42 @@
+const router = require("express").Router();
+const Organization = require("../models/Organization");
+const Permission = require("../models/Permission");
+
+router.post("/", async (req, res) => {
+  const organization = req.body;
+
+  Organization.create(organization).then((organization) => {
+    res.status(201).json(organization);
+  });
+});
+
+router.get("/", async (req, res) => {
+  const { userId } = req.session;
+
+  const organizations = await Organization.findAll({
+    include: [
+      {
+        model: Permission,
+        as: "permissions",
+        where: { userId },
+        attributes: [],
+      },
+    ],
+  });
+
+  res.status(200).json(organizations);
+});
+
+router.get("/:id", async (req, res) => {
+  const { organizationId } = req.session;
+  const { id } = req.params;
+
+  if (organizationId !== id) {
+    return res.status(401).end();
+  }
+
+  const organization = await Organization.findByPk(organizationId);
+  res.status(200).json(organization);
+});
+
+module.exports = router;

package/src/routes/permissions.js

@@ -0,0 +1,50 @@
+const router = require("express").Router();
+const Permission = require("../models/Permission");
+
+router.post("/", async (req, res) => {
+  const { userId } = req.body;
+  const { projectId, organizationId, appId, roles } = req.session;
+  const permissionInstance = await Permission.create({
+    userId,
+    projectId,
+    organizationId,
+    appId,
+    role: roles[0],
+  });
+  res.status(201).json(permissionInstance);
+});
+
+router.get("/", async (req, res) => {
+  const { projectId, organizationId } = req.session;
+
+  const permissions = await Permission.findAll({
+    where: {
+      projectId,
+      organizationId,
+    },
+  });
+
+  if (permissions.length === 0) {
+    res.status(404).end();
+  } else {
+    res.status(200).json(permissions);
+  }
+});
+
+router.delete("/:userId", async (req, res) => {
+  const { projectId, organizationId } = req.session;
+  const userId = req.params.userId;
+
+  const instance = await Permission.findOne({
+    where: { userId: userId, projectId, organizationId },
+  });
+
+  if (instance) {
+    await instance.destroy();
+    res.status(204).end();
+  } else {
+    res.status(404).end();
+  }
+});
+
+module.exports = router;

package/src/routes/projects.js

@@ -0,0 +1,125 @@
+const Joi = require("joi");
+const router = require("express").Router();
+const Project = require("../models/Project");
+const Organization = require("../models/Organization");
+const Permission = require("../models/Permission");
+const schemas = require("../schemas");
+const config = require("../config");
+
+router.post("/", async (req, res) => {
+  const project = Joi.attempt(req.body, schemas.Project);
+
+  if (config.link && config.link.project) {
+    Joi.attempt(project.type, config.link.project.type);
+  }
+
+  const projectInstance = await Project.create(project);
+
+  await Permission.create({
+    userId: req.session.userId,
+    organizationId: project.organizationId,
+    role: "OWNER",
+    projectId: projectInstance.id,
+    appId: req.session.appId,
+  });
+
+  res.status(201).json(projectInstance);
+});
+
+router.get("/", async (req, res) => {
+  const { userId, appId } = req.session;
+
+  const projects = await Project.findAll({
+    include: [
+      {
+        model: Permission,
+        where: { userId, appId },
+        attributes: [],
+        as: "permissions",
+      },
+      {
+        model: Organization,
+        as: "organization",
+      },
+    ],
+    attributes: {
+      exclude: ["organizationId"],
+    },
+  });
+
+  res.status(200).json(projects);
+});
+
+router.get("/:id", async (req, res) => {
+  const { userId, organizationId } = req.session;
+  const { id } = req.params;
+
+  const project = await Project.findOne({
+    include: [
+      {
+        model: Permission,
+        where: { userId, organizationId },
+        attributes: [],
+        as: "permissions",
+      },
+    ],
+    where: { id },
+  });
+
+  if (project) {
+    res.status(200).json(project);
+  } else {
+    res.status(404).end();
+  }
+});
+
+router.delete("/:id", async (req, res) => {
+  const { userId, organizationId } = req.session;
+  const { id } = req.params;
+
+  const project = await Project.findOne({
+    include: [
+      {
+        model: Permission,
+        where: { userId, organizationId },
+        attributes: [],
+        as: "permissions",
+      },
+    ],
+    where: { id },
+  });
+
+  if (project) {
+    await project.destroy();
+    res.status(204).end();
+  } else {
+    res.status(404).end();
+  }
+});
+
+router.patch("/:id", async (req, res) => {
+  const { userId, organizationId } = req.session;
+  const { id } = req.params;
+
+  const project = await Project.findOne({
+    include: [
+      {
+        model: Permission,
+        where: { userId, organizationId },
+        attributes: [],
+        as: "permissions",
+      },
+    ],
+    where: { id },
+  });
+
+  if (project) {
+    const updatedProject = Joi.attempt(req.body, schemas.Project);
+    await project.update(updatedProject);
+    res.status(200).json(project);
+  } else {
+    res.status(404).end();
+  }
+});
+
+module.exports = router;

package/src/routes/settings.js

@@ -0,0 +1,25 @@
+const express = require("express");
+const router = express.Router({ mergeParams: true });
+
+const settings = require("../lib/settings");
+const { AuthorizationError } = require("../error");
+
+router.get("/", async (req, res) => {
+  if (req.params.projectId !== req.session.projectId) {
+    throw new AuthorizationError();
+  }
+
+  const setting = await settings.get(req.session, req.params);
+  res.json(setting);
+});
+
+router.patch("/", async (req, res) => {
+  if (req.params.projectId !== req.session.projectId) {
+    throw new AuthorizationError();
+  }
+
+  await settings.upsert(req.session, req.body, req.params);
+  res.end();
+});
+
+module.exports = router;