@sanity/sdk 0.0.0-chore-react-18-compat.1 → 0.0.0-chore-react-18-compat.3

package/src/utils/createFetcherStore.ts

@@ -14,15 +14,14 @@ import {
   tap,
 } from 'rxjs/operators'
 
-import {type SanityInstance} from '../instance/types'
+import {bindActionGlobally, type BoundStoreAction} from '../store/createActionBinder'
+import {type SanityInstance} from '../store/createSanityInstance'
 import {
-  type ActionContext,
-  createAction,
-  createInternalAction,
-  type ResourceAction,
-} from '../resources/createAction'
-import {createResource} from '../resources/createResource'
-import {createStateSourceAction, type StateSource} from '../resources/createStateSourceAction'
+  createStateSourceAction,
+  type SelectorContext,
+  type StateSource,
+} from '../store/createStateSourceAction'
+import {defineStore, type StoreContext} from '../store/defineStore'
 import {insecureRandomId} from '../utils/ids'
 
 interface CreateFetcherStoreOptions<TParams extends unknown[], TData> {
@@ -38,7 +37,7 @@ interface CreateFetcherStoreOptions<TParams extends unknown[], TData> {
    * The function used to convert the params into keys that state related to
    * those params will be stored.
    */
-  getKey: (...params: TParams) => string
+  getKey: (instance: SanityInstance, ...params: TParams) => string
   /**
    * Delay in ms before clearing state after the last subscription is removed.
    * This results in react components suspending again due to no previous state
@@ -53,6 +52,7 @@ interface CreateFetcherStoreOptions<TParams extends unknown[], TData> {
 
 interface StoreEntry<TParams extends unknown[], TData> {
   params: TParams
+  instance: SanityInstance
   key: string
   data?: TData
   error?: unknown
@@ -74,12 +74,12 @@ export interface FetcherStoreState<TParams extends unknown[], TData> {
  * @public
  */
 export interface FetcherStore<TParams extends unknown[], TData> {
-  getState: ResourceAction<
+  getState: BoundStoreAction<
     FetcherStoreState<TParams, TData>,
     TParams,
     StateSource<TData | undefined>
   >
-  resolveState: ResourceAction<FetcherStoreState<TParams, TData>, TParams, Promise<TData>>
+  resolveState: BoundStoreAction<FetcherStoreState<TParams, TData>, TParams, Promise<TData>>
 }
 
 /**
@@ -108,13 +108,13 @@ export function createFetcherStore<TParams extends unknown[], TData>({
   fetchThrottleInternal = 1000,
   stateExpirationDelay = 5000,
 }: CreateFetcherStoreOptions<TParams, TData>): FetcherStore<TParams, TData> {
-  const store = createResource<FetcherStoreState<TParams, TData>>({
+  const store = defineStore<FetcherStoreState<TParams, TData>>({
     name,
     getInitialState: () => ({
       stateByParams: {},
     }),
-    initialize() {
-      const subscription = subscribeToSubscriptionsAndFetch(this)
+    initialize: (context) => {
+      const subscription = subscribeToSubscriptionsAndFetch(context)
       return () => subscription.unsubscribe()
     },
   })
@@ -125,160 +125,157 @@ export function createFetcherStore<TParams extends unknown[], TData>({
    * and if enough time has elapsed since the last fetch, we update the timestamp
    * and call the factory function for that key.
    */
-  const subscribeToSubscriptionsAndFetch = createInternalAction(
-    ({instance, state}: ActionContext<FetcherStoreState<TParams, TData>>) => {
-      return function () {
-        const factoryFn = getObservable(instance)
+  const subscribeToSubscriptionsAndFetch = ({
+    state,
+  }: StoreContext<FetcherStoreState<TParams, TData>>) => {
+    return state.observable
+      .pipe(
+        // Map the state to an array of [serialized, entry] pairs.
+        switchMap((s: FetcherStoreState<TParams, TData>) => {
+          const entries = Object.entries(s.stateByParams)
+          return entries.length > 0 ? from(entries) : EMPTY
+        }),
+        // Group by the serialized key.
+        groupBy(([key]) => key),
+        mergeMap((group$) =>
+          group$.pipe(
+            // Emit an initial value for pairwise comparisons.
+            startWith<[string, StoreEntry<TParams, TData> | undefined]>([group$.key, undefined]),
+            pairwise(),
+            // Trigger only when the subscriptions array grows.
+            filter(([[, prevEntry], [, currEntry]]) => {
+              const prevSubs = prevEntry?.subscriptions ?? []
+              const currSubs = currEntry?.subscriptions ?? []
+              return currSubs.length > prevSubs.length
+            }),
+            map(([, [, currEntry]]) => currEntry),
 
-        return state.observable
-          .pipe(
-            // Map the state to an array of [serialized, entry] pairs.
-            switchMap((s: FetcherStoreState<TParams, TData>) => {
-              const entries = Object.entries(s.stateByParams)
-              return entries.length > 0 ? from(entries) : EMPTY
+            // Only trigger if we haven't fetched recently.
+            filter((entry) => {
+              const lastFetch = entry?.lastFetchInitiatedAt
+              if (!lastFetch) return true
+              return Date.now() - new Date(lastFetch).getTime() >= fetchThrottleInternal
             }),
-            // Group by the serialized key.
-            groupBy(([key]) => key),
-            mergeMap((group$) =>
-              group$.pipe(
-                // Emit an initial value for pairwise comparisons.
-                startWith<[string, StoreEntry<TParams, TData> | undefined]>([
-                  group$.key,
-                  undefined,
-                ]),
-                pairwise(),
-                // Trigger only when the subscriptions array grows.
-                filter(([[, prevEntry], [, currEntry]]) => {
-                  const prevSubs = prevEntry?.subscriptions ?? []
-                  const currSubs = currEntry?.subscriptions ?? []
-                  return currSubs.length > prevSubs.length
-                }),
-                map(([, [, currEntry]]) => currEntry),
+            switchMap((entry) => {
+              // Retrieve params from the entry
+              if (!entry) return EMPTY
 
-                // Only trigger if we haven't fetched recently.
-                filter((entry) => {
-                  const lastFetch = entry?.lastFetchInitiatedAt
-                  if (!lastFetch) return true
-                  return Date.now() - new Date(lastFetch).getTime() >= fetchThrottleInternal
-                }),
-                switchMap((entry) => {
-                  // Retrieve params from the entry
-                  if (!entry) return EMPTY
+              // Record that a fetch is being initiated.
+              state.set('setLastFetchInitiatedAt', (prev: FetcherStoreState<TParams, TData>) => ({
+                stateByParams: {
+                  ...prev.stateByParams,
+                  [entry.key]: {
+                    ...entry,
+                    ...prev.stateByParams[entry.key],
+                    lastFetchInitiatedAt: new Date().toISOString(),
+                  },
+                },
+              }))
 
-                  // Record that a fetch is being initiated.
-                  state.set(
-                    'setLastFetchInitiatedAt',
-                    (prev: FetcherStoreState<TParams, TData>) => ({
-                      stateByParams: {
-                        ...prev.stateByParams,
-                        [entry.key]: {
-                          ...entry,
-                          ...prev.stateByParams[entry.key],
-                          lastFetchInitiatedAt: new Date().toISOString(),
-                        },
+              const factoryFn = getObservable(entry.instance)
+              return factoryFn(...entry.params).pipe(
+                // the `createStateSourceAction` util requires the update
+                // to
+                delay(0, asapScheduler),
+                tap((data: TData) =>
+                  state.set('setData', (prev: FetcherStoreState<TParams, TData>) => ({
+                    stateByParams: {
+                      ...prev.stateByParams,
+                      [entry.key]: {
+                        ...omit(entry, 'error'),
+                        ...omit(prev.stateByParams[entry.key], 'error'),
+                        data,
                       },
-                    }),
-                  )
-
-                  return factoryFn(...entry.params).pipe(
-                    // the `createStateSourceAction` util requires the update
-                    // to
-                    delay(0, asapScheduler),
-                    tap((data: TData) =>
-                      state.set('setData', (prev: FetcherStoreState<TParams, TData>) => ({
-                        stateByParams: {
-                          ...prev.stateByParams,
-                          [entry.key]: {
-                            ...omit(entry, 'error'),
-                            ...omit(prev.stateByParams[entry.key], 'error'),
-                            data,
-                          },
-                        },
-                      })),
-                    ),
-                    catchError((error) => {
-                      state.set('setError', (prev) => ({
-                        stateByParams: {
-                          ...prev.stateByParams,
-                          [entry.key]: {
-                            ...entry,
-                            ...prev.stateByParams[entry.key],
-                            error,
-                          },
-                        },
-                      }))
+                    },
+                  })),
+                ),
+                catchError((error) => {
+                  state.set('setError', (prev) => ({
+                    stateByParams: {
+                      ...prev.stateByParams,
+                      [entry.key]: {
+                        ...entry,
+                        ...prev.stateByParams[entry.key],
+                        error,
+                      },
+                    },
+                  }))
 
-                      return EMPTY
-                    }),
-                  )
+                  return EMPTY
                 }),
-              ),
-            ),
-          )
-          .subscribe({
-            error: (error) => state.set('setError', {error}),
-          })
-      }
-    },
-  )
+              )
+            }),
+          ),
+        ),
+      )
+      .subscribe({
+        error: (error) => state.set('setError', {error}),
+      })
+  }
 
-  const getState = createStateSourceAction(store, {
-    selector: ({stateByParams, error}: FetcherStoreState<TParams, TData>, ...params: TParams) => {
-      if (error) throw error
-      const key = getKey(...params)
-      const entry = stateByParams[key]
-      if (entry?.error) throw entry.error
-      return entry?.data
-    },
-    onSubscribe: ({state}, ...params: TParams) => {
-      const subscriptionId = insecureRandomId()
-      const key = getKey(...params)
+  const getState = bindActionGlobally(
+    store,
+    createStateSourceAction({
+      selector: (
+        {
+          instance,
+          state: {stateByParams, error},
+        }: SelectorContext<FetcherStoreState<TParams, TData>>,
+        ...params: TParams
+      ) => {
+        if (error) throw error
+        const key = getKey(instance, ...params)
+        const entry = stateByParams[key]
+        if (entry?.error) throw entry.error
+        return entry?.data
+      },
+      onSubscribe: ({instance, state}, ...params: TParams) => {
+        const subscriptionId = insecureRandomId()
+        const key = getKey(instance, ...params)
 
-      state.set('addSubscription', (prev: FetcherStoreState<TParams, TData>) => ({
-        stateByParams: {
-          ...prev.stateByParams,
-          [key]: {
-            ...prev.stateByParams[key],
-            key,
-            params: prev.stateByParams[key]?.params || params,
-            subscriptions: [...(prev.stateByParams[key]?.subscriptions || []), subscriptionId],
+        state.set('addSubscription', (prev: FetcherStoreState<TParams, TData>) => ({
+          stateByParams: {
+            ...prev.stateByParams,
+            [key]: {
+              ...prev.stateByParams[key],
+              instance,
+              key,
+              params: prev.stateByParams[key]?.params || params,
+              subscriptions: [...(prev.stateByParams[key]?.subscriptions || []), subscriptionId],
+            },
           },
-        },
-      }))
+        }))
 
-      return () => {
-        setTimeout(() => {
-          state.set('removeSubscription', (prev: FetcherStoreState<TParams, TData>) => {
-            const entry = prev.stateByParams[key]
-            if (!entry) return prev
+        return () => {
+          setTimeout(() => {
+            state.set('removeSubscription', (prev: FetcherStoreState<TParams, TData>) => {
+              const entry = prev.stateByParams[key]
+              if (!entry) return prev
 
-            const newSubs = (entry.subscriptions || []).filter((id) => id !== subscriptionId)
-            if (newSubs.length === 0) {
-              return {stateByParams: omit(prev.stateByParams, key)}
-            }
+              const newSubs = (entry.subscriptions || []).filter((id) => id !== subscriptionId)
+              if (newSubs.length === 0) {
+                return {stateByParams: omit(prev.stateByParams, key)}
+              }
 
-            return {
-              stateByParams: {
-                ...prev.stateByParams,
-                [key]: {
-                  ...entry,
-                  subscriptions: newSubs,
+              return {
+                stateByParams: {
+                  ...prev.stateByParams,
+                  [key]: {
+                    ...entry,
+                    subscriptions: newSubs,
+                  },
                 },
-              },
-            }
-          })
-        }, stateExpirationDelay)
-      }
-    },
-  })
+              }
+            })
+          }, stateExpirationDelay)
+        }
+      },
+    }),
+  )
 
-  const resolveState = createAction(store, () => {
-    return function (...params: TParams) {
-      return firstValueFrom(
-        getState(this, ...params).observable.pipe(first((i) => i !== undefined)),
-      )
-    }
-  })
+  const resolveState = bindActionGlobally(store, ({instance}, ...params: TParams) =>
+    firstValueFrom(getState(instance, ...params).observable.pipe(first((i) => i !== undefined))),
+  )
 
   return {getState, resolveState}
 }

package/src/utils/createGroqSearchFilter.test.ts

@@ -0,0 +1,75 @@
+import {describe, expect, test} from 'vitest'
+
+import {createGroqSearchFilter} from './createGroqSearchFilter'
+
+describe('createGroqSearchFilter', () => {
+  test('should create filter with wildcard added to the last token', () => {
+    expect(createGroqSearchFilter('hello world')).toBe('[@] match text::query("hello world*")')
+  })
+
+  test('should create filter with wildcard added to the last non-negated token', () => {
+    expect(createGroqSearchFilter('hello -world')).toBe('[@] match text::query("hello* -world")')
+  })
+
+  test('should create filter with wildcard before an exact match phrase', () => {
+    expect(createGroqSearchFilter('hello "exact match"')).toBe(
+      '[@] match text::query("hello* \\"exact match\\"")',
+    )
+  })
+
+  test('should create filter without adding wildcard if the last eligible token already has one', () => {
+    expect(createGroqSearchFilter('hello world*')).toBe('[@] match text::query("hello world*")')
+  })
+
+  test('should create filter without wildcard if the only token is negated', () => {
+    expect(createGroqSearchFilter('-negated')).toBe('[@] match text::query("-negated")')
+  })
+
+  test('should create filter without wildcard if the only token is an exact phrase', () => {
+    expect(createGroqSearchFilter('"exact phrase"')).toBe(
+      '[@] match text::query("\\"exact phrase\\"")',
+    )
+  })
+
+  test('should return empty string for empty input', () => {
+    expect(createGroqSearchFilter('')).toBe('')
+  })
+
+  test('should return empty string for whitespace input', () => {
+    expect(createGroqSearchFilter('  ')).toBe('')
+  })
+
+  test('should handle leading whitespace', () => {
+    expect(createGroqSearchFilter(' leading space')).toBe('[@] match text::query("leading space*")')
+  })
+
+  test('should handle trailing whitespace', () => {
+    expect(createGroqSearchFilter('trailing space ')).toBe(
+      '[@] match text::query("trailing space*")',
+    )
+  })
+
+  test('should handle multiple spaces between tokens', () => {
+    expect(createGroqSearchFilter('multiple  spaces')).toBe(
+      '[@] match text::query("multiple spaces*")',
+    )
+  })
+
+  test('should handle mixed token types', () => {
+    expect(createGroqSearchFilter('term1 "exact phrase" -negated term2')).toBe(
+      '[@] match text::query("term1 \\"exact phrase\\" -negated term2*")',
+    )
+  })
+
+  test('should handle mixed token types ending with negation', () => {
+    expect(createGroqSearchFilter('term1 "exact phrase" term2 -negated')).toBe(
+      '[@] match text::query("term1 \\"exact phrase\\" term2* -negated")',
+    )
+  })
+
+  test('should handle mixed token types ending with exact match', () => {
+    expect(createGroqSearchFilter('term1 -negated term2 "exact phrase"')).toBe(
+      '[@] match text::query("term1 -negated term2* \\"exact phrase\\"")',
+    )
+  })
+})

package/src/utils/createGroqSearchFilter.ts

@@ -0,0 +1,85 @@
+const WILDCARD_TOKEN = '*'
+const NEGATION_TOKEN = '-'
+// This regex handles simple cases including quoted phrases.
+// More complex query syntaxes might need a more robust parser.
+const TOKEN_REGEX = /(?:[^\s"]+|"[^"]*")+/g
+
+/**
+ * @internal
+ * Checks if a token starts with the negation character.
+ */
+function isNegationToken(token: string | undefined): boolean {
+  return typeof token !== 'undefined' && token.trim().startsWith(NEGATION_TOKEN)
+}
+
+/**
+ * @internal
+ * Checks if a token ends with the wildcard character.
+ */
+function isPrefixToken(token: string | undefined): boolean {
+  return typeof token !== 'undefined' && token.trim().endsWith(WILDCARD_TOKEN)
+}
+
+/**
+ * @internal
+ * Checks if a token is enclosed in double quotes.
+ */
+function isExactMatchToken(token: string | undefined): boolean {
+  // Ensure the token exists, has at least 2 characters, and starts/ends with "
+  return !!token && token.length >= 2 && token.startsWith('"') && token.endsWith('"')
+}
+
+/**
+ * Creates a GROQ search filter string (`[@] match text::query("...")`)
+ * from a raw search query string.
+ *
+ * It applies wildcard ('*') logic to the last eligible token and escapes
+ * double quotes within the search term.
+ *
+ * If the input query is empty or only whitespace, it returns an empty string.
+ *
+ * @param query - The raw input search string.
+ * @returns The GROQ search filter string, or an empty string.
+ * @internal
+ */
+export function createGroqSearchFilter(query: string): string {
+  // Trim leading/trailing whitespace from the overall query first
+  const trimmedQuery = query.trim()
+  if (!trimmedQuery) {
+    return '' // Return empty if query is empty or just whitespace
+  }
+
+  // Extract tokens using the regex
+  const tokens = trimmedQuery.match(TOKEN_REGEX) ?? []
+
+  // Find the index of the last token eligible for wildcard appending
+  const reversedTokens = [...tokens].reverse()
+  const reversedIndex = reversedTokens.findIndex(
+    (token: string) => !isNegationToken(token) && !isExactMatchToken(token),
+  )
+  const finalIncrementalTokenIndex = reversedIndex === -1 ? -1 : tokens.length - 1 - reversedIndex
+
+  // Get the actual token based on the found index
+  const finalIncrementalToken = tokens[finalIncrementalTokenIndex]
+
+  const processedTokens = [...tokens]
+  // If a suitable token was found and it doesn't already end with a wildcard,
+  // apply the wildcard.
+  if (finalIncrementalToken !== undefined && !isPrefixToken(finalIncrementalToken)) {
+    // Replace the identified token with its wildcarded version
+    processedTokens.splice(
+      finalIncrementalTokenIndex,
+      1,
+      `${finalIncrementalToken}${WILDCARD_TOKEN}`,
+    )
+  }
+
+  // Join the tokens back into a space-separated string
+  const wildcardSearch = processedTokens.join(' ')
+
+  // Escape double quotes within the final search term for the GROQ query
+  const escapedSearch = wildcardSearch.replace(/"/g, '\\"')
+
+  // Construct the final GROQ filter clause
+  return `[@] match text::query("${escapedSearch}")`
+}

package/src/{common/util.test.ts → utils/hashString.test.ts}

@@ -1,6 +1,6 @@
 import {describe, expect, it} from 'vitest'
 
-import {hashString} from './util'
+import {hashString} from './hashString'
 
 describe('hashString', () => {
   it('should generate consistent hashes for the same input', () => {