spice-js 2.6.38 → 2.6.40

package/src/models/SpiceModel.js

@@ -784,333 +784,190 @@ export default class SpiceModel {
     JSON.stringify(this);
   }
 
-  async list(args) {
-    try {
-      if (!args) {
-        args = {};
-      }
+  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}\``;
+            }
+            if (
+              column &&
+              !column.includes(".") &&
+              !column.startsWith(this.type)
+            ) {
+              column = `\`${this.type}\`.${column}`;
+            }
+            return column;
+          })
+        ),
+        ","
+      );
+    }
+    return columns;
+  }
 
-      function prepColumns(columns) {
-        if (columns && columns != "") {
-          let columnList = columns.split(","); // Convert comma-separated string to array
-          return _.join(
-            _.compact(
-              _.map(columnList, (column) => {
-                if (column == "meta().id") {
-                  column = undefined;
-                } else if (!column.startsWith("`") && !column.endsWith("`")) {
-                  `\`${column}\``;
-                }
-                if (column) {
-                  if (!column.includes(".") && !column.startsWith(that.type)) {
-                    column = `\`${that.type}\`.${column}`;
-                  }
-                }
-                return column;
-              })
-            ),
-            ","
-          );
-        }
-        return columns;
-      }
+  filterResultsByColumns(data, columns) {
+    if (columns && columns !== "") {
+      columns = columns.replace(/`/g, "").replace(/meta\(\)\.id/g, "id");
+      let columnList = columns
+        .split(",")
+        .map((column) =>
+          column.includes(".") ? _.last(column.split(".")) : column
+        );
+      columnList.push("_permissions", "_permissions_", "id");
+      return data.map((entry) => _.pick(entry, columnList));
+    }
+    return data;
+  }
 
-      let query = "";
-      args.columns = prepColumns(args.columns);
-      function filterResultsByColumns(data, columns) {
-        if (columns && columns != "") {
-          columns = columns.replace(/`/g, "");
-          columns = columns.replace(/meta\(\)\.id/g, "id");
-          let columnList = columns.split(",").map((column) => {
-            //if colums has a . then remove the first part of the string
-            return column.includes(".") ? _.last(column.split(".")) : column;
-          }); // Convert comma-separated string to array
-          columnList.push("_permissions"); // Always include _permissions
-          columnList.push("_permissions_"); // Always include _permissions
-          columnList.push("id"); // Always include _permissions
-          return _.map(data, (entry) => _.pick(entry, columnList));
-        }
-        return data;
+  extractNestings(string, localType) {
+    let returnVal = [];
+    let regex = /(`?\w+`?)\.(`?\w+`?)/g;
+    let match;
+
+    while ((match = regex.exec(string)) !== null) {
+      let first = match[1].replace(/`/g, "");
+      if (first !== localType) {
+        returnVal.push(first);
       }
+    }
 
-      function extractNestings(string, localType) {
-        let returnVal = [];
+    let queryRegex = /(ANY|EVERY)\s+\w+\s+IN\s+`?(\w+)`?/g;
+    let queryMatch;
 
-        // Regex for nested properties, including backtick-quoted ones
-        let regex = /(`?\w+`?)\.(`?\w+`?)/g;
-        let match;
+    while ((queryMatch = queryRegex.exec(string)) !== null) {
+      returnVal.push(queryMatch[2]);
+    }
 
-        while ((match = regex.exec(string)) !== null) {
-          let first = match[1].replace(/`/g, "");
-          let second = match[2].replace(/`/g, "");
-          if (first !== localType) {
-            returnVal.push(first);
-          }
-        }
-        // Regex for ANY/EVERY clauses
-        let queryRegex = /(ANY|EVERY)\s+\w+\s+IN\s+`?(\w+)`?/g;
-        let queryMatch;
+    return [...new Set(returnVal)];
+  }
 
-        while ((queryMatch = queryRegex.exec(string)) !== null) {
-          returnVal.push(queryMatch[2]);
+  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}\``;
+        } else {
+          return `LEFT JOIN \`${fixCollection(nesting.reference)}\` AS \`${nesting.alias}\` ON KEYS \`${this.type}\`.\`${nesting.alias}\``;
         }
+      })
+      .join(" ");
+  }
 
