daevin 1.0.0

package/bin/classes/Helpers.js

@@ -0,0 +1,150 @@
+
+//import db_config from '../dbconfig.json';
+import fs from 'fs';
+import child_process from "child_process";
+
+ class Helpers{
+
+     static dbConfig = null
+
+         constructor(dbconfig) {
+        this.dbConfig = dbconfig;
+    }
+      static loadDBConfigs(dbconfig){
+          Helpers.dbConfig = dbconfig;
+         //console.log(this.dbConfig)
+    }
+
+      static getDbConfig(){
+        return Helpers.dbConfig
+    }
+
+      static getDbAccess(){
+        return {
+            database: Helpers.getDbConfig().database,
+            username: Helpers.getDbConfig().username,
+            password: Helpers.getDbConfig().password,
+            host: Helpers.getDbConfig().host,
+        }
+     }
+
+        static getTables(){
+         //console.log(this.getDbConfig())
+        return Helpers.getDbConfig()?.tables
+    }
+
+      static getTableFromName(table_name){
+        const tables = Helpers.getTables();
+       return  tables.filter(table => table.table_name === table_name)[0]
+    }
+
+    static getTableColumns(table_name){
+         return Helpers.getTableFromName(table_name).columns
+    }
+
+
+    static createPath(path){
+         //console.log(`Creating path ${path}`);
+        if (!fs.existsSync(path)){
+            fs.mkdirSync(path, { recursive: true });
+            return true;
+        }
+
+        return  fs.existsSync(path);
+    }
+
+    static writeToFile(path, fileName, content){
+        const filepath = `${path}/${fileName}`;
+       try{
+           const pathCreated = Helpers.createPath(path)
+           if(pathCreated){
+               fs.writeFile(filepath, content, function (err) {
+                  // console.log(`Writing to ${filepath}`);
+                   if (err) return console.log(err);
+                   //console.log(`Writing to ${fileName} completed`);
+               });
+           }
+           return filepath;
+       }catch (e) {
+           throw e
+       }
+
+    }
+
+    static formatColumnsToPhpArraysUsage(columns){
+         let data = "";
+        for (let column of columns) {
+            data += `'${column.column_name}' => $request->${column.column_name},`;
+        }
+        return data;
+    }
+
+    static formatColumnsForRequestUsage(columns)
+    {
+        let data = "";
+        for (let column of columns) {
+            data += `'${column.column_name}' => ${Helpers.formatColumnPropertiesToValidators(column)}`;
+        }
+        return data;
+    }
+
+    static formatColumnPropertiesToValidators(column){
+         let properties = column.properties;
+         if( !properties || typeof properties != "array" || properties.length === 0 ){
+             return 'nullable';
+         }
+         let validator = '';
+
+        for (const validatorElement of properties) {
+            switch (validatorElement) {
+                case 'required':
+                            validator += validator === '' ? 'required' : '|required';
+                            break
+                case 'unique':
+                            validator += validator === '' ? 'required|unique' : '|unique';
+                            break
+                case 'string':
+                            validator += validator === '' ? 'required|string' : '|string';
+                            break
+                case validatorElement.startsWith('max'):
+                            validator += validator === '' ? 'required|'+validatorElement : '|'+validatorElement;
+                            break
+
+            }
+        }
+        return validator
+    }
+
+    static capitalise(str){
+         return str.charAt(0).toUpperCase() + str.slice(1)
+    }
+
+    static generateRandomString(length) {
+        const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        let result = '';
+        for (let i = 0; i < length; i++) {
+            result += characters.charAt(Math.floor(Math.random() * characters.length));
+        }
+        return result;
+    }
+
+
+
+
+}
+
+function executeCommand(command, successMessage, callback) {
+    child_process.exec(command, { stdio: 'inherit' }).on('exit', (code, signal) => {
+        if (code !== 0) {
+            callback(new Error(`Command failed with code ${code} and signal ${signal}`));
+            process.exit(1);
+        } else {
+            //console.clear();
+            console.log(successMessage);
+            callback();
+        }
+    });
+}
+
+export default Helpers;
+ export {executeCommand}

package/bin/constants.js

