@rnaga/wp-node 1.1.0

package/query-builder/meta.query.js

@@ -0,0 +1,188 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var MetaQuery_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetaQuery = void 0;
+const component_1 = require("../decorators/component");
+const alias_1 = require("./alias");
+const query_builder_1 = require("./query-builder");
+const query_builders_1 = require("./query-builders");
+let MetaQuery = MetaQuery_1 = class MetaQuery extends query_builder_1.QueryBuilder {
+    alias;
+    builders;
+    builder;
+    table;
+    primaryTable;
+    columns;
+    #valueType = "CHAR";
+    constructor(alias, builders, builder, table, primaryTable, columns) {
+        super(alias, builders, builder, MetaQuery_1);
+        this.alias = alias;
+        this.builders = builders;
+        this.builder = builder;
+        this.table = table;
+        this.primaryTable = primaryTable;
+        this.columns = columns;
+    }
+    setPrimaryTable(table) {
+        this.columns = {
+            primary: "post" === table || "user" === table
+                ? "ID"
+                : "site" === table
+                    ? "id"
+                    : `${table}_id`,
+            meta: `${table}_id`,
+        };
+        this.primaryTable = table == "site" ? "site" : `${table}s`;
+        this.table = `${table}meta`;
+        return this;
+    }
+    get from() {
+        this.builder.from(this.alias.as(this.table));
+        return this;
+    }
+    select(columns) {
+        this.builder.select(columns);
+        return this;
+    }
+    valueType(type) {
+        if (!type.match(/^(?:BINARY|CHAR|DATE|DATETIME|SIGNED|UNSIGNED|TIME|NUMERIC(?:(d+(?:,s?d+)?))?|DECIMAL(?:(d+(?:,s?d+)?))?)$/)) {
+            type = "CHAR";
+        }
+        this.#valueType = "NUMERIC" === type ? "SIGNED" : type;
+        return this;
+    }
+    joinPrimary(type = "inner") {
+        const { as, column } = this.alias;
+        this.builder[`${type}Join`](as(this.primaryTable), column(this.table, this.columns.meta), column(this.primaryTable, this.columns.primary));
+        return this;
+    }
+    withIds(ids, options) {
+        const { joinPrimary = true } = options ?? {};
+        this.builder.clear("join");
+        if (joinPrimary) {
+            this.joinPrimary();
+        }
+        if (options?.not === true) {
+            this.builder.not;
+        }
+        this.builder.whereIn(
+        //this.alias.column(this.primaryTable, this.columns.primary),
+        this.alias.column(this.table, this.columns.meta), ids);
+        return this;
+    }
+    onNotExists(column, value) {
+        return this.onExists(column, value, true);
+    }
+    onExists(column, value, not = false) {
+        this.builder.clear("join");
+        const { column: toColumn, as } = this.alias;
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        this.builder[not ? "leftJoin" : "innerJoin"](as(this.primaryTable), function (qb) {
+            qb.on(toColumn(self.table, self.columns.meta), toColumn(self.primaryTable, self.columns.primary))[not ? "onNotExists" : "onExists"](function () {
+                this.select(toColumn(self.table, self.columns.meta))
+                    .from(as(self.table))
+                    .where(toColumn(self.table, column), value)
+                    .limit(1);
+            });
+        });
+        return this;
+    }
+    castValue(v, as = this.#valueType) {
+        return this.builders.raw(`CAST(? as ${as})`, [v]);
+    }
+    whereKeyLike(value, options) {
+        const { column } = this.alias;
+        if (options?.not === true) {
+            this.builder.not.whereILike(column(this.table, "meta_key"), `%${value}%`);
+        }
+        else {
+            this.builder.whereILike(column(this.table, "meta_key"), `%${value}%`);
+        }
+        return this;
+    }
+    whereKeyNotLike(value) {
+        return this.whereKeyLike(value, { not: true });
+    }
+    whereLike(key, value, options) {
+        const { column } = this.alias;
+        this.builder.andWhere((subBuilder) => {
+            subBuilder.where(column(this.table, "meta_key"), key);
+            if (options?.not === true) {
+                subBuilder.not;
+            }
+            subBuilder.whereILike(column(this.table, "meta_value"), `%${value}%`);
+        });
+        return this;
+    }
+    whereNotLike(key, value) {
+        return this.whereLike(key, value, { not: true });
+    }
+    whereIn(key, obj) {
+        const { column } = this.alias;
+        this.builder.andWhere((subBuilder) => {
+            subBuilder
+                .where(column(this.table, "meta_key"), key)
+                .whereIn(column(this.table, "meta_value"), obj);
+        });
+        return this;
+    }
+    whereBetween(key, range) {
+        const { column } = this.alias;
+        this.builder.andWhere((subBuilder) => {
+            subBuilder
+                .where(column(this.table, "meta_key"), key)
+                .whereBetween(column(this.table, "meta_value"), range);
+        });
+        return this;
+    }
+    withKeys(keys) {
+        const { column } = this.alias;
+        this.builder.andWhere((subBuilder) => {
+            for (const key of keys) {
+                subBuilder.orWhere(column(this.table, "meta_key"), key);
+            }
+        });
+        return this;
+    }
+    where(key, value, op = "=") {
+        const { column } = this.alias;
+        //this.builder.where(toColumn(this.table, column), op, this.castValue(value));
+        this.builder.andWhere((subBuilder) => {
+            subBuilder.where(column(this.table, "meta_key"), key);
+            if (value) {
+                subBuilder.where(column(this.table, "meta_value"), op, value
+                //this.castValue(value)
+                );
+            }
+        });
+        return this;
+    }
+    regex(key, regex) {
+        const { column } = this.alias;
+        const value = this.#valueType === "BINARY"
+            ? this.castValue(regex.source)
+            : `'${regex.source}'`;
+        this.builder.andWhere((subBuilder) => {
+            subBuilder
+                .where(column(this.table, "meta_key"), key)
+                .whereRaw(`?? REGEXP ${value}`, [column(this.table, "meta_value")]);
+        });
+        return this;
+    }
+};
+exports.MetaQuery = MetaQuery;
+exports.MetaQuery = MetaQuery = MetaQuery_1 = __decorate([
+    (0, component_1.queryBuilder)(),
+    __metadata("design:paramtypes", [alias_1.Alias,
+        query_builders_1.QueryBuilders, Object, String, String, Object])
+], MetaQuery);

