@canmingir/link-express 1.6.11 → 1.7.0

package/.eslintrc.ts

@@ -0,0 +1,29 @@
+export default {
+  env: {
+    es6: true,
+    node: true,
+    mocha: true,
+  },
+  parser: "@typescript-eslint/parser",
+  parserOptions: {
+    ecmaVersion: 2022,
+    sourceType: "module",
+    project: "./tsconfig.json",
+  },
+  plugins: ["@typescript-eslint"],
+  extends: [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/recommended",
+    "plugin:prettier/recommended",
+  ],
+  ignorePatterns: ["/node_modules", "/dist"],
+  rules: {
+    eqeqeq: ["error", "always"],
+    "no-console": "off",
+    "no-eval": "error",
+    "no-var": "error",
+    "prefer-arrow-callback": "error",
+    "@typescript-eslint/no-explicit-any": "error",
+    "@typescript-eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_" }],
+  },
+};

package/index.ts

@@ -0,0 +1,2 @@
+import * as platform from "./src/platform";
+export default platform;

package/package.json

@@ -1,22 +1,48 @@
 {
   "name": "@canmingir/link-express",
-  "version": "1.6.11",
+  "version": "1.7.0",
   "description": "",
-  "main": "index.js",
+  "main": "index.ts",
+  "types": "index.ts",
+  "typesVersions": {
+    "*": {
+      "models": [
+        "src/models/index.ts"
+      ],
+      "test": [
+        "src/test.ts"
+      ],
+      "authorization": [
+        "src/authorization.ts"
+      ],
+      "error": [
+        "src/error.ts"
+      ],
+      "types": [
+        "src/types/index.ts"
+      ],
+      "sequelize": [
+        "src/sequelize.ts"
+      ]
+    }
+  },
   "author": "NucTeam",
   "exports": {
-    ".": "./index.js",
-    "./models": "./src/models/index.js",
-    "./test": "./src/test.js",
-    "./authorization": "./src/authorization.js",
-    "./error": "./src/error.js"
+    ".": "./index.ts",
+    "./models": "./src/models/index.ts",
+    "./test": "./src/test.ts",
+    "./authorization": "./src/authorization.ts",
+    "./error": "./src/error.ts",
+    "./types": "./src/types/index.ts",
+    "./sequelize": "./src/sequelize.ts"
   },
   "scripts": {
-    "prepare": "node prepare.js",
+    "prepare": "tsx prepare.ts",
+    "build": "tsc",
     "dev": "node server --dev",
     "start": "node server",
     "test": "echo 'No tests'",
-    "lint": "eslint . --ext .js"
+    "lint": "eslint . --ext .ts"
   },
   "dependencies": {
     "@aws-sdk/client-dynamodb": "^3.614.0",
@@ -37,12 +63,24 @@
     "pino": "^10.1.0",
     "pino-elasticsearch": "^8.1.0",
     "prom-client": "^15.1.3",
-    "sequelize": "^6.37.3",
+    "sequelize": "^6.37.7",
+    "sequelize-typescript": "^2.1.6",
     "swagger-jsdoc": "^6.2.8",
-    "swagger-ui-express": "^5.0.1",
     "uuid": "^10.0.0"
   },
   "devDependencies": {
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.5",
+    "@types/jsonwebtoken": "^9.0.10",
+    "@types/lodash": "^4.17.21",
+    "@types/morgan": "^1.9.10",
+    "@types/node": "^24.10.1",
+    "@types/pg": "^8.15.6",
+    "@types/swagger-jsdoc": "^6.0.4",
+    "@types/swagger-ui-express": "^4.1.8",
+    "@types/uuid": "^10.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.48.0",
+    "@typescript-eslint/parser": "^8.48.0",
     "axios-mock-adapter": "^1.21.1",
     "eslint": "^8.57.1",
     "eslint-config-prettier": "^8.5.0",
@@ -50,6 +88,8 @@
     "mocha": "10.8.2",
     "prettier": "^2.6.2",
     "sqlite3": "^5.1.6",
-    "supertest": "^7.0.0"
+    "supertest": "^7.0.0",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.3"
   }
 }

package/{prepare.js → prepare.ts}

