vr-migrations 1.0.2

package/README.md

@@ -0,0 +1 @@
+

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+export declare const program: Command;

package/dist/cli.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.program = void 0;
+const commander_1 = require("commander");
+const migrate_1 = require("./migrate");
+const rollback_1 = require("./rollback");
+const seed_1 = require("./seed");
+const reset_1 = require("./reset");
+const create_migration_1 = require("./create-migration");
+const create_seeder_1 = require("./create-seeder");
+const db_1 = require("./db");
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+exports.program = new commander_1.Command();
+exports.program
+    .name("vr-migrate") //
+    .description("CENTRALIZED VR Migration Tool") //
+    .version("1.0.0")
+    .hook("preAction", async () => {
+    const sequelize = await (0, db_1.initializeDatabase)({
+        DB_HOST: process.env.DB_HOST,
+        DB_PORT: parseInt(process.env.DB_PORT || "5432"),
+        DB_USER: process.env.DB_USER,
+        DB_PASSWORD: process.env.DB_PASSWORD,
+        DB_NAME: process.env.DB_NAME,
+        NODE_ENV: process.env.NODE_ENV,
+    });
+    await sequelize.authenticate();
+});
+// Centralized Commands (No path overrides allowed)
+exports.program
+    .command("migrate")
+    .description("Run CENTRALIZED migrations from vr-migrations package") //
+    .action(async () => await (0, migrate_1.migrate)());
+exports.program
+    .command("rollback")
+    .description("Rollback CENTRALIZED migrations")
+    .option("--all", "Rollback all migrations")
+    .action(async (options) => await (0, rollback_1.rollback)(options.all ? "all" : 1));
+exports.program
+    .command("seed")
+    .description("Run CENTRALIZED seeders")
+    .action(async () => await (0, seed_1.seed)());
+exports.program
+    .command("reset")
+    .description("Reset database (DANGER!)")
+    .action(async () => await (0, reset_1.reset)());
+exports.program
+    .command("create:migration <name>")
+    .description("Create new migration in vr-migrations package") //
+    .action((name) => (0, create_migration_1.createMigration)(name));
+exports.program
+    .command("create:seeder <name>")
+    .description("Create new seeder in vr-migrations package") //
+    .action((name) => (0, create_seeder_1.createSeeder)(name));
+exports.program.parse(process.argv);

package/dist/create-migration.d.ts

@@ -0,0 +1 @@
+export declare function createMigration(name: string): void;

package/dist/create-migration.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMigration = createMigration;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// const migrationsDir = path.join(__dirname, "../migrations");
+const migrationsDir = path_1.default.join(__dirname, "migrations");
+const template = `module.exports = {
+  async up(queryInterface, Sequelize) {
+    // Migration code here
+  },
+  async down(queryInterface) {
+    // Rollback code here
+  }
+};`;
+function createMigration(name) {
+    const timestamp = new Date().toISOString().replace(/\D/g, "").slice(0, 14);
+    const fileName = `${timestamp}-${name}.js`;
+    const filePath = path_1.default.join(migrationsDir, fileName);
+    fs_1.default.mkdirSync(migrationsDir, { recursive: true });
+    fs_1.default.writeFileSync(filePath, template);
+    console.log(`✅ Created migration: ${fileName}`);
+}

package/dist/create-seeder.d.ts

@@ -0,0 +1 @@
+export declare function createSeeder(name: string): void;

package/dist/create-seeder.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSeeder = createSeeder;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// const seedersDir = path.join(__dirname, "../seeders");
+const seedersDir = path_1.default.join(__dirname, "seeders");
+const template = `module.exports = {
+  async up(queryInterface, Sequelize) {
+    // Migration code here
+  },
+  async down(queryInterface) {
+    // Rollback code here
+  }
+};`;
+function createSeeder(name) {
+    const timestamp = new Date().toISOString().replace(/\D/g, "").slice(0, 14);
+    const fileName = `${timestamp}-${name}.js`;
+    const filePath = path_1.default.join(seedersDir, fileName);
+    fs_1.default.mkdirSync(seedersDir, { recursive: true });
+    fs_1.default.writeFileSync(filePath, template);
+    console.log(`✅ Created CENTRALIZED seeder: ${fileName}`);
+}

package/dist/db.d.ts

@@ -0,0 +1,12 @@
+import { Sequelize } from "sequelize";
+export declare function getSequelize(): Sequelize;
+export declare function initializeDatabase(config: {
+    DB_HOST: string;
+    DB_PORT: number;
+    DB_USER: string;
+    DB_PASSWORD: string;
+    DB_NAME: string;
+    NODE_ENV?: string;
+}): Promise<Sequelize>;
+export declare function closeDatabase(): Promise<void>;
+export { Model, InferAttributes, InferCreationAttributes, DataTypes, CreationOptional, ModelStatic, ModelAttributes, NonAttribute, Op, } from "sequelize";

