@ecopex/ecopex-framework 1.0.0

package/routes/common/auto/languages.json

@@ -0,0 +1,26 @@
+{
+    "table": "languages",
+    "primary_key": "language_id",
+    "store": "languages",
+    "schema": {
+        "language_id": { "type": "integer", "example": 1 },
+        "code": { "type": "string", "default": "", "example": "en" },
+        "flag": { "type": "string", "default": "", "example": "🇬🇧" },
+        "name": { "type": "string", "default": "", "example": "English" }
+    },
+    "routes": [
+        {
+            "action": "list",
+            "method": "GET",
+            "path": "/languages",
+            "searchable_fields": ["code", "name", "flag"],
+            "pagination": true,
+            "additionalProperties": false
+        },
+        {
+            "action": "get",
+            "method": "GET",
+            "path": "/languages/:language_id"
+        }
+    ]
+}

package/routes/common/auto/taxes.json

@@ -0,0 +1,46 @@
+{
+    "table": "taxes",
+    "primary_key": "tax_id",
+    "schema": {
+        "tax_id": { "type": "integer", "example": 1 },
+        "name": { "type": "string", "search_type": "like", "creatable": true, "create_required": true, "updatable": true, "example": "VAT" },
+        "rate": { "type": "number", "minimum": 0, "maximum": 1, "creatable": true, "create_required": true, "updatable": true, "example": 0.18 }
+    },
+    "store": "taxes",
+    "routes": [
+        {
+            "action": "list",
+            "method": "GET",
+            "path": "/taxes",
+            "searchable_fields": ["name", "rate"],
+            "pagination": true,
+            "additionalProperties": false
+        },
+        {
+            "action": "get",
+            "method": "GET",
+            "path": "/taxes/:tax_id"
+        },
+        {
+            "action": "create",
+            "method": "POST",
+            "path": "/taxes",
+            "security": "auth",
+            "additionalProperties": false
+        },
+        {
+            "action": "update",
+            "method": "PUT",
+            "path": "/taxes/:tax_id",
+            "security": "auth",
+            "additionalProperties": false
+        },
+        {
+            "action": "delete",
+            "method": "DELETE",
+            "path": "/taxes/:tax_id",
+            "security": "auth",
+            "additionalProperties": false
+        }
+    ]
+}

package/routes/common/auto/timezones.json

@@ -0,0 +1,29 @@
+{
+    "table": "timezones",
+    "primary_key": "timezone_id",
+    "store": "timezones",
+    "schema": {
+        "timezone_id": { "type": "integer", "search_type": "equal", "example": 1 },
+        "name": { "type": "string", "default": "", "search_type": "like", "example": "UTC" },
+        "code": { "type": "string", "default": "", "search_type": "like", "example": "UTC+00:00" },
+        "offset": { "type": "string", "default": "", "search_type": "like", "example": "+00:00" },
+        "gmt": { "type": "string", "default": "", "search_type": "like", "example": "UTC" }
+    },
+    "routes": [
+        {
+            "action": "list",
+            "method": "GET",
+            "path": "/timezones",
+            "searchable_fields": ["name", "code", "offset", "gmt"],
+            "pagination": true,
+            "additionalProperties": false
+        },
+        {
+            "action": "get",
+            "method": "GET",
+            "path": "/timezones/:timezone_id",
+            "security": "auth",
+            "additionalProperties": false
+        }
+    ]
+}

package/stores/base.js

