Do not create a type index if we only have one model type in the table.

Author: autopulated

lib/table.js

@@ -105,7 +105,7 @@ class Table {
                 AttributeDefinitions: uniqueRequiredAttributes,
                 KeySchema: tableKeySchema,
                 BillingMode: 'PAY_PER_REQUEST',
-                GlobalSecondaryIndexes: requiredIndexes.map(x => x.index),
+                ...(requiredIndexes.length && {GlobalSecondaryIndexes: requiredIndexes.map(x => x.index)})
             }));
         } catch (err) {
             // ResourceInUseException is only thrown if the table already exists
@@ -272,8 +272,11 @@ class Table {
     }
 
     #requiredIndexes() {
-        const requiredIndexes = [
-            {
+        const requiredIndexes = [];
+        // Only require the type index if we have multiple schemas in this
+        // table, to support single-model tables mode efficiently:
+        if (this.#models.size > 1) {
+            requiredIndexes.push({
                 index: {
                     // The built-in type index,
                     IndexName: 'type',
@@ -289,8 +292,8 @@ class Table {
                 ],
                 hashKey: this.#typeFieldName,
                 sortKey: this.#idFieldName
-            }
-        ];
+            });
+        }
         for (const schema of this.#models.keys()) {
             requiredIndexes.push(...schema[kSchemaIndices]);
         }
@@ -301,6 +304,15 @@ class Table {
         const uniqueRequiredAttributes = [];
         const attributeTypes = new Map();
         const indexNames = new Map();
+
+        // The table hash key is always the ID field, and while it is not an
+        // index field, it is a required attribute type that we need to check
+        // compatibility with:
+        allRequiredIndexes = [{
+            requiredAttributes: [
+                { AttributeName: this.#idFieldName, AttributeType: 'S' },
+            ]
+        }].concat(allRequiredIndexes);
         for (const {index, requiredAttributes} of allRequiredIndexes) {
             for (const {AttributeName, AttributeType} of requiredAttributes) {
                 // store all the types we encounter for each attribute name for comparison:
@@ -326,21 +338,23 @@ class Table {
                     throw new Error(`Schema(s) "${offendingSchemas.join(', ')}" define incompatible types (${offendingDefinitions.join(',')}) for ".${AttributeName}" in index(es) "${offendingIndexes.join(', ')}".`);
                 }
             }
-            if(!indexNames.has(index.IndexName)) {
-                indexNames.set(index.IndexName, index);
-            } else if(!indexDescriptionsEqual(index, indexNames.get(index.IndexName))) {
-                let offendingSchemas = [];
-                let offendingDefinitions = [];
-                for (const schema of this.#models.keys()) {
-                    for (const schemaIndex of schema[kSchemaIndices]) {
-                        if (schemaIndex.index.IndexName === index.IndexName) {
-                            offendingSchemas.push(schema.name);
-                            offendingDefinitions.push(schemaIndex.index);
-                            break;
+            if (index) {
+                if(!indexNames.has(index.IndexName)) {
+                    indexNames.set(index.IndexName, index);
+                } else if(!indexDescriptionsEqual(index, indexNames.get(index.IndexName))) {
+                    let offendingSchemas = [];
+                    let offendingDefinitions = [];
+                    for (const schema of this.#models.keys()) {
+                        for (const schemaIndex of schema[kSchemaIndices]) {
+                            if (schemaIndex.index.IndexName === index.IndexName) {
+                                offendingSchemas.push(schema.name);
+                                offendingDefinitions.push(schemaIndex.index);
+                                break;
+                            }
                         }
                     }
+                    throw new Error(`Schema(s) "${offendingSchemas.join(', ')}" define incompatible versions of index "${index.IndexName}".`);
                 }
-                throw new Error(`Schema(s) "${offendingSchemas.join(', ')}" define incompatible versions of index "${index.IndexName}".`);
             }
         }
         return {uniqueRequiredAttributes};

readme.md

@@ -777,7 +777,7 @@ const result = await Comment.queryOne({
 **Querying for a two properties** named `field1`, and `field2`, equal to
 values `"v1"` and `2`. This requires an index that either:
  * has `field1` as its hash key, and `field2` as its sort key, or:
- * has `field2` as its hash key, and `field2` as its sort key.
+ * has `field2` as its hash key, and `field1` as its sort key.
 
 Note that this query may return multiple results, since neither hash key nor
 sort key values in global secondary indexes are necessarily unique.
@@ -1016,7 +1016,8 @@ console.log(await Comment.queryMany({ section: 'thread-123' }))
 
 ### Caveats for Indexes
 A dynamoDB table supports up to 20 global secondary indexes in the default
-quota. DynamoDM creates one built-in index on the id field.
+quota. DynamoDM creates one built-in index on the type field, if a table
+contains multiple types of models.
 
 All documents in the same table share the same indexes, and all documents that
 include a field that is used as the hash key of an index will be included in

test/multi.js

@@ -36,6 +36,7 @@ tap.test('crud with schema from separate module', async t => {
         additionalProperties: false
     });
     const Thing = table.model(ThingSchema);
+    table.model(DynamoDM2.Schema('other'));
 
     await table.ready();