@@ -0,0 +1,11 @@
+// const {PROJECT} = require("./index");
+//
+//
+// const PROJECT_DIR= PROJECT
+//
+// console.log('PROJECT_DIR')
+// console.log('PROJECT_DIR')
+// console.log('PROJECT_DIR')
+// console.log(PROJECT_DIR)
+//
+// module.exports = { PROJECT_DIR };

package/bin/core/output.json

@@ -0,0 +1,13 @@
+{
+    "table_name": "my_table",
+    "columns": [
+        {
+            "column_name": "id",
+            "type": "integer",
+            "properties": [
+                "int(11"
+            ]
+        }
+    ],
+    "relations": []
+}

package/bin/core/schemaToSql.js

@@ -0,0 +1,118 @@
+
+// Generate SQL for a single column
+import path from "path";
+import fs from "fs/promises";
+import Helpers from "../classes/Helpers.js";
+
+function columnToSql(column) {
+    let sql = `${column.column_name} ${column.type}`;
+
+    if (column.properties.includes('notNull')) {
+        sql += ' NOT NULL';
+    }
+
+    if (column.properties.includes('unique')) {
+        sql += ' UNIQUE';
+    }
+
+    if (column.properties.includes('hidden')) {
+        sql += ' HIDDEN';
+    }
+
+    if (column.properties.includes('min') || column.properties.includes('max')) {
+        const lengthProps = column.properties.filter(p => p.startsWith('min:') || p.startsWith('max:'));
+        const lengths = lengthProps.map(p => parseInt(p.slice(4)));
+        const min = Math.min(...lengths);
+        const max = Math.max(...lengths);
+
+        if (min) {
+            sql += ` CHECK (LENGTH(${column.column_name}) >= ${min})`;
+        }
+
+        if (max) {
+            sql += ` CHECK (LENGTH(${column.column_name}) <= ${max})`;
+        }
+    }
+
+    return sql;
+}
+
+function tableToSql(table) {
+    const columns = table.columns.map((column) => {
+        let columnStr = `${column.column_name} `;
+        if (column.type.toString().toUpperCase() === "STRING") {
+            const maxLength = column.properties.find((p) => p.startsWith("max:"));
+            columnStr += `VARCHAR(${maxLength ? maxLength.slice(4) : 255}) `;
+        } else if (column.type.toString().toUpperCase() === "ARRAY") {
+            columnStr += `JSON`;
+        } else {
+            columnStr += `${column.type} `;
+        }
+        if (column.properties.includes("notNull")) {
+            columnStr += "NOT NULL ";
+        }
+        if (column.properties.includes("unique")) {
+            columnStr += "UNIQUE ";
+        }
+        if (column.properties.includes("hidden")) {
+            columnStr += "COMMENT 'hidden' ";
+        }
+        return columnStr.trim();
+    });
+
+    const relations = table.relations.map((relation) => {
+        let relationString = '';
+        relationString += getRelation(relation)
+        return relationString;
+    });
+
+    const primaryKey = "id INT AUTO_INCREMENT PRIMARY KEY";
+    columns.unshift(primaryKey);
+
+    return `CREATE TABLE ${table.table_name} (\n ${columns.join(",\n ")}${relations.toString().trim() === '' ? '' : ','}\n ${relations || ''}\n);`;
+}
+
+function getType(type, properties) {
+    let typeString = type.toUpperCase();
+    if (typeString === 'STRING') {
+        let maxLength = 255;
+        for (const property of properties) {
+            if (property.includes('max:')) {
+                const length = parseInt(property.split(':')[1]);
+                if (length && length < maxLength) {
+                    maxLength = length;
+                }
+            }
+        }
+        typeString += `(${maxLength})`;
+    }
+    if (typeString === 'ARRAY') {
+        typeString = 'TEXT';
+    }
+    if (properties.includes('notNull')) {
+        typeString += ' NOT NULL';
+    }
+    return typeString;
+}
+
+function getRelation(relation) {
+    let relationString = '';
+    if (relation.relation === 'belongsTo') {
+        relationString = `  FOREIGN KEY (${relation.foreignKey}) REFERENCES ${relation.table}(id)`;
+    } else if (relation.relation === 'hasMany') {
+       // relationString = `  FOREIGN KEY (${relation.foreignKey}) REFERENCES ${relation.table}(id) ON DELETE CASCADE`;
+    }
+
+    return relationString;
+}
+
+function schemaToSql(schema) {
+    return schema.tables.map((table) => tableToSql(table)).join("\n\n");
+}
+
+
+const absolutePath = '../../dbconfig.json'; // Resolve the absolute path
+const fileData = await fs.readFile(absolutePath, "utf8"); // Read the file data
+const db_config = JSON.parse(fileData);
+
+console.log(schemaToSql(db_config))

