@nordcraft/search 1.0.93 → 1.0.94

package/src/rules/search/fieldSearchRule.ts

@@ -0,0 +1,391 @@
+import equal from 'fast-deep-equal'
+import type { NodeType, SearchRule } from '../../types'
+import { parseSearchQuery } from '../../util/parseSearchQuery'
+
+type MatchResult =
+  | {
+      hasMatch: boolean
+      context: { before: string; matched: string; after: string }
+    }
+  | boolean
+
+function makeMatch(str: string, index: number, length: number): MatchResult {
+  return {
+    hasMatch: true,
+    context: {
+      before: str.slice(0, index),
+      matched: str.slice(index, index + length),
+      after: str.slice(index + length),
+    },
+  }
+}
+
+function fullMatch(matched: string): MatchResult {
+  return { hasMatch: true, context: { before: '', matched, after: '' } }
+}
+
+function checkStringMatch(
+  stringVal: string,
+  targetValue: string,
+  isExact: boolean,
+): MatchResult {
+  const stringValueLower = stringVal.toLowerCase()
+  const targetValueLower = targetValue.toLowerCase()
+
+  if (targetValueLower === '') {
+    return stringValueLower === ''
+      ? { hasMatch: true, context: { before: '', matched: '', after: '' } }
+      : false
+  }
+
+  if (isExact) {
+    // Attempt JSON structural match for bracket/brace targets
+    if (isJsonStructuralTarget(targetValue)) {
+      try {
+        // JSON parse only used for structural equality — not reproduced as output
+        const parsed = JSON.parse(targetValue)
+        if (equal(stringVal, parsed) || equal(JSON.parse(stringVal), parsed)) {
+          return fullMatch(stringVal)
+        }
+      } catch {
+        // fall through to string comparison
+      }
+    }
+    return stringValueLower === targetValueLower ? fullMatch(stringVal) : false
+  }
+
+  const index = stringValueLower.indexOf(targetValueLower)
+  return index !== -1 ? makeMatch(stringVal, index, targetValue.length) : false
+}
+
+function matchRegex(value: any, matcher: RegExp, key?: string): MatchResult {
+  const check = (v: any): MatchResult => {
+    const str = String(v)
+    const m = str.match(matcher)
+    if (!m) {
+      if (key) {
+        const combined = `${key}: ${str}`
+        const mCombined = combined.match(matcher)
+        if (mCombined) {
+          return {
+            hasMatch: true,
+            context: {
+              before: combined.slice(0, mCombined.index),
+              matched: combined.slice(
+                mCombined.index ?? 0,
+                (mCombined.index ?? 0) + mCombined[0].length,
+              ),
+              after: combined.slice(
+                (mCombined.index ?? 0) + mCombined[0].length,
+              ),
+            },
+          }
+        }
+      }
+      return false
+    }
+
+    return makeMatch(str, m.index ?? 0, m[0].length)
+  }
+
+  if (!Array.isArray(value)) {
+    return check(value)
+  }
+
+  return false
+}
+
+function matchString(value: any, matcher: string, key?: string): MatchResult {
+  const isExact = matcher.startsWith('"') && matcher.endsWith('"')
+  const targetValue = isExact ? matcher.slice(1, -1) : matcher
+  const valToCheck = value
+
+  if (Array.isArray(valToCheck)) {
+    const isExactStructural = isExact && isJsonStructuralTarget(targetValue)
+
+    if (!isExactStructural) {
+      for (const v of valToCheck) {
+        if (typeof v === 'object' && v !== null && !Array.isArray(v)) {
+          if (v.type === 'value' || v.type === 'formula') {
+            const inner = matchString(v.value, matcher)
+            if (typeof inner === 'object' && inner.hasMatch) {
+              return inner
+            }
+          }
+          continue
+        }
+        const m = matchString(v, matcher)
+        if (typeof m === 'object' && m.hasMatch) {
+          return m
+        }
+      }
+
+      for (const sep of [',', ', ']) {
+        const res = checkStringMatch(valToCheck.join(sep), targetValue, isExact)
+        if (res) {
+          return res
+        }
+      }
+      return false
+    }
+
+    return checkStringMatch(String(valToCheck), targetValue, isExact)
+  }
+
+  if (typeof valToCheck === 'object' && valToCheck !== null) {
+    if (isExact) {
+      if (isJsonStructuralTarget(targetValue)) {
+        try {
+          if (equal(valToCheck, JSON.parse(targetValue)))
+            return fullMatch(targetValue)
+        } catch {
+          // fall through
+        }
+      }
+      return false
+    }
+
+    const stringified = String(valToCheck)
+    if (
+      stringified === '[object Object]' &&
+      targetValue.toLowerCase() !== '[object object]'
+    ) {
+      return false
+    }
+
+    return checkStringMatch(stringified, targetValue, isExact)
+  }
+
+  const matchRes = checkStringMatch(String(valToCheck), targetValue, isExact)
+  if (
+    typeof matchRes === 'object' &&
+    matchRes.hasMatch &&
+    key?.toLowerCase().includes(targetValue.toLowerCase())
+  ) {
+    return matchRes
+  }
+
+  return matchRes
+}
+
+function isMatch(
+  value: any,
+  matcher: string | RegExp | object | null,
+  key?: string,
+): MatchResult {
+  if (matcher instanceof RegExp) {
+    return matchRegex(value, matcher, key)
+  }
+
+  if (typeof matcher === 'string') {
+    return matchString(value, matcher, key)
+  }
+
+  if (Array.isArray(matcher)) {
+    return (
+      Array.isArray(value) &&
+      value.length >= matcher.length &&
+      matcher.every((m, i) => equal(value[i], m))
+    )
+  }
+
+  if (typeof matcher === 'object' && matcher !== null) {
+    if (typeof value !== 'object' || value === null) {
+      return false
+    }
+    for (const key in matcher) {
+      if (!equal(value[key], (matcher as any)[key])) {
+        return false
+      }
+    }
+    return true
+  }
+
+  return value === matcher
+}
+
+function getValueByPath(
+  obj: any,
+  path: string,
+): { value: any; found: boolean } {
+  const parts: string[] = []
+  const partRegex = /"([^"]+)"|'([^']+)'|([^.\s]+)/g
+  let match
+  const trimmedPath = path.trim()
+
+  while ((match = partRegex.exec(trimmedPath)) !== null) {
+    parts.push(match[1] || match[2] || match[3])
+  }
+
+  if (trimmedPath.includes('*')) {
+    const results: any[] = []
+    const walk = (curr: any, i: number) => {
+      if (i === parts.length) {
+        results.push(curr)
+        return
+      }
+      if (curr === null || typeof curr !== 'object') {
+        return
+      }
+      if (parts[i] === '*') {
+        for (const k in curr) walk(curr[k], i + 1)
+      } else if (parts[i] in curr) {
+        walk(curr[parts[i]], i + 1)
+      }
+    }
+    walk(obj, 0)
+    return { value: results, found: results.length > 0 }
+  }
+
+  let curr = obj
+  for (const p of parts) {
+    if (curr === null || typeof curr !== 'object' || !(p in curr)) {
+      return { value: undefined, found: false }
+    }
+    curr = curr[p]
+  }
+  return { value: curr, found: true }
+}
+
+export function createFieldSearchRule({
+  query,
+  skippedFields,
+}: {
+  query: string
+  withDetails?: boolean
+  skippedFields?: Partial<{
+    [K in NodeType as K['nodeType']]: (keyof K['value'])[]
+  }>
+}): SearchRule {
+  const parsedQuery = parseSearchQuery(query)
+  const reportedPaths = new Set<string>()
+
+  function evaluateFieldsObject(
+    val: any,
+    fieldsObj: Record<string, string | RegExp>,
+  ): MatchResult {
+    let lastMatch: MatchResult = true
+    for (const f in fieldsObj) {
+      const m = fieldsObj[f]
+
+      const { value: fv, found } = getValueByPath(val, f)
+      if (!found) {
+        return false
+      }
+
+      const matchResult = isMatch(fv, m, f)
+      if (!matchResult) {
+        return false
+      }
+
+      if (typeof matchResult === 'object' && matchResult.hasMatch) {
+        lastMatch = { ...matchResult, field: f } as any
+      }
+    }
+
+    return lastMatch
+  }
+
+  function evaluateValue(val: any, part: any, key: string): MatchResult {
+    const { fields, exclude } = part
+
+    if (!fields) {
+      return !exclude
+    }
+
+    let matched: MatchResult = false
+
+    if (
+      typeof fields === 'object' &&
+      !Array.isArray(fields) &&
+      !(fields instanceof RegExp)
+    ) {
+      matched = evaluateFieldsObject(
+        val,
+        fields as Record<string, string | RegExp>,
+      )
+    } else {
+      const matchResult = isMatch(val, fields, key)
+      matched =
+        typeof matchResult === 'object' && matchResult.hasMatch
+          ? matchResult
+          : !!matchResult
+    }
+
+    return exclude ? !matched : matched
+  }
+
+  return {
+    visit: (report, { path, value, nodeType }) => {
+      if (
+        typeof value !== 'object' ||
+        value === null ||
+        parsedQuery.length === 0
+      )
+        return
+
+      let matchContext: any = null
+      let matchedFieldName: string | null = null
+
+      const allMatched = parsedQuery.every((p) => {
+        if (p.nodeType && nodeType !== p.nodeType) {
+          return false
+        }
+
+        const evalRes = evaluateValue(value, p, '')
+        if (evalRes) {
+          if (typeof evalRes === 'object' && evalRes.hasMatch) {
+            matchContext = evalRes.context
+            matchedFieldName = (evalRes as any).field ?? matchedFieldName
+          }
+          {
+            return true
+          }
+        }
+
+        return Object.entries(value).some(([k, v]) => {
+          if (
+            (skippedFields?.[nodeType] as Array<string> | undefined)?.includes(
+              k,
+            )
+          ) {
+            return false
+          }
+
+          const resValue = evaluateValue(v, p, k)
+          if (resValue) {
+            if (typeof resValue === 'object' && resValue.hasMatch) {
+              matchContext = resValue.context
+              matchedFieldName = (resValue as any).field ?? k
+            }
+            return true
+          }
+
+          return false
+        })
+      })
+
+      if (allMatched) {
+        const pk = path.join('.')
+        if (!reportedPaths.has(pk)) {
+          reportedPaths.add(pk)
+          report({
+            path,
+            details: {
+              context: matchContext,
+              field: matchedFieldName,
+              nodeType,
+            },
+          })
+        }
+      }
+    },
+  }
+}
+
+function isJsonStructuralTarget(targetValue: string): boolean {
+  return (
+    (targetValue.startsWith('[') && targetValue.endsWith(']')) ||
+    (targetValue.startsWith('{') && targetValue.endsWith('}'))
+  )
+}

