nextpress-core 1.0.0

package/lib/repository/termquery/term-query-args.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Defines the arguments for querying terms.
+ * Maps standard WordPress WP_Term_Query parameters.
+ */
+interface TermQueryArgs {
+    /** Taxonomy name, or array of taxonomy names, to which results should be limited. */
+    taxonomy?: string | string[];
+    /** Taxonomy ID, or array of term taxonomy IDs, to match when querying terms. */
+    taxonomyId?: number | number[];
+    /** TermId or array of term IDs to include along with all of their descendant terms. */
+    termId?: number | number[];
+    /** TermId or array of term IDs to exclude along with all of their descendant terms. */
+    termIdNot?: number | number[];
+    /** Slug or array of slugs to return term(s) for. Default empty. */
+    termSlug?: string | string[];
+    /** Slug or array of slugs to return term(s) for. Default empty. */
+    termSlugNot?: string | string[];
+    /** Name or array of names to return term(s) for. Default empty. */
+    termName?: string | string[];
+    /** Nextpress path to the term */
+    path?: string;
+    /** Whether to hide terms not assigned to any posts. Default true. */
+    hideEmpty?: boolean;
+    /** Field(s) to order terms by. Default 'none'. */
+    orderBy?:
+        | 'term_id'
+        | 'name'
+        | 'slug'
+        | 'term_group'
+        | 'description'
+        | 'parent'
+        | 'term_order'
+        | 'count'
+        | 'none'
+        | string;
+    /** Whether to order terms in ascending or descending order. Default 'ASC'. */
+    order?: 'ASC' | 'DESC';
+    /** Maximum number of terms to return. Accepts 0 (all) or any positive number. Default 0 (all). */
+    number?: number;
+    /** The number by which to offset the terms query. Default empty. */
+    offset?: number;
+    /** Parent term ID to retrieve direct-child terms of. Default empty. */
+    parent?: number;
+    /** True to limit results to terms that have no children. This parameter has no effect on non-hierarchical taxonomies. Default false. */
+    childless?: boolean;
+    /** Search criteria to match terms. Will be SQL-formatted with wildcards before and after. Default empty. */
+    search?: string;
+    /** Retrieve terms with criteria by which a term is LIKE `$nameLike`. Default empty. */
+    nameLike?: string;
+    /** Retrieve terms where the description is LIKE `$descriptionLike`. Default empty. */
+    descriptionLike?: string;
+    /** 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/termquery/term-query.ts

@@ -0,0 +1,243 @@
+import { QueryCreator } from "kysely";
+import { DB } from "../../wpdb/wpdb.interface";
+import { EntityQuery } from "../../globals/entity-loader/entity-loader";
+import { ITerm } from "../../entities/term/term.interface";
+import { wpdb } from "@/wpdb/wpdb";
+
+/**
+ * Executes database queries to retrieve term IDs based on provided arguments.
+ */
+export class TermQuery implements EntityQuery<ITerm>
+{
+    public constructor(
+        private args: TermQueryArgs
+    ) {}
+
+    public getCount() {
+        return undefined;
+    }
+
+    public async getIds(): Promise<number[]> {
+        let builder = wpdb as QueryCreator<any>;
+
+        const isMultiple = this.args.multiple !== false;
+
+        // -- Build CTEs --
+        if (this.args.termId) {
+            const termIds = Array.isArray(this.args.termId) ? this.args.termId : [this.args.termId];
+            const baseQuery = (qb: any) => qb.selectFrom('wpTermTaxonomy')
+                .select(['termId', 'parent'])
+                .where((eb: any) => eb.or([
+                    eb('termId', 'in', termIds),
+                    eb('parent', 'in', termIds)
+                ]));
+
+            if (isMultiple) {
+                builder = builder.withRecursive('included_branch_id', (qb) =>
+                    baseQuery(qb).unionAll(
+                        qb.selectFrom('wpTermTaxonomy as t')
+                        .select(['t.termId', 't.parent'])
+                        .innerJoin('included_branch_id as f', 'f.termId', 't.parent')
+                    )
+                );
+            } else {
+                builder = builder.with('included_branch_id', baseQuery);
+            }
+        }
+
+        if (this.args.termIdNot) {
+            const termIds = Array.isArray(this.args.termIdNot) ? this.args.termIdNot : [this.args.termIdNot];
+            const baseQuery = (qb: any) => qb.selectFrom('wpTermTaxonomy')
+                .select(['termId', 'parent'])
+                .where((eb: any) => eb.or([
+                    eb('termId', 'in', termIds),
+                    eb('parent', 'in', termIds)
+                ]));
+
+            if (isMultiple) {
+                builder = builder.withRecursive('excluded_branch_id', (qb) =>
+                    baseQuery(qb).unionAll(
+                        qb.selectFrom('wpTermTaxonomy as t')
+                        .select(['t.termId', 't.parent'])
+                        .innerJoin('excluded_branch_id as f', 'f.termId', 't.parent')
+                    )
+                );
+            } else {
+                builder = builder.with('excluded_branch_id', baseQuery);
+            }
+        }
+
+        if (this.args.termName) {
+            const names = Array.isArray(this.args.termName) ? this.args.termName : [this.args.termName];
+            const baseQuery = (qb: any) => qb.selectFrom('wpTermTaxonomy')
+                .innerJoin('wpTerms', 'wpTerms.termId', 'wpTermTaxonomy.termId')
+                .select(['wpTermTaxonomy.termId', 'wpTermTaxonomy.parent'])
+                .where('wpTerms.name', 'in', names);
+
+            if (isMultiple) {
+                builder = builder.withRecursive('included_branch_name', (qb) =>
+                    baseQuery(qb).unionAll(
+                        qb.selectFrom('wpTermTaxonomy as t')
+                        .select(['t.termId', 't.parent'])
+                        .innerJoin('included_branch_name as f', 'f.termId', 't.parent')
+                    )
+                );
+            } else {
+                builder = builder.with('included_branch_name', baseQuery);
+            }
+        }
+
+        if (this.args.termSlug) {
+            const slugs = Array.isArray(this.args.termSlug) ? this.args.termSlug : [this.args.termSlug];
+            const baseQuery = (qb: any) => qb.selectFrom('wpTermTaxonomy')
+                .innerJoin('wpTerms', 'wpTerms.termId', 'wpTermTaxonomy.termId')
+                .select(['wpTermTaxonomy.termId', 'wpTermTaxonomy.parent'])
+                .where('wpTerms.slug', 'in', slugs);
+
+            if (isMultiple) {
+                builder = builder.withRecursive('included_branch_slug', (qb) =>
+                    baseQuery(qb).unionAll(
+                        qb.selectFrom('wpTermTaxonomy as t')
+                        .select(['t.termId', 't.parent'])
+                        .innerJoin('included_branch_slug as f', 'f.termId', 't.parent')
+                    )
+                );
+            } else {
+                builder = builder.with('included_branch_slug', baseQuery);
+            }
+        }
+
+        if (this.args.termSlugNot) {
+            const slugs = Array.isArray(this.args.termSlugNot) ? this.args.termSlugNot : [this.args.termSlugNot];
+            const baseQuery = (qb: any) => qb.selectFrom('wpTermTaxonomy')
+                .innerJoin('wpTerms', 'wpTerms.termId', 'wpTermTaxonomy.termId')
+                .select(['wpTermTaxonomy.termId', 'wpTermTaxonomy.parent'])
+                .where('wpTerms.slug', 'in', slugs);
+
+            if (isMultiple) {
+                builder = builder.withRecursive('excluded_branch_slug', (qb) =>
+                    baseQuery(qb).unionAll(
+                        qb.selectFrom('wpTermTaxonomy as t')
+                        .select(['t.termId', 't.parent'])
+                        .innerJoin('excluded_branch_slug as f', 'f.termId', 't.parent')
+                    )
+                );
+            } else {
+                builder = builder.with('excluded_branch_slug', baseQuery);
+            }
+        }
+
+        // -- Begin Main SELECT Statement --
+        let query = (builder as QueryCreator<DB>).selectFrom('wpTerms')
+            .innerJoin('wpTermTaxonomy', 'wpTerms.termId', 'wpTermTaxonomy.termId');
+
+        // -- Apply Filters (WHERE clauses) --
+        if (this.args.taxonomy) {
+            const taxonomies = Array.isArray(this.args.taxonomy) ? this.args.taxonomy : [this.args.taxonomy];
+            query = query.where('wpTermTaxonomy.taxonomy', 'in', taxonomies);
+        }
+        if (this.args.taxonomyId) {
+            const ids = Array.isArray(this.args.taxonomyId) ? this.args.taxonomyId : [this.args.taxonomyId];
+            query = query.where('wpTermTaxonomy.termTaxonomyId', 'in', ids);
+        }
+
+        if (this.args.termId)       query = query.where('wpTerms.termId', 'in', (qb: any) => qb.selectFrom('included_branch_id').select('termId'));
+        if (this.args.termIdNot)    query = query.where('wpTerms.termId', 'not in', (qb: any) => qb.selectFrom('excluded_branch_id').select('termId'));
+        if (this.args.termName)     query = query.where('wpTerms.termId', 'in', (qb: any) => qb.selectFrom('included_branch_name').select('termId'));
+        if (this.args.termSlug)     query = query.where('wpTerms.termId', 'in', (qb: any) => qb.selectFrom('included_branch_slug').select('termId'));
+        if (this.args.termSlugNot)  query = query.where('wpTerms.termId', 'not in', (qb: any) => qb.selectFrom('excluded_branch_slug').select('termId'));
+        if (this.args.hideEmpty !== false) query = query.where('wpTermTaxonomy.count', '>', 0);
+
+        if (this.args.parent !== undefined) {
+            query = query.where('wpTermTaxonomy.parent', '=', this.args.parent);
+        }
+        if (this.args.childless) {
+            query = query.where('wpTerms.termId', 'not in', (qb) =>
+                qb.selectFrom('wpTermTaxonomy').select('wpTermTaxonomy.parent').where('wpTermTaxonomy.parent', '>', 0)
+            );
+        }
+
+        if (this.args.search) {
+            const searchStr = `%${this.args.search}%`;
+            query = query.where((eb) => eb.or([
+                eb('wpTerms.name', 'like', searchStr),
+                eb('wpTerms.slug', 'like', searchStr)
+            ]));
+        }
+        if (this.args.nameLike) {
+            query = query.where('wpTerms.name', 'like', this.args.nameLike);
+        }
+        if (this.args.descriptionLike) {
+            query = query.where('wpTermTaxonomy.description', 'like', this.args.descriptionLike);
+        }
+
+        if (this.args.path) {
+            query = query.where((eb) => eb.exists(
+                eb.selectFrom('wpTermmeta')
+                    .select('wpTerms.termId')
+                    .whereRef('wpTermmeta.termId', '=', 'wpTerms.termId')
+                    .where('wpTermmeta.metaKey', '=', '_nextpress_path')
+                    .where('wpTermmeta.metaValue', '=', this.args.path as string)
+            ));
+        }
+
+        // -- Apply ORDER BY --
+        const orderDirection = this.args.order === 'DESC' ? 'desc' : 'asc';
+        const orderBy = this.args.orderBy || 'none';
+
+        switch(orderBy) {
+            case 'none': break;
+            case 'term_id':     query = query.orderBy('wpTerms.termId', orderDirection); break;
+            case 'name':        query = query.orderBy('wpTerms.name', orderDirection).orderBy('wpTerms.termId', orderDirection); break;
+            case 'slug':        query = query.orderBy('wpTerms.slug', orderDirection).orderBy('wpTerms.termId', orderDirection); break;
+            case 'term_group':  query = query.orderBy('wpTerms.termGroup', orderDirection).orderBy('wpTerms.termId', orderDirection); break;
+            case 'description': query = query.orderBy('wpTermTaxonomy.description', orderDirection).orderBy('wpTerms.termId', orderDirection); break;
+            case 'parent':      query = query.orderBy('wpTermTaxonomy.parent', orderDirection).orderBy('wpTerms.termId', orderDirection); break;
+            case 'count':       query = query.orderBy('wpTermTaxonomy.count', orderDirection).orderBy('wpTerms.termId', orderDirection); break;
+            default:            query = query.orderBy('wpTerms.name', orderDirection).orderBy('wpTerms.termId', orderDirection); break;
+        }
+
+        // -- Apply LIMIT & OFFSET --
+        const limit = this.args.number ?? 0;
+        if (limit > 0) {
+            query = query.limit(limit);
+        }
+
+        const offsetAmount = this.args.offset ?? 0;
+        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(`wpTermmeta as ${uniqueAlias}`, (join: any) =>
+                    join
+                        .onRef(`${uniqueAlias}.termId`, '=', 'wpTerms.termId')
+                        .on(`${uniqueAlias}.metaKey`, '=', metaQuery.metaKey)
+                    )
+                    .select(`${uniqueAlias}.metaValue as ${metaQuery.as}`);
+            }
+
+            query = dynamicQuery;
+        }
+
+        try {
+            if (isMultiple) {
+                return (await query
+                    .select('wpTerms.termId')
+                    .groupBy('wpTerms.termId')
+                    .execute()).map((res: any) => res.termId);
+            } else {
+                return (await query
+                    .select('wpTerms.termId')
+                    .execute()).map((res: any) => res.termId);
+            }
+        } catch (error: any) {
+            throw new Error(`WPTermQuery: Cannot get terms: ${error.message}`, { cause: error });
+        }
+    }
+}

