parseWhereFlat added to tags. / safeParseString NOT issue fixed.

Author: JasminDreasond

src/PuddySqlTags.mjs

@@ -1,7 +1,7 @@
 import _ from 'lodash';
 import { isJsonObject } from 'tiny-essentials';
 
-/** @typedef {{ title: string; parser?: function(string): string }} SpecialQuery */
+/** @typedef {{ title: string; parser?: (value: string) => string }} SpecialQuery */
 /** @typedef {import('./PuddySqlQuery.mjs').Pcache} Pcache */
 /** @typedef {import('./PuddySqlQuery.mjs').TagCriteria} TagCriteria */
 
@@ -235,6 +235,7 @@ class PuddySqlTags {
    *
    * @param {Object} config - The special query object to be added.
    * @param {string} config.title - The unique title identifier of the special query.
+   * @param {(value: string) => string} [config.parser] The special query function to convert the final value.
    */
   addSpecialQuery(config) {
     if (!isJsonObject(config) || typeof config.title !== 'string')
@@ -520,6 +521,84 @@ class PuddySqlTags {
     return where.length ? `(${where.join(' AND ')})` : '1';
   }
 
+  /**
+   * Builds an SQL WHERE clause for "flat" tag tables (one tag per row).
+   *
+   * Works like parseWhere, but does NOT use EXISTS/json_each.
+   * Filters rows by direct equality or LIKE, supports negation (!tag),
+   * wildcards, OR/AND groups, and updates pCache for parameterized queries.
+   *
+   * @param {TagCriteria} [group={}] - Tag group definition
+   * @param {Pcache} [pCache={ index: 1, values: [] }] - Placeholder cache object
+   * @returns {string} SQL WHERE clause string
+   */
+  parseWhereFlat(group = {}, pCache = { index: 1, values: [] }) {
+    if (!isJsonObject(pCache))
+      throw new TypeError(`Expected pCache to be a valid object, but got ${typeof pCache}`);
+    if (!isJsonObject(group))
+      throw new TypeError(`Expected group to be a valid object, but got ${typeof group}`);
+    if (typeof pCache.index !== 'number')
+      throw new TypeError(`Invalid or missing pCache.index; expected number`);
+    if (!Array.isArray(pCache.values))
+      throw new TypeError(`Invalid or missing pCache.values; expected array`);
+
+    const where = [];
+    const tagsColumn = group.column || 'tag';
+    const allowWildcards = typeof group.allowWildcards === 'boolean' ? group.allowWildcards : false;
+    const include = Array.isArray(group.include) ? group.include : [];
+
+    /**
+     * @param {string} tag
+     * @returns {{ param: string; usesWildcard: boolean; not: boolean; }}
+     */
+    const filterTag = (tag) => {
+      if (typeof tag !== 'string')
+        throw new TypeError(`Each tag must be a string, but received: ${typeof tag}`);
+
+      const not = tag.startsWith('!');
+      const cleanTag = not ? tag.slice(1) : tag;
+
+      if (typeof pCache.index !== 'number') throw new Error('Invalid pCache index');
+      const param = `$${pCache.index++}`;
+
+      const usesWildcard =
+        allowWildcards &&
+        (cleanTag.includes(this.#wildcardA) || cleanTag.includes(this.#wildcardB));
+
+      const filteredTag = usesWildcard
+        ? cleanTag
+            .replace(/([%_])/g, '\\$1')
+            .replaceAll(this.#wildcardA, '%')
+            .replaceAll(this.#wildcardB, '_')
+        : cleanTag;
+
+      if (!Array.isArray(pCache.values)) throw new Error('Invalid pCache values');
+      pCache.values.push(filteredTag);
+      return { param, usesWildcard, not };
+    };
+
+    /** @param {{ param: string; usesWildcard: boolean; not: boolean; }} tagObj */
+    const createQuery = (tagObj) => {
+      const { param, usesWildcard, not } = tagObj;
+      const operator = usesWildcard ? 'LIKE' : '=';
+      return `${tagsColumn} ${not ? '!=' : operator} ${param}`;
+    };
+
+    for (const clause of include) {
+      if (Array.isArray(clause)) {
+        // OR group
+        const ors = clause.map((tag) => createQuery(filterTag(tag)));
+        if (ors.length) where.push(`(${ors.join(' OR ')})`);
+      } else {
+        // single tag
+        where.push(createQuery(filterTag(clause)));
+      }
+    }
+
+    // Combine all with AND
+    return where.length ? `(${where.join(' AND ')})` : '1';
+  }
+
   /**
    * Extracts special query elements and custom tag input groups from parsed search chunks.
    *
@@ -825,7 +904,7 @@ class PuddySqlTags {
         .map((item) => item.trim())
         .join(' AND ')
         .replace(/(?:^|[\s(,])-(?=\w)/g, (match) => match.replace('-', '!'))
-        .replace(/\bNOT\b/g, '!')
+        .replace(/\s*\bNOT\b\s*/g, '!')
         .replace(/\&\&/g, 'AND')
         .replace(/\|\|/g, 'OR'),
       strictMode,

test/index.mjs

@@ -107,8 +107,6 @@ const db = new PuddySql.Instance();
     ['tags', 'TAGS'],
   ]);
 
-  const tagManager = tagTable.getTagEditor('tags');
-
   await tagTable.set('a1', {
     title: 'Post 1',
     tags: ['cute', 'funny', 'smiling', 'safe', 'pony', 'solo'],
@@ -258,6 +256,23 @@ const db = new PuddySql.Instance();
     }),
   );
 
+  const tagManager = tagTable.getTagEditor('tags');
+  tagManager.addSpecialQuery({ title: 'rating', parser: (value) => {
+    console.log(`\n🔖 \x1b[34mRating Tag Detected: ${value}\x1b[0m\n`);
+    return value;
+  }});
+
+  const tagsList = `(pinkie pie OR rarity) AND (applejack OR rarity) AND (farm OR boutique) AND (!party OR balloons) AND rating:safe AND order:random AND NOT order:random2`;
+
+  console.log('\n🔖 \x1b[34mParse Tags: JSON\x1b[0m\n');
+  console.log(tagsList);
+  const tagParse = tagManager.safeParseString(tagsList);
+  console.log(tagParse);
+  console.log('\n🔖 \x1b[34mParse JSON: JSON\x1b[0m\n');
+  console.log(tagManager.parseWhere(tagParse));
+  console.log('\n🔖 \x1b[34mParse Tags: Normal\x1b[0m\n');
+  console.log(tagManager.parseWhereFlat(tagParse));
+
   console.log('\n✅ \x1b[1;32mAll tag tests done.\x1b[0m');
   console.log('\n🎉 \x1b[1;32mDone. Everything looks delicious! 🍮\x1b[0m\n');
 })();