@stacksjs/search-engine 0.58.48 → 0.58.49

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/search-engine",
   "type": "module",
-  "version": "0.58.48",
+  "version": "0.58.49",
   "description": "The Stacks search engine integrations.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -45,7 +45,8 @@
   ],
   "files": [
     "README.md",
-    "dist"
+    "dist",
+    "src"
   ],
   "scripts": {
     "build": "bun --bun build.ts",

package/src/drivers/index.ts

@@ -0,0 +1 @@
+export * as meilisearch from './meilisearch'

package/src/drivers/meilisearch.ts

@@ -0,0 +1,124 @@
+import process from 'node:process'
+import { searchEngine } from '@stacksjs/config'
+import { log } from '@stacksjs/logging'
+import type { MeiliSearchOptions, SearchEngineDriver } from '@stacksjs/types'
+import { ExitCode } from '@stacksjs/types'
+import type { DocumentOptions, EnqueuedTask, Index, IndexOptions, IndexesResults, SearchResponse } from 'meilisearch'
+import { MeiliSearch } from 'meilisearch'
+
+function client(options?: MeiliSearchOptions) {
+  let host = searchEngine.meilisearch?.host
+  let apiKey = searchEngine.meilisearch?.apiKey
+
+  if (options?.host)
+    host = options.host
+
+  if (options?.apiKey)
+    apiKey = options.apiKey
+
+  if (!host) {
+    log.error('Please specify a search engine host.')
+    process.exit(ExitCode.FatalError)
+  }
+
+  return new MeiliSearch({ host, apiKey })
+}
+
+async function search(index: string, params: any): Promise<SearchResponse<Record<string, any>>> {
+  const offsetVal = ((params.page * params.perPage) - 20) || 0
+  const filter = convertToFilter(params.filter)
+  const sort = convertToMeilisearchSorting(params.sort)
+
+  return await client()
+    .index(index)
+    .search(params.query, { limit: params.perPage, filter, sort, offset: offsetVal })
+}
+
+async function addDocument(indexName: string, params: any): Promise<EnqueuedTask> {
+  return await client().index(indexName).addDocuments([params])
+}
+
+async function addDocuments(indexName: string, params: any[]): Promise<EnqueuedTask> {
+  return await client().index(indexName).addDocuments(params)
+}
+
+async function createIndex(name: string, options?: IndexOptions): Promise<EnqueuedTask> {
+  return await client().createIndex(name, options)
+}
+
+async function updateIndex(indexName: string, params: IndexOptions): Promise<EnqueuedTask> {
+  return await client().updateIndex(indexName, params)
+}
+
+async function updateDocument(indexName: string, params: DocumentOptions): Promise<EnqueuedTask> {
+  return await client().index(indexName).updateDocuments([params])
+}
+
+async function updateDocuments(indexName: string, params: DocumentOptions[]): Promise<EnqueuedTask> {
+  return await client().index(indexName).updateDocuments(params)
+}
+
+async function deleteDocument(indexName: string, id: number): Promise<EnqueuedTask> {
+  return await client().index(indexName).deleteDocument(id)
+}
+
+async function deleteDocuments(indexName: string, filters: string | string[]): Promise<EnqueuedTask> {
+  return await client().index(indexName).deleteDocuments({ filter: filters })
+}
+
+async function getDocument(indexName: string, id: number, fields: any): Promise<EnqueuedTask> {
+  return await client().index(indexName).getDocument(id, fields)
+}
+
+async function deleteIndex(indexName: string): Promise<EnqueuedTask> {
+  return await client().deleteIndex(indexName)
+}
+
+async function listAllIndexes(): Promise<IndexesResults<Index[]>> {
+  return await client().getIndexes()
+}
+
+function convertToFilter(jsonData: any): string[] {
+  const filters: string[] = []
+
+  for (const key in jsonData) {
+    if (Object.prototype.hasOwnProperty.call(jsonData, key)) {
+      const value = jsonData[key]
+      const filter = `${key}='${value}'`
+      filters.push(filter)
+    }
+  }
+
+  return filters
+}
+
+function convertToMeilisearchSorting(jsonData: any): string[] {
+  const filters: string[] = []
+
+  for (const key in jsonData) {
+    if (Object.prototype.hasOwnProperty.call(jsonData, key)) {
+      const value = jsonData[key]
+      const filter = `${key}='${value}'`
+      filters.push(filter)
+    }
+  }
+
+  return filters
+}
+
+export default {
+  client,
+  search,
+  createIndex,
+  deleteIndex,
+  updateIndex,
+  listAllIndexes,
+  addDocument,
+  addDocuments,
+  updateDocument,
+  listAllIndices: listAllIndexes,
+  updateDocuments,
+  deleteDocument,
+  deleteDocuments,
+  getDocument,
+} satisfies SearchEngineDriver

package/src/drivers/opensearch.ts

@@ -0,0 +1,59 @@
+import { searchEngine } from '@stacksjs/config'
+import type { ApiResponse } from '@opensearch-project/opensearch'
+import { Client } from '@opensearch-project/opensearch'
+import type { SearchEngineDriver } from '@stacksjs/types'
+
+const host = searchEngine.openSearch?.host
+const protocol = searchEngine.openSearch?.protocol
+const port = searchEngine.openSearch?.port
+const auth = searchEngine.openSearch?.auth
+
+const client = new Client({
+  node: `${protocol}://${auth}@${host}:${port}`,
+})
+
+async function search(index: string, params?: any) {
+  const response = await client.search({
+    index,
+    body: params.query,
+  })
+
+  return response
+}
+
+async function createIndex(indexName: string, settings?: any): Promise<ApiResponse<any, any>> {
+  return await client.indices.create({ index: indexName, body: settings })
+}
+// async function updateIndex(indexName: string,  settings?: any): Promise<ApiResponse<any, any>> {
+//   return await client.indices.update({ index: indexName, body: settings })
+// }
+
+async function deleteIndex(indexName: string): Promise<ApiResponse<any, any>> {
+  return await client.indices.delete({ index: indexName })
+}
+
+async function addDocument(indexName: string, document: any): Promise<ApiResponse<any, any>> {
+  return await client.index({
+    id: document.id,
+    index: indexName,
+    body: document,
+    refresh: true,
+  })
+}
+
+async function deleteDocument(indexName: string, document: any): Promise<ApiResponse<any, any>> {
+  return await client.delete({
+    id: document.id,
+    index: indexName,
+  })
+}
+
+export default {
+  client,
+  search,
+  createIndex,
+  deleteIndex,
+  addDocument,
+  deleteDocument,
+  // ...other methods
+} satisfies SearchEngineDriver

package/src/helpers.ts

@@ -0,0 +1,138 @@
+/**
+ * This file is used to define the types/interfaces used in the project.
+ */
+
+import type { Hits, SearchResponse } from 'meilisearch'
+
+// export function isString(val: unknown): val is string {
+//   return typeof val === 'string'
+// }
+
+// this interface is primarily used to persist data to localStorage, in a unified way
+export interface SearchEngineStore {
+  /**
+   * The search engine index.
+   */
+  index: string
+  /**
+   * The search engine host.
+   * @default 'http://127.0.0.1:7700'
+   */
+  source?: string
+  /**
+   * The search engine password/API key.
+   */
+  password?: string
+  /**
+   * The search query.
+   * @default 20
+   * @type {string}
+   * @default: ''
+   */
+  query?: string
+  /**
+   * The number of results to return.
+   * @default 20
+   * @type {number}
+   */
+  perPage?: number
+  /**
+   * The current page number
+   * @default 1
+   * @type {number}
+   */
+  currentPage?: number
+  /**
+   * The results object returned from the search engine.
+   */
+  results?: SearchResponse<Record<string, any>> // optional: the Meilisearch search response (defaults: {})
+  /**
+   * The hits object returned from the search engine.
+   */
+  hits?: Hits<Record<string, any>>
+
+  /**
+   * The search Filter Name
+   */
+  filterName?: string
+
+  /**
+   * The search filters
+   */
+  filters?: object
+
+  /**
+   * The next page value
+   */
+  goToNextPage?: number
+
+  /**
+   * Set to go to a specific page
+   */
+  goToPage?: number
+
+  /**
+   * Set to go to the previous page
+   */
+  goToPrevPage?: number
+
+  /**
+   * The last page number value
+   */
+  lastPageNumber?: number
+
+  /**
+   * The searched term to use for the search
+   */
+  search?: string
+
+  /**
+   * The search params filters to use for the search
+   */
+  searchFilters?: object
+
+  /**
+   * The search params to use for the search
+   */
+  searchParams?: object
+
+  /**
+   * Total hits value to use for the search
+   */
+  setTotalHits?: number
+
+  /**
+   * The sort value to use for the search
+   */
+  sort?: string
+
+  /**
+   * The sorts value to use for the search
+   */
+  sorts?: object
+
+  // table related config
+  // actionable?: string | boolean // optional: determines whether the table displays any "action items" (defaults: true)
+  // actions?: string | string[] // optional: the specific type of actions to be displayed/utilized in the table (defaults: 'Edit, Delete')
+  // columns: string[] // used as table heads/column titles
+  // selectable?: string | boolean // optional: determines whether the table displays the checkboxes (defaults: true)
+  // selectedRows?: number[] | string[] // optional: holds the selected rows (defaults: [])
+  // selectedAll?: boolean // optional: determines whether all the rows are selected (defaults: false)
+  // stickyHeader?: string | boolean // optional: determines whether the table displays the sticky header (defaults: false)
+  // stickyFooter?: string | boolean // optional: determines whether the table displays the sticky footer (defaults: false)
+}
+
+export function determineState(): SearchEngineStore {
+  const ls = localStorage.getItem('search-engine')
+
+  if (isString(ls))
+    return JSON.parse(ls) as SearchEngineStore
+
+  return { // default state
+    source: 'http://127.0.0.1:7700',
+    index: '',
+    perPage: 20,
+    currentPage: 1,
+    query: '',
+  }
+}

package/src/index.ts

@@ -0,0 +1,69 @@
+import { searchEngine } from '@stacksjs/config'
+import type { UiEngine } from '@stacksjs/ui'
+import { useStorage } from '@stacksjs/utils'
+
+// import { client as meilisearch } from './drivers/meilisearch'
+import { determineState } from './helpers'
+
+// import type { Ref } from '@stacksjs/types'
+
+const table = (useStorage('table', determineState()).value)
+const totalHits = table.results?.estimatedTotalHits ?? 1
+
+// state
+const pages: UiEngine.Ref<number[]> = ref([])
+export const totalPages = ref(0)
+export const currentPage = computed(() => table.currentPage)
+export const filterName = computed(() => table.filterName)
+
+export const filters = computed(() => table.filters)
+export const goToNextPage = computed(() => table.goToNextPage)
+export const goToPage = computed(() => table.goToPage)
+export const goToPrevPage = computed(() => table.goToPrevPage)
+export const hits = computed(() => table.hits)
+export const index = computed(() => table.index)
+export const lastPageNumber = computed(() => table.lastPageNumber)
+export const perPage = computed(() => table.perPage)
+export const query = computed(() => table.query)
+export const results = computed(() => table.results)
+export const searchFilters = computed(() => table.searchFilters)
+export const searchParams = computed(() => table.searchParams)
+export const setTotalHits = computed(() => table.setTotalHits)
+export const sort = computed(() => table.sort)
+export const sorts = computed(() => table.sorts)
+
+export function client() {
+  if (searchEngine.driver === 'meilisearch')
+    return meilisearch
+}
+
+export function useSearchEngine() {
+  return client()
+}
+
+export function calculatePagination() {
+  if (table.perPage)
+    totalPages.value = Math.ceil(totalHits / table.perPage)
+
+  const hitPages = [...Array(totalPages.value).keys()].map(i => i + 1)
+  const offset = 2
+  const currentPage = table.currentPage ?? 1
+  const lastPage = hitPages[hitPages.length - 1]
+
+  let from = currentPage - offset
+  if (from < 1)
+    from = 1
+
+  let to = from + offset * 2
+  if (to >= lastPage)
+    to = lastPage
+
+  const allPages = []
+  for (let page = from; page <= to; page++)
+    allPages.push(page)
+
+  pages.value = allPages
+}
+
+// it needs these exports
+// currentPage, filterName, filters, goToNextPage, goToPage, goToPrevPage, hits, index, lastPageNumber, perPage, query, results, search, searchFilters, searchParams, setTotalHits, sort, sorts, totalPages