hgs-twilio-class-lib 1.1.72 → 1.1.74

package/README.md

@@ -1,5 +1,5 @@
-# Flex V2 Backend Code 
-
-Package to manage Flex V2 Backend.
-
-Run "npm install hgs-twilio-class-lib --save"
+# Flex V2 Backend Code 
+
+Package to manage Flex V2 Backend.
+
+Run "npm install hgs-twilio-class-lib --save"

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

@@ -0,0 +1,9 @@
+import { DatabaseObjectStore } from "../../common/abstract/DatabaseObjectStore";
+import { SearchParameterType } from "../../common/type/SearchParameterType";
+import { IServiceObjectStore } from "../interface/IServiceObjectStore";
+import { IServiceTransaction } from "../interface/IServiceTransation";
+export declare abstract class ServiceObjectStore extends DatabaseObjectStore implements IServiceObjectStore {
+    constructor(name: string, transaction?: IServiceTransaction, autoIncrement?: boolean, indexNames?: DOMStringList, keyPath?: string);
+    abstract asyncGet(query: IDBValidKey | IDBKeyRange): Promise<any[]>;
+    abstract asyncGetAll(query: SearchParameterType, count?: number | undefined): Promise<IDBRequest<any[]>>;
+}

package/lib/aws/abstract/ServiceObjectStore.js

@@ -0,0 +1,10 @@
+"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

@@ -0,0 +1,7 @@
+import { DatabaseOpenRequest } from "../../common/abstract/DatabaseOpenRequest";
+import { IServiceDBOpenRequest } from "../interface/IServiceDBOpenRequest";
+import { IServiceObjectStore } from "../interface/IServiceObjectStore";
+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);
+}

package/lib/aws/abstract/ServiceOpenRequest.js

@@ -0,0 +1,10 @@
+"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

@@ -0,0 +1,3 @@
+import { DatabaseRequest } from "../../common/abstract/DatabaseRequest";
+export declare abstract class ServiceRequest extends DatabaseRequest {
+}

package/lib/aws/abstract/ServiceRequest.js

@@ -0,0 +1,7 @@
+"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

@@ -0,0 +1,20 @@
+import { Database } from "../../common/abstract/Database";
+import { IServiceObjectStore } from "../interface/IServiceObjectStore";
+import { IServiceObjectStoreParameters } from "../interface/IServiceObjectStoreParameters";
+import { IServiceResource } from "../interface/IServiceResource";
+export declare abstract class ServiceResource extends Database implements IServiceResource {
+    private _region;
+    private _endpoint;
+    private _accessKeyId;
+    private _secretAccessKey;
+    get region(): string;
+    set region(value: string);
+    get endpoint(): string;
+    set endpoint(value: string);
+    get accessKeyId(): string;
+    set accessKeyId(value: string);
+    get secretAccessKey(): string;
+    set secretAccessKey(value: string);
+    abstract createObjectStore(name: string, options?: IServiceObjectStoreParameters | undefined): IServiceObjectStore;
+    abstract fetchObjectStores(): IServiceObjectStore[];
+}

package/lib/aws/abstract/ServiceResource.js

@@ -0,0 +1,31 @@
+"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

@@ -0,0 +1,13 @@
+import { DatabaseFactory } from "../../common/abstract/DatabaseFactory";
+import { IDatabaseInfo } from "../../common/interface/IDatabaesInfo";
+import { IServiceDBOpenRequest } from "../interface/IServiceDBOpenRequest";
+import { AWSClient } from "../impl/AWSClient";
+export declare abstract class ServiceResourceFactory extends DatabaseFactory {
+    private _awsService;
+    constructor(AWSClient: AWSClient);
+    get awsService(): any;
+    abstract open(name: string, version?: number): IServiceDBOpenRequest;
+    abstract asyncOpen(name: string, version?: number): Promise<IServiceDBOpenRequest>;
+    abstract deleteDatabase(name: string): IServiceDBOpenRequest;
+    abstract databases(): Promise<IDatabaseInfo[]>;
+}