-        return [...new Set(returnVal)]; // Remove duplicates
-      }
-
-      /* function extractNestings(string, localType) {
-        let returnVal = [];
-        let regex = /(\w+)\.(\w+)/g;
-        let match;
-
-        while ((match = regex.exec(string)) !== null) {
-          if (match[1] !== localType) {
-            returnVal.push(match[1]);
-          } else {
-            returnVal.push(match[2]);
-          }
-        }
+  formatSortComponent(sortComponent) {
+    const parts = sortComponent.split(" ");
+    parts[0] = `\`${parts[0]}\``;
+    return parts.join(" ");
+  }
 
-        return [...new Set(returnVal)]; // Remove duplicates
-      } */
-      /*  function extractNestings(string, localType) {
-        let returnVal = [];
-        let regex = /(\w+)\./g;
-        let match = regex.exec(string);
-        console.log("Local:", localType, match);
-        while (match) {
-          if (match[1] != localType) returnVal.push(match[1]);
-        }
-        return returnVal;
-      } */
+  removeSpaceAndSpecialCharacters(str) {
+    return str.replace(/[^a-zA-Z0-9]/g, "");
+  }
 
-      //console.log("Query", args?.query);
+  async list(args = {}) {
+    try {
+      args.columns = this.prepColumns(args.columns);
 
-      let nestings = [
-        ...extractNestings(args?.query, this.type),
-        ...extractNestings(args?.columns, this.type),
-        ...extractNestings(args?.sort, this.type),
+      const nestings = [
+        ...this.extractNestings(args?.query, this.type),
+        ...this.extractNestings(args?.columns, this.type),
+        ...this.extractNestings(args?.sort, this.type),
       ];
-      let mappedNestings = _.compact(
-        _.map(_.uniq(nestings), (nesting) => {
-          let prop = this.props[nesting];
-          if (prop) {
-            if (prop.map) {
-              if (prop.map.type == MapType.MODEL) {
-                return {
-                  alias: nesting,
-                  reference: prop.map.reference.toLowerCase(),
-                  type: prop.type,
-                  value_field: prop.map.value_field,
-                };
-              }
-            }
+
+      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,
+            };
           }
         })
       );
 
-      function createJoinSection(nestings) {
-        //create join section with nestings
-        let joinSection = "";
-        _.each(nestings, (nesting) => {
-          if (
-            nesting.type == DataType.ARRAY ||
-            nesting.type == Array ||
-            nesting.type == "array"
-          ) {
-            joinSection += `LEFT NEST \`${fixCollection(nesting.reference)}\` AS \`${nesting.alias}\` ON KEYS \`${that.type}\`.\`${nesting.alias}\` `;
-          } else {
-            joinSection += `LEFT JOIN \`${fixCollection(nesting.reference)}\` AS \`${nesting.alias}\` ON KEYS \`${that.type}\`.\`${nesting.alias}\` `;
-          }
-        });
-        return joinSection;
-      }
-      let _join = createJoinSection(mappedNestings);
-      //console.log("Props", that.type, nestings, _join, args?.query);
-
-      args._join = _join;
+      args._join = this.createJoinSection(mappedNestings);
 
-      if (
-        (args.is_full_text && args.is_full_text === "true") ||
-        (args.is_custom_query && args.is_custom_query === "true")
-      ) {
+      let query = "";
+      if (args.is_full_text === "true" || args.is_custom_query === "true") {
         query = args.query;
       } else {
-        if (args.filters) {
-          query = this.makeQueryFromFilter(args.filters);
-        } else {
-          if (args.query) {
-            query =
-              args.query +
-              ` AND (\`${this.type}\`.deleted = false OR \`${this.type}\`.deleted IS MISSING) `;
-          } else {
-            query = `(\`${this.type}\`.deleted = false OR \`${this.type}\`.deleted IS MISSING) `;
-          }
-        }
-      }
-
-      function formatSortComponent(sortComponent) {
-        // Split the string by spaces to get individual parts
-        const parts = sortComponent.split(" ");
-        // Assuming the first part is the column name, add backticks around it
-        parts[0] = `\`${parts[0]}\``;
-        // Rejoin the parts back into a string and return
-        return parts.join(" ");
+        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 [];
       }
-      if (args.limit) {
-        args.limit = Number(args.limit);
-      }
-      if (args.offset) {
-        args.offset = Number(args.offset);
-      }
 
-      if (!args.sort) {
-        args.sort = `\`${this.type}\`.created_at DESC`;
-      } else {
-        let sort_array = args.sort.split(",");
-        // check the first string in each item in the array to see if it contains a . if not then add the type
-        let new_sort_array = [];
-        for (let i = 0; i < sort_array.length; i++) {
-          if (!sort_array[i].includes(".")) {
-            new_sort_array.push(
-              `\`${this.type}\`.${formatSortComponent(sort_array[i])}`
-            );
-          } else {
-            new_sort_array.push(sort_array[i]);
-          }
-        }
-        args.sort = _.join(new_sort_array, ",");
-      }
-      if (args.skip_hooks != true) {
+      args.limit = Number(args.limit) || undefined;
+      args.offset = Number(args.offset) || 0;
+      args.sort = args.sort
+        ? args.sort
+            .split(",")
+            .map((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");
       }
-      function removeSpaceAndSpecialCharacters(str) {
-        return str.replace(/[^a-zA-Z0-9]/g, "");
-      }
-      let key = removeSpaceAndSpecialCharacters(
+
+      const cacheKey = this.removeSpaceAndSpecialCharacters(
         `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 (args.is_custom_query && args.is_custom_query === "true") {
-        if (args.ids.length > 0) {
-          if (this.shouldUseCache(this.type)) {
-            let cached_results = await this.getCacheProviderObject(
-              this.type
-            ).get(key);
-            results = cached_results?.value;
-            if (
-              cached_results?.value == undefined ||
-              (await this.shouldForceRefresh(cached_results))
-            ) {
-              results = await this.database.query(query);
-              this.getCacheProviderObject(this.type).set(
-                key,
-                { value: results, time: new Date().getTime() },
-                this.getCacheConfig(this.type)
-              );
-            }
-          } else {
-            results = await this.database.query(query);
-          }
+      if (this.shouldUseCache(this.type)) {
+        const cachedResults = await this.getCacheProviderObject(this.type).get(
+          cacheKey
+        );
+        results = cachedResults?.value;
+
+        if (!results || (await this.shouldForceRefresh(cachedResults))) {
+          results = await this.fetchResults(args, query);
+          await this.getCacheProviderObject(this.type).set(
+            cacheKey,
+            { value: results, time: new Date().getTime() },
+            this.getCacheConfig(this.type)
+          );
         }
       } else {
-        if (args.is_full_text && args.is_full_text === "true") {
-          if (this.shouldUseCache(this.type)) {
-            let cached_results = await this.getCacheProviderObject(
-              this.type
-            ).get(key);
-            results = cached_results?.value;
-            if (
-              cached_results?.value == undefined ||
-              (await this.shouldForceRefresh(cached_results))
-            ) {
-              results = await this.database.full_text_search(
-                this.type,
-                query || "",
-                args.limit,
-                args.offset,
-                args._join
-              );
-              this.getCacheProviderObject(this.type).set(
-                key,
-                { value: results, time: new Date().getTime() },
-                this.getCacheConfig(this.type)
-              );
-            }
-          } else {
-            results = await this.database.full_text_search(
-              this.type,
-              query || "",
-              args.limit,
-              args.offset,
-              args._join
-            );
-          }
-        } else {
-          if (this.shouldUseCache(this.type)) {
-            let cached_results = await this.getCacheProviderObject(
-              this.type
-            ).get(key);
-            results = cached_results?.value;
-            let shouleForceRefresh =
-              await this.shouldForceRefresh(cached_results);
-            if (cached_results?.value == undefined || shouleForceRefresh) {
-              results = await this.database.search(
-                this.type,
-                args.columns || "",
-                query || "",
-                args.limit,
-                args.offset,
-                args.sort,
-                args.do_count,
-                args.statement_consistent,
-                args._join
-              );
-              this.getCacheProviderObject(this.type).set(
-                key,
-                { value: results, time: new Date().getTime() },
-                this.getCacheConfig(this.type)
-              );
-            }
-          } else {
-            results = await this.database.search(
-              this.type,
-              args.columns || "",
-              query || "",
-              args.limit,
-              args.offset,
-              args.sort,
-              args.do_count,
-              args.statement_consistent,
-              args._join
-            );
-          }
-        }
+        results = await this.fetchResults(args, query);
       }
-      try {
-        if (args.skip_read_serialize != true && args.skip_serialize != true) {
-          results.data = await this.do_serialize(
-            results.data,
-            "read",
-            {},
-            args,
-            await this.propsToBeRemoved(results.data)
-          );
-        }
-        if (this.type == "resourcedetail");
 
-        if (args.skip_hooks != true) {
-          await this.run_hook(results.data, "list", "after");
-        }
-      } catch (e) {
-        console.log(e);
+      if (args.skip_read_serialize !== true && args.skip_serialize !== true) {
+        results.data = await this.do_serialize(
+          results.data,
+          "read",
+          {},
+          args,
+          await this.propsToBeRemoved(results.data)
+        );
       }
-      results.data = filterResultsByColumns(results.data, args.columns);
+
+      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) {
       console.log(e.stack);
@@ -1118,6 +975,33 @@ export default class SpiceModel {
     }
   }
 
+  async fetchResults(args, query) {
+    if (args.is_custom_query === "true" && args.ids.length > 0) {
+      return await this.database.query(query);
+    } else if (args.is_full_text === "true") {
+      return await this.database.full_text_search(
+        this.type,
+        query || "",
+        args.limit,
+        args.offset,
+        args._join
+      );
+    } else {
+      let result = await this.database.search(
+        this.type,
+        args.columns || "",
+        query || "",
+        args.limit,
+        args.offset,
+        args.sort,
+        args.do_count,
+        args.statement_consistent,
+        args._join
+      );
+      return result;
+    }
+  }
+
   addHook({ operation, when, execute }) {
     this[_hooks][operation][when].push(execute);
   }

package/src/storage/providers/Local.js

@@ -1,69 +1,78 @@
-let fs = require('fs-extra');
-var path = require('path');
-var open = require("open");
-let uuid = require('uuid');
-import _ from 'lodash';
+let fs = require("fs-extra");
+let uuid = require("uuid");
+import _ from "lodash";
 
-export default class Local{
-  
-    
-	constructor(args={}){
-        this.args = args;
+export default class Local {
+  constructor(args = {}) {
+    this.args = args;
+  }
+
+  async save({ files, path }) {
+    if (
+      _.has(files, "path") &&
+      _.has(files, "size") &&
+      _.has(files, "_writeStream")
+    ) {
+      files = { files };
     }
 
-    async save({files, path}){
-        if(_.has(files, 'path') && _.has(files, 'size') && _.has(files, '_writeStream')){
-          files = {files}
+    files = _.reduce(
+      _.map(_.values(files), (file) => {
+        if (!_.isArray(file)) {
+          return Array.of(file);
         }
+        return file;
+      }),
+      (accu, item) => {
+        return [...accu, ...item];
+      },
+      []
+    );
 
-        files =  _.reduce(_.map(_.values(files), (file)=>{
-            if(!_.isArray(file)){
-              return Array.of(file)
-            }
-            return file;
-        }), (accu, item)=>{
-          return [...accu, ...item];
-        }, []);
-
-        function makeDirectory(dir) {
-            if (!fs.existsSync(dir)) {
-              fs.mkdirSync(dir);
-            }
-          }
-        // Create folders 
-        let pathArray = path.split('/');
-        _.reduce(pathArray, (accu, item)=>{
-          if(item !=  accu){
-            accu = _.join([accu, item], '/'); 
-          }
-          makeDirectory(accu);
-          return accu
-        }, pathArray[0])
+    function makeDirectory(dir) {
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir);
+      }
+    }
+    // Create folders
+    let pathArray = path.split("/");
+    _.reduce(
+      pathArray,
+      (accu, item) => {
+        if (item != accu) {
+          accu = _.join([accu, item], "/");
+        }
+        makeDirectory(accu);
+        return accu;
+      },
+      pathArray[0]
+    );
 
-        // Create read stream
-        const readStreams = _.map(files, (file)=>{
-          return {file, readStream: fs.createReadStream(file.path)}
-        });
-        // Create Write Stream
-        ;
-        let paths = _.map(readStreams, (item)=>{
-          let extension = _.last(item.file.name.split("."));
-          let file_name = _.last(uuid.v4().split("-"));
-          let writeStream = fs.createWriteStream(`${path}/${file_name}.${extension}`);
-          item.readStream.pipe(writeStream);
-          item.readStream.on("end", function (err) {
-            fs.unlink(item.file.path, function (obj) { });
-          });
-          return `${path}/${file_name}.${extension}`;
-        });
+    // Create read stream
+    const readStreams = _.map(files, (file) => {
+      return { file, readStream: fs.createReadStream(file.path) };
+    });
+    // Create Write Stream
+    let paths = _.map(readStreams, (item) => {
+      let extension = _.last(item.file.name.split("."));
+      let file_name = _.last(uuid.v4().split("-"));
+      let writeStream = fs.createWriteStream(
+        `${path}/${file_name}.${extension}`
+      );
+      item.readStream.pipe(writeStream);
+      item.readStream.on("end", function (err) {
+        fs.unlink(item.file.path, function (obj) {});
+      });
+      return `${path}/${file_name}.${extension}`;
+    });
 
-        if(paths.length==1){
-          return _.first(paths);
-        }
-        return paths;
+    if (paths.length == 1) {
+      return _.first(paths);
     }
+    return paths;
+  }
 
-    async delete({path}){
-        console.log("Sending",this.args, path)
-    }
-}
+  async delete({ path }) {
+    console.log("Sending", this.args, path);
+  }
+}