electrodb 2.2.2 → 2.2.4

package/README.md

@@ -3419,6 +3419,8 @@ operation     | example                               | result
 `value`       | `value(rent, amount)`                 | `:rent1`                                                              | Create a reference to a particular value, can be passed to other operation that allows leveraging existing attribute values in calculating new values
 `ifNotExists` | `ifNotExists(rent, amount)`           | `#rent = if_not_exists(#rent, :rent0)`                                | Update a property's value only if that property doesn't yet exist on the record
 
+> _NOTE: Usage of `name` and `value` operations allow for some escape hatching in the case that a custom operation needs to be expressed. When used however, ElectroDB loses the context necessary to validate the expression created by the user. In practical terms, this means the `validation` function/regex on the impacted attribute will not be called._
+
 Example:
 ```javascript
 await StoreLocations
@@ -5635,12 +5637,16 @@ let stores = await StoreLocations.malls({mallId}).query({buildingId, storeId}).g
 ElectroDB using advanced dynamic typing techniques to automatically create types based on the configurations in your model. Changes to your model will automatically change the types returned by ElectroDB.
 
 ## Custom Attributes
-If you have a need for a custom attribute type (beyond those supported by ElectroDB) you can use the the export function `createCustomAttribute`. This function takes an attribute definition and allows you to specify a custom typed attribute with ElectroDB:
+If you have a need for a custom attribute type (beyond those supported by ElectroDB) you can use the the export function `CustomAttributeType` or `OpaquePrimitiveType`. These functions can be passed a generic and that allow you to specify a custom attribute with ElectroDB:
+
+### CustomAttributeType
+This function allows for a narrowing of ElectroDB's `any` type, which does not enforce runtime type checks. This can be useful for expressing complex attribute types.
 
-> _NOTE: creating a custom type, ElectroDB will enforce attribute constraints based on the attribute definition provided, but will yield typing control to the user. This may result in some mismatches between your typing and the constraints enforced by ElectroDB._
+The function `CustomAttributeType` takes one argument, which is the "base" type of the attribute. For complex objects and arrays, the base object would be "any" but you can also use a base type like "string", "number", or "boolean" to accomplish (Opaque Keys)[#opaque-keys] which can be used as Composite Attributes.
 
+In this example we accomplish a complex union type:
 ```typescript
-import { Entity, createCustomAttribute } from 'electrodb';
+import { Entity, CustomAttributeType } from 'electrodb';
 
 const table = 'workplace_table';
 
@@ -5654,7 +5660,6 @@ type PersonnelRole = {
     contractEndDate: number;
 };
 
