fiberx-backend-toolkit 0.0.14 → 0.0.16

package/dist/code_templates/sequelize_code_template.d.ts

@@ -0,0 +1,8 @@
+import { SchemaColumnInterface, SchemaDiffInterface } from "../types/schema_type";
+declare const SEQUELIZE_SCHEMA_CODE_TEMPLATE: (schema_name: string, table_name: string, model_name: string, migration_priority: number) => string;
+declare const SEQUELIZE_CREATE_NEW_SCHEMA_MIGRATION_FILE_CODE_TEMPLATE: (schema_table_name: string, schema_model_name: string, schema_file_name: string) => string;
+declare const SEQUELIZE_UPDATE_EXISTING_SCHEMA_MIGRATION_FILE_CODE_TEMPLATE: (schema_table_name: string, schema_model_name: string, diff: SchemaDiffInterface, schema_file_name: string) => string;
+declare const SEQUELIZE_SEEDER_TEMPLATE: (class_name: string, table_name: string) => string;
+declare const SEQUELIZE_MODEL_CODE_TEMPLATE: (schema_model_name: string, schema_file_name: string, schema_columns: Record<string, SchemaColumnInterface>) => string;
+declare const SEQUELIZE_MODELS_INDEX_CODE_TEMPLATE: (model_names: string[], imports: string) => string;
+export { SEQUELIZE_SCHEMA_CODE_TEMPLATE, SEQUELIZE_SEEDER_TEMPLATE, SEQUELIZE_CREATE_NEW_SCHEMA_MIGRATION_FILE_CODE_TEMPLATE, SEQUELIZE_UPDATE_EXISTING_SCHEMA_MIGRATION_FILE_CODE_TEMPLATE, SEQUELIZE_MODEL_CODE_TEMPLATE, SEQUELIZE_MODELS_INDEX_CODE_TEMPLATE };

package/dist/code_templates/sequelize_code_template.js

