camusdb 0.1.0

package/dist/client.d.ts

@@ -0,0 +1,406 @@
+/**
+ * This file is part of CamusDB
+ *
+ * For the full copyright and license information, please view the LICENSE.txt
+ * file that was distributed with this source code.
+ */
+import { CamusBackupClient } from './backup.js';
+import type { CamusCacheMetadata } from './cache.js';
+import type { CamusClientOptions, CamusProtocol, ResolvedConfig } from './config.js';
+import type { CamusTransactionOptions } from './options.js';
+import { CamusQueryStream } from './query-stream.js';
+import type { CamusColumn } from './result-set.js';
+import type { CamusRoutingAdvice } from './routing/advice.js';
+import { CamusTransaction } from './transaction.js';
+import type { CamusBranchRow } from './transport/transport.js';
+import type { Int64Mode } from './values/decode.js';
+import type { Parameters } from './values/encode.js';
+/** What one statement may override for itself. */
+export interface StatementOptions {
+    /** The transaction to run inside. Without one the statement runs in its own short transaction. */
+    readonly transaction?: CamusTransaction | undefined;
+    /** Ends the statement early. */
+    readonly signal?: AbortSignal | undefined;
+    /** A deadline for this statement alone, in seconds. */
+    readonly timeoutSeconds?: number | undefined;
+    /** How an `int64` column reaches the caller, for this statement alone. */
+    readonly int64?: Int64Mode | undefined;
+}
+/** Options for a statement that begins its own short transaction. */
+export interface AutocommitStatementOptions extends StatementOptions {
+    /** Concurrency knobs for the short transaction the server begins for this statement. */
+    readonly transactionOptions?: CamusTransactionOptions | undefined;
+}
+/** The rows of one query, and what the server reported about running it. */
+export interface QueryResult<T> {
+    /** The rows, as plain objects keyed by column name. */
+    readonly rows: T[];
+    /** The output columns, in order. Present even when there are no rows. */
+    readonly columns: CamusColumn[];
+    readonly rowCount: number;
+    /** How a cache-hinted `SELECT` resolved, or `undefined` when the statement carried no hint. */
+    readonly cacheMetadata?: CamusCacheMetadata | undefined;
+    /**
+     * The routing advice the response carried. It arrives only on a client with routing on, and only
+     * for a statement the server judged eligible. It is diagnostic: the driver has already applied it.
+     */
+    readonly routingAdvice?: CamusRoutingAdvice | undefined;
+}
+/** What a write statement did. */
+export interface ExecuteResult {
+    readonly affectedRows: number;
+    /** See `QueryResult.routingAdvice`. */
+    readonly routingAdvice?: CamusRoutingAdvice | undefined;
+}
+/** How `client.transaction` runs and retries a unit of work. */
+export interface TransactionRunOptions {
+    /** How many times the work runs in total, the first attempt included. Default 5. */
+    readonly maxAttempts?: number | undefined;
+    /** Concurrency knobs for the transaction. */
+    readonly transactionOptions?: CamusTransactionOptions | undefined;
+    /** Ends the work early. */
+    readonly signal?: AbortSignal | undefined;
+}
+/**
+ * A connection to one CamusDB database.
+ *
+ * A client is cheap to create and safe to share. It holds no socket of its own: the endpoint
+ * rotation, the bearer token, the wire transport, and the learned routes are shared process-wide
+ * by what they actually depend on, so building a client per request costs almost nothing and still
+ * reuses the connections, the token, and the prepared statements a long-lived one would.
+ *
+ * ```ts
+ * const client = CamusClient.fromConnectionString('Endpoint=http://localhost:8082;Database=test');
+ *
+ * const { rows } = await client.query<Robot>('SELECT * FROM robots WHERE year = @year', { year: 1974 });
+ * ```
+ *
+ * Every method that reaches the server accepts an `AbortSignal` and a per-statement timeout.
+ */
+export declare class CamusClient implements AsyncDisposable {
+    private readonly runtime;
+    private backupClient;
+    /**
+     * Builds a client from an options object, or from a connection string.
+     *
+     * ```ts
+     * new CamusClient({ endpoint: 'http://localhost:8082', database: 'test' });
+     * new CamusClient('Endpoint=http://localhost:8082;Database=test');
+     * ```
+     */
+    constructor(options: CamusClientOptions | string);
+    /**
+     * Builds a client from a `key=value;key=value` connection string.
+     *
+     * ```ts
+     * CamusClient.fromConnectionString('Endpoint=http://localhost:8082;Database=test;User=app;Password=secret');
+     * ```
+     *
+     * Keys are matched without regard to case. Wrap a value in quotes to keep a semicolon or
+     * surrounding spaces in it, and double the quote character to include one.
+     */
+    static fromConnectionString(connectionString: string): CamusClient;
+    /** @internal The resolved configuration, for tests and diagnostics. */
+    get config(): ResolvedConfig;
+    /** The database statements run against. */
+    get database(): string;
+    /** The wire protocol this client speaks. */
+    get protocol(): CamusProtocol;
+    /** The bearer token currently held, or `undefined`. Reading it never triggers a login. */
+    get accessToken(): string | undefined;
+    /**
+     * The node's online backup administration API.
+     *
+     * It is server-level and node-wide, not scoped to this client's database, and it needs a
+     * superuser token when authentication is on.
+     */
+    get backups(): CamusBackupClient;
+    /** How many statements this client currently keeps prepared on the server. */
+    get preparedStatementCount(): number;
+    /** How many destinations learned routing currently holds. Zero when routing is off. */
+    get learnedRouteCount(): number;
+    /** Points this client at another database. It sends nothing. */
+    changeDatabase(database: string): void;
+    /** The configuration as text, with every secret masked. Safe to log. */
+    toString(): string;
+    /**
+     * Runs a `SELECT` and reads every row.
+     *
+     * ```ts
+     * const { rows } = await client.query<Robot>(
+     *   'SELECT id, name, year FROM robots WHERE year > @year',
+     *   { year: 1970 },
+     * );
+     * ```
+     *
+     * Give a type argument to describe the row shape. It is not checked against the server's schema —
+     * nothing on this side can check that — so it states what you expect, and the driver maps each
+     * column to the JavaScript value its declared type calls for.
+     *
+     * Use `queryStream` when the result may be large: this method holds every row in memory.
+     */
+    query<T = Record<string, unknown>>(sql: string, parameters?: Parameters, options?: StatementOptions): Promise<QueryResult<T>>;
+    /** Runs a `SELECT` and reads its first row, or `undefined` when it returned none. */
+    queryOne<T = Record<string, unknown>>(sql: string, parameters?: Parameters, options?: StatementOptions): Promise<T | undefined>;
+    /**
+     * Runs a `SELECT` and reads the first column of its first row, or `undefined`.
+     *
+     * ```ts
+     * const total = await client.scalar<number>('SELECT COUNT(*) FROM robots');
+     * ```
+     */
+    scalar<T = unknown>(sql: string, parameters?: Parameters, options?: StatementOptions): Promise<T | undefined>;
+    /**
+     * Runs a `SELECT` and reports its rows one at a time, so a large result never fully materializes
+     * on this side.
+     *
+     * ```ts
+     * await using stream = await client.queryStream<Robot>('SELECT * FROM robots');
+     *
+     * for await (const robot of stream) {
+     *   process(robot);
+     * }
+     * ```
+     *
+     * It is genuinely incremental over REST. Over gRPC the data plane multiplexes results over
+     * shared streams that decode a whole result before returning, so this buffers and replays: the
+     * caller's code is the same, but the memory saving is not there.
+     *
+     * The streaming path gives up the transparent retry of a serializable conflict that `query` has;
+     * see `CamusQueryStream`.
+     */
+    queryStream<T = Record<string, unknown>>(sql: string, parameters?: Parameters, options?: StatementOptions): Promise<CamusQueryStream<T>>;
+    /**
+     * Runs an `INSERT`, `UPDATE`, or `DELETE` and reports how many rows it changed.
+     *
+     * ```ts
+     * const { affectedRows } = await client.execute(
+     *   'UPDATE robots SET year = @year WHERE id = @id',
+     *   { year: 1984, id: robotId },
+     * );
+     * ```
+     *
+     * A DDL statement is accepted here too and is sent to the DDL route, where it reports zero rows.
+     */
+    execute(sql: string, parameters?: Parameters, options?: AutocommitStatementOptions): Promise<ExecuteResult>;
+    /**
+     * Runs a schema statement: `CREATE TABLE`, `ALTER TABLE`, `DROP INDEX`, a view definition, and
+     * so on.
+     *
+     * `TRUNCATE` is refused inside an explicit transaction. It commits a replicated schema entry that
+     * a rollback cannot undo, so the server refuses it rather than promise a rollback it cannot
+     * deliver, and the driver refuses it before the round trip.
+     */
+    executeDdl(sql: string, options?: AutocommitStatementOptions): Promise<boolean>;
+    /**
+     * Inserts one row through the server's typed row-level route, naming a table and a column-to-value
+     * map instead of composing SQL.
+     *
+     * ```ts
+     * await client.insert('robots', { id: CamusObjectId.generateAsString(), name: 'r1', year: 1974 });
+     * ```
+     *
+     * It performs exactly what `INSERT INTO` performs, and takes the same authorization, endpoint
+     * health, and error translation. Use it to avoid building statement text for a hot write path.
+     */
+    insert(table: string, values: Parameters, options?: StatementOptions): Promise<number>;
+    /** Reports whether the server answers. */
+    ping(options?: {
+        signal?: AbortSignal;
+        timeoutSeconds?: number;
+    }): Promise<boolean>;
+    /**
+     * Begins an explicit transaction.
+     *
+     * Prefer `transaction`, which commits, rolls back, and retries for you. Use this when the unit of
+     * work does not fit inside one function — a saga driven by external events, say.
+     *
+     * ```ts
+     * await using txn = await client.beginTransaction();
+     *
+     * await client.execute('UPDATE accounts SET balance = balance - 10 WHERE id = @id', { id: from }, { transaction: txn });
+     * await client.execute('UPDATE accounts SET balance = balance + 10 WHERE id = @id', { id: to }, { transaction: txn });
+     *
+     * await txn.commit();
+     * ```
+     *
+     * With `await using`, a transaction that is left without a commit is rolled back as the block
+     * unwinds.
+     */
+    beginTransaction(options?: CamusTransactionOptions, signal?: AbortSignal): Promise<CamusTransaction>;
+    /**
+     * Runs a unit of work inside a transaction, committing it when the work returns and rolling it
+     * back when the work throws.
+     *
+     * ```ts
+     * await client.transaction(async (txn) => {
+     *   await client.execute('UPDATE accounts SET balance = balance - @amount WHERE id = @id',
+     *     { amount, id: from }, { transaction: txn });
+     *   await client.execute('UPDATE accounts SET balance = balance + @amount WHERE id = @id',
+     *     { amount, id: to }, { transaction: txn });
+     * });
+     * ```
+     *
+     * A serializable conflict is retried: the whole function runs again on a fresh transaction, with
+     * an exponential back-off. So the function must be safe to run more than once — it must not send
+     * an email, charge a card, or mutate state outside the database on a path that could repeat.
+     *
+     * A commit that reports an unresolved outcome is **not** retried this way. That case is resolved
+     * inside `CamusTransaction`, by re-issuing the same commit on the same handle, because replaying
+     * the work could apply an already-durable commit twice.
+     */
+    transaction<T>(work: (transaction: CamusTransaction) => Promise<T>, options?: TransactionRunOptions): Promise<T>;
+    /**
+     * Registers a statement with the server, so this and every later execution of the same SQL sends
+     * only a handle and its parameter values.
+     *
+     * Calling it is optional. The driver prepares a statement on its own once it has seen the same
+     * SQL a few times; see the `maxAutoPrepare` and `autoPrepareMinUsages` settings. Call it to skip
+     * that warm-up for a statement you already know is hot.
+     *
+     * Registration is idempotent per endpoint, database, and SQL, so preparing twice costs nothing. A
+     * statement that cannot be prepared — schema, administration, or a server with no support for it
+     * — is remembered as such and keeps running inline. That is not an error, and this method does
+     * not report one for it.
+     */
+    prepare(sql: string, options?: StatementOptions): Promise<void>;
+    /** Whether a statement is currently kept prepared for this client's database. */
+    isPrepared(sql: string): boolean;
+    /**
+     * Authenticates as a user and caches the resulting bearer token for every later statement.
+     *
+     * It is only needed when the credentials are not already in the configuration, which
+     * authenticates on first use, or to switch identity. Prefer it over putting a password in a
+     * connection string when the password comes from a secret manager at run time.
+     *
+     * Against a server with authentication off this still performs a real login and will fail, so do
+     * not call it unconditionally.
+     *
+     * @returns the minted token. The driver already holds it; it is reported for a caller that wants
+     * to pass it to another process.
+     */
+    login(user: string, password: string, signal?: AbortSignal): Promise<string>;
+    /**
+     * Revokes this client's bearer token on the server.
+     *
+     * The configured credentials are kept, so a later statement authenticates again on its own: this
+     * ends a session, it does not switch authentication off. It does nothing when no token has been
+     * minted.
+     */
+    logout(signal?: AbortSignal): Promise<void>;
+    /**
+     * Creates a database.
+     *
+     * Concurrent creations can collide transiently while the server allocates the shared database id
+     * sequence, which is what several environments provisioning in parallel produce. That is reported
+     * as a retryable condition and is retried here.
+     *
+     * With `ifNotExists`, a creation that loses a registration race is treated as success. The caller
+     * asked for the database to exist, and it does.
+     */
+    createDatabase(database?: string, options?: {
+        ifNotExists?: boolean;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /** Drops a database and everything in it. */
+    dropDatabase(database?: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /**
+     * Creates a copy-on-write branch of a database. It is the same operation as
+     * `CREATE DATABASE branch BRANCH FROM source`.
+     */
+    createBranchDatabase(branchName: string, sourceDatabaseName: string, options?: {
+        ifNotExists?: boolean;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /**
+     * Every transitive descendant of a database, ordered by depth and then by name. A database with
+     * no descendants reports an empty list.
+     */
+    showBranches(database?: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<CamusBranchRow[]>;
+    /**
+     * The ancestry chain of a database, from its nearest parent to the root. A root database reports
+     * an empty list.
+     */
+    showAncestors(database?: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<CamusBranchRow[]>;
+    /** Drops every cached query result in one family, for the current database. */
+    evictCache(name: string, options?: StatementOptions): Promise<void>;
+    /** Drops every cached query result for the current database. It never touches another one's. */
+    evictAllCache(options?: StatementOptions): Promise<void>;
+    /**
+     * Releases what this client holds on its own, which today is nothing: the transport, the token,
+     * and the endpoint rotation are shared, and outlive any one client.
+     *
+     * Call `CamusTransportPool.closeAll` to release the shared gRPC channels when a process is
+     * shutting down.
+     */
+    close(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+    private executeNonQuery;
+    /**
+     * Resolves where one statement is sent, in strict order of precedence.
+     *
+     * An explicit transaction's pinned endpoint always wins: its operations must land in one
+     * server-side ordering chain, and advice may inform the next transaction but never relocates
+     * this one. Then a fresh learned route, when routing is on. Then the pool's ordinary rotation.
+     *
+     * It also reports the router and the route entry's revision, so the reply's advice can be applied
+     * conditionally: a late reply must never overwrite a route a faster reply already refreshed. A
+     * router of `undefined` means "do not negotiate", and a client with routing off then sends
+     * requests identical to a pre-routing driver's.
+     *
+     * A deferred transaction — routing on, no statement yet — is started here by its first statement,
+     * on that statement's learned endpoint when one is fresh and on rotation otherwise. Every later
+     * statement finds the pin already set.
+     */
+    private route;
+    private buildRequest;
+    /**
+     * Whether this execution should name a prepared statement instead of carrying its SQL,
+     * registering it first when this is the execution that tips it over the threshold.
+     *
+     * The registration is awaited rather than started in the background, because the whole point is
+     * that this execution and the ones after it are cheap. Firing it off and running inline anyway
+     * would leave a busy statement racing its own warm-up. It costs one extra round trip, once per
+     * statement per endpoint.
+     *
+     * The caller passes the endpoint it already resolved. A REST handle is node-local and the pool
+     * rotates, so registering against a freshly drawn endpoint would routinely prepare on one node
+     * and execute on another — correct, because the transport re-registers where it lands, but a
+     * wasted round trip every single time.
+     */
+    private shouldPrepare;
+    /**
+     * Registers a statement and records what happened, reporting whether it may now run prepared.
+     *
+     * A registration failure never reaches the caller: preparing is an optimization, and the
+     * statement runs inline exactly as it would have if the driver had not tried. What the failure
+     * does decide is whether to ask again. A refusal specific to this statement stops asking for that
+     * statement; anything that says the node has no prepared-statement support at all stops asking
+     * for every statement, because one round trip per distinct SQL to relearn that is worse than not
+     * trying.
+     */
+    private register;
+    /**
+     * Releases a statement the policy evicted, so the server stops holding a handle this client has
+     * stopped using.
+     *
+     * It is best effort and off the caller's path: it is bookkeeping, not part of the statement being
+     * run. It takes the endpoint the caller already resolved rather than drawing a new one, which
+     * would rotate the pool as a side effect of housekeeping.
+     */
+    private release;
+    /**
+     * The effective options for a transaction or an autocommit statement: the caller's explicit knobs
+     * win, then this client's defaults, then the server default for any knob still unset.
+     */
+    private resolveTransactionOptions;
+    private decodeOptions;
+    private withTransientRetry;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

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