@carbonorm/carbonnode 3.8.4 → 3.9.2

package/src/api/orm/builders/JoinBuilder.ts

@@ -1,20 +1,88 @@
 import {OrmGenerics} from "../../types/ormGenerics";
 import {ConditionBuilder} from "./ConditionBuilder";
+import {C6C} from "../../C6Constants";
+import {resolveDerivedTable, isDerivedTableKey} from "../queryHelpers";
 
 export abstract class JoinBuilder<G extends OrmGenerics> extends ConditionBuilder<G>{
 
+    protected createSelectBuilder(
+        _request: any
+    ): { build(table: string, isSubSelect: boolean): { sql: string; params: any[] | Record<string, any> } } {
+        throw new Error('Subclasses must implement createSelectBuilder to support derived table serialization.');
+    }
+
     buildJoinClauses(joinArgs: any, params: any[] | Record<string, any>): string {
         let sql = '';
 
         for (const joinType in joinArgs) {
             const joinKind = joinType.replace('_', ' ').toUpperCase();
+            const entries: Array<[any, any]> = [];
+            const joinSection = joinArgs[joinType];
+
+            if (joinSection instanceof Map) {
+                joinSection.forEach((value, key) => {
+                    entries.push([key, value]);
+                });
+            } else {
+                for (const raw in joinSection) {
+                    entries.push([raw, joinSection[raw]]);
+                }
+            }
+
+            for (const [rawKey, conditions] of entries) {
+                const raw = typeof rawKey === 'string' ? rawKey : String(rawKey);
+                const [table, aliasCandidate] = raw.trim().split(/\s+/, 2);
+                if (!table) continue;
+
+                if (isDerivedTableKey(table)) {
+                    const derived = resolveDerivedTable(table);
+                    if (!derived) {
+                        throw new Error(`Derived table '${table}' was not registered. Wrap the object with derivedTable(...) before using it in JOIN.`);
+                    }
+
+                    const configuredAliasRaw = derived[C6C.AS];
+                    const configuredAlias = typeof configuredAliasRaw === 'string' ? configuredAliasRaw.trim() : '';
+                    const alias = (aliasCandidate ?? configuredAlias).trim();
+
+                    if (!alias) {
+                        throw new Error('Derived tables require an alias via C6C.AS.');
+                    }
+
+                    this.registerAlias(alias, table);
+
+                    const subRequest = derived[C6C.SUBSELECT];
+                    if (!subRequest || typeof subRequest !== 'object') {
+                        throw new Error('Derived tables must include a C6C.SUBSELECT payload.');
+                    }
+
+                    const fromTable = subRequest[C6C.FROM];
+                    if (typeof fromTable !== 'string' || fromTable.trim() === '') {
+                        throw new Error('Derived table subselects require a base table defined with C6C.FROM.');
+                    }
+
+                    const subBuilder = this.createSelectBuilder(subRequest as any);
+                    const { sql: subSql, params: subParams } = subBuilder.build(fromTable, true);
+                    const normalizedSql = this.integrateSubSelectParams(subSql, subParams, params);
 
-            for (const raw in joinArgs[joinType]) {
-                const [table, alias] = raw.split(' ');
-                this.aliasMap[alias || table] = table;
-                const onClause = this.buildBooleanJoinedConditions(joinArgs[joinType][raw], true, params);
-                const joinSql = alias ? `\`${table}\` AS \`${alias}\`` : `\`${table}\``;
-                sql += ` ${joinKind} JOIN ${joinSql} ON ${onClause}`;
+                    const formatted = normalizedSql.trim().split('\n').map(line => `  ${line}`).join('\n');
+                    const joinSql = `(\n${formatted}\n) AS \`${alias}\``;
+                    const onClause = this.buildBooleanJoinedConditions(conditions, true, params);
+                    sql += ` ${joinKind} JOIN ${joinSql}`;
+                    if (onClause) {
+                        sql += ` ON ${onClause}`;
+                    }
+                } else {
+                    const alias = aliasCandidate;
+                    if (alias) {
+                        this.registerAlias(alias, table);
+                    }
+                    const joinSql = alias ? `\`${table}\` AS \`${alias}\`` : `\`${table}\``;
+                    const onClause = this.buildBooleanJoinedConditions(conditions, true, params);
+                    sql += ` ${joinKind} JOIN ${joinSql}`;
+                    if (onClause) {
+                        sql += ` ON ${onClause}`;
+                    }
+                }
             }
         }
 
@@ -22,4 +90,47 @@ export abstract class JoinBuilder<G extends OrmGenerics> extends ConditionBuilde
 
         return sql;
     }
+
+    protected integrateSubSelectParams(
+        subSql: string,
+        subParams: any[] | Record<string, any>,
+        target: any[] | Record<string, any>
+    ): string {
+        if (!subParams) return subSql;
+
+        if (this.useNamedParams) {
+            let normalized = subSql;
+            const extras = subParams as Record<string, any>;
+            for (const key of Object.keys(extras)) {
+                const placeholder = this.addParam(target, '', extras[key]);
+                const original = `:${key}`;
+                if (original !== placeholder) {
+                    normalized = normalized.split(original).join(placeholder);
+                }
+            }
+            return normalized;
+        }
+
+        (target as any[]).push(...(subParams as any[]));
+        return subSql;
+    }
+
+    protected buildScalarSubSelect(
+        subRequest: any,
+        params: any[] | Record<string, any>
+    ): string {
+        if (!subRequest || typeof subRequest !== 'object') {
+            throw new Error('Scalar subselect requires a C6C.SUBSELECT object payload.');
+        }
+
+        const fromTable = subRequest[C6C.FROM];
+        if (typeof fromTable !== 'string' || fromTable.trim() === '') {
+            throw new Error('Scalar subselects require a base table specified with C6C.FROM.');
+        }
+
+        const subBuilder = this.createSelectBuilder(subRequest as any);
+        const { sql: subSql, params: subParams } = subBuilder.build(fromTable, true);
+        const normalized = this.integrateSubSelectParams(subSql, subParams, params).trim();
+        return `(${normalized})`;
+    }
 }

package/src/api/orm/builders/PaginationBuilder.ts

@@ -17,7 +17,7 @@ export abstract class PaginationBuilder<G extends OrmGenerics> extends JoinBuild
      * }
      * ```
      */
-    buildPaginationClause(pagination: any): string {
+    buildPaginationClause(pagination: any, params?: any[] | Record<string, any>): string {
         let sql = "";
 
         /* -------- ORDER BY -------- */
@@ -25,10 +25,27 @@ export abstract class PaginationBuilder<G extends OrmGenerics> extends JoinBuild
             const orderParts: string[] = [];
 
             for (const [key, val] of Object.entries(pagination[C6Constants.ORDER])) {
+                if (typeof key === 'string' && key.includes('.')) {
+                    this.assertValidIdentifier(key, 'ORDER BY');
+                }
                 // FUNCTION CALL: val is an array of args
                 if (Array.isArray(val)) {
+                    const identifierPathRegex = /^[A-Za-z_][A-Za-z0-9_]*\.[A-Za-z_][A-Za-z0-9_]*$/;
+                    const isNumericString = (s: string) => /^-?\d+(?:\.\d+)?$/.test(s.trim());
                     const args = val
-                        .map((arg) => Array.isArray(arg) ? this.buildAggregateField(arg) : String(arg))
+                        .map((arg) => {
+                            if (Array.isArray(arg)) return this.buildAggregateField(arg, params);
+                            if (typeof arg === 'string') {
+                                if (identifierPathRegex.test(arg)) {
+                                    this.assertValidIdentifier(arg, 'ORDER BY argument');
+                                    return arg;
+                                }
+                                // numeric-looking strings should be treated as literals
+                                if (isNumericString(arg)) return arg;
+                                return arg;
+                            }
+                            return String(arg);
+                        })
                         .join(", ");
                     orderParts.push(`${key}(${args})`);
                 }

package/src/api/orm/queries/DeleteQueryBuilder.ts

@@ -1,8 +1,13 @@
 import { OrmGenerics } from "../../types/ormGenerics";
 import { SqlBuilderResult } from "../utils/sqlUtils";
 import { JoinBuilder } from "../builders/JoinBuilder";
+import { SelectQueryBuilder } from "./SelectQueryBuilder";
 
 export class DeleteQueryBuilder<G extends OrmGenerics> extends JoinBuilder<G> {
+    protected createSelectBuilder(request: any) {
+        return new SelectQueryBuilder(this.config as any, request, this.useNamedParams);
+    }
+
     build(
         table: string
     ): SqlBuilderResult {

package/src/api/orm/queries/SelectQueryBuilder.ts

@@ -4,6 +4,10 @@ import {SqlBuilderResult} from "../utils/sqlUtils";
 
 export class SelectQueryBuilder<G extends OrmGenerics> extends PaginationBuilder<G>{
 
+    protected createSelectBuilder(request: any) {
+        return new SelectQueryBuilder(this.config as any, request, this.useNamedParams);
+    }
+
     build(
         table: string,
         isSubSelect: boolean = false
@@ -17,7 +21,7 @@ export class SelectQueryBuilder<G extends OrmGenerics> extends PaginationBuilder
         const params = this.useNamedParams ? {} : [];
         const selectList = args.SELECT ?? ['*'];
         const selectFields = selectList
-            .map((f: any) => this.buildAggregateField(f))
+            .map((f: any) => this.buildAggregateField(f, params))
             .join(', ');
 
         let sql = `SELECT ${selectFields} FROM \`${table}\``;