@@ -0,0 +1,73 @@
+const knex = require('@root/libraries/knex');
+
+module.exports = class StoreModel {
+    constructor(name = 'store_model', primary_key = 'id', schema = {}) {
+        this.name = name;
+        this.knex = knex;
+        this.data = new Map();
+        this.primary_key = primary_key;
+        this.schema = schema;
+        this.initialized = false;
+    }
+
+    async init() {
+        await this.get_data();
+        this.initialized = true;
+    }
+
+    async get_data() {
+        const data = await this.knex(this.name).select(Object.keys(this.schema));
+        data.forEach(item => {
+            this.data.set(item[this.primary_key], item);
+        });
+        return this.data;
+    }
+
+    async get_data_by_primary_key(primary_key) {
+        const data = this.data.get(primary_key);
+        if(!data) {
+            throw new Error('Data not found');
+        }
+        return data;
+    }
+
+    async create_data(data) {
+        const validated_data = this.validate_data(data);
+        const check_data = await this.knex(this.name).where(this.primary_key, validated_data[this.primary_key]).first();
+        if(check_data) {
+            throw new Error('Data already exists');
+        }
+        const [primary_key] = await this.knex(this.name).insert(validated_data);
+        const data_created = await this.knex(this.name).where(this.primary_key, primary_key).first();
+        this.data.set(primary_key, data_created);
+        return data_created;
+    }
+
+    async update_data(primary_key, data) {
+        const validated_data = this.validate_data(data);
+        const check_data = await this.knex(this.name).where(this.primary_key, primary_key).first();
+        if(!check_data) {
+            throw new Error('Data not found');
+        }
+        await this.knex(this.name).where(this.primary_key, primary_key).update(validated_data);
+        const updated_data = await this.knex(this.name).where(this.primary_key, primary_key).first();
+        this.data.set(primary_key, updated_data);
+        return updated_data;
+    }
+
+    async delete_data(primary_key) {
+        await this.knex(this.name).where(this.primary_key, primary_key).delete();
+        this.data.delete(primary_key);
+        return true;
+    }
+
+    validate_data(data) {
+        const validated_data = {};
+        for(const key in this.schema) {
+            if(data[key]) {
+                validated_data[key] = data[key];
+            }
+        }
+        return validated_data;
+    }
+}

package/stores/index.js

