wpheadless-lib 1.0.0

package/dist/api/categories.d.ts

@@ -0,0 +1,29 @@
+import type { WPCategory, WPPost } from "wpjsapi-lib";
+import type { ApiResult } from "./posts";
+export type CategoryClientConfig = {
+    baseApiUrl: string;
+    username?: string;
+    appPassword?: string;
+};
+export declare function listCategoryStaticParams({ baseApiUrl, lang, }: CategoryClientConfig & {
+    lang: string;
+}): Promise<ApiResult<Array<{
+    category: string;
+}>>>;
+export declare function getCategoryBySlug({ baseApiUrl, slug, lang, }: CategoryClientConfig & {
+    slug: string;
+    lang: string;
+}): Promise<ApiResult<WPCategory | null>>;
+export declare function listCategoryPosts({ baseApiUrl, categoryId, perPage, langId, }: CategoryClientConfig & {
+    categoryId: number;
+    perPage: number;
+    langId: string;
+}): Promise<ApiResult<{
+    posts: WPPost[];
+    totalPages: number;
+}>>;
+export declare function getCategoryByTranslationKey({ baseApiUrl, translationKey, lang, perPage, }: CategoryClientConfig & {
+    translationKey: string;
+    lang: string;
+    perPage?: number;
+}): Promise<ApiResult<WPCategory | null>>;

package/dist/api/categories.js

