spice-js 2.6.64 → 2.6.66

package/build/models/SpiceModel.js

@@ -916,25 +916,76 @@ class SpiceModel {
     JSON.stringify(this);
   }
 
-  prepColumns(columns) {
-    if (columns && columns !== "") {
-      var columnList = columns.split(",");
-      return _.join(_.compact(columnList.map(column => {
-        if (column === "meta().id") return undefined;
+  buildArrayProjection(alias, field) {
+    var safeAlias = String(alias).replace(/`/g, "");
+    var safeField = String(field).replace(/`/g, "");
+    return "ARRAY rc." + safeField + " FOR rc IN IFMISSINGORNULL(" + safeAlias + ", []) END AS `" + safeAlias + "_" + safeField + "`";
+  }
+
+  prepColumns(columns, protectedAliases, arrayAliases) {
+    if (protectedAliases === void 0) {
+      protectedAliases = [];
+    }
+
+    if (arrayAliases === void 0) {
+      arrayAliases = [];
+    }
+
+    if (!columns || columns === "") return columns;
+    var protectedSet = new Set(protectedAliases);
+    var arraySet = new Set(arrayAliases);
+    var tokens = columns.split(",");
+    var out = tokens.map(raw => {
+      var col = (raw || "").trim();
+      if (col === "" || col === "meta().id") return undefined;
+      if (/^\s*ARRAY\s+/i.test(col) || /\w+\s*\(/.test(col)) return col;
+      var m = col.match(/^\s*`?(\w+)`?\.`?(\w+)`?(?:\s+AS\s+`?([\w]+)`?)?\s*$/i);
+
+      if (m) {
+        var alias = m[1];
+        var field = m[2];
+        var explicitAs = m[3];
+
+        if (arraySet.has(alias)) {
+          var proj = this.buildArrayProjection(alias, field);
+
+          if (explicitAs && explicitAs !== alias + "_" + field) {
+            proj = proj.replace(/AS\s+`[^`]+`$/i, "AS `" + explicitAs + "`");
+          }
 
-        if (!column.startsWith("`") && !column.endsWith("`")) {
-          column = "`" + column.trim() + "`";
+          return proj;
         }
 
-        if (column && !column.includes(".") && !column.startsWith(this.type)) {
-          column = "`" + this.type + "`." + column.trim();
+        if (protectedSet.has(alias)) {
+          var aliased = "`" + alias + "`." + (field.startsWith("`") ? field : "`" + field + "`");
+          return explicitAs ? aliased + " AS `" + explicitAs + "`" : aliased;
         }
 
-        return column;
-      })), ",");
-    }
+        var bare = col.replace(/`/g, "");
+        return "`" + this.type + "`." + bare;
+      }
+
+      var looksProtected = [...protectedSet].some(a => col === a || col === "`" + a + "`" || col.startsWith(a + ".") || col.startsWith("`" + a + "`."));
 
-    return columns;
+      if (!looksProtected) {
+        if (!col.startsWith("`") && !col.endsWith("`") && !col.includes("(")) {
+          col = "`" + col + "`";
+        }
+
+        if (col && !col.includes(".") && !col.startsWith(this.type)) {
+          col = "`" + this.type + "`." + col.replace(/`/g, "");
+        }
+
+        return col;
+      }
+
+      if (!col.includes(".") && !col.startsWith("`")) {
+        return "`" + col + "`";
+      }
+
+      return col;
+    });
+    return _.join(_.compact(out), ",");
   }
 
   filterResultsByColumns(data, columns) {
@@ -989,12 +1040,20 @@ class SpiceModel {
     return [...new Set(returnVal)];
   }
 
-  createJoinSection(nestings) {
-    return nestings.map(nesting => {
-      if (nesting.type === _2.DataType.ARRAY || nesting.type === Array || nesting.type === "array") {
-        return "LEFT NEST `" + (0, _fix.fixCollection)(nesting.reference) + "` AS `" + nesting.alias + "` ON KEYS `" + this.type + "`.`" + nesting.alias + "`";
+  createJoinSection(mappedNestings) {
+    if (!mappedNestings || mappedNestings.length === 0) return "";
+    return mappedNestings.map((_ref2) => {
+      var {
+        alias,
+        reference,
+        is_array
+      } = _ref2;
+      var keyspace = (0, _fix.fixCollection)(reference);
+
+      if (is_array === true) {
+        return "LEFT NEST `" + keyspace + "` AS `" + alias + "` ON KEYS `" + this.type + "`.`" + alias + "`";
       } else {
-        return "LEFT JOIN `" + (0, _fix.fixCollection)(nesting.reference) + "` AS `" + nesting.alias + "` ON KEYS `" + this.type + "`.`" + nesting.alias + "`";
+        return "LEFT JOIN `" + keyspace + "` AS `" + alias + "` ON KEYS `" + this.type + "`.`" + alias + "`";
       }
     }).join(" ");
   }
@@ -1009,67 +1068,63 @@ class SpiceModel {
   } */
 
 
-  fixColumnName(columns) {
-    // Guard clause: if columns is not provided or not a string, return it as-is.
-    if (!columns || typeof columns !== "string") {
-      return columns;
-    } // Split the columns string on commas and trim each column expression.
+  fixColumnName(columns, protectedAliases) {
+    if (protectedAliases === void 0) {
+      protectedAliases = [];
+    }
+
+    if (!columns || typeof columns !== "string") return columns;
+    var protectedSet = new Set(protectedAliases);
+    var tokens = columns.split(",").map(s => s.trim());
+    var aliasTracker = {};
+    var out = tokens.map(col => {
+      if (!col) return undefined; // Do not rewrite ARRAY projections
 
+      if (/^\s*ARRAY\s+/i.test(col)) return col; // If token is literally this.type.alias → compress to `alias`
+
+      for (var a of protectedSet) {
+        var re = new RegExp("^`?" + _.escapeRegExp(this.type) + "`?\\.`?" + _.escapeRegExp(a) + "`?$");
+
+        if (re.test(col)) {
+          return "`" + a + "`";
+        }
+      } // Extract explicit AS
 
-    var columnList = columns.split(",").map(col => col.trim()); // Object to keep track of alias usage to avoid duplicates.
 
-    var aliasTracker = {};
-    var fixedColumns = columnList.map(col => {
-      // Check if an explicit alias is already provided.
       var aliasRegex = /\s+AS\s+`?([\w]+)`?$/i;
       var aliasMatch = col.match(aliasRegex);
-      var explicitAlias = aliasMatch ? aliasMatch[1] : null; // Remove the alias clause for easier processing.
+      var explicitAlias = aliasMatch ? aliasMatch[1] : null;
+      var colWithoutAlias = explicitAlias ? col.replace(aliasRegex, "").trim() : col; // `table`.`col` or table.col
 
-      var colWithoutAlias = explicitAlias ? col.replace(aliasRegex, "").trim() : col; // Use regex to extract the table and column names.
-      // This regex matches optional backticks around each identifier.
-
-      var tableName = this.type;
-      var columnName = "";
       var columnRegex = /^`?([\w]+)`?\.`?([\w]+)`?$/;
       var match = colWithoutAlias.match(columnRegex);
+      var tableName = this.type;
+      var columnName = colWithoutAlias.replace(/`/g, "");
 
       if (match) {
         tableName = match[1];
         columnName = match[2];
-      } else {
-        // If no table prefix is found, use the column name only.
-        columnName = colWithoutAlias.replace(/`/g, "");
-      } // Generate the alias.
-      // If the column comes from a table different from this.type, then the alias
-      // becomes tableName_columnName. Otherwise, just use the column name.
-
+      } // For joined table columns, add default alias <table_col> if none
 
-      var newAlias = columnName;
 
       if (tableName && tableName !== this.type) {
-        newAlias = tableName + "_" + columnName; // If an explicit alias was provided, favor that.
-
-        if (explicitAlias) {
-          newAlias = explicitAlias;
-        } // Avoid duplicates by appending a count if needed.
-
-
-        if (aliasTracker.hasOwnProperty(newAlias)) {
-          aliasTracker[newAlias]++;
-          newAlias = newAlias + "_" + aliasTracker[newAlias];
-        } else {
-          aliasTracker[newAlias] = 0;
-        } // If there's no explicit alias, add an alias clause.
-
+        var newAlias = explicitAlias || tableName + "_" + columnName;
 
         if (!explicitAlias) {
+          if (aliasTracker.hasOwnProperty(newAlias)) {
+            aliasTracker[newAlias]++;
+            newAlias = newAlias + "_" + aliasTracker[newAlias];
+          } else {
+            aliasTracker[newAlias] = 0;
+          }
+
           return colWithoutAlias + " AS `" + newAlias + "`";
         }
       }
 
       return col;
     });
-    return fixedColumns.join(", ");
+    return _.join(_.compact(out), ", ");
   }
 
   list(args) {
@@ -1083,38 +1138,55 @@ class SpiceModel {
       try {
         var _args6, _args7, _args8;
 
-        args.columns = _this12.prepColumns(args.columns);
-        if (args.mapping_dept) _this12[_mapping_dept] = args.mapping_dept;
-        var nestings = [..._this12.extractNestings((_args6 = args) == null ? void 0 : _args6.query, _this12.type), ..._this12.extractNestings((_args7 = args) == null ? void 0 : _args7.columns, _this12.type), ..._this12.extractNestings((_args8 = args) == null ? void 0 : _args8.sort, _this12.type)];
-        args.columns = _this12.fixColumnName(args.columns);
+        if (args.mapping_dept) _this12[_mapping_dept] = args.mapping_dept; // Find alias tokens from query/columns/sort
 
-        var mappedNestings = _.compact(_.uniq(nestings).map(nesting => {
-          var _prop$map;
+        var nestings = [..._this12.extractNestings(((_args6 = args) == null ? void 0 : _args6.query) || "", _this12.type), ..._this12.extractNestings(((_args7 = args) == null ? void 0 : _args7.columns) || "", _this12.type), ..._this12.extractNestings(((_args8 = args) == null ? void 0 : _args8.sort) || "", _this12.type)]; // Decide which aliases we can join: only when map.type===MODEL AND reference is a STRING keyspace.
 
-          var prop = _this12.props[nesting];
+        var mappedNestings = _.compact(_.uniq(nestings).map(alias => {
+          var prop = _this12.props[alias];
+          if (!(prop == null ? void 0 : prop.map) || prop.map.type !== _2.MapType.MODEL) return null;
+          var ref = prop.map.reference;
 
-          if ((prop == null ? void 0 : (_prop$map = prop.map) == null ? void 0 : _prop$map.type) === _2.MapType.MODEL) {
-            return {
-              alias: nesting,
-              reference: prop.map.reference.toLowerCase(),
-              type: prop.type,
-              value_field: prop.map.value_field
-            };
+          if (typeof ref !== "string") {
+            // reference is a class/function/array-of-classes → no SQL join; serializer will handle it
+            return null;
           }
+
+          var is_array = prop.type === "array" || prop.type === Array || prop.type === _2.DataType.ARRAY;
+          return {
+            alias,
+            reference: ref.toLowerCase(),
+            // keyspace to join
+            is_array,
+            type: prop.type,
+            value_field: prop.map.value_field,
+            destination: prop.map.destination || alias
+          };
         }));
 
-        args._join = _this12.createJoinSection(mappedNestings);
+        var protectedAliases = mappedNestings.map(m => m.alias);
+        var arrayAliases = mappedNestings.filter(m => m.is_array).map(m => m.alias); // Columns: first prepare (prefix base table, rewrite array alias.field → ARRAY proj),
+        // then normalize names and add default aliases
+
+        args.columns = _this12.prepColumns(args.columns, protectedAliases, arrayAliases);
+        args.columns = _this12.fixColumnName(args.columns, protectedAliases); // Build JOIN/NEST from the mapped keyspaces
+
+        args._join = _this12.createJoinSection(mappedNestings); // WHERE
+
         var query = "";
+        var deletedCondition = "(`" + _this12.type + "`.deleted = false OR `" + _this12.type + "`.deleted IS MISSING)";
 
         if (args.is_full_text === "true" || args.is_custom_query === "true") {
-          query = args.query;
+          query = args.query || "";
+        } else if (args.filters) {
+          query = _this12.makeQueryFromFilter(args.filters);
+        } else if (args.query) {
+          query = args.query + " AND " + deletedCondition;
         } else {
-          query = args.filters ? _this12.makeQueryFromFilter(args.filters) : args.query ? args.query + " AND (`" + _this12.type + "`.deleted = false OR `" + _this12.type + "`.deleted IS MISSING)" : "(`" + _this12.type + "`.deleted = false OR `" + _this12.type + "`.deleted IS MISSING)";
+          query = deletedCondition;
         }
 
-        if ((0, _Security.hasSQLInjection)(query)) {
-          return [];
-        }
+        if ((0, _Security.hasSQLInjection)(query)) return []; // LIMIT/OFFSET/SORT
 
         args.limit = Number(args.limit) || undefined;
         args.offset = Number(args.offset) || 0;
@@ -1128,15 +1200,12 @@ class SpiceModel {
         var results;
 
         if (_this12.shouldUseCache(_this12.type)) {
-          var cachedResults = yield _this12.getCacheProviderObject(_this12.type).get(cacheKey);
-          results = cachedResults == null ? void 0 : cachedResults.value; // Check if there is no cached value
+          var cached = yield _this12.getCacheProviderObject(_this12.type).get(cacheKey);
+          results = cached == null ? void 0 : cached.value;
+          var isEmpty = (cached == null ? void 0 : cached.value) === undefined;
+          var refresh = yield _this12.shouldForceRefresh(cached);
 
-          var isCacheEmpty = (cachedResults == null ? void 0 : cachedResults.value) === undefined; // Check if the cached value should be refreshed (e.g., due to the monitor's timestamp)
-
-          var shouldRefresh = yield _this12.shouldForceRefresh(cachedResults); // Always force a refresh for "workflow" type
-
-          if (isCacheEmpty || shouldRefresh) {
-            // Force a database read and cache update
+          if (isEmpty || refresh) {
             results = yield _this12.fetchResults(args, query);
 
             _this12.getCacheProviderObject(_this12.type).set(cacheKey, {
@@ -1146,7 +1215,8 @@ class SpiceModel {
           }
         } else {
           results = yield _this12.fetchResults(args, query);
-        }
+        } // Serializer still handles class-based refs and value_field
+
 
         if (args.skip_read_serialize !== true && args.skip_serialize !== true) {
           results.data = yield _this12.do_serialize(results.data, "read", {}, args, (yield _this12.propsToBeRemoved(results.data)));
@@ -1180,12 +1250,12 @@ class SpiceModel {
     })();
   }
 
-  addHook(_ref2) {
+  addHook(_ref3) {
     var {
       operation,
       when,
       execute
-    } = _ref2;
+    } = _ref3;
 
     this[_hooks][operation][when].push(execute);
   }
@@ -1362,11 +1432,11 @@ class SpiceModel {
     })();
   }
 
-  addModifier(_ref3) {
+  addModifier(_ref4) {
     var {
       when,
       execute
-    } = _ref3;
+    } = _ref4;
 
     if (this[_serializers][when]) {
       this[_serializers][when]["modifiers"].push(execute);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spice-js",
-  "version": "2.6.64",
+  "version": "2.6.66",
   "description": "spice",
   "main": "build/index.js",
   "repository": {

package/src/models/SpiceModel.js

@@ -1,3 +1,4 @@
+
 "use strict";
 
 import { MapType, DataType } from "..";
@@ -817,32 +818,75 @@ export default class SpiceModel {
     JSON.stringify(this);
   }
 
-  prepColumns(columns) {
-    if (columns && columns !== "") {
-      let columnList = columns.split(",");
-      return _.join(
-        _.compact(
-          columnList.map((column) => {
-            if (column === "meta().id") return undefined;
-            if (!column.startsWith("`") && !column.endsWith("`")) {
-              column = `\`${column.trim()}\``;
-            }
-            if (
-              column &&
-              !column.includes(".") &&
-              !column.startsWith(this.type)
-            ) {
-              column = `\`${this.type}\`.${column.trim()}`;
-            }
-            return column;
-          })
-        ),
-        ","
-      );
-    }
-    return columns;
+  buildArrayProjection(alias, field) {
+    const safeAlias = String(alias).replace(/`/g, "");
+    const safeField = String(field).replace(/`/g, "");
+    return `ARRAY rc.${safeField} FOR rc IN IFMISSINGORNULL(${safeAlias}, []) END AS \`${safeAlias}_${safeField}\``;
   }
 
+
+prepColumns(columns, protectedAliases = [], arrayAliases = []) {
+  if (!columns || columns === "") return columns;
+
+  const protectedSet = new Set(protectedAliases);
+  const arraySet = new Set(arrayAliases);
+
+  const tokens = columns.split(",");
+
+  const out = tokens.map((raw) => {
+    let col = (raw || "").trim();
+    if (col === "" || col === "meta().id") return undefined;
+
+
+    if (/^\s*ARRAY\s+/i.test(col) || /\w+\s*\(/.test(col)) return col;
+
+    const m = col.match(/^\s*`?(\w+)`?\.`?(\w+)`?(?:\s+AS\s+`?([\w]+)`?)?\s*$/i);
+    if (m) {
+      const alias = m[1];
+      const field = m[2];
+      const explicitAs = m[3];
+
+      if (arraySet.has(alias)) {
+        let proj = this.buildArrayProjection(alias, field);
+        if (explicitAs && explicitAs !== `${alias}_${field}`) {
+          proj = proj.replace(/AS\s+`[^`]+`$/i, `AS \`${explicitAs}\``);
+        }
+        return proj;
+      }
+
+      if (protectedSet.has(alias)) {
+        const aliased = `\`${alias}\`.${field.startsWith("`") ? field : `\`${field}\``}`;
+        return explicitAs ? `${aliased} AS \`${explicitAs}\`` : aliased;
+      }
+
+      const bare = col.replace(/`/g, "");
+      return `\`${this.type}\`.${bare}`;
+    }
+
+    const looksProtected = [...protectedSet].some(
+      (a) => col === a || col === `\`${a}\`` || col.startsWith(`${a}.`) || col.startsWith(`\`${a}\`.`)
+    );
+
+    if (!looksProtected) {
+      if (!col.startsWith("`") && !col.endsWith("`") && !col.includes("(")) {
+        col = `\`${col}\``;
+      }
+      if (col && !col.includes(".") && !col.startsWith(this.type)) {
+        col = `\`${this.type}\`.${col.replace(/`/g, "")}`;
+      }
+      return col;
+    }
+
+    if (!col.includes(".") && !col.startsWith("`")) {
+      return `\`${col}\``;
+    }
+    return col;
+  });
+
+  return _.join(_.compact(out), ",");
+}
+
+
   filterResultsByColumns(data, columns) {
     if (columns && columns !== "") {
       // Remove backticks and replace meta().id with id
@@ -898,21 +942,17 @@ export default class SpiceModel {
     return [...new Set(returnVal)];
   }
 
-  createJoinSection(nestings) {
-    return nestings
-      .map((nesting) => {
-        if (
-          nesting.type === DataType.ARRAY ||
-          nesting.type === Array ||
-          nesting.type === "array"
-        ) {
-          return `LEFT NEST \`${fixCollection(nesting.reference)}\` AS \`${
-            nesting.alias
-          }\` ON KEYS \`${this.type}\`.\`${nesting.alias}\``;
+  createJoinSection(mappedNestings) {
+    if (!mappedNestings || mappedNestings.length === 0) return "";
+  
+    return mappedNestings
+      .map(({ alias, reference, is_array }) => {
+
+        const keyspace = fixCollection(reference);
+        if (is_array === true) {
+          return `LEFT NEST \`${keyspace}\` AS \`${alias}\` ON KEYS \`${this.type}\`.\`${alias}\``;
         } else {
-          return `LEFT JOIN \`${fixCollection(nesting.reference)}\` AS \`${
-            nesting.alias
-          }\` ON KEYS \`${this.type}\`.\`${nesting.alias}\``;
+          return `LEFT JOIN \`${keyspace}\` AS \`${alias}\` ON KEYS \`${this.type}\`.\`${alias}\``;
         }
       })
       .join(" ");
@@ -928,152 +968,155 @@ export default class SpiceModel {
     return str.replace(/[^a-zA-Z0-9]/g, "");
   } */
 
-  fixColumnName(columns) {
-    // Guard clause: if columns is not provided or not a string, return it as-is.
-    if (!columns || typeof columns !== "string") {
-      return columns;
-    }
-
-    // Split the columns string on commas and trim each column expression.
-    const columnList = columns.split(",").map((col) => col.trim());
-    // Object to keep track of alias usage to avoid duplicates.
+  fixColumnName(columns, protectedAliases = []) {
+    if (!columns || typeof columns !== "string") return columns;
+    const protectedSet = new Set(protectedAliases);
+  
+    const tokens = columns.split(",").map((s) => s.trim());
     const aliasTracker = {};
-
-    const fixedColumns = columnList.map((col) => {
-      // Check if an explicit alias is already provided.
+  
+    const out = tokens.map((col) => {
+      if (!col) return undefined;
+  
+      // Do not rewrite ARRAY projections
+      if (/^\s*ARRAY\s+/i.test(col)) return col;
+  
+      // If token is literally this.type.alias → compress to `alias`
+      for (const a of protectedSet) {
+        const re = new RegExp("^`?" + _.escapeRegExp(this.type) + "`?\\.`?" + _.escapeRegExp(a) + "`?$");
+        if (re.test(col)) {
+          return `\`${a}\``;
+        }
+      }
+  
+      // Extract explicit AS
       const aliasRegex = /\s+AS\s+`?([\w]+)`?$/i;
       const aliasMatch = col.match(aliasRegex);
-      let explicitAlias = aliasMatch ? aliasMatch[1] : null;
-
-      // Remove the alias clause for easier processing.
-      let colWithoutAlias =
-        explicitAlias ? col.replace(aliasRegex, "").trim() : col;
-
-      // Use regex to extract the table and column names.
-      // This regex matches optional backticks around each identifier.
-      let tableName = this.type;
-      let columnName = "";
+      const explicitAlias = aliasMatch ? aliasMatch[1] : null;
+      const colWithoutAlias = explicitAlias ? col.replace(aliasRegex, "").trim() : col;
+  
+      // `table`.`col` or table.col
       const columnRegex = /^`?([\w]+)`?\.`?([\w]+)`?$/;
       const match = colWithoutAlias.match(columnRegex);
+  
+      let tableName = this.type;
+      let columnName = colWithoutAlias.replace(/`/g, "");
       if (match) {
         tableName = match[1];
         columnName = match[2];
-      } else {
-        // If no table prefix is found, use the column name only.
-        columnName = colWithoutAlias.replace(/`/g, "");
       }
-
-      // Generate the alias.
-      // If the column comes from a table different from this.type, then the alias
-      // becomes tableName_columnName. Otherwise, just use the column name.
-      let newAlias = columnName;
+  
+      // For joined table columns, add default alias <table_col> if none
       if (tableName && tableName !== this.type) {
-        newAlias = `${tableName}_${columnName}`;
-
-        // If an explicit alias was provided, favor that.
-        if (explicitAlias) {
-          newAlias = explicitAlias;
-        }
-
-        // Avoid duplicates by appending a count if needed.
-        if (aliasTracker.hasOwnProperty(newAlias)) {
-          aliasTracker[newAlias]++;
-          newAlias = `${newAlias}_${aliasTracker[newAlias]}`;
-        } else {
-          aliasTracker[newAlias] = 0;
-        }
-
-        // If there's no explicit alias, add an alias clause.
+        let newAlias = explicitAlias || `${tableName}_${columnName}`;
         if (!explicitAlias) {
+          if (aliasTracker.hasOwnProperty(newAlias)) {
+            aliasTracker[newAlias]++;
+            newAlias = `${newAlias}_${aliasTracker[newAlias]}`;
+          } else {
+            aliasTracker[newAlias] = 0;
+          }
           return `${colWithoutAlias} AS \`${newAlias}\``;
         }
       }
+  
       return col;
     });
-
-    return fixedColumns.join(", ");
+  
+    return _.join(_.compact(out), ", ");
   }
+  
 
   async list(args = {}) {
     try {
-      args.columns = this.prepColumns(args.columns);
-
       if (args.mapping_dept) this[_mapping_dept] = args.mapping_dept;
-
+  
+      // Find alias tokens from query/columns/sort
       const nestings = [
-        ...this.extractNestings(args?.query, this.type),
-        ...this.extractNestings(args?.columns, this.type),
-        ...this.extractNestings(args?.sort, this.type),
+        ...this.extractNestings(args?.query || "", this.type),
+        ...this.extractNestings(args?.columns || "", this.type),
+        ...this.extractNestings(args?.sort || "", this.type),
       ];
-
-      args.columns = this.fixColumnName(args.columns);
-
+  
+      // Decide which aliases we can join: only when map.type===MODEL AND reference is a STRING keyspace.
       const mappedNestings = _.compact(
-        _.uniq(nestings).map((nesting) => {
-          const prop = this.props[nesting];
-          if (prop?.map?.type === MapType.MODEL) {
-            return {
-              alias: nesting,
-              reference: prop.map.reference.toLowerCase(),
-              type: prop.type,
-              value_field: prop.map.value_field,
-            };
+        _.uniq(nestings).map((alias) => {
+          const prop = this.props[alias];
+          if (!prop?.map || prop.map.type !== MapType.MODEL) return null;
+  
+          const ref = prop.map.reference;
+          if (typeof ref !== "string") {
+            // reference is a class/function/array-of-classes → no SQL join; serializer will handle it
+            return null;
           }
+  
+          const is_array =
+            prop.type === "array" || prop.type === Array || prop.type === DataType.ARRAY;
+  
+          return {
+            alias,
+            reference: ref.toLowerCase(), // keyspace to join
+            is_array,
+            type: prop.type,
+            value_field: prop.map.value_field,
+            destination: prop.map.destination || alias,
+          };
         })
       );
-
+  
+      const protectedAliases = mappedNestings.map((m) => m.alias);
+      const arrayAliases = mappedNestings.filter((m) => m.is_array).map((m) => m.alias);
+  
+      // Columns: first prepare (prefix base table, rewrite array alias.field → ARRAY proj),
+      // then normalize names and add default aliases
+      args.columns = this.prepColumns(args.columns, protectedAliases, arrayAliases);
+      args.columns = this.fixColumnName(args.columns, protectedAliases);
+  
+      // Build JOIN/NEST from the mapped keyspaces
       args._join = this.createJoinSection(mappedNestings);
-
+  
+      // WHERE
       let query = "";
+      const deletedCondition = `(\`${this.type}\`.deleted = false OR \`${this.type}\`.deleted IS MISSING)`;
       if (args.is_full_text === "true" || args.is_custom_query === "true") {
-        query = args.query;
+        query = args.query || "";
+      } else if (args.filters) {
+        query = this.makeQueryFromFilter(args.filters);
+      } else if (args.query) {
+        query = `${args.query} AND ${deletedCondition}`;
       } else {
-        query =
-          args.filters ? this.makeQueryFromFilter(args.filters)
-          : args.query ?
-            `${args.query} AND (\`${this.type}\`.deleted = false OR \`${this.type}\`.deleted IS MISSING)`
-          : `(\`${this.type}\`.deleted = false OR \`${this.type}\`.deleted IS MISSING)`;
-      }
-
-      if (hasSQLInjection(query)) {
-        return [];
+        query = deletedCondition;
       }
-
+  
+      if (hasSQLInjection(query)) return [];
+  
+      // LIMIT/OFFSET/SORT
       args.limit = Number(args.limit) || undefined;
       args.offset = Number(args.offset) || 0;
-      args.sort =
-        args.sort ?
-          args.sort
+      args.sort = args.sort
+        ? args.sort
             .split(",")
             .map((item) =>
-              item.includes(".") ? item : (
-                `\`${this.type}\`.${this.formatSortComponent(item)}`
-              )
+              item.includes(".")
+                ? item
+                : `\`${this.type}\`.${this.formatSortComponent(item)}`
             )
             .join(",")
         : `\`${this.type}\`.created_at DESC`;
-
+  
       if (args.skip_hooks !== true) {
         await this.run_hook(this, "list", "before");
       }
-
+  
       const cacheKey = `list::${this.type}::${args._join}::${query}::${args.limit}::${args.offset}::${args.sort}::${args.do_count}::${args.statement_consistent}::${args.columns}::${args.is_full_text}::${args.is_custom_query}`;
       let results;
+  
       if (this.shouldUseCache(this.type)) {
-        const cachedResults = await this.getCacheProviderObject(this.type).get(
-          cacheKey
-        );
-        results = cachedResults?.value;
-
-        // Check if there is no cached value
-        const isCacheEmpty = cachedResults?.value === undefined;
-
-        // Check if the cached value should be refreshed (e.g., due to the monitor's timestamp)
-        const shouldRefresh = await this.shouldForceRefresh(cachedResults);
-
-        // Always force a refresh for "workflow" type
-        if (isCacheEmpty || shouldRefresh) {
-          // Force a database read and cache update
+        const cached = await this.getCacheProviderObject(this.type).get(cacheKey);
+        results = cached?.value;
+        const isEmpty = cached?.value === undefined;
+        const refresh = await this.shouldForceRefresh(cached);
+        if (isEmpty || refresh) {
           results = await this.fetchResults(args, query);
           this.getCacheProviderObject(this.type).set(
             cacheKey,
@@ -1084,7 +1127,8 @@ export default class SpiceModel {
       } else {
         results = await this.fetchResults(args, query);
       }
-
+  
+      // Serializer still handles class-based refs and value_field
       if (args.skip_read_serialize !== true && args.skip_serialize !== true) {
         results.data = await this.do_serialize(
           results.data,
@@ -1094,11 +1138,11 @@ export default class SpiceModel {
           await this.propsToBeRemoved(results.data)
         );
       }
-
+  
       if (args.skip_hooks !== true) {
         await this.run_hook(results.data, "list", "after");
       }
-
+  
       results.data = this.filterResultsByColumns(results.data, args.columns);
       return results;
     } catch (e) {
@@ -1106,6 +1150,7 @@ export default class SpiceModel {
       throw e;
     }
   }
+  
 
   async fetchResults(args, query) {
     if (args.is_custom_query === "true" && args.ids.length > 0) {
@@ -1452,3 +1497,4 @@ export default class SpiceModel {
     }
   }
 }
+