firestore-queue
Version:
A powerful, scalable queue system built on Google Firestore with time-based indexing, auto-configuration, and connection reuse
220 lines • 8.74 kB
JavaScript
;
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.createFirequeueDatabase = createFirequeueDatabase;
exports.generateCreateDatabaseCommand = generateCreateDatabaseCommand;
exports.generateFirebaseConsoleUrl = generateFirebaseConsoleUrl;
exports.getSetupInstructions = getSetupInstructions;
exports.checkAndGuideSetup = checkAndGuideSetup;
exports.validateDatabaseSetup = validateDatabaseSetup;
const admin = __importStar(require("firebase-admin"));
/**
* Create the dedicated firequeue database
*/
async function createFirequeueDatabase(config) {
try {
// Initialize Firebase Admin if not already done
if (admin.apps.length === 0) {
if (config.serviceAccountPath) {
const serviceAccount = require(config.serviceAccountPath);
admin.initializeApp({
credential: admin.credential.cert(serviceAccount),
projectId: config.projectId,
});
}
else {
admin.initializeApp({
projectId: config.projectId,
});
}
}
const databaseId = 'firequeue';
try {
// Test if database exists by trying to connect
const db = new admin.firestore.Firestore({
projectId: config.projectId,
databaseId: databaseId,
});
// Try a simple operation to verify database exists
await db.listCollections();
return {
success: true,
databaseId,
message: `Database '${databaseId}' is ready and accessible`,
};
}
catch (error) {
// Check if it's a "database not found" error
if (error.code === 5 || error.message?.includes('not found')) {
return {
success: false,
databaseId,
message: `Database '${databaseId}' does not exist. Fire Queue will guide you through creating it.`,
};
}
// Other errors (permissions, network, etc.)
return {
success: false,
databaseId,
message: `Cannot access database '${databaseId}': ${error.message || error}`,
};
}
}
catch (error) {
return {
success: false,
databaseId: 'firequeue',
message: `Failed to check database: ${error instanceof Error ? error.message : String(error)}`,
};
}
}
/**
* Generate gcloud CLI command to create the firequeue database
*/
function generateCreateDatabaseCommand(projectId, region = 'us-central1') {
return `gcloud firestore databases create --database=firequeue --location=${region} --project=${projectId}`;
}
/**
* Generate Firebase Console URL to create the database
*/
function generateFirebaseConsoleUrl(projectId) {
return `https://console.firebase.google.com/project/${projectId}/firestore/databases`;
}
/**
* Setup instructions for creating the firequeue database
*/
function getSetupInstructions(projectId, region = 'us-central1') {
return {
gcloudCommand: generateCreateDatabaseCommand(projectId, region),
consoleUrl: generateFirebaseConsoleUrl(projectId),
instructions: [
'🔥 Fire Queue Database Setup',
'==========================',
'',
'Fire Queue uses a dedicated "firequeue" database to keep your queue data separate from your application data.',
'',
'📋 Option 1: Using gcloud CLI',
'-----------------------------',
`Run: ${generateCreateDatabaseCommand(projectId, region)}`,
'',
'📋 Option 2: Using Firebase Console',
'-----------------------------------',
`1. Go to: ${generateFirebaseConsoleUrl(projectId)}`,
'2. Click "Create database"',
'3. Choose database ID: "firequeue"',
`4. Select region: ${region}`,
'5. Choose security rules (start in test mode for development)',
'',
'✅ Once created, Fire Queue will automatically use this database for all queue operations.',
'',
'💡 Benefits of dedicated database:',
' • Isolated queue data from application data',
' • Independent scaling and performance tuning',
' • Easier backup and monitoring of queue operations',
' • No interference with existing Firestore queries',
],
};
}
/**
* Check if firequeue database exists and provide setup guidance
*/
async function checkAndGuideSetup(config) {
console.log('🔍 Checking firequeue database...');
const result = await createFirequeueDatabase(config);
if (result.success) {
console.log(`✅ ${result.message}`);
}
else {
console.log(`⚠️ ${result.message}`);
console.log('');
const instructions = getSetupInstructions(config.projectId, config.region);
instructions.instructions.forEach(line => console.log(line));
}
}
/**
* Validate database setup before queue operations
*/
async function validateDatabaseSetup(projectId, databaseId = 'firequeue', serviceAccountPath) {
try {
// Initialize admin if needed
if (admin.apps.length === 0) {
if (serviceAccountPath) {
const serviceAccount = require(serviceAccountPath);
admin.initializeApp({
credential: admin.credential.cert(serviceAccount),
projectId,
});
}
else {
admin.initializeApp({ projectId });
}
}
const db = new admin.firestore.Firestore({
projectId,
databaseId,
});
// Test basic operations
await db.listCollections();
// Test write permissions (create a test document)
const testDoc = db.collection('_fire_queue_test').doc('test');
await testDoc.set({ timestamp: admin.firestore.FieldValue.serverTimestamp() });
await testDoc.delete();
return {
valid: true,
message: `Database '${databaseId}' is ready for Fire Queue operations`,
};
}
catch (error) {
const suggestions = [];
const err = error;
if (err.code === 5) { // NOT_FOUND
suggestions.push(`Create database '${databaseId}' using Firebase Console or gcloud CLI`);
}
else if (err.code === 7) { // PERMISSION_DENIED
suggestions.push('Check Firebase security rules allow read/write operations');
suggestions.push('Verify service account has proper Firestore permissions');
}
else if (err.message && err.message.includes('UNAUTHENTICATED')) {
suggestions.push('Verify service account JSON file is valid');
suggestions.push('Check GOOGLE_APPLICATION_CREDENTIALS environment variable');
}
return {
valid: false,
message: `Database validation failed: ${error instanceof Error ? error.message : String(error)}`,
suggestions,
};
}
}
//# sourceMappingURL=database-setup.js.map