@twin.org/messaging-connector-entity-storage 0.0.1-next.3 → 0.0.1-next.4

package/dist/esm/index.mjs

@@ -1,255 +1,7 @@
+import { property, entity, EntitySchemaFactory, EntitySchemaHelper } from '@twin.org/entity';
 import { Is, StringHelper, Guards, Converter, RandomHelper, GeneralError } from '@twin.org/core';
 import { EntityStorageConnectorFactory } from '@twin.org/entity-storage-models';
 import { LoggingConnectorFactory } from '@twin.org/logging-models';
-import { property, entity, EntitySchemaFactory, EntitySchemaHelper } from '@twin.org/entity';
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class for connecting to the email messaging operations of the Entity Storage.
- */
-class EntityStorageMessagingEmailConnector {
-    /**
-     * Runtime name for the class.
-     */
-    CLASS_NAME = "EntityStorageMessagingEmailConnector";
-    /**
-     * The logging connector.
-     * @internal
-     */
-    _logging;
-    /**
-     * The entity storage for the emails entries.
-     * @internal
-     */
-    _messagingEmailEntryStorage;
-    /**
-     * Create a new instance of EntityStorageMessagingEmailConnector.
-     * @param options The options for the connector.
-     * @param options.loggingConnectorType The type of logging connector to use, defaults to no logging.
-     * @param options.messagingEmailEntryStorageConnectorType The type of entity storage connector to use for the email entries, defaults to "email-entry".
-     */
-    constructor(options) {
-        if (Is.stringValue(options?.loggingConnectorType)) {
-            this._logging = LoggingConnectorFactory.get(options.loggingConnectorType);
-        }
-        this._messagingEmailEntryStorage = EntityStorageConnectorFactory.get(options?.messagingEmailEntryStorageConnectorType ??
-            StringHelper.kebabCase("EmailEntry"));
-    }
-    /**
-     * Store a custom email using Entity Storage.
-     * @param sender The sender email address.
-     * @param recipients An array of recipients email addresses.
-     * @param subject The subject of the email.
-     * @param content The html content of the email.
-     * @returns True if the email was send successfully, otherwise undefined.
-     */
-    async sendCustomEmail(sender, recipients, subject, content) {
-        Guards.stringValue(this.CLASS_NAME, "sender", sender);
-        Guards.arrayValue(this.CLASS_NAME, "recipients", recipients);
-        Guards.stringValue(this.CLASS_NAME, "subject", subject);
-        Guards.stringValue(this.CLASS_NAME, "content", content);
-        try {
-            await this._logging?.log({
-                level: "info",
-                source: this.CLASS_NAME,
-                ts: Date.now(),
-                message: "emailSending",
-                data: {
-                    type: "Custom Email"
-                }
-            });
-            const id = Converter.bytesToHex(RandomHelper.generate(32));
-            const entity = {
-                id,
-                sender,
-                recipients,
-                ts: Date.now(),
-                message: content,
-                subject,
-                status: "pending"
-            };
-            await this._messagingEmailEntryStorage.set(entity);
-            return true;
-        }
-        catch (err) {
-            throw new GeneralError(this.CLASS_NAME, "sendCustomEmailFailed", undefined, err);
-        }
-    }
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class for connecting to the push notifications messaging operations of the Entity Storage.
- */
-class EntityStorageMessagingPushNotificationConnector {
-    /**
-     * Runtime name for the class.
-     */
-    CLASS_NAME = "EntityStorageMessagingPushNotificationConnector";
-    /**
-     * The logging connector.
-     * @internal
-     */
-    _logging;
-    /**
-     * The entity storage for the push notifications device entries.
-     * @internal
-     */
-    _messagingDeviceEntryStorage;
-    /**
-     * The entity storage for the push notifications message entries.
-     * @internal
-     */
-    _messagingMessageEntryStorage;
-    /**
-     * Create a new instance of EntityStorageMessagingPushNotificationConnector.
-     * @param options The options for the connector.
-     * @param options.loggingConnectorType The type of logging connector to use, defaults to no logging.
-     * @param options.messagingDeviceEntryStorageConnectorType The type of entity storage connector to use for the push notifications entries, defaults to "push-notification-device-entry".
-     * @param options.messagingMessageEntryStorageConnectorType The type of entity storage connector to use for the push notifications entries, defaults to "push-notification-message-entry".
-     */
-    constructor(options) {
-        if (Is.stringValue(options?.loggingConnectorType)) {
-            this._logging = LoggingConnectorFactory.get(options.loggingConnectorType);
-        }
-        this._messagingDeviceEntryStorage = EntityStorageConnectorFactory.get(options?.messagingDeviceEntryStorageConnectorType ??
-            StringHelper.kebabCase("PushNotificationDeviceEntry"));
-        this._messagingMessageEntryStorage = EntityStorageConnectorFactory.get(options?.messagingMessageEntryStorageConnectorType ??
-            StringHelper.kebabCase("PushNotificationMessageEntry"));
-    }
-    /**
-     * Registers a device to an specific app in order to send notifications to it.
-     * @param applicationId The application address.
-     * @param deviceToken The device token.
-     * @returns If the device was registered successfully.
-     */
-    async registerDevice(applicationId, deviceToken) {
-        Guards.stringValue(this.CLASS_NAME, "applicationId", applicationId);
-        Guards.stringValue(this.CLASS_NAME, "deviceToken", deviceToken);
-        try {
-            await this._logging?.log({
-                level: "info",
-                source: this.CLASS_NAME,
-                ts: Date.now(),
-                message: "deviceRegistering"
-            });
-            const id = Converter.bytesToHex(RandomHelper.generate(32));
-            const entity = {
-                id,
-                applicationId,
-                deviceToken,
-                ts: Date.now(),
-                status: "pending"
-            };
-            await this._messagingDeviceEntryStorage.set(entity);
-            return id;
-        }
-        catch (err) {
-            throw new GeneralError(this.CLASS_NAME, "deviceTokenRegisterFailed", { property: "applicationId", value: applicationId }, err);
-        }
-    }
-    /**
-     * Send a push notification to a device.
-     * @param deviceAddress The address of the device.
-     * @param title The title of the notification.
-     * @param message The message to send.
-     * @returns If the notification was sent successfully.
-     */
-    async sendSinglePushNotification(deviceAddress, title, message) {
-        Guards.stringValue(this.CLASS_NAME, "deviceAddress", deviceAddress);
-        Guards.stringValue(this.CLASS_NAME, "title", title);
-        Guards.stringValue(this.CLASS_NAME, "message", message);
-        try {
-            await this._logging?.log({
-                level: "info",
-                source: this.CLASS_NAME,
-                ts: Date.now(),
-                message: "pushNotificationSending"
-            });
-            const id = Converter.bytesToHex(RandomHelper.generate(32));
-            const entity = {
-                id,
-                deviceAddress,
-                title,
-                message,
-                ts: Date.now(),
-                status: "pending"
-            };
-            await this._messagingMessageEntryStorage.set(entity);
-            return true;
-        }
-        catch (err) {
-            throw new GeneralError(this.CLASS_NAME, "sendPushNotificationFailed", { value: deviceAddress }, err);
-        }
-    }
-}
-
-// Copyright 2024 IOTA Stiftung.
-// SPDX-License-Identifier: Apache-2.0.
-/**
- * Class for connecting to the SMS messaging operations of the Entity Storage.
- */
-class EntityStorageMessagingSmsConnector {
-    /**
-     * Runtime name for the class.
-     */
-    CLASS_NAME = "EntityStorageMessagingSmsConnector";
-    /**
-     * The logging connector.
-     * @internal
-     */
-    _logging;
-    /**
-     * The entity storage for the sms entries.
-     * @internal
-     */
-    _messagingSmsEntryStorage;
-    /**
-     * Create a new instance of EntityStorageMessagingSmsConnector.
-     * @param options The options for the connector.
-     * @param options.loggingConnectorType The type of logging connector to use, defaults to no logging.
-     * @param options.messagingSmsEntryStorageConnectorType The type of entity storage connector to use for the sms entries, defaults to "sms-entry".
-     */
-    constructor(options) {
-        if (Is.stringValue(options?.loggingConnectorType)) {
-            this._logging = LoggingConnectorFactory.get(options.loggingConnectorType);
-        }
-        this._messagingSmsEntryStorage = EntityStorageConnectorFactory.get(options?.messagingSmsEntryStorageConnectorType ?? StringHelper.kebabCase("SmsEntry"));
-    }
-    /**
-     * Send a SMS message to a phone number.
-     * @param phoneNumber The recipient phone number.
-     * @param message The message to send.
-     * @returns If the SMS was sent successfully.
-     */
-    async sendSMS(phoneNumber, message) {
-        Guards.stringValue(this.CLASS_NAME, "phoneNumber", phoneNumber);
-        Guards.stringValue(this.CLASS_NAME, "message", message);
-        try {
-            await this._logging?.log({
-                level: "info",
-                source: this.CLASS_NAME,
-                ts: Date.now(),
-                message: "smsSending"
-            });
-            const id = Converter.bytesToHex(RandomHelper.generate(32));
-            const entity = {
-                id,
-                phoneNumber,
-                message,
-                ts: Date.now(),
-                status: "sent"
-            };
-            await this._messagingSmsEntryStorage.set(entity);
-            return true;
-        }
-        catch (err) {
-            throw new GeneralError(this.CLASS_NAME, "sendSMSFailed", undefined, err);
-        }
-    }
-}
 
 /**
  * Call defining an email entry.
@@ -503,16 +255,274 @@ SmsEntry = __decorate([
     entity()
 ], SmsEntry);
 
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Class for connecting to the email messaging operations of the Entity Storage.
+ */
+class EntityStorageMessagingEmailConnector {
+    /**
+     * Runtime name for the class.
+     */
+    CLASS_NAME = "EntityStorageMessagingEmailConnector";
+    /**
+     * The logging connector.
+     * @internal
+     */
+    _logging;
+    /**
+     * The entity storage for the emails entries.
+     * @internal
+     */
+    _messagingEmailEntryStorage;
+    /**
+     * Create a new instance of EntityStorageMessagingEmailConnector.
+     * @param options The options for the connector.
+     * @param options.loggingConnectorType The type of logging connector to use, defaults to no logging.
+     * @param options.messagingEmailEntryStorageConnectorType The type of entity storage connector to use for the email entries, defaults to "email-entry".
+     */
+    constructor(options) {
+        if (Is.stringValue(options?.loggingConnectorType)) {
+            this._logging = LoggingConnectorFactory.get(options.loggingConnectorType);
+        }
+        this._messagingEmailEntryStorage = EntityStorageConnectorFactory.get(options?.messagingEmailEntryStorageConnectorType ??
+            StringHelper.kebabCase("EmailEntry"));
+    }
+    /**
+     * Store a custom email using Entity Storage.
+     * @param sender The sender email address.
+     * @param recipients An array of recipients email addresses.
+     * @param subject The subject of the email.
+     * @param content The html content of the email.
+     * @returns True if the email was send successfully, otherwise undefined.
+     */
+    async sendCustomEmail(sender, recipients, subject, content) {
+        Guards.stringValue(this.CLASS_NAME, "sender", sender);
+        Guards.arrayValue(this.CLASS_NAME, "recipients", recipients);
+        Guards.stringValue(this.CLASS_NAME, "subject", subject);
+        Guards.stringValue(this.CLASS_NAME, "content", content);
+        try {
+            await this._logging?.log({
+                level: "info",
+                source: this.CLASS_NAME,
+                ts: Date.now(),
+                message: "emailSending",
+                data: {
+                    type: "Custom Email"
+                }
+            });
+            const id = Converter.bytesToHex(RandomHelper.generate(32));
+            const entity = {
+                id,
+                sender,
+                recipients,
+                ts: Date.now(),
+                message: content,
+                subject,
+                status: "pending"
+            };
+            await this._messagingEmailEntryStorage.set(entity);
+            return true;
+        }
+        catch (err) {
+            throw new GeneralError(this.CLASS_NAME, "sendCustomEmailFailed", undefined, err);
+        }
+    }
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Class for connecting to the push notifications messaging operations of the Entity Storage.
+ */
+class EntityStorageMessagingPushNotificationConnector {
+    /**
+     * Runtime name for the class.
+     */
+    CLASS_NAME = "EntityStorageMessagingPushNotificationConnector";
+    /**
+     * The logging connector.
+     * @internal
+     */
+    _logging;
+    /**
+     * The entity storage for the push notifications device entries.
+     * @internal
+     */
+    _messagingDeviceEntryStorage;
+    /**
+     * The entity storage for the push notifications message entries.
+     * @internal
+     */
+    _messagingMessageEntryStorage;
+    /**
+     * Create a new instance of EntityStorageMessagingPushNotificationConnector.
+     * @param options The options for the connector.
+     * @param options.loggingConnectorType The type of logging connector to use, defaults to no logging.
+     * @param options.messagingDeviceEntryStorageConnectorType The type of entity storage connector to use for the push notifications entries, defaults to "push-notification-device-entry".
+     * @param options.messagingMessageEntryStorageConnectorType The type of entity storage connector to use for the push notifications entries, defaults to "push-notification-message-entry".
+     */
+    constructor(options) {
+        if (Is.stringValue(options?.loggingConnectorType)) {
+            this._logging = LoggingConnectorFactory.get(options.loggingConnectorType);
+        }
+        this._messagingDeviceEntryStorage = EntityStorageConnectorFactory.get(options?.messagingDeviceEntryStorageConnectorType ??
+            StringHelper.kebabCase("PushNotificationDeviceEntry"));
+        this._messagingMessageEntryStorage = EntityStorageConnectorFactory.get(options?.messagingMessageEntryStorageConnectorType ??
+            StringHelper.kebabCase("PushNotificationMessageEntry"));
+    }
+    /**
+     * Registers a device to an specific app in order to send notifications to it.
+     * @param applicationId The application address.
+     * @param deviceToken The device token.
+     * @returns If the device was registered successfully.
+     */
+    async registerDevice(applicationId, deviceToken) {
+        Guards.stringValue(this.CLASS_NAME, "applicationId", applicationId);
+        Guards.stringValue(this.CLASS_NAME, "deviceToken", deviceToken);
+        try {
+            await this._logging?.log({
+                level: "info",
+                source: this.CLASS_NAME,
+                ts: Date.now(),
+                message: "deviceRegistering"
+            });
+            const id = Converter.bytesToHex(RandomHelper.generate(32));
+            const entity = {
+                id,
+                applicationId,
+                deviceToken,
+                ts: Date.now(),
+                status: "pending"
+            };
+            await this._messagingDeviceEntryStorage.set(entity);
+            return id;
+        }
+        catch (err) {
+            throw new GeneralError(this.CLASS_NAME, "deviceTokenRegisterFailed", { property: "applicationId", value: applicationId }, err);
+        }
+    }
+    /**
+     * Send a push notification to a device.
+     * @param deviceAddress The address of the device.
+     * @param title The title of the notification.
+     * @param message The message to send.
+     * @returns If the notification was sent successfully.
+     */
+    async sendSinglePushNotification(deviceAddress, title, message) {
+        Guards.stringValue(this.CLASS_NAME, "deviceAddress", deviceAddress);
+        Guards.stringValue(this.CLASS_NAME, "title", title);
+        Guards.stringValue(this.CLASS_NAME, "message", message);
+        try {
+            await this._logging?.log({
+                level: "info",
+                source: this.CLASS_NAME,
+                ts: Date.now(),
+                message: "pushNotificationSending"
+            });
+            const id = Converter.bytesToHex(RandomHelper.generate(32));
+            const entity = {
+                id,
+                deviceAddress,
+                title,
+                message,
+                ts: Date.now(),
+                status: "pending"
+            };
+            await this._messagingMessageEntryStorage.set(entity);
+            return true;
+        }
+        catch (err) {
+            throw new GeneralError(this.CLASS_NAME, "sendPushNotificationFailed", { value: deviceAddress }, err);
+        }
+    }
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Class for connecting to the SMS messaging operations of the Entity Storage.
+ */
+class EntityStorageMessagingSmsConnector {
+    /**
+     * Runtime name for the class.
+     */
+    CLASS_NAME = "EntityStorageMessagingSmsConnector";
+    /**
+     * The logging connector.
+     * @internal
+     */
+    _logging;
+    /**
+     * The entity storage for the sms entries.
+     * @internal
+     */
+    _messagingSmsEntryStorage;
+    /**
+     * Create a new instance of EntityStorageMessagingSmsConnector.
+     * @param options The options for the connector.
+     * @param options.loggingConnectorType The type of logging connector to use, defaults to no logging.
+     * @param options.messagingSmsEntryStorageConnectorType The type of entity storage connector to use for the sms entries, defaults to "sms-entry".
+     */
+    constructor(options) {
+        if (Is.stringValue(options?.loggingConnectorType)) {
+            this._logging = LoggingConnectorFactory.get(options.loggingConnectorType);
+        }
+        this._messagingSmsEntryStorage = EntityStorageConnectorFactory.get(options?.messagingSmsEntryStorageConnectorType ?? StringHelper.kebabCase("SmsEntry"));
+    }
+    /**
+     * Send a SMS message to a phone number.
+     * @param phoneNumber The recipient phone number.
+     * @param message The message to send.
+     * @returns If the SMS was sent successfully.
+     */
+    async sendSMS(phoneNumber, message) {
+        Guards.stringValue(this.CLASS_NAME, "phoneNumber", phoneNumber);
+        Guards.stringValue(this.CLASS_NAME, "message", message);
+        try {
+            await this._logging?.log({
+                level: "info",
+                source: this.CLASS_NAME,
+                ts: Date.now(),
+                message: "smsSending"
+            });
+            const id = Converter.bytesToHex(RandomHelper.generate(32));
+            const entity = {
+                id,
+                phoneNumber,
+                message,
+                ts: Date.now(),
+                status: "sent"
+            };
+            await this._messagingSmsEntryStorage.set(entity);
+            return true;
+        }
+        catch (err) {
+            throw new GeneralError(this.CLASS_NAME, "sendSMSFailed", undefined, err);
+        }
+    }
+}
+
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 /**
  * Initialize the schema for the messaging connector entity storage.
+ * @param options The options for the initialisation.
+ * @param options.email Should we register email schemas.
+ * @param options.sms Should we register sms schemas.
+ * @param options.pushNotification Should we register push notification schemas.
  */
-function initSchema() {
-    EntitySchemaFactory.register("EmailEntry", () => EntitySchemaHelper.getSchema(EmailEntry));
-    EntitySchemaFactory.register("PushNotificationDeviceEntry", () => EntitySchemaHelper.getSchema(PushNotificationDeviceEntry));
-    EntitySchemaFactory.register("PushNotificationMessageEntry", () => EntitySchemaHelper.getSchema(PushNotificationMessageEntry));
-    EntitySchemaFactory.register("SmsEntry", () => EntitySchemaHelper.getSchema(SmsEntry));
+function initSchema(options) {
+    if (options?.email ?? true) {
+        EntitySchemaFactory.register("EmailEntry", () => EntitySchemaHelper.getSchema(EmailEntry));
+    }
+    if (options?.pushNotification ?? true) {
+        EntitySchemaFactory.register("PushNotificationDeviceEntry", () => EntitySchemaHelper.getSchema(PushNotificationDeviceEntry));
+        EntitySchemaFactory.register("PushNotificationMessageEntry", () => EntitySchemaHelper.getSchema(PushNotificationMessageEntry));
+    }
+    if (options?.sms ?? true) {
+        EntitySchemaFactory.register("SmsEntry", () => EntitySchemaHelper.getSchema(SmsEntry));
+    }
 }
 
-export { EntityStorageMessagingEmailConnector, EntityStorageMessagingPushNotificationConnector, EntityStorageMessagingSmsConnector, initSchema };
+export { EmailEntry, EntityStorageMessagingEmailConnector, EntityStorageMessagingPushNotificationConnector, EntityStorageMessagingSmsConnector, PushNotificationDeviceEntry, PushNotificationMessageEntry, SmsEntry, initSchema };

package/dist/types/index.d.ts

@@ -1,3 +1,7 @@
+export * from "./entities/emailEntry";
+export * from "./entities/pushNotificationDeviceEntry";
+export * from "./entities/pushNotificationMessageEntry";
+export * from "./entities/smsEntry";
 export * from "./entityStorageMessagingEmailConnector";
 export * from "./entityStorageMessagingPushNotificationConnector";
 export * from "./entityStorageMessagingSmsConnector";

package/dist/types/schema.d.ts

@@ -1,4 +1,12 @@
 /**
  * Initialize the schema for the messaging connector entity storage.
+ * @param options The options for the initialisation.
+ * @param options.email Should we register email schemas.
+ * @param options.sms Should we register sms schemas.
+ * @param options.pushNotification Should we register push notification schemas.
  */
-export declare function initSchema(): void;
+export declare function initSchema(options?: {
+    email?: boolean;
+    sms?: boolean;
+    pushNotification?: boolean;
+}): void;

package/docs/changelog.md

@@ -1,5 +1,5 @@
 # @twin.org/messaging-connector-entity-storage - Changelog
 
-## v0.0.1-next.3
+## v0.0.1-next.4
 
 - Initial Release

package/docs/reference/classes/EmailEntry.md

@@ -0,0 +1,77 @@
+# Class: EmailEntry
+
+Call defining an email entry.
+
+## Constructors
+
+### new EmailEntry()
+
+> **new EmailEntry**(): [`EmailEntry`](EmailEntry.md)
+
+#### Returns
+
+[`EmailEntry`](EmailEntry.md)
+
+## Properties
+
+### id
+
+> **id**: `string`
+
+The id.
+
+***
+
+### sender
+
+> **sender**: `string`
+
+The sender email address.
+
+***
+
+### recipients
+
+> **recipients**: `string`[]
+
+The recipient email addresses.
+
+***
+
+### ts
+
+> **ts**: `number`
+
+The timestamp of the email entry.
+
+***
+
+### message
+
+> **message**: `string`
+
+The message.
+
+***
+
+### subject
+
+> **subject**: `string`
+
+The subject.
+
+***
+
+### status
+
+> **status**: `string`
+
+The status.
+
+***
+
+### error?
+
+> `optional` **error**: `IError`
+
+The error.