@lossless.org/client 1.1.0 → 1.2.0

package/ts/nosqldb/classes.collectiontopology.ts

@@ -298,6 +298,31 @@ export const getExpectedCollectionTopologyForSchema = (
   });
 };
 
+/**
+ * @internal A single-field ascending unique index is what makes a declared
+ * identity globally constraining, whatever the index is called.
+ */
+export const isIdentityIndexFor = (
+  indexArg: INormalizedCollectionModelSchema['indexes'][number],
+  fieldArg: string,
+): boolean =>
+  indexArg.options.unique === true &&
+  indexArg.key.length === 1 &&
+  indexArg.key[0][0] === fieldArg &&
+  indexArg.key[0][1] === 1;
+
+/**
+ * @internal Name of the unique index that backs an identity field in a bound
+ * schema. Index-creation fallbacks resolve it here so that a model naming its
+ * own backing index never gets a second unique index over the same key.
+ */
+export const getIdentityIndexName = (
+  schemaArg: INormalizedCollectionModelSchema | undefined,
+  fieldArg: string,
+): string | undefined =>
+  schemaArg?.indexes.find((indexArg) => isIdentityIndexFor(indexArg, fieldArg))
+    ?.name;
+
 const normalizeActualIndex = (
   rawIndexArg: unknown,
 ): IActualIndexNormalization => {

package/ts/nosqldb/classes.doc.ts

@@ -78,6 +78,7 @@ interface ISmartdataDecoratorMetadata extends DecoratorMetadataObject {
   saveableProperties?: string[];
   uniqueIndexes?: string[];
   identityValueTypes?: Record<string, TSmartdataIdentityValueType>;
+  identityIndexNames?: Record<string, string>;
   regularIndexes?: Array<{field: string, options: IIndexOptions}>;
   compoundIndexes?: Array<{
     name: string;
@@ -98,6 +99,14 @@ export interface IUnIOptions {
    * non-empty string. Numeric identities require an explicit opt-in.
    */
   valueType?: TSmartdataIdentityValueType;
+  /**
+   * Name of the single-field ascending unique index that backs this identity.
+   * Defaults to `<field>_1`. A collection whose unique index was created by a
+   * migration under another name declares that name here: MongoDB refuses a
+   * second index over the same key, so without it the identity could not be
+   * declared at all.
+   */
+  indexName?: string;
 }
 
 /**
@@ -323,11 +332,13 @@ export function unI(optionsArg: IUnIOptions = {}) {
     typeof optionsArg !== 'object'
     || optionsArg === null
     || Array.isArray(optionsArg)
-    || Object.keys(optionsArg).some((keyArg) => keyArg !== 'valueType')
+    || Object.keys(optionsArg).some(
+      (keyArg) => keyArg !== 'valueType' && keyArg !== 'indexName',
+    )
   ) {
     throw new SmartdataPersistenceError(
       'invalid_configuration',
-      'unI options must be an object containing only valueType.',
+      'unI options must be an object containing only valueType and indexName.',
     );
   }
   const valueType = optionsArg.valueType ?? 'string';
@@ -337,6 +348,25 @@ export function unI(optionsArg: IUnIOptions = {}) {
       'unI valueType must be "string" or "positiveSafeInteger".',
     );
   }
+  const indexName = optionsArg.indexName;
+  if (indexName !== undefined) {
+    if (
+      typeof indexName !== 'string'
+      || indexName.trim().length === 0
+      || indexName.includes('\0')
+    ) {
+      throw new SmartdataPersistenceError(
+        'invalid_configuration',
+        'unI indexName must be a non-empty index name.',
+      );
+    }
+    if (indexName === '_id_') {
+      throw new SmartdataPersistenceError(
+        'invalid_configuration',
+        'unI indexName "_id_" is reserved for MongoDB.',
+      );
+    }
+  }
   return (value: undefined, context: ClassFieldDecoratorContext) => {
     if (context.kind !== 'field') {
       throw new Error('unI can only decorate fields');
@@ -365,6 +395,24 @@ export function unI(optionsArg: IUnIOptions = {}) {
       );
     }
     metadata.identityValueTypes![propName] = valueType;
+    // An unnamed declaration writes no entry, so a subclass that redeclares
+    // the identity without a name keeps the index the base class named. Only
+    // a second, different name is a contradiction worth refusing.
+    if (indexName !== undefined) {
+      if (
+        !Object.prototype.hasOwnProperty.call(metadata, 'identityIndexNames')
+      ) {
+        metadata.identityIndexNames = { ...(metadata.identityIndexNames || {}) };
+      }
+      const existingIndexName = metadata.identityIndexNames![propName];
+      if (existingIndexName && existingIndexName !== indexName) {
+        throw new SmartdataPersistenceError(
+          'invalid_configuration',
+          `Identity field "${propName}" has divergent indexName declarations.`,
+        );
+      }
+      metadata.identityIndexNames![propName] = indexName;
+    }
 
     // Also mark as saveable
     if (!Object.prototype.hasOwnProperty.call(metadata, 'saveableProperties')) {

package/ts/nosqldb/classes.exactpersistence.ts

@@ -4,6 +4,7 @@ import { assertBsonWithoutMutation } from './classes.bsonassertion.js';
 import { getOrdinaryPersistencePolicy } from './classes.ordinarypersistence.js';
 
 import type { SmartdataCollection } from './classes.collection.js';
+import { getIdentityIndexName } from './classes.collectiontopology.js';
 import { registerCollectionReconnectHandler } from './classes.collectionlifecycle.js';
 import type { SmartdataSession } from './classes.session.js';
 import { acquireSmartdataSession } from './classes.session.js';
@@ -1024,10 +1025,17 @@ export class SmartdataExactCollection<
     const missingUniqueIndexes = this.uniqueIndexes.filter(
       (uniqueIndexArg) => !this.collection.uniqueIndexes.includes(uniqueIndexArg),
     );
+    const boundSchema = this.collection.getBoundModelSchema();
     for (const uniqueIndex of missingUniqueIndexes) {
       await targetCollectionArg.createIndex(
         { [uniqueIndex]: 1 },
-        { unique: true, name: `${uniqueIndex}_1` },
+        {
+          unique: true,
+          // A model may back its identity with a differently named index;
+          // creating `<field>_1` would duplicate that key.
+          name: getIdentityIndexName(boundSchema, uniqueIndex)
+            ?? `${uniqueIndex}_1`,
+        },
       );
     }
 

package/ts/nosqldb/classes.persistence.ts

@@ -43,6 +43,23 @@ export const isMongoDuplicateKeyError = (
   );
 };
 
+/**
+ * MongoDB refuses an index whose key or name collides with an existing one:
+ * `IndexOptionsConflict` when an equivalent index already carries another
+ * name, `IndexKeySpecsConflict` when the name is taken by another key.
+ */
+export const isMongoIndexConflictError = (
+  errorArg: unknown,
+): errorArg is plugins.mongodb.MongoServerError => {
+  return (
+    errorArg instanceof plugins.mongodb.MongoServerError &&
+    (errorArg.code === 85 ||
+      errorArg.code === 86 ||
+      errorArg.codeName === 'IndexOptionsConflict' ||
+      errorArg.codeName === 'IndexKeySpecsConflict')
+  );
+};
+
 export const normalizeOrdinaryPersistenceError = (
   errorArg: unknown,
   messageArg: string,