package/query-builder/options.query.d.ts

@@ -0,0 +1,19 @@
+import { Alias } from "./alias";
+import { QueryBuilder } from "./query-builder";
+import { QueryBuilders } from "./query-builders";
+import type * as types from "../types";
+export declare class OptionsQuery extends QueryBuilder<OptionsQuery> {
+    alias: Alias;
+    protected builders: QueryBuilders;
+    builder: types.QueryBuilder;
+    readonly table = "options";
+    constructor(alias: Alias, builders: QueryBuilders, builder: types.QueryBuilder);
+    get from(): this;
+    get(name: string): this;
+    whereIn(names: string[]): void;
+    whereLike(column: types.Columns<"options">, value: string, options?: {
+        not: boolean;
+    }): this;
+    whereNotLike(column: types.Columns<"options">, value: string): this;
+}
+//# sourceMappingURL=options.query.d.ts.map

package/query-builder/options.query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.query.d.ts","sourceRoot":"","sources":["../../src/query-builder/options.query.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,KAAK,KAAK,MAAM,UAAU,CAAC;AAEvC,qBACa,YAAa,SAAQ,YAAY,CAAC,YAAY,CAAC;IAGjD,KAAK,EAAE,KAAK;IACnB,SAAS,CAAC,QAAQ,EAAE,aAAa;IAC1B,OAAO,EAAE,KAAK,CAAC,YAAY;IAJpC,QAAQ,CAAC,KAAK,aAAa;gBAElB,KAAK,EAAE,KAAK,EACT,QAAQ,EAAE,aAAa,EAC1B,OAAO,EAAE,KAAK,CAAC,YAAY;IAKpC,IAAI,IAAI,SAGP;IAED,GAAG,CAAC,IAAI,EAAE,MAAM;IAKhB,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE;IAIvB,SAAS,CACP,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,EAChC,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE;QAAE,GAAG,EAAE,OAAO,CAAA;KAAE;IAY5B,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,MAAM;CAG7D"}

package/query-builder/options.query.js

