@carbonorm/carbonnode 1.1.3 → 1.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carbonorm/carbonnode",
-  "version": "1.1.3",
+  "version": "1.1.8",
   "main": "dist/index.cjs.js",
   "module": "dist/index.esm.js",
   "browser": "dist/index.umd.js",
@@ -25,6 +25,7 @@
     "@types/qs": "^6.9.8",
     "autoprefixer": "^10.4.14",
     "deepmerge": "^4.3.1",
+    "handlebars": "^4.7.8",
     "postcss": "^8.4.27",
     "postcss-nested": "^6.0.1",
     "postcss-simple-vars": "^7.0.1",
@@ -34,14 +35,20 @@
     "typescript": "^5.1.6"
   },
   "scripts": {
-    "build": "npm run build:index && rollup -c",
+    "build": "npm run build:index && npm run build:generateRestBindings && rollup -c",
     "dev": "rollup -c -w",
     "test": "node test/test.js",
     "pretest": "npm run build",
-    "build:index": "npx barrelsby -d ./src --delete --exclude '(jestHoc|\\.test|\\.d).(js|tsx?)$' --exportDefault --verbose"
+    "build:index": "npx barrelsby -d ./src --delete --exclude '(jestHoc|\\.test|\\.d).(js|tsx?)$' --exportDefault --verbose",
+    "build:generateRestBindings": "cd ./scripts/ && tsc --downlevelIteration generateRestBindings.ts && mv generateRestBindings.js generateRestBindings.cjs",
+    "generateRestBindings": "npm run build:generateRestBindings && node ./scripts/generateRestBindings.cjs"
+  },
+  "bin": {
+    "generateRestBindings": "./scripts/generateRestBindings.cjs"
   },
   "files": [
     "dist",
-    "src"
+    "src",
+    "scripts"
   ]
 }

package/scripts/assets/handlebars/C6.tsx.handlebars

