sim-node-lib 0.0.52 → 0.0.53

package/dist/Enums/PubSubTableEnum.d.ts

@@ -1,5 +1,6 @@
 export declare enum PubSubTableEnum {
     agrupador = "agrupador",
+    autosystem_plate = "autosystema-pessoa_frota",
     bandeira = "bandeira",
     cargo = "cargo",
     cliente = "cliente",

package/dist/Enums/PubSubTableEnum.js

@@ -4,6 +4,7 @@ exports.PubSubTableEnum = void 0;
 var PubSubTableEnum;
 (function (PubSubTableEnum) {
     PubSubTableEnum["agrupador"] = "agrupador";
+    PubSubTableEnum["autosystem_plate"] = "autosystema-pessoa_frota";
     PubSubTableEnum["bandeira"] = "bandeira";
     PubSubTableEnum["cargo"] = "cargo";
     PubSubTableEnum["cliente"] = "cliente";

package/dist/google-pub-sub.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+export declare class PubSubModel {
+    readonly value: object;
+    readonly action: string;
+    readonly table: string;
+    constructor(value: object, action: PubSubActionEnum, table: string);
+}
+export declare class GooglePubSubSubscription {
+    constructor(subscriptionName: string);
+    private _subscription;
+    listenMessages(eventEmitter: EventEmitter): Promise<void>;
+}
+export declare class GooglePubSubPublish {
+    constructor(topicName: string);
+    private _topicName;
+    createMessages(message: object, action: PubSubActionEnum, table: string): Promise<void>;
+}
+export declare abstract class PubSubHandelerAction {
+    constructor(pubsubModel: PubSubModel);
+    protected _pubsubValueModel: any;
+    protected handlerAction(action: string): void;
+    protected insert(): void;
+    protected update(): void;
+    protected remove(): void;
+    protected buildData(): Object;
+}
+export declare enum PubSubActionEnum {
+    insert = "insert",
+    update = "update",
+    remove = "remove"
+}

package/dist/google-pub-sub.js

@@ -0,0 +1,107 @@
+"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 });
+const pubsub_1 = require("@google-cloud/pubsub");
+class PubSubModel {
+    constructor(value, action, table) {
+        this.value = value;
+        this.action = action.toString();
+        this.table = table;
+    }
+}
+exports.PubSubModel = PubSubModel;
+class GooglePubSubSubscription {
+    constructor(subscriptionName) {
+        this._subscription = new pubsub_1.PubSub().subscription(subscriptionName);
+    }
+    listenMessages(eventEmitter) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._subscription.on('message', (message) => {
+                try {
+                    const data = JSON.parse(message.data.toString());
+                    const pubSubModel = new PubSubModel(data.value, data.action, data.table);
+                    eventEmitter.emit('event', [pubSubModel, message]);
+                }
+                catch (error) {
+                    console.error(error);
+                    throw Error(error);
+                }
+            });
+            // Receive callbacks for errors on the subscription
+            this._subscription.on('error', (error) => {
+                console.error('Received error:', error);
+                throw Error(error);
+            });
+        });
+    }
+}
+exports.GooglePubSubSubscription = GooglePubSubSubscription;
+class GooglePubSubPublish {
+    constructor(topicName) {
+        this._topicName = topicName;
+    }
+    createMessages(message, action, table) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pubSubClient = new pubsub_1.PubSub();
+            const send = new PubSubModel(message, action, table);
+            // Creates a new topic
+            const topic = pubSubClient.topic(this._topicName);
+            console.log(`Topic ${topic.name} created.`);
+            const dataSend = JSON.stringify(send);
+            //Create message
+            const data = Buffer.from(dataSend);
+            // Send a message to the topic
+            yield topic.publishMessage({ data });
+        });
+    }
+}
+exports.GooglePubSubPublish = GooglePubSubPublish;
+class PubSubHandelerAction {
+    constructor(pubsubModel) {
+        this._pubsubValueModel = pubsubModel.value;
+        this.handlerAction(pubsubModel.action);
+    }
+    handlerAction(action) {
+        switch (action) {
+            case 'insert':
+                this.insert();
+                break;
+            case 'update':
+                this.update();
+                break;
+            case 'delete':
+                this.remove();
+                break;
+            default:
+                this.insert();
+            //throw new Error('PubSub handler action not implemented.')
+        }
+    }
+    insert() {
+        throw new Error('Method insert PubSub handler action not implemented.');
+    }
+    update() {
+        throw new Error('Method update PubSub handler action not implemented.');
+    }
+    remove() {
+        throw new Error('Method remove PubSub handler action not implemented.');
+    }
+    buildData() {
+        throw new Error('Method buildData PubSub handler action not implemented.');
+    }
+}
+exports.PubSubHandelerAction = PubSubHandelerAction;
+var PubSubActionEnum;
+(function (PubSubActionEnum) {
+    PubSubActionEnum["insert"] = "insert";
+    PubSubActionEnum["update"] = "update";
+    PubSubActionEnum["remove"] = "remove";
+})(PubSubActionEnum = exports.PubSubActionEnum || (exports.PubSubActionEnum = {}));

package/dist/hello-world.d.ts

@@ -0,0 +1,2 @@
+export declare function sayHello(): void;
+export declare function sayGoodbye(): void;

package/dist/hello-world.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("dotenv").config();
+function sayHello() {
+    console.log("hi my friend, the NODE PORT  is: ", process.env.PORT);
+}
+exports.sayHello = sayHello;
+function sayGoodbye() {
+    console.log("goodbye");
+}
+exports.sayGoodbye = sayGoodbye;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sim-node-lib",
-  "version": "0.0.52",
+  "version": "0.0.53",
   "description": "Library from SIMLabs",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",