@@ -0,0 +1,57 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var OptionsQuery_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptionsQuery = void 0;
+const component_1 = require("../decorators/component");
+const alias_1 = require("./alias");
+const query_builder_1 = require("./query-builder");
+const query_builders_1 = require("./query-builders");
+let OptionsQuery = OptionsQuery_1 = class OptionsQuery extends query_builder_1.QueryBuilder {
+    alias;
+    builders;
+    builder;
+    table = "options";
+    constructor(alias, builders, builder) {
+        super(alias, builders, builder, OptionsQuery_1);
+        this.alias = alias;
+        this.builders = builders;
+        this.builder = builder;
+    }
+    get from() {
+        this.builder.table(this.alias.as("options"));
+        return this;
+    }
+    get(name) {
+        this.builder.where("option_name", name).first();
+        return this;
+    }
+    whereIn(names) {
+        this.builder.whereIn("option_name", names);
+    }
+    whereLike(column, value, options) {
+        const { column: toColumn } = this.alias;
+        if (options?.not === true) {
+            this.builder.not;
+        }
+        this.builder.whereILike(toColumn("options", column), `%${value}%`);
+        return this;
+    }
+    whereNotLike(column, value) {
+        return this.whereLike(column, value, { not: true });
+    }
+};
+exports.OptionsQuery = OptionsQuery;
+exports.OptionsQuery = OptionsQuery = OptionsQuery_1 = __decorate([
+    (0, component_1.queryBuilder)(),
+    __metadata("design:paramtypes", [alias_1.Alias,
+        query_builders_1.QueryBuilders, Object])
+], OptionsQuery);

package/query-builder/posts.query.d.ts

@@ -0,0 +1,30 @@
+import { Alias } from "./alias";
+import { QueryBuilder } from "./query-builder";
+import { QueryBuilders } from "./query-builders";
+import { TermsQuery } from "./terms.query";
+import type * as types from "../types";
+export declare class PostsQuery extends QueryBuilder<PostsQuery> {
+    alias: Alias<"cte_p" | "p" | "p2" | "cte_c" | "c" | "c2">;
+    protected builders: QueryBuilders;
+    builder: types.QueryBuilder;
+    readonly table = "posts";
+    constructor(alias: Alias<"cte_p" | "p" | "p2" | "cte_c" | "c" | "c2">, builders: QueryBuilders, builder: types.QueryBuilder);
+    get from(): this;
+    get(id: number): this;
+    withMeta(type?: "inner" | "right"): this;
+    withoutMeta(key: string, value?: string): this;
+    withChildren(id: number): this;
+    withParents(id: number): this;
+    select(columns: Array<types.Columns<"posts"> | types.Columns<"postmeta">>): this;
+    whereIn(column: types.Columns<"posts"> | "meta_key" | "meta_value", values: Array<string | number>): this;
+    where(column: types.Columns<"posts"> | "meta_key" | "meta_value", value: string | number | Array<string | number>, op?: string): this;
+    whereLike(column: types.Columns<"posts">, value: string, options?: {
+        not: boolean;
+    }): this;
+    whereNotLike(column: types.Columns<"posts">, value: string): this;
+    countPublished(postType?: string): this;
+    withTerms(taxonomies: types.TaxonomyName[], fn?: (query: TermsQuery) => void): this;
+    countTerm(termTaxonomyId: number, postStatuses: types.PostStatus[], postTypes: types.PostType[]): this;
+    countAttachment(termTaxonomyId: number, postStatues: types.PostStatus[]): this;
+}
+//# sourceMappingURL=posts.query.d.ts.map

