@stacksjs/search-engine 0.75.432 → 0.75.443

package/dist/drivers/algolia.d.ts

@@ -0,0 +1,268 @@
+import type { SearchEngineDriver } from '@stacksjs/types';
+/**
+ * Configure Algolia client
+ */
+export declare function configure(options: AlgoliaConfig): void;
+/**
+ * Search an index
+ */
+export declare function search(indexName: string, params?: AlgoliaSearchParams): Promise<AlgoliaSearchResponse>;
+/**
+ * Multi-index search
+ */
+export declare function multiSearch(queries: Array<{ indexName: string, params?: AlgoliaSearchParams }>): Promise<{ results: AlgoliaSearchResponse[] }>;
+/**
+ * Add or update a single object
+ */
+export declare function saveObject(indexName: string, object: Record<string, any>, objectID?: string): Promise<AlgoliaTask>;
+/**
+ * Add or update multiple objects
+ */
+export declare function saveObjects(indexName: string, objects: Array<Record<string, any>>): Promise<AlgoliaTask>;
+/**
+ * Partially update an object
+ */
+export declare function partialUpdateObject(indexName: string, objectID: string, attributes: Record<string, any>, createIfNotExists?: boolean): Promise<AlgoliaTask>;
+/**
+ * Delete an object
+ */
+export declare function deleteObject(indexName: string, objectID: string): Promise<AlgoliaTask>;
+/**
+ * Delete multiple objects
+ */
+export declare function deleteObjects(indexName: string, objectIDs: string[]): Promise<AlgoliaTask>;
+/**
+ * Delete objects matching a filter
+ */
+export declare function deleteBy(indexName: string, filters: string): Promise<AlgoliaTask>;
+/**
+ * Get an object by ID
+ */
+export declare function getObject(indexName: string, objectID: string, attributesToRetrieve?: string[]): Promise<AlgoliaHit>;
+/**
+ * Get multiple objects by IDs
+ */
+export declare function getObjects(indexName: string, objectIDs: string[], attributesToRetrieve?: string[]): Promise<{ results: AlgoliaHit[] }>;
+/**
+ * Clear all objects from an index
+ */
+export declare function clearObjects(indexName: string): Promise<AlgoliaTask>;
+/**
+ * Get index settings
+ */
+export declare function getSettings(indexName: string): Promise<AlgoliaIndexSettings>;
+/**
+ * Update index settings
+ */
+export declare function setSettings(indexName: string, settings: AlgoliaIndexSettings, forwardToReplicas?: boolean): Promise<AlgoliaTask>;
+/**
+ * List all indices
+ */
+export declare function listIndices(): Promise<{
+  items: Array<{
+    name: string
+    createdAt: string
+    updatedAt: string
+    entries: number
+    dataSize: number
+    fileSize: number
+    lastBuildTimeS: number
+    numberOfPendingTasks: number
+    pendingTask: boolean
+    primary?: string
+    replicas?: string[]
+  }>
+}>;
+/**
+ * Copy an index
+ */
+export declare function copyIndex(srcIndexName: string, dstIndexName: string, scope?: Array<'settings' | 'synonyms' | 'rules'>): Promise<AlgoliaTask>;
+/**
+ * Move an index
+ */
+export declare function moveIndex(srcIndexName: string, dstIndexName: string): Promise<AlgoliaTask>;
+/**
+ * Delete an index
+ */
+export declare function deleteIndex(indexName: string): Promise<AlgoliaTask>;
+/**
+ * Check if an index exists
+ */
+export declare function indexExists(indexName: string): Promise<boolean>;
+/**
+ * Wait for a task to complete
+ */
+export declare function waitTask(indexName: string, taskID: number, timeoutMs?: number, intervalMs?: number): Promise<{ status: 'published' | 'notPublished' }>;
+/**
+ * Add a synonym
+ */
+export declare function saveSynonym(indexName: string, synonym: {
+    objectID: string
+    type: 'synonym' | 'oneWaySynonym' | 'altCorrection1' | 'altCorrection2' | 'placeholder'
+    synonyms?: string[]
+    input?: string
+    word?: string
+    corrections?: string[]
+    placeholder?: string
+    replacements?: string[]
+  }, forwardToReplicas?: boolean): Promise<AlgoliaTask>;
+/**
+ * Search synonyms
+ */
+export declare function searchSynonyms(indexName: string, query?: string, type?: string, page?: number, hitsPerPage?: number): Promise<{ hits: any[], nbHits: number }>;
+/**
+ * Clear all synonyms
+ */
+export declare function clearSynonyms(indexName: string, forwardToReplicas?: boolean): Promise<AlgoliaTask>;
+/**
+ * Add a rule
+ */
+export declare function saveRule(indexName: string, rule: {
+    objectID: string
+    conditions?: Array<{
+      pattern?: string
+      anchoring?: 'is' | 'startsWith' | 'endsWith' | 'contains'
+      context?: string
+    }>
+    consequence: {
+      params?: Record<string, any>
+      promote?: Array<{ objectID: string, position: number }>
+      hide?: Array<{ objectID: string }>
+      userData?: Record<string, any>
+    }
+    description?: string
+    enabled?: boolean
+    validity?: Array<{ from: number, until: number }>
+  }, forwardToReplicas?: boolean): Promise<AlgoliaTask>;
+/**
+ * Search rules
+ */
+export declare function searchRules(indexName: string, query?: string, anchoring?: string, context?: string, page?: number, hitsPerPage?: number): Promise<{ hits: any[], nbHits: number }>;
+/**
+ * Clear all rules
+ */
+export declare function clearRules(indexName: string, forwardToReplicas?: boolean): Promise<AlgoliaTask>;
+/**
+ * Browse all records in an index
+ */
+export declare function browse(indexName: string, params?: AlgoliaSearchParams): AsyncGenerator<AlgoliaHit>;
+/**
+ * The raw REST wrappers, in Algolia's own terms. The driver is the default
+ * export.
+ */
+export declare const algolia: {
+  configure: typeof configure;
+  search: typeof search;
+  multiSearch: typeof multiSearch;
+  saveObject: typeof saveObject;
+  saveObjects: typeof saveObjects;
+  partialUpdateObject: typeof partialUpdateObject;
+  deleteObject: typeof deleteObject;
+  deleteObjects: typeof deleteObjects;
+  deleteBy: typeof deleteBy;
+  getObject: typeof getObject;
+  getObjects: typeof getObjects;
+  clearObjects: typeof clearObjects;
+  getSettings: typeof getSettings;
+  setSettings: typeof setSettings;
+  listIndices: typeof listIndices;
+  copyIndex: typeof copyIndex;
+  moveIndex: typeof moveIndex;
+  deleteIndex: typeof deleteIndex;
+  indexExists: typeof indexExists;
+  waitTask: typeof waitTask;
+  saveSynonym: typeof saveSynonym;
+  searchSynonyms: typeof searchSynonyms;
+  clearSynonyms: typeof clearSynonyms;
+  saveRule: typeof saveRule;
+  searchRules: typeof searchRules;
+  clearRules: typeof clearRules;
+  browse: typeof browse
+};
+declare const algoliaDriver: SearchEngineDriver;
+export declare interface AlgoliaConfig {
+  appId: string
+  apiKey: string
+  searchOnlyApiKey?: string
+}
+export declare interface AlgoliaSearchParams {
+  query?: string
+  page?: number
+  hitsPerPage?: number
+  filters?: string
+  facets?: string[]
+  attributesToRetrieve?: string[]
+  attributesToHighlight?: string[]
+  attributesToSnippet?: string[]
+  sortBy?: string
+}
+export declare interface AlgoliaHit {
+  objectID: string
+  [key: string]: any
+}
+export declare interface AlgoliaSearchResponse {
+  hits: AlgoliaHit[]
+  nbHits: number
+  page: number
+  nbPages: number
+  hitsPerPage: number
+  processingTimeMS: number
+  query: string
+  params: string
+  facets?: Record<string, Record<string, number>>
+}
+export declare interface AlgoliaIndexSettings {
+  searchableAttributes?: string[]
+  attributesForFaceting?: string[]
+  unretrievableAttributes?: string[]
+  attributesToRetrieve?: string[]
+  ranking?: string[]
+  customRanking?: string[]
+  replicas?: string[]
+  maxValuesPerFacet?: number
+  sortFacetValuesBy?: 'count' | 'alpha'
+  attributesToHighlight?: string[]
+  attributesToSnippet?: string[]
+  highlightPreTag?: string
+  highlightPostTag?: string
+  snippetEllipsisText?: string
+  restrictHighlightAndSnippetArrays?: boolean
+  minWordSizefor1Typo?: number
+  minWordSizefor2Typos?: number
+  typoTolerance?: boolean | 'min' | 'strict'
+  allowTyposOnNumericTokens?: boolean
+  disableTypoToleranceOnAttributes?: string[]
+  disableTypoToleranceOnWords?: string[]
+  ignorePlurals?: boolean | string[]
+  removeStopWords?: boolean | string[]
+  separatorsToIndex?: string
+  queryType?: 'prefixLast' | 'prefixAll' | 'prefixNone'
+  removeWordsIfNoResults?: 'none' | 'lastWords' | 'firstWords' | 'allOptional'
+  advancedSyntax?: boolean
+  optionalWords?: string[]
+  disablePrefixOnAttributes?: string[]
+  disableExactOnAttributes?: string[]
+  exactOnSingleWordQuery?: 'attribute' | 'none' | 'word'
+  alternativesAsExact?: Array<'ignorePlurals' | 'singleWordSynonym' | 'multiWordsSynonym'>
+  numericAttributesForFiltering?: string[]
+  allowCompressionOfIntegerArray?: boolean
+  attributeForDistinct?: string
+  distinct?: boolean | number
+  replaceSynonymsInHighlight?: boolean
+  minProximity?: number
+  responseFields?: string[]
+  maxFacetHits?: number
+  paginationLimitedTo?: number
+}
+export declare interface AlgoliaTask {
+  taskID: number
+  objectID?: string
+  objectIDs?: string[]
+  createdAt?: string
+  updatedAt?: string
+}
+export declare class AlgoliaRequestError extends Error {
+  public status: number;
+  constructor(status: number, message: string);
+}
+export default algoliaDriver;

