hgs-twilio-class-lib 1.1.52 → 1.1.54

package/lib/aws/abstract/ServiceObjectStore.d.ts

@@ -7,4 +7,3 @@ export declare abstract class ServiceObjectStore extends DatabaseObjectStore imp
     abstract asyncGet(query: IDBValidKey | IDBKeyRange): Promise<any[]>;
     abstract asyncGetAll(query: SearchParameterType, count?: number | undefined): Promise<IDBRequest<any[]>>;
 }
-//# sourceMappingURL=ServiceObjectStore.d.ts.map

package/lib/aws/abstract/ServiceObjectStore.js

@@ -1 +1,10 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.ServiceObjectStore=void 0;const e=require("../../common/abstract/DatabaseObjectStore");class t extends e.DatabaseObjectStore{constructor(e,t,r,o,c){super(e,t,r,o,c)}}exports.ServiceObjectStore=t;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceObjectStore = void 0;
+const DatabaseObjectStore_1 = require("../../common/abstract/DatabaseObjectStore");
+class ServiceObjectStore extends DatabaseObjectStore_1.DatabaseObjectStore {
+    constructor(name, transaction, autoIncrement, indexNames, keyPath) {
+        super(name, transaction, autoIncrement, indexNames, keyPath);
+    }
+}
+exports.ServiceObjectStore = ServiceObjectStore;

package/lib/aws/abstract/ServiceOpenRequest.d.ts

@@ -5,4 +5,3 @@ import { IServiceTransaction } from "../interface/IServiceTransation";
 export declare abstract class ServiceDBOpenRequest extends DatabaseOpenRequest implements IServiceDBOpenRequest {
     constructor(result: any, readyState: IDBRequestReadyState, source?: IServiceObjectStore, transaction?: IServiceTransaction | null, error?: DOMException | null);
 }
-//# sourceMappingURL=ServiceOpenRequest.d.ts.map

package/lib/aws/abstract/ServiceOpenRequest.js

@@ -1 +1,10 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.ServiceDBOpenRequest=void 0;const e=require("../../common/abstract/DatabaseOpenRequest");class s extends e.DatabaseOpenRequest{constructor(e,s,t,r,o){super(e,s,t,r,o)}}exports.ServiceDBOpenRequest=s;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceDBOpenRequest = void 0;
+const DatabaseOpenRequest_1 = require("../../common/abstract/DatabaseOpenRequest");
+class ServiceDBOpenRequest extends DatabaseOpenRequest_1.DatabaseOpenRequest {
+    constructor(result, readyState, source, transaction, error) {
+        super(result, readyState, source, transaction, error);
+    }
+}
+exports.ServiceDBOpenRequest = ServiceDBOpenRequest;

package/lib/aws/abstract/ServiceRequest.d.ts

@@ -1,4 +1,3 @@
 import { DatabaseRequest } from "../../common/abstract/DatabaseRequest";
 export declare abstract class ServiceRequest extends DatabaseRequest {
 }
-//# sourceMappingURL=ServiceRequest.d.ts.map

package/lib/aws/abstract/ServiceRequest.js

@@ -1 +1,7 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.ServiceRequest=void 0;const e=require("../../common/abstract/DatabaseRequest");class s extends e.DatabaseRequest{}exports.ServiceRequest=s;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceRequest = void 0;
+const DatabaseRequest_1 = require("../../common/abstract/DatabaseRequest");
+class ServiceRequest extends DatabaseRequest_1.DatabaseRequest {
+}
+exports.ServiceRequest = ServiceRequest;

package/lib/aws/abstract/ServiceResource.d.ts

@@ -18,4 +18,3 @@ export declare abstract class ServiceResource extends Database implements IServi
     abstract createObjectStore(name: string, options?: IServiceObjectStoreParameters | undefined): IServiceObjectStore;
     abstract fetchObjectStores(): IServiceObjectStore[];
 }
-//# sourceMappingURL=ServiceResource.d.ts.map

package/lib/aws/abstract/ServiceResource.js

