@mailwoman/resolver-wof-sqlite 8.0.0 → 8.2.0

package/address-point-interpolation.ts

@@ -56,7 +56,9 @@ interface PointRow {
 	release: string
 }
 
-/** One known house number on the street: the centroid of its rows (unit siblings collapse). */
+/**
+ * One known house number on the street: the centroid of its rows (unit siblings collapse).
+ */
 interface NumberAnchor {
 	n: number
 	lat: number
@@ -81,6 +83,7 @@ export class AddressPointInterpolator implements InterpolationLookup {
 		} else {
 			throw new Error("AddressPointInterpolator: one of dbPath or database is required")
 		}
+
 		this.#fallback = opts.fallback
 
 		// Degrade gracefully on an empty/tableless shard (#568): with no `address_point` table this tier
@@ -121,7 +124,9 @@ export class AddressPointInterpolator implements InterpolationLookup {
 	}
 }
 
-/** Collapse rows to one centroid anchor per distinct house number, sorted ascending. */
+/**
+ * Collapse rows to one centroid anchor per distinct house number, sorted ascending.
+ */
 function anchorsByNumber(rows: readonly PointRow[]): NumberAnchor[] {
 	const byN = new Map<number, PointRow[]>()
 
@@ -143,7 +148,7 @@ function anchorsByNumber(rows: readonly PointRow[]): NumberAnchor[] {
 			source: group[0]!.source,
 			release: group[0]!.release,
 		}))
-		.sort((a, b) => a.n - b.n)
+		.toSorted((a, b) => a.n - b.n)
 }
 
 function interpolateFromNeighbors(rows: readonly PointRow[], n: number): InterpolatedHit | null {
@@ -158,6 +163,7 @@ function interpolateFromNeighbors(rows: readonly PointRow[], n: number): Interpo
 			below = anchor
 		} else {
 			above = anchor
+
 			break
 		}
 	}

package/address-point-schema.ts

@@ -24,27 +24,43 @@ import type { Kysely } from "kysely"
  * non-finite coords). `unit`/`postcode`/`locality_norm` are nullable (not every source carries all three).
  */
 export interface AddressPointTable {
-	/** Shared {@link normalizeStreetForKey} of the street — the build/query-consistent probe key. */
+	/**
+	 * Shared {@link normalizeStreetForKey} of the street — the build/query-consistent probe key.
+	 */
 	street_norm: string
-	/** `canonicalizeRouteKey(street_norm)` — the route-fold key (#483 Method 2). */
+	/**
+	 * `canonicalizeRouteKey(street_norm)` — the route-fold key (#483 Method 2).
+	 */
 	street_key: string
-	/** House number, normalized lower-case (kept TEXT — "123-A", "12 1/2" must survive). */
+	/**
+	 * House number, normalized lower-case (kept TEXT — "123-A", "12 1/2" must survive).
+	 */
 	number: string
 	unit: string | null
 	postcode: string | null
-	/** Shared {@link normalizeLocalityForKey} of the locality — the fallback scope. */
+	/**
+	 * Shared {@link normalizeLocalityForKey} of the locality — the fallback scope.
+	 */
 	locality_norm: string | null
-	/** The street as it appeared in the source (kept for display / debugging). */
+	/**
+	 * The street as it appeared in the source (kept for display / debugging).
+	 */
 	street_raw: string
 	lat: number
 	lon: number
-	/** Provenance: the dataset this point came from (e.g. `overture:us`, `openaddresses`). */
+	/**
+	 * Provenance: the dataset this point came from (e.g. `overture:us`, `openaddresses`).
+	 */
 	source: string
-	/** The pinned data release the point was ingested from. */
+	/**
+	 * The pinned data release the point was ingested from.
+	 */
 	release: string
 }
 
-/** The address-point database schema for `new DatabaseClient<AddressPointDatabase>(...)`. */
+/**
+ * The address-point database schema for `new DatabaseClient<AddressPointDatabase>(...)`.
+ */
 export interface AddressPointDatabase {
 	address_point: AddressPointTable
 }
@@ -67,7 +83,9 @@ export const ADDRESS_POINT_COLUMNS = [
 	"release",
 ] as const
 
-/** Create the `address_point` table — called before the streaming bulk load. */
+/**
+ * Create the `address_point` table — called before the streaming bulk load.
+ */
 export async function createAddressPointTable(db: Kysely<AddressPointDatabase>): Promise<void> {
 	await db.schema
 		.createTable("address_point")
@@ -86,18 +104,22 @@ export async function createAddressPointTable(db: Kysely<AddressPointDatabase>):
 		.execute()
 }
 