package/bin/core/sqlToSchema.js

@@ -0,0 +1,206 @@
+
+import fs from 'fs'
+function sqlToSchema(sql) {
+    // Split the SQL into separate statements and remove whitespace
+    const statements = sql.trim().split(/;\s*\n+/);
+
+    // Create an object to hold the schema
+    const schema = {
+        project: '',
+        database: '',
+        host: '',
+        username: '',
+        password: '',
+        tables: [],
+    };
+
+    // Loop through each statement and process it
+    for (const statement of statements) {
+        // Skip any empty statements
+        if (!statement) {
+            continue;
+        }
+
+        // Determine the type of statement
+        const type = statement.trim().split(/\s+/)[0].toUpperCase();
+
+        // Process the statement based on its type
+        switch (type) {
+            case 'CREATE':
+                processCreateStatement(statement, schema);
+                break;
+            default:
+                console.warn(`Unrecognized SQL statement: ${type}`);
+        }
+    }
+
+    return schema;
+}
+
+function processCreateStatement(statement, schema) {
+    // Extract the table name from the statement
+    const tableNameMatch = statement.match(/CREATE TABLE\s+(\w+)\s*\(/i);
+    if (!tableNameMatch) {
+        console.error(`Could not extract table name from SQL statement: ${statement}`);
+        return;
+    }
+    const tableName = tableNameMatch[1];
+
+    // Extract the column definitions from the statement
+    const columnDefinitionsMatch = statement.match(/\(\s*([\s\S]*)\s*\)/);
+    if (!columnDefinitionsMatch) {
+        console.error(`Could not extract column definitions from SQL statement: ${statement}`);
+        return;
+    }
+    const columnDefinitions = columnDefinitionsMatch[1];
+
+    // Create a table object
+    const table = {
+        table_name: tableName,
+        columns: [],
+        relations: [],
+    };
+
+    // Loop through each column definition and process it
+    const columnDefs = columnDefinitions.split(',');
+    for (const columnDef of columnDefs) {
+        const column = processColumnDefinition(columnDef);
+        if (column) {
+            table.columns.push(column);
+        }
+    }
+
+    // Add the table to the schema
+    schema.tables.push(table);
+}
+
+function processColumnDefinition(columnDef) {
+    // Extract the column name and type from the definition
+    const nameMatch = columnDef.match(/^\s*(\w+)\s+/);
+    const typeMatch = columnDef.match(/\s+(\w+)(?:\((.*?)\))?/);
+
+    if (!nameMatch || !typeMatch) {
+        console.error(`Could not extract column name and/or type from column definition: ${columnDef}`);
+        return null;
+    }
+
+    const name = nameMatch[1];
+    const type = typeMatch[1].toUpperCase();
+    const length = typeMatch[2];
+
+    // Create a column object
+    const column = {
+        column_name: name,
+        type: getColumnType(type, length),
+        properties: [],
+        is_searchable: false,
+    };
+
+    // Determine the column properties
+    if (columnDef.match(/\bNOT\s+NULL\b/i)) {
+        column.properties.push('notNull');
+    }
+    if (columnDef.match(/\bUNIQUE\b/i)) {
+        column.properties.push('unique');
+    }
+    if (columnDef.match(/COMMENT\s+'hidden'/i)) {
+        column.properties.push('hidden');
+    }
+
+    return column;
+}
+
+function getColumnType(typeStr) {
+
+    const type = typeStr.toString().toUpperCase();
+    if (type.startsWith('VARCHAR')) {
+        return { type: 'string', properties: [`max:${type.slice(8, -1)}`] };
+    }
+    if (type === 'TEXT' || type === 'LONGTEXT') {
+        return { type: 'string' };
+    }
+    if (type === 'BOOLEAN') {
+        return { type: 'boolean' };
+    }
+    if (type.startsWith('INT') || type === 'YEAR') {
+        return { type: 'integer' };
+    }
+    if (type === 'BIGINT') {
+        return { type: 'bigint' };
+    }
+    if (type === 'FLOAT' || type === 'DOUBLE') {
+        return { type: 'float' };
+    }
+    if (type === 'DECIMAL') {
+        return { type: 'decimal' };
+    }
+    if (type === 'DATE' || type === 'DATETIME' || type === 'TIMESTAMP') {
+        return { type: 'date' };
+    }
+    if (type === 'JSON') {
+        return { type: 'array' };
+    }
+    return { type: type.toLowerCase() };
+}
+
+function getColumnsFromSql(tableStr) {
+    const columns = [];
+    const matches = tableStr.match(/\(([^)]+)\)/);
+    if (matches) {
+        const columnDefs = matches[1].split(',\n');
+        columnDefs.forEach((columnDef) => {
+            const [nameAndType, ...properties] = columnDef.trim().split(' ');
+            const [name] = nameAndType.split('`').filter(Boolean);
+            const typeStr = properties[0];
+            console.log(properties)
+            console.log(columnDef)
+            console.log(nameAndType)
+            const column = {
+                column_name: name,
+                ...getColumnType(typeStr),
+                properties: properties.map((p) => p.trim()),
+            };
+            columns.push(column);
+        });
+    }
+    return columns;
+}
+
+function getRelationsFromSql(sql) {
+    const relations = [];
+    const matches = sql.match(/FOREIGN KEY \(`(.+)`\) REFERENCES `(.+)` \(`(.+)`\)/g);
+    if (matches) {
+        matches.forEach((match) => {
+            const [_, foreignKeyName, tableName, columnName] = match.split(' ');
+            const relation = {
+                table: tableName.slice(1, -1),
+                relation: 'belongsTo',
+                foreignKey: foreignKeyName.slice(2, -1),
+            };
+            relations.push(relation);
+        });
+    }
+    return relations;
+}
+
+function getTableFromSql(sql) {
+    const tableName = sql.match(/CREATE TABLE (\w+) \(/)[1];
+    const columns = getColumnsFromSql(sql);
+    const relations = getRelationsFromSql(sql);
+    return { table_name: tableName, columns, relations };
+}
+
+const sql = `CREATE TABLE my_table (
+                                       id int(11) NOT NULL AUTO_INCREMENT,
+                                       name varchar(255) NOT NULL,
+                                       is_active tinyint(1) NOT NULL DEFAULT '0',
+                                       price decimal(10,2) NOT NULL DEFAULT '0.00',
+                                       created_at timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
+                                       status enum('ACTIVE','INACTIVE') NOT NULL DEFAULT 'ACTIVE',
+                                       PRIMARY KEY (id),
+                                       UNIQUE KEY name (name)
+             ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;`;
+
+const table = getTableFromSql(sql);
+fs.writeFileSync('output.json', JSON.stringify(table, null, 4));
+console.log(table);

package/bin/index.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+
+import yargs from "yargs";
+import fs from "fs/promises";
+import path from "path";
+import Helpers from './classes/Helpers.js';
+import chalk from "chalk";
+import boxen from "boxen";
+import { hideBin } from "yargs/helpers";
+import generateApiatoproject, {serveWithValet} from "./classes/Apiato/index.js";
+import inquirer from 'inquirer';
+
+const banner = boxen(chalk.bold.white('Daevin gen CLI Tool'), {
+    padding: 1,
+    margin: 1,
+    borderStyle: 'double',
+    borderColor: 'green',
+});
+
+console.info(`${banner}\n`);
+
+yargs(hideBin(process.argv))
+    .command(['gen', 'generate'], 'Generate Backend Source code', (yargs) => {
+        yargs.command('apiato', 'Generate Apiato Source project', (yargs) => {
+            yargs.option('path', {
+                alias: 'p',
+                describe: 'Path to config file',
+                type: 'string',
+                demandOption: true
+            })
+        }, async (argv) => {
+            console.info(chalk.magenta.bold('Generating Apiato Source project with options:'));
+            const absolutePath = path.resolve(argv.path);
+            const fileData = await fs.readFile(absolutePath, "utf8");
+            const db_config = JSON.parse(fileData);
+
+            Helpers.loadDBConfigs(db_config);
+
+            await generateApiatoproject();
+
+
+            console.info(chalk.bgGreenBright.bold('Code generation Completed !'));
+        });
+        yargs.command('nestjs', 'Generate Nestjs Source project', (yargs) => {
+            yargs.option('path', {
+                alias: 'p',
+                describe: 'Path to config file',
+                type: 'string',
+                demandOption: true
+            })
+        }, async () => {
+            console.info(chalk.magenta.bold('Generating Nest js Source project with options:'));
+            console.info(chalk.red.bold('!!! Comming soon'));
+        });
+    }, (argv) => {
+        console.info('argv for daevin');
+        console.info(argv);
+    })
+    .demandCommand(1)
+    .parse();
+
+const questions = [
+    {
+        type: 'list',
+        name: 'command',
+        message: 'Which command would you like to execute?',
+        choices: ['apiato', 'nestjs'],
+    },
+    {
+        type: 'input',
+        name: 'path',
+        message: 'Enter the path to the configuration file:',
+        when: (answers) => answers.command === 'apiato',
+    },
+];
+
+inquirer.prompt(questions).then(async (answers) => {
+    if (answers.command === 'apiato') {
+        if (answers.path === '') {
+            console.info(chalk.red.bold('No config path provided.'));
+            process.exit(1);
+        }
+        console.info(chalk.magenta.bold('Generating Apiato Source project with options:'));
+        const absolutePath = path.resolve(answers.path);
+        const fileData = await fs.readFile(absolutePath, 'utf8');
+        const db_config = JSON.parse(fileData);
+
+        Helpers.loadDBConfigs(db_config);
+
+        await generateApiatoproject();
+
+
+        console.info(chalk.bgGreenBright.bold('Code generation Completed !'));
+    } else if (answers.command === 'nestjs') {
+        console.info(chalk.magenta.bold('Generating Nest js Source project with options:'));
+        console.info(chalk.red.bold('!!! Coming soon'));
+    }
+});
+
+
+
+
+

package/dbconfig.json

@@ -0,0 +1,74 @@
+{
+  "project": "Daevin_test",
+  "database" : "test_db",
+  "host": "",
+  "username": "",
+  "password": "",
+  "tables": [
+    {
+      "table_name": "users",
+      "columns": [
+        {
+          "column_name": "email",
+          "type": "string",
+          "properties": ["unique", "string", "max:40"],
+          "is_searchable": true
+        },
+        {
+          "column_name": "is_active",
+          "type": "boolean",
+          "properties": ["notNull"],
+          "is_searchable": true
+        },
+        {
+          "column_name": "password",
+          "type": "string",
+          "properties": ["notNull", "min:8", "max:20", "string", "hidden" ]
+        },
+        {
+          "column_name": "name",
+          "type": "string",
+          "properties": ["string"]
+        }
+      ],
+      "relations": [
+        {
+          "table": "post",
+          "relation": "hasMany",
+          "foreignKey": "user_id"
+        }
+      ]
+    },
+    {
+      "table_name": "posts",
+      "columns": [
+        {
+          "column_name": "message",
+          "type": "string",
+          "properties": [ "min:8"],
+          "is_searchable": true
+        },
+        {
+          "column_name": "user_id",
+          "type": "string",
+          "properties": [ "min:8"],
+          "is_searchable": true
+        },
+        {
+          "column_name": "reposted_by",
+          "type": "array",
+          "properties": ["nullable"],
+          "is_searchable": true
+        }
+      ],
+      "relations": [
+        {
+          "table": "users",
+          "relation": "belongsTo",
+          "foreignKey": "user_id"
+        }
+      ]
+    }
+  ]
+
+}