@docyrus/ui-pro-ai-assistant 0.4.8 → 0.4.9

package/dist/hooks/use-resolved-record-fields.d.ts

@@ -1,11 +1,15 @@
 import { type DataSourceField } from '../lib/assistant-config';
 export interface ResolvedDataSource {
     name?: string;
+    type?: string;
     appSlug: string;
     dsSlug: string;
     labelField?: {
         slug: string;
     };
+    idField?: {
+        slug: string;
+    };
 }
 export declare function clearRecordFieldsCache(): void;
 export interface UseResolvedRecordFieldsResult {

package/dist/index.js

@@ -4957,12 +4957,14 @@ var USER_TYPES = /* @__PURE__ */ new Set([
   "userSelect",
   "userMultiSelect"
 ]);
+var RELATION_TYPES = /* @__PURE__ */ new Set(["field-relation", "relation"]);
 var CACHE_TTL_MS = 10 * 60 * 1e3;
 var USERS_PAGE_LIMIT = 200;
 var USERS_PAGE_CAP = 5;
 var metaCache = /* @__PURE__ */ new Map();
 var enumsCache = /* @__PURE__ */ new Map();
 var usersCache = /* @__PURE__ */ new Map();
+var relationCache = /* @__PURE__ */ new Map();
 function getOrFetch(cache, key, loader) {
   const now = Date.now();
   const cached = cache.get(key);
@@ -4998,9 +5000,11 @@ async function fetchMeta(apiClient, dataSourceId, baseUrl, getDataSourceSchema)
     return {
       dataSource: {
         name: ds.name,
+        type: ds.type,
         appSlug,
         dsSlug,
-        labelField: ds.label_field
+        labelField: ds.label_field || ds.labelField,
+        idField: ds.id_field || ds.idField
       },
       fields: dsFields
     };
@@ -5023,7 +5027,15 @@ async function fetchEnums(apiClient, dataSourceId, baseUrl) {
         id: opt.id,
         name: opt.name,
         color: opt.color,
-        icon: opt.icon
+        icon: opt.icon,
+        parent: opt.parent || opt.parentId || opt.parent_id,
+        slug: opt.slug,
+        sort_order: opt.sortOrder ?? opt.sort_order,
+        active: opt.active,
+        is_final_option: opt.isFinalOption ?? opt.is_final_option,
+        force_description: opt.forceDescription ?? opt.force_description,
+        force_followup_date: opt.forceFollowupDate ?? opt.force_followup_date,
+        description: opt.description
       });
     }
     return byFieldId.size > 0 ? byFieldId : null;
