webspresso 0.0.98 → 0.0.100

package/core/orm/repository.js

@@ -6,10 +6,12 @@
 
 const { createQueryBuilder } = require('./query-builder');
 const { loadRelations } = require('./eager-loader');
+const { resolveRelationModel, isCascadeEnabled } = require('./model');
 const {
   applyInsertModifiers,
   applyUpdateModifiers,
   getSoftDeleteData,
+  getRestoreData,
   createScopeContext,
   applyScopes,
 } = require('./scopes');
@@ -73,7 +75,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 +146,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 +232,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)
@@ -458,14 +460,236 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
   }
 
   /**
-   * Delete a record by primary key (soft delete if enabled)
+   * Cascade soft-delete child records for cascading relations
+   * @param {import('./types').ModelDefinition} currentModel
+   * @param {Object} record
+   * @param {Date} deletedAt
+   * @param {Object} [options={}]
+   * @param {Set<string>} [visited=new Set()]
+   */
+  async function cascadeSoftDelete(currentModel, record, deletedAt, options = {}, visited = new Set()) {
+    const pkVal = record[currentModel.primaryKey];
+    if (pkVal === undefined || pkVal === null) return;
+    const visitKey = `${currentModel.name}:${pkVal}`;
+    if (visited.has(visitKey)) return;
+    visited.add(visitKey);
+
+    const activeKnex = getActiveKnex();
+
+    for (const [relationName, relation] of Object.entries(currentModel.relations || {})) {
+      if (!['hasMany', 'hasOne'].includes(relation.type)) continue;
+      if (!isCascadeEnabled(relation, 'delete')) continue;
+
+      let relatedModel;
+      try {
+        relatedModel = resolveRelationModel(relation);
+      } catch {
+        continue;
+      }
+      if (!relatedModel || !relatedModel.scopes.softDelete) continue;
+
+      const localKey = relation.localKey || currentModel.primaryKey;
+      const foreignKey = relation.foreignKey;
+      const parentVal = record[localKey];
+      if (parentVal === undefined || parentVal === null) continue;
+
+      let childQuery = activeKnex(relatedModel.table)
+        .where(foreignKey, parentVal)
+        .whereNull('deleted_at');
+
+      if (scopeContext && scopeContext.tenantId !== undefined && relatedModel.scopes.tenant) {
+        childQuery = childQuery.where(relatedModel.scopes.tenant, scopeContext.tenantId);
+      }
+
+      const children = await childQuery.select('*');
+      if (!children || children.length === 0) continue;
+
+      const childIds = children.map(c => c[relatedModel.primaryKey]);
+
+      await activeKnex(relatedModel.table)
+        .whereIn(relatedModel.primaryKey, childIds)
+        .update(getSoftDeleteData(deletedAt));
+
+      if (cacheLayer) {
+        cacheLayer.invalidateModelAll(relatedModel);
+      }
+
+      const hasDeeper = Object.values(relatedModel.relations || {}).some(
+        r => ['hasMany', 'hasOne'].includes(r.type) && isCascadeEnabled(r, 'delete')
+      );
+      if (hasDeeper) {
+        for (const child of children) {
+          await cascadeSoftDelete(relatedModel, child, deletedAt, options, visited);
+        }
+      }
+
+      if (ModelEvents.hasListeners(relatedModel.name, Hooks.AFTER_DELETE)) {
+        for (const child of children) {
+          const childCtx = createEventContext(relatedModel.name, 'delete', getHookTrx());
+          ModelEvents.emit(relatedModel.name, Hooks.AFTER_DELETE, child, childCtx);
+        }
+      }
+    }
+  }
+
+  /**
+   * Cascade hard-delete child records for cascading relations
+   * @param {import('./types').ModelDefinition} currentModel
+   * @param {Object} record
+   * @param {Object} [options={}]
+   * @param {Set<string>} [visited=new Set()]
+   */
+  async function cascadeHardDelete(currentModel, record, options = {}, visited = new Set()) {
+    const pkVal = record[currentModel.primaryKey];
+    if (pkVal === undefined || pkVal === null) return;
+    const visitKey = `${currentModel.name}:${pkVal}`;
+    if (visited.has(visitKey)) return;
+    visited.add(visitKey);
+
+    const activeKnex = getActiveKnex();
+
+    for (const [relationName, relation] of Object.entries(currentModel.relations || {})) {
+      if (!['hasMany', 'hasOne'].includes(relation.type)) continue;
+      if (!isCascadeEnabled(relation, 'delete')) continue;
+
+      let relatedModel;
+      try {
+        relatedModel = resolveRelationModel(relation);
+      } catch {
+        continue;
+      }
+      if (!relatedModel) continue;
+
+      const localKey = relation.localKey || currentModel.primaryKey;
+      const foreignKey = relation.foreignKey;
+      const parentVal = record[localKey];
+      if (parentVal === undefined || parentVal === null) continue;
+
+      let childQuery = activeKnex(relatedModel.table)
+        .where(foreignKey, parentVal);
+
+      if (scopeContext && scopeContext.tenantId !== undefined && relatedModel.scopes.tenant) {
+        childQuery = childQuery.where(relatedModel.scopes.tenant, scopeContext.tenantId);
+      }
+
+      const children = await childQuery.select('*');
+      if (!children || children.length === 0) continue;
+
+      // Delete deeper relations first to avoid FK constraint violations
+      const hasDeeper = Object.values(relatedModel.relations || {}).some(
+        r => ['hasMany', 'hasOne'].includes(r.type) && isCascadeEnabled(r, 'delete')
+      );
+      if (hasDeeper) {
+        for (const child of children) {
+          await cascadeHardDelete(relatedModel, child, options, visited);
+        }
+      }
+
+      const childIds = children.map(c => c[relatedModel.primaryKey]);
+      await activeKnex(relatedModel.table)
+        .whereIn(relatedModel.primaryKey, childIds)
+        .delete();
+
+      if (cacheLayer) {
+        cacheLayer.invalidateModelAll(relatedModel);
+      }
+
+      if (ModelEvents.hasListeners(relatedModel.name, Hooks.AFTER_DELETE)) {
+        for (const child of children) {
+          const childCtx = createEventContext(relatedModel.name, 'delete', getHookTrx());
+          ModelEvents.emit(relatedModel.name, Hooks.AFTER_DELETE, child, childCtx);
+        }
+      }
+    }
+  }
+
+  /**
+   * Cascade restore child records for cascading relations
+   * @param {import('./types').ModelDefinition} currentModel
+   * @param {Object} trashedRecord
+   * @param {Date|string|number} parentDeletedAt
+   * @param {Object} [options={}]
+   * @param {Set<string>} [visited=new Set()]
+   */
+  async function cascadeRestore(currentModel, trashedRecord, parentDeletedAt, options = {}, visited = new Set()) {
+    const pkVal = trashedRecord[currentModel.primaryKey];
+    if (pkVal === undefined || pkVal === null) return;
+    const visitKey = `${currentModel.name}:${pkVal}`;
+    if (visited.has(visitKey)) return;
+    visited.add(visitKey);
+
+    const activeKnex = getActiveKnex();
+
+    for (const [relationName, relation] of Object.entries(currentModel.relations || {})) {
+      if (!['hasMany', 'hasOne'].includes(relation.type)) continue;
+      if (!isCascadeEnabled(relation, 'restore')) continue;
+
+      let relatedModel;
+      try {
+        relatedModel = resolveRelationModel(relation);
+      } catch {
+        continue;
+      }
+      if (!relatedModel || !relatedModel.scopes.softDelete) continue;
+
+      const localKey = relation.localKey || currentModel.primaryKey;
+      const foreignKey = relation.foreignKey;
+      const parentVal = trashedRecord[localKey];
+      if (parentVal === undefined || parentVal === null) continue;
+
+      let childQuery = activeKnex(relatedModel.table)
+        .where(foreignKey, parentVal)
+        .whereNotNull('deleted_at');
+
+      if (scopeContext && scopeContext.tenantId !== undefined && relatedModel.scopes.tenant) {
+        childQuery = childQuery.where(relatedModel.scopes.tenant, scopeContext.tenantId);
+      }
+
+      // Selective restore by matching deletion timestamp
+      if (!options.allChildren && parentDeletedAt != null) {
+        childQuery = childQuery.where('deleted_at', parentDeletedAt);
+      }
+
+      const children = await childQuery.select('*');
+      if (!children || children.length === 0) continue;
+
+      const hasDeeper = Object.values(relatedModel.relations || {}).some(
+        r => ['hasMany', 'hasOne'].includes(r.type) && isCascadeEnabled(r, 'restore')
+      );
+      if (hasDeeper) {
+        for (const child of children) {
+          await cascadeRestore(relatedModel, child, child.deleted_at || parentDeletedAt, options, visited);
+        }
+      }
+
+      const childIds = children.map(c => c[relatedModel.primaryKey]);
+      await activeKnex(relatedModel.table)
+        .whereIn(relatedModel.primaryKey, childIds)
+        .update(getRestoreData());
+
+      if (cacheLayer) {
+        cacheLayer.invalidateModelAll(relatedModel);
+      }
+
+      if (ModelEvents.hasListeners(relatedModel.name, Hooks.AFTER_RESTORE)) {
+        for (const child of children) {
+          const childCtx = createEventContext(relatedModel.name, 'restore', getHookTrx());
+          ModelEvents.emit(relatedModel.name, Hooks.AFTER_RESTORE, { ...child, deleted_at: null }, childCtx);
+        }
+      }
+    }
+  }
+
+  /**
+   * Delete a record by primary key (soft delete if enabled, with relation cascading)
    * @param {number|string} id - Primary key value
+   * @param {Object} [options={}] - Delete options ({ cascade?: boolean, deletedAt?: Date })
    * @returns {Promise<boolean>}
    */