package/dist/drivers/meilisearch.d.ts

@@ -0,0 +1,3 @@
+import type { SearchEngineDriver } from '@stacksjs/types';
+declare const meilisearch: SearchEngineDriver;
+export default meilisearch;

package/dist/drivers/opensearch.d.ts

@@ -0,0 +1,7 @@
+import type { SearchEngineDriver } from '@stacksjs/types';
+declare const opensearch: SearchEngineDriver;
+declare class OpenSearchRequestError extends Error {
+  public status: number;
+  constructor(status: number, method: string, path: string, detail: string);
+}
+export default opensearch;

package/dist/drivers/typesense.d.ts

@@ -0,0 +1,38 @@
+import type { SearchEngineDriver } from '@stacksjs/types';
+declare const typesense: SearchEngineDriver;
+declare interface TypesenseField {
+  name: string
+  type: string
+  facet?: boolean
+  sort?: boolean
+  optional?: boolean
+  [key: string]: unknown
+}
+declare type TypesenseConfig = {
+  host: string
+  port: number
+  protocol: string
+  apiKey: string
+}
+/**
+ * The PATCH that brings an existing collection in line with the settings and
+ * with the documents about to be written.
+ *
+ * A field whose facet or sort flag has to change is dropped and re-added in the
+ * same request, which is how Typesense alters a field. A document field the
+ * schema lacks is added, typed from the documents. A declared attribute no
+ * document has carried yet is left out, because nothing yet says its type.
+ */
+declare type FieldChange = TypesenseField | { name: string, drop: true }
+declare class TypesenseRequestError extends Error {
+  public status: number;
+  constructor(status: number, method: string, path: string, detail: string);
+}
+/** A bulk import Typesense accepted with HTTP 200 and then refused, line by line. */
+export declare class TypesenseImportError extends Error {
+  public indexName: string;
+  public failures: Array<{ id: unknown, error: string }>;
+  public total: number;
+  constructor(indexName: string, failures: Array<{ id: unknown, error: string }>, total: number);
+}
+export default typesense;