@@ -42,7 +46,7 @@ export class SelectQueryBuilder<G extends OrmGenerics> extends PaginationBuilder
         }
 
         if (args.PAGINATION) {
-            sql += this.buildPaginationClause(args.PAGINATION);
+            sql += this.buildPaginationClause(args.PAGINATION, params);
         } else if (!isSubSelect) {
             sql += ` LIMIT 100`;
         }

package/src/api/orm/queries/UpdateQueryBuilder.ts

@@ -2,8 +2,13 @@ import {C6C} from "../../C6Constants";
 import {OrmGenerics} from "../../types/ormGenerics";
 import { PaginationBuilder } from '../builders/PaginationBuilder';
 import {SqlBuilderResult} from "../utils/sqlUtils";
+import {SelectQueryBuilder} from "./SelectQueryBuilder";
 
 export class UpdateQueryBuilder<G extends OrmGenerics> extends PaginationBuilder<G>{
+    protected createSelectBuilder(request: any) {
+        return new SelectQueryBuilder(this.config as any, request, this.useNamedParams);
+    }
+
     private trimTablePrefix(table: string, column: string): string {
         if (!column.includes('.')) return column;
         const [prefix, col] = column.split('.', 2);
@@ -44,7 +49,7 @@ export class UpdateQueryBuilder<G extends OrmGenerics> extends PaginationBuilder
         }
 
         if (args.PAGINATION) {
-            sql += this.buildPaginationClause(args.PAGINATION);
+            sql += this.buildPaginationClause(args.PAGINATION, params);
         }
 
         return { sql, params };

package/src/api/orm/queryHelpers.ts

@@ -1,6 +1,65 @@
 // Alias a table name with a given alias
 import {C6C} from "../C6Constants";
 
+type DerivedTableSpec = Record<string, any> & {
+    [C6C.SUBSELECT]?: Record<string, any>;
+    [C6C.AS]?: string;
+};
+
+const DERIVED_TABLE_PREFIX = '__c6DerivedTable__';
+const DERIVED_ID_SYMBOL = Symbol('c6DerivedTableId');
+
+const derivedTableLookup = new Map<string, DerivedTableSpec>();
+const derivedTableReverseLookup = new WeakMap<DerivedTableSpec, string>();
+let derivedTableCounter = 0;
+
+export const isDerivedTableKey = (key: string): boolean =>
+    typeof key === 'string' && key.startsWith(DERIVED_TABLE_PREFIX);
+
+export const resolveDerivedTable = (key: string): DerivedTableSpec | undefined =>
+    derivedTableLookup.get(key);
+
+export const derivedTable = <T extends DerivedTableSpec>(spec: T): T => {
+    if (!spec || typeof spec !== 'object') {
+        throw new Error('Derived table definition must be an object.');
+    }
+
+    const aliasRaw = spec[C6C.AS];
+    if (typeof aliasRaw !== 'string' || aliasRaw.trim() === '') {
+        throw new Error('Derived tables require a non-empty alias via C6C.AS.');
+    }
+
+    if (!spec[C6C.SUBSELECT] || typeof spec[C6C.SUBSELECT] !== 'object') {
+        throw new Error('Derived tables require a nested SELECT payload under C6C.SUBSELECT.');
+    }
+
+    let id = derivedTableReverseLookup.get(spec);
+
+    if (!id) {
+        id = `${DERIVED_TABLE_PREFIX}${++derivedTableCounter}`;
+        derivedTableReverseLookup.set(spec, id);
+        derivedTableLookup.set(id, spec);
+        Object.defineProperty(spec, DERIVED_ID_SYMBOL, {
+            value: id,
+            configurable: false,
+            enumerable: false,
+            writable: false
+        });
+    }
+
+    const alias = aliasRaw.trim();
+    derivedTableLookup.set(id!, spec);
+
+    Object.defineProperty(spec, 'toString', {
+        value: () => `${id} ${alias}`,
+        configurable: true,
+        enumerable: false,
+        writable: true
+    });
+
+    return spec;
+};
+
 export const A = (tableName: string, alias: string): string =>
     `${tableName} ${alias}`;