electrodb 2.11.0 → 2.12.1

package/README.md

@@ -46,10 +46,10 @@ _Please submit issues/feedback or reach out on Twitter [@tinkertamper](https://t
 - [**Easily Query Across Entities**](https://electrodb.dev/en/core-concepts/single-table-relationships) - Define "collections" to create powerful/idiomatic queries that return multiple entities in a single request.
 - [**Automatic Index Selection**](https://electrodb.dev/en/queries/find/) - Use `.find()` or `.match()` methods to dynamically and efficiently query based on defined sort key structures.
 - [**Simplified Pagination API**](https://electrodb.dev/en/queries/pagination/) - ElectroDB generates url safe cursors for pagination, allows for fine grain automated pagination, and supports async iteration.
-- [**TypeScript Support**](https://electrodb.dev/en/reference/typscript/) - Strong **TypeScript** support for both Entities and Services now in Beta.
+- [**Strong TypeScript Inference**](https://electrodb.dev/en/reference/typescript/) - Strong **TypeScript** support for both Entities and Services now in Beta.
 - [**Query Directly via the Terminal**](https://github.com/tywalch/electrocli#query-taskapp) - Execute queries against your `Entities`, `Services`, `Models` directly from the command line.
 - [**Stand Up Rest Server for Entities**](https://github.com/tywalch/electrocli#query-taskapp) - Stand up a REST Server to interact with your `Entities`, `Services`, `Models` for easier prototyping.
-- [**Use with your existing tables**](https://electrodb.dev/en/core-concepts/use-electrodb-with-existing-table/) - ElectroDB simplifies building DocumentClient parameters, so you can use it with existing tables/data.
+- [**Use with your existing tables**](https://electrodb.dev/en/recipes/use-electrodb-with-existing-table/) - ElectroDB simplifies building DocumentClient parameters, so you can use it with existing tables/data.
 
 ---
 

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;
 
@@ -3658,6 +3758,7 @@ export interface Schema<A extends string, F extends string, C extends 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;
@@ -3813,51 +3914,53 @@ type PartialDefinedKeys<T> = {
 };
 
 export type ItemAttribute<A extends Attribute> =
-  A["type"] extends OpaquePrimitiveTypeName<infer T>
-    ? T
-    : A["type"] extends CustomAttributeTypeName<infer T>
-    ? T
-    : A["type"] extends infer R
-    ? R extends "string"
-      ? string
-      : R extends "number"
-      ? number
-      : R extends "boolean"
-      ? boolean
-      : R extends ReadonlyArray<infer E>
-      ? E
-      : R extends "map"
-      ? "properties" extends keyof A
-        ? {
-            [P in keyof A["properties"]]: A["properties"][P] extends infer M
-              ? M extends Attribute
-                ? ItemAttribute<M>
-                : never
-              : never;
-          }
-        : never
-      : R extends "list"
-      ? "items" extends keyof A
-        ? A["items"] extends infer I
-          ? I extends Attribute
-            ? Array<ItemAttribute<I>>
+  A["type"] extends infer T
+    ? T extends OpaquePrimitiveTypeName<infer OP>
+      ? OP
+      : T extends CustomAttributeTypeName<infer CA>
+      ? CA
+      : T extends infer R
+      ? R extends "string"
+        ? string
+        : R extends "number"
+        ? number
+        : R extends "boolean"
+        ? boolean
+        : R extends ReadonlyArray<infer E>
+        ? E
+        : R extends "map"
+        ? "properties" extends keyof A
+          ? {
+              [P in keyof A["properties"]]: A["properties"][P] extends infer M
+                ? M extends Attribute
+                  ? ItemAttribute<M>
+                  : never
+                : never;
+            }
+          : never
+        : R extends "list"
+        ? "items" extends keyof A
+          ? A["items"] extends infer I
+            ? I extends Attribute
+              ? Array<ItemAttribute<I>>
+              : never
             : never
           : never
-        : never
-      : R extends "set"
-      ? "items" extends keyof A
-        ? A["items"] extends infer I
-          ? I extends "string"
-            ? string[]
-            : I extends "number"
-            ? number[]
-            : I extends ReadonlyArray<infer ENUM>
-            ? ENUM[]
+        : R extends "set"
+        ? "items" extends keyof A
+          ? A["items"] extends infer I
+            ? I extends "string"
+              ? string[]
+              : I extends "number"
+              ? number[]
+              : I extends ReadonlyArray<infer ENUM>
+              ? ENUM[]
+              : never
             : never
           : never
+        : R extends "any"
+        ? any
         : never
-      : R extends "any"
-      ? any
       : never
     : never;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electrodb",
-  "version": "2.11.0",
+  "version": "2.12.1",
   "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 =
@@ -3846,6 +3869,14 @@ class Entity {
       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);
       }
@@ -3953,6 +3984,7 @@ class Entity {
         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/validations.js

@@ -174,6 +174,11 @@ const Index = {
       enum: ["clustered", "isolated"],
       required: false,
     },
+    condition: {
+      type: "any",
+      required: false,
+      format: "isFunction",
+    }
   },
 };