put item

Author: lucasmafra

package.json

@@ -16,7 +16,8 @@
   "license": "ISC",
   "dependencies": {
     "aws-sdk": "git+https://[email protected]/lucasmafra/aws-sdk-js.git",
-    "commander": "^2.11.0"
+    "commander": "^2.11.0",
+    "dynamodb-marshaler": "^2.0.0"
   },
   "devDependencies": {
     "@types/chai": "^4.1.2",

playground/test.ts

@@ -67,9 +67,23 @@ async function queryOnIndexTest() {
     console.log('QUERY ON INDEX', users.data)
 }
 
+async function putTest() {
+    const user = await  User
+                        .save({
+                            email: '[email protected]',
+                            name: 'Maithe',
+                            companyName: 'AppSimples',
+                            hiringDate: 1520748807000,
+                            age: 22,
+                        })
+                        .execute()
+    console.log('PUT', user.data)
+}
+
 scanTest()
 queryTest()
 getTest()
 batchGetTest()
 scanOnIndexTest()
 queryOnIndexTest()
+putTest()

src/chaining/common/index.ts

@@ -13,6 +13,7 @@ export abstract class Chaining<ChainingKind> {
 }
 
 export * from './with-attributes'
+export * from './with-condition'
 export * from './paginate'
 export * from './filter'
 export * from './all-results'

src/chaining/common/with-condition.ts

@@ -0,0 +1,23 @@
+import Expression from '../../expressions/expression'
+import { Chaining, CommonWithAttributes } from './'
+
+export type WithConditionType = 'withCondition'
+
+export interface WithCondition {
+    expression: Expression
+}
+
+export class CommonWithCondition<ChainingKind> extends Chaining<ChainingKind | WithConditionType> {
+
+    private _withCondition: WithCondition
+
+    constructor(
+        withCondition: WithCondition,
+        currentStack: Array<Chaining<ChainingKind>>,
+    ) {
+        super('withCondition', currentStack)
+        this._withCondition = withCondition
+        this._stack.push(this)
+    }
+
+}

src/chaining/save/batch-write/execute.ts

@@ -0,0 +1,28 @@
+import { DynamoDB } from 'aws-sdk'
+import { buildGetInput, get} from '../../../database-operations/get'
+import { EntitySchema } from '../../../schema'
+import { Chaining, Filter, Paginate, WithAttributes } from '../../common'
+import { GetChainingKind } from './'
+import { Get } from './get'
+
+function extractFromStack<KeySchema>(stack: Array<Chaining<GetChainingKind>>): {
+    getMetadata: Get<KeySchema>,
+    withAttributes?: WithAttributes,
+} {
+    const getMetadata = (stack[0] as any)._get
+    let withAttributes: WithAttributes | undefined
+    for (const current of stack) {
+        switch ((current as any)._kind) {
+            case 'withAttributes': withAttributes = (current as any)._withAttributes
+        }
+    }
+    return { getMetadata, withAttributes }
+}
+
+export function execute<Entity, KeySchema>(
+    stack: Array<Chaining<GetChainingKind>>,
+) {
+    const { getMetadata, withAttributes } = extractFromStack<KeySchema>(stack)
+    const getInput = buildGetInput(getMetadata, withAttributes)
+    return get<Entity, KeySchema>(getInput)
+}

src/chaining/save/batch-write/get.ts

@@ -0,0 +1,39 @@
+import { EntitySchema } from '../../../schema'
+import { Chaining } from '../../common'
+import { GetChainingKind } from './'
+import { execute } from './execute'
+import { DynamoGetWithAttributes } from './with-attributes'
+
+export type GetType = 'get'
+
+export interface Get<KeySchema> {
+    schema: EntitySchema,
+    key: KeySchema,
+}
+
+export class DynamoGet<
+    Entity,
+    KeySchema
+> extends Chaining<GetChainingKind> {
+
+    protected _get: Get<KeySchema>
+
+    constructor(
+        get: Get<KeySchema>,
+    ) {
+        super('get')
+        this._get = get
+        this._stack.push(this)
+    }
+
+    public withAttributes<K extends keyof Entity>(attributes: K[]) {
+        return new DynamoGetWithAttributes<Pick<Entity, K>, KeySchema>(
+            attributes, this._stack,
+        )
+    }
+
+    public execute() {
+        return execute<Entity, KeySchema>(this._stack)
+    }
+
+}

src/chaining/save/batch-write/index.ts

@@ -0,0 +1,6 @@
+import { WithAttributesType } from '../../common'
+import { GetType } from './get'
+
+export type GetChainingKind = GetType | WithAttributesType
+
+export { DynamoGet } from './get'

src/chaining/save/batch-write/with-attributes.ts

@@ -0,0 +1,22 @@
+import { randomGenerator } from '../../../expressions/random-generator'
+import { Chaining, CommonWithAttributes } from '../../common'
+import { GetChainingKind } from './'
+import { execute } from './execute'
+
+export class DynamoGetWithAttributes<
+    Entity,
+    KeySchema
+> extends CommonWithAttributes<GetChainingKind> {
+
+    constructor(
+        attributes: string[],
+        currentStack: Array<Chaining<GetChainingKind>>,
+    ) {
+        super(attributes, currentStack)
+    }
+
+    public execute() {
+        return execute<Entity, KeySchema>(this._stack)
+    }
+
+}

src/chaining/save/index.ts

@@ -0,0 +1 @@
+export * from './put'

src/chaining/save/put/execute.ts

@@ -0,0 +1,28 @@
+import { DynamoDB } from 'aws-sdk'
+import { buildPutInput, put } from '../../../database-operations/put'
+import { EntitySchema } from '../../../schema'
+import { Chaining, WithCondition } from '../../common'
+import { PutChainingKind } from './'
+import { Put } from './put'
+
+function extractFromStack<Entity>(stack: Array<Chaining<PutChainingKind>>): {
+    putMetadata: Put<Entity>,
+    withCondition?: WithCondition,
+} {
+    const putMetadata = (stack[0] as any)._put
+    let withCondition: WithCondition | undefined
+    for (const current of stack) {
+        switch ((current as any)._kind) {
+            case 'withCondition': withCondition = (current as any)._withCondition
+        }
+    }
+    return { putMetadata, withCondition }
+}
+
+export function execute<Entity>(
+    stack: Array<Chaining<PutChainingKind>>,
+) {
+    const { putMetadata, withCondition } = extractFromStack<Entity>(stack)
+    const putInput = buildPutInput(putMetadata, withCondition)
+    return put<Entity>(putInput)
+}

src/chaining/save/put/index.ts

@@ -0,0 +1,6 @@
+import { WithConditionType } from '../../common'
+import { PutType } from './put'
+
+export type PutChainingKind = PutType | WithConditionType
+
+export { DynamoPut } from './put'

src/chaining/save/put/put.ts

@@ -0,0 +1,36 @@
+import Expression from '../../../expressions/expression'
+import { EntitySchema } from '../../../schema'
+import { Chaining } from '../../common'
+import { PutChainingKind } from './'
+import { execute } from './execute'
+import { DynamoPutWithCondition } from './with-condition'
+export type PutType = 'put'
+
+export interface Put<Entity> {
+    schema: EntitySchema,
+    item: Entity,
+}
+
+export class DynamoPut<
+    Entity
+> extends Chaining<PutChainingKind> {
+
+    protected _put: Put<Entity>
+
+    constructor(
+        put: Put<Entity>,
+    ) {
+        super('put')
+        this._put = put
+        this._stack.push(this)
+    }
+
+    public withCondition(expression: Expression) {
+        return new DynamoPutWithCondition<Entity>({ expression }, this._stack)
+    }
+
+    public execute() {
+        return execute<Entity>(this._stack)
+    }
+
+}

src/chaining/save/put/with-condition.ts

@@ -0,0 +1,21 @@
+import { Chaining, CommonWithCondition, WithCondition } from '../../common'
+import { PutChainingKind } from './'
+import { execute } from './execute'
+export type PutType = 'put'
+
+export class DynamoPutWithCondition<
+    Entity
+> extends CommonWithCondition<PutChainingKind> {
+
+    constructor(
+        withCondition: WithCondition,
+        currentStack: Array<Chaining<PutChainingKind>>,
+    ) {
+        super(withCondition, currentStack)
+    }
+
+    public execute() {
+        return execute<Entity>(this._stack)
+    }
+
+}

src/database-operations/batch-write/build-get-input.ts

@@ -0,0 +1,20 @@
+import { DynamoDB } from 'aws-sdk'
+import { WithAttributes } from '../../chaining/common'
+import { Get } from '../../chaining/find/get/get'
+import { EntitySchema } from '../../schema'
+import { buildKey, projectionExpression } from '../helpers'
+
+export function buildGetInput<KeySchema>(
+    get: Get<KeySchema>,
+    withAttributes?: WithAttributes,
+): DynamoDB.GetItemInput {
+    const input: DynamoDB.GetItemInput = {
+        TableName: get.schema.tableName,
+        Key: buildKey(get.key),
+    }
+    if (withAttributes) {
+        input.ProjectionExpression = projectionExpression(withAttributes.attributes)
+        input.ExpressionAttributeNames = withAttributes.expressionAttributeNames
+    }
+    return input
+}

src/database-operations/batch-write/get.ts

@@ -0,0 +1,24 @@
+import { DynamoDB } from 'aws-sdk'
+import DynamoToPromise from '../dynamo-to-promise'
+
+const dynamoPromise = new DynamoToPromise(new DynamoDB.DocumentClient({
+    region: 'localhost',
+    endpoint: 'http://localhost:8000',
+}))
+
+export interface GetResult<TableModel, KeySchema> {
+    data: TableModel
+}
+
+export async function get<
+    Entity, KeySchema
+>(getInput: DynamoDB.GetItemInput): Promise<GetResult<Entity, KeySchema>> {
+    const getOutput = await dynamoPromise.getItem(getInput)
+    if (!getOutput.Item) {
+        throw new Error('ItemNotFound')
+    }
+    const result: GetResult<Entity, KeySchema> = {
+        data: getOutput.Item as any,
+    }
+    return result
+}

src/database-operations/batch-write/index.ts

@@ -0,0 +1,2 @@
+export * from './build-get-input'
+export * from './get'

src/database-operations/put/build-put-input.ts

@@ -0,0 +1,23 @@
+import { DynamoDB } from 'aws-sdk'
+const marshalItem = require('dynamodb-marshaler').marshalItem
+import { WithCondition } from '../../chaining/common/with-condition'
+import { Put } from '../../chaining/save/put/put'
+import Expression from '../../expressions/expression'
+import { resolveExpression } from '../../expressions/resolve-expression'
+import { EntitySchema } from '../../schema'
+export function buildPutInput<Table>(
+    put: Put<Table>,
+    conditionalExpression?: WithCondition,
+): DynamoDB.PutItemInput {
+    const input: DynamoDB.PutItemInput = {
+        TableName: put.schema.tableName,
+        Item: marshalItem(put.item),
+    }
+    if (conditionalExpression) {
+        const expression = resolveExpression((conditionalExpression.expression as any).stack)
+        input.ConditionExpression = expression.resolvedExpression
+        input.ExpressionAttributeNames = expression.expressionAttributeNames
+        input.ExpressionAttributeValues = expression.expressionAttributeValues
+    }
+    return input
+}

src/database-operations/put/index.ts

@@ -0,0 +1,2 @@
+export * from './build-put-input'
+export * from './put'

src/database-operations/put/put.ts

@@ -0,0 +1,21 @@
+import { DynamoDB } from 'aws-sdk'
+import DynamoToPromise from '../dynamo-to-promise'
+
+const dynamoPromise = new DynamoToPromise(new DynamoDB.DocumentClient({
+    region: 'localhost',
+    endpoint: 'http://localhost:8000',
+}))
+
+export interface PutResult<TableModel> {
+    data: TableModel
+}
+
+export async function put<
+    Entity
+>(putInput: DynamoDB.PutItemInput): Promise<PutResult<Entity>> {
+    const putOutput = await dynamoPromise.put(putInput)
+    const result: PutResult<Entity> = {
+        data: putInput.Item as any,
+    }
+    return result
+}