package/dist/db.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Op = exports.DataTypes = exports.Model = void 0;
+exports.getSequelize = getSequelize;
+exports.initializeDatabase = initializeDatabase;
+exports.closeDatabase = closeDatabase;
+const sequelize_1 = require("sequelize");
+let _sequelize = null;
+let _isInitialized = false;
+function getSequelize() {
+    if (!_isInitialized) {
+        throw new Error("Database not initialized. Call initializeDatabase() first");
+    }
+    return _sequelize;
+}
+async function initializeDatabase(config) {
+    if (_isInitialized)
+        return _sequelize;
+    _sequelize = new sequelize_1.Sequelize({
+        dialect: "postgres",
+        host: config.DB_HOST,
+        port: config.DB_PORT,
+        username: config.DB_USER,
+        password: config.DB_PASSWORD,
+        database: config.DB_NAME,
+        logging: false,
+        pool: {
+            max: 20,
+            min: 2,
+            acquire: 120000,
+            idle: 10000,
+        },
+        dialectOptions: config.NODE_ENV === "production"
+            ? {
+                ssl: { require: true, rejectUnauthorized: false },
+            }
+            : {},
+    });
+    await _sequelize.authenticate();
+    _isInitialized = true;
+    return _sequelize;
+}
+async function closeDatabase() {
+    if (_sequelize) {
+        await _sequelize.close();
+        _sequelize = null;
+        _isInitialized = false;
+    }
+}
+// Export types for models
+var sequelize_2 = require("sequelize");
+Object.defineProperty(exports, "Model", { enumerable: true, get: function () { return sequelize_2.Model; } });
+Object.defineProperty(exports, "DataTypes", { enumerable: true, get: function () { return sequelize_2.DataTypes; } });
+Object.defineProperty(exports, "Op", { enumerable: true, get: function () { return sequelize_2.Op; } });

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./types";
+export * from "./db";
+export * from "./migrate";
+export * from "./rollback";
+export * from "./seed";
+export * from "./reset";
+export * from "./create-migration";
+export * from "./create-seeder";

package/dist/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Export types first
+__exportStar(require("./types"), exports);
+// Then export functionality
+__exportStar(require("./db"), exports);
+__exportStar(require("./migrate"), exports);
+__exportStar(require("./rollback"), exports);
+__exportStar(require("./seed"), exports);
+__exportStar(require("./reset"), exports);
+__exportStar(require("./create-migration"), exports);
+__exportStar(require("./create-seeder"), exports);
+// // CLI export
+// import { program } from "./cli";
+// export default program;

package/dist/migrate.d.ts

@@ -0,0 +1 @@
+export declare function migrate(): Promise<void>;

package/dist/migrate.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrate = migrate;
+const umzug_1 = require("umzug");
+const db_1 = require("./db");
+const sequelize_1 = require("sequelize");
+const path_1 = __importDefault(require("path"));
+// const migrationsPath = path.join(__dirname, "../migrations/[0-9]*-*.js");
+const migrationsPath = path_1.default.join(__dirname, "migrations/[0-9]*-*.js");
+async function migrate() {
+    console.log("looking for migrations at:", migrationsPath);
+    const sequelize = (0, db_1.getSequelize)();
+    const migrator = new umzug_1.Umzug({
+        migrations: {
+            glob: migrationsPath,
+            resolve: ({ name, path: filePath }) => ({
+                name,
+                up: async () => {
+                    const migration = require(filePath);
+                    return migration.up(sequelize.getQueryInterface(), sequelize_1.Sequelize);
+                },
+                down: async () => {
+                    const migration = require(filePath);
+                    return migration.down(sequelize.getQueryInterface());
+                },
+            }),
+        },
+        storage: new umzug_1.SequelizeStorage({ sequelize }),
+        logger: console,
+    });
+    await migrator.up();
+    console.log("✅ Migrations completed");
+}

package/dist/migrations/001-create-security-clearances.js

