Rework of the Shape type system

examples/lib/data-lake.ts

@@ -5,20 +5,23 @@ import { Core, Lambda } from 'punchcard';
 
 import * as Analytics from '@punchcard/data-lake';
 
-import { integer, string, timestamp, char, array, } from 'punchcard/lib/shape';
+import { Record, string, array, integer, timestamp, Shape } from '@punchcard/shape';
+import { char } from '@punchcard/shape-glue';
 
 export const app = new Core.App();
 const stack = app.root.map(app => new core.Stack(app, 'data-lake'));
 
+class DataPoint extends Record({
+  key: string,
+  value: char(10),
+  data_points: array(integer),
+  timestamp
+}) {}
+
 // create a schema to describe our data
 const dataPoints = new Analytics.Schema({
   schemaName: 'data_points',
-  shape: {
-    key: string(),
-    value: char(10),
-    data_points: array(integer()),
-    timestamp
-  },
+  shape: DataPoint,
   timestampField: 'timestamp'
 });
 
@@ -53,12 +56,10 @@ Lambda.schedule(stack, 'DummyDataPoints', {
   depends: lake.pipelines.dataPoints.stream.writeAccess(),
   schedule: Schedule.rate(Duration.minutes(1)),
 }, async (_, stream) => {
-  await stream.putRecord({
-    Data: {
-      key: 'key',
-      data_points: [0, 1, 2],
-      timestamp: new Date(),
-      value: 'some-value'
-    }
-  });
+  await stream.putRecord(new DataPoint({
+    key: 'key',
+    data_points: [0, 1, 2],
+    timestamp: new Date(),
+    value: 'some-value'
+  }));
 });

examples/lib/dynamodb.ts

@@ -5,75 +5,63 @@ import { Schedule } from '@aws-cdk/aws-events';
 
 import { Core, DynamoDB, Lambda } from 'punchcard';
 
-import { array, dynamic, string, integer, struct } from 'punchcard/lib/shape';
+import { array, string, integer, Record, any, Shape, Minimum } from '@punchcard/shape';
 import { Build } from 'punchcard/lib/core/build';
 
 export const app = new Core.App();
 
 const stack = app.root.map(app => new cdk.Stack(app, 'invoke-function'));
 
-type Item = typeof Item;
-const Item = {
-  id: string(),
-  count: integer({
-    minimum: 0
-  }),
-  name: string(),
-  array: array(string()),
-  struct: struct({
-    key: string(),
-    number: integer()
-  }),
-  any: dynamic
-}
+class Struct extends Record({
+  key: string,
+  number: integer
+}) {}
+
+class Item extends Record({
+  id: string,
+  count: integer
+    .apply(Minimum(0)),
+  name: string,
+  array: array(string),
+  struct: Struct,
+  any
+}) {}
 
 // the type can be inferred, but we explicitly define them to illustrate how it works
 // 'id' is the partitionKey, undefined is the sortKey (no sort key), and Item is the attributes of data in the table
-const table: DynamoDB.Table<'id', undefined, Item> = new DynamoDB.Table(stack, 'hash-table', {
-  partitionKey: 'id',
-  attributes: Item,
-  tableProps: Build.of({
-    billingMode: BillingMode.PAY_PER_REQUEST
-  })
-});
+const table = new DynamoDB.Table(stack, 'hash-table', Item, 'id', Build.of({
+  billingMode: BillingMode.PAY_PER_REQUEST
+}));
 
 // 'count' is the sortKey in this case