-/** Create the three probe indexes the reader relies on (postcode-scope, locality-scope, route-key). */
+/**
+ * Create the three probe indexes the reader relies on (postcode-scope, locality-scope, route-key).
+ */
 export async function createAddressPointIndexes(db: Kysely<AddressPointDatabase>): Promise<void> {
 	await db.schema
 		.createIndex("idx_ap_postcode")
 		.on("address_point")
 		.columns(["postcode", "street_norm", "number"])
 		.execute()
+
 	await db.schema
 		.createIndex("idx_ap_locality")
 		.on("address_point")
 		.columns(["locality_norm", "street_norm", "number"])
 		.execute()
+
 	await db.schema.createIndex("idx_ap_streetkey").on("address_point").columns(["postcode", "street_key"]).execute()
 	// Street-first index for the BBOX scope (#247): OSM points often carry no postcode/locality, so the
 	// reader scopes a `(street_norm, number)` probe by the resolved locality's bbox (lat/lon BETWEEN). The

package/address-point.ts

@@ -63,10 +63,12 @@ export class AddressPointSqliteLookup implements AddressPointLookup {
 				`SELECT ${SELECT_COLS} FROM address_point
 				 WHERE postcode = ? AND street_norm = ? AND number = ? LIMIT 1`
 			)
+
 			this.#byLocality = this.#db.prepare(
 				`SELECT ${SELECT_COLS} FROM address_point
 				 WHERE locality_norm = ? AND street_norm = ? AND number = ? LIMIT 1`
 			)
+
 			this.#byBbox = this.#db.prepare(
 				`SELECT ${SELECT_COLS} FROM address_point
 				 WHERE street_norm = ? AND number = ? AND lat BETWEEN ? AND ? AND lon BETWEEN ? AND ? LIMIT 1`
@@ -101,6 +103,7 @@ export class AddressPointSqliteLookup implements AddressPointLookup {
 				this.#locale === "fr"
 					? stripArrondissement(normalizeLocalityForKey(query.locality))
 					: normalizeLocalityForKey(query.locality)
+
 			row = this.#byLocality.get(localityKey, streetNorm, number) as AddressPointRow | undefined
 		}
 

package/ancestry-backfill.ts

@@ -30,13 +30,19 @@ import { existsSync, readdirSync, readFileSync } from "node:fs"
 import { join } from "node:path"
 import type { DatabaseSync } from "node:sqlite"
 
