@kelpie/server 0.1.0

package/dist/modules/reseal.js

@@ -0,0 +1,108 @@
+import { eq } from 'drizzle-orm';
+import { SecretDecryptionError } from '../lib/secrets.js';
+import { agentRegistrations } from './agent-tasks/schema.js';
+import { integrationConnections } from './integrations/schema.js';
+import { webhooks } from './webhooks/schema.js';
+/**
+ * Every column holding a value sealed by `lib/secrets.ts`.
+ *
+ * All three that exist are here, including the two nothing writes yet. Covering
+ * a column before its first write is the cheap half of this: the expensive half
+ * is noticing, a year later, that a rotation reported success while stranding a
+ * customer's stored OAuth credential with no way back. `resealTest` asserts this
+ * list against the schema, so a fourth `_encrypted` column fails a test the day
+ * it is added rather than at the next rotation.
+ *
+ * There is no registry for modules to declare these through, on purpose. One
+ * caller does not need an extension point, and a sealed column that nothing
+ * re-seals is a bug whichever way it was registered.
+ */
+const SEALED_COLUMNS = [
+    {
+        label: 'webhooks.secret_encrypted',
+        read: async (db) => db.select({ id: webhooks.id, sealed: webhooks.secretEncrypted }).from(webhooks),
+        write: async (db, id, sealed) => {
+            await db.update(webhooks).set({ secretEncrypted: sealed }).where(eq(webhooks.id, id));
+        },
+    },
+    {
+        label: 'webhooks.previous_secret_encrypted',
+        read: async (db) => db.select({ id: webhooks.id, sealed: webhooks.previousSecretEncrypted }).from(webhooks),
+        write: async (db, id, sealed) => {
+            await db.update(webhooks).set({ previousSecretEncrypted: sealed }).where(eq(webhooks.id, id));
+        },
+    },
+    {
+        label: 'agent_registrations.auth_header_encrypted',
+        read: async (db) => db
+            .select({ id: agentRegistrations.id, sealed: agentRegistrations.authHeaderEncrypted })
+            .from(agentRegistrations),
+        write: async (db, id, sealed) => {
+            await db
+                .update(agentRegistrations)
+                .set({ authHeaderEncrypted: sealed })
+                .where(eq(agentRegistrations.id, id));
+        },
+    },
+    {
+        label: 'integration_connections.secrets_encrypted',
+        read: async (db) => db
+            .select({ id: integrationConnections.id, sealed: integrationConnections.secretsEncrypted })
+            .from(integrationConnections),
+        write: async (db, id, sealed) => {
+            await db
+                .update(integrationConnections)
+                .set({ secretsEncrypted: sealed })
+                .where(eq(integrationConnections.id, id));
+        },
+    },
+];
+/** The columns this pass covers. Exported for the test that checks none is missing. */
+export const RESEALED_COLUMNS = SEALED_COLUMNS.map((column) => column.label);
+/**
+ * Reads every sealed column, and rewrites anything not already under the
+ * current key.
+ *
+ * Does not throw for a row it cannot open. One unreadable row must not stop the
+ * pass from fixing every other one, so it is reported and the caller decides
+ * what a non-empty `unreadable` means.
+ */
+export async function resealStoredSecrets(db, cipher) {
+    const columns = [];
+    for (const column of SEALED_COLUMNS) {
+        // Null means the row holds no secret, which is every row of a column whose
+        // module has not started writing one. Not counted as examined: a report
+        // saying it looked at forty rows and re-sealed none would read as a problem.
+        const rows = (await column.read(db)).filter((row) => row.sealed !== null);
+        const unreadable = [];
+        let resealed = 0;
+        for (const row of rows) {
+            let next;
+            try {
+                next = cipher.reseal(row.sealed);
+            }
+            catch (error) {
+                if (!(error instanceof SecretDecryptionError)) {
+                    throw error;
+                }
+                unreadable.push(row.id);
+                continue;
+            }
+            // Undefined means it is already sealed under the current key, which is
+            // every row on a second run and most rows on the first.
+            if (next === undefined) {
+                continue;
+            }
+            await column.write(db, row.id, next);
+            resealed += 1;
+        }
+        columns.push({ label: column.label, examined: rows.length, resealed, unreadable });
+    }
+    return {
+        columns,
+        examined: columns.reduce((total, column) => total + column.examined, 0),
+        resealed: columns.reduce((total, column) => total + column.resealed, 0),
+        unreadable: columns.reduce((total, column) => total + column.unreadable.length, 0),
+    };
+}
+//# sourceMappingURL=reseal.js.map

