electrodb 3.5.3 → 3.6.0

package/src/schema.js

@@ -1215,7 +1215,7 @@ class Schema {
   constructor(
     properties = {},
     facets = {},
-    { traverser = new AttributeTraverser(), getClient, parent, isRoot } = {},
+    { traverser = new AttributeTraverser(), getClient, parent, isRoot, identifiers } = {},
   ) {
     this._validateProperties(properties, parent);
     let schema = Schema.normalizeAttributes(properties, facets, {
@@ -1223,6 +1223,7 @@ class Schema {
       getClient,
       parent,
       isRoot,
+      identifiers,
     });
     this.getClient = getClient;
     this.attributes = schema.attributes;
@@ -1242,7 +1243,7 @@ class Schema {
   static normalizeAttributes(
     attributes = {},
     facets = {},
-    { traverser, getClient, parent, isRoot } = {},
+    { traverser, getClient, parent, isRoot, identifiers = {} } = {},
   ) {
     const attributeHasParent = !!parent;
     let invalidProperties = [];
@@ -1540,11 +1541,33 @@ class Schema {
       );
     }
 
+    let missingProjectionAttributes = Array.isArray(facets.projections)
+      ? facets.projections.filter(({ name }) => !normalized[name] && !identifiers[name])
+      : [];
+
+    if (missingProjectionAttributes.length > 0) {
+      const byAccessPattern = facets.projections.reduce((groups, { name, accessPattern }) => {
+        groups[accessPattern] = groups[accessPattern] || [];
+        groups[accessPattern].push(name);
+        return groups;
+      }, {});
+
+      const invalidDefinitionsByAccessPattern = Object.entries(byAccessPattern).map(([accessPattern, attributes]) => {
+        return `${accessPattern}: ${u.commaSeparatedString(attributes)}`
+      });
+
+      throw new e.ElectroError(
+        e.ErrorCodes.InvalidProjectionDefinition,
+        `Unknown index projection attributes provided. The following access patterns were defined with unknown attributes: ${u.commaSeparatedString(invalidDefinitionsByAccessPattern, '', '')}`,
+      );
+    }
+
     let missingFacetAttributes = Array.isArray(facets.attributes)
       ? facets.attributes
           .filter(({ name }) => !normalized[name])
           .map((facet) => `"${facet.type}: ${facet.name}"`)
       : [];
+
     if (missingFacetAttributes.length > 0) {
       throw new e.ElectroError(
         e.ErrorCodes.InvalidKeyCompositeAttributeTemplate,

package/src/service.js

@@ -13,7 +13,7 @@ const {
   ElectroInstanceTypes,
   ModelVersions,
   IndexTypes,
-  DataOptions,
+  DataOptions, IndexProjectionOptions,
 } = require("./types");
 const { FilterFactory } = require("./filters");
 const { FilterOperations } = require("./operations");
@@ -369,6 +369,7 @@ class Service {
         record,
         entities: this.entities,
         allowMatchOnKeys: config.ignoreOwnership,
+        config,
       });
 
       if (!entityAlias) {
@@ -460,7 +461,7 @@ class Service {
     const expression = identifiers.expression || "";
 
     let options = {
-      // expressions, // DynamoDB doesnt return what I expect it would when provided with these entity filters
+      // expressions, // DynamoDB doesn't return what I expect it would when provided with these entity filters
       parse: (options, data) => {
         if (options.data === DataOptions.raw) {
           return data;
@@ -497,29 +498,21 @@ class Service {
             hydrator: undefined,
             _isCollectionQuery: false,
             ignoreOwnership: config._providedIgnoreOwnership,
+            attributes: config._providedAttributes,
           });
         }
 
-        // let itemLookup = [];
         let entityItemRefs = {};
-        // let entityResultRefs = {};
         for (let i = 0; i < items.length; i++) {
           const item = items[i];
           for (let entityName in entities) {
             entityItemRefs[entityName] = entityItemRefs[entityName] || [];
             const entity = entities[entityName];
-            // if (entity.ownsKeys({ keys: item })) {
-            if (entity.ownsKeys(item)) {
-              // const entityItemRefsIndex =
+            if (entity.is(item, config)) {
               entityItemRefs[entityName].push({
                 item,
                 itemSlot: i,
               });
-              // itemLookup[i] = {
-              // 	entityName,
-              // 	entityItemRefsIndex,
-              // 	originalItem: item,
-              // }
             }
           }
         }
@@ -536,6 +529,7 @@ class Service {
             hydrator: undefined,
             _isCollectionQuery: false,
             ignoreOwnership: config._providedIgnoreOwnership,
+            attributes: config._providedAttributes,
           });
           unprocessed = unprocessed.concat(results.unprocessed);
           if (results.data.length !== itemRefs.length) {
@@ -575,6 +569,12 @@ class Service {
     };
   }
 
+  _validateIndexProjectionsMatch(definition = {}, providedIndex = {}) {
+    const definitionProjection = definition.projection;
+    const providedProjection = providedIndex.projection;
+    return v.isMatchingProjection(providedIndex.projection, definition.projection)
+  }
+
   _validateCollectionDefinition(definition = {}, providedIndex = {}) {
     let isCustomMatchPK = definition.pk.isCustom === providedIndex.pk.isCustom;
     let isCustomMatchSK =
@@ -594,6 +594,11 @@ class Service {
       providedIndex,
     );
 
+    const matchingProjection = v.isMatchingProjection(
+      providedIndex.projection,
+      definition.projection
+    )
+
     for (
       let i = 0;
       i < Math.max(definition.pk.labels.length, providedIndex.pk.labels.length);
@@ -699,6 +704,12 @@ class Service {
       );
     }
 
+    if (!matchingProjection) {
+      collectionDifferences.push(
+        `The provided projection definition ${u.commaSeparatedString(providedIndex.projection ?? '<undefined>')} does not match the established projection definition ${u.commaSeparatedString(definition.projection)} on index ${providedIndexName}. Index projection definitions must match across all entities participating in a collection`
+      );
+    }
+
     if (!matchingKeyCasing.sk) {
       const definedSk = definition.sk || {};
       const providedSk = providedIndex.sk || {};

package/src/types.js

@@ -335,6 +335,18 @@ const CastKeyOptions = {
   number: "number",
 };
 
+const IndexProjectionOptions = {
+  all: 'all',
+  keys_only: 'keys_only',
+};
+
+const EntityIdentifiers = {
+  entity: "__edb_e__",
+  version: "__edb_v__",
+}
+
+const EntityIdentifierFields = ["__edb_e__", "__edb_v__"];
+
 module.exports = {
   Pager,
   KeyTypes,
@@ -381,4 +393,7 @@ module.exports = {
   UpsertOperations,
   BatchWriteTypes,
   DefaultKeyCasing,
+  IndexProjectionOptions,
+  EntityIdentifiers,
+  EntityIdentifierFields,
 };

package/src/util.js

@@ -79,9 +79,19 @@ function batchItems(arr = [], size) {
 }
 
 function commaSeparatedString(array = [], prefix = '"', postfix = '"') {
+  if (typeof array === 'string') {
+    array = [array];
+  }
   return array.map((value) => `${prefix}${value}${postfix}`).join(", ");
 }
 
+function toDisplayString(value) {
+  if (value === undefined) {
+    return "<undefined>";
+  }
+  return JSON.stringify(value);
+}
+
 function formatStringCasing(str, casing, defaultCase) {
   if (typeof str !== "string") {
     return str;
@@ -275,6 +285,7 @@ module.exports = {
   removeFixings,
   parseJSONPath,
   shiftSortOrder,
+  toDisplayString,
   getFirstDefined,
   getInstanceType,
   getModelVersion,

package/src/validations.js

@@ -1,5 +1,5 @@
 const e = require("./errors");
-const { KeyCasing } = require("./types");
+const { KeyCasing, IndexProjectionOptions } = require("./types");
 
 const Validator = require("jsonschema").Validator;
 Validator.prototype.customFormats.isFunction = function (input) {
@@ -179,6 +179,12 @@ const Index = {
       required: false,
       format: "isFunction",
     },
+    projection: {
+      type: ["array", "string"],
+      items: {
+        type: "string",
+      }
+    },
   },
 };
 
@@ -398,10 +404,25 @@ function isMatchingCasing(casing1, casing2) {
   }
 }
 
+function isValueOrUndefined(received, expected) {
+  return expected === received || received === undefined;
+}
+
+function isMatchingProjection(received, expected) {
+  if (isStringHasLength(received) && isStringHasLength(expected)) {
+    return received === expected;
+  } else if (Array.isArray(received) && Array.isArray(expected)) {
+    return received.length === expected.length && expected.every((attribute) => received.includes(attribute));
+  } else {
+    return isValueOrUndefined(received, IndexProjectionOptions.all) && isValueOrUndefined(expected, IndexProjectionOptions.all)
+  }
+}
+
 module.exports = {
   testModel,
   isFunction,
   stringArrayMatch,
+  isMatchingProjection,
   isMatchingCasing,
   isArrayHasLength,
   isStringHasLength,