@socket.tech/dl-common 1.0.3-test.8 → 1.0.4

package/dist/dl-common/models/proposal.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addProposalHooks = exports.ProposalModel = exports.Proposal = exports.ProposalTripRelayStatus = exports.MatchState = exports.RootMatchState = exports.TripStatus = void 0;
+const sequelize_1 = require("sequelize");
+const utils_1 = require("../utils");
+var TripStatus;
+(function (TripStatus) {
+    TripStatus["TRIP_REQUIRED"] = "TRIP_REQUIRED";
+    TripStatus["TRIP_INITIATED"] = "TRIP_INITIATED";
+    TripStatus["TRIP_SUCCESSFUL"] = "TRIP_SUCCESSFUL";
+    TripStatus["TRIP_FAILED"] = "TRIP_FAILED";
+    TripStatus["NO"] = "NO";
+})(TripStatus || (exports.TripStatus = TripStatus = {}));
+var RootMatchState;
+(function (RootMatchState) {
+    RootMatchState["ROOTS_MATCHED"] = "ROOTS_MATCHED";
+    RootMatchState["ROOTS_MISMATCHED"] = "ROOTS_MISMATCHED";
+    RootMatchState["NO"] = "NO";
+})(RootMatchState || (exports.RootMatchState = RootMatchState = {}));
+var MatchState;
+(function (MatchState) {
+    MatchState["MATCHED"] = "MATCHED";
+    MatchState["MISMATCHED"] = "MISMATCHED";
+    MatchState["NO"] = "NO";
+})(MatchState || (exports.MatchState = MatchState = {}));
+var ProposalTripRelayStatus;
+(function (ProposalTripRelayStatus) {
+    ProposalTripRelayStatus["IS_TRIPPING"] = "IS_TRIPPING";
+    ProposalTripRelayStatus["NO"] = "NO";
+    ProposalTripRelayStatus["TRIPPING_FAILED"] = "TRIPPING_FAILED";
+    ProposalTripRelayStatus["TRIPPED"] = "TRIPPED";
+})(ProposalTripRelayStatus || (exports.ProposalTripRelayStatus = ProposalTripRelayStatus = {}));
+class Proposal extends sequelize_1.Model {
+}
+exports.Proposal = Proposal;
+exports.ProposalModel = {
+    id: {
+        type: sequelize_1.DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+    },
+    srcChainSlug: {
+        type: sequelize_1.DataTypes.BIGINT,
+    },
+    dstChainSlug: {
+        type: sequelize_1.DataTypes.BIGINT,
+    },
+    packetId: {
+        type: sequelize_1.DataTypes.STRING,
+        unique: "uniqueProposalPointer",
+    },
+    proposalCount: {
+        type: sequelize_1.DataTypes.INTEGER,
+        unique: "uniqueProposalPointer",
+    },
+    root: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    switchboard: {
+        type: sequelize_1.DataTypes.STRING,
+        unique: "uniqueProposalPointer",
+    },
+    proposer: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    proposeTxHash: {
+        type: sequelize_1.DataTypes.STRING,
+        defaultValue: "",
+    },
+    proposeTime: {
+        type: sequelize_1.DataTypes.INTEGER,
+    },
+    tripTxId: {
+        type: sequelize_1.DataTypes.STRING,
+        defaultValue: "",
+    },
+    tripTxHash: {
+        type: sequelize_1.DataTypes.STRING,
+        defaultValue: "",
+    },
+    tripTime: {
+        type: sequelize_1.DataTypes.INTEGER,
+    },
+    tripErrorMessage: {
+        type: sequelize_1.DataTypes.STRING,
+        defaultValue: "",
+    },
+    isTripped: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+        defaultValue: false,
+    },
+    tripRelayStatus: {
+        type: sequelize_1.DataTypes.ENUM,
+        values: [...Object.values(ProposalTripRelayStatus)],
+        defaultValue: ProposalTripRelayStatus.NO,
+    },
+    totalAttestations: {
+        type: sequelize_1.DataTypes.INTEGER,
+        defaultValue: 0,
+    },
+    rootMatchState: {
+        type: sequelize_1.DataTypes.ENUM,
+        values: [...Object.values(RootMatchState)],
+        defaultValue: RootMatchState.NO,
+    },
+    switchboardMatchState: {
+        type: sequelize_1.DataTypes.ENUM,
+        values: [...Object.values(MatchState)],
+        defaultValue: MatchState.NO,
+    },
+    isTripRequired: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+        defaultValue: false,
+    },
+};
+function processStrings(proposal) {
+    if (proposal.packetId)
+        proposal.packetId = (0, utils_1.toLowerCase)(proposal.packetId);
+    if (proposal.root)
+        proposal.root = (0, utils_1.toLowerCase)(proposal.root);
+    if (proposal.switchboard)
+        proposal.switchboard = (0, utils_1.toLowerCase)(proposal.switchboard);
+    if (proposal.proposer)
+        proposal.proposer = (0, utils_1.toLowerCase)(proposal.proposer);
+    if (proposal.proposeTxHash)
+        proposal.proposeTxHash = (0, utils_1.toLowerCase)(proposal.proposeTxHash);
+    if (proposal.tripTxHash)
+        proposal.tripTxHash = (0, utils_1.toLowerCase)(proposal.tripTxHash);
+    return proposal;
+}
+const addProposalHooks = () => {
+    Proposal.beforeBulkCreate((proposal, options) => {
+        for (let index = 0; index < proposal.length; index++) {
+            proposal[index] = processStrings(proposal[index]);
+        }
+    });
+    Proposal.beforeSave((proposal, options) => {
+        proposal = processStrings(proposal);
+    });
+};
+exports.addProposalHooks = addProposalHooks;

