hgs-twilio-class-lib 1.1.72 → 1.1.73

package/lib/twilio/impl/sync/SyncMapTransaction.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncMapTransaction = void 0;
+const ServiceTransaction_1 = require("../../abstract/ServiceTransaction");
+const SyncMap_1 = require("./SyncMap");
+const SyncServiceFactory_1 = require("./SyncServiceFactory");
+class SyncMapTransaction 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 syncMapInstance() {
+        return SyncMapTransaction._syncMapInstance;
+    }
+    abort() {
+        throw new Error("Method not implemented.");
+    }
+    commit() {
+        throw new Error("Method not implemented.");
+    }
+    objectStore(name) {
+        SyncMapTransaction._syncMapInstance = SyncServiceFactory_1.SyncServiceFactory.syncServiceInstance.syncMaps(name);
+        console.log('map try ', SyncMapTransaction._syncMapInstance);
+        return new SyncMap_1.SyncMap(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.SyncMapTransaction = SyncMapTransaction;

package/lib/twilio/impl/sync/SyncOpenRequest.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 SyncOpenDBRequest 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/twilio/impl/sync/SyncOpenRequest.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncOpenDBRequest = void 0;
+const ServiceOpenRequest_1 = require("../../abstract/ServiceOpenRequest");
+class SyncOpenDBRequest 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.SyncOpenDBRequest = SyncOpenDBRequest;

package/lib/twilio/impl/sync/SyncRequest.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 SyncRequest 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/twilio/impl/sync/SyncRequest.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncRequest = void 0;
+const ServiceRequest_1 = require("../../abstract/ServiceRequest");
+class SyncRequest 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.SyncRequest = SyncRequest;

package/lib/twilio/impl/sync/SyncResource.d.ts

@@ -0,0 +1,50 @@
+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 { SyncDocument } from "./SyncDocument";
+import { SyncList } from "./SyncList";
+import { SyncMap } from "./SyncMap";
+export declare class SyncResource extends ServiceResource {
+    private _createdBy;
+    private _dateExpires;
+    private _revision;
+    private _serviceSid;
+    private _uniqueName;
+    private _url;
+    private static _syncResourceInstance;
+    constructor(name: string, version?: number);
+    static get syncResourceInstance(): any;
+    get createdBy(): string;
+    set createdBy(value: string);
+    get dateExpires(): Date;
+    set dateExpires(value: Date);
+    get revision(): string;
+    set revision(value: string);
+    get serviceSid(): string;
+    set serviceSid(value: string);
+    get uniqueName(): string;
+    set uniqueName(value: string);
+    get url(): string;
+    set url(value: string);
+    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): SyncMap | SyncDocument | SyncList;
+    fetchObjectStores(): SyncMap[] | SyncDocument[] | SyncDocument[];
+    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/twilio/impl/sync/SyncResource.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncResource = void 0;
+const ServiceResource_1 = require("../../abstract/ServiceResource");
+const SyncMapTransaction_1 = require("./SyncMapTransaction");
+const SyncServiceFactory_1 = require("./SyncServiceFactory");
+class SyncResource extends ServiceResource_1.ServiceResource {
+    constructor(name, version = 1) {
+        super(name, version);
+        // get dbConnection() {
+        //     return this._dbConnection;
+        // }
+        this.onabort = null;
+        this.onclose = null;
+        this.onerror = null;
+        this.onversionchange = null;
+    }
+    static get syncResourceInstance() {
+        return this._syncResourceInstance;
+    }
+    get createdBy() {
+        return this._createdBy;
+    }
+    set createdBy(value) {
+        this._createdBy = value;
+    }
+    get dateExpires() {
+        return this._dateExpires;
+    }
+    set dateExpires(value) {
+        this._dateExpires = value;
+    }
+    get revision() {
+        return this._revision;
+    }
+    set revision(value) {
+        this._revision = value;
+    }
+    get serviceSid() {
+        return this._serviceSid;
+    }
+    set serviceSid(value) {
+        this._serviceSid = value;
+    }
+    get uniqueName() {
+        return this._uniqueName;
+    }
+    set uniqueName(value) {
+        this._uniqueName = value;
+    }
+    get url() {
+        return this._url;
+    }
+    set url(value) {
+        this._url = value;
+    }
+    close() {
+        throw new Error("Method not implemented.");
+    }
+    createObjectStore(name, options) {
+        throw new Error("Method not implemented.");
+        // if (options?.serviceResourceType === 'Document') {
+        //     // return this.SyncDocuments.create({ uniqueName: name }).then({
+        //     // });
+        //     return this.db
+        // }
+        // return this.dbConnection;
+        // else if (options?.serviceResourceType === 'Map') {
+        //     return this.SyncMaps.create({ uniqueName: name });
+        // }
+        // else { //Consider default is List 
+        //     return this.syncLists.create({ uniqueName: name });
+        // }
+    }
+    fetchObjectStores() {
+        throw new Error("Method not implemented.");
+    }
+    deleteObjectStore(name) {
+        throw new Error("Method not implemented.");
+    }
+    transaction(storeNames, mode, options) {
+        //Not setting the storenames - need to be checked 
+        //
+        SyncResource._syncResourceInstance = SyncServiceFactory_1.SyncServiceFactory.syncServiceInstance;
+        return new SyncMapTransaction_1.SyncMapTransaction(SyncServiceFactory_1.SyncServiceFactory.syncServiceInstance, 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.SyncResource = SyncResource;

package/lib/twilio/impl/sync/SyncServiceFactory.d.ts

@@ -0,0 +1,22 @@
+import { IDatabase } from "../../../common/interface/IDatabase";
+import { ServiceResourceFactory } from "../../abstract/ServiceResourceFactory";
+import { IServiceDBOpenRequest } from "../../interface/IServiceDBOpenRequest";
+import { IServiceRequest } from "../../interface/IServiceRequest";
+import { IServiceResource } from "../../interface/IServiceResource";
+import { TwilioClient } from "../TwilioClient";
+export declare class SyncServiceFactory extends ServiceResourceFactory {
+    private _syncServiceSid?;
+    private static _syncServiceInstance;
+    constructor(twilioClient: TwilioClient);
+    static get syncServiceInstance(): any;
+    open(name: string, version: number): IServiceDBOpenRequest;
+    asyncOpen(name: string, version: number): Promise<IServiceDBOpenRequest>;
+    deleteDatabase(name: string): IServiceDBOpenRequest;
+    databases(name?: string): Promise<IServiceResource[]>;
+    create(database: IDatabase): Promise<IServiceRequest<IDatabase>>;
+    cmp(first: any, second: any): number;
+    getDatabase(): any;
+    private checkDatabaseExists;
+    private setDatabaseDetails;
+    private syncServiceOpen;
+}

package/lib/twilio/impl/sync/SyncServiceFactory.js

@@ -0,0 +1,117 @@
+"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.SyncServiceFactory = void 0;
+const ServiceResourceFactory_1 = require("../../abstract/ServiceResourceFactory");
+const SyncOpenRequest_1 = require("./SyncOpenRequest");
+const SyncRequest_1 = require("./SyncRequest");
+const SyncResource_1 = require("./SyncResource");
+class SyncServiceFactory extends ServiceResourceFactory_1.ServiceResourceFactory {
+    constructor(twilioClient) {
+        super(twilioClient);
+    }
+    static get syncServiceInstance() {
+        return SyncServiceFactory._syncServiceInstance;
+    }
+    open(name, version) {
+        throw new Error("Method not implemented.");
+    }
+    asyncOpen(name, version) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.setDatabaseDetails(name, version);
+            if (this._syncServiceSid) {
+                return new Promise((resolve) => {
+                    resolve(new SyncOpenRequest_1.SyncOpenDBRequest(new SyncResource_1.SyncResource(this._syncServiceSid ? this._syncServiceSid : ""), 'done'));
+                });
+            }
+            else {
+                const error = new Error("Database does not exists: " + name);
+                return new Promise((resolve) => {
+                    resolve(new SyncOpenRequest_1.SyncOpenDBRequest(null, "done", error));
+                });
+            }
+        });
+    }
+    deleteDatabase(name) {
+        return this.syncService(name).remove().then((res) => {
+            return new SyncOpenRequest_1.SyncOpenDBRequest(res, 'done');
+        }).catch((err) => {
+            console.log(err);
+            return new SyncOpenRequest_1.SyncOpenDBRequest(null, 'done', err);
+        });
+    }
+    databases(name) {
+        return this.syncService.list();
+    }
+    create(database) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const syncResources = yield this.databases();
+                const existingSyncResource = syncResources.filter((syncResource) => {
+                    return syncResource.friendlyName === database.name + '-' + database.version;
+                });
+                if (existingSyncResource.length > 0) {
+                    const error = new Error("Database already exists: " + database.name + '-' + database.version);
+                    return new SyncRequest_1.SyncRequest(null, "done", error);
+                }
+                else {
+                    return this.syncService.create({ friendlyName: database.name + '-' + database.version });
+                }
+            }
+            catch (error) {
+                return new SyncRequest_1.SyncRequest(null, "done", error);
+            }
+        });
+    }
+    cmp(first, second) {
+        throw new Error("Method not implemented.");
+    }
+    getDatabase() {
+        return this.syncService(this._syncServiceSid);
+    }
+    checkDatabaseExists(name, version) {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('database and version ', `${name}-${version}`);
+            let syncServices = yield this.databases();
+            const existingSyncService = syncServices.filter((syncResource) => {
+                return syncResource.friendlyName === `${name}-${version}`;
+            });
+            return existingSyncService;
+        });
+    }
+    setDatabaseDetails(name, version) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const existingResource = yield this.checkDatabaseExists(name, version);
+            console.log('existingResource', existingResource);
+            if (existingResource.length === 0) {
+                this._syncServiceSid = undefined;
+            }
+            else {
+                this._syncServiceSid = existingResource[0].sid;
+                SyncServiceFactory._syncServiceInstance = this.syncService(this._syncServiceSid);
+            }
+            return this._syncServiceSid;
+        });
+    }
+    syncServiceOpen(name, version) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.setDatabaseDetails(name, version);
+            if (this._syncServiceSid) {
+                return new SyncOpenRequest_1.SyncOpenDBRequest(new SyncResource_1.SyncResource(this._syncServiceSid), 'done');
+            }
+            else {
+                const error = new Error("Database does not exists: " + name);
+                return new SyncOpenRequest_1.SyncOpenDBRequest(null, "done", error);
+            }
+        });
+    }
+}
+exports.SyncServiceFactory = SyncServiceFactory;

