firestore-queue
Version:
A powerful, scalable queue system built on Google Firestore with time-based indexing, auto-configuration, and connection reuse
175 lines • 7.96 kB
JavaScript
;
/**
* Fire Queue with Pre-configured Firestore Instance
* Demonstrates reusing connections and manager pattern
*/
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.demonstrateFirestoreInstance = demonstrateFirestoreInstance;
exports.demonstrateReusableConfig = demonstrateReusableConfig;
const admin = __importStar(require("firebase-admin"));
const index_1 = require("../index");
async function demonstrateFirestoreInstance() {
console.log('🔥 Fire Queue - Firestore Instance Usage');
console.log('=========================================\n');
// Method 1: Using pre-configured Firestore instance
console.log('📋 Method 1: Using Pre-configured Firestore Instance');
console.log('---------------------------------------------------');
// Initialize Firebase Admin once
if (admin.apps.length === 0) {
admin.initializeApp({
credential: admin.credential.cert('./firebase-service-account.json'),
projectId: 'your-project-id',
});
}
// Create a dedicated Firestore instance for queues
const firestoreInstance = new admin.firestore.Firestore({
projectId: 'your-project-id',
databaseId: 'firequeue',
});
// Use the instance with Fire Queue
const { enqueue: enqueue1, consume: consume1, shutdown: shutdown1 } = await (0, index_1.createReadyQueue)({
projectId: 'your-project-id',
topic: 'shared_queue',
firestoreInstance, // Pass the pre-configured instance
});
console.log('✅ Queue created with shared Firestore instance\n');
// Method 2: Using FireQueueManager for reusable configuration
console.log('📋 Method 2: Using FireQueueManager');
console.log('----------------------------------');
const manager = await (0, index_1.setupFireQueue)({
projectId: 'your-project-id',
serviceAccountPath: './firebase-service-account.json',
dbId: 'firequeue',
});
// Create multiple queues with the same configuration
const emailQueue = await manager.createQueue('email_notifications');
const analyticsQueue = await manager.createQueue('analytics_events');
const backupQueue = await manager.createQueue('daily_backups');
console.log('✅ Manager created with shared configuration');
console.log(`📊 Active queues: ${manager.listQueues().join(', ')}\n`);
// Method 3: Using shared Firestore instance across multiple queues
console.log('📋 Method 3: Sharing Firestore Instance Across Queues');
console.log('-----------------------------------------------------');
const sharedManager = await index_1.FireQueueManager.configure({
projectId: 'your-project-id',
firestoreInstance, // Use the same instance from Method 1
});
const queue1 = await sharedManager.createQueue('queue1');
const queue2 = await sharedManager.createQueue('queue2');
const queue3 = await sharedManager.createQueue('queue3');
console.log('✅ Multiple queues sharing one Firestore connection');
console.log(`📊 Shared queues: ${sharedManager.listQueues().join(', ')}\n`);
// Demonstrate usage
console.log('🚀 Testing Queue Operations');
console.log('---------------------------');
// Add messages to different queues
await emailQueue.enqueue('welcome_email', { userId: 'user1', email: 'user1@example.com' });
await analyticsQueue.enqueue('page_view', { page: '/home', userId: 'user1' });
await queue1.enqueue('process_data', { dataId: 'data123' });
console.log('📝 Messages added to all queues');
// Start consumers
await emailQueue.consume('email-worker', async (messages) => {
for (const msg of messages) {
console.log(`📧 Processing email: ${JSON.stringify(msg.payload)}`);
await msg.ack();
}
});
await analyticsQueue.consume('analytics-worker', async (messages) => {
for (const msg of messages) {
console.log(`📊 Processing analytics: ${JSON.stringify(msg.payload)}`);
await msg.ack();
}
});
console.log('👥 Consumers started\n');
// Let them process
await new Promise(resolve => setTimeout(resolve, 5000));
// Get metrics from all queues
console.log('📈 Getting Metrics from All Queues');
console.log('----------------------------------');
const allMetrics = await manager.getAllMetrics();
for (const [queueName, metrics] of Object.entries(allMetrics)) {
console.log(`${queueName}: ${JSON.stringify(metrics, null, 2)}`);
}
// Cleanup
console.log('\n🧹 Shutting Down');
console.log('----------------');
await shutdown1();
await manager.shutdown();
await sharedManager.shutdown();
console.log('✅ All queues shut down successfully');
}
async function demonstrateReusableConfig() {
console.log('\n🔧 Reusable Configuration Pattern');
console.log('=================================\n');
// Setup manager once with your standard config
const manager = await (0, index_1.setupFireQueue)({
projectId: 'your-project-id',
serviceAccountPath: './firebase-service-account.json',
dbId: 'firequeue',
});
// Get the shared Firestore instance for other use cases
const sharedFirestore = manager.getFirestoreInstance();
console.log(`🔗 Shared Firestore instance available: ${!!sharedFirestore}`);
// Create queues as needed throughout your application
const userQueue = await manager.createQueue('user_events');
const orderQueue = await manager.createQueue('order_processing');
const notificationQueue = await manager.createQueue('notifications');
console.log('✅ Multiple specialized queues created');
console.log(`📋 Queue list: ${manager.listQueues().join(', ')}`);
// Use the same Firestore instance for non-queue operations
if (sharedFirestore) {
// Example: Direct Firestore operations using the same connection
const usersCollection = sharedFirestore.collection('users');
console.log('📂 Can reuse Firestore instance for other collections');
}
await manager.shutdown();
console.log('✅ Manager cleanup complete');
}
// Run the examples
async function runExamples() {
try {
await demonstrateFirestoreInstance();
await demonstrateReusableConfig();
}
catch (error) {
console.error('❌ Error:', error);
}
}
if (require.main === module) {
runExamples().catch(console.error);
}
//# sourceMappingURL=firestore-instance-usage.js.map