@carbonorm/carbonnode 2.0.34 → 3.0.0

package/scripts/generateRestBindings.ts

@@ -24,7 +24,7 @@ class MySQLDump {
     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_NAME = argMap['--dbname'] || 'assessorly';
     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);
@@ -151,34 +151,91 @@ function capitalizeFirstLetter(string) {
     return string.charAt(0).toUpperCase() + string.slice(1);
 }
 
-function determineTypeScriptType(mysqlType) {
+function determineTypeScriptType(mysqlType: string, enumValues?: string[]): string {
+    const baseType = mysqlType.toLowerCase().replace(/\(.+?\)/, '').split(' ')[0];
 
-    switch (mysqlType.toLowerCase()) {
-        case 'varchar':
-        case 'text':
-        case 'char':
+    if (baseType === 'enum' && Array.isArray(enumValues)) {
+        return enumValues.map(val => `'${val}'`).join(' | ');
+    }
+
+    switch (mysqlType) {
+        case 'enum':
+            throw Error('An unexpected error occurred. Please report this issue to the maintainers of this script.');
+
+        // Date & Time
+        case 'time':
+        case 'year':
+        case 'date':
         case 'datetime':
         case 'timestamp':
-        case 'date':
+            return 'Date | string';
+
+        // String & Temporal
+        case 'char':
+        case 'varchar':
+        case 'text':
+        case 'tinytext':
+        case 'mediumtext':
+        case 'longtext':
+        case 'set':
             return 'string';
+
+        // Numeric
+        case 'tinyint':
+        case 'smallint':
+        case 'mediumint':
         case 'int':
+        case 'integer':
         case 'bigint':
-        case 'smallint':
         case 'decimal':
+        case 'dec':
+        case 'numeric':
         case 'float':
         case 'double':
-        case 'tinyint':
+        case 'real':
             return 'number';
+
+        // Boolean
         case 'boolean':
+        case 'bool':
             return 'boolean';
+
+        // JSON
         case 'json':
-            return 'any';  // or 'object' based on usage
+            return 'any';
+
+        // GeoJSON
+        case 'geometry':
+            return 'GeoJSON.Geometry';
+        case 'point':
+            return '{ x: number; y: number }';
+        case 'linestring':
+            return 'GeoJSON.LineString';
+        case 'polygon':
+            return 'GeoJSON.Polygon';
+        case 'multipoint':
+            return 'GeoJSON.MultiPoint';
+        case 'multilinestring':
+            return 'GeoJSON.MultiLineString';
+        case 'multipolygon':
+            return 'GeoJSON.MultiPolygon';
+        case 'geometrycollection':
+            return 'GeoJSON.GeometryCollection';
+
+        // Binary
+        case 'binary':
+        case 'varbinary':
+        case 'blob':
+        case 'tinyblob':
+        case 'mediumblob':
+        case 'longblob':
+            return 'Buffer | string';
+
         default:
             return 'string';
     }
 }
 
-
 const parseSQLToTypeScript = (sql: string) => {
 
     const tableMatches = sql.matchAll(/CREATE\s+TABLE\s+`?(\w+)`?\s+\(((.|\n)+?)\)\s*(ENGINE=.+?);/gm);
@@ -216,22 +273,37 @@ const parseSQLToTypeScript = (sql: string) => {
         let columns = {};
 
         // Improved regular expression to match column definitions
-        const columnRegex = /\s*`([^`]*)`\s+(\w+)(?:\(([^)]+)\))?\s*(NOT NULL)?\s*(AUTO_INCREMENT)?\s*(DEFAULT\s+'.*?'|DEFAULT\s+\S+)?/gm;
-
-        let columnMatch;
-
+        const columnRegex = /^\s*`([^`]+)`\s+((?:enum|set)\((?:'(?:[^']|\\')*'(?:,\s*'(?:[^']|\\')*')*)\)|[a-zA-Z0-9_]+(?:\s+unsigned)?(?:\(\d+(?:,\d+)?\))?)\s*(NOT NULL|NULL)?\s*(DEFAULT\s+(?:'[^']*'|[^\s,]+))?\s*(AUTO_INCREMENT)?/i;
 
         const columnDefinitionsLines = columnDefinitions.split('\n');
 
         columnDefinitionsLines.forEach(line => {
             if (!line.match(/(PRIMARY KEY|UNIQUE KEY|CONSTRAINT)/)) {
-                while ((columnMatch = columnRegex.exec(line))) {
-                    columns[columnMatch[1]] = {
-                        type: columnMatch[2],
-                        length: columnMatch[3] || '',
-                        notNull: !!columnMatch[4],
-                        autoIncrement: !!columnMatch[5],
-                        defaultValue: columnMatch[6] ? columnMatch[6].replace(/^DEFAULT\s+/i, '') : ''
+                const match = columnRegex.exec(line.trim());
+                if (match) {
+                    const [, name, fullTypeRaw, nullability, defaultRaw, autoInc] = match;
+
+                    const fullType = fullTypeRaw.trim();
+                    const enumMatch = /^enum\((.+)\)$/i.exec(fullType);
+                    const enumValues = enumMatch
+                        ? enumMatch[1]
+                            .split(/,(?=(?:[^']*'[^']*')*[^']*$)/) // split only top-level commas
+                            .map(s => s.trim().replace(/^'(.*)'$/, '$1'))
+                        : null;
+                    const type = fullType.replace(/\(.+?\)/, '').split(' ')[0].toLowerCase();                    const lengthMatch = fullType.match(/\(([^)]+)\)/);
+                    const length = lengthMatch ? lengthMatch[1] : '';
+
+                    const sridMatch = line.match(/SRID\s+(\d+)/i);
+                    const srid = sridMatch ? parseInt(sridMatch[1], 10) : null;
+
+                    columns[name] = {
+                        type,
+                        length,
+                        srid,
+                        enumValues,
+                        notNull: nullability?.toUpperCase() === 'NOT NULL',
+                        autoIncrement: !!autoInc,
+                        defaultValue: defaultRaw ? defaultRaw.replace(/^DEFAULT\s+/i, '') : ''
                     };
                 }
             }
@@ -269,7 +341,7 @@ const parseSQLToTypeScript = (sql: string) => {
 
         let REACT_IMPORT: false|string = false, CARBON_REACT_INSTANCE : false|string = false;
 
-        if (argMap['--react'] || false) {
+        if (argMap['--react']) {
 
             const reactArgSplit = argMap['--react'].split(';')
 
@@ -282,11 +354,12 @@ const parseSQLToTypeScript = (sql: string) => {
 
         }
 
-
         const tsModel = {
             RELATIVE_OUTPUT_DIR: pathRuntimeReference,
             TABLE_NAME: tableName,
-            TABLE_DEFINITION: tableMatch[0],
+            TABLE_DEFINITION: tableMatch[0].replace(/\/\*!([0-9]{5}) ([^*]+)\*\//g, (_match, _version, body) => {
+                return `/!* ${body.trim()} *!/`;
+            }),
             TABLE_CONSTRAINT: references,
             REST_URL_EXPRESSION: argMap['--restUrlExpression'] || '"/rest/"',
             TABLE_NAME_SHORT: tableName.replace(MySQLDump.DB_PREFIX, ''),
@@ -312,13 +385,13 @@ const parseSQLToTypeScript = (sql: string) => {
 
             tsModel.COLUMNS_UPPERCASE[colName.toUpperCase()] = tableName + '.' + colName;
 
-            const typescript_type = determineTypeScriptType(columns[colName].type.toLowerCase()) === "number" ? "number" : "string"
+            const typescript_type = determineTypeScriptType(columns[colName].type.toLowerCase(), columns[colName].enumValues)
 
             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_STRING: typescript_type === 'string' || typescript_type.includes("'"),
                 TYPESCRIPT_TYPE_IS_NUMBER: 'number' === typescript_type,
                 MAX_LENGTH: columns[colName].length,
                 AUTO_INCREMENT: columns[colName].autoIncrement,

package/src/api/carbonSqlExecutor.ts

@@ -0,0 +1,279 @@
+import {iC6Object} from "@carbonorm/carbonnode";
+import { Pool, PoolConnection, RowDataPacket } from 'mysql2/promise';
+import { Request, Response, NextFunction } from 'express';
+// import { validatePayloadAgainstSchema } from './validator'; // C6 schema validator
+
+
+export class CarbonSqlExecutor {
+
+    constructor(private pool: Pool, private C6 : iC6Object ) {}
+
+    private async withConnection<T>(cb: (conn: PoolConnection) => Promise<T>): Promise<T> {
+        const conn = await this.pool.getConnection();
+        try {
+            return await cb(conn);
+        } finally {
+            conn.release();
+        }
+    }
+
+    public async handle(req: Request, res: Response, next: NextFunction) {
+        try {
+            const method = req.method.toUpperCase();
+            const table = req.params.table;
+            const primary = req.params.primary;
+            const payload = method === 'GET' ? req.query : req.body;
+
+            if (!(table in this.C6.TABLES)){
+                res.status(400).json({ error: `Invalid table: ${table}` });
+                return;
+            }
+
+            let result: unknown;
+
+            switch (method) {
+                case 'GET':
+                case 'OPTIONS':
+                    result = await this.select(table, primary, payload);
+                    break;
+                case 'POST':
+                    result = await this.insert(table, payload);
+                    break;
+                case 'PUT':
+                    result = await this.update(table, primary, payload);
+                    break;
+                case 'DELETE':
+                    result = await this.delete(table, primary, payload);
+                    break;
+                default:
+                    throw new Error(`Unsupported method: ${method}`);
+            }
+
+            res.status(200).json({ success: true, result });
+        } catch (err) {
+            next(err);
+        }
+    }
+
+    private buildBooleanJoinedConditions(set: any, andMode = true): string {
+        const booleanOperator = andMode ? 'AND' : 'OR';
+        let sql = '';
+
+        const OPERATORS = ['=', '!=', '<', '<=', '>', '>=', 'LIKE', 'NOT LIKE', 'IN', 'NOT IN', 'IS', 'IS NOT'];
+
+        const isAggregateArray = (value: any) => Array.isArray(value) && typeof value[0] === 'string' && OPERATORS.includes(value[0]);
+
+        const isNumericKeyed = (obj: any) => Array.isArray(obj) && Object.keys(obj).every(k => /^\d+$/.test(k));
+
+        // todo - we should be doing something with value no????
+        const addCondition = (column: string, op: string, _value: any): string => {
+            const paramName = column.replace(/\W+/g, '_');
+            return `(${column} ${op} :${paramName})`;
+        };
+
+        if (isNumericKeyed(set)) {
+            switch (set.length) {
+                case 2:
+                    sql += addCondition(set[0], '=', set[1]);
+                    break;
+                case 3:
+                    if (!OPERATORS.includes(set[1])) {
+                        throw new Error(`Invalid operator: ${set[1]}`);
+                    }
+                    sql += addCondition(set[0], set[1], set[2]);
+                    break;
+                default:
+                    throw new Error(`Invalid array condition: ${JSON.stringify(set)}`);
+            }
+        } else {
+            const parts: string[] = [];
+            for (const [key, value] of Object.entries(set)) {
+                if (/^\d+$/.test(key)) {
+                    parts.push(this.buildBooleanJoinedConditions(value, !andMode));
+                    continue;
+                }
+
+                if (!Array.isArray(value) || isAggregateArray(value)) {
+                    parts.push(addCondition(key, '=', value));
+                    continue;
+                }
+
+                if (value.length === 2 && OPERATORS.includes(value[0])) {
+                    parts.push(addCondition(key, value[0], value[1]));
+                } else if (value.length === 1 && isAggregateArray(value[0])) {
+                    parts.push(addCondition(key, '=', value[0]));
+                } else {
+                    throw new Error(`Invalid condition for ${key}: ${JSON.stringify(value)}`);
+                }
+            }
+
+            sql = parts.join(` ${booleanOperator} `);
+        }
+
+        return `(${sql})`;
+    }
+
+    private buildAggregateField(field: string | any[]): string {
+        if (typeof field === 'string') return field;
+
+        if (!Array.isArray(field)) throw new Error('Invalid SELECT entry: must be string or array');
+
+        const [agg, ...args] = field;
+
+        switch (agg) {
+            case 'COUNT':
+                return `COUNT(${args[0] || '*'})`;
+            case 'SUM':
+            case 'AVG':
+            case 'MIN':
+            case 'MAX':
+                return `${agg}(${args[0]})${args[1] ? ` AS ${args[1]}` : ''}`;
+            case 'DISTINCT':
+                return `DISTINCT(${args[0]})${args[1] ? ` AS ${args[1]}` : ''}`;
+            case 'GROUP_CONCAT': {
+                const [col, alias, sortCol, sortType] = args;
+                const order = sortCol ? ` ORDER BY ${sortCol} ${sortType || 'ASC'}` : '';
+                return `GROUP_CONCAT(DISTINCT ${col}${order} SEPARATOR ',')${alias ? ` AS ${alias}` : ''}`;
+            }
+            case 'AS': {
+                const [col, alias] = args;
+                return `${col} AS ${alias}`;
+            }
+            case 'CONVERT_TZ': {
+                const [ts, fromTz, toTz] = args;
+                return `CONVERT_TZ(${ts}, ${fromTz}, ${toTz})`;
+            }
+            case 'NOW':
+                return 'NOW()';
+            default:
+                throw new Error(`Unsupported aggregate: ${agg}`);
+        }
+    }
+
+    private buildSelectQuery<RestShortTableNames>(table: RestShortTableNames, primary: string | undefined, args: any, isSubSelect = false): string {
+        const selectList = args?.[this.C6.SELECT] ?? ['*'];
+        const selectFields = Array.isArray(selectList)
+            ? selectList.map(f => this.buildAggregateField(f)).join(', ')
+            : '*';
+
+        let sql = `SELECT ${selectFields} FROM \`${table}\``;
+
+        if (args?.[this.C6.JOIN]) {
+            const joins = args[this.C6.JOIN];
+            for (const joinType in joins) {
+                const joinKeyword = joinType.replace('_', ' ').toUpperCase();
+                for (const joinTable in joins[joinType]) {
+                    const onClause = this.buildBooleanJoinedConditions(joins[joinType][joinTable]);
+                    sql += ` ${joinKeyword} JOIN \`${joinTable}\` ON ${onClause}`;
+                }
+            }
+        }
+
+        if (args?.[this.C6.WHERE]) {
+            sql += ` WHERE ${this.buildBooleanJoinedConditions(args[this.C6.WHERE])}`;
+        }
+
+        if (args?.[this.C6.GROUP_BY]) {
+            const groupByFields = Array.isArray(args[this.C6.GROUP_BY]) ? args[this.C6.GROUP_BY].join(', ') : args[this.C6.GROUP_BY];
+            sql += ` GROUP BY ${groupByFields}`;
+        }
+
+        if (args?.[this.C6.HAVING]) {
+            sql += ` HAVING ${this.buildBooleanJoinedConditions(args[this.C6.HAVING])}`;
+        }
+
+        if (args?.[this.C6.PAGINATION]) {
+            const p = args[this.C6.PAGINATION];
+            let limitClause = '';
+
+            if (p[this.C6.ORDER]) {
+                const orderArray = Object.entries(p[this.C6.ORDER]).map(([col, dir]) => {
+                    if (!['ASC', 'DESC'].includes(String(dir).toUpperCase())) {
+                        throw new Error(`Invalid order direction: ${dir}`);
+                    }
+                    return `${col} ${String(dir).toUpperCase()}`;
+                });
+                sql += ` ORDER BY ${orderArray.join(', ')}`;
+            } else if (primary) {
+                sql += ` ORDER BY ${primary} DESC`;
+            } else {
+                // todo this is wrong
+                const primaryKey = this.C6.TABLES['users'].PRIMARY_SHORT?.[0] ?? 'user_id';
+                sql += ` ORDER BY ${primaryKey} DESC`;
+            }
+
+            if (p[this.C6.LIMIT] != null) {
+                const limit = parseInt(p[this.C6.LIMIT], 10);
+                if (isNaN(limit) || limit < 0) {
+                    throw new Error(`Invalid LIMIT: ${p[this.C6.LIMIT]}`);
+                }
+
+                const page = parseInt(p[this.C6.PAGE] ?? 1, 10);
+                if (isNaN(page) || page < 1) {
+                    throw new Error(`PAGE must be >= 1 (got ${p[this.C6.PAGE]})`);
+                }
+
+                const offset = (page - 1) * limit;
+                limitClause += ` LIMIT ${offset}, ${limit}`;
+            }
+
+            sql += limitClause;
+        } else if (!isSubSelect && primary) {
+            sql += ` ORDER BY ${primary} ASC LIMIT 1`;
+        } else if (!isSubSelect && !primary) {
+            sql += ` ORDER BY id ASC LIMIT 100`; // fallback default limit
+        }
+
+        return sql;
+    }
+
+    async select<RestShortTableNames>(table: RestShortTableNames, primary: string | undefined, args: any) {
+        const sql = this.buildSelectQuery<RestShortTableNames>(table, primary, args);
+        return await this.withConnection(async (conn) => {
+            console.log(sql)
+            const [rows] = await conn.query<RowDataPacket[]>(sql);
+            return rows;
+        });
+    }
+
+    async insert<RestShortTableNames>(table: RestShortTableNames, data: any) {
+        const keys = Object.keys(data);
+        const values = keys.map(k => data[k]);
+        const placeholders = keys.map(() => '?').join(', ');
+        const sql = `INSERT INTO \`${table}\` (${keys.join(', ')}) VALUES (${placeholders})`;
+        return await this.withConnection(async (conn) => {
+            const [result] = await conn.execute(sql, values);
+            return result;
+        });
+    }
+
+    async update<RestShortTableNames>(table: RestShortTableNames, primary: string | undefined, data: any) {
+        if (!primary) {
+            throw new Error('Primary key is required for update');
+        }
+
+        const keys = Object.keys(data);
+        const values = keys.map(k => data[k]);
+        const updates = keys.map(k => `\`${k}\` = ?`).join(', ');
+        const sql = `UPDATE \`${table}\` SET ${updates} WHERE \`${primary}\` = ?`;
+        values.push(data[primary]);
+
+        return await this.withConnection(async (conn) => {
+            const [result] = await conn.execute(sql, values);
+            return result;
+        });
+    }
+
+    async delete<RestShortTableNames>(table: RestShortTableNames, primary: string | undefined, args: any) {
+        if (!primary || !args?.[primary]) {
+            throw new Error('Primary key and value required for delete');
+        }
+
+        const sql = `DELETE FROM \`${table}\` WHERE \`${primary}\` = ?`;
+        return await this.withConnection(async (conn) => {
+            const [result] = await conn.execute(sql, [args[primary]]);
+            return result;
+        });
+    }
+}
+

package/src/api/interfaces/ormInterfaces.ts

@@ -4,7 +4,7 @@ import {
     iDeleteC6RestResponse,
     iPostC6RestResponse,
     iGetC6RestResponse,
-    iPutC6RestResponse
+    iPutC6RestResponse, RequestGetPutDeleteBody
 } from "api/restRequest";
 import {AxiosResponse} from "axios";
 
@@ -32,6 +32,13 @@ export interface iTypeValidation {
     SKIP_COLUMN_IN_POST: boolean
 }
 
+export type iRestReactiveLifecycle<T extends RequestGetPutDeleteBody> = {
+    beforeProcessing?: (args: { request: T[]; requestMeta?: any }) => void | Promise<void>;
+    beforeExecution?: (args: { request: T[]; requestMeta?: any }) => void | Promise<void>;
+    afterExecution?: (args: { response: T[]; request: T[]; responseMeta?: any }) => void | Promise<void>;
+    afterCommit?: (args: { response: T[]; request: T[]; responseMeta?: any }) => void | Promise<void>;
+};
+
 export interface iConstraint {
     TABLE: string,
     COLUMN: string,
@@ -43,6 +50,7 @@ export interface iC6RestfulModel<RestShortTableNames extends string = string> {
     PRIMARY: string[],
     PRIMARY_SHORT: string[],
     COLUMNS: stringMap,
+    LIFECYCLE_HOOKS: iRestReactiveLifecycle<RequestGetPutDeleteBody>[],
     REGEX_VALIDATION: RegExpMap,
     TYPE_VALIDATION: { [key: string]: iTypeValidation },
     TABLE_REFERENCES: { [columnName: string]: iConstraint[] },