nextpress-core 1.0.0

package/lib/globals/globals.ts

@@ -0,0 +1,25 @@
+import { cache } from 'react';
+
+import './nextpress-config/nextpress-config'
+import './entity-loader/post-loader';
+import './entity-loader/term-loader';
+import './entity-loader/user-loader';
+import './entity-loader/option-loader';
+import './get-field/get-field';
+
+/**
+ * Initializes and returns request-scoped storage for the application state.
+ * Uses React cache to prevent state bleeding across requests.
+ *
+ * @returns {{ currentState: any, loaderStates: Record<string, any> }} Object containing current queried object state and loader states.
+ */
+export const queriedObjectState = cache(() => {
+    return {
+        currentState: null as any,
+        loaderStates: {} as Record<string, any>
+    };
+});
+
+import './queried-object/queried-object';
+
+export {};

package/lib/globals/nextpress-config/nextpress-config.interface.d.ts

@@ -0,0 +1,18 @@
+type NextpressConfig = {
+    /** Custom taxonomies used to categorize and group content (like categories or tags). Expects the taxonomy's URL prefix, so tag instead of post_tag */
+    readonly publicTaxonomies?: string[],
+
+    /** Custom post types registered for public consumption (like posts, pages, or portfolio). */
+    readonly publicPostTypes?: string[],
+
+    /** Post types that should display archive pages on the frontend. */
+    readonly archivedPostTypes?: string[],
+
+    /** The word/character count limit for automatically generated post teasers. */
+    readonly excerptLength?: number,
+
+    /** Database option keys (from wp_options) to fetch early for performance optimization. */
+    readonly preLoadOptions?: string[],
+} & {
+    [key: string]: any;
+};

package/lib/globals/nextpress-config/nextpress-config.ts

@@ -0,0 +1,7 @@
+import nextpressConfig from "../../../../../nextpress.config";
+
+declare global {
+    var nextpressConfig: NextpressConfig
+}
+
+globalThis.nextpressConfig = nextpressConfig;

package/lib/globals/queried-object/queried-object.ts

