@etainabl/nodejs-sdk 1.2.43 → 1.2.45

package/src/api.ts

@@ -1,382 +0,0 @@
-import axios from 'axios';
-import type { AxiosRequestConfig, AxiosInstance, CreateAxiosDefaults, AxiosResponse } from 'axios';
-import https from 'https';
-
-import logger from './logger.js';
-
-import type { Account, Asset, Automation, Entity, Company, DataIngest, Invoice, Log, Reading, Report, Supplier } from './types/index.js'
-
-const log = logger('etainablApi');
-
-export interface ETNPagedResponse<T = any>  {
-  data: T[];
-  total: number;
-  limit: number;
-  skip: number;
-}
-
-export interface ETNReq {
-  method: string;
-  url: string;
-}
-
-function _handleResponse(req: ETNReq, res: AxiosResponse, isPaged = false) {
-  if (!res) {
-    throw new Error(`No response from API (${req.method} ${req.url})`);
-  }
-
-  if (res.status !== 200) {
-    throw new Error(`${res.status} ${res.statusText} response from API (${req.method} ${req.url})`);
-  }
-
-  if (!res.data) {
-    throw new Error(`No data from API (${req.method} ${req.url})`);
-  }
-
-  if (isPaged && !res.data.data) {
-    throw new Error(`No data from API (${req.method} ${req.url})`);
-  }
-
-  return res;
-}
-
-const factory = {
-  getWithId: <T = any> (etainablApi: AxiosInstance, endpoint: string, postEndpoint?: string) => async (id: string, options: AxiosRequestConfig = {}): Promise<T> => {
-    const req = {
-      method: 'GET',
-      url: `${endpoint}/${id}${postEndpoint ? `/${postEndpoint}` : ''}`
-    };
-
-    log.info(`API Request: ${req.method} ${process.env.ETAsINABL_API_URL}/${req.url}`);
-
-    let res: AxiosResponse;
-
-    try {
-      res = await etainablApi.get(req.url, options);
-    } catch (e: any) {
-      if (e.response?.data) throw new Error(`API error response: ${JSON.stringify(e.response.data)}`);
-      throw e;
-    }
-
-    console.log(`API Response: ${req.method} ${process.env.ETAINABL_API_URL}/${req.url}`);
-
-    _handleResponse(req, res)
-
-    return res.data;
-  },
-  get: <T = any> (etainablApi: AxiosInstance, endpoint: string, postEndpoint?: string) => async (options: AxiosRequestConfig = {}): Promise<T> => {
-    const req = {
-      method: 'GET',
-      url: `${endpoint}${postEndpoint ? `/${postEndpoint}` : ''}`
-    };
-
-    log.info(`API Request: ${req.method} ${process.env.ETAINABL_API_URL}/${req.url}`);
-
-    let res: AxiosResponse;
-
-    try {
-      res = await etainablApi.get(req.url, options);
-    } catch (e: any) {
-      if (e.response?.data) throw new Error(`API error response: ${JSON.stringify(e.response.data)}`);
-      throw e;
-    }
-
-    console.log(`API Response: ${req.method} ${process.env.ETAINABL_API_URL}/${req.url}`);
-    _handleResponse(req, res)
-
-    return res.data;
-  },
-  list: <T = any> (etainablApi: AxiosInstance, endpoint: string, postEndpoint?: string) => async (options: AxiosRequestConfig = {}): Promise<ETNPagedResponse<T>> => {
-    const req = {
-      method: 'GET',
-      url: `${endpoint}${postEndpoint ? `/${postEndpoint}` : ''}`
-    };
-    
-    log.info(`API Request: ${req.method} ${process.env.ETAINABL_API_URL}/${req.url}`);
-
-    let res: AxiosResponse;
-    
-    try {
-      res = await etainablApi.get(req.url, options);
-    } catch (e: any) {
-      if (e.response?.data) throw new Error(`API error response: ${JSON.stringify(e.response.data)}`);
-      throw e;
-    }
-
-    console.log(`API Response: ${req.method} ${process.env.ETAINABL_API_URL}/${req.url}`);
-    _handleResponse(req, res, true)
-
-    return res.data;
-  },
-  update: (etainablApi: AxiosInstance, endpoint: string, postEndpoint?: string) => async (id: string, data: any, options: AxiosRequestConfig = {}) => {
-    const req = {
-      method: 'PATCH',
-      url: `${endpoint}/${id}${postEndpoint ? `/${postEndpoint}` : ''}`
-    };
-    
-    log.info(`API Request: ${req.method} ${process.env.ETAINABL_API_URL}/${req.url}`);
-
-    let res: AxiosResponse;
-    
-    try {
-      res = await etainablApi.patch(req.url, data, options);
-    } catch (e: any) {
-      if (e.response?.data) throw new Error(`API error response: ${JSON.stringify(e.response.data)}`);
-      throw e;
-    }
-
-    _handleResponse(req, res)
-
-    return res.data;
-  },
-  create: (etainablApi: AxiosInstance, endpoint: string, postEndpoint?: string) => async (data: any, options: AxiosRequestConfig = {}) => {
-    const req = {
-      method: 'POST',
-      url: `${endpoint}${postEndpoint ? `/${postEndpoint}` : ''}`
-    };
-
-    log.info(`API Request: ${req.method} ${process.env.ETAINABL_API_URL}/${req.url}`);
-
-    let res: AxiosResponse;
-    
-    try {
-      res = await etainablApi.post(req.url, data, options);
-    } catch (e: any) {
-      if (e.response?.data) throw new Error(`API error response: ${JSON.stringify(e.response.data)}`);
-      throw e;
-    }
-
-    _handleResponse(req, res)
-
-    return res.data;
-  },
-  remove: (etainablApi: AxiosInstance, endpoint: string, postEndpoint?: string) => async (id: string, options: AxiosRequestConfig = {}) => {
-    const req = {
-      method: 'DELETE',
-      url: `${endpoint}/${id}${postEndpoint ? `/${postEndpoint}` : ''}`
-    };
-
-    let res: AxiosResponse;
-
-    log.info(`API Request: ${req.method} ${process.env.ETAINABL_API_URL}/${req.url}`);
-
-    try {
-      res = await etainablApi.delete(req.url, options);
-    } catch (e: any) {
-      if (e.response?.data) throw new Error(`API error response: ${JSON.stringify(e.response.data)}`);
-      throw e;
-    }
-
-    _handleResponse(req, res);
-
-    return res.data;
-  },
-  customWithId: (etainablApi: AxiosInstance, method: string, endpoint: string, postEndpoint?: string) => async (id: string, data: any, options: AxiosRequestConfig = {}) => {
-    const req = {
-      method: method,
-      url: `${endpoint}/${id}${postEndpoint ? `/${postEndpoint}` : ''}`,
-      data,
-      ...options
-    };
-    
-    log.info(`API Request (Custom): ${req.method} ${process.env.ETAINABL_API_URL}/${req.url}`);
-
-    let res: AxiosResponse;
-    
-    try {
-      res = await etainablApi.request(req);
-    } catch (e: any) {
-      if (e.response?.data) throw new Error(`API error response: ${JSON.stringify(e.response.data)}`);
-      throw e;
-    }
-
-    _handleResponse(req, res)
-
-    return res.data;
-  }
-};
-
-// ETN Sub Endpoints
-// e.g. /assets/:id/documents/:documentId
-const subFactory = {
-  // e.g. POST /assets/:id/documents
-  create: (etainablApi: AxiosInstance, endpoint: string, subEndpoint: string) => async (id: string, data: any, options: AxiosRequestConfig = {}) => {    
-    const subUrl = `${id}/${subEndpoint}`;
-    return factory.create(etainablApi, endpoint, subUrl)(data, options);
-  },
-  // e.g. PATCH /assets/:id/documents/:documentId
-  update: (etainablApi: AxiosInstance, endpoint: string, subEndpoint: string) => async (id: string, subId: string, data: any, options: AxiosRequestConfig = {}) => {
-    const subUrl = `${subEndpoint}/${subId}`;
-    
-    return factory.update(etainablApi, endpoint, subUrl)(id, data, options);
-  },
-  // e.g. DELETE /assets/:id/documents/:documentId
-  remove: (etainablApi: AxiosInstance, endpoint: string, subEndpoint: string) => async (id: string, subId: string, options: AxiosRequestConfig = {}) => {
-    const subUrl = `${subEndpoint}/${subId}`;
-    
-    return factory.remove(etainablApi, endpoint, subUrl)(id, options);
-  }
-}
-
-interface AuthOptions {
-  key?: string;
-  token?: string;
-}
-
-export default (auth: AuthOptions, instanceOptions: CreateAxiosDefaults = {}) => {
-  try {
-    const headers: any = {};
-
-    if (auth.key) {
-      headers['x-key'] = auth.key;
-    } else if (auth.token) {
-      headers['Authorization'] = auth.token;
-    } else {
-      headers['x-key'] = process.env.ETAINABL_API_KEY;
-    }
-  
-    const etainablApi = axios.create({
-      baseURL: process.env.ETAINABL_API_URL,
-      timeout: 300000,
-      httpsAgent: new https.Agent({ keepAlive: true }),
-      headers,
-      ...instanceOptions
-    });
-  
-    return {
-      instance: etainablApi,
-  
-      // accounts
-      getAccount: factory.getWithId<Account>(etainablApi, 'accounts'),
-      listAccounts: factory.list<Account>(etainablApi, 'accounts'),
-      updateAccount: factory.update(etainablApi, 'accounts'),
-      createAccount: factory.create(etainablApi, 'accounts'),
-      removeAccount: factory.remove(etainablApi, 'accounts'),
-      getAccountSchema: factory.get(etainablApi, 'accounts', 'schema'),
-      invalidateAccountCache: factory.customWithId(etainablApi, 'put',  'accounts', 'invalidate-cache'),
-
-      // assets
-      getAsset: factory.getWithId<Asset>(etainablApi, 'assets'),
-      listAssets: factory.list<Asset>(etainablApi, 'assets'),
-      updateAsset: factory.update(etainablApi, 'assets'),
-      createAsset: factory.create(etainablApi, 'assets'),
-      removeAsset: factory.remove(etainablApi, 'assets'),
-      getAssetSchema: factory.get(etainablApi, 'assets', 'schema'),
-  
-      // assetGroups
-      getAssetGroup: factory.getWithId(etainablApi, 'asset-groups'),
-      listAssetGroups: factory.list(etainablApi, 'asset-groups'),
-      updateAssetGroup: factory.update(etainablApi, 'asset-groups'),
-      createAssetGroup: factory.create(etainablApi, 'asset-groups'),
-      removeAssetGroup: factory.remove(etainablApi, 'asset-groups'),
-      getAssetGroupAssets: factory.getWithId(etainablApi, 'asset-groups', 'assets'),
-      getAssetGroupSchema:  factory.get(etainablApi, 'asset-groups', 'schema'),
-  
-      // automation
-      getAutomation: factory.getWithId<Automation>(etainablApi, 'automation'),
-      listAutomations: factory.list<Automation>(etainablApi, 'automation'),
-      updateAutomation: factory.update(etainablApi, 'automation'),
-      createAutomation: factory.create(etainablApi, 'automation'),
-      removeAutomation: factory.remove(etainablApi, 'automation'),
-      createAutomationLog: subFactory.create(etainablApi, 'automation', 'logs'),
-      updateAutomationLog: subFactory.update(etainablApi, 'automation', 'logs'),
-      removeAutomationLog: subFactory.remove(etainablApi, 'automation', 'logs'),
-  
-      // company
-      getCompany: factory.getWithId<Company>(etainablApi, 'companies'),
-  
-      // consumption
-      getConsumption: factory.getWithId(etainablApi, 'consumptions'),
-      listConsumptions: factory.list(etainablApi, 'consumptions'),
-      updateConsumption: factory.update(etainablApi, 'consumptions'),
-      createConsumption: factory.create(etainablApi, 'consumptions'),
-      removeConsumption: factory.remove(etainablApi, 'consumptions'),
-      getConsumptionSchema:  factory.get(etainablApi, 'consumptions', 'schema'),
-  
-      // emails
-      getEmail: factory.getWithId(etainablApi, 'emails'),
-      listEmails: factory.list(etainablApi, 'emails'),
-      updateEmail: factory.update(etainablApi, 'emails'),
-      createEmail: factory.create(etainablApi, 'emails'),
-      removeEmail: factory.remove(etainablApi, 'emails'),
-  
-      // emission factors
-      getEmissionFactor: factory.getWithId(etainablApi, 'emission-factors'),
-      listEmissionFactors: factory.list(etainablApi, 'emission-factors'),
-      updateEmissionFactor: factory.update(etainablApi, 'emission-factors'),
-      createEmissionFactor: factory.create(etainablApi, 'emission-factors'),
-      removeEmissionFactor: factory.remove(etainablApi, 'emission-factors'),
-
-      // entity
-      getEntity: factory.getWithId<Entity>(etainablApi, 'entities'),
-      listEntities: factory.list<Entity>(etainablApi, 'entities'),
-      updateEntity: factory.update(etainablApi, 'entities'),
-      createEntity: factory.create(etainablApi, 'entities'),
-      removeEntity: factory.remove(etainablApi, 'entities'),
-      getEntitiesSchema: factory.get(etainablApi, 'entities', 'schema'),
-        
-  
-      // logs
-      getLog: factory.getWithId<Log>(etainablApi, 'logs'),
-      listLogs: factory.list<Log>(etainablApi, 'logs'),
-      updateLog: factory.update(etainablApi, 'logs'),
-      createLog: factory.create(etainablApi, 'logs'),
-      removeLog: factory.remove(etainablApi, 'logs'),
-  
-      // readings
-      getReading: factory.getWithId<Reading>(etainablApi, 'readings'),
-      listReadings: factory.list<Reading>(etainablApi, 'readings'),
-      updateReading: factory.update(etainablApi, 'readings'),
-      createReading: factory.create(etainablApi, 'readings'),
-      removeReading: factory.remove(etainablApi, 'readings'),
-      getReadingSchema: factory.get(etainablApi, 'readings', 'schema'),
-  
-      // reports
-      getReport: factory.getWithId<Report>(etainablApi, 'reports'),
-      listReports: factory.list<Report>(etainablApi, 'reports'),
-      updateReport: factory.update(etainablApi, 'reports'),
-      createReport: factory.create(etainablApi, 'reports'),
-      removeReport: factory.remove(etainablApi, 'reports'),
-      sendReport: factory.customWithId(etainablApi, 'post',  'reports', 'send'),
-  
-      // report templates
-      getReportTemplate: factory.getWithId(etainablApi, 'report-templates'),
-      listReportTemplates: factory.list(etainablApi, 'report-templates'),
-      updateReportTemplate: factory.update(etainablApi, 'report-templates'),
-      createReportTemplate: factory.create(etainablApi, 'report-templates'),
-      removeReportTemplate: factory.remove(etainablApi, 'report-templates'),
-  
-      // scheduled reports
-      getScheduledReport: factory.getWithId(etainablApi, 'scheduled-reports'),
-      listScheduledReports: factory.list(etainablApi, 'scheduled-reports'),
-      updateScheduledReport: factory.update(etainablApi, 'scheduled-reports'),
-      createScheduledReport: factory.create(etainablApi, 'scheduled-reports'),
-      removeScheduledReport: factory.remove(etainablApi, 'scheduled-reports'),
-      sendScheduledReport: factory.customWithId(etainablApi, 'post',  'scheduled-reports', 'send'),
-  
-      // invoices
-      getInvoice: factory.getWithId<Invoice>(etainablApi, 'invoices'),
-      listInvoices: factory.list<Invoice>(etainablApi, 'invoices'),
-      updateInvoice: factory.update(etainablApi, 'invoices'),
-      createInvoice: factory.create(etainablApi, 'invoices'),
-      removeInvoice: factory.remove(etainablApi, 'invoices'),
-      getInvoiceSchema: factory.get(etainablApi, 'invoices', 'schema'),
-
-      //suppliers
-      listSuppliers: factory.list<Supplier>(etainablApi, 'suppliers'),
-      getSupplierSchema:  factory.get(etainablApi, 'suppliers', 'schema'),
-
-      // import templates
-      getImportTemplate:  factory.getWithId(etainablApi, 'import-templates'),
-
-      //data imports
-      updateDataIngest: factory.update(etainablApi, 'data-ingests'),
-      createDataIngest: factory.create(etainablApi, 'data-ingests'),
-      listDataIngest: factory.list<DataIngest>(etainablApi, 'data-ingests'),
-
-    }
-  } catch (e) {
-    log.error(e);
-    throw e;
-  }
-};