package/lib/aws/abstract/ServiceResourceFactory.js

@@ -0,0 +1,14 @@
+"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

@@ -0,0 +1,6 @@
+import { DatabaseTransaction } from "../../common/abstract/DatabaseTransaction";
+import { IServiceResource } from "../interface/IServiceResource";
+export declare abstract class ServiceTransaction extends DatabaseTransaction {
+    private _syncResource;
+    constructor(db: IServiceResource, mode: IDBTransactionMode, error?: DOMException | null, objectStoreNames?: DOMStringList, durability?: IDBTransactionDurability);
+}

package/lib/aws/abstract/ServiceTransaction.js

@@ -0,0 +1,11 @@
+"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

@@ -0,0 +1,14 @@
+import { DatabaseTypes, IDatabaseClientConfig } from "../../common/interface/IDatabaseConfig";
+export declare class AWSAPIConfig implements IDatabaseClientConfig {
+    type: DatabaseTypes;
+    private _region;
+    private _accessKeyId;
+    private _secretAccessKey;
+    constructor(region: string, accessKeyId: string, secretAccessKey: string);
+    set region(value: string);
+    get region(): string;
+    set accessKeyId(value: string);
+    get accessKeyId(): string;
+    set secretAccessKey(value: string);
+    get secretAccessKey(): string;
+}

package/lib/aws/impl/AWSAPIConfig.js

@@ -0,0 +1,38 @@
+"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

@@ -0,0 +1,5 @@
+import { AWSConnectAPIConfig } from './AWSConnectAPIConfig';
+import { DatabaseClient } from '../../common/abstract/DatabaseClient';
+export declare class AWSClient extends DatabaseClient {
+    constructor(AWSClientConfig: AWSConnectAPIConfig);
+}

package/lib/aws/impl/AWSClient.js

@@ -0,0 +1,21 @@
+"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

@@ -0,0 +1,17 @@
+import { DatabaseTypes, IDatabaseClientConfig } from "../../common/interface/IDatabaseConfig";
+export declare class AWSConnectAPIConfig implements IDatabaseClientConfig {
+    type: DatabaseTypes;
+    private _region;
+    private _service;
+    private _accessKeyId;
+    private _secretAccessKey;
+    constructor(region: string, service: string, accessKeyId: string, secretAccessKey: string);
+    set region(value: string);
+    get region(): string;
+    set service(value: string);
+    get service(): string;
+    set accessKeyId(value: string);
+    get accessKeyId(): string;
+    set secretAccessKey(value: string);
+    get secretAccessKey(): string;
+}

package/lib/aws/impl/AWSConnectAPIConfig.js

@@ -0,0 +1,38 @@
+"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

