@webda/aws 2.0.0-beta.1 → 2.0.0

package/lib/services/dynamodb.spec.js

@@ -1,83 +1,36 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 var DynamoDBTest_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DynamoDBTest = void 0;
-const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
-const mocha_1 = require("@testdeck/mocha");
-const core_1 = require("@webda/core");
-const store_spec_1 = require("@webda/core/lib/stores/store.spec");
-const workout_1 = require("@webda/workout");
-const assert = __importStar(require("assert"));
-const aws_sdk_client_mock_1 = require("aws-sdk-client-mock");
-const path_1 = __importDefault(require("path"));
-const sinon = __importStar(require("sinon"));
-const index_spec_1 = require("../index.spec");
-const dynamodb_1 = require("./dynamodb");
-let DynamoDBTest = DynamoDBTest_1 = class DynamoDBTest extends store_spec_1.StoreTest {
-    before() {
-        const _super = Object.create(null, {
-            before: { get: () => super.before }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            process.env.AWS_ACCESS_KEY_ID = index_spec_1.defaultCreds.accessKeyId;
-            process.env.AWS_SECRET_ACCESS_KEY = index_spec_1.defaultCreds.secretAccessKey;
-            process.env.AWS_DEFAULT_REGION = "us-east-1";
-            yield (0, index_spec_1.checkLocalStack)();
-            this.buildWebda();
-            yield DynamoDBTest_1.install("webda-test-idents");
-            yield DynamoDBTest_1.install("webda-test-users");
-            yield _super.before.call(this);
-        });
+import { BatchWriteItemCommand, DescribeTableCommand, DynamoDB, DynamoDBClient, ScanCommand } from "@aws-sdk/client-dynamodb";
+import { suite, test } from "@testdeck/mocha";
+import { getCommonJS, Ident, UpdateConditionFailError } from "@webda/core";
+import { StoreTest } from "@webda/core/lib/stores/store.spec.js";
+import { WorkerOutput } from "@webda/workout";
+import * as assert from "assert";
+import { mockClient } from "aws-sdk-client-mock";
+import path from "path";
+import * as sinon from "sinon";
+import { checkLocalStack, defaultCreds } from "../index.spec.js";
+import { DynamoStore, DynamoStoreParameters } from "./dynamodb.js";
+const { __dirname } = getCommonJS(import.meta.url);
+let DynamoDBTest = DynamoDBTest_1 = class DynamoDBTest extends StoreTest {
+    async before() {
+        process.env.AWS_ACCESS_KEY_ID = defaultCreds.accessKeyId;
+        process.env.AWS_SECRET_ACCESS_KEY = defaultCreds.secretAccessKey;
+        process.env.AWS_DEFAULT_REGION = "us-east-1";
+        await checkLocalStack();
+        this.buildWebda();
+        await DynamoDBTest_1.install("webda-test-idents");
+        await DynamoDBTest_1.install("webda-test-users");
+        await super.before();
     }
-    tweakApp(app) {
-        const _super = Object.create(null, {
-            tweakApp: { get: () => super.tweakApp }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            _super.tweakApp.call(this, app);
-            app.addService("test/awsevents", (yield Promise.resolve().then(() => __importStar(require(path_1.default.join(__dirname, ..."../../test/moddas/awsevents.js".split("/")))))).default);
-        });
+    async tweakApp(app) {
+        super.tweakApp(app);
+        app.addService("test/awsevents", (await import(path.join(__dirname, ..."../../test/moddas/awsevents.js".split("/")))).AWSEventsHandler);
     }
     getIdentStore() {
         return this.getService("idents");
@@ -86,148 +39,135 @@ let DynamoDBTest = DynamoDBTest_1 = class DynamoDBTest extends store_spec_1.Stor
         return this.getService("users");
     }
     getModelClass() {
-        return core_1.Ident;
+        return Ident;
     }
-    queryOrder() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Disable default ordering query as it is not possible with Dynamo
-        });
+    async queryOrder() {
+        // Disable default ordering query as it is not possible with Dynamo
     }
-    static install(TableName, GlobalSecondaryIndexes, attrs = []) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var dynamodb = new client_dynamodb_1.DynamoDB({
-                endpoint: "http://localhost:4566",
-                credentials: index_spec_1.defaultCreds,
-                region: "us-east-1"
-            });
-            try {
-                yield dynamodb.describeTable({
-                    TableName
-                });
-            }
-            catch (err) {
-                if (err.name === "ResourceNotFoundException") {
-                    let createTable = {
-                        TableName,
-                        ProvisionedThroughput: {
-                            ReadCapacityUnits: 5,
-                            WriteCapacityUnits: 5
-                        },
-                        GlobalSecondaryIndexes,
-                        KeySchema: [
-                            {
-                                AttributeName: "uuid",
-                                KeyType: "HASH"
-                            }
-                        ],
-                        AttributeDefinitions: [
-                            {
-                                AttributeName: "uuid",
-                                AttributeType: "S"
-                            },
-                            ...attrs
-                        ]
-                    };
-                    let table = dynamodb.createTable(createTable);
-                    return table;
-                }
-            }
+    static async install(TableName, GlobalSecondaryIndexes, attrs = []) {
+        var dynamodb = new DynamoDB({
+            endpoint: "http://localhost:4566",
+            credentials: defaultCreds,
+            region: "us-east-1"
         });
-    }
-    fillForQuery() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield DynamoDBTest_1.install("webda-test-query", [
-                {
-                    IndexName: "States",
+        try {
+            await dynamodb.describeTable({
+                TableName
+            });
+        }
+        catch (err) {
+            if (err.name === "ResourceNotFoundException") {
+                let createTable = {
+                    TableName,
+                    ProvisionedThroughput: {
+                        ReadCapacityUnits: 5,
+                        WriteCapacityUnits: 5
+                    },
+                    GlobalSecondaryIndexes,
                     KeySchema: [
                         {
-                            AttributeName: "state",
+                            AttributeName: "uuid",
                             KeyType: "HASH"
-                        },
-                        {
-                            AttributeName: "order",
-                            KeyType: "RANGE"
                         }
                     ],
-                    Projection: { ProjectionType: "ALL" },
-                    ProvisionedThroughput: {
-                        ReadCapacityUnits: 5,
-                        WriteCapacityUnits: 5
+                    AttributeDefinitions: [
+                        {
+                            AttributeName: "uuid",
+                            AttributeType: "S"
+                        },
+                        ...attrs
+                    ]
+                };
+                let table = dynamodb.createTable(createTable);
+                return table;
+            }
+        }
+    }
+    async fillForQuery() {
+        await DynamoDBTest_1.install("webda-test-query", [
+            {
+                IndexName: "States",
+                KeySchema: [
+                    {
+                        AttributeName: "state",
+                        KeyType: "HASH"
+                    },
+                    {
+                        AttributeName: "order",
+                        KeyType: "RANGE"
                     }
+                ],
+                Projection: { ProjectionType: "ALL" },
+                ProvisionedThroughput: {
+                    ReadCapacityUnits: 5,
+                    WriteCapacityUnits: 5
                 }
-            ], [
-                {
-                    AttributeName: "state",
-                    AttributeType: "S"
-                },
-                {
-                    AttributeName: "order",
-                    AttributeType: "N"
-                }
-            ]);
-            let store = new dynamodb_1.DynamoStore(this.webda, "queryStore", {
-                table: "webda-test-query",
-                globalIndexes: {
-                    States: {
-                        key: "state",
-                        sort: "order"
-                    }
-                },
-                expose: {
-                    url: "/none"
-                },
-                credentials: index_spec_1.defaultCreds,
-                endpoint: "http://localhost:4566",
-                region: "us-east-1"
-            });
-            store.resolve();
-            yield store.init();
-            if ((yield store.getAll()).length < 1000) {
-                yield Promise.all(this.getQueryDocuments().map(d => store.save(d)));
             }
-            return store;
-        });
-    }
-    query() {
-        const _super = Object.create(null, {
-            query: { get: () => super.query }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            // Run default query
-            let store = yield _super.query.call(this);
-            let res = yield store.query('state = "CA" AND order < 100 ORDER BY team.id ASC, order DESC');
-            console.log("RES", res.results.map(c => this.mapQueryModel(c)));
-            assert.strictEqual(res.results.shift().order, 96);
-            let set = ["CA"];
-            for (let i = 1; i < 150; i++) {
-                set.push(i.toString(16));
+        ], [
+            {
+                AttributeName: "state",
+                AttributeType: "S"
+            },
+            {
+                AttributeName: "order",
+                AttributeType: "N"
             }
-            assert.strictEqual((yield store.query(`state IN [${set.map(e => `"${e}"`).join(",")}]`)).results.length, 250);
-            // Add more test here
-            return store;
+        ]);
+        let store = new DynamoStore(this.webda, "queryStore", {
+            table: "webda-test-query",
+            globalIndexes: {
+                States: {
+                    key: "state",
+                    sort: "order"
+                }
+            },
+            expose: {
+                url: "/none"
+            },
+            credentials: defaultCreds,
+            endpoint: "http://localhost:4566",
+            region: "us-east-1"
         });
+        store.resolve();
+        await store.init();
+        if ((await store.getAll()).length < 1000) {
+            await Promise.all(this.getQueryDocuments().map(d => store.save(d)));
+        }
+        return store;
     }
-    dateHandling() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let userStore = this.getUserStore();
-            yield userStore.save({
-                uuid: "testUpdate",
-                subobject: {
-                    empty: "",
-                    t: {
-                        plop: ""
-                    },
-                    date: new Date()
-                }
-            });
-            let user = yield userStore.get("testUpdate");
-            assert.notStrictEqual(user.date, {});
+    async query() {
+        // Run default query
+        let store = await super.query();
+        let res = await store.query('state = "CA" AND order < 100 ORDER BY team.id ASC, order DESC');
+        console.log("RES", res.results.map(c => this.mapQueryModel(c)));
+        assert.strictEqual(res.results.shift().order, 96);
+        let set = ["CA"];
+        for (let i = 1; i < 150; i++) {
+            set.push(i.toString(16));
+        }
+        assert.strictEqual((await store.query(`state IN [${set.map(e => `"${e}"`).join(",")}]`)).results.length, 250);
+        // Add more test here
+        return store;
+    }
+    async dateHandling() {
+        let userStore = this.getUserStore();
+        await userStore.save({
+            uuid: "testUpdate",
+            subobject: {
+                empty: "",
+                t: {
+                    plop: ""
+                },
+                date: new Date()
+            }
         });
+        let user = await userStore.get("testUpdate");
+        assert.notStrictEqual(user.date, {});
     }
     bodyCleaning() {
         //var parse = require("./data/to_clean.json");
         let identStore = this.getIdentStore();
-        let ident = new core_1.Ident();
+        let ident = new Ident();
         ident.load({
             arr: [
                 {
@@ -263,148 +203,138 @@ let DynamoDBTest = DynamoDBTest_1 = class DynamoDBTest extends store_spec_1.Stor
         userStore.getParameters().CloudFormationSkip = true;
         assert.deepStrictEqual(userStore.getCloudFormation(undefined), {});
     }
-    patchSkip() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let userStore = this.getService("users");
-            let s = sinon.spy(userStore._client, "update");
-            try {
-                yield userStore._patch({ uuid: "test" }, "test");
-                assert.strictEqual(s.callCount, 0);
-            }
-            finally {
-                s.restore();
-            }
-        });
+    async patchSkip() {
+        let userStore = this.getService("users");
+        let s = sinon.spy(userStore._client, "update");
+        try {
+            await userStore._patch({ uuid: "test" }, "test");
+            assert.strictEqual(s.callCount, 0);
+        }
+        finally {
+            s.restore();
+        }
     }
-    deleteWithCondition() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield assert.rejects(() => this.getService("users")._delete("nop", new Date(), "p"), core_1.UpdateConditionFailError);
-        });
+    async deleteWithCondition() {
+        await assert.rejects(() => this.getService("users")._delete("nop", new Date(), "p"), UpdateConditionFailError);
     }
     params() {
-        assert.throws(() => new dynamodb_1.DynamoStoreParameters({}, this.getService("users")), /Need to define a table at least/);
-    }
-    errors() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let stubs = [];
-            try {
-                const faultyMethod = () => {
-                    throw new Error("Unknown");
-                };
-                let userStore = this.getService("users");
-                yield assert.rejects(() => userStore._upsertItemToCollection("plop2", "test", "plop", 1, 2, "", new Date()), /Item not found plop2 Store/);
-                stubs = ["update", "delete", "put"].map(method => {
-                    // @ts-ignore
-                    return sinon.stub(userStore._client, method).callsFake(faultyMethod);
-                });
-                stubs.push(sinon.stub(userStore._client, "scan").callsFake((p, c) => {
-                    // @ts-ignore
-                    throw new Error("Unknown");
-                }));
-                yield assert.rejects(() => userStore._removeAttribute("plop", "test"), /Unknown/);
-                yield assert.rejects(() => userStore._deleteItemFromCollection("plop", "test", 1, "plop", 2, new Date()), /Unknown/);
-                yield assert.rejects(() => userStore._upsertItemToCollection("plop", "test", "plop", 1, 2, "", new Date()), /Unknown/);
-                yield assert.rejects(() => userStore._delete("plop"), /Unknown/);
-                yield assert.rejects(() => userStore._patch({ t: "l" }, "plop"), /Unknown/);
-                yield assert.rejects(() => userStore._update({ t: "l" }, "plop"), /Unknown/);
-                yield assert.rejects(() => userStore._scan([]), /Unknown/);
-                yield assert.rejects(() => userStore._incrementAttribute("plop", "t", 1, new Date()), /Unknown/);
-            }
-            finally {
-                stubs.forEach(s => s.restore());
-            }
-        });
+        assert.throws(() => new DynamoStoreParameters({}, this.getService("users")), /Need to define a table at least/);
     }
-    patch() {
-        return __awaiter(this, void 0, void 0, function* () {
+    async errors() {
+        let stubs = [];
+        try {
+            const faultyMethod = () => {
+                throw new Error("Unknown");
+            };
             let userStore = this.getService("users");
-            let stub = sinon.stub(userStore._client, "update").callsFake(() => {
-                let err = new Error();
+            await assert.rejects(() => userStore._upsertItemToCollection("plop2", "test", "plop", 1, 2, "", new Date()), /Item not found plop2 Store/);
+            stubs = ["update", "delete", "put"].map(method => {
                 // @ts-ignore
-                err.code = "ConditionalCheckFailedException";
-                throw err;
+                return sinon.stub(userStore._client, method).callsFake(faultyMethod);
             });
-            try {
-                assert.rejects(() => userStore._patch({ t: "l" }, "plop"), core_1.UpdateConditionFailError);
-            }
-            finally {
-                stub.restore();
-            }
+            stubs.push(sinon.stub(userStore._client, "scan").callsFake((p, c) => {
+                // @ts-ignore
+                throw new Error("Unknown");
+            }));
+            await assert.rejects(() => userStore._removeAttribute("plop", "test"), /Unknown/);
+            await assert.rejects(() => userStore._deleteItemFromCollection("plop", "test", 1, "plop", 2, new Date()), /Unknown/);
+            await assert.rejects(() => userStore._upsertItemToCollection("plop", "test", "plop", 1, 2, "", new Date()), /Unknown/);
+            await assert.rejects(() => userStore._delete("plop"), /Unknown/);
+            await assert.rejects(() => userStore._patch({ t: "l" }, "plop"), /Unknown/);
+            await assert.rejects(() => userStore._update({ t: "l" }, "plop"), /Unknown/);
+            await assert.rejects(() => userStore._scan([]), /Unknown/);
+            await assert.rejects(() => userStore._incrementAttribute("plop", "t", 1, new Date()), /Unknown/);
+        }
+        finally {
+            stubs.forEach(s => s.restore());
+        }
+    }
+    async patch() {
+        let userStore = this.getService("users");
+        let stub = sinon.stub(userStore._client, "update").callsFake(() => {
+            let err = new Error();
+            // @ts-ignore
+            err.code = "ConditionalCheckFailedException";
+            throw err;
         });
+        try {
+            assert.rejects(() => userStore._patch({ t: "l" }, "plop"), UpdateConditionFailError);
+        }
+        finally {
+            stub.restore();
+        }
     }
-    copyTable() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const mock = (0, aws_sdk_client_mock_1.mockClient)(client_dynamodb_1.DynamoDBClient);
-            try {
-                mock.on(client_dynamodb_1.DescribeTableCommand).resolves({
-                    Table: {
-                        ItemCount: 50
-                    }
-                });
-                const results = [];
-                let output = new workout_1.WorkerOutput();
-                for (let i = 0; i < 50; i++) {
-                    results.push({ Item: { S: `Title ${i}` } });
+    async copyTable() {
+        const mock = mockClient(DynamoDBClient);
+        try {
+            mock.on(DescribeTableCommand).resolves({
+                Table: {
+                    ItemCount: 50
                 }
-                mock.on(client_dynamodb_1.ScanCommand).callsFake((p) => __awaiter(this, void 0, void 0, function* () {
-                    let offset = 0;
-                    let LastEvaluatedKey;
-                    if (p.ExclusiveStartKey) {
-                        offset = parseInt(p.ExclusiveStartKey.year.N);
-                    }
-                    if (offset + 35 < results.length) {
-                        LastEvaluatedKey = { year: { N: (offset + 35).toString() } };
-                    }
-                    return {
-                        Items: results.slice(offset, 35),
-                        LastEvaluatedKey
-                    };
-                }));
-                mock.on(client_dynamodb_1.BatchWriteItemCommand).resolves({});
-                let userStore = this.getService("users");
-                yield dynamodb_1.DynamoStore.copyTable(output, "table1", "table2");
-            }
-            finally {
-                mock.restore();
+            });
+            const results = [];
+            let output = new WorkerOutput();
+            for (let i = 0; i < 50; i++) {
+                results.push({ Item: { S: `Title ${i}` } });
             }
-        });
+            mock.on(ScanCommand).callsFake(async (p) => {
+                let offset = 0;
+                let LastEvaluatedKey;
+                if (p.ExclusiveStartKey) {
+                    offset = parseInt(p.ExclusiveStartKey.year.N);
+                }
+                if (offset + 35 < results.length) {
+                    LastEvaluatedKey = { year: { N: (offset + 35).toString() } };
+                }
+                return {
+                    Items: results.slice(offset, 35),
+                    LastEvaluatedKey
+                };
+            });
+            mock.on(BatchWriteItemCommand).resolves({});
+            let userStore = this.getService("users");
+            await DynamoStore.copyTable(output, "table1", "table2");
+        }
+        finally {
+            mock.restore();
+        }
     }
 };
 __decorate([
-    mocha_1.test
+    test
 ], DynamoDBTest.prototype, "queryOrder", null);
 __decorate([
-    mocha_1.test
+    test
 ], DynamoDBTest.prototype, "query", null);
 __decorate([
-    mocha_1.test
+    test
 ], DynamoDBTest.prototype, "dateHandling", null);
 __decorate([
-    mocha_1.test
+    test
 ], DynamoDBTest.prototype, "bodyCleaning", null);
 __decorate([
-    mocha_1.test
+    test
 ], DynamoDBTest.prototype, "ARNPolicy", null);
 __decorate([
-    mocha_1.test
+    test
 ], DynamoDBTest.prototype, "patchSkip", null);
 __decorate([
-    mocha_1.test
+    test
 ], DynamoDBTest.prototype, "deleteWithCondition", null);
 __decorate([
-    mocha_1.test
+    test
 ], DynamoDBTest.prototype, "params", null);
 __decorate([
-    mocha_1.test
+    test
 ], DynamoDBTest.prototype, "errors", null);
 __decorate([
-    mocha_1.test
+    test
 ], DynamoDBTest.prototype, "patch", null);
 __decorate([
-    mocha_1.test
+    test
 ], DynamoDBTest.prototype, "copyTable", null);
 DynamoDBTest = DynamoDBTest_1 = __decorate([
-    mocha_1.suite
+    suite
 ], DynamoDBTest);
-exports.DynamoDBTest = DynamoDBTest;
+export { DynamoDBTest };
 //# sourceMappingURL=dynamodb.spec.js.map