@@ -5046,7 +5058,7 @@ async function fetchUsers(apiClient, baseUrl) {
         const id = u.id || u.user_id;
         if (!id || seen.has(id)) continue;
         seen.add(id);
-        added += 1;
+        added++;
         const nameParts = [u.firstname, u.lastname].filter(Boolean).join(" ");
         all3.push({
           id,
@@ -5059,6 +5071,61 @@ async function fetchUsers(apiClient, baseUrl) {
     return all3.length > 0 ? all3 : null;
   });
 }
+function resolveDisplayName(record, labelSlug) {
+  const labelValue = record[labelSlug];
+  if (typeof labelValue === "string" && labelValue) return labelValue;
+  if (labelValue && typeof labelValue === "object" && "name" in labelValue) {
+    return labelValue.name;
+  }
+  const nameValue = record.name;
+  if (typeof nameValue === "string" && nameValue) return nameValue;
+  if (nameValue && typeof nameValue === "object" && "name" in nameValue) {
+    return nameValue.name;
+  }
+  return record.title || record.label || record.display_name || record.id;
+}
+var RELATION_ITEMS_LIMIT = 50;
+async function fetchRelationRecords(apiClient, relationDataSourceId, baseUrl, getDataSourceSchema) {
+  return getOrFetch(relationCache, `${baseUrl}::${relationDataSourceId}`, async () => {
+    const relMeta = await fetchMeta(apiClient, relationDataSourceId, baseUrl, getDataSourceSchema);
+    if (!relMeta) return null;
+    const {
+      appSlug,
+      dsSlug,
+      labelField,
+      idField,
+      type: dsType
+    } = relMeta.dataSource;
+    const idSlug = idField?.slug || "id";
+    const labelSlug = labelField?.slug;
+    const columns = dsType === "simple" ? ["name", "id", "autonumber_id"] : [idSlug];
+    if (labelSlug && !columns.includes(labelSlug)) {
+      columns.push(labelSlug);
+    }
+    if (!columns.includes("name")) {
+      columns.push("name");
+    }
+    const res = await apiClient.get(
+      `/apps/${appSlug}/data-sources/${dsSlug}/items`,
+      {
+        limit: RELATION_ITEMS_LIMIT,
+        columns: columns.join(","),
+        dataSourceId: relationDataSourceId,
+        fullCount: false
+      }
+    );
+    if (!res.success) return null;
+    const payload = res.data;
+    const items2 = Array.isArray(payload) ? payload : payload?.items ?? payload?.data;
+    if (!Array.isArray(items2) || items2.length === 0) return null;
+    return items2.map((record) => ({
+      id: record.id,
+      name: resolveDisplayName(record, labelSlug || "name"),
+      icon: record.icon || void 0,
+      color: record.color || void 0
+    }));
+  });
+}
 function useResolvedRecordFields(dataSourceId, recordSlugs) {
   const apiClient = useApiClient();
   const config3 = useAssistantConfig();
@@ -5072,12 +5139,8 @@ function useResolvedRecordFields(dataSourceId, recordSlugs) {
   );
   const apiClientRef = useRef(apiClient);
   const configRef = useRef(config3);
-  useEffect(() => {
-    apiClientRef.current = apiClient;
-  });
-  useEffect(() => {
-    configRef.current = config3;
-  });
+  apiClientRef.current = apiClient;
+  configRef.current = config3;
   const baseUrl = config3.apiBaseUrl;
   useEffect(() => {
     if (!dataSourceId) {
@@ -5086,7 +5149,7 @@ function useResolvedRecordFields(dataSourceId, recordSlugs) {
     }
     let cancelled = false;
     setLoading(true);
-    (async () => {
+    const run = async () => {
       const meta = await fetchMeta(
         apiClientRef.current,
         dataSourceId,
@@ -5106,26 +5169,44 @@ function useResolvedRecordFields(dataSourceId, recordSlugs) {
       }
       const hasSelectFields = displayFields.some((f) => SELECT_TYPES.has(f.type));
       const hasUserFields = displayFields.some((f) => USER_TYPES.has(f.type));
-      let enumsPromise = Promise.resolve(null);
-      let usersPromise = Promise.resolve(null);
-      if (hasSelectFields) enumsPromise = fetchEnums(apiClientRef.current, dataSourceId, baseUrl);
-      if (hasUserFields) usersPromise = fetchUsers(apiClientRef.current, baseUrl);
-      const [enums, users] = await Promise.all([enumsPromise, usersPromise]);
+      const relationDsIds = [
+        ...new Set(
+          displayFields.filter((f) => RELATION_TYPES.has(f.type) && f.relation_data_source_id).map((f) => f.relation_data_source_id)
+        )
+      ];
+      const enumsPromise = hasSelectFields ? fetchEnums(apiClientRef.current, dataSourceId, baseUrl) : Promise.resolve(null);
+      const usersPromise = hasUserFields ? fetchUsers(apiClientRef.current, baseUrl) : Promise.resolve(null);
+      const relationPromises = relationDsIds.map((relDsId) => fetchRelationRecords(apiClientRef.current, relDsId, baseUrl, configRef.current.getDataSourceSchema).then((options3) => [relDsId, options3]));
+      const [enums, users, ...relationResults] = await Promise.all([enumsPromise, usersPromise, ...relationPromises]);
       if (cancelled) return;
+      const relationMap = /* @__PURE__ */ new Map();
+      for (const [relDsId, options3] of relationResults) {
+        if (options3) relationMap.set(relDsId, options3);
+      }
       const enrichedFields = displayFields.map((f) => {
-        if (enums && SELECT_TYPES.has(f.type) && enums.has(f.id)) {
-          return { ...f, enumOptions: enums.get(f.id) };
+        if (SELECT_TYPES.has(f.type)) {
+          if (enums && enums.has(f.id)) {
+            return { ...f, enumOptions: enums.get(f.id) };
+          }
+          const inlineData = f.data || f.options?.data || f.options?.editorOptions?.data;
+          if (Array.isArray(inlineData) && inlineData.length > 0) {
+            return { ...f, enumOptions: inlineData };
+          }
         }
         if (users && USER_TYPES.has(f.type)) {
           return { ...f, enumOptions: users };
         }
+        if (RELATION_TYPES.has(f.type) && f.relation_data_source_id && relationMap.has(f.relation_data_source_id)) {
+          return { ...f, enumOptions: relationMap.get(f.relation_data_source_id) };
+        }
         return f;
       });
       setFields(enrichedFields);
       setDataSource(meta.dataSource);
       setResolved(true);
       setLoading(false);
-    })();
+    };
+    void run();
     return () => {
       cancelled = true;
     };
@@ -10186,12 +10267,12 @@ function UpdateRecord({
   useEffect(() => {
     if (!dataSource || !recordId || isBatch) return;
     let cancelled = false;
-    (async () => {
+    const run = async () => {
       const { appSlug, dsSlug, labelField } = dataSource;
       const columns = ["autonumber_id", labelField?.slug].filter(Boolean);
       const endpoint = `/apps/${appSlug}/data-sources/${dsSlug}/items/${recordId}`;
       try {
-        const result = await apiClient.get(endpoint, { columns });
+        const result = await apiClient.get(endpoint, { columns: columns.join(",") });
         if (!cancelled && result.success && result.data) {
           setExistingRecord(result.data);
         }
@@ -10200,7 +10281,8 @@ function UpdateRecord({
           console.warn("[update-record] header fetch failed", err);
         }
       }
-    })();
+    };
+    void run();
     return () => {
       cancelled = true;
     };