sensedeep / dynamodb-onetable Goto Github PK

    models: {

        Tenant: {
            pk: { type: String, value: 'tenant#${id}' },
            sk: { type: String, value: 'tenant#' },
            id: { type: String, uuid: true, validate: Match.ulid },
            name: { type: String, required: true, unique: true, validate: Match.name },
            balance: { type: Number, default: 0 },

            //  Search by tenant name or by type
            gs1pk: { type: String, value: 'tenant#' },
            gs1sk: { type: String, value: 'tenant#${name}#${id}' },
        },
}

// API to remove
 await this.Tenant.remove({ id: id });

TS2322: Type '{ indexes: { primary: { hash: string; sort: string; }; gs1: { hash: string; sort: string; follow: boolean; }; }; models: { Account: { pk: { type: StringConstructor; value: string; }; sk: { type: StringConstructor; value: string; }; id: { ...; }; name: { ...; }; status: { ...; }; zip: { ...; }; }; User: { ...; }; }; }' is not assignable to type 'OneSchema'.   Types of property 'models' are incompatible.     Type '{ Account: { pk: { type: StringConstructor; value: string; }; sk: { type: StringConstructor; value: string; }; id: { type: StringConstructor; uuid: boolean; validate: RegExp; }; name: { ...; }; status: { ...; }; zip: { ...; }; }; User: { ...; }; }' is not assignable to type '{ [key: string]: OneModelSchema; }'.       Property 'User' is incompatible with index signature.         Type '{ pk: { type: StringConstructor; value: string; }; sk: { type: StringConstructor; value: string; }; id: { type: StringConstructor; required: boolean; }; ... 8 more ...; gs1sk: { ...; }; }' is not assignable to type 'OneModelSchema'.           Property 'balance' is incompatible with index signature.             Type '{ type: NumberConstructor; default: number; }' is not assignable to type 'OneFieldSchema'.               Types of property 'default' are incompatible.                 Type 'number' is not assignable to type 'string | (() => any) | undefined'.

const schema = {
    indexes: {
        primary: { hash: 'pk', sort: 'sk' },
        ls1: { hash: 'pk', sort: 'ls1sk', project: 'all' },
        ls2: { hash: 'pk', sort: 'ls2sk', project: 'all' },
    },
    models: {
        User: {
            //  Yes, this is a bad PK and puts all users in the same partition
            pk:         { type: String, value: 'user#' },
            sk:         { type: String, value: 'user#${id}' },
            id:         { type: String, uuid: true },
            name:       { type: String },
            email:      { type: String },

            ls1sk:      { type: String, value: 'user#${name}' },
            ls2sk:      { type: String, value: 'user#${_type}' },
        }
    }
}


const table = new Table({
    name: 'LocalTestTable',
    client: Client,
    schema,
})

let result: any = await table.createTable()

schema = {
    indexes: {
      primary: { hash: 'pk', sort: 'sk' },
      gsi1: { hash: 'gsi1pk', sort: 'gsi1sk', project: 'all', follow: true },
      gsi2: { hash: 'gsi2pk', sort: 'gsi2sk', follow: true },
      gsi3: { hash: 'gsi3pk', sort: 'gsi3sk', follow: true },
    },
    models: {
      Mailbox: {
        pk: { type: String, value: 'mail#${id}' },
        sk: { type: String, value: 'mail#${id}' },
        read: { type: Boolean },
        subject: { type: String },
        desc: { type: String },
        body: { type: String },
        userId: { type: String, required: true },
        id: { type: String, required: true, uuid: 'ulid' },
        gsi1pk: {
          type: String,
          value: 'user#${userId}',
        },
        gsi1sk: {
          type: String,
          value: 'mail#${id}',
        },
        gsi2pk: {
          type: String,
          value: 'user#${userId}#unread',
        },
        gsi2sk: {
          type: String,
          value: 'mail#${id}',
        },
        _type: { type: String, filter: false, value: 'Mailbox' },
      },
    },
  };
table = new Table({
    client: client,
    name: 'table-name',
    delimiter: '#',
    schema: schema,
  });
  mailboxModel = this.table.getModel('Mailbox');

return this.mailBoxModel.update(data, {
      log: true,
      updateIndexes: true,
      remove: data.read ? ['gsi2pk', 'gsi2sk'] : [],
    });