@@ -1,4 +1,4 @@
-const fs = require("fs");
+import fs from "fs";
 
 const prePush = `#!/usr/bin/env node
 const { execSync } = require("child_process");

package/src/{authorization.js → authorization.ts}

@@ -1,6 +1,22 @@
-const jwt = require("jsonwebtoken");
-const { AuthorizationError } = require("./error");
-function verify(req, res, next) {
+import jwt from "jsonwebtoken";
+import { Request, Response, NextFunction } from "express";
+import { AuthorizationError } from "./error";
+
+interface Session {
+  projectId: string;
+  userId: string;
+  roles: string[];
+  appId: string;
+  organizationId: string;
+}
+
+declare module "express-serve-static-core" {
+  interface Request {
+    session: Session;
+  }
+}
+
+function verify(req: Request, _res: Response, next: NextFunction): void {
   if (process.env.PROFILE === "TEST") {
     switch (process.env.PROJECT_ID) {
       case "0c756054-2d28-4f87-9b12-8023a79136a5":
@@ -69,8 +85,15 @@ function verify(req, res, next) {
   try {
     const { sub, aud, rls, aid, oid } = jwt.verify(
       token,
-      process.env.JWT_SECRET
-    );
+      process.env.JWT_SECRET as string
+    ) as {
+      sub: string;
+      aud: string;
+      rls: string[];
+      aid: string;
+      oid: string;
+    };
+
     req.session = {
       projectId: aud,
       userId: sub,
@@ -85,9 +108,8 @@ function verify(req, res, next) {
   next();
 }
 
-// eslint-disable-next-line no-unused-vars
-function authorize(role) {
-  return (req, res, next) => {
+function authorize(_role: string) {
+  return (req: Request, _res: Response, next: NextFunction): void => {
     const { roles } = req.session;
 
     // TODO Add expression check for role
@@ -99,4 +121,4 @@ function authorize(role) {
   };
 }
 
-module.exports = { verify, authorize };
+export { verify, authorize };

package/src/config.ts

@@ -0,0 +1,112 @@
+import _ from "lodash";
+
+interface LoggerConfig {
+  elasticsearch: {
+    index: string;
+    consistency?: string;
+    node: string;
+    esVersion?: number;
+    flushBytes?: number;
+  };
+}
+
+interface ProjectConfig {
+  name: string;
+  version: string;
+  oauth?: {
+    jwt: {
+      identifier: string;
+    };
+    providers: Record<
+      string,
+      {
+        tokenUrl: string;
+        userUrl: string;
+        clientId: string;
+        redirectUri?: string;
+        userIdentifier: string;
+        userFields: {
+          name: string;
+          displayName: string;
+          avatarUrl: string;
+          email: string;
+        };
+      }
+    >;
+  };
+}
+
+interface LinkConfig {
+  [key: string]: unknown;
+}
+
+interface OpenapiConfig {
+  [key: string]: unknown;
+}
+
+interface PostgresConfig {
+  uri: string;
+  debug?: boolean;
+  sync?: boolean;
+}
+
+interface DynamodbConfig {
+  region: string;
+}
+
+interface PushGatewayConfig {
+  url?: string;
+  jobName?: string;
+  instance?: string;
+  interval?: number;
+}
+
+interface MetricsConfig {
+  enabled: boolean;
+  url?: string;
+  pushGateway: PushGatewayConfig;
+  interval?: number;
+}
+
+interface Config {
+  link: LinkConfig;
+  project: ProjectConfig | null;
+  openapi: OpenapiConfig;
+  postgres: PostgresConfig | null;
+  dynamodb: DynamodbConfig | null;
+  pushGateway: PushGatewayConfig;
+  title?: string;
+  version?: string;
+  logger?: LoggerConfig;
+  metrics?: MetricsConfig;
+}
+
+let _config: Config = {
+  link: {},
+  project: null,
+  openapi: {},
+  postgres: null,
+  dynamodb: null,
+  pushGateway: {},
+};
+
+function init(config: Partial<Config> = {}): Config {
+  _config = _.merge(
+    {
+      link: {},
+      project: null,
+      openapi: {},
+      postgres: null,
+      dynamodb: null,
+      pushGateway: {},
+    },
+    config
+  );
+
+  return _config;
+}
+
+const getConfig = (): Config => _config;
+
+export { getConfig, init, Config };
+export default getConfig;

package/src/dynamodb.ts

@@ -0,0 +1,24 @@
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb";
+import { getConfig } from "./config";
+import dotenv from "dotenv";
+
+dotenv.config();
+
+const { dynamodb } = getConfig();
+
+if (!dynamodb) {
+  throw new Error("DynamoDB configuration is required");
+}
+
+const client = new DynamoDBClient({
+  region: dynamodb.region,
+  credentials: {
+    accessKeyId: process.env.AWS_ACCESS_KEY_ID as string,
+    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY as string,
+  },
+});
+
+const docClient = DynamoDBDocumentClient.from(client);
+
+export { docClient };

package/src/{error.js → error.ts}

@@ -1,7 +1,31 @@
-const { ValidationError } = require("joi");
+import { ValidationError } from "joi";
+import { Request, Response, NextFunction } from "express";
 
-// eslint-disable-next-line no-unused-vars
-const handle = (err, req, res, next) => {
+interface AxiosError extends Error {
+  isAxiosError: boolean;
+  response?: {
+    status: number;
+  };
+}
+
+interface ErrorWithError {
+  error: unknown;
+}
+
+const handle = (
+  err:
+    | string
+    | ValidationError
+    | AuthorizationError
+    | AuthenticationError
+    | NotFoundError
+    | AxiosError
+    | ErrorWithError
+    | Error,
+  _req: Request,
+  res: Response,
+  _next: NextFunction
+): Response => {
   if (typeof err === "string") {
     return res.status(400).json({ error: err });
   }
@@ -22,11 +46,11 @@ const handle = (err, req, res, next) => {
     return res.status(404).end();
   }
 
-  if (err.isAxiosError) {
+  if ("isAxiosError" in err && err.isAxiosError) {
     return res.status(err.response?.status || 503).end();
   }
 
-  if (err.error) {
+  if ("error" in err && err.error) {
     return res.status(400).json(err);
   } else {
     console.error(err);
@@ -38,9 +62,4 @@ class AuthorizationError extends Error {}
 class AuthenticationError extends Error {}
 class NotFoundError extends Error {}
 
-module.exports = {
-  handle,
-  AuthorizationError,
-  NotFoundError,
-  AuthenticationError,
-};
+export { handle, AuthorizationError, NotFoundError, AuthenticationError };

package/src/express.ts

@@ -0,0 +1,66 @@
+import express, { Request, Response, NextFunction } from "express";
+import "express-async-errors";
+import cors from "cors";
+import morgan from "morgan";
+import helmet from "helmet";
+import * as error from "./error";
+import * as authorization from "./authorization";
+import settings from "./routes/settings";
+import metrics from "./routes/metrics";
+import { getConfig } from "./config";
+
+const app = express();
+
+const appConfig = getConfig();
+
+app.use(helmet());
+app.use(cors());
+app.use(morgan("tiny"));
+
+app.use(
+  express.json(),
+  (err: Error, _req: Request, res: Response, next: NextFunction) =>
+    err ? res.status(422).end() : next()
+);
+
+if (appConfig.project) {
+  import("./routes/oauth.ts").then((oauthModule) => {
+    const oauth = oauthModule.default || oauthModule;
+    app.use(
+      "/oauth",
+      express.urlencoded(),
+      (err: Error, _req: Request, res: Response, next: NextFunction) =>
+        err ? res.status(422).end() : next(),
+      oauth
+    );
+  });
+}
+
+app.use("/metrics", metrics);
+
+setImmediate(async () => {
+  process.env.PROFILE === "TEST" && app.use(authorization.verify);
+
+  if (appConfig.project) {
+    const [permissionsModule, organizationsModule, projectsModule] =
+      await Promise.all([
+        import("./routes/permissions.ts"),
+        import("./routes/organizations.ts"),
+        import("./routes/projects.ts"),
+      ]);
+
+    const permissions = permissionsModule.default || permissionsModule;
+    const organizations = organizationsModule.default || organizationsModule;
+    const projects = projectsModule.default || projectsModule;
+
+    app.use("/projects", projects);
+    app.use("/organizations", organizations);
+    app.use("/permissions", permissions);
+    app.use("/projects/:projectId/settings", settings);
+  }
+
+  app.use((_req: Request, res: Response) => res.status(404).end());
+  app.use(error.handle);
+});
+
+export default app;

package/src/lib/{settings.js → settings.ts}

@@ -1,6 +1,10 @@
-const Settings = require("../models/Settings");
+import Settings from "../models/Settings.model";
 
-async function get({ projectId }) {
+async function get({
+  projectId,
+}: {
+  projectId: string;
+}): Promise<Record<string, unknown>> {
   const settingsInstance = await Settings.findOne({
     where: { projectId },
   });
@@ -12,7 +16,15 @@ async function get({ projectId }) {
   }
 }
 
-async function upsert({ projectId }, settings) {
+async function upsert(
+  {
+    projectId,
+  }: {
+    projectId: string;
+  },
+  settings: Record<string, unknown>,
+  _params?: Record<string, unknown>
+): Promise<void> {
   const settingsInstance = await Settings.findOne({
     where: { projectId },
   });
@@ -33,4 +45,4 @@ async function upsert({ projectId }, settings) {
   }
 }
 
-module.exports = { get, upsert };
+export { get, upsert };

package/src/lib/test.ts

@@ -0,0 +1,68 @@
+import dotenv from "dotenv";
+import platform from "../platform";
+import { Sequelize } from "sequelize";
+
+dotenv.config({ path: ".env.test" });
+
+platform.init({
+  project: {
+    name: "test",
+    version: "1.0.0",
+    oauth: {
+      jwt: {
+        identifier: "email",
+      },
+      providers: {
+        github: {
+          tokenUrl: "https://github.com/login/oauth/access_token",
+          userUrl: "https://api.github.com/user",
+          clientId: "0c2844d3d19dc9293fc5",
+          redirectUri: "http://localhost:5173/callback",
+          userIdentifier: "id",
+          userFields: {
+            name: "name",
+            displayName: "login",
+            avatarUrl: "avatar_url",
+            email: "email",
+          },
+        },
+      },
+    },
+  },
+  postgres: {
+    uri: "sqlite::memory:",
+    debug: true,
+    sync: false,
+  },
+});
+
+import { init } from "../models";
+
+async function reset(): Promise<void> {
+  const { sequelize }: { sequelize: Sequelize } = await import("../postgres");
+
+  if (await init()) {
+    await sequelize.sync({ force: true });
+  }
+
+  await sequelize.models.Organization.destroy({ truncate: true });
+  await sequelize.models.Project.destroy({ truncate: true });
+  await sequelize.models.Permission.destroy({ truncate: true });
+  await sequelize.models.Settings.destroy({ truncate: true });
+
+  async function seed(): Promise<void> {
+    const { seed: organizations } = await import("../seeds/Organization.json");
+    const { seed: permissions } = await import("../seeds/Permission.json");
+    const { seed: projects } = await import("../seeds/Project.json");
+    const { seed: settings } = await import("../seeds/Settings.json");
+
+    await sequelize.models.Organization.bulkCreate(organizations);
+    await sequelize.models.Project.bulkCreate(projects);
+    await sequelize.models.Permission.bulkCreate(permissions);
+    await sequelize.models.Settings.bulkCreate(settings);
+  }
+
+  await seed();
+}
+
+export { reset };

package/src/{logger.js → logger.ts}

@@ -1,20 +1,22 @@
-const { ecsFormat } = require("@elastic/ecs-pino-format");
-const pino = require("pino");
-const pinoElastic = require("pino-elasticsearch");
+import { ecsFormat } from "@elastic/ecs-pino-format";
+import pino from "pino";
+import pinoElastic from "pino-elasticsearch";
+import { getConfig } from "./config";
 
-const config = require("./config");
+const { logger: loggerConfig, project } = getConfig();
 
-const { logger: loggerConfig, project } = config();
+if (!loggerConfig || !project) {
+  throw new Error("Logger and project configuration are required");
+}
 
-const streams = [{ stream: process.stdout }];
+const streams: pino.StreamEntry[] = [{ stream: process.stdout }];
 
 const streamToElastic = pinoElastic({
   index: loggerConfig.elasticsearch.index,
-  consistency: loggerConfig.elasticsearch.consistency || "one",
   node: loggerConfig.elasticsearch.node,
   esVersion: loggerConfig.elasticsearch.esVersion || 8,
   flushBytes: loggerConfig.elasticsearch.flushBytes || 1000,
-});
+} as Parameters<typeof pinoElastic>[0]);
 
 streams.push({ stream: streamToElastic });
 
@@ -31,4 +33,4 @@ const logger = pino(
   pino.multistream(streams)
 );
 
-module.exports = logger;
+export default logger;