@@ -1 +1,31 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.ServiceResource=void 0;const e=require("../../common/abstract/Database");class s extends e.Database{get region(){return this._region}set region(e){this._region=e}get endpoint(){return this._endpoint}set endpoint(e){this._endpoint=e}get accessKeyId(){return this._accessKeyId}set accessKeyId(e){this._accessKeyId=e}get secretAccessKey(){return this._secretAccessKey}set secretAccessKey(e){this._secretAccessKey=e}}exports.ServiceResource=s;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceResource = void 0;
+const Database_1 = require("../../common/abstract/Database");
+class ServiceResource extends Database_1.Database {
+    get region() {
+        return this._region;
+    }
+    set region(value) {
+        this._region = value;
+    }
+    get endpoint() {
+        return this._endpoint;
+    }
+    set endpoint(value) {
+        this._endpoint = value;
+    }
+    get accessKeyId() {
+        return this._accessKeyId;
+    }
+    set accessKeyId(value) {
+        this._accessKeyId = value;
+    }
+    get secretAccessKey() {
+        return this._secretAccessKey;
+    }
+    set secretAccessKey(value) {
+        this._secretAccessKey = value;
+    }
+}
+exports.ServiceResource = ServiceResource;

package/lib/aws/abstract/ServiceResourceFactory.d.ts

@@ -11,4 +11,3 @@ export declare abstract class ServiceResourceFactory extends DatabaseFactory {
     abstract deleteDatabase(name: string): IServiceDBOpenRequest;
     abstract databases(): Promise<IDatabaseInfo[]>;
 }
-//# sourceMappingURL=ServiceResourceFactory.d.ts.map

package/lib/aws/abstract/ServiceResourceFactory.js

@@ -1 +1,14 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.ServiceResourceFactory=void 0;const e=require("../../common/abstract/DatabaseFactory");class t extends e.DatabaseFactory{constructor(e){super(e),this._awsService=this.databaseClient.databaseInstance}get awsService(){return this._awsService}}exports.ServiceResourceFactory=t;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceResourceFactory = void 0;
+const DatabaseFactory_1 = require("../../common/abstract/DatabaseFactory");
+class ServiceResourceFactory extends DatabaseFactory_1.DatabaseFactory {
+    constructor(AWSClient) {
+        super(AWSClient);
+        this._awsService = this.databaseClient.databaseInstance;
+    }
+    get awsService() {
+        return this._awsService;
+    }
+}
+exports.ServiceResourceFactory = ServiceResourceFactory;

package/lib/aws/abstract/ServiceTransaction.d.ts

@@ -4,4 +4,3 @@ export declare abstract class ServiceTransaction extends DatabaseTransaction {
     private _syncResource;
     constructor(db: IServiceResource, mode: IDBTransactionMode, error?: DOMException | null, objectStoreNames?: DOMStringList, durability?: IDBTransactionDurability);
 }
-//# sourceMappingURL=ServiceTransaction.d.ts.map

package/lib/aws/abstract/ServiceTransaction.js

@@ -1 +1,11 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.ServiceTransaction=void 0;const e=require("../../common/abstract/DatabaseTransaction");class s extends e.DatabaseTransaction{constructor(e,s,t,a,r){super(e,s,t,a,r),this._syncResource=this.db}}exports.ServiceTransaction=s;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceTransaction = void 0;
+const DatabaseTransaction_1 = require("../../common/abstract/DatabaseTransaction");
+class ServiceTransaction extends DatabaseTransaction_1.DatabaseTransaction {
+    constructor(db, mode, error, objectStoreNames, durability) {
+        super(db, mode, error, objectStoreNames, durability);
+        this._syncResource = this.db;
+    }
+}
+exports.ServiceTransaction = ServiceTransaction;

package/lib/aws/impl/AWSAPIConfig.d.ts

@@ -12,4 +12,3 @@ export declare class AWSAPIConfig implements IDatabaseClientConfig {
     set secretAccessKey(value: string);
     get secretAccessKey(): string;
 }
-//# sourceMappingURL=AWSAPIConfig.d.ts.map

package/lib/aws/impl/AWSAPIConfig.js

