@flutry/sequelize 0.0.1

package/README.md

@@ -0,0 +1,26 @@
+# @flutry/sequelize
+
+![npm version](https://img.shields.io/npm/v/@flutry/sequelize)
+
+A fully customizable sequelize integration for Flutry projects, with automatic model loading, database connection, and support for advanced features like associations and hooks.
+
+## 🔧 Features
+
+- 🔌 Automatically connects to the database using Flutry configuration.
+- 📦 Dynamically loads all sequelize models from the `models/` directory.
+- 🛠️ Built-in support for model synchronization.
+- 🔁 Integrates smoothly with the Flutry dynamic adapters system.
+- 🔍 Enhanced error handling and logging for development.
+
+## Access Database Type
+
+- mysql
+- mariadb
+
+## 📄 Licenc
+
+MIT
+
+## 🌐 Website
+
+The official website of the package: [https://flutry.com/docs/package/sequelize](https://flutry.com/docs/package/sequelize)

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { Flutry_Sequelize } from './main';
+export { Model, DataTypes, Sequelize } from 'sequelize';
+export { FlutryDatabase } from './utils/databaseWrap';

package/dist/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlutryDatabase = exports.Sequelize = exports.DataTypes = exports.Model = exports.Flutry_Sequelize = void 0;
+//!EXPORTS
+var main_1 = require("./main");
+Object.defineProperty(exports, "Flutry_Sequelize", { enumerable: true, get: function () { return main_1.Flutry_Sequelize; } });
+var sequelize_1 = require("sequelize");
+Object.defineProperty(exports, "Model", { enumerable: true, get: function () { return sequelize_1.Model; } });
+Object.defineProperty(exports, "DataTypes", { enumerable: true, get: function () { return sequelize_1.DataTypes; } });
+Object.defineProperty(exports, "Sequelize", { enumerable: true, get: function () { return sequelize_1.Sequelize; } });
+var databaseWrap_1 = require("./utils/databaseWrap");
+Object.defineProperty(exports, "FlutryDatabase", { enumerable: true, get: function () { return databaseWrap_1.FlutryDatabase; } });

package/dist/main.d.ts

@@ -0,0 +1,5 @@
+import 'dotenv/config';
+export declare class Flutry_Sequelize {
+    static logger: any;
+    constructor(logger: any);
+}

package/dist/main.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Flutry_Sequelize = void 0;
+require("dotenv/config");
+const connect_1 = require("./utils/connect");
+class Flutry_Sequelize {
+    constructor(logger) {
+        Flutry_Sequelize.logger = logger;
+        new connect_1.Flutry_Connect();
+    }
+}
+exports.Flutry_Sequelize = Flutry_Sequelize;

package/dist/models/models.d.ts

@@ -0,0 +1,8 @@
+export declare class Flutry_Models {
+    private readonly functions;
+    private models;
+    constructor();
+    private init;
+    private initModels;
+    private loadModel;
+}

package/dist/models/models.js

@@ -0,0 +1,101 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Flutry_Models = void 0;
+const main_1 = require("../main");
+const connect_1 = require("../utils/connect");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const function_1 = require("../utils/function");
+class Flutry_Models {
+    constructor() {
+        this.functions = new function_1.Functions();
+        this.models = {};
+        this.init = async () => {
+            await this.initModels(path_1.default.join(process.cwd(), `${(await this.functions.isDevelompent()) ? 'src/models' : 'dist/models'}`), '');
+            // Asszociációk beállítása
+            for (const modelName of Object.keys(this.models)) {
+                const model = this.models[modelName];
+                if (typeof model.associate === 'function') {
+                    model.associate(this.models);
+                }
+            }
+            try {
+                await connect_1.Flutry_Connect.sequelize.sync({ alter: true });
+                main_1.Flutry_Sequelize.logger.info('All models were synchronized successfully.');
+            }
+            catch (error) {
+                main_1.Flutry_Sequelize.logger.error('Unable to synchronize models:', error);
+            }
+        };
+        this.initModels = async (dir, basePath) => {
+            if (connect_1.Flutry_Connect.sequelize) {
+                const files = await fs_1.default.readdirSync(dir);
+                for (const file of files) {
+                    const filePath = path_1.default.join(dir, file);
+                    const stat = await fs_1.default.statSync(filePath);
+                    if (stat.isDirectory()) {
+                        await this.initModels(filePath, path_1.default.join(basePath, file));
+                    }
+                    else if (file.endsWith('.model.ts') || file.endsWith('.model.js')) {
+                        await this.loadModel(filePath);
+                    }
+                }
+            }
+        };
+        this.loadModel = async (filePath) => {
+            try {
+                const module = await Promise.resolve(`${filePath}`).then(s => __importStar(require(s)));
+                const ModelClass = module.default;
+                if (ModelClass && typeof ModelClass.initialize === 'function') {
+                    ModelClass.initialize(connect_1.Flutry_Connect.sequelize);
+                    // Model neve pl. a class neve vagy fájlnév alapján
+                    this.models[ModelClass.name] = ModelClass;
+                }
+                else {
+                    main_1.Flutry_Sequelize.logger.warn(`Model at ${filePath} does not have an initialize method.`);
+                }
+            }
+            catch (error) {
+                main_1.Flutry_Sequelize.logger.error(`Failed to load model at ${filePath}`, error);
+            }
+        };
+        this.init();
+    }
+}
+exports.Flutry_Models = Flutry_Models;

package/dist/utils/connect.d.ts

@@ -0,0 +1,8 @@
+import { Sequelize } from 'sequelize';
+export declare class Flutry_Connect {
+    static sequelize: Sequelize;
+    private readonly functions;
+    constructor();
+    private init;
+    private connect;
+}

package/dist/utils/connect.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Flutry_Connect = void 0;
+const sequelize_1 = require("sequelize");
+const main_1 = require("../main");
+const function_1 = require("./function");
+const models_1 = require("../models/models");
+class Flutry_Connect {
+    constructor() {
+        this.functions = new function_1.Functions();
+        this.init = async () => {
+            if (await this.functions.DBConfigVerify()) {
+                this.connect();
+            }
+        };
+        this.connect = async () => {
+            Flutry_Connect.sequelize = new sequelize_1.Sequelize(`${process.env.DB_NAME}`, `${process.env.DB_USER}`, `${process.env.DB_PASS}`, {
+                host: `${process.env.DB_HOST}`,
+                dialect: `${process.env.DB_TYPE}`,
+                logging: false,
+                timezone: await await this.functions.getTimeZone(),
+            });
+            try {
+                await Flutry_Connect.sequelize.authenticate();
+                //Flutry_Sequelize.logger.info('Connection has been established successfully'); //! This line commented for now
+                await new models_1.Flutry_Models();
+            }
+            catch (error) {
+                main_1.Flutry_Sequelize.logger.error('Unebale to connect to the database');
+            }
+        };
+        this.init();
+    }
+}
+exports.Flutry_Connect = Flutry_Connect;

package/dist/utils/databaseWrap.d.ts

@@ -0,0 +1,9 @@
+import { Model, ModelStatic, FindOptions, CreateOptions, UpdateOptions, DestroyOptions, Utils } from 'sequelize';
+export declare class FlutryDatabase {
+    static findAll<T extends Model>(model: ModelStatic<T>, options?: FindOptions): Promise<object[]>;
+    static findOne<T extends Model>(model: ModelStatic<T>, options?: FindOptions): Promise<object | null>;
+    static create<T extends Model>(model: ModelStatic<T>, values: Utils.MakeNullishOptional<T['_creationAttributes']>, options?: CreateOptions<T['_creationAttributes']>): Promise<object>;
+    static update<T extends Model>(model: ModelStatic<T>, values: Partial<T['_creationAttributes']>, options: UpdateOptions<T['_creationAttributes']>): Promise<object[]>;
+    static destroy<T extends Model>(model: ModelStatic<T>, options: DestroyOptions<T['_creationAttributes']>): Promise<number>;
+    static count<T extends Model>(model: ModelStatic<T>, options?: FindOptions): Promise<number>;
+}

package/dist/utils/databaseWrap.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlutryDatabase = void 0;
+class FlutryDatabase {
+    static async findAll(model, options) {
+        const results = await model.findAll(options);
+        return results.map((row) => row.get({ plain: true }));
+    }
+    static async findOne(model, options) {
+        const result = await model.findOne(options);
+        return result ? result.get({ plain: true }) : null;
+    }
+    static async create(model, values, options) {
+        const result = await model.create(values, options);
+        return result.get({ plain: true });
+    }
+    static async update(model, values, options) {
+        const result = await model.update(values, { ...options, returning: true });
+        if (Array.isArray(result)) {
+            const [count, updatedRows] = result;
+            if (Array.isArray(updatedRows)) {
+                return updatedRows.map((row) => row.get({ plain: true }));
+            }
+        }
+        return [];
+    }
+    static async destroy(model, options) {
+        return await model.destroy(options);
+    }
+    static async count(model, options) {
+        return await model.count(options);
+    }
+}
+exports.FlutryDatabase = FlutryDatabase;

package/dist/utils/function.d.ts

@@ -0,0 +1,5 @@
+export declare class Functions {
+    DBConfigVerify: () => Promise<boolean>;
+    getTimeZone: () => Promise<string>;
+    isDevelompent: () => Promise<boolean>;
+}

package/dist/utils/function.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Functions = void 0;
+const main_1 = require("../main");
+class Functions {
+    constructor() {
+        this.DBConfigVerify = async () => {
+            const requiredEnvVars = ['DB_NAME', 'DB_USER', 'DB_PASS', 'DB_HOST', 'DB_TYPE'];
+            const missingVars = requiredEnvVars.filter((key) => !process.env[key]);
+            if (missingVars.length > 0) {
+                missingVars.forEach((key) => {
+                    main_1.Flutry_Sequelize.logger.error(`${key} is not defined`);
+                });
+                process.exit(1);
+            }
+            const validDbTypes = ['mysql', 'mariadb'];
+            if (!validDbTypes.includes(process.env.DB_TYPE)) {
+                main_1.Flutry_Sequelize.logger.error(`DB_TYPE must be one of: ${validDbTypes.join(', ')}`);
+                process.exit(1);
+            }
+            return true;
+        };
+        this.getTimeZone = async () => {
+            const date = new Date();
+            const offsetMinutes = date.getTimezoneOffset();
+            const sign = offsetMinutes > 0 ? '-' : '+';
+            const offsetHours = String(Math.abs(Math.floor(offsetMinutes / 60))).padStart(2, '0');
+            const offsetMinutesFormatted = String(Math.abs(offsetMinutes % 60)).padStart(2, '0');
+            const offset = `${sign}${offsetHours}:${offsetMinutesFormatted}`;
+            return offset;
+        };
+        this.isDevelompent = async () => {
+            if (process.env.NODE_ENV !== 'production') {
+                return true;
+            }
+            else {
+                return false;
+            }
+        };
+    }
+}
+exports.Functions = Functions;

package/dist/utils/models.d.ts

@@ -0,0 +1,5 @@
+export declare class Flutry_Models {
+    private models;
+    constructor();
+    private initmodels;
+}

package/dist/utils/models.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Flutry_Models = void 0;
+const sequelize_1 = require("sequelize");
+const connect_1 = require("./connect");
+class Flutry_Models {
+    constructor() {
+        this.models = [];
+        this.initmodels = async () => {
+            if (connect_1.Flutry_Connect.sequelize) {
+                connect_1.Flutry_Connect.sequelize.define('User', {
+                    id: {
+                        type: sequelize_1.DataTypes.INTEGER,
+                        primaryKey: true,
+                        autoIncrement: true,
+                        allowNull: false,
+                    },
+                    emailId: {
+                        type: sequelize_1.DataTypes.STRING,
+                        unique: true,
+                        allowNull: false,
+                    },
+                    age: {
+                        type: sequelize_1.DataTypes.INTEGER,
+                        allowNull: false,
+                    },
+                });
+                connect_1.Flutry_Connect.sequelize.sync();
+            }
+        };
+        this.initmodels();
+    }
+}
+exports.Flutry_Models = Flutry_Models;

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@flutry/sequelize",
+  "version": "0.0.1",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "dotenv": "^16.5.0",
+    "mariadb": "^3.4.2",
+    "mysql2": "^3.14.1",
+    "sequelize": "^6.37.7"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  }
+}