@@ -0,0 +1,18 @@
+import { IDatabase } from "../../../common/interface/IDatabase";
+import { IDatabaseRequest } from "../../../common/interface/IDatabaseRequest";
+import { ServiceDBOpenRequest } from "../../abstract/ServiceOpenRequest";
+import { IServiceDBOpenRequest } from "../../interface/IServiceDBOpenRequest";
+import { IServiceObjectStore } from "../../interface/IServiceObjectStore";
+import { IServiceTransaction } from "../../interface/IServiceTransation";
+export declare class DynamoOpenDBRequest extends ServiceDBOpenRequest {
+    constructor(result: any, readyState: IDBRequestReadyState, error?: any | null, source?: IServiceObjectStore, transaction?: IServiceTransaction);
+    onblocked: ((this: IServiceDBOpenRequest, ev: IDBVersionChangeEvent) => any) | null;
+    onupgradeneeded: ((this: IServiceDBOpenRequest, ev: IDBVersionChangeEvent) => any) | null;
+    addEventListener<K extends keyof IDBOpenDBRequestEventMap>(type: K, listener: (this: IServiceDBOpenRequest, ev: IDBOpenDBRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+    removeEventListener<K extends keyof IDBOpenDBRequestEventMap>(type: K, listener: (this: IServiceDBOpenRequest, ev: IDBOpenDBRequestEventMap[K]) => any, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+    onerror: ((this: IDatabaseRequest<IDatabase>, ev: Event) => any) | null;
+    onsuccess: ((this: IDatabaseRequest<IDatabase>, ev: Event) => any) | null;
+    dispatchEvent(event: Event): boolean;
+}

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

@@ -0,0 +1,24 @@
+"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

@@ -0,0 +1,16 @@
+import { ServiceRequest } from "../../abstract/ServiceRequest";
+import { IServiceObjectStore } from "../../interface/IServiceObjectStore";
+import { IServiceRequest } from "../../interface/IServiceRequest";
+import { IServiceTransaction } from "../../interface/IServiceTransation";
+export declare class DynamoRequest extends ServiceRequest implements IServiceRequest<any> {
+    constructor(result: any, readyState: IDBRequestReadyState, error?: any | null, source?: IServiceObjectStore, transaction?: IServiceTransaction);
+    onerror: ((this: IServiceRequest<any>, ev: Event) => any) | null;
+    onsuccess: ((this: IServiceRequest<any>, ev: Event) => any) | null;
+    addEventListener<K extends keyof IDBRequestEventMap>(type: K, listener: (this: IServiceRequest<any>, ev: IDBRequestEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+    addEventListener(type: unknown, listener: unknown, options?: unknown): void;
+    removeEventListener<K extends keyof IDBRequestEventMap>(type: K, listener: (this: IServiceRequest<any>, ev: IDBRequestEventMap[K]) => any, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: unknown, listener: unknown, options?: unknown): void;
+    dispatchEvent(event: Event): boolean;
+}

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

@@ -0,0 +1,21 @@
+"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

@@ -0,0 +1,29 @@
+import { IDatabase } from "../../../common/interface/IDatabase";
+import { ServiceResource } from "../../abstract/ServiceResource";
+import { IServiceObjectStoreParameters } from "../../interface/IServiceObjectStoreParameters";
+import { IServiceResource } from "../../interface/IServiceResource";
+import { IServiceTransaction } from "../../interface/IServiceTransation";
+import { ISyncTransactionOptions } from "../../interface/ISyncTransactionOptions";
+import { DynamoTable } from "./DynamoTable";
+export declare class DynamoResource extends ServiceResource {
+    private static _dynamoResourceInstance;
+    static get DynamoResourceInstance(): any;
+    onabort: ((this: IDatabase, ev: Event) => any) | null;
+    onclose: ((this: IDatabase, ev: Event) => any) | null;
+    onerror: ((this: IDatabase, ev: Event) => any) | null;
+    onversionchange: ((this: IDatabase, ev: IDBVersionChangeEvent) => any) | null;
+    close(): void;
+    createObjectStore(name: string, options: IServiceObjectStoreParameters): DynamoTable;
+    fetchObjectStores(): DynamoTable[];
+    deleteObjectStore(name: string): void;
+    transaction(storeNames: string | string[], mode?: IDBTransactionMode | undefined, options?: ISyncTransactionOptions | undefined): IServiceTransaction;
+    transaction(storeNames: string | Iterable<string>, mode?: IDBTransactionMode | undefined, options?: ISyncTransactionOptions | undefined): IServiceTransaction;
+    transaction(storeNames: unknown, mode?: unknown, options?: unknown): IServiceTransaction;
+    addEventListener<K extends keyof IDBDatabaseEventMap>(type: K, listener: (this: IServiceResource, ev: IDBDatabaseEventMap[K]) => any, options?: boolean | AddEventListenerOptions | undefined): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions | undefined): void;
+    addEventListener(type: unknown, listener: unknown, options?: unknown): void;
+    removeEventListener<K extends keyof IDBDatabaseEventMap>(type: K, listener: (this: IServiceResource, ev: IDBDatabaseEventMap[K]) => any, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions | undefined): void;
+    removeEventListener(type: unknown, listener: unknown, options?: unknown): void;
+    dispatchEvent(event: Event): boolean;
+}

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

@@ -0,0 +1,45 @@
+"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

@@ -0,0 +1,16 @@
+import { IDatabaseInfo } from "../../../common/interface/IDatabaesInfo";
+import { IDatabase } from "../../../common/interface/IDatabase";
+import { IDatabaseRequest } from "../../../common/interface/IDatabaseRequest";
+import { ServiceResourceFactory } from "../../abstract/ServiceResourceFactory";
+import { IServiceDBOpenRequest } from "../../interface/IServiceDBOpenRequest";
+import { AWSClient } from "../AWSClient";
+export declare class DynamoServiceFactory extends ServiceResourceFactory {
+    static DynamoServiceInstance: any;
+    constructor(AwsClient: AWSClient);
+    open(name: string, version?: number): IServiceDBOpenRequest;
+    asyncOpen(name: string, version?: number): Promise<IServiceDBOpenRequest>;
+    deleteDatabase(name: string): IServiceDBOpenRequest;
+    databases(): Promise<IDatabaseInfo[]>;
+    create(database: IDatabase): Promise<IDatabaseRequest<IDatabase>>;
+    cmp(first: any, second: any): number;
+}

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

@@ -0,0 +1,63 @@
+"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

@@ -0,0 +1,26 @@
+import { SearchParameterType } from "../../../common/type/SearchParameterType";
+import { ServiceObjectStore } from "../../abstract/ServiceObjectStore";
+export declare class DynamoTable extends ServiceObjectStore {
+    constructor(name: string, transaction?: IDBTransaction, autoIncrement?: boolean, indexNames?: DOMStringList, keyPath?: string);
+    add(value: any, key?: IDBValidKey | undefined): IDBRequest<IDBValidKey>;
+    clear(): IDBRequest<undefined>;
+    count(query?: IDBValidKey | IDBKeyRange | undefined): IDBRequest<number>;
+    createIndex(name: string, keyPath: string | string[], options?: IDBIndexParameters | undefined): IDBIndex;
+    createIndex(name: string, keyPath: string | Iterable<string>, options?: IDBIndexParameters | undefined): IDBIndex;
+    createIndex(name: unknown, keyPath: unknown, options?: unknown): IDBIndex;
+    delete(query: IDBValidKey | IDBKeyRange): IDBRequest<undefined>;
+    delete(query: IDBValidKey | IDBKeyRange): Promise<IDBRequest<undefined>>;
+    deleteIndex(name: string): void;
+    get(query: IDBValidKey | IDBKeyRange): IDBRequest<any>;
+    getAll(query?: IDBValidKey | IDBKeyRange | null | undefined, count?: number | undefined): IDBRequest<any[]>;
+    getAll(query: SearchParameterType, count?: number | undefined): Promise<IDBRequest<any[]>>;
+    asyncGet(query: IDBValidKey | IDBKeyRange): Promise<any[]>;
+    asyncGetAll(query: SearchParameterType, count?: number | undefined): Promise<any>;
+    getAllKeys(query?: IDBValidKey | IDBKeyRange | null | undefined, count?: number | undefined): IDBRequest<IDBValidKey[]>;
+    getKey(query: IDBValidKey | IDBKeyRange): IDBRequest<IDBValidKey | undefined>;
+    index(name: string): IDBIndex;
+    openCursor(query?: IDBValidKey | IDBKeyRange | null | undefined, direction?: IDBCursorDirection | undefined): IDBRequest<IDBCursorWithValue | null>;
+    openKeyCursor(query?: IDBValidKey | IDBKeyRange | null | undefined, direction?: IDBCursorDirection | undefined): IDBRequest<IDBCursor | null>;
+    put(value: any, key?: IDBValidKey | undefined): IDBRequest<IDBValidKey>;
+    put(value: Object, key: IDBValidKey): Promise<IDBRequest<IDBValidKey>>;
+}