@@ -1 +1,38 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.AWSAPIConfig=void 0;const e=require("../../common/interface/IDatabaseConfig");exports.AWSAPIConfig=class{constructor(s,t,c){this.type=e.DatabaseTypes.AWS,this.region=s,this.accessKeyId=t,this.secretAccessKey=c}set region(e){this._region=e}get region(){return this._region}set accessKeyId(e){this._accessKeyId=e}get accessKeyId(){return this._accessKeyId}set secretAccessKey(e){this._secretAccessKey=e}get secretAccessKey(){return this._secretAccessKey}};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AWSAPIConfig = void 0;
+const IDatabaseConfig_1 = require("../../common/interface/IDatabaseConfig");
+class AWSAPIConfig {
+    constructor(region, accessKeyId, secretAccessKey) {
+        this.type = IDatabaseConfig_1.DatabaseTypes.AWS;
+        this.region = region;
+        // this.endpoint = endpoint;
+        this.accessKeyId = accessKeyId;
+        this.secretAccessKey = secretAccessKey;
+    }
+    set region(value) {
+        this._region = value;
+    }
+    get region() {
+        return this._region;
+    }
+    // set endpoint(value: string) {
+    //     this._endpoint = value;
+    // }
+    // get endpoint() {
+    //     return this._endpoint;
+    // }
+    set accessKeyId(value) {
+        this._accessKeyId = value;
+    }
+    get accessKeyId() {
+        return this._accessKeyId;
+    }
+    set secretAccessKey(value) {
+        this._secretAccessKey = value;
+    }
+    get secretAccessKey() {
+        return this._secretAccessKey;
+    }
+}
+exports.AWSAPIConfig = AWSAPIConfig;

package/lib/aws/impl/AWSClient.d.ts

@@ -1,7 +1,5 @@
-import { AWSAPIConfig } from "./AWSAPIConfig";
 import { AWSConnectAPIConfig } from './AWSConnectAPIConfig';
 import { DatabaseClient } from '../../common/abstract/DatabaseClient';
 export declare class AWSClient extends DatabaseClient {
-    constructor(AWSClientConfig: AWSAPIConfig | AWSConnectAPIConfig);
+    constructor(AWSClientConfig: AWSConnectAPIConfig);
 }
-//# sourceMappingURL=AWSClient.d.ts.map

package/lib/aws/impl/AWSClient.js

@@ -1 +1,21 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.AWSClient=void 0;const e=require("tslib").__importDefault(require("aws-sdk")),s=require("@aws-sdk/client-connect"),t=require("./AWSAPIConfig"),c=require("./AWSConnectAPIConfig"),n=require("../../common/abstract/DatabaseClient");class a extends n.DatabaseClient{constructor(n){if(super(n),n instanceof t.AWSAPIConfig){const s=n;this.databaseInstance=e.default,this.databaseInstance.config.update({region:s.region,accessKeyId:s.accessKeyId,secretAccessKey:s.secretAccessKey})}if(n instanceof c.AWSConnectAPIConfig){const e=n,t={region:e.region,accessKeyId:e.accessKeyId,secretAccessKey:e.secretAccessKey};this.databaseInstance=new s.ConnectClient(t)}}}exports.AWSClient=a;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AWSClient = void 0;
+const client_connect_1 = require("@aws-sdk/client-connect");
+const AWSConnectAPIConfig_1 = require("./AWSConnectAPIConfig");
+const DatabaseClient_1 = require("../../common/abstract/DatabaseClient");
+class AWSClient extends DatabaseClient_1.DatabaseClient {
+    constructor(AWSClientConfig) {
+        super(AWSClientConfig);
+        if (AWSClientConfig instanceof AWSConnectAPIConfig_1.AWSConnectAPIConfig) {
+            const _AWSClientConfig = AWSClientConfig;
+            const config = {
+                "region": _AWSClientConfig.region,
+                "accessKeyId": _AWSClientConfig.accessKeyId,
+                "secretAccessKey": _AWSClientConfig.secretAccessKey
+            };
+            this.databaseInstance = new client_connect_1.ConnectClient(config);
+        }
+    }
+}
+exports.AWSClient = AWSClient;

package/lib/aws/impl/AWSConnectAPIConfig.d.ts

@@ -15,4 +15,3 @@ export declare class AWSConnectAPIConfig implements IDatabaseClientConfig {
     set secretAccessKey(value: string);
     get secretAccessKey(): string;
 }
-//# sourceMappingURL=AWSConnectAPIConfig.d.ts.map

package/lib/aws/impl/AWSConnectAPIConfig.js

