@amohamud23/notihub 1.0.155 → 1.0.157

package/dist/index.cjs

@@ -595,7 +595,7 @@ var ddbDocClient = import_lib_dynamodb.DynamoDBDocumentClient.from(ddbClient, {
 });
 var USER_TABLE_NAME = process.env.USER_TABLE_NAME || "NotiHub-Users-v1-dev";
 
-// src/DynamoModels/UserModel.ts
+// src/DynamoModels/User.ts
 var import_lib_dynamodb2 = require("@aws-sdk/lib-dynamodb");
 var User = class _User {
   static ENV = process.env.ENV || "dev";
@@ -694,7 +694,7 @@ var User = class _User {
     }
   }
 };
-var UserModel_default2 = User;
+var User_default = User;
 
 // src/DynamoModels/Customer.ts
 var import_lib_dynamodb3 = require("@aws-sdk/lib-dynamodb");
@@ -803,10 +803,541 @@ var Customer2 = class _Customer {
 };
 var Customer_default = Customer2;
 
+// src/DynamoModels/Notifications.ts
+var import_lib_dynamodb4 = require("@aws-sdk/lib-dynamodb");
+var Notifications = class _Notifications {
+  static ENV = process.env.ENV || "dev";
+  static TABLE_NAME = `NotiHub-Notifications-${_Notifications.ENV}`;
+  /**
+   * Retrieves a notification by its ID.
+   * @param id - The ID of the notification to retrieve.
+   * @returns A promise that resolves to the notification object or null if not found.
+   */
+  static async getNotificationById(id) {
+    const command = new import_lib_dynamodb4.GetCommand({
+      TableName: _Notifications.TABLE_NAME,
+      Key: { id }
+    });
+    try {
+      const result = await ddbDocClient.send(command);
+      return result.Item || null;
+    } catch (error) {
+      console.error("Error fetching notification:", error);
+      throw new Error("Could not fetch notification");
+    }
+  }
+  static async getNotificationsByEntityId(entityId) {
+    const command = new import_lib_dynamodb4.QueryCommand({
+      TableName: _Notifications.TABLE_NAME,
+      IndexName: "EntityIdIndex",
+      // Assuming you have a GSI for entityId
+      KeyConditionExpression: "entityId = :entityId",
+      ExpressionAttributeValues: {
+        ":entityId": entityId
+      }
+    });
+    try {
+      const result = await ddbDocClient.send(command);
+      return result.Items || null;
+    } catch (error) {
+      console.error(
+        `Error fetching notifications by entityId: ${entityId}`,
+        error
+      );
+      throw new Error("Could not fetch notifications by entityId");
+    }
+  }
+  /**
+   * Creates a new notification.
+   * @param notification - The notification object to create.
+   * @returns A promise that resolves to the created notification object.
+   */
+  static async createNotification(notification) {
+    const command = new import_lib_dynamodb4.PutCommand({
+      TableName: _Notifications.TABLE_NAME,
+      Item: notification
+    });
+    try {
+      await ddbDocClient.send(command);
+      return notification;
+    } catch (error) {
+      console.error("Error creating notification:", error);
+      throw new Error("Could not create notification");
+    }
+  }
+  // Additional methods can be added here as needed
+};
+var Notifications_default = Notifications;
+
+// src/DynamoModels/NotiHubStats.ts
+var import_lib_dynamodb5 = require("@aws-sdk/lib-dynamodb");
+var NotiHubStats = class _NotiHubStats {
+  static ENV = process.env.ENV || "dev";
+  static TABLE_NAME = `NotiHub-Stats-${_NotiHubStats.ENV}`;
+  /**
+   * Retrieves the statistics for NotiHub.
+   * @returns A promise that resolves to the statistics object or null if not found.
+   */
+  static async getStats(notificationId) {
+    const command = new import_lib_dynamodb5.GetCommand({
+      TableName: _NotiHubStats.TABLE_NAME,
+      Key: { notificationId }
+    });
+    try {
+      const result = await ddbDocClient.send(command);
+      return result.Item || null;
+    } catch (error) {
+      console.error("Error fetching NotiHub stats:", error);
+      throw new Error("Could not fetch NotiHub stats");
+    }
+  }
+  /**
+   * Updates the statistics for NotiHub.
+   * @param notificationId - The ID of the notification to update the stats for.
+   * @returns A promise that resolves to the updated statistics object.
+   */
+  static async updateViewsStats(notificationId) {
+    const command = new import_lib_dynamodb5.UpdateCommand({
+      TableName: _NotiHubStats.TABLE_NAME,
+      Key: { notificationId },
+      UpdateExpression: "ADD views :inc",
+      ExpressionAttributeValues: {
+        ":inc": 1
+      },
+      ReturnValues: "ALL_NEW"
+    });
+    try {
+      const result = await ddbDocClient.send(command);
+      return result.Attributes;
+    } catch (error) {
+      console.error("Error updating NotiHub stats:", error);
+      throw new Error("Could not update NotiHub stats");
+    }
+  }
+};
+var NotiHubStats_default = NotiHubStats;
+
+// src/DynamoModels/NotiType.ts
+var import_lib_dynamodb6 = require("@aws-sdk/lib-dynamodb");
+var NotiType = class _NotiType {
+  static ENV = process.env.ENV || "dev";
+  static TABLE_NAME = `NotiHub-NotiTypes-${_NotiType.ENV}`;
+  /**
+   * Retrieves a notification type by its ID.
+   * @param id - The ID of the notification type to retrieve.
+   * @returns A promise that resolves to the notification type object or null if not found.
+   */
+  static async getNotiTypeById(id) {
+    const command = new import_lib_dynamodb6.GetCommand({
+      TableName: _NotiType.TABLE_NAME,
+      Key: { id }
+    });
+    try {
+      const result = await ddbDocClient.send(command);
+      return result.Item || null;
+    } catch (error) {
+      console.error("Error fetching notification type:", error);
+      throw new Error("Could not fetch notification type");
+    }
+  }
+  /**
+   * Retrieves all notification types.
+   * @returns A promise that resolves to an array of notification type objects.
+   */
+  static async getAllNotiTypesByEntityId(entityId) {
+    const command = new import_lib_dynamodb6.QueryCommand({
+      TableName: _NotiType.TABLE_NAME,
+      IndexName: "EntityIdIndex",
+      // Assuming you have a GSI for entityId
+      KeyConditionExpression: "entityId = :entityId",
+      ExpressionAttributeValues: {
+        ":entityId": entityId
+      }
+    });
+    try {
+      const result = await ddbDocClient.send(command);
+      return result.Items || null;
+    } catch (error) {
+      console.error(
+        `Error fetching notification types by entityId: ${entityId}`,
+        error
+      );
+      throw new Error("Could not fetch notification types by entityId");
+    }
+  }
+  /**
+   * Creates a new notification type.
+   * @param notiType - The notification type object to create.
+   * @returns A promise that resolves to the created notification type object.
+   */
+  static async createNotiType(notiType) {
+    const command = new import_lib_dynamodb6.PutCommand({
+      TableName: _NotiType.TABLE_NAME,
+      Item: notiType
+    });
+    try {
+      await ddbDocClient.send(command);
+      return notiType;
+    } catch (error) {
+      console.error("Error creating notification type:", error);
+      throw new Error("Could not create notification type");
+    }
+  }
+  /**
+   * Updates an existing notification type.
+   * @param id - The ID of the notification type to update.
+   * @param updates - An object containing the fields to update.
+   * @returns A promise that resolves to the updated notification type object.
+   */
+  static async updateNotiType(id, updates) {
+    const command = new import_lib_dynamodb6.UpdateCommand({
+      TableName: _NotiType.TABLE_NAME,
+      Key: { id },
+      UpdateExpression: "set #type = :type, updatedAt = :updatedAt",
+      ExpressionAttributeNames: {
+        "#type": "type",
+        "#updatedAt": "updatedAt"
+      },
+      ExpressionAttributeValues: {
+        ":type": updates.type,
+        ":updatedAt": (/* @__PURE__ */ new Date()).toISOString()
+      },
+      ReturnValues: "ALL_NEW"
+    });
+    try {
+      const result = await ddbDocClient.send(command);
+      return result.Attributes;
+    } catch (error) {
+      console.error("Error updating notification type:", error);
+      throw new Error("Could not update notification type");
+    }
+  }
+};
+var NotiType_default = NotiType;
+
+// src/DynamoModels/Subscription.ts
+var import_lib_dynamodb7 = require("@aws-sdk/lib-dynamodb");
+var Subscription2 = class _Subscription {
+  static ENV = process.env.ENV || "dev";
+  static TABLE_NAME = `NotiHub-Subscriptions-${_Subscription.ENV}`;
+  /**
+   * Retrieves a subscription by its ID.
+   * @param id - The ID of the subscription to retrieve.
+   * @returns A promise that resolves to the subscription object or null if not found.
+   */
+  static async getSubscriptionById(id) {
+    const command = new import_lib_dynamodb7.GetCommand({
+      TableName: _Subscription.TABLE_NAME,
+      Key: { id }
+    });
+    try {
+      const result = await ddbDocClient.send(command);
+      return result.Item || null;
+    } catch (error) {
+      console.error("Error fetching subscription:", error);
+      throw new Error("Could not fetch subscription");
+    }
+  }
+  /**
+   * Retrieves subscriptions by user ID.
+   * @param userId - The ID of the user whose subscriptions to retrieve.
+   * @returns A promise that resolves to an array of subscription objects or null if not found.
+   */
+  static async getSubscriptionsByUserId(userId) {
+    const command = new import_lib_dynamodb7.QueryCommand({
+      TableName: _Subscription.TABLE_NAME,
+      IndexName: "UserIdIndex",
+      // Assuming you have a GSI for userId
+      KeyConditionExpression: "userId = :userId",
+      ExpressionAttributeValues: {
+        ":userId": userId
+      }
+    });
+    try {
+      const result = await ddbDocClient.send(command);
+      return result.Items || null;
+    } catch (error) {
+      console.error(`Error fetching subscriptions by userId: ${userId}`, error);
+      throw new Error("Could not fetch subscriptions by userId");
+    }
+  }
+  /**
+   * Creates or updates a subscription.
+   * @param subscription - The subscription object to create or update.
+   * @returns A promise that resolves to the created or updated subscription object.
+   */
+  static async createOrUpdateSubscription(subscription) {
+    const command = new import_lib_dynamodb7.PutCommand({
+      TableName: _Subscription.TABLE_NAME,
+      Item: subscription
+    });
+    try {
+      await ddbDocClient.send(command);
+      return subscription;
+    } catch (error) {
+      console.error("Error creating or updating subscription:", error);
+      throw new Error("Could not create or update subscription");
+    }
+  }
+  /**
+   * Deletes a subscription by its ID.
+   * @param id - The ID of the subscription to delete.
+   * @returns A promise that resolves when the deletion is complete.
+   */
+  static async deleteSubscriptionById(id) {
+    const command = new import_lib_dynamodb7.DeleteCommand({
+      TableName: _Subscription.TABLE_NAME,
+      Key: { id }
+    });
+    try {
+      await ddbDocClient.send(command);
+    } catch (error) {
+      console.error("Error deleting subscription:", error);
+      throw new Error("Could not delete subscription");
+    }
+  }
+  /**
+   * Fetch subscription by SubscriptionId.
+   * @param subscriptionId - The ID of the subscription to retrieve.
+   * @returns A promise that resolves to the subscription object or null if not found.
+   */
+  static async getSubscriptionBySubscriptionId(subscriptionId) {
+    const command = new import_lib_dynamodb7.GetCommand({
+      TableName: _Subscription.TABLE_NAME,
+      Key: { subscriptionId }
+    });
+    try {
+      const result = await ddbDocClient.send(command);
+      return result.Item || null;
+    } catch (error) {
+      console.error("Error fetching subscription by SubscriptionId:", error);
+      throw new Error("Could not fetch subscription by SubscriptionId");
+    }
+  }
+};
+var Subscription_default = Subscription2;
+
+// src/DynamoModels/NotiTypeStats.ts
+var import_lib_dynamodb8 = require("@aws-sdk/lib-dynamodb");
+var NotiTypeStats = class _NotiTypeStats {
+  static ENV = process.env.ENV || "dev";
+  static TABLE_NAME = `NotiHub-NotiTypeStats-${_NotiTypeStats.ENV}`;
+  /**
+   * Retrieves notification type stats by their ID.
+   * @param id - The ID of the notification type stats to retrieve.
+   * @returns A promise that resolves to the notification type stats object or null if not found.
+   */
+  static async getNotiTypeStatsById(id) {
+    const command = new import_lib_dynamodb8.GetCommand({
+      TableName: _NotiTypeStats.TABLE_NAME,
+      Key: { id }
+    });
+    try {
+      const result = await ddbDocClient.send(command);
+      return result.Item || null;
+    } catch (error) {
+      console.error("Error fetching notification type stats:", error);
+      throw new Error("Could not fetch notification type stats");
+    }
+  }
+  /**
+   * Retrieves all notification type stats by entity ID.
+   * @param notiTypeId - The ID of the notification type to retrieve stats for.
+   * @returns A promise that resolves to an array of notification type stats objects or null if not found.
+   */
+  static async getNotiTypeStatsByNotiTypeId(notiTypeId) {
+    const command = new import_lib_dynamodb8.QueryCommand({
+      TableName: _NotiTypeStats.TABLE_NAME,
+      IndexName: "NotiTypeIdIndex",
+      // Assuming you have a GSI for notiTypeId
+      KeyConditionExpression: "notiTypeId = :notiTypeId",
+      ExpressionAttributeValues: {
+        ":notiTypeId": notiTypeId
+      }
+    });
+    try {
+      const result = await ddbDocClient.send(command);
+      return result.Items || null;
+    } catch (error) {
+      console.error(
+        `Error fetching notification type stats by notiTypeId: ${notiTypeId}`,
+        error
+      );
+      throw new Error("Could not fetch notification type stats by notiTypeId");
+    }
+  }
+  /**
+   * Creates or updates notification type stats.
+   * @param notiTypeStats - The notification type stats object to create or update.
+   * @returns A promise that resolves to the created or updated notification type stats object.
+   */
+  static async createOrUpdateNotiTypeStats(notiTypeStats) {
+    const command = new import_lib_dynamodb8.PutCommand({
+      TableName: _NotiTypeStats.TABLE_NAME,
+      Item: notiTypeStats
+    });
+    try {
+      await ddbDocClient.send(command);
+      return notiTypeStats;
+    } catch (error) {
+      console.error(
+        "Error creating or updating notification type stats:",
+        error
+      );
+      throw new Error("Could not create or update notification type stats");
+    }
+  }
+};
+var NotiTypeStats_default = NotiTypeStats;
+
+// src/DynamoModels/Views.ts
+var import_lib_dynamodb9 = require("@aws-sdk/lib-dynamodb");
+var Views = class _Views {
+  static ENV = process.env.ENV || "dev";
+  static TABLE_NAME = `NotiHub-Views-${_Views.ENV}`;
+  /**
+   * Retrieves a view by its ID.
+   * @param id - The ID of the view to retrieve.
+   * @returns A promise that resolves to the view object or null if not found.
+   */
+  static async getViewById(id) {
+    const command = new import_lib_dynamodb9.GetCommand({
+      TableName: _Views.TABLE_NAME,
+      Key: { id }
+    });
+    try {
+      const result = await ddbDocClient.send(command);
+      return result.Item || null;
+    } catch (error) {
+      console.error("Error fetching view:", error);
+      throw new Error("Could not fetch view");
+    }
+  }
+  /**
+   * Creates or updates a view.
+   * @param view - The view object to create or update.
+   * @returns A promise that resolves to the created or updated view object.
+   */
+  static async createView(view) {
+    const command = new import_lib_dynamodb9.PutCommand({
+      TableName: _Views.TABLE_NAME,
+      Item: view
+    });
+    try {
+      await ddbDocClient.send(command);
+      return view;
+    } catch (error) {
+      console.error("Error creating or updating view:", error);
+      throw new Error("Could not create or update view");
+    }
+  }
+};
+var Views_default = Views;
+
+// src/DynamoModels/SubscriptionType.ts
+var import_lib_dynamodb10 = require("@aws-sdk/lib-dynamodb");
+var SubscriptionType2 = class _SubscriptionType {
+  static ENV = process.env.ENV || "dev";
+  static TABLE_NAME = `NotiHub-SubscriptionTypes-${_SubscriptionType.ENV}`;
+  /**
+   * Retrieves a subscription type by its ID.
+   * @param id - The ID of the subscription type to retrieve.
+   * @returns A promise that resolves to the subscription type object or null if not found.
+   */
+  static async getSubscriptionTypeById(id) {
+    const command = new import_lib_dynamodb10.GetCommand({
+      TableName: _SubscriptionType.TABLE_NAME,
+      Key: { id }
+    });
+    try {
+      const result = await ddbDocClient.send(command);
+      return result.Item || null;
+    } catch (error) {
+      console.error("Error fetching subscription type:", error);
+      throw new Error("Could not fetch subscription type");
+    }
+  }
+  static async getSubscriptionTypesByUserId(userId) {
+    const command = new import_lib_dynamodb10.QueryCommand({
+      TableName: _SubscriptionType.TABLE_NAME,
+      IndexName: "UserIdIndex",
+      // Assuming you have a GSI for userId
+      KeyConditionExpression: "userId = :userId",
+      ExpressionAttributeValues: {
+        ":userId": userId
+      }
+    });
+    try {
+      const result = await ddbDocClient.send(command);
+      return result.Items || null;
+    } catch (error) {
+      console.error(
+        `Error fetching subscription types by userId: ${userId}`,
+        error
+      );
+      throw new Error("Could not fetch subscription types by userId");
+    }
+  }
+  // Additional methods for creating, updating, and deleting subscription types can be added here
+};
+var SubscriptionType_default = SubscriptionType2;
+
+// src/DynamoModels/CustomerMetaData.ts
+var import_lib_dynamodb11 = require("@aws-sdk/lib-dynamodb");
+var CustomerMetaData = class _CustomerMetaData {
+  static ENV = process.env.ENV || "dev";
+  static TABLE_NAME = `NotiHub-CustomerMetaData-${_CustomerMetaData.ENV}`;
+  /**
+   * Retrieves customer metadata by its ID.
+   * @param id - The ID of the customer metadata to retrieve.
+   * @returns A promise that resolves to the customer metadata object or null if not found.
+   */
+  static async getCustomerMetaDataById(id) {
+    const command = new import_lib_dynamodb11.GetCommand({
+      TableName: _CustomerMetaData.TABLE_NAME,
+      Key: { id }
+    });
+    try {
+      const result = await ddbDocClient.send(command);
+      return result.Item || null;
+    } catch (error) {
+      console.error("Error fetching customer metadata:", error);
+      throw new Error("Could not fetch customer metadata");
+    }
+  }
+  /**
+   * Creates or updates customer metadata.
+   * @param customerMetaData - The customer metadata object to create or update.
+   * @returns A promise that resolves to the created or updated customer metadata object.
+   */
+  static async createOrUpdateCustomerMetaData(customerMetaData) {
+    const command = new import_lib_dynamodb11.PutCommand({
+      TableName: _CustomerMetaData.TABLE_NAME,
+      Item: customerMetaData
+    });
+    try {
+      await ddbDocClient.send(command);
+      return customerMetaData;
+    } catch (error) {
+      console.error("Error creating or updating customer metadata:", error);
+      throw new Error("Could not create or update customer metadata");
+    }
+  }
+};
+var CustomerMetaData_default = CustomerMetaData;
+
 // src/DynamoModels/index.ts
 var TABLES = {
-  User: UserModel_default2,
-  Customer: Customer_default
+  User: User_default,
+  Customer: Customer_default,
+  Notifications: Notifications_default,
+  NotiHubStats: NotiHubStats_default,
+  NotiType: NotiType_default,
+  Subscription: Subscription_default,
+  NotiTypeStats: NotiTypeStats_default,
+  Views: Views_default,
+  SubscriptionType: SubscriptionType_default,
+  CustomerMetaData: CustomerMetaData_default
 };
 
 // src/errorcodes.ts