-/** Genuinely top-level placetypes — they never have (or need) an ancestor, so skip them. */
+/**
+ * Genuinely top-level placetypes — they never have (or need) an ancestor, so skip them.
+ */
 const TOP_PLACETYPES = new Set(["country", "continent", "empire", "ocean", "marinearea", "planet"])
 
 export interface AncestryBackfillResult {
-	/** Places that gained at least one ancestor row. */
+	/**
+	 * Places that gained at least one ancestor row.
+	 */
 	placesFixed: number
-	/** Total ancestor rows inserted. */
+	/**
+	 * Total ancestor rows inserted.
+	 */
 	rowsAdded: number
 	/**
 	 * Only-self candidates whose source geojson could not be found (non-WOF backfilled places, or repos not present
@@ -83,7 +89,9 @@ export function discoverAdminDataRoots(reposRoot: string): string[] {
 	return roots
 }
 
-/** WOF geojson lives sharded: an id resolves to `<3-char chunks>/<id>.geojson` under each data root. */
+/**
+ * WOF geojson lives sharded: an id resolves to `<3-char chunks>/<id>.geojson` under each data root.
+ */
 function geojsonForID(id: number, roots: readonly string[]): Record<string, unknown> | null {
 	const s = String(id)
 	const chunks: string[] = []
@@ -91,6 +99,7 @@ function geojsonForID(id: number, roots: readonly string[]): Record<string, unkn
 	for (let i = 0; i < s.length; i += 3) {
 		chunks.push(s.slice(i, i + 3))
 	}
+
 	const rel = join(chunks.join("/"), `${s}.geojson`)
 
 	for (const root of roots) {
@@ -136,6 +145,7 @@ export function backfillAncestorsFromHierarchy(
 	opts: { maxId?: number } = {}
 ): AncestryBackfillResult {
 	const maxId = opts.maxId ?? Number.MAX_SAFE_INTEGER
+
 	// `s.id < ?` first lets SQLite prune by the PK index before the correlated only-self subquery runs at all.
 	const candidates = db
 		.prepare(
@@ -147,6 +157,7 @@ export function backfillAncestorsFromHierarchy(
 	const insert = db.prepare(
 		"INSERT INTO ancestors (id, ancestor_id, ancestor_placetype, lastmodified) VALUES (?, ?, ?, 0)"
 	)
+
 	const hasRow = db.prepare("SELECT 1 FROM ancestors WHERE id = ? AND ancestor_id = ? LIMIT 1")
 
 	let placesFixed = 0
@@ -160,10 +171,11 @@ export function backfillAncestorsFromHierarchy(
 		const props = (gj?.["properties"] ?? null) as Record<string, unknown> | null
 		const hierarchy = (props?.["wof:hierarchy"] ?? null) as Array<Record<string, number>> | null
 
-		if (!hierarchy || hierarchy.length === 0) {
+		if (!hierarchy || !hierarchy.length) {
 			if (!gj) {
 				noGeojson++
 			}
+
 			continue
 		}
 
@@ -190,6 +202,7 @@ export function backfillAncestorsFromHierarchy(
 		for (const [aid, pt] of seen) {
 			if (hasRow.get(id, aid)) continue
 			insert.run(id, aid, pt)
+
 			added++
 		}
 

package/ancestry.ts

@@ -36,12 +36,16 @@ export const PLACETYPE_DEPTH: Readonly<Record<string, number>> = {
 	microhood: 11,
 }
 
-/** Containment depth for a placetype — 0 (sorts coarsest) when unknown. */
+/**
+ * Containment depth for a placetype — 0 (sorts coarsest) when unknown.
+ */
 export function placetypeDepth(placetype: string): number {
 	return PLACETYPE_DEPTH[placetype] ?? 0
 }
 
-/** One ancestor row, enriched with the `spr` columns both consumers need. */
+/**
+ * One ancestor row, enriched with the `spr` columns both consumers need.
+ */
 export interface AncestorPlaceRow {
 	id: number
 	placetype: string
@@ -64,6 +68,7 @@ export function ancestorLineage(db: DatabaseSync, id: number, schemaName = "main
 			WHERE a.id = ? AND a.ancestor_id != a.id`
 		)
 		.all(id) as unknown as AncestorPlaceRow[]
+
 	rows.sort((a, b) => placetypeDepth(b.placetype) - placetypeDepth(a.placetype))
 
 	return rows

package/build-candidate.ts

@@ -42,13 +42,19 @@ import {
 } from "./candidate-schema.ts"
 import { normalizeLocalityForKey } from "./street-normalize.ts"
 
-/** Boundary-preserving alias-bag separator (#523, U+E000). */
+/**
+ * Boundary-preserving alias-bag separator (#523, U+E000).
+ */
 const ALIAS_SEP = "\u{E000}"
 
 export interface BuildCandidateOptions {
-	/** Source unified admin DB — needs spr, place_population, place_search, place_abbr, ancestors. */
+	/**
+	 * Source unified admin DB — needs spr, place_population, place_search, place_abbr, ancestors.
+	 */
 	input: string
-	/** Output candidate DB path (overwritten if present). */
+	/**
+	 * Output candidate DB path (overwritten if present).
+	 */
 	output: string
 	/**
 	 * Optional postcode shards (`spr` rows with `placetype='postalcode'` + real coords, e.g. postalcode-us.db) — folded
@@ -56,7 +62,9 @@ export interface BuildCandidateOptions {
 	 * path; the postcode-*.bin anchor stays the fallback). Matches the slim wof-hot.db, which took one such postcode DB.
 	 */
 	postcodes?: string[]
-	/** Optional progress callback for CLI / test introspection. */
+	/**
+	 * Optional progress callback for CLI / test introspection.
+	 */
 	onProgress?: (phase: string, message: string) => void
 }
 
@@ -104,6 +112,7 @@ export async function buildCandidateTable(opts: BuildCandidateOptions): Promise<
 	// assigned here; the rows are bulk-inserted via kdb once the passes have discovered every code. ---
 	const ccodes = new Map<string, number>()
 	const ptcodes = new Map<string, number>()
+
 	const ccID = (code: string | null): number => {
 		const c = (code || "??").toUpperCase()
 		let id = ccodes.get(c)
@@ -115,6 +124,7 @@ export async function buildCandidateTable(opts: BuildCandidateOptions): Promise<
 
 		return id
 	}
+
 	const ptID = (pt: string | null): number => {
 		const p = pt || ""
 		let id = ptcodes.get(p)
@@ -134,6 +144,7 @@ export async function buildCandidateTable(opts: BuildCandidateOptions): Promise<
 	for (const r of src.prepare("SELECT id, ancestor_id FROM ancestors WHERE ancestor_placetype='region'").iterate()) {
 		regionOf.set(Number(r.id), Number(r.ancestor_id))
 	}
+
 	progress("region", `${regionOf.size.toLocaleString()} places carry a region`)
 
 	// The hot path — millions of clustered rows. Kept a single positional prepared statement (the fastest
@@ -165,6 +176,7 @@ export async function buildCandidateTable(opts: BuildCandidateOptions): Promise<
 		const neg = -Math.log10(pop + 1)
 		const name = String(r.name ?? "")
 		const pkey = normalizeLocalityForKey(name)
+
 		const a: PlaceAttrs = {
 			cid,
 			rid,
@@ -180,13 +192,16 @@ export async function buildCandidateTable(opts: BuildCandidateOptions): Promise<
 			neg,
 			pkey,
 		}
+
 		attrs.set(sid, a)
 
 		if (pkey) {
 			insStage.run(pkey, cid, rid, ptid, neg, sid, name, a.lat, a.lon, a.mnLat, a.mnLon, a.mxLat, a.mxLon, pop, 1)
+
 			nPrim++
 		}
 	}
+
 	out.exec("COMMIT")
 	progress("primaries", `${nPrim.toLocaleString()} primaries; ${attrs.size.toLocaleString()} places`)
 
@@ -228,9 +243,11 @@ export async function buildCandidateTable(opts: BuildCandidateOptions): Promise<
 			if (!k || seen.has(k)) continue
 			seen.add(k)
 			stageRow(k, a, Number(r.wof_id), 0)
+
 			nAlias++
 		}
 	}
+
 	out.exec("COMMIT")
 	progress("aliases", `${nAlias.toLocaleString()} aliases`)
 
@@ -246,8 +263,10 @@ export async function buildCandidateTable(opts: BuildCandidateOptions): Promise<
 
 		if (!k) continue
 		stageRow(k, a, Number(r.id), 1)
+
 		nAbbr++
 	}
+
 	out.exec("COMMIT")
 	progress("abbrevs", `${nAbbr.toLocaleString()} abbrevs`)
 
@@ -273,6 +292,7 @@ export async function buildCandidateTable(opts: BuildCandidateOptions): Promise<
 			if (!key) continue
 			const lat = r.latitude as number
 			const lon = r.longitude as number
+
 			// region_id 0 (a postcode is unique by name+country — no same-name disambiguation); neg_rank 0
 			// (no population). bbox = the postcode's own min/max (falls back to the centroid point).
 			insStage.run(
@@ -292,8 +312,10 @@ export async function buildCandidateTable(opts: BuildCandidateOptions): Promise<
 				0,
 				1
 			)
+
 			nPostcode++
 		}
+
 		out.exec("COMMIT")
 		pc.close()
 	}
@@ -303,14 +325,14 @@ export async function buildCandidateTable(opts: BuildCandidateOptions): Promise<
 	}
 
 	// --- code dictionaries: typed batch inserts via kdb (a few hundred rows — Kysely is clean here) ---
-	if (ccodes.size > 0) {
+	if (ccodes.size) {
 		await kdb
 			.insertInto("country_codes")
 			.values([...ccodes].map(([code, id]) => ({ id, code })))
 			.execute()
 	}
 
-	if (ptcodes.size > 0) {
+	if (ptcodes.size) {
 		await kdb
 			.insertInto("placetype_codes")
 			.values([...ptcodes].map(([placetype, id]) => ({ id, placetype })))
@@ -343,6 +365,7 @@ export async function buildCandidateTable(opts: BuildCandidateOptions): Promise<
 		.selectFrom("candidate")
 		.select((eb) => eb.fn.countAll<number>().as("n"))
 		.executeTakeFirstOrThrow()
+
 	src.close()
 	await kdb.destroy()
 

package/build-slim.ts

@@ -48,13 +48,21 @@ import { buildPlaceSearchFTS, PLACE_BBOX_TABLE, PLACE_POPULATION_TABLE, PLACE_SE
 import type { NamesTable, SprTable } from "./schema.ts"
 
 export interface BuildSlimOptions {
-	/** Input WOF SQLite distributions. Each should already have spr / names / place_population tables. */
+	/**
+	 * Input WOF SQLite distributions. Each should already have spr / names / place_population tables.
+	 */
 	inputs: string[]
-	/** Output path for the slim DB. Will be overwritten if it exists. */
+	/**
+	 * Output path for the slim DB. Will be overwritten if it exists.
+	 */
 	output: string
-	/** Country codes to keep (ISO 2-letter). Defaults to `["US"]`. */
+	/**
+	 * Country codes to keep (ISO 2-letter). Defaults to `["US"]`.
+	 */
 	countries?: string[]
-	/** Cap on the number of localities to keep per country, by descending population. */
+	/**
+	 * Cap on the number of localities to keep per country, by descending population.
+	 */
 	topLocalitiesPerCountry?: number
 	/**
 	 * Drop the `names` table after the FTS index is built (default false). `place_search` is a self-contained FTS5 (no
@@ -64,7 +72,9 @@ export interface BuildSlimOptions {
 	 * alt-names at runtime should ship a SEPARATE shard rather than re-bloat the hot DB.
 	 */
 	dropNames?: boolean
-	/** Optional progress callback for CLI / test introspection. */
+	/**
+	 * Optional progress callback for CLI / test introspection.
+	 */
 	onProgress?: (phase: SlimBuildPhase, detail: string) => void
 }
 
@@ -96,16 +106,24 @@ export interface BuildSlimResult {
 	}
 }
 
-/** Placetypes that we always keep so the ancestor chain a selected locality reports stays valid. */
+/**
+ * Placetypes that we always keep so the ancestor chain a selected locality reports stays valid.
+ */
 const ANCESTOR_PLACETYPES = ["country", "region", "county", "borough", "macroregion"] as const
 
-/** Tables copied verbatim (schema + filtered rows) from each source DB. Anything else is dropped. */
+/**
+ * Tables copied verbatim (schema + filtered rows) from each source DB. Anything else is dropped.
+ */
 const COPIED_TABLES = ["spr", "names", PLACE_POPULATION_TABLE] as const
 
-/** Fallback DDL for `place_population` when the first source predates the aux table (defensive). */
+/**
+ * Fallback DDL for `place_population` when the first source predates the aux table (defensive).
+ */
 const PLACE_POPULATION_DDL = `CREATE TABLE ${PLACE_POPULATION_TABLE} (id INTEGER PRIMARY KEY, population INTEGER NOT NULL DEFAULT 0)`
 
-/** Minimal row shape for the population aux table — id + population, nothing else. */
+/**
+ * Minimal row shape for the population aux table — id + population, nothing else.
+ */
 interface PlacePopulationTable {
 	id: number
 	population: number
@@ -135,7 +153,7 @@ export async function buildSlimWOFDatabase(opts: BuildSlimOptions): Promise<Buil
 	// Skip empties up front; require every remaining path to exist.
 	const inputs = opts.inputs.filter((p) => p.length > 0)
 
-	if (inputs.length === 0) throw new Error("no input WOF dbs provided")
+	if (!inputs.length) throw new Error("no input WOF dbs provided")
 
 	for (const input of inputs) {
 		if (!existsSync(input)) throw new Error(`input WOF db not found: ${input}`)
@@ -177,6 +195,7 @@ export async function buildSlimWOFDatabase(opts: BuildSlimOptions): Promise<Buil
 					throw new Error(`source DB ${inputs[0]} is missing required table '${table}'`)
 				}
 			}
+
 			// PRIMARY KEY on spr.id + place_population.id come from the schemas we copied; an explicit
 			// index on names.id helps the per-id INSERT SELECT later.
 			out.exec(`CREATE INDEX IF NOT EXISTS names_id_idx ON names(id);`)
@@ -196,6 +215,7 @@ export async function buildSlimWOFDatabase(opts: BuildSlimOptions): Promise<Buil
 		// population aux table is NOT rebuilt here: it was copied verbatim above, and fts.ts only
 		// (re)builds it when a `geojson` table is present, which the slim DB intentionally has not.
 		progress("fts", "building place_search / place_bbox on slim DB")
+
 		buildPlaceSearchFTS(out, {
 			drop: true, // schema we copied had no FTS tables, but be explicit
 			onProgress: (phase, name) => progress("fts", `${phase} ${name}`),
@@ -239,6 +259,7 @@ export async function buildSlimWOFDatabase(opts: BuildSlimOptions): Promise<Buil
 			placeBbox: countRows(out, PLACE_BBOX_TABLE),
 			placePopulation: countRows(out, PLACE_POPULATION_TABLE),
 		}
+
 		progress("done", JSON.stringify(rowCounts))
 
 		result = {
@@ -249,6 +270,7 @@ export async function buildSlimWOFDatabase(opts: BuildSlimOptions): Promise<Buil
 	} finally {
 		out.close()
 	}
+
 	// The sealed-artifact invariant: a built DB is a read-only asset from the moment it exists.
 	sealDatabase(opts.output)
 
@@ -273,7 +295,7 @@ async function copyFromSource(
 	copyFileSync(inputPath, scratchPath)
 
 	try {
-		out.exec(`ATTACH DATABASE '${scratchPath.replace(/'/g, "''")}' AS src;`)
+		out.exec(`ATTACH DATABASE '${scratchPath.replaceAll("'", "''")}' AS src;`)
 
 		try {
 			// Does this shard carry the pre-built population aux table? The admin source does; a bare
@@ -290,6 +312,7 @@ async function copyFromSource(
 
 			// 1. Ancestor placetypes (country / region / county / etc.) — always-kept.
 			progress("country", `${inputPath}: ancestor placetypes in (${countries.join(",")})`)
+
 			await kysely
 				.insertInto("spr")
 				.expression((eb) =>
@@ -308,6 +331,7 @@ async function copyFromSource(
 			// aux table — left-join it so localities without a population row still qualify (sorted
 			// last). If the shard has no population table, fall back to a deterministic id ordering.
 			progress("locality", `${inputPath}: top-${topLocalities} localities by population`)
+
 			await kysely
 				.insertInto("spr")
 				.expression((eb) =>
@@ -327,6 +351,7 @@ async function copyFromSource(
 
 			// 3. All postcodes in scope.
 			progress("postcode", `${inputPath}: all postcodes`)
+
 			await kysely
 				.insertInto("spr")
 				.expression((eb) =>
@@ -343,6 +368,7 @@ async function copyFromSource(
 
 			// 4. Pull names for the IDs we just selected.
 			progress("names", `${inputPath}: names rows for selected IDs`)
+
 			await kysely
 				.insertInto("names")
 				.expression((eb) => eb.selectFrom("src.names").selectAll().where("id", "in", eb.selectFrom("spr").select("id")))
@@ -352,6 +378,7 @@ async function copyFromSource(
 			// 5. Pull population rows for the selected IDs (sparse — only the places WOF has a count for).
 			if (srcHasPopulation) {
 				progress("place_population", `${inputPath}: population rows for selected IDs`)
+
 				await kysely
 					.insertInto("place_population")
 					.expression((eb) =>
@@ -373,10 +400,12 @@ async function copyFromSource(
 			if (relationSchema?.sql) {
 				progress("coincident_roles", `${inputPath}: copying dual-role relation`)
 				out.exec(relationSchema.sql.replace(/CREATE TABLE/i, "CREATE TABLE IF NOT EXISTS"))
+
 				out.exec(
 					`INSERT OR IGNORE INTO coincident_roles SELECT * FROM src.coincident_roles
 						WHERE admin_id IN (SELECT id FROM spr) AND locality_id IN (SELECT id FROM spr)`
 				)
+
 				out.exec(`CREATE INDEX IF NOT EXISTS coincident_roles_by_admin ON coincident_roles (admin_id)`)
 			}
 		} finally {

package/candidate-fts.ts

@@ -37,6 +37,7 @@ export const CANDIDATE_FTS_TABLE = "candidate_fts"
 export function createCandidateFTS(db: DatabaseSync): void {
 	db.exec(`DROP TABLE IF EXISTS ${CANDIDATE_FTS_TABLE}`)
 	db.exec(`CREATE VIRTUAL TABLE ${CANDIDATE_FTS_TABLE} USING fts5(name_key, tokenize='trigram')`)
+
 	db.exec(
 		`INSERT INTO ${CANDIDATE_FTS_TABLE}(name_key) SELECT DISTINCT name_key FROM candidate WHERE name_key IS NOT NULL`
 	)