package/dist/dl-common/models/switchboard.d.ts

@@ -0,0 +1,69 @@
+import { IntegrationTypes } from "@socket.tech/dl-core";
+import { DataTypes, Model } from "sequelize";
+export declare enum CapacitorType {
+    singleCapacitor = "1",
+    hashChainCapacitor = "2"
+}
+export declare class Switchboard extends Model {
+    id: number;
+    switchboardId: string;
+    srcChainSlug: number;
+    dstChainSlug: number;
+    maxPacketLength: number;
+    srcSwitchboard: string;
+    dstSwitchboard: string;
+    srcCapacitor: string;
+    srcDecapacitor: string;
+    capacitorType: CapacitorType;
+    isEnabled: boolean;
+    integrationType: IntegrationTypes;
+}
+export declare const SwitchboardModel: {
+    id: {
+        type: DataTypes.IntegerDataTypeConstructor;
+        autoIncrement: boolean;
+        primaryKey: boolean;
+    };
+    switchboardId: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    srcChainSlug: {
+        type: DataTypes.BigIntDataTypeConstructor;
+        unique: string;
+    };
+    dstChainSlug: {
+        type: DataTypes.BigIntDataTypeConstructor;
+        unique: string;
+    };
+    maxPacketLength: {
+        type: DataTypes.IntegerDataTypeConstructor;
+    };
+    srcSwitchboard: {
+        type: DataTypes.StringDataTypeConstructor;
+        unique: string;
+    };
+    dstSwitchboard: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    srcCapacitor: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    srcDecapacitor: {
+        type: DataTypes.StringDataTypeConstructor;
+    };
+    capacitorType: {
+        type: DataTypes.EnumDataTypeConstructor;
+        values: CapacitorType[];
+        defaultValue: CapacitorType;
+    };
+    isEnabled: {
+        type: DataTypes.AbstractDataTypeConstructor;
+        defaultValue: boolean;
+    };
+    integrationType: {
+        type: DataTypes.EnumDataTypeConstructor;
+        values: IntegrationTypes[];
+        defaultValue: IntegrationTypes;
+    };
+};
+export declare const addSwitchboardHooks: () => Promise<void>;