package/src/consumption.ts

@@ -1,40 +0,0 @@
-import moment from 'moment';
-
-interface ConsumptionData {
-  date: Date;
-  consumption: number;
-}
-
-interface DayNightConsumption {
-  dayConsumption: number,
-  nightConsumption: number,
-  consumption: number
-}
-
-export const dayNightConsumption = (data: ConsumptionData[]) => data.reduce((acc: DayNightConsumption, item: ConsumptionData): DayNightConsumption => {
-  const hour = moment.utc(item.date).hour(); // End Time of HH consumption period
-
-  if (hour >= 0 && hour < 7) {
-    acc.nightConsumption += item.consumption;
-  } else {
-    acc.dayConsumption += item.consumption;
-  }
-
-  acc.consumption += item.consumption;
-
-  return acc;
-}, {
-  dayConsumption: 0,
-  nightConsumption: 0,
-  consumption: 0
-});
-
-export const calcMaxConsumptionValue = (data: ConsumptionData[]) => Math.max(...data.map((item: ConsumptionData) => item.consumption));
-
-export const calcMaxDemand = (data: ConsumptionData[]) => calcMaxConsumptionValue(data) * 2;
-
-export const calcPeakLoad = (consumption: number, maxDemand: number, startDate: string | moment.Moment, endDate: string | moment.Moment) => {
-  const days = Math.ceil(moment(endDate).diff(moment(startDate), 'days', true));
-
-  return maxDemand === 0 ? 0 : ((consumption / (maxDemand * 24 * days)) * 100);
-};

