@nocobase/portal-template-default 1.0.0 → 1.0.2

package/registry/nocobase-ai/tests/form-filler-regression.mjs

@@ -0,0 +1,129 @@
+import assert from "node:assert/strict";
+import { createServer } from "vite";
+
+const server = await createServer({
+  appType: "custom",
+  logLevel: "silent",
+  server: { middlewareMode: true },
+});
+
+try {
+  const { AIFormRegistry, createFormFillerInvoker } =
+    await server.ssrLoadModule(
+      "/registry/nocobase-ai/providers/form-registry.tsx"
+    );
+
+  const registry = new AIFormRegistry();
+  const applied = [];
+  const unregister = registry.register({
+    id: "lead-form",
+    title: "Lead form",
+    fields: [
+      { name: "company", type: "string" },
+      {
+        name: "priority",
+        type: "string",
+        enum: ["normal", "high"],
+      },
+      { name: "owner", type: "string", readonly: true },
+    ],
+    getValues: () => ({}),
+    setValues: (values) => applied.push(values),
+  });
+  const invoke = createFormFillerInvoker(registry);
+
+  const allowedContext = { allowedFormIds: ["lead-form"] };
+  assert.deepEqual(
+    await invoke(
+      {
+        form: "lead-form",
+        data: { company: "Acme", priority: "high" },
+      },
+      allowedContext
+    ),
+    {
+      status: "success",
+      content:
+        'Filled "Lead form". Please review the values and submit the form manually.',
+      appliedFields: ["company", "priority"],
+      skippedFields: [],
+    }
+  );
+  assert.deepEqual(applied, [{ company: "Acme", priority: "high" }]);
+
+  assert.deepEqual(
+    await invoke(
+      {
+        form: "lead-form",
+        data: { company: 42, owner: "Ada", unknown: true },
+      },
+      allowedContext
+    ),
+    {
+      status: "error",
+      content: 'No valid editable fields were provided for "Lead form".',
+      appliedFields: [],
+      skippedFields: [
+        {
+          name: "company",
+          reason: "invalid",
+          message: "Expected a string.",
+        },
+        {
+          name: "owner",
+          reason: "readonly",
+          message: "This field is read-only.",
+        },
+        {
+          name: "unknown",
+          reason: "undeclared",
+          message: "This field is not declared by the target form.",
+        },
+      ],
+    }
+  );
+
+  assert.throws(
+    () =>
+      registry.register({
+        id: "lead-form",
+        title: "Duplicate lead form",
+        fields: [],
+        getValues: () => ({}),
+        setValues: () => undefined,
+      }),
+    /already registered/
+  );
+
+  unregister();
+  assert.deepEqual(
+    await invoke(
+      { form: "lead-form", data: { company: "Acme" } },
+      allowedContext
+    ),
+    {
+      status: "error",
+      content: 'The target form "lead-form" is not available on this page.',
+      appliedFields: [],
+      skippedFields: [],
+    }
+  );
+
+  assert.deepEqual(
+    await invoke(
+      { form: "lead-form", data: { company: "Acme" } },
+      { allowedFormIds: [] }
+    ),
+    {
+      status: "error",
+      content:
+        'The target form "lead-form" is not available in this conversation context.',
+      appliedFields: [],
+      skippedFields: [],
+    }
+  );
+
+  console.log("AI Form filler regression tests passed");
+} finally {
+  await server.close();
+}

package/registry/nocobase-ai/tests/frontend-tool-regression.mjs

