@culturefy/shared 1.0.0 → 1.0.1

package/src/utils/index.ts

@@ -0,0 +1,3 @@
+export * from './secrets';
+export * from './response';
+export * from './initializers';

package/src/utils/initializers.ts

@@ -0,0 +1,131 @@
+// packages/libs/src/db-initializers.ts
+
+import mongoose, { Connection } from "mongoose";
+import { InvocationContext } from "@azure/functions";
+import { getAzureVaultSecretByKey } from "./secrets";
+import { AzureSecretKeysEnum } from "../enums";
+
+export abstract class Initializers {
+  protected db!: Connection;
+
+  constructor(
+    context: InvocationContext,
+    dbSecret: AzureSecretKeysEnum
+  ) {
+    MongoConnectionSingleton
+      .getInstance(context, dbSecret)
+      .then(conn => {
+        this.db = conn;
+        context.info("✅ MongoDB initialized");
+      })
+      .catch(err => {
+        context.error("❌ Failed to initialize MongoDB:", err);
+        throw err;
+      });
+  }
+}
+
+class MongoConnectionSingleton {
+  private static instances = new Map<AzureSecretKeysEnum, Connection>();
+
+  static async getInstance(
+    context: InvocationContext,
+    secretKey: AzureSecretKeysEnum
+  ): Promise<Connection> {
+    if (!this.instances.has(secretKey)) {
+      const vaultName = process.env.KEY_VAULT_NAME!;
+      if (!vaultName) throw new Error("Missing KEY_VAULT_NAME env var");
+
+      context.info(`[Mongo] fetching secret "${secretKey}" from vault "${vaultName}"`);
+      const uri = await getAzureVaultSecretByKey(context, vaultName, secretKey);
+      if (!uri) throw new Error(`No value for secret "${secretKey}"`);
+
+      context.info("[Mongo] connecting to MongoDB…");
+      const conn = await mongoose
+        .createConnection(uri, {})
+        .asPromise();
+      context.info("[Mongo] connected to MongoDB");
+
+      this.instances.set(secretKey, conn);
+    }
+    return this.instances.get(secretKey)!;
+  }
+}
+
+
+
+
+
+// import mongoose, { Mongoose } from "mongoose";
+// import { InvocationContext } from "@azure/functions";
+// import { getAzureVaultSecretByKey } from "./secrets";
+// import { AzureSecretKeysEnum } from "../enums";
+
+// /**
+//  * Base class for any service that needs a MongoDB connection.
+//  * Pass in the name of the Key Vault secret that holds your MongoDB URI.
+//  */
+// export abstract class Initializers {
+//    mongoose!: Mongoose;
+
+//   constructor(
+//     context: InvocationContext,
+//     dbConnectionSecretKey: AzureSecretKeysEnum
+//   ) {
+//     MongoConnectionSingleton
+//       .getInstance(context, dbConnectionSecretKey)
+//       .then(singleton => {
+//         this.mongoose = singleton.mongoose;
+//       })
+//       .catch(err => {
+//         context.error("Failed to initialize MongoDB:", err);
+//         throw err;
+//       });
+//   }
+// }
+
+// /**
+//  * A singleton manager that caches one mongoose connection per secret key.
+//  */
+// class MongoConnectionSingleton {
+//   private static instances: Map<AzureSecretKeysEnum, MongoConnectionSingleton> = new Map();
+//   public mongoose!: Mongoose;
+
+//   private constructor() { }
+
+//   public static async getInstance(
+//     context: InvocationContext,
+//     secretKey: AzureSecretKeysEnum
+//   ): Promise<MongoConnectionSingleton> {
+//     if (!this.instances.has(secretKey)) {
+//       const inst = new MongoConnectionSingleton();
+//       await inst.connect(context, secretKey);
+//       this.instances.set(secretKey, inst);
+//     }
+//     return this.instances.get(secretKey)!;
+//   }
+
+//   private async connect(
+//     context: InvocationContext,
+//     secretKey: AzureSecretKeysEnum
+//   ): Promise<void> {
+//     // 1) Fetch vault name and secret
+//     const vaultName =  process.env.AZURE_KEY_VAULT_NAME!;
+//     if (!vaultName) throw new Error("Missing KEY_VAULT_NAME env var");
+
+//     context.info(`[Mongo] Fetching connection string from vault "${vaultName}", secret "${secretKey}"`);
+//     const connString = await getAzureVaultSecretByKey(
+//       context,
+//       vaultName,
+//       secretKey
+//     );
+//     if (!connString) {
+//       throw new Error(`No value found for secret "${secretKey}"`);
+//     }
+
+//     // 2) Connect via mongoose
+//     context.info(`[Mongo] Connecting to MongoDB…`);
+//     this.mongoose = await mongoose.connect(connString);
+//     context.info(`[Mongo] Connected using secret "${secretKey}"`);
+//   }
+// }

