electrodb 2.10.7 → 2.12.0

package/index.d.ts

@@ -3216,6 +3216,27 @@ export interface MapAttribute {
   readonly watch?: ReadonlyArray<string> | "*";
 }
 
+export interface NestedCustomListAttribute {
+  readonly type: "list";
+  readonly items: CustomAttribute;
+  readonly required?: boolean;
+  readonly hidden?: boolean;
+  readonly readOnly?: boolean;
+  readonly get?: (
+      val: Array<any>,
+      item: any,
+  ) => Array<string> | undefined | void;
+  readonly set?: (
+      val?: Array<any>,
+      item?: any,
+  ) => Array<any> | undefined | void;
+  readonly default?: Array<any> | (() => Array<any>);
+  readonly validate?:
+      | ((val: Array<any>) => boolean)
+      | ((val: Array<any>) => void)
+      | ((val: Array<any>) => string | void);
+}
+
 export interface NestedStringListAttribute {
   readonly type: "list";
   readonly items: {
@@ -3354,6 +3375,28 @@ export interface NestedMapListAttribute {
   readonly field?: string;
 }
 
+export interface NestedAnyListAttribute {
+  readonly type: "list";
+  readonly items: NestedAnyAttribute;
+  readonly required?: boolean;
+  readonly hidden?: boolean;
+  readonly readOnly?: boolean;
+  readonly get?: (
+      val: Record<string, any>[],
+      item: any,
+  ) => Record<string, any>[] | undefined | void;
+  readonly set?: (
+      val?: Record<string, any>[],
+      item?: any,
+  ) => Record<string, any>[] | undefined | void;
+  readonly default?: Record<string, any>[] | (() => Record<string, any>[]);
+  readonly validate?:
+      | ((val: Record<string, any>[]) => boolean)
+      | ((val: Record<string, any>[]) => void)
+      | ((val: Record<string, any>[]) => string | void);
+  readonly field?: string;
+}
+
 export interface MapListAttribute {
   readonly type: "list";
   readonly items: NestedMapAttribute;
@@ -3377,6 +3420,52 @@ export interface MapListAttribute {
   readonly watch?: ReadonlyArray<string> | "*";
 }
 
+export interface CustomListAttribute {
+  readonly type: "list";
+  readonly items: NestedCustomAttribute;
+  readonly required?: boolean;
+  readonly hidden?: boolean;
+  readonly readOnly?: boolean;
+  readonly get?: (
+      val: Array<any>,
+      item: any,
+  ) => Array<any> | undefined | void;
+  readonly set?: (
+      val?: Array<any>,
+      item?: any,
+  ) => Array<any> | undefined | void;
+  readonly default?: Array<any> | (() => Array<any>);
+  readonly validate?:
+      | ((val: Array<any>) => boolean)
+      | ((val: Array<any>) => void)
+      | ((val: Array<any>) => string | void);
+  readonly field?: string;
+  readonly watch?: ReadonlyArray<string> | "*";
+}
+
+export interface AnyListAttribute {
+  readonly type: "list";
+  readonly items: NestedAnyAttribute;
+  readonly required?: boolean;
+  readonly hidden?: boolean;
+  readonly readOnly?: boolean;
+  readonly get?: (
+      val: Array<any>,
+      item: any,
+  ) => Array<any> | undefined | void;
+  readonly set?: (
+      val?: Array<any>,
+      item?: any,
+  ) => Array<any> | undefined | void;
+  readonly default?: Array<any> | (() => Array<any>);
+  readonly validate?:
+      | ((val: Array<any>) => boolean)
+      | ((val: Array<any>) => void)
+      | ((val: Array<any>) => string | void);
+  readonly field?: string;
+  readonly watch?: ReadonlyArray<string> | "*";
+}
+
 export interface NestedStringSetAttribute {
   readonly type: "set";
   readonly items: "string";
@@ -3563,13 +3652,6 @@ export interface NumberSetAttribute {
   readonly watch?: ReadonlyArray<string> | "*";
 }
 
-type StaticAttribute = {
-  readonly type: "static";
-  readonly hidden?: boolean;
-  value: string | number | boolean;
-  readonly field?: string;
-};
-
 type CustomAttributeTypeName<T> = { readonly [CustomAttributeSymbol]: T };
 
 type OpaquePrimitiveTypeName<T extends string | number | boolean> =
@@ -3597,6 +3679,21 @@ type CustomAttribute = {
   readonly watch?: ReadonlyArray<string> | "*";
 };
 
+type NestedCustomAttribute = {
+  readonly type: CustomAttributeTypeName<any> | OpaquePrimitiveTypeName<any>;
+  readonly required?: boolean;
+  readonly hidden?: boolean;
+  readonly readOnly?: boolean;
+  readonly get?: (val: any, item: any) => any | undefined | void;
+  readonly set?: (val?: any, item?: any) => any | undefined | void;
+  readonly default?: any | (() => any);
+  readonly validate?:
+      | ((val: any) => boolean)
+      | ((val: any) => void)
+      | ((val: any) => string | void);
+  readonly field?: string;
+};
+
 export type Attribute =
   | BooleanAttribute
   | NumberAttribute
@@ -3609,7 +3706,8 @@ export type Attribute =
   | StringListAttribute
   | NumberListAttribute
   | MapListAttribute
-  | StaticAttribute
+  | AnyListAttribute
+  | CustomListAttribute
   | CustomAttribute
   | EnumNumberSetAttribute
   | EnumStringSetAttribute;
@@ -3621,12 +3719,14 @@ export type NestedAttributes =
   | NestedAnyAttribute
   | NestedMapAttribute
   | NestedStringListAttribute
+  | NestedCustomListAttribute
   | NestedNumberListAttribute
   | NestedMapListAttribute
+  | NestedAnyListAttribute
   | NestedStringSetAttribute
   | NestedNumberSetAttribute
   | NestedEnumAttribute
-  | NestedEnumAttribute
+  | NestedCustomAttribute
   | NestedEnumNumberSetAttribute
   | NestedEnumStringSetAttribute;
 
@@ -3655,8 +3755,10 @@ export interface Schema<A extends string, F extends string, C extends string> {
     [accessPattern: string]: {
       readonly project?: "keys_only";
       readonly index?: string;
+      readonly scope?: string;
       readonly type?: "clustered" | "isolated";
       readonly collection?: AccessPatternCollection<C>;
+      readonly condition?: (composite: Record<string, unknown>) => boolean;
       readonly pk: {
         readonly casing?: "upper" | "lower" | "none" | "default";
         readonly field: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electrodb",
-  "version": "2.10.7",
+  "version": "2.12.0",
   "description": "A library to more easily create and interact with multiple entities and heretical relationships in dynamodb",
   "main": "index.js",
   "scripts": {

package/src/entity.js

@@ -2412,7 +2412,7 @@ class Entity {
           (!attribute || !attribute.indexes || attribute.indexes.length === 0)
         ) {
           /*
-						// this should be considered but is likely overkill at best and unexpected at worst. 
+						// this should be considered but is likely overkill at best and unexpected at worst.
 						// It also is likely symbolic of a deeper issue. That said maybe it could be helpful
 						// in the future? It is unclear, if this were added, whether this should get the
 						// default value and then call the setter on the defaultValue. That would at least
@@ -2880,12 +2880,18 @@ class Entity {
         )}. If a composite attribute is readOnly and cannot be set, use the 'composite' chain method on update to supply the value for key formatting purposes.`,
       );
     }
+
     return complete;
   }
 
   _makeKeysFromAttributes(indexes, attributes) {
     let indexKeys = {};
     for (let [index, keyTypes] of Object.entries(indexes)) {
+      const shouldMakeKeys = this.model.indexes[this.model.translations.indexes.fromIndexToAccessPattern[index]].condition(attributes);
+      if (!shouldMakeKeys) {
+        continue;
+      }
+
       let keys = this._makeIndexKeys({
         index,
         pkAttributes: attributes,
@@ -2912,6 +2918,10 @@ class Entity {
   _makePutKeysFromAttributes(indexes, attributes) {
     let indexKeys = {};
     for (let index of indexes) {
+      const shouldMakeKeys = this.model.indexes[this.model.translations.indexes.fromIndexToAccessPattern[index]].condition(attributes);
+      if (!shouldMakeKeys) {
+        continue;
+      }
       indexKeys[index] = this._makeIndexKeys({
         index,
         pkAttributes: attributes,
@@ -2984,6 +2994,7 @@ class Entity {
       completeFacets.impactedIndexTypes,
       { ...set, ...keyAttributes },
     );
+
     let updatedKeys = {};
     let deletedKeys = [];
     let indexKey = {};
@@ -3027,6 +3038,7 @@ class Entity {
   _getIndexImpact(attributes = {}, included = {}) {
     let includedFacets = Object.keys(included);
     let impactedIndexes = {};
+    let skippedIndexes = new Set();
     let impactedIndexTypes = {};
     let completedIndexes = [];
     let facets = {};
@@ -3034,21 +3046,32 @@ class Entity {
       if (attributes[attribute] !== undefined) {
         facets[attribute] = attributes[attribute];
         indexes.forEach(({ index, type }) => {
-          impactedIndexes[index] = impactedIndexes[index] || {};
-          impactedIndexes[index][type] = impactedIndexes[index][type] || [];
-          impactedIndexes[index][type].push(attribute);
-          impactedIndexTypes[index] = impactedIndexTypes[index] || {};
-          impactedIndexTypes[index][type] =
-            this.model.translations.keys[index][type];
+            impactedIndexes[index] = impactedIndexes[index] || {};
+            impactedIndexes[index][type] = impactedIndexes[index][type] || [];
+            impactedIndexes[index][type].push(attribute);
+            impactedIndexTypes[index] = impactedIndexTypes[index] || {};
+            impactedIndexTypes[index][type] =
+                this.model.translations.keys[index][type];
         });
       }
     }
 
+    for (const indexName in impactedIndexes) {
+      const accessPattern = this.model.translations.indexes.fromIndexToAccessPattern[indexName];
+      const shouldMakeKeys = this.model.indexes[accessPattern].condition({ ...attributes, ...included });
+      if (!shouldMakeKeys) {
+        skippedIndexes.add(indexName);
+      }
+    }
+
     let incomplete = Object.entries(this.model.facets.byIndex)
       .map(([index, { pk, sk }]) => {
         let impacted = impactedIndexes[index];
-        let impact = { index, missing: [] };
-        if (impacted) {
+        let impact = {
+          index,
+          missing: []
+        };
+        if (impacted && !skippedIndexes.has(index)) {
           let missingPk =
             impacted[KeyTypes.pk] && impacted[KeyTypes.pk].length !== pk.length;
           let missingSk =
@@ -3222,6 +3245,9 @@ class Entity {
 
     // If keys are not custom, set the prefixes
     if (!keys.pk.isCustom) {
+      if (tableIndex.scope) {
+        pk = `${pk}_${tableIndex.scope}`;
+      }
       keys.pk.prefix = u.formatKeyCasing(pk, tableIndex.pk.casing);
     }
 
@@ -3842,6 +3868,15 @@ class Entity {
       let indexName = index.index || TableIndex;
       let indexType =
         typeof index.type === "string" ? index.type : IndexTypes.isolated;
+      let indexScope = index.scope || "";
+      if (index.index === undefined && v.isFunction(index.condition)) {
+        throw new e.ElectroError(
+            e.ErrorCodes.InvalidIndexCondition,
+            `The index option 'condition' is only allowed on secondary indexes`,
+        );
+      }
+      let indexCondition = index.condition || (() => true);
+
       if (indexType === "clustered") {
         clusteredIndexes.add(accessPattern);
       }
@@ -3940,14 +3975,16 @@ class Entity {
         }
       }
 
-      let definition = {
+      let definition= {
         pk,
         sk,
-        collection,
         hasSk,
+        collection,
         customFacets,
-        index: indexName,
         type: indexType,
+        index: indexName,
+        scope: indexScope,
+        condition: indexCondition,
       };
 
       indexHasSubCollections[indexName] =

package/src/errors.js

@@ -211,6 +211,12 @@ const ErrorCodes = {
     name: "DuplicateUpdateCompositesProvided",
     sym: ErrorCode,
   },
+  InvalidIndexCondition: {
+    code: 2011,
+    section: "invalid-index-option",
+    name: "InvalidIndexOption",
+    sym: ErrorCode,
+  },
   InvalidAttribute: {
     code: 3001,
     section: "invalid-attribute",

package/src/operations.js

@@ -313,16 +313,13 @@ class AttributeOperationProxy {
           return AttributeOperationProxy.pathProxy(() => {
             const { commit, root, target, builder } = build();
             const attribute = target.getChild(prop);
+            const nestedAny = attribute.type === AttributeTypes.any &&
+                // if the name doesn't match that's because we are nested under 'any'
+                attribute.name !== prop;
             let field;
             if (attribute === undefined) {
-              throw new Error(
-                `Invalid attribute "${prop}" at path "${target.path}.${prop}"`,
-              );
-            } else if (
-              attribute === root &&
-              attribute.type === AttributeTypes.any
-            ) {
-              // This function is only called if a nested property is called. If this attribute is ultimately the root, don't use the root's field name
+              throw new Error(`Invalid attribute "${prop}" at path "${target.path}.${prop}"`);
+            } else if (nestedAny) {
               field = prop;
             } else {
               field = attribute.field;
@@ -331,6 +328,7 @@ class AttributeOperationProxy {
             return {
               root,
               builder,
+              nestedAny,
               target: attribute,
               commit: () => {
                 const paths = commit();

package/src/schema.js

@@ -1496,18 +1496,6 @@ class Schema {
         case AttributeTypes.set:
           normalized[name] = new SetAttribute(definition);
           break;
-        case AttributeTypes.any:
-          if (attributeHasParent) {
-            throw new e.ElectroError(
-              e.ErrorCodes.InvalidAttributeDefinition,
-              `Invalid attribute "${definition.name}" defined within "${
-                parent.parentPath
-              }". Attributes with type ${u.commaSeparatedString([
-                AttributeTypes.any,
-                AttributeTypes.custom,
-              ])} are only supported as root level attributes.`,
-            );
-          }
         default:
           normalized[name] = new Attribute(definition);
       }

package/src/service.js

@@ -584,6 +584,7 @@ class Service {
     let pkFieldMatch = definition.pk.field === providedIndex.pk.field;
     let pkFacetLengthMatch =
       definition.pk.facets.length === providedIndex.pk.facets.length;
+    let scopeMatch = definition.scope === providedIndex.scope;
     let mismatchedFacetLabels = [];
     let collectionDifferences = [];
     let definitionIndexName = u.formatIndexNameForDisplay(definition.index);
@@ -631,6 +632,16 @@ class Service {
       }
     }
 
+    if (!scopeMatch) {
+      collectionDifferences.push(
+          `The index scope value provided "${
+              providedIndex.scope || "undefined"
+          }" does not match established index scope value "${
+              definition.scope || "undefined"
+          }" on index "${providedIndexName}". Index scope options must match across all entities participating in a collection`,
+      );
+    }
+
     if (!isCustomMatchPK) {
       collectionDifferences.push(
         `The usage of key templates the partition key on index ${definitionIndexName} must be consistent across all Entities, some entities provided use template while others do not`,

package/src/validations.js

@@ -119,6 +119,10 @@ const Index = {
           enum: ["string", "number"],
           required: false,
         },
+        scope: {
+          type: "string",
+          required: false,
+        }
       },
     },
     sk: {
@@ -170,6 +174,11 @@ const Index = {
       enum: ["clustered", "isolated"],
       required: false,
     },
+    condition: {
+      type: "any",
+      required: false,
+      format: "isFunction",
+    }
   },
 };