nextpress-core 1.0.0 → 1.0.1

package/dist/repository/postquery/post-query.js

@@ -0,0 +1,272 @@
+import { sql } from "kysely";
+import * as phpSerialize from "php-serialize";
+import { wpdb } from "@/wpdb/wpdb";
+/**
+ * Executes database queries to retrieve post IDs and counts based on provided arguments.
+ */
+export class PostQuery {
+    constructor(args) {
+        this.args = args;
+    }
+    getCount() {
+        return this.postCount;
+    }
+    async getIds() {
+        var _a, _b, _c;
+        let builder = wpdb;
+        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.selectFrom('wpPosts');
+        if (this.args.postAncestryOf) {
+            query = query.where('wpPosts.postName', 'in', (qb) => 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)));
+        }
+        // --- 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 `count(*)`.as('count'))
+                    .executeTakeFirst();
+                this.postCount = countResult ? Number(countResult.count) : undefined;
+            }
+            catch (error) {
+                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 = [];
+            try {
+                const parsed = phpSerialize.unserialize(rawStickyPostIds !== null && rawStickyPostIds !== void 0 ? rawStickyPostIds : 'a:0:{}');
+                stickyPosts = Object.values(parsed);
+            }
+            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 = (_a = this.args.postsPerPage) !== null && _a !== void 0 ? _a : 10;
+            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 offsetAmount = ((page - 1) * perPage) + baseOffset;
+                if (offsetAmount > 0) {
+                    query = query.offset(offsetAmount);
+                }
+            }
+        }
+        if (this.args.metaQuery) {
+            let dynamicQuery = query;
+            for (let metaQuery of this.args.metaQuery) {
+                const uniqueAlias = `meta_${metaQuery.as}`;
+                dynamicQuery = dynamicQuery.leftJoin(`wpPostmeta as ${uniqueAlias}`, (join) => 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) {
+            throw new Error(`WPPostQuery: Cannot get posts: ${error.message}`, { cause: error });
+        }
+    }
+}

package/dist/repository/termquery/term-query.d.ts

@@ -0,0 +1,11 @@
+import { EntityQuery } from "../../globals/entity-loader/entity-loader";
+import { ITerm } from "../../entities/term/term.interface";
+/**
+ * Executes database queries to retrieve term IDs based on provided arguments.
+ */
+export declare class TermQuery implements EntityQuery<ITerm> {
+    private args;
+    constructor(args: TermQueryArgs);
+    getCount(): undefined;
+    getIds(): Promise<number[]>;
+}

package/dist/repository/termquery/term-query.js

@@ -0,0 +1,213 @@
+import { wpdb } from "@/wpdb/wpdb";
+/**
+ * Executes database queries to retrieve term IDs based on provided arguments.
+ */
+export class TermQuery {
+    constructor(args) {
+        this.args = args;
+    }
+    getCount() {
+        return undefined;
+    }
+    async getIds() {
+        var _a, _b;
+        let builder = wpdb;
+        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) => qb.selectFrom('wpTermTaxonomy')
+                .select(['termId', 'parent'])
+                .where((eb) => 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) => qb.selectFrom('wpTermTaxonomy')
+                .select(['termId', 'parent'])
+                .where((eb) => 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) => 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) => 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) => 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.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) => qb.selectFrom('included_branch_id').select('termId'));
+        if (this.args.termIdNot)
+            query = query.where('wpTerms.termId', 'not in', (qb) => qb.selectFrom('excluded_branch_id').select('termId'));
+        if (this.args.termName)
+            query = query.where('wpTerms.termId', 'in', (qb) => qb.selectFrom('included_branch_name').select('termId'));
+        if (this.args.termSlug)
+            query = query.where('wpTerms.termId', 'in', (qb) => qb.selectFrom('included_branch_slug').select('termId'));
+        if (this.args.termSlugNot)
+            query = query.where('wpTerms.termId', 'not in', (qb) => 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)));
+        }
+        // -- 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 = (_a = this.args.number) !== null && _a !== void 0 ? _a : 0;
+        if (limit > 0) {
+            query = query.limit(limit);
+        }
+        const offsetAmount = (_b = this.args.offset) !== null && _b !== void 0 ? _b : 0;
+        if (offsetAmount > 0) {
+            query = query.offset(offsetAmount);
+        }
+        if (this.args.metaQuery) {
+            let dynamicQuery = query;
+            for (let metaQuery of this.args.metaQuery) {
+                const uniqueAlias = `meta_${metaQuery.as}`;
+                dynamicQuery = dynamicQuery.leftJoin(`wpTermmeta as ${uniqueAlias}`, (join) => 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) => res.termId);
+            }
+            else {
+                return (await query
+                    .select('wpTerms.termId')
+                    .execute()).map((res) => res.termId);
+            }
+        }
+        catch (error) {
+            throw new Error(`WPTermQuery: Cannot get terms: ${error.message}`, { cause: error });
+        }
+    }
+}

package/dist/repository/userquery/user-query.d.ts

@@ -0,0 +1,12 @@
+import { IUser } from "../../entities/user/user.interface";
+import { EntityQuery } from "../../globals/entity-loader/entity-loader";
+/**
+ * Executes database queries to retrieve user IDs and counts based on provided arguments.
+ */
+export declare class UserQuery implements EntityQuery<IUser> {
+    private args;
+    private userCount?;
+    constructor(args: UserQueryArgs);
+    getCount(): number | undefined;
+    getIds(): Promise<number[]>;
+}