better-supabase 0.14.0 → 0.15.0

package/dist/knowledge-CFkCRxO9.d.ts

@@ -1,202 +0,0 @@
-/// <reference lib="esnext.temporal" />
-import { T as ErrorMapper, t as AsyncResult } from "./result-C6jDfedy.js";
-import { n as Logger } from "./logger-DWVYUmwi.js";
-import { r as BlockTemporalOptions } from "./block-helpers-BaugZlJV.js";
-import { t as BlockTransport } from "./block-transport-d53POsem.js";
-import { n as BlockHooks } from "./block-hooks-CmjPKqQ_.js";
-import { f as AiFiles, o as AiFile } from "./types-BEDfwXL4.js";
-import { g as JobHandler } from "./types-CGUDoF5I.js";
-//#region src/blocks/knowledge/knowledge.d.ts
-/**
- * Turns texts into vectors. `model` is stored with each document, so a document
- * embedded by another model can be found and embedded again.
- */
-interface Embedder {
-  /** The embedder contract version. Omitted means 1. */
-  readonly apiVersion?: 1;
-  readonly model: string;
-  embed(values: readonly string[], options?: {
-    readonly signal?: AbortSignal;
-  }): Promise<readonly (readonly number[])[]>;
-}
-type KnowledgeScope = "organization" | "agent" | "project" | "chat" | "user";
-type KnowledgeStatus = "pending" | "ready" | "failed";
-interface KnowledgeDocument {
-  readonly id: string;
-  readonly organizationId: string;
-  readonly ownerId: string;
-  readonly scope: KnowledgeScope;
-  /**
-   * The agent, project, chat or user the document belongs to; none for
-   * organization scope.
-   */
-  readonly scopeId: string | undefined;
-  readonly fileId: string | undefined;
-  readonly title: string;
-  readonly source: string | undefined;
-  readonly metadata: Readonly<Record<string, unknown>>;
-  readonly status: KnowledgeStatus;
-  readonly error: string | undefined;
-  readonly chunkCount: number;
-  readonly embeddingModel: string | undefined;
-  readonly createdAt: Temporal.Instant;
-  readonly updatedAt: Temporal.Instant;
-}
-interface NewKnowledgeDocument {
-  readonly title: string;
-  /** Default `user`, scoped to the caller. */
-  readonly scope?: KnowledgeScope;
-  readonly scopeId?: string;
-  readonly fileId?: string;
-  /** Where the text came from: a URL, a file name or a table. */
-  readonly source?: string;
-  readonly metadata?: Readonly<Record<string, unknown>>;
-  /** The service role only: the user the document belongs to. */
-  readonly ownerId?: string;
-}
-interface KnowledgeChunk {
-  readonly content: string;
-  /** An estimate of the tokens in `content`. */
-  readonly tokens?: number;
-  readonly metadata?: Readonly<Record<string, unknown>>;
-}
-interface KnowledgeHit {
-  readonly documentId: string;
-  readonly index: number;
-  readonly content: string;
-  readonly metadata: Readonly<Record<string, unknown>>;
-  readonly title: string;
-  /** The fused reciprocal rank score; higher is better. */
-  readonly score: number;
-}
-interface KnowledgeQuery {
-  /** Searched as full text, and embedded when the block has an embedder. */
-  readonly text?: string;
-  /** An embedding of the query, used instead of embedding `text`. */
-  readonly embedding?: readonly number[];
-}
-interface KnowledgeSearchOptions {
-  /** The scopes to search, each with an optional id; every scope when unset. */
-  readonly scopes?: readonly {
-    readonly scope: KnowledgeScope;
-    readonly id?: string;
-  }[];
-  /** How many chunks to return. Default 8, at most 100. */
-  readonly k?: number;
-  /** Matches documents whose metadata contains this object. */
-  readonly filter?: Readonly<Record<string, unknown>>;
-  readonly signal?: AbortSignal;
-}
-interface ChunkOptions {
-  /** The most characters in a chunk. Default 2000. */
-  readonly size?: number;
-  /**
-   * Characters repeated from the end of the previous chunk. Default 200, or a
-   * tenth of a smaller `size`.
-   */
-  readonly overlap?: number;
-}
-interface KnowledgeOptions extends BlockTemporalOptions {
-  /** Calls as the user: `rpcTransport(supabase)`. */
-  readonly transport: BlockTransport;
-  /** Calls as the service role, for `process`, `drain` and `reembed`. */
-  readonly service?: BlockTransport;
-  /**
-   * The module schema, or its API schema: `defineBlocks` passes it from
-   * `blocks.generated.ts`. Default `better_supabase`.
-   */
-  readonly schema?: string;
-  readonly mappers?: readonly ErrorMapper[];
-  /** Embeds chunks and queries; without one, search is full text only. */
-  readonly embedder?: Embedder;
-  /** The ai-files block, for `ingest.file`. */
-  readonly files?: AiFiles;
-  /**
-   * The text of a file. The default decodes `text/*`, JSON, XML and YAML as
-   * UTF-8 and fails with `KNOWLEDGE_UNSUPPORTED` for anything else.
-   */
-  readonly extract?: (file: AiFile, data: Uint8Array) => Promise<string>;
-  readonly chunking?: ChunkOptions;
-  /** Chunks per embedding call. Default 64. */
-  readonly batchSize?: number;
-  /**
-   * `withBlockHooks` hooks around the methods, and around each group's under
-   * its name (ADR 0015).
-   */
-  readonly hooks?: KnowledgeHooks;
-  /** Receives the errors `after` hooks throw. */
-  readonly logger?: Logger;
-}
-/**
- * Hooks for `Knowledge`: the top-level methods, and `documents` and `ingest` by
- * group.
- */
-type KnowledgeHooks = BlockHooks<Knowledge> & {
-  readonly documents?: BlockHooks<Knowledge["documents"]>;
-  readonly ingest?: BlockHooks<Knowledge["ingest"]>;
-};
-interface Knowledge {
-  readonly documents: {
-    create(organizationId: string, document: NewKnowledgeDocument): AsyncResult<KnowledgeDocument>;
-    get(documentId: string): AsyncResult<KnowledgeDocument>;
-    list(organizationId: string, options?: {
-      readonly scope?: KnowledgeScope;
-      readonly scopeId?: string;
-      readonly limit?: number;
-    }): AsyncResult<readonly KnowledgeDocument[]>;
-    /** Replaces the chunks; unchanged chunks keep their embedding. */
-    write(documentId: string, chunks: readonly KnowledgeChunk[]): AsyncResult<KnowledgeDocument>;
-    remove(documentId: string): AsyncResult<boolean>;
-  };
-  readonly ingest: {
-    /** Creates a document from text and writes its chunks. */
-    text(organizationId: string, document: NewKnowledgeDocument & {
-      readonly text: string;
-    }): AsyncResult<KnowledgeDocument>;
-    /** Creates a document from a ready ai-files file and writes its chunks. */
-    file(organizationId: string, fileId: string, document?: Partial<NewKnowledgeDocument>): AsyncResult<KnowledgeDocument>;
-  };
-  /**
-   * Embeds a document's pending chunks (service role). Returns how many still
-   * wait, 0 once the document is ready.
-   */
-  process(documentId: string, options?: {
-    readonly signal?: AbortSignal | undefined;
-  }): AsyncResult<number>;
-  /**
-   * The handler for the `knowledge_embed` queue. The last attempt marks the
-   * document failed with the error.
-   */
-  embedJob(): JobHandler<{
-    readonly document_id: string;
-  }>;
-  /**
-   * Processes pending documents without a queue (service role). Returns how
-   * many. A document is marked failed only after `attempts` (default 3) tries
-   * fail, and never when the signal aborted it.
-   */
-  drain(options?: {
-    readonly batch?: number;
-    readonly attempts?: number;
-    readonly signal?: AbortSignal;
-  }): AsyncResult<number>;
-  search(organizationId: string, query: string | KnowledgeQuery, options?: KnowledgeSearchOptions): AsyncResult<readonly KnowledgeHit[]>;
-  /**
-   * Marks documents embedded by another model (or every document when `model`
-   * is unset) pending again (service role). Returns how many.
-   */
-  reembed(options?: {
-    readonly organizationId?: string;
-    readonly model?: string;
-  }): AsyncResult<number>;
-}
-/**
- * Splits text into chunks of at most `size` characters, preferring a paragraph,
- * line, sentence or word break in the second half of each chunk, and repeating
- * `overlap` characters of the previous one.
- */
-declare function chunk(text: string, options?: ChunkOptions): readonly KnowledgeChunk[];
-/** Documents, chunks and hybrid search for retrieval. */
-declare function createKnowledge(options: KnowledgeOptions): Knowledge;
-//#endregion
-export { KnowledgeDocument as a, KnowledgeOptions as c, KnowledgeSearchOptions as d, KnowledgeStatus as f, createKnowledge as h, KnowledgeChunk as i, KnowledgeQuery as l, chunk as m, Embedder as n, KnowledgeHit as o, NewKnowledgeDocument as p, Knowledge as r, KnowledgeHooks as s, ChunkOptions as t, KnowledgeScope as u };

