@unson/brainbase-mcp 0.43.0 → 0.44.1

package/dist/canonical-task-postgres.d.ts

@@ -0,0 +1,139 @@
+type JsonRecord = Record<string, unknown>;
+export interface CanonicalTaskPgQueryResult {
+    rows: any[];
+    rowCount?: number | null;
+}
+export interface CanonicalTaskPgClient {
+    query(text: string, values?: unknown[]): Promise<CanonicalTaskPgQueryResult>;
+    release?(): void;
+}
+/** A node-postgres compatible pool. `connect` is needed for guarded updates. */
+export interface CanonicalTaskPgPool extends CanonicalTaskPgClient {
+    connect?(): Promise<CanonicalTaskPgClient>;
+}
+/** Identifies rows imported from an earlier table. Tenant configuration, never a default. */
+export interface CanonicalTaskLegacyIdentity {
+    baseId: string;
+    tableId: string;
+}
+export interface CanonicalTaskTaskLocator {
+    column: 'id' | 'legacy_nocodb_id';
+    value: string;
+}
+/**
+ * Host-supplied visibility for list and search. It reads the filters the
+ * host policy put there (for example a verified organization scope) and
+ * returns one SQL condition over `canonical_tasks`, or null. `param` appends a
+ * value and returns its placeholder. The adapter does not interpret it.
+ */
+export type CanonicalTaskScopeCondition = (input: {
+    filters: JsonRecord;
+    param: (value: unknown) => string;
+}) => string | null | undefined;
+/**
+ * Checked inside the transaction that holds the Task row lock, before an
+ * update that completes a Task or changes its completion contract. A host
+ * whose typed children (for example agent delegations) take the same row lock
+ * can refuse the mutation by throwing; the error reaches the caller unchanged.
+ */
+export interface CanonicalTaskMutationGuard {
+    check(input: {
+        client: CanonicalTaskPgClient;
+        rowId: string;
+        patch: JsonRecord;
+        completes: boolean;
+        changesCompletionContract: boolean;
+    }): Promise<void>;
+}
+export interface CanonicalTaskPostgresRepositoryOptions {
+    pool: CanonicalTaskPgPool;
+    schemaVersion: string;
+    idSecret: string;
+    legacyIdentity?: CanonicalTaskLegacyIdentity | null;
+    webBaseUrl?: string | null;
+    scopeCondition?: CanonicalTaskScopeCondition | null;
+    mutationGuard?: CanonicalTaskMutationGuard | null;
+    /** Error codes a mutation guard may raise that must pass through unwrapped. */
+    passthroughErrorCodes?: Iterable<string>;
+}
+export interface CanonicalTaskPurposeLabels {
+    labels: Array<{
+        purpose_label: string;
+        task_count: number;
+    }>;
+    truncated: boolean;
+}
+export declare function encodeCanonicalTaskCursor(offset: number): string;
+export declare function decodeCanonicalTaskCursor(cursor: unknown): number;
+/** The disabled backend: every operation reports that no store is configured. */
+export declare class CanonicalTaskUnavailableRepository {
+    private unavailable;
+    assertAvailable(): never;
+    list(): never;
+    search(): never;
+    get(): never;
+    findByIdempotencyKey(): never;
+    create(): never;
+    update(): never;
+    delete(): never;
+    listPurposeLabels(): never;
+}
+/**
+ * PostgreSQL persistence for Canonical Tasks (`canonical_tasks`, see
+ * `contracts/canonical-task/store-schema.sql`).
+ *
+ * Task IDs are opaque HMAC-signed `ct1.` tokens. The adapter does not decide
+ * who may see a Task: list/search visibility comes from the host's
+ * `scopeCondition`, and authorization stays in the service policy.
+ */
+export declare class CanonicalTaskPostgresRepository {
+    /**
+     * PostgreSQL is a durable mutation boundary. Services must bind it to the
+     * persisted release readiness gate before exposing mutations.
+     */
+    readonly requiresReadiness = true;
+    readonly pool: CanonicalTaskPgPool;
+    readonly schemaVersion: string;
+    readonly legacyIdentity: CanonicalTaskLegacyIdentity | null;
+    readonly webBaseUrl: string | null;
+    private readonly idSecret;
+    private readonly scopeCondition;
+    private readonly mutationGuard;
+    private readonly passthroughErrorCodes;
+    constructor(options: CanonicalTaskPostgresRepositoryOptions);
+    private sign;
+    private encodePayload;
+    /** The public ID of a stored row. */
+    encodeTaskId(row: {
+        id?: unknown;
+        legacy_nocodb_id?: unknown;
+    }): string;
+    /** The stored row a public ID names. A tampered or foreign ID is task_not_found. */
+    decodeTaskLocator(taskId: unknown): CanonicalTaskTaskLocator;
+    normalize(row: JsonRecord | null | undefined): JsonRecord | null;
+    /** Store failures become task_store_unavailable; meaningful errors pass through. */
+    private unavailable;
+    query(text: string, values?: unknown[]): Promise<CanonicalTaskPgQueryResult>;
+    withTransaction<T>(callback: (client: CanonicalTaskPgClient) => Promise<T>): Promise<T>;
+    private rejectStorageScope;
+    private visibility;
+    list(filters?: JsonRecord, storageScope?: string): Promise<JsonRecord>;
+    search(filters?: JsonRecord, storageScope?: string): Promise<JsonRecord>;
+    get(taskId: string, storageScope?: string): Promise<JsonRecord | null>;
+    /** Tasks one meeting run created in one project, matched on the source reference. */
+    listByMeetingMinutesRun({ projectCode, runId, limit }?: {
+        projectCode?: unknown;
+        runId?: unknown;
+        limit?: number;
+    }): Promise<(JsonRecord | null)[]>;
+    findByIdempotencyKey(key: string, storageScope?: string): Promise<JsonRecord | null>;
+    create(input: JsonRecord, storageScope?: string): Promise<JsonRecord>;
+    update(taskId: string, patch: JsonRecord, storageScope?: string): Promise<JsonRecord>;
+    listPurposeLabels({ projectCode, assigneePersonId, limit }: {
+        projectCode: string;
+        assigneePersonId?: string | null;
+        limit?: number;
+    }): Promise<CanonicalTaskPurposeLabels>;
+    delete(taskId: string, expectedVersion: number, storageScope?: string): Promise<void>;
+}
+export {};