@@ -0,0 +1,115 @@
+import {
+    C6RestfulModel,
+    C6Constants
+} from "@carbonorm/carbonnode";
+
+export type RestTableNames = {{{RestTableNames}}};
+
+export type RestShortTableNames = {{{RestShortTableNames}}};
+
+{{#TABLES}}
+
+export interface i{{TABLE_NAME_SHORT_PASCAL_CASE}} {
+{{#each TYPE_VALIDATION}}
+    '{{this.COLUMN_NAME}}'?: {{this.TYPESCRIPT_TYPE}};
+{{/each}}
+}
+
+interface iDefine{{TABLE_NAME_SHORT_PASCAL_CASE}} {
+{{#each COLUMNS_UPPERCASE}}
+    '{{@key}}': string;
+{{/each}}
+}
+
+export const {{TABLE_NAME_SHORT}}: C6RestfulModel & iDefine{{TABLE_NAME_SHORT_PASCAL_CASE}} = {
+    TABLE_NAME: '{{TABLE_NAME}}',
+    {{#each COLUMNS_UPPERCASE}}
+    {{@key}}: '{{this}}',
+    {{/each}}
+    PRIMARY: [
+    {{#PRIMARY}}
+        '{{this}}',
+    {{/PRIMARY}}
+    ],
+    PRIMARY_SHORT: [
+    {{#each PRIMARY_SHORT}}
+        '{{this}}',
+    {{/each}}
+    ],
+    COLUMNS: {
+    {{#each COLUMNS}}
+        '{{@key}}': '{{this}}',
+    {{/each}}
+    },
+    TYPE_VALIDATION: {
+    {{#each TYPE_VALIDATION}}
+        '{{@key}}': {
+            MYSQL_TYPE: '{{this.MYSQL_TYPE}}',
+            MAX_LENGTH: '{{this.MAX_LENGTH}}',
+            AUTO_INCREMENT: {{this.AUTO_INCREMENT}},
+            SKIP_COLUMN_IN_POST: {{this.SKIP_COLUMN_IN_POST}}
+        },
+    {{/each}}
+    },
+    REGEX_VALIDATION: {
+    {{#each REGEX_VALIDATION}}
+        '{{@key}}': '{{this}}',
+    {{/each}}
+    },
+    TABLE_REFERENCES: {
+        {{#each TABLE_REFERENCES}}'{{@key}}': [{{#this}}{
+            TABLE: '{{TABLE}}',
+            COLUMN: '{{COLUMN}}',
+            CONSTRAINT: '{{CONSTRAINT}}',
+        },{{/this}}],{{/each}}
+    },
+    TABLE_REFERENCED_BY: {
+        {{#each TABLE_REFERENCED_BY}}'{{@key}}': [{{#this}}{
+            TABLE: '{{TABLE}}',
+            COLUMN: '{{COLUMN}}',
+            CONSTRAINT: '{{CONSTRAINT}}',
+        },{{/this}}],{{/each}}
+    },
+}
+{{/TABLES}}
+
+export const TABLES = {
+{{#TABLES}}
+    {{TABLE_NAME_SHORT}}: {{TABLE_NAME_SHORT}},
+{{/TABLES}}
+};
+
+export const C6 : { TABLES: { [key: string]: (C6RestfulModel & { [key: string]: any }) } }
+& { [key: string]: any } = {
+    ...C6Constants,
+    TABLES: TABLES,
+    ...TABLES
+};
+
+export const COLUMNS = {
+{{#TABLES}}{{#each TYPE_VALIDATION}}'{{@key}}': '{{this.COLUMN_NAME}}',{{/each}}
+{{/TABLES}}
+
+};
+
+
+export type RestTableInterfaces = {{{RestTableInterfaces}}};
+
+export type tStatefulApiData<T> = T[] | undefined | null;
+
+
+// this refers to the value types of the keys above, aka values in the state
+export interface iRestfulObjectArrayTypes {
+    {{#TABLES}}
+    {{TABLE_NAME_SHORT}}: tStatefulApiData<i{{TABLE_NAME_SHORT_PASCAL_CASE}}>,
+    {{/TABLES}}
+}
+
+export const initialRestfulObjectsState: iRestfulObjectArrayTypes = {
+    {{#TABLES}}
+    {{TABLE_NAME_SHORT}}: undefined,
+    {{/TABLES}}
+};
+
+export type tRestfulObjectArrayValues = iRestfulObjectArrayTypes[keyof iRestfulObjectArrayTypes];
+

package/scripts/assets/handlebars/Tests.tsx.handlebars

@@ -0,0 +1,121 @@
+import {xdescribe, expect, test} from '@jest/globals';
+import {CarbonReact} from "@carbonorm/carbonreact";
+import {checkAllRequestsComplete} from "@carbonorm/carbonnode";
+import {act, waitFor} from '@testing-library/react';
+import {C6, iRestfulObjectArrayTypes, i{{TABLE_NAME_SHORT_PASCAL_CASE}}, {{TABLE_NAME_SHORT}} } from "{{RELATIVE_OUTPUT_DIR}}/C6";
+
+const randomString = Math.random().toString(36).substring(7);
+const randomInt = Math.floor(Math.random() * 1000000);
+const fillString = 'string' + randomString + randomInt;
+
+/**
+{{{TABLE_DEFINITION}}}
+**/
+
+const Test_Data: i{{TABLE_NAME_SHORT_PASCAL_CASE}} = {
+{{#each TYPE_VALIDATION}}
+    {{#SKIP_COLUMN_IN_POST}}{{COLUMN_NAME}}: {{#TYPESCRIPT_TYPE_IS_STRING}}fillString.substring(0, {{MAX_LENGTH}}){{/TYPESCRIPT_TYPE_IS_STRING}}{{#TYPESCRIPT_TYPE_IS_NUMBER}}randomInt,{{/TYPESCRIPT_TYPE_IS_NUMBER}}{{/SKIP_COLUMN_IN_POST}}
+{{/each}}
+}
+
+export default Test_Data;
+
+xdescribe('REST {{TABLE_NAME_SHORT_PASCAL_CASE}} api', () => {
+
+    let testData = Test_Data;
+
+    test('GET POST PUT DELETE', async () => {
+
+        await act(async () => {
+
+            let selectAllResponse = await {{TABLE_NAME_SHORT}}.Get({})
+
+            if ('function' === typeof selectAllResponse) {
+                throw Error('selectAllResponse is a promise, this typically means this specific get request has already run during test setup.');
+            }
+
+            // We don't care if it is filled or not, just that the request can be made.
+            expect(selectAllResponse?.data?.rest).not.toBeUndefined();
+
+            const postResponse = await {{TABLE_NAME_SHORT}}.Post(testData);
+
+            console.log('postResponse', postResponse?.data)
+
+            expect(postResponse?.data?.created).not.toBeUndefined();
+
+            const primaryKey = {{TABLE_NAME_SHORT}}.PRIMARY_SHORT[0];
+
+            const postID = postResponse?.data?.created
+
+            const singleRowSelect = await {{TABLE_NAME_SHORT}}.Get({
+                [C6.WHERE]: {
+                    [{{TABLE_NAME_SHORT}}[primaryKey.toUpperCase()]]: postID,
+                }
+            })
+
+            if ('function' === typeof singleRowSelect) {
+                throw Error('singleRowSelect is a promise, this is unexpected.');
+            }
+
+            console.log('singleRowSelect', singleRowSelect?.data)
+
+            // Ensure the expected response datastructure is returned
+            expect(singleRowSelect?.data?.rest).not.toBeUndefined();
+
+            // Make sure the previously created post is now returned
+            expect(typeof singleRowSelect?.data?.rest).toEqual('object');
+
+            // todo - make this work correctly with multiple primary keys
+            const selectedPostId = singleRowSelect?.data?.rest[0][primaryKey]
+
+            expect(selectedPostId).toEqual(postID);
+
+            const multipleRowSelect = await {{TABLE_NAME_SHORT}}.Get({
+                [C6.WHERE]: {
+                    [{{TABLE_NAME_SHORT}}[primaryKey.toUpperCase()]]: [C6.IN, [0, postID]],
+                }
+            })
+
+            if ('function' === typeof multipleRowSelect) {
+                throw Error('singleRowSelect is a promise, this is unexpected.');
+            }
+
+            console.log('singleRowSelect', multipleRowSelect?.data)
+
+            // Ensure the expected response datastructure is returned
+            expect(multipleRowSelect?.data?.rest).not.toBeUndefined();
+
+            // Make sure the previously created post is now returned
+            expect(typeof multipleRowSelect?.data?.rest).toEqual('object');
+
+            testData[primaryKey] = postID
+
+            {{#each TYPE_VALIDATION}}
+            testData.{{@key}} = {{#TYPESCRIPT_TYPE_IS_STRING}}fillString.substring(0, {{TYPE_VALIDATION.MAX_LENGTH}}){{/TYPESCRIPT_TYPE_IS_STRING}}{{#TYPESCRIPT_TYPE_IS_NUMBER}}randomInt{{/TYPESCRIPT_TYPE_IS_NUMBER}};
+            {{/each}}
+
+            // wait for the global state to be updated
+            expect(CarbonReact.getState<iRestfulObjectArrayTypes>().{{TABLE_NAME_SHORT}}).not.toBeUndefined();
+
+            const updateResponse = await {{TABLE_NAME_SHORT}}.Put(testData)
+
+            expect(updateResponse?.data?.updated).not.toBeUndefined();
+
+            const deleteResponse = await {{TABLE_NAME_SHORT}}.Delete({
+                [primaryKey]: postID
+            })
+
+            console.log('deleteResponse', deleteResponse?.data)
+
+            expect(deleteResponse?.data?.deleted).not.toBeUndefined();
+
+            await waitFor(async () => {
+                expect(checkAllRequestsComplete()).toEqual(true);
+            }, {timeout: 10000, interval: 1000});
+
+        })
+
+    }, 100000);
+
+})
+

package/scripts/generateRestBindings.cjs

@@ -0,0 +1,291 @@
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var execSync = require('child_process').execSync;
+var fs = require('fs');
+var path = require('path');
+var Handlebars = require('handlebars');
+var args = process.argv.slice(2); // Slice the first two elements
+var argMap = {};
+for (var i = 0; i < args.length; i += 2) {
+    argMap[args[i]] = args[i + 1];
+}
+var createDirIfNotExists = function (dir) {
+    return !fs.existsSync(dir) ? fs.mkdirSync(dir) : undefined;
+};
+var MySQLDump = /** @class */ (function () {
+    function MySQLDump() {
+    }
+    MySQLDump.buildCNF = function (cnfFile) {
+        if (cnfFile === void 0) { cnfFile = null; }
+        if (this.mysqlcnf !== '') {
+            return this.mysqlcnf;
+        }
+        var cnf = [
+            '[client]',
+            "user = ".concat(this.DB_USER),
+            "password = ".concat(this.DB_PASS),
+            "host = ".concat(this.DB_HOST),
+            "port = ".concat(this.DB_PORT),
+            '',
+        ];
+        cnf.push("");
+        cnfFile !== null && cnfFile !== void 0 ? cnfFile : (cnfFile = path.join(process.cwd(), '/mysql.cnf'));
+        try {
+            fs.writeFileSync(cnfFile, cnf.join('\n'));
+            fs.chmodSync(cnfFile, 488);
+            console.log("Successfully created mysql.cnf file in (".concat(cnfFile, ")"));
+        }
+        catch (error) {
+            console.error("Failed to store file contents of mysql.cnf in (".concat(process.cwd(), ")"), error);
+            process.exit(1);
+        }
+        return (this.mysqlcnf = cnfFile);
+    };
+    MySQLDump.MySQLDump = function (mysqldump, data, schemas, outputFile, otherOption, specificTable) {
+        if (mysqldump === void 0) { mysqldump = null; }
+        if (data === void 0) { data = false; }
+        if (schemas === void 0) { schemas = true; }
+        if (outputFile === void 0) { outputFile = null; }
+        if (otherOption === void 0) { otherOption = ''; }
+        if (specificTable === void 0) { specificTable = null; }
+        specificTable = specificTable || '';
+        if (outputFile === null) {
+            outputFile = path.join(process.cwd(), 'mysqldump.sql');
+        }
+        if (!data && !schemas) {
+            console.warn("MysqlDump is running with --no-create-info and --no-data. Why?");
+        }
+        var defaultsExtraFile = this.buildCNF();
+        var hexBlobOption = data ? '--hex-blob ' : '--no-data ';
+        var createInfoOption = schemas ? '' : ' --no-create-info ';
+        var cmd = "".concat(mysqldump || 'mysqldump', " --defaults-extra-file=\"").concat(defaultsExtraFile, "\" ").concat(otherOption, " --skip-add-locks --single-transaction --quick ").concat(createInfoOption).concat(hexBlobOption).concat(this.DB_NAME, " ").concat(specificTable, " > '").concat(outputFile, "'");
+        this.executeAndCheckStatus(cmd);
+        return (this.mysqldump = outputFile);
+    };
+    MySQLDump.executeAndCheckStatus = function (command, exitOnFailure, output) {
+        if (exitOnFailure === void 0) { exitOnFailure = true; }
+        if (output === void 0) { output = []; }
+        try {
+            var stdout = execSync(command, { encoding: 'utf-8' });
+            output.push(stdout);
+        }
+        catch (error) {
+            console.log("The command >>  ".concat(command, " \n\t returned with a status code (").concat(error.status, "). Expecting 0 for success."));
+            console.log("Command output::\t ".concat(error.stdout));
+            if (exitOnFailure) {
+                process.exit(error.status);
+            }
+        }
+    };
+    MySQLDump.mysqlcnf = '';
+    MySQLDump.mysqldump = '';
+    MySQLDump.DB_USER = argMap['--user'] || 'root';
+    MySQLDump.DB_PASS = argMap['--pass'] || 'password';
+    MySQLDump.DB_HOST = argMap['--host'] || '127.0.0.1';
+    MySQLDump.DB_PORT = argMap['--port'] || '3306';
+    MySQLDump.DB_NAME = argMap['--dbname'] || 'carbonPHP';
+    MySQLDump.DB_PREFIX = argMap['--prefix'] || 'carbon_';
+    MySQLDump.RELATIVE_OUTPUT_DIR = argMap['--output'] || '/src/api/rest';
+    MySQLDump.OUTPUT_DIR = path.join(process.cwd(), MySQLDump.RELATIVE_OUTPUT_DIR);
+    return MySQLDump;
+}());
+createDirIfNotExists(MySQLDump.OUTPUT_DIR);
+var pathRuntimeReference = MySQLDump.RELATIVE_OUTPUT_DIR.replace(/(^\/(src\/)?)|(\/+$)/g, '');
+// Usage example
+var dumpFileLocation = MySQLDump.MySQLDump();
+function capitalizeFirstLetter(string) {
+    return string.charAt(0).toUpperCase() + string.slice(1);
+}
+function determineTypeScriptType(mysqlType) {
+    switch (mysqlType.toLowerCase()) {
+        case 'varchar':
+        case 'text':
+        case 'char':
+        case 'datetime':
+        case 'timestamp':
+        case 'date':
+            return 'string';
+        case 'int':
+        case 'bigint':
+        case 'smallint':
+        case 'decimal':
+        case 'float':
+        case 'double':
+            return 'number';
+        case 'boolean':
+        case 'tinyint(1)':
+            return 'boolean';
+        case 'json':
+            return 'any'; // or 'object' based on usage
+        default:
+            return 'string';
+    }
+}
+var parseSQLToTypeScript = function (sql) {
+    var e_1, _a, e_2, _b;
+    var tableMatches = sql.matchAll(/CREATE\s+TABLE\s+`?(\w+)`?\s+\(((.|\n)+?)\)\s*(ENGINE=.+?);/gm);
+    var tableData = {};
+    var references = [];
+    var _loop_1 = function (tableMatch) {
+        var tableName = tableMatch[1];
+        var columnDefinitions = tableMatch[2];
+        var columns = {};
+        var columnRegex = /^\s*`(\w+)` (\w+)(?:\((\d+)\))?( NOT NULL)?( AUTO_INCREMENT)?(?: DEFAULT '(\w+)')?/g;
+        var columnMatch = void 0;
+        while ((columnMatch = columnRegex.exec(columnDefinitions))) {
+            columns[columnMatch[1]] = {
+                type: columnMatch[2],
+                length: columnMatch[3] || '',
+                notNull: !!columnMatch[4],
+                autoIncrement: !!columnMatch[5],
+                defaultValue: columnMatch[6] || '',
+            };
+        }
+        // Extract primary keys
+        var primaryKeyMatch = columnDefinitions.match(/PRIMARY KEY \(([^)]+)\)/i);
+        var primaryKeys = primaryKeyMatch
+            ? primaryKeyMatch[1].split(',').map(function (key) { return key.trim().replace(/`/g, ''); })
+            : [];
+        // Extract foreign keys
+        var foreignKeyRegex = /CONSTRAINT `([^`]+)` FOREIGN KEY \(`([^`]+)`\) REFERENCES `([^`]+)` \(`([^`]+)`\)( ON DELETE (\w+))?( ON UPDATE (\w+))?/g;
+        var foreignKeyMatch = void 0;
+        while ((foreignKeyMatch = foreignKeyRegex.exec(columnDefinitions))) {
+            var constraintName = foreignKeyMatch[1];
+            var localColumn = foreignKeyMatch[2];
+            var foreignTable = foreignKeyMatch[3];
+            var foreignColumn = foreignKeyMatch[4];
+            var onDeleteAction = foreignKeyMatch[6] || null;
+            var onUpdateAction = foreignKeyMatch[8] || null;
+            references.push({
+                TABLE: tableName,
+                CONSTRAINT: constraintName,
+                FOREIGN_KEY: localColumn,
+                REFERENCES: "".concat(foreignTable, ".").concat(foreignColumn),
+                ON_DELETE: onDeleteAction,
+                ON_UPDATE: onUpdateAction
+            });
+        }
+        var tsModel = {
+            RELATIVE_OUTPUT_DIR: pathRuntimeReference,
+            TABLE_NAME: tableName,
+            TABLE_DEFINITION: tableMatch[0],
+            TABLE_CONSTRAINT: references,
+            TABLE_NAME_SHORT: tableName.replace(MySQLDump.DB_PREFIX, ''),
+            TABLE_NAME_LOWER: tableName.toLowerCase(),
+            TABLE_NAME_UPPER: tableName.toUpperCase(),
+            TABLE_NAME_PASCAL_CASE: tableName.split('_').map(capitalizeFirstLetter).join('_'),
+            TABLE_NAME_SHORT_PASCAL_CASE: tableName.replace(MySQLDump.DB_PREFIX, '').split('_').map(capitalizeFirstLetter).join('_'),
+            PRIMARY: primaryKeys.map(function (pk) { return "".concat(tableName, ".").concat(pk); }),
+            PRIMARY_SHORT: primaryKeys,
+            COLUMNS: {},
+            COLUMNS_UPPERCASE: {},
+            TYPE_VALIDATION: {},
+            REGEX_VALIDATION: {},
+            TABLE_REFERENCES: {},
+            TABLE_REFERENCED_BY: {},
+        };
+        for (var colName in columns) {
+            tsModel.COLUMNS["".concat(tableName, ".").concat(colName)] = colName;
+            tsModel.COLUMNS_UPPERCASE[colName.toUpperCase()] = tableName + '.' + colName;
+            var typescript_type = determineTypeScriptType(columns[colName].type.toLowerCase()) === "number" ? "number" : "string";
+            tsModel.TYPE_VALIDATION["".concat(tableName, ".").concat(colName)] = {
+                COLUMN_NAME: colName,
+                MYSQL_TYPE: columns[colName].type.toLowerCase(),
+                TYPESCRIPT_TYPE: typescript_type,
+                TYPESCRIPT_TYPE_IS_STRING: 'string' === typescript_type,
+                TYPESCRIPT_TYPE_IS_NUMBER: 'number' === typescript_type,
+                MAX_LENGTH: columns[colName].length,
+                AUTO_INCREMENT: columns[colName].autoIncrement,
+                SKIP_COLUMN_IN_POST: !columns[colName].notNull && !columns[colName].defaultValue,
+            };
+        }
+        tableData[tableName] = tsModel;
+    };
+    try {
+        // @ts-ignore
+        for (var tableMatches_1 = __values(tableMatches), tableMatches_1_1 = tableMatches_1.next(); !tableMatches_1_1.done; tableMatches_1_1 = tableMatches_1.next()) {
+            var tableMatch = tableMatches_1_1.value;
+            _loop_1(tableMatch);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (tableMatches_1_1 && !tableMatches_1_1.done && (_a = tableMatches_1.return)) _a.call(tableMatches_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    try {
+        for (var references_1 = __values(references), references_1_1 = references_1.next(); !references_1_1.done; references_1_1 = references_1.next()) {
+            var ref = references_1_1.value;
+            var foreignTable = ref.REFERENCES.split('.')[0];
+            var foreignColumn = ref.REFERENCES.split('.')[1];
+            var tableName = ref.TABLE;
+            var columnName = ref.FOREIGN_KEY;
+            var constraintName = ref.CONSTRAINT;
+            if (!tableData[foreignTable]) {
+                console.log("Foreign table ".concat(foreignTable, " not found for ").concat(ref.TABLE, ".").concat(ref.CONSTRAINT));
+                continue;
+            }
+            if (!tableData[foreignTable].TABLE_REFERENCED_BY) {
+                tableData[foreignTable].TABLE_REFERENCED_BY = {};
+            }
+            if (!tableData[foreignTable].TABLE_REFERENCED_BY[foreignColumn]) {
+                tableData[foreignTable].TABLE_REFERENCED_BY[foreignColumn] = [];
+            }
+            tableData[foreignTable].TABLE_REFERENCED_BY[foreignColumn].push({
+                TABLE: tableName,
+                COLUMN: columnName,
+                CONSTRAINT: constraintName
+            });
+            if (!tableData[tableName].TABLE_REFERENCES) {
+                tableData[tableName].TABLE_REFERENCES = {};
+            }
+            if (!tableData[tableName].TABLE_REFERENCES[columnName]) {
+                tableData[tableName].TABLE_REFERENCES[columnName] = [];
+            }
+            tableData[tableName].TABLE_REFERENCES[columnName].push({
+                TABLE: foreignTable,
+                COLUMN: foreignColumn,
+                CONSTRAINT: constraintName
+            });
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (references_1_1 && !references_1_1.done && (_b = references_1.return)) _b.call(references_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    var tables = Object.values(tableData);
+    return {
+        TABLES: tables,
+        RestTableNames: tables.map(function (table) { return "'" + table.TABLE_NAME + "'"; }).join('\n | '),
+        RestShortTableNames: tables.map(function (table) { return "'" + table.TABLE_NAME_SHORT + "'"; }).join('\n | '),
+        RestTableInterfaces: tables.map(function (table) { return 'i' + table.TABLE_NAME_SHORT_PASCAL_CASE; }).join('\n | '),
+    };
+};
+// use dumpFileLocation to get sql
+var sql = fs.readFileSync(dumpFileLocation, 'utf-8');
+var tableData = parseSQLToTypeScript(sql);
+// write to file
+fs.writeFileSync(path.join(process.cwd(), 'C6MySqlDump.json'), JSON.stringify(tableData));
+// import this file  src/assets/handlebars/C6.tsx.handlebars for a mustache template
+var template = fs.readFileSync(path.resolve(__dirname, 'assets/handlebars/C6.tsx.handlebars'), 'utf-8');
+fs.writeFileSync(path.join(MySQLDump.OUTPUT_DIR, 'C6.tsx'), Handlebars.compile(template)(tableData));
+var testTemplate = fs.readFileSync(path.resolve(__dirname, 'assets/handlebars/Tests.tsx.handlebars'), 'utf-8');
+Object.values(tableData.TABLES).map(function (tableData, key) {
+    var tableName = tableData.TABLE_NAME_SHORT;
+    fs.writeFileSync(path.join(MySQLDump.OUTPUT_DIR, tableName + '.tsx'), Handlebars.compile(testTemplate)(tableData));
+});
+console.log('Successfully created CarbonORM bindings!');

package/scripts/generateRestBindings.ts

@@ -0,0 +1,383 @@
+#!/usr/bin/env node
+
+const {execSync} = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const Handlebars = require('handlebars');
+
+
+const args = process.argv.slice(2);  // Slice the first two elements
+const argMap = {};
+
+for (let i = 0; i < args.length; i += 2) {
+    argMap[args[i]] = args[i + 1];
+}
+
+const createDirIfNotExists = dir =>
+    !fs.existsSync(dir) ? fs.mkdirSync(dir) : undefined;
+
+class MySQLDump {
+
+    static mysqlcnf: string = '';
+    static mysqldump: string = '';
+    static DB_USER = argMap['--user'] || 'root';
+    static DB_PASS = argMap['--pass'] || 'password';
+    static DB_HOST = argMap['--host'] || '127.0.0.1';
+    static DB_PORT = argMap['--port'] || '3306';
+    static DB_NAME = argMap['--dbname'] || 'carbonPHP';
+    static DB_PREFIX = argMap['--prefix'] || 'carbon_';
+    static RELATIVE_OUTPUT_DIR = argMap['--output'] || '/src/api/rest';
+    static OUTPUT_DIR = path.join(process.cwd(), MySQLDump.RELATIVE_OUTPUT_DIR);
+
+    static buildCNF(cnfFile = null) {
+
+        if (this.mysqlcnf !== '') {
+
+            return this.mysqlcnf;
+
+        }
+
+        const cnf = [
+            '[client]',
+            `user = ${this.DB_USER}`,
+            `password = ${this.DB_PASS}`,
+            `host = ${this.DB_HOST}`,
+            `port = ${this.DB_PORT}`,
+            '',
+        ];
+
+
+        cnf.push(``);
+
+        cnfFile ??= path.join(process.cwd(), '/mysql.cnf');
+
+        try {
+
+            fs.writeFileSync(cnfFile, cnf.join('\n'));
+
+            fs.chmodSync(cnfFile, 0o750);
+
+            console.log(`Successfully created mysql.cnf file in (${cnfFile})`);
+
+        } catch (error) {
+
+            console.error(`Failed to store file contents of mysql.cnf in (${process.cwd()})`, error);
+
+            process.exit(1);
+
+        }
+
+        return (this.mysqlcnf = cnfFile);
+
+    }
+
+    static MySQLDump(mysqldump = null, data = false, schemas = true, outputFile = null, otherOption = '', specificTable = null) {
+        specificTable = specificTable || '';
+
+        if (outputFile === null) {
+            outputFile = path.join(process.cwd(), 'mysqldump.sql');
+        }
+
+        if (!data && !schemas) {
+            console.warn("MysqlDump is running with --no-create-info and --no-data. Why?");
+        }
+
+        const defaultsExtraFile = this.buildCNF();
+
+        const hexBlobOption = data ? '--hex-blob ' : '--no-data ';
+
+        const createInfoOption = schemas ? '' : ' --no-create-info ';
+
+        const cmd = `${mysqldump || 'mysqldump'} --defaults-extra-file="${defaultsExtraFile}" ${otherOption} --skip-add-locks --single-transaction --quick ${createInfoOption}${hexBlobOption}${this.DB_NAME} ${specificTable} > '${outputFile}'`;
+
+        this.executeAndCheckStatus(cmd);
+
+        return (this.mysqldump = outputFile);
+
+    }
+
+    static executeAndCheckStatus(command, exitOnFailure = true, output = []) {
+
+        try {
+
+            const stdout = execSync(command, {encoding: 'utf-8'});
+
+            output.push(stdout);
+
+        } catch (error) {
+
+            console.log(`The command >>  ${command} \n\t returned with a status code (${error.status}). Expecting 0 for success.`);
+
+            console.log(`Command output::\t ${error.stdout}`);
+
+            if (exitOnFailure) {
+
+                process.exit(error.status);
+
+            }
+
+        }
+
+    }
+
+}
+
+createDirIfNotExists(MySQLDump.OUTPUT_DIR)
+
+const pathRuntimeReference = MySQLDump.RELATIVE_OUTPUT_DIR.replace(/(^\/(src\/)?)|(\/+$)/g, '')
+
+// Usage example
+const dumpFileLocation = MySQLDump.MySQLDump();
+
+type ColumnInfo = {
+    type: string;
+    length?: string;
+    autoIncrement: boolean;
+    notNull: boolean;
+    defaultValue?: string;
+};
+
+type foreignKeyInfo = {
+    TABLE: string,
+    CONSTRAINT: string,
+    FOREIGN_KEY: string,
+    REFERENCES: string,
+    ON_DELETE: string,
+    ON_UPDATE: string
+}
+
+function capitalizeFirstLetter(string) {
+    return string.charAt(0).toUpperCase() + string.slice(1);
+}
+
+function determineTypeScriptType(mysqlType) {
+    switch (mysqlType.toLowerCase()) {
+        case 'varchar':
+        case 'text':
+        case 'char':
+        case 'datetime':
+        case 'timestamp':
+        case 'date':
+            return 'string';
+        case 'int':
+        case 'bigint':
+        case 'smallint':
+        case 'decimal':
+        case 'float':
+        case 'double':
+            return 'number';
+        case 'boolean':
+        case 'tinyint(1)':
+            return 'boolean';
+        case 'json':
+            return 'any';  // or 'object' based on usage
+        default:
+            return 'string';
+    }
+}
+
+
+const parseSQLToTypeScript = (sql: string) => {
+
+    const tableMatches = sql.matchAll(/CREATE\s+TABLE\s+`?(\w+)`?\s+\(((.|\n)+?)\)\s*(ENGINE=.+?);/gm);
+
+    let tableData: {
+        [TableName: string]: {
+            RELATIVE_OUTPUT_DIR: string,
+            TABLE_NAME: string,
+            TABLE_DEFINITION: string,
+            TABLE_CONSTRAINT: {},
+            TABLE_NAME_SHORT: string,
+            TABLE_NAME_LOWER: string,
+            TABLE_NAME_UPPER: string,
+            TABLE_NAME_PASCAL_CASE: string,
+            TABLE_NAME_SHORT_PASCAL_CASE: string,
+            TABLE_REFERENCED_BY?: {},
+            TABLE_REFERENCES?: {},
+            PRIMARY: string[],
+            PRIMARY_SHORT: string[],
+            COLUMNS: {},
+            COLUMNS_UPPERCASE: {},
+            TYPE_VALIDATION: {},
+            REGEX_VALIDATION: {},
+        }
+    } = {};
+
+    let references: foreignKeyInfo[] = [];
+
+    // @ts-ignore
+    for (const tableMatch of tableMatches) {
+
+        const tableName = tableMatch[1];
+        const columnDefinitions = tableMatch[2];
+
+        let columns: any = {};
+        const columnRegex: RegExp = /^\s*`(\w+)` (\w+)(?:\((\d+)\))?( NOT NULL)?( AUTO_INCREMENT)?(?: DEFAULT '(\w+)')?/g;
+        let columnMatch: RegExpExecArray | null;
+
+        while ((columnMatch = columnRegex.exec(columnDefinitions))) {
+            columns[columnMatch[1]] = {
+                type: columnMatch[2],
+                length: columnMatch[3] || '',
+                notNull: !!columnMatch[4],
+                autoIncrement: !!columnMatch[5],
+                defaultValue: columnMatch[6] || '',
+            };
+        }
+
+        // Extract primary keys
+        const primaryKeyMatch = columnDefinitions.match(/PRIMARY KEY \(([^)]+)\)/i);
+        const primaryKeys = primaryKeyMatch
+            ? primaryKeyMatch[1].split(',').map(key => key.trim().replace(/`/g, ''))
+            : [];
+
+        // Extract foreign keys
+        const foreignKeyRegex: RegExp = /CONSTRAINT `([^`]+)` FOREIGN KEY \(`([^`]+)`\) REFERENCES `([^`]+)` \(`([^`]+)`\)( ON DELETE (\w+))?( ON UPDATE (\w+))?/g;
+        let foreignKeyMatch: RegExpExecArray | null;
+
+        while ((foreignKeyMatch = foreignKeyRegex.exec(columnDefinitions))) {
+            const constraintName = foreignKeyMatch[1];
+            const localColumn = foreignKeyMatch[2];
+            const foreignTable = foreignKeyMatch[3];
+            const foreignColumn = foreignKeyMatch[4];
+            const onDeleteAction = foreignKeyMatch[6] || null;
+            const onUpdateAction = foreignKeyMatch[8] || null;
+
+            references.push({
+                TABLE: tableName,
+                CONSTRAINT: constraintName,
+                FOREIGN_KEY: localColumn,
+                REFERENCES: `${foreignTable}.${foreignColumn}`,
+                ON_DELETE: onDeleteAction,
+                ON_UPDATE: onUpdateAction
+            });
+
+        }
+
+        const tsModel = {
+            RELATIVE_OUTPUT_DIR: pathRuntimeReference,
+            TABLE_NAME: tableName,
+            TABLE_DEFINITION: tableMatch[0],
+            TABLE_CONSTRAINT: references,
+            TABLE_NAME_SHORT: tableName.replace(MySQLDump.DB_PREFIX, ''),
+            TABLE_NAME_LOWER: tableName.toLowerCase(),
+            TABLE_NAME_UPPER: tableName.toUpperCase(),
+            TABLE_NAME_PASCAL_CASE: tableName.split('_').map(capitalizeFirstLetter).join('_'),
+            TABLE_NAME_SHORT_PASCAL_CASE: tableName.replace(MySQLDump.DB_PREFIX, '').split('_').map(capitalizeFirstLetter).join('_'),
+            PRIMARY: primaryKeys.map(pk => `${tableName}.${pk}`),
+            PRIMARY_SHORT: primaryKeys,
+            COLUMNS: {},
+            COLUMNS_UPPERCASE: {},
+            TYPE_VALIDATION: {},
+            REGEX_VALIDATION: {},
+            TABLE_REFERENCES: {},
+            TABLE_REFERENCED_BY:{},
+        };
+
+        for (const colName in columns) {
+
+            tsModel.COLUMNS[`${tableName}.${colName}`] = colName;
+
+            tsModel.COLUMNS_UPPERCASE[colName.toUpperCase()] = tableName + '.' + colName;
+
+            const typescript_type = determineTypeScriptType(columns[colName].type.toLowerCase()) === "number" ? "number" : "string"
+
+            tsModel.TYPE_VALIDATION[`${tableName}.${colName}`] = {
+                COLUMN_NAME: colName,
+                MYSQL_TYPE: columns[colName].type.toLowerCase(),
+                TYPESCRIPT_TYPE: typescript_type,
+                TYPESCRIPT_TYPE_IS_STRING: 'string' === typescript_type,
+                TYPESCRIPT_TYPE_IS_NUMBER: 'number' === typescript_type,
+                MAX_LENGTH: columns[colName].length,
+                AUTO_INCREMENT: columns[colName].autoIncrement,
+                SKIP_COLUMN_IN_POST: !columns[colName].notNull && !columns[colName].defaultValue,
+            };
+
+        }
+
+        tableData[tableName] = tsModel;
+
+    }
+
+    for (const ref of references) {
+
+        const foreignTable = ref.REFERENCES.split('.')[0];
+        const foreignColumn = ref.REFERENCES.split('.')[1];
+        const tableName = ref.TABLE;
+        const columnName = ref.FOREIGN_KEY;
+        const constraintName = ref.CONSTRAINT;
+
+        if (!tableData[foreignTable]) {
+            console.log(`Foreign table ${foreignTable} not found for ${ref.TABLE}.${ref.CONSTRAINT}`);
+            continue;
+        }
+
+        if (!tableData[foreignTable].TABLE_REFERENCED_BY) {
+            tableData[foreignTable].TABLE_REFERENCED_BY = {};
+        }
+
+        if (!tableData[foreignTable].TABLE_REFERENCED_BY[foreignColumn]) {
+            tableData[foreignTable].TABLE_REFERENCED_BY[foreignColumn] = [];
+        }
+
+        tableData[foreignTable].TABLE_REFERENCED_BY[foreignColumn].push({
+            TABLE: tableName,
+            COLUMN: columnName,
+            CONSTRAINT: constraintName
+        });
+
+        if (!tableData[tableName].TABLE_REFERENCES) {
+            tableData[tableName].TABLE_REFERENCES = {};
+        }
+
+        if (!tableData[tableName].TABLE_REFERENCES[columnName]) {
+            tableData[tableName].TABLE_REFERENCES[columnName] = [];
+        }
+
+        tableData[tableName].TABLE_REFERENCES[columnName].push({
+            TABLE: foreignTable,
+            COLUMN: foreignColumn,
+            CONSTRAINT: constraintName
+        });
+
+    }
+
+    const tables = Object.values(tableData);
+
+
+    return {
+        TABLES: tables,
+        RestTableNames: tables.map(table => "'" + table.TABLE_NAME + "'").join('\n | '),
+        RestShortTableNames: tables.map(table => "'" + table.TABLE_NAME_SHORT + "'").join('\n | '),
+        RestTableInterfaces: tables.map(table => 'i' + table.TABLE_NAME_SHORT_PASCAL_CASE).join('\n | '),
+    };
+};
+
+
+// use dumpFileLocation to get sql
+const sql = fs.readFileSync(dumpFileLocation, 'utf-8');
+
+const tableData = parseSQLToTypeScript(sql);
+
+// write to file
+fs.writeFileSync(path.join(process.cwd(), 'C6MySqlDump.json'), JSON.stringify(tableData));
+
+
+// import this file  src/assets/handlebars/C6.tsx.handlebars for a mustache template
+
+const template = fs.readFileSync(path.resolve(__dirname, 'assets/handlebars/C6.tsx.handlebars'), 'utf-8');
+
+fs.writeFileSync(path.join(MySQLDump.OUTPUT_DIR, 'C6.tsx'), Handlebars.compile(template)(tableData));
+
+const testTemplate = fs.readFileSync(path.resolve(__dirname, 'assets/handlebars/Tests.tsx.handlebars'), 'utf-8');
+
+Object.values(tableData.TABLES).map((tableData, key) => {
+
+    const tableName = tableData.TABLE_NAME_SHORT
+
+    fs.writeFileSync(path.join(MySQLDump.OUTPUT_DIR, tableName + '.tsx'), Handlebars.compile(testTemplate)(tableData));
+
+})
+
+console.log('Successfully created CarbonORM bindings!')
+

package/src/api/interfaces/ormInterfaces.ts

@@ -22,6 +22,12 @@ export interface iTypeValidation {
     SKIP_COLUMN_IN_POST: boolean
 }
 
+export interface iConstraint {
+    TABLE: string,
+    COLUMN: string,
+    CONSTRAINT: string
+}
+
 export interface C6RestfulModel<RestShortTableNames extends string = string> {
     TABLE_NAME: RestShortTableNames,
     PRIMARY: string[],
@@ -29,4 +35,6 @@ export interface C6RestfulModel<RestShortTableNames extends string = string> {
     COLUMNS: stringMap,
     REGEX_VALIDATION: RegExpMap,
     TYPE_VALIDATION: {[key: string]: iTypeValidation},
+    TABLE_REFERENCES: {[columnName: string]: iConstraint[]},
+    TABLE_REFERENCED_BY: {[columnName: string]: iConstraint[]}
 }