@@ -0,0 +1,124 @@
+import { IPost } from "../../entities/post/post.interface";
+import { ITerm } from "../../entities/term/term.interface";
+import { IUser } from "../../entities/user/user.interface";
+import { queriedObjectState } from "../globals";
+
+/**
+ * Represents the state of the queried object.
+ */
+interface IQueriedObject {
+    /** Type of the queried object. */
+    objectType: 'post' | 'term' | 'user' | null,
+    /** Array of post IDs associated with the query. */
+    posts: number[],
+    /** Current page number. */
+    page: number,
+    /** Total page count. */
+    pageCount: number,
+    /** ID of the main queried term. */
+    mainTerm?: number,
+    /** Array of term IDs associated with the query. */
+    terms: number[],
+    /** ID of the queried user. */
+    user?: number,
+}
+
+/**
+ * Creates a blank queried object state.
+ *
+ * @returns {IQueriedObject} Blank state object.
+ */
+const createBlankState = (): IQueriedObject => ({
+    objectType: null,
+    posts: [],
+    page: 1,
+    pageCount: 1,
+    terms: [],
+});
+
+declare global {
+    /** The current queried object. */
+    var queriedObject: IQueriedObject
+    /**
+     * Retrieves the first post from the queried object.
+     * @returns {Promise<IPost | undefined>} The post.
+     */
+    var getThePost: () => Promise<IPost | undefined>
+    /**
+     * Retrieves all posts from the queried object.
+     * @returns {Promise<IPost[]>} Array of posts.
+     */
+    var getThePosts: () => Promise<IPost[]>
+    /**
+     * Retrieves the current page number.
+     * @returns {number} Page number.
+     */
+    var getThePage: () => number
+    /**
+     * Retrieves the total page count.
+     * @returns {number} Page count.
+     */
+    var getThePageCount: () => number
+    /**
+     * Retrieves the main term from the queried object.
+     * @returns {Promise<ITerm | undefined>} The term.
+     */
+    var getTheTerm: () => Promise<ITerm | undefined>
+    /**
+     * Retrieves all terms from the queried object.
+     * @returns {Promise<ITerm[]>} Array of terms.
+     */
+    var getTheTerms: () => Promise<ITerm[]>
+    /**
+     * Retrieves the user from the queried object.
+     * @returns {Promise<IUser | undefined>} The user.
+     */
+    var getTheUser: () => Promise<IUser | undefined>
+}
+
+Object.defineProperty(globalThis, 'queriedObject', {
+    configurable: true,
+    enumerable: true,
+    get() {
+        const state = queriedObjectState();
+        return state.currentState || createBlankState();
+    },
+    set(newData: IQueriedObject) {
+        const store = queriedObjectState();
+
+        if (newData.posts) postLoader.prime(newData.posts);
+        if (newData.mainTerm) termLoader.prime([newData.mainTerm]);
+        if (newData.terms) termLoader.prime(newData.terms);
+        if (newData.user) userLoader.prime([newData.user]);
+
+        if (!store.currentState) store.currentState = {};
+        Object.assign(store.currentState, newData);
+    }
+});
+
+globalThis.getThePost = async () => {
+    return (await postLoader.get(globalThis.queriedObject.posts))[0];
+};
+globalThis.getThePosts = () => {
+    return postLoader.get(globalThis.queriedObject.posts);
+};
+
+globalThis.getThePage = () => globalThis.queriedObject.page;
+
+globalThis.getThePageCount = () => globalThis.queriedObject.pageCount;
+
+globalThis.getTheTerm = async () => {
+    if (!globalThis.queriedObject.mainTerm) return;
+    return (await termLoader.get([globalThis.queriedObject.mainTerm]))[0];
+};
+
+globalThis.getTheTerms = () => {
+    return termLoader.get(globalThis.queriedObject.terms);
+};
+
+globalThis.getTheUser = async () => {
+    if (!globalThis.queriedObject.user) return;
+    return (await userLoader.get([globalThis.queriedObject.user]))[0];
+};
+
+export {};

package/lib/repository/optionquery/option-query-args.d.ts

@@ -0,0 +1,21 @@
+import { DB, WpOption } from "../../wpdb/wpdb.interface";
+
+/**
+ * Defines the arguments for querying options.
+ */
+interface OptionQueryArgs {
+    /**
+     * Database column reference to query against.
+     */
+    column: ReferenceExpression<DB, WpOption>;
+
+    /**
+     * Comparison operator for the query.
+     */
+    operand?: ComparisonOperatorExpression;
+
+    /**
+     * Value or array of values to compare.
+     */
+    value: string | string[];
+}

package/lib/repository/optionquery/option-query.ts

@@ -0,0 +1,29 @@
+import { ComparisonOperatorExpression } from "kysely";
+import { EntityQuery } from "../../globals/entity-loader/entity-loader";
+import { OptionQueryArgs } from "./option-query-args";
+import { IOption } from "../../entities/option/option.interface";
+import { wpdb } from "@/wpdb/wpdb";
+
+/**
+ * Executes database queries to retrieve option IDs (or keys) based on provided arguments.
+ */
+export class OptionQuery implements EntityQuery<IOption>
+{
+    constructor(
+        private args: OptionQueryArgs
+    ) {}
+
+    public getCount(): number | undefined {
+        return undefined;
+    }
+
+    public async getIds(): Promise<number[]> {
+        const operand: ComparisonOperatorExpression = this.args.operand || '=';
+
+        return (await wpdb
+            .selectFrom('wpOptions')
+            .select('optionId')
+            .where(this.args.column, operand, this.args.value)
+            .execute()).map(option => option.optionId);
+    }
+}

package/lib/repository/postquery/post-query-args.d.ts