@@ -0,0 +1,195 @@
+const BaseStore = require('./base');
+
+const stores = {}
+
+const add_model = async (name, primary_key, schema) => {
+    if(stores[name]) {
+        return stores[name];
+    }
+    stores[name] = new BaseStore(name, primary_key, schema);
+    await stores[name].init();
+    return stores[name];
+}
+
+const get_all = (name, query, reply, routeOptions) => {
+
+    let { page = 1, limit = 10, search, order } = query;
+    const offset = (page - 1) * limit;
+
+    const store_model = stores[name] || false;
+    if(!store_model) {
+        return reply.status(404).send({
+            status: false,
+            message: 'Store not found'
+        });
+    }
+
+    let all_data = [...store_model.data.values()];
+
+    if(search) {
+        all_data = all_data.filter(item => {
+            return Object.values(item).some(value => value.toString().toLowerCase().includes(search.toLowerCase()));
+        });
+    }
+
+    if(order) {
+        const splitOrder = order.split(':');
+        const orderBy = splitOrder[0];
+        const orderDirection = splitOrder[1];
+        all_data = all_data.sort((a, b) => {
+            if(orderDirection === 'desc') {
+                return b[orderBy] - a[orderBy];
+            }
+            return a[orderBy] - b[orderBy];
+        });
+    }
+
+    const filters = routeOptions.filters || {};
+    if(Object.keys(filters).length > 0) {
+        all_data = all_data.filter(item => {
+            return Object.keys(filters).every(key => {
+                if(query[key] === undefined) {
+                    return true;
+                }
+                let filterStatus = true
+                if(filters[key].search_type === 'like') {
+                    filterStatus = item[key].toString().toLowerCase().includes(query[key].toString().toLowerCase());
+                } else if(filters[key].search_type === 'equal') {
+                    filterStatus = item[key] == query[key];
+                } else if(filters[key].search_type === 'in') {
+                    filterStatus = query[key].includes(item[key]);
+                } else if(filters[key].search_type === 'not_in') {
+                    filterStatus = !query[key].includes(item[key]);
+                } else if(filters[key].search_type === 'between') {
+                    filterStatus = item[key] >= query[key][0] && item[key] <= query[key][1];
+                } else if(filters[key].search_type === 'not_between') {
+                    filterStatus = item[key] < query[key][0] || item[key] > query[key][1];
+                }
+                return filterStatus;
+            });
+        });
+    }
+
+    const totalPages = Math.ceil(all_data.length / parseInt(limit));
+    if(page > totalPages && page !== 1) {
+        return reply.status(404).send({
+            status: false,
+            message: 'Page not found'
+        });
+    }
+    
+    return reply.send({
+        status: true,
+        data: all_data.slice(offset, offset + limit),
+        pagination: {
+            page: parseInt(page),
+            limit: parseInt(limit),
+            total: all_data.length,
+            totalPages: totalPages
+        }
+    });
+}
+
+const get_by_primary_key = (name, primary_key, reply, routeOptions = {}) => {
+
+    const store_model = stores[name] || false;
+    if(!store_model) {
+        return reply.status(404).send({
+            status: false,
+            message: 'Store not found'
+        });
+    }
+    
+    const data = store_model.data.get(primary_key);
+    if(!data) {
+        return reply.status(404).send({
+            status: false,
+            message: 'Data not found'
+        });
+    }
+
+    return reply.send({
+        status: true,
+        data: data
+    });
+}
+
+const create_item = async (name, data, reply, routeOptions = {}) => {
+
+    const store_model = stores[name] || false;
+    if(!store_model) {
+        return reply.status(404).send({
+            status: false,
+            message: 'Store not found'
+        });
+    }
+
+    try {
+        const data_created = await store_model.create_data(data);
+        return reply.send({
+            status: true,
+            data: data_created
+        });
+    } catch (error) {
+        return reply.status(500).send({
+            status: false,
+            message: error.message
+        });
+    }
+}
+
+const update_item = async (name, primary_key, data, reply, routeOptions = {}) => {
+    const store_model = stores[name] || false;
+    if(!store_model) {
+        return reply.status(404).send({
+            status: false,
+            message: 'Store not found'
+        });
+    }
+
+    try {
+        const data_updated = await store_model.update_data(primary_key, data);
+        return reply.send({
+            status: true,
+            data: data_updated
+        });
+    } catch (error) {
+        return reply.status(500).send({
+            status: false,
+            message: error.message
+        });
+    }
+}
+
+const delete_item = async (name, primary_key, reply, routeOptions = {}) => {
+    const store_model = stores[name] || false;
+    if(!store_model) {
+        return reply.status(404).send({
+            status: false,
+            message: 'Store not found'
+        });
+    }
+
+    try {
+        const data_deleted = await store_model.delete_data(primary_key);
+        return reply.send({
+            status: true,
+            data: data_deleted
+        });
+    } catch (error) {
+        return reply.status(500).send({
+            status: false,
+            message: error.message
+        });
+    }
+}
+
+module.exports = {
+    add_model,
+    get_all,
+    get_by_primary_key,
+    create_item,
+    update_item,
+    delete_item,
+    stores
+}

package/utils/i18n.js

