@njinlabs/njin 0.7.0 → 0.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@njinlabs/njin",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "A modern framework for building company profiles, landing pages, and content-driven websites.",
   "type": "module",
   "keywords": ["bun", "elysia", "surrealdb", "edgejs", "cms", "framework"],

package/src/core/model/index.ts

@@ -197,14 +197,21 @@ export const makeModel = <Rules extends z.ZodObject>(
     // id/createdAt/updatedAt are always present on every record but aren't part of the
     // user-defined schema shape (they're injected in create()/update()) — allow sorting by them too.
     const sortableFields = new Set([...Object.keys(config.schema.shape), "id", "createdAt", "updatedAt"]);
+    const hasExplicitSort = Boolean(sort && sortableFields.has(sort));
     // An explicit sort always wins; otherwise, when searching, rank by BM25 relevance
     // (summed across every matched search field) instead of leaving result order unspecified.
-    const orderBy =
-      sort && sortableFields.has(sort)
-        ? `ORDER BY ${sort} ${order === "desc" ? "DESC" : "ASC"}`
-        : search && config.searchFields.length
-          ? `ORDER BY (${config.searchFields.map((_, i) => `search::score(${i + 1})`).join(" + ")}) DESC`
-          : "";
+    // `ORDER BY` only accepts a bare identifier here, not a function call — so relevance is
+    // projected as an aliased field below (SELECT ... AS __relevance) and stripped back out
+    // of each returned record afterwards, since it isn't part of the model's schema.
+    const useRelevance = !hasExplicitSort && Boolean(search && config.searchFields.length);
+    const orderBy = hasExplicitSort
+      ? `ORDER BY ${sort} ${order === "desc" ? "DESC" : "ASC"}`
+      : useRelevance
+        ? "ORDER BY __relevance DESC"
+        : "";
+    const relevanceSelect = useRelevance
+      ? `, (${config.searchFields.map((_, i) => `search::score(${i + 1})`).join(" + ")}) AS __relevance`
+      : "";
 
     // Validate populate against known relation fields — prevents FETCH injection
     const fetchFields =
@@ -216,16 +223,22 @@ export const makeModel = <Rules extends z.ZodObject>(
     const fetch = fetchFields.length ? `FETCH ${fetchFields.join(", ")}` : "";
     const start = (page - 1) * pageLimit;
 
-    const [data, [countRow]] = await surreal().query<[Returning[], { count: number }[]]>(
-      `SELECT * FROM ${prefix} ${where} ${orderBy} LIMIT ${pageLimit} START ${start} ${fetch};
+    const [rows, [countRow]] = await surreal().query<[(Returning & { __relevance?: number })[], { count: number }[]]>(
+      `SELECT *${relevanceSelect} FROM ${prefix} ${where} ${orderBy} LIMIT ${pageLimit} START ${start} ${fetch};
        SELECT count() as count FROM ${prefix} ${where} GROUP ALL`,
       params,
     );
 
+    const data = (rows ?? []).map((row) => {
+      if (!useRelevance) return row;
+      const { __relevance, ...rest } = row;
+      return rest as Returning;
+    });
+
     const total = countRow?.count ?? 0;
 
     return {
-      data: data ?? [],
+      data,
       meta: {
         total,
         page,

package/src/modules/surreal.ts

@@ -8,9 +8,11 @@ const EMBEDDED_SCHEMES = ["mem://", "rocksdb://", "surrealkv://"];
 
 export const isRemotePath = (path: string) => REMOTE_SCHEMES.some((scheme) => path.startsWith(scheme));
 
-// Shared by every model's search index (see ../core/model/index.ts's read()) — a `class`
-// tokenizer splits on Unicode character-class boundaries (language-agnostic word
-// splitting), and the `ngram` filter indexes overlapping 2-10 char slices of each token so
+// Shared by every model's search index (see ../core/model/index.ts's read()) — `blank`
+// tokenizer splits on whitespace only (unlike `class`, which also splits on punctuation:
+// "Next.js" would become "next" / "." / "js", and a lone "." can't form any 2-char ngram,
+// so a query for "next.js" — tokenized the same way — would never match). The `ngram`
+// filter then indexes overlapping 2-10 char slices of each whitespace-delimited token so
 // the `@N@` match operator can find a term anywhere inside a field (not just a whole-field
 // match) and still tolerate minor typos, similar to trigram search.
 const SEARCH_ANALYZER = "njin_search";
@@ -36,7 +38,7 @@ const ensureTables = async (db: Surreal) => {
     await db.query(`DEFINE TABLE IF NOT EXISTS ${prefix} SCHEMALESS;`);
   }
 
-  await db.query(`DEFINE ANALYZER IF NOT EXISTS ${SEARCH_ANALYZER} TOKENIZERS class FILTERS lowercase,ngram(2,10);`);
+  await db.query(`DEFINE ANALYZER IF NOT EXISTS ${SEARCH_ANALYZER} TOKENIZERS blank FILTERS lowercase,ngram(2,10);`);
 
   const definedIndexes = new Set<string>(); // dedupe prefix+field in case two factories share a prefix
   for (const model of models) {
@@ -45,8 +47,10 @@ const ensureTables = async (db: Surreal) => {
       if (definedIndexes.has(key)) continue;
       definedIndexes.add(key);
 
+      // FULLTEXT, not SEARCH — this SurrealDB version renamed the index-type keyword;
+      // SEARCH ANALYZER ... is a parse error here even though older docs/examples use it.
       await db.query(
-        `DEFINE INDEX IF NOT EXISTS idx_search_${model.prefix}_${field} ON TABLE ${model.prefix} FIELDS ${field} SEARCH ANALYZER ${SEARCH_ANALYZER} BM25 HIGHLIGHTS;`,
+        `DEFINE INDEX IF NOT EXISTS idx_search_${model.prefix}_${field} ON TABLE ${model.prefix} FIELDS ${field} FULLTEXT ANALYZER ${SEARCH_ANALYZER} BM25 HIGHLIGHTS;`,
       );
     }
   }