@trafficgroup/knex-rel 0.0.1

package/.env

@@ -0,0 +1,5 @@
+PG_DB=trafficgroup
+PG_USER=postgres
+PG_PASSWORD=DGp$I%9xb42s$A
+PG_HOST=trafficgroup-db.c2j4keo04gcg.us-east-1.rds.amazonaws.com
+PG_PORT=5432

package/knexfile.ts

@@ -0,0 +1,63 @@
+import type { Knex } from "knex";
+require("dotenv").config();
+
+const config: { [key: string]: Knex.Config } = {
+  development: {
+    client: "postgresql",
+    connection: {
+      database: process.env.PG_DB,
+      user: process.env.PG_USER,
+      password: process.env.PG_PASSWORD,
+      host: process.env.PG_HOST,
+      port: !!process.env.PG_PORT ? +process.env.PG_PORT : 54323,
+      ssl: { rejectUnauthorized: false },
+    },
+    pool: {
+      min: 2,
+      max: 10,
+    },
+    migrations: {
+      tableName: "knex_migrations",
+    },
+  },
+
+  staging: {
+    client: "postgresql",
+    connection: {
+      database: process.env.PG_DB,
+      user: process.env.PG_USER,
+      password: process.env.PG_PASSWORD,
+      host: process.env.PG_HOST,
+      port: !!process.env.PG_PORT ? +process.env.PG_PORT : 54323,
+      ssl: { rejectUnauthorized: false },
+    },
+    pool: {
+      min: 2,
+      max: 10,
+    },
+    migrations: {
+      tableName: "knex_migrations",
+    },
+  },
+
+  production: {
+    client: "postgresql",
+    connection: {
+      database: process.env.PG_DB,
+      user: process.env.PG_USER,
+      password: process.env.PG_PASSWORD,
+      host: process.env.PG_HOST,
+      port: !!process.env.PG_PORT ? +process.env.PG_PORT : 54323,
+      ssl: { rejectUnauthorized: false },
+    },
+    pool: {
+      min: 2,
+      max: 10,
+    },
+    migrations: {
+      tableName: "knex_migrations",
+    },
+  },
+};
+
+module.exports = config;

package/migrations/20250717160737_migration.ts