package/src/db.ts

@@ -1,69 +0,0 @@
-import { MongoClient, Db } from 'mongodb';
-import logger from './logger.js';
-
-const log = logger('dbHelpers');
-
-let cachedDb: Db;
-
-async function connectToDatabase(retryAttempt: number = 1): Promise<Db> {
-  if (!process.env.ETAINABL_DB_URL) throw new Error("ETAINABL_DB_URL is not set");
-  if (!process.env.AWS_ACCESS_KEY_ID) throw new Error("AWS_ACCESS_KEY_ID is not set");
-  if (!process.env.AWS_SECRET_ACCESS_KEY) throw new Error("AWS_SECRET_ACCESS_KEY is not set");
-
-  if (cachedDb) {
-    log.debug('Using cached MongoDB connection.');
-    return Promise.resolve(cachedDb);
-  }
-  
-  const uri = `mongodb+srv://${process.env.ETAINABL_DB_URL}`;
-  
-  try {
-    if (process.env.DB_BASIC_AUTH === 'true') {
-      log.debug('Connecting to MongoDB server... (Auth: Basic)');
-
-      const client = new MongoClient(uri);
-      await client.connect();
-
-      log.debug('Connected successfully to MongoDB server! (Auth: Basic)');
-
-      cachedDb = client.db('etainabl');
-
-      return cachedDb;
-    }
-
-    log.debug('Connecting to MongoDB server... (Auth: AWS)');
-
-    const client = new MongoClient(uri, {
-      auth: {
-        username: process.env.AWS_ACCESS_KEY_ID,
-        password: process.env.AWS_SECRET_ACCESS_KEY
-      },
-      authSource: '$external',
-      authMechanism: 'MONGODB-AWS'
-    });
-
-    await client.connect();
-
-    log.debug('Connected successfully to MongoDB server! (Auth: AWS)');
-
-    cachedDb = client.db('etainabl');
-
-    return cachedDb;
-
-  } catch (e: any) {
-    // Retry
-    if (retryAttempt > 5) {
-      console.log(`Error connecting to MongoDB server after 5 attempts...`);
-      throw e;
-    }
-
-    console.log(`MongoDB Connection error: ${e.message}`);
-
-    console.log(`Error connecting to MongoDB server... Retrying in 3 seconds... (Attempt ${retryAttempt})`);
-    return connectToDatabase(retryAttempt + 1);
-  }
-}
-
-export default {
-  connectToDatabase
-};