@@ -0,0 +1,187 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Internationalization utility for multi-language support
+ */
+class I18n {
+  constructor() {
+    this.locales = {};
+    this.defaultLocale = 'en';
+    this.supportedLocales = ['en', 'tr', 'es'];
+    this.loadLocales();
+  }
+
+  /**
+   * Load all locale files
+   */
+  loadLocales() {
+    const localesPath = path.join(__dirname, '../locales');
+    
+    for (const locale of this.supportedLocales) {
+      const localePath = path.join(localesPath, locale);
+      if (fs.existsSync(localePath)) {
+        this.locales[locale] = {};
+        
+        // Load all JSON files in the locale directory
+        const files = fs.readdirSync(localePath);
+        for (const file of files) {
+          if (file.endsWith('.json')) {
+            const filePath = path.join(localePath, file);
+            const content = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+            const key = file.replace('.json', '');
+            this.locales[locale][key] = content;
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Get translation for a key
+   * @param {string} key - Translation key (e.g., 'validation.required')
+   * @param {string} locale - Locale code
+   * @param {Object} params - Parameters to replace in the translation
+   * @returns {string} Translated string
+   */
+  t(key, locale = this.defaultLocale, params = {}) {
+    const keys = key.split('.');
+    let translation = this.locales[locale] || this.locales[this.defaultLocale];
+    
+    // Navigate through nested keys
+    for (const k of keys) {
+      if (translation && translation[k]) {
+        translation = translation[k];
+      } else {
+        // Fallback to default locale
+        translation = this.locales[this.defaultLocale];
+        for (const k of keys) {
+          if (translation && translation[k]) {
+            translation = translation[k];
+          } else {
+            return key; // Return key if translation not found
+          }
+        }
+        break;
+      }
+    }
+
+    // Replace parameters in the translation
+    if (typeof translation === 'string') {
+      return this.replaceParams(translation, params);
+    }
+
+    return key;
+  }
+
+  /**
+   * Replace parameters in translation string
+   * @param {string} str - String with parameters
+   * @param {Object} params - Parameters to replace
+   * @returns {string} String with replaced parameters
+   */
+  replaceParams(str, params) {
+    return str.replace(/\{(\w+)\}/g, (match, key) => {
+      return params[key] !== undefined ? params[key] : match;
+    });
+  }
+
+  /**
+   * Detect language from request headers
+   * @param {Object} request - Fastify request object
+   * @returns {string} Detected locale
+   */
+  detectLanguage(request) {
+    // Check Accept-Language header
+    const acceptLanguage = request.headers['locale'] || request.headers['Accept-Language'];
+    if (acceptLanguage) {
+      const languages = acceptLanguage.split(',').map(lang => {
+        const [locale, quality] = lang.trim().split(';q=');
+        return {
+          locale: locale.split('-')[0], // Get language part only
+          quality: quality ? parseFloat(quality) : 1.0
+        };
+      });
+
+      // Sort by quality and find first supported locale
+      languages.sort((a, b) => b.quality - a.quality);
+      for (const lang of languages) {
+        if (this.supportedLocales.includes(lang.locale)) {
+          return lang.locale;
+        }
+      }
+    }
+
+    // Check custom header
+    const customLang = request.headers['locale'];
+    if (customLang && this.supportedLocales.includes(customLang)) {
+      return customLang;
+    }
+
+    // Check query parameter
+    const queryLang = request.query?.lang;
+    if (queryLang && this.supportedLocales.includes(queryLang)) {
+      return queryLang;
+    }
+
+    return this.defaultLocale;
+  }
+
+  /**
+   * Get validation error message
+   * @param {Object} error - Ajv validation error
+   * @param {string} locale - Locale code
+   * @returns {string} Localized error message
+   */
+  getValidationErrorMessage(error, locale = this.defaultLocale) {
+    const { keyword, instancePath, params, message } = error;
+    const field = instancePath.replace('/', '') || 'field';
+    
+    let errorKey = `validation.${keyword}`;
+    
+    // Special cases for common validation errors
+    if (keyword === 'minLength') {
+      errorKey = 'validation.minLength';
+    } else if (keyword === 'maxLength') {
+      errorKey = 'validation.maxLength';
+    } else if (keyword === 'minimum') {
+      errorKey = 'validation.min';
+    } else if (keyword === 'maximum') {
+      errorKey = 'validation.max';
+    } else if (keyword === 'format' && params?.format === 'email') {
+      errorKey = 'validation.invalidEmail';
+    } else if (keyword === 'enum') {
+      errorKey = 'validation.enum';
+    }
+
+    const errorParams = {
+      field,
+      ...params,
+      enum: params?.allowedValues ? params.allowedValues.join(', ') : ''
+    };
+
+    return this.t(errorKey, locale, errorParams);
+  }
+
+  /**
+   * Get all supported locales
+   * @returns {Array} Array of supported locale codes
+   */
+  getSupportedLocales() {
+    return this.supportedLocales;
+  }
+
+  /**
+   * Check if locale is supported
+   * @param {string} locale - Locale code
+   * @returns {boolean} True if supported
+   */
+  isLocaleSupported(locale) {
+    return this.supportedLocales.includes(locale);
+  }
+}
+
+// Create singleton instance
+const i18n = new I18n();
+
+module.exports = i18n;