TypeError: Cannot read property 'createTable' of undefined
    at Table.<anonymous> (/some-path/2021-05-27-dynamodb-onetable-test/node_modules/dynamodb-onetable/dist/cjs/Table.js:256:46)
    at Generator.next (<anonymous>)
    at /some-path/2021-05-27-dynamodb-onetable-test/node_modules/dynamodb-onetable/dist/cjs/Table.js:11:71
    at new Promise (<anonymous>)
    at __awaiter (/some-path/2021-05-27-dynamodb-onetable-test/node_modules/dynamodb-onetable/dist/cjs/Table.js:7:12)
    at Table.createTable (/some-path/2021-05-27-dynamodb-onetable-test/node_modules/dynamodb-onetable/dist/cjs/Table.js:182:16)
    at _callee$ (/some-path/2021-05-27-dynamodb-onetable-test/dist/index.js:138:26)
    at tryCatch (/some-path/2021-05-27-dynamodb-onetable-test/node_modules/regenerator-runtime/runtime.js:63:40)
    at Generator.invoke [as _invoke] (/some-path/2021-05-27-dynamodb-onetable-test/node_modules/regenerator-runtime/runtime.js:293:22)
    at Generator.next (/some-path/2021-05-27-dynamodb-onetable-test/node_modules/regenerator-runtime/runtime.js:118:21)

(node:87375) UnhandledPromiseRejectionWarning: ValidationException: Attribute name must be specified.

/*
    Demonstrate simple CRUD with OneTable
 */
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import { Table } from "dynamodb-onetable";
//  For AWS V3
import Dynamo from "dynamodb-onetable/Dynamo";

const client = new Dynamo({
  client: new DynamoDBClient({
   // region: "ap-south-1",
    region: "local",
    endpoint:"http://localhost:8000"
  }),
});
/*
    Single-table schema and setup. This is used for general access and by `createTable`
 */
const table = new Table({
  name: "TestCrud",
  client: client,
  uuid: "ulid",
  delimiter: "#",
  logger: true,
  schema: {
    indexes: {
      primary: { hash: "pk", sort: "sk" },
      userName: { hash: "name"},
    },
    models: {
      User: {
        pk: { type: String, value: "user#${id}" },
        sk: { type: String, value: "user#${id}" },
        id: { type: String, uuid: true },
        name: { type: String },
        status: { type: String, default: "active" },
        zip: { type: String }
      },
    },
  },
});
//  Create a model to manage User entities
const User = table.getModel("User");
async function main() {
  if (!(await table.exists())) {
    await table.createTable();
  }
  
}
main();