@@ -1 +1,38 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.AWSConnectAPIConfig=void 0;const e=require("../../common/interface/IDatabaseConfig");exports.AWSConnectAPIConfig=class{constructor(s,t,c,r){this.type=e.DatabaseTypes.AWS,this.region=s,this.service=t,this.accessKeyId=c,this.secretAccessKey=r}set region(e){this._region=e}get region(){return this._region}set service(e){this._service=e}get service(){return this._service}set accessKeyId(e){this._accessKeyId=e}get accessKeyId(){return this._accessKeyId}set secretAccessKey(e){this._secretAccessKey=e}get secretAccessKey(){return this._secretAccessKey}};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AWSConnectAPIConfig = void 0;
+const IDatabaseConfig_1 = require("../../common/interface/IDatabaseConfig");
+class AWSConnectAPIConfig {
+    constructor(region, service, accessKeyId, secretAccessKey) {
+        this.type = IDatabaseConfig_1.DatabaseTypes.AWS;
+        this.region = region;
+        this.service = service;
+        this.accessKeyId = accessKeyId;
+        this.secretAccessKey = secretAccessKey;
+    }
+    set region(value) {
+        this._region = value;
+    }
+    get region() {
+        return this._region;
+    }
+    set service(value) {
+        this._service = value;
+    }
+    get service() {
+        return this._service;
+    }
+    set accessKeyId(value) {
+        this._accessKeyId = value;
+    }
+    get accessKeyId() {
+        return this._accessKeyId;
+    }
+    set secretAccessKey(value) {
+        this._secretAccessKey = value;
+    }
+    get secretAccessKey() {
+        return this._secretAccessKey;
+    }
+}
+exports.AWSConnectAPIConfig = AWSConnectAPIConfig;

package/lib/aws/impl/DynamoDB/DynamoOpenRequest.d.ts

@@ -16,4 +16,3 @@ export declare class DynamoOpenDBRequest extends ServiceDBOpenRequest {
     onsuccess: ((this: IDatabaseRequest<IDatabase>, ev: Event) => any) | null;
     dispatchEvent(event: Event): boolean;
 }
-//# sourceMappingURL=DynamoOpenRequest.d.ts.map

package/lib/aws/impl/DynamoDB/DynamoOpenRequest.js