package/dist/dl-common/models/switchboard.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addSwitchboardHooks = exports.SwitchboardModel = exports.Switchboard = exports.CapacitorType = void 0;
+const dl_core_1 = require("@socket.tech/dl-core");
+const sequelize_1 = require("sequelize");
+const __1 = require("..");
+var CapacitorType;
+(function (CapacitorType) {
+    CapacitorType["singleCapacitor"] = "1";
+    CapacitorType["hashChainCapacitor"] = "2";
+})(CapacitorType || (exports.CapacitorType = CapacitorType = {}));
+class Switchboard extends sequelize_1.Model {
+}
+exports.Switchboard = Switchboard;
+exports.SwitchboardModel = {
+    id: {
+        type: sequelize_1.DataTypes.INTEGER,
+        autoIncrement: true,
+        primaryKey: true,
+    },
+    switchboardId: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    srcChainSlug: {
+        type: sequelize_1.DataTypes.BIGINT,
+        unique: "uniqueSwitchboardPointer",
+    },
+    dstChainSlug: {
+        type: sequelize_1.DataTypes.BIGINT,
+        unique: "uniqueSwitchboardPointer",
+    },
+    maxPacketLength: {
+        type: sequelize_1.DataTypes.INTEGER,
+    },
+    srcSwitchboard: {
+        type: sequelize_1.DataTypes.STRING,
+        unique: "uniqueSwitchboardPointer",
+    },
+    dstSwitchboard: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    srcCapacitor: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    srcDecapacitor: {
+        type: sequelize_1.DataTypes.STRING,
+    },
+    capacitorType: {
+        type: sequelize_1.DataTypes.ENUM,
+        values: [...Object.values(CapacitorType)],
+        defaultValue: CapacitorType.singleCapacitor,
+    },
+    isEnabled: {
+        type: sequelize_1.DataTypes.BOOLEAN,
+        defaultValue: false,
+    },
+    integrationType: {
+        type: sequelize_1.DataTypes.ENUM,
+        values: [...Object.values(dl_core_1.IntegrationTypes)],
+        defaultValue: dl_core_1.IntegrationTypes.unknown,
+    },
+};
+const addSwitchboardHooks = async () => {
+    Switchboard.beforeBulkCreate((switchboards, options) => {
+        for (let index = 0; index < switchboards.length; index++) {
+            switchboards[index] = processStrings(switchboards[index]);
+            switchboards[index] = createSwitchboardId(switchboards[index]);
+        }
+    });
+    Switchboard.beforeSave((switchboard, options) => {
+        switchboard = processStrings(switchboard);
+    });
+};
+exports.addSwitchboardHooks = addSwitchboardHooks;
+function processStrings(switchboard) {
+    if (switchboard.srcSwitchboard)
+        switchboard.srcSwitchboard = (0, __1.toLowerCase)(switchboard.srcSwitchboard);
+    if (switchboard.dstSwitchboard)
+        switchboard.dstSwitchboard = (0, __1.toLowerCase)(switchboard.dstSwitchboard);
+    if (switchboard.srcCapacitor)
+        switchboard.srcCapacitor = (0, __1.toLowerCase)(switchboard.srcCapacitor);
+    if (switchboard.srcDecapacitor)
+        switchboard.srcDecapacitor = (0, __1.toLowerCase)(switchboard.srcDecapacitor);
+    return switchboard;
+}
+function createSwitchboardId(switchboard) {
+    if (switchboard.srcSwitchboard &&
+        switchboard.srcChainSlug &&
+        switchboard.dstChainSlug)
+        switchboard.switchboardId = `${switchboard.srcChainSlug}-${switchboard.dstChainSlug}-${switchboard.srcSwitchboard.toLowerCase()}`;
+    return switchboard;
+}

package/dist/dl-common/models/transaction.js

