Ensure expressions can be easily created inside a schema-driven data mapper

Author: jeskew

packages/dynamodb-auto-marshaller/src/NumberValue.ts

@@ -3,6 +3,7 @@ const EXPECTED_TAG = `[object ${NUMBER_VALUE_TAG}]`;
 
 export class NumberValue {
     public readonly value: string;
+    public readonly [Symbol.toStringTag] = NUMBER_VALUE_TAG;
 
     constructor(value: string|number) {
         this.value = value.toString().trim();
@@ -20,10 +21,6 @@ export class NumberValue {
         return Number(this.value);
     }
 
-    get [Symbol.toStringTag](): string {
-        return NUMBER_VALUE_TAG;
-    }
-
     static isNumberValue(arg: any): arg is NumberValue {
         return Boolean(arg)
             && Object.prototype.toString.call(arg) === EXPECTED_TAG;

packages/dynamodb-auto-marshaller/src/ObjectSet.ts

@@ -1,4 +1,10 @@
 export abstract class ObjectSet<T> implements Set<T> {
+    /**
+     * Returns the string literal 'Set' for use by Object.prototype.toString.
+     * This allows for identifying Sets without checking constructor identity.
+     */
+    public readonly [Symbol.toStringTag]: 'Set' = 'Set';
+
     protected _values: Array<T> = [];
 
     /**
@@ -110,12 +116,4 @@ export abstract class ObjectSet<T> implements Set<T> {
     [Symbol.iterator](): IterableIterator<T> {
         return this._values[Symbol.iterator]();
     }
-
-    /**
-     * Returns the string literal 'Set' for use by Object.prototype.toString.
-     * This allows for identifying Sets without checking constructor identity.
-     */
-    get [Symbol.toStringTag](): 'Set' {
-        return 'Set';
-    }
 }

packages/dynamodb-expressions/package.json

@@ -20,5 +20,8 @@
   },
   "peerDependencies": {
     "aws-sdk": "^2.7.0"
+  },
+  "dependencies": {
+    "@aws/dynamodb-auto-marshaller": "^0.0.0"
   }
 }

packages/dynamodb-expressions/src/AttributeName.spec.ts

@@ -0,0 +1,116 @@
+import {AttributePath, PathElement} from "./AttributePath";
+
+describe('AttributePath', () => {
+    it('should convert a string path to a list of elements', () => {
+        expect(
+            new AttributePath('foo.bar.baz[3][4][2].fizz[0].buzz[1]').elements
+        ).toEqual([
+            {type: 'AttributeName', name: 'foo'},
+            {type: 'AttributeName', name: 'bar'},
+            {type: 'AttributeName', name: 'baz'},
+            {type: 'ListIndex', index: 3},
+            {type: 'ListIndex', index: 4},
+            {type: 'ListIndex', index: 2},
+            {type: 'AttributeName', name: 'fizz'},
+            {type: 'ListIndex', index: 0},
+            {type: 'AttributeName', name: 'buzz'},
+            {type: 'ListIndex', index: 1},
+        ]);
+    });
+
+    it('should clone an iterable of elements passed to the constructor', () => {
+        const elements: Array<PathElement> = [
+            {type: 'AttributeName', name: 'foo'},
+            {type: 'AttributeName', name: 'bar'},
+            {type: 'AttributeName', name: 'baz'},
+            {type: 'ListIndex', index: 3},
+            {type: 'ListIndex', index: 4},
+            {type: 'ListIndex', index: 2},
+            {type: 'AttributeName', name: 'fizz'},
+            {type: 'ListIndex', index: 0},
+            {type: 'AttributeName', name: 'buzz'},
+            {type: 'ListIndex', index: 1},
+        ];
+        const path = new AttributePath(elements);
+
+        expect(path.elements).toEqual(elements);
+        expect(path.elements).not.toBe(elements);
+
+        elements.shift();
+        expect(path.elements).not.toEqual(elements);
+        expect(path.elements.slice(1)).toEqual(elements);
+    });
+
+    it('should allow attribute names with embedded control characters', () => {
+        expect(new AttributePath('_bracket_\\[_period_\\._backslash_\\\\_unescaped_backslash_\\_.foo').elements).toEqual([
+            {type: 'AttributeName', name: '_bracket_[_period_._backslash_\\_unescaped_backslash_\\_'},
+            {type: 'AttributeName', name: 'foo'},
+        ]);
+    });
+
+    describe('path correctness checking', () => {
+        it(
+            'should throw an error when a path begins with a control character',
+            () => {
+                expect(() => new AttributePath('[1]'))
+                    .toThrowError(/Invalid control character/);
+            }
+        );
+
+        it(
+            'should throw an error when a list index access contains invalid characters',
+            () => {
+                expect(() => new AttributePath('foo[a]'))
+                    .toThrowError(/Invalid array index character/);
+            }
+        );
+
+        it(
+            'should throw an error when a list index access contains no characters',
+            () => {
+                expect(() => new AttributePath('foo[]'))
+                    .toThrowError(/Invalid array index/);
+            }
+        );
+
+        it(
+            'should throw an error when an identifier immediately follows a list index access',
+            () => {
+                expect(() => new AttributePath('foo[1]a'))
+                    .toThrowError(/Bare identifier encountered/);
+            }
+        );
+    });
+
+    describe('::isAttributePath', () => {
+        const ctor = AttributePath;
+
+        afterEach(() => {
+            (AttributePath as any) = ctor;
+        });
+
+        it('should return true for AttributePath objects', () => {
+            expect(
+                AttributePath.isAttributePath(new AttributePath('foo'))
+            ).toBe(true);
+        });
+
+        it('should return false for scalar values', () => {
+            for (let scalar of ['string', 123.234, true, null, void 0]) {
+                expect(AttributePath.isAttributePath(scalar)).toBe(false);
+            }
+        });
+
+        it(
+            'should return true for AttributePaths created with a different instance of the AttributePath constructor',
+            () => {
+                const {isAttributePath} = AttributePath;
+                const path = new AttributePath('foo.bar');
+                (AttributePath as any) = () => path;
+
+                expect(path).not.toBeInstanceOf(AttributePath);
+                expect(isAttributePath(path)).toBe(true);
+            }
+        );
+    });
+});