package/src/utils/response.ts

@@ -0,0 +1,35 @@
+import { HttpRequest, HttpResponseInit, InvocationContext } from '@azure/functions';
+
+// This function generates a standard response with a structured body: { status, message, data }
+export function sendResponse(
+    statusCode: number,
+    data: any = null,
+    message: string = '',
+    headers: Record<string, string> = { 'Content-Type': 'application/json' }
+): HttpResponseInit {
+    return {
+        status: statusCode,
+        body: JSON.stringify({
+            status: statusCode,
+            message: message || (statusCode >= 200 && statusCode < 300 ? 'Success' : 'Error'),
+            data: data,
+        }),
+        headers: headers,
+    };
+}
+
+// Centralized asyncHandler to catch all errors
+export function asyncHandler(handler: Function) {
+    return async (request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> => {
+        try {
+            context.log('Handling request:', request.url);
+            const response = await handler(request, context);  // Call the actual handler logic
+            context.log('Response sent:', response.status);
+            return response;
+        } catch (error: any) {
+            console.error('Error occurred:', error);
+            context.error('Error occurred:', error);
+            return sendResponse(500, null, error.message ? error.message : 'An unexpected error occurred');
+        }
+    };
+}

package/src/utils/secrets.ts

@@ -0,0 +1,45 @@
+import { DefaultAzureCredential } from "@azure/identity";
+import { SecretClient } from "@azure/keyvault-secrets";
+import { InvocationContext } from "@azure/functions";
+import { AzureSecretKeysEnum } from "../enums";
+
+/**
+ * Fetches a secret value from Azure Key Vault by key.
+ * @param key - The key name from the AzureSecretKeysEnum enum.
+ * @returns The secret value.
+ * @throws Error if the key is invalid or if the secret fetch fails.
+*/
+export async function getAzureVaultSecretByKey(
+  context: InvocationContext,
+  azureVaultName: string,
+  key: AzureSecretKeysEnum
+): Promise<string> {
+  try {
+    
+    // Azure Key Vault URL
+    const vaultName = azureVaultName || "";
+    const vaultUrl = `https://${vaultName}.vault.azure.net`;
+
+    // Initialize SecretClient
+    const credential = new DefaultAzureCredential();
+    const client = new SecretClient(vaultUrl, credential);
+    
+    // Validate the key using a switch case
+    switch (key) {
+      
+      case AzureSecretKeysEnum.STRIPE_SECRET_KEY:
+      case AzureSecretKeysEnum.STRIPE_PAYMENT_WEBHOOK_SECRET_KEY:
+      case AzureSecretKeysEnum.STRIPE_PRODUCT_WEBHOOK_SECRET:
+      case AzureSecretKeysEnum.STRIPE_PRICE_WEBHOOK_SECRET:
+      case AzureSecretKeysEnum.EMAIL_SERVICE_URL:
+      case AzureSecretKeysEnum.STRIPE_CUSTOMER_SYNC_WEBHOOK_SECRET_KEY:
+        const secret = await client.getSecret(key);
+        return secret.value || "";
+      default:
+        throw new Error(`Invalid key name: ${key}`);
+    }
+  } catch (err) {
+    context.error(`Error fetching secret for key ${key}:`, err);
+    throw new Error(`Failed to fetch secret for key ${key}`);
+  }
+}

package/dist/tsconfig.tsbuildinfo

@@ -1 +0,0 @@
-{"root":["../src/index.ts","../src/enums/index.ts","../src/enums/secretkeys.enum.ts","../src/types/create-enterprise-business.ts","../src/types/events.ts","../src/types/index.ts","../src/types/payloads.ts","../src/utils/index.ts","../src/utils/initializers.ts","../src/utils/response.ts","../src/utils/secrets.ts"],"version":"5.8.3"}