@@ -0,0 +1,280 @@
+"use strict";
+// import { IntegrationTypes } from "@socket.tech/dl-core";
+// import { DataTypes, Model } from "sequelize";
+// import { toLowerCase } from "../utils";
+// import {Project} from "@socket.tech/socket-plugs";
+// export enum SealRelayStatus {
+//   SEALED = "SEALED",
+//   SEALING = "SEALING",
+//   NO = "NO",
+//   SEAL_FAILED = "SEAL_FAILED",
+// }
+// export enum PacketTripRelayStatus {
+//   IS_TRIPPING = "IS_TRIPPING",
+//   NO = "NO",
+//   TRIPPING_FAILED = "TRIPPING_FAILED",
+//   TRIPPED = "TRIPPED",
+// }
+// export enum ProposeRelayStatus {
+//   PROPOSED = "PROPOSED",
+//   PROPOSING = "PROPOSING",
+//   CONFIRMING = "CONFIRMING",
+//   NO = "NO",
+//   PROPOSE_FAILED = "PROPOSE_FAILED",
+//   CONFIRM_FAILED = "CONFIRM_FAILED",
+// }
+// export enum TxType {
+//   SUPERBRIDGE = "SUPERBRIDGE",
+//   SUPERTOKEN = "SUPERTOKEN"
+// }
+// export class Transaction extends Model {
+//   declare id: number;
+//   srcChainSlug: number;
+//   dstChainSlug: number;
+//   from: string;
+//   to:string;
+//   amount:number;
+//   token: string;
+//   tokenAddress: string;
+//   srcPlug: string;
+//   dstPlug: string;
+//   usdAmount: number;
+//   type: TxType;
+//   project: Project;
+//   srcTxHash: string;
+//   txTime: string;
+//   root: string;
+//   rootSealed: string;
+//   sealer: string;
+//   sealTxHash: string;
+//   sealTxId: string;
+//   sealSignature: string;
+//   sealTime: number;
+//   sealRelayStatus: SealRelayStatus;
+//   packetTripTime: number;
+//   packetTripTxnHash: string;
+//   packetTripErrorMessage: string;
+//   isPacketTripped: boolean;
+//   packetTripRelayStatus: PacketTripRelayStatus;
+//   // proposeTxId, proposeTxHash refers to the proposal sent by us. For details of other proposals, see Proposal table.
+//   proposeTxId: string;
+//   proposeTxHash: string;
+//   proposeRelayStatus: ProposeRelayStatus;
+//   selectedProposalCount: number;
+//   // attestTxId, attestTxHash refers to the attestation sent by us. For details of other attestations, see Attestation table.
+//   attestTxId: string;
+//   attestTxHash: string;
+//   attestRelayStatus: AttestRelayStatus;
+//   outboundTxHash: string;
+//   outboundTime: number;
+//   sealIndexTime: number;
+//   proposeTime: number;
+//   attestTime: number;
+//   packetTripTxHash: string;
+//   isFilled: boolean;
+//   isSealed: boolean;
+//   isProposed: boolean;
+//   isAttested: boolean;
+//   isVerified: boolean;
+//   isFullyExecuted: boolean;
+//   tripreason: TripReason;
+//   executionWaitTime: number;
+// }
+// export const PacketModel = {
+//   id: {
+//     type: DataTypes.INTEGER,
+//     autoIncrement: true,
+//   },
+//   srcChainSlug: {
+//     type: DataTypes.BIGINT,
+//   },
+//   dstChainSlug: {
+//     type: DataTypes.BIGINT,
+//   },
+//   srcCapacitor: {
+//     type: DataTypes.STRING,
+//   },
+//   dstSwitchboard: {
+//     type: DataTypes.STRING,
+//   },
+//   switchboardId: {
+//     type: DataTypes.STRING,
+//   },
+//   integrationType: {
+//     type: DataTypes.ENUM,
+//     values: [...Object.values(IntegrationTypes)],
+//     defaultValue: IntegrationTypes.unknown,
+//   },
+//   packetId: {
+//     type: DataTypes.STRING,
+//     primaryKey: true,
+//   },
+//   capacitorPacketCount: {
+//     type: DataTypes.STRING,
+//   },
+//   root: {
+//     type: DataTypes.STRING,
+//   },
+//   rootSealed: {
+//     type: DataTypes.STRING,
+//   },
+//   isFilled: {
+//     type: DataTypes.BOOLEAN,
+//   },
+//   isSealed: {
+//     type: DataTypes.BOOLEAN,
+//     defaultValue: false,
+//   },
+//   isProposed: {
+//     type: DataTypes.BOOLEAN,
+//     defaultValue: false,
+//   },
+//   isAttested: {
+//     type: DataTypes.BOOLEAN,
+//     defaultValue: false,
+//   },
+//   isVerified: {
+//     type: DataTypes.BOOLEAN,
+//     defaultValue: false,
+//   },
+//   isFullyExecuted: {
+//     type: DataTypes.BOOLEAN,
+//     defaultValue: false,
+//   },
+//   sealer: {
+//     type: DataTypes.STRING,
+//   },
+//   sealRelayStatus: {
+//     type: DataTypes.ENUM,
+//     values: [...Object.values(SealRelayStatus)],
+//     defaultValue: SealRelayStatus.NO,
+//   },
+//   sealTxId: {
+//     type: DataTypes.STRING,
+//     defaultValue: "",
+//   },
+//   sealTxHash: {
+//     type: DataTypes.STRING,
+//     defaultValue: "",
+//   },
+//   outboundTxHash: {
+//     type: DataTypes.STRING,
+//     defaultValue: "",
+//   },
+//   outboundTime: {
+//     type: DataTypes.INTEGER,
+//   },
+//   proposeTime: {
+//     type: DataTypes.INTEGER,
+//   },
+//   attestTime: {
+//     type: DataTypes.INTEGER,
+//   },
+//   sealTime: {
+//     type: DataTypes.INTEGER,
+//   },
+//   sealIndexTime: {
+//     type: DataTypes.INTEGER,
+//   },
+//   sealSignature: {
+//     type: DataTypes.STRING,
+//   },
+//   packetTripRelayStatus: {
+//     type: DataTypes.ENUM,
+//     values: [...Object.values(PacketTripRelayStatus)],
+//     defaultValue: PacketTripRelayStatus.NO,
+//   },
+//   packetTripTxId: {
+//     type: DataTypes.STRING,
+//     defaultValue: "",
+//   },
+//   packetTripTxHash: {
+//     type: DataTypes.STRING,
+//     defaultValue: "",
+//   },
+//   packetTripErrorMessage: {
+//     type: DataTypes.STRING,
+//     defaultValue: "",
+//   },
+//   packetTripTime: {
+//     type: DataTypes.INTEGER,
+//   },
+//   isPacketTripped: {
+//     type: DataTypes.BOOLEAN,
+//     defaultValue: false,
+//   },
+//   proposeTxId: {
+//     type: DataTypes.STRING,
+//     defaultValue: "",
+//   },
+//   proposeTxHash: {
+//     type: DataTypes.STRING,
+//     defaultValue: "",
+//   },
+//   proposeRelayStatus: {
+//     type: DataTypes.ENUM,
+//     values: [...Object.values(ProposeRelayStatus)],
+//     defaultValue: ProposeRelayStatus.NO,
+//   },
+//   selectedProposalCount: {
+//     type: DataTypes.INTEGER,
+//   },
+//   executionWaitTime: {
+//     type: DataTypes.INTEGER,
+//   },
+//   attestTxId: {
+//     type: DataTypes.STRING,
+//     defaultValue: "",
+//   },
+//   attestTxHash: {
+//     type: DataTypes.STRING,
+//     defaultValue: "",
+//   },
+//   tripReason: {
+//     type: DataTypes.ENUM,
+//     values: [...Object.values(TripReason)],
+//     defaultValue: TripReason.NO,
+//   },
+//   // packetTripTxHash: {
+//   //   type: DataTypes.STRING,
+//   //   defaultValue: "",
+//   // },
+//   attestRelayStatus: {
+//     type: DataTypes.ENUM,
+//     values: [...Object.values(AttestRelayStatus)],
+//     defaultValue: AttestRelayStatus.NO,
+//   },
+// };
+// function processStrings(packet: Packet): Packet {
+//   if (packet.packetId) packet.packetId = toLowerCase(packet.packetId);
+//   if (packet.root) packet.root = toLowerCase(packet.root);
+//   if (packet.rootSealed) packet.rootSealed = toLowerCase(packet.rootSealed);
+//   if (packet.sealer) packet.sealer = toLowerCase(packet.sealer);
+//   if (packet.outboundTxHash) {
+//     packet.outboundTxHash = toLowerCase(packet.outboundTxHash);
+//   }
+//   if (packet.sealTxHash) packet.sealTxHash = toLowerCase(packet.sealTxHash);
+//   if (packet.sealSignature) {
+//     packet.sealSignature = toLowerCase(packet.sealSignature);
+//   }
+//   if (packet.dstSwitchboard) {
+//     packet.dstSwitchboard = toLowerCase(packet.dstSwitchboard);
+//   }
+//   if (packet.switchboardId) {
+//     packet.switchboardId = toLowerCase(packet.switchboardId);
+//   }
+//   if (packet.packetTripTxHash) {
+//     packet.packetTripTxHash = toLowerCase(packet.packetTripTxHash);
+//   }
+//   return packet;
+// }
+// export const addPacketHooks = () => {
+//   Packet.beforeBulkCreate((packet, options) => {
+//     for (let index = 0; index < packet.length; index++) {
+//       packet[index] = processStrings(packet[index]);
+//     }
+//   });
+//   Packet.beforeSave((packet, options) => {
+//     packet = processStrings(packet);
+//   });
+// };