package/lib/repository/userquery/user-query-args.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Defines the arguments for querying users.
+ * Maps standard WordPress WP_User_Query parameters.
+ */
+interface UserQueryArgs {
+    /** User ID, or array of user IDs, to match when querying terms. */
+    userId?: number | number[];
+    /** An array of user IDs to exclude. Default empty array. */
+    userIdsNotIn?: number[];
+    /** The user nicename. Default empty. */
+    nicename?: string;
+    /** An array of nicenames to include. Default empty array. */
+    nicenameIn?: string[];
+    /** An array of nicenames to exclude. Default empty array. */
+    nicenameNotIn?: string[];
+    /** The user display name. Default empty. */
+    displayName?: string;
+    /** An array of display names to include. Default empty array. */
+    displayNameIn?: string[];
+    /** An array of display names to exclude. Default empty array. */
+    displayNameNotIn?: string[];
+    /** The user login. Default empty. */
+    login?: string;
+    /** An array of logins to include. Default empty array. */
+    loginIn?: string[];
+    /** An array of logins to exclude. Default empty array. */
+    loginNotIn?: string[];
+    /** An array of role names. Matched users must have at least one of these roles. Default empty array. */
+    roleIn?: string[];
+    /** An array of role names that users must match to be included in results. Note that this is an inclusive list: users must match *each* role. Default empty. */
+    roleAnd?: string[];
+    /** An array of role names to exclude. Users matching one or more of these roles will not be included in results. Default empty array. */
+    roleNotIn?: string[];
+    /** Search keyword. Searches for possible string matches on columns. */
+    search?: string;
+    /** Array of column names to be searched. */
+    search_columns?: ('ID' | 'userLogin' | 'userEmail' | 'userUrl' | 'userNicename' | 'displayName')[]
+    /** Field(s) to order terms by. Default 'none'. */
+    orderBy?:
+        | 'ID'
+        | 'name'
+        | 'login'
+        | 'nicename'
+        | 'first_name'
+        | 'last_name'
+        | 'email'
+        | 'registered'
+        | 'post_count'
+        | 'count'
+        | 'none'
+        | string;
+    /** Designates ascending or descending order of users. Accepts 'ASC', 'DESC'. Default 'ASC'. */
+    order?: 'ASC' | 'DESC';
+    /** Number of users to offset in retrieved results. Can be used in conjunction with pagination. Default 0. */
+    offset?: number;
+    /** Number of users to limit the query for. Value -1 (all) is supported. Default -1. */
+    usersPerPage?: number;
+    /** Show users that would show up on page. */
+    page?: number;
+    /** Show all posts (true) or paginate (false). Default false. */
+    noPaging?: boolean;
+    /** Whether to skip counting the total rows found. Default false. */
+    noFoundRows?: boolean;
+    /** Pass an array of post types to filter results to users who have published posts in those post types. `true` is an alias for all public post types. */
+    hasPublishedPosts?: boolean | string[];
+    /** Meta query  */
+    metaQuery?: {
+        /** Meta key */
+        metaKey: string,
+        /** Variable name to save result to */
+        as: string
+    }[]
+    /** Whether to get multiple, default false */
+    multiple?: bool
+}

