@loopress/cli 0.23.0 → 0.24.0

package/dist/lib/wp-client.d.ts

@@ -9,6 +9,9 @@ export declare class WpClient {
     constructor(siteUrl: string, token: string);
     delete<T = unknown>(path: string, options?: RequestOptions): Promise<T>;
     get<T>(path: string, options?: RequestOptions): Promise<T>;
+    getAll<T>(path: string, options?: RequestOptions & {
+        perPage?: number;
+    }): Promise<T[]>;
     post<T = unknown>(path: string, json?: Record<string, unknown>, options?: RequestOptions): Promise<T>;
     put<T = unknown>(path: string, json?: Record<string, unknown>, options?: RequestOptions): Promise<T>;
     private request;
@@ -17,6 +20,8 @@ type RequestOptions = {
     timeoutMs?: number;
 };
 export declare function isNotFoundError(error: unknown): boolean;
+export declare function isApplicative404(error: unknown, marker: string): boolean;
 export declare function isTimeoutError(error: unknown): boolean;
+export declare function isInvalidPageNumber(error: unknown): boolean;
 export declare function formatWpError(error: unknown, url: string, timeoutMs?: number): string;
 export {};

package/dist/lib/wp-client.js

@@ -22,6 +22,32 @@ export class WpClient {
     async get(path, options) {
         return this.request('get', path, undefined, options);
     }
+    // Fetches every page of a paginated WP REST collection by walking `?page=N`, stopping on the
+    // first short page or on WordPress core's 400 "rest_post_invalid_page_number" past the last
+    // one. `path` may already carry query params. Use for `wp/v2/*` list endpoints, which cap at
+    // 100 items per request.
+    async getAll(path, options) {
+        const perPage = options?.perPage ?? 100;
+        const separator = path.includes('?') ? '&' : '?';
+        const all = [];
+        for (let page = 1;; page += 1) {
+            let batch;
+            try {
+                batch = await this.get(`${path}${separator}per_page=${perPage}&page=${page}`, options);
+            }
+            catch (error) {
+                if (isInvalidPageNumber(error))
+                    break;
+                throw error;
+            }
+            if (!Array.isArray(batch) || batch.length === 0)
+                break;
+            all.push(...batch);
+            if (batch.length < perPage)
+                break;
+        }
+        return all;
+    }
     async post(path, json, options) {
         return this.request('post', path, json, options);
     }
@@ -43,10 +69,40 @@ export function isNotFoundError(error) {
     const cause = error?.cause;
     return cause?.response?.statusCode === 404;
 }
+// A 404 a Loopress controller raises on purpose, identified by its JSON body's `error` field
+// (e.g. `{"error": "composer.lock not found"}` from ComposerController). Narrower than
+// isNotFoundError: a bare 404 also covers the route being absent because the plugin isn't
+// installed or predates the feature, which callers must still surface normally.
+export function isApplicative404(error, marker) {
+    if (!isNotFoundError(error))
+        return false;
+    const body = error.cause?.response?.body;
+    if (!body)
+        return false;
+    try {
+        return JSON.parse(body).error === marker;
+    }
+    catch {
+        return false;
+    }
+}
 export function isTimeoutError(error) {
     const cause = error?.cause;
     return cause?.name === 'TimeoutError';
 }
+// WordPress core answers 400 with this `code` when `?page=N` is past the last page of a
+// collection, which is how `WpClient.getAll` knows it has walked them all.
+export function isInvalidPageNumber(error) {
+    const body = error.cause?.response?.body;
+    if (!body)
+        return false;
+    try {
+        return JSON.parse(body).code === 'rest_post_invalid_page_number';
+    }
+    catch {
+        return false;
+    }
+}
 export function formatWpError(error, url, timeoutMs = REQUEST_TIMEOUT_MS) {
     const err = error;
     const status = err.response?.statusCode;

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

@@ -23,18 +23,22 @@ export interface LoopressProjectConfiguration {
      * Directory where forms (WPForms today) are read from and written to, relative to rootDir.
      */
     formDir?: string;
-    /**
-     * Directory where WordPress pages are read from and written to, relative to rootDir.
-     */
-    pageDir?: string;
     /**
      * Directory where custom API route files are read from and written to, relative to rootDir.
      */
     apiDir?: string;
+    /**
+     * Directory where hook files (WordPress actions, filters, and scheduled tasks) are read from and written to, relative to rootDir.
+     */
+    hooksDir?: string;
     /**
      * Directory where single-page app bundles are read from and written to, relative to rootDir. Each subdirectory is one app: a loopress.app.json plus a built dist/ folder.
      */
     appsDir?: string;
+    /**
+     * Directory where explicitly tracked WordPress options (wp_options rows) are read from and written to, relative to rootDir. Only options added via `lps option add` live here, this is never the whole options table.
+     */
+    optionsDir?: string;
     /**
      * Project identifier from the global Loopress config. When set, takes precedence over the currently active project in the global config.
      */

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

@@ -0,0 +1,31 @@
+export declare const OPTIONS_ENDPOINT = "loopress/v1/options";
+export declare function optionEndpoint(name: string): string;
+export declare const RESERVED_OPTION_NAMES: readonly ["active_plugins", "stylesheet", "template"];
+export declare const READONLY_BY_DEFAULT_OPTION_NAMES: readonly ["siteurl", "home", "db_version", "cron", "rewrite_rules", "WPLANG"];
+export type LocalOption = {
+    autoload: string;
+    name: string;
+    readonly?: boolean;
+    value: unknown;
+};
+export type RemoteOption = {
+    autoload: string;
+    name: string;
+    value: unknown;
+};
+export type ListedOption = {
+    autoload: string;
+    confirmed: boolean;
+    core: boolean;
+    guess: null | string;
+    name: string;
+    pluginName: null | string;
+};
+export declare function isReservedOptionName(name: string): boolean;
+export declare function defaultReadonlyFor(name: string): boolean;
+export declare function optionFileName(name: string): string;
+export declare function partitionByReadonly(tracked: LocalOption[]): {
+    skipped: LocalOption[];
+    writable: LocalOption[];
+};
+export declare function parseLocalOption(raw: string): LocalOption;

package/dist/utils/option-format.js

@@ -0,0 +1,51 @@
+export const OPTIONS_ENDPOINT = 'loopress/v1/options';
+export function optionEndpoint(name) {
+    return `${OPTIONS_ENDPOINT}/${encodeURIComponent(name)}`;
+}
+// Mirrors OptionsService::RESERVED_NAMES on the WordPress side (the actual, unbypassable
+// enforcement lives there). Checked here too so `option add` fails fast with a clear pointer to
+// the right command, instead of a round trip just to hit the server's 409.
+export const RESERVED_OPTION_NAMES = ['active_plugins', 'stylesheet', 'template'];
+// Options WordPress core owns or regenerates itself: legitimate to track for visibility (`diff`
+// still shows drift), but never something `push` should overwrite by default. siteurl/home in
+// particular: pushing a value copied from another environment would repoint the target site's
+// own URLs, potentially locking out wp-admin.
+export const READONLY_BY_DEFAULT_OPTION_NAMES = ['siteurl', 'home', 'db_version', 'cron', 'rewrite_rules', 'WPLANG'];
+export function isReservedOptionName(name) {
+    return RESERVED_OPTION_NAMES.includes(name);
+}
+export function defaultReadonlyFor(name) {
+    return READONLY_BY_DEFAULT_OPTION_NAMES.includes(name);
+}
+export function optionFileName(name) {
+    return `${name}.json`;
+}
+// Splits tracked options into what `push` may write and what it must skip: readonly is a local
+// policy flag (see READONLY_BY_DEFAULT_OPTION_NAMES), never something WordPress itself enforces.
+export function partitionByReadonly(tracked) {
+    const writable = [];
+    const skipped = [];
+    for (const option of tracked)
+        (option.readonly ? skipped : writable).push(option);
+    return { skipped, writable };
+}
+export function parseLocalOption(raw) {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new Error('not a JSON object');
+    }
+    const { autoload, name, value } = parsed;
+    if (typeof name !== 'string' || name === '') {
+        throw new Error('missing a "name" string');
+    }
+    if (typeof autoload !== 'string') {
+        throw new TypeError('missing an "autoload" string');
+    }
+    // `value` itself is deliberately untyped (a WP option can hold any JSON-safe value, including
+    // null); only the key's presence is checked, so a hand-edited file that dropped it entirely is
+    // rejected here rather than silently pushing an `undefined` value to WordPress.
+    if (value === undefined) {
+        throw new Error('missing a "value" field');
+    }
+    return parsed;
+}

package/dist/utils/resource-dirs.d.ts

@@ -0,0 +1,13 @@
+import { type LoopressLocalConfig } from './loopress-config.js';
+export declare const RESOURCE_DIR_DEFAULTS: {
+    readonly acf: "acf";
+    readonly api: "api";
+    readonly apps: "apps";
+    readonly form: "forms";
+    readonly hooks: "hooks";
+    readonly options: "options";
+    readonly seo: "seo";
+    readonly snippets: "snippets";
+};
+export type ResourceDirKind = keyof typeof RESOURCE_DIR_DEFAULTS;
+export declare function resolveResourceDir(kind: ResourceDirKind, localConfig: LoopressLocalConfig, override?: string): string;

package/dist/utils/resource-dirs.js

@@ -0,0 +1,34 @@
+import { join } from 'node:path';
+// The default subdirectory for each file-backed resource, relative to rootDir. `lps init`
+// writes these same defaults into loopress.json, keep the two in sync.
+export const RESOURCE_DIR_DEFAULTS = {
+    acf: 'acf',
+    api: 'api',
+    apps: 'apps',
+    form: 'forms',
+    hooks: 'hooks',
+    options: 'options',
+    seo: 'seo',
+    snippets: 'snippets',
+};
+const CONFIG_KEY = {
+    acf: 'acfDir',
+    api: 'apiDir',
+    apps: 'appsDir',
+    form: 'formDir',
+    hooks: 'hooksDir',
+    options: 'optionsDir',
+    seo: 'seoDir',
+    snippets: 'snippetsDir',
+};
+// Resolves where a resource's files live: an explicit override wins, otherwise the
+// loopress.json `<kind>Dir` setting, otherwise the built-in default, all under `rootDir`.
+// Shared by every pull/push command (via LoopressCommand's resolve*Path helpers) and by
+// `lps diff`, so the resolution rule has a single home.
+export function resolveResourceDir(kind, localConfig, override) {
+    if (override)
+        return override;
+    const rootDir = localConfig.rootDir ?? '.';
+    const configured = localConfig[CONFIG_KEY[kind]];
+    return join(rootDir, configured ?? RESOURCE_DIR_DEFAULTS[kind]);
+}