@@ -0,0 +1,108 @@
+type WPQueryOrderByParam =
+    | 'none' | 'id' | 'author' | 'title' | 'name' | 'date' | 'modified'
+    | 'parent' | 'menuOrder'| 'commentCount' | 'rand' | `RAND(${number})`
+    | (string & {});
+
+/**
+ * Defines the arguments for querying posts.
+ * Maps standard WordPress WP_Query parameters.
+ */
+interface PostQueryArgs {
+    /** Post ID. */
+    postId?: number;
+    /** An array of post IDs to retrieve, sticky posts will be included. */
+    postIn?: number[];
+    /** An array of post IDs not to retrieve. */
+    postNotIn?: number[];
+    /** Path to post */
+    path?: string;
+    /** A post type slug (string) or array of post type slugs. */
+    postType?: string | string[];
+    /** A post type slug (string) or array of post type slugs to NOT include. */
+    postTypeNot?: string | string[];
+    /** A post status (string) or array of post statuses. */
+    postStatus?: string | string[];
+    /** A post slug (string) or array of post slugs. */
+    postSlug?: string | string[];
+    /** A post id to retrieve anscestry tree off */
+    postAncestryOf?: string;
+    /** Post title. */
+    title?: string;
+    /** The mime type of the post. Used for 'attachment' post_type. */
+    postMimeType?: string;
+    /** Page ID to retrieve child pages for. Use 0 to only retrieve top-level pages. */
+    postParent?: number;
+    /** An array containing parent page IDs to query child pages from. */
+    postParentIn?: number[];
+    /** An array containing parent page IDs not to query child pages from. */
+    postParentNotIn?: number[];
+    /** Term ID. */
+    termId?: number;
+    /** An array of term IDs (AND in). */
+    termAnd?: number[];
+    /** An array of term IDs (OR in). */
+    termIn?: number[];
+    /** An array of term IDs (NOT in). */
+    termNotIn?: number[];
+    /** Use term slug (not name, this or any children). */
+    termSlug?: string;
+    /** An array of term slugs (AND in). */
+    termSlugAnd?: string[];
+    /** An array of term slugs (OR in). */
+    termSlugIn?: string[];
+    /** Author ID. */
+    authorId?: number;
+    /** User 'user_nicename'. */
+    authorName?: string;
+    /** An array of author IDs to query from. */
+    authorIn?: number[];
+    /** An array of author IDs not to query from. */
+    authorNotIn?: number[];
+    /** search keyword(s). */
+    search?: string;
+    /** Whether to search by exact keyword. Default false. */
+    exact?: boolean;
+    /** array of column names to be searched. accepts 'postTitle', 'postExcerpt' and 'postContent'. */
+    searchColumns?: ('postTitle' | 'postExcerpt' | 'postContent')[];
+    /** Combination YearMonth. Accepts any four-digit year and month numbers 01-12. */
+    yyyymm?: number;
+    /** The four-digit year. Default empty. Accepts any four-digit year. */
+    year?: number;
+    /** The two-digit month. Default empty. Accepts numbers 1-12. */
+    monthnum?: number;
+    /** The week number of the year. Default empty. Accepts numbers 0-53. */
+    w?: number;
+    /** Day of the month. Default empty. Accepts numbers 1-31. */
+    day?: number;
+    /** Hour of the day. Default empty. Accepts numbers 0-23. */
+    hour?: number;
+    /** Minute of the hour. Default empty. Accepts numbers 0-59. */
+    minute?: number;
+    /** Second of the minute. Default empty. Accepts numbers 0-59. */
+    second?: number;
+    /** Whether to ignore sticky posts or not. Default false. */
+    ignoreStickyPosts?: boolean;
+    /** Designates ascending or descending order of posts. Default 'DESC'. */
+    order?: 'ASC' | 'DESC';
+    /** Sort retrieved posts by parameter. */
+    orderBy?: WPQueryOrderByParam;
+    /** Show posts that would show up on page X of a static front page. */
+    page?: number;
+    /** Show all posts (true) or paginate (false). Default false. */
+    noPaging?: boolean;
+    /** The number of posts to offset before retrieval. */
+    offset?: number;
+    /** The number of posts to query for. Use -1 to request all posts. */
+    postsPerPage?: number;
+    /** Whether to skip counting the total rows found. Default false. */
+    noFoundRows?: boolean;
+    /** Meta query  */
+    metaQuery?: {
+        /** Meta key */
+        metaKey: string,
+        /** Variable name to save result to */
+        as: string
+    }[]
+    /** Whether to get multiple, default true */
+    multiple?: bool
+}