@@ -0,0 +1,382 @@
+const SEQUELIZE_SCHEMA_CODE_TEMPLATE = (schema_name, table_name, model_name, migration_priority) => {
+    return `
+import { DataTypes } from "sequelize";
+import { SchemaDefinitionInterface } from "fiberx-backend-toolkit/types/schema_type";
+
+const ${schema_name}: SchemaDefinitionInterface = {
+    database_name: "public",
+    migration_priority: ${migration_priority},
+
+    table_name: "${table_name}",
+    model_name: "${model_name}",
+    timestamps:true,
+
+    columns: {
+        id: {
+            type: DataTypes.BIGINT,
+            primaryKey: true,
+            autoIncrement: true,
+            allowNull: false,
+        },
+
+        created_at: {
+            type: DataTypes.DATE,
+            defaultValue: DataTypes.NOW,
+        },
+
+        updated_at: {
+            type: DataTypes.DATE,
+            allowNull: true,
+            defaultValue: null,
+        },
+    },
+
+    indexes: [
+        { fields: [""], name: "" },
+    ],
+};
+
+export default ${schema_name};
+`;
+};
+const SEQUELIZE_CREATE_NEW_SCHEMA_MIGRATION_FILE_CODE_TEMPLATE = (schema_table_name, schema_model_name, schema_file_name) => `
+import { QueryInterface, DataTypes, Sequelize } from "sequelize";
+import { LoggerUtil } from "fiberx-backend-toolkit//utils";
+import { SchemaDefinitionInterface } from "fiberx-backend-toolkit/types/schema_type";
+import ${schema_model_name}Schema from "@/database/schemas/${schema_file_name.replace(".ts", "")}";
+
+class Create${schema_model_name}TableMigration {
+    private name: string = "create_table_${schema_table_name}_migration_file";
+    private schema: SchemaDefinitionInterface = ${schema_model_name}Schema;
+    private readonly logger: LoggerUtil = new LoggerUtil(this.name);
+
+    constructor() {}
+
+    // Migration UP
+    public async up(
+        queryInterface: QueryInterface, 
+        Sequelize: typeof import("sequelize")
+    ) {
+        try {
+            const { table_name, columns = {}, indexes = [] } = this.schema;
+
+            await queryInterface.createTable(table_name, columns);
+
+            for (const index_field_obj of indexes) {
+
+                const { fields, name, index_options } = index_field_obj;
+                const index_name = \`idx_\${table_name}_\${fields.join("_")}\`
+            
+                await queryInterface.addIndex(
+                    table_name, 
+                    fields, 
+                    { name: index_name, ...index_options }
+                );
+            }
+
+            this.logger.success(\`✅ Table "\${table_name}" for schema "\${model_name}Schema" created with "\${this.index_attributes.length}" indexed Fields.\`);
+        } 
+        catch (error: any) {
+            this.logger.error(\`🚫 Migration failed: "\${error.message}"\`, { error });
+            throw new Error(\`🚫 Migration failed: "\${error.message}"\`);
+        }
+    }
+
+    // Migration DOWN
+    public async down(
+        queryInterface: QueryInterface, 
+        Sequelize: typeof import("sequelize")
+    ) {
+        try {
+            const { table_name, database_name, model_name } = this.schema;
+            await queryInterface.dropTable(table_name, {});
+            this.logger.success(\`🗑️ Table "\${table_name}" dropped successfully.\`);
+        } catch (error: any) {
+            this.logger.error(\`🚫 Migration rollback failed: "\${error.message}"\`, { error });
+            throw new Error(\`🚫 Migration rollback failed: "\${error.message}"\`);
+        }
+    }
+}
+
+export default Create${schema_model_name}TableMigration;
+`;
+const SEQUELIZE_UPDATE_EXISTING_SCHEMA_MIGRATION_FILE_CODE_TEMPLATE = (schema_table_name, schema_model_name, diff, schema_file_name) => `
+import { QueryInterface, DataTypes, Sequelize } from "sequelize";
+import { LoggerUtil } from "fiberx-backend-toolkit//utils";
+import { SchemaDefinitionInterface } from "fiberx-backend-toolkit/types/schema_type";
+import ${schema_model_name}Schema from "@/database/schemas/${schema_file_name.replace(".ts", "")}";
+
+class Update${schema_model_name}TableMigration {
+    private name: string = "update_table_${schema_table_name}_migration_file";
+    private schema: SchemaDefinitionInterface = ${schema_model_name}Schema;
+    private readonly logger: LoggerUtil = new LoggerUtil(this.name);
+
+    constructor() {}
+
+    public async up(
+        queryInterface: QueryInterface, 
+        Sequelize: typeof import("sequelize")
+    ) {
+        try {
+            const { table_name, model_name, columns = {}, indexes = [] } = this.schema;
+
+        ${diff.table_renamed ? `
+            await queryInterface.renameTable(
+                "${diff.table_renamed.from}",
+                "${diff.table_renamed.to}"
+            );`
+    :
+        ""}
+
+        // Add columns
+        ${diff.columns.added.map((column_name) => `
+            await queryInterface.addColumn(
+                table_name,
+                "${column_name}",
+                columns["${column_name}"]
+            );
+        `).join("")}
+
+        // Modify columns
+        ${Object.entries(diff.columns.modified).map(([col_name, col_modified]) => `
+            await queryInterface.changeColumn(
+                table_name, 
+                "${col_name}", 
+                ${JSON.stringify(col_modified?.after)}
+            );
+            `).join("")}
+
+        // Remove columns
+        ${Object.entries(diff.columns.modified).map(([col_name, col_Def]) => `
+            await queryInterface.removeColumn(
+                table_name, 
+                "${col_name}"
+            );
+            `).join("")}
+
+
+        // Add indexes
+        ${diff.indexes.added.map((idx) => `
+            await queryInterface.addIndex(
+                table_name, 
+                ${JSON.stringify(idx.fields)}, 
+                ${JSON.stringify(idx)}
+            );
+            `).join("")}
+
+        // Modify indexes (remove + add)
+        ${Object.entries(diff.indexes.modified).map(([idx_name, idx_modified]) => `
+            await queryInterface.removeIndex(
+                table_name, 
+                ${JSON.stringify(idx_modified.before.name)}
+            );
+
+            await queryInterface.addIndex(
+                table_name, 
+                ${JSON.stringify(idx_modified.after.fields)}, 
+                ${JSON.stringify(idx_modified.after)}
+            );
+            `).join("")}
+
+        // Remove indexes
+        ${diff.indexes.removed.map((idx) => `
+            await queryInterface.removeIndex(
+                table_name, 
+                ${JSON.stringify(idx.name)}
+            );
+            `).join("")}
+
+
+            this.logger.success(\`✅ Table "\${table_name}" for schema "\${model_name}Schema" updated successfully.\`);
+        } 
+        catch (error: any) {
+            this.logger.error(\`🚫 Update migration failed: "\${error.message}"\`, { error });
+            throw new Error(\`🚫 Update migration failed: "\${error.message}"\`);
+        }
+    }
+
+    public async down(
+        queryInterface: QueryInterface, 
+        Sequelize: typeof import("sequelize")
+    ) {
+        try {
+            const { table_name, model_name, columns = {} } = this.schema;
+
+        // Revert Added indexes
+        ${diff.indexes.added.map((idx) => `
+            await queryInterface.removeIndex(
+                table_name, 
+                ${JSON.stringify(idx.name)}
+            );`).join("")}
+
+        // Revert Modified Indexes
+        ${Object.entries(diff.indexes.modified).map(([idx_name, idx_modified]) => `
+            await queryInterface.removeIndex(
+                table_name, 
+                ${JSON.stringify(idx_modified.after.name)}
+            );
+
+
+            await queryInterface.addIndex(
+                table_name, 
+                ${JSON.stringify(idx_modified.before.fields)}, 
+                ${JSON.stringify(idx_modified.before)}
+            );`).join("")}
+
+        // Revert removed indexes
+        ${diff.indexes.removed.map((idx) => `
+            await queryInterface.addIndex(
+                table_name, 
+                ${JSON.stringify(idx.fields)}, 
+                ${JSON.stringify(idx)}
+            );`).join("")}
+
+        // Revert Modified columns
+        ${Object.entries(diff.columns.modified).map(([col_name, col_modified]) => `
+            await queryInterface.changeColumn(
+                table_name, 
+                "${col_name}", 
+                ${JSON.stringify(col_modified.before)}
+            );`).join("")}
+
+        // Revert added columns
+        ${diff.columns.added.map((column_name) => `
+            await queryInterface.removeColumn(table_name, "${column_name}");
+        `).join("")}
+
+        ${Object.entries(diff.columns.modified).map(([col_name, col_Def]) => `
+            await queryInterface.addColumn(
+                table_name, 
+                "${col_name}", 
+                ${JSON.stringify(col_Def)}
+            );
+        `).join("")}
+
+        ${diff.table_renamed ? `
+            await queryInterface.renameTable(
+                "${diff.table_renamed.to}",
+                "${diff.table_renamed.from}"
+            );` : ""}
+
+            this.logger.success(\`🗑️ Rollback of table "\${table_name}" completed successfully.\`);
+        } 
+        catch (error: any) {
+            this.logger.error(\`🚫 Rollback migration failed: "\${error.message}"\`, { error });
+            throw new Error(\`🚫 Rollback migration failed: "\${error.message}"\`);
+        }
+    }
+}
+
+export default Update${schema_model_name}TableMigration;
+`;
+const SEQUELIZE_SEEDER_TEMPLATE = (class_name, table_name) => `
+'use strict';
+
+import { QueryInterface } from 'sequelize';
+
+class ${class_name}Seeder {
+	/**
+	 * Seed method
+	 */
+	public async up(queryInterface: QueryInterface): Promise<void> {
+        const seed_data = this.getSeedData();
+
+		if (!seed_data || seed_data.length === 0) {
+			throw new Error("❌ Seeder data for 'roles' is empty. Aborting bulk insert.");
+		}
+
+		await queryInterface.bulkInsert('${table_name.toLowerCase()}', seed_data);
+	}
+
+	/**
+	 * Undo seed method
+	 */
+	public async down(queryInterface: QueryInterface): Promise<void> {
+        const seed_data = this.getSeedData();
+
+		if (!seed_data || seed_data.length === 0) {
+			throw new Error("❌ Seeder data for 'roles' is empty. Nothing to delete.");
+		}
+
+		const ids = seed_data.map(row => row.id);
+
+		await queryInterface.bulkDelete('${table_name.toLowerCase()}', { id: ids });
+	}
+
+	/**
+	 * Provide seed data array
+	 */
+	private getSeedData(): Array<Record<string, any>> {
+		// TODO: Replace this with real seed data
+		return [];
+	}
+}
+
+export default  ${class_name}Seeder;
+`;
+const SEQUELIZE_MODEL_CODE_TEMPLATE = (schema_model_name, schema_file_name, schema_columns) => {
+    const attributes = Object.keys(schema_columns)
+        .map(col => `    declare ${col}: any;`)
+        .join("\n");
+    return `
+import { Model, Sequelize } from "sequelize";
+import ${schema_model_name}Schema from "@/database/schemas/${schema_file_name.replace(".ts", "")}";
+
+
+class ${schema_model_name} extends Model {
+${attributes}
+
+    public static initModel(sequelize: Sequelize): typeof ${schema_model_name} {
+        sequelize: Sequelize
+    ): ${schema_model_name}  {
+        ${schema_model_name}.init(
+            ${schema_model_name}Schema.columns,
+            {
+                sequelize,
+                tableName: ${schema_model_name}Schema.table_name,
+                modelName: ${schema_model_name}Schema.model_name,
+                timestamps: ${schema_model_name}Schema.timestamps,
+                indexes: ${schema_model_name}Schema.indexes,
+                createdAt: "created_at",
+                updatedAt: "updated_at",
+                hooks: {}
+            }
+        );
+        return ${schema_model_name};
+    } 
+
+    public static registerAssociations(): void {
+        // Example:
+        // User.belongsTo(models.Organization, { foreignKey: "org_id" });
+    }
+}
+
+export default ${schema_model_name}
+`;
+};
+const SEQUELIZE_MODELS_INDEX_CODE_TEMPLATE = (model_names, imports) => {
+    const exports = model_names.join(",\n    ");
+    return `
+import { Sequelize } from "sequelize";
+${imports}
+
+const models = {
+    ${exports}
+};
+
+export const initModels = (sequelize: Sequelize) => {
+    Object.values(models).forEach(model => {
+        model.initModel(sequelize);
+    });
+
+    Object.values(models).forEach(model => {
+        model.registerAssociations();
+    });
+
+    return models;
+};
+
+export default models;
+`;
+};
+export { SEQUELIZE_SCHEMA_CODE_TEMPLATE, SEQUELIZE_SEEDER_TEMPLATE, SEQUELIZE_CREATE_NEW_SCHEMA_MIGRATION_FILE_CODE_TEMPLATE, SEQUELIZE_UPDATE_EXISTING_SCHEMA_MIGRATION_FILE_CODE_TEMPLATE, SEQUELIZE_MODEL_CODE_TEMPLATE, SEQUELIZE_MODELS_INDEX_CODE_TEMPLATE };