package/query-builder/posts.query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"posts.query.d.ts","sourceRoot":"","sources":["../../src/query-builder/posts.query.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE3C,OAAO,KAAK,KAAK,KAAK,MAAM,UAAU,CAAC;AAGvC,qBACa,UAAW,SAAQ,YAAY,CAAC,UAAU,CAAC;IAG7C,KAAK,EAAE,KAAK,CAAC,OAAO,GAAG,GAAG,GAAG,IAAI,GAAG,OAAO,GAAG,GAAG,GAAG,IAAI,CAAC;IAChE,SAAS,CAAC,QAAQ,EAAE,aAAa;IAC1B,OAAO,EAAE,KAAK,CAAC,YAAY;IAJpC,QAAQ,CAAC,KAAK,WAAW;gBAEhB,KAAK,EAAE,KAAK,CAAC,OAAO,GAAG,GAAG,GAAG,IAAI,GAAG,OAAO,GAAG,GAAG,GAAG,IAAI,CAAC,EACtD,QAAQ,EAAE,aAAa,EAC1B,OAAO,EAAE,KAAK,CAAC,YAAY;IAKpC,IAAI,IAAI,SAGP;IAED,GAAG,CAAC,EAAE,EAAE,MAAM;IAMd,QAAQ,CAAC,IAAI,GAAE,OAAO,GAAG,OAAiB;IAM1C,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM;IAsBvC,YAAY,CAAC,EAAE,EAAE,MAAM;IA0BvB,WAAW,CAAC,EAAE,EAAE,MAAM;IA+BtB,MAAM,CAAC,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;IAKzE,OAAO,CACL,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,UAAU,GAAG,YAAY,EAC1D,MAAM,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC;IAMhC,KAAK,CACH,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,UAAU,GAAG,YAAY,EAC1D,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,EAC/C,EAAE,GAAE,MAAY;IAoBlB,SAAS,CACP,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAC9B,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE;QAAE,GAAG,EAAE,OAAO,CAAA;KAAE;IAY5B,YAAY,CAAC,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,MAAM;IAI1D,cAAc,CAAC,QAAQ,GAAE,MAAe;IAWxC,SAAS,CACP,UAAU,EAAE,KAAK,CAAC,YAAY,EAAE,EAChC,EAAE,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI;IAoBlC,SAAS,CACP,cAAc,EAAE,MAAM,EACtB,YAAY,EAAE,KAAK,CAAC,UAAU,EAAE,EAChC,SAAS,EAAE,KAAK,CAAC,QAAQ,EAAE;IAoB7B,eAAe,CAAC,cAAc,EAAE,MAAM,EAAE,WAAW,EAAE,KAAK,CAAC,UAAU,EAAE;CA2CxE"}

package/query-builder/posts.query.js