@@ -0,0 +1,91 @@
+import { createWpClient } from "./wpClient";
+import { fetchCategoriesByTranslationKey } from "./translations";
+export async function listCategoryStaticParams({ baseApiUrl, lang, }) {
+    try {
+        const { categoriesApi } = createWpClient({
+            baseUrl: baseApiUrl,
+        });
+        const categories = await categoriesApi.listAll({ lang });
+        return {
+            ok: true,
+            data: categories.map((category) => ({ category: category.slug })),
+            error: null,
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            data: [],
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}
+export async function getCategoryBySlug({ baseApiUrl, slug, lang, }) {
+    try {
+        const { categoriesApi } = createWpClient({
+            baseUrl: baseApiUrl,
+        });
+        const response = await categoriesApi.list({
+            slug,
+            per_page: 1,
+            lang,
+            _fields: ["id", "slug", "name", "description", "yoast_head_json", "meta"],
+        });
+        return { ok: true, data: response.items[0] ?? null, error: null };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            data: null,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}
+export async function listCategoryPosts({ baseApiUrl, categoryId, perPage, langId, }) {
+    try {
+        const { postsApi } = createWpClient({
+            baseUrl: baseApiUrl,
+        });
+        const response = await postsApi.list({
+            categories: [categoryId],
+            per_page: perPage,
+            orderby: "date",
+            order: "desc",
+            _embed: true,
+            taxonomies: { language: [langId] },
+        });
+        return {
+            ok: true,
+            data: {
+                posts: response.items,
+                totalPages: response.pagination.totalPages,
+            },
+            error: null,
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            data: { posts: [], totalPages: 0 },
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}
+export async function getCategoryByTranslationKey({ baseApiUrl, translationKey, lang, perPage = 1, }) {
+    try {
+        const categories = await fetchCategoriesByTranslationKey({
+            baseApiUrl,
+            translationKey,
+            lang,
+            perPage,
+        });
+        return { ok: true, data: categories[0] ?? null, error: null };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            data: null,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}

package/dist/api/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./types";
+export * from "./posts";
+export * from "./categories";
+export * from "./translations";
+export * from "./mappers";
+export * from "./wpClient";

package/dist/api/index.js

@@ -0,0 +1,6 @@
+export * from "./types";
+export * from "./posts";
+export * from "./categories";
+export * from "./translations";
+export * from "./mappers";
+export * from "./wpClient";

package/dist/api/mappers.d.ts

@@ -0,0 +1,5 @@
+import type { WPCategory, WPPost, WPPage } from "wpjsapi-lib";
+import { type CategoryEntity, type PostEntity, type PageEntity } from "./types";
+export declare function mapPostEntity(post: WPPost): PostEntity;
+export declare function mapCategoryEntity(category: WPCategory): CategoryEntity;
+export declare function mapPageEntity(page: WPPage): PageEntity<WPPage>;

package/dist/api/mappers.js

@@ -0,0 +1,30 @@
+import { getEntityLanguageId, getTranslationKey } from "../utils/hreflang";
+const getEmbeddedCategories = (post) => (post._embedded?.["wp:term"]?.[0] || []).filter(Boolean);
+export function mapPostEntity(post) {
+    return {
+        post,
+        meta: {
+            translationKey: getTranslationKey(post),
+            languageId: getEntityLanguageId(post),
+            categories: getEmbeddedCategories(post),
+        },
+    };
+}
+export function mapCategoryEntity(category) {
+    return {
+        category,
+        meta: {
+            translationKey: getTranslationKey(category),
+            languageId: getEntityLanguageId(category),
+        },
+    };
+}
+export function mapPageEntity(page) {
+    return {
+        page,
+        meta: {
+            translationKey: getTranslationKey(page),
+            languageId: getEntityLanguageId(page),
+        },
+    };
+}

package/dist/api/posts.d.ts

@@ -0,0 +1,44 @@
+import type { WPPost, WPPaginatedResponse, WPPostParameters } from "wpjsapi-lib";
+export type ApiResult<T> = {
+    ok: boolean;
+    data: T | null;
+    error: string | null;
+};
+export type ClientConfig = {
+    baseApiUrl: string;
+    username?: string;
+    appPassword?: string;
+};
+export declare function getPostBySlug({ baseApiUrl, slug, langId, username, appPassword, }: ClientConfig & {
+    slug: string;
+    langId: string;
+}): Promise<ApiResult<WPPost | null>>;
+export declare function listPostStaticParams({ baseApiUrl, lang, langId, }: ClientConfig & {
+    lang: string;
+    langId: string;
+}): Promise<ApiResult<Array<{
+    category: string;
+    post: string;
+}>>>;
+export declare function listPostsByTranslationKey({ baseApiUrl, translationKey, username, appPassword, perPage, }: ClientConfig & {
+    translationKey: string;
+    perPage?: number;
+}): Promise<ApiResult<WPPost[]>>;
+type ListPostsParams = ClientConfig & {
+    perPage: number;
+    page?: number;
+    langId: string;
+    categories?: number[];
+    embed?: boolean;
+    fields?: string[];
+    orderby?: WPPostParameters["orderby"];
+    order?: WPPostParameters["order"];
+};
+export declare function listPosts({ baseApiUrl, perPage, page, langId, categories, embed, fields, order, orderby, }: ListPostsParams): Promise<ApiResult<WPPaginatedResponse<WPPost>>>;
+export declare function listPostsWithEmbeds(params: Omit<ListPostsParams, "embed">): Promise<ApiResult<WPPaginatedResponse<WPPost>>>;
+export declare function getPostsTotalPages({ baseApiUrl, perPage, langId, categories, }: ClientConfig & {
+    perPage: number;
+    langId: string;
+    categories?: number[];
+}): Promise<ApiResult<number>>;
+export {};

package/dist/api/posts.js

@@ -0,0 +1,104 @@
+import { createWpClient } from "./wpClient";
+import { fetchPostsByTranslationKey } from "./translations";
+const toMessage = (err) => err instanceof Error ? err.message : "Unknown error";
+export async function getPostBySlug({ baseApiUrl, slug, langId, username, appPassword, }) {
+    try {
+        const { postsApi } = createWpClient({
+            baseUrl: baseApiUrl,
+            username,
+            appPassword,
+        });
+        const response = await postsApi.list({
+            slug,
+            per_page: 1,
+            _embed: true,
+            taxonomies: { language: [langId] },
+        });
+        return { ok: true, data: response.items[0] ?? null, error: null };
+    }
+    catch (error) {
+        return { ok: false, data: null, error: toMessage(error) };
+    }
+}
+export async function listPostStaticParams({ baseApiUrl, lang, langId, }) {
+    try {
+        const { postsApi, categoriesApi } = createWpClient({ baseUrl: baseApiUrl });
+        const categories = await categoriesApi.listAll({ lang });
+        const response = await postsApi.list({
+            per_page: 100,
+            _fields: ["slug", "categories"],
+            taxonomies: { language: [langId] },
+        });
+        const paths = [];
+        for (const post of response.items) {
+            for (const categoryId of post.categories) {
+                const category = categories.find((cat) => cat.id === categoryId);
+                if (category) {
+                    paths.push({
+                        category: category.slug,
+                        post: post.slug,
+                    });
+                }
+            }
+        }
+        return { ok: true, data: paths, error: null };
+    }
+    catch (error) {
+        return { ok: false, data: [], error: toMessage(error) };
+    }
+}
+export async function listPostsByTranslationKey({ baseApiUrl, translationKey, username, appPassword, perPage = 20, }) {
+    try {
+        const posts = await fetchPostsByTranslationKey({
+            baseApiUrl,
+            translationKey,
+            perPage,
+            username,
+            appPassword,
+        });
+        return { ok: true, data: posts, error: null };
+    }
+    catch (error) {
+        return { ok: false, data: [], error: toMessage(error) };
+    }
+}
+export async function listPosts({ baseApiUrl, perPage, page, langId, categories, embed = false, fields, order, orderby, }) {
+    try {
+        const { postsApi } = createWpClient({
+            baseUrl: baseApiUrl,
+        });
+        const response = await postsApi.list({
+            per_page: perPage,
+            page,
+            ...(orderby ? { orderby } : {}),
+            ...(order ? { order } : {}),
+            ...(categories ? { categories } : {}),
+            ...(embed ? { _embed: true } : {}),
+            ...(fields ? { _fields: fields } : {}),
+            taxonomies: { language: [langId] },
+        });
+        return { ok: true, data: response, error: null };
+    }
+    catch (error) {
+        return { ok: false, data: null, error: toMessage(error) };
+    }
+}
+export async function listPostsWithEmbeds(params) {
+    return listPosts({ ...params, embed: true, fields: undefined });
+}
+export async function getPostsTotalPages({ baseApiUrl, perPage, langId, categories, }) {
+    const response = await listPosts({
+        baseApiUrl,
+        perPage: 1,
+        page: 1,
+        langId,
+        categories,
+        fields: ["id"],
+        embed: false,
+    });
+    if (!response.ok || !response.data) {
+        return { ok: false, data: 0, error: response.error };
+    }
+    const totalPosts = response.data.pagination.total;
+    return { ok: true, data: Math.ceil(totalPosts / perPage), error: null };
+}

package/dist/api/translations.d.ts

@@ -0,0 +1,16 @@
+import type { WPPost, WPCategory } from "wpjsapi-lib";
+type ClientConfig = {
+    baseApiUrl: string;
+    username?: string;
+    appPassword?: string;
+};
+export declare function fetchPostsByTranslationKey({ baseApiUrl, translationKey, username, appPassword, perPage, }: ClientConfig & {
+    translationKey: string;
+    perPage?: number;
+}): Promise<WPPost[]>;
+export declare function fetchCategoriesByTranslationKey({ baseApiUrl, translationKey, lang, username, appPassword, perPage, }: ClientConfig & {
+    translationKey: string;
+    lang?: string;
+    perPage?: number;
+}): Promise<WPCategory[]>;
+export {};

package/dist/api/translations.js

@@ -0,0 +1,28 @@
+import { createWpClient } from "./wpClient";
+export async function fetchPostsByTranslationKey({ baseApiUrl, translationKey, username, appPassword, perPage = 20, }) {
+    const { postsApi } = createWpClient({
+        baseUrl: baseApiUrl,
+        username,
+        appPassword,
+    });
+    const response = await postsApi.list({
+        per_page: perPage,
+        _embed: true,
+        translation_key_v2: translationKey,
+    });
+    return response.items;
+}
+export async function fetchCategoriesByTranslationKey({ baseApiUrl, translationKey, lang, username, appPassword, perPage = 20, }) {
+    const { categoriesApi } = createWpClient({
+        baseUrl: baseApiUrl,
+        username,
+        appPassword,
+    });
+    const response = await categoriesApi.list({
+        translation_key_v2: translationKey,
+        per_page: perPage,
+        lang,
+        _fields: ["id", "slug", "name", "description", "yoast_head_json", "meta"],
+    });
+    return response.items;
+}

package/dist/api/types.d.ts

@@ -0,0 +1,30 @@
+import type { WPPost, WPCategory } from "wpjsapi-lib";
+export type EmbeddedCategory = NonNullable<NonNullable<WPPost["_embedded"]>["wp:term"]>[number][number];
+export type EmbeddedLanguageMeta = {
+    translationKey?: string;
+    languageId?: LanguageId;
+};
+export type LanguageId = string;
+export type PostTranslationMeta = {
+    translationKey?: string;
+    languageId?: LanguageId;
+    categories: EmbeddedCategory[];
+};
+export type CategoryTranslationMeta = {
+    translationKey?: string;
+    languageId?: LanguageId;
+};
+export type PostEntity = {
+    post: WPPost;
+    meta: PostTranslationMeta;
+};
+export type CategoryEntity = {
+    category: WPCategory;
+    meta: CategoryTranslationMeta;
+};
+export type PageEntity<T extends {
+    meta?: unknown;
+}> = {
+    page: T;
+    meta: EmbeddedLanguageMeta;
+};

package/dist/api/types.js

@@ -0,0 +1 @@
+export {};

package/dist/api/wpClient.d.ts

@@ -0,0 +1,31 @@
+type WpClientOptions = {
+    baseUrl: string;
+    username?: string;
+    appPassword?: string;
+};
+export declare function createWpClient({ baseUrl, username, appPassword, }: WpClientOptions): {
+    postsApi: {
+        list: (params?: import("wpjsapi-lib").WPPostParameters, options?: import("wpjsapi-lib").RequestOptions) => Promise<import("wpjsapi-lib").WPPaginatedResponse<import("wpjsapi-lib").WPPost>>;
+        listAll: (params?: Omit<import("wpjsapi-lib").WPPostParameters, "page" | "per_page">, options?: import("wpjsapi-lib").RequestOptions) => Promise<import("wpjsapi-lib").WPPost[]>;
+        pages: (params?: import("wpjsapi-lib").WPPostParameters, options?: import("wpjsapi-lib").RequestOptions) => {
+            [Symbol.asyncIterator](): AsyncGenerator<import("wpjsapi-lib").WPPaginatedResponse<import("wpjsapi-lib").WPPost>, void, unknown>;
+        };
+        get: (id: number, context?: "view" | "embed" | "edit", embed?: boolean, options?: import("wpjsapi-lib").RequestOptions) => Promise<import("wpjsapi-lib").WPPost>;
+        create: (data: import("wpjsapi-lib").WPPostCreate, options?: import("wpjsapi-lib").RequestOptions) => Promise<import("wpjsapi-lib").WPPost>;
+        update: (id: number, data: import("wpjsapi-lib").WPPostUpdate, options?: import("wpjsapi-lib").RequestOptions) => Promise<import("wpjsapi-lib").WPPost>;
+        delete: (id: number, force?: boolean, options?: import("wpjsapi-lib").RequestOptions) => Promise<import("wpjsapi-lib").WPPost>;
+        getRevisions: (id: number, options?: import("wpjsapi-lib").RequestOptions) => Promise<import("wpjsapi-lib").WPPost[]>;
+    };
+    categoriesApi: {
+        list: (params?: import("wpjsapi-lib").WPCategoryParameters, options?: import("wpjsapi-lib").RequestOptions) => Promise<import("wpjsapi-lib").WPPaginatedResponse<import("wpjsapi-lib").WPCategory>>;
+        listAll: (params?: Omit<import("wpjsapi-lib").WPCategoryParameters, "page" | "per_page">, options?: import("wpjsapi-lib").RequestOptions) => Promise<import("wpjsapi-lib").WPCategory[]>;
+        pages: (params?: import("wpjsapi-lib").WPCategoryParameters, options?: import("wpjsapi-lib").RequestOptions) => {
+            [Symbol.asyncIterator](): AsyncGenerator<import("wpjsapi-lib").WPPaginatedResponse<import("wpjsapi-lib").WPCategory>, void, unknown>;
+        };
+        get: (id: number, context?: "view" | "embed" | "edit", embed?: boolean, options?: import("wpjsapi-lib").RequestOptions) => Promise<import("wpjsapi-lib").WPCategory>;
+        create: (data: import("wpjsapi-lib").WPCategoryCreate, options?: import("wpjsapi-lib").RequestOptions) => Promise<import("wpjsapi-lib").WPCategory>;
+        update: (id: number, data: import("wpjsapi-lib").WPCategoryUpdate, options?: import("wpjsapi-lib").RequestOptions) => Promise<import("wpjsapi-lib").WPCategory>;
+        delete: (id: number, force?: boolean, options?: import("wpjsapi-lib").RequestOptions) => Promise<import("wpjsapi-lib").WPCategory>;
+    };
+};
+export {};

package/dist/api/wpClient.js

@@ -0,0 +1,23 @@
+import { createAuth, createCategoryEndpoints, createPostsEndpoints, } from "wpjsapi-lib";
+export function createWpClient({ baseUrl, username, appPassword, }) {
+    const hasAuth = username && appPassword;
+    const auth = hasAuth
+        ? createAuth({
+            method: "basic",
+            credentials: {
+                username: username,
+                password: appPassword,
+            },
+        })
+        : undefined;
+    const sharedOptions = {
+        baseUrl,
+        ...(auth ? { auth } : {}),
+    };
+    const postsApi = createPostsEndpoints(sharedOptions);
+    const categoriesApi = createCategoryEndpoints(sharedOptions);
+    return {
+        postsApi,
+        categoriesApi,
+    };
+}

package/dist/app/config.d.ts

@@ -0,0 +1,5 @@
+import type { LanguageConfig } from "../utils/hreflang";
+export declare const languages: LanguageConfig[];
+export declare const runtimeConfig: {
+    postsPerPagePagination: number;
+};

package/dist/app/config.js

@@ -0,0 +1,28 @@
+const parseLanguagesFromEnv = () => {
+    const raw = process.env.WP_LANGUAGES;
+    if (!raw)
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed
+            .map((item) => {
+            if (!item || typeof item !== "object")
+                return null;
+            const { code, basePath, langId } = item;
+            if (typeof code !== "string" || typeof basePath !== "string")
+                return null;
+            return { code, basePath, langId: typeof langId === "string" ? langId : undefined };
+        })
+            .filter(Boolean);
+    }
+    catch (error) {
+        console.warn("Unable to parse WP_LANGUAGES env var", error);
+        return [];
+    }
+};
+export const languages = parseLanguagesFromEnv();
+export const runtimeConfig = {
+    postsPerPagePagination: Number.parseInt(process.env.WP_POSTS_PER_PAGE_PAGINATION ?? "", 10) || 10,
+};