@rxdrag/website-lib-core 0.1.0 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rxdrag/website-lib-core",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "exports": {
     ".": "./index.ts"
@@ -23,9 +23,9 @@
     "@types/react-dom": "^19.1.0",
     "eslint": "^9.39.2",
     "typescript": "^5",
+    "@rxdrag/tiptap-preview": "0.1.0",
     "@rxdrag/eslint-config-custom": "0.3.0",
-    "@rxdrag/tsconfig": "0.3.0",
-    "@rxdrag/tiptap-preview": "0.1.0"
+    "@rxdrag/tsconfig": "0.3.0"
   },
   "dependencies": {
     "@iconify/utils": "^3.0.2",
@@ -33,8 +33,8 @@
     "gsap": "^3.12.7",
     "hls.js": "^1.6.13",
     "lodash-es": "^4.17.21",
-    "@rxdrag/entify-lib": "0.1.0",
-    "@rxdrag/rxcms-models": "0.4.0"
+    "@rxdrag/entify-lib": "0.1.1",
+    "@rxdrag/rxcms-models": "0.4.1"
   },
   "peerDependencies": {
     "astro": "^5.18.1",

package/src/entify/Entify.ts

@@ -15,6 +15,9 @@ import {
   queryPosts,
   queryProductCategories,
   queryProducts,
+  queryProductsBatch,
+  queryPostsBatch,
+  PostsBatchOptions,
   queryTagCategories,
   queryTags,
   queryUserPosts,
@@ -298,6 +301,45 @@ export class Entify implements IEntify {
     )?.items;
   }
 
+  /**
+   * 批量获取多组产品列表（不同分类/分页），底层折叠为最少的 HTTP 请求，
+   * 用于静态构建时显著减少网络往返。返回顺序与入参顺序严格一致。
+   */
+  public async getProductsBatch(
+    conditionsList: ListConditions[],
+    imageSize?: ImageSize,
+    addonFields?: (keyof Product)[],
+  ) {
+    const langAbbr = this.ensureLangAbbr();
+    const size = imageSize ?? this.imageSizes.productThumbnial;
+    const results = await queryProductsBatch(
+      conditionsList,
+      size,
+      this.envVariables,
+      addonFields,
+      langAbbr,
+    );
+    return results.map((r) => r?.items);
+  }
+
+  /**
+   * 批量获取多组文章列表（不同分类/分页），底层折叠为最少的 HTTP 请求。
+   */
+  public async getPostsBatch(
+    conditionsList: ListConditions[],
+    options?: PostsBatchOptions,
+  ) {
+    const langAbbr = this.ensureLangAbbr();
+    const coverSize = options?.coverSize ?? this.imageSizes.postThumbnial;
+    const results = await queryPostsBatch(
+      conditionsList,
+      { coverSize, addonFields: options?.addonFields },
+      this.envVariables,
+      langAbbr,
+    );
+    return results.map((r) => r?.items);
+  }
+
   public async getProductListPaths(options: {
     category?: string;
     pageSize: number;

package/src/entify/IEntify.ts

@@ -120,6 +120,19 @@ export interface IEntify {
     addonFields?: (keyof Product)[] | undefined
   ): Promise<TProduct[] | undefined>;
 
+  /** 批量获取多组产品列表（折叠为最少 HTTP 请求） */
+  getProductsBatch(
+    conditionsList: ListConditions[],
+    imageSize?: ImageSize,
+    addonFields?: (keyof Product)[]
+  ): Promise<(TProduct[] | undefined)[]>;
+
+  /** 批量获取多组文章列表（折叠为最少 HTTP 请求） */
+  getPostsBatch(
+    conditionsList: ListConditions[],
+    options?: { coverSize?: ImageSize; addonFields?: (keyof import("@rxdrag/rxcms-models").Post)[] }
+  ): Promise<(TPost[] | undefined)[]>;
+
   getProductListPaths(options: {
     category?: string;
     pageSize: number;

package/src/entify/lib/index.ts

@@ -6,6 +6,9 @@ export * from "./newQueryPostOptions";
 export * from "./newQueryProductOptions";
 export * from "./newQueryProductsMediaOptions";
 export * from "./queryEntityList";
+export * from "./queryEntityListBatch";
+export * from "./queryProductsBatch";
+export * from "./queryPostsBatch";
 export * from "./queryFeaturedProducts";
 export * from "./queryLangs";
 export * from "./queryLatestPosts";

package/src/entify/lib/queryEntityListBatch.ts

@@ -0,0 +1,71 @@
+import { IQueryOptions, ListResult } from "@rxdrag/entify-lib";
+import { createEntifyClient } from "./createEntifyClient";
+import { EnvVariables } from "../types";
+import {
+  Post,
+  PostCategoryEntityName,
+  PostEntityName,
+  Product,
+  ProductCategoryEntityName,
+  ProductEntityName,
+  UserEntityName,
+} from "@rxdrag/rxcms-models";
+import {
+  postCategoriesToViewModel,
+  postListToViewModel,
+  productCategoriesToViewModel,
+  productListToViewModel,
+  userListToViewModel,
+} from "../view-model";
+
+/**
+ * queryEntityList 的批量版本：把 N 个 list 查询通过 GraphQL 别名打包成一次 HTTP 请求。
+ *
+ * 与 queryEntityList 行为对齐：
+ * - 当 envVariables.websiteId 存在时，统一向每个子查询注入 website.id 过滤
+ * - 按子查询的 entityName 走对应 viewmodel 转换
+ * - 返回顺序与入参顺序严格一致
+ */
+export async function queryEntityListBatch<
+  T,
+  WhereExp = unknown,
+  OrderBy = unknown,
+  DistinctExp = unknown
+>(
+  optionsList: IQueryOptions<T, WhereExp, OrderBy, DistinctExp>[],
+  envVariables: EnvVariables,
+) {
+  if (!optionsList?.length) return [];
+  const client = createEntifyClient(envVariables);
+
+  const scoped = optionsList.map((options) =>
+    !envVariables.websiteId
+      ? options
+      : options.setQueryArgs({
+          ...options.getQueryArgs(),
+          where: {
+            website: { id: { _eq: envVariables.websiteId } },
+            ...options.getQueryArgs()?.where,
+          } as WhereExp,
+        }),
+  );
+
+  const results = await client.batchEntityList<T, WhereExp, OrderBy, DistinctExp>(scoped);
+
+  return scoped.map((options, i) => {
+    const result = results[i];
+    switch (options.entityName) {
+      case ProductEntityName:
+        return productListToViewModel(result as ListResult<Product> | undefined);
+      case PostEntityName:
+        return postListToViewModel(result as ListResult<Post> | undefined);
+      case ProductCategoryEntityName:
+        return productCategoriesToViewModel(result as ListResult<Product> | undefined);
+      case PostCategoryEntityName:
+        return postCategoriesToViewModel(result as ListResult<Post> | undefined);
+      case UserEntityName:
+        return userListToViewModel(result as ListResult<Post> | undefined);
+    }
+    return result;
+  });
+}

package/src/entify/lib/queryPostsBatch.ts

@@ -0,0 +1,187 @@
+import {
+  Post,
+  PostBoolExp,
+  PostOrderBy,
+  PostDistinctExp,
+  PostFields,
+  PublishableStatus,
+  PostAssciations,
+  PostQueryOptions,
+  MediaQueryOptions,
+  UserQueryOptions,
+  UserFields,
+  ImageSize,
+  PostCategoryFields,
+  MediaFields,
+  PostCategory,
+  PostCategoryBoolExp,
+  PostCategoryOrderBy,
+  PostCategoryDistinctExp,
+  PostCategoryQueryOptions,
+  TagFields,
+} from "@rxdrag/rxcms-models";
+import { ListResult } from "@rxdrag/entify-lib";
+import { ListConditions } from "./queryPosts";
+import { queryEntityListBatch } from "./queryEntityListBatch";
+import { createEntifyClient } from "./createEntifyClient";
+import { EnvVariables } from "../types";
+import { TPost } from "../view-model";
+import { CategoryNode, collectCategoryIds } from "./collectCategoryIds";
+
+/**
+ * 批量文章列表查询：把同一语言下多个分类/分页的 posts 查询折叠成最少的 HTTP 请求。
+ *
+ * 与 queryPosts 行为对齐：分类树展开（三级）、website 注入、viewmodel 转换、author/cover 字段。
+ */
+export interface PostsBatchOptions {
+  coverSize?: ImageSize;
+  addonFields?: (keyof Post)[];
+}
+
+export async function queryPostsBatch(
+  conditionsList: ListConditions[],
+  options: PostsBatchOptions | undefined,
+  envVariables: EnvVariables,
+  langAbbr: string,
+): Promise<(ListResult<TPost> | undefined)[]> {
+  if (!conditionsList?.length) return [];
+
+  const categoryIdsBySlug = await resolvePostCategoryIds(
+    conditionsList.map((c) => c.category).filter((s): s is string => !!s),
+    envVariables,
+    langAbbr,
+  );
+
+  const postOptions = conditionsList.map((c) =>
+    buildPostQueryOptions(c, options, langAbbr, categoryIdsBySlug),
+  );
+
+  const results = await queryEntityListBatch<
+    Post,
+    PostBoolExp,
+    PostOrderBy,
+    PostDistinctExp
+  >(postOptions, envVariables);
+
+  return results.map((r) => r as ListResult<TPost> | undefined);
+}
+
+async function resolvePostCategoryIds(
+  slugs: string[],
+  envVariables: EnvVariables,
+  langAbbr: string,
+): Promise<Map<string, string[]>> {
+  const map = new Map<string, string[]>();
+  const uniq = Array.from(new Set(slugs));
+  if (!uniq.length) return map;
+
+  const client = createEntifyClient(envVariables);
+  const categoryOptions = uniq.map((slug) =>
+    new PostCategoryQueryOptions(
+      [PostCategoryFields.id, PostCategoryFields.slug],
+      {
+        where: {
+          slug: { _eq: slug },
+          lang: { abbr: { _eq: langAbbr } },
+        },
+      },
+    ).children(
+      new PostCategoryQueryOptions([
+        PostCategoryFields.id,
+        PostCategoryFields.slug,
+      ]).children([PostCategoryFields.id]),
+    ),
+  );
+
+  const results = await client.batchEntityList<
+    PostCategory,
+    PostCategoryBoolExp,
+    PostCategoryOrderBy,
+    PostCategoryDistinctExp
+  >(categoryOptions);
+
+  uniq.forEach((slug, i) => {
+    const item = results[i]?.items?.[0];
+    if (item) {
+      map.set(slug, collectCategoryIds(item as unknown as CategoryNode));
+    }
+  });
+  return map;
+}
+
+function buildPostQueryOptions(
+  conditions: ListConditions,
+  options: PostsBatchOptions | undefined,
+  langAbbr: string,
+  categoryIdsBySlug: Map<string, string[]>,
+): PostQueryOptions {
+  const { category: categorySlug, page = 1, pageSize } = conditions;
+  const addonFields = options?.addonFields;
+  const coverSize = options?.coverSize;
+
+  const where: Record<string, unknown> = {};
+  if (categorySlug) {
+    const ids = categoryIdsBySlug.get(categorySlug);
+    if (ids?.length) {
+      where[PostAssciations.category] = { id: { _in: ids } };
+    }
+  }
+
+  const defaultFields = [
+    PostFields.id,
+    PostFields.title,
+    PostFields.slug,
+    PostFields.description,
+    PostFields.status,
+    PostFields.updatedAt,
+    PostFields.createdAt,
+    PostFields.publishedAt,
+  ];
+  const fields = addonFields || defaultFields;
+
+  const queryOptions = new PostQueryOptions(fields, {
+    offset: (page - 1) * pageSize,
+    limit: pageSize,
+    where: {
+      [PostFields.status]: { _eq: PublishableStatus.published },
+      lang: { abbr: { _eq: langAbbr } },
+      _or: [
+        { [PostFields.isDeleted]: { _eq: false } },
+        { [PostFields.isDeleted]: { _isNull: true } },
+      ],
+      ...where,
+    },
+    orderBy: [
+      { [PostFields.pinToTop]: "desc" },
+      { [PostFields.seqValue]: "asc" },
+      { [PostFields.updatedAt]: "desc" },
+    ],
+  })
+    .category([PostCategoryFields.id, PostCategoryFields.name, PostCategoryFields.slug])
+    .tags([TagFields.id, TagFields.name, TagFields.color]);
+
+  if (!addonFields || addonFields.includes("cover" as keyof Post)) {
+    queryOptions.cover(
+      new MediaQueryOptions().file([
+        "thumbnail",
+        coverSize
+          ? `resize(width:${coverSize.width}, height:${coverSize.height})`
+          : "resize(width:480, height:180)",
+      ]),
+    );
+  }
+
+  if (!addonFields || addonFields.includes("author" as keyof Post)) {
+    queryOptions.author(
+      new UserQueryOptions([UserFields.id, UserFields.name]).avatar(
+        new MediaQueryOptions([
+          MediaFields.id,
+          MediaFields.mediaType,
+          MediaFields.mediaRef,
+        ]).file(["thumbnail", "original"]),
+      ),
+    );
+  }
+
+  return queryOptions;
+}

package/src/entify/lib/queryProducts.ts

@@ -58,6 +58,11 @@ export async function queryProducts(
             slug: {
               _eq: categorySlug,
             },
+            lang: {
+              abbr: {
+                _eq: langAbbr,
+              },
+            },
           },
         }
         //支持三级结构

package/src/entify/lib/queryProductsBatch.ts

@@ -0,0 +1,161 @@
+import {
+  Product,
+  ProductBoolExp,
+  ProductOrderBy,
+  ProductDistinctExp,
+  ProductFields,
+  ProductQueryOptions,
+  PublishableStatus,
+  ProductAssciations,
+  ProductCategory,
+  ProductCategoryBoolExp,
+  ProductCategoryOrderBy,
+  ProductCategoryDistinctExp,
+  ProductCategoryFields,
+  ProductCategoryQueryOptions,
+  TagFields,
+  ImageSize,
+} from "@rxdrag/rxcms-models";
+import { ListResult } from "@rxdrag/entify-lib";
+import { ListConditions } from "./queryPosts";
+import { queryEntityListBatch } from "./queryEntityListBatch";
+import { newQueryProductsMediaOptions } from "./newQueryProductsMediaOptions";
+import { createEntifyClient } from "./createEntifyClient";
+import { EnvVariables } from "../types";
+import { TProduct } from "../view-model";
+import { CategoryNode, collectCategoryIds } from "./collectCategoryIds";
+
+/**
+ * 批量产品列表查询：把同一语言下多个分类/分页的 products 查询折叠成最少的 HTTP 请求。
+ *
+ * 流程：
+ * 1. 收集所有非空 category slug，一次批量解析分类树（最多 1 次 HTTP）。
+ * 2. 复用统一的产品查询字段配置，构造 N 个 ProductQueryOptions。
+ * 3. 一次批量发出（1 次 HTTP），按入参顺序返回结果。
+ *
+ * 与 queryProducts 行为对齐：分类树展开（三级）、website 注入、viewmodel 转换。
+ */
+export async function queryProductsBatch(
+  conditionsList: ListConditions[],
+  imageSize: ImageSize | undefined,
+  envVariables: EnvVariables,
+  addonFields: (keyof Product)[] | undefined,
+  langAbbr: string,
+): Promise<(ListResult<TProduct> | undefined)[]> {
+  if (!conditionsList?.length) return [];
+
+  const categoryIdsBySlug = await resolveProductCategoryIds(
+    conditionsList.map((c) => c.category).filter((s): s is string => !!s),
+    envVariables,
+    langAbbr,
+  );
+
+  const productOptions = conditionsList.map((c) =>
+    buildProductQueryOptions(c, imageSize, addonFields, langAbbr, categoryIdsBySlug),
+  );
+
+  const results = await queryEntityListBatch<
+    Product,
+    ProductBoolExp,
+    ProductOrderBy,
+    ProductDistinctExp
+  >(productOptions, envVariables);
+
+  return results.map((r) => r as ListResult<TProduct> | undefined);
+}
+
+async function resolveProductCategoryIds(
+  slugs: string[],
+  envVariables: EnvVariables,
+  langAbbr: string,
+): Promise<Map<string, string[]>> {
+  const map = new Map<string, string[]>();
+  const uniq = Array.from(new Set(slugs));
+  if (!uniq.length) return map;
+
+  const client = createEntifyClient(envVariables);
+  const categoryOptions = uniq.map((slug) =>
+    new ProductCategoryQueryOptions(
+      [ProductCategoryFields.id, ProductCategoryFields.slug],
+      {
+        where: {
+          slug: { _eq: slug },
+          lang: { abbr: { _eq: langAbbr } },
+        },
+      },
+    ).children(
+      new ProductCategoryQueryOptions([
+        ProductCategoryFields.id,
+        ProductCategoryFields.slug,
+      ]).children([ProductCategoryFields.id]),
+    ),
+  );
+
+  const results = await client.batchEntityList<
+    ProductCategory,
+    ProductCategoryBoolExp,
+    ProductCategoryOrderBy,
+    ProductCategoryDistinctExp
+  >(categoryOptions);
+
+  uniq.forEach((slug, i) => {
+    const item = results[i]?.items?.[0];
+    if (item) {
+      map.set(slug, collectCategoryIds(item as unknown as CategoryNode));
+    }
+  });
+  return map;
+}
+
+function buildProductQueryOptions(
+  conditions: ListConditions,
+  imageSize: ImageSize | undefined,
+  addonFields: (keyof Product)[] | undefined,
+  langAbbr: string,
+  categoryIdsBySlug: Map<string, string[]>,
+): ProductQueryOptions {
+  const { category: categorySlug, page = 1, pageSize = 10, orderBy } = conditions;
+
+  const where: Record<string, unknown> = {};
+  if (categorySlug) {
+    const ids = categoryIdsBySlug.get(categorySlug);
+    if (ids?.length) {
+      where[ProductAssciations.category] = { id: { _in: ids } };
+    }
+  }
+
+  const defaultFields = [
+    ProductFields.id,
+    ProductFields.slug,
+    ProductFields.title,
+    ProductFields.shortTitle,
+    ProductFields.description,
+    ProductFields.seqValue,
+    ProductFields.updatedAt,
+  ];
+  const fields = [...defaultFields, ...(addonFields || [])];
+
+  const queryOptions = new ProductQueryOptions(fields, {
+    offset: (page - 1) * pageSize,
+    limit: pageSize,
+    where: {
+      [ProductFields.status]: { _eq: PublishableStatus.published },
+      lang: { abbr: { _eq: langAbbr } },
+      _or: [
+        { [ProductFields.isDeleted]: { _eq: false } },
+        { [ProductFields.isDeleted]: { _isNull: true } },
+      ],
+      ...where,
+    },
+    orderBy: orderBy || [
+      { [ProductFields.seqValue]: "asc" },
+      { [ProductFields.updatedAt]: "desc" },
+    ],
+  }).tags([TagFields.id, TagFields.name, TagFields.color]);
+
+  if (!addonFields || !addonFields.includes("slug" as keyof Product)) {
+    queryOptions.mediaPivots(newQueryProductsMediaOptions(imageSize));
+  }
+
+  return queryOptions;
+}