@@ -1 +1,24 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.DynamoOpenDBRequest=void 0;const e=require("../../abstract/ServiceOpenRequest");class t extends e.ServiceDBOpenRequest{constructor(e,t,n,r,o){super(e,t,r,o,n),this.onblocked=null,this.onupgradeneeded=null,this.onerror=null,this.onsuccess=null,this.result=e}addEventListener(e,t,n){throw new Error("Method not implemented.")}removeEventListener(e,t,n){throw new Error("Method not implemented.")}dispatchEvent(e){throw new Error("Method not implemented.")}}exports.DynamoOpenDBRequest=t;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamoOpenDBRequest = void 0;
+const ServiceOpenRequest_1 = require("../../abstract/ServiceOpenRequest");
+class DynamoOpenDBRequest extends ServiceOpenRequest_1.ServiceDBOpenRequest {
+    constructor(result, readyState, error, source, transaction) {
+        super(result, readyState, source, transaction, error);
+        this.onblocked = null;
+        this.onupgradeneeded = null;
+        this.onerror = null;
+        this.onsuccess = null;
+        this.result = result;
+    }
+    addEventListener(type, listener, options) {
+        throw new Error("Method not implemented.");
+    }
+    removeEventListener(type, listener, options) {
+        throw new Error("Method not implemented.");
+    }
+    dispatchEvent(event) {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.DynamoOpenDBRequest = DynamoOpenDBRequest;

package/lib/aws/impl/DynamoDB/DynamoRequest.d.ts

@@ -14,4 +14,3 @@ export declare class DynamoRequest extends ServiceRequest implements IServiceReq
     removeEventListener(type: unknown, listener: unknown, options?: unknown): void;
     dispatchEvent(event: Event): boolean;
 }
-//# sourceMappingURL=DynamoRequest.d.ts.map

package/lib/aws/impl/DynamoDB/DynamoRequest.js

@@ -1 +1,21 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.DynamoRequest=void 0;const e=require("../../abstract/ServiceRequest");class t extends e.ServiceRequest{constructor(e,t,r,o,n){super(e,t,r,o,n),this.onerror=null,this.onsuccess=null}addEventListener(e,t,r){throw new Error("Method not implemented.")}removeEventListener(e,t,r){throw new Error("Method not implemented.")}dispatchEvent(e){throw new Error("Method not implemented.")}}exports.DynamoRequest=t;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamoRequest = void 0;
+const ServiceRequest_1 = require("../../abstract/ServiceRequest");
+class DynamoRequest extends ServiceRequest_1.ServiceRequest {
+    constructor(result, readyState, error, source, transaction) {
+        super(result, readyState, error, source, transaction);
+        this.onerror = null;
+        this.onsuccess = null;
+    }
+    addEventListener(type, listener, options) {
+        throw new Error("Method not implemented.");
+    }
+    removeEventListener(type, listener, options) {
+        throw new Error("Method not implemented.");
+    }
+    dispatchEvent(event) {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.DynamoRequest = DynamoRequest;

package/lib/aws/impl/DynamoDB/DynamoResourse.d.ts

@@ -27,4 +27,3 @@ export declare class DynamoResource extends ServiceResource {
     removeEventListener(type: unknown, listener: unknown, options?: unknown): void;
     dispatchEvent(event: Event): boolean;
 }
-//# sourceMappingURL=DynamoResourse.d.ts.map

package/lib/aws/impl/DynamoDB/DynamoResourse.js

@@ -1 +1,45 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.DynamoResource=void 0;const e=require("../../abstract/ServiceResource"),r=require("./DynamoTransaction");class t extends e.ServiceResource{constructor(){super(...arguments),this.onabort=null,this.onclose=null,this.onerror=null,this.onversionchange=null}static get DynamoResourceInstance(){return this._dynamoResourceInstance}close(){throw new Error("Method not implemented.")}createObjectStore(e,r){throw new Error("Feature is not available")}fetchObjectStores(){throw new Error("Feature is not available")}deleteObjectStore(e){throw new Error("Feature is not available")}transaction(e,o,n){return new r.DynamoTransaction(t.DynamoResourceInstance,o)}addEventListener(e,r,t){throw new Error("Method not implemented.")}removeEventListener(e,r,t){throw new Error("Method not implemented.")}dispatchEvent(e){throw new Error("Method not implemented.")}}exports.DynamoResource=t;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamoResource = void 0;
+const ServiceResource_1 = require("../../abstract/ServiceResource");
+const DynamoTransaction_1 = require("./DynamoTransaction");
+class DynamoResource extends ServiceResource_1.ServiceResource {
+    constructor() {
+        super(...arguments);
+        this.onabort = null;
+        this.onclose = null;
+        this.onerror = null;
+        this.onversionchange = null;
+    }
+    //TODO : Need to follow the way how Indexed DB uses the transaction to hold the database connection. Refer tansaction method below
+    static get DynamoResourceInstance() {
+        return this._dynamoResourceInstance;
+    }
+    close() {
+        throw new Error("Method not implemented.");
+    }
+    createObjectStore(name, options) {
+        throw new Error("Feature is not available");
+    }
+    fetchObjectStores() {
+        throw new Error("Feature is not available");
+    }
+    deleteObjectStore(name) {
+        throw new Error("Feature is not available");
+    }
+    transaction(storeNames, mode, options) {
+        //Not setting the storenames - need to be checked 
+        //
+        return new DynamoTransaction_1.DynamoTransaction(DynamoResource.DynamoResourceInstance, mode);
+    }
+    addEventListener(type, listener, options) {
+        throw new Error("Method not implemented.");
+    }
+    removeEventListener(type, listener, options) {
+        throw new Error("Method not implemented.");
+    }
+    dispatchEvent(event) {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.DynamoResource = DynamoResource;

package/lib/aws/impl/DynamoDB/DynamoServiceFactory.d.ts

@@ -14,4 +14,3 @@ export declare class DynamoServiceFactory extends ServiceResourceFactory {
     create(database: IDatabase): Promise<IDatabaseRequest<IDatabase>>;
     cmp(first: any, second: any): number;
 }
-//# sourceMappingURL=DynamoServiceFactory.d.ts.map

package/lib/aws/impl/DynamoDB/DynamoServiceFactory.js

@@ -1 +1,63 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.DynamoServiceFactory=void 0;const e=require("tslib"),r=require("../../abstract/ServiceResourceFactory"),o=require("./DynamoOpenRequest"),t=require("./DynamoResourse");class n extends r.ServiceResourceFactory{constructor(e){super(e)}open(e,r){throw new Error("Method not implemented.inside open")}asyncOpen(r,n){return e.__awaiter(this,void 0,void 0,(function*(){try{return new Promise((e=>{e(new o.DynamoOpenDBRequest(new t.DynamoResource("No Database",1),"done"))}))}catch(e){throw new Error("Failed to open connection to DynamoDB:")}}))}deleteDatabase(e){throw new Error("Method not implemented.")}databases(){throw new Error("Method not implemented.")}create(e){throw new Error("Method not implemented.")}cmp(e,r){throw new Error("Method not implemented.")}}exports.DynamoServiceFactory=n;
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamoServiceFactory = void 0;
+const ServiceResourceFactory_1 = require("../../abstract/ServiceResourceFactory");
+const DynamoOpenRequest_1 = require("./DynamoOpenRequest");
+const DynamoResourse_1 = require("./DynamoResourse");
+class DynamoServiceFactory extends ServiceResourceFactory_1.ServiceResourceFactory {
+    constructor(AwsClient) {
+        super(AwsClient);
+        // DynamoServiceFactory.DynamoServiceInstance = new this.awsService.DynamoDB({});
+    }
+    open(name, version) {
+        // console.log("Test---1111",name);
+        // // Assuming you have the AWS configuration set up properly elsewhere
+        // const dynamoDB = new DynamoDB();
+        // // Check if the table exists (assuming "name" is the table name)
+        // dynamoDB.scan({ TableName: name }, (error, data) => {
+        //     if (error) {
+        //         // If an error occurs, throw the error
+        //         throw new Error("Failed to connect to DynamoDB: " + error.message);
+        //     } else {
+        //         // If the table exists, you can do something here
+        //         console.log('Connected to DynamoDB successfully:', data);
+        //         return data;
+        //     }
+        // });
+        throw new Error("Method not implemented.inside open");
+    }
+    asyncOpen(name, version) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return new Promise((resolve) => {
+                    resolve(new DynamoOpenRequest_1.DynamoOpenDBRequest(new DynamoResourse_1.DynamoResource("No Database", 1), 'done'));
+                });
+            }
+            catch (error) {
+                throw new Error("Failed to open connection to DynamoDB:");
+            }
+        });
+    }
+    deleteDatabase(name) {
+        throw new Error("Method not implemented.");
+    }
+    databases() {
+        throw new Error("Method not implemented.");
+    }
+    create(database) {
+        throw new Error("Method not implemented.");
+    }
+    cmp(first, second) {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.DynamoServiceFactory = DynamoServiceFactory;

package/lib/aws/impl/DynamoDB/DynamoTable.d.ts

@@ -24,4 +24,3 @@ export declare class DynamoTable extends ServiceObjectStore {
     put(value: any, key?: IDBValidKey | undefined): IDBRequest<IDBValidKey>;
     put(value: Object, key: IDBValidKey): Promise<IDBRequest<IDBValidKey>>;
 }
-//# sourceMappingURL=DynamoTable.d.ts.map

package/lib/aws/impl/DynamoDB/DynamoTable.js

@@ -1 +1,126 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.DynamoTable=void 0;const e=require("tslib"),t=require("../../../common/utils/pagination"),r=require("../../../common/utils/sort"),o=require("../../../common/utils/search"),n=require("../../../common/utils/filter"),a=require("../../abstract/ServiceObjectStore"),i=require("./DynamoServiceFactory");class s extends a.ServiceObjectStore{constructor(e,t,r,o,n){super(e,t,r,o,n)}add(e,t){return console.log("value ",e,t),i.DynamoServiceFactory.DynamoServiceInstance.create({key:t,data:e})}clear(){throw new Error("Method not implemented.")}count(e){throw new Error("Method not implemented.")}createIndex(e,t,r){throw new Error("Method not implemented.")}delete(e){return i.DynamoServiceFactory.DynamoServiceInstance(e).remove().then((e=>(console.log("delete Dynamo item ",e),!0))).catch((e=>{throw e}))}deleteIndex(e){throw new Error("Method not implemented.")}get(e){return i.DynamoServiceFactory.DynamoServiceInstance(e).fetch().then((e=>e.data))}getAll(e,t){throw new Error("Method not implemented.")}asyncGet(t){return e.__awaiter(this,void 0,void 0,(function*(){throw new Error("Method not implemented.")}))}asyncGetAll(a,s){return e.__awaiter(this,void 0,void 0,(function*(){let e=(yield i.DynamoServiceFactory.DynamoServiceInstance.scan({TableName:this.name}).promise()).Items.map((e=>e)),s=0;if(console.log("items intially:::",e),a&&"object"==typeof a&&(console.log("querry:::",a),"sortOptions"in a&&Array.isArray(a.sortOptions)&&a.sortOptions.forEach((t=>{const o=Object.keys(t)[0];if(o&&t[o]){const n=o,a="ASC"===t[o];e=(0,r.sortData)(e,n,a)}})),"searchOptions"in a&&a.searchOptions&&(e=(0,o.searchData)(e,a.searchOptions)),"filters"in a&&a.filters&&(e=(0,n.filterData)(e,a.filters)),"itemsPerPage"in a)){const r=a.itemsPerPage||5,o=a.pageNo||1;s=e.length&&r<e.length?Math.ceil(e.length/r):0,e=(0,t.paginateData)(e,r,o)}return{totalPages:s,items:e}}))}getAllKeys(e,t){throw new Error("Method not implemented.")}getKey(e){throw new Error("Method not implemented.")}index(e){throw new Error("Method not implemented.")}openCursor(e,t){throw new Error("Method not implemented.")}openKeyCursor(e,t){throw new Error("Method not implemented.")}put(e,t){return i.DynamoServiceFactory.DynamoServiceInstance(t).update({data:e}).then((e=>e.key))}}exports.DynamoTable=s;
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamoTable = void 0;
+const pagination_1 = require("../../../common/utils/pagination");
+const sort_1 = require("../../../common/utils/sort");
+const search_1 = require("../../../common/utils/search");
+const filter_1 = require("../../../common/utils/filter");
+const ServiceObjectStore_1 = require("../../abstract/ServiceObjectStore");
+const DynamoServiceFactory_1 = require("./DynamoServiceFactory");
+class DynamoTable extends ServiceObjectStore_1.ServiceObjectStore {
+    constructor(name, transaction, autoIncrement, indexNames, keyPath) {
+        super(name, transaction, autoIncrement, indexNames, keyPath);
+    }
+    add(value, key) {
+        console.log('value ', value, key);
+        return DynamoServiceFactory_1.DynamoServiceFactory.DynamoServiceInstance.create({ key: key, data: value });
+    }
+    clear() {
+        throw new Error("Method not implemented.");
+    }
+    count(query) {
+        throw new Error("Method not implemented.");
+    }
+    createIndex(name, keyPath, options) {
+        throw new Error("Method not implemented.");
+    }
+    delete(query) {
+        return DynamoServiceFactory_1.DynamoServiceFactory.DynamoServiceInstance(query).remove().then((Item) => {
+            console.log('delete Dynamo item ', Item);
+            return true;
+        }).catch((error) => {
+            throw error;
+        });
+    }
+    deleteIndex(name) {
+        throw new Error("Method not implemented.");
+    }
+    get(query) {
+        return DynamoServiceFactory_1.DynamoServiceFactory.DynamoServiceInstance(query).fetch().then((Item) => {
+            return Item.data;
+        });
+    }
+    getAll(query, count) {
+        throw new Error("Method not implemented.");
+    }
+    asyncGet(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error("Method not implemented.");
+        });
+    }
+    asyncGetAll(query, count) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // let data = await DynamoServiceFactory.DynamoServiceInstance.scan({TableName : this.name }).promise();
+            // // console.log("data----here----", data);
+            // return data;
+            let data = yield DynamoServiceFactory_1.DynamoServiceFactory.DynamoServiceInstance.scan({ TableName: this.name }).promise();
+            let items = data.Items.map((item) => item); // Extract the 'data' field from each item
+            let totalPages = 0;
+            console.log("items intially:::", items);
+            // Check if query is defined and is an object
+            if (query && typeof query === 'object') {
+                console.log("querry:::", query);
+                // Handle sorting
+                if ('sortOptions' in query && Array.isArray(query.sortOptions)) {
+                    query.sortOptions.forEach((item) => {
+                        const key = Object.keys(item)[0];
+                        if (key && item[key]) {
+                            const sortBy = key;
+                            const direction = item[key] === 'ASC';
+                            items = (0, sort_1.sortData)(items, sortBy, direction);
+                        }
+                    });
+                }
+                // Handle searching
+                if ('searchOptions' in query && query.searchOptions) {
+                    items = (0, search_1.searchData)(items, query.searchOptions);
+                }
+                // Handle filtering
+                if ('filters' in query && query.filters) {
+                    items = (0, filter_1.filterData)(items, query.filters);
+                }
+                // Handle pagination
+                if ('itemsPerPage' in query) {
+                    const itemsPerPage = query.itemsPerPage || 5;
+                    const pageNo = query.pageNo || 1;
+                    totalPages = items.length && itemsPerPage < items.length ? Math.ceil(items.length / itemsPerPage) : 0;
+                    items = (0, pagination_1.paginateData)(items, itemsPerPage, pageNo);
+                }
+            }
+            return {
+                totalPages,
+                items
+            };
+        });
+    }
+    getAllKeys(query, count) {
+        throw new Error("Method not implemented.");
+    }
+    getKey(query) {
+        throw new Error("Method not implemented.");
+    }
+    index(name) {
+        throw new Error("Method not implemented.");
+    }
+    openCursor(query, direction) {
+        throw new Error("Method not implemented.");
+    }
+    openKeyCursor(query, direction) {
+        throw new Error("Method not implemented.");
+    }
+    put(value, key) {
+        return DynamoServiceFactory_1.DynamoServiceFactory.DynamoServiceInstance(key).update({ data: value }).then((Item) => {
+            return Item.key;
+        });
+    }
+}
+exports.DynamoTable = DynamoTable;

