nextpress-core 1.0.3 → 2.0.0

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

@@ -0,0 +1,244 @@
+import { QueryCreator } from "kysely";
+import { EntityQuery } from "../../globals/entity-loader/entity-loader";
+import { ITerm } from "../../entities/term/term.interface";
+import { TermQueryArgs } from "./term-query-args";
+import { DB } from "nextpress/wpdb/wpdb.interface";
+import { wpdb } from "nextpress/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/{dist/repository/userquery/user-query-args.d.ts → lib/repository/userquery/user-query-args.ts}

@@ -2,7 +2,7 @@
  * Defines the arguments for querying users.
  * Maps standard WordPress WP_User_Query parameters.
  */
-interface UserQueryArgs {
+export 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. */
@@ -34,9 +34,21 @@ interface UserQueryArgs {
     /** 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')[];
+    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;
+    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. */
@@ -54,10 +66,10 @@ interface UserQueryArgs {
     /** Meta query  */
     metaQuery?: {
         /** Meta key */
-        metaKey: string;
+        metaKey: string,
         /** Variable name to save result to */
-        as: string;
-    }[];
+        as: string
+    }[]
     /** Whether to get multiple, default false */
-    multiple?: boolean;
+    multiple?: boolean
 }

package/{dist/repository/userquery/user-query.js → lib/repository/userquery/user-query.ts}

@@ -1,178 +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";
+import { UserQueryArgs } from "./user-query-args";
+import { wpdb } from "nextpress/wpdb/wpdb";
+
 /**
  * Executes database queries to retrieve user IDs and counts based on provided arguments.
  */
-export class UserQuery {
-    constructor(args) {
-        this.args = args;
-    }
-    getCount() {
+export class UserQuery implements EntityQuery<IUser>
+{
+    private userCount?: number;
+
+    constructor(
+        private args: UserQueryArgs
+    ) {}
+
+    public getCount(): number | undefined {
         return this.userCount;
     }
-    async getIds() {
-        var _a, _b, _c;
+
+    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);
+        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);
+        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);
+        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);
+        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);
-            });
+                    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}`;
+                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}`;
+                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('ID').as('count'))
-                .whereRef('wpPosts.postAuthor', '=', 'wpUsers.ID')
-                .where('wpPosts.postStatus', '=', 'publish'), '>', 0));
+            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 `count(*)`.as('count'))
+                    .select(sql<number>`count(*)`.as('count'))
                     .executeTakeFirst();
+
                 this.userCount = countResult ? Number(countResult.count) : undefined;
-            }
-            catch (error) {
+            } catch (error: any) {
                 console.error('WPUserQuery: Cannot get row count: ', error.message);
                 this.userCount = undefined;
             }
-        }
-        else {
+        } 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;
+
+        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);
+                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 = (_a = this.args.usersPerPage) !== null && _a !== void 0 ? _a : -1;
+            const perPage = this.args.usersPerPage ?? -1;
+
             if (perPage > -1) {
                 query = query.limit(perPage);
-                const page = (_b = this.args.page) !== null && _b !== void 0 ? _b : 1;
-                const baseOffset = (_c = this.args.offset) !== null && _c !== void 0 ? _c : 0;
+
+                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 = query;
+            let dynamicQuery: any = query;
+
             for (let metaQuery of this.args.metaQuery) {
                 const uniqueAlias = `meta_${metaQuery.as}`;
-                dynamicQuery = dynamicQuery.leftJoin(`wpUsermeta as ${uniqueAlias}`, (join) => join
-                    .onRef(`${uniqueAlias}.userId`, '=', 'wpUsers.ID')
-                    .on(`${uniqueAlias}.metaKey`, '=', metaQuery.metaKey))
+
+                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 {
+            } else {
                 return (await query
                     .select('wpUsers.ID as id')
                     .execute()).map(res => res.id);
             }
-        }
-        catch (error) {
+        } catch (error: any) {
             throw new Error(`WPUserQuery: Cannot get users: ${error.message}`, { cause: error });
         }
     }

package/{dist/router/helpers.js → lib/router/helpers.ts}

@@ -4,17 +4,17 @@
  * @param {string[]} path - Array of path segments.
  * @returns {number | undefined} Page number or undefined.
  */
-export function getPageNumber(path) {
+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) {
-    if (!path)
-        return [];
+export function splitPath(path: string): string[] {
+    if (!path) return [];
     return path.split('/').filter(Boolean);
 }

package/{dist/router/nextpress-layout.js → lib/router/nextpress-layout.tsx}

@@ -1,10 +1,13 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import fonts from "@/fonts";
+import "nextpress/globals/globals";
+import "@/app/_css/globals.css";
 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";
+import fonts from "@/fonts";
+import { getLanguageAttributes } from "nextpress/services/metadata/get-language-attribute";
+import { RenderTheAdminBar } from "nextpress/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,
@@ -13,19 +16,35 @@ const fontClasses = fonts.map(font => font.className).join(' ');
  * @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 }) {
-    var _a, _b;
+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((_a = cookieStore.get('nextpress_logged_in_user_id')) === null || _a === void 0 ? void 0 : _a.value) || 0;
+        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 (_jsx("html", { lang: languageAttributes, className: fontClasses, children: _jsxs("body", { className: "", children: [(draftModeEnabled && ((_b = (await getUser(loggedInUserId))) === null || _b === void 0 ? void 0 : _b.showAdminBar)) && _jsx(RenderTheAdminBar, { loggedInUserId: loggedInUserId }), _jsx(LayoutTemplate, { children: children })] }) }));
+
+    return (
+        <html
+            lang={languageAttributes}
+            className={fontClasses}
+        >
+            <body className="">
+                {(draftModeEnabled && (await getUser(loggedInUserId))?.showAdminBar) && <RenderTheAdminBar loggedInUserId={loggedInUserId}/>}
+                <LayoutTemplate>
+                    {children}
+                </LayoutTemplate>
+            </body>
+        </html>
+    );
 }
+
+