@@ -0,0 +1,128 @@
+import assert from "node:assert/strict";
+import { createServer } from "vite";
+
+const server = await createServer({
+  appType: "custom",
+  logLevel: "silent",
+  server: { middlewareMode: true },
+});
+
+try {
+  const { AIFrontendToolRegistry, createFrontendToolInvokers } =
+    await server.ssrLoadModule(
+      "/registry/nocobase-ai/providers/frontend-tool-registry.tsx"
+    );
+
+  const registry = new AIFrontendToolRegistry();
+  const calls = [];
+  const unregister = registry.register("quote-card", {
+    name: "update_quote_discount",
+    description: "Update the quote discount preview.",
+    permission: "ASK",
+    inputSchema: {
+      type: "object",
+      properties: { discountPercent: { type: "number" } },
+    },
+    execute: (args) => {
+      calls.push(args);
+      return { updated: true };
+    },
+  });
+  const [manifest] = registry.list("quote-card");
+  assert.deepEqual(manifest, {
+    id: "quote-card:update_quote_discount",
+    blockUid: "quote-card",
+    name: "update_quote_discount",
+    title: undefined,
+    description: "Update the quote discount preview.",
+    permission: "ASK",
+    inputSchema: {
+      type: "object",
+      properties: { discountPercent: { type: "number" } },
+    },
+  });
+
+  const invokers = createFrontendToolInvokers(registry);
+  const allowedContext = { allowedFrontendToolIds: [manifest.id] };
+  assert.deepEqual(
+    await invokers.loadFrontendTool({ toolId: manifest.id }, allowedContext),
+    manifest
+  );
+  assert.deepEqual(
+    await invokers.executeFrontendTool(
+      { toolId: manifest.id, args: { discountPercent: 12 } },
+      allowedContext
+    ),
+    { updated: true }
+  );
+  assert.deepEqual(calls, [{ discountPercent: 12 }]);
+
+  assert.throws(
+    () =>
+      registry.register("quote-card", {
+        name: "update_quote_discount",
+        description: "Duplicate Tool",
+        execute: () => undefined,
+      }),
+    /already registered/
+  );
+  assert.throws(
+    () =>
+      registry.register("quote-card", {
+        name: "invalid_schema",
+        description: "Invalid schema",
+        inputSchema: [],
+        execute: () => undefined,
+      }),
+    /inputSchema must be an object/
+  );
+
+  const unregisterInvalidResult = registry.register("quote-card", {
+    name: "invalid_result",
+    description: "Return an invalid result.",
+    execute: () => ({ value: 1n }),
+  });
+  assert.deepEqual(
+    await invokers.executeFrontendTool(
+      { toolId: "quote-card:invalid_result", args: {} },
+      {
+        allowedFrontendToolIds: ["quote-card:invalid_result"],
+      }
+    ),
+    {
+      status: "error",
+      content:
+        'Frontend Tool "quote-card:invalid_result" returned a non-serializable result',
+    }
+  );
+  unregisterInvalidResult();
+
+  unregister();
+  assert.deepEqual(
+    await invokers.executeFrontendTool(
+      { toolId: manifest.id, args: {} },
+      allowedContext
+    ),
+    {
+      status: "error",
+      content:
+        'Frontend Tool "quote-card:update_quote_discount" is unavailable',
+    }
+  );
+
+  assert.deepEqual(
+    await invokers.executeFrontendTool(
+      { toolId: manifest.id, args: {} },
+      { allowedFrontendToolIds: [] }
+    ),
+    {
+      status: "error",
+      content:
+        'Frontend Tool "quote-card:update_quote_discount" is not available in this conversation context',
+    }
+  );
+
+  console.log("AI frontend Tool regression tests passed");
+} finally {
+  await server.close();
+}

package/registry/nocobase-ai/tests/page-context-regression.mjs

@@ -0,0 +1,48 @@
+import assert from "node:assert/strict";
+import { createServer } from "vite";
+
+const server = await createServer({
+  appType: "custom",
+  logLevel: "silent",
+  server: { middlewareMode: true },
+});
+
+try {
+  const {
+    createAIPageContextReference,
+    getAIWorkContextRequiredTools,
+    mergeAIRequiredTools,
+  } = await server.ssrLoadModule(
+    "/registry/nocobase-ai/providers/page-context.tsx"
+  );
+
+  const formContext = createAIPageContextReference({
+    id: "lead-form",
+    title: "Lead form",
+    kind: "form",
+  });
+  assert.deepEqual(formContext, {
+    type: "page-element",
+    id: "lead-form",
+    title: "Lead form",
+    kind: "form",
+  });
+  assert.deepEqual(getAIWorkContextRequiredTools([formContext]), [
+    "formFiller",
+  ]);
+  assert.deepEqual(
+    mergeAIRequiredTools(
+      { skills: ["lead-review"], tools: ["inspect-record"] },
+      ["formFiller", "inspect-record"]
+    ),
+    {
+      skills: ["lead-review"],
+      tools: ["inspect-record", "formFiller"],
+    }
+  );
+  assert.equal(mergeAIRequiredTools(undefined, []), undefined);
+
+  console.log("AI page context regression tests passed");
+} finally {
+  await server.close();
+}

