@canmingir/link-express 1.6.10 → 1.7.0

package/src/metrics/{dbMetrics.js → dbMetrics.ts}

@@ -1,6 +1,30 @@
-const promClient = require("prom-client");
+import promClient from "prom-client";
+
+interface PushgatewayConfig {
+  url: string;
+  jobName: string;
+  instance?: string;
+  interval: number;
+}
+
+interface MetricsConfig {
+  url?: string;
+  pushGateway: {
+    jobName?: string;
+    instance?: string;
+  };
+  interval?: number;
+}
 
 class DBMetrics {
+  registry: promClient.Registry;
+  pushgatewayInterval: NodeJS.Timeout | null;
+  pushgatewayConfig: PushgatewayConfig | null;
+  dbReadOps: promClient.Counter<string>;
+  dbWriteOps: promClient.Counter<string>;
+  dbReadLatency: promClient.Histogram<string>;
+  dbWriteLatency: promClient.Histogram<string>;
+
   constructor() {
     this.registry = new promClient.Registry();
     this.pushgatewayInterval = null;
@@ -33,17 +57,17 @@ class DBMetrics {
     });
   }
 
-  recordDbRead() {
+  recordDbRead(): () => number {
     this.dbReadOps.inc();
     return this.dbReadLatency.startTimer();
   }
 
-  recordDbWrite() {
+  recordDbWrite(): () => number {
     this.dbWriteOps.inc();
     return this.dbWriteLatency.startTimer();
   }
 
-  startPushgateway(metrics = {}) {
+  startPushgateway(metrics: MetricsConfig): void {
     this.pushgatewayConfig = {
       url: metrics.url || "http://localhost:9091",
       jobName: metrics.pushGateway.jobName || "api",
@@ -62,19 +86,18 @@ class DBMetrics {
     );
   }
 
-  stopPushgateway() {
+  stopPushgateway(): void {
     if (this.pushgatewayInterval) {
       clearInterval(this.pushgatewayInterval);
-      this.pushgatewayInterval = undefined;
+      this.pushgatewayInterval = null;
       console.log("Stopped pushing metrics to Pushgateway");
     }
   }
 
-  async pushMetricsToGateway() {
+  async pushMetricsToGateway(): Promise<void> {
     if (!this.pushgatewayConfig) {
-      throw new Error(
-        "Pushgateway not configured. Call startPushgateway() first."
-      );
+      console.error("[DBMetrics] Pushgateway not configured");
+      return;
     }
 
     try {
@@ -95,15 +118,15 @@ class DBMetrics {
         throw new Error(`HTTP ${response.status}: ${response.statusText}`);
       }
 
-      console.log("Metrics pushed to Pushgateway successfully");
+      console.log("[DBMetrics] Metrics pushed to Pushgateway successfully");
     } catch (err) {
-      console.error("Failed to push metrics to Pushgateway:", err);
+      console.error("[DBMetrics] Failed to push metrics to Pushgateway:", err);
     }
   }
 
-  getPushgatewayConfig() {
+  getPushgatewayConfig(): PushgatewayConfig | null {
     return this.pushgatewayConfig;
   }
 }
 
-module.exports = { DBMetrics };
+export { DBMetrics };

package/src/models/Organization.model.ts

@@ -0,0 +1,27 @@
+import {
+  Table,
+  Column,
+  Model,
+  DataType,
+  Default,
+  PrimaryKey,
+  AllowNull,
+} from "sequelize-typescript";
+
+@Table({
+  tableName: "Organization",
+  timestamps: false,
+  underscored: true,
+})
+class Organization extends Model {
+  @PrimaryKey
+  @Default(DataType.UUIDV4)
+  @Column(DataType.UUID)
+  declare id: string;
+
+  @AllowNull(false)
+  @Column(DataType.STRING)
+  declare name: string;
+}
+
+export default Organization;

package/src/models/Permission.model.ts

@@ -0,0 +1,48 @@
+import {
+  Table,
+  Column,
+  Model,
+  DataType,
+  Default,
+  PrimaryKey,
+  AllowNull,
+  ForeignKey,
+} from "sequelize-typescript";
+import Organization from "./Organization.model";
+import Project from "./Project.model";
+
+@Table({
+  tableName: "Permission",
+  timestamps: false,
+  underscored: true,
+})
+class Permission extends Model {
+  @PrimaryKey
+  @Default(DataType.UUIDV4)
+  @Column(DataType.UUID)
+  declare id: string;
+
+  @AllowNull(false)
+  @Column(DataType.UUID)
+  declare appId: string;
+
+  @AllowNull(false)
+  @ForeignKey(() => Organization)
+  @Column(DataType.UUID)
+  declare organizationId: string;
+
+  @AllowNull(false)
+  @ForeignKey(() => Project)
+  @Column(DataType.UUID)
+  declare projectId: string;
+
+  @AllowNull(false)
+  @Column(DataType.STRING)
+  declare userId: string;
+
+  @AllowNull(false)
+  @Column(DataType.STRING)
+  declare role: string;
+}
+
+export default Permission;

package/src/models/Project.model.ts

@@ -0,0 +1,50 @@
+import {
+  Table,
+  Column,
+  Model,
+  DataType,
+  Default,
+  PrimaryKey,
+  AllowNull,
+  ForeignKey,
+} from "sequelize-typescript";
+import Organization from "./Organization.model";
+
+@Table({
+  tableName: "Project",
+  timestamps: false,
+  underscored: true,
+})
+class Project extends Model {
+  @PrimaryKey
+  @Default(DataType.UUIDV4)
+  @Column(DataType.UUID)
+  declare id: string;
+
+  @AllowNull(false)
+  @Column(DataType.STRING)
+  declare name: string;
+
+  @AllowNull(false)
+  @Column(DataType.STRING)
+  declare icon: string;
+
+  @AllowNull(true)
+  @Column(DataType.STRING)
+  declare description: string | null;
+
+  @AllowNull(true)
+  @Column(DataType.STRING)
+  declare type: string | null;
+
+  @AllowNull(true)
+  @ForeignKey(() => Organization)
+  @Column(DataType.UUID)
+  declare organizationId: string | null;
+
+  @AllowNull(true)
+  @Column(DataType.STRING)
+  declare coach: string | null;
+}
+
+export default Project;

package/src/models/Settings.model.ts

@@ -0,0 +1,31 @@
+import {
+  Table,
+  Column,
+  Model,
+  DataType,
+  Default,
+  PrimaryKey,
+  AllowNull,
+} from "sequelize-typescript";
+
+@Table({
+  tableName: "Settings",
+  timestamps: false,
+  underscored: true,
+})
+class Settings extends Model {
+  @PrimaryKey
+  @Default(DataType.UUIDV4)
+  @Column(DataType.UUID)
+  declare id: string;
+
+  @AllowNull(false)
+  @Column(DataType.UUID)
+  declare projectId: string;
+
+  @AllowNull(false)
+  @Column(DataType.JSONB)
+  declare settings: Record<string, unknown>;
+}
+
+export default Settings;

package/src/models/{index.js → index.ts}

@@ -1,11 +1,11 @@
-const Project = require("./Project");
-const Organization = require("./Organization");
-const Permission = require("./Permission");
-const Setting = require("./Settings");
+import Project from "./Project.model";
+import Organization from "./Organization.model";
+import Permission from "./Permission.model";
+import Setting from "./Settings.model";
 
 let _init = false;
 
-async function init() {
+async function init(): Promise<boolean> {
   if (!_init) {
     _init = true;
   } else {
@@ -37,10 +37,10 @@ async function init() {
     as: "permissions",
   });
 
-  Organization.addHook("beforeDestroy", async (organization) => {
+  Organization.addHook("beforeDestroy", async (organization: Organization) => {
     await Project.destroy({
       where: {
-        organizationId: organization.id,
+        organizationId: organization.getDataValue("id"),
       },
     });
   });
@@ -48,4 +48,4 @@ async function init() {
   return true;
 }
 
-module.exports = { Project, Organization, Permission, init, Setting };
+export { Project, Organization, Permission, init, Setting };

package/src/platform.ts

@@ -0,0 +1,55 @@
+import * as authorization from "./authorization";
+import * as error from "./error";
+import { Application } from "express";
+import { Sequelize } from "sequelize-typescript";
+import { Config } from "./config";
+import { DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb";
+import type { Logger } from "pino";
+
+let _express: Application;
+let _postgres: { sequelize: Sequelize };
+let _dynamodb: { docClient: DynamoDBDocumentClient };
+let _logger: Logger | Console;
+
+async function init(config: Partial<Config> = {}): Promise<void> {
+  const configModule = await import("./config.ts");
+  const { postgres, dynamodb, logger } = configModule.init(config as Config);
+
+  const expressModule = await import("./express.ts");
+  _express = (expressModule as any).default as Application;
+
+  if (logger) {
+    const loggerModule = await import("./logger.ts");
+    _logger = (loggerModule as any).default;
+  } else {
+    _logger = console;
+  }
+
+  if (postgres) {
+    const postgresModule = await import("./postgres.ts");
+    _postgres = { sequelize: postgresModule.sequelize };
+  }
+
+  if (dynamodb) {
+    const dynamodbModule = await import("./dynamodb.ts");
+    _dynamodb = { docClient: dynamodbModule.docClient };
+  }
+}
+
+const getModules = () => ({
+  Postgres: _postgres,
+  DynamoDB: _dynamodb,
+  Kafka: {},
+});
+
+const importModule = (pkg: string) => import(pkg);
+
+export {
+  init,
+  _express as express,
+  getModules,
+  importModule,
+  authorization,
+  error,
+  _logger as logger,
+};

package/src/postgres.ts

@@ -0,0 +1,309 @@
+import { Model, Sequelize } from "sequelize-typescript";
+import config from "./config";
+import path from "path";
+import fs from "fs";
+import { DBMetrics } from "./metrics/dbMetrics";
+import { DestroyOptions, InstanceDestroyOptions } from "sequelize";
+
+const appConfig = config();
+
+const { postgres, project } = appConfig;
+
+const metricsConfig = appConfig.metrics;
+
+if (!postgres) {
+  throw new Error("Postgres configuration is required");
+}
+
+let dbMetrics: DBMetrics | null = null;
+
+if (metricsConfig && metricsConfig.enabled) {
+  dbMetrics = new DBMetrics();
+  dbMetrics.startPushgateway(metricsConfig);
+}
+
+interface SequelizeOptions {
+  metricsTimer?: () => number;
+  metricsType?: string;
+}
+
+const originalDestroy = Model.prototype.destroy;
+Model.prototype.destroy = async function (
+  options?: InstanceDestroyOptions
+): Promise<void> {
+  return originalDestroy.call(this, {
+    ...options,
+    individualHooks: true,
+  }) as Promise<void>;
+};
+
+const sequelize = new Sequelize(process.env.PG || postgres.uri, {
+  logging: postgres.debug && console.log,
+  models: [
+    path.join(__dirname, "models/*.model.ts"),
+    path.join(process.cwd(), "src/models/[A-Z]*.ts"),
+  ],
+  define: {
+    freezeTableName: true,
+    underscored: true,
+    timestamps: false,
+    paranoid: false,
+  },
+  hooks:
+    metricsConfig && metricsConfig.enabled
+      ? {
+          beforeFind: (options = {}) => {
+            const timer = dbMetrics!.dbReadLatency.startTimer();
+            (options as SequelizeOptions).metricsTimer = timer;
+            (options as SequelizeOptions).metricsType = "read";
+          },
+          afterFind: (_result, options = {}) => {
+            const opts = options as SequelizeOptions;
+            if (opts?.metricsTimer) {
+              opts.metricsTimer();
+              dbMetrics!.dbReadOps.inc();
+            }
+          },
+
+          beforeCreate: (_instance, options = {}) => {
+            const timer = dbMetrics!.dbWriteLatency.startTimer();
+            (options as SequelizeOptions).metricsTimer = timer;
+            (options as SequelizeOptions).metricsType = "write";
+          },
+          afterCreate: (_instance, options = {}) => {
+            const opts = options as SequelizeOptions;
+            if (opts?.metricsTimer) {
+              opts.metricsTimer();
+              dbMetrics!.dbWriteOps.inc();
+            }
+          },
+
+          beforeUpdate: (_instance, options = {}) => {
+            const timer = dbMetrics!.dbWriteLatency.startTimer();
+            (options as SequelizeOptions).metricsTimer = timer;
+            (options as SequelizeOptions).metricsType = "write";
+          },
+          afterUpdate: (_instance, options = {}) => {
+            const opts = options as SequelizeOptions;
+            if (opts?.metricsTimer) {
+              opts.metricsTimer();
+              dbMetrics!.dbWriteOps.inc();
+            }
+          },
+
+          beforeDestroy: (_instance, options = {}) => {
+            const timer = dbMetrics!.dbWriteLatency.startTimer();
+            (options as SequelizeOptions).metricsTimer = timer;
+            (options as SequelizeOptions).metricsType = "write";
+          },
+          afterDestroy: (_instance, options = {}) => {
+            const opts = options as SequelizeOptions;
+            if (opts?.metricsTimer) {
+              opts.metricsTimer();
+              dbMetrics!.dbWriteOps.inc();
+            }
+          },
+
+          beforeBulkCreate: (_instances, options = {}) => {
+            const timer = dbMetrics!.dbWriteLatency.startTimer();
+            (options as SequelizeOptions).metricsTimer = timer;
+            (options as SequelizeOptions).metricsType = "write";
+          },
+          afterBulkCreate: (instances, options = {}) => {
+            const opts = options as SequelizeOptions;
+            if (opts?.metricsTimer) {
+              opts.metricsTimer();
+              dbMetrics!.dbWriteOps.inc(instances.length || 1);
+            }
+          },
+
+          beforeBulkUpdate: (_instances, options = {}) => {
+            const timer = dbMetrics!.dbWriteLatency.startTimer();
+            (options as SequelizeOptions).metricsTimer = timer;
+            (options as SequelizeOptions).metricsType = "write";
+          },
+          afterBulkUpdate: (_instances, options = {}) => {
+            const opts = options as SequelizeOptions;
+            if (opts?.metricsTimer) {
+              opts.metricsTimer();
+              dbMetrics!.dbWriteOps.inc(1);
+            }
+          },
+
+          beforeBulkDestroy: (options = {}) => {
+            const timer = dbMetrics!.dbWriteLatency.startTimer();
+            (options as SequelizeOptions).metricsTimer = timer;
+            (options as SequelizeOptions).metricsType = "write";
+          },
+          afterBulkDestroy: (options = {}) => {
+            const opts = options as SequelizeOptions;
+            if (opts?.metricsTimer) {
+              opts.metricsTimer();
+              dbMetrics!.dbWriteOps.inc(1);
+            }
+          },
+        }
+      : {},
+});
+
+const seed = async (): Promise<void> => {
+  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;
+  }
+
+  try {
+    if (project) {
+      const { seed: companiesSeed } = require("./seeds/Organization.json");
+
+      sequelize.models.Organization.bulkCreate(companiesSeed, {
+        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"];
+        sequelize.models.Organization.bulkCreate(seed, {
+          validate: true,
+        });
+        console.log(`[NUC] Loading seed data for Organization`);
+      }
+
+      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`);
+      }
+
+      sequelize.models.Project.bulkCreate(projectSeed, {
+        validate: true,
+      });
+    }
+    const fileNames = fs.readdirSync(baseDir).filter((fileName) => {
+      return !["index.ts"].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) as { sequence: number; fileName: string }[];
+
+    fileSequences.sort((a, b) => a.sequence - b.sequence);
+
+    for (const { fileName } of fileSequences) {
+      const seedName = fileName.split(".")[0];
+      const seederPath = path.join(seedDir, `${seedName}.json`);
+
+      try {
+        const seedData = require(seederPath);
+        const seed = seedData["seed"];
+
+        console.log(`[NUC] Loading seed data for ${fileName}`);
+
+        await sequelize.model(seedName).bulkCreate(seed, {
+          validate: true,
+        });
+      } catch (error) {
+        console.error(`[NUC] Error loading seed data for ${fileName}:`, error);
+        throw error;
+      }
+    }
+
+    if (project) {
+      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`);
+      }
+
+      sequelize.models.Permission.bulkCreate(permissionsSeed, {
+        validate: true,
+      });
+
+      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`);
+      }
+
+      sequelize.models.Settings.bulkCreate(settingsSeed, {
+        validate: true,
+      });
+    }
+  } catch (error) {
+    console.error("[NUC] Error during seed operation:", error);
+    throw error;
+  }
+};
+
+const associateModels = async (): Promise<void> => {
+  const models = await import("./models");
+  await models.init();
+};
+
+if (postgres.sync) {
+  setImmediate(async () => {
+    project && (await associateModels());
+    await sequelize.sync({ force: true });
+    await seed();
+  });
+}
+
+export { sequelize };

package/src/routes/index.ts

@@ -0,0 +1,8 @@
+import metrics from "./metrics";
+import permissions from "./permissions";
+import oauth from "./oauth";
+import organizations from "./organizations";
+import projects from "./projects";
+import settings from "./settings";
+
+export { metrics, permissions, oauth, organizations, projects, settings };

package/src/routes/metrics.ts

@@ -0,0 +1,13 @@
+import express, { Request, Response } from "express";
+import os from "os";
+
+const router = express.Router();
+
+router.get("/", (_req: Request, res: Response) => {
+  res.json({
+    free: os.freemem(),
+    total: os.totalmem(),
+  });
+});
+
+export default router;