@loopress/cli 0.16.0 → 0.18.0

package/dist/commands/seo/push.js

@@ -0,0 +1,171 @@
+import { Args } from '@oclif/core';
+import { Listr } from 'listr2';
+import { readdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { dirname, extname, join } from 'node:path';
+import { PushCommand } from '../../lib/push-command.js';
+import { isNotFoundError } from '../../lib/wp-client.js';
+import { SEO_REDIRECTS_ENDPOINT, SEO_SETTINGS_ENDPOINT, seoPostMetaEndpoint, seoRedirectEndpoint, } from '../../utils/seo-format.js';
+import { redirectFileBase } from './pull.js';
+export default class Push extends PushCommand {
+    static args = {
+        path: Args.string({ description: 'Path to SEO directory (overrides project config)' }),
+    };
+    static description = 'Push SEO settings, post meta, and redirects to WordPress. Local redirect files created remotely are renamed on disk to the `<id>-<slug>` convention. Fails clearly per file if the active SEO plugin does not support redirects.';
+    static examples = ['$ lps seo push'];
+    static flags = {
+        ...PushCommand.dryRunFlag,
+    };
+    failedCount = 0;
+    async run() {
+        const { args } = await this.parse(Push);
+        const { url } = this.siteConfig;
+        const path = this.resolveSeoPath(args.path);
+        this.log(`Pushing SEO configuration to ${url}`);
+        this.log(`SEO path: ${path}`);
+        await this.pushSettings(path);
+        await this.pushPostMeta(path);
+        await this.pushRedirects(path);
+        if (this.failedCount > 0) {
+            this.error(`${this.failedCount} SEO item${this.failedCount === 1 ? '' : 's'} failed to push.`);
+        }
+        if (this.dryRun)
+            return;
+        await this.recordSuccess();
+        this.log('All SEO configuration pushed.');
+    }
+    async jsonFilesIn(dir) {
+        try {
+            return (await readdir(dir)).filter((file) => extname(file) === '.json');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return [];
+            throw error;
+        }
+    }
+    async pushPostMeta(basePath) {
+        const root = join(basePath, 'post-meta');
+        let postTypeDirs;
+        try {
+            postTypeDirs = (await readdir(root, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return;
+            throw error;
+        }
+        for (const postType of postTypeDirs) {
+            const dir = join(root, postType);
+            const files = await this.jsonFilesIn(dir);
+            if (files.length === 0)
+                continue;
+            this.log(`Found ${files.length} ${postType} post-meta file${files.length === 1 ? '' : 's'} to push`);
+            await new Listr(files.map((file) => ({
+                task: async (_ctx, task) => this.pushPostMetaFile(postType, join(dir, file), task),
+                title: `Push ${file}`,
+            })), { concurrent: false, exitOnError: false }).run();
+        }
+    }
+    async pushPostMetaFile(postType, filePath, task) {
+        if (this.dryRun) {
+            if (task)
+                task.output = `[dry-run] Would push: ${filePath}`;
+            return;
+        }
+        try {
+            const post = JSON.parse(await readFile(filePath, 'utf8'));
+            await this.wp.post(seoPostMetaEndpoint(postType), { meta: post.meta, slug: post.slug });
+            if (task)
+                task.output = `Pushed: ${post.slug}`;
+        }
+        catch (error) {
+            const message = `Failed to push ${filePath}: ${error.message}`;
+            if (task)
+                task.output = message;
+            else
+                this.warn(`  ${message}`);
+            this.failedCount++;
+            throw error;
+        }
+    }
+    async pushRedirectFile(filePath, task) {
+        if (this.dryRun) {
+            if (task)
+                task.output = `[dry-run] Would push: ${filePath}`;
+            return;
+        }
+        try {
+            const redirect = JSON.parse(await readFile(filePath, 'utf8'));
+            const payload = { headerCode: redirect.headerCode, sources: redirect.sources, status: redirect.status, urlTo: redirect.urlTo };
+            if (redirect.id) {
+                try {
+                    await this.wp.put(seoRedirectEndpoint(redirect.id), payload);
+                    if (task)
+                        task.output = `Pushed: redirect #${redirect.id}`;
+                    return;
+                }
+                catch (error) {
+                    // The id recorded locally doesn't exist on this site (e.g. a fresh install): create it
+                    // instead of failing, and adopt whatever id the site assigns (same fallback as snippet push).
+                    if (!isNotFoundError(error))
+                        throw error;
+                }
+            }
+            const created = await this.wp.post(SEO_REDIRECTS_ENDPOINT, payload);
+            await this.renameToCanonical(filePath, created);
+            if (task)
+                task.output = `Pushed: redirect #${created.id}`;
+        }
+        catch (error) {
+            const message = `Failed to push ${filePath}: ${error.message}`;
+            if (task)
+                task.output = message;
+            else
+                this.warn(`  ${message}`);
+            this.failedCount++;
+            throw error;
+        }
+    }
+    async pushRedirects(basePath) {
+        const dir = join(basePath, 'redirects');
+        const files = await this.jsonFilesIn(dir);
+        if (files.length === 0)
+            return;
+        this.log(`Found ${files.length} redirect${files.length === 1 ? '' : 's'} to push`);
+        await new Listr(files.map((file) => ({
+            task: async (_ctx, task) => this.pushRedirectFile(join(dir, file), task),
+            title: `Push ${file}`,
+        })), { concurrent: false, exitOnError: false }).run();
+    }
+    async pushSettings(basePath) {
+        const file = join(basePath, 'settings.json');
+        let raw;
+        try {
+            raw = await readFile(file, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return;
+            throw error;
+        }
+        if (this.dryRun) {
+            this.log(`[dry-run] Would push: ${file}`);
+            return;
+        }
+        try {
+            await this.wp.put(SEO_SETTINGS_ENDPOINT, JSON.parse(raw));
+            this.log(`Pushed: ${file}`);
+        }
+        catch (error) {
+            this.failedCount++;
+            this.warn(`Failed to push ${file}: ${error.message}`);
+        }
+    }
+    async renameToCanonical(filePath, redirect) {
+        const dir = dirname(filePath);
+        const canonicalPath = join(dir, `${redirectFileBase(redirect)}.json`);
+        await writeFile(canonicalPath, JSON.stringify(redirect, null, 2) + '\n');
+        if (canonicalPath !== filePath)
+            await rm(filePath, { force: true });
+    }
+}

package/dist/lib/base.d.ts

@@ -14,6 +14,9 @@ export declare abstract class LoopressCommand extends Command {
     protected get wp(): WpClient;
     init(): Promise<void>;
     protected resolveAcfPath(override?: string): string;
+    protected resolveApiPath(override?: string): string;
+    protected resolveFormPath(override?: string): string;
+    protected resolveSeoPath(override?: string): string;
     protected resolveSnippetsPath(override?: string): string;
     private resolveEnvironment;
 }

package/dist/lib/base.js

@@ -40,6 +40,21 @@ export class LoopressCommand extends Command {
             return override;
         return join(this.rootDir, this.localConfig.acfDir ?? 'acf');
     }
+    resolveApiPath(override) {
+        if (override)
+            return override;
+        return join(this.rootDir, this.localConfig.apiDir ?? 'api');
+    }
+    resolveFormPath(override) {
+        if (override)
+            return override;
+        return join(this.rootDir, this.localConfig.formDir ?? 'forms');
+    }
+    resolveSeoPath(override) {
+        if (override)
+            return override;
+        return join(this.rootDir, this.localConfig.seoDir ?? 'seo');
+    }
     resolveSnippetsPath(override) {
         if (override)
             return override;

package/dist/types/project-config.generated.d.ts

@@ -15,6 +15,18 @@ export interface LoopressProjectConfiguration {
      * Directory where ACF field groups, post types, taxonomies and options pages are read from and written to, relative to rootDir.
      */
     acfDir?: string;
+    /**
+     * Directory where SEO settings, post meta, and redirects (RankMath and Yoast SEO, whichever is active) are read from and written to, relative to rootDir.
+     */
+    seoDir?: string;
+    /**
+     * Directory where forms (WPForms today) are read from and written to, relative to rootDir.
+     */
+    formDir?: string;
+    /**
+     * Directory where custom API route files are read from and written to, relative to rootDir.
+     */
+    apiDir?: string;
     /**
      * Project identifier from the global Loopress config. When set, takes precedence over the currently active project in the global config.
      */

package/dist/utils/form-format.d.ts

@@ -0,0 +1,3 @@
+export declare const FORM_ENDPOINT = "loopress/v1/forms";
+export declare function getFormId(data: Record<string, unknown>): null | number;
+export declare function getFormTitle(data: Record<string, unknown>): string;

package/dist/utils/form-format.js

@@ -0,0 +1,17 @@
+export const FORM_ENDPOINT = 'loopress/v1/forms';
+// Deliberately loose, same reasoning as getAcfKey in acf-format.ts: a form plugin's own data
+// format (WPForms today: fields, settings, notifications, confirmations, providers, meta; other
+// WordPress form plugins may be supported later, same shape as snippet-format.ts's Code
+// Snippets/WPCode split) is large, deeply nested, and versioned by whichever plugin release
+// wrote it. We only need `id` for filenames/identity and `settings.form_title` for display
+// (the field WPForms itself uses; a future provider may differ), everything else round-trips
+// through pull/push untouched.
+export function getFormId(data) {
+    const id = Number(data.id);
+    return Number.isInteger(id) && id > 0 ? id : null;
+}
+export function getFormTitle(data) {
+    const settings = data.settings;
+    const title = settings?.form_title;
+    return typeof title === 'string' && title.trim() !== '' ? title : '(untitled)';
+}

package/dist/utils/seo-format.d.ts

@@ -0,0 +1,20 @@
+export declare const DEFAULT_POST_TYPES: readonly ["post", "page"];
+export declare const SEO_SETTINGS_ENDPOINT = "loopress/v1/seo/settings";
+export declare const SEO_REDIRECTS_ENDPOINT = "loopress/v1/seo/redirects";
+export declare function seoRedirectEndpoint(id: number): string;
+export declare function seoPostMetaEndpoint(postType: string): string;
+export interface SeoPostMeta {
+    meta: Record<string, unknown>;
+    slug: string;
+    title: string;
+}
+export interface SeoRedirect {
+    createdAt: null | string;
+    headerCode: number;
+    hits: number;
+    id: number;
+    sources: unknown;
+    status: string;
+    updatedAt: null | string;
+    urlTo: string;
+}

package/dist/utils/seo-format.js

@@ -0,0 +1,10 @@
+// Post types synced by `lps seo pull` when --post-type isn't given.
+export const DEFAULT_POST_TYPES = ['post', 'page'];
+export const SEO_SETTINGS_ENDPOINT = 'loopress/v1/seo/settings';
+export const SEO_REDIRECTS_ENDPOINT = 'loopress/v1/seo/redirects';
+export function seoRedirectEndpoint(id) {
+    return `${SEO_REDIRECTS_ENDPOINT}/${id}`;
+}
+export function seoPostMetaEndpoint(postType) {
+    return `loopress/v1/seo/post-meta/${postType}`;
+}