package/dist/config/constants.d.ts

@@ -0,0 +1,20 @@
+export declare const BASE_DIR: string;
+export declare const LOG_DIR: string;
+export declare const ENV_VAR_DIR: string;
+export declare const SCHEMAS_DIR: string;
+export declare const SCHEMA_SNAPSHOTS_DIR: string;
+export declare const MODELS_DIR: string;
+export declare const MIGRATIONS_DIR: string;
+export declare const SEEDERS_DIR: string;
+export declare const SEQUELIZE_META_TABLE_NAME = "sequelize_database_tables_meta";
+export declare const SEQUELIZE_SEEDER_META_TABLE_NAME = "sequelize_database_table_seeder_meta";
+export declare const REQUEST_ID_COOKIE_MAX_AGE: number;
+export declare const CORS_ALLOWED_METHODS: string[];
+export declare const CORS_ALLOWED_HEADERS: string[];
+export declare const CORS_MAX_AGE_IN_SECONDS = 600;
+export declare const CORS_MAX_AGE_IN_MICRO_SECONDS: number;
+export declare const REQUEST_RATE_LIMITTER_OPTIONS: {
+    window_ms: number;
+    max_requests: number;
+    message: string;
+};

package/dist/config/constants.js

@@ -0,0 +1,24 @@
+import path from "path";
+// Database constants
+export const BASE_DIR = process.cwd();
+export const LOG_DIR = path.join(BASE_DIR, "logs");
+export const ENV_VAR_DIR = path.join(BASE_DIR, "environment_varaiables");
+export const SCHEMAS_DIR = path.join(BASE_DIR, "src/database/schemas");
+export const SCHEMA_SNAPSHOTS_DIR = path.join(BASE_DIR, "src/database/schema_snapshots");
+export const MODELS_DIR = path.join(BASE_DIR, "src/database/models");
+export const MIGRATIONS_DIR = path.join(BASE_DIR, "src/database/migrations");
+export const SEEDERS_DIR = path.join(BASE_DIR, "src/database/seeders");
+export const SEQUELIZE_META_TABLE_NAME = "sequelize_database_tables_meta";
+export const SEQUELIZE_SEEDER_META_TABLE_NAME = "sequelize_database_table_seeder_meta";
+export const REQUEST_ID_COOKIE_MAX_AGE = (1000 * 60 * 60 * 24 * 7); // 7 days
+// CORS constants
+export const CORS_ALLOWED_METHODS = ["GET", "POST", "PATCH", "DELETE", "OPTIONS"];
+export const CORS_ALLOWED_HEADERS = ["Content-Type", "Authorization", "X-Device-Id", "X-Device-Name", "User-Agent"];
+export const CORS_MAX_AGE_IN_SECONDS = (600); // default: 10 min
+export const CORS_MAX_AGE_IN_MICRO_SECONDS = (1000 * 60 * 10); // 10 minutes
+// Rate limitter
+export const REQUEST_RATE_LIMITTER_OPTIONS = {
+    window_ms: (60 * 1000), // 1 MINS
+    max_requests: 50,
+    message: "⏳ Too many requests from this IP, please try again later"
+};

