DDL operation

.sequelizerc

@@ -1,8 +1,9 @@
-const path = require('path');
+const path = require("path");
 require('dotenv').config();
+require("ts-node/register");
 
 module.exports = {
-  "config": path.resolve(__dirname, "src/config/sequelize.config.js"),
+  config: path.resolve(__dirname, "src/config/sequelize.config.js"),
   "models-path": path.resolve(__dirname, "src/models"),
   "seeders-path": path.resolve(__dirname, "src/seeders"),
   "migrations-path": path.resolve(__dirname, "src/migrations"),

eslint.config.mjs

@@ -1,22 +1,29 @@
 import js from "@eslint/js";
 import tseslint from "@typescript-eslint/eslint-plugin";
 import tsparser from "@typescript-eslint/parser";
+import prettier from "eslint-plugin-prettier"; 
 
 export default [
   js.configs.recommended,
   {
+    files: ["src/**/*.ts"],
+    ignores: ["dist/**", "node_modules/**"],
     languageOptions: {
       parser: tsparser,
     },
     plugins: {
       "@typescript-eslint": tseslint,
+      prettier,
     },
     rules: {
+      "prettier/prettier": "error", 
+      "@typescript-eslint/no-explicit-any": "off",
       "@typescript-eslint/no-var-requires": "off",
+      "no-undef": "off",
     },
   },
   {
-    files: ["src/migrations/*.js", "src/config/sequelize.config.js"],
+    files: ["src/config/sequelize.config.js"],
     languageOptions: {
       sourceType: "commonjs",
     },

package.json

@@ -7,7 +7,7 @@
     "dev": "nodemon --exec ts-node src/index.ts",
     "build": "tsc",
     "start": "node dist/index.js",
-    "migrate": "sequelize-cli db:migrate --config=src/config/sequelize.config.js",
+    "migrate": "sequelize-cli db:migrate --config src/config/sequelize.config.js",
     "seed": "sequelize-cli db:seed:all",
     "prepare": "husky install",
     "lint": "eslint src",
@@ -30,7 +30,7 @@
     "@types/bcryptjs": "^2.4.6",
     "@types/express": "^5.0.0",
     "@types/jsonwebtoken": "^9.0.8",
-    "@types/node": "^22.13.1",
+    "@types/node": "^22.13.2",
     "@types/sequelize": "^4.28.20",
     "eslint": "^9.20.1",
     "eslint-config-prettier": "^10.0.1",

src/controllers/ddl-controller.ts

@@ -0,0 +1,66 @@
+import { Request, Response } from 'express';
+import { sequelize } from '../config/database';
+import { successResponse, errorResponse } from '../utils/response';
+import { Operations } from '../types/ddl';
+import {
+  CreateTable,
+  CreateColumn,
+  AlterTable,
+  AlterColumn,
+  DropColumn,
+  DropTable,
+} from '../operations/ddl';
+
+export const migrate = async (req: Request, res: Response) => {
+  const { operations }: { operations: Operations[] } = req.body;
+  if (!operations || !Array.isArray(operations))
+    return errorResponse(res, 'Invalid payload structure', 400);
+
+  const transaction = await sequelize.transaction();
+
+  try {
+    for (const { operation, resource, migration } of operations) {
+      const { name, table, column, from, to } = migration;
+
+      let finalColumnDefinition = {};
+      if (column && typeof column === 'object' && 'definition' in column) {
+        finalColumnDefinition = (column as any).definition;
+      }
+
+      switch (`${operation}-${resource}`) {
+        case 'Create-Table':
+          await CreateTable.execute(name!, migration!, transaction);
+          break;
+        case 'Create-Column':
+          await CreateColumn.execute(table!, migration!, transaction);
+          break;
+        case 'Alter-Table':
+          await AlterTable.execute(from!, to!, transaction);
+          break;
+        case 'Alter-Column':
+          await AlterColumn.execute(
+            table!,
+            from!,
+            to!,
+            finalColumnDefinition,
+            transaction,
+          );
+          break;
+        case 'Drop-Column':
+          await DropColumn.execute(table!, column!, transaction);
+          break;
+        case 'Drop-Table':
+          await DropTable.execute(name!, transaction);
+          break;
+        default:
+          throw new Error(`Unsupported operation: ${operation} on ${resource}`);
+      }
+    }
+
+    await transaction.commit();
+    return successResponse(res, {}, 'DDL operations completed successfully');
+  } catch (error: any) {
+    await transaction.rollback();
+    return errorResponse(res, error.message, 500);
+  }
+};

src/controllers/user-controller.ts

@@ -14,15 +14,15 @@ export const registerUser = async (req: Request, res: Response) => {
       return errorResponse(res, 'Name, email, and password are required', 400);
     }
 
-    const existingUser = await UserRepository.findByEmail(email);
+    const existingUser = await UserRepository.findOne({ email });
     if (existingUser) {
       return errorResponse(res, 'Email is already registered', 400);
     }
 
     const hashedPassword = await hashPassword(password);
     const apiKey = await generateApiKey();
 
-    const newUser = await UserRepository.createUser({
+    const newUser = await UserRepository.insert({
       name,
       email,
       password: hashedPassword,
@@ -44,7 +44,7 @@ export const loginUser = async (req: Request, res: Response) => {
   try {
     const { email, password } = req.body;
 
-    const user = await UserRepository.findByEmail(email);
+    const user = await UserRepository.findOne({ email });
     if (!user) {
       return errorResponse(res, 'Unauthorized', 401);
     }
@@ -79,7 +79,7 @@ export const getUserDetails = async (req: Request, res: Response) => {
     }
 
     const decoded: any = jwt.verify(token, ENV.JWT_SECRET);
-    const user = await UserRepository.findById(decoded.userId);
+    const user = await UserRepository.findOne({ id: decoded.userId });
 
     if (!user) {
       return errorResponse(res, 'Unauthorized', 401);

src/index.ts

@@ -2,6 +2,17 @@ import express, { Request, Response } from 'express';
 import dotenv from 'dotenv';
 import userRoutes from './routes/user-routes';
 import authRoutes from './routes/auth-routes';
+import ddlRoutes from './routes/ddl-routes';
+import { sequelize } from './config/database';
+
+sequelize
+  .sync({ force: true })
+  .then(async () => {
+    console.log('Database synchronized successfully.');
+  })
+  .catch((err) => {
+    console.error('Failed to synchronize database:', err);
+  });
 
 dotenv.config();
 
@@ -14,6 +25,7 @@ const apiRouter = express.Router();
 
 apiRouter.use('/auth', authRoutes);
 apiRouter.use('/users', userRoutes);
+apiRouter.use('/migrate', ddlRoutes);
 
 app.use('/api', apiRouter);
 

src/middlewares/auth-middleware.ts

@@ -18,6 +18,7 @@ export const authMiddleware = (
     (req as any).user = decoded;
     next();
   } catch (error) {
+    console.error('Error:', error);
     return errorResponse(res, 'Unauthorized', 401);
   }
 };

src/migrations/20250206065327-create-user.ts

@@ -0,0 +1,51 @@
+import { QueryInterface, DataTypes, Sequelize } from 'sequelize';
+
+/** @type {import('sequelize-cli').Migration} */
+export default {
+  async up(queryInterface: QueryInterface, sequelize: Sequelize) {
+    await queryInterface.sequelize.query(
+      'CREATE EXTENSION IF NOT EXISTS "uuid-ossp";',
+    );
+
+    await queryInterface.createTable('users', {
+      id: {
+        allowNull: false,
+        primaryKey: true,
+        type: DataTypes.UUID,
+        defaultValue: sequelize.literal('uuid_generate_v4()'),
+      },
+      name: {
+        type: DataTypes.STRING,
+        allowNull: false,
+      },
+      email: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        unique: true,
+      },
+      password: {
+        type: DataTypes.STRING,
+        allowNull: false,
+      },
+      apikey: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        unique: true,
+      },
+      created_at: {
+        allowNull: false,
+        type: DataTypes.DATE,
+        defaultValue: sequelize.literal('CURRENT_TIMESTAMP'),
+      },
+      updated_at: {
+        allowNull: false,
+        type: DataTypes.DATE,
+        defaultValue: sequelize.literal('CURRENT_TIMESTAMP'),
+      },
+    });
+  },
+
+  async down(queryInterface: QueryInterface) {
+    await queryInterface.dropTable('users');
+  },
+};

src/models/metadata-column.ts

@@ -0,0 +1,76 @@
+import { Model, DataTypes } from 'sequelize';
+import { sequelize } from '../config/database';
+import MetadataTable from './metadata-table';
+
+class MetadataColumn extends Model {
+  public id!: string;
+  public table_id!: string;
+  public column_name!: string;
+  public data_type!: string;
+  public is_primary!: boolean;
+  public is_nullable!: boolean;
+  public is_unique!: boolean;
+  public readonly createdAt!: Date;
+  public readonly updatedAt!: Date;
+}
+
+MetadataColumn.init(
+  {
+    id: {
+      type: DataTypes.UUID,
+      defaultValue: DataTypes.UUIDV4,
+      primaryKey: true,
+    },
+    table_id: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: MetadataTable,
+        key: 'id',
+      },
+      onDelete: 'CASCADE',
+    },
+    column_name: {
+      type: DataTypes.STRING,
+      allowNull: false,
+    },
+    data_type: {
+      type: DataTypes.STRING,
+      allowNull: false,
+    },
+    is_primary: {
+      type: DataTypes.BOOLEAN,
+      defaultValue: false,
+    },
+    is_nullable: {
+      type: DataTypes.BOOLEAN,
+      defaultValue: true,
+    },
+    is_unique: {
+      type: DataTypes.BOOLEAN,
+      defaultValue: false,
+    },
+    created_at: {
+      type: DataTypes.DATE,
+      defaultValue: DataTypes.NOW,
+    },
+    updated_at: {
+      type: DataTypes.DATE,
+      defaultValue: DataTypes.NOW,
+    },
+  },
+  {
+    sequelize,
+    modelName: 'MetadataColumn',
+    tableName: 'metadata_column',
+    timestamps: true,
+    underscored: true,
+  },
+);
+
+MetadataColumn.belongsTo(MetadataTable, {
+  foreignKey: 'table_id',
+  onDelete: 'CASCADE',
+});
+
+export default MetadataColumn;