package/lib/repository/userquery/user-query.ts

@@ -0,0 +1,195 @@
+import { wpdb } from "@/wpdb/wpdb";
+import { IUser } from "../../entities/user/user.interface";
+import { EntityQuery } from "../../globals/entity-loader/entity-loader";
+import { sql } from "kysely";
+
+/**
+ * Executes database queries to retrieve user IDs and counts based on provided arguments.
+ */
+export class UserQuery implements EntityQuery<IUser>
+{
+    private userCount?: number;
+
+    constructor(
+        private args: UserQueryArgs
+    ) {}
+
+    public getCount(): number | undefined {
+        return this.userCount;
+    }
+
+    public async getIds(): Promise<number[]> {
+        let query = wpdb.selectFrom('wpUsers');
+
+        // --- ID Filters ---
+        if (this.args.userId) {
+            const types = Array.isArray(this.args.userId) ? this.args.userId : [this.args.userId];
+            query = query.where('wpUsers.ID', 'in', types);
+        }
+        if (this.args.userIdsNotIn) query = query.where('wpUsers.ID', 'not in', this.args.userIdsNotIn);
+
+        // --- Nicename Filters ---
+        if (this.args.nicename)         query = query.where('wpUsers.userNicename', '=', this.args.nicename);
+        if (this.args.nicenameIn)       query = query.where('wpUsers.userNicename', 'in', this.args.nicenameIn);
+        if (this.args.nicenameNotIn)    query = query.where('wpUsers.userNicename', 'not in', this.args.nicenameNotIn);
+
+        // --- Display name Filters ---
+        if (this.args.displayName)      query = query.where('wpUsers.displayName', '=', this.args.displayName);
+        if (this.args.displayNameIn)    query = query.where('wpUsers.displayName', 'in', this.args.displayNameIn);
+        if (this.args.displayNameNotIn) query = query.where('wpUsers.displayName', 'not in', this.args.displayNameNotIn);
+
+        // --- Login Filters ---
+        if (this.args.login)        query = query.where('wpUsers.userLogin', '=', this.args.login);
+        if (this.args.loginIn)      query = query.where('wpUsers.userLogin', 'in', this.args.loginIn);
+        if (this.args.loginNotIn)   query = query.where('wpUsers.userLogin', 'not in', this.args.loginNotIn);
+
+        // --- Role Filters ---
+        if (this.args.roleIn) {
+            query = query
+                .innerJoin('wpUsermeta as um_role_in', 'wpUsers.ID', 'um_role_in.userId')
+                .where('um_role_in.metaKey', '=', 'wp_capabilities')
+                .where((eb) => {
+                    const orClauses = this.args.roleIn!.map(role =>
+                        eb('um_role_in.metaValue', 'like', `%"${role}"%`)
+                    );
+                    return eb.or(orClauses);
+                });
+        }
+
+        if (this.args.roleAnd) {
+            this.args.roleAnd.forEach((role, index) => {
+                const alias = `um_role_and_${index}` as const;
+
+                query = query
+                    .innerJoin(`wpUsermeta as ${alias}`, 'wpUsers.ID', `${alias}.userId`)
+                    .where(`${alias}.metaKey`, '=', 'wp_capabilities')
+                    .where(`${alias}.metaValue`, 'like', `%"${role}"%`);
+            });
+        }
+
+        if (this.args.roleNotIn) {
+            this.args.roleNotIn.forEach((role, index) => {
+                const alias = `um_role_not_${index}` as const;
+
+                query = query
+                    .innerJoin(`wpUsermeta as ${alias}`, 'wpUsers.ID', `${alias}.userId`)
+                    .where(`${alias}.metaKey`, '=', 'wp_capabilities')
+                    .where(`${alias}.metaValue`, 'not like', `%"${role}"%`);
+            });
+        }
+
+        // --- Search Filters ---
+        if (this.args.search) {
+            const searchTerm = `%${this.args.search}%`;
+            const searchCols = this.args.search_columns || ['ID', 'userLogin', 'userEmail', 'userUrl', 'userNicename', 'displayName'];
+
+            query = query.where((eb) => {
+                const orClauses = searchCols.map(col => eb(col, 'like', searchTerm));
+                return eb.or(orClauses);
+            });
+        }
+
+        // --- Published Posts Filter ---
+        if (this.args.hasPublishedPosts) {
+            query = query.where((eb) => eb(
+                eb.selectFrom('wpPosts')
+                    .select(eb.fn.count<number>('ID').as('count'))
+                    .whereRef('wpPosts.postAuthor', '=', 'wpUsers.ID')
+                    .where('wpPosts.postStatus', '=', 'publish'),
+                '>', 0
+            ));
+        }
+
+        // 3. Calculate Total Count (Before Limits/Offsets)
+        if (!this.args.noFoundRows) {
+            try {
+                const countQueryBase = query.clearSelect().select('wpUsers.ID').distinct();
+                const countResult = await wpdb.selectFrom(countQueryBase.as('sub'))
+                    .select(sql<number>`count(*)`.as('count'))
+                    .executeTakeFirst();
+
+                this.userCount = countResult ? Number(countResult.count) : undefined;
+            } catch (error: any) {
+                console.error('WPUserQuery: Cannot get row count: ', error.message);
+                this.userCount = undefined;
+            }
+        } else {
+            this.userCount = undefined;
+        }
+
+        // 4. Apply ORDER BY
+        const orderDirection = this.args.order === 'DESC' ? 'desc' : 'asc';
+        const orderBy = this.args.orderBy || 'none';
+
+        switch(orderBy) {
+            case 'ID':         query = query.orderBy('wpUsers.ID', orderDirection).orderBy('wpUsers.ID', orderDirection); break;
+            case 'name':       query = query.orderBy('wpUsers.displayName', orderDirection).orderBy('wpUsers.ID', orderDirection); break;
+            case 'login':      query = query.orderBy('wpUsers.userLogin', orderDirection).orderBy('wpUsers.ID', orderDirection); break;
+            case 'nicename':   query = query.orderBy('wpUsers.userNicename', orderDirection).orderBy('wpUsers.ID', orderDirection); break;
+            case 'email':      query = query.orderBy('wpUsers.userEmail', orderDirection).orderBy('wpUsers.ID', orderDirection); break;
+            case 'registered': query = query.orderBy('wpUsers.userRegistered', orderDirection).orderBy('wpUsers.ID', orderDirection); break;
+            case 'post_count':
+                query = query.orderBy(
+                    (eb) => eb.selectFrom('wpPosts')
+                            .select(eb.fn.count('ID').as('count'))
+                            .whereRef('wpPosts.postAuthor', '=', 'wpUsers.ID')
+                            .where('wpPosts.postStatus', '=', 'publish'),
+                    orderDirection
+                ).orderBy('wpUsers.ID', orderDirection);
+                break;
+            case 'none': break;
+            default:
+                query = query.orderBy('wpUsers.userLogin', orderDirection).orderBy('wpUsers.ID', orderDirection);
+                break;
+        }
+
+        // 5. Apply LIMIT & OFFSET
+        if (!this.args.noPaging) {
+            const perPage = this.args.usersPerPage ?? -1;
+
+            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(`wpUsermeta as ${uniqueAlias}`, (join: any) =>
+                    join
+                        .onRef(`${uniqueAlias}.userId`, '=', 'wpUsers.ID')
+                        .on(`${uniqueAlias}.metaKey`, '=', metaQuery.metaKey)
+                    )
+                    .select(`${uniqueAlias}.metaValue as ${metaQuery.as}`);
+            }
+
+            query = dynamicQuery;
+        }
+
+        try {
+            if (this.args.multiple !== false) {
+                return (await query
+                    .select('wpUsers.ID as id')
+                    .groupBy('wpUsers.ID')
+                    .execute()).map(res => res.id);
+            } else {
+                return (await query
+                    .select('wpUsers.ID as id')
+                    .execute()).map(res => res.id);
+            }
+        } catch (error: any) {
+            throw new Error(`WPUserQuery: Cannot get users: ${error.message}`, { cause: error });
+        }
+    }
+}