@@ -0,0 +1,62 @@
+"use strict";
+
+/** @type {import('sequelize-cli').Migration} */
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.createTable("security_clearances", {
+      id: {
+        type: Sequelize.UUID,
+        defaultValue: Sequelize.UUIDV4,
+        primaryKey: true,
+        allowNull: false
+      },
+      role: {
+        type: Sequelize.ENUM(
+          "RIDER",
+          "PASSENGER",
+          "ADMIN",
+          "AGENT",
+          "SUPER_ADMIN"
+        ),
+        allowNull: false,
+        unique: true
+      },
+      description: {
+        type: Sequelize.TEXT,
+        allowNull: true
+      },
+      level: {
+        type: Sequelize.INTEGER,
+        allowNull: false,
+        defaultValue: 0
+      },
+      permissions: {
+        type: Sequelize.ARRAY(Sequelize.STRING),
+        allowNull: false,
+        defaultValue: []
+      },
+      isDefault: {
+        type: Sequelize.BOOLEAN,
+        allowNull: false,
+        defaultValue: false
+      },
+      createdAt: {
+        type: Sequelize.DATE,
+        allowNull: false,
+        defaultValue: Sequelize.fn("NOW")
+      },
+      updatedAt: {
+        type: Sequelize.DATE,
+        allowNull: false,
+        defaultValue: Sequelize.fn("NOW")
+      }
+    });
+  },
+
+  async down(queryInterface) {
+    await queryInterface.dropTable("security_clearances");
+    await queryInterface.sequelize.query(
+      'DROP TYPE IF EXISTS "enum_security_clearances_role";'
+    );
+  }
+};

package/dist/migrations/002-create-users.js

@@ -0,0 +1,141 @@
+"use strict";
+
+/** @type {import('sequelize').Migration} */
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.createTable("users", {
+      id: {
+        type: Sequelize.UUID,
+        defaultValue: Sequelize.UUIDV4,
+        primaryKey: true,
+        allowNull: false
+      },
+
+      firstName: {
+        type: Sequelize.STRING(50),
+        allowNull: false
+      },
+      securityClearanceId: {
+        type: Sequelize.UUID,
+        allowNull: false,
+        references: {
+          model: "security_clearances",
+          key: "id"
+        }
+      },
+      lastName: {
+        type: Sequelize.STRING(50),
+        allowNull: false
+      },
+
+      phoneNumber: {
+        type: Sequelize.STRING(20),
+        allowNull: false,
+        unique: true
+      },
+      email: {
+        type: Sequelize.STRING(100),
+        allowNull: true,
+        unique: true
+      },
+      password: {
+        type: Sequelize.STRING,
+        allowNull: true
+      },
+      jacketId: {
+        type: Sequelize.STRING(50),
+        allowNull: true,
+        unique: true
+      },
+
+      nationalId: {
+        type: Sequelize.STRING(60),
+        allowNull: true,
+        unique: true
+      },
+
+      role: {
+        type: Sequelize.ENUM("RIDER", "ADMIN", "AGENT"),
+        allowNull: false,
+        defaultValue: "RIDER"
+      },
+
+      plateNumber: {
+        type: Sequelize.STRING(20),
+        allowNull: true
+      },
+      isActive: {
+        type: Sequelize.BOOLEAN,
+        allowNull: false,
+        defaultValue: true
+      },
+      tokenVersion: {
+        type: Sequelize.INTEGER,
+        allowNull: false,
+        defaultValue: 1
+      },
+      forgotPassword: {
+        type: Sequelize.BOOLEAN,
+        defaultValue: false
+      },
+      otp: {
+        type: Sequelize.STRING(6),
+        allowNull: true
+      },
+      otpExpiresAt: {
+        type: Sequelize.DATE,
+        allowNull: true
+      },
+      isSuspended: {
+        type: Sequelize.BOOLEAN,
+        allowNull: false,
+        defaultValue: false
+      },
+      bannedAt: {
+        type: Sequelize.DATE,
+        allowNull: true
+      },
+      banReason: {
+        type: Sequelize.TEXT,
+        allowNull: true
+      },
+      suspendedAt: {
+        type: Sequelize.DATE,
+        allowNull: true
+      },
+      suspensionReason: {
+        type: Sequelize.TEXT,
+        allowNull: true
+      },
+      lastLoginAt: {
+        type: Sequelize.DATE,
+        allowNull: true
+      },
+      isDeactivated: {
+        type: Sequelize.BOOLEAN,
+        defaultValue: false
+      },
+      deactivatedAt: {
+        type: Sequelize.DATE,
+        allowNull: true
+      },
+      createdAt: {
+        type: Sequelize.DATE,
+        allowNull: false,
+        defaultValue: Sequelize.fn("NOW")
+      }
+    });
+
+    // Optional: explicit indexes (Postgres already enforces uniques, but this is clarity)
+    await queryInterface.addIndex("users", ["phoneNumber"]);
+    await queryInterface.addIndex("users", ["jacketId"]);
+    await queryInterface.addIndex("users", ["nationalId"]);
+  },
+
+  async down(queryInterface) {
+    await queryInterface.dropTable("users");
+    await queryInterface.sequelize.query(
+      'DROP TYPE IF EXISTS "enum_users_role";'
+    );
+  }
+};

package/dist/migrations/003-create-products.js