package/src/search.worker.ts

@@ -1,49 +1,22 @@
-import type { ProjectFiles } from '@nordcraft/ssr/dist/ssr.types'
-
-type Query =
-  | {
-      type: 'freeform'
-      value: string
-    }
-  | {
-      type: 'component'
-      name: string
-      references?: boolean
-    }
-  | {
-      type: 'formula'
-      name: string
-      references?: boolean
-    }
-  | {
-      type: 'action'
-      name: string
-      references?: boolean
-    }
-
-export type Options = {
-  /**
-   * Useful for running search on a subset or a single file.
-   */
-  pathsToVisit?: string[][]
-  /**
-   * The number of reports to send per message.
-   * @default 1
-   */
-  batchSize?: number | 'all' | 'per-file'
-}
-
+/* eslint-disable no-console */
 /**
- * Similar to problems with using rules and returning paths, but for searching the toddle file format instead of searching for problems.
- *
- * Great for finding freeform text anywhere in a project, or references, dependencies etc.
+ * This function is a web worker that checks for problems in the files.
  */
-onmessage = (
-  _event: MessageEvent<{
-    files: ProjectFiles
-    query: Query
-    options?: unknown
-  }>,
-) => {
-  throw new Error('Not yet implemented')
+import { findSearch } from './findSearch'
+import type { SearchArgs } from './types'
+
+onmessage = (event: MessageEvent<SearchArgs>) => {
+  console.time('search:' + event.data.id)
+  findSearch(event.data, (results) => postMessage(results))
+    .then(() => {
+      console.timeEnd('search:' + event.data.id)
+    })
+    .catch((error) => {
+      postMessage({
+        id: event.data.id,
+        complete: true,
+        cancelled: true,
+        cancelReason: `Search failed with error: ${error instanceof Error ? error.message : String(error)}`,
+      })
+    })
 }

package/src/searchProject.ts

@@ -3,11 +3,20 @@ import type { CustomPropertyName } from '@nordcraft/core/dist/component/componen
 import { ToddleComponent } from '@nordcraft/core/dist/component/ToddleComponent'
 import { isToddleFormula } from '@nordcraft/core/dist/formula/formula'
 import { ToddleFormula } from '@nordcraft/core/dist/formula/ToddleFormula'
+import { isDefined } from '@nordcraft/core/dist/utils/util'
 import type { ProjectFiles } from '@nordcraft/ssr/dist/ssr.types'
 import { ToddleApiService } from '@nordcraft/ssr/dist/ToddleApiService'
 import { ToddleRoute } from '@nordcraft/ssr/dist/ToddleRoute'
-import type { AllRuleTypes } from './rules/issues/issueRules.index'
-import type { ApplicationState, FixType, NodeType, Result, Rule } from './types'
+import type {
+  ApplicationState,
+  FixType,
+  IssueResult,
+  IssueRule,
+  NodeType,
+  Rule,
+  SearchResult,
+  SearchRule,
+} from './types'
 import { shouldSearchExactPath, shouldVisitTree } from './util/helpers'
 
 interface FixOptions {
@@ -27,14 +36,21 @@ interface FixOptions {
  */
 export function searchProject(args: {
   files: Omit<ProjectFiles, 'config'> & Partial<Pick<ProjectFiles, 'config'>>
-  rules: AllRuleTypes[]
+  rules: SearchRule<any, any>[]
+  pathsToVisit?: string[][]
+  useExactPaths?: boolean
+  withDetails?: boolean
+}): Generator<SearchResult>
+export function searchProject(args: {
+  files: Omit<ProjectFiles, 'config'> & Partial<Pick<ProjectFiles, 'config'>>
+  rules: IssueRule<any, any>[]
   pathsToVisit?: string[][]
   useExactPaths?: boolean
   state?: ApplicationState
-}): Generator<Result>
+}): Generator<IssueResult>
 export function searchProject(args: {
   files: Omit<ProjectFiles, 'config'> & Partial<Pick<ProjectFiles, 'config'>>
-  rules: AllRuleTypes[]
+  rules: IssueRule<any, any>[]
   pathsToVisit?: string[][]
   useExactPaths?: boolean
   state?: ApplicationState
@@ -49,12 +65,12 @@ export function* searchProject({
   fixOptions,
 }: {
   files: Omit<ProjectFiles, 'config'> & Partial<Pick<ProjectFiles, 'config'>>
-  rules: AllRuleTypes[]
+  rules: Rule[]
   pathsToVisit?: string[][]
   useExactPaths?: boolean
   state?: ApplicationState
   fixOptions?: FixOptions
-}): Generator<Result | ProjectFiles | void> {
+}): Generator<SearchResult | IssueResult | ProjectFiles | void> {
   const memos = new Map<string, any>()
   const memo = (key: string | string[], fn: () => any) => {
     const stringKey = Array.isArray(key) ? key.join('/') : key
@@ -238,18 +254,18 @@ export function* searchProject({
 function visitNode(args: {
   args: {
     path: (string | number)[]
-    rules: Rule<any, any>[]
+    rules: Rule[]
     files: Omit<ProjectFiles, 'config'> & Partial<Pick<ProjectFiles, 'config'>>
     pathsToVisit: string[][]
     useExactPaths: boolean
   } & NodeType
   state: ApplicationState | undefined
   fixOptions: never
-}): Generator<Result>
+}): Generator<IssueResult>
 function visitNode(args: {
   args: {
     path: (string | number)[]
-    rules: Rule<any, any>[]
+    rules: Rule[]
     files: Omit<ProjectFiles, 'config'> & Partial<Pick<ProjectFiles, 'config'>>
     pathsToVisit: string[][]
     useExactPaths: boolean
@@ -264,14 +280,14 @@ function* visitNode({
 }: {
   args: {
     path: (string | number)[]
-    rules: Rule<any, any>[]
+    rules: Rule[]
     files: Omit<ProjectFiles, 'config'> & Partial<Pick<ProjectFiles, 'config'>>
     pathsToVisit: string[][]
     useExactPaths: boolean
   } & NodeType
   state: ApplicationState | undefined
   fixOptions?: FixOptions
-}): Generator<Result | ProjectFiles | void> {
+}): Generator<IssueResult | ProjectFiles | void> {
   const { rules, pathsToVisit, useExactPaths, ...data } = args
   const { files, value, path, memo, nodeType } = data
   if (
@@ -288,11 +304,9 @@ function* visitNode({
     !useExactPaths ||
     shouldSearchExactPath({ path: data.path, pathsToVisit })
   ) {
-    const results: Result[] = []
+    const results: IssueResult[] | SearchResult[] = []
     let fixedFiles: ProjectFiles | undefined
-    for (const rule of rules) {
-      // eslint-disable-next-line no-console
-      console.timeStamp(`Visiting rule ${rule.code}`)
+    for (const rule of rules as (IssueRule & SearchRule)[]) {
       rule.visit(
         // Report callback used to report issues
         ({ path, details, fixes, info }) => {
@@ -316,16 +330,20 @@ function* visitNode({
               }
             }
           } else {
-            // We're in "report mode"
-            results.push({
-              code: rule.code,
-              category: rule.category,
-              level: rule.level,
-              path,
-              details,
-              fixes,
-              info,
-            })
+            // Optional filtering to remove undefined entries as different rule types have only subset of fields
+            results.push(
+              Object.fromEntries(
+                [
+                  ['code', rule.code],
+                  ['category', rule.category],
+                  ['level', rule.level],
+                  ['path', path],
+                  ['details', details],
+                  ['fixes', fixes],
+                  ['info', info],
+                ].filter(([, value]) => isDefined(value)),
+              ),
+            )
           }
         },
         data,
@@ -343,7 +361,7 @@ function* visitNode({
       }
     } else {
       for (const result of results) {
-        yield result
+        yield result as IssueResult & SearchResult
       }
     }
   }

package/src/types.ts

@@ -158,7 +158,7 @@ export type Category =
 
 export type Level = 'error' | 'warning' | 'info'
 
-export type Result = {
+export type IssueResult = {
   path: (string | number)[]
   code: Code
   category: Category
@@ -168,6 +168,11 @@ export type Result = {
   info: ReportedIssueInfo
 }
 
+export type SearchResult = {
+  path: (string | number)[]
+  details?: any
+}
+
 export interface ApplicationCookie {
   url: string
   name: string
@@ -494,7 +499,7 @@ interface ReportedIssueInfo {
   description: string
 }
 
-export interface Rule<
+export interface IssueRule<
   T = unknown,
   V extends NodeType = NodeType,
   N extends NodeType = V,
@@ -515,6 +520,16 @@ export interface Rule<
   fixes?: Partial<Record<FixType, FixFunction<N, T>>>
 }
 
+export interface SearchRule<T = unknown, V extends NodeType = NodeType> {
+  visit: (
+    report: (args: { path: (string | number)[]; details?: T }) => void,
+    data: V,
+    state?: ApplicationState | undefined,
+  ) => void
+}
+
+export type Rule = IssueRule | SearchRule
+
 export interface FixFunctionArgs<Data extends NodeType, Details = unknown> {
   data: Data
   details?: Details
@@ -565,7 +580,8 @@ export interface FindProblemsArgs {
 
 export interface FindProblemsResponse {
   id: string
-  results: Result[]
+  results: IssueResult[]
+  complete?: true
 }
 
 export interface FixProblemsArgs {
@@ -582,3 +598,25 @@ export interface FixProblemsResponse {
   fixRule: Code
   fixType: FixType
 }
+
+export interface SearchArgs {
+  id: string
+  query: string
+  // Files are optional, to allow for updating the query without resending the files in cases where they have not changed
+  files?: ProjectFiles
+  options?: {
+    pathsToVisit?: string[][]
+    useExactPaths?: boolean
+    batchSize?: number | 'all' | 'per-file'
+    // disabling details can improve performance as they sometimes require extra computation
+    withDetails?: boolean
+  }
+}
+
+export interface SearchResponse {
+  id: string
+  results: SearchResult[]
+  complete?: boolean
+  cancelled?: boolean
+  cancelReason?: string
+}