package/dist/list-query-BtluNnYk.d.ts

@@ -1,222 +0,0 @@
-import { D as ValidationIssue, t as AsyncResult } from "./result-C6jDfedy.js";
-import { M as AnyFunctions, N as AnyModels, l as CountMode, mt as TableKey, st as Row } from "./executor-CPyrQdjh.js";
-import { Et as SelectArg, St as Payload, a as CursorPageArgs, bt as OrderByArg, h as OffsetPageArgs, i as CursorPage, kt as WhereInput, m as OffsetPage, pt as IncludeArg, t as BetterSupabase, u as FindExt, w as RepositoryOf } from "./define-Dw7pRO4h.js";
-import { c as FilterFieldLabels, h as FilterQuery, o as FilterField, r as FilterClock, s as FilterFieldInfo, v as ListFilterConfig } from "./filter-query-o3b_GuyC.js";
-import { StandardSchemaV1 } from "@standard-schema/spec";
-//#region src/list/list-query.d.ts
-/** Facet value meaning "not set": filters with `is null`. */
-declare const UNSET = "__unset__";
-type Column<M extends AnyModels, T extends keyof M> = Extract<keyof Row<M, T>, string>;
-type TextColumn<M extends AnyModels, T extends keyof M> = { [K in Column<M, T>]: [NonNullable<Row<M, T>[K]>] extends [string] ? K : never; }[Column<M, T>];
-/** `offset` pages by number; `cursor` continues after the last row (keyset). */
-type ListPagination = "offset" | "cursor";
-interface ListQueryConfig<M extends AnyModels, T extends keyof M, S extends string, F extends string, C extends boolean = boolean, P extends ListPagination = ListPagination> {
-  /**
-   * Also count rows per facet value, with one grouped aggregate per facet that
-   * runs next to the page: one wave. Needs PostgREST aggregates.
-   */
-  readonly facetCounts?: C;
-  /**
-   * How the page total is counted. Defaults to `'planned'`, the planner's
-   * estimate.
-   */
-  readonly count?: CountMode;
-  /** Text columns matched case-insensitively (OR), or a full-text column. */
-  readonly search?: readonly TextColumn<M, T>[] | {
-    readonly fts: Column<M, T>;
-    readonly config?: string;
-  };
-  /**
-   * Filterable columns by URL key. Values are validated against enums and CHECK
-   * unions.
-   */
-  readonly facets?: { readonly [K in F]: Column<M, T>; };
-  /**
-   * Fields a filter tree (ReUI Filters' `FilterQuery`) may name, by field id.
-   * Each has a type and, optionally, the subset of its operators to allow.
-   */
-  readonly filters?: Readonly<Record<string, ListFilterConfig<Column<M, T>>>>;
-  /** Most nested group levels in a filter tree, the root included. Defaults to 4. */
-  readonly maxFilterDepth?: number;
-  /** Most rules in a filter tree. Defaults to 50. */
-  readonly maxFilterRules?: number;
-  /** Named orderings. Add a unique column last for stable pages. */
-  readonly sorts: { readonly [K in S]: OrderByArg<M, T>; };
-  readonly defaultSort: NoInfer<S>;
-  /**
-   * `cursor` takes an `after` cursor instead of `page` and returns
-   * `nextCursor`: the cost of a page stays the same however deep it is, and
-   * rows inserted meanwhile don't shift it. Defaults to `cursor`; `offset`
-   * takes `page` and returns `total` and `pageCount`.
-   */
-  readonly pagination?: P;
-  /** Defaults to 50. */
-  readonly pageSize?: number;
-  /** Defaults to 200. */
-  readonly maxPageSize?: number;
-  /** Defaults to 200 characters. */
-  readonly maxSearchLength?: number;
-  /**
-   * Most values counted per facet; a facet with more lists its key in
-   * `facetCountsTruncated`. Defaults to 100.
-   */
-  readonly facetLimit?: number;
-}
-interface ListQuery<S extends string, F extends string> {
-  readonly q?: string;
-  readonly sort: S;
-  /** 1-based. Always 1 with cursor pagination. */
-  readonly page: number;
-  /** Cursor pagination: the `nextCursor` of the previous page. */
-  readonly after?: string;
-  readonly size: number;
-  readonly facets: { readonly [K in F]?: readonly string[]; };
-  /** The checked filter tree, without unfinished rules and empty groups. */
-  readonly filter?: FilterQuery;
-  /** The IANA time zone date filters resolve in, from `parse`'s options. */
-  readonly timeZone?: string;
-}
-/** Typed input (JSON APIs, actions, MCP tools). Everything is optional. */
-interface ListQueryInput<S extends string, F extends string> {
-  readonly q?: string;
-  readonly sort?: S;
-  readonly page?: number;
-  readonly after?: string;
-  readonly size?: number;
-  readonly facets?: { readonly [K in F]?: readonly string[]; };
-  readonly filter?: FilterQuery;
-}
-/** URL input: `URLSearchParams` or a Next.js `searchParams` record. */
-type ListSearchParams = URLSearchParams | Readonly<Record<string, string | readonly string[] | undefined>>;
-type ListParseResult<S extends string, F extends string> = {
-  readonly ok: true;
-  readonly value: ListQuery<S, F>;
-  readonly issues?: undefined;
-} | {
-  readonly ok: false;
-  readonly value?: undefined;
-  readonly issues: readonly ValidationIssue[];
-};
-interface ParserSpec<V> {
-  parse(value: string): V | null;
-  serialize(value: V): string;
-  /** Equality for object values, which nuqs uses to skip URL updates. */
-  eq?(a: V, b: V): boolean;
-}
-interface OpenApiParameter {
-  readonly name: string;
-  readonly in: "query";
-  readonly required: false;
-  readonly description: string;
-  readonly schema: Readonly<Record<string, unknown>>;
-  readonly style?: "form";
-  readonly explode?: boolean;
-}
-interface ListParseOptions {
-  /**
-   * IANA time zone that date filters resolve in, such as the request's.
-   * Defaults to `UTC`.
-   */
-  readonly timeZone?: string;
-}
-interface FacetInfo {
-  readonly key: string;
-  readonly column: string;
-  readonly nullable: boolean;
-  /** Allowed values when the column is an enum or CHECK union. */
-  readonly values?: readonly string[];
-}
-/** Rows per facet value, keyed by facet and then by value (`UNSET` for empty). */
-type FacetCounts<F extends string> = { readonly [K in F]: Readonly<Record<string, number>>; };
-/** A page of a list; with `facetCounts: true`, also the counts per facet value. */
-type ListPage<R, F extends string, C extends boolean, P extends ListPagination = "cursor"> = ([P] extends ["cursor"] ? CursorPage<R> : OffsetPage<R>) & ([C] extends [true] ? FacetCountFields<F> : [C] extends [false] ? unknown : Partial<FacetCountFields<F>>);
-/** The facet fields of a page with `facetCounts: true`. */
-interface FacetCountFields<F extends string> {
-  readonly facetCounts: FacetCounts<F>;
-  /** Facets with more values than `facetLimit`, whose counts are cut. */
-  readonly facetCountsTruncated: readonly F[];
-}
-interface ListDefinition<M extends AnyModels, T extends TableKey<M>, E, S extends string, F extends string, C extends boolean = false, P extends ListPagination = "cursor"> {
-  readonly table: T;
-  readonly pagination: P;
-  readonly defaults: ListQuery<S, F>;
-  readonly facets: readonly FacetInfo[];
-  /** The checked `filters` config. */
-  readonly filters: readonly FilterFieldInfo[];
-  /** Validates typed input or URL params. Also a Standard Schema (`schema`). */
-  parse(input: ListQueryInput<S, F> | ListSearchParams | undefined, options?: ListParseOptions): ListParseResult<S, F>;
-  /** `FilterField` objects for ReUI Filters, with labels you can translate. */
-  filterFields(labels?: FilterFieldLabels): FilterField[];
-  /**
-   * The repository `where` of the query's filter tree; relative dates resolve
-   * against `clock.now`.
-   */
-  filterWhere(query: ListQuery<S, F>, clock?: Pick<FilterClock, "now">): WhereInput<M, T> | undefined;
-  readonly schema: StandardSchemaV1<ListQueryInput<S, F> | ListSearchParams | undefined, ListQuery<S, F>>;
-  /** URL params, leaving out defaults. */
-  toSearchParams(query: Partial<ListQuery<S, F>>): URLSearchParams;
-  /**
-   * `{ parse, serialize }` per URL key, for routers and nuqs
-   * (`list.nuqs(createParser)`).
-   */
-  readonly parsers: ListParsers<S, F>;
-  nuqs<P>(createParser: (spec: ParserSpec<unknown>) => P): { readonly [K in keyof ListParsers<S, F>]: P; };
-  /**
-   * Repository arguments: `where`, `orderBy`, `size`, and `page` and `count` or
-   * `after`.
-   */
-  args(query: ListQuery<S, F>, clock?: Pick<FilterClock, "now">): [P] extends ["cursor"] ? CursorPageArgs<M, T> : OffsetPageArgs<M, T>;
-  /**
-   * Runs the list against a table, merging your `select`, `include`, `where`
-   * and `count`. One request, plus one per facet for `facetCounts`, always one
-   * wave.
-   */
-  run<const A extends ListExtra<M, T> & FindExt<E, M, T>>(db: { readonly [K in T]: RepositoryOf<M, K, E>; }, query: ListQuery<S, F>, extra?: A): AsyncResult<ListPage<Payload<M, T, A>, F, C, P>>;
-  /** OpenAPI 3.1 query parameters. */
-  readonly openapi: readonly OpenApiParameter[];
-  /** JSON Schema of the typed input, e.g. for MCP tool arguments. */
-  readonly jsonSchema: Readonly<Record<string, unknown>>;
-}
-interface ListExtra<M extends AnyModels, T extends keyof M> {
-  readonly select?: SelectArg<M, T>;
-  readonly include?: IncludeArg<M, T>;
-  readonly where?: WhereInput<M, T>;
-  /** Overrides the config's `count` for this run. */
-  readonly count?: CountMode;
-}
-type ListParsers<S extends string, F extends string> = {
-  readonly q: ParserSpec<string>;
-  readonly sort: ParserSpec<S>;
-  readonly page: ParserSpec<number>;
-  readonly after: ParserSpec<string>;
-  readonly size: ParserSpec<number>;
-  /**
-   * The filter tree as base64url JSON, when the list has `filters`; `parse`
-   * checks it.
-   */
-  readonly filter?: ParserSpec<FilterQuery>;
-} & { readonly [K in F]: ParserSpec<readonly string[]>; };
-/**
- * A reusable list endpoint for one table: search, facets, sorts and pagination,
- * validated from URL params or typed input, with URL parsers, OpenAPI
- * parameters and a JSON Schema derived from the same definition.
- *
- * ```ts
- * export const customerList = defineListQuery(
- *   betterSupabase,
- *   "customers",
- *   {
- *     search: ["name", "kvk"],
- *     facets: { status: "status" },
- *     sorts: {
- *       name: { name: "asc" },
- *       newest: [{ createdAt: "desc" }, { id: "asc" }],
- *     },
- *     defaultSort: "newest",
- *   },
- * );
- * ```
- */
-declare function defineListQuery<M extends AnyModels, D, Fn extends AnyFunctions, E, T extends TableKey<M>, const S extends string, const F extends string = never, const C extends boolean = false, const P extends ListPagination = "cursor">(betterSupabase: BetterSupabase<M, D, Fn, E>, table: T, config: ListQueryConfig<M, T, S, F, C, P>): ListDefinition<M, T, E, S, F, C, P>;
-//#endregion
-export { UNSET as _, ListExtra as a, ListParseOptions as c, ListQuery as d, ListQueryConfig as f, ParserSpec as g, OpenApiParameter as h, ListDefinition as i, ListParseResult as l, ListSearchParams as m, FacetCounts as n, ListPage as o, ListQueryInput as p, FacetInfo as r, ListPagination as s, FacetCountFields as t, ListParsers as u, defineListQuery as v };