@rnaga/wp-node 1.1.0

package/crud/crud.js

@@ -0,0 +1,278 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Crud = void 0;
+const config_1 = require("../config");
+const current_1 = require("../core/current");
+const blog_util_1 = require("../core/utils/blog.util");
+const post_util_1 = require("../core/utils/post.util");
+const query_util_1 = require("../core/utils/query.util");
+const roles_util_1 = require("../core/utils/roles.util");
+const val = __importStar(require("../validators"));
+const error_1 = require("./error");
+class Crud {
+    components;
+    constructor(components) {
+        this.components = components;
+    }
+    async getUser() {
+        const current = this.components.get(current_1.Current);
+        const user = current.user;
+        const role = await user?.role();
+        if (!user || (!user?.props?.ID && !role?.is("anonymous"))) {
+            throw new Error("User not found");
+        }
+        return { user, userId: user.props?.ID, userProps: user.props };
+    }
+    async checkPostsPermission(action, postType, defaultUser) {
+        const postUtil = this.components.get(post_util_1.PostUtil);
+        const postTypeObject = postUtil.getTypeObject(postType);
+        const { user: currentUser } = await this.getUser();
+        const user = defaultUser ?? currentUser;
+        return postTypeObject?.capabilities &&
+            postTypeObject.capabilities[action] &&
+            (await user.can(postTypeObject.capabilities[action]))
+            ? true
+            : false;
+    }
+    originalBlogId = 0;
+    originalSiteId = 0;
+    async switchBlog(args) {
+        const config = this.components.get(config_1.Config);
+        if (!config.isMultiSite()) {
+            return;
+        }
+        let { siteId = undefined } = args;
+        const { blogId = undefined } = args;
+        if (!siteId && !blogId) {
+            return;
+        }
+        const current = this.components.get(current_1.Current);
+        const { user: currentUser } = await this.getUser();
+        if (blogId) {
+            const blogUtil = this.components.get(blog_util_1.BlogUtil);
+            const blog = await blogUtil.get(blogId);
+            if (!blog?.props || (siteId && siteId !== blog?.props.site_id)) {
+                throw new error_1.CrudError(error_1.StatusMessage.BAD_REQUEST, "Invalid Blog");
+            }
+            if (!siteId) {
+                siteId = blog.props.site_id;
+            }
+        }
+        else if (siteId) {
+            if (!currentUser.props?.user_login) {
+                throw new error_1.CrudError(error_1.StatusMessage.UNAUTHORIZED, "Not permitted");
+            }
+            const userLogin = currentUser.props?.user_login;
+            const rolesUtil = this.components.get(roles_util_1.RolesUtil);
+            const superAdmins = await rolesUtil.getSuperAdmins({ siteId });
+            if (!superAdmins.includes(userLogin)) {
+                // Only superadmin has access to all users in site (network)
+                throw new error_1.CrudError(error_1.StatusMessage.UNAUTHORIZED, "Not permitted");
+            }
+        }
+        if (!siteId) {
+            throw new error_1.CrudError(error_1.StatusMessage.BAD_REQUEST, "Invalid site");
+        }
+        this.originalBlogId = current.blogId;
+        this.originalSiteId = current.siteId;
+        await current.switchSite(siteId, blogId);
+        await current.assumeUser(currentUser.props?.ID);
+    }
+    async restoreBlog() {
+        const config = this.components.get(config_1.Config);
+        if (0 >= this.originalSiteId ||
+            0 >= this.originalBlogId ||
+            !config.isMultiSite()) {
+            return;
+        }
+        const { user: currentUser } = await this.getUser();
+        const current = this.components.get(current_1.Current);
+        await current.switchSite(this.originalSiteId, this.originalBlogId);
+        await current.assumeUser(currentUser.props?.ID);
+    }
+    async getAvailableBlogs(args) {
+        const { siteIds, canArgs } = args;
+        let { blogIds = [] } = args;
+        const errors = [];
+        const current = this.components.get(current_1.Current);
+        const originalBlogId = current.blogId;
+        const originalSiteId = current.siteId;
+        const originalUserId = current.user?.props?.ID;
+        try {
+            const { user: currentUser } = await this.getUser();
+            if (!currentUser.props?.ID) {
+                errors.push(new error_1.CrudError(error_1.StatusMessage.BAD_REQUEST, "User not found"));
+                return [[], errors];
+            }
+            const config = this.components.get(config_1.Config);
+            const queryUtil = this.components.get(query_util_1.QueryUtil);
+            const userId = currentUser.props?.ID;
+            if (!config.isMultiSite()) {
+                blogIds = [1];
+            }
+            else if (siteIds) {
+                const blogs = (await queryUtil.blogs((query) => {
+                    query.whereIn("site_id", siteIds);
+                })) ?? [];
+                blogs.map((blog) => blogIds.push(blog.blog_id));
+            }
+            const blogs = [];
+            for (const blogId of blogIds) {
+                let blog;
+                if (!config.isMultiSite()) {
+                    blog = { blog_id: blogId, site_id: 0 };
+                }
+                else {
+                    const result = await queryUtil.blogs((query) => {
+                        query.where("blog_id", blogId).builder.first();
+                    }, val.database.wpBlogs);
+                    if (!result) {
+                        errors.push(new error_1.CrudError(error_1.StatusMessage.BAD_REQUEST, "Invalid input"));
+                        continue;
+                    }
+                    blog = {
+                        blog_id: result.blog_id,
+                        site_id: result.site_id,
+                    };
+                }
+                const siteId = blog.site_id;
+                await current.switchSite(siteId, blogId);
+                await current.assumeUser(userId);
+                if (!current?.user) {
+                    errors.push(new error_1.CrudError(error_1.StatusMessage.UNAUTHORIZED, "User not found"));
+                    continue;
+                }
+                for (const canArg of canArgs) {
+                    if (!(await current.user.can(...canArg))) {
+                        errors.push(new error_1.CrudError(error_1.StatusMessage.UNAUTHORIZED, "User not found"));
+                        continue;
+                    }
+                }
+                blogs.push(blog);
+            }
+            return [blogs, errors];
+        }
+        finally {
+            await current.switchSite(originalSiteId, originalBlogId);
+            await current.assumeUser(originalUserId);
+        }
+    }
+    async checkBlogsPermission(args) {
+        const result = await this.getAvailableBlogs(args);
+        if (result[1].length > 0) {
+            throw result[1][0];
+        }
+    }
+    async canEditPosts(postType, defaultUser) {
+        return await this.checkPostsPermission("edit_posts", postType, defaultUser);
+    }
+    async canDeletePosts(postType, defaultUser) {
+        return await this.checkPostsPermission("delete_posts", postType, defaultUser);
+    }
+    async canReadPrivatePosts(postType, defaultUser) {
+        return await this.checkPostsPermission("read_private_posts", postType, defaultUser);
+    }
+    // check_read_permission
+    async canReadPost(post) {
+        const postUtil = this.components.get(post_util_1.PostUtil);
+        const postTypeObject = postUtil.getTypeObject(post.post_type);
+        if (!postTypeObject) {
+            return false;
+        }
+        const { user: currentUser } = await this.getUser();
+        if ("publish" == post.post_status ||
+            (await currentUser.can("read_post", post.ID))) {
+            return true;
+        }
+        const postStatusObject = postUtil.getStatusObject(post.post_status);
+        if (postStatusObject && postStatusObject.public) {
+            return true;
+        }
+        // Can we read the parent if we're inheriting?
+        if ("inherit" === post.post_status && post.post_parent > 0) {
+            const parentPost = await postUtil.get(post.post_parent);
+            if (parentPost.props) {
+                return await this.canReadPost(parentPost.props);
+            }
+        }
+        /*
+         * If there isn't a parent, but the status is set to inherit, assume
+         * it's published (as per get_post_status()).
+         */
+        if ("inherit" === post.post_status) {
+            return true;
+        }
+        return false;
+    }
+    checkPasswordProtectedPost(post, password) {
+        return post.post_password == "" || post.post_password == password;
+    }
+    pagination(params) {
+        return {
+            page: params.page,
+            limit: params.limit,
+            totalPage: Math.ceil(params.count / params.limit),
+            count: params.count,
+        };
+    }
+    returnValue(data, info = undefined) {
+        return {
+            data,
+            info,
+        };
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async get(...arg2) {
+        throw new Error("Get method not defined");
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async create(...arg2) {
+        throw new Error("Create method not defined");
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async update(...arg2) {
+        throw new Error("Update method not defined");
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async delete(...arg2) {
+        throw new Error("Delete method not defined");
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async list(...arg2) {
+        throw new Error("List method not defined");
+    }
+}
+exports.Crud = Crud;

package/crud/error.d.ts

@@ -0,0 +1,23 @@
+export type StatusCode = 400 | 401 | 404 | 500;
+export declare enum StatusMessage {
+    BAD_REQUEST = "BAD_REQUEST",
+    UNAUTHORIZED = "UNAUTHORIZED",
+    NOT_FOUND = "NOT_FOUND",
+    INTERNAL_SERVER_ERROR = "INTERNAL_SERVER_ERROR"
+}
+export declare class StatusCodeMapper {
+    private static statusMap;
+    private static reverseStatusMap;
+    static getCode(message: StatusMessage): StatusCode;
+    static getMessage(statusCode: StatusCode): StatusMessage;
+}
+declare class CustomError extends Error {
+    statusCode: StatusCode;
+    isOperational: boolean;
+    constructor(message: string, statusMessage: StatusMessage, isOperational?: boolean, stack?: string);
+}
+export declare class CrudError extends CustomError {
+    constructor(statusMessage: StatusMessage | undefined, detail: string);
+}
+export {};
+//# sourceMappingURL=error.d.ts.map

package/crud/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../src/crud/error.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,UAAU,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAE/C,oBAAY,aAAa;IACvB,WAAW,gBAAgB;IAC3B,YAAY,iBAAiB;IAC7B,SAAS,cAAc;IACvB,qBAAqB,0BAA0B;CAChD;AAED,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAC,SAAS,CAKb;IAEX,OAAO,CAAC,MAAM,CAAC,gBAAgB,CAMU;WAE3B,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,UAAU;WAI3C,UAAU,CAAC,UAAU,EAAE,UAAU,GAAG,aAAa;CAKhE;AAED,cAAM,WAAY,SAAQ,KAAK;IACtB,UAAU,EAAE,UAAU,CAAC;IACvB,aAAa,EAAE,OAAO,CAAC;gBAG5B,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,aAAa,EAC5B,aAAa,GAAE,OAAc,EAC7B,KAAK,SAAK;CAWb;AAED,qBAAa,SAAU,SAAQ,WAAW;gBAEtC,aAAa,EAAE,aAAa,YAAsC,EAClE,MAAM,EAAE,MAAM;CAKjB"}

package/crud/error.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrudError = exports.StatusCodeMapper = exports.StatusMessage = void 0;
+var StatusMessage;
+(function (StatusMessage) {
+    StatusMessage["BAD_REQUEST"] = "BAD_REQUEST";
+    StatusMessage["UNAUTHORIZED"] = "UNAUTHORIZED";
+    StatusMessage["NOT_FOUND"] = "NOT_FOUND";
+    StatusMessage["INTERNAL_SERVER_ERROR"] = "INTERNAL_SERVER_ERROR";
+})(StatusMessage || (exports.StatusMessage = StatusMessage = {}));
+class StatusCodeMapper {
+    static statusMap = {
+        [StatusMessage.BAD_REQUEST]: 400,
+        [StatusMessage.UNAUTHORIZED]: 401,
+        [StatusMessage.NOT_FOUND]: 404,
+        [StatusMessage.INTERNAL_SERVER_ERROR]: 500,
+    };
+    static reverseStatusMap = Object.fromEntries(Object.entries(StatusCodeMapper.statusMap).map(([key, value]) => [
+        value,
+        key,
+    ]));
+    static getCode(message) {
+        return this.statusMap[message] || 500; // Default to 500 if not found
+    }
+    static getMessage(statusCode) {
+        return (this.reverseStatusMap[statusCode] ?? StatusMessage.INTERNAL_SERVER_ERROR);
+    }
+}
+exports.StatusCodeMapper = StatusCodeMapper;
+class CustomError extends Error {
+    statusCode;
+    isOperational;
+    constructor(message, statusMessage, isOperational = true, stack = "") {
+        super(message);
+        this.statusCode = StatusCodeMapper.getCode(statusMessage);
+        this.isOperational = isOperational;
+        if (stack) {
+            this.stack = stack;
+        }
+        else {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+}
+class CrudError extends CustomError {
+    constructor(statusMessage = StatusMessage.INTERNAL_SERVER_ERROR, detail) {
+        super(`Error: ${detail}`, statusMessage, true);
+        Object.setPrototypeOf(this, CrudError.prototype);
+    }
+}
+exports.CrudError = CrudError;

package/crud/meta.crud.d.ts

@@ -0,0 +1,69 @@
+import { z } from "zod";
+import { Config } from "../config";
+import { Components } from "../core/components";
+import { Logger } from "../core/logger";
+import * as val from "../validators";
+import { Crud } from "./crud";
+import type * as types from "../types";
+type Data = Exclude<z.infer<typeof val.trx.postUpsert.shape.meta_input>, undefined>;
+export declare class MetaCrud extends Crud {
+    private config;
+    private logger;
+    constructor(components: Components, config: Config, logger: Logger);
+    private hasObject;
+    private sync;
+    get(table: types.MetaTable, objectId: number, keys?: string[]): Promise<{
+        data: Record<string, any>;
+        info: undefined;
+    }>;
+    create(table: types.MetaTable, objectId: number, data: Data): Promise<{
+        data: number;
+        info: undefined;
+    }>;
+    update(table: types.MetaTable, objectId: number, data: Data, mode?: "update" | "sync"): Promise<{
+        data: boolean;
+        info: number;
+    }>;
+    delete(table: types.MetaTable, objectId: number, metaKeys: string[]): Promise<{
+        data: number;
+        info: undefined;
+    }>;
+    list(table: types.MetaTable, args?: Partial<z.infer<typeof val.crud.termListParams>>, options?: {
+        unserialize?: boolean;
+    }): Promise<{
+        data: ({
+            meta_value: string | number | bigint | boolean | symbol | object | Function | null | undefined;
+            meta_id: number;
+            blog_id: number;
+            meta_key: string | null;
+        } | {
+            meta_value: string | number | bigint | boolean | symbol | object | Function | null | undefined;
+            meta_id: number;
+            meta_key: string | null;
+            comment_id: number;
+        } | {
+            meta_value: string | number | bigint | boolean | symbol | object | Function | null | undefined;
+            meta_id: number;
+            meta_key: string | null;
+            post_id: number;
+        } | {
+            meta_value: string | number | bigint | boolean | symbol | object | Function | null | undefined;
+            meta_id: number;
+            meta_key: string | null;
+            site_id: number;
+        } | {
+            meta_value: string | number | bigint | boolean | symbol | object | Function | null | undefined;
+            meta_id: number;
+            meta_key: string | null;
+            term_id: number;
+        } | {
+            meta_value: string | number | bigint | boolean | symbol | object | Function | null | undefined;
+            meta_key: string | null;
+            user_id: number;
+            umeta_id: number;
+        })[];
+        info: undefined;
+    }>;
+}
+export {};
+//# sourceMappingURL=meta.crud.d.ts.map

package/crud/meta.crud.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"meta.crud.d.ts","sourceRoot":"","sources":["../../src/crud/meta.crud.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACnC,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAKxC,OAAO,KAAK,GAAG,MAAM,eAAe,CAAC;AACrC,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAG9B,OAAO,KAAK,KAAK,KAAK,MAAM,UAAU,CAAC;AAEvC,KAAK,IAAI,GAAG,OAAO,CACjB,CAAC,CAAC,KAAK,CAAC,OAAO,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,KAAK,CAAC,UAAU,CAAC,EACnD,SAAS,CACV,CAAC;AAEF,qBACa,QAAS,SAAQ,IAAI;IAG9B,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,MAAM;gBAFd,UAAU,EAAE,UAAU,EACd,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM;YAKV,SAAS;YA4CT,IAAI;IAmFZ,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE;;;;IAyB7D,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI;;;;IAK3D,MAAM,CACV,KAAK,EAAE,KAAK,CAAC,SAAS,EACtB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,IAAI,EACV,IAAI,GAAE,QAAQ,GAAG,MAAiB;;;;IAM9B,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE;;;;IA4BnE,IAAI,CACR,KAAK,EAAE,KAAK,CAAC,SAAS,EACtB,IAAI,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,GAAG,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,EACvD,OAAO,CAAC,EAAE;QACR,WAAW,CAAC,EAAE,OAAO,CAAC;KACvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiEJ"}

package/crud/meta.crud.js

@@ -0,0 +1,244 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+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 __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetaCrud = void 0;
+const common_1 = require("../common");
+const diff_1 = require("../common/diff");
+const config_1 = require("../config");
+const components_1 = require("../core/components");
+const logger_1 = require("../core/logger");
+const meta_util_1 = require("../core/utils/meta.util");
+const query_util_1 = require("../core/utils/query.util");
+const component_1 = require("../decorators/component");
+const transactions_1 = require("../transactions");
+const val = __importStar(require("../validators"));
+const crud_1 = require("./crud");
+const error_1 = require("./error");
+let MetaCrud = class MetaCrud extends crud_1.Crud {
+    config;
+    logger;
+    constructor(components, config, logger) {
+        super(components);
+        this.config = config;
+        this.logger = logger;
+    }
+    async hasObject(table, objectId) {
+        const queryUtil = this.components.get(query_util_1.QueryUtil);
+        switch (table) {
+            case "blog":
+                return (typeof (await queryUtil.blogs((query) => {
+                    query.where("blog_id", objectId);
+                })) !== "undefined");
+            case "comment":
+                return (typeof (await queryUtil.comments((query) => {
+                    query.where("ID", objectId);
+                })) !== "undefined");
+            case "post":
+                return (typeof (await queryUtil.posts((query) => {
+                    query.where("ID", objectId);
+                })) !== "undefined");
+            case "site":
+                return (typeof (await queryUtil.sites((query) => {
+                    query.where("id", objectId);
+                })) !== "undefined");
+            case "term":
+                return (typeof (await queryUtil.terms((query) => {
+                    query.where("term_id", objectId);
+                })) !== "undefined");
+            case "user":
+                return (typeof (await queryUtil.users((query) => {
+                    query.where("ID", objectId);
+                })) !== "undefined");
+            default:
+                return false;
+        }
+    }
+    async sync(table, objectId, data, mode) {
+        if (!(await this.hasObject(table, objectId))) {
+            throw new error_1.CrudError(error_1.StatusMessage.NOT_FOUND, `object not found - ${objectId}`);
+        }
+        if (typeof data === "undefined") {
+            return;
+        }
+        const { user } = await this.getUser();
+        const currentMetas = (await this.get(table, objectId)).data ?? {};
+        const diffFormData = (0, diff_1.diffObject)(data, currentMetas);
+        if (!diffFormData) {
+            return;
+        }
+        const metaTrx = this.components.get(transactions_1.MetaTrx);
+        const metaUtil = this.components.get(meta_util_1.MetaUtil);
+        const metaKeys = Object.keys(common_1.formatting.primitive(diffFormData));
+        for (const metaKey of metaKeys) {
+            if (metaUtil.isProtected(metaKey, table)) {
+                this.logger.info(`Protected meta key ${metaKey}`, { metaKey });
+                continue;
+            }
+            // Update
+            if ((mode == "sync" && data[metaKey]) ||
+                (mode == "update" &&
+                    currentMetas &&
+                    currentMetas[metaKey] &&
+                    data[metaKey] &&
+                    currentMetas[metaKey] !== data[metaKey])) {
+                if (!(await user.can(`edit_${table}_meta`, objectId, metaKey))) {
+                    throw new error_1.CrudError(error_1.StatusMessage.UNAUTHORIZED, `Sorry, you are not allowed to edit the ${table} custom field - ${metaKey}`);
+                }
+                await metaTrx.upsert(table, objectId, metaKey, data[metaKey]);
+                // Create
+            }
+            else if (mode == "create" &&
+                (!currentMetas || !currentMetas[metaKey])) {
+                if (!(await user.can(`add_${table}_meta`, objectId, metaKey))) {
+                    throw new error_1.CrudError(error_1.StatusMessage.UNAUTHORIZED, `Sorry, you are not allowed to create the ${table} custom field`);
+                }
+                await metaTrx.upsert(table, objectId, metaKey, data[metaKey]);
+                // Delete
+            }
+            else if (mode == "sync" && !data[metaKey]) {
+                if (!(await user.can(`delete_${table}_meta`, objectId, metaKey))) {
+                    throw new error_1.CrudError(error_1.StatusMessage.UNAUTHORIZED, `Sorry, you are not allowed to delete the ${table} custom field`);
+                }
+                await metaTrx.remove(table, {
+                    key: metaKey,
+                    objectId,
+                });
+            }
+        }
+    }
+    async get(table, objectId, keys) {
+        const queryUtil = this.components.get(query_util_1.QueryUtil);
+        const metas = await queryUtil.meta(table, (query) => {
+            query.withIds([objectId]);
+            if (keys) {
+                query.withKeys(keys);
+            }
+        });
+        if (!metas) {
+            return this.returnValue({});
+        }
+        return this.returnValue(metas.reduce((a, v) => ({
+            ...a,
+            [`${v.meta_key}`]: common_1.formatting.primitive(v.meta_value),
+        }), {}));
+    }
+    async create(table, objectId, data) {
+        await this.sync(table, objectId, data, "create");
+        return this.returnValue(objectId);
+    }
+    async update(table, objectId, data, mode = "update") {
+        await this.sync(table, objectId, data, mode);
+        return this.returnValue(true, objectId);
+    }
+    async delete(table, objectId, metaKeys) {
+        if (!(await this.hasObject(table, objectId))) {
+            throw new error_1.CrudError(error_1.StatusMessage.NOT_FOUND, `object not found - ${objectId}`);
+        }
+        const { user } = await this.getUser();
+        const metaTrx = this.components.get(transactions_1.MetaTrx);
+        for (const metaKey of metaKeys) {
+            if (!(await user.can(`delete_${table}_meta`, objectId, metaKey))) {
+                throw new error_1.CrudError(error_1.StatusMessage.UNAUTHORIZED, `Sorry, you are not allowed to delete the ${table} custom field`);
+            }
+            await metaTrx.remove(table, {
+                key: metaKey,
+                objectId,
+            });
+        }
+        return this.returnValue(objectId);
+    }
+    async list(table, args, options) {
+        const { user } = await this.getUser();
+        const role = await user.role();
+        // Only admin or superadmin is permitted to list all metas
+        if ((this.config.isMultiSite() && !role.isSuperAdmin()) ||
+            !role.isAdmin()) {
+            throw new error_1.CrudError(error_1.StatusMessage.UNAUTHORIZED, "Not permitted");
+        }
+        const queryUtil = this.components.get(query_util_1.QueryUtil);
+        const parsedArgs = val.crud.metaListParams.parse(args ?? {});
+        const buildQuery = (table, query) => {
+            const { column } = query.alias;
+            const offset = (parsedArgs.page - 1) * parsedArgs.per_page;
+            const limit = parsedArgs.per_page;
+            query.builder.offset(offset).limit(limit);
+            if (parsedArgs.orderby) {
+                query.builder.orderBy(column(`${table}meta`, parsedArgs.orderby), parsedArgs.order);
+            }
+            if (Array.isArray(parsedArgs.include)) {
+                query.withIds(parsedArgs.include);
+            }
+            if (Array.isArray(parsedArgs.exclude)) {
+                query.withIds(parsedArgs.exclude, {
+                    not: true,
+                });
+            }
+            if (parsedArgs.search) {
+                query.whereKeyLike(parsedArgs.search);
+            }
+        };
+        const metas = await queryUtil.meta(table, (query) => {
+            query.setPrimaryTable(table).joinPrimary();
+            buildQuery(table, query);
+        });
+        if (!metas) {
+            return this.returnValue([]);
+        }
+        return this.returnValue(!options?.unserialize
+            ? metas
+            : metas.map((meta) => {
+                return {
+                    ...meta,
+                    meta_value: common_1.formatting.primitive(meta.meta_value),
+                };
+            }));
+    }
+};
+exports.MetaCrud = MetaCrud;
+exports.MetaCrud = MetaCrud = __decorate([
+    (0, component_1.component)(),
+    __metadata("design:paramtypes", [components_1.Components,
+        config_1.Config,
+        logger_1.Logger])
+], MetaCrud);