package/dist/modules/reseal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reseal.js","sourceRoot":"","sources":["../../src/modules/reseal.ts"],"names":[],"mappings":"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"}

package/dist/modules/search/index.d.ts

@@ -0,0 +1,21 @@
+import type { KelpieModule } from '../../runtime/module.ts';
+/**
+ * One box across nine collections.
+ *
+ * It contributes no tables and calls no `context.schema`. The `search_vector`
+ * column each searchable table carries belongs to that table's own module, which
+ * is the only place that knows which of its columns are worth indexing.
+ *
+ * `requires` names every module holding one of those columns, including the two
+ * that are never results themselves: `positions` carries the job titles People are
+ * found by, and `plans` the step titles Deals, Opportunities and Raises are found
+ * by. Nothing here runs at registration, so this is not about ordering. It is
+ * about an assembly built without one of them, which would boot and then answer
+ * this endpoint with a query against a table that has no migration.
+ *
+ * `structural`, like `dashboard`: the search box is in the application shell on
+ * every page, so a workspace that switched this off would be left with a control
+ * that answers 404.
+ */
+export declare function createSearchModule(): KelpieModule;
+//# sourceMappingURL=index.d.ts.map

package/dist/modules/search/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/modules/search/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAK3D;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,IAAI,YAAY,CA+BjD"}

package/dist/modules/search/index.js

