@marvalt/digivalt-core 0.2.21 → 0.2.24

package/dist/generators.d.ts

@@ -10,6 +10,10 @@ declare function generateMauticData(options?: {
     outputPath?: string;
 }): Promise<boolean>;
 
+declare function generatePhplistData(options?: {
+    outputPath?: string;
+}): Promise<boolean>;
+
 declare function generateSuiteCRMData(options?: {
     outputPath?: string;
 }): Promise<boolean>;
@@ -39,5 +43,5 @@ declare function generateSitemapPathsSafe(options?: GenerateSitemapPathsOptions)
 
 declare function generateAllData(): Promise<void>;
 
-export { PSEUDO_POST_TYPES, generateAllData, generateGoogleReviewsData, generateGravityFormsData, generateMauticData, generateSitemapPaths, generateSitemapPathsSafe, generateSuiteCRMData, generateWordPressData, getWordPressPostTypes, isGoogleReviewsEnabled, parseEnabledPostTypes };
+export { PSEUDO_POST_TYPES, generateAllData, generateGoogleReviewsData, generateGravityFormsData, generateMauticData, generatePhplistData, generateSitemapPaths, generateSitemapPathsSafe, generateSuiteCRMData, generateWordPressData, getWordPressPostTypes, isGoogleReviewsEnabled, parseEnabledPostTypes };
 export type { GenerateSitemapPathsOptions };

package/dist/generators.esm.js

