@lossless.org/client 1.0.0 → 1.1.0

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

@@ -11,6 +11,12 @@ export interface IOrdinaryPersistencePolicy {
     readonly timestamps: 'managed' | 'none';
     readonly assertStoredDocument: (valueArg: unknown) => void;
 }
+/**
+ * Reports whether a model opted into exact persistence. Exact persistence owns
+ * the stored `_id` as a MongoDB ObjectId, so options that hand the primary key
+ * to a declared identity field must refuse those models by name.
+ */
+export declare const hasExactPersistencePolicy: (modelArg: any) => boolean;
 export declare const getOrdinaryPersistencePolicy: (modelArg: any) => IOrdinaryPersistencePolicy | undefined;
 /** Opt into immutable whole-stored-document validation for an ordinary model. */
 export declare const ordinaryPersistence: (opts: IOrdinaryPersistenceOptions) => <T extends new (...args: any[]) => any>(modelArg: T, _contextArg?: ClassDecoratorContext<T>) => T;

package/dist_ts/nosqldb/classes.ordinarypersistence.js

@@ -3,6 +3,12 @@ import { SmartdataPersistenceError } from './classes.persistence.js';
 import { assertBsonWithoutMutation } from './classes.bsonassertion.js';
 const policySymbol = Symbol.for('@push.rocks/smartdata.ordinaryPersistencePolicy');
 const exactSymbol = Symbol.for('@push.rocks/smartdata.exactPersistencePolicy');
