@graphcommerce/docs 3.1.4 → 4.0.0

package/lib/DocumentIndexer.ts

@@ -1,59 +0,0 @@
-/* eslint-disable class-methods-use-this */
-import path from 'path'
-import { remark } from 'remark'
-import remarkGfm from 'remark-gfm'
-import strip from 'strip-markdown'
-import { toVFile as vfile } from 'to-vfile'
-import { matter } from 'vfile-matter'
-import { FileNode, findByUrl, getDirectoryPaths, getDirectoryTree } from './files'
-import { indexName } from './instantSearch'
-import { BaseDocument, SearchIndexer } from './typesense/SearchIndexer'
-
-export type DocumentationDocument = BaseDocument & {
-  url: string
-  content: string
-  name: string
-}
-
-export class DocumentIndexer extends SearchIndexer<DocumentationDocument> {
-  #root: string
-
-  constructor(root: string) {
-    super({
-      name: indexName,
-      fields: {
-        id: { type: 'string' },
-        name: { type: 'string' },
-        url: { type: 'string' },
-        content: { type: 'string' },
-      },
-    })
-    this.#root = root
-  }
-
-  // load a single document
-  async #loadDocument(node?: FileNode | false): Promise<DocumentationDocument> {
-    if (!node) throw Error('Node not found')
-
-    const file = path.join(process.cwd(), this.#root, node.path)
-    const res = matter(await vfile.read(file), { strip: true })
-    const content = (await remark().use(strip).process(res)).value.toString()
-
-    if (!content) throw Error('Can not load file')
-
-    const { name, url } = node
-    return { id: node.path, content, url, name: node.matter.menu ?? name }
-  }
-
-  async *all() {
-    const paths = await getDirectoryPaths(this.#root)
-    const menuData = await getDirectoryTree(this.#root)
-    if (!menuData) return false
-
-    for (const p of paths) {
-      yield this.#loadDocument(findByUrl(p.split('/'), menuData))
-    }
-
-    return true
-  }
-}

package/lib/files.ts

@@ -1,168 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import { toVFile as vfile } from 'to-vfile'
-import { matter } from 'vfile-matter'
-
-export type MatterFields = {
-  menu?: string
-  order?: string
-  metaTitle?: string
-  metaDescription?: string
-}
-
-type BaseFields = {
-  type: 'folder' | 'file'
-  path: string
-  name: string
-  childNodes?: FileOrFolderNode[]
-  matter?: MatterFields
-}
-
-export type FolderNode = BaseFields & { type?: 'folder' }
-export type FileNode = BaseFields & { type?: 'file'; url: string; matter: MatterFields }
-
-export type FileOrFolderNode = FolderNode | FileNode
-
-function toUrl(p: string) {
-  let url = p.replace('.mdx', '')
-  url = url.replace('.md', '')
-  url = url.endsWith('/') ? url.slice(0, -1) : url
-  return url
-}
-
-async function dirTree(dir: string, root: string): Promise<FileOrFolderNode> {
-  const stats = await fs.promises.lstat(dir)
-
-  let name = path.basename(dir)
-  name = name.replace('.mdx', '')
-  name = name.replace('.md', '')
-  name = name.replace(/-/g, ' ').replace(/^./, (x) => x.toUpperCase())
-
-  const filePath = path.relative(root, dir)
-
-  const info: Partial<FileOrFolderNode> = { path: filePath, name }
-
-  if (stats.isDirectory()) {
-    info.type = 'folder'
-    info.childNodes = await Promise.all(
-      (await fs.promises.readdir(dir)).map((child) => dirTree(`${dir}/${child}`, root)),
-    )
-  } else {
-    info.type = 'file'
-  }
-
-  if (info.type === 'file') {
-    info.url = toUrl(path.relative(root, dir))
-    info.matter = matter(await vfile.read(dir)).data.matter as Record<string, string>
-  }
-
-  return info as FileOrFolderNode
-}
-
-// Replace the path of the parent with the path of the child having index.mdx as name and remove from children.
-// Do this recursively for each child.
-// Remove type from tree
-function hoistIndex(tree: FileOrFolderNode): FileOrFolderNode {
-  let newTree: FileOrFolderNode = tree
-
-  if (newTree.type === 'folder') {
-    const index = newTree.childNodes?.find(
-      (child) =>
-        child.path.endsWith('readme.mdx') ||
-        (child.path.endsWith('readme.md') && child.type === 'file'),
-    ) as FileNode | undefined
-
-    if (index) {
-      newTree = { ...index, name: tree.name, url: index.url.slice(0, -7) }
-      newTree.childNodes = tree.childNodes?.filter((child) => child !== index)
-
-      const order = index.matter?.order?.split(',').map((x) => x.trim())
-      if (order) {
-        newTree.childNodes = newTree.childNodes?.sort((a, b) => {
-          const aPath = toUrl(a.path.split('/').pop() as string)
-          const bPath = toUrl(b.path.split('/').pop() as string)
-          return order.indexOf(aPath) === -1 ? 1 : order.indexOf(aPath) - order.indexOf(bPath)
-        })
-      }
-
-      newTree.childNodes = newTree.childNodes?.map((child) => hoistIndex(child))
-    }
-  }
-  return newTree
-}
-
-export async function getDirectoryTree(dir: string): Promise<false | FileNode> {
-  const absDir = path.join(process.cwd(), dir)
-
-  const tree = await dirTree(absDir, absDir)
-
-  return hoistIndex(tree) as FileNode
-}
-
-export async function getDirectoryPaths(dir: string) {
-  const menuData = await getDirectoryTree(dir)
-
-  const paths: string[] = []
-  const addPathsFromTree = (tree: FileOrFolderNode) => {
-    if (tree.type === 'file') paths.push(tree.url)
-
-    if (tree.childNodes?.length) {
-      tree.childNodes.forEach((child) => addPathsFromTree(child))
-    }
-  }
-  if (menuData) addPathsFromTree(menuData)
-
-  return paths
-}
-
-/**
- * Recursively traverse the tree and return the aggregated path of of each node.
- *
- * Each URL segment should reference a path (except for the readme.md/readme.mdx file)
- */
-export function urlToPath(url: string[], node: FileOrFolderNode): string | false {
-  if (node.childNodes?.length) {
-    const child = node.childNodes?.reduce<string | false>((prev, curr) => {
-      if (prev) return prev
-      const childPath = urlToPath(url, curr)
-      return childPath ?? prev
-    }, false)
-
-    if (child) return child
-  }
-
-  if (node.type === 'file' && node.url === url.join('/')) return node.path
-
-  return false
-}
-
-/** Get the contens of the requested file. */
-export function getFileContents(dir: string, filePath: string) {
-  const absDir = path.join(process.cwd(), dir, filePath)
-  try {
-    return fs.promises.readFile(absDir, 'utf8')
-  } catch (e) {
-    return false
-  }
-}
-
-/**
- * Recursively traverse the tree and return the aggregated path of of each node.
- *
- * Each URL segment should reference a path (except for the readme.md/readme.mdx file)
- */
-export function findByUrl(url: string[], node: FileOrFolderNode): FileNode | false {
-  if (node.childNodes?.length) {
-    const child = node.childNodes?.reduce<FileNode | false>((prev, curr) => {
-      if (prev) return prev
-      const childPath = findByUrl(url, curr)
-      return childPath ?? prev
-    }, false)
-
-    if (child) return child
-  }
-
-  if (node.type === 'file' && node.url === url.join('/')) return node
-
-  return false
-}

package/lib/instantSearch.ts

@@ -1,26 +0,0 @@
-import type { HitsRenderState } from 'instantsearch.js/es/connectors/hits/connectHits'
-import { useHits as useHitsBase } from 'react-instantsearch-hooks'
-import { SetReturnType } from 'type-fest'
-import type { DocumentationDocument } from './DocumentIndexer'
-import { createInstantSearchProps } from './typesense/createInstantSearchProps'
-
-export const indexName = 'documents'
-
-export const instantSearchProps = createInstantSearchProps<DocumentationDocument>(indexName, {
-  query_by: {
-    name: 2,
-    content: 1,
-  },
-  numTypos: '1',
-  typoTokensThreshold: 1,
-  highlight_fields: 'content',
-  highlight_full_fields: 'name',
-  include_fields: 'name,url',
-  // highlight_affix_num_tokens: ,
-})
-
-const useHits: SetReturnType<typeof useHitsBase, HitsRenderState<DocumentationDocument>> = (
-  ...params
-) => useHitsBase(...params) as HitsRenderState<DocumentationDocument>
-
-export { useHits }

package/lib/typesense/IndexerHandler.ts

@@ -1,47 +0,0 @@
-import { Client } from 'typesense/lib/Typesense'
-import { ConfigurationOptions } from 'typesense/lib/Typesense/Configuration'
-import { ObjectNotFound } from 'typesense/lib/Typesense/Errors'
-import { BaseDocument, SearchIndexer } from './SearchIndexer'
-import { batchIterable } from './batchInterable'
-
-export class IndexerHandler {
-  client: Client
-
-  constructor(
-    clientOptions: ConfigurationOptions,
-    public indexers: SearchIndexer<BaseDocument>[],
-    private batchSize: number = 1000,
-  ) {
-    this.client = new Client(clientOptions)
-  }
-
-  async all() {
-    let count = 0
-    for await (const indexer of this.indexers) {
-      const resCount = await this.#reindex(indexer)
-      count += resCount
-    }
-    return count
-  }
-
-  /** @throws {TypesenseError} */
-  async #reindex(indexer: SearchIndexer<BaseDocument>) {
-    const { name } = indexer.schema
-
-    try {
-      await this.client.collections(name).retrieve()
-      await this.client.collections(name).delete()
-    } catch (e) {
-      if (!(e instanceof ObjectNotFound)) throw e
-    }
-    await this.client.collections().create(indexer.schema)
-
-    let count = 0
-    for await (const documents of batchIterable(indexer.all(), this.batchSize)) {
-      const result = await this.client.collections(name).documents().import(documents)
-      count += result.length
-    }
-
-    return count
-  }
-}

package/lib/typesense/Leaves.ts

@@ -1,37 +0,0 @@
-export type Leaves<T, D extends number = 10> = [D] extends [never]
-  ? never
-  : T extends object
-  ? { [K in keyof T]-?: Join<K, Leaves<T[K], Prev[D]>> }[keyof T]
-  : ''
-
-type Prev = [
-  never,
-  0,
-  1,
-  2,
-  3,
-  4,
-  5,
-  6,
-  7,
-  8,
-  9,
-  10,
-  11,
-  12,
-  13,
-  14,
-  15,
-  16,
-  17,
-  18,
-  19,
-  20,
-  ...0[]
-]
-
-type Join<K, P> = K extends string | number
-  ? P extends string | number
-    ? `${K}${'' extends P ? '' : '.'}${P}`
-    : never
-  : never

package/lib/typesense/SearchIndexer.ts

@@ -1,64 +0,0 @@
-import { ConditionalExcept, Get } from 'type-fest'
-import { CollectionFieldSchema } from 'typesense/lib/Typesense/Collection'
-import { CollectionCreateSchema } from 'typesense/lib/Typesense/Collections'
-import { Leaves } from './Leaves'
-
-type FieldValues = Record<string, any>
-
-type SchemaType<
-  TFieldValues extends FieldValues,
-  TFieldPath extends Leaves<TFieldValues>,
-  T = Get<TFieldValues, TFieldPath>,
-> = T extends object
-  ? never
-  : T extends string
-  ? 'string'
-  : T extends number
-  ? 'number'
-  : T extends boolean
-  ? 'boolean'
-  : T
-
-type OptionalType<
-  TFieldValues extends FieldValues,
-  TFieldPath extends Leaves<TFieldValues>,
-  T = Get<TFieldValues, TFieldPath>,
-> = T extends undefined ? true : never
-
-export type BaseDocument = {
-  id: string
-}
-
-export type CreateSchema<Schema extends BaseDocument> = Omit<CollectionCreateSchema, 'fields'> & {
-  fields: {
-    [K in Leaves<Schema>]: ConditionalExcept<
-      {
-        type: SchemaType<Schema, K>
-        optional: OptionalType<Schema, K>
-      } & Omit<CollectionFieldSchema, 'type' | 'optional' | 'name'>,
-      never
-    >
-  }
-}
-
-export abstract class SearchIndexer<T extends BaseDocument> {
-  name: string
-
-  schema: CollectionCreateSchema
-
-  constructor(schema: CreateSchema<T>) {
-    this.name = schema.name
-
-    const fields = Object.entries(schema.fields).map(
-      ([name, field]) =>
-        ({
-          name,
-          ...(field as Omit<CollectionFieldSchema, 'name'>),
-        } as CollectionFieldSchema),
-    )
-
-    this.schema = { ...schema, fields }
-  }
-
-  abstract all(): AsyncGenerator<T>
-}

package/lib/typesense/batchInterable.ts

@@ -1,13 +0,0 @@
-export async function* batchIterable<T>(iterable: AsyncIterableIterator<T>, batchSize: number) {
-  let items: T[] = []
-  for await (const item of iterable) {
-    items.push(item)
-    if (items.length >= batchSize) {
-      yield items
-      items = []
-    }
-  }
-  if (items.length !== 0) {
-    yield items
-  }
-}

package/lib/typesense/createInstantSearchProps.ts

@@ -1,36 +0,0 @@
-import { InstantSearchProps } from 'react-instantsearch-hooks'
-import TypesenseInstantSearchAdapter from 'typesense-instantsearch-adapter'
-import { Leaves } from './Leaves'
-import { BaseDocument } from './SearchIndexer'
-import { typesenseClientConf } from './typesenseClientConf'
-
-type BaseParams = Omit<
-  NonNullable<
-    ConstructorParameters<typeof TypesenseInstantSearchAdapter>[0]['additionalSearchParameters']
-  >,
-  'query_by' | 'query_by_weight'
->
-
-type InstantSearchClientParams<Document extends BaseDocument> = BaseParams & {
-  query_by: {
-    [key in Leaves<Document>]?: number
-  }
-}
-
-export function createInstantSearchProps<Document extends BaseDocument>(
-  indexName: string,
-  params: InstantSearchClientParams<Document>,
-): InstantSearchProps {
-  const { query_by, ...rest } = params
-
-  const { searchClient } = new TypesenseInstantSearchAdapter({
-    server: typesenseClientConf(),
-    additionalSearchParameters: {
-      query_by: Object.keys(query_by).join(','),
-      query_by_weights: Object.values(query_by).join(','),
-      ...rest,
-    },
-  })
-
-  return { searchClient, indexName }
-}

package/lib/typesense/typesenseClientConf.ts

@@ -1,23 +0,0 @@
-import { ConfigurationOptions } from 'typesense/lib/Typesense/Configuration'
-
-export function typesenseClientConf() {
-  // Be sure to use an API key that only allows searches, in production
-  const apiKey = process.env.NEXT_PUBLIC_TYPESENSE_SEARCH_ONLY_API_KEY
-  const host = process.env.NEXT_PUBLIC_TYPESENSE_HOST
-  const port = Number(process.env.NEXT_PUBLIC_TYPESENSE_PORT)
-  const protocol = process.env.NEXT_PUBLIC_TYPESENSE_PROTOCOL
-
-  if (!apiKey) throw Error('Please provide NEXT_PUBLIC_TYPESENSE_SEARCH_ONLY_API_KEY')
-  if (!host) throw Error('Please provide NEXT_PUBLIC_TYPESENSE_HOST')
-  if (!port) throw Error('Please provide NEXT_PUBLIC_TYPESENSE_PORT')
-  if (!protocol) throw Error('Please provide NEXT_PUBLIC_TYPESENSE_PROTOCOL')
-
-  const conf: ConfigurationOptions = {
-    apiKey,
-    nodes: [{ host, port, protocol }],
-    numRetries: 8,
-    connectionTimeoutSeconds: 1,
-  }
-
-  return conf
-}

package/lib/typesense/typesenseIndexerHandler.ts

@@ -1,23 +0,0 @@
-import type { NextApiRequest, NextApiResponse } from 'next'
-import { TypesenseError } from 'typesense/lib/Typesense/Errors'
-import { IndexerHandler } from './IndexerHandler'
-import { BaseDocument, SearchIndexer } from './SearchIndexer'
-import { typesenseClientConf } from './typesenseClientConf'
-
-export function typesenseIndexerHandler(indexers: SearchIndexer<BaseDocument>[]) {
-  return async (req: NextApiRequest, res: NextApiResponse) => {
-    const handler = new IndexerHandler(typesenseClientConf(), indexers)
-    try {
-      const count = await handler.all()
-      res.status(200).json({ status: 'success', count })
-    } catch (e) {
-      if (e instanceof TypesenseError) {
-        res.json(e)
-      }
-      console.log(e)
-      res.status(500)
-    }
-
-    res.end()
-  }
-}

package/next-env.d.ts

@@ -1,5 +0,0 @@
-/// <reference types="next" />
-/// <reference types="next/image-types/global" />
-
-// NOTE: This file should not be edited
-// see https://nextjs.org/docs/basic-features/typescript for more information.

package/next.config.js

@@ -1,21 +0,0 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
-const withYarn1Workspaces = require('@graphcommerce/next-config').withYarn1Scopes()
-
-/** @type {import('next').NextConfig} */
-const nextConfig = {
-  // https://nextjs.org/docs/api-reference/next.config.js/configuring-onDemandEntries
-  onDemandEntries: {
-    maxInactiveAge: 10 * 60 * 1000, // 10 minutes
-  },
-  eslint: {
-    ignoreDuringBuilds: true,
-  },
-  typescript: {
-    ignoreBuildErrors: true,
-  },
-  experimental: {
-    scrollRestoration: true,
-  },
-}
-
-module.exports = withYarn1Workspaces(nextConfig)