@@ -0,0 +1,208 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var PostsQuery_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostsQuery = void 0;
+const component_1 = require("../decorators/component");
+const alias_1 = require("./alias");
+const meta_query_1 = require("./meta.query");
+const query_builder_1 = require("./query-builder");
+const query_builders_1 = require("./query-builders");
+const terms_query_1 = require("./terms.query");
+let PostsQuery = PostsQuery_1 = class PostsQuery extends query_builder_1.QueryBuilder {
+    alias;
+    builders;
+    builder;
+    table = "posts";
+    constructor(alias, builders, builder) {
+        super(alias, builders, builder, PostsQuery_1);
+        this.alias = alias;
+        this.builders = builders;
+        this.builder = builder;
+    }
+    get from() {
+        this.builder.table(this.alias.as("posts"));
+        return this;
+    }
+    get(id) {
+        const { column } = this.alias;
+        this.builder.where(column("posts", "ID"), id).first();
+        return this;
+    }
+    withMeta(type = "right") {
+        const meta = this.builders.get(meta_query_1.MetaQuery, this.builder, this.alias);
+        meta.setPrimaryTable("post").from.joinPrimary(type);
+        return this;
+    }
+    withoutMeta(key, value) {
+        const { column } = this.alias;
+        this.andWhere((query) => {
+            query.builder.where(column("posts", "ID"), "not in", (qb) => {
+                const meta = this.builders.get(meta_query_1.MetaQuery, qb);
+                meta
+                    .setPrimaryTable("post")
+                    .from.joinPrimary("inner")
+                    .select(["post_id"]);
+                if (value)
+                    meta.where(key, value);
+                else
+                    meta.withKeys([key]);
+            });
+        });
+        return this;
+    }
+    withChildren(id) {
+        const { as, column: toColumn, get } = this.alias;
+        this.builder
+            .withRecursive(get("cte_c").table, (qb) => {
+            qb.select(toColumn("posts", "ID", "c"), this.builders.raw("0 as depth"))
+                .from(as("posts", "c"))
+                .where(toColumn("posts", "post_parent", "c"), id)
+                .union((qb) => {
+                qb.select(toColumn("posts", "ID", "c2"), this.builders.raw(`${get("cte_c").key}.depth + 1`))
+                    .from(as("posts", "c2"))
+                    .join(as("cte_c"), toColumn("posts", "post_parent", "c2"), toColumn("cte_c", "ID"));
+            });
+        })
+            .select(toColumn("cte_c", "depth"), toColumn("posts", "*"))
+            .join(as("cte_c"), toColumn("posts", "ID"), toColumn("cte_c", "ID"));
+        return this;
+    }
+    withParents(id) {
+        const { as, column: toColumn, get } = this.alias;
+        this.builder
+            .withRecursive(get("cte_p").table, (qb) => {
+            qb.select(toColumn("posts", "ID", "p"), toColumn("posts", "post_parent", "p"), this.builders.raw("0 as depth"))
+                .from(as("posts", "p"))
+                .where(toColumn("posts", "ID", "p"), id)
+                .where(toColumn("posts", "post_parent", "p"), ">", 0)
+                .union((qb) => {
+                qb.select(toColumn("posts", "ID", "p2"), toColumn("posts", "post_parent", "p2"), this.builders.raw(`${get("cte_p").key}.depth + 1`))
+                    .from(as("posts", "p2"))
+                    .join(as("cte_p"), toColumn("cte_p", "ID"), toColumn("posts", "post_parent", "p2"));
+            });
+        })
+            .select(toColumn("cte_p", "depth"), toColumn("posts", "*"))
+            .join(as("cte_p"), toColumn("posts", "ID"), toColumn("cte_p", "ID"));
+        return this;
+    }
+    select(columns) {
+        this.builder.select(columns);
+        return this;
+    }
+    whereIn(column, values) {
+        this.where(column, values);
+        return this;
+    }
+    where(column, value, op = "=") {
+        const { column: toColumn } = this.alias;
+        if (Array.isArray(value)) {
+            op = "in";
+        }
+        this.builder.where(toColumn((column == "meta_key" || column == "meta_value"
+            ? "postmeta"
+            : "posts"), column), op, value);
+        return this;
+    }
+    whereLike(column, value, options) {
+        const { column: toColumn } = this.alias;
+        if (options?.not === true) {
+            this.builder.not;
+        }
+        this.builder.whereILike(toColumn("posts", column), `%${value}%`);
+        return this;
+    }
+    whereNotLike(column, value) {
+        return this.whereLike(column, value, { not: true });
+    }
+    countPublished(postType = "post") {
+        const { column } = this.alias;
+        this.from.builder
+            .count("* as count")
+            .where(column("posts", "post_status"), "publish")
+            .where(column("posts", "post_type"), postType)
+            .first();
+        return this;
+    }
+    withTerms(taxonomies, fn) {
+        const termsQuery = this.builders.get(terms_query_1.TermsQuery, this.builder, this.alias);
+        const { column } = this.alias;
+        this.builder
+            .__ref(termsQuery)
+            .joinTermRelationships(column("posts", "ID"))
+            .joinTermTaxonomy()
+            .joinTerms()
+            .andWhere((query) => {
+            for (const taxonomy of taxonomies) {
+                query.or.where("taxonomy", taxonomy);
+            }
+        });
+        fn && fn(termsQuery);
+        return this;
+    }
+    // Used by term.trx.ts / _update_post_term_count
+    countTerm(termTaxonomyId, postStatuses, postTypes) {
+        const termsQuery = this.builders.get(terms_query_1.TermsQuery, this.builder, this.alias);
+        const { column } = this.alias;
+        this.from.builder
+            .count("* as count")
+            .__ref(termsQuery)
+            .joinTermRelationships(column("posts", "ID"))
+            .builder.__ref(this)
+            .whereIn("post_status", postStatuses)
+            .whereIn("post_type", postTypes)
+            .builder.__ref(termsQuery)
+            .where("terms_relationships.term_taxonomy_id", termTaxonomyId)
+            .builder.first();
+        return this;
+    }
+    // Used by term.trx.ts / _update_post_term_count
+    countAttachment(termTaxonomyId, postStatues) {
+        const terms = this.builders.get(terms_query_1.TermsQuery, this.builder, this.alias);
+        const { column } = this.alias;
+        this.from.builder
+            .count("* as count")
+            .__ref(terms)
+            .joinTermRelationships(column("posts", "ID"))
+            .builder.__ref(this)
+            .builder.andWhere((subBuilder) => {
+            this.builders
+                .get(PostsQuery_1, subBuilder, this.alias)
+                .whereIn("post_status", postStatues)
+                .builder.orWhere((subBuilder2) => {
+                const subBuilderWhere = this.builders.get(PostsQuery_1);
+                const { column: innerColumn } = subBuilderWhere.alias;
+                subBuilderWhere
+                    .select(["post_status"])
+                    .from.builder.whereRaw(`${innerColumn("posts", "ID")} = ${column("posts", "post_parent")}`);
+                this.builders
+                    .get(PostsQuery_1, subBuilder2, this.alias)
+                    .whereIn("post_status", ["inherit"])
+                    .where("post_parent", 0, ">")
+                    .builder.whereRaw(`(${subBuilderWhere.builder}) in (${postStatues
+                    .map(() => "?")
+                    .join(",")})`, postStatues);
+            });
+        })
+            .__ref(this)
+            .where("post_type", "attachment")
+            .builder.__ref(terms)
+            .where("terms_relationships.term_taxonomy_id", termTaxonomyId)
+            .builder.first();
+        return this;
+    }
+};
+exports.PostsQuery = PostsQuery;
+exports.PostsQuery = PostsQuery = PostsQuery_1 = __decorate([
+    (0, component_1.queryBuilder)(),
+    __metadata("design:paramtypes", [alias_1.Alias,
+        query_builders_1.QueryBuilders, Object])
+], PostsQuery);

