@lossless.org/client 1.0.0 → 1.1.0

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

@@ -175,6 +175,13 @@ type TSmartdataAtomicIncrement<T> = Partial<Record<{
 export type TSmartdataNumericDocumentPath<T> = {
     [TKey in TSmartdataDocumentPath<T>]: NonNullable<T[TKey]> extends number ? TKey : never;
 }[TSmartdataDocumentPath<T>];
+/** Declared top-level fields that carry a monotonic ordering: numbers and dates. */
+export type TSmartdataMonotonicDocumentPath<T> = {
+    [TKey in TSmartdataDocumentPath<T>]: NonNullable<T[TKey]> extends number ? TKey : NonNullable<T[TKey]> extends Date ? TKey : never;
+}[TSmartdataDocumentPath<T>];
+type TSmartdataAtomicMonotonic<T> = Partial<{
+    [TKey in TSmartdataMonotonicDocumentPath<T>]: NonNullable<T[TKey]> extends Date ? Date : number;
+}> & Partial<Record<TSmartdataAtomicNestedDocumentPath<T>, number | Date>>;
 export type TSmartdataAtomicNumericFieldReference<T> = `$${TSmartdataNumericDocumentPath<T>}`;
 export type TSmartdataAtomicNumericExpressionOperand<T> = number | TSmartdataAtomicNumericFieldReference<T> | {
     $add: readonly [
@@ -243,6 +250,18 @@ export interface ISmartdataAtomicUpdate<T> {
     $set?: TSmartdataAtomicSet<T>;
     $unset?: Partial<Record<TSmartdataAtomicDocumentPath<T>, '' | true | 1>>;
     $inc?: TSmartdataAtomicIncrement<T>;
+    /**
+     * Monotonic ceiling for a declared numeric or date field: one server-side
+     * compare-and-write that never lowers the stored value, so a retried or
+     * out-of-order writer cannot regress a counter. With `upsert: true` a
+     * missing field is inserted with the operand.
+     */
+    $max?: TSmartdataAtomicMonotonic<T>;
+    /**
+     * Monotonic floor for a declared numeric or date field: the mirror of
+     * `$max`, never raising the stored value.
+     */
+    $min?: TSmartdataAtomicMonotonic<T>;
     $setOnInsert?: TSmartdataAtomicSet<T>;
     /**
      * Appends one element to a declared top-level array field. Modifier
@@ -356,6 +375,27 @@ export interface ISmartdataAtomicUpdateManyResult {
     matchedCount: number;
     modifiedCount: number;
 }
+/** One strict selector and its update, both validated before any write. */
+export interface ISmartdataAtomicUpsertManyOperation<T> {
+    filter: TSmartdataAtomicFilter<T>;
+    update: ISmartdataAtomicUpdate<T>;
+}
+export interface ISmartdataAtomicUpsertManyOptions {
+    session?: TSmartdataOrdinarySession;
+    /** Client-side bulk operation deadline, including server selection and pool waits. */
+    timeoutMS?: number;
+    /**
+     * Only `false`. The batch is always unordered, so one conflicting entry
+     * never hides the outcome of the entries behind it.
+     */
+    ordered?: false;
+}
+export interface ISmartdataAtomicUpsertManyResult {
+    acknowledged: boolean;
+    matchedCount: number;
+    modifiedCount: number;
+    upsertedCount: number;
+}
 export declare const convertFilterForMongoDb: (filterArg: {
     [key: string]: any;
 }) => {
@@ -386,6 +426,16 @@ export declare class SmartDataDbDoc<T extends TImplements, TImplements, TManager
     private static getDeclaredUniqueRoots;
     private static getDeclaredIdentityValueTypes;
     private static getDeclaredNumericRoots;
+    /**
+     * Returns the declared identity field this model stores as the document
+     * `_id`, or undefined when SmartData owns the primary key.
+     */
+    private static getIdentityDocumentIdField;
+    /**
+     * Converts an ordinary read filter and routes a declared document-id
+     * identity onto `_id`, so reads use the primary key index.
+     */
+    private static normalizeReadFilter;
     /**
      * Returns every equality key set that globally constrains a single document
      * of this model: each declared identity field on its own, plus the full key
@@ -485,6 +535,14 @@ export declare class SmartDataDbDoc<T extends TImplements, TImplements, TManager
      * rejected.
      */
     static atomicUpdateMany<T>(this: plugins.tsclass.typeFest.Class<T>, filterArg: TSmartdataAtomicFilter<T>, updateArg: Omit<ISmartdataAtomicUpdate<T>, '$setOnInsert'>, opts?: ISmartdataAtomicUpdateManyOptions): Promise<ISmartdataAtomicUpdateManyResult>;
+    /**
+     * Atomically upserts a bounded batch of ordinary model documents in one
+     * round trip. Every entry carries its own strict selector and update, and
+     * each entry applies atomically; the batch as a whole is not isolated unless
+     * the caller supplies a transaction session. The complete batch is validated
+     * before any write, so one invalid entry rejects the call without writing.
+     */
+    static atomicUpsertMany<T>(this: plugins.tsclass.typeFest.Class<T>, operationsArg: ReadonlyArray<ISmartdataAtomicUpsertManyOperation<T>>, opts?: ISmartdataAtomicUpsertManyOptions): Promise<ISmartdataAtomicUpsertManyResult>;
     /**
      * Computes bounded grouped counts and optional numeric sums server-side.
      * Groups by one or two declared top-level fields, always returns a `count`