@carbonorm/carbonnode 2.0.34 → 3.0.1

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/builders/sqlBuilder.ts

@@ -0,0 +1,173 @@
+import { C6Constants } from "api/C6Constants";
+
+export function 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(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})`;
+}
+
+export function  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}`);
+    }
+}
+
+export function  buildSelectQuery<RestShortTableNames>(table: RestShortTableNames, primary: string | undefined, args: any, isSubSelect = false): string {
+    const selectList = args?.[C6Constants.SELECT] ?? ['*'];
+    const selectFields = Array.isArray(selectList)
+        ? selectList.map(f => buildAggregateField(f)).join(', ')
+        : '*';
+
+    let sql = `SELECT ${selectFields} FROM \`${table}\``;
+
+    if (args?.[C6Constants.JOIN]) {
+        const joins = args[C6Constants.JOIN];
+        for (const joinType in joins) {
+            const joinKeyword = joinType.replace('_', ' ').toUpperCase();
+            for (const joinTable in joins[joinType]) {
+                const onClause = buildBooleanJoinedConditions(joins[joinType][joinTable]);
+                sql += ` ${joinKeyword} JOIN \`${joinTable}\` ON ${onClause}`;
+            }
+        }
+    }
+
+    if (args?.[C6Constants.WHERE]) {
+        sql += ` WHERE ${buildBooleanJoinedConditions(args[C6Constants.WHERE])}`;
+    }
+
+    if (args?.[C6Constants.GROUP_BY]) {
+        const groupByFields = Array.isArray(args[C6Constants.GROUP_BY]) ? args[C6Constants.GROUP_BY].join(', ') : args[C6Constants.GROUP_BY];
+        sql += ` GROUP BY ${groupByFields}`;
+    }
+
+    if (args?.[C6Constants.HAVING]) {
+        sql += ` HAVING ${buildBooleanJoinedConditions(args[C6Constants.HAVING])}`;
+    }
+
+    if (args?.[C6Constants.PAGINATION]) {
+        const p = args[C6Constants.PAGINATION];
+        let limitClause = '';
+
+        if (p[C6Constants.ORDER]) {
+            const orderArray = Object.entries(p[C6Constants.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 = C6Constants.TABLES['users'].PRIMARY_SHORT?.[0] ?? 'user_id';
+            sql += ` ORDER BY ${primaryKey} DESC`;
+        }*/
+
+        if (p[C6Constants.LIMIT] != null) {
+            const limit = parseInt(p[C6Constants.LIMIT], 10);
+            if (isNaN(limit) || limit < 0) {
+                throw new Error(`Invalid LIMIT: ${p[C6Constants.LIMIT]}`);
+            }
+
+            const page = parseInt(p[C6Constants.PAGE] ?? 1, 10);
+            if (isNaN(page) || page < 1) {
+                throw new Error(`PAGE must be >= 1 (got ${p[C6Constants.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;
+}

package/src/api/convertForRequestBody.ts

@@ -1,6 +1,5 @@
 import {C6Constants} from "api/C6Constants";
-import {iC6RestfulModel} from "api/interfaces/ormInterfaces";
-import {iC6Object} from "api/restRequest";
+import {iC6Object, iC6RestfulModel} from "./types/ormInterfaces";
 
 
 export default function <RestTableInterfaces extends { [key:string] : any }>(restfulObject: RestTableInterfaces, tableName: string | string[], C6: iC6Object, regexErrorHandler: (message:string) => void = alert) {

package/src/api/executors/Executor.ts

@@ -0,0 +1,26 @@
+import {apiReturn, iAPI, iRest} from "@carbonorm/carbonnode";
+import {Modify} from "../types/modifyTypes";
+
+export abstract class Executor<
+    CustomAndRequiredFields extends { [key: string]: any },           // CustomAndRequiredFields
+    RestTableInterfaces extends  { [key: string]: any },            // RestTableInterfaces
+    RequestTableOverrides = { [key in keyof RestTableInterfaces]: any },   // RequestTableOverrides
+    ResponseDataType = any,                // ResponseDataType
+    RestShortTableNames extends string = ""    // RestShortTableNames
+> {
+
+    public constructor(
+        protected config: iRest<
+            CustomAndRequiredFields,
+            RestTableInterfaces,
+            RequestTableOverrides,
+            ResponseDataType,
+            RestShortTableNames
+        >,
+        protected request: iAPI<Modify<RestTableInterfaces, RequestTableOverrides>> & CustomAndRequiredFields = {} as iAPI<Modify<RestTableInterfaces, RequestTableOverrides>> & CustomAndRequiredFields
+    ) {
+    }
+
+    abstract execute(): Promise<apiReturn<ResponseDataType>>
+
+}