package/query-builder/query-builder.d.ts

@@ -0,0 +1,21 @@
+import { Alias } from "./alias";
+import { QueryBuilders } from "./query-builders";
+import type * as types from "../types";
+export declare abstract class QueryBuilder<T> {
+    alias: Alias;
+    protected builders: QueryBuilders;
+    builder: types.QueryBuilder;
+    clazz: types.Constructor<T>;
+    constructor(alias: Alias, builders: QueryBuilders, builder: types.QueryBuilder, clazz: types.Constructor<T>);
+    abstract get from(): this;
+    get or(): this;
+    get not(): this;
+    count<T extends keyof types.Tables>(table: T, column: types.Columns<T>): this;
+    countGroupby<T extends keyof types.Tables>(table: T, column: types.Columns<T>): this;
+    andWhere(fn: (query: T) => void, alias?: Alias): this;
+    andWhereNot(func: (query: T) => void, alias?: Alias): this;
+    orWhere(fn: (query: T) => void, alias?: Alias): this;
+    orWhereNot(func: (query: T) => void, alias?: Alias): this;
+    usingQuery<T>(target: types.Constructor<T>, alias?: Alias): T;
+}
+//# sourceMappingURL=query-builder.d.ts.map

package/query-builder/query-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-builder.d.ts","sourceRoot":"","sources":["../../src/query-builder/query-builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAChC,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEjD,OAAO,KAAK,KAAK,KAAK,MAAM,UAAU,CAAC;AAEvC,8BAAsB,YAAY,CAAC,CAAC;IAEzB,KAAK,EAAE,KAAK;IACnB,SAAS,CAAC,QAAQ,EAAE,aAAa;IAC1B,OAAO,EAAE,KAAK,CAAC,YAAY;IAC3B,KAAK,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC;gBAH3B,KAAK,EAAE,KAAK,EACT,QAAQ,EAAE,aAAa,EAC1B,OAAO,EAAE,KAAK,CAAC,YAAY,EAC3B,KAAK,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC;IAGpC,QAAQ,KAAK,IAAI,IAAI,IAAI,CAAC;IAE1B,IAAI,EAAE,SAGL;IAED,IAAI,GAAG,SAGN;IAED,KAAK,CAAC,CAAC,SAAS,MAAM,KAAK,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;IAWtE,YAAY,CAAC,CAAC,SAAS,MAAM,KAAK,CAAC,MAAM,EACvC,KAAK,EAAE,CAAC,EACR,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;IAa1B,QAAQ,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EAAE,KAAK,CAAC,EAAE,KAAK;IAY9C,WAAW,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EAAE,KAAK,CAAC,EAAE,KAAK;IAKnD,OAAO,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EAAE,KAAK,CAAC,EAAE,KAAK;IAY7C,UAAU,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EAAE,KAAK,CAAC,EAAE,KAAK;IAKlD,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,KAAK,GACE,CAAC;CAE7D"}