package/dist/dl-common/services/cacheService.d.ts

@@ -0,0 +1,14 @@
+export declare let client: any;
+export declare const initCache: (host: string, port: number, password: string, stage: string, serviceName: string) => void;
+export declare const formatKey: (key: string) => string;
+export declare const getKey: (key: string) => Promise<any>;
+export declare const lock: (key: string, expire?: number) => Promise<boolean>;
+export declare const deleteKey: (key: string) => Promise<any>;
+export declare const unlock: (key: string) => Promise<any>;
+export declare const setKey: (key: string, value: any, expire?: number, setIfNotExist?: boolean) => Promise<boolean>;
+export declare const rpush: (key: string, values: any[]) => Promise<any>;
+export declare const lpop: (key: string) => Promise<any>;
+export declare const getListLength: (key: string) => Promise<any>;
+export declare const increment: (key: string) => Promise<any>;
+export declare const decrement: (key: string) => Promise<any>;
+export declare const sendCommand: (command: string, params: any[]) => Promise<any>;

package/dist/dl-common/services/cacheService.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendCommand = exports.decrement = exports.increment = exports.getListLength = exports.lpop = exports.rpush = exports.setKey = exports.unlock = exports.deleteKey = exports.lock = exports.getKey = exports.formatKey = exports.initCache = exports.client = void 0;
+const redis = require("async-redis");
+let deploymentStage;
+let servicePrefix;
+const initCache = (host, port, password, stage, serviceName) => {
+    exports.client = redis.createClient({
+        port,
+        host,
+        password,
+    });
+    deploymentStage = stage;
+    servicePrefix = serviceName;
+};
+exports.initCache = initCache;
+const formatKey = (key) => {
+    return deploymentStage + "_" + servicePrefix + "_" + key;
+};
+exports.formatKey = formatKey;
+const getKey = async (key) => {
+    return await exports.client.get((0, exports.formatKey)(key));
+};
+exports.getKey = getKey;
+const lock = async (key, expire = 0) => {
+    return await (0, exports.setKey)(key, "locked", expire, true);
+};
+exports.lock = lock;
+const deleteKey = async (key) => {
+    return await exports.client.del((0, exports.formatKey)(key));
+};
+exports.deleteKey = deleteKey;
+const unlock = async (key) => {
+    return await exports.client.del((0, exports.formatKey)(key));
+};
+exports.unlock = unlock;
+const setKey = async (key, value, expire = 0, setIfNotExist = false) => {
+    let params = [(0, exports.formatKey)(key), value];
+    if (expire > 0)
+        params.push("EX", expire);
+    if (setIfNotExist)
+        params.push("NX");
+    let response = await exports.client.sendCommand("SET", params);
+    if (response) {
+        return true;
+    }
+    else
+        return false;
+};
+exports.setKey = setKey;
+const rpush = async (key, values) => {
+    return await exports.client.rpush((0, exports.formatKey)(key), values);
+};
+exports.rpush = rpush;
+const lpop = async (key) => {
+    return await exports.client.lpop((0, exports.formatKey)(key));
+};
+exports.lpop = lpop;
+const getListLength = async (key) => {
+    return await exports.client.llen((0, exports.formatKey)(key));
+};
+exports.getListLength = getListLength;
+const increment = async (key) => {
+    let value = await exports.client.incr((0, exports.formatKey)(key));
+    console.log("incremented key : ", (0, exports.formatKey)(key), " value : ", value);
+    return value;
+};
+exports.increment = increment;
+const decrement = async (key) => {
+    return await exports.client.decr((0, exports.formatKey)(key));
+};
+exports.decrement = decrement;
+const sendCommand = async (command, params) => {
+    params[0] = (0, exports.formatKey)(params[0]);
+    return await exports.client.sendCommand(command, params);
+};
+exports.sendCommand = sendCommand;

package/dist/dl-common/services/eventBridgeService.d.ts

@@ -0,0 +1,8 @@
+export type EventBridgeEntry = {
+    eventBus: string;
+    source: string;
+    detailType: string;
+    data: Object;
+};
+export declare const initEventBridgeClient: (region?: string) => void;
+export declare const sendEvents: (events: EventBridgeEntry[]) => Promise<import("@aws-sdk/client-eventbridge").ServiceOutputTypes>;