package/dist/params.d.ts

@@ -0,0 +1,31 @@
+import type { SearchEngineSearchParams, SearchFilter, SearchSort } from '@stacksjs/types';
+export declare function resolveSearchParams(params: SearchEngineSearchParams | string | undefined, defaultLimit?: number): ResolvedSearchParams;
+/** An object filter: `{ field: value }`, as opposed to engine syntax. */
+export declare function isObjectFilter(filter: unknown): filter is Record<string, unknown>;
+export declare function assertSafeField(driver: string, field: string): void;
+/** `{ price: 'desc', name: 'asc' }` as `['price:desc', 'name:asc']`; strings pass through. */
+export declare function sortToList(driver: string, sort: SearchSort | undefined): string[];
+export declare const DEFAULT_SEARCH_LIMIT: 20;
+/**
+ * Field names go into a filter DSL as identifiers, so only identifier
+ * characters (plus `.` for nested paths) are accepted. Without the check a key
+ * like `"category';TRUNCATE INDEX;'"` closes the clause and injects its own.
+ */
+export declare const SAFE_FILTER_FIELD: RegExp;
+/**
+ * The search parameters every driver reads, resolved once.
+ *
+ * Each driver used to read its own subset of names. The ORM's builder sends
+ * `{ q, limit, offset, filter }`; Meilisearch read `query`, `page` and
+ * `perPage`, found none of them, and searched for nothing - so
+ * `Product.search('widget').get()` returned the first twenty documents in the
+ * index, and `.paginate(10, 3)` returned page one every time. Resolving the
+ * contract here, once, is what keeps the drivers from drifting apart again.
+ */
+export declare interface ResolvedSearchParams {
+  query: string
+  limit: number
+  offset: number
+  filter?: SearchFilter
+  sort?: SearchSort
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@stacksjs/search-engine",
   "type": "module",
   "sideEffects": false,
-  "version": "0.75.432",
+  "version": "0.75.443",
   "description": "The Stacks search engine integrations.",
   "author": "Chris Breuer",
   "contributors": [
@@ -64,14 +64,14 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@stacksjs/config": "0.75.432",
-    "@stacksjs/database": "0.75.432",
-    "@stacksjs/error-handling": "0.75.432",
-    "@stacksjs/logging": "0.75.432",
-    "@stacksjs/orm": "0.75.432",
-    "@stacksjs/path": "0.75.432",
-    "@stacksjs/storage": "0.75.432",
-    "@stacksjs/strings": "0.75.432"
+    "@stacksjs/config": "0.75.443",
+    "@stacksjs/database": "0.75.443",
+    "@stacksjs/error-handling": "0.75.443",
+    "@stacksjs/logging": "0.75.443",
+    "@stacksjs/orm": "0.75.443",
+    "@stacksjs/path": "0.75.443",
+    "@stacksjs/storage": "0.75.443",
+    "@stacksjs/strings": "0.75.443"
   },
   "peerDependencies": {
     "meilisearch": "^0.62.0"