-const sortedTable: DynamoDB.Table<'id', 'count', Item> = new DynamoDB.Table(stack, 'sorted-table', {
-  partitionKey: 'id',
-  sortKey: 'count',
-  attributes: Item,
-  tableProps: Build.of({
-    billingMode: BillingMode.PAY_PER_REQUEST
-  })
-});
+const sortedTable = new DynamoDB.Table(stack, 'sorted-table', Item, ['id', 'count'], Build.of({
+  billingMode: BillingMode.PAY_PER_REQUEST
+}));
 
 // call the incrementer function from another Lambda Function
 Lambda.schedule(stack, 'Caller', {
   depends: Core.Dependency.concat(table.readWriteAccess(), sortedTable.readAccess()),
   schedule: Schedule.rate(Duration.minutes(1)),
 }, async (_, [table, sortedTable]) => {
-  await table.get({
-    id: 'id',
-  });
+  await table.get('id');
 
-  await table.put({
+  await table.putIf(new Item({
     // the item is type-safe and well structured
-    item: {
-      id: 'id',
-      count: 1,
-      name: 'name',
-      any: {
-        a: 'value'
-      },
-      array: ['some', 'values'],
-      struct: {
-        key: 'value',
-        number: 1
-      }
+    id: 'id',
+    count: 1,
+    name: 'name',
+    any: {
+      a: 'value'
     },
+    array: ['some', 'values'],
+    struct: new Struct({
+      key: 'value',
+      number: 1
+    })
+  }), item =>
     // condition expressions are generated with a nice type-safe DSL
-    if: item => item.count.eq(0)
-      .or(DynamoDB.not(item.count.greaterThan(0))) 
+     item.count.equals(0)
+      // .or(DynamoDB.not(item.count.greaterThan(0))) 
       .and(
         // string
         item.name.equals('name'),
@@ -82,67 +70,58 @@ Lambda.schedule(stack, 'Caller', {
         // arrays
         item.array.length.greaterThan(0),
         item.array.equals(['a', 'b']),
-        item.array.at(0).equals('a'))
+        item.array[0].equals('a'))
       .and(
         // structs
-        item.struct.eq({
+        item.struct.equals(new Struct({
           key: 'value',
           number: 1
-        }),
+        })),
         item.struct.fields.key.equals('value'),
         item.struct.fields.key.length.greaterThanOrEqual(5),
         item.struct.fields.number.lessThan(0))
       .and(
         // the dynamic type is casted to a static type before building a condition expression
         item.any
-          .as(string())
-          .lessThan('value'),
-        item.any.as(integer()).greaterThanOrEqual(1),
-        item.any.as(array(integer())).equals([1]),
-        item.any.as(array(integer())).at(0).lessThanOrEqual(1),
-        item.any.as(struct({
-          key: string()
-        })).eq({
-          key: 'value'
-        }))
-  });
+          .as(string)
+          .equals('value'),
+        item.any.as(integer).greaterThanOrEqual(1),
+        item.any.as(array(integer)).equals([1]),
+        item.any.as(array(integer))[0].lessThanOrEqual(1),
+        item.any.as(Shape.of(Struct)).equals(new Struct({
+          key: 'value',
+          number: 1
+        })))
+  );
 
-  await table.update({
-    key: {
-      id: 'id',
-    },
-    actions: item => [
-      // strings
-      item.name.set('name'), // item.name = 'name'
-      // numbers
-      item.count.set(1), // item.count = 1
-      item.count.decrement(1), // item.count -- or item.count -= 1
-      item.count.increment(1), // item.count += 1
-      item.count.set(item.count.plus(1)), // explicitly: item.count += 1
-
-      // structs
-      item.count.set(item.struct.fields.number), // item.count = item.struct.number
-      item.struct.set({ // item.struct = { 
-        key: 'value',   //   key: 'value',
-        number: 1       //   number: 1
-      }),               // }
-      item.struct.fields.key.set('value'), // item.struct.key = 'value'
+  await table.update('id', item => [
+    // strings
+    item.name.set('name'), // item.name = 'name'
+    // numbers
+    item.count.set(1), // item.count = 1
+    item.count.decrement(1), // item.count -- or item.count -= 1
+    item.count.increment(1), // item.count += 1
+    item.count.set(item.count.plus(1)), // explicitly: item.count += 1
+
+    // structs
+    item.count.set(item.struct.fields.number), // item.count = item.struct.number
+    item.struct.set(new Struct({ // item.struct = { 
+      key: 'value',              //   key: 'value',
+      number: 1                  //   number: 1
+    })),                         // }
+    item.struct.fields.key.set('value'), // item.struct.key = 'value'
 
-      // arrays
-      item.array.set(['some', 'values']), // item.array = ['some', 'values']
-      item.name.set(item.array.at(0)), // item.name = item.array[0]
-      item.array.at(1).set('value'), // item.array[0] = 'value'
-      item.array.at(1).set(item.name), // item.array[0] = item.name
-    ],
-    if: item => DynamoDB.attribute_exists(item.id),
-  });
+    // arrays
+    item.array.set(['some', 'values']), // item.array = ['some', 'values']
+    item.name.set(item.array[0]), // item.name = item.array[0]
+    item.array[1].set('value'), // item.array[0] = 'value'
+    item.array[1].set(item.name), // item.array[0] = item.name
+  ], //item => DynamoDB.attribute_exists(item.id),
+  );
 
   // sorted tables can be queried
-  await sortedTable.query({
-    key: {
-      id: 'id',
-      count: DynamoDB.greaterThan(1)
-    },
+  await sortedTable.query(['id', count => count.greaterThan(1)], {
+
     filter: item => item.array.length.equals(item.count) // item.array.lenth === item.count
   });
 });

examples/lib/hello-world.ts

@@ -1,10 +1,62 @@
 import cdk = require('@aws-cdk/core');
 import { Schedule } from '@aws-cdk/aws-events';
-import { Core, Lambda } from 'punchcard';
+import { Core, Lambda, DynamoDB, SQS } from 'punchcard';
+import { string, integer, Record, MaxLength } from '@punchcard/shape';
+import { Dependency } from 'punchcard/lib/core';
+
+import json = require('@punchcard/shape-json');
 
 export const app = new Core.App();
 const stack = app.root.map(app => new cdk.Stack(app, 'hello-world'));
 
+/**
+ * State of a counter.
+ */
+class Counter extends Record({
+
+  /**
+   * Rate Key documentation goes here.
+   */
+  key: string
+    .apply(MaxLength(1)),
+
+  count: integer
+}) {}
+
+const hashTable = new DynamoDB.Table(stack, 'Table', Counter, 'key');
+
+const queue = new SQS.Queue(stack, 'queue', {
+  shape: Counter
+});
+
+// schedule a Lambda function to increment counts in DynamoDB and send SQS messages with each update.
 Lambda.schedule(stack, 'MyFunction', {
-  schedule: Schedule.rate(cdk.Duration.minutes(1))
-}, async() => console.log('Hello, World!'));
+  schedule: Schedule.rate(cdk.Duration.minutes(1)),
+  depends: Dependency.concat(
+    hashTable.readWriteAccess(),
+    queue.sendAccess()),
+}, async(_, [hashTable, queue]) => {
+  console.log('Hello, World!');
+
+  let rateType = await hashTable.get('hash key');
+  if (rateType === undefined) {
+    rateType = new Counter({
+      key: 'key',
+      count: 0
+    })
+    await hashTable.put(rateType);
+  }
+
+  await queue.sendMessage(rateType);
+  await hashTable.update('key', _ => [
+    _.count.increment()
+  ]);
+});
+
+// print out a message for each SQS message received
+queue.messages().forEach(stack, 'ForEachMessage', {}, async (msg) => {
+  console.log(`received message with key ${msg.key} and count ${msg.count}`);
+});
+
+
+