webspresso 0.0.98 → 0.0.99

package/core/orm/eager-loader.js

@@ -1,31 +1,109 @@
 /**
  * Webspresso ORM - Eager Loader
- * Batch loading algorithm for relations
+ * Batch loading algorithm for relations (supports direct & arbitrary nested relations)
  * @module core/orm/eager-loader
  */
 
 const { resolveRelationModel, getRelationKeys } = require('./model');
 const { applyScopes, createScopeContext } = require('./scopes');
+const { getJsonColumns, deserializeJsonFields } = require('./json-fields');
 
 /**
- * Load relations for a set of records using batch queries
+ * Parse relation specifications into a grouped structure: Map<topLevelRelation, string[]>
+ * Supports dot notation ('author.profile'), arrays (['author', 'comments.author']),
+ * and nested relation chains of arbitrary depth.
+ * 
+ * @param {Array<string|Object>} relationNames
+ * @returns {Map<string, string[]>}
+ */
+function parseRelationTree(relationNames) {
+  const tree = new Map();
+
+  function addPath(top, nested) {
+    if (!top || typeof top !== 'string') return;
+    const cleanTop = top.trim();
+    if (!cleanTop) return;
+
+    if (!tree.has(cleanTop)) {
+      tree.set(cleanTop, []);
+    }
+    if (nested) {
+      if (Array.isArray(nested)) {
+        for (const item of nested) {
+          if (item && typeof item === 'string') tree.get(cleanTop).push(item.trim());
+        }
+      } else if (typeof nested === 'string') {
+        const cleanNested = nested.trim();
+        if (cleanNested) tree.get(cleanTop).push(cleanNested);
+      }
+    }
+  }
+
+  function processItem(item) {
+    if (!item) return;
+
+    if (typeof item === 'string') {
+      const dotIndex = item.indexOf('.');
+      if (dotIndex === -1) {
+        addPath(item);
+      } else {
+        const top = item.slice(0, dotIndex);
+        const rest = item.slice(dotIndex + 1);
+        addPath(top, rest);
+      }
+    } else if (Array.isArray(item)) {
+      for (const sub of item) {
+        processItem(sub);
+      }
+    } else if (typeof item === 'object') {
+      for (const [key, value] of Object.entries(item)) {
+        if (value === true || value == null) {
+          processItem(key);
+        } else if (typeof value === 'string' || Array.isArray(value)) {
+          const dotIndex = key.indexOf('.');
+          if (dotIndex === -1) {
+            addPath(key, value);
+          } else {
+            const top = key.slice(0, dotIndex);
+            const rest = key.slice(dotIndex + 1);
+            const nestedValues = Array.isArray(value) ? value : [value];
+            for (const v of nestedValues) {
+              addPath(top, `${rest}.${v}`);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  const list = Array.isArray(relationNames) ? relationNames : [relationNames];
+  for (const item of list) {
+    processItem(item);
+  }
+
+  return tree;
+}
+
+/**
+ * Load relations for a set of records using batch queries (supports nested relations)
  * @param {Object[]} records - Records to load relations for
- * @param {string[]} relationNames - Names of relations to load
+ * @param {Array<string|Object>} relationNames - Names of relations to load (e.g. ['author.profile', 'comments.author'])
  * @param {import('./types').ModelDefinition} model - Model definition
  * @param {import('knex').Knex|import('knex').Knex.Transaction} knex - Knex instance
  * @param {import('./types').ScopeContext} [scopeContext] - Scope context
  * @returns {Promise<Object[]>} Records with relations attached
  */
 async function loadRelations(records, relationNames, model, knex, scopeContext) {
-  if (!records.length || !relationNames.length) {
+  if (!records || !records.length || !relationNames || !relationNames.length) {
     return records;
   }
 
   const context = scopeContext || createScopeContext();
+  const tree = parseRelationTree(relationNames);
 
-  // Process each relation
-  for (const relationName of relationNames) {
-    const relation = model.relations[relationName];
+  // Process each relation grouped by top-level
+  for (const [relationName, nestedPaths] of tree.entries()) {
+    const relation = model.relations?.[relationName];
     if (!relation) {
       console.warn(`Relation "${relationName}" not found on model "${model.name}"`);
       continue;
@@ -43,6 +121,38 @@ async function loadRelations(records, relationNames, model, knex, scopeContext)
       case 'hasOne':
         await loadHasOne(records, relationName, localKey, foreignKey, relatedModel, knex, context);
         break;
+      default:
+        console.warn(`Unsupported relation type "${relation.type}" for relation "${relationName}" on model "${model.name}"`);
+        continue;
+    }
+
+    // Process nested relations if any
+    if (nestedPaths.length > 0) {
+      const childRecords = [];
+      const seenRefs = new Set();
+      const len = records.length;
+
+      for (let i = 0; i < len; i++) {
+        const child = records[i][relationName];
+        if (!child) continue;
+
+        if (Array.isArray(child)) {
+          for (let j = 0; j < child.length; j++) {
+            const item = child[j];
+            if (item && typeof item === 'object' && !seenRefs.has(item)) {
+              seenRefs.add(item);
+              childRecords.push(item);
+            }
+          }
+        } else if (typeof child === 'object' && !seenRefs.has(child)) {
+          seenRefs.add(child);
+          childRecords.push(child);
+        }
+      }
+
+      if (childRecords.length > 0) {
+        await loadRelations(childRecords, nestedPaths, relatedModel, knex, context);
+      }
     }
   }
 
@@ -116,6 +226,14 @@ async function loadBelongsTo(records, relationName, localKey, foreignKey, relate
     relatedModel
   );
 
+  const jsonCols = getJsonColumns(relatedModel);
+  if (jsonCols.size > 0) {
+    const rLen = relatedRecords.length;
+    for (let i = 0; i < rLen; i++) {
+      deserializeJsonFields(relatedRecords[i], jsonCols);
+    }
+  }
+
   const relatedMap = new Map();
   const rLen = relatedRecords.length;
   const pk = relatedModel.primaryKey;
@@ -171,6 +289,14 @@ async function loadHasMany(records, relationName, localKey, foreignKey, relatedM
     relatedModel
   );
 
+  const jsonCols = getJsonColumns(relatedModel);
+  if (jsonCols.size > 0) {
+    const rLen = relatedRecords.length;
+    for (let i = 0; i < rLen; i++) {
+      deserializeJsonFields(relatedRecords[i], jsonCols);
+    }
+  }
+
   const relatedGroups = new Map();
   const rLen = relatedRecords.length;
   for (let i = 0; i < rLen; i++) {
@@ -229,6 +355,14 @@ async function loadHasOne(records, relationName, localKey, foreignKey, relatedMo
     relatedModel
   );
 
+  const jsonCols = getJsonColumns(relatedModel);
+  if (jsonCols.size > 0) {
+    const rLen = relatedRecords.length;
+    for (let i = 0; i < rLen; i++) {
+      deserializeJsonFields(relatedRecords[i], jsonCols);
+    }
+  }
+
   const relatedMap = new Map();
   const rLen = relatedRecords.length;
   for (let i = 0; i < rLen; i++) {
@@ -247,9 +381,9 @@ async function loadHasOne(records, relationName, localKey, foreignKey, relatedMo
 }
 
 /**
- * Load a single relation for a single record
+ * Load a single relation (or nested relation path) for a single record
  * @param {Object} record - Record to load relation for
- * @param {string} relationName - Name of relation to load
+ * @param {string} relationName - Name or dot-separated path of relation to load (e.g. 'author.profile')
  * @param {import('./types').ModelDefinition} model - Model definition
  * @param {import('knex').Knex} knex - Knex instance
  * @param {import('./types').ScopeContext} [scopeContext] - Scope context
@@ -267,5 +401,5 @@ module.exports = {
   loadHasMany,
   loadHasOne,
   queryInChunks,
+  parseRelationTree,
 };
-

package/core/orm/index.js

@@ -372,9 +372,17 @@ module.exports = {
   Hooks,
   HookCancellationError,
   createEventContext,
+  // Eager loading & nested relations
+  loadRelations: require('./eager-loader').loadRelations,
+  loadRelation: require('./eager-loader').loadRelation,
+  parseRelationTree: require('./eager-loader').parseRelationTree,
   // Query Complexity & DoS Protection
   QueryComplexityError: require('./complexity').QueryComplexityError,
   validateQueryComplexity: require('./complexity').validateQueryComplexity,
   resolveQueryLimits: require('./complexity').resolveQueryLimits,
   DEFAULT_QUERY_LIMITS: require('./complexity').DEFAULT_QUERY_LIMITS,
+  // Universal Full-Text Search
+  buildSearchClause: require('./search').buildSearchClause,
+  tokenizeSearchTerm: require('./search').tokenizeSearchTerm,
+  detectDialect: require('./search').detectDialect,
 };

package/core/orm/model.js

@@ -33,6 +33,7 @@ function defineModel(options) {
     hidden = [],
     queryLimits = {},
     cache: cacheOption,
+    searchable,
   } = options;
 
   // Validate required fields
@@ -131,6 +132,9 @@ function defineModel(options) {
       allowInclude: Array.isArray(rest.allowInclude) ? rest.allowInclude.filter((x) => typeof x === 'string') : null,
     },
     hidden: Array.isArray(hidden) ? hidden : [],
+    searchable: Array.isArray(searchable)
+      ? searchable
+      : (Array.isArray(admin.searchFields) ? admin.searchFields : null),
     queryLimits: typeof queryLimits === 'object' && queryLimits !== null ? queryLimits : {},
     hooks: {},
     cache: cacheOption,

package/core/orm/query-builder.js

@@ -15,6 +15,7 @@ const {
 } = require('./json-fields');
 const { getAmbientTransaction } = require('./transaction');
 const { validateQueryComplexity } = require('./complexity');
+const { buildSearchClause } = require('./search');
 
 /**
  * Create a new query builder
@@ -232,6 +233,70 @@ class QueryBuilder {
     return this;
   }
 
+  /**
+   * Add a raw ORDER BY clause
+   * @param {string} sql - Raw SQL expression
+   * @param {Array} [bindings=[]] - Parameter bindings
+   * @returns {this}
+   */
+  orderByRaw(sql, bindings = []) {
+    this.state.orderBys.push({ raw: true, sql, bindings });
+    return this;
+  }
+
+  /**
+   * Full-Text / Keyword Search across columns
+   * Supports SQLite, PostgreSQL, and MySQL with dialect-aware FTS and tokenized LIKE fallback
+   * @param {string} term - Search query string
+   * @param {string|string[]} [columns] - Columns to search (defaults to model.searchable)
+   * @param {Object} [options] - Search options
+   * @param {'auto'|'fts'|'like'} [options.mode='auto'] - Search mode
+   * @param {string} [options.language='english'] - PostgreSQL text search language
+   * @param {boolean} [options.matchAllWords=true] - Require all words to match (AND)
+   * @param {boolean} [options.exact=false] - Match exact phrase
+   * @param {boolean} [options.rank=false] - Order by relevance rank (Postgres)
+   * @param {string} [options.ftsTable] - Separate SQLite FTS virtual table name
+   * @returns {this}
+   */
+  search(term, columns, options = {}) {
+    const activeKnex = this.getActiveKnex();
+    const clause = buildSearchClause({
+      knex: activeKnex,
+      model: this.model,
+      term,
+      columns,
+      options,
+    });
+
+    if (!clause) {
+      return this;
+    }
+
+    this.state.wheres.push({
+      raw: true,
+      sql: clause.sql,
+      bindings: clause.bindings,
+      boolean: clause.boolean || 'and',
+    });
+
+    if (clause.rankClause) {
+      this.orderByRaw(clause.rankClause.sql, clause.rankClause.bindings);
+    }
+
+    return this;
+  }
+
+  /**
+   * Add an OR Full-Text / Keyword Search clause
+   * @param {string} term - Search query string
+   * @param {string|string[]} [columns] - Columns to search
+   * @param {Object} [options] - Search options
+   * @returns {this}
+   */
+  orSearch(term, columns, options = {}) {
+    return this.search(term, columns, { ...options, boolean: 'or' });
+  }
+
   /**
    * Set LIMIT
    * @param {number} limit - Limit value
@@ -265,6 +330,15 @@ class QueryBuilder {
     return this;
   }
 
+  /**
+   * Add relations to eager load (alias for with)
+   * @param {...string} relations - Relation names or nested paths (e.g. 'author.profile')
+   * @returns {this}
+   */
+  include(...relations) {
+    return this.with(...relations);
+  }
+
   /**
    * Include soft-deleted records
    * @returns {this}
@@ -376,7 +450,11 @@ class QueryBuilder {
 
     // Apply order by
     for (const orderBy of this.state.orderBys) {
-      qb = qb.orderBy(orderBy.column, orderBy.direction);
+      if (orderBy.raw) {
+        qb = qb.orderByRaw(orderBy.sql, orderBy.bindings);
+      } else {
+        qb = qb.orderBy(orderBy.column, orderBy.direction);
+      }
     }
 
     if (includeLimitOffset) {
@@ -416,7 +494,7 @@ class QueryBuilder {
 
       const withs = self.getWiths();
       if (withs.length > 0) {
-        await loadRelations([result], ensureArray(withs), self.model, self.knex, self.scopeContext);
+        await loadRelations([result], ensureArray(withs), self.model, self.getActiveKnex(), self.scopeContext);
       }
 
       ModelEvents.emit(self.model.name, Hooks.AFTER_FIND, result, ctx);
@@ -482,7 +560,7 @@ class QueryBuilder {
 
       const withs = self.getWiths();
       if (withs.length > 0 && results.length > 0) {
-        await loadRelations(results, ensureArray(withs), self.model, self.knex, self.scopeContext);
+        await loadRelations(results, ensureArray(withs), self.model, self.getActiveKnex(), self.scopeContext);
       }
 
       for (const record of results) {
@@ -527,6 +605,14 @@ class QueryBuilder {
     return this.list();
   }
 
+  /**
+   * Alias for list()
+   * @returns {Promise<Object[]>}
+   */
+  async find() {
+    return this.list();
+  }
+
   /**
    * Execute query and return count
    * @returns {Promise<number>}
@@ -613,7 +699,7 @@ class QueryBuilder {
 
       const withs = self.getWiths();
       if (withs.length > 0 && data.length > 0) {
-        await loadRelations(data, ensureArray(withs), self.model, self.knex, self.scopeContext);
+        await loadRelations(data, ensureArray(withs), self.model, self.getActiveKnex(), self.scopeContext);
       }
 
       for (const record of data) {

package/core/orm/repository.js

@@ -73,7 +73,7 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
    * @returns {Promise<Object|null>}
    */
   async function findById(id, options = {}, emitEvents = true) {
-    const { with: withs = [], select } = options;
+    const { with: withs = options.include || [], select } = options;
     const shouldEmit = emitEvents && (
       ModelEvents.hasListeners(model.name, Hooks.BEFORE_FIND) ||
       ModelEvents.hasListeners(model.name, Hooks.AFTER_FIND)
@@ -144,7 +144,7 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
    * @returns {Promise<Object|null>}
    */
   async function findOne(conditions, options = {}) {
-    const { with: withs = [], select } = options;
+    const { with: withs = options.include || [], select } = options;
     const shouldEmit = (
       ModelEvents.hasListeners(model.name, Hooks.BEFORE_FIND) ||
       ModelEvents.hasListeners(model.name, Hooks.AFTER_FIND)
@@ -230,7 +230,7 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
    * @returns {Promise<Object[]>}
    */
   async function findAll(options = {}) {
-    const { with: withs = [], select } = options;
+    const { with: withs = options.include || [], select } = options;
     const shouldEmit = (
       ModelEvents.hasListeners(model.name, Hooks.BEFORE_FIND) ||
       ModelEvents.hasListeners(model.name, Hooks.AFTER_FIND)
@@ -619,10 +619,49 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
     return query().with(...relations);
   }
 
+  /**
+   * Find records matching conditions (with optional relations to eager load)
+   * @param {Object} [conditions={}] - WHERE conditions
+   * @param {import('./types').FindOptions} [options={}] - Find options
+   * @returns {Promise<Object[]>}
+   */
+  async function find(conditions = {}, options = {}) {
+    if (!conditions || Object.keys(conditions).length === 0) {
+      return findAll(options);
+    }
+    const withs = options.include || options.with || [];
+    let qb = query().where(conditions);
+    if (withs.length > 0) {
+      qb = qb.with(withs);
+    }
+    if (options.select && options.select.length > 0) {
+      qb = qb.select(options.select);
+    }
+    if (options.limit !== undefined) {
+      qb = qb.limit(options.limit);
+    }
+    if (options.offset !== undefined) {
+      qb = qb.offset(options.offset);
+    }
+    return qb.list();
+  }
+
+  /**
+   * Search records using Full-Text / Keyword Search
+   * @param {string} term - Search query
+   * @param {string|string[]} [columns] - Columns to search
+   * @param {Object} [options] - Search options
+   * @returns {import('./query-builder').QueryBuilder}
+   */
+  function search(term, columns, options) {
+    return query().search(term, columns, options);
+  }
+
   return {
     findById,
     findOne,
     findAll,
+    find,
     create,
     createMany,
     update,
@@ -631,10 +670,12 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
     forceDelete,
     restore,
     query,
+    search,
     raw,
     count,
     exists,
     with: withRelations,
+    include: withRelations,
     // Expose model for introspection
     model,
   };

package/core/orm/search.js

@@ -0,0 +1,213 @@
+/**
+ * Webspresso ORM - Universal Full-Text Search (FTS)
+ * Database-agnostic full-text search abstraction for SQLite, PostgreSQL, and MySQL
+ * @module core/orm/search
+ */
+
+const { ensureArray } = require('./utils');
+
+/**
+ * Detect database dialect from Knex instance
+ * @param {import('knex').Knex} knex
+ * @returns {'sqlite'|'postgres'|'mysql'|'generic'}
+ */
+function detectDialect(knex) {
+  const client = knex?.client?.config?.client || knex?.client?.dialect || '';
+  const s = String(client).toLowerCase();
+  if (s.includes('sqlite')) return 'sqlite';
+  if (s.includes('pg') || s.includes('postgres')) return 'postgres';
+  if (s.includes('mysql') || s.includes('maria')) return 'mysql';
+  return 'generic';
+}
+
+/**
+ * Tokenize search term into clean tokens, supporting quoted exact phrases
+ * e.g. 'apple "macbook pro" laptop' -> ['apple', 'macbook pro', 'laptop']
+ * @param {string} term
+ * @returns {string[]}
+ */
+function tokenizeSearchTerm(term) {
+  if (!term || typeof term !== 'string') return [];
+  const matches = term.match(/(?:[^\s"]+|"[^"]*")+/g) || [];
+  return matches
+    .map((t) => t.replace(/^"|"$/g, '').trim())
+    .filter(Boolean);
+}
+
+/**
+ * Normalize and validate search columns for a model
+ * @param {Object} model
+ * @param {string|string[]} [columns]
+ * @returns {string[]}
+ */
+function normalizeSearchColumns(model, columns) {
+  if (columns != null && (Array.isArray(columns) ? columns.length > 0 : Boolean(columns))) {
+    return ensureArray(columns);
+  }
+
+  // Fallback to model searchable fields if configured
+  if (Array.isArray(model?.searchable) && model.searchable.length > 0) {
+    return model.searchable;
+  }
+  if (Array.isArray(model?.admin?.searchFields) && model.admin.searchFields.length > 0) {
+    return model.admin.searchFields;
+  }
+
+  throw new Error(
+    `No searchable columns specified for model "${model?.name || 'Unknown'}". Pass columns to .search(term, columns) or define searchable: [...] on the model.`
+  );
+}
+
+/**
+ * Build SQL search clause and parameter bindings
+ * @param {Object} params
+ * @param {import('knex').Knex} params.knex - Knex instance
+ * @param {Object} params.model - Model definition
+ * @param {string} params.term - Search query
+ * @param {string|string[]} [params.columns] - Columns to search
+ * @param {Object} [params.options] - Search options
+ * @param {'auto'|'fts'|'like'} [params.options.mode='auto'] - Search mode
+ * @param {string} [params.options.language='english'] - PostgreSQL text search configuration
+ * @param {boolean} [params.options.matchAllWords=true] - Require all words to match (AND vs OR)
+ * @param {boolean} [params.options.exact=false] - Treat entire term as exact substring
+ * @param {boolean} [params.options.rank=false] - Order by search relevance rank (Postgres)
+ * @param {string} [params.options.ftsTable] - Separate SQLite FTS virtual table name
+ * @param {'and'|'or'} [params.options.boolean='and'] - Where condition boolean operator
+ * @returns {{ raw: true, sql: string, bindings: any[], boolean: 'and'|'or', rankClause: Object|null }|null}
+ */
+function buildSearchClause({ knex, model, term, columns, options = {} }) {
+  if (!term || typeof term !== 'string' || !term.trim()) {
+    return null;
+  }
+
+  const cleanTerm = term.trim();
+  const searchColumns = normalizeSearchColumns(model, columns);
+  const dialect = detectDialect(knex);
+  const mode = options.mode || 'auto';
+  const language = options.language || 'english';
+  const matchAllWords = options.matchAllWords !== false;
+  const exact = options.exact === true;
+  const boolean = options.boolean === 'or' ? 'or' : 'and';
+  const rank = options.rank === true;
+
+  // 1. PostgreSQL Full-Text Search (when mode is 'fts' or 'auto' on postgres)
+  if (dialect === 'postgres' && (mode === 'fts' || mode === 'auto')) {
+    const colsSql = searchColumns
+      .map((c) => `COALESCE(${knex.ref(c)}::text, '')`)
+      .join(" || ' ' || ");
+
+    const queryFn = exact || cleanTerm.includes('"')
+      ? 'websearch_to_tsquery'
+      : 'plainto_tsquery';
+
+    const sql = `to_tsvector(?, ${colsSql}) @@ ${queryFn}(?, ?)`;
+    const bindings = [language, language, cleanTerm];
+
+    let rankClause = null;
+    if (rank) {
+      rankClause = {
+        sql: `ts_rank(to_tsvector(?, ${colsSql}), ${queryFn}(?, ?)) DESC`,
+        bindings: [language, language, cleanTerm],
+      };
+    }
+
+    return {
+      raw: true,
+      sql,
+      bindings,
+      boolean,
+      rankClause,
+    };
+  }
+
+  // 2. SQLite Native FTS5 (when mode is 'fts' on sqlite)
+  if (dialect === 'sqlite' && mode === 'fts') {
+    if (options.ftsTable) {
+      const ftsRef = knex.ref(options.ftsTable).toString();
+      const sql = `rowid IN (SELECT rowid FROM ${ftsRef} WHERE ${ftsRef} MATCH ?)`;
+      return {
+        raw: true,
+        sql,
+        bindings: [cleanTerm],
+        boolean,
+        rankClause: null,
+      };
+    }
+
+    const tableRef = knex.ref(model.table).toString();
+    const sql = `${tableRef} MATCH ?`;
+    return {
+      raw: true,
+      sql,
+      bindings: [cleanTerm],
+      boolean,
+      rankClause: null,
+    };
+  }
+
+  // 3. MySQL FullText (when mode is 'fts' on mysql)
+  if (dialect === 'mysql' && mode === 'fts') {
+    const colsList = searchColumns.map((c) => knex.ref(c).toString()).join(', ');
+    const sql = `MATCH(${colsList}) AGAINST(? IN BOOLEAN MODE)`;
+    return {
+      raw: true,
+      sql,
+      bindings: [cleanTerm],
+      boolean,
+      rankClause: null,
+    };
+  }
+
+  // 4. Universal Tokenized LIKE Search (default for SQLite, MySQL, and mode: 'like')
+  if (exact) {
+    const pattern = `%${cleanTerm}%`;
+    const bindings = [];
+    const colClauses = searchColumns.map((c) => {
+      bindings.push(pattern);
+      return `LOWER(${knex.ref(c)}) LIKE LOWER(?)`;
+    });
+
+    return {
+      raw: true,
+      sql: `(${colClauses.join(' OR ')})`,
+      bindings,
+      boolean,
+      rankClause: null,
+    };
+  }
+
+  const tokens = tokenizeSearchTerm(cleanTerm);
+  if (tokens.length === 0) {
+    return null;
+  }
+
+  const wordClauses = [];
+  const bindings = [];
+
+  for (const token of tokens) {
+    const pattern = `%${token}%`;
+    const colClauses = searchColumns.map((c) => {
+      bindings.push(pattern);
+      return `LOWER(${knex.ref(c)}) LIKE LOWER(?)`;
+    });
+    wordClauses.push(`(${colClauses.join(' OR ')})`);
+  }
+
+  const joinOp = matchAllWords ? ' AND ' : ' OR ';
+  const sql = `(${wordClauses.join(joinOp)})`;
+
+  return {
+    raw: true,
+    sql,
+    bindings,
+    boolean,
+    rankClause: null,
+  };
+}
+
+module.exports = {
+  detectDialect,
+  tokenizeSearchTerm,
+  normalizeSearchColumns,
+  buildSearchClause,
+};