+/**
+ * Reports whether a model opted into exact persistence. Exact persistence owns
+ * the stored `_id` as a MongoDB ObjectId, so options that hand the primary key
+ * to a declared identity field must refuse those models by name.
+ */
+export const hasExactPersistencePolicy = (modelArg) => Boolean(modelArg?.[exactSymbol]);
 export const getOrdinaryPersistencePolicy = (modelArg) => {
     const policy = modelArg?.[policySymbol];
     if (policy && modelArg[exactSymbol]) {
@@ -68,4 +74,4 @@ export const validateOrdinaryStoredDocument = (documentArg, policyArg, persisted
     // The assertion must not retain authority to mutate the returned document.
     return plugins.mongodb.BSON.deserialize(plugins.mongodb.BSON.serialize(clone));
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lossless.org/client",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "private": false,
   "description": "One typed client for NoSQLDB, MongoDB, SQLDB, MariaDB, ClickHouse and S3 object storage.",
   "exports": {

package/readme.md

@@ -78,6 +78,15 @@ Literal connection names and backend discriminators determine the return types.
 
 Family imports preserve the established SmartData and SmartBucket names and constructors. Their implementations live here; the client does not depend on the old packages. The aggregate loads only configured families. Direct family entry points do not initialize unrelated connections.
 
+| `@lossless.org/client/nosqldb` addition | API |
+| --- | --- |
+| Monotonic counters and timestamps | `$max` / `$min` in `ISmartdataAtomicUpdate`, for declared numeric and date fields |
+| Race-free registration on a second unique key | `$setOnInsert` may seed a declared `@unI()` identity when `upsert: true` |
+| Bounded plural upsert | `Model.atomicUpsertMany(operations, opts?)` — 1..1000 per-document filter/update pairs in one unordered round trip |
+| Content-addressed primary keys | model option `identityAsDocumentId` on `defineCollectionModel()` and `@Collection()` |
+
+`docs/source/smartdata/readme.md` documents each one with its refusals.
+
 ## Relational SQL
 
 `SqlConnection` uses the official MariaDB connector for parameters, protocol, TLS and decoding. This client owns cancellable admission and TCP sockets from authentication onward. A transaction holds one physical session; releasing a session resets its state before reuse.
@@ -144,7 +153,7 @@ SmartClickHouse migration changes: replace RxJS `next/complete` insertion with a
 
 `@lossless.org/client/nosqldb` is a fork of @push.rocks/smartdata 11.14.2 (commit `9868817a63de72caef787bd8e68bac3deb9d6131`), taken on 2026-09-10; this repository continues that package's git history, so every upstream fix up to and including 11.14.2 is present here. `nosqldbLineage`, exported from the family entry point, carries the same baseline for runtime and tooling checks, and `docs/source/smartdata` keeps the upstream readme, hints and changelog.
 
-The fork departs from that baseline in three places: `NoSqlConnection` adds the client backend, capability and readiness contract; the family entry point exports it together with `nosqldbLineage`; and `watch()` refuses to open a change stream when the connected backend reports change streams as unsupported. The package version file was dropped, because versioning belongs to `@lossless.org/client`.
+The fork departs from that baseline in three places: `NoSqlConnection` adds the client backend, capability and readiness contract; the family entry point exports it together with `nosqldbLineage`; and `watch()` refuses to open a change stream when the connected backend reports change streams as unsupported. The package version file was dropped, because versioning belongs to `@lossless.org/client`. Document-model capabilities added after the fork — `$max`/`$min`, identity seeding through `$setOnInsert`, `atomicUpsertMany()` and `identityAsDocumentId` — are this package's own additions and have no upstream counterpart.
 
 Fixes land here. @push.rocks/smartdata is no longer a release channel for this implementation, so a later upstream version is not a source to merge from and not an upgrade path for consumers of this package.
 

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@lossless.org/client',
-  version: '1.0.0',
+  version: '1.1.0',
   description: 'One typed client for NoSQLDB, MongoDB, SQLDB, MariaDB, ClickHouse and S3 object storage.'
 }

package/ts/nosqldb/classes.atomicupdate.ts

@@ -52,6 +52,73 @@ export const executeAtomicUpdate = async <T>(
   );
 };
 
+/**
+ * Executes a bounded batch of model-validated atomic upserts against MongoDB.
+ *
+ * This helper is package-internal. `SmartDataDbDoc.atomicUpsertMany()` owns the
+ * public API and must validate and normalize every filter and update before
+ * calling this raw persistence boundary. Each entry applies atomically; the
+ * batch as a whole is not isolated unless the caller supplies a transaction
+ * session.
+ */
+export const executeAtomicUpsertMany = async <T>(
+  collectionArg: SmartdataCollection<T>,
+  operationsArg: ReadonlyArray<{
+    filter: plugins.mongodb.Filter<plugins.mongodb.Document>;
+    update: plugins.mongodb.UpdateFilter<plugins.mongodb.Document>;
+  }>,
+  optsArg?: {
+    session?: TSmartdataOrdinarySession;
+    timeoutMS?: number;
+  },
+): Promise<{
+  acknowledged: boolean;
+  matchedCount: number;
+  modifiedCount: number;
+  upsertedCount: number;
+}> => {
+  return runWithOrdinarySmartdataSession(
+    optsArg?.session,
+    collectionArg.smartdataDb,
+    {
+      ordinaryWrite: true,
+      prepared: collectionArg.isInitializedForCurrentDatabase(),
+      preparationMessage:
+        `Initialize collection "${collectionArg.collectionName}" before using an owned SmartData session.`,
+    },
+    async (rawSessionArg) => {
+      await collectionArg.init();
+      try {
+        const result = await collectionArg.mongoDbCollection.bulkWrite(
+          operationsArg.map((operationArg) => ({
+            updateOne: {
+              filter: operationArg.filter,
+              update: operationArg.update,
+              upsert: true,
+            },
+          })),
+          {
+            ordered: false,
+            session: rawSessionArg,
+            timeoutMS: optsArg?.timeoutMS,
+          },
+        );
+        return {
+          acknowledged: result.isOk(),
+          matchedCount: result.matchedCount,
+          modifiedCount: result.modifiedCount,
+          upsertedCount: result.upsertedCount,
+        };
+      } catch (errorArg) {
+        return normalizeOrdinaryPersistenceError(
+          errorArg,
+          `Atomic upsert-many conflicts with a unique index in collection "${collectionArg.collectionName}".`,
+        );
+      }
+    },
+  );
+};
+
 /**
  * Executes a model-validated atomic update-many against MongoDB.
  *

package/ts/nosqldb/classes.collection.ts

@@ -6,7 +6,8 @@ import {
   type ISmartdataCollectionPreparationOptions,
 } from './classes.collectionpreparation.js';
 import {
-  getOrdinaryPersistencePolicy, validateOrdinaryStoredDocument,
+  getOrdinaryPersistencePolicy, hasExactPersistencePolicy,
+  validateOrdinaryStoredDocument,
   type IOrdinaryPersistencePolicy,
 } from './classes.ordinarypersistence.js';
 import { SmartdataDb } from './classes.db.js';
@@ -57,6 +58,14 @@ export interface ICollectionBindingOptions {
    * its legacy collection without changing stored data.
    */
   collectionName?: string;
+  /**
+   * Stores one declared `@unI()` string identity as the document `_id`, making
+   * the primary key itself the uniqueness authority. The field keeps its own
+   * stored value and receives no separate unique index. Irreversible for an
+   * existing collection: every stored document must already satisfy
+   * `_id === document[field]`.
+   */
+  identityAsDocumentId?: string;
 }
 
 export type TCollectionModelIndexDirection = 1 | -1 | 'text';
@@ -106,6 +115,13 @@ export interface ICollectionModelConfig<TModel extends object = any> {
    * ascending unique index in `indexes`.
    */
   identityFields?: ReadonlyArray<TStringFieldKey<TModel>>;
+  /**
+   * Stores one declared string identity as the document `_id`. The primary key
+   * becomes the uniqueness authority, so the field must not declare its own
+   * unique index. Irreversible for an existing collection: every stored
+   * document must already satisfy `_id === document[field]`.
+   */
+  identityAsDocumentId?: TStringFieldKey<TModel>;
   /**
    * Persisted fields used by SmartData's search helpers.
    */
@@ -122,6 +138,8 @@ export interface INormalizedCollectionModelSchema {
   readonly persistedFields: readonly string[];
   readonly numericFields: readonly string[];
   readonly identityFields: readonly string[];
+  /** Declared identity field stored as the document `_id`, if any. */
+  readonly identityAsDocumentId?: string;
   readonly identityValueTypes: Readonly<
     Record<string, TSmartdataIdentityValueType>
   >;
@@ -323,6 +341,7 @@ const normalizeCollectionModelSchema = (
     'persistedFields',
     'numericFields',
     'identityFields',
+    'identityAsDocumentId',
     'searchableFields',
     'indexes',
   ]);
@@ -395,6 +414,24 @@ const normalizeCollectionModelSchema = (
       identityFields.push(field);
     }
   }
+  const identityAsDocumentId = configArg.identityAsDocumentId;
+  if (identityAsDocumentId !== undefined) {
+    if (
+      typeof identityAsDocumentId !== 'string' ||
+      !identityFields.includes(identityAsDocumentId)
+    ) {
+      throw new SmartdataPersistenceError(
+        'invalid_configuration',
+        'Collection model identityAsDocumentId must name a declared identity field.',
+      );
+    }
+    if (ordinaryPolicyArg?.idType === 'string') {
+      throw new SmartdataPersistenceError(
+        'invalid_configuration',
+        `Identity field "${identityAsDocumentId}" cannot own the document _id together with a string ordinary persistence _id.`,
+      );
+    }
+  }
   const identityValueTypes: Record<string, TSmartdataIdentityValueType> = {};
   for (const field of Object.keys(identityValueTypesArg || {})) {
     if (!identityFields.includes(field)) {
@@ -564,6 +601,25 @@ const normalizeCollectionModelSchema = (
         indexArg.key[0][0] === identityField &&
         indexArg.key[0][1] === 1,
     );
+    if (identityField === identityAsDocumentId) {
+      // The primary key is the only uniqueness authority for this field. A
+      // second unique index would have to be built on a live collection and
+      // could disagree with _id, so the declaration is refused rather than
+      // silently ignored.
+      if (hasIdentityIndex) {
+        throw new SmartdataPersistenceError(
+          'invalid_configuration',
+          `Identity field "${identityField}" owns the document _id and must not declare its own unique index.`,
+        );
+      }
+      if (identityValueTypes[identityField] !== 'string') {
+        throw new SmartdataPersistenceError(
+          'invalid_configuration',
+          `Identity field "${identityField}" must be a string identity to own the document _id.`,
+        );
+      }
+      continue;
+    }
     if (!hasIdentityIndex) {
       throw new SmartdataPersistenceError(
         'invalid_configuration',
@@ -577,6 +633,7 @@ const normalizeCollectionModelSchema = (
     persistedFields: Object.freeze([...persistedFields]),
     numericFields: Object.freeze([...numericFields]),
     identityFields: Object.freeze([...identityFields]),
+    ...(identityAsDocumentId !== undefined ? { identityAsDocumentId } : {}),
     identityValueTypes: Object.freeze({ ...identityValueTypes }),
     searchableFields: Object.freeze([...searchableFields]),
     indexes: Object.freeze([...indexesByName.values()]),
@@ -591,6 +648,7 @@ const normalizeCollectionModelSchema = (
       persistedFields: [...persistedFields].sort(compareSmartdataTopologyStrings),
       numericFields: [...numericFields].sort(compareSmartdataTopologyStrings),
       identityFields: [...identityFields].sort(compareSmartdataTopologyStrings),
+      ...(identityAsDocumentId !== undefined ? { identityAsDocumentId } : {}),
       identityValueTypes,
       searchableFields: [...searchableFields].sort(
         compareSmartdataTopologyStrings,
@@ -854,6 +912,7 @@ const definedModelSchemaSymbol = Symbol.for(
 const schemaFromDecoratorMetadata = (
   constructorArg: TCollectionModelConstructor<any>,
   collectionNameArg: string,
+  identityAsDocumentIdArg?: string,
 ): INormalizedCollectionModelSchema => {
   const ownMetadata = Object.prototype.hasOwnProperty.call(
     constructorArg,
@@ -885,6 +944,11 @@ const schemaFromDecoratorMetadata = (
     .map(([fieldArg]) => fieldArg);
   const indexes: ICollectionModelIndex[] = [];
   for (const uniqueField of metadata.uniqueIndexes || []) {
+    if (uniqueField === identityAsDocumentIdArg) {
+      // The document _id enforces this identity; a derived unique index would
+      // duplicate the primary key and require an index build on live data.
+      continue;
+    }
     indexes.push({
       name: `${uniqueField}_1`,
       key: { [uniqueField]: 1 },
@@ -924,6 +988,9 @@ const schemaFromDecoratorMetadata = (
       persistedFields,
       numericFields,
       identityFields: metadata.uniqueIndexes || [],
+      ...(identityAsDocumentIdArg !== undefined
+        ? { identityAsDocumentId: identityAsDocumentIdArg }
+        : {}),
       searchableFields: metadata.searchableFields || [],
       indexes,
     },
@@ -933,6 +1000,35 @@ const schemaFromDecoratorMetadata = (
   );
 };
 
+/**
+ * Exact persistence owns the stored `_id` as a MongoDB ObjectId, so a model
+ * cannot also hand the primary key to a declared identity field.
+ */
+const assertIdentityDocumentIdIsOrdinary = (
+  modelArg: TCollectionModelConstructor<any>,
+  identityAsDocumentIdArg: string,
+): void => {
+  if (hasExactPersistencePolicy(modelArg)) {
+    throw new SmartdataPersistenceError(
+      'invalid_configuration',
+      `Identity field "${identityAsDocumentIdArg}" cannot own the document _id for an exact-persistence model.`,
+    );
+  }
+};
+
+/**
+ * Returns the declared identity field a model stores as its document `_id`.
+ * Reading the bound schema resolver never resolves a database.
+ */
+export const getIdentityDocumentIdField = (modelArg: any): string | undefined => {
+  const resolver = modelArg?.[collectionModelSchemaResolverSymbol] as
+    | (() => INormalizedCollectionModelSchema)
+    | undefined;
+  return typeof resolver === 'function'
+    ? resolver().identityAsDocumentId
+    : undefined;
+};
+
 const installCollectionBinding = <
   TModel extends SmartDataDbDoc<any, any>,
 >(
@@ -1016,6 +1112,11 @@ export function defineCollectionModel<
       }
     | undefined;
   const inheritedSchema = inheritedConstructor?.[definedModelSchemaSymbol];
+  const identityAsDocumentId =
+    configArg.identityAsDocumentId ?? inheritedSchema?.identityAsDocumentId;
+  if (identityAsDocumentId !== undefined) {
+    assertIdentityDocumentIdIsOrdinary(modelArg, identityAsDocumentId);
+  }
   const normalizedSchema = normalizeCollectionModelSchema({
     ...configArg,
     persistedFields: [
@@ -1030,6 +1131,9 @@ export function defineCollectionModel<
       ...(inheritedSchema?.identityFields || []),
       ...(configArg.identityFields || []),
     ] as Array<keyof TModel & string>,
+    ...(identityAsDocumentId !== undefined
+      ? { identityAsDocumentId: identityAsDocumentId as TStringFieldKey<TModel> }
+      : {}),
     searchableFields: [
       ...(inheritedSchema?.searchableFields || []),
       ...(configArg.searchableFields || []),
@@ -1254,13 +1358,30 @@ export function Collection(
     const collectionName = normalizeCollectionName(
       optionsArg?.collectionName ?? constructor.name,
     );
+    const identityAsDocumentId = optionsArg?.identityAsDocumentId;
+    if (
+      identityAsDocumentId !== undefined
+      && (typeof identityAsDocumentId !== 'string' || identityAsDocumentId.length === 0)
+    ) {
+      throw new SmartdataPersistenceError(
+        'invalid_configuration',
+        'Collection identityAsDocumentId must name a declared @unI() identity field.',
+      );
+    }
     return installCollectionBinding(
       constructor as TCollectionModelConstructor<any>,
       () => (dbArg instanceof SmartdataDb ? dbArg : dbArg()),
       () => {
+        if (identityAsDocumentId !== undefined) {
+          assertIdentityDocumentIdIsOrdinary(
+            constructor as TCollectionModelConstructor<any>,
+            identityAsDocumentId,
+          );
+        }
         return schemaFromDecoratorMetadata(
           constructor as TCollectionModelConstructor<any>,
           collectionName,
+          identityAsDocumentId,
         );
       },
     ) as any;
@@ -1719,6 +1840,11 @@ export class SmartdataCollection<T> {
    */
   public async markUniqueIndexes(keyArrayArg: string[] = []) {
     for (const key of keyArrayArg) {
+      if (key === this.modelSchema?.identityAsDocumentId) {
+        // The primary key already enforces this identity; building a second
+        // unique index on a live collection is exactly what the option avoids.
+        continue;
+      }
       if (!this.uniqueIndexes.includes(key)) {
         try {
           await this.mongoDbCollection.createIndex({ [key]: 1 }, {
@@ -1959,6 +2085,7 @@ export class SmartdataCollection<T> {
    * create an object in the database
    */
   private prepareOrdinaryInsert(documentArg: any): any {
+    documentArg = this.applyIdentityDocumentId(documentArg);
     const policy = this.modelSchema?.ordinaryPersistence;
     if (!policy) return documentArg;
     if (policy.idType === 'objectId' && !Object.prototype.hasOwnProperty.call(documentArg, '_id')) {
@@ -1967,11 +2094,46 @@ export class SmartdataCollection<T> {
     return validateOrdinaryStoredDocument(documentArg, policy, this.modelSchema!.persistedFields);
   }
 
+  /**
+   * Keys a stored document by its declared identity when the model opted into
+   * `identityAsDocumentId`. The identity keeps its own stored field, but reads
+   * address `_id`, so a document written before the option was declared is
+   * reachable only if its `_id` already equals that identity.
+   */
+  private applyIdentityDocumentId(documentArg: any): any {
+    const identityField = this.modelSchema?.identityAsDocumentId;
+    if (!identityField) return documentArg;
+    const identityValue = documentArg?.[identityField];
+    if (typeof identityValue !== 'string' || identityValue.trim().length === 0) {
+      throw new SmartdataPersistenceError(
+        'invalid_argument',
+        `Identity field "${identityField}" must contain a non-empty string identity value to key the document.`,
+      );
+    }
+    if (
+      Object.prototype.hasOwnProperty.call(documentArg, '_id')
+      && documentArg._id !== identityValue
+    ) {
+      throw new SmartdataPersistenceError(
+        'invalid_argument',
+        `Identity field "${identityField}" owns the document _id and cannot be stored with a divergent _id.`,
+      );
+    }
+    return { ...documentArg, _id: identityValue };
+  }
+
+  /** True when stored documents need SmartData-owned preparation before a write. */
+  private get preparesStoredDocuments(): boolean {
+    return Boolean(
+      this.modelSchema?.ordinaryPersistence || this.modelSchema?.identityAsDocumentId,
+    );
+  }
+
   public async insert(
     dbDocArg: T & SmartDataDbDoc<T, unknown>,
     opts?: { session?: TSmartdataOrdinarySession }
   ): Promise<any> {
-    const preparedObject = this.modelSchema?.ordinaryPersistence
+    const preparedObject = this.preparesStoredDocuments
       ? this.prepareOrdinaryInsert(await dbDocArg.createSavableObject()) : undefined;
     return this.runWithOrdinarySession(
       opts?.session,
@@ -2049,7 +2211,7 @@ export class SmartdataCollection<T> {
         `insertMany requires a non-empty document batch for collection "${this.collectionName}".`,
       );
     }
-    const preparedObjects: any[] | undefined = this.modelSchema?.ordinaryPersistence ? [] : undefined;
+    const preparedObjects: any[] | undefined = this.preparesStoredDocuments ? [] : undefined;
     if (preparedObjects) {
       for (const dbDocArg of dbDocsArg) {
         preparedObjects.push(this.prepareOrdinaryInsert(await dbDocArg.createSavableObject()));
@@ -2118,14 +2280,23 @@ export class SmartdataCollection<T> {
       const first = documentsArg[0];
       await this.markUniqueIndexes(first.uniqueIndexes);
       await this.createRegularIndexes(first.regularIndexes || []);
+      // A document keyed by its identity is addressed through _id, and the
+      // seeded body must not repeat the immutable primary key: MongoDB derives
+      // it from the filter's equality condition on the insert branch.
+      const documentIdIdentity = this.modelSchema?.identityAsDocumentId === identityFieldArg;
       try {
-        const result = await this.mongoDbCollection.bulkWrite(prepared.map((document) => ({
-          updateOne: {
-            filter: { [identityFieldArg]: document[identityFieldArg] },
-            update: { $setOnInsert: document },
-            upsert: true,
-          },
-        })), { ordered: false, session: rawSessionArg, timeoutMS: optsArg.timeoutMS });
+        const result = await this.mongoDbCollection.bulkWrite(prepared.map((document) => {
+          const { _id: storedId, ...body } = document as Record<string, unknown>;
+          return {
+            updateOne: {
+              filter: documentIdIdentity
+                ? { _id: storedId as plugins.mongodb.Condition<plugins.mongodb.ObjectId> }
+                : { [identityFieldArg]: document[identityFieldArg] },
+              update: { $setOnInsert: documentIdIdentity ? body : document },
+              upsert: true,
+            },
+          };
+        }), { ordered: false, session: rawSessionArg, timeoutMS: optsArg.timeoutMS });
         if (result.upsertedCount + result.matchedCount !== prepared.length) {
           throw new SmartdataPersistenceError('unsupported_operation',
             'insertManyIfAbsent requires an acknowledged result for every identity.');