@nocobase/portal-template-default 1.0.0 → 1.0.1

package/src/providers/data.ts

@@ -22,7 +22,13 @@ import type {
   UpdateResponse,
 } from "@refinedev/core";
 
-import { API_URL, getNocoBaseHeaders, NOCOBASE_TOKEN_KEY } from "./constants";
+import { nocobaseClient } from "@/lib/nocobase/client";
+import {
+  notifyRecordPermissionsChanged,
+  resolveAclDataSourceKey,
+  type ResourceAcl,
+  updateRecordPermissions,
+} from "@/lib/nocobase/acl";
 
 type NocoBaseListResponse<T> = {
   rows?: T[];
@@ -30,23 +36,30 @@ type NocoBaseListResponse<T> = {
   data?: T[] | NocoBaseListResponse<T>;
   meta?: {
     count?: number;
+    allowedActions?: Record<string, Array<string | number>>;
+  };
+  allowedActions?: Record<string, Array<string | number>>;
+};
+
+type NocoBaseGetResponse<T> = {
+  data?: T;
+  meta?: {
+    allowedActions?: Record<string, Array<string | number>>;
   };
 };
 
 type NocoBaseMeta = MetaQuery & {
   appends?: string[];
   token?: string;
+  dataSourceKey?: string;
+  idField?: string;
+  acl?: ResourceAcl;
 };
 
 type NocoBaseFilter = Record<string, unknown>;
 
-const getToken = (meta?: NocoBaseMeta) =>
-  meta?.token ??
-  localStorage.getItem(NOCOBASE_TOKEN_KEY) ??
-  import.meta.env.NOCOBASE_API_TOKEN;
-
 const toNocoBaseFilter = (
-  filters: GetListParams["filters"] = [],
+  filters: GetListParams["filters"] = []
 ): NocoBaseFilter | undefined => {
   const filterItems: NocoBaseFilter[] = filters.flatMap((filter) => {
     if ("field" in filter) {
@@ -81,31 +94,6 @@ const toNocoBaseFilter = (
   return filterItems.length === 1 ? filterItems[0] : { $and: filterItems };
 };
 
-const buildUrl = (
-  resource: string,
-  action: string,
-  query: Record<string, string | number | undefined> = {},
-  meta?: NocoBaseMeta,
-) => {
-  const endpoint = `${API_URL.replace(/\/$/, "")}/${resource}:${action}`;
-  const url = endpoint.startsWith("http://") || endpoint.startsWith("https://")
-    ? new URL(endpoint)
-    : new URL(endpoint, window.location.origin);
-
-  for (const [key, value] of Object.entries(query)) {
-    if (value !== undefined) url.searchParams.set(key, String(value));
-  }
-
-  meta?.appends?.forEach((append) => url.searchParams.append("appends[]", append));
-  if (Array.isArray(meta?.fields)) {
-    meta.fields
-      .filter((field): field is string => typeof field === "string")
-      .forEach((field) => url.searchParams.append("fields[]", field));
-  }
-
-  return url;
-};
-
 const request = async <T>(
   resource: string,
   action: string,
@@ -115,30 +103,70 @@ const request = async <T>(
     body?: unknown;
     meta?: NocoBaseMeta;
     unwrapData?: boolean;
-  } = {},
+  } = {}
 ): Promise<T> => {
-  const token = getToken(options.meta);
-  const response = await fetch(buildUrl(resource, action, options.query, options.meta), {
-    method: options.method ?? "GET",
-    headers: getNocoBaseHeaders({
-      token,
-      includeContentType: Boolean(options.body),
-    }),
-    body: options.body ? JSON.stringify(options.body) : undefined,
+  const dataSourceKey = resolveAclDataSourceKey(options.meta);
+  const fields = Array.isArray(options.meta?.fields)
+    ? options.meta.fields.filter(
+        (field): field is string => typeof field === "string"
+      )
+    : undefined;
+  return nocobaseClient.action<T>(resource, action, {
+    method: options.method,
+    query: {
+      ...options.query,
+      ...(options.meta?.appends?.length
+        ? { "appends[]": options.meta.appends }
+        : {}),
+      ...(fields?.length ? { "fields[]": fields } : {}),
+    },
+    body: options.body,
+    token: options.meta?.token,
+    headers: dataSourceKey
+      ? { "X-Data-Source": dataSourceKey }
+      : undefined,
+    unwrap: options.unwrapData === false ? "none" : "data",
   });
+};
 
-  const payload = await response.json().catch(() => undefined);
-  if (!response.ok) {
-    throw new Error(
-      payload?.errors?.[0]?.message ?? payload?.message ?? `NocoBase request failed (${response.status})`,
-    );
-  }
+const getAllowedActions = (response: NocoBaseListResponse<unknown>) =>
+  response.meta?.allowedActions ??
+  response.allowedActions ??
+  (!Array.isArray(response.data) && response.data
+    ? response.data.meta?.allowedActions ?? response.data.allowedActions
+    : undefined);
 
-  // Most NocoBase resource actions return their record in `data`. List endpoints
-  // can also return `{ data: [...], meta: { count } }`, which must stay intact.
-  return (options.unwrapData === false ? payload : payload?.data ?? payload) as T;
+const cacheAllowedActions = <TData extends BaseRecord>({
+  resource,
+  records,
+  response,
+  meta,
+}: {
+  resource: string;
+  records: TData[];
+  response: NocoBaseListResponse<TData>;
+  meta?: NocoBaseMeta;
+}) => {
+  const idField = meta?.idField ?? "id";
+  const dataSourceKey = resolveAclDataSourceKey(meta);
+  const recordIds = records
+    .map((record) => record[idField])
+    .filter(
+      (id): id is string | number =>
+        typeof id === "string" || typeof id === "number"
+    );
+  return updateRecordPermissions({
+    dataSourceKey,
+    resource,
+    recordIds,
+    allowedActions: getAllowedActions(response),
+  });
 };
 
+const getResponseData = <TData extends BaseRecord>(
+  response: NocoBaseGetResponse<TData>
+) => response.data ?? (response as TData);
+
 export const dataProvider: DataProvider = {
   async getList<TData extends BaseRecord = BaseRecord>({
     resource,
@@ -150,51 +178,144 @@ export const dataProvider: DataProvider = {
     const page = pagination?.currentPage ?? 1;
     const pageSize = pagination?.pageSize ?? 10;
     const filter = toNocoBaseFilter(filters);
-    const sort = sorters?.map((sorter) => `${sorter.order === "desc" ? "-" : ""}${sorter.field}`);
-    const response = await request<NocoBaseListResponse<TData>>(resource, "list", {
-      query: {
-        page,
-        pageSize,
-        ...(filter ? { filter: JSON.stringify(filter) } : {}),
-        ...(sort?.length ? { sort: sort.join(",") } : {}),
-      },
-      meta,
-      unwrapData: false,
-    });
+    const sort = sorters?.map(
+      (sorter) => `${sorter.order === "desc" ? "-" : ""}${sorter.field}`
+    );
+    const response = await request<NocoBaseListResponse<TData>>(
+      resource,
+      "list",
+      {
+        query: {
+          page,
+          pageSize,
+          ...(filter ? { filter: JSON.stringify(filter) } : {}),
+          ...(sort?.length ? { sort: sort.join(",") } : {}),
+        },
+        meta,
+        unwrapData: false,
+      }
+    );
 
     const list = Array.isArray(response.data)
       ? { rows: response.data, count: response.meta?.count }
       : response.data ?? response;
+    const records = list.rows ?? [];
+    if (cacheAllowedActions({ resource, records, response, meta })) {
+      notifyRecordPermissionsChanged();
+    }
 
     return {
-      data: list.rows ?? [],
-      total: list.count ?? list.rows?.length ?? 0,
+      data: records,
+      total: list.count ?? records.length,
+      meta: response.meta,
     };
   },
 
-  async getOne<TData extends BaseRecord = BaseRecord>({ resource, id, meta }: GetOneParams): Promise<GetOneResponse<TData>> {
-    return { data: await request<TData>(resource, "get", { query: { filterByTk: id }, meta }) };
+  async getOne<TData extends BaseRecord = BaseRecord>({
+    resource,
+    id,
+    meta,
+  }: GetOneParams): Promise<GetOneResponse<TData>> {
+    const response = await request<NocoBaseGetResponse<TData>>(
+      resource,
+      "get",
+      {
+        query: { filterByTk: id },
+        meta,
+        unwrapData: false,
+      }
+    );
+    const data = getResponseData(response);
+    if (
+      cacheAllowedActions({
+        resource,
+        records: [data],
+        response: response as NocoBaseListResponse<TData>,
+        meta,
+      })
+    ) {
+      notifyRecordPermissionsChanged();
+    }
+    return {
+      data,
+    };
   },
 
-  async getMany<TData extends BaseRecord = BaseRecord>({ resource, ids, meta }: GetManyParams): Promise<GetManyResponse<TData>> {
-    const data = await Promise.all(
-      ids.map((id) => request<TData>(resource, "get", { query: { filterByTk: id }, meta })),
+  async getMany<TData extends BaseRecord = BaseRecord>({
+    resource,
+    ids,
+    meta,
+  }: GetManyParams): Promise<GetManyResponse<TData>> {
+    const responses = await Promise.all(
+      ids.map((id) =>
+        request<NocoBaseGetResponse<TData>>(resource, "get", {
+          query: { filterByTk: id },
+          meta,
+          unwrapData: false,
+        })
+      )
     );
+    const data = responses.map(getResponseData);
+    let permissionsChanged = false;
+    responses.forEach((response, index) => {
+      permissionsChanged =
+        cacheAllowedActions({
+          resource,
+          records: [data[index]],
+          response: response as NocoBaseListResponse<TData>,
+          meta,
+        }) || permissionsChanged;
+    });
+    if (permissionsChanged) notifyRecordPermissionsChanged();
     return { data };
   },
 
-  async create<TData extends BaseRecord = BaseRecord, TVariables = {}>({ resource, variables, meta }: CreateParams<TVariables>): Promise<CreateResponse<TData>> {
-    return { data: await request<TData>(resource, "create", { method: "POST", body: variables, meta }) };
+  async create<
+    TData extends BaseRecord = BaseRecord,
+    TVariables = Record<string, unknown>
+  >({
+    resource,
+    variables,
+    meta,
+  }: CreateParams<TVariables>): Promise<CreateResponse<TData>> {
+    return {
+      data: await request<TData>(resource, "create", {
+        method: "POST",
+        body: variables,
+        meta,
+      }),
+    };
   },
 
-  async createMany<TData extends BaseRecord = BaseRecord, TVariables = {}>({ resource, variables, meta }: CreateManyParams<TVariables>): Promise<CreateManyResponse<TData>> {
+  async createMany<
+    TData extends BaseRecord = BaseRecord,
+    TVariables = Record<string, unknown>
+  >({
+    resource,
+    variables,
+    meta,
+  }: CreateManyParams<TVariables>): Promise<CreateManyResponse<TData>> {
     const data = await Promise.all(
-      variables.map((values) => request<TData>(resource, "create", { method: "POST", body: values, meta })),
+      variables.map((values) =>
+        request<TData>(resource, "create", {
+          method: "POST",
+          body: values,
+          meta,
+        })
+      )
     );
     return { data };
   },
 
-  async update<TData extends BaseRecord = BaseRecord, TVariables = {}>({ resource, id, variables, meta }: UpdateParams<TVariables>): Promise<UpdateResponse<TData>> {
+  async update<
+    TData extends BaseRecord = BaseRecord,
+    TVariables = Record<string, unknown>
+  >({
+    resource,
+    id,
+    variables,
+    meta,
+  }: UpdateParams<TVariables>): Promise<UpdateResponse<TData>> {
     return {
       data: await request<TData>(resource, "update", {
         method: "POST",
@@ -205,28 +326,64 @@ export const dataProvider: DataProvider = {
     };
   },
 
-  async updateMany<TData extends BaseRecord = BaseRecord, TVariables = {}>({ resource, ids, variables, meta }: UpdateManyParams<TVariables>): Promise<UpdateManyResponse<TData>> {
+  async updateMany<
+    TData extends BaseRecord = BaseRecord,
+    TVariables = Record<string, unknown>
+  >({
+    resource,
+    ids,
+    variables,
+    meta,
+  }: UpdateManyParams<TVariables>): Promise<UpdateManyResponse<TData>> {
     const data = await Promise.all(
-      ids.map((id) => request<TData>(resource, "update", {
-        method: "POST",
-        query: { filterByTk: id },
-        body: variables,
-        meta,
-      })),
+      ids.map((id) =>
+        request<TData>(resource, "update", {
+          method: "POST",
+          query: { filterByTk: id },
+          body: variables,
+          meta,
+        })
+      )
     );
     return { data };
   },
 
-  async deleteOne<TData extends BaseRecord = BaseRecord, TVariables = {}>({ resource, id, meta }: DeleteOneParams<TVariables>): Promise<DeleteOneResponse<TData>> {
-    return { data: await request<TData>(resource, "destroy", { method: "POST", query: { filterByTk: id }, meta }) };
+  async deleteOne<
+    TData extends BaseRecord = BaseRecord,
+    TVariables = Record<string, unknown>
+  >({
+    resource,
+    id,
+    meta,
+  }: DeleteOneParams<TVariables>): Promise<DeleteOneResponse<TData>> {
+    return {
+      data: await request<TData>(resource, "destroy", {
+        method: "POST",
+        query: { filterByTk: id },
+        meta,
+      }),
+    };
   },
 
-  async deleteMany<TData extends BaseRecord = BaseRecord, TVariables = {}>({ resource, ids, meta }: DeleteManyParams<TVariables>): Promise<DeleteManyResponse<TData>> {
+  async deleteMany<
+    TData extends BaseRecord = BaseRecord,
+    TVariables = Record<string, unknown>
+  >({
+    resource,
+    ids,
+    meta,
+  }: DeleteManyParams<TVariables>): Promise<DeleteManyResponse<TData>> {
     const data = await Promise.all(
-      ids.map((id) => request<TData>(resource, "destroy", { method: "POST", query: { filterByTk: id }, meta })),
+      ids.map((id) =>
+        request<TData>(resource, "destroy", {
+          method: "POST",
+          query: { filterByTk: id },
+          meta,
+        })
+      )
     );
     return { data };
   },
 
-  getApiUrl: () => API_URL,
+  getApiUrl: () => nocobaseClient.getApiUrl(),
 };

package/vite.config.ts

@@ -60,6 +60,23 @@ export default defineConfig(({ mode }) => {
               target: proxyTarget,
               changeOrigin: true,
               secure: false,
+              configure(proxy) {
+                proxy.on("proxyReq", (proxyRequest, request) => {
+                  if (!request.url?.includes("aiConversations:")) return;
+                  proxyRequest.setHeader("accept-encoding", "identity");
+                  proxyRequest.setHeader("cache-control", "no-cache");
+                });
+                proxy.on("proxyRes", (proxyResponse) => {
+                  const contentType = String(
+                    proxyResponse.headers["content-type"] ?? ""
+                  );
+                  if (!contentType.includes("text/event-stream")) return;
+                  delete proxyResponse.headers["content-length"];
+                  proxyResponse.headers["cache-control"] =
+                    "no-cache, no-transform";
+                  proxyResponse.headers["x-accel-buffering"] = "no";
+                });
+              },
               headers: proxyOrigin
                 ? {
                     origin: proxyOrigin,