@adtrackify/at-service-common 1.2.11 → 1.2.13

package/dist/index.esm.js

@@ -0,0 +1,1374 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+
+// src/clients/generic/dynamodb-client.ts
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { DynamoDBDocument } from "@aws-sdk/lib-dynamodb";
+import * as log from "lambda-log";
+var marshallOptions = {
+  convertEmptyValues: false,
+  removeUndefinedValues: false,
+  convertClassInstanceToMap: true
+};
+var unmarshallOptions = {
+  wrapNumbers: false
+};
+var translateConfig = { marshallOptions, unmarshallOptions };
+var ddbClient = new DynamoDBClient({});
+var client = DynamoDBDocument.from(ddbClient, translateConfig);
+var _DynamoDbClient = class {
+};
+var DynamoDbClient = _DynamoDbClient;
+__publicField(DynamoDbClient, "safeGet", async (tableName, keyName, keyValue) => {
+  try {
+    const params = {
+      TableName: tableName,
+      Key: {
+        [keyName]: keyValue
+      }
+    };
+    const res = await client.get(params);
+    return res?.Item ?? null;
+  } catch (e) {
+    log.error(e, { message: "Dynamo Client Get Failed" });
+    return null;
+  }
+});
+__publicField(DynamoDbClient, "safePut", async (tableName, data) => {
+  try {
+    const params = {
+      TableName: tableName,
+      Item: data
+    };
+    const res = await client.put(params);
+    return res;
+  } catch (e) {
+    log.error(e, { message: "Dynamo failed simplePut" });
+    return null;
+  }
+});
+__publicField(DynamoDbClient, "safeDelete", async (tableName, keyName, keyValue) => {
+  try {
+    const params = {
+      TableName: tableName,
+      Key: {
+        [keyName]: keyValue
+      }
+    };
+    const res = await client.delete(params);
+    return res;
+  } catch (e) {
+    log.error(e, { message: "Dynamo failed safeDelete" });
+    return null;
+  }
+});
+__publicField(DynamoDbClient, "safeQueryByGSI", async (tableName, gsiName, keyName, keyValue) => {
+  const query = {
+    TableName: tableName,
+    IndexName: gsiName,
+    KeyConditionExpression: `${keyName} = :value`,
+    ExpressionAttributeValues: {
+      ":value": keyValue
+    }
+  };
+  const results = await _DynamoDbClient.queryAll(query);
+  return results;
+});
+__publicField(DynamoDbClient, "safeBatchGet", async (tableName, keys) => {
+  try {
+    const params = {
+      RequestItems: {}
+    };
+    params.RequestItems[tableName] = {
+      Keys: keys
+    };
+    const res = await client.batchGet(params);
+    log.info("batchget res", { batchGetRes: res });
+    if (res?.Responses?.[tableName]) {
+      return res?.Responses?.[tableName];
+    }
+    return [];
+  } catch (e) {
+    log.error(e, { message: "Dynamo failed safeBatchGet" });
+    return [];
+  }
+});
+__publicField(DynamoDbClient, "queryAll", async (params) => {
+  try {
+    log.info("Invoke Query All", { params });
+    let currentResult, exclusiveStartKey;
+    let accumulatedResults = [];
+    do {
+      params.ExclusiveStartKey = exclusiveStartKey;
+      params.Limit = 200;
+      currentResult = await client.query(params);
+      if (currentResult.Items) {
+        exclusiveStartKey = currentResult.LastEvaluatedKey;
+        accumulatedResults = [...accumulatedResults, ...currentResult.Items];
+      }
+    } while (currentResult.Items && currentResult.Items.length > 0 && currentResult.LastEvaluatedKey);
+    return accumulatedResults;
+  } catch (e) {
+    log.error(e, { message: "Dynamo failed queryAll" });
+    return null;
+  }
+});
+__publicField(DynamoDbClient, "batchGet", (params) => client.batchGet(params));
+__publicField(DynamoDbClient, "get", (params) => client.get(params));
+__publicField(DynamoDbClient, "put", (params) => client.put(params));
+__publicField(DynamoDbClient, "query", (params) => client.query(params));
+__publicField(DynamoDbClient, "scan", (params) => client.scan(params));
+__publicField(DynamoDbClient, "update", (params) => client.update(params));
+__publicField(DynamoDbClient, "delete", (params) => client.delete(params));
+
+// src/clients/generic/eventbridge-client.ts
+import { EventBridgeClient as EventBridge, PutEventsCommand } from "@aws-sdk/client-eventbridge";
+import { v4 as uuidv4 } from "uuid";
+
+// src/libs/dates.ts
+import { DateTime } from "luxon";
+var getCurrentTimestamp = () => {
+  return DateTime.utc().toJSDate().toISOString();
+};
+var getDateFromTimestamp = (timestamp) => {
+  return timestamp.split("T")[0];
+};
+var getCurrentDate = () => {
+  return getDateFromTimestamp(getCurrentTimestamp());
+};
+
+// src/clients/generic/eventbridge-client.ts
+import * as log2 from "lambda-log";
+var EventBridgeClient = class {
+  eventBridge;
+  EVENT_BUS_NAME;
+  constructor(eventBusName) {
+    this.eventBridge = new EventBridge({});
+    this.EVENT_BUS_NAME = eventBusName;
+  }
+  buildAndSendEvent = async (eventSource, eventType, eventData) => {
+    const event = this.buildEvent(eventType, eventData);
+    return await this.putEvent(eventSource, eventType, event);
+  };
+  buildEvent = (eventType, eventData, eventId = uuidv4(), eventTime = getCurrentTimestamp()) => {
+    return {
+      eventId,
+      eventType,
+      eventTime,
+      eventData
+    };
+  };
+  putEvent = async (source, detailType, data, headers = null) => {
+    const params = {
+      Entries: [{
+        Detail: JSON.stringify({ headers, data }),
+        DetailType: detailType,
+        EventBusName: this.EVENT_BUS_NAME,
+        Source: source,
+        Time: /* @__PURE__ */ new Date()
+      }]
+    };
+    const putEventscommand = new PutEventsCommand(params);
+    const response = await this.eventBridge.send(putEventscommand);
+    log2.debug(
+      "EventBus Event Published",
+      {
+        eventBusName: this.EVENT_BUS_NAME,
+        eventSource: source,
+        eventType: detailType,
+        event: data,
+        response
+      }
+    );
+    return response;
+  };
+};
+
+// src/clients/generic/http-client.ts
+import axios from "axios";
+import https from "https";
+var httpResponse = (res = {}) => {
+  return {
+    headers: res?.headers || {},
+    data: res?.data || {},
+    status: res?.status || 0
+  };
+};
+var handleAxiosError = (error7) => {
+  if (!error7?.response && !error7?.request)
+    throw error7;
+  return error7.response ? httpResponse(error7.response) : httpResponse({ status: 500, data: { error: error7.request } });
+};
+var axiosHttpService = (config = {}) => {
+  config.adapter = "http";
+  config.httpsAgent = new https.Agent({ keepAlive: true });
+  const axiosService = axios.create(config);
+  return {
+    instance: () => axiosService,
+    get: (url, config2) => axiosService.get(url, config2).then(httpResponse, handleAxiosError),
+    post: (url, data, config2) => axiosService.post(url, data, config2).then(httpResponse, handleAxiosError),
+    delete: (url, config2) => axiosService.delete(url, config2).then(httpResponse, handleAxiosError),
+    put: (url, data, config2) => axiosService.put(url, data, config2).then(httpResponse, handleAxiosError),
+    patch: (url, data, config2) => axiosService.patch(url, data, config2).then(httpResponse, handleAxiosError),
+    setBaseUrl: (url) => !!(axiosService.defaults.baseURL = url)
+  };
+};
+
+// src/clients/generic/s3-client.ts
+import { ObjectCannedACL, S3 } from "@aws-sdk/client-s3";
+import * as log3 from "lambda-log";
+var S3Client = class {
+  s3;
+  constructor(region = "us-west-2") {
+    this.s3 = new S3({ region });
+  }
+  async uploadJson(path, bucket, jsonData, ACL = ObjectCannedACL.private) {
+    try {
+      const res = await this.s3.putObject({
+        ACL,
+        Bucket: bucket,
+        ContentType: "application/json; charset=utf-8",
+        Body: JSON.stringify(jsonData),
+        Key: path
+      });
+      return res;
+    } catch (error7) {
+      log3.error("Error in s3 upload json", { error: error7 });
+      return error7;
+    }
+  }
+};
+
+// src/clients/generic/cognito-client.ts
+import { CognitoIdentityProvider } from "@aws-sdk/client-cognito-identity-provider";
+import * as log4 from "lambda-log";
+function dictToAwsAttributes(input) {
+  delete input.email;
+  delete input.password;
+  const output = [];
+  for (const att in input) {
+    if (Object.prototype.hasOwnProperty.call(input, att)) {
+      output.push({ Name: att, Value: input[att] });
+    }
+  }
+  return output;
+}
+var buildAttributes = (data) => {
+  const attributes = {
+    name: data.givenName,
+    family_name: data.familyName
+  };
+  return dictToAwsAttributes(attributes);
+};
+var CognitoClient = class {
+  cognitoClient;
+  USER_POOL_ID;
+  USER_POOL_NO_SECRET_CLIENT_ID;
+  constructor(userPoolId, userPoolNoSecretClientId) {
+    this.cognitoClient = new CognitoIdentityProvider({});
+    this.USER_POOL_ID = userPoolId;
+    this.USER_POOL_NO_SECRET_CLIENT_ID = userPoolNoSecretClientId;
+  }
+  signupUser = async (data) => {
+    const params = {
+      ClientId: this.USER_POOL_NO_SECRET_CLIENT_ID,
+      Password: data.password,
+      Username: data.email,
+      UserAttributes: buildAttributes(data)
+    };
+    const cognitoResponse = await this.cognitoClient.signUp(params);
+    log4.debug("Successfully Registered User", { cognitoResponse });
+    return cognitoResponse;
+  };
+  forgotPassword = async (email) => {
+    await this.adminEmailVerify(email);
+    const params = {
+      ClientId: this.USER_POOL_NO_SECRET_CLIENT_ID,
+      Username: email
+    };
+    const cognitoResponse = await this.cognitoClient.forgotPassword(params);
+    log4.debug("Sent Forgot Password", { cognitoResponse });
+    return cognitoResponse;
+  };
+  adminEmailVerify = async (email) => {
+    try {
+      const user = await this.getUserByEmail(email);
+      if (user && user?.UserStatus === "CONFIRMED" && user?.email_verified !== "true") {
+        await this.forceValidateEmail(email);
+      }
+    } catch (error7) {
+      log4.error("Failed admin email verify", { error: error7 });
+    }
+  };
+  forceValidateEmail = async (email) => {
+    try {
+      const params = {
+        UserPoolId: this.USER_POOL_ID,
+        Username: email,
+        UserAttributes: [
+          {
+            Name: "email_verified",
+            Value: "true"
+          }
+        ]
+      };
+      await this.cognitoClient.adminUpdateUserAttributes(params);
+    } catch (error7) {
+      log4.error("Failed force validate email", { email, error: error7 });
+    }
+  };
+  adminConfirmUser = async (data) => {
+    const params = {
+      UserPoolId: this.USER_POOL_ID,
+      Username: data.email
+    };
+    const cognitoResponse = await this.cognitoClient.adminConfirmSignUp(params);
+    await this.forceValidateEmail(data.email);
+    log4.debug("Admin Successfully Confirmed User", { cognitoResponse });
+    return cognitoResponse;
+  };
+  confirmUser = async (data) => {
+    const params = {
+      ClientId: this.USER_POOL_NO_SECRET_CLIENT_ID,
+      ConfirmationCode: data.confirmationCode,
+      Username: data.email
+    };
+    const cognitoResponse = await this.cognitoClient.confirmSignUp(params);
+    log4.debug("Successfully Confirmed User", { cognitoResponse });
+    return cognitoResponse;
+  };
+  resendCode = async (email) => {
+    const params = {
+      ClientId: this.USER_POOL_NO_SECRET_CLIENT_ID,
+      Username: email
+    };
+    await this.cognitoClient.resendConfirmationCode(params);
+    log4.debug("Successfully Resend Confirmation Code", { email });
+    return;
+  };
+  adminDeleteUser = async (userId) => {
+    const params = {
+      UserPoolId: this.USER_POOL_ID,
+      Username: userId
+    };
+    await this.cognitoClient.adminDeleteUser(params);
+    return true;
+  };
+  getUserByEmail = async (email) => {
+    const params = {
+      UserPoolId: this.USER_POOL_ID,
+      Filter: `email="${email}"`,
+      Limit: 1
+    };
+    const cognitoResponse = await this.cognitoClient.listUsers(params);
+    log4.debug("Get Users by Email", { cognitoResponse });
+    if (cognitoResponse?.Users && cognitoResponse?.Users.length > 0) {
+      const attributes = cognitoResponse.Users[0].Attributes;
+      const user = {
+        ...cognitoResponse.Users[0],
+        Attributes: void 0,
+        id: cognitoResponse.Users[0].sub
+      };
+      attributes.forEach((attr) => {
+        user[attr.Name] = attr?.Value;
+      });
+      return user;
+    }
+    return null;
+  };
+};
+
+// src/clients/generic/sqs-client.ts
+import { SQS } from "@aws-sdk/client-sqs";
+import { v4 as uuidv42 } from "uuid";
+import * as log5 from "lambda-log";
+var SQSClient = class {
+  sqs;
+  queueUrl;
+  constructor(region, accountId, queueName) {
+    this.sqs = new SQS({ region });
+    this.queueUrl = `https://sqs.${region}.amazonaws.com/${accountId}/${queueName}`;
+  }
+  buildAndSendMessage = async (messageType, messageBody, deplaySeconds = 0) => {
+    const message = this.buildMessage(messageType, messageBody);
+    return await this.sendMessage(message, deplaySeconds);
+  };
+  buildMessage = (messageType, messageBody, messageId = uuidv42(), messageTime = getCurrentTimestamp()) => {
+    return {
+      messageId,
+      messageType,
+      messageTime,
+      messageBody
+    };
+  };
+  sendMessage = async (messageBody, delaySeconds = 0) => {
+    const params = {
+      QueueUrl: this.queueUrl,
+      DelaySeconds: delaySeconds,
+      MessageBody: JSON.stringify(messageBody)
+    };
+    const response = await this.sqs.sendMessage(params);
+    log5.debug("SQS Message Sent", { queueUrl: this.queueUrl, messageBody, delaySeconds, response });
+    return response;
+  };
+};
+
+// src/clients/internal-api/destinations-client.ts
+import * as log6 from "lambda-log";
+var DestinationsClient = class {
+  BASE_API_URL;
+  DESTINATIONS_API_KEY;
+  constructor(baseApiUrl, destinationsApiKey) {
+    this.BASE_API_URL = baseApiUrl;
+    this.DESTINATIONS_API_KEY = destinationsApiKey;
+  }
+  getConfig = () => {
+    const SERVICE_API_ROOT_URL = `${this.BASE_API_URL}/destinations`;
+    return {
+      baseURL: SERVICE_API_ROOT_URL,
+      headers: {
+        common: {
+          "x-api-key": this.DESTINATIONS_API_KEY
+        }
+      }
+    };
+  };
+  getClient = async () => {
+    return axiosHttpService(this.getConfig());
+  };
+  createDestination = async (createDestinationRequest) => {
+    const client2 = await this.getClient();
+    const response = await client2.post("/", createDestinationRequest);
+    log6.info("createDestinationResponse", { response });
+    return response;
+  };
+  getPixelDestinations = async (pixelId) => {
+    const client2 = await this.getClient();
+    const response = await client2.get(`/?pixelId=${pixelId}`);
+    log6.info("getPixelResponse", { response });
+    return response;
+  };
+};
+
+// src/clients/internal-api/accounts-client.ts
+import * as log7 from "lambda-log";
+var AccountsClient = class {
+  BASE_API_URL;
+  ACCOUNTS_API_KEY;
+  constructor(baseApiUrl, accountsApiKey) {
+    this.BASE_API_URL = baseApiUrl;
+    this.ACCOUNTS_API_KEY = accountsApiKey;
+  }
+  getConfig = () => {
+    const SERVICE_API_ROOT_URL = `${this.BASE_API_URL}/accounts`;
+    const params = {
+      baseURL: SERVICE_API_ROOT_URL
+    };
+    if (this.ACCOUNTS_API_KEY) {
+      params.headers = {
+        common: {
+          "x-api-key": this.ACCOUNTS_API_KEY
+        }
+      };
+    }
+    return params;
+  };
+  getClient = async () => {
+    return axiosHttpService(this.getConfig());
+  };
+  createAccount = async (createAccountRequest) => {
+    const client2 = await this.getClient();
+    const createAccountResponse = await client2.post("", createAccountRequest);
+    log7.info("createAccountResponse", { createAccountResponse });
+    return createAccountResponse;
+  };
+  updateAccount = async (accountId, body) => {
+    const client2 = await this.getClient();
+    const response = await client2.patch(`/${accountId}/`, body);
+    log7.info("update Account response", { response });
+    return response;
+  };
+  addOwner = async (accountId, userId) => {
+    const client2 = await this.getClient();
+    const addOwnerResponse = await client2.post("/addOwner", { accountId, userId });
+    log7.info("addOwnerResponse", { addOwnerResponse });
+    return addOwnerResponse;
+  };
+  isAuthorizedUser = async (userId, accountId, pixelId) => {
+    const client2 = await this.getClient();
+    const body = {
+      userId,
+      accountId,
+      pixelId
+    };
+    const response = await client2.post("/checkUserAuthorization", body);
+    log7.info("checkUserAuthorization", { response });
+    return response;
+  };
+  adminDeleteAccount = async (accountId) => {
+    const client2 = await this.getClient();
+    const success2 = await client2.delete(`/${accountId}`);
+    log7.info("adminDeleteAccount");
+    return success2;
+  };
+  getPixelConfigById = async (pixelId) => {
+    const client2 = await this.getClient();
+    const pixelResponse = await client2.get(`/px/${pixelId}/config`);
+    log7.debug("get pixelResponse", { pixelResponse });
+    return pixelResponse;
+  };
+  getAccount = async (accountId) => {
+    const client2 = await this.getClient();
+    const response = await client2.get(`/${accountId}/`);
+    log7.info("get account response", { response });
+    return response;
+  };
+  addUserToAccount = async (accountId, userId) => {
+    const client2 = await this.getClient();
+    const response = await client2.post("/addUser", { accountId, userId });
+    log7.info("add user account response", { response });
+    return response;
+  };
+  // setAccountSubscriptionId = async (accountId: string, subscriptionId: string): Promise<ApiResponse<any>> => {
+  //   const client = await this.getClient();
+  //   const pixelResponse = await client.get(`/px/${pixelId}/config`);
+  //   log.debug('pixelResponse', { pixelResponse });
+  //   return pixelResponse;
+  // };
+};
+
+// src/clients/internal-api/users-auth-client.ts
+import * as log8 from "lambda-log";
+
+// src/libs/http-error.ts
+import { strict as assert } from "assert";
+var deepClone = (o = {}) => JSON.parse(JSON.stringify(o));
+var containsStackTrace = (text = "") => /at.+\.js:\d+:\d+/.test(text);
+var objectContainsStackTrace = (obj) => !obj ? false : containsStackTrace(JSON.stringify(obj));
+var supportedStatusCodes = {
+  400: "Bad Request",
+  401: "Unauthorized",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  409: "Conflict",
+  412: "Precondition Failed",
+  413: "Payload Too Large",
+  415: "Unsupported Media Type",
+  428: "Precondition Required",
+  429: "Too Many Requests",
+  500: "Internal Server Error",
+  501: "Not Implemented",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout"
+};
+var supportedStatusCodesMessage = `statusCode must be one of the following: ${JSON.stringify(Object.keys(supportedStatusCodes))}`;
+var _HttpError = class extends Error {
+  body;
+  headers;
+  statusCode;
+  isServerError;
+  constructor(statusCode, message, body, headers) {
+    assert(statusCode in supportedStatusCodes, supportedStatusCodesMessage);
+    const isServerError = statusCode > 499;
+    assert(
+      body === void 0 || typeof body === "object",
+      "body must be an object or omitted"
+    );
+    assert(
+      headers === void 0 || typeof headers === "object",
+      "headers must be an object or omitted"
+    );
+    message = message ?? supportedStatusCodes[statusCode];
+    assert(
+      !containsStackTrace(message) && !objectContainsStackTrace(body),
+      "the message or data parameters may not contain errors or stack traces"
+    );
+    super(message);
+    this.body = deepClone(body);
+    this.headers = deepClone(headers);
+    this.statusCode = statusCode;
+    this.isServerError = isServerError;
+    if (!this?.body?.message) {
+      this.body.message = this.message;
+    }
+  }
+  static get supportedStatusCodes() {
+    return supportedStatusCodes;
+  }
+};
+var HttpError = _HttpError;
+__publicField(HttpError, "badRequest", (message, body, headers) => {
+  return new _HttpError(400, message, body, headers);
+});
+__publicField(HttpError, "unauthorized", (message, body, headers) => new _HttpError(401, message, body, headers));
+__publicField(HttpError, "forbidden", (message, body, headers) => new _HttpError(403, message, body, headers));
+__publicField(HttpError, "notFound", (message, body, headers) => new _HttpError(404, message, body, headers));
+__publicField(HttpError, "internal", (message, body, headers) => new _HttpError(500, message, body, headers));
+__publicField(HttpError, "notImplemented", () => new _HttpError(501));
+__publicField(HttpError, "badGateway", () => new _HttpError(502));
+__publicField(HttpError, "serviceUnavailable", (headers) => new _HttpError(503, void 0, void 0, headers));
+__publicField(HttpError, "gatewayTimeout", () => new _HttpError(504));
+
+// src/libs/http-status-codes.ts
+var HttpStatusCodes = /* @__PURE__ */ ((HttpStatusCodes2) => {
+  HttpStatusCodes2[HttpStatusCodes2["CONTINUE"] = 100] = "CONTINUE";
+  HttpStatusCodes2[HttpStatusCodes2["SWITCHING_PROTOCOLS"] = 101] = "SWITCHING_PROTOCOLS";
+  HttpStatusCodes2[HttpStatusCodes2["PROCESSING"] = 102] = "PROCESSING";
+  HttpStatusCodes2[HttpStatusCodes2["OK"] = 200] = "OK";
+  HttpStatusCodes2[HttpStatusCodes2["CREATED"] = 201] = "CREATED";
+  HttpStatusCodes2[HttpStatusCodes2["ACCEPTED"] = 202] = "ACCEPTED";
+  HttpStatusCodes2[HttpStatusCodes2["NON_AUTHORITATIVE_INFORMATION"] = 203] = "NON_AUTHORITATIVE_INFORMATION";
+  HttpStatusCodes2[HttpStatusCodes2["NO_CONTENT"] = 204] = "NO_CONTENT";
+  HttpStatusCodes2[HttpStatusCodes2["RESET_CONTENT"] = 205] = "RESET_CONTENT";
+  HttpStatusCodes2[HttpStatusCodes2["PARTIAL_CONTENT"] = 206] = "PARTIAL_CONTENT";
+  HttpStatusCodes2[HttpStatusCodes2["MULTI_STATUS"] = 207] = "MULTI_STATUS";
+  HttpStatusCodes2[HttpStatusCodes2["MULTIPLE_CHOICES"] = 300] = "MULTIPLE_CHOICES";
+  HttpStatusCodes2[HttpStatusCodes2["MOVED_PERMANENTLY"] = 301] = "MOVED_PERMANENTLY";
+  HttpStatusCodes2[HttpStatusCodes2["MOVED_TEMPORARILY"] = 302] = "MOVED_TEMPORARILY";
+  HttpStatusCodes2[HttpStatusCodes2["SEE_OTHER"] = 303] = "SEE_OTHER";
+  HttpStatusCodes2[HttpStatusCodes2["NOT_MODIFIED"] = 304] = "NOT_MODIFIED";
+  HttpStatusCodes2[HttpStatusCodes2["USE_PROXY"] = 305] = "USE_PROXY";
+  HttpStatusCodes2[HttpStatusCodes2["TEMPORARY_REDIRECT"] = 307] = "TEMPORARY_REDIRECT";
+  HttpStatusCodes2[HttpStatusCodes2["PERMANENT_REDIRECT"] = 308] = "PERMANENT_REDIRECT";
+  HttpStatusCodes2[HttpStatusCodes2["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+  HttpStatusCodes2[HttpStatusCodes2["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+  HttpStatusCodes2[HttpStatusCodes2["PAYMENT_REQUIRED"] = 402] = "PAYMENT_REQUIRED";
+  HttpStatusCodes2[HttpStatusCodes2["FORBIDDEN"] = 403] = "FORBIDDEN";
+  HttpStatusCodes2[HttpStatusCodes2["NOT_FOUND"] = 404] = "NOT_FOUND";
+  HttpStatusCodes2[HttpStatusCodes2["METHOD_NOT_ALLOWED"] = 405] = "METHOD_NOT_ALLOWED";
+  HttpStatusCodes2[HttpStatusCodes2["NOT_ACCEPTABLE"] = 406] = "NOT_ACCEPTABLE";
+  HttpStatusCodes2[HttpStatusCodes2["PROXY_AUTHENTICATION_REQUIRED"] = 407] = "PROXY_AUTHENTICATION_REQUIRED";
+  HttpStatusCodes2[HttpStatusCodes2["REQUEST_TIMEOUT"] = 408] = "REQUEST_TIMEOUT";
+  HttpStatusCodes2[HttpStatusCodes2["CONFLICT"] = 409] = "CONFLICT";
+  HttpStatusCodes2[HttpStatusCodes2["GONE"] = 410] = "GONE";
+  HttpStatusCodes2[HttpStatusCodes2["LENGTH_REQUIRED"] = 411] = "LENGTH_REQUIRED";
+  HttpStatusCodes2[HttpStatusCodes2["PRECONDITION_FAILED"] = 412] = "PRECONDITION_FAILED";
+  HttpStatusCodes2[HttpStatusCodes2["REQUEST_TOO_LONG"] = 413] = "REQUEST_TOO_LONG";
+  HttpStatusCodes2[HttpStatusCodes2["REQUEST_URI_TOO_LONG"] = 414] = "REQUEST_URI_TOO_LONG";
+  HttpStatusCodes2[HttpStatusCodes2["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
+  HttpStatusCodes2[HttpStatusCodes2["REQUESTED_RANGE_NOT_SATISFIABLE"] = 416] = "REQUESTED_RANGE_NOT_SATISFIABLE";
+  HttpStatusCodes2[HttpStatusCodes2["EXPECTATION_FAILED"] = 417] = "EXPECTATION_FAILED";
+  HttpStatusCodes2[HttpStatusCodes2["IM_A_TEAPOT"] = 418] = "IM_A_TEAPOT";
+  HttpStatusCodes2[HttpStatusCodes2["INSUFFICIENT_SPACE_ON_RESOURCE"] = 419] = "INSUFFICIENT_SPACE_ON_RESOURCE";
+  HttpStatusCodes2[HttpStatusCodes2["METHOD_FAILURE"] = 420] = "METHOD_FAILURE";
+  HttpStatusCodes2[HttpStatusCodes2["MISDIRECTED_REQUEST"] = 421] = "MISDIRECTED_REQUEST";
+  HttpStatusCodes2[HttpStatusCodes2["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+  HttpStatusCodes2[HttpStatusCodes2["LOCKED"] = 423] = "LOCKED";
+  HttpStatusCodes2[HttpStatusCodes2["FAILED_DEPENDENCY"] = 424] = "FAILED_DEPENDENCY";
+  HttpStatusCodes2[HttpStatusCodes2["PRECONDITION_REQUIRED"] = 428] = "PRECONDITION_REQUIRED";
+  HttpStatusCodes2[HttpStatusCodes2["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
+  HttpStatusCodes2[HttpStatusCodes2["REQUEST_HEADER_FIELDS_TOO_LARGE"] = 431] = "REQUEST_HEADER_FIELDS_TOO_LARGE";
+  HttpStatusCodes2[HttpStatusCodes2["UNAVAILABLE_FOR_LEGAL_REASONS"] = 451] = "UNAVAILABLE_FOR_LEGAL_REASONS";
+  HttpStatusCodes2[HttpStatusCodes2["INTERNAL_SERVER_ERROR"] = 500] = "INTERNAL_SERVER_ERROR";
+  HttpStatusCodes2[HttpStatusCodes2["NOT_IMPLEMENTED"] = 501] = "NOT_IMPLEMENTED";
+  HttpStatusCodes2[HttpStatusCodes2["BAD_GATEWAY"] = 502] = "BAD_GATEWAY";
+  HttpStatusCodes2[HttpStatusCodes2["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
+  HttpStatusCodes2[HttpStatusCodes2["GATEWAY_TIMEOUT"] = 504] = "GATEWAY_TIMEOUT";
+  HttpStatusCodes2[HttpStatusCodes2["HTTP_VERSION_NOT_SUPPORTED"] = 505] = "HTTP_VERSION_NOT_SUPPORTED";
+  HttpStatusCodes2[HttpStatusCodes2["INSUFFICIENT_STORAGE"] = 507] = "INSUFFICIENT_STORAGE";
+  HttpStatusCodes2[HttpStatusCodes2["NETWORK_AUTHENTICATION_REQUIRED"] = 511] = "NETWORK_AUTHENTICATION_REQUIRED";
+  return HttpStatusCodes2;
+})(HttpStatusCodes || {});
+
+// src/clients/internal-api/users-auth-client.ts
+var UsersAuthClient = class {
+  SERVICE_API_ROOT_URL;
+  BASE_API_URL;
+  USERS_AUTH_API_KEY;
+  constructor(baseApiUrl, usersAuthApiKey) {
+    this.BASE_API_URL = baseApiUrl;
+    this.USERS_AUTH_API_KEY = usersAuthApiKey;
+    this.SERVICE_API_ROOT_URL = `${this.BASE_API_URL}/auth`;
+  }
+  getConfig = () => {
+    return {
+      baseURL: this.SERVICE_API_ROOT_URL,
+      headers: {
+        common: {}
+      }
+    };
+  };
+  getClient = async () => {
+    return axiosHttpService(this.getConfig());
+  };
+  signupAndConfirmUser = async (userSignupRequest) => {
+    const user = await this.signupUser(userSignupRequest);
+    await this.adminConfirmUser(user.email);
+    return user;
+  };
+  signupUser = async (userSignupRequest) => {
+    log8.info("Attempting to signup user", { email: userSignupRequest.email });
+    const client2 = await this.getClient();
+    const response = await client2.post("/signup", userSignupRequest);
+    if (response.status !== 200 || !response?.data?.user) {
+      const message = "User Signup Failed";
+      log8.error(message, { response });
+      throw new HttpError(500 /* INTERNAL_SERVER_ERROR */, message);
+    }
+    log8.info("User Signup Successful", { response });
+    return response.data.user;
+  };
+  //userName is same as user id
+  adminConfirmUser = async (email) => {
+    log8.info("Attempting to admin confirm user", { email });
+    const client2 = await this.getClient();
+    const response = await client2.post(
+      "/admin/confirm",
+      {
+        email
+      },
+      {
+        headers: {
+          "x-api-key": this.USERS_AUTH_API_KEY
+        }
+      }
+    );
+    if (response.status !== 200) {
+      const message = "Admin User Confirmation Failed";
+      log8.error(message, { response });
+      throw new HttpError(500 /* INTERNAL_SERVER_ERROR */, message);
+    }
+    log8.info("Admin User Confirmation Successful", { response });
+    return response;
+  };
+  getUserByEmail = async (email) => {
+    const client2 = await this.getClient();
+    const getUserResponse = await client2.get("/lookup", {
+      headers: {
+        "x-api-key": this.USERS_AUTH_API_KEY
+      },
+      params: {
+        email
+      }
+    });
+    log8.info("getUserResponse", { getUserResponse });
+    return getUserResponse;
+  };
+};
+
+// src/clients/internal-api/shopify-app-install-client.ts
+import log9 from "lambda-log";
+var ShopifyAppInstallClient = class {
+  BASE_API_URL;
+  SHOPIFY_APP_INSTALL_API_KEY;
+  constructor(baseApiUrl, shopifyAppInstallApiKey) {
+    this.BASE_API_URL = baseApiUrl;
+    this.SHOPIFY_APP_INSTALL_API_KEY = shopifyAppInstallApiKey;
+  }
+  getConfig = () => {
+    const SERVICE_API_ROOT_URL = `${this.BASE_API_URL}/shopify-app-installs`;
+    return {
+      baseURL: SERVICE_API_ROOT_URL,
+      headers: {
+        common: {
+          "x-api-key": this.SHOPIFY_APP_INSTALL_API_KEY
+        }
+      }
+    };
+  };
+  getClient = async () => {
+    return axiosHttpService(this.getConfig());
+  };
+  updateShopifyAppInstall = async (shopifyAppInstallId, updateShopifyAppInstallRequest) => {
+    const client2 = await this.getClient();
+    const response = await client2.put(`/${shopifyAppInstallId}`, updateShopifyAppInstallRequest);
+    log9.info("updateShopifyAppInstall", { response });
+    return response;
+  };
+  getShopifyAppInstall = async (shopifyAppInstallId) => {
+    const client2 = await this.getClient();
+    const response = await client2.get(`/${shopifyAppInstallId}`);
+    log9.info("getShopifyAppInstall", { response });
+    return response;
+  };
+  getShopifyAppInstallByShop = async (shop) => {
+    const client2 = await this.getClient();
+    const response = await client2.get(`/?shop=${shop}`);
+    log9.info("getShopifyAppInstallByShop", { response });
+    return response;
+  };
+};
+
+// src/clients/third-party/shopify-client.ts
+import * as log10 from "lambda-log";
+var _ShopifyClient = class {
+};
+var ShopifyClient = _ShopifyClient;
+__publicField(ShopifyClient, "_shopify_api_version", process.env.SHOPIFY_API_VERSION);
+__publicField(ShopifyClient, "getConfig", (shopifyDomain, accessToken) => {
+  const config = {
+    baseURL: `https://${shopifyDomain}/admin/api/${_ShopifyClient._shopify_api_version}`,
+    headers: {
+      common: {
+        "X-Shopify-Access-Token": accessToken
+      }
+    }
+  };
+  return config;
+});
+__publicField(ShopifyClient, "getClient", (shopifyDomain, accessToken) => {
+  return axiosHttpService(
+    _ShopifyClient.getConfig(shopifyDomain, accessToken)
+  );
+});
+__publicField(ShopifyClient, "registerApp", async (shop, code, appKey, appSecret) => {
+  const client2 = axiosHttpService();
+  const url = "https://" + shop + "/admin/oauth/access_token";
+  const payload = {
+    client_id: appKey,
+    client_secret: appSecret,
+    code
+  };
+  const res = await client2.post(url, payload);
+  return res;
+});
+__publicField(ShopifyClient, "registerWebhookTopic", async (shop, accessToken, eventBridgeArn, topic) => {
+  const client2 = axiosHttpService();
+  const url = `https://${shop}/admin/api/${_ShopifyClient._shopify_api_version}/webhooks.json`;
+  const payload = {
+    webhook: {
+      topic,
+      address: eventBridgeArn,
+      format: "json"
+    }
+  };
+  const res = await client2.post(url, payload, { headers: { "X-Shopify-Access-Token": accessToken } });
+  if (res.status >= 400) {
+    log10.error("Failed to register Webhook Topic", { shop, accessToken, eventBridgeArn, topic, url, payload });
+  }
+  log10.debug("Shopify Client Webhook Registration Response", { registrationResponse: res });
+  return res;
+});
+__publicField(ShopifyClient, "updateShopifyAppMetafield", async (shop, accessToken, pixelId) => {
+  const url = `https://${shop}/admin/api/${_ShopifyClient._shopify_api_version}/metafields.json`;
+  const payload = {
+    metafield: {
+      namespace: "adtr",
+      key: "adtr.config",
+      value: pixelId,
+      type: "single_line_text_field"
+    }
+  };
+  const res = await _ShopifyClient.genericShopifyPost(url, accessToken, payload);
+  if (res.status >= 400) {
+    log10.error("Failed to update Shopify app Metafield ", { shop, accessToken, url, payload });
+  }
+  return res;
+});
+__publicField(ShopifyClient, "getShopifyStoreProperties", async (shop, accessToken) => {
+  const url = `https://${shop}/admin/api/${_ShopifyClient._shopify_api_version}/shop.json`;
+  const res = await _ShopifyClient.genericShopifyGet(url, accessToken);
+  if (res.status >= 400) {
+    log10.error("Failed to get Shopify Store Properties", { shop, accessToken, url });
+  }
+  return res;
+});
+__publicField(ShopifyClient, "createAppSubscription", async (shop, accessToken, planName, price, returnUrl, trialDays, test) => {
+  const url = `https://${shop}/admin/api/${_ShopifyClient._shopify_api_version}/recurring_application_charges.json`;
+  const recurring_application_charge = {
+    name: planName,
+    price,
+    return_url: returnUrl,
+    trial_days: trialDays,
+    test
+  };
+  const res = await _ShopifyClient.genericShopifyPost(url, accessToken, { recurring_application_charge });
+  if (res.status >= 400) {
+    log10.error("Failed to create App Subscription", { shop, accessToken, url });
+  }
+  return res;
+});
+__publicField(ShopifyClient, "cancelAppSubscription", async (shop, accessToken, chargeId) => {
+  const url = `https://${shop}/admin/api/${_ShopifyClient._shopify_api_version}/recurring_application_charges/${chargeId}.json`;
+  const client2 = axiosHttpService();
+  const res = await client2.delete(url, { headers: { "X-Shopify-Access-Token": accessToken } });
+  if (res.status !== 200) {
+    log10.error("Failed to cancel recurring App billing", { shop, accessToken, url });
+  }
+  return res;
+});
+__publicField(ShopifyClient, "listAppSubscriptions", async (shop, accessToken) => {
+  const url = `https://${shop}/admin/api/${_ShopifyClient._shopify_api_version}/recurring_application_charges.json`;
+  const res = await _ShopifyClient.genericShopifyGet(url, accessToken);
+  if (res.status >= 400) {
+    log10.error("Failed to get App Subscriptions", { shop, accessToken, url });
+  }
+  return res;
+});
+__publicField(ShopifyClient, "genericShopifyPost", async (url, accessToken, payload) => {
+  const client2 = axiosHttpService();
+  const res = await client2.post(url, payload, { headers: { "X-Shopify-Access-Token": accessToken, "Content-Type": "application/json" } });
+  log10.debug("Shopify Client Response", { res });
+  return res;
+});
+__publicField(ShopifyClient, "genericShopifyGet", async (url, accessToken) => {
+  const client2 = axiosHttpService();
+  const res = await client2.get(url, { headers: { "X-Shopify-Access-Token": accessToken } });
+  log10.debug("Shopify Client Response", { res });
+  return res;
+});
+__publicField(ShopifyClient, "genericShopifyPut", async (url, accessToken, payload) => {
+  const client2 = axiosHttpService();
+  const res = await client2.put(url, payload, { headers: { "X-Shopify-Access-Token": accessToken } });
+  log10.debug("Shopify Client Response", { res });
+  return res;
+});
+
+// src/helpers/input-validation-helper.ts
+import * as log11 from "lambda-log";
+var validateInput = (schema, input) => {
+  const { error: error7, value } = schema.validate(input);
+  if (error7) {
+    log11.info("", { error: error7 });
+    const httperr = HttpError.badRequest("Bad Request", {
+      errors: error7.details.map((detail) => ({
+        message: detail?.message,
+        key: detail?.context?.key,
+        path: detail?.path
+      }))
+    });
+    log11.info("", { httperr });
+    throw httperr;
+  }
+  return value;
+};
+
+// src/helpers/logging-helper.ts
+import * as log12 from "lambda-log";
+var stage = process?.env?.STAGE;
+var configureLogger = (event, context, debug6 = true) => {
+  log12.options.meta.stage = stage;
+  log12.options.meta.source_name = context?.functionName || "unknown";
+  log12.options.meta.awsRequestId = context?.awsRequestId || "unknown";
+  log12.options.meta.lambdaEvent = event;
+  log12.options.debug = debug6;
+};
+
+// src/helpers/response-helper.ts
+var success = (body) => {
+  return buildResponse(200, body);
+};
+var defaultError = {
+  message: "internalServerError"
+};
+var failure = (error7, statusCode = 500) => {
+  statusCode = error7?.statusCode ?? statusCode;
+  let body = defaultError;
+  if (error7?.body) {
+    body = error7.body;
+  } else if (error7?.message) {
+    body = { message: error7.message };
+  } else if (statusCode === 500) {
+    body = defaultError;
+  }
+  return buildResponse(statusCode, body);
+};
+var buildResponse = (statusCode, body = {}) => {
+  delete body.stack;
+  return {
+    statusCode,
+    headers: {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Credentials": true,
+      "cache-control": "max-age=86400",
+      Date: /* @__PURE__ */ new Date(),
+      "Last-Modified": /* @__PURE__ */ new Date(),
+      "Access-Control-Allow-Headers": "Content-Type, Content-Encoding"
+    },
+    body: JSON.stringify(body)
+  };
+};
+
+// src/helpers/shopify-helper.ts
+import { createHmac } from "crypto";
+import * as log13 from "lambda-log";
+
+// src/libs/url.ts
+var mapObjectToQueryString = (inputObj) => {
+  const qsp = Object.entries(inputObj).sort((a, b) => a[0] < b[0] ? -1 : 1);
+  const urlParams = new URLSearchParams();
+  qsp.map((p2) => {
+    urlParams.append(p2[0], p2[1]);
+  });
+  const qs = urlParams.toString();
+  return qs;
+};
+
+// src/helpers/shopify-helper.ts
+var isShopifyRequestValid = (validationParams, validationHmac, shopifyAppApiSecret) => {
+  delete validationParams.hmac;
+  const hmacString = mapObjectToQueryString(validationParams);
+  const generatedHash = createHmac("sha256", shopifyAppApiSecret).update(hmacString).digest("hex");
+  return generatedHash === validationHmac;
+};
+var validateShopifyRequest = (validationParams, validationHmac, shopifyAppApiSecret) => {
+  log13.info("Validating shopify request is authentic", { validationParams });
+  const isValid = isShopifyRequestValid(validationParams, validationHmac, shopifyAppApiSecret);
+  if (!isValid) {
+    const message = "Failed: Shopify Request hmac validation";
+    log13.error(message);
+    throw HttpError.badRequest(message);
+  }
+  log13.info("Sucess: Shopify Request hmac validation");
+  return true;
+};
+
+// node_modules/@adtrackify/at-tracking-event-types/dist/index.js
+var s = ((n) => (n.PENDING = "pending", n.ACTIVE = "active", n.INACTIVE = "inactive", n))(s || {});
+var g = ((i) => (i.FACEBOOK = "facebook", i.TIKTOK = "tiktok", i.GOOGLE_ADS = "googleAds", i.GOOGLE_ANALYTICS_4 = "googleAnalytics4", i.HUBSPOT = "hubspot", i.WEBHOOK = "webhook", i.CUSTOM_HTML = "customHTML", i.CUSTOM_JS = "customJS", i.SNAPCHAT = "snapchat", i.TWITTER = "twitter", i.REDDIT = "reddit", i))(g || {});
+var c = ((n) => (n.HEADER = "header", n.FOOTER = "footer", n.BODY = "body", n))(c || {});
+var p = ((o) => (o.STARTED = "started", o.COMPLETED = "completed", o.UNINSTALLED = "uninstalled", o.FAILED = "failed", o.NONE = "none", o))(p || {});
+var d = ((e) => (e.ACTIVE = "active", e.CANCELLED = "cancelled", e.DECLINED = "declined", e.EXPIRED = "expired", e.FROZEN = "frozen", e.PENDING = "pending", e.NOT_SUBMITTED = "na", e))(d || {});
+var f = ((a) => (a.MONTHLY = "monthly", a.YEARLY = "yearly", a))(f || {});
+var m = ((r) => (r.CURRENT = "current", r.PAST_DUE = "past_due", r.CANCELLED = "cancelled", r.FAILED = "failed", r))(m || {});
+var l = ((e) => (e.ACTIVE = "active", e.CANCELLED = "cancelled", e.DECLINED = "declined", e.EXPIRED = "expired", e.FROZEN = "frozen", e.PENDING = "pending", e.NOT_SUBMITTED = "na", e))(l || {});
+var u = ((n) => (n.STRIPE = "stripe", n.PAYPAL = "paypal", n.SHOPIFY = "shopify", n))(u || {});
+var x = ((t) => (t.ADD_PAYMENT_INFO = "add_payment_info", t.ADD_SHIPPING_INFO = "add_shipping_info", t.ADD_TO_CART = "add_to_cart", t.ADD_TO_WISHLIST = "add_to_wishlist", t.INITIATE_CHECKOUT = "initiate_checkout", t.LEAD = "lead", t.LOGIN = "login", t.PAGE_VIEW = "page_view", t.PURCHASE = "purchase", t.REFUND = "refund", t.SEARCH = "search", t.SIGN_UP = "sign_up", t.VIEW_CART = "view_cart", t.VIEW_CONTENT = "view_content", t.SELECT_SHIPPING_METHOD = "select_shipping_method", t.VIRTUALIZED_VIEWED_PAYMENT_FORM = "virtualized_viewd_payment_form", t.METRIC = "metric", t.WEB_VITAL = "web_vital", t))(x || {});
+var C = ((r) => (r.TRACKING = "tracking", r.METRIC = "metric", r.IDENTIFY = "identify", r.LOG = "log", r))(C || {});
+
+// src/helpers/subscription-helper.ts
+var StripeBillingMap = {
+  dev2: {
+    "free": "price_1JzjbKK7krGh4037ezNbGJEm",
+    "starter_monthly": "price_1JwzsGK7krGh4037Li0hPpsZ",
+    "starter_yearly": "price_1JwzsGK7krGh4037Li0hPpsZ",
+    "scale_monthly": "price_1JzjcSK7krGh4037yh34LPk3",
+    "scale_yearly": "price_1JzjcSK7krGh4037QiBJYfnD",
+    "growth_monthly": "price_1Jzje1K7krGh4037KErHBp5N",
+    "growth_yearly": "price_1Jzje1K7krGh4037MhCUhTDh"
+  },
+  qa2: {
+    "free": "price_1JzjbKK7krGh4037ezNbGJEm",
+    "starter_monthly": "price_1JwzsGK7krGh4037Li0hPpsZ",
+    "starter_yearly": "price_1JwzsGK7krGh4037Li0hPpsZ",
+    "scale_monthly": "price_1JzjcSK7krGh4037yh34LPk3",
+    "scale_yearly": "price_1JzjcSK7krGh4037QiBJYfnD",
+    "growth_monthly": "price_1Jzje1K7krGh4037KErHBp5N",
+    "growth_yearly": "price_1Jzje1K7krGh4037MhCUhTDh"
+  },
+  prod2: {
+    "free": "price_1KAFsIK7krGh4037RsaAYMEl",
+    "starter_monthly": "price_1KAFsMK7krGh4037Lz3P0ksU",
+    "starter_yearly": "price_1KAFsMK7krGh4037Dj1WmSi8",
+    "scale_monthly": "price_1KAFrxK7krGh4037zWCdaTly",
+    "scale_yearly": "price_1KAFrxK7krGh40375fhymyWP",
+    "growth_monthly": "price_1KAFs7K7krGh4037JChjz5Cr",
+    "growth_yearly": "price_1KAFs7K7krGh4037rZElg12s"
+  },
+  dev: {
+    "free": "price_1JzjbKK7krGh4037ezNbGJEm",
+    "starter_monthly": "price_1JwzsGK7krGh4037Li0hPpsZ",
+    "starter_yearly": "price_1JwzsGK7krGh4037Li0hPpsZ",
+    "scale_monthly": "price_1JzjcSK7krGh4037yh34LPk3",
+    "scale_yearly": "price_1JzjcSK7krGh4037QiBJYfnD",
+    "growth_monthly": "price_1Jzje1K7krGh4037KErHBp5N",
+    "growth_yearly": "price_1Jzje1K7krGh4037MhCUhTDh"
+  },
+  qa: {
+    "free": "price_1JzjbKK7krGh4037ezNbGJEm",
+    "starter_monthly": "price_1JwzsGK7krGh4037Li0hPpsZ",
+    "starter_yearly": "price_1JwzsGK7krGh4037Li0hPpsZ",
+    "scale_monthly": "price_1JzjcSK7krGh4037yh34LPk3",
+    "scale_yearly": "price_1JzjcSK7krGh4037QiBJYfnD",
+    "growth_monthly": "price_1Jzje1K7krGh4037KErHBp5N",
+    "growth_yearly": "price_1Jzje1K7krGh4037MhCUhTDh"
+  },
+  prod: {
+    "free": "price_1KAFsIK7krGh4037RsaAYMEl",
+    "starter_monthly": "price_1KAFsMK7krGh4037Lz3P0ksU",
+    "starter_yearly": "price_1KAFsMK7krGh4037Dj1WmSi8",
+    "scale_monthly": "price_1KAFrxK7krGh4037zWCdaTly",
+    "scale_yearly": "price_1KAFrxK7krGh40375fhymyWP",
+    "growth_monthly": "price_1KAFs7K7krGh4037JChjz5Cr",
+    "growth_yearly": "price_1KAFs7K7krGh4037rZElg12s"
+  }
+};
+var CommonPlanInfo = [
+  //'60-day Risk Free Trial',
+  "Free Server Side Tracking & Conversion API",
+  "MultiPixel Support (Multiple facebook, tiktok, etc)",
+  "Corrects Facebook Conversion Tracking post IOS14",
+  "Increase ROAS & Attribution Data",
+  "Enhanced Fingerprinting & Identity Resolution",
+  "Unlimited Integrations",
+  "Advanced Integrations (Webhooks, Custom JS/HTML, Hubspot)"
+];
+var SubscriptionPlanSeedItems = {
+  items: [
+    {
+      id: 1,
+      planName: "free",
+      displayName: "Free",
+      sku: "ADT-001",
+      description: "Free Plan - Monthly",
+      price: "0",
+      displayPrice: "$0",
+      billingFrequency: f.MONTHLY,
+      trialLengthDays: 0,
+      trialRequiresCreditCard: false,
+      planDesc: [
+        ...CommonPlanInfo,
+        "Free Up to 500 orders/month (50,000 events)*"
+      ],
+      unitPriceText: "try now - free forever",
+      isHighlighted: false,
+      isBanner: false
+    },
+    // STARTER PLANS
+    {
+      id: 2,
+      planName: "starter_monthly",
+      displayName: "Starter",
+      sku: "ADT-002",
+      description: "Starter Plan - Monthly",
+      price: "79.99",
+      displayPrice: "$79.99",
+      billingFrequency: f.MONTHLY,
+      trialLengthDays: 60,
+      trialRequiresCreditCard: false,
+      planDesc: [
+        "60-day Risk Free Trial",
+        ...CommonPlanInfo,
+        "Up to 2,000 orders/month (250,000 events)*"
+      ],
+      isHighlighted: true,
+      isBanner: true,
+      bannerColor: "blue",
+      bannerText: "MOST POPULAR"
+    },
+    {
+      id: 3,
+      planName: "starter_yearly",
+      displayName: "Starter",
+      sku: "ADT-003",
+      description: "Starter Plan - Yearly",
+      price: "767.90",
+      displayPrice: "$63.99",
+      billingFrequency: f.YEARLY,
+      trialLengthDays: 30,
+      trialRequiresCreditCard: false,
+      planDesc: [
+        "60-day Risk Free Trial",
+        ...CommonPlanInfo,
+        "Up to 2,000 orders/month (250,000 events)*"
+      ],
+      unitPriceText: "billed yearly ($767.90) - 20% savings",
+      isHighlighted: true,
+      isBanner: true,
+      bannerColor: "blue",
+      bannerText: "MOST POPULAR"
+    },
+    // SCALE PLANS
+    {
+      id: 4,
+      planName: "scale_monthly",
+      displayName: "Scale",
+      sku: "ADT-004",
+      description: "Scale Plan - Monthly",
+      price: "199.99",
+      displayPrice: "$199.99",
+      billingFrequency: f.MONTHLY,
+      trialLengthDays: 60,
+      trialRequiresCreditCard: false,
+      planDesc: [
+        "60-day Risk Free Trial",
+        ...CommonPlanInfo,
+        "Up to 7,500 orders/month (750,000 events)*"
+      ],
+      unitPriceText: "",
+      isHighlighted: false,
+      isBanner: false
+    },
+    {
+      id: 5,
+      planName: "scale_yearly",
+      displayName: "Scale",
+      sku: "ADT-005",
+      description: "Scale Plan - Yearly",
+      price: "1823.91",
+      displayPrice: "$151.99",
+      billingFrequency: f.YEARLY,
+      trialLengthDays: 60,
+      trialRequiresCreditCard: false,
+      planDesc: [
+        "60-day Risk Free Trial",
+        ...CommonPlanInfo,
+        "Up to 7,500 orders/month (750,000 events)*"
+      ],
+      unitPriceText: "billed yearly ($1823.91) - 24% savings",
+      isHighlighted: false,
+      isBanner: false
+    }
+    // // GROWTH PLANS
+    // {
+    //   id: 6,
+    //   planName: 'growth_monthly',
+    //   displayName: 'Growth',
+    //   sku: 'ADT-006',
+    //   description: 'Growth Plan - Monthly',
+    //   price: '199.99',
+    //   displayPrice: '$199.99',
+    //   billingFrequency: PLAN_BILLING_FREQUENCY.MONTHLY,
+    //   trialLengthDays: 60,
+    //   trialRequiresCreditCard: false,
+    //   planDesc: [
+    //     '60-day Risk Free Trial',
+    //     ...CommonPlanInfo,
+    //     '250,000 tracking events/mo'
+    //   ],
+    //   unitPriceText: 'billed yearly ($540) - 25% savings',
+    //   isHighlighted: false,
+    //   isBanner: true,
+    //   bannerColor: 'orange',
+    //   bannerText: 'BEST VALUE'
+    // }, {
+    //   id: 7,
+    //   planName: 'growth_yearly',
+    //   displayName: 'Growth',
+    //   sku: 'ADT-007',
+    //   description: 'Growth Plan - Yearly',
+    //   price: '1799.91',
+    //   displayPrice: '$149.99',
+    //   billingFrequency: PLAN_BILLING_FREQUENCY.YEARLY,
+    //   trialLengthDays: 60,
+    //   trialRequiresCreditCard: false,
+    //   planDesc: [
+    //     '30-day Risk Free Trial',
+    //     'Fixes IOS14.5 tracking',
+    //     'Multi Pixel Support',
+    //     'Enhanced Tracking / Attribution',
+    //     'Unlimited Facebook Conversion API',
+    //     'Unlimited Integrations',
+    //     'Easy no code setup',
+    //     '100,000 tracking events/mo'
+    //   ],
+    //   unitPriceText: 'billed yearly ($1799.91) - 25% savings',
+    //   isHighlighted: false,
+    //   isBanner: true,
+    //   bannerColor: 'orange',
+    //   bannerText: 'BEST VALUE'
+    // },
+  ]
+};
+var getPlanDetails = (planId, stage2) => {
+  const plan = SubscriptionPlanSeedItems.items.filter((x2) => x2.id === planId)[0];
+  plan.stripePriceId = StripeBillingMap[stage2][plan.planName];
+  return plan;
+};
+var getPlanByStripePriceId = (stripePriceId, stage2) => {
+  const stripePriceIds = StripeBillingMap[stage2];
+  const planName = Object.keys(stripePriceIds).find((key) => stripePriceIds[key] === stripePriceId);
+  const plan = SubscriptionPlanSeedItems.items.filter((x2) => x2.planName === planName)[0];
+  plan.stripePriceId = stripePriceId;
+  return plan;
+};
+
+// src/libs/crypto.ts
+import crypto from "crypto";
+var generatePublicKey = () => {
+  const publicKey = crypto.randomBytes(26);
+  return publicKey.toString("utf8");
+};
+
+// src/types/internal-events/event-detail-types.ts
+var ADTRACKIFY_EVENT_TYPES = /* @__PURE__ */ ((ADTRACKIFY_EVENT_TYPES2) => {
+  ADTRACKIFY_EVENT_TYPES2["NOTIFY_SHOPIFY_SUBSCRIPTION_CREATED"] = "shopifySubscriptionCreated";
+  ADTRACKIFY_EVENT_TYPES2["NOTIFY_SUBSCRIPTION_SIGNUP_COMPLETED"] = "subscription.signupCompleted";
+  ADTRACKIFY_EVENT_TYPES2["REQUEST_SET_ACCOUNT_OWNER"] = "setAccountOwner";
+  ADTRACKIFY_EVENT_TYPES2["REQUEST_SET_ACCOUNT_SUBSCRIPTION_ID"] = "setAccountSubscriptionId";
+  return ADTRACKIFY_EVENT_TYPES2;
+})(ADTRACKIFY_EVENT_TYPES || {});
+var ADTRACKIFY_EVENT_SOURCES = /* @__PURE__ */ ((ADTRACKIFY_EVENT_SOURCES2) => {
+  ADTRACKIFY_EVENT_SOURCES2["SUBSCRIPTIONS"] = "subscriptions";
+  return ADTRACKIFY_EVENT_SOURCES2;
+})(ADTRACKIFY_EVENT_SOURCES || {});
+var PostmarkRequestType = /* @__PURE__ */ ((PostmarkRequestType2) => {
+  PostmarkRequestType2["SINGLE_EMAIL"] = "single_email";
+  PostmarkRequestType2["TEMPLATE_EMAIL"] = "template_email";
+  return PostmarkRequestType2;
+})(PostmarkRequestType || {});
+var ADTRACKIFY_EVENT_BRIDGE_EVENTS = /* @__PURE__ */ ((ADTRACKIFY_EVENT_BRIDGE_EVENTS2) => {
+  ADTRACKIFY_EVENT_BRIDGE_EVENTS2["SEND_POSTMARK_EMAIL"] = "integration.sendPostmarkEmail";
+  ADTRACKIFY_EVENT_BRIDGE_EVENTS2["NOTIFY_SHOPIFY_SUBSCRIPTION_CREATED"] = "shopifySubscriptionCreated";
+  ADTRACKIFY_EVENT_BRIDGE_EVENTS2["NOTIFY_SUBSCRIPTION_SIGNUP_COMPLETED"] = "subscription.signupCompleted";
+  ADTRACKIFY_EVENT_BRIDGE_EVENTS2["REQUEST_SET_ACCOUNT_OWNER"] = "setAccountOwner";
+  ADTRACKIFY_EVENT_BRIDGE_EVENTS2["REQUEST_SET_ACCOUNT_SUBSCRIPTION_ID"] = "setAccountSubscriptionId";
+  return ADTRACKIFY_EVENT_BRIDGE_EVENTS2;
+})(ADTRACKIFY_EVENT_BRIDGE_EVENTS || {});
+
+// src/services/eventbridge-integration-service.ts
+var EventBridgeIntegrationService = class {
+  eventBridgeClient;
+  EVENT_BUS_NAME;
+  constructor(eventBusName) {
+    this.eventBridgeClient = new EventBridgeClient(eventBusName);
+    this.EVENT_BUS_NAME = eventBusName;
+  }
+  sendPostmarkEmailEvent = async (eventSource, postmarkMessage, postmarkServerToken) => {
+    return await this.eventBridgeClient.buildAndSendEvent(
+      eventSource,
+      "integration.sendPostmarkEmail" /* SEND_POSTMARK_EMAIL */,
+      {
+        postmarkMessage,
+        postmarkRequestType: "single_email" /* SINGLE_EMAIL */,
+        postmarkServerToken
+      }
+    );
+  };
+  sendPostmarkTemplatedEmailEvent = async (eventSource, postmarkMessage, postmarkServerToken) => {
+    return await this.eventBridgeClient.buildAndSendEvent(
+      eventSource,
+      "integration.sendPostmarkEmail" /* SEND_POSTMARK_EMAIL */,
+      {
+        postmarkMessage,
+        postmarkRequestType: "template_email" /* TEMPLATE_EMAIL */,
+        postmarkServerToken
+      }
+    );
+  };
+};
+export {
+  ADTRACKIFY_EVENT_BRIDGE_EVENTS,
+  ADTRACKIFY_EVENT_SOURCES,
+  ADTRACKIFY_EVENT_TYPES,
+  AccountsClient,
+  CognitoClient,
+  CommonPlanInfo,
+  DestinationsClient,
+  DynamoDbClient,
+  EventBridgeClient,
+  EventBridgeIntegrationService,
+  HttpError,
+  HttpStatusCodes,
+  PostmarkRequestType,
+  S3Client,
+  SQSClient,
+  ShopifyAppInstallClient,
+  ShopifyClient,
+  StripeBillingMap,
+  SubscriptionPlanSeedItems,
+  UsersAuthClient,
+  axiosHttpService,
+  buildResponse,
+  configureLogger,
+  dictToAwsAttributes,
+  failure,
+  generatePublicKey,
+  getCurrentDate,
+  getCurrentTimestamp,
+  getDateFromTimestamp,
+  getPlanByStripePriceId,
+  getPlanDetails,
+  isShopifyRequestValid,
+  mapObjectToQueryString,
+  success,
+  validateInput,
+  validateShopifyRequest
+};
+//# sourceMappingURL=index.esm.js.map