@@ -0,0 +1,50 @@
+import { mountSearchRoutes } from './routes.js';
+import { createSearchService } from './service.js';
+import { registerSearchTools } from './tools.js';
+/**
+ * One box across nine collections.
+ *
+ * It contributes no tables and calls no `context.schema`. The `search_vector`
+ * column each searchable table carries belongs to that table's own module, which
+ * is the only place that knows which of its columns are worth indexing.
+ *
+ * `requires` names every module holding one of those columns, including the two
+ * that are never results themselves: `positions` carries the job titles People are
+ * found by, and `plans` the step titles Deals, Opportunities and Raises are found
+ * by. Nothing here runs at registration, so this is not about ordering. It is
+ * about an assembly built without one of them, which would boot and then answer
+ * this endpoint with a query against a table that has no migration.
+ *
+ * `structural`, like `dashboard`: the search box is in the application shell on
+ * every page, so a workspace that switched this off would be left with a control
+ * that answers 404.
+ */
+export function createSearchModule() {
+    return {
+        id: 'search',
+        requires: [
+            'workspace',
+            'people',
+            'positions',
+            'companies',
+            'deals',
+            'opportunities',
+            'partnerships',
+            'raises',
+            'hiring',
+            'plans',
+            'decisions',
+            'handbook',
+        ],
+        structural: true,
+        register(context) {
+            const service = createSearchService({ db: context.db });
+            context.routes((router) => {
+                mountSearchRoutes(router, { db: context.db, now: context.now, service });
+            });
+            registerSearchTools(context.mcp, service);
+            return Promise.resolve();
+        },
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/modules/search/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/modules/search/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAC/C,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAClD,OAAO,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AAEhD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,kBAAkB;IAChC,OAAO;QACL,EAAE,EAAE,QAAQ;QACZ,QAAQ,EAAE;YACR,WAAW;YACX,QAAQ;YACR,WAAW;YACX,WAAW;YACX,OAAO;YACP,eAAe;YACf,cAAc;YACd,QAAQ;YACR,QAAQ;YACR,OAAO;YACP,WAAW;YACX,UAAU;SACX;QACD,UAAU,EAAE,IAAI;QAEhB,QAAQ,CAAC,OAAO;YACd,MAAM,OAAO,GAAG,mBAAmB,CAAC,EAAE,EAAE,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,CAAA;YAEvD,OAAO,CAAC,MAAM,CAAC,CAAC,MAAM,EAAE,EAAE;gBACxB,iBAAiB,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,OAAO,CAAC,EAAE,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE,OAAO,EAAE,CAAC,CAAA;YAC1E,CAAC,CAAC,CAAA;YAEF,mBAAmB,CAAC,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,CAAA;YAEzC,OAAO,OAAO,CAAC,OAAO,EAAE,CAAA;QAC1B,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/modules/search/query.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Turning what someone typed into a `tsquery`, and lifting a readable fragment
+ * out of what matched.
+ *
+ * Pure: no database, no actor, no clock. Both halves are the parts of search most
+ * likely to be wrong in a way no integration test would notice, so both are unit
+ * tested against their own cases.
+ */
+/**
+ * How long a `?q=` may be before the boundary refuses it.
+ *
+ * Every word becomes a clause of an `&`-joined `tsquery`, so an unbounded string
+ * is an unbounded query plan. Nobody searches a CRM with a paragraph.
+ */
+export declare const MAX_SEARCH_TERM_LENGTH = 200;
+/**
+ * The typed string as a `tsquery`, or null when it holds nothing to search for.
+ *
+ * Every word is a prefix clause. Someone typing `acm` into a search box is part
+ * way through `acme` and expects to see it; `to_tsquery('acm')` alone finds
+ * nothing, because full-text matches whole lexemes. Stemming still applies on top,
+ * so `meetings` finds a record that says `meeting`.
+ *
+ * Words are joined with `&`: every word has to appear somewhere in the record.
+ * `|` would rank a record matching one word of four alongside one matching all of
+ * them, which reads as a search box that ignores what you typed.
+ *
+ * @returns null when the input holds no letters or digits at all, which is a
+ *   query with no clauses rather than a syntax error to hand to Postgres.
+ */
+export declare function toTsQuery(raw: string): string | null;
+/** The words `toTsQuery` searched for, which is what `snippet` centres on. */
+export declare function searchWords(raw: string): readonly string[];
+/**
+ * A one-line fragment of `body`, centred on the first search word it contains.
+ *
+ * Falls back to the opening of the text when no word appears literally, because a
+ * result with no preview at all reads as a result with no content.
+ *
+ * @param body The record's own prose. Markdown is flattened first.
+ * @param words What was searched for, from `searchWords`.
+ */
+export declare function snippet(body: string, words: readonly string[]): string;
+//# sourceMappingURL=query.d.ts.map

package/dist/modules/search/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../src/modules/search/query.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,MAAM,CAAA;AAKzC;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQpD;AAED,8EAA8E;AAC9E,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAE1D;AA6BD;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAiBtE"}

package/dist/modules/search/query.js

@@ -0,0 +1,88 @@
+/**
+ * Turning what someone typed into a `tsquery`, and lifting a readable fragment
+ * out of what matched.
+ *
+ * Pure: no database, no actor, no clock. Both halves are the parts of search most
+ * likely to be wrong in a way no integration test would notice, so both are unit
+ * tested against their own cases.
+ */
+/**
+ * How long a `?q=` may be before the boundary refuses it.
+ *
+ * Every word becomes a clause of an `&`-joined `tsquery`, so an unbounded string
+ * is an unbounded query plan. Nobody searches a CRM with a paragraph.
+ */
+export const MAX_SEARCH_TERM_LENGTH = 200;
+/** Anything that is not a letter or a digit separates one word from the next. */
+const SEPARATORS = /[^\p{L}\p{N}]+/gu;
+/**
+ * The typed string as a `tsquery`, or null when it holds nothing to search for.
+ *
+ * Every word is a prefix clause. Someone typing `acm` into a search box is part
+ * way through `acme` and expects to see it; `to_tsquery('acm')` alone finds
+ * nothing, because full-text matches whole lexemes. Stemming still applies on top,
+ * so `meetings` finds a record that says `meeting`.
+ *
+ * Words are joined with `&`: every word has to appear somewhere in the record.
+ * `|` would rank a record matching one word of four alongside one matching all of
+ * them, which reads as a search box that ignores what you typed.
+ *
+ * @returns null when the input holds no letters or digits at all, which is a
+ *   query with no clauses rather than a syntax error to hand to Postgres.
+ */
+export function toTsQuery(raw) {
+    const words = raw.split(SEPARATORS).filter((word) => word.length > 0);
+    if (words.length === 0) {
+        return null;
+    }
+    return words.map((word) => `${word}:*`).join(' & ');
+}
+/** The words `toTsQuery` searched for, which is what `snippet` centres on. */
+export function searchWords(raw) {
+    return raw.split(SEPARATORS).filter((word) => word.length > 0);
+}
+/** How much of the source text a snippet carries, either side of the match. */
+const LEAD = 24;
+const TRAIL = 56;
+/** Markdown punctuation, which is noise once a page body is one line of preview. */
+const MARKUP = /[#*`|[\]_>]/gu;
+function flatten(body) {
+    return body.replace(MARKUP, ' ').replace(/\s+/gu, ' ').trim();
+}
+/**
+ * Finds the earliest position any search word appears at, case-insensitively.
+ *
+ * @returns -1 when none of them appear literally. That is not a contradiction of
+ *   the match: the row matched a stemmed lexeme (`meeting` for `meetings`) or
+ *   matched on a different field than the one being excerpted.
+ */
+function firstMatch(haystack, words) {
+    const lowered = haystack.toLowerCase();
+    return words
+        .map((word) => lowered.indexOf(word.toLowerCase()))
+        .filter((index) => index >= 0)
+        .reduce((earliest, index) => (earliest < 0 ? index : Math.min(earliest, index)), -1);
+}
+/**
+ * A one-line fragment of `body`, centred on the first search word it contains.
+ *
+ * Falls back to the opening of the text when no word appears literally, because a
+ * result with no preview at all reads as a result with no content.
+ *
+ * @param body The record's own prose. Markdown is flattened first.
+ * @param words What was searched for, from `searchWords`.
+ */
+export function snippet(body, words) {
+    const plain = flatten(body);
+    if (plain.length === 0) {
+        return '';
+    }
+    const found = firstMatch(plain, words);
+    if (found < 0) {
+        return plain.length > LEAD + TRAIL ? `${plain.slice(0, LEAD + TRAIL)}…` : plain;
+    }
+    const start = Math.max(0, found - LEAD);
+    const end = Math.min(plain.length, found + TRAIL);
+    return `${start > 0 ? '…' : ''}${plain.slice(start, end)}${end < plain.length ? '…' : ''}`;
+}
+//# sourceMappingURL=query.js.map

package/dist/modules/search/query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.js","sourceRoot":"","sources":["../../../src/modules/search/query.ts"],"names":[],"mappings":"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"}

package/dist/modules/search/repository.d.ts

@@ -0,0 +1,44 @@
+import type { SearchCollection } from '@kelpie/schemas';
+import type { SQL } from 'drizzle-orm';
+import type { Queryable } from '../../runtime/transaction.ts';
+/**
+ * The reads behind `GET /v1/search`: one query per collection, each against that
+ * collection's own `search_vector` GIN index.
+ *
+ * Eleven tables and no repository imports, the same licence `dashboard` takes and
+ * for the same reason. A search that composed nine repositories would ask each of
+ * them for a page it then had to re-rank, and none of them can rank at all.
+ *
+ * **Every branch of every query has to be indexable.** Four collections match on a
+ * second table as well: a Person is found by a job title that lives on Position,
+ * and a Deal, Opportunity or Raise by a step that lives on Plan. Written as
+ * `own_vector @@ q OR EXISTS (…)` that is a sequential scan, because Postgres will
+ * not use an index for an `OR` whose other branch is a subquery. Written as a
+ * `UNION ALL` of two matches, each branch uses its own index and the ranks are
+ * merged afterwards. That is why the shape below looks indirect.
+ */
+/** A row on its way to becoming a result. `subtitle` and `snippet` are per collection. */
+export interface SearchHit {
+    readonly id: string;
+    readonly title: string;
+    readonly subtitle: string | null;
+    readonly snippetSource: string | null;
+}
+/** What one collection answered: a capped, ranked page and the exact number of matches. */
+export interface CollectionHits {
+    readonly collection: SearchCollection;
+    readonly hits: readonly SearchHit[];
+    readonly total: number;
+}
+/** The compiled `tsquery`, built once per request and shared by every collection. */
+export declare function compileQuery(tsQuery: string): SQL;
+export declare function searchHandbookPages(db: Queryable, workspaceId: string, query: SQL, limit: number): Promise<CollectionHits>;
+export declare function searchPeople(db: Queryable, workspaceId: string, query: SQL, limit: number): Promise<CollectionHits>;
+export declare function searchRoles(db: Queryable, workspaceId: string, query: SQL, limit: number): Promise<CollectionHits>;
+export declare function searchCompanies(db: Queryable, workspaceId: string, query: SQL, limit: number): Promise<CollectionHits>;
+export declare function searchDeals(db: Queryable, workspaceId: string, query: SQL, limit: number): Promise<CollectionHits>;
+export declare function searchOpportunities(db: Queryable, workspaceId: string, query: SQL, limit: number): Promise<CollectionHits>;
+export declare function searchRaises(db: Queryable, workspaceId: string, query: SQL, limit: number): Promise<CollectionHits>;
+export declare function searchPartnerships(db: Queryable, workspaceId: string, query: SQL, limit: number): Promise<CollectionHits>;
+export declare function searchDecisions(db: Queryable, workspaceId: string, query: SQL, limit: number): Promise<CollectionHits>;
+//# sourceMappingURL=repository.d.ts.map

package/dist/modules/search/repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../../../src/modules/search/repository.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAEvD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,aAAa,CAAA;AAItC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAc7D;;;;;;;;;;;;;;;GAeG;AAEH,0FAA0F;AAC1F,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IAChC,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;CACtC;AAED,2FAA2F;AAC3F,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAA;IACrC,QAAQ,CAAC,IAAI,EAAE,SAAS,SAAS,EAAE,CAAA;IACnC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;CACvB;AAYD,qFAAqF;AACrF,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,GAAG,CAEjD;AAiCD,wBAAsB,mBAAmB,CACvC,EAAE,EAAE,SAAS,EACb,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,GAAG,EACV,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,cAAc,CAAC,CAezB;AAED,wBAAsB,YAAY,CAChC,EAAE,EAAE,SAAS,EACb,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,GAAG,EACV,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,cAAc,CAAC,CA8BzB;AAED,wBAAsB,WAAW,CAC/B,EAAE,EAAE,SAAS,EACb,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,GAAG,EACV,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,cAAc,CAAC,CAgBzB;AAED,wBAAsB,eAAe,CACnC,EAAE,EAAE,SAAS,EACb,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,GAAG,EACV,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,cAAc,CAAC,CAezB;AA0BD,wBAAsB,WAAW,CAC/B,EAAE,EAAE,SAAS,EACb,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,GAAG,EACV,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,cAAc,CAAC,CAwBzB;AAED,wBAAsB,mBAAmB,CACvC,EAAE,EAAE,SAAS,EACb,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,GAAG,EACV,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,cAAc,CAAC,CAuBzB;AAED,wBAAsB,YAAY,CAChC,EAAE,EAAE,SAAS,EACb,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,GAAG,EACV,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,cAAc,CAAC,CAwBzB;AAED,wBAAsB,kBAAkB,CACtC,EAAE,EAAE,SAAS,EACb,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,GAAG,EACV,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,cAAc,CAAC,CAezB;AAED,wBAAsB,eAAe,CACnC,EAAE,EAAE,SAAS,EACb,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,GAAG,EACV,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,cAAc,CAAC,CAiBzB"}

package/dist/modules/search/repository.js

@@ -0,0 +1,252 @@
+import { and, asc, desc, eq, max, sql } from 'drizzle-orm';
+import { unionAll } from 'drizzle-orm/pg-core';
+import { companies } from '../companies/schema.js';
+import { deals } from '../deals/schema.js';
+import { decisions } from '../decisions/schema.js';
+import { handbookPages } from '../handbook/schema.js';
+import { roles } from '../hiring/schema.js';
+import { opportunities } from '../opportunities/schema.js';
+import { partnerships } from '../partnerships/schema.js';
+import { people } from '../people/schema.js';
+import { pipelineStages } from '../pipelines/schema.js';
+import { planItems } from '../plans/schema.js';
+import { positions } from '../positions/schema.js';
+import { raises } from '../raises/schema.js';
+/**
+ * How far a match on a related record sits below a match on the record itself.
+ *
+ * A Deal whose own summary says "renewal" is a better answer than one with a
+ * planned step that mentions it. Without this they interleave by `ts_rank` alone,
+ * which compares the wrong two things: one rank is over the record, the other over
+ * a single line attached to it.
+ */
+const RELATED_RANK_FACTOR = 0.4;
+/** The compiled `tsquery`, built once per request and shared by every collection. */
+export function compileQuery(tsQuery) {
+    return sql `to_tsquery('english', ${tsQuery})`;
+}
+function matches(vector, query) {
+    return sql `${vector} @@ ${query}`;
+}
+function rank(vector, query) {
+    return sql `ts_rank(${vector}, ${query})`;
+}
+function relatedRank(vector, query) {
+    return sql `ts_rank(${vector}, ${query}) * ${RELATED_RANK_FACTOR}`;
+}
+/**
+ * The number of matching records, which is not the number of rows returned.
+ *
+ * A window function is evaluated before `LIMIT`, so this counts every group the
+ * query found and the page below it stays capped. `api.md` has no envelope for
+ * this endpoint and the dashboard's precedent is an exact total beside a short
+ * list, because a capped list cannot answer "how many".
+ *
+ * Cast to `int` because `count` is `bigint`, and postgres.js hands a bigint back
+ * as a string rather than losing precision on it. Summing those gives `'01'`
+ * instead of `1`, which is a wrong number rather than a type error.
+ */
+const total = sql `(count(*) over ())::int`;
+/** Rows are grouped by id, so a record matching on both itself and a related row appears once. */
+function bestRank(rankColumn) {
+    return sql `${max(rankColumn)}`;
+}
+export async function searchHandbookPages(db, workspaceId, query, limit) {
+    const rows = await db
+        .select({
+        id: handbookPages.id,
+        title: handbookPages.title,
+        subtitle: handbookPages.slug,
+        snippetSource: handbookPages.body,
+        total,
+    })
+        .from(handbookPages)
+        .where(and(eq(handbookPages.workspaceId, workspaceId), matches(handbookPages.searchVector, query)))
+        .orderBy(desc(rank(handbookPages.searchVector, query)), asc(handbookPages.id))
+        .limit(limit);
+    return collect('handbook_page', rows);
+}
+export async function searchPeople(db, workspaceId, query, limit) {
+    const own = db
+        .select({ id: people.id, rank: rank(people.searchVector, query).as('rank') })
+        .from(people)
+        .where(and(eq(people.workspaceId, workspaceId), matches(people.searchVector, query)));
+    // A person is found by the title they hold, which is on Position and never on
+    // Person (`brief.md`). `?q=` on people already reaches the same way.
+    const byTitle = db
+        .select({ id: positions.personId, rank: relatedRank(positions.searchVector, query).as('rank') })
+        .from(positions)
+        .where(and(eq(positions.workspaceId, workspaceId), matches(positions.searchVector, query)));
+    const hits = unionAll(own, byTitle).as('hits');
+    const rows = await db
+        .select({
+        id: people.id,
+        title: people.name,
+        subtitle: people.email,
+        snippetSource: people.summary,
+        total,
+    })
+        .from(hits)
+        .innerJoin(people, eq(people.id, hits.id))
+        .groupBy(people.id)
+        .orderBy(desc(bestRank(hits.rank)), asc(people.id))
+        .limit(limit);
+    return collect('person', rows);
+}
+export async function searchRoles(db, workspaceId, query, limit) {
+    const rows = await db
+        .select({
+        id: roles.id,
+        title: roles.title,
+        subtitle: roles.status,
+        // A Role is a title and a status. There is no prose on it to excerpt.
+        snippetSource: sql `null::text`,
+        total,
+    })
+        .from(roles)
+        .where(and(eq(roles.workspaceId, workspaceId), matches(roles.searchVector, query)))
+        .orderBy(desc(rank(roles.searchVector, query)), asc(roles.id))
+        .limit(limit);
+    return collect('role', rows);
+}
+export async function searchCompanies(db, workspaceId, query, limit) {
+    const rows = await db
+        .select({
+        id: companies.id,
+        title: companies.name,
+        subtitle: companies.domain,
+        snippetSource: companies.summary,
+        total,
+    })
+        .from(companies)
+        .where(and(eq(companies.workspaceId, workspaceId), matches(companies.searchVector, query)))
+        .orderBy(desc(rank(companies.searchVector, query)), asc(companies.id))
+        .limit(limit);
+    return collect('company', rows);
+}
+/**
+ * A Deal, Opportunity or Raise found by one of its Plan items.
+ *
+ * `plan_items` is polymorphic with no foreign key, so the target type is part of
+ * the match rather than something a join expresses.
+ */
+function byPlanItem(db, workspaceId, query, targetType) {
+    return db
+        .select({ id: planItems.targetId, rank: relatedRank(planItems.searchVector, query).as('rank') })
+        .from(planItems)
+        .where(and(eq(planItems.workspaceId, workspaceId), eq(planItems.targetType, targetType), matches(planItems.searchVector, query)));
+}
+export async function searchDeals(db, workspaceId, query, limit) {
+    const own = db
+        .select({ id: deals.id, rank: rank(deals.searchVector, query).as('rank') })
+        .from(deals)
+        .where(and(eq(deals.workspaceId, workspaceId), matches(deals.searchVector, query)));
+    const hits = unionAll(own, byPlanItem(db, workspaceId, query, 'deal')).as('hits');
+    const rows = await db
+        .select({
+        id: deals.id,
+        title: deals.name,
+        subtitle: pipelineStages.label,
+        snippetSource: deals.summary,
+        total,
+    })
+        .from(hits)
+        .innerJoin(deals, eq(deals.id, hits.id))
+        .innerJoin(pipelineStages, eq(pipelineStages.id, deals.stageId))
+        .groupBy(deals.id, pipelineStages.label)
+        .orderBy(desc(bestRank(hits.rank)), asc(deals.id))
+        .limit(limit);
+    return collect('deal', rows);
+}
+export async function searchOpportunities(db, workspaceId, query, limit) {
+    const own = db
+        .select({ id: opportunities.id, rank: rank(opportunities.searchVector, query).as('rank') })
+        .from(opportunities)
+        .where(and(eq(opportunities.workspaceId, workspaceId), matches(opportunities.searchVector, query)));
+    const hits = unionAll(own, byPlanItem(db, workspaceId, query, 'opportunity')).as('hits');
+    const rows = await db
+        .select({
+        id: opportunities.id,
+        title: opportunities.name,
+        subtitle: opportunities.kind,
+        snippetSource: opportunities.summary,
+        total,
+    })
+        .from(hits)
+        .innerJoin(opportunities, eq(opportunities.id, hits.id))
+        .groupBy(opportunities.id)
+        .orderBy(desc(bestRank(hits.rank)), asc(opportunities.id))
+        .limit(limit);
+    return collect('opportunity', rows);
+}
+export async function searchRaises(db, workspaceId, query, limit) {
+    const own = db
+        .select({ id: raises.id, rank: rank(raises.searchVector, query).as('rank') })
+        .from(raises)
+        .where(and(eq(raises.workspaceId, workspaceId), matches(raises.searchVector, query)));
+    const hits = unionAll(own, byPlanItem(db, workspaceId, query, 'raise')).as('hits');
+    const rows = await db
+        .select({
+        id: raises.id,
+        title: raises.name,
+        subtitle: pipelineStages.label,
+        snippetSource: raises.summary,
+        total,
+    })
+        .from(hits)
+        .innerJoin(raises, eq(raises.id, hits.id))
+        .innerJoin(pipelineStages, eq(pipelineStages.id, raises.stageId))
+        .groupBy(raises.id, pipelineStages.label)
+        .orderBy(desc(bestRank(hits.rank)), asc(raises.id))
+        .limit(limit);
+    return collect('raise', rows);
+}
+export async function searchPartnerships(db, workspaceId, query, limit) {
+    const rows = await db
+        .select({
+        id: partnerships.id,
+        title: partnerships.name,
+        subtitle: partnerships.kind,
+        snippetSource: partnerships.summary,
+        total,
+    })
+        .from(partnerships)
+        .where(and(eq(partnerships.workspaceId, workspaceId), matches(partnerships.searchVector, query)))
+        .orderBy(desc(rank(partnerships.searchVector, query)), asc(partnerships.id))
+        .limit(limit);
+    return collect('partnership', rows);
+}
+export async function searchDecisions(db, workspaceId, query, limit) {
+    const rows = await db
+        .select({
+        id: decisions.id,
+        title: decisions.body,
+        // The date it was decided, as `YYYY-MM-DD`. A decision has no name and no
+        // stage; when it was made is the line the mockup shows beside it.
+        subtitle: sql `to_char(${decisions.decidedAt} at time zone 'UTC', 'YYYY-MM-DD')`,
+        snippetSource: decisions.rationale,
+        total,
+    })
+        .from(decisions)
+        .where(and(eq(decisions.workspaceId, workspaceId), matches(decisions.searchVector, query)))
+        .orderBy(desc(rank(decisions.searchVector, query)), asc(decisions.id))
+        .limit(limit);
+    return collect('decision', rows);
+}
+/**
+ * `count(*) over ()` is on every row, so an empty page carries no total at all.
+ * That is the only case where zero is the right answer.
+ */
+function collect(collection, rows) {
+    return {
+        collection,
+        hits: rows.map(({ id, title, subtitle, snippetSource }) => ({
+            id,
+            title,
+            subtitle,
+            snippetSource,
+        })),
+        total: rows[0]?.total ?? 0,
+    };
+}
+//# sourceMappingURL=repository.js.map