@an5/adapters 0.2.5 → 0.2.9

package/dist/an5Adapter.d.ts

@@ -1,16 +1,36 @@
 import { An5SheetsAdapter, An5SheetsAdapterConfig, SheetsTableClient } from './googlesheets';
 import type { An5AdapterConfig, Dialect, TransactionHandle } from './base/types';
+import { type NBaseAdapterConfig, type NBaseVectorClient } from './nbase';
 export type { An5AdapterConfig, Dialect, QueryEngine, TransactionHandle } from './base/types';
-export { setAdapterMetadata, type AdapterMetadata } from './base/metadata';
+export { setAdapterMetadata, createAdapterProxy, type AdapterMetadata } from './base/metadata';
+export type { TypedAn5Adapter, AdapterAPI } from './typed';
 export type AnyAdapter = An5Adapter | An5SheetsAdapter;
 export type AnyAdapterConfig = An5AdapterConfig | An5SheetsAdapterConfig | {
     connectionString: string;
 };
 export declare class An5Adapter {
+    [key: string]: any;
     private _engine;
     private _engineType;
     private _engineConfig;
     sheetsAdapter: An5SheetsAdapter | null;
+    private _nbase;
+    private _nbaseConfig;
+    private _nbaseOnly;
+    /**
+     * Returns the NBase client for this adapter, if the project configured one.
+     * The connection string may also point straight at NBase, which keeps
+     * `DATABASE_URL=nbase://host:port` working on its own.
+     */
+    nbaseClient(): {
+        client: NBaseVectorClient;
+        config: NBaseAdapterConfig;
+    } | null;
+    /**
+     * True when the adapter only knows about NBase, so there is no relational
+     * database to read rows from.
+     */
+    get nbaseOnly(): boolean;
     get dialect(): Dialect;
     constructor(adapterConfig: An5AdapterConfig | An5SheetsAdapterConfig);
     private requireEngine;
@@ -23,34 +43,107 @@ export declare class An5Adapter {
     $executeRaw(query: string, ...values: any[]): Promise<number>;
     $executeRawUnsafe(query: string, ...values: any[]): Promise<number>;
     $connect(): Promise<void>;
+    /**
+     * Health check for the configured NBase instance, or the database when the
+     * adapter has none.
+     */
+    $nbaseHealth(): Promise<{
+        connected: boolean;
+        endpoint?: string;
+        error?: string;
+    }>;
     $disconnect(): Promise<void>;
     /** Real transaction with BEGIN / COMMIT / ROLLBACK */
     $transaction<R>(fn: (tx: An5AdapterTx) => Promise<R>, options?: {
         timeout?: number;
     }): Promise<R>;
     $transaction<R>(list: Promise<R>[]): Promise<R[]>;
+    $begin(): Promise<An5AdapterTx>;
     table<T = any>(modelName: string): AdapterTableClient<T> | SheetsTableClient<T>;
+    private _listeners;
+    private _middlewares;
+    $on(event: 'query' | 'error' | 'warn' | 'info' | string, callback: (...args: any[]) => void): this;
+    $off(event: string, callback: (...args: any[]) => void): this;
+    $emit(event: string, ...args: any[]): void;
+    $use(middleware: (params: {
+        model?: string;
+        action: string;
+        args: any;
+        run: (args: any) => Promise<any>;
+    }) => Promise<any>): this;
+    view<T = any>(viewName: string): ViewClient<T>;
+    $queryProc<T = any>(procName: string, params?: Record<string, any> | any[]): Promise<T[]>;
+    $executeProc(procName: string, params?: Record<string, any> | any[]): Promise<number>;
     readRange<T = any>(range: string): Promise<T[][]>;
     writeRange(range: string, values: any[][]): Promise<void>;
     appendRange(range: string, values: any[][]): Promise<void>;
     listSheets(): Promise<string[]>;
     deleteSheet(name: string): Promise<void>;
 }
+export declare class ViewClient<T = any> {
+    readonly adapter: An5Adapter | An5AdapterTx;
+    readonly viewName: string;
+    private readonly tableClient;
+    constructor(adapter: An5Adapter | An5AdapterTx, viewName: string);
+    get dialect(): Dialect;
+    get tableName(): string;
+    findMany(args?: {
+        where?: any;
+        orderBy?: any;
+        skip?: number;
+        take?: number;
+        select?: any;
+        include?: any;
+    }): Promise<T[]>;
+    findFirst(args?: {
+        where?: any;
+        orderBy?: any;
+        select?: any;
+        include?: any;
+    }): Promise<T | null>;
+    findUnique(args: {
+        where: any;
+        select?: any;
+        include?: any;
+    }): Promise<T | null>;
+    count(args?: {
+        where?: any;
+    }): Promise<number>;
+    aggregate(args: any): Promise<any>;
+    groupBy(args: any): Promise<any[]>;
+    vectorSearch(args: any): Promise<(T & {
+        distance: number;
+    })[]>;
+    create(): Promise<never>;
+    createMany(): Promise<never>;
+    update(): Promise<never>;
+    updateMany(): Promise<never>;
+    delete(): Promise<never>;
+    deleteMany(): Promise<never>;
+    upsert(): Promise<never>;
+}
 export declare class An5AdapterTx {
     private readonly handle;
     readonly dialect: Dialect;
+    [key: string]: any;
+    private closed;
     constructor(handle: TransactionHandle, dialect: Dialect);
     exec<T = any>(query: string, params?: Record<string, any>): Promise<T[]>;
     _executeRaw(query: string, params?: Record<string, any>): Promise<number>;
+    $commit(): Promise<void>;
+    $rollback(): Promise<void>;
     table<T = any>(modelName: string): AdapterTableClient<T>;
+    private ensureOpen;
 }
 export declare class AdapterTableClient<T = any> {
-    private readonly adapter;
-    private readonly modelName;
+    readonly adapter: An5Adapter | An5AdapterTx;
+    readonly modelName: string;
     constructor(adapter: An5Adapter | An5AdapterTx, modelName: string);
-    private get dialect();
-    private get tableName();
+    get dialect(): Dialect;
+    get tableName(): string;
     private get nolock();
+    /** Build the shared context used by parseWhere to resolve relations and self references. */
+    private whereContext;
     private doExec;
     private doExecuteRaw;
     findMany(args?: {
@@ -59,20 +152,26 @@ export declare class AdapterTableClient<T = any> {
         skip?: number;
         take?: number;
         select?: any;
+        include?: any;
     }): Promise<T[]>;
     findFirst(args?: {
         where?: any;
         orderBy?: any;
         select?: any;
+        include?: any;
     }): Promise<T | null>;
     findUnique(args: {
         where: any;
+        select?: any;
+        include?: any;
     }): Promise<T | null>;
     count(args?: {
         where?: any;
     }): Promise<number>;
     create(args: {
-        data: Partial<T>;
+        data: Partial<T> | any;
+        include?: any;
+        select?: any;
     }): Promise<T>;
     createMany(args: {
         data: Partial<T>[];
@@ -82,7 +181,9 @@ export declare class AdapterTableClient<T = any> {
     }>;
     update(args: {
         where: any;
-        data: Partial<T>;
+        data: Partial<T> | any;
+        include?: any;
+        select?: any;
     }): Promise<T>;
     updateMany(args: {
         where?: any;
@@ -105,15 +206,49 @@ export declare class AdapterTableClient<T = any> {
     }): Promise<T>;
     aggregate(args: any): Promise<any>;
     groupBy(args: any): Promise<any[]>;
+    /**
+     * Runs similarity search in NBase and hydrates the matching rows from the
+     * relational table, keeping the `{ ...row, distance }` shape the other
+     * engines return.
+     */
+    private searchViaNBase;
+    /**
+     * Vector search for an adapter configured with only an NBase connection
+     * string. The hit id and metadata are the result, since there is no
+     * relational row to hydrate.
+     */
+    private searchViaNBaseOnly;
+    /** The primary key column registered for this model, falling back to `id`. */
+    private primaryKeyColumn;
+    /** Scalar column names known for this model from the generated metadata. */
+    private modelFields;
+    /**
+     * Pushes a table's embedding column into NBase so it can be searched there.
+     *
+     * Each vector keeps the row id in its metadata, which is what lets
+     * `vectorSearch` return real rows instead of bare vector ids.
+     */
+    indexVectorsInNBase(args?: {
+        vectorField?: string;
+        where?: any;
+        take?: number;
+        batchSize?: number;
+    }): Promise<{
+        indexed: number;
+    }>;
     vectorSearch(args: {
         vector: number[];
         take?: number;
         where?: any;
         vectorField?: string;
         distanceMetric?: 'cosine' | 'euclidean' | 'dot';
+        vectorElementType?: 'float32' | 'float16' | 'uint8';
     }): Promise<(T & {
         distance: number;
     })[]>;
 }
 export declare function createAn5Adapter(config: AnyAdapterConfig): AnyAdapter;
+export declare function createAn5Adapter<TModels extends object>(config: AnyAdapterConfig): import('./typed').TypedAn5Adapter<TModels>;
 export declare const createAdapter: typeof createAn5Adapter;
+export declare function createBrowserSqliteAdapter(config: any): An5Adapter;
+export declare function executorFromAdapter(adapterLike: any): any;