@@ -0,0 +1,15 @@
+import type { Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.createTable("user", (table) => {
+    table.increments("id").primary();
+    table.string("email").notNullable().unique();
+    table.string("nombre").notNullable();
+    table.enu("role", ["ADMIN", "USER"]).notNullable().defaultTo("USER");
+    table.timestamps(true, true); // created_at, updated_at
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.dropTableIfExists("user");
+}

package/migrations/20250717160908_migration.ts

@@ -0,0 +1,24 @@
+import type { Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.createTable("study", (table) => {
+    table.increments("id").primary();
+    table.string("name").notNullable();
+
+    table
+      .integer("createdBy")
+      .unsigned()
+      .notNullable()
+      .references("id")
+      .inTable("user")
+      .onDelete("CASCADE");
+
+    table.enu("status", ["COMPLETE", "IN PROGRESS", "FAILED"]).notNullable().defaultTo("IN PROGRESS");
+
+    table.timestamps(true, true); // created_at, updated_at
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.dropTableIfExists("study");
+}

package/migrations/20250717161310_migration.ts

@@ -0,0 +1,35 @@
+import type { Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.createTable("folders", (table) => {
+    table.increments("id").primary();
+    table.string("name").notNullable();
+
+    table
+      .integer("createdBy")
+      .unsigned()
+      .notNullable()
+      .references("id")
+      .inTable("user")
+      .onDelete("CASCADE");
+
+    table
+      .enu("status", ["UPLOADING", "COMPLETE"])
+      .notNullable()
+      .defaultTo("UPLOADING");
+
+    table
+      .integer("studyId")
+      .unsigned()
+      .notNullable()
+      .references("id")
+      .inTable("study")
+      .onDelete("CASCADE");
+
+    table.timestamps(true, true);
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.dropTableIfExists("folders");
+}

package/migrations/20250717161406_migration.ts

@@ -0,0 +1,36 @@
+import type { Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.schema.createTable("video", (table) => {
+    table.increments("id").primary();
+
+    table
+      .integer("folderId")
+      .unsigned()
+      .notNullable()
+      .references("id")
+      .inTable("folders")
+      .onDelete("CASCADE");
+
+    table.string("videoLocation").notNullable();
+    table.float("videoRate").notNullable(); // FPS
+
+    table
+      .enu("videoType", ["TMC", "ATR", "JUNCTION", "ROUNDABOUT", "PATHWAY"])
+      .notNullable();
+
+    table.jsonb("metadata").defaultTo('{}');
+    table
+      .enu("status", ["QUEUED", "PROCESSING", "COMPLETED", "FAILED"])
+      .notNullable()
+      .defaultTo("QUEUE");
+
+    table.jsonb("results").defaultTo('{}');
+
+    table.timestamps(true, true);
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.dropTableIfExists("video");
+}

package/migrations/20250717162431_migration.ts

@@ -0,0 +1,59 @@
+import type { Knex } from "knex";
+
+export async function up(knex: Knex): Promise<void> {
+  await knex.raw(`CREATE EXTENSION IF NOT EXISTS "uuid-ossp"`);
+
+  // === USER ===
+  await knex.schema.alterTable("user", (table) => {
+    table.uuid("uuid").defaultTo(knex.raw("uuid_generate_v4()"));
+  });
+  await knex("user").update({ uuid: knex.raw("uuid_generate_v4()") });
+  await knex.schema.alterTable("user", (table) => {
+    table.uuid("uuid").notNullable().unique().alter();
+  });
+
+  // === STUDY ===
+  await knex.schema.alterTable("study", (table) => {
+    table.uuid("uuid").defaultTo(knex.raw("uuid_generate_v4()"));
+  });
+  await knex("study").update({ uuid: knex.raw("uuid_generate_v4()") });
+  await knex.schema.alterTable("study", (table) => {
+    table.uuid("uuid").notNullable().unique().alter();
+  });
+
+  // === FOLDERS ===
+  await knex.schema.alterTable("folders", (table) => {
+    table.uuid("uuid").defaultTo(knex.raw("uuid_generate_v4()"));
+  });
+  await knex("folders").update({ uuid: knex.raw("uuid_generate_v4()") });
+  await knex.schema.alterTable("folders", (table) => {
+    table.uuid("uuid").notNullable().unique().alter();
+  });
+
+  // === VIDEO ===
+  await knex.schema.alterTable("video", (table) => {
+    table.uuid("uuid").defaultTo(knex.raw("uuid_generate_v4()"));
+  });
+  await knex("video").update({ uuid: knex.raw("uuid_generate_v4()") });
+  await knex.schema.alterTable("video", (table) => {
+    table.uuid("uuid").notNullable().unique().alter();
+  });
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.alterTable("video", (table) => {
+    table.dropColumn("uuid");
+  });
+
+  await knex.schema.alterTable("folders", (table) => {
+    table.dropColumn("uuid");
+  });
+
+  await knex.schema.alterTable("study", (table) => {
+    table.dropColumn("uuid");
+  });
+
+  await knex.schema.alterTable("user", (table) => {
+    table.dropColumn("uuid");
+  });
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@trafficgroup/knex-rel",
+  "version": "0.0.1",
+  "description": "Knex Module",
+  "main": "dist/index.js",
+  "scripts": {
+    "test": "jest",
+    "format": "prettier --write .",
+    "build": "tsc",
+    "clean": "rimraf dist && npm run format && npm run build",
+    "npm:publish": "npm run clean && npm publish",
+    "migrate:create": "knex migrate:make migration -x ts",
+    "migrate:deploy": "knex migrate:latest",
+    "seed:create": "knex seed:make seed -x ts",
+    "seed:run": "knex seed:run"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tms-world/knex-module.git"
+  },
+  "author": "Genium, Inc",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/tms-world/knex-module/issues"
+  },
+  "homepage": "https://github.com/tms-world/knex-module#readme",
+  "devDependencies": {
+    "@eslint/js": "^9.23.0",
+    "@types/dotenv": "^6.1.1",
+    "@types/lodash": "^4.17.16",
+    "@types/node": "^22.13.13",
+    "eslint": "^9.23.0",
+    "globals": "^16.0.0",
+    "prettier": "^3.5.3",
+    "rimraf": "^6.0.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.2",
+    "typescript-eslint": "^8.28.0"
+  },
+  "dependencies": {
+    "dotenv": "^16.4.7",
+    "knex": "^3.1.0",
+    "lodash": "^4.17.21",
+    "pg": "^8.14.1",
+    "uuid": "^11.1.0"
+  }
+}

package/src/KnexConnection.ts

@@ -0,0 +1,95 @@
+import { knex, Knex } from "knex";
+
+class KnexManager {
+  private static knexInstance: Knex<any, unknown[]> | null = null;
+
+  /**
+   * Open a new connection. Reuse the already existing one if there's any.
+   */
+  static async connect(
+    config?: Knex.Config,
+    connections?: number,
+  ): Promise<Knex<any, unknown[]>> {
+    if (!KnexManager.knexInstance) {
+      const testConfig = {
+        client: "pg",
+        connection: {
+          host: process.env.SQL_HOST,
+          user: process.env.SQL_USER,
+          password: process.env.SQL_PASSWORD,
+          database: process.env.SQL_DB_NAME,
+          charset: "utf8mb4",
+          port: Number(process.env.SQL_PORT) || 5432,
+          ssl: { rejectUnauthorized: false },
+        },
+        pool: {
+          min: 1,
+          max: connections || 15,
+          idleTimeoutMillis: 20000,
+          acquireTimeoutMillis: 30000,
+        },
+        migrations: {
+          tableName: "knex_migrations",
+        },
+      };
+      KnexManager.knexInstance = knex(
+        config || {
+          client: "pg",
+          connection: {
+            host: process.env.SQL_HOST,
+            user: process.env.SQL_USER,
+            password: process.env.SQL_PASSWORD,
+            database: process.env.SQL_DB_NAME,
+            charset: "utf8mb4",
+            port: Number(process.env.SQL_PORT) || 5432,
+            ssl: { rejectUnauthorized: false },
+          },
+          pool: {
+            min: 1,
+            max: connections || 15,
+            idleTimeoutMillis: 20000,
+            acquireTimeoutMillis: 30000,
+          },
+          migrations: {
+            tableName: "knex_migrations",
+          },
+        },
+      );
+      try {
+        await KnexManager.knexInstance.raw("SELECT 1");
+        console.info(`Knex connection established`);
+      } catch (error) {
+        console.error(`Failed to establish Knex connection:`, error);
+        KnexManager.knexInstance = null;
+        throw error;
+      }
+    }
+
+    return KnexManager.knexInstance;
+  }
+
+  /**
+   * Devuelve la conexión activa.
+   */
+  static getConnection(): Knex<any, unknown[]> {
+    if (!KnexManager.knexInstance) {
+      throw new Error(
+        "Knex connection has not been established. Call connect() first.",
+      );
+    }
+    return KnexManager.knexInstance;
+  }
+
+  /**
+   * Cierra la conexión y destruye la instancia.
+   */
+  static async disconnect(): Promise<void> {
+    if (KnexManager.knexInstance) {
+      await KnexManager.knexInstance.destroy();
+      KnexManager.knexInstance = null;
+      console.info(`Knex connection closed`);
+    }
+  }
+}
+
+export default KnexManager;

package/src/d.types.ts

@@ -0,0 +1,18 @@
+export interface IDataPaginator<T> {
+    success: boolean;
+    data: T[];
+    page: number;
+    limit: number;
+    count: number;
+    totalCount: number;
+    totalPages: number;
+}   
+
+export interface IBaseDAO<T> {
+  create(item: T): Promise<T>;
+  getById(id: number): Promise<T | null>;
+  getByUuid(uuid: string): Promise<T | null>;
+  getAll(): Promise<IDataPaginator<T>>;
+  update(id: number, item: T): Promise<T | null>;
+  delete(id: number): Promise<boolean>;
+}

package/src/dao/user/user.dao.ts

@@ -0,0 +1,53 @@
+import { Knex } from "knex";
+import { IBaseDAO, IDataPaginator } from "../../d.types";
+import { IUser } from "../../interfaces/user/user.interfaces";
+import KnexManager from "../../KnexConnection";
+
+export class UserDAO implements IBaseDAO<IUser> {
+    private _knex: Knex<any, unknown[]> = KnexManager.getConnection();
+
+    async create(item: IUser): Promise<IUser> {
+        const [createdUser] = await this._knex("user").insert(item).returning("*");
+        return createdUser;
+    }
+
+    async getById(id: number): Promise<IUser | null> {
+        const user = await this._knex("user").where({ id }).first();
+        return user || null;
+    }
+
+    async getByUuid(uuid: string): Promise<IUser | null> {
+        const user = await this._knex("user").where({ uuid }).first();
+        return user || null;
+    }
+
+    async update(id: number, item: Partial<IUser>): Promise<IUser | null> {
+        const [updatedUser] = await this._knex("user").where({ id }).update(item).returning("*");
+        return updatedUser || null;
+    }
+
+    async delete(id: number): Promise<boolean> {
+        const result = await this._knex("user").where({ id }).del();
+        return result > 0;
+    }
+
+    async getAll(): Promise<IDataPaginator<IUser>> {
+        const page = 1; // Default to first page
+        const limit = 10; // Default limit
+        const offset = (page - 1) * limit;
+
+        const [countResult] = await this._knex("user").count("* as count");
+        const totalCount = +countResult.count;
+        const users = await this._knex("user").limit(limit).offset(offset);
+
+        return {
+            success: true,
+            data: users,
+            page,
+            limit,
+            count: users.length,
+            totalCount,
+            totalPages: Math.ceil(totalCount / limit),
+        };
+    }
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+// DAOs
+export { UserDAO } from "./dao/user/user.dao";
+
+// Interfaces
+export { IUser } from "./interfaces/user/user.interfaces";
+
+import KnexManager from "./KnexConnection";
+export { KnexManager };

package/src/interfaces/folder/folder.interfaces.ts

@@ -0,0 +1,10 @@
+export interface IFolder {
+  id: number;
+  uuid: string;
+  name: string;
+  createdBy: number; // user.id
+  status: 'UPLOADING' | 'COMPLETE';
+  studyId: number; // study.id
+  created_at: string;
+  updated_at: string;
+}

package/src/interfaces/study/study.interfaces.ts

@@ -0,0 +1,9 @@
+export interface IStudy {
+  id: number;
+  uuid: string;
+  name: string;
+  createdBy: number;
+  status: 'COMPLETE' | 'IN PROGRESS' | 'FAILED';
+  created_at: string;
+  updated_at: string;
+}

package/src/interfaces/user/user.interfaces.ts

@@ -0,0 +1,9 @@
+export interface IUser {
+    id: number;
+    uuid: string;
+    email: string;
+    nombre: string;
+    role: 'ADMIN' | 'USER';
+    created_at: string;
+    updated_at: string;
+}

package/src/interfaces/video/video.interfaces.ts

@@ -0,0 +1,13 @@
+export interface IVideo {
+    id: number;
+    uuid: string;
+    folderId: number;
+    videoLocation: string;
+    videoRate: number;
+    videoType: 'TMC' | 'ATR' | 'JUNCTION' | 'ROUNDABOUT' | 'PATHWAY';
+    metadata: Record<string, any>;
+    status: 'QUEUE' | 'PROCESSING' | 'COMPLETED' | 'FAILED';
+    results: Record<string, any>;
+    created_at: string;
+    updated_at: string;
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "module": "CommonJS",
+    "target": "es2016",
+    "sourceMap": true,
+    "esModuleInterop": true,
+    "noImplicitAny": true,
+    "declaration": true,
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules"]
+}