package/lib/repository/postquery/post-query.ts

@@ -0,0 +1,281 @@
+import { QueryCreator, sql } from "kysely";
+import { DB } from "../../wpdb/wpdb.interface";
+import * as phpSerialize from "php-serialize";
+import { EntityQuery } from "../../globals/entity-loader/entity-loader";
+import { IPost } from "../../entities/post/post.interface";
+import { wpdb } from "@/wpdb/wpdb";
+
+/**
+ * Executes database queries to retrieve post IDs and counts based on provided arguments.
+ */
+export class PostQuery implements EntityQuery<IPost>
+{
+    private postCount?: number;
+
+    constructor(
+        private args: PostQueryArgs
+    ) {}
+
+    public getCount(): number | undefined {
+        return this.postCount;
+    }
+
+    public async getIds(): Promise<number[]> {
+        let builder = wpdb as QueryCreator<any>;
+
+        if (this.args.postAncestryOf) {
+            builder = builder.withRecursive('decendent_tree', (qb) =>
+                qb.selectFrom('wpPosts')
+                    .select(['wpPosts.ID', 'wpPosts.postName', 'wpPosts.postParent'])
+                    .where('wpPosts.postName', '=', this.args.postAncestryOf)
+                    .unionAll(
+                        qb.selectFrom('wpPosts as p')
+                            .select(['p.ID', 'p.postName', 'p.postParent'])
+                            .innerJoin('decendent_tree as d', 'p.postParent', 'd.ID')
+                    )
+            )
+        }
+
+        let query = (builder as QueryCreator<DB>).selectFrom('wpPosts');
+
+        if (this.args.postAncestryOf) {
+            query = query.where('wpPosts.postName', 'in', (qb: any) =>
+                qb.selectFrom('decendent_tree').select('postName')
+            );
+        }
+
+        // --- ID Filters ---
+        if (this.args.postId)    query = query.where('wpPosts.ID', '=', this.args.postId);
+        if (this.args.postIn)    query = query.where('wpPosts.ID', 'in', this.args.postIn);
+        if (this.args.postNotIn) query = query.where('wpPosts.ID', 'not in', this.args.postNotIn);
+
+        if (this.args.path) {
+            query = query.where((eb) => eb.exists(
+                eb.selectFrom('wpPostmeta')
+                    .select('postId')
+                    .whereRef('postId', '=', 'wpPosts.ID')
+                    .where('wpPostmeta.metaKey', '=', '_nextpress_path')
+                    .where('wpPostmeta.metaValue', '=', this.args.path as string)
+            ));
+        }
+        // --- Type Filters ---
+        if (this.args.postType) {
+            const types = Array.isArray(this.args.postType) ? this.args.postType : [this.args.postType];
+            query = query.where('wpPosts.postType', 'in', types);
+        }
+        if (this.args.postTypeNot) {
+            const types = Array.isArray(this.args.postTypeNot) ? this.args.postTypeNot : [this.args.postTypeNot];
+            query = query.where('wpPosts.postType', 'not in', types);
+        }
+
+        // --- Status Filters ---
+        if (this.args.postStatus) {
+            const statuses = Array.isArray(this.args.postStatus) ? this.args.postStatus : [this.args.postStatus];
+            query = query.where('wpPosts.postStatus', 'in', statuses);
+        }
+
+        // --- Content Filters ---
+        if (this.args.postSlug) {
+            const postSlugs = Array.isArray(this.args.postSlug) ? this.args.postSlug : [this.args.postSlug];
+            query = query.where('wpPosts.postName', 'in', postSlugs);
+        }
+        if (this.args.title)        query = query.where('wpPosts.postTitle', '=', this.args.title);
+        if (this.args.postMimeType) query = query.where('wpPosts.postMimeType', 'like', `%${this.args.postMimeType}%`);
+
+        // --- Parent Filters ---
+        if (this.args.postParent !== undefined)  query = query.where('wpPosts.postParent', '=', this.args.postParent);
+        if (this.args.postParentIn)              query = query.where('wpPosts.postParent', 'in', this.args.postParentIn);
+        if (this.args.postParentNotIn)           query = query.where('wpPosts.postParent', 'not in', this.args.postParentNotIn);
+
+        // --- Term Filters ---
+        if (this.args.termId) {
+            query = query.innerJoin('wpTermRelationships', 'wpPosts.ID', 'wpTermRelationships.objectId')
+                        .where('wpTermRelationships.termTaxonomyId', '=', this.args.termId);
+        }
+        if (this.args.termAnd) {
+            query = query.innerJoin('wpTermRelationships', 'wpPosts.ID', 'wpTermRelationships.objectId')
+                        .where('wpTermRelationships.termTaxonomyId', 'in', this.args.termAnd)
+                        .groupBy('wpPosts.ID')
+                        .having((eb) => eb.fn.count('wpTermRelationships.termTaxonomyId'), '=', this.args.termAnd!.length);
+        }
+        if (this.args.termIn) {
+            query = query.innerJoin('wpTermRelationships', 'wpPosts.ID', 'wpTermRelationships.objectId')
+                        .where('wpTermRelationships.termTaxonomyId', 'in', this.args.termIn);
+        }
+        if (this.args.termNotIn) {
+            query = query.where('wpPosts.ID', 'not in',
+                (qb) =>
+                    qb.selectFrom('wpTermRelationships')
+                        .select('wpTermRelationships.objectId')
+                        .where('wpTermRelationships.termTaxonomyId', 'in', this.args.termNotIn!)
+            );
+        }
+        if (this.args.termSlug) {
+            query = query.innerJoin('wpTermRelationships', 'wpPosts.ID', 'wpTermRelationships.objectId')
+                        .innerJoin('wpTerms', 'wpTermRelationships.termTaxonomyId', 'wpTerms.termId')
+                        .where('wpTerms.slug', '=', this.args.termSlug)
+                        .groupBy('wpPosts.ID');
+        }
+        if (this.args.termSlugAnd) {
+            query = query.innerJoin('wpTermRelationships', 'wpPosts.ID', 'wpTermRelationships.objectId')
+                        .innerJoin('wpTerms', 'wpTermRelationships.termTaxonomyId', 'wpTerms.termId')
+                        .where('wpTerms.slug', 'in', this.args.termSlugAnd)
+                        .groupBy('wpPosts.ID')
+                        .having((eb) => eb.fn.count('wpTermRelationships.termTaxonomyId'), '=', this.args.termSlugAnd!.length);
+        }
+        if (this.args.termSlugIn) {
+            query = query.innerJoin('wpTermRelationships', 'wpPosts.ID', 'wpTermRelationships.objectId')
+                        .innerJoin('wpTerms', 'wpTermRelationships.termTaxonomyId', 'wpTerms.termId')
+                        .where('wpTerms.slug', 'in', this.args.termSlugIn)
+                        .groupBy('wpPosts.ID');
+        }
+
+        // --- Author Filters ---
+        if (this.args.authorId)      query = query.where('wpPosts.postAuthor', '=', this.args.authorId);
+        if (this.args.authorIn)      query = query.where('wpPosts.postAuthor', 'in', this.args.authorIn);
+        if (this.args.authorNotIn)   query = query.where('wpPosts.postAuthor', 'not in', this.args.authorNotIn);
+        if (this.args.authorName) {
+            query = query.innerJoin('wpUsers', 'wpPosts.postAuthor', 'wpUsers.ID')
+                        .where('wpUsers.displayName', '=', this.args.authorName);
+        }
+
+        // --- Search Filters ---
+        if (this.args.search) {
+            const searchTerm = this.args.exact ? this.args.search : `%${this.args.search}%`;
+            const searchCols = this.args.searchColumns || ['postTitle', 'postContent', 'postExcerpt'];
+            const isExact = this.args.exact;
+
+            query = query.where((eb) => {
+                const orClauses = searchCols.map(col => eb(col, isExact ? '=' : 'like', searchTerm));
+                return eb.or(orClauses);
+            });
+        }
+
+        // --- Date Filters ---
+        if (this.args.yyyymm) {
+            const mStr = String(this.args.yyyymm);
+            const y = Number(mStr.substring(0, 4));
+            const mon = Number(mStr.substring(4, 6));
+            query = query.where((eb) => eb.fn('YEAR', [eb.ref('wpPosts.postDate')]), '=', y)
+                        .where((eb) => eb.fn('MONTH', [eb.ref('wpPosts.postDate')]), '=', mon);
+        }
+        if (this.args.year)                 query = query.where((eb) => eb.fn('YEAR', [eb.ref('wpPosts.postDate')]), '=', this.args.year);
+        if (this.args.monthnum)             query = query.where((eb) => eb.fn('MONTH', [eb.ref('wpPosts.postDate')]), '=', this.args.monthnum);
+        if (this.args.w)                    query = query.where((eb) => eb.fn('WEEK', [eb.ref('wpPosts.postDate')]), '=', this.args.w);
+        if (this.args.day)                  query = query.where((eb) => eb.fn('DAY', [eb.ref('wpPosts.postDate')]), '=', this.args.day);
+        if (this.args.hour !== undefined)   query = query.where((eb) => eb.fn('HOUR', [eb.ref('wpPosts.postDate')]), '=', this.args.hour);
+        if (this.args.minute !== undefined) query = query.where((eb) => eb.fn('MINUTE', [eb.ref('wpPosts.postDate')]), '=', this.args.minute);
+        if (this.args.second !== undefined) query = query.where((eb) => eb.fn('SECOND', [eb.ref('wpPosts.postDate')]), '=', this.args.second);
+
+        // -- Calculate Total Count (Before Limits/Offsets) --
+        if (!this.args.noFoundRows) {
+            try {
+                const countQueryBase = query.clearSelect().select('wpPosts.ID').distinct();
+                const countResult = await wpdb.selectFrom(countQueryBase.as('sub'))
+                    .select(sql<number>`count(*)`.as('count'))
+                    .executeTakeFirst();
+
+                this.postCount = countResult ? Number(countResult.count) : undefined;
+            } catch (error: any) {
+                console.error('WPPostQuery: Cannot get row count: ', error.message);
+                this.postCount = undefined;
+            }
+        } else {
+            this.postCount = undefined;
+        }
+
+        // -- Apply ORDER BY --
+        if (!this.args.ignoreStickyPosts) {
+            const rawStickyPostIds = await getOption('sticky_posts');
+
+            let stickyPosts: number[] = [];
+            try {
+                const parsed = phpSerialize.unserialize(rawStickyPostIds ?? 'a:0:{}');
+                stickyPosts = Object.values(parsed as Record<string, number> | number[]);
+            } catch (error) {
+                console.warn('WPPostQuery: Failed to parse sticky_posts option. Defaulting to empty.', error);
+            }
+
+            if (stickyPosts.length > 0) {
+                query = query.orderBy(
+                    sql`CASE WHEN wp_posts.ID IN (${sql.join(stickyPosts)}) THEN 0 ELSE 1 END`,
+                    'asc'
+                );
+            }
+        }
+
+        const orderDirection = this.args.order === 'ASC' ? 'asc' : 'desc';
+        const orderBy = this.args.orderBy || 'none';
+
+        switch(orderBy) {
+            case 'none': break;
+            case 'id':              query = query.orderBy('wpPosts.ID', orderDirection); break;
+            case 'author':          query = query.orderBy('wpPosts.postAuthor', orderDirection).orderBy('wpPosts.ID', orderDirection); break;
+            case 'title':           query = query.orderBy('wpPosts.postTitle', orderDirection).orderBy('wpPosts.ID', orderDirection); break;
+            case 'name':            query = query.orderBy('wpPosts.postName', orderDirection).orderBy('wpPosts.ID', orderDirection); break;
+            case 'date':            query = query.orderBy('wpPosts.postDate', orderDirection).orderBy('wpPosts.ID', orderDirection); break;
+            case 'modified':        query = query.orderBy('wpPosts.postModified', orderDirection).orderBy('wpPosts.ID', orderDirection); break;
+            case 'parent':          query = query.orderBy('wpPosts.postParent', orderDirection).orderBy('wpPosts.ID', orderDirection); break;
+            case 'menuOrder':       query = query.orderBy('wpPosts.menuOrder', orderDirection).orderBy('wpPosts.ID', orderDirection); break;
+            case 'commentCount':    query = query.orderBy('wpPosts.commentCount', orderDirection).orderBy('wpPosts.ID', orderDirection); break;
+            case 'rand':            query = query.orderBy((eb) => eb.fn('RAND', [])).orderBy('wpPosts.ID', orderDirection); break;
+            default:
+                if (orderBy.startsWith('RAND(')) {
+                    const seed = parseInt(orderBy.replace(/\D/g, ''), 10);
+                    query = query.orderBy((eb) => eb.fn('RAND', [eb.val(seed)])).orderBy('wpPosts.ID', orderDirection);
+                } else {
+                    query = query.orderBy('wpPosts.postDate', orderDirection).orderBy('wpPosts.ID', orderDirection);
+                }
+                break;
+        }
+
+        // -- Apply LIMIT & OFFSET --
+        if (!this.args.noPaging) {
+            const perPage = this.args.postsPerPage ?? 10;
+
+            if (perPage > -1) {
+                query = query.limit(perPage);
+
+                const page = this.args.page ?? 1;
+                const baseOffset = this.args.offset ?? 0;
+                const offsetAmount = ((page - 1) * perPage) + baseOffset;
+
+                if (offsetAmount > 0) {
+                    query = query.offset(offsetAmount);
+                }
+            }
+        }
+
+        if (this.args.metaQuery) {
+            let dynamicQuery: any = query;
+
+            for (let metaQuery of this.args.metaQuery) {
+                const uniqueAlias = `meta_${metaQuery.as}`;
+
+                dynamicQuery = dynamicQuery.leftJoin(`wpPostmeta as ${uniqueAlias}`, (join: any) =>
+                    join
+                        .onRef(`${uniqueAlias}.postId`, '=', 'wpPosts.ID')
+                        .on(`${uniqueAlias}.metaKey`, '=', metaQuery.metaKey)
+                    )
+                    .select(`${uniqueAlias}.metaValue as ${metaQuery.as}`);
+            }
+
+            query = dynamicQuery;
+        }
+
+        try {
+            if(this.args.multiple !== false) {
+                return (await query
+                    .select('wpPosts.ID as id')
+                    .groupBy('wpPosts.ID')
+                    .execute()).map(res => res.id);
+            } else {
+                return (await query
+                    .select('wpPosts.ID as id')
+                    .execute()).map(res => res.id);
+            }
+        } catch (error: any) {
+            throw new Error(`WPPostQuery: Cannot get posts: ${error.message}`, { cause: error });
+        }
+    }
+}