@@ -2428,8 +2428,335 @@ async function generateMauticData(options) {
         return true;
     }
     catch (e) {
-        console.error('❌ Mautic generation failed:', e.message);
-        return false;
+        console.warn(`⚠️  Mautic generation failed (build continues): ${e.message}`);
+        return true;
+    }
+}
+
+/** Normalize PHPList base URL to REST API v2 root. */
+function getApiBaseUrl(phplistUrl) {
+    const trimmed = phplistUrl.replace(/\/$/, '');
+    if (trimmed.endsWith('/api/v2'))
+        return trimmed;
+    if (trimmed.endsWith('/lists'))
+        return `${trimmed}/api/v2`;
+    return `${trimmed}/lists/api/v2`;
+}
+function buildViewProxyPath(messageId, uid) {
+    const params = new URLSearchParams({ endpoint: 'view', mid: String(messageId) });
+    return `/api/phplist-proxy?${params.toString()}`;
+}
+
+let cachedSession = null;
+function buildAccessHeaders(options) {
+    const headers = {};
+    if (options.cfAccessClientId && options.cfAccessClientSecret) {
+        headers['CF-Access-Client-Id'] = options.cfAccessClientId;
+        headers['CF-Access-Client-Secret'] = options.cfAccessClientSecret;
+    }
+    return headers;
+}
+async function createPhplistSession(options) {
+    if (cachedSession && cachedSession.expiresAt > Date.now() + 300000) {
+        return cachedSession.key;
+    }
+    const apiBase = getApiBaseUrl(options.apiUrl);
+    const headers = {
+        'Content-Type': 'application/json',
+        ...buildAccessHeaders(options),
+    };
+    const response = await fetch(`${apiBase}/sessions`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({
+            login_name: options.apiUser,
+            password: options.apiPassword,
+        }),
+    });
+    if (!response.ok) {
+        const errText = await response.text();
+        throw new Error(`PHPList session failed: ${response.status} ${errText}`);
+    }
+    const data = (await response.json());
+    const expiryMs = data.expiry ? Date.parse(data.expiry) : Date.now() + 3600000;
+    cachedSession = { key: data.key, expiresAt: expiryMs };
+    return data.key;
+}
+async function phplistApiFetch(options, path, init = {}) {
+    const sessionKey = await createPhplistSession(options);
+    const apiBase = getApiBaseUrl(options.apiUrl);
+    const url = path.startsWith('http') ? path : `${apiBase}${path.startsWith('/') ? path : `/${path}`}`;
+    const headers = {
+        'Content-Type': 'application/json',
+        'php-auth-pw': sessionKey,
+        ...init.headers,
+        ...buildAccessHeaders(options),
+    };
+    const response = await fetch(url, { ...init, headers });
+    if (!response.ok) {
+        const errText = await response.text();
+        throw new Error(`PHPList API ${path} failed: ${response.status} ${errText}`);
+    }
+    if (response.status === 204) {
+        return undefined;
+    }
+    const text = await response.text();
+    if (!text)
+        return undefined;
+    return JSON.parse(text);
+}
+
+/** URL-safe slug from subject line. */
+function slugifySubject(subject) {
+    return subject
+        .toLowerCase()
+        .normalize('NFKD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 80) || 'newsletter';
+}
+function slugifyListName(name) {
+    return slugifySubject(name);
+}
+function buildNewsletterSlug(listSlug, messageId, subject) {
+    return `${listSlug}/${messageId}-${slugifySubject(subject)}`;
+}
+function stripHtmlExcerpt(html, maxLength = 200) {
+    const text = html
+        .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
+        .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
+        .replace(/<[^>]+>/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (text.length <= maxLength)
+        return text;
+    return `${text.slice(0, maxLength).trim()}…`;
+}
+
+async function generatePhplistData$1(config) {
+    console.log('🔄 Generating PHPList newsletter JSON data...');
+    try {
+        const authOptions = {
+            apiUrl: config.apiUrl,
+            apiUser: config.apiUser,
+            apiPassword: config.apiPassword,
+            cfAccessClientId: config.cfAccessClientId,
+            cfAccessClientSecret: config.cfAccessClientSecret,
+        };
+        const list = await phplistApiFetch(authOptions, `/lists/${config.listId}`);
+        const listSlug = slugifyListName(list.name);
+        const existing = readExistingData(config.outputPath);
+        const knownIds = new Set(existing?.newsletters.map((n) => n.id) ?? []);
+        const lastSentAt = existing?.newsletters.reduce((max, n) => {
+            const t = Date.parse(n.sent_at);
+            return Number.isNaN(t) ? max : Math.max(max, t);
+        }, 0) ?? 0;
+        const listMessageIds = await fetchListMessageIds(authOptions, config.listId);
+        const listMessageIdSet = new Set(listMessageIds);
+        const newItems = [];
+        let afterId = 0;
+        let hasMore = true;
+        while (hasMore) {
+            const page = await phplistApiFetch(authOptions, `/campaigns?limit=100&after_id=${afterId || 1}`);
+            const items = page.items ?? [];
+            if (items.length === 0)
+                break;
+            for (const summary of items) {
+                const id = summary.id;
+                if (!id || !listMessageIdSet.has(id) || knownIds.has(id))
+                    continue;
+                if (summary.message_metadata?.status !== 'sent')
+                    continue;
+                const sentAt = summary.message_metadata?.sent;
+                if (sentAt && lastSentAt > 0 && Date.parse(sentAt) <= lastSentAt) {
+                    continue;
+                }
+                const detail = await phplistApiFetch(authOptions, `/campaigns/${id}`);
+                const item = messageToNewsletter(detail, listSlug, config.newsletterRouteBase);
+                if (item) {
+                    newItems.push(item);
+                    knownIds.add(id);
+                }
+            }
+            const lastId = items[items.length - 1]?.id;
+            if (!lastId || items.length < 100) {
+                hasMore = false;
+            }
+            else {
+                afterId = lastId;
+                const oldestSent = items
+                    .map((m) => m.message_metadata?.sent)
+                    .filter(Boolean)
+                    .map((s) => Date.parse(s))
+                    .filter((t) => !Number.isNaN(t));
+                if (lastSentAt > 0 && oldestSent.length && Math.min(...oldestSent) <= lastSentAt) {
+                    hasMore = false;
+                }
+            }
+        }
+        const mergedNewsletters = [
+            ...(existing?.newsletters ?? []),
+            ...newItems,
+        ].sort((a, b) => Date.parse(b.sent_at) - Date.parse(a.sent_at));
+        const subscribePages = await fetchSubscribePages(authOptions, config.subscribePageIds);
+        const data = {
+            generated_at: new Date().toISOString(),
+            list: {
+                id: list.id,
+                name: list.name,
+                slug: listSlug,
+                description: list.description,
+            },
+            subscribe_pages: subscribePages,
+            newsletters: mergedNewsletters,
+        };
+        writeStaticData(config.outputPath, data);
+        console.log(`✅ PHPList: ${mergedNewsletters.length} newsletters (${newItems.length} new)`);
+        return { success: true, data };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.warn(`⚠️  PHPList generation failed: ${message}`);
+        return { success: false, error: message };
+    }
+}
+async function fetchListMessageIds(authOptions, listId) {
+    const response = await phplistApiFetch(authOptions, `/list-messages/list/${listId}/messages`);
+    return (response.items ?? []).map((row) => row.message_id).filter(Boolean);
+}
+async function fetchSubscribePages(authOptions, pageIds) {
+    const pages = [];
+    for (const pageId of pageIds) {
+        try {
+            const publicPage = await phplistApiFetch(authOptions, `/public/subscribe-pages/${pageId}`);
+            pages.push({
+                id: pageId,
+                title: publicPage.title,
+                intro: publicPage.intro,
+                attributes: publicPage.attributes ?? [],
+                list_ids: publicPage.list_ids,
+            });
+        }
+        catch (e) {
+            console.warn(`⚠️  Could not load subscribe page ${pageId}:`, e.message);
+        }
+    }
+    return pages;
+}
+function messageToNewsletter(message, listSlug, _routeBase) {
+    const subject = message.message_content?.subject?.trim();
+    const html = message.message_content?.text ?? '';
+    const sentAt = message.message_metadata?.sent;
+    if (!subject || !sentAt || message.message_metadata?.status !== 'sent') {
+        return null;
+    }
+    const slug = buildNewsletterSlug(listSlug, message.id, subject);
+    return {
+        id: message.id,
+        unique_id: message.unique_id,
+        slug,
+        subject,
+        sent_at: sentAt,
+        excerpt: stripHtmlExcerpt(html),
+        html,
+        plain_text: message.message_content?.text_message,
+        view_url: buildViewProxyPath(message.id),
+    };
+}
+function readExistingData(outputPath) {
+    try {
+        if (!fs.existsSync(outputPath))
+            return null;
+        return JSON.parse(fs.readFileSync(outputPath, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function writeStaticData(outputPath, data) {
+    const dir = path.dirname(outputPath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(outputPath, JSON.stringify(data, null, 2), 'utf8');
+}
+
+function parseSubscribePageIds(raw) {
+    if (!raw?.trim())
+        return [];
+    return raw
+        .split(',')
+        .map((s) => parseInt(s.trim(), 10))
+        .filter((n) => !Number.isNaN(n));
+}
+async function generatePhplistData(options) {
+    const outputPath = options?.outputPath || './public/phplist-data.json';
+    const phplistUrl = process.env.PHPLIST_URL || process.env.VITE_PHPLIST_URL;
+    const listIdRaw = process.env.PHPLIST_LIST_ID || process.env.VITE_PHPLIST_LIST_ID;
+    const apiUser = process.env.PHPLIST_API_USER || process.env.VITE_PHPLIST_API_USER;
+    const apiPassword = process.env.PHPLIST_API_PASSWORD || process.env.VITE_PHPLIST_API_PASSWORD;
+    const proxyUrl = process.env.PHPLIST_PROXY_URL || process.env.VITE_PHPLIST_PROXY_URL;
+    const subscribePageIds = parseSubscribePageIds(process.env.PHPLIST_SUBSCRIBE_PAGE_IDS || process.env.VITE_PHPLIST_SUBSCRIBE_PAGE_IDS);
+    const newsletterRouteBase = process.env.VITE_PHPLIST_NEWSLETTER_ROUTE_BASE || '/newsletters';
+    const cfAccessClientId = process.env.CF_ACCESS_CLIENT_ID || process.env.VITE_CF_ACCESS_CLIENT_ID;
+    const cfAccessClientSecret = process.env.CF_ACCESS_CLIENT_SECRET || process.env.VITE_CF_ACCESS_CLIENT_SECRET;
+    const restApiEndpoint = process.env.PHPLIST_API_ENDPOINT || process.env.VITE_PHPLIST_API_ENDPOINT;
+    const publicBaseUrl = process.env.PHPLIST_PUBLIC_BASE_URL || process.env.VITE_PHPLIST_PUBLIC_BASE_URL;
+    const apiSecret = process.env.PHPLIST_API_SECRET || process.env.VITE_PHPLIST_API_SECRET;
+    const subscribeStrategy = process.env.PHPLIST_SUBSCRIBE_STRATEGY || process.env.VITE_PHPLIST_SUBSCRIBE_STRATEGY;
+    const subscribePageId = process.env.PHPLIST_SUBSCRIBE_PAGE_ID || process.env.VITE_PHPLIST_SUBSCRIBE_PAGE_ID;
+    const apiModeRaw = process.env.PHPLIST_API_MODE || process.env.VITE_PHPLIST_API_MODE;
+    const apiMode = apiModeRaw === 'rest_v2' || apiModeRaw === 'v2'
+        ? 'rest_v2'
+        : apiModeRaw === 'restapi' || apiModeRaw === 'plugin' || restApiEndpoint
+            ? 'restapi'
+            : undefined;
+    if (!phplistUrl) {
+        console.log('⚠️  PHPList URL not configured. Skipping PHPList data generation.');
+        return true;
+    }
+    const listId = parseInt(listIdRaw || '0', 10);
+    if (!listId || Number.isNaN(listId)) {
+        console.warn('⚠️  PHPList list ID not configured. Skipping PHPList data generation.');
+        return true;
+    }
+    if (!apiUser || !apiPassword) {
+        console.warn('⚠️  PHPList API credentials missing. Skipping PHPList data generation.');
+        return true;
+    }
+    try {
+        const authMode = proxyUrl ? 'cloudflare_proxy' : 'direct';
+        const result = await generatePhplistData$1({
+            authMode,
+            apiUrl: phplistUrl,
+            cloudflareWorkerUrl: authMode === 'cloudflare_proxy' ? proxyUrl : undefined,
+            apiUser,
+            apiPassword,
+            listId,
+            subscribePageIds,
+            outputPath,
+            newsletterRouteBase,
+            cfAccessClientId,
+            cfAccessClientSecret,
+            apiMode,
+            restApiEndpoint,
+            publicBaseUrl,
+            apiSecret,
+            subscribeStrategy: subscribeStrategy === 'direct' ? 'direct' : subscribeStrategy === 'confirm-email' ? 'confirm-email' : undefined,
+            subscribePageId,
+        });
+        if (result.success) {
+            console.log(`📁 PHPList data written to: ${path.join(process.cwd(), outputPath)}`);
+        }
+        else {
+            console.warn(`⚠️  PHPList generation completed with warnings: ${result.error ?? 'unknown'}`);
+        }
+        return true;
+    }
+    catch (e) {
+        console.warn(`⚠️  PHPList generation failed: ${e.message}`);
+        return true;
     }
 }
 
@@ -2463,8 +2790,8 @@ async function generateSuiteCRMData(options) {
         return true;
     }
     catch (e) {
-        console.error('❌ SuiteCRM generation failed:', e.message);
-        return false;
+        console.warn(`⚠️  SuiteCRM generation failed (build continues): ${e.message}`);
+        return true;
     }
 }
 
@@ -2779,16 +3106,18 @@ async function generateAllData() {
     }
     const wpSuccess = await generateWordPressData();
     const gfSuccess = await generateGravityFormsData();
-    const mauticSuccess = await generateMauticData();
-    const suitecrmSuccess = await generateSuiteCRMData();
-    const googleReviewsSuccess = await generateGoogleReviewsData();
-    if (!wpSuccess || !gfSuccess || !mauticSuccess || !suitecrmSuccess || !googleReviewsSuccess) {
-        console.error('❌ Some generation tasks failed. See above for details.');
+    // Optional integrations — warn-only (same as PHPList); do not block deploy
+    await generateMauticData();
+    await generatePhplistData();
+    await generateSuiteCRMData();
+    await generateGoogleReviewsData();
+    if (!wpSuccess || !gfSuccess) {
+        console.error('❌ Required generation failed (WordPress or Gravity Forms). See above for details.');
         process.exit(1);
     }
     await generateSitemapPathsSafe();
     console.log('✅ Generation complete!');
 }
 
-export { PSEUDO_POST_TYPES, generateAllData, generateGoogleReviewsData, generateGravityFormsData, generateMauticData, generateSitemapPaths, generateSitemapPathsSafe, generateSuiteCRMData, generateWordPressData, getWordPressPostTypes, isGoogleReviewsEnabled, parseEnabledPostTypes };
+export { PSEUDO_POST_TYPES, generateAllData, generateGoogleReviewsData, generateGravityFormsData, generateMauticData, generatePhplistData, generateSitemapPaths, generateSitemapPathsSafe, generateSuiteCRMData, generateWordPressData, getWordPressPostTypes, isGoogleReviewsEnabled, parseEnabledPostTypes };
 //# sourceMappingURL=generators.esm.js.map