package/lib/twilio/interface/IDirection.d.ts

@@ -0,0 +1,2 @@
+export interface InterfaceDirection {
+}

package/lib/twilio/interface/IDirection.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/twilio/interface/ILink.d.ts

@@ -0,0 +1,2 @@
+export interface InterfaceLink {
+}

package/lib/twilio/interface/ILink.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/twilio/interface/IServiceDBOpenRequest.d.ts

@@ -0,0 +1,3 @@
+import { IDatabaseDBOpenRequest } from "../../common/interface/IDatabaseDBOpenRequest";
+export interface IServiceDBOpenRequest extends IDatabaseDBOpenRequest {
+}

package/lib/twilio/interface/IServiceDBOpenRequest.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/twilio/interface/IServiceObjectStore.d.ts

@@ -0,0 +1,3 @@
+import { IDatabaseObjectStore } from "../../common/interface/IDatabaseObjectStore";
+export interface IServiceObjectStore extends IDatabaseObjectStore {
+}

package/lib/twilio/interface/IServiceObjectStore.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/twilio/interface/IServiceObjectStoreParameters.d.ts

@@ -0,0 +1,4 @@
+import { IDatabaseObjectStoreParameters } from "../../common/interface/IDatabaseObjectStoreParameters";
+export interface IServiceObjectStoreParameters extends IDatabaseObjectStoreParameters {
+    serviceResourceType: 'Document' | 'List' | 'Map';
+}