-  async function del(id) {
+  async function del(id, options = {}) {
     const ctx = createEventContext(model.name, 'delete', getHookTrx());
     
-    // Get the record before deletion for hooks
+    // Get the record before deletion for hooks and cascading
     const record = await findById(id);
     if (!record) {
       return false;
@@ -478,39 +702,76 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
     }
 
     let success = false;
+    const deletedAt = (options && options.deletedAt instanceof Date) ? options.deletedAt : new Date();
 
     // Soft delete if enabled
     if (model.scopes.softDelete) {
       const updated = await baseQuery()
         .where(model.primaryKey, id)
-        .update(getSoftDeleteData());
+        .update(getSoftDeleteData(deletedAt));
       success = updated > 0;
+
+      if (success) {
+        if (cacheLayer) {
+          cacheLayer.invalidateModelAll(model);
+        }
+
+        if (!options || options.cascade !== false) {
+          await cascadeSoftDelete(model, record, deletedAt, options);
+        }
+
+        // Emit afterDelete
+        ModelEvents.emit(model.name, Hooks.AFTER_DELETE, record, ctx);
+      }
     } else {
       // Hard delete
+      // Cascade hard-delete child records first to satisfy FK constraints
+      if (!options || options.cascade !== false) {
+        await cascadeHardDelete(model, record, options);
+      }
+
       const deleted = await baseQuery()
         .where(model.primaryKey, id)
         .delete();
       success = deleted > 0;
-    }
 
-    if (success) {
-      // Emit afterDelete
-      ModelEvents.emit(model.name, Hooks.AFTER_DELETE, record, ctx);
+      if (success) {
+        if (cacheLayer) {
+          cacheLayer.invalidateModelAll(model);
+        }
+
+        // Emit afterDelete
+        ModelEvents.emit(model.name, Hooks.AFTER_DELETE, record, ctx);
+      }
     }
 
     return success;
   }
 
   /**
-   * Force delete a record (bypass soft delete)
+   * Force delete a record (bypass soft delete, cascading to related models)
    * @param {number|string} id - Primary key value
+   * @param {Object} [options={}] - Force delete options ({ cascade?: boolean })
    * @returns {Promise<boolean>}
    */
-  async function forceDelete(id) {
+  async function forceDelete(id, options = {}) {
+    const record = await getActiveKnex()(model.table)
+      .where(model.primaryKey, id)
+      .first();
+
+    if (!record) {
+      return false;
+    }
+
+    if (!options || options.cascade !== false) {
+      await cascadeHardDelete(model, record, options);
+    }
+
     // Use raw query to bypass soft delete scope
     const deleted = await getActiveKnex()(model.table)
       .where(model.primaryKey, id)
       .delete();
+
     if (cacheLayer && deleted > 0) {
       cacheLayer.invalidateModelAll(model);
     }
@@ -518,11 +779,12 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
   }
 
   /**
-   * Restore a soft-deleted record
+   * Restore a soft-deleted record (with selective cascading restore)
    * @param {number|string} id - Primary key value
+   * @param {Object} [options={}] - Restore options ({ cascade?: boolean, allChildren?: boolean })
    * @returns {Promise<Object|null>}
    */
-  async function restore(id) {
+  async function restore(id, options = {}) {
     if (!model.scopes.softDelete) {
       throw new Error(`Model "${model.name}" does not have soft delete enabled`);
     }
@@ -549,12 +811,20 @@ function createRepository(model, knex, initialContext, cacheLayer = null) {
     const updated = await getActiveKnex()(model.table)
       .where(model.primaryKey, id)
       .whereNotNull('deleted_at')
-      .update({ deleted_at: null });
+      .update(getRestoreData());
 
     if (updated === 0) {
       return null;
     }
 
+    if (cacheLayer) {
+      cacheLayer.invalidateModelAll(model);
+    }
+
+    if (!options || options.cascade !== false) {
+      await cascadeRestore(model, trashedRecord, trashedRecord.deleted_at, options);
+    }
+
     const record = await findById(id, {}, false);
 
     // Emit afterRestore
@@ -619,10 +889,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 +940,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/scopes.js

@@ -142,10 +142,11 @@ function applyInsertNanoidPrimary(data, model) {
 
 /**
  * Get soft delete data (for UPDATE instead of DELETE)
+ * @param {Date|string|number} [date=new Date()] - Soft delete timestamp
  * @returns {Object} Soft delete update data
  */
-function getSoftDeleteData() {
-  return { deleted_at: new Date() };
+function getSoftDeleteData(date = new Date()) {
+  return { deleted_at: date instanceof Date ? date : new Date(date) };
 }
 
 /**

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,
+};