@@ -0,0 +1,52 @@
+"use strict";
+
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.createTable("products", {
+      id: {
+        type: Sequelize.UUID,
+        defaultValue: Sequelize.UUIDV4,
+        primaryKey: true,
+        allowNull: false
+      },
+
+      name: {
+        type: Sequelize.STRING(100),
+        allowNull: false
+      },
+
+      description: {
+        type: Sequelize.TEXT,
+        allowNull: true
+      },
+
+      stock: {
+        type: Sequelize.INTEGER,
+        allowNull: false,
+        defaultValue: 0
+      },
+
+      isActive: {
+        type: Sequelize.BOOLEAN,
+        allowNull: false,
+        defaultValue: true
+      },
+
+      createdAt: {
+        type: Sequelize.DATE,
+        allowNull: false,
+        defaultValue: Sequelize.fn("NOW")
+      },
+
+      updatedAt: {
+        type: Sequelize.DATE,
+        allowNull: false,
+        defaultValue: Sequelize.fn("NOW")
+      }
+    });
+  },
+
+  async down(queryInterface) {
+    await queryInterface.dropTable("products");
+  }
+};

package/dist/migrations/004-create-pricing.js

@@ -0,0 +1,82 @@
+"use strict";
+
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.createTable("pricings", {
+      id: {
+        type: Sequelize.UUID,
+        defaultValue: Sequelize.UUIDV4,
+        primaryKey: true,
+        allowNull: false
+      },
+
+      productId: {
+        type: Sequelize.UUID,
+        allowNull: false,
+        references: {
+          model: "products",
+          key: "id"
+        },
+        onUpdate: "CASCADE",
+        onDelete: "CASCADE"
+      },
+
+      name: {
+        type: Sequelize.STRING(100),
+        allowNull: false
+      },
+
+      upfrontPrice: {
+        type: Sequelize.DECIMAL(10, 2),
+        allowNull: false
+      },
+
+      downPayment: {
+        type: Sequelize.DECIMAL(10, 2),
+        allowNull: false,
+        defaultValue: 0
+      },
+
+      installmentAmount: {
+        type: Sequelize.DECIMAL(10, 2),
+        allowNull: true
+      },
+
+      installmentIntervalDays: {
+        type: Sequelize.INTEGER,
+        allowNull: true
+      },
+
+      totalAmount: {
+        type: Sequelize.DECIMAL(10, 2),
+        allowNull: false
+      },
+
+      isActive: {
+        type: Sequelize.BOOLEAN,
+        allowNull: false,
+        defaultValue: true
+      },
+
+      createdAt: {
+        type: Sequelize.DATE,
+        allowNull: false,
+        defaultValue: Sequelize.fn("NOW")
+      },
+
+      updatedAt: {
+        type: Sequelize.DATE,
+        allowNull: false,
+        defaultValue: Sequelize.fn("NOW")
+      }
+    });
+
+    // Optional but recommended indexes
+    await queryInterface.addIndex("pricings", ["productId"]);
+    await queryInterface.addIndex("pricings", ["isActive"]);
+  },
+
+  async down(queryInterface) {
+    await queryInterface.dropTable("pricings");
+  }
+};

package/dist/migrations/005-create-devices.js

@@ -0,0 +1,63 @@
+"use strict";
+
+/** @type {import('sequelize').QueryInterface} */
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.createTable("devices", {
+      id: {
+        type: Sequelize.UUID,
+        defaultValue: Sequelize.UUIDV4,
+        primaryKey: true,
+        allowNull: false
+      },
+      serialNumber: {
+        type: Sequelize.STRING(64),
+        allowNull: false,
+        unique: true
+      },
+      productId: {
+        type: Sequelize.UUID,
+        allowNull: false,
+        references: {
+          model: "products",
+          key: "id"
+        },
+        onUpdate: "CASCADE",
+        onDelete: "RESTRICT"
+      },
+
+      status: {
+        type: Sequelize.ENUM("locked", "unlocked", "disabled"),
+        allowNull: false,
+        defaultValue: "locked"
+      },
+      isPermanentlyUnlocked: {
+        type: Sequelize.BOOLEAN,
+        allowNull: false,
+        defaultValue: false
+      },
+      activatedAt: {
+        type: Sequelize.DATE,
+        allowNull: true
+      },
+      createdAt: {
+        type: Sequelize.DATE,
+        allowNull: false,
+        defaultValue: Sequelize.fn("NOW")
+      },
+      updatedAt: {
+        type: Sequelize.DATE,
+        allowNull: false,
+        defaultValue: Sequelize.fn("NOW")
+      }
+    });
+  },
+
+  async down(queryInterface) {
+    await queryInterface.dropTable("devices");
+
+    await queryInterface.sequelize.query(
+      'DROP TYPE IF EXISTS "enum_devices_status"'
+    );
+  }
+};