package/dist/database/connectors/base_connector.d.ts

@@ -0,0 +1,12 @@
+import { LoggerUtil, EnvManagerUtil } from "../../utils";
+/**
+ * Base connector abstraction for all DB / external service connectors
+ */
+declare abstract class BaseConnector<TConnection> {
+    protected readonly connector_name: string;
+    readonly env_manager: EnvManagerUtil;
+    readonly logger: LoggerUtil;
+    protected constructor(connector_name: string);
+    abstract connect(): TConnection;
+}
+export default BaseConnector;

package/dist/database/connectors/base_connector.js

@@ -0,0 +1,14 @@
+import { LoggerUtil, EnvManagerUtil } from "../../utils";
+/**
+ * Base connector abstraction for all DB / external service connectors
+ */
+class BaseConnector {
+    connector_name;
+    env_manager = EnvManagerUtil.getInstance();
+    logger;
+    constructor(connector_name) {
+        this.connector_name = connector_name;
+        this.logger = new LoggerUtil(connector_name);
+    }
+}
+export default BaseConnector;

package/dist/database/connectors/sequelize_connector.d.ts

@@ -0,0 +1,17 @@
+import { Sequelize } from "sequelize";
+import BaseConnector from "./base_connector";
+import { SequelizeConnectionOptions } from "../../types/database_type";
+declare class SequelizeConnector extends BaseConnector<Sequelize> {
+    private static instance;
+    private static connections;
+    private constructor();
+    static getInstance(): SequelizeConnector;
+    private formatSQLQueryLog;
+    connect(options?: SequelizeConnectionOptions): Sequelize;
+    connectNamed(name: string, options?: SequelizeConnectionOptions): Sequelize;
+    getConnection(name?: string): Sequelize | undefined;
+    hasConnection(name?: string): boolean;
+    closeConnection(name?: string): Promise<void>;
+    closeAll(): Promise<void>;
+}
+export default SequelizeConnector;