package/src/etainabl.ts

@@ -1,10 +0,0 @@
-export interface AuthorizerContext {
-  companyId: string,
-  isAdmin: boolean,
-  isKiosk: boolean,
-  isPublicApiRequest: boolean,
-  isService: boolean,
-  scope: string,
-  sub: string,
-  token: string
-}

package/src/index.ts

@@ -1,21 +0,0 @@
-import api from './api.js';
-import logger from './logger.js';
-import db from './db.js';
-import slack from './slack.js';
-import * as units from './units.js';
-import * as consumption from './consumption.js';
-import * as monitoring from './monitoring.js';
-import * as reporting from './reporting.js';
-
-export {
-  api,
-  logger,
-  consumption,
-  monitoring,
-  db,
-  slack,
-  units,
-  reporting
-}
-
-export * from './types/index.js';

package/src/logger.ts

@@ -1,13 +0,0 @@
-import winston from 'winston';
-
-export default (namespace: string) => winston.createLogger({
-  level: 'debug',
-  format: winston.format.combine(
-    winston.format.timestamp(),
-    winston.format.json()
-  ),
-  defaultMeta: { service: process.env.AWS_LAMBDA_FUNCTION_NAME, script: namespace },
-  transports: [
-    new winston.transports.Console()
-  ]
-});

