@lossless.org/client 1.12.0 → 1.14.0

package/dist_ts/nosqldb/classes.persistence.d.ts

@@ -25,6 +25,12 @@ export declare const isMongoDeadlineError: (errorArg: unknown) => boolean;
 /** Maps an expired driver deadline to `timeout`; every other error passes through unchanged. */
 export declare const normalizeDeadlineError: (errorArg: unknown) => unknown;
 export declare const isMongoTransactionRetryError: (errorArg: unknown) => boolean;
+/**
+ * The server or the driver stated that the transaction was aborted and may be
+ * run again from its start, so nothing of it was committed. A timeout the
+ * driver raises in place of such an error copies its labels.
+ */
+export declare const isMongoTransientTransactionError: (errorArg: unknown) => boolean;
 export declare const isMongoDuplicateKeyError: (errorArg: unknown) => errorArg is plugins.mongodb.MongoServerError;
 /**
  * MongoDB refuses an index whose key or name collides with an existing one:

package/dist_ts/nosqldb/classes.persistence.js

@@ -34,6 +34,13 @@ export const normalizeDeadlineError = (errorArg) => isMongoDeadlineError(errorAr
 export const isMongoTransactionRetryError = (errorArg) => errorArg instanceof plugins.mongodb.MongoServerError &&
     (errorArg.hasErrorLabel('TransientTransactionError') ||
         errorArg.hasErrorLabel('UnknownTransactionCommitResult'));
+/**
+ * The server or the driver stated that the transaction was aborted and may be
+ * run again from its start, so nothing of it was committed. A timeout the
+ * driver raises in place of such an error copies its labels.
+ */
+export const isMongoTransientTransactionError = (errorArg) => errorArg instanceof plugins.mongodb.MongoError
+    && errorArg.hasErrorLabel(plugins.mongodb.MongoErrorLabel.TransientTransactionError);
 export const isMongoDuplicateKeyError = (errorArg) => {
     return (errorArg instanceof plugins.mongodb.MongoServerError &&
         (errorArg.code === 11000 || errorArg.codeName === 'DuplicateKey'));
@@ -62,4 +69,4 @@ export const normalizeOrdinaryPersistenceError = (errorArg, messageArg) => {
     }
     throw errorArg;
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/nosqldb/classes.queryplaninspection.d.ts

@@ -0,0 +1,65 @@
+import * as plugins from './plugins.js';
+import type { SmartdataDb } from './classes.db.js';
+import type { MongoFilter, TSmartdataProjection, TSmartdataSort } from './classes.doc.js';
+export interface ISmartdataQueryPlanOptions<T> {
+    /** Validated exactly like the filter of the model's ordinary reads. */
+    filter: MongoFilter<T>;
+    /** Declared paths or `_id`, each 1 or -1, as for `getCursor()` and `getOffsetPage()`. */
+    sort?: TSmartdataSort<T>;
+    /** Declared paths or `_id`, 0 or 1, as for `getCursor()` and `getOffsetPage()`. */
+    projection?: TSmartdataProjection<T>;
+    /** 1..10000. Without it the plan executes over every match. */
+    limit?: number;
+    /** Client deadline for the explained execution. Default 5000ms, maximum 120000ms. */
+    timeoutMS?: number;
+    signal?: AbortSignal;
+}
+/** One stage of the winning plan, in depth-first order from the root. */
+export interface ISmartdataQueryPlanStage {
+    /** The engine's stage name, such as `IXSCAN`, `COLLSCAN`, `FETCH`, `SORT` or `LIMIT`. */
+    readonly stage: string;
+    /** 0 for the root; a stage's inputs follow it at one level deeper. */
+    readonly depth: number;
+    /** The index the stage reads, when the engine names one. */
+    readonly indexName?: string;
+    /** The scan direction, when the engine states one. */
+    readonly direction?: 'forward' | 'backward';
+}
+export interface ISmartdataQueryPlan {
+    /** The winning plan's stage tree, flattened depth-first. */
+    readonly stages: readonly ISmartdataQueryPlanStage[];
+    readonly nReturned: number;
+    readonly totalKeysExamined: number;
+    readonly totalDocsExamined: number;
+    /** Present when the engine reports it. */
+    readonly executionTimeMillis?: number;
+}
+/** @internal The query-plan options after their bounds are checked. */
+export interface IValidatedQueryPlanOptions<T> {
+    readonly filter: MongoFilter<T>;
+    readonly sort: TSmartdataSort<T> | undefined;
+    readonly projection: TSmartdataProjection<T> | undefined;
+    readonly limit: number | undefined;
+    readonly timeoutMS: number;
+    readonly signal: AbortSignal | undefined;
+}
+/** @internal The normalized query one inspection explains. */
+export interface IQueryPlanRequest {
+    readonly collectionName: string;
+    readonly filter: plugins.mongodb.Filter<plugins.mongodb.Document>;
+    readonly sort: plugins.mongodb.Sort | undefined;
+    readonly projection: plugins.mongodb.Document | undefined;
+    readonly limit: number | undefined;
+    readonly timeoutMS: number;
+    readonly signal: AbortSignal | undefined;
+}
+/** @internal Refuses every option shape the query-plan inspection does not define. */
+export declare const requireQueryPlanOptions: <T>(optionsArg: ISmartdataQueryPlanOptions<T>) => IValidatedQueryPlanOptions<T>;
+/** @internal Reduces an `executionStats` explanation to the stable summary; exported for its unit test. */
+export declare const summarizeQueryPlanExplanation: (explanationArg: plugins.mongodb.Document) => ISmartdataQueryPlan;
+/**
+ * @internal Explains one model query with `executionStats` on the given
+ * database. Nothing is created, bound or hydrated; the raw explanation never
+ * leaves this module.
+ */
+export declare const inspectQueryPlan: (dbArg: SmartdataDb, requestArg: IQueryPlanRequest) => Promise<ISmartdataQueryPlan>;

package/dist_ts/nosqldb/classes.queryplaninspection.js

@@ -0,0 +1,148 @@
+import * as plugins from './plugins.js';
+import { SmartdataPersistenceError, createSmartdataTimeoutError, isMongoDeadlineError } from './classes.persistence.js';
+import { requireOperationSignal, requireOperationTimeoutMS } from './classes.operationdeadline.js';
+import { runCursorOperation } from './classes.cursoroperation.js';
+import { collectionTopologyDbInspectionSymbol } from './classes.collectiontopology.js';
+const queryPlanOptionKeys = ['filter', 'sort', 'projection', 'limit', 'timeoutMS', 'signal'];
+const maximumPlanStages = 256;
+const maximumPlanDepth = 64;
+const maximumPlanStringLength = 1024;
+/** MongoDB's `CommandNotFound`, the answer of an engine that implements no `explain`. */
+const commandNotFoundCode = 59;
+const isRecord = (valueArg) => typeof valueArg === 'object' && valueArg !== null && !Array.isArray(valueArg);
+const isPlainRecord = (valueArg) => {
+    if (!isRecord(valueArg))
+        return false;
+    const prototype = Object.getPrototypeOf(valueArg);
+    return prototype === Object.prototype || prototype === null;
+};
+/** @internal Refuses every option shape the query-plan inspection does not define. */
+export const requireQueryPlanOptions = (optionsArg) => {
+    const options = optionsArg;
+    if (!isPlainRecord(options) || Reflect.ownKeys(options).some((keyArg) => typeof keyArg !== 'string' || !queryPlanOptionKeys.includes(keyArg) ||
+        !('value' in Object.getOwnPropertyDescriptor(options, keyArg)))) {
+        throw new SmartdataPersistenceError('invalid_argument', 'Invalid query plan inspection options.');
+    }
+    if (!isPlainRecord(optionsArg.filter)) {
+        throw new SmartdataPersistenceError('invalid_argument', 'Query plan inspection requires a plain filter object.');
+    }
+    const limit = optionsArg.limit;
+    if (limit !== undefined &&
+        (typeof limit !== 'number' || !Number.isSafeInteger(limit) || limit < 1 || limit > 10_000)) {
+        throw new SmartdataPersistenceError('invalid_argument', 'limit must be an integer from 1 through 10000.');
+    }
+    return {
+        filter: optionsArg.filter,
+        sort: optionsArg.sort,
+        projection: optionsArg.projection,
+        limit,
+        timeoutMS: requireOperationTimeoutMS(optionsArg.timeoutMS, 'timeoutMS') ?? 5_000,
+        signal: requireOperationSignal(optionsArg.signal, 'signal'),
+    };
+};
+const unreadablePlan = () => new SmartdataPersistenceError('unsupported_operation', 'The engine returned an unreadable query plan.');
+const readCount = (valueArg) => {
+    if (typeof valueArg !== 'number' || !Number.isSafeInteger(valueArg) || valueArg < 0) {
+        throw unreadablePlan();
+    }
+    return valueArg;
+};
+const readPlanString = (valueArg) => {
+    if (typeof valueArg !== 'string' || valueArg.length === 0 || valueArg.length > maximumPlanStringLength) {
+        throw unreadablePlan();
+    }
+    return valueArg;
+};
+/**
+ * Flattens the winning plan depth-first. MongoDB's slot-based engine wraps the
+ * classic tree as `queryPlan`; every other field of a stage stays behind.
+ */
+const flattenWinningPlan = (winningPlanArg) => {
+    const root = isRecord(winningPlanArg) && winningPlanArg.stage === undefined && isRecord(winningPlanArg.queryPlan)
+        ? winningPlanArg.queryPlan
+        : winningPlanArg;
+    const stages = [];
+    const visit = (nodeArg, depthArg) => {
+        if (!isRecord(nodeArg) || depthArg >= maximumPlanDepth || stages.length === maximumPlanStages) {
+            throw unreadablePlan();
+        }
+        const direction = nodeArg.direction === 'forward' || nodeArg.direction === 'backward'
+            ? nodeArg.direction
+            : undefined;
+        stages.push(Object.freeze({
+            stage: readPlanString(nodeArg.stage),
+            depth: depthArg,
+            ...(nodeArg.indexName === undefined ? {} : { indexName: readPlanString(nodeArg.indexName) }),
+            ...(direction === undefined ? {} : { direction }),
+        }));
+        const inputs = nodeArg.inputStages === undefined ? [] : nodeArg.inputStages;
+        if (!Array.isArray(inputs))
+            throw unreadablePlan();
+        if (nodeArg.inputStage !== undefined)
+            visit(nodeArg.inputStage, depthArg + 1);
+        for (const input of inputs)
+            visit(input, depthArg + 1);
+    };
+    visit(root, 0);
+    return stages;
+};
+/** @internal Reduces an `executionStats` explanation to the stable summary; exported for its unit test. */
+export const summarizeQueryPlanExplanation = (explanationArg) => {
+    const queryPlanner = explanationArg.queryPlanner;
+    const executionStats = explanationArg.executionStats;
+    if (!isRecord(queryPlanner) || !isRecord(executionStats) || executionStats.executionSuccess === false) {
+        throw unreadablePlan();
+    }
+    const stages = flattenWinningPlan(queryPlanner.winningPlan);
+    const executionTimeMillis = executionStats.executionTimeMillis === undefined
+        ? undefined
+        : readCount(executionStats.executionTimeMillis);
+    return Object.freeze({
+        stages: Object.freeze(stages),
+        nReturned: readCount(executionStats.nReturned),
+        totalKeysExamined: readCount(executionStats.totalKeysExamined),
+        totalDocsExamined: readCount(executionStats.totalDocsExamined),
+        ...(executionTimeMillis === undefined ? {} : { executionTimeMillis }),
+    });
+};
+/**
+ * @internal Explains one model query with `executionStats` on the given
+ * database. Nothing is created, bound or hydrated; the raw explanation never
+ * leaves this module.
+ */
+export const inspectQueryPlan = async (dbArg, requestArg) => {
+    const { signal } = requestArg;
+    signal?.throwIfAborted();
+    let failure;
+    let explanation;
+    try {
+        explanation = await dbArg[collectionTopologyDbInspectionSymbol](async (mongoDbArg) => {
+            const cursor = mongoDbArg.collection(requestArg.collectionName).find(requestArg.filter, {
+                ...(requestArg.sort === undefined ? {} : { sort: requestArg.sort }),
+                ...(requestArg.projection === undefined ? {} : { projection: requestArg.projection }),
+                ...(requestArg.limit === undefined ? {} : { limit: requestArg.limit }),
+                ...(signal === undefined ? {} : { signal }),
+            });
+            try {
+                return await runCursorOperation(cursor, (cursorArg) => cursorArg.explain('executionStats', { timeoutMS: requestArg.timeoutMS }), signal);
+            }
+            catch (errorArg) {
+                failure = { error: errorArg };
+                throw errorArg;
+            }
+        });
+    }
+    catch (errorArg) {
+        signal?.throwIfAborted();
+        if (failure !== undefined && isMongoDeadlineError(failure.error)) {
+            throw createSmartdataTimeoutError('Query plan inspection exceeded its client deadline.', failure.error);
+        }
+        if (failure !== undefined && failure.error instanceof plugins.mongodb.MongoServerError &&
+            failure.error.code === commandNotFoundCode) {
+            throw new SmartdataPersistenceError('unsupported_operation', 'The connected engine does not explain queries.');
+        }
+        throw errorArg;
+    }
+    return summarizeQueryPlanExplanation(explanation);
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.queryplaninspection.js","sourceRoot":"","sources":["../../ts/nosqldb/classes.queryplaninspection.ts"],"names":[],"mappings":"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"}

package/dist_ts/nosqldb/classes.session.d.ts

@@ -1,6 +1,17 @@
 import * as plugins from './plugins.js';
 import type { SmartdataDb } from './classes.db.js';
 import { SmartdataOperationDeadline } from './classes.operationdeadline.js';
+/**
+ * Whether a transaction that `SmartdataSession.withTransaction()` rejected
+ * could have committed:
+ *
+ * - `not_committed`: nothing of the transaction was committed. The call failed
+ *   before the driver sent a commit, or the database answered the commit with
+ *   an error that states the transaction was aborted.
+ * - `unknown`: a commit was sent and its outcome was never confirmed; it may
+ *   have applied.
+ */
+export type TSmartdataTransactionCommitOutcome = 'not_committed' | 'unknown';
 interface ISmartdataSessionAcquireOptions {
     ordinaryWrite?: boolean;
 }
@@ -32,6 +43,20 @@ export interface ISmartdataTransactionOptions {
     signal?: AbortSignal;
 }
 export declare class SmartdataSession {
+    /**
+     * Whether the transaction whose `withTransaction()` call rejected with
+     * `errorArg` could have committed: `not_committed` when nothing of it was
+     * committed, `unknown` when a commit was sent and never confirmed, so it may
+     * have applied. Every rejection of `withTransaction()` carries one, whatever
+     * it is: the client's own errors, the callback's error, the abort reason or
+     * a driver error, which all keep their identity. A value several calls
+     * rejected with reads `unknown` once any of them may have committed.
+     *
+     * Returns `undefined` for any other value, and for a primitive rejection —
+     * a callback that throws a string, or a string abort reason — which cannot
+     * carry the outcome; treat `undefined` as `unknown`.
+     */
+    static getCommitOutcome(errorArg: unknown): TSmartdataTransactionCommitOutcome | undefined;
     /**
      * Runs `callbackArg` in a transaction, retrying it as the driver decides.
      *
@@ -63,6 +88,10 @@ export declare class SmartdataSession {
      * `unsupported_operation`: before the callback returned nothing was
      * committed, afterwards the commit outcome is unknown. The callback's
      * error, if it threw, is the `cause`.
+     *
+     * Every rejection states whether the transaction could have committed:
+     * `SmartdataSession.getCommitOutcome(error)` returns `not_committed` or
+     * `unknown` for the value the call rejected with.
      */
     withTransaction<TResult>(callbackArg: (sessionArg: SmartdataSession) => Promise<TResult>, optionsArg?: ISmartdataTransactionOptions): Promise<TResult | undefined>;
     close(): Promise<void>;