-
 const person = new Entity({
     model: {
         entity: 'personnel',
@@ -5665,9 +5670,10 @@ const person = new Entity({
         id: {
             type: 'string'
         },
-        role: createCustomAttribute<PersonnelRole>({
+        role: {
+            type: CustomAttributeType<PersonnelRole>('any'),
             required: true,
-        }),
+        },
     },
     indexes: {
         record: {
@@ -5684,6 +5690,61 @@ const person = new Entity({
 }, { table });
 ```
 
+[![Try it out!](https://img.shields.io/badge/electrodb-try_out_this_example_›-%23f9bd00?style=for-the-badge&logo=amazondynamodb&labelColor=1a212a)](https://electrodb.fun/?ssl=3&ssc=29&pln=37&pc=2#code/JYWwDg9gTgLgBAbzgUQHY2DAngGjgYQFcBnGCEAQRhimACNCYBTAFSzCbgF84AzKcnADkTADZMAxjQgATOkIDcAKCUSIqUnACqqYAEdCTANJMsAZSwg6EUQC44hXQc7FL10XAC8cC1ZsAKAEplbA4UcFEILCYmAEkAES84UlpUAHM4ADJEAG0dfUMTczcbAF17AENULC5lVXVNfOcKNKZfd3tHApcSj292gOClUM4AWXUYAAsk1EIrJigs3KbDFrbe8rgqmrqRuAAFBeJ1VDEAJRtObwQlODu4EfsRCKiYxVv70grYeIrmexSwHSynucCYqBkv2YAH4ATQgWllDwAD6ID53R7CNToKAVKTQd6g7E0PEwMwwb4wKFMOGpRHouDE3FSNCQv405Lw4FKWoqbGaCl0cRJIQAd2gAGswKI8UwAPqC8TveoaeAcKDHVAzJiilDoTBYfw3UEgWRiezG0H3cEYbBPdWa06iIQ4Bmg4gLABuwAkHLFkulspdbvunqOwHUTwAjEIGVxXaC-vCGMxiBaQ3cmC9onEZOmrQWHuwOURSOQqMnGKxiwAeZDZmIJAB8-iEgPSQkCGe4CcLWelrwW+cLoMxba5aVjI-j3d4wA1MAAchUQBzLSOMcWnu3J72N3AoEwDPOmHmHlBDHurTORzLSMvV8P92Od8H93dD8fD2eaJfuzfCwqVonw3MdZnmKAp0LACCyAuJUHGdBJjTNF3zgUU-gkSZ7ByIQ4KEUorxHTFSzIShqFoFNqw4GtEKmFshHAugFk7IjCw9GB7CCLwm0QGCNxkJheAqQhRE4uBuM8XiEH4kdWnE-w5XsOjJjwBA4K4C04PsJiFi4QIeNQtD7kPGBCCgLVRj+SYADpeEiaB-DguAAHo4CjAAmIY0K4f82I-S4QOIrcCBIMiK0oqs2Bow4NROc5LgY7ZWP-OMryBQSAA8mBQ9crUPNQoDPPKRzACUgvfOcxDPIQyrfYy7jUcAIGITAOVw-tIhzSDSm7UFZPY8qjIaqrRBq4gJXqhqmsgVr-jgDqG1zAj-OvVL+p5NSHgqIVOH0up+XgCRD3ZWIZCSIJ7HrAccwSQy8tM8ytQAAwAEgQakbNQCBRSCLhnq2Yhwhuxt4iRFQHXUBkbOOph2SNbsXLc4gOAkYAKg8CAwAqZw4GAc6Rm7TrBzO+xYdOmQglW4nuqefYqkICQ0aB-ZgAALzZiopqtOcFwfP19kmYBRGAMBudBO8lxXP0ADEoCwcX7m0uAPIAVlWgRxAqgsxxpt5VvdCkfnZaMAE5TYAdgAWgABg8q2PNNxWC3BNl5qEKNzdNq3PKtgBmGNVt8-qu1BGy0ggIJoamcF-EPYhRPgKThqtJGDyYMyLKLDggYx448fAUlT27ePE5smQ-gqGy4NiBCJmQuNAiAA)
+
+### Opaque Keys
+If you use Opaque Keys for identifiers or other primitive types, you can use the function `CustomAttributeType` and pass it the primitive base type of your key ('string', 'number', 'boolean'). This can be useful to gain more precise control over which properties can be used as entity identifiers, create unique unit types, etc.
+
+```
+import { Entity, CustomAttributeType } from 'electrodb';
+
+const UniqueKeySymbol: unique symbol = Symbol();
+type EmployeeID = string & {[UniqueKeySymbol]: any};
+
+const UniqueAgeSymbol: unique symbol = Symbol();
+type Month = number & {[UniqueAgeSymbol]: any};
+
+const table = 'workplace_table';
+
+const person = new Entity({
+    model: {
+        entity: 'personnel',
+        service: 'workplace',
+        version: '1'
+    },
+    attributes: {
+        employeeId: {
+            type: CustomAttributeType<EmployeeID>('string')
+        },
+        firstName: {
+            type: 'string',
+            required: true,
+        },
+        lastName: {
+            type: 'string',
+            required: true,
+        },
+        ageInMonths: {
+            type: CustomAttributeType<Month>('number')
+        }
+    },
+    indexes: {
+        record: {
+            pk: {
+                field: 'pk',
+                composite: ['employeeId']
+            },
+            sk: {
+                field: 'sk',
+                composite: [],
+            }
+        }
+    }
+}, { table });
+```
+
+[![Try it out!](https://img.shields.io/badge/electrodb-try_out_this_example_›-%23f9bd00?style=for-the-badge&logo=amazondynamodb&labelColor=1a212a)](https://electrodb.fun/?ssl=3&ssc=29&pln=37&pc=2#code/JYWwDg9gTgLgBAbzgUQHY2DAngGjgYQFcBnGCEAQRhimACNCYBTAFSzCbgF84AzKcnADkTADZMAxjQgATOkIDcAKCUSIqUnACqqYAEdCTANJMsAZSwg6EUQC44hXQc7FL10XAC8cC1ZsAKAEplbA4UcFEILCYmAEkAES84UlpUAHM4ADJEAG0dfUMTczcbAF17AENULC5lVXVNfOcKNKZfd3tHApcSj292gOClUM4AWXUYAAsk1EIrJigs3KbDFrbe8rgqmrqRuAAFBeJ1VDEAJRtObwQlODu4EfsRCKiYxVv70grYeIrmexSwHSynucCYqBkv2YAH4ATQgWllDwAD6ID53R7CNToKAVKTQd6g7E0PEwMwwb4wKFMOGpRHouDE3FSNCQv405Lw4FKWoqbGaCl0cRJIQAd2gAGswKI8UwAPqC8TveoaeAcKDHVAzJiilDoTBYfw3UEgWRiezG0H3cEYbBPdWa06iIQ4Bmg4gLABuwAkHLFkulspdbvunqOwHUTwAjEIGVxXaC-vCGMxiBaQ3cmC9onEZOmrQWHuwOURSOQqMnGKxiwAeZDZmIJAB8-iEgPSQkCGe4CcLWelrwW+cLoMxba5aVjI-j3d4wA1MAAchUQBzLSOMcWnu3J72N3AoEwDPOmHmHlBDHurTORzLSMvV8P92Od8H93dD8fD2eaJfuzfCwqVonw3MdZnmKAp0LACCyAuJUHGdBJjTNF3zgUU-gkSZ7ByIQ4KEUorxHTFSzIShqFoFNqw4GtEKmFshHAugFk7IjCw9GB7CCLwm0QGCNxkJheAqQhRE4uBuM8XiEH4kdWnE-w5XsOjJjwBA4K4C04PsJiFi4QIeNQtD7kPGBCCgLVRj+SYADpeEiaB-DguAAHo4CjAAmIY0K4f82I-S4QOIrcCBIMiK0oqs2Bow4NROc5LgY7ZWP-OMryBQSAA8mBQ9crUPNQoDPPKRzACUgvfOcxDPIQyrfYy7jUcAIGITAOVw-tIhzSDSm7UFZPY8qjIaqrRBq4gJXqhqmsgVr-jgDqG1zAj-OvVL+p5NSHgqIVOH0up+XgCRD3ZWIZCSIJ7HrAccwSQy8tM8ytQAAwAEgQakbNQCBRSCLhnq2Yhwhuxt4iRFQHXUBkbOOph2SNbsXLc4gOAkYAKg8CAwAqZw4GAc6Rm7TrBzO+xYdOmQglW4nuqefYqkICQ0aB-ZgAALzZiopqtOcFwfP19kmYBRGAMBudBO8lxXP0ADEoCwcX7m0uAPIAVlWgRxAqgsxxpt5VvdCkfnZaMAE5TYAdgAWgABg8q2PNNxWC3BNl5qEKNzdNq3PKtgBmGNVt8-qu1BGy0ggIJoamcF-EPYhRPgKThqtJGDyYMyLKLDggYx448fAUlT27ePE5smQ-gqGy4NiBCJmQuNAiAA)
+
 ## Exported Types
 
 The following types are exported for easier use while using ElectroDB with TypeScript. The naming convention for the types include three different kinds:

package/index.d.ts

@@ -987,16 +987,7 @@ export type ServiceQueryRecordsGo<ResponseType, Options = QueryOptions> = <T = R
 
 export type QueryRecordsGo<ResponseType, Options = QueryOptions> = <T = ResponseType>(options?: Options) => Promise<{ data: T, cursor: string | null }>;
 
-export type UpdateRecordGo<ResponseType> = <T = ResponseType, Options extends UpdateQueryOptions = UpdateQueryOptions>(options?: Options) => 
-        Options extends infer O
-            ? 'response' extends keyof O
-                ? O['response'] extends 'all_new'
-                    ? Promise<{data: T}>
-                    : O['response'] extends 'all_old'
-                        ? Promise<{data: T}>
-                        : Promise<{data: Partial<T>}>
-                : Promise<{data: Partial<T>}>
-            : never;
+export type UpdateRecordGo<ResponseType> = <T = ResponseType, Options extends UpdateQueryOptions = UpdateQueryOptions>(options?: Options) => Promise<{data: Partial<T>}>
 
 export type PutRecordGo<ResponseType, Options = QueryOptions> = <T = ResponseType>(options?: Options) => Promise<{ data: T }>;
 
@@ -1454,16 +1445,23 @@ type StaticAttribute = {
     readonly field?: string;
 }
 
-type CustomAttribute<T extends any = any> = {
-    readonly type: "custom";
-    readonly [CustomAttributeSymbol]: T;
+type CustomAttributeTypeName<T> = { readonly [CustomAttributeSymbol]: T };
+
+type OpaquePrimitiveTypeName<T extends string | number | boolean> =
+    T extends string ? 'string' & { readonly [OpaquePrimitiveSymbol]: T }
+    : T extends number ? 'number' & { readonly [OpaquePrimitiveSymbol]: T }
+    : T extends boolean ? 'boolean' & { readonly [OpaquePrimitiveSymbol]: T }
+    : never;
+
+type CustomAttribute = {
+    readonly type: CustomAttributeTypeName<any> | OpaquePrimitiveTypeName<any>;
     readonly required?: boolean;
     readonly hidden?: boolean;
     readonly readOnly?: boolean;
-    readonly get?: (val: T, item: any) => T | undefined | void;
-    readonly set?: (val?: T, item?: any) => T | undefined | void;
-    readonly default?: T | (() => T);
-    readonly validate?: ((val: T) => boolean) | ((val: T) => void) | ((val: T) => string | void);
+    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;
     readonly watch?: ReadonlyArray<string> | "*";
 };
@@ -1621,7 +1619,9 @@ type PartialDefinedKeys<T> = {
 }
 
 export type ItemAttribute<A extends Attribute> =
-    A extends CustomAttribute<infer T>
+    A['type'] extends OpaquePrimitiveTypeName<infer T>
+        ? T
+        : A['type'] extends CustomAttributeTypeName<infer T>
         ? T
     : A["type"] extends infer R
         ? R extends "string" ? string
@@ -1661,8 +1661,10 @@ export type ItemAttribute<A extends Attribute> =
         : never
 
 export type ReturnedAttribute<A extends Attribute> =
-    A extends CustomAttribute<infer T>
-    ? T
+    A['type'] extends OpaquePrimitiveTypeName<infer T>
+        ? T
+        : A['type'] extends CustomAttributeTypeName<infer T>
+        ? T
     : A["type"] extends infer R
         ? R extends "static" ? never
         : R extends "string" ? string
@@ -1716,7 +1718,9 @@ export type ReturnedAttribute<A extends Attribute> =
         : never
 
 export type CreatedAttribute<A extends Attribute> =
-    A extends CustomAttribute<infer T>
+    A['type'] extends OpaquePrimitiveTypeName<infer T>
+        ? T
+        : A['type'] extends CustomAttributeTypeName<infer T>
         ? T
         : A["type"] extends infer R
         ? R extends "static" ? never
@@ -1779,8 +1783,10 @@ export type CreatedItem<A extends string, F extends string, C extends string, S
 }
 
 export type EditableItemAttribute<A extends Attribute> =
-    A extends CustomAttribute<infer T>
-    ? T
+    A['type'] extends OpaquePrimitiveTypeName<infer T>
+        ? T
+        : A['type'] extends CustomAttributeTypeName<infer T>
+        ? T
     : A extends ReadOnlyAttribute
         ? never
         : A["type"] extends infer R
@@ -1826,7 +1832,9 @@ export type EditableItemAttribute<A extends Attribute> =
         : never
 
 export type UpdatableItemAttribute<A extends Attribute> =
-    A extends CustomAttribute<infer T>
+    A['type'] extends OpaquePrimitiveTypeName<infer T>
+        ? T
+        : A['type'] extends CustomAttributeTypeName<infer T>
         ? T
         : A extends ReadOnlyAttribute
         ? never
@@ -1888,7 +1896,9 @@ export type UpdatableItemAttribute<A extends Attribute> =
         : never
 
 export type RemovableItemAttribute<A extends Attribute> =
-    A extends CustomAttribute<infer T>
+    A['type'] extends OpaquePrimitiveTypeName<infer T>
+        ? T
+        : A['type'] extends CustomAttributeTypeName<infer T>
         ? T
         : A extends ReadOnlyAttribute | RequiredAttribute
         ? never
@@ -2072,7 +2082,7 @@ export type RemoveItem<A extends string, F extends string, C extends string, S e
 export type AppendItem<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> =
     {
         [
-        P in keyof ItemTypeDescription<A,F,C,S> as ItemTypeDescription<A,F,C,S>[P] extends 'list' | 'any' | 'custom'
+        P in keyof ItemTypeDescription<A,F,C,S> as ItemTypeDescription<A,F,C,S>[P] extends 'list' | 'any' | 'custom' | CustomAttributeTypeName<any>
             ? P
             : never
         ]?: P extends keyof SetItem<A,F,C,S>
@@ -2083,7 +2093,7 @@ export type AppendItem<A extends string, F extends string, C extends string, S e
 export type AddItem<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> =
     {
         [
-        P in keyof ItemTypeDescription<A,F,C,S> as ItemTypeDescription<A,F,C,S>[P] extends 'number' | 'any' | 'set' | 'custom'
+        P in keyof ItemTypeDescription<A,F,C,S> as ItemTypeDescription<A,F,C,S>[P] extends 'number' | 'any' | 'set' | 'custom' | CustomAttributeTypeName<any> | OpaquePrimitiveTypeName<number>
             ? P
             : never
         ]?: P extends keyof SetItem<A,F,C,S>
@@ -2094,7 +2104,7 @@ export type AddItem<A extends string, F extends string, C extends string, S exte
 export type SubtractItem<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> =
     {
         [
-        P in keyof ItemTypeDescription<A,F,C,S> as ItemTypeDescription<A,F,C,S>[P] extends 'number' | 'any' | 'custom'
+        P in keyof ItemTypeDescription<A,F,C,S> as ItemTypeDescription<A,F,C,S>[P] extends 'number' | 'any' | 'custom' | OpaquePrimitiveTypeName<number>
             ? P
             : never
         ]?: P extends keyof SetItem<A,F,C,S>
@@ -2105,7 +2115,7 @@ export type SubtractItem<A extends string, F extends string, C extends string, S
 export type DeleteItem<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> =
     {
         [
-        P in keyof ItemTypeDescription<A,F,C,S> as ItemTypeDescription<A,F,C,S>[P] extends 'any' | 'set' | 'custom'
+        P in keyof ItemTypeDescription<A,F,C,S> as ItemTypeDescription<A,F,C,S>[P] extends 'any' | 'set' | 'custom' | CustomAttributeTypeName<any>
             ? P
             : never
         ]?: P extends keyof SetItem<A,F,C,S>
@@ -2116,6 +2126,7 @@ export type DeleteItem<A extends string, F extends string, C extends string, S e
 export declare const WhereSymbol: unique symbol;
 export declare const UpdateDataSymbol: unique symbol;
 export declare const CustomAttributeSymbol: unique symbol;
+export declare const OpaquePrimitiveSymbol: unique symbol;
 
 export type WhereAttributeSymbol<T extends any> =
         { [WhereSymbol]: void }
@@ -2317,6 +2328,16 @@ type CustomAttributeDefinition<T> = {
     readonly validate?: ((val: T) => boolean) | ((val: T) => void) | ((val: T) => string | void);
     readonly field?: string;
     readonly watch?: ReadonlyArray<string> | "*";
-}
+};
 
-declare function createCustomAttribute<T>(definition?: CustomAttributeDefinition<T>): CustomAttribute<T>;
+/** @depricated use 'CustomAttributeType' or 'OpaquePrimitiveType' instead */
+declare function createCustomAttribute<T, A extends Readonly<CustomAttributeDefinition<T>> = Readonly<CustomAttributeDefinition<T>>>(definition?: A): A & { type: CustomAttributeTypeName<T> };
+
+declare function CustomAttributeType<T>(
+    base: T extends string ? 'string'
+        : T extends number ? 'number'
+        : T extends boolean ? 'boolean'
+        : 'any'
+): T extends string | number | boolean
+    ? OpaquePrimitiveTypeName<T>
+    : CustomAttributeTypeName<T>;

package/index.js

@@ -1,12 +1,13 @@
 const { Entity } = require("./src/entity");
 const { Service } = require("./src/service");
-const { createCustomAttribute } = require('./src/schema');
+const { createCustomAttribute, CustomAttributeType } = require('./src/schema');
 const { ElectroError, ElectroValidationError, ElectroUserValidationError, ElectroAttributeValidationError } = require('./src/errors');
 
 module.exports = {
     Entity,
     Service,
-    createCustomAttribute,
     ElectroError,
+    CustomAttributeType,
+    createCustomAttribute,
     ElectroValidationError,
 };

package/package.json

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

package/src/clauses.js

@@ -309,7 +309,16 @@ let clauses = {
 				for (const path of Object.keys(state.query.update.refs)) {
 					const operation = state.query.update.impacted[path];
 					const attribute = state.query.update.refs[path];
-					entity.model.schema.checkOperation(attribute, operation);
+					// note: keyValue will be empty if the user used `name`/`value` operations
+					// because it becomes hard to know how they are used and which attribute
+					// should validate the change. This is an edge case however, this change
+					// still improves on the existing implementation.
+					const keyValue = state.query.update.paths[path] || {};
+					if (!attribute) {
+						throw new e.ElectroAttributeValidationError(path, `Attribute "${path}" does not exist on model.`);
+					}
+
+					entity.model.schema.checkOperation(attribute, operation, keyValue.value);
 				}
 				return state;
 			} catch(err) {

package/src/entity.js

@@ -229,7 +229,7 @@ class Entity {
 		if (Array.isArray(facets)) {
 			return this._makeChain(index, this._clausesWithFilters, clauses.index).batchGet(facets);
 		} else {
-			return this._makeChain(index, clauses, clauses.index).get(facets);
+			return this._makeChain(index, this._clausesWithFilters, clauses.index).get(facets);
 		}
 	}
 

package/src/filters.js

@@ -16,6 +16,7 @@ class FilterFactory {
 			case MethodTypes.update:
 			case MethodTypes.patch:
 			case MethodTypes.delete:
+			case MethodTypes.get:
 				return ExpressionTypes.ConditionExpression
 			default:
 				return ExpressionTypes.FilterExpression

package/src/schema.js

@@ -1,4 +1,4 @@
-const { CastTypes, ValueTypes, KeyCasing, AttributeTypes, AttributeMutationMethods, AttributeWildCard, PathTypes, TableIndex } = require("./types");
+const { CastTypes, ValueTypes, KeyCasing, AttributeTypes, AttributeMutationMethods, AttributeWildCard, PathTypes, TableIndex, ItemOperations } = require("./types");
 const AttributeTypeNames = Object.keys(AttributeTypes);
 const ValidFacetTypes = [AttributeTypes.string, AttributeTypes.number, AttributeTypes.boolean, AttributeTypes.enum];
 const e = require("./errors");
@@ -1389,16 +1389,6 @@ class Schema {
 		return record;
 	}
 
-	checkOperation(attribute, operation) {
-		if (!attribute) {
-			throw new e.ElectroAttributeValidationError(path, `Attribute "${path}" does not exist on model.`);
-		} else if (attribute.required && operation === 'remove') {
-			throw new e.ElectroAttributeValidationError(attribute.path, `Attribute "${attribute.path}" is Required and cannot be removed`);
-		} else if (attribute.readOnly) {
-			throw new e.ElectroAttributeValidationError(attribute.path, `Attribute "${attribute.path}" is Read-Only and cannot be updated`);
-		}
-	}
-
 	checkRemove(paths = []) {
 		for (const path of paths) {
 			const attribute = this.traverser.getPath(path);
@@ -1413,6 +1403,18 @@ class Schema {
 		return paths;
 	}
 
+	checkOperation(attribute, operation, value) {
+		if (attribute.required && operation === ItemOperations.remove) {
+			throw new e.ElectroAttributeValidationError(attribute.path, `Attribute "${attribute.path}" is Required and cannot be removed`);
+		} else if (attribute.readOnly) {
+			throw new e.ElectroAttributeValidationError(attribute.path, `Attribute "${attribute.path}" is Read-Only and cannot be updated`);
+		}
+
+		return value === undefined
+			? undefined
+			: attribute.getValidate(value);
+	}
+
 	checkUpdate(payload = {}) {
 		let record = {};
 		for (let [path, attribute] of this.traverser.getAll()) {
@@ -1464,10 +1466,19 @@ function createCustomAttribute(definition = {}) {
 	};
 }
 
+function CustomAttributeType(base) {
+	const supported = ['string', 'number', 'boolean', 'any'];
+	if (!supported.includes(base)) {
+		throw new Error(`OpaquePrimitiveType only supports base types: ${u.commaSeparatedString(supported)}`);
+	}
+	return base;
+}
+
 module.exports = {
 	Schema,
 	Attribute,
 	SetAttribute,
 	CastTypes,
+	CustomAttributeType,
 	createCustomAttribute,
 };

package/src/where.js

@@ -74,6 +74,7 @@ class WhereFactory {
 		case MethodTypes.patch:
 		case MethodTypes.delete:
 		case MethodTypes.remove:
+		case MethodTypes.get:
 			return ExpressionTypes.ConditionExpression
 		default:
 			return ExpressionTypes.FilterExpression