package/lib/router/helpers.ts

@@ -0,0 +1,20 @@
+/**
+ * Retrieves page number from path array.
+ *
+ * @param {string[]} path - Array of path segments.
+ * @returns {number | undefined} Page number or undefined.
+ */
+export function getPageNumber(path: string[]): number|undefined {
+    return path[path.length - 2] === 'page' ? Number(path[path.length - 1]) || undefined : undefined;
+}
+
+/**
+ * Splits path string into array of segments.
+ *
+ * @param {string} path - Path string.
+ * @returns {string[]} Array of path segments.
+ */
+export function splitPath(path: string): string[] {
+    if (!path) return [];
+    return path.split('/').filter(Boolean);
+}

package/lib/router/nextpress-layout.tsx

@@ -0,0 +1,48 @@
+import fonts from "@/fonts";
+import { LayoutTemplate } from "@/app/_templates/layout";
+import { cookies, draftMode } from "next/headers";
+import { getLanguageAttributes } from "@/services/metadata/get-language-attribute";
+import { RenderTheAdminBar } from "@/ui/render-the-admin-bar";
+
+const fontClasses = fonts.map(font => font.className).join(' ');
+
+/**
+ * The layout for the application.
+ * Defines the main HTML shell, handles Draft Mode validation, primes necessary global WordPress options,
+ * and routes directly to the `LayoutTemplate` within the Nextpress template hierarchy.
+ *
+ * @param {Readonly<{children: React.ReactNode;}>} props - Component properties, wrapping the children pages.
+ * @returns {Promise<JSX.Element>} The root layout of the entire app.
+ */
+export async function NextpressLayout({ children }: Readonly<{children: React.ReactNode;}>) {
+    const draftModeEnabled = (await draftMode()).isEnabled;
+    let loggedInUserId = 0;
+    if (draftModeEnabled) {
+        const cookieStore = await cookies();
+        loggedInUserId = Number(cookieStore.get('nextpress_logged_in_user_id')?.value) || 0;
+    }
+
+    optionLoader.findAndPrime({
+        column: 'optionName',
+        operand: 'in',
+        value: nextpressConfig.preLoadOptions || ''
+    })
+
+    const languageAttributes = await getLanguageAttributes();
+
+    return (
+        <html
+            lang={languageAttributes}
+            className={fontClasses}
+        >
+            <body className="">
+                {(draftModeEnabled && (await getUser(loggedInUserId))?.showAdminBar) && <RenderTheAdminBar loggedInUserId={loggedInUserId}/>}
+                <LayoutTemplate>
+                    {children}
+                </LayoutTemplate>
+            </body>
+        </html>
+    );
+}
+
+