@plasmicpkgs/wordpress 0.0.10 → 0.0.12

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import type { RulesLogic } from 'json-logic-js';
+
 export declare function _ensure<T>(x: T | null | undefined, message?: string): T;
 
 export declare type _QueryOperator = (typeof _queryOperators)[number]["value"];
@@ -13,14 +15,85 @@ export declare const _queryOperators: readonly [{
     readonly label: "Filter by author";
 }];
 
-export declare function queryWordpress({ wordpressUrl, queryType, queryOperator, filterValue, limit, }: QueryWordpressOpts): Promise<any>;
+/**
+ * Query WordPress posts or pages with optional filtering, pagination, and ordering.
+ *
+ * @param opts - Query options including URL, content type, filter logic, pagination, and ordering
+ * @returns Promise resolving to the WordPress query response or raw items array for backward compatibility
+ *
+ * @example
+ * ```ts
+ * // Fetch all published posts
+ * const result = await queryWordpress({
+ *   wordpressUrl: 'https://example.com',
+ *   queryType: 'posts'
+ * });
+ *
+ * // Fetch with filters
+ * const filtered = await queryWordpress({
+ *   wordpressUrl: 'https://example.com',
+ *   queryType: 'posts',
+ *   filterLogic: { "==": [{ var: "status" }, "publish"] },
+ * });
+ * ```
+ */
+export declare function queryWordpress(opts: QueryWordpressOpts): Promise<QueryWordpressResponse | any>;
+
+/**
+ * Query Wordpress with simplified filter props.
+ *
+ * @deprecated Use {@link queryWordpress} with `filterLogic` parameter instead.
+ *
+ * @example
+ * ```ts
+ * // Old way (deprecated)
+ * _queryWordpress({
+ *   wordpressUrl: 'https://example.com',
+ *   queryType: 'posts',
+ *   queryOperator: 'status',
+ *   filterValue: 'publish'
+ * });
+ *
+ * // New way
+ * queryWordpress({
+ *   wordpressUrl: 'https://example.com',
+ *   queryType: 'posts',
+ *   filterLogic: { "==": [{ var: "status" }, "publish"] },
+ * });
+ * ```
+ */
+export declare function _queryWordpress(opts: QueryWordpressOpts & QueryWordpressOldFilterProps): Promise<QueryWordpressResponse>;
+
+/**
+ * @deprecated These filter props are deprecated. Use `filterLogic` with the query builder instead.
+ * Only used by the deprecated plasmic-wordpress package
+ */
+declare interface QueryWordpressOldFilterProps {
+    queryOperator?: _QueryOperator;
+    filterValue?: string;
+}
 
 declare interface QueryWordpressOpts {
     wordpressUrl?: string;
     queryType?: "pages" | "posts";
-    queryOperator?: _QueryOperator;
-    filterValue?: string;
+    /**
+     * Filter logic using JSON Logic format to filter WordPress entries.
+     * See {@link https://www.npmjs.com/package/@types/json-logic-js?activeTab=readme}
+     */
+    filterLogic?: RulesLogic;
     limit?: number;
+    page?: number;
+    offset?: number;
+    reverseOrder?: boolean;
+    orderby?: string;
+}
+
+declare interface QueryWordpressResponse {
+    items: any[];
+    total: number;
+    totalPages: number;
+    page: number;
+    perPage: number;
 }
 
 export declare function registerWordpress(loader?: {

package/dist/index.esm.js

@@ -1,3 +1,22 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __async = (__this, __arguments, generator) => {
   return new Promise((resolve, reject) => {
     var fulfilled = (value) => {
@@ -45,33 +64,344 @@ function ensure(x, message) {
     return x;
   }
 }
+function cleanUrl(url) {
+  return url.replace(/\/$/, "");
+}
+
+// src/where.ts
+var WORDPRESS_POST_FIELDS = {
+  id: {
+    type: "number",
+    label: "ID",
+    operators: ["equal", "not_equal"]
+  },
+  date: {
+    type: "datetime",
+    label: "Published Date",
+    operators: ["less", "greater"],
+    defaultOperator: "greater"
+    // this prevents "equals" operator from being shown by default
+  },
+  modified: {
+    type: "datetime",
+    label: "Modified Date",
+    operators: ["less", "greater"],
+    defaultOperator: "greater"
+  },
+  slug: {
+    type: "text",
+    label: "Slug",
+    operators: ["equal"]
+  },
+  author: {
+    type: "number",
+    label: "Author ID",
+    operators: ["equal", "not_equal"]
+  },
+  categories: {
+    type: "multiselect",
+    label: "Category",
+    operators: ["multiselect_contains", "multiselect_not_contains"],
+    defaultOperator: "multiselect_contains",
+    fieldSettings: {
+      listValues: []
+      // Will be populated dynamically
+    }
+  },
+  tags: {
+    type: "multiselect",
+    label: "Tag",
+    operators: ["multiselect_contains", "multiselect_not_contains"],
+    defaultOperator: "multiselect_contains",
+    fieldSettings: {
+      listValues: []
+      // Will be populated dynamically
+    }
+  },
+  sticky: {
+    type: "boolean",
+    label: "Sticky",
+    operators: ["equal"]
+  },
+  search: {
+    type: "text",
+    label: "Search",
+    operators: ["equal"]
+  },
+  search_columns: {
+    type: "multiselect",
+    label: "Search Columns",
+    operators: ["multiselect_contains"],
+    defaultOperator: "multiselect_contains",
+    fieldSettings: {
+      listValues: ["post_title", "post_content", "post_excerpt"]
+    }
+  }
+};
+var WORDPRESS_PAGE_FIELDS = {
+  id: WORDPRESS_POST_FIELDS.id,
+  date: WORDPRESS_POST_FIELDS.date,
+  modified: WORDPRESS_POST_FIELDS.modified,
+  slug: WORDPRESS_POST_FIELDS.slug,
+  author: WORDPRESS_POST_FIELDS.author,
+  search: WORDPRESS_POST_FIELDS.search,
+  search_columns: WORDPRESS_POST_FIELDS.search_columns,
+  // Page-specific fields
+  parent: {
+    type: "number",
+    label: "Parent Page",
+    operators: ["equal", "not_equal"]
+  },
+  menu_order: {
+    type: "number",
+    label: "Menu Order",
+    operators: ["equal"]
+  }
+};
+function fetchCategories(wordpressUrl) {
+  return __async(this, null, function* () {
+    try {
+      const url = `${cleanUrl(
+        wordpressUrl
+      )}/wp-json/wp/v2/categories?per_page=100`;
+      const resp = yield fetch(url);
+      if (!resp.ok) {
+        return [];
+      }
+      const categories = yield resp.json();
+      const formatted = categories.map((cat) => ({
+        value: cat.id,
+        title: cat.name
+      }));
+      return formatted;
+    } catch (error) {
+      console.error("Failed to fetch WordPress categories:", error);
+      return [];
+    }
+  });
+}
+function fetchTags(wordpressUrl) {
+  return __async(this, null, function* () {
+    try {
+      const url = `${cleanUrl(wordpressUrl)}/wp-json/wp/v2/tags?per_page=100`;
+      const resp = yield fetch(url);
+      if (!resp.ok) {
+        return [];
+      }
+      const tags = yield resp.json();
+      const formatted = tags.map((tag) => ({
+        value: tag.id,
+        title: tag.name
+      }));
+      return formatted;
+    } catch (error) {
+      console.error("Failed to fetch WordPress tags:", error);
+      return [];
+    }
+  });
+}
+function buildWordPressConfig(queryType, categories, tags) {
+  const fields = queryType === "posts" ? __spreadValues({}, WORDPRESS_POST_FIELDS) : __spreadValues({}, WORDPRESS_PAGE_FIELDS);
+  if (queryType === "posts" && categories && tags) {
+    fields.categories = __spreadProps(__spreadValues({}, fields.categories), {
+      fieldSettings: { listValues: categories }
+    });
+    fields.tags = __spreadProps(__spreadValues({}, fields.tags), {
+      fieldSettings: { listValues: tags }
+    });
+  }
+  return {
+    fields,
+    // WordPress REST API doesn't support OR logic natively
+    // Limit to AND-only combinations
+    conjunctions: {
+      AND: { label: "AND" }
+    },
+    settings: {
+      showNot: false,
+      // hides group controls (we don't want to support nested groups, because the only supported conjunction is AND)
+      maxNesting: 1
+    }
+  };
+}
+function rulesLogicToWordPressFilters(logic) {
+  if (logic === null || logic === void 0) {
+    return {};
+  } else if (typeof logic !== "object") {
+    throw new Error(`unexpected logic: ${JSON.stringify(logic)}`);
+  } else if ("and" in logic) {
+    return handleAndGroup(logic.and);
+  }
+  return handleCondition(logic);
+}
+function handleAndGroup(conditions) {
+  const filters = {};
+  for (const condition of conditions) {
+    const result = handleCondition(condition);
+    Object.assign(filters, result);
+  }
+  return filters;
+}
+function handleCondition(condition, negated = false) {
+  if ("some" in condition) {
+    const [fieldExpr, inExpr] = condition.some;
+    if ("var" in fieldExpr && "in" in inExpr && Array.isArray(inExpr.in) && inExpr.in.length === 2) {
+      const field = fieldExpr.var;
+      const values = inExpr.in[1];
+      return negated ? convertNotEqualOperator(field, values) : convertEqualOperator(field, values);
+    }
+  }
+  if ("!" in condition) {
+    return handleCondition(condition["!"], true);
+  }
+  if ("==" in condition) {
+    const [fieldExpr, value] = condition["=="];
+    if ("var" in fieldExpr) {
+      return convertEqualOperator(fieldExpr.var, value);
+    }
+  }
+  if ("!=" in condition) {
+    const [fieldExpr, value] = condition["!="];
+    if ("var" in fieldExpr) {
+      return convertNotEqualOperator(fieldExpr.var, value);
+    }
+  }
+  if ("<" in condition) {
+    const [fieldExpr, value] = condition["<"];
+    if ("var" in fieldExpr) {
+      return convertLessThanOperator(fieldExpr.var, value);
+    }
+  }
+  if (">" in condition) {
+    const [fieldExpr, right] = condition[">"];
+    if ("var" in fieldExpr) {
+      return convertGreaterThanOperator(fieldExpr.var, right);
+    }
+  }
+  throw new Error(
+    `Unsupported WordPress filter condition: ${JSON.stringify(condition)}`
+  );
+}
+function convertEqualOperator(field, value) {
+  if (field === "id") {
+    return { include: value };
+  }
+  return { [field]: value };
+}
+function convertNotEqualOperator(field, value) {
+  if (field === "id") {
+    return { exclude: value };
+  }
+  return { [`${field}_exclude`]: value };
+}
+function convertLessThanOperator(field, value) {
+  if (field === "date") {
+    return { before: value };
+  }
+  if (field === "modified") {
+    return { modified_before: value };
+  }
+  console.warn(
+    `WordPress: Less than operator not supported for field: ${field}`
+  );
+  return {};
+}
+function convertGreaterThanOperator(field, value) {
+  if (field === "date") {
+    return { after: value };
+  }
+  if (field === "modified") {
+    return { modified_after: value };
+  }
+  console.warn(
+    `WordPress: Greater than operator not supported for field: ${field}`
+  );
+  return {};
+}
 
 // src/query-wordpress.ts
-function queryWordpress(_0) {
-  return __async(this, arguments, function* ({
-    wordpressUrl,
-    queryType,
-    queryOperator,
-    filterValue,
-    limit
-  }) {
+function _queryWordpress(opts) {
+  return __async(this, null, function* () {
+    const {
+      wordpressUrl,
+      queryType,
+      queryOperator,
+      filterValue,
+      filterLogic,
+      limit,
+      page,
+      offset,
+      reverseOrder,
+      orderby
+    } = opts;
     if (!wordpressUrl || !queryType) {
       throw new Error("Wordpress URL and query type are required");
     }
     const urlParams = new URLSearchParams();
-    if (queryOperator && filterValue) {
+    if (filterLogic) {
+      const filters = rulesLogicToWordPressFilters(filterLogic);
+      appendFiltersToParams(urlParams, filters);
+    } else if (queryOperator && filterValue) {
       urlParams.append(queryOperator, filterValue);
     }
     if (limit) {
-      urlParams.append("per_page", limit.toString());
+      urlParams.append("per_page", String(Math.min(limit, 100)));
     }
-    const urlWithSlash = wordpressUrl.endsWith("/") ? wordpressUrl : `${wordpressUrl}/`;
-    const url = new URL(`wp-json/wp/v2/${queryType}`, urlWithSlash);
+    if (page) {
+      urlParams.append("page", String(page));
+    }
+    if (offset) {
+      urlParams.append("offset", String(offset));
+    }
+    if (reverseOrder) {
+      urlParams.append("order", "asc");
+    }
+    if (orderby) {
+      urlParams.append("orderby", orderby);
+    }
+    const url = new URL(`wp-json/wp/v2/${queryType}`, cleanUrl(wordpressUrl));
     url.search = urlParams.toString();
     const resp = yield fetch(url);
-    return yield resp.json();
+    if (!resp.ok) {
+      const errorText = yield resp.text();
+      let errorMessage = `WordPress API error (${resp.status})`;
+      try {
+        const errorJson = JSON.parse(errorText);
+        errorMessage = errorJson.message || errorMessage;
+      } catch (e) {
+        errorMessage += `: ${errorText}`;
+      }
+      throw new Error(errorMessage);
+    }
+    const items = yield resp.json();
+    const total = parseInt(resp.headers.get("X-WP-Total") || "0", 10);
+    const totalPages = parseInt(resp.headers.get("X-WP-TotalPages") || "0", 10);
+    return {
+      items,
+      total,
+      totalPages,
+      page: page || 1,
+      perPage: limit || 10
+    };
+  });
+}
+function queryWordpress(opts) {
+  return __async(this, null, function* () {
+    return _queryWordpress(opts);
   });
 }
+function appendFiltersToParams(params, filters) {
+  for (const [key, value] of Object.entries(filters)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      params.append(key, value.join(","));
+    } else {
+      params.append(key, String(value));
+    }
+  }
+}
 var queryWordpressMeta = {
   name: "queryWordpress",
   displayName: "Query WordPress",
@@ -83,28 +413,139 @@ var queryWordpressMeta = {
       display: "flatten",
       fields: {
         wordpressUrl: {
-          type: "string"
+          type: "string",
+          displayName: "WordPress URL",
+          description: "Base URL of your WordPress site (e.g., https://example.com)",
+          helpText: "The root URL of your WordPress installation"
         },
         queryType: {
           type: "choice",
-          options: ["pages", "posts"]
+          options: [
+            { label: "Posts", value: "posts" },
+            { label: "Pages", value: "pages" }
+          ],
+          displayName: "Content Type",
+          description: "Type of content to query",
+          defaultValue: "posts"
         },
-        queryOperator: {
-          type: "choice",
-          options: Object.values(queryOperators).map((item) => ({
-            label: item.label,
-            value: item.value
-          }))
+        filterLogic: {
+          type: "queryBuilder",
+          displayName: "Filters",
+          description: "Filter fetched entries. Defaults to fetch all entries.",
+          config: (_, ctx) => {
+            const { queryType, categories, tags } = ctx;
+            if (!queryType) {
+              return { fields: {} };
+            }
+            return buildWordPressConfig(queryType, categories, tags);
+          }
         },
-        filterValue: {
-          type: "string"
+        // Pagination
+        page: {
+          type: "number",
+          displayName: "Page",
+          description: "Page number for pagination (starts at 1)",
+          min: 1,
+          defaultValueHint: 1
         },
         limit: {
-          type: "number"
+          type: "number",
+          displayName: "Items per page",
+          description: "Maximum number of items to return (max: 100)",
+          min: 1,
+          max: 100,
+          defaultValueHint: 10
+        },
+        offset: {
+          type: "number",
+          displayName: "Offset",
+          description: "Number of items to skip",
+          min: 0,
+          hidden: (opts) => !!opts.page,
+          // Hide if page is being used
+          defaultValueHint: 0
+        },
+        // Ordering
+        // One of: author, date, id, include, modified, parent, relevance, slug, include_slugs, title
+        orderby: {
+          type: "choice",
+          options: ([opts]) => [
+            {
+              label: "Relevance (search results)",
+              value: "relevance"
+            },
+            {
+              label: "Publish date",
+              value: "date"
+            },
+            {
+              label: "Last modified date",
+              value: "modified"
+            },
+            {
+              label: "Title (A\u2013Z)",
+              value: "title"
+            },
+            {
+              label: "Slug (URL)",
+              value: "slug"
+            },
+            {
+              label: "Author",
+              value: "author"
+            },
+            {
+              label: "ID",
+              value: "id"
+            },
+            ...(opts == null ? void 0 : opts.queryType) === "pages" ? [
+              {
+                label: "Menu order",
+                value: "menu_order"
+              },
+              {
+                label: "Parent page",
+                value: "parent"
+              }
+            ] : []
+          ],
+          displayName: "Sort by",
+          description: "Field to sort results by",
+          defaultValueHint: "date"
+        },
+        reverseOrder: {
+          type: "boolean",
+          displayName: "Reverse order",
+          description: "Reverse the order of the results",
+          defaultValueHint: false
         }
       }
     }
-  ]
+  ],
+  fnContext: (wordpressOpts) => {
+    const { wordpressUrl, queryType } = wordpressOpts != null ? wordpressOpts : {};
+    if (!wordpressUrl || !queryType) {
+      return {
+        dataKey: "",
+        fetcher: () => __async(void 0, null, function* () {
+          return { categories: [], tags: [] };
+        })
+      };
+    }
+    return {
+      dataKey: `${wordpressUrl}:${queryType}`,
+      fetcher: () => __async(void 0, null, function* () {
+        if (queryType === "posts") {
+          const [categories, tags] = yield Promise.all([
+            fetchCategories(wordpressUrl),
+            fetchTags(wordpressUrl)
+          ]);
+          return { categories, tags, queryType };
+        }
+        return { categories: [], tags: [], queryType };
+      })
+    };
+  }
 };
 
 // src/index.ts
@@ -121,6 +562,7 @@ function registerWordpress(loader) {
 export {
   ensure as _ensure,
   queryOperators as _queryOperators,
+  _queryWordpress,
   queryWordpress,
   registerWordpress
 };