feat: add discovermassId to church-matcher ExistingChurch and ChurchCandidate
Add discovermassId field to ExistingChurch interface and ChurchCandidate type, insert a dedicated matching pass in findDuplicateChurch, and update all 15 importer push blocks plus 16 loadExistingChurches select queries to include the new field. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
albertfj114
742
scripts/import-philmass.ts
Normal file
742
scripts/import-philmass.ts
Normal file
@@ -0,0 +1,742 @@
|
||||
#!/usr/bin/env tsx
|
||||
/**
|
||||
* Import Catholic churches and mass schedules from Philmass.com
|
||||
*
|
||||
* Philmass.com provides rich Schema.org-annotated mass schedule data for
|
||||
* Philippine churches. It has no coordinates, so we match against existing
|
||||
* churches (OSM + mass-schedules.com) and only update matched records.
|
||||
* Unmatched churches are logged for manual review.
|
||||
*
|
||||
* Discovery strategy:
|
||||
* 1. Fetch Philippines page → extract province URLs
|
||||
* 2. For each province → extract city listing URLs
|
||||
* 3. For each city listing → extract church mass-schedule URLs
|
||||
* 4. Deduplicate all church URLs globally
|
||||
* 5. For each church: parse JSON-LD + Schema.org Events, match, upsert
|
||||
*
|
||||
* Usage:
|
||||
* npx tsx scripts/import-philmass.ts --all
|
||||
* npx tsx scripts/import-philmass.ts --all --dry-run
|
||||
* npx tsx scripts/import-philmass.ts --province Metro-Manila
|
||||
* npx tsx scripts/import-philmass.ts --all --resume-from Cebu
|
||||
* npx tsx scripts/import-philmass.ts --all --job-id {uuid}
|
||||
*/
|
||||
|
||||
import dotenv from 'dotenv';
|
||||
import path from 'path';
|
||||
|
||||
dotenv.config({ path: path.resolve(process.cwd(), '.env.local') });
|
||||
dotenv.config({ path: path.resolve(process.cwd(), '.env') });
|
||||
|
||||
import { Pool } from 'pg';
|
||||
import { PrismaPg } from '@prisma/adapter-pg';
|
||||
import { PrismaClient } from '@prisma/client';
|
||||
|
||||
const dbUrl = process.env.DATABASE_URL || 'postgresql://postgres:postgres@localhost:5432/nearestmass';
|
||||
console.log(`Connecting to database: ${dbUrl.replace(/:[^:@]+@/, ':***@')}`);
|
||||
const pool = new Pool({
|
||||
connectionString: dbUrl,
|
||||
ssl: dbUrl.includes('neon') ? { rejectUnauthorized: false } : undefined,
|
||||
});
|
||||
const adapter = new PrismaPg(pool);
|
||||
const prisma = new PrismaClient({ adapter });
|
||||
|
||||
import { findDuplicateChurch } from '../src/lib/church-matcher';
|
||||
import type { ExistingChurch } from '../src/lib/church-matcher';
|
||||
|
||||
// ─── Constants ───────────────────────────────────────────────────────────────
|
||||
|
||||
const SITE_BASE = 'https://www.philmass.com';
|
||||
const PHILIPPINES_URL = `${SITE_BASE}/Asia/Philippines.html`;
|
||||
const USER_AGENT = 'NearestMass-Importer/1.0 (parish data aggregator; contact: privacy@nearestmass.com)';
|
||||
const REQUEST_DELAY_MS = 2000;
|
||||
|
||||
// ─── Types ───────────────────────────────────────────────────────────────────
|
||||
|
||||
interface ProvinceInfo {
|
||||
name: string;
|
||||
url: string;
|
||||
}
|
||||
|
||||
interface ChurchUrl {
|
||||
url: string;
|
||||
slug: string; // URL slug used as philmassId
|
||||
province: string;
|
||||
city: string;
|
||||
}
|
||||
|
||||
interface ParsedPhilmassChurch {
|
||||
name: string;
|
||||
streetAddress: string | null;
|
||||
city: string | null;
|
||||
region: string | null;
|
||||
}
|
||||
|
||||
interface ParsedSchedule {
|
||||
dayOfWeek: number;
|
||||
time: string;
|
||||
}
|
||||
|
||||
interface ImportStats {
|
||||
provincesProcessed: number;
|
||||
citiesProcessed: number;
|
||||
churchUrlsDiscovered: number;
|
||||
churchesProcessed: number;
|
||||
churchesMatched: number;
|
||||
churchesUnmatched: number;
|
||||
churchesSkipped: number;
|
||||
schedulesUpdated: number;
|
||||
massSchedulesCreated: number;
|
||||
errors: number;
|
||||
}
|
||||
|
||||
interface CLIArgs {
|
||||
all: boolean;
|
||||
province?: string;
|
||||
dryRun: boolean;
|
||||
resumeFrom?: string;
|
||||
jobId?: string;
|
||||
}
|
||||
|
||||
// ─── HTTP Client ─────────────────────────────────────────────────────────────
|
||||
|
||||
let requestCount = 0;
|
||||
|
||||
function delay(ms: number): Promise<void> {
|
||||
return new Promise((resolve) => setTimeout(resolve, ms));
|
||||
}
|
||||
|
||||
async function fetchPage(url: string): Promise<string | null> {
|
||||
if (requestCount > 0) {
|
||||
await delay(REQUEST_DELAY_MS);
|
||||
}
|
||||
requestCount++;
|
||||
|
||||
try {
|
||||
const response = await fetch(url, {
|
||||
headers: {
|
||||
'User-Agent': USER_AGENT,
|
||||
'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
|
||||
},
|
||||
});
|
||||
|
||||
if (!response.ok) {
|
||||
console.error(` HTTP ${response.status} for ${url}`);
|
||||
return null;
|
||||
}
|
||||
|
||||
return await response.text();
|
||||
} catch (error) {
|
||||
console.error(` Fetch error for ${url}: ${error instanceof Error ? error.message : error}`);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
// ─── Discovery: Province → City → Church URLs ───────────────────────────────
|
||||
|
||||
async function fetchProvinceUrls(): Promise<ProvinceInfo[]> {
|
||||
console.log(`Fetching Philippines page: ${PHILIPPINES_URL}`);
|
||||
const html = await fetchPage(PHILIPPINES_URL);
|
||||
if (!html) throw new Error('Failed to fetch Philippines page');
|
||||
|
||||
const provinces: ProvinceInfo[] = [];
|
||||
const seen = new Set<string>();
|
||||
|
||||
// Pattern: href="https://www.philmass.com/Asia/Philippines/{Province}.html"
|
||||
const regex = /href="(https:\/\/www\.philmass\.com\/Asia\/Philippines\/([^/"]+)\.html)"/g;
|
||||
let match;
|
||||
while ((match = regex.exec(html)) !== null) {
|
||||
const url = match[1];
|
||||
const name = match[2];
|
||||
// Skip non-province pages (weekly-sunday, etc.)
|
||||
if (name.includes('weekly') || name.includes('Roman-Catholic') || seen.has(name)) continue;
|
||||
seen.add(name);
|
||||
provinces.push({ name, url });
|
||||
}
|
||||
|
||||
return provinces;
|
||||
}
|
||||
|
||||
function decodeHtmlEntities(str: string): string {
|
||||
return str
|
||||
.replace(/&#(\d+);/g, (_, code: string) => String.fromCharCode(parseInt(code)))
|
||||
.replace(/&/g, '&')
|
||||
.replace(/</g, '<')
|
||||
.replace(/>/g, '>')
|
||||
.replace(/"/g, '"');
|
||||
}
|
||||
|
||||
async function fetchCityListingUrls(provinceUrl: string, provinceName: string): Promise<string[]> {
|
||||
const html = await fetchPage(provinceUrl);
|
||||
if (!html) return [];
|
||||
|
||||
const urls: string[] = [];
|
||||
const seen = new Set<string>();
|
||||
|
||||
// Pattern: href=".../{Province}/{City}/Roman-Catholic-Churches-in-{City}...html"
|
||||
const regex = /href="(https:\/\/www\.philmass\.com\/Asia\/Philippines\/[^"]*\/Roman-Catholic-Churches-in-[^"]*\.html)"/g;
|
||||
let match;
|
||||
while ((match = regex.exec(html)) !== null) {
|
||||
const url = decodeHtmlEntities(match[1]);
|
||||
if (seen.has(url)) continue;
|
||||
seen.add(url);
|
||||
urls.push(url);
|
||||
}
|
||||
|
||||
return urls;
|
||||
}
|
||||
|
||||
async function fetchChurchUrlsFromCityPage(cityUrl: string, provinceName: string): Promise<ChurchUrl[]> {
|
||||
const html = await fetchPage(cityUrl);
|
||||
if (!html) return [];
|
||||
|
||||
const churches: ChurchUrl[] = [];
|
||||
const seen = new Set<string>();
|
||||
|
||||
// Pattern: href=".../Roman-Catholic-Churches/{Church-Name}/mass-schedule.html"
|
||||
const regex = /href="(https:\/\/www\.philmass\.com\/Asia\/Philippines\/([^/]+)\/([^/]+)\/Roman-Catholic-Churches\/([^/]+)\/mass-schedule\.html)"/g;
|
||||
let match;
|
||||
while ((match = regex.exec(html)) !== null) {
|
||||
const url = decodeHtmlEntities(match[1]);
|
||||
const province = decodeURIComponent(decodeHtmlEntities(match[2]));
|
||||
const city = decodeURIComponent(decodeHtmlEntities(match[3]));
|
||||
const slug = decodeURIComponent(decodeHtmlEntities(match[4]));
|
||||
|
||||
if (seen.has(url)) continue;
|
||||
seen.add(url);
|
||||
|
||||
churches.push({ url, slug, province, city });
|
||||
}
|
||||
|
||||
return churches;
|
||||
}
|
||||
|
||||
// ─── HTML Parsers ────────────────────────────────────────────────────────────
|
||||
|
||||
function parseChurchJsonLd(html: string): ParsedPhilmassChurch | null {
|
||||
// Extract JSON-LD: <script type="application/ld+json">{...}</script>
|
||||
const jsonLdMatch = html.match(/<script\s+type="application\/ld\+json"\s*>([\s\S]*?)<\/script>/i);
|
||||
if (!jsonLdMatch) return null;
|
||||
|
||||
try {
|
||||
const data = JSON.parse(jsonLdMatch[1]);
|
||||
const church = data.mainEntityOfPage;
|
||||
if (!church || church['@type'] !== 'PlaceOfWorship') return null;
|
||||
|
||||
const address = church.address || {};
|
||||
return {
|
||||
name: church.name || null,
|
||||
streetAddress: address.streetAddress?.replace(/,\s*$/, '').trim() || null,
|
||||
city: address.addressLocality || null,
|
||||
region: address.addressRegion || null,
|
||||
};
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function parseChurchNameFromH1(html: string): string | null {
|
||||
// Fallback: <h1>Quiapo Church mass schedule 2026 - Minor Basilica of the Black Nazarene</h1>
|
||||
const h1Match = html.match(/<h1>([^<]+)<\/h1>/i);
|
||||
if (!h1Match) return null;
|
||||
|
||||
let name = h1Match[1].trim();
|
||||
// Remove "mass schedule YYYY" and trailing " - "
|
||||
name = name.replace(/\s*mass\s+schedule\s+\d{4}\s*/i, '');
|
||||
name = name.replace(/^\s*-\s*/, '').replace(/\s*-\s*$/, '');
|
||||
return name.trim() || null;
|
||||
}
|
||||
|
||||
function parseScheduleFromStartDates(html: string): ParsedSchedule[] {
|
||||
// Extract all startDate ISO timestamps from Schema.org Event microdata
|
||||
// Pattern: itemprop="startDate" content="2026-02-22T05:00:00+08:00"
|
||||
const schedules: ParsedSchedule[] = [];
|
||||
const seen = new Set<string>();
|
||||
|
||||
const regex = /itemprop="startDate"\s+content="(\d{4}-\d{2}-\d{2})T(\d{2}):(\d{2}):\d{2}[^"]*"/g;
|
||||
let match;
|
||||
while ((match = regex.exec(html)) !== null) {
|
||||
const dateStr = match[1];
|
||||
const hours = match[2];
|
||||
const minutes = match[3];
|
||||
|
||||
// Derive dayOfWeek from the date
|
||||
const date = new Date(`${dateStr}T12:00:00`); // noon to avoid TZ issues
|
||||
const dayOfWeek = date.getDay(); // 0=Sun, 1=Mon, ..., 6=Sat
|
||||
|
||||
const time = `${hours}:${minutes}`;
|
||||
const key = `${dayOfWeek}:${time}`;
|
||||
|
||||
if (seen.has(key)) continue;
|
||||
seen.add(key);
|
||||
|
||||
schedules.push({ dayOfWeek, time });
|
||||
}
|
||||
|
||||
return schedules;
|
||||
}
|
||||
|
||||
// ─── Database Operations ─────────────────────────────────────────────────────
|
||||
|
||||
async function loadExistingPhilippineChurches(): Promise<ExistingChurch[]> {
|
||||
console.log('Loading existing Philippine churches for deduplication...');
|
||||
const churches = await prisma.church.findMany({
|
||||
where: { country: 'PH' },
|
||||
select: {
|
||||
id: true,
|
||||
name: true,
|
||||
latitude: true,
|
||||
longitude: true,
|
||||
osmId: true,
|
||||
baiduId: true,
|
||||
masstimesId: true,
|
||||
orarimesseId: true,
|
||||
massSchedulesPhId: true,
|
||||
philmassId: true,
|
||||
horariosMisasId: true,
|
||||
mszeInfoId: true,
|
||||
weekdayMassesId: true,
|
||||
messesInfoId: true,
|
||||
bohosluzbyId: true,
|
||||
miserendId: true,
|
||||
kerknetId: true,
|
||||
gottesdienstzeitenId: true,
|
||||
discovermassId: true,
|
||||
source: true,
|
||||
website: true,
|
||||
phone: true,
|
||||
address: true,
|
||||
},
|
||||
});
|
||||
console.log(`Loaded ${churches.length} existing Philippine churches`);
|
||||
return churches;
|
||||
}
|
||||
|
||||
// ─── Import Logic ────────────────────────────────────────────────────────────
|
||||
|
||||
async function processChurch(
|
||||
churchUrl: ChurchUrl,
|
||||
existingChurches: ExistingChurch[],
|
||||
unmatchedLog: string[],
|
||||
dryRun: boolean,
|
||||
stats: ImportStats,
|
||||
): Promise<void> {
|
||||
stats.churchesProcessed++;
|
||||
|
||||
const html = await fetchPage(churchUrl.url);
|
||||
if (!html) {
|
||||
stats.errors++;
|
||||
return;
|
||||
}
|
||||
|
||||
// Parse church info from JSON-LD
|
||||
const jsonLd = parseChurchJsonLd(html);
|
||||
const churchName = jsonLd?.name || parseChurchNameFromH1(html);
|
||||
|
||||
if (!churchName) {
|
||||
console.log(` Skipping ${churchUrl.slug}: no name found`);
|
||||
stats.churchesSkipped++;
|
||||
return;
|
||||
}
|
||||
|
||||
// Parse schedules from Schema.org startDate attributes
|
||||
const schedules = parseScheduleFromStartDates(html);
|
||||
|
||||
// Try to find a match by philmassId first
|
||||
const existingByPhilmass = existingChurches.find((c) => c.philmassId === churchUrl.slug);
|
||||
let matched = existingByPhilmass || null;
|
||||
|
||||
// If no philmassId match, try name-based matching against churches with coordinates
|
||||
if (!matched) {
|
||||
// Try matching by name similarity against all PH churches
|
||||
// We can't use findDuplicateChurch() without coordinates, so do name-only matching
|
||||
const normalizedName = churchName.toLowerCase()
|
||||
.replace(/\bst\.\s/g, 'saint ')
|
||||
.replace(/\bst\s/g, 'saint ')
|
||||
.replace(/\bcatholic church\b/g, '')
|
||||
.replace(/\bparish\b/g, '')
|
||||
.replace(/\bchurch\b/g, '')
|
||||
.replace(/[^\w\s]/g, '')
|
||||
.replace(/\s+/g, ' ')
|
||||
.trim();
|
||||
|
||||
// Filter to churches in the same city if possible
|
||||
const cityName = jsonLd?.city || churchUrl.city.replace(/-/g, ' ');
|
||||
const candidatesInCity = existingChurches.filter((c) => {
|
||||
if (!c.address) return false;
|
||||
return c.address.toLowerCase().includes(cityName.toLowerCase());
|
||||
});
|
||||
|
||||
// Search in-city candidates first, then all PH churches
|
||||
const searchPools = candidatesInCity.length > 0
|
||||
? [candidatesInCity, existingChurches]
|
||||
: [existingChurches];
|
||||
|
||||
for (const searchPool of searchPools) {
|
||||
if (matched) break;
|
||||
for (const existing of searchPool) {
|
||||
const existingNorm = existing.name.toLowerCase()
|
||||
.replace(/\bst\.\s/g, 'saint ')
|
||||
.replace(/\bst\s/g, 'saint ')
|
||||
.replace(/\bcatholic church\b/g, '')
|
||||
.replace(/\bparish\b/g, '')
|
||||
.replace(/\bchurch\b/g, '')
|
||||
.replace(/[^\w\s]/g, '')
|
||||
.replace(/\s+/g, ' ')
|
||||
.trim();
|
||||
|
||||
// Require strong name match: one name contains the other, or very similar
|
||||
// Guard against overly generic names ("chapel", "holy", etc.) by requiring
|
||||
// that the shorter name is at least 8 chars after normalization
|
||||
const shorter = normalizedName.length <= existingNorm.length ? normalizedName : existingNorm;
|
||||
if (shorter.length >= 8) {
|
||||
if (normalizedName.includes(existingNorm) || existingNorm.includes(normalizedName)) {
|
||||
matched = existing;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (dryRun) {
|
||||
if (matched) {
|
||||
stats.churchesMatched++;
|
||||
console.log(` [MATCH] "${churchName}" → existing "${matched.name}" (${matched.id})`);
|
||||
} else {
|
||||
stats.churchesUnmatched++;
|
||||
unmatchedLog.push(`${churchName} | ${jsonLd?.city || churchUrl.city} | ${churchUrl.url}`);
|
||||
console.log(` [UNMATCHED] "${churchName}" in ${jsonLd?.city || churchUrl.city}`);
|
||||
}
|
||||
if (schedules.length > 0) {
|
||||
stats.massSchedulesCreated += schedules.length;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
if (!matched) {
|
||||
stats.churchesUnmatched++;
|
||||
unmatchedLog.push(`${churchName} | ${jsonLd?.city || churchUrl.city} | ${churchUrl.url}`);
|
||||
return;
|
||||
}
|
||||
|
||||
stats.churchesMatched++;
|
||||
|
||||
// Update existing church: set philmassId, fill missing fields
|
||||
const updateData: Record<string, unknown> = {
|
||||
philmassId: churchUrl.slug,
|
||||
};
|
||||
|
||||
if (!matched.address && jsonLd?.streetAddress) {
|
||||
const fullAddress = [jsonLd.streetAddress, jsonLd.city, jsonLd.region]
|
||||
.filter(Boolean).join(', ');
|
||||
updateData.address = fullAddress;
|
||||
}
|
||||
|
||||
// Fill city/state from JSON-LD or URL
|
||||
const dbRecord = await prisma.church.findUnique({
|
||||
where: { id: matched.id },
|
||||
select: { city: true, state: true },
|
||||
});
|
||||
if (dbRecord && !dbRecord.city && (jsonLd?.city || churchUrl.city)) {
|
||||
updateData.city = jsonLd?.city || churchUrl.city.replace(/-/g, ' ');
|
||||
}
|
||||
if (dbRecord && !dbRecord.state && (jsonLd?.region || churchUrl.province)) {
|
||||
updateData.state = jsonLd?.region || churchUrl.province.replace(/-/g, ' ');
|
||||
}
|
||||
|
||||
try {
|
||||
await prisma.church.update({
|
||||
where: { id: matched.id },
|
||||
data: updateData,
|
||||
});
|
||||
} catch (error) {
|
||||
if (error instanceof Error && error.message.includes('Unique constraint')) {
|
||||
stats.churchesSkipped++;
|
||||
return;
|
||||
}
|
||||
throw error;
|
||||
}
|
||||
|
||||
// Replace mass schedules if we have any
|
||||
if (schedules.length > 0) {
|
||||
try {
|
||||
await prisma.$transaction(async (tx) => {
|
||||
await tx.massSchedule.deleteMany({ where: { churchId: matched!.id } });
|
||||
await tx.massSchedule.createMany({
|
||||
data: schedules.map((s) => ({
|
||||
churchId: matched!.id,
|
||||
dayOfWeek: s.dayOfWeek,
|
||||
time: s.time,
|
||||
language: 'English',
|
||||
})),
|
||||
});
|
||||
await tx.church.update({
|
||||
where: { id: matched!.id },
|
||||
data: { lastScrapedAt: new Date() },
|
||||
});
|
||||
});
|
||||
stats.schedulesUpdated++;
|
||||
stats.massSchedulesCreated += schedules.length;
|
||||
} catch (error) {
|
||||
stats.errors++;
|
||||
console.error(` Error saving schedules for ${churchUrl.slug}: ${error instanceof Error ? error.message : error}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ─── CLI ─────────────────────────────────────────────────────────────────────
|
||||
|
||||
function parseArgs(): CLIArgs {
|
||||
const args = process.argv.slice(2);
|
||||
const result: CLIArgs = {
|
||||
all: false,
|
||||
dryRun: false,
|
||||
};
|
||||
|
||||
for (let i = 0; i < args.length; i++) {
|
||||
switch (args[i]) {
|
||||
case '--all':
|
||||
result.all = true;
|
||||
break;
|
||||
case '--province':
|
||||
result.province = args[++i];
|
||||
break;
|
||||
case '--dry-run':
|
||||
result.dryRun = true;
|
||||
break;
|
||||
case '--resume-from':
|
||||
result.resumeFrom = args[++i];
|
||||
break;
|
||||
case '--job-id':
|
||||
result.jobId = args[++i];
|
||||
break;
|
||||
case '--help':
|
||||
case '-h':
|
||||
console.log(`
|
||||
Usage: npx tsx scripts/import-philmass.ts [options]
|
||||
|
||||
Options:
|
||||
--all Import from all provinces
|
||||
--province <name> Import from a single province (e.g. "Metro-Manila")
|
||||
--dry-run No database writes, just report what would happen
|
||||
--resume-from <province> Skip provinces until reaching this one
|
||||
--job-id <uuid> Background job tracking ID
|
||||
--help, -h Show this help message
|
||||
|
||||
Examples:
|
||||
npx tsx scripts/import-philmass.ts --province Metro-Manila --dry-run
|
||||
npx tsx scripts/import-philmass.ts --all
|
||||
npx tsx scripts/import-philmass.ts --all --resume-from Cebu
|
||||
`);
|
||||
process.exit(0);
|
||||
}
|
||||
}
|
||||
|
||||
if (!result.all && !result.province) {
|
||||
console.error('Error: specify --all or --province <name>');
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
// ─── Helpers ─────────────────────────────────────────────────────────────────
|
||||
|
||||
function formatDuration(ms: number): string {
|
||||
const seconds = Math.floor(ms / 1000);
|
||||
const minutes = Math.floor(seconds / 60);
|
||||
const hours = Math.floor(minutes / 60);
|
||||
if (hours > 0) return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
|
||||
if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
|
||||
return `${seconds}s`;
|
||||
}
|
||||
|
||||
// ─── Main ────────────────────────────────────────────────────────────────────
|
||||
|
||||
async function main() {
|
||||
const args = parseArgs();
|
||||
const startTime = Date.now();
|
||||
|
||||
console.log('\n' + '='.repeat(70));
|
||||
console.log('PHILMASS.COM IMPORTER');
|
||||
console.log('='.repeat(70));
|
||||
console.log(`Mode: ${args.all ? 'All provinces' : `Single province: ${args.province}`}`);
|
||||
console.log(`Dry run: ${args.dryRun ? 'YES (no DB writes)' : 'NO'}`);
|
||||
if (args.resumeFrom) console.log(`Resume from: ${args.resumeFrom}`);
|
||||
console.log(`Time: ${new Date().toISOString()}`);
|
||||
console.log('='.repeat(70) + '\n');
|
||||
|
||||
// Update background job status if provided
|
||||
if (args.jobId) {
|
||||
try {
|
||||
await prisma.backgroundJob.update({
|
||||
where: { id: args.jobId },
|
||||
data: { status: 'running', startedAt: new Date() },
|
||||
});
|
||||
} catch {
|
||||
// Job might not exist yet
|
||||
}
|
||||
}
|
||||
|
||||
// Load existing Philippine churches for dedup
|
||||
const existingChurches = await loadExistingPhilippineChurches();
|
||||
|
||||
// ─── Phase 1: Discover all church URLs ───────────────────────────────────
|
||||
|
||||
console.log('=== Phase 1: Discovering church URLs ===\n');
|
||||
|
||||
const allProvinces = await fetchProvinceUrls();
|
||||
console.log(`Found ${allProvinces.length} provinces\n`);
|
||||
|
||||
// Filter to requested provinces
|
||||
let provincesToProcess: ProvinceInfo[];
|
||||
if (args.province) {
|
||||
const found = allProvinces.find((p) => p.name === args.province);
|
||||
if (!found) {
|
||||
console.error(`Province "${args.province}" not found. Available: ${allProvinces.map((p) => p.name).join(', ')}`);
|
||||
process.exit(1);
|
||||
}
|
||||
provincesToProcess = [found];
|
||||
} else {
|
||||
provincesToProcess = allProvinces;
|
||||
}
|
||||
|
||||
// Handle --resume-from
|
||||
if (args.resumeFrom) {
|
||||
const idx = provincesToProcess.findIndex((p) => p.name === args.resumeFrom);
|
||||
if (idx === -1) {
|
||||
console.error(`Resume province "${args.resumeFrom}" not found.`);
|
||||
process.exit(1);
|
||||
}
|
||||
console.log(`Resuming from province "${args.resumeFrom}" (skipping ${idx} provinces)\n`);
|
||||
provincesToProcess = provincesToProcess.slice(idx);
|
||||
}
|
||||
|
||||
// Collect all unique church URLs across all provinces/cities
|
||||
const allChurchUrls = new Map<string, ChurchUrl>(); // keyed by URL to deduplicate
|
||||
|
||||
const stats: ImportStats = {
|
||||
provincesProcessed: 0,
|
||||
citiesProcessed: 0,
|
||||
churchUrlsDiscovered: 0,
|
||||
churchesProcessed: 0,
|
||||
churchesMatched: 0,
|
||||
churchesUnmatched: 0,
|
||||
churchesSkipped: 0,
|
||||
schedulesUpdated: 0,
|
||||
massSchedulesCreated: 0,
|
||||
errors: 0,
|
||||
};
|
||||
|
||||
for (let pi = 0; pi < provincesToProcess.length; pi++) {
|
||||
const province = provincesToProcess[pi];
|
||||
const elapsed = formatDuration(Date.now() - startTime);
|
||||
console.log(`[${pi + 1}/${provincesToProcess.length}] Province: ${province.name} [${elapsed} elapsed]`);
|
||||
|
||||
try {
|
||||
// Get city listing URLs from province page
|
||||
const cityUrls = await fetchCityListingUrls(province.url, province.name);
|
||||
console.log(` Found ${cityUrls.length} city listing pages`);
|
||||
|
||||
for (const cityUrl of cityUrls) {
|
||||
const churchUrls = await fetchChurchUrlsFromCityPage(cityUrl, province.name);
|
||||
stats.citiesProcessed++;
|
||||
|
||||
for (const church of churchUrls) {
|
||||
if (!allChurchUrls.has(church.url)) {
|
||||
allChurchUrls.set(church.url, church);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
stats.provincesProcessed++;
|
||||
console.log(` Total unique churches so far: ${allChurchUrls.size}`);
|
||||
} catch (error) {
|
||||
stats.errors++;
|
||||
console.error(` ERROR discovering ${province.name}: ${error instanceof Error ? error.message : error}`);
|
||||
}
|
||||
}
|
||||
|
||||
stats.churchUrlsDiscovered = allChurchUrls.size;
|
||||
console.log(`\nDiscovery complete: ${allChurchUrls.size} unique church URLs across ${stats.citiesProcessed} city pages\n`);
|
||||
|
||||
// ─── Phase 2: Process each church ─────────────────────────────────────────
|
||||
|
||||
console.log('=== Phase 2: Processing churches ===\n');
|
||||
|
||||
const churchList = [...allChurchUrls.values()];
|
||||
const unmatchedLog: string[] = [];
|
||||
|
||||
for (let i = 0; i < churchList.length; i++) {
|
||||
const church = churchList[i];
|
||||
const elapsed = formatDuration(Date.now() - startTime);
|
||||
if ((i + 1) % 50 === 0 || i === 0) {
|
||||
console.log(`[${i + 1}/${churchList.length}] Processing churches... [${elapsed} elapsed]`);
|
||||
}
|
||||
|
||||
try {
|
||||
await processChurch(church, existingChurches, unmatchedLog, args.dryRun, stats);
|
||||
} catch (error) {
|
||||
stats.errors++;
|
||||
console.error(` ERROR processing ${church.slug}: ${error instanceof Error ? error.message : error}`);
|
||||
}
|
||||
}
|
||||
|
||||
// Print summary
|
||||
const totalTime = Date.now() - startTime;
|
||||
console.log('\n' + '='.repeat(70));
|
||||
console.log(`IMPORT SUMMARY ${args.dryRun ? '(DRY RUN)' : ''}`);
|
||||
console.log('='.repeat(70));
|
||||
console.log(`Provinces processed: ${stats.provincesProcessed}`);
|
||||
console.log(`Cities processed: ${stats.citiesProcessed}`);
|
||||
console.log(`Church URLs discovered: ${stats.churchUrlsDiscovered}`);
|
||||
console.log(`Churches processed: ${stats.churchesProcessed}`);
|
||||
console.log(` Matched (updated): ${stats.churchesMatched}`);
|
||||
console.log(` Unmatched (skipped): ${stats.churchesUnmatched}`);
|
||||
console.log(` Skipped (other): ${stats.churchesSkipped}`);
|
||||
console.log(`Schedules updated: ${stats.schedulesUpdated}`);
|
||||
console.log(`Mass schedules created: ${stats.massSchedulesCreated}`);
|
||||
console.log(`Errors: ${stats.errors}`);
|
||||
console.log(`Total time: ${formatDuration(totalTime)}`);
|
||||
console.log(`HTTP requests: ${requestCount}`);
|
||||
console.log('='.repeat(70));
|
||||
|
||||
// Log unmatched churches for manual review
|
||||
if (unmatchedLog.length > 0) {
|
||||
console.log(`\nUnmatched churches (${unmatchedLog.length}):`);
|
||||
console.log('-'.repeat(70));
|
||||
for (const line of unmatchedLog) {
|
||||
console.log(` ${line}`);
|
||||
}
|
||||
console.log('-'.repeat(70));
|
||||
}
|
||||
|
||||
console.log('');
|
||||
|
||||
// Update background job
|
||||
if (args.jobId) {
|
||||
try {
|
||||
await prisma.backgroundJob.update({
|
||||
where: { id: args.jobId },
|
||||
data: {
|
||||
status: stats.errors > 0 ? 'completed_with_errors' : 'completed',
|
||||
completedAt: new Date(),
|
||||
result: JSON.stringify(stats),
|
||||
},
|
||||
});
|
||||
} catch {
|
||||
// Ignore
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
main()
|
||||
.catch((error) => {
|
||||
console.error('Fatal error:', error);
|
||||
process.exit(1);
|
||||
})
|
||||
.finally(async () => {
|
||||
await prisma.$disconnect();
|
||||
await pool.end();
|
||||
});
|
||||
Reference in New Issue
Block a user