package/src/monitoring.ts

@@ -1,18 +0,0 @@
-import axios from 'axios';
-
-import logger from './logger.js';
-
-const log = logger('monitoring');
-
-export const sendHeartbeat = async () => {
-    if (!process.env.HEARTBEAT_URL || process.env.HEARTBEAT_URL.endsWith('/')) return false;
-
-    try {
-        await axios.post(process.env.HEARTBEAT_URL);
-
-        return true;
-    } catch (e: any) {
-        log.warn(`Failed to send heartbeat: ${e.message || e}`);
-        return false;
-    }
-}

package/src/reporting.ts

@@ -1,78 +0,0 @@
-import moment from 'moment';
-
-moment.locale('en', {
-  week: {
-    dow: 1
-  }
-});
-
-const getNextRunTime = (startDate: moment.Moment, schedule: any, taskTime: moment.Moment): moment.Moment => {
-  const [num, freq] = schedule.frequency.split('|');
-  const targetDate = moment(startDate).add(num, freq as moment.unitOfTime.Base);
-
-  if (schedule.frequencyPeriod === 'first') {
-    targetDate.startOf(freq as moment.unitOfTime.StartOf);
-  } else if (schedule.frequencyPeriod === 'last') {
-    targetDate.endOf(freq as moment.unitOfTime.StartOf);
-  }
-
-  const isWeekday = targetDate.isoWeekday() > 0 && targetDate.isoWeekday() < 6;
-  const isSaturday = targetDate.isoWeekday() === 6;
-
-  // The weekday or weekend chosen should be within the same month as the target date
-  if (schedule.frequencyDay === 'weekdays' && !isWeekday) {
-    if ((targetDate.date() / 7) < 2) {
-      targetDate.add(isSaturday ? 2 : 1, 'days');
-    } else {
-      targetDate.subtract(isSaturday ? 1 : 2, 'days');
-    }
-  } else if (schedule.frequencyDay === 'weekends' && isWeekday) {
-    if ((targetDate.date() / 7) < 2) {
-      targetDate.isoWeekday(6);
-    } else {
-      targetDate.isoWeekday(0);
-    }
-  }
-
-  if (taskTime.isAfter(targetDate, 'minute')) {
-    return getNextRunTime(targetDate, schedule, taskTime);
-  }
-
-  return targetDate;
-};
-
-export const getScheduledReportRunTimes = (schedule: any, limit = 1, taskTime = moment()): moment.Moment[] => {
-  if (!schedule.startDate || !schedule.enabled) return [];
-
-  const originalStartDate = moment.utc(schedule.startDate);
-
-  let startDate = originalStartDate;
-
-  const includeStartDate = taskTime.isSameOrBefore(originalStartDate, 'minute');
-
-  let runTimes = [] as moment.Moment[];
-
-  if (includeStartDate) {
-    runTimes = [originalStartDate];
-  }
-
-  const [, freq] = schedule.frequency.split('|');
-
-  if (freq === 'once') {
-    const nextRunTime = runTimes[0];
-
-    // If this is now beyond the start date, return an empty array
-    return taskTime.isAfter(nextRunTime, 'minute') ? [] : runTimes;
-  }
-
-
-  const scheduleRunTimes = Array.from(Array(includeStartDate ? limit - 1 : limit).keys()).map(() => {
-    const nextRunTime = getNextRunTime(startDate, schedule, taskTime);
-
-    startDate = nextRunTime.hour(originalStartDate.hour()).minute(originalStartDate.minute());
-
-    return nextRunTime;
-  });
-
-  return [...runTimes, ...scheduleRunTimes];
-};

package/src/slack.ts

@@ -1,16 +0,0 @@
-import axios from 'axios';
-
-const postMessage = async (message: string) => {
-  const url = 'https://hooks.slack.com/services/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';
-  const data = {
-    text: `[${(process.env.ENV || '').toUpperCase()}][${process.env.AWS_LAMBDA_FUNCTION_NAME}] ${message}`
-  };
-  const headers = {
-    'Content-Type': 'application/json'
-  };
-  return axios.post(url, data, { headers });
-};
-
-export default {
-  postMessage
-}