package/dist/database/connectors/sequelize_connector.js

@@ -0,0 +1,93 @@
+import { Sequelize } from "sequelize";
+import BaseConnector from "./base_connector";
+import SqlFormatterUtil from "../../utils/sql_formatter_util";
+class SequelizeConnector extends BaseConnector {
+    static instance;
+    static connections = new Map();
+    constructor() {
+        super("sequelize_connector");
+    }
+    static getInstance() {
+        if (!SequelizeConnector.instance) {
+            SequelizeConnector.instance = new SequelizeConnector();
+        }
+        return SequelizeConnector.instance;
+    }
+    // ----------------------------------
+    // SQL logging
+    // ----------------------------------
+    formatSQLQueryLog = (sql, timing) => {
+        try {
+            const formatted = SqlFormatterUtil.format(sql);
+            if (typeof timing === "number") {
+                this.logger.info(`[SQL ${timing}ms] ${formatted}`);
+            }
+            else {
+                this.logger.info(`[SQL] ${formatted}`);
+            }
+        }
+        catch (error) {
+            this.logger.error("Failed to log SQL query", { error });
+        }
+    };
+    // ----------------------------------
+    // Single default connection
+    // ----------------------------------
+    connect(options = {}) {
+        return this.connectNamed(options.name ?? "default", options);
+    }
+    // ----------------------------------
+    // Multiple named connections
+    // ----------------------------------
+    connectNamed(name, options = {}) {
+        if (SequelizeConnector.connections.has(name)) {
+            return SequelizeConnector.connections.get(name);
+        }
+        const dialect = options.dialect ?? this.env_manager.getEnvVar("DB_DIALECT", "postgres");
+        const logging_enabled = options.logging ?? this.env_manager.getEnvVar("DB_LOGGING", false);
+        const logging = logging_enabled ? this.formatSQLQueryLog : false;
+        const database = options.database ?? this.env_manager.getEnvVar("DB_NAME");
+        const username = options.username ?? this.env_manager.getEnvVar("DB_USER");
+        const password = options.password ?? this.env_manager.getEnvVar("DB_PASSWORD");
+        const host = options.host ?? this.env_manager.getEnvVar("DB_HOST");
+        const port = options.port ?? this.env_manager.getEnvVar("DB_PORT", 5432);
+        const sequelize = new Sequelize({
+            database,
+            username,
+            password,
+            host,
+            port,
+            dialect,
+            logging,
+            benchmark: logging_enabled,
+        });
+        SequelizeConnector.connections.set(name, sequelize);
+        this.logger.success(`✅ Sequelize connected [${name}]`);
+        return sequelize;
+    }
+    // ----------------------------------
+    // Utilities
+    // ----------------------------------
+    getConnection(name = "default") {
+        return SequelizeConnector.connections.get(name);
+    }
+    hasConnection(name = "default") {
+        return SequelizeConnector.connections.has(name);
+    }
+    async closeConnection(name = "default") {
+        const conn = SequelizeConnector.connections.get(name);
+        if (conn) {
+            await conn.close();
+            SequelizeConnector.connections.delete(name);
+            this.logger.info(`🔌 Sequelize connection closed [${name}]`);
+        }
+    }
+    async closeAll() {
+        for (const [name, conn] of SequelizeConnector.connections.entries()) {
+            await conn.close();
+            this.logger.info(`🔌 Sequelize connection closed [${name}]`);
+        }
+        SequelizeConnector.connections.clear();
+    }
+}
+export default SequelizeConnector;