spice-js 2.6.67 → 2.6.69

package/build/models/SpiceModel.js

@@ -932,6 +932,17 @@ class SpiceModel {
     }
 
     if (!columns || columns === "") return columns;
+
+    var q = function q(s) {
+      if (s === void 0) {
+        s = "";
+      }
+
+      var t = (s || "").trim();
+      if (t.startsWith("`") && t.endsWith("`")) return t;
+      return "`" + t.replace(/`/g, "``") + "`";
+    };
+
     var protectedSet = new Set(protectedAliases);
     var arraySet = new Set(arrayAliases);
     var tokens = columns.split(",");
@@ -944,43 +955,52 @@ class SpiceModel {
       if (m) {
         var alias = m[1];
         var field = m[2];
-        var explicitAs = m[3];
+        var explicitAs = m[3]; // If alias matches this.type, don't prepend again
+
+        if (alias === this.type) {
+          var _qualified = q(alias) + "." + q(field);
+
+          return explicitAs ? _qualified + " AS " + q(explicitAs) : _qualified;
+        }
 
         if (arraySet.has(alias)) {
           var proj = this.buildArrayProjection(alias, field);
 
           if (explicitAs && explicitAs !== alias + "_" + field) {
-            proj = proj.replace(/AS\s+`[^`]+`$/i, "AS `" + explicitAs + "`");
+            proj = proj.replace(/AS\s+`[^`]+`$/i, "AS " + q(explicitAs));
           }
 
           return proj;
         }
 
         if (protectedSet.has(alias)) {
-          var aliased = "`" + alias + "`." + (field.startsWith("`") ? field : "`" + field + "`");
-          return explicitAs ? aliased + " AS `" + explicitAs + "`" : aliased;
+          var aliased = q(alias) + "." + (field.startsWith("`") ? field : q(field));
+          return explicitAs ? aliased + " AS " + q(explicitAs) : aliased;
         }
 
-        var bare = col.replace(/`/g, "");
-        return "`" + this.type + "`." + bare;
+        var qualified = q(this.type) + "." + q(alias) + "." + q(field);
+        return explicitAs ? qualified + " AS " + q(explicitAs) : qualified;
       }
 
-      var looksProtected = [...protectedSet].some(a => col === a || col === "`" + a + "`" || col.startsWith(a + ".") || col.startsWith("`" + a + "`."));
+      var looksProtected = [...protectedSet].some(a => col === a || col === q(a) || col.startsWith(a + ".") || col.startsWith(q(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, "");
+        if (!col.includes(".")) {
+          var fieldQuoted = col.startsWith("`") ? col : q(col);
+          return q(this.type) + "." + fieldQuoted;
         }
 
-        return col;
+        var parts = col.split(".");
+        var safeParts = parts.map(p => {
+          var t = p.trim();
+          if (t === "" || /\w+\s*\(/.test(t)) return t;
+          return t.startsWith("`") ? t : q(t);
+        });
+        return q(this.type) + "." + safeParts.join(".");
       }
 
       if (!col.includes(".") && !col.startsWith("`")) {
-        return "`" + col + "`";
+        return q(col);
       }
 
       return col;

package/package.json

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

package/src/models/SpiceModel.js

@@ -1,4 +1,3 @@
-
 "use strict";
 
 import { MapType, DataType } from "..";
@@ -166,17 +165,15 @@ export default class SpiceModel {
               }
               case Number:
               case "number": {
-                this[i] =
-                  _.isNumber(args.args[i]) ?
-                    args.args[i]
+                this[i] = _.isNumber(args.args[i])
+                  ? args.args[i]
                   : Number(args.args[i]);
                 break;
               }
               case Boolean:
               case "boolean": {
-                this[i] =
-                  _.isBoolean(args.args[i]) ?
-                    args.args[i]
+                this[i] = _.isBoolean(args.args[i])
+                  ? args.args[i]
                   : args.args[i] == "true" ||
                     args.args[i] == 1 ||
                     args.args[i] == "True";
@@ -189,17 +186,15 @@ export default class SpiceModel {
               }
               case Array:
               case "array": {
-                this[i] =
-                  _.isArray(args.args[i]) ?
-                    args.args[i]
+                this[i] = _.isArray(args.args[i])
+                  ? args.args[i]
                   : JSON.parse(args.args[i]);
                 break;
               }
               case Object:
               case "object": {
-                this[i] =
-                  _.isObject(args.args[i]) ?
-                    args.args[i]
+                this[i] = _.isObject(args.args[i])
+                  ? args.args[i]
                   : JSON.parse(args.args[i]);
                 break;
               }
@@ -824,68 +819,88 @@ export default class SpiceModel {
     return `ARRAY rc.${safeField} FOR rc IN IFMISSINGORNULL(${safeAlias}, []) END AS \`${safeAlias}_${safeField}\``;
   }
 
+  prepColumns(columns, protectedAliases = [], arrayAliases = []) {
+    if (!columns || columns === "") return columns;
 
-prepColumns(columns, protectedAliases = [], arrayAliases = []) {
-  if (!columns || columns === "") return columns;
+    const q = (s = "") => {
+      const t = (s || "").trim();
+      if (t.startsWith("`") && t.endsWith("`")) return t;
+      return "`" + t.replace(/`/g, "``") + "`";
+    };
 
-  const protectedSet = new Set(protectedAliases);
-  const arraySet = new Set(arrayAliases);
+    const protectedSet = new Set(protectedAliases);
+    const arraySet = new Set(arrayAliases);
 
-  const tokens = columns.split(",");
+    const tokens = columns.split(",");
 
-  const out = tokens.map((raw) => {
-    let col = (raw || "").trim();
-    if (col === "" || col === "meta().id") return undefined;
+    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;
 
-    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 alias matches this.type, don't prepend again
+        if (alias === this.type) {
+          const qualified = `${q(alias)}.${q(field)}`;
+          return explicitAs ? `${qualified} AS ${q(explicitAs)}` : qualified;
+        }
 
-    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 ${q(explicitAs)}`);
+          }
+          return proj;
+        }
 
-      if (arraySet.has(alias)) {
-        let proj = this.buildArrayProjection(alias, field);
-        if (explicitAs && explicitAs !== `${alias}_${field}`) {
-          proj = proj.replace(/AS\s+`[^`]+`$/i, `AS \`${explicitAs}\``);
+        if (protectedSet.has(alias)) {
+          const aliased = `${q(alias)}.${field.startsWith("`") ? field : q(field)}`;
+          return explicitAs ? `${aliased} AS ${q(explicitAs)}` : aliased;
         }
-        return proj;
-      }
 
-      if (protectedSet.has(alias)) {
-        const aliased = `\`${alias}\`.${field.startsWith("`") ? field : `\`${field}\``}`;
-        return explicitAs ? `${aliased} AS \`${explicitAs}\`` : aliased;
+        const qualified = `${q(this.type)}.${q(alias)}.${q(field)}`;
+        return explicitAs ? `${qualified} AS ${q(explicitAs)}` : qualified;
       }
 
-      const bare = col.replace(/`/g, "");
-      return `\`${this.type}\`.${bare}`;
-    }
+      const looksProtected = [...protectedSet].some(
+        (a) =>
+          col === a ||
+          col === q(a) ||
+          col.startsWith(`${a}.`) ||
+          col.startsWith(`${q(a)}.`)
+      );
 
-    const looksProtected = [...protectedSet].some(
-      (a) => col === a || col === `\`${a}\`` || col.startsWith(`${a}.`) || col.startsWith(`\`${a}\`.`)
-    );
+      if (!looksProtected) {
+        if (!col.includes(".")) {
+          const fieldQuoted = col.startsWith("`") ? col : q(col);
+          return `${q(this.type)}.${fieldQuoted}`;
+        }
 
-    if (!looksProtected) {
-      if (!col.startsWith("`") && !col.endsWith("`") && !col.includes("(")) {
-        col = `\`${col}\``;
+        const parts = col.split(".");
+        const safeParts = parts.map((p) => {
+          const t = p.trim();
+          if (t === "" || /\w+\s*\(/.test(t)) return t;
+          return t.startsWith("`") ? t : q(t);
+        });
+        return `${q(this.type)}.${safeParts.join(".")}`;
       }
-      if (col && !col.includes(".") && !col.startsWith(this.type)) {
-        col = `\`${this.type}\`.${col.replace(/`/g, "")}`;
+
+      if (!col.includes(".") && !col.startsWith("`")) {
+        return q(col);
       }
       return col;
-    }
-
-    if (!col.includes(".") && !col.startsWith("`")) {
-      return `\`${col}\``;
-    }
-    return col;
-  });
-
-  return _.join(_.compact(out), ",");
-}
+    });
 
+    return _.join(_.compact(out), ",");
+  }
 
   filterResultsByColumns(data, columns) {
     if (columns && columns !== "") {
@@ -944,10 +959,9 @@ prepColumns(columns, protectedAliases = [], arrayAliases = []) {
 
   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}\``;
@@ -971,41 +985,49 @@ prepColumns(columns, protectedAliases = [], arrayAliases = []) {
   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 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) + "`?$");
+        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);
       const explicitAlias = aliasMatch ? aliasMatch[1] : null;
-      const colWithoutAlias = explicitAlias ? col.replace(aliasRegex, "").trim() : col;
-  
+      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];
       }