package/lib/aws/impl/DynamoDB/DynamoTransaction.d.ts

@@ -19,4 +19,3 @@ export declare class DynamoTransaction extends ServiceTransaction {
     removeEventListener(type: unknown, listener: unknown, options?: unknown): void;
     dispatchEvent(event: Event): boolean;
 }
-//# sourceMappingURL=DynamoTransaction.d.ts.map

package/lib/aws/impl/DynamoDB/DynamoTransaction.js

@@ -1 +1,37 @@
-Object.defineProperty(exports,"__esModule",{value:!0}),exports.DynamoTransaction=void 0;const e=require("../../abstract/ServiceTransaction"),t=require("./DynamoServiceFactory"),n=require("./DynamoTable");class r extends e.ServiceTransaction{constructor(e,t,n,r,o){super(e,t,n,r,o),this.onabort=null,this.oncomplete=null,this.onerror=null}static get DynamoInstance(){return r._DynamoInstance}abort(){throw new Error("Method not implemented.")}commit(){throw new Error("Method not implemented.")}objectStore(e){return r._DynamoInstance=t.DynamoServiceFactory.DynamoServiceInstance,new n.DynamoTable(e,this)}addEventListener(e,t,n){throw new Error("Method not implemented.")}removeEventListener(e,t,n){throw new Error("Method not implemented.")}dispatchEvent(e){throw new Error("Method not implemented.")}}exports.DynamoTransaction=r;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DynamoTransaction = void 0;
+const ServiceTransaction_1 = require("../../abstract/ServiceTransaction");
+const DynamoServiceFactory_1 = require("./DynamoServiceFactory");
+const DynamoTable_1 = require("./DynamoTable");
+class DynamoTransaction extends ServiceTransaction_1.ServiceTransaction {
+    constructor(db, mode, error, objectStoreNames, durability) {
+        super(db, mode, error, objectStoreNames, durability);
+        this.onabort = null;
+        this.oncomplete = null;
+        this.onerror = null;
+    }
+    static get DynamoInstance() {
+        return DynamoTransaction._DynamoInstance;
+    }
+    abort() {
+        throw new Error("Method not implemented.");
+    }
+    commit() {
+        throw new Error("Method not implemented.");
+    }
+    objectStore(name) {
+        DynamoTransaction._DynamoInstance = DynamoServiceFactory_1.DynamoServiceFactory.DynamoServiceInstance;
+        return new DynamoTable_1.DynamoTable(name, this); // need to explore how to get the database transaction , which holds the connection
+    }
+    addEventListener(type, listener, options) {
+        throw new Error("Method not implemented.");
+    }
+    removeEventListener(type, listener, options) {
+        throw new Error("Method not implemented.");
+    }
+    dispatchEvent(event) {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.DynamoTransaction = DynamoTransaction;