package/lib/twilio/interface/IServiceObjectStoreParameters.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/twilio/interface/IServiceRequest.d.ts

@@ -0,0 +1,3 @@
+import { IDatabaseRequest } from "../../common/interface/IDatabaseRequest";
+export interface IServiceRequest<T> extends IDatabaseRequest<T> {
+}

package/lib/twilio/interface/IServiceRequest.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/twilio/interface/IServiceResource.d.ts

@@ -0,0 +1,8 @@
+import { IDatabase } from "../../common/interface/IDatabase";
+export interface IServiceResource extends IDatabase {
+    accountSid: string;
+    dateCreated: Date;
+    dateUpdated: Date;
+    links: Record<string, string>;
+    sid: string;
+}

package/lib/twilio/interface/IServiceResource.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/twilio/interface/IServiceTransation.d.ts

@@ -0,0 +1,3 @@
+import { IDatabaseTransaction } from "../../common/interface/IDatabaseTransaction";
+export interface IServiceTransaction extends IDatabaseTransaction {
+}

package/lib/twilio/interface/IServiceTransation.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/twilio/interface/ISubResourceUri.d.ts

@@ -0,0 +1,2 @@
+export interface InterfaceSubResourceUris {
+}

package/lib/twilio/interface/ISubResourceUri.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/twilio/interface/ISyncItemData.js

@@ -0,0 +1 @@
+"use strict";

package/lib/twilio/interface/ISyncObjectStoreParameters.js

@@ -0,0 +1 @@
+"use strict";

package/lib/twilio/interface/ISyncTransactionOptions.d.ts

@@ -0,0 +1,4 @@
+import { IDatabaseTransactionOptions } from "../../common/interface/IDatabaseTransactionOptions";
+export interface ISyncTransactionOptions extends IDatabaseTransactionOptions {
+    syncResource: "Document" | "List" | "Map";
+}

package/lib/twilio/interface/ISyncTransactionOptions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hgs-twilio-class-lib",
-  "version": "1.1.72",
+  "version": "1.1.73",
   "description": "Flex 2.0 backend to connect with any database ",
   "main": "./lib/index.js",
   "types": "./types/index.d.ts",