package/query-builder/query-builder.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryBuilder = void 0;
+class QueryBuilder {
+    alias;
+    builders;
+    builder;
+    clazz;
+    constructor(alias, builders, builder, clazz) {
+        this.alias = alias;
+        this.builders = builders;
+        this.builder = builder;
+        this.clazz = clazz;
+    }
+    get or() {
+        this.builder.or.__ref(this);
+        return this;
+    }
+    get not() {
+        this.builder.not.__ref(this);
+        return this;
+    }
+    count(table, column) {
+        const { column: toColumn } = this.alias;
+        this.builder
+            .clear("select")
+            .clear("offset")
+            .clear("group")
+            .countDistinct(`${toColumn(table, column)} as count`)
+            .first();
+        return this;
+    }
+    countGroupby(table, column) {
+        const { column: toColumn } = this.alias;
+        this.builder
+            .clear("select")
+            .clear("offset")
+            .clear("group")
+            .select(`${toColumn(table, column)} as ${column.toString()}`)
+            .count(`${toColumn(table, column)} as count`)
+            .groupBy(toColumn(table, column));
+        return this;
+    }
+    andWhere(fn, alias) {
+        this.builder.andWhere((subBuilder) => {
+            const query = this.builders.get(this.clazz, subBuilder, alias ?? this.alias);
+            fn(query);
+        });
+        return this;
+    }
+    andWhereNot(func, alias) {
+        this.builder.not.__ref(this).andWhere(func, alias);
+        return this;
+    }
+    orWhere(fn, alias) {
+        this.builder.orWhere((subBuilder) => {
+            const query = this.builders.get(this.clazz, subBuilder, alias ?? this.alias);
+            fn(query);
+        });
+        return this;
+    }
+    orWhereNot(func, alias) {
+        this.builder.not.__ref(this).orWhere(func, alias);
+        return this;
+    }
+    usingQuery(target, alias) {
+        return this.builders.get(target, this.builder, alias);
+    }
+}
+exports.QueryBuilder = QueryBuilder;

package/query-builder/query-builders.d.ts

@@ -0,0 +1,18 @@
+import { Knex } from "knex";
+import { Components } from "../core/components";
+import { Tables } from "../core/tables";
+import Database from "../database";
+import * as types from "../types";
+import { Alias } from "./alias";
+export declare class QueryBuilders {
+    #private;
+    database: Database;
+    private components;
+    tables: Tables;
+    constructor(database: Database, components: Components, tables: Tables);
+    get queryBuilder(): Knex.QueryBuilder<any, any[]>;
+    getTableName(table: string): string;
+    raw(raw: any, args?: any): Knex.Raw<any>;
+    get<T>(target: types.Constructor<T>, builder?: Knex.QueryBuilder, alias?: Alias): T;
+}
+//# sourceMappingURL=query-builders.d.ts.map

package/query-builder/query-builders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-builders.d.ts","sourceRoot":"","sources":["../../src/query-builder/query-builders.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAQ,MAAM,MAAM,CAAC;AAGlC,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AACxC,OAAO,QAAQ,MAAM,aAAa,CAAC;AAEnC,OAAO,KAAK,KAAK,MAAM,UAAU,CAAC;AAClC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAMhC,qBACa,aAAa;;IAGf,QAAQ,EAAE,QAAQ;IACzB,OAAO,CAAC,UAAU;IACX,MAAM,EAAE,MAAM;gBAFd,QAAQ,EAAE,QAAQ,EACjB,UAAU,EAAE,UAAU,EACvB,MAAM,EAAE,MAAM;IAMvB,IAAI,YAAY,kCAEf;IAED,YAAY,CAAC,KAAK,EAAE,MAAM;IAI1B,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,GAAG;IAIxB,GAAG,CAAC,CAAC,EACH,MAAM,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,EAC5B,OAAO,CAAC,EAAE,IAAI,CAAC,YAAY,EAC3B,KAAK,CAAC,EAAE,KAAK,GACZ,CAAC;CAUL"}