-  
+
       // For joined table columns, add default alias <table_col> if none
       if (tableName && tableName !== this.type) {
         let newAlias = explicitAlias || `${tableName}_${columnName}`;
@@ -1019,40 +1041,41 @@ prepColumns(columns, protectedAliases = [], arrayAliases = []) {
           return `${colWithoutAlias} AS \`${newAlias}\``;
         }
       }
-  
+
       return col;
     });
-  
+
     return _.join(_.compact(out), ", ");
   }
-  
 
   async list(args = {}) {
     try {
       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),
       ];
-  
+
       // Decide which aliases we can join: only when map.type===MODEL AND reference is a STRING keyspace.
       const mappedNestings = _.compact(
         _.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;
-  
+            prop.type === "array" ||
+            prop.type === Array ||
+            prop.type === DataType.ARRAY;
+
           return {
             alias,
             reference: ref.toLowerCase(), // keyspace to join
@@ -1063,18 +1086,24 @@ prepColumns(columns, protectedAliases = [], arrayAliases = []) {
           };
         })
       );
-  
+
       const protectedAliases = mappedNestings.map((m) => m.alias);
-      const arrayAliases = mappedNestings.filter((m) => m.is_array).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.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)`;
@@ -1087,9 +1116,9 @@ prepColumns(columns, protectedAliases = [], arrayAliases = []) {
       } else {
         query = deletedCondition;
       }
-  
+
       if (hasSQLInjection(query)) return [];
-  
+
       // LIMIT/OFFSET/SORT
       args.limit = Number(args.limit) || undefined;
       args.offset = Number(args.offset) || 0;
@@ -1103,16 +1132,18 @@ prepColumns(columns, protectedAliases = [], arrayAliases = []) {
             )
             .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 cached = await this.getCacheProviderObject(this.type).get(cacheKey);
+        const cached = await this.getCacheProviderObject(this.type).get(
+          cacheKey
+        );
         results = cached?.value;
         const isEmpty = cached?.value === undefined;
         const refresh = await this.shouldForceRefresh(cached);
@@ -1127,7 +1158,7 @@ prepColumns(columns, protectedAliases = [], arrayAliases = []) {
       } 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(
@@ -1138,11 +1169,11 @@ prepColumns(columns, protectedAliases = [], arrayAliases = []) {
           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) {
@@ -1150,7 +1181,6 @@ prepColumns(columns, protectedAliases = [], arrayAliases = []) {
       throw e;
     }
   }
-  
 
   async fetchResults(args, query) {
     if (args.is_custom_query === "true" && args.ids.length > 0) {
@@ -1249,7 +1279,6 @@ prepColumns(columns, protectedAliases = [], arrayAliases = []) {
 
       var returned_all = await Promise.allSettled(
         _.map(classes, (obj) => {
-
           return new obj({
             ...this[_args],
             skip_cache: this[_skip_cache],
@@ -1288,7 +1317,6 @@ prepColumns(columns, protectedAliases = [], arrayAliases = []) {
     store_property,
     property
   ) {
- 
     let original_is_array = _.isArray(data);
     if (!original_is_array) {
       data = Array.of(data);
@@ -1310,7 +1338,7 @@ prepColumns(columns, protectedAliases = [], arrayAliases = []) {
         ids = _.union(ids, items);
       });
 
-      let classes = _.compact(_.isArray(Class) ? Class : [Class])
+      let classes = _.compact(_.isArray(Class) ? Class : [Class]);
       var returned_all = await Promise.allSettled(
         _.map(classes, (obj) => {
           return new obj({
@@ -1389,9 +1417,9 @@ prepColumns(columns, protectedAliases = [], arrayAliases = []) {
                   execute: async (data) => {
                     return await this.mapToObject(
                       data,
-                      _.isString(properties[i].map.reference) ?
-                        spice.models[properties[i].map.reference]
-                      : properties[i].map.reference,
+                      _.isString(properties[i].map.reference)
+                        ? spice.models[properties[i].map.reference]
+                        : properties[i].map.reference,
                       i,
                       properties[i].map.destination || i,
                       properties[i]
@@ -1407,9 +1435,9 @@ prepColumns(columns, protectedAliases = [], arrayAliases = []) {
                   execute: async (data) => {
                     return await this.mapToObjectArray(
                       data,
-                      _.isString(properties[i].map.reference) ?
-                        spice.models[properties[i].map.reference]
-                      : properties[i].map.reference,
+                      _.isString(properties[i].map.reference)
+                        ? spice.models[properties[i].map.reference]
+                        : properties[i].map.reference,
                       i,
                       properties[i].map.destination || i,
                       properties[i]
@@ -1462,9 +1490,8 @@ prepColumns(columns, protectedAliases = [], arrayAliases = []) {
       const defaults = Object.keys(this.props).reduce((acc, key) => {
         const def = this.props[key]?.defaults?.[type];
         if (def !== undefined) {
-          acc[key] =
-            _.isFunction(def) ?
-              def({ old_data: data, new_data: old_data })
+          acc[key] = _.isFunction(def)
+            ? def({ old_data: data, new_data: old_data })
             : def;
         }
         return acc;
@@ -1497,4 +1524,3 @@ prepColumns(columns, protectedAliases = [], arrayAliases = []) {
     }
   }
 }
-