(base) Kunals-MacBook-Air:crud kunaldeshmukh$ node dist/index1.js 
info Dynamo createTable for "TestCrud" {
    "def": {
        "AttributeDefinitions": [
            {
                "AttributeName": "pk",
                "AttributeType": "S"
            },
            {
                "AttributeName": "sk",
                "AttributeType": "S"
            },
            {
                "AttributeName": "name",
                "AttributeType": "S"
            },
            {
                "AttributeType": "S"
            }
        ],
        "KeySchema": [
            {
                "AttributeName": "pk",
                "KeyType": "HASH"
            },
            {
                "AttributeName": "sk",
                "KeyType": "RANGE"
            }
        ],
        "GlobalSecondaryIndexes": [
            {
                "IndexName": "userName",
                "KeySchema": [
                    {
                        "AttributeName": "name",
                        "KeyType": "HASH"
                    },
                    {
                        "KeyType": "RANGE".  ### HERE IS THE ISSUE - WHERE SORT KEY IS GOING EMPTY.  THIS OBJECT SHOULD NOT BE THERE
                    }
                ],
                "Projection": {
                    "ProjectionType": "ALL"
                }
            }
        ],
        "TableName": "TestCrud",
        "BillingMode": "PAY_PER_REQUEST"
    }
}
(node:87839) UnhandledPromiseRejectionWarning: ValidationException: Attribute name must be specified.
    at deserializeAws_json1_0CreateTableCommandError (/Users/kunaldeshmukh/Downloads/test/crud/node_modules/@aws-sdk/client-dynamodb/dist/cjs/protocols/Aws_json1_0.js:972:41)
    at processTicksAndRejections (internal/process/task_queues.js:97:5)
    at async /Users/kunaldeshmukh/Downloads/test/crud/node_modules/@aws-sdk/middleware-serde/dist/cjs/deserializerMiddleware.js:6:20
    at async /Users/kunaldeshmukh/Downloads/test/crud/node_modules/@aws-sdk/middleware-signing/dist/cjs/middleware.js:12:24
    at async StandardRetryStrategy.retry (/Users/kunaldeshmukh/Downloads/test/crud/node_modules/@aws-sdk/middleware-retry/dist/cjs/StandardRetryStrategy.js:51:46)
    at async /Users/kunaldeshmukh/Downloads/test/crud/node_modules/@aws-sdk/middleware-logger/dist/cjs/loggerMiddleware.js:6:22
    at async Dynamo.send (file:///Users/kunaldeshmukh/Downloads/test/crud/node_modules/dynamodb-onetable/dist/mjs/Dynamo.js:77:16)
    at async Dynamo.createTable (file:///Users/kunaldeshmukh/Downloads/test/crud/node_modules/dynamodb-onetable/dist/mjs/Dynamo.js:22:16)
    at async Table.createTable (file:///Users/kunaldeshmukh/Downloads/test/crud/node_modules/dynamodb-onetable/dist/mjs/Table.js:248:20)
    at async main (file:///Users/kunaldeshmukh/Downloads/test/crud/dist/index1.js:46:5)
(node:87839) UnhandledPromiseRejectionWarning: Unhandled promise rejection. This error originated either by throwing inside of an async function without a catch block, or by rejecting a promise which was not handled with .catch(). To terminate the node process on unhandled promise rejection, use the CLI flag `--unhandled-rejections=strict` (see https://nodejs.org/api/cli.html#cli_unhandled_rejections_mode). (rejection id: 15)
(node:87839) [DEP0018] DeprecationWarning: Unhandled promise rejections are deprecated. In the future, promise rejections that are not handled will terminate the Node.js process with a non-zero exit code.

    let items = await db.queryItems({pk})
    let results = db.groupByType(items)

// line 222
v.replace(/\${(.*?)}/g, (match, varName)

if (field.value && typeof field.value !== 'function')

import { Entity, Model, Table } from 'dynamodb-onetable'

const mySchema = {
    indexes: { primary: { hash: 'pk', sort: 'sk' } },
    models: {
        Model1: {
            pk: { type: String, required: true },
            sk: { type: String, required: true },

            strField: { type: String, required: true },
            dateField: { type: Date, required: true }
        }
    }
}

type MyType = Entity<typeof mySchema.models.Model1>

export const table = new Table({ name: 'MyTable', delimiter: '#', timestamps: true, isoDates: true, schema: mySchema })
export const Foo: Model<MyType> = table.getModel<MyType>('Foo')

void Foo.create({ pk: 'pk', sk: 'sk', strField: 'field1', dateField: new Date() })

const batch = this.prepareBatch<CorrespondenceLogByEventType>();

for (const logId of logIds) {
  await this.logByEventType.remove(
    { type: CorrespondenceEventType.UNREAD, logId },
    { batch, many: true, log: this.logEnabled }
  );
}

await this.processBatchWrite<CorrespondenceLogByEventType>(batch);

// Expression.js
throw new Error('Invalid filters with batch operation');

--- a/src/Model.d.ts
+++ b/src/Model.d.ts
@@ -130,6 +130,7 @@ export type OneParams = {
     delete?: object,
     execute?: boolean,
     exists?: boolean,
+    fields?: string[]
     hidden?: boolean,
     index?: string,
     limit?: number,

src/db.ts:3:20 - error TS2307: Cannot find module 'dynamodb-onetable/Dynamo' or its corresponding type declarations.

3 import Dynamo from 'dynamodb-onetable/Dynamo'
                     ~~~~~~~~~~~~~~~~~~~~~~~~~~

TS: 1 error

    let items = await db.queryItems({})
    db.groupByType(items)

-        for (let [index, item] of Object.entries(items)) {
+        for (let item of items) {

node_modules/dynamodb-onetable/dist/cjs/Model.d.ts:44:11 - error TS2304: Cannot find name 'OneType'.

44     type: OneType,
             ~~~~~~~

node_modules/dynamodb-onetable/dist/cjs/Model.d.ts:188:2 - error TS1036: Statements are not allowed in ambient contexts.

188 };
     ~

node_modules/dynamodb-onetable/dist/cjs/Table.d.ts:21:25 - error TS2314: Generic type 'Model<T>' requires 1 type argument(s).

21     intercept?: (model: Model, op: string, rec: {}, params: OneParams, raw?: {}) => void,
                           ~~~~~

node_modules/dynamodb-onetable/dist/cjs/Table.d.ts:57:2 - error TS1036: Statements are not allowed in ambient contexts.

57 };
    ~

Found 4 errors.

export async function create(bordereaux: BordereauxEntityType[]): Promise<BordereauxEntityType[]> {
    const promises = bordereaux.map(async b => Bordereaux.create(b))
    return Promise.all(promises)
}

    async create(properties, params = {}) {
        ({ params, properties } = this.checkArgs(properties, params, { parse: true, high: true, exists: false }));
        let result;
        if (this.hasUniqueFields) {
            result = await this.createUnique(properties, params);
        }
        else {
            result = await this.putItem(properties, params);
        }
        return result;
    }

    async create(properties, params = {}) {
        ({ params, properties } = this.checkArgs(properties, params, { parse: true, high: true, exists: false }));
        let result;
        if (this.hasUniqueFields) {
            return this.createUnique(properties, params);
        }
        else {
            return this.putItem(properties, params);
        }
    }

import Dynamo from 'dynamodb-onetable/Dynamo'
import {Table} from 'dynamodb-onetable'
import {DynamoDBClient} from '@aws-sdk/client-dynamodb'
const client = new Dynamo({client: new DynamoDBClient(params)})

 pk: { type: String },
            sk: { type: String, value: 'ACT#${actID}' },
            internalActID: { type: String },
            actID: { type: String, ksuid: true, required: true },
           
       .... other code

import ksuid = require('ksuid');

  this.usersTable = new Table({
            timestamps: true,
            name: TableNameConstants.USERS_TABLE,
            ksuid: () => {
                return ksuid.randomSync().string;
            },

------ other code

{\"model\":\"Accounts\",\"properties\":{\"opnBal\":0,\"opnBalCurrency\":\"string\",\"actDash\":true,\"actDate\":\"string\",\"actDesc\":\"string\",\"actName\":\"string\",\"actNo\":0,\"actType\":\"string\",\"transactionLog\":[\"string\"],\"closingAmt\":0,\"internalActID\":\"0\",\"pk\":\"fbf909a0-a0e1-11eb-9480-979110379335\",\"_type\":\"Accounts\",\"created\":\"2021-07-05T07:59:31.676Z\",\"updated\":\"2021-07-05T07:59:31.676Z\"},\"details\":{\"sk\":\"Value not defined for required field \\\"sk\\\"\",\"actID\":\"Value not defined for required field \\\"actID\\\"\"}}"}

{
  User: [ { id: '0b4c8d6a-1c52-4784-b5da-ad1bac65a3ec', _type: 'User' } ],
  UserProfile: [
    {
      id: '0b4c8d6a-1c52-4784-b5da-ad1bac65a3ec',
      email: '[email protected]',
      firstName: 'Colten',
      lastName: 'Monahan',
      displayName: 'Colten Monahan',
      _type: 'UserProfile'
    }
  ]
}

zip: { type: String, required: true }
state: { type: String, required: true },
city: { type: String, required: true },

/*
    Demonstrate simple CRUD with OneTable
 */
import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import { Table } from "dynamodb-onetable";
//  For AWS V3
import Dynamo from "dynamodb-onetable/Dynamo";

const client = new Dynamo({
  client: new DynamoDBClient({
    region: "local",
    endpoint: "http://localhost:8000",
  }),
});
/*
    Single-table schema and setup. This is used for general access and by `createTable`
 */
const table = new Table({
  name: "TestCrud",
  client: client,
  uuid: "ulid",
  delimiter: "#",
  logger: true,
  schema: {
    indexes: {
      primary: { hash: "pk", sort: "sk" },
      emailIndex: { hash: "email" },
    },
    models: {
      User: {
        pk: { type: String, value: "user#${email}" },
        sk: { type: String, value: "user#${email}" },
        id: { type: String, uuid: true },
        email: { type: String, required: true },
        name: { type: String },
        status: { type: String, default: "active" },
        zip: { type: String },
      },
    },
  },
});
//  Create a model to manage User entities
const User = table.getModel("User");
async function main() {
  if (!(await table.exists())) {
    await table.createTable();
  }

  let user = await User.create(
    {
      email: "[email protected]",
      name: "Peter Smith",
    },
    { log: true }
  ); //  Emit console trace for the command and result
  console.log("CREATED user", user);


  let users = await table.queryItems(
    { pk: "user#[email protected]" },
    { parse: true }
  );
  console.log("Query on Primary Index", users);


  users = await table.queryItems(
    { email: "[email protected]" },
    { index: "emailIndex", parse: true }
  );
  console.log("Query on GSI Index", users);
}

main();

--- a/src/Model.d.ts
+++ b/src/Model.d.ts
@@ -91,7 +91,7 @@ type EntityField<T extends OneTypedField> =
     : T['type'] extends BooleanConstructor ? boolean
     : T['type'] extends ObjectConstructor ? object
     : T['type'] extends DateConstructor ? Date
-    : T['type'] extends ArrayConstructor ? []
+    : T['type'] extends ArrayConstructor ? any[]
     : never;

let account = await User.create({
    id: '01ARZ3NDEKTSV4RRFFQ69G5FAV',
    name: 'Eric',
    status: 'active',
    zip: 'XYZ'
})

ResourceNotFoundException: ResourceNotFoundException
    at deserializeAws_json1_0PutItemCommandError (/some-path/2021-05-27-dynamodb-onetable-test/node_modules/@aws-sdk/client-dynamodb/dist/cjs/protocols/Aws_json1_0.js:2904:41)
    at processTicksAndRejections (internal/process/task_queues.js:93:5)
    at async /some-path/2021-05-27-dynamodb-onetable-test/node_modules/@aws-sdk/middleware-serde/dist/cjs/deserializerMiddleware.js:6:20
    at async /some-path/2021-05-27-dynamodb-onetable-test/node_modules/@aws-sdk/middleware-signing/dist/cjs/middleware.js:12:24
    at async StandardRetryStrategy.retry (/some-path/2021-05-27-dynamodb-onetable-test/node_modules/@aws-sdk/middleware-retry/dist/cjs/defaultStrategy.js:56:46)
    at async /some-path/2021-05-27-dynamodb-onetable-test/node_modules/@aws-sdk/middleware-logger/dist/cjs/loggerMiddleware.js:6:22

import Dynamo from 'dynamodb-onetable/Dynamo'
import {Table, Model, } from 'dynamodb-onetable'

import {DynamoDBClient} from '@aws-sdk/client-dynamodb'

const params = {
    /** input parameters */
    credentials: {
        accessKeyId: "", 
        secretAccessKey: "", 
        },
    region : "us-east-1"
  };
// const client = new DynamoDBClient(params);

const client = new Dynamo({client: new DynamoDBClient(params)})

await results.next();

params = Object.assign({}, params, {start: result.LastEvaluatedKey})

params = Object.assign({}, params, { start: items.start });

2021-04-18T04:32:49.623Z	9945dda7-db39-4e55-be9a-dc1119352034	ERROR	Invoke Error 	{"errorType":"ValidationException","errorMessage":"The provided key element does not match the schema","__type":"com.amazon.coral.validate#ValidationException","name":"ValidationException","$fault":"client","$metadata":{"httpStatusCode":400,"requestId":"JH9CAULMN2P18723AI80A7GF3RVV4KQNSO5AEMVJF66Q9ASUAAJG","attempts":1,"totalRetryDelay":0},"stack":["ValidationException: The provided key element does not match the schema","    at s9i (/var/node_modules/@aws-sdk/client-dynamodb/protocols/Aws_json1_0.ts:3704:39)","    at processTicksAndRejections (internal/process/task_queues.js:93:5)","    at /var/node_modules/@aws-sdk/middleware-serde/src/deserializerMiddleware.ts:20:18","    at /var/node_modules/@aws-sdk/middleware-signing/src/middleware.ts:26:22","    at ZHe.retry (/var/node_modules/@aws-sdk/middleware-retry/src/defaultStrategy.ts:125:38)","    at /var/node_modules/@aws-sdk/middleware-logger/src/loggerMiddleware.ts:21:20","    at GEe.send (/var/node_modules/dynamodb-onetable/dist/mjs/Dynamo.js:61:16)","    at GEe.find (/var/node_modules/dynamodb-onetable/dist/mjs/Dynamo.js:30:16)","    at V8.run (/var/node_modules/dynamodb-onetable/dist/mjs/Model.js:252:30)","    at V8.queryItems (/var/node_modules/dynamodb-onetable/dist/mjs/Model.js:528:16)"]}

export const getEventsByDriverId = async (driverId: string, filter?: Filter): Promise<AWSEvent[]> => {
  const sk = { begins: { sk: buildPrefix(filter) } }
  const results = await EventModel.find({ driverId, sk  }, { tunnel, index: 'gs2' })
  return results as AWSEvent[]
}

export const getEventsByDriverId = async (driverId: string, filter?: Filter): Promise<AWSEvent[]> => {
  const tunnel = { begins: { sk: buildPrefix(filter) } }
  const results = await EventModel.find({ driverId }, { tunnel, index: 'gs2' })
  return results as AWSEvent[]
}