package/registry/nocobase-ai/tests/stream-regression.mjs

@@ -0,0 +1,207 @@
+import assert from "node:assert/strict";
+import { createServer } from "vite";
+
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+const encodeSSE = (events) => {
+  const encoder = new TextEncoder();
+  return new ReadableStream({
+    start(controller) {
+      controller.enqueue(
+        encoder.encode(
+          events.map((event) => `data: ${JSON.stringify(event)}\n\n`).join("")
+        )
+      );
+      controller.close();
+    },
+  });
+};
+
+const collectStream = async (stream) => {
+  const result = [];
+  for await (const chunk of stream) result.push(chunk);
+  return result;
+};
+
+const server = await createServer({
+  appType: "custom",
+  logLevel: "silent",
+  server: { middlewareMode: true },
+});
+
+try {
+  const { StreamCoalescer } = await server.ssrLoadModule(
+    "/registry/nocobase-ai/providers/stream-coalescer.ts"
+  );
+  const { NocoBaseChatTransport } = await server.ssrLoadModule(
+    "/registry/nocobase-ai/providers/chat-transport.ts"
+  );
+  const { SubAgentStreamAccumulator } = await server.ssrLoadModule(
+    "/registry/nocobase-ai/providers/sub-agent-stream.ts"
+  );
+  const { NocoBaseClient } = await server.ssrLoadModule(
+    "/src/lib/nocobase/client.ts"
+  );
+
+  {
+    const client = new NocoBaseClient("http://localhost:13001/api");
+    assert.equal(
+      client.resolveUrl("/files/main/main/aiFiles/5.png?preview=1"),
+      "http://localhost:13001/files/main/main/aiFiles/5.png?preview=1"
+    );
+    assert.equal(
+      client.resolveUrl("https://cdn.example.com/file.png"),
+      "https://cdn.example.com/file.png"
+    );
+  }
+
+  {
+    const flushed = [];
+    const coalescer = new StreamCoalescer({
+      interval: 20,
+      maxSize: 100,
+      getSize: (value) => value.length,
+      merge: (current, incoming) => current + incoming,
+      onFlush: (key, value) => flushed.push([key, value]),
+    });
+    coalescer.push("message", "hello ");
+    coalescer.push("message", "world");
+    await wait(35);
+    assert.deepEqual(flushed, [["message", "hello world"]]);
+  }
+
+  {
+    const seedMessage = {
+      id: "assistant-existing",
+      role: "assistant",
+      parts: [
+        {
+          type: "data-subAgent",
+          id: "sub-1",
+          data: {
+            sessionId: "sub-1",
+            username: "viz",
+            status: "pending",
+            messages: [
+              {
+                id: "sub-message",
+                role: "assistant",
+                parts: [{ type: "text", text: "saved ", state: "done" }],
+              },
+            ],
+          },
+        },
+      ],
+    };
+    const accumulator = new SubAgentStreamAccumulator(seedMessage);
+    const [chunk] = accumulator.process({
+      type: "content",
+      body: "tail",
+      from: "sub-agent",
+      sessionId: "sub-1",
+      username: "viz",
+    });
+    assert.equal(chunk.data.messages.length, 1);
+    assert.equal(chunk.data.messages[0].parts[0].text, "saved tail");
+  }
+
+  {
+    const toolCallId = "report-tool";
+    const events = [
+      ...Array.from({ length: 100 }, (_, index) => ({
+        type: "tool_call_chunks",
+        from: "main-agent",
+        sessionId: "conversation-1",
+        body: [
+          index === 0
+            ? {
+                id: toolCallId,
+                name: "businessReportGenerator",
+                args: "{",
+              }
+            : { id: toolCallId, args: "x" },
+        ],
+      })),
+      { type: "stream_end", from: "main-agent", sessionId: "conversation-1" },
+    ];
+    const service = {
+      resumeConversationStream: async () => encodeSSE(events),
+    };
+    const transport = new NocoBaseChatTransport({
+      service,
+      getContext: () => ({
+        sessionId: "conversation-1",
+        employee: { username: "atlas", nickname: "Atlas" },
+        model: { value: "test", label: "Test" },
+      }),
+    });
+    transport.prepareConversationResume([
+      { id: "assistant-existing", role: "assistant", parts: [] },
+    ]);
+    const chunks = await collectStream(await transport.reconnectToStream());
+    const start = chunks.find((chunk) => chunk.type === "start");
+    const toolDeltas = chunks.filter(
+      (chunk) => chunk.type === "tool-input-delta"
+    );
+    assert.equal(start.messageId, undefined);
+    assert.ok(toolDeltas.length < 10, `received ${toolDeltas.length} deltas`);
+    assert.equal(
+      toolDeltas.reduce((size, chunk) => size + chunk.inputTextDelta.length, 0),
+      100
+    );
+  }
+
+  {
+    let request;
+    const service = {
+      sendMessagesStream: async (input) => {
+        request = input;
+        return encodeSSE([
+          { type: "content", body: "ok", from: "main-agent" },
+          { type: "stream_end", from: "main-agent" },
+        ]);
+      },
+    };
+    const transport = new NocoBaseChatTransport({
+      service,
+      getContext: () => ({
+        sessionId: "conversation-context",
+        employee: { username: "mira", nickname: "Mira" },
+        model: { value: "test", label: "Test" },
+      }),
+    });
+    await collectStream(
+      await transport.sendMessages({
+        messages: [
+          {
+            id: "user-context",
+            role: "user",
+            metadata: {
+              workContext: [
+                {
+                  type: "page-element",
+                  id: "customer-form",
+                  title: "Customer form",
+                  content: { values: { name: "Northwind" } },
+                },
+              ],
+            },
+            parts: [{ type: "text", text: "Review this form" }],
+          },
+        ],
+      })
+    );
+    assert.deepEqual(request.messages[0].workContext, [
+      {
+        type: "page-element",
+        id: "customer-form",
+        title: "Customer form",
+        content: { values: { name: "Northwind" } },
+      },
+    ]);
+  }
+
+  console.log("AI stream regression tests passed");
+} finally {
+  await server.close();
+}

