@dokebi/search 0.0.0-stage → 0.1.1

package/templates/indexes.ts

@@ -0,0 +1,10 @@
+// The search indexes of this application (@dokebi/search, D-0170): each index has the fields a
+// list searches, and each field its term rules. `prefix` is the longest word prefix indexed
+// (default 10, so a search for a stem finds the words that start with it, Korean particles
+// included); 0 indexes whole words only. Replace the example with your own lists. After changing
+// a field's rules, index its rows again and call search.markCurrent(<index>).
+import { defineSearchIndexes } from '@dokebi/search';
+
+export default defineSearchIndexes({
+  posts: { fields: { title: {}, body: {}, author: { prefix: 0 } } },
+});

package/templates/migrations/dokebi_search.ts

@@ -0,0 +1,92 @@
+// The tables of @dokebi/search (D-0170): written by `dokebi add @dokebi/search` into the
+// migrations folder of options.dokebi-search.connection (default main). Run it with
+// `npx dokebi-migrate up`; the app never creates tables at start. Works on PostgreSQL (pg),
+// MySQL 8 (mysql2) and MariaDB 10.6+ (mariadb): the driver is told apart by the shape of one
+// SELECT answer. The tables are new, so creating them locks nothing that runs. Edit only before
+// it was applied.
+//
+// Every search reads the primary key of dokebi_search_terms backwards: an equality on
+// (index_name, field, term, scope), then the display order (sort_key, item_id). Words, scopes
+// and ids compare byte by byte (the plugin normalises the words).
+
+interface Db {
+  query(sql: string, values?: unknown[]): Promise<unknown>;
+}
+
+const TERMS = 'dokebi_search_terms';
+const COUNTS = 'dokebi_search_counts';
+const INDEXES = 'dokebi_search_indexes';
+
+const POSTGRES = [
+  `CREATE TABLE IF NOT EXISTS ${TERMS} (
+  index_name varchar(40)  COLLATE "C" NOT NULL,
+  field      varchar(40)  COLLATE "C" NOT NULL,
+  term       varchar(64)  COLLATE "C" NOT NULL,
+  scope      varchar(64)  COLLATE "C" NOT NULL DEFAULT '',
+  sort_key   bigint       NOT NULL,
+  item_id    varchar(128) COLLATE "C" NOT NULL,
+  PRIMARY KEY (index_name, field, term, scope, sort_key, item_id)
+)`,
+  `CREATE INDEX IF NOT EXISTS ${TERMS}_item ON ${TERMS} (index_name, item_id)`,
+  `CREATE TABLE IF NOT EXISTS ${COUNTS} (
+  index_name varchar(40) COLLATE "C" NOT NULL,
+  field      varchar(40) COLLATE "C" NOT NULL,
+  term       varchar(64) COLLATE "C" NOT NULL,
+  slot       smallint    NOT NULL,
+  count      bigint      NOT NULL,
+  PRIMARY KEY (index_name, field, term, slot)
+)`,
+  `CREATE TABLE IF NOT EXISTS ${INDEXES} (
+  name        varchar(40) COLLATE "C" PRIMARY KEY,
+  fingerprint varchar(64) NOT NULL,
+  updated_at  bigint      NOT NULL
+)`,
+];
+
+// MySQL and MariaDB: binary collations, so a word matches only itself (the default collation
+// would match other letter cases and accents) and the order is the byte order.
+const BIN = 'CHARACTER SET utf8mb4 COLLATE utf8mb4_bin';
+const ASCII = 'CHARACTER SET ascii COLLATE ascii_bin';
+const MYSQL = [
+  `CREATE TABLE IF NOT EXISTS ${TERMS} (
+  index_name VARCHAR(40)  ${ASCII} NOT NULL,
+  field      VARCHAR(40)  ${ASCII} NOT NULL,
+  term       VARCHAR(64)  ${BIN} NOT NULL,
+  scope      VARCHAR(64)  ${BIN} NOT NULL DEFAULT '',
+  sort_key   BIGINT       NOT NULL,
+  item_id    VARCHAR(128) ${BIN} NOT NULL,
+  PRIMARY KEY (index_name, field, term, scope, sort_key, item_id),
+  KEY ${TERMS}_item (index_name, item_id)
+) ENGINE=InnoDB`,
+  `CREATE TABLE IF NOT EXISTS ${COUNTS} (
+  index_name VARCHAR(40) ${ASCII} NOT NULL,
+  field      VARCHAR(40) ${ASCII} NOT NULL,
+  term       VARCHAR(64) ${BIN} NOT NULL,
+  slot       SMALLINT    NOT NULL,
+  count      BIGINT      NOT NULL,
+  PRIMARY KEY (index_name, field, term, slot)
+) ENGINE=InnoDB`,
+  `CREATE TABLE IF NOT EXISTS ${INDEXES} (
+  name        VARCHAR(40) ${ASCII} NOT NULL PRIMARY KEY,
+  fingerprint VARCHAR(64) ${ASCII} NOT NULL,
+  updated_at  BIGINT      NOT NULL
+) ENGINE=InnoDB`,
+];
+
+/** pg answers `{ rows }`; mysql2 and mariadb answer arrays. */
+async function statements(db: Db): Promise<string[]> {
+  const probe = await db.query('SELECT 1 AS one');
+  const postgres =
+    probe !== null &&
+    typeof probe === 'object' &&
+    Array.isArray((probe as { rows?: unknown }).rows);
+  return postgres ? POSTGRES : MYSQL;
+}
+
+export async function up(db: Db): Promise<void> {
+  for (const sql of await statements(db)) await db.query(sql);
+}
+
+export async function down(db: Db): Promise<void> {
+  for (const table of [INDEXES, COUNTS, TERMS]) await db.query(`DROP TABLE IF EXISTS ${table}`);
+}