package/registry/nocobase-i18n/README.md

@@ -0,0 +1,53 @@
+# NocoBase i18n
+
+Optional frontend-owned internationalization for the NocoBase Admin Starter.
+
+The Registry connects i18next to the application translation provider, persists
+the selected locale through the Starter's shared NocoBase client, sends it as
+`X-Locale`, and adds a reusable language switcher to the signed-in user menu.
+Its integrated Demo route shows the complete configuration model without
+requiring a second Registry item.
+
+Starter and Registry UI resources remain frontend-owned. At startup the runtime
+reads `enabledLanguages` from `systemSettings:get` and merges only registered
+dynamic NocoBase namespaces from `app:getLang`; `lm-collections` is registered
+by default so collection and field translations remain compatible.
+
+Application-owned React translations belong in `src/locales`, outside the
+installed Registry directory. Register them through the Starter-level
+`registerTranslationResources` helper so the application remains buildable when
+the optional i18n Registry is not installed. When this Registry is present, it
+consumes both resources registered before startup and resources added later by
+lazy features.
+
+On NocoBase versions that support filtered language resources, the request uses
+`app:getLang?ns=lm-collections,...`. Older servers ignore the query parameter;
+the client still merges only registered namespaces, so the integration remains
+backward compatible.
+
+Other installed components can register their own namespace without changing
+the runtime:
+
+```ts
+import { registerLocaleResources } from "@/extensions/nocobase-i18n";
+
+registerLocaleResources("my-extension", {
+  "en-US": { title: "Orders" },
+  "zh-CN": { title: "订单" },
+});
+```
+
+If a component relies on another server-generated namespace, opt in explicitly:
+
+```ts
+import { registerServerResourceNamespace } from "@/extensions/nocobase-i18n";
+
+registerServerResourceNamespace("my-dynamic-namespace");
+```
+
+Namespaces registered after application startup are loaded incrementally, so
+lazy Registry components do not need to participate in the initial request.
+
+Use the application's `useTranslate` hook in React components. Existing exact
+NocoBase-style expressions such as `{{t("Orders")}}` and expressions with a
+string namespace are resolved through the Starter compatibility helper.

package/registry/nocobase-i18n/components/index.ts

@@ -0,0 +1 @@
+export * from "./language-switcher";

package/registry/nocobase-i18n/components/language-switcher.tsx

@@ -0,0 +1,138 @@
+import { useGetLocale, useSetLocale, useTranslate } from "@refinedev/core";
+import { Languages, Loader2 } from "lucide-react";
+import { useState, type ReactNode } from "react";
+
+import {
+  DropdownMenuRadioGroup,
+  DropdownMenuRadioItem,
+  DropdownMenuSeparator,
+  DropdownMenuSub,
+  DropdownMenuSubContent,
+  DropdownMenuSubTrigger,
+} from "@/components/ui/dropdown-menu";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import { cn } from "@/lib/utils";
+import { useEnabledLocales } from "../locale-store";
+
+export type LanguageSwitcherProps = {
+  className?: string;
+  label?: ReactNode | false;
+  triggerClassName?: string;
+};
+
+export function LanguageSwitcher({
+  className,
+  label,
+  triggerClassName,
+}: LanguageSwitcherProps) {
+  const translate = useTranslate();
+  const getLocale = useGetLocale();
+  const setLocale = useSetLocale();
+  const locales = useEnabledLocales();
+  const currentLocale = getLocale();
+  const [switching, setSwitching] = useState(false);
+  const [error, setError] = useState<string>();
+  const resolvedLabel =
+    typeof label === "undefined"
+      ? translate("language.label", { ns: "nocobase-i18n" }, "Language")
+      : label;
+
+  if (locales.length < 2) return null;
+
+  const currentDefinition =
+    locales.find(({ locale }) => locale === currentLocale) ?? locales[0];
+
+  return (
+    <div className={cn("space-y-2", className)}>
+      {resolvedLabel === false ? null : (
+        <p className="text-xs font-medium text-muted-foreground">
+          {resolvedLabel}
+        </p>
+      )}
+      <Select
+        value={currentLocale}
+        disabled={switching}
+        onValueChange={(value) => {
+          if (!value || value === currentLocale) return;
+          setSwitching(true);
+          setError(undefined);
+          Promise.resolve(setLocale(value)).catch((reason) => {
+            setError(
+              reason instanceof Error
+                ? reason.message
+                : translate(
+                    "language.switchError",
+                    { ns: "nocobase-i18n" },
+                    "Unable to switch language."
+                  )
+            );
+            setSwitching(false);
+          });
+        }}
+      >
+        <SelectTrigger
+          className={cn("w-full min-w-52", triggerClassName)}
+          aria-label={String(resolvedLabel || "Language")}
+        >
+          {switching ? <Loader2 className="animate-spin" /> : <Languages />}
+          <SelectValue>{currentDefinition?.label ?? currentLocale}</SelectValue>
+        </SelectTrigger>
+        <SelectContent>
+          {locales.map((definition) => (
+            <SelectItem key={definition.locale} value={definition.locale}>
+              {definition.label}
+            </SelectItem>
+          ))}
+        </SelectContent>
+      </Select>
+      {error ? <p className="text-xs text-destructive">{error}</p> : null}
+    </div>
+  );
+}
+
+export function LanguageUserMenuItems() {
+  const translate = useTranslate();
+  const getLocale = useGetLocale();
+  const setLocale = useSetLocale();
+  const locales = useEnabledLocales();
+  const currentLocale = getLocale();
+
+  if (locales.length < 2) return null;
+
+  return (
+    <>
+      <DropdownMenuSeparator />
+      <DropdownMenuSub>
+        <DropdownMenuSubTrigger className="min-h-9 gap-2 px-2 text-muted-foreground focus:text-foreground">
+          <Languages />
+          <span>
+            {translate("language.label", { ns: "nocobase-i18n" }, "Language")}
+          </span>
+        </DropdownMenuSubTrigger>
+        <DropdownMenuSubContent className="min-w-44">
+          <DropdownMenuRadioGroup
+            value={currentLocale}
+            onValueChange={(value) => {
+              if (value && value !== currentLocale) void setLocale(value);
+            }}
+          >
+            {locales.map((definition) => (
+              <DropdownMenuRadioItem
+                key={definition.locale}
+                value={definition.locale}
+              >
+                {definition.label}
+              </DropdownMenuRadioItem>
+            ))}
+          </DropdownMenuRadioGroup>
+        </DropdownMenuSubContent>
+      </DropdownMenuSub>
+    </>
+  );
+}