@object-ui/app-shell 11.3.0 → 11.4.0

package/dist/views/RelatedRecordActionsBridge.js

@@ -0,0 +1,114 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * RelatedRecordActionsBridge — supplies the console's object-aware CRUD +
+ * action handlers to the `record:related_list` renderers on a detail page.
+ *
+ * The renderer (in `@object-ui/plugin-detail`) knows the child object, the FK
+ * back to the parent, and the parent id — but not the SPA routes, the
+ * create/edit form pages, or the per-object lifecycle affordances. This bridge
+ * (mounted inside the page's `ActionProvider`) closes that gap:
+ *
+ *   - 查看详情 → navigate to the child record's detail route
+ *   - 增        → navigate to the child's `/new` page, pre-linking the parent
+ *                 via `?<relationshipField>=<parentId>` (the convention
+ *                 RecordFormPage already reads as create-mode initial values)
+ *   - 改        → navigate to the child record's `/edit` page
+ *   - 删        → `dataSource.delete(child, id)` (RelatedList shows the confirm
+ *                 dialog and refreshes afterwards)
+ *   - 子对象 action → the child object's `list_item` actions, executed against
+ *                 the clicked row through the page's shared ActionRunner
+ *
+ * Each affordance is gated by {@link resolveCrudAffordances} so system /
+ * append-only children never show New / Edit / Delete. When this bridge is
+ * absent (e.g. the Studio designer) the related list stays read-only.
+ */
+import { useCallback, useMemo } from 'react';
+import { useNavigate } from 'react-router-dom';
+import { RelatedRecordActionsProvider, useAction, } from '@object-ui/react';
+import { resolveCrudAffordances } from '../utils/crudAffordances';
+/** Notify open related lists for `objectName` to refetch (see RelatedList). */
+export function notifyRelatedChanged(objectName) {
+    if (typeof window === 'undefined')
+        return;
+    window.dispatchEvent(new CustomEvent('objectui:related-changed', { detail: { objectName } }));
+}
+/**
+ * Derive the child object's row actions (metadata `actions` filtered to the
+ * `list_item` location), localized and shaped for the related-list row menu.
+ */
+function deriveRowActions(childDef, actionLabel) {
+    const actions = Array.isArray(childDef?.actions) ? childDef.actions : [];
+    return actions
+        .filter((a) => Array.isArray(a?.locations) && a.locations.includes('list_item'))
+        .map((a) => ({
+        ...a,
+        label: actionLabel(childDef.name, a.name, a.label || a.name),
+    }));
+}
+export function RelatedRecordActionsBridge({ appName, objects, dataSource, actionLabel, children, }) {
+    const navigate = useNavigate();
+    const { execute } = useAction();
+    const base = appName ? `/apps/${appName}` : '';
+    // Execute a child object's row action against the clicked record. Reuses the
+    // page's ActionRunner (confirm dialog, toast, param collection are handled by
+    // it) but retargets it at the CHILD object + row via the action's
+    // `objectName` / `recordId`, which the record-detail action handlers honor.
+    const runRowAction = useCallback(async (childObject, record, action) => {
+        const id = record?.id ?? record?._id;
+        const def = {
+            ...action,
+            objectName: childObject,
+            ...(id != null ? { recordId: String(id) } : {}),
+            params: { ...action.params },
+        };
+        const res = await execute(def);
+        // Refresh open related lists for this child object after a successful
+        // mutating action (the row menu handler is otherwise fire-and-forget).
+        if (res?.success)
+            notifyRelatedChanged(childObject);
+    }, [execute]);
+    const value = useMemo(() => ({
+        resolve: ({ objectName, relationshipField, parentId }) => {
+            const childDef = objects.find((o) => o?.name === objectName);
+            if (!childDef || !base)
+                return {};
+            const aff = resolveCrudAffordances(childDef);
+            const detailUrl = (id) => `${base}/${objectName}/record/${encodeURIComponent(String(id))}`;
+            const handlers = {
+                // Viewing a child record is always allowed when the list is visible.
+                onView: (id) => navigate(detailUrl(id)),
+            };
+            if (aff.create) {
+                handlers.onCreate = () => {
+                    const canLink = relationshipField && parentId != null && parentId !== '';
+                    const qs = canLink
+                        ? `?${encodeURIComponent(relationshipField)}=${encodeURIComponent(String(parentId))}`
+                        : '';
+                    navigate(`${base}/${objectName}/new${qs}`);
+                };
+            }
+            if (aff.edit) {
+                handlers.onEdit = (id) => navigate(`${detailUrl(id)}/edit`);
+            }
+            if (aff.delete) {
+                handlers.onDelete = async (id) => {
+                    await dataSource?.delete?.(objectName, String(id));
+                };
+            }
+            const rowActions = deriveRowActions(childDef, actionLabel);
+            if (rowActions.length > 0) {
+                handlers.rowActions = rowActions;
+                handlers.onRowAction = (action, record) => runRowAction(objectName, record, action);
+            }
+            return handlers;
+        },
+    }), [objects, base, navigate, dataSource, actionLabel, runRowAction]);
+    return (_jsx(RelatedRecordActionsProvider, { value: value, children: children }));
+}

package/dist/views/metadata-admin/PackagesPage.js

@@ -44,16 +44,23 @@ async function apiJson(path, init) {
 /* -------------------------------------------------------------------------- */
 function ScopeBadge({ scope }) {
     const locale = React.useMemo(() => detectLocale(), []);
-    const s = scope ?? 'project';
-    const variant = s === 'project' ? 'default' : s === 'system' ? 'secondary' : 'outline';
-    const labelKey = s === 'project'
+    // Writability semantics, aligned with the builder (studio-design/packages-io):
+    // a SCOPE-LESS entry is a database base package (writable — authoring lives
+    // there), while `project` marks a read-only code package. Defaulting the
+    // missing scope to 'project' used to render both with the same badge, which
+    // contradicted the builder's 可写/只读 labeling for the very same package.
+    if (!scope) {
+        return (_jsx(Badge, { className: "bg-emerald-400/15 text-emerald-600 hover:bg-emerald-400/15 dark:text-emerald-300", children: t('engine.packages.scope.writable', locale) }));
+    }
+    const variant = scope === 'project' ? 'default' : scope === 'system' ? 'secondary' : 'outline';
+    const labelKey = scope === 'project'
         ? 'engine.packages.scope.project'
-        : s === 'system'
+        : scope === 'system'
             ? 'engine.packages.scope.system'
-            : s === 'cloud'
+            : scope === 'cloud'
                 ? 'engine.packages.scope.cloud'
                 : '';
-    return _jsx(Badge, { variant: variant, children: labelKey ? t(labelKey, locale) : s });
+    return _jsx(Badge, { variant: variant, children: labelKey ? t(labelKey, locale) : scope });
 }
 function StatusBadge({ pkg }) {
     const locale = React.useMemo(() => detectLocale(), []);
@@ -99,7 +106,11 @@ export function CreatePackageDialog({ open, onOpenChange, onCreated, }) {
                         name: name.trim(),
                         version: version.trim(),
                         type: 'app',
-                        scope: 'project',
+                        // No `scope`: runtime-created base packages are writable authoring
+                        // targets. `scope: 'project'` marks read-only CODE packages — the
+                        // old hardcode here made Setup-created bases read as 只读 in the
+                        // builder's switcher/landing while the builder's own creator made
+                        // writable ones. One creation semantic everywhere now.
                     },
                 }),
             });

package/dist/views/metadata-admin/PermissionMatrixEditor.d.ts

@@ -35,5 +35,22 @@ import * as React from 'react';
 export interface PermissionMatrixEditPageProps {
     type: string;
     name: string;
+    /**
+     * When set, the matrix is scoped to a single package (ADR-0086 P0): it lists
+     * only the objects that package declares, and Save merges just that slice
+     * back — other packages' contributed rows are left untouched. When omitted,
+     * the matrix operates at environment scope (all objects, whole-record save).
+     */
+    packageId?: string;
+    /**
+     * ADR-0086 P2 (D6/D7 — the package door). When editing under a `packageId`,
+     * a permission set is package **metadata**: Save writes a **draft** (not a
+     * live record), published atomically with the rest of the package. `onDraftSaved`
+     * notifies the surface so its pending-changes counter refreshes; `publishNonce`
+     * bumps on publish so the editor re-reads the now-published baseline (its draft
+     * is gone). Both are no-ops at environment scope, where Save stays live (D7).
+     */
+    onDraftSaved?: () => void;
+    publishNonce?: number;
 }
-export declare function PermissionMatrixEditPage({ type, name }: PermissionMatrixEditPageProps): React.JSX.Element;
+export declare function PermissionMatrixEditPage({ type, name, packageId, onDraftSaved, publishNonce }: PermissionMatrixEditPageProps): React.JSX.Element;

package/dist/views/metadata-admin/PermissionMatrixEditor.js

@@ -48,6 +48,7 @@ import { useMetadataClient, useMetadataTypes } from './useMetadata';
 import { resolveResourceConfig } from './registry';
 import { t as translate, detectLocale } from './i18n';
 import { AssignedUsersSection } from './AssignedUsersSection';
+import { mergePermissionSlice, scopePermissionSet, } from './permission-slice';
 function getObjectActions(locale) {
     return [
         { key: 'allowCreate', short: 'C', tip: translate('perm.action.create', locale) },
@@ -64,7 +65,7 @@ function getObjectActions(locale) {
 /* ────────────────────────────────────────────────────────────────── */
 /* Component                                                          */
 /* ────────────────────────────────────────────────────────────────── */
-export function PermissionMatrixEditPage({ type, name }) {
+export function PermissionMatrixEditPage({ type, name, packageId, onDraftSaved, publishNonce }) {
     const navigate = useNavigate();
     const client = useMetadataClient();
     const { entries } = useMetadataTypes(client);
@@ -94,20 +95,27 @@ export function PermissionMatrixEditPage({ type, name }) {
         setLoading(true);
         (async () => {
             try {
-                const [lay, objList] = await Promise.all([
+                const [lay, objList, pendingDraft] = await Promise.all([
                     client.layered(type, name).catch(() => null),
-                    client.list('object').catch(() => []),
+                    // In package scope, list only the objects this package declares
+                    // (ADR-0086 P0) — otherwise the whole environment leaks into the panel.
+                    client.list('object', packageId ? { packageId } : {}).catch(() => []),
+                    // ADR-0086 P2 (D6): under the package door a set is draft/published
+                    // metadata, so surface the PENDING draft if one exists — otherwise a
+                    // just-saved-not-yet-published edit would appear lost on reopen. Draft
+                    // reads return the `{ type, name, item }` envelope; `null` = no draft.
+                    packageId
+                        ? client.getDraft(type, name, { packageId }).catch(() => null)
+                        : Promise.resolve(null),
                 ]);
                 if (cancelled)
                     return;
-                const effective = (lay?.effective ??
+                const draftBody = pendingDraft
+                    ? (pendingDraft.item ?? pendingDraft)
+                    : null;
+                // Draft wins over the published baseline for display (D6).
+                const effective = (draftBody ?? lay?.effective ??
                     lay?.code ?? { name, objects: {} });
-                setDraft({
-                    ...effective,
-                    name: String(effective?.name ?? name),
-                    objects: effective?.objects ?? {},
-                    fields: effective?.fields ?? {},
-                });
                 const list = (objList ?? [])
                     .map((row) => {
                     const item = row?.item ?? row;
@@ -116,6 +124,22 @@ export function PermissionMatrixEditPage({ type, name }) {
                     .filter((o) => !!o.name)
                     .sort((a, b) => a.name.localeCompare(b.name));
                 setObjects(list);
+                const full = {
+                    ...effective,
+                    name: String(effective?.name ?? name),
+                    objects: effective?.objects ?? {},
+                    fields: effective?.fields ?? {},
+                };
+                // Package scope: only surface this package's slice for editing; rows
+                // contributed by other packages stay off-screen and are re-merged on
+                // Save from a fresh read (see doSave).
+                if (packageId) {
+                    const sliced = scopePermissionSet(full, list.map((o) => o.name));
+                    setDraft({ ...full, objects: sliced.objects, fields: sliced.fields });
+                }
+                else {
+                    setDraft(full);
+                }
             }
             catch (err) {
                 setError(err?.message ?? String(err));
@@ -128,7 +152,7 @@ export function PermissionMatrixEditPage({ type, name }) {
         return () => {
             cancelled = true;
         };
-    }, [client, type, name]);
+    }, [client, type, name, packageId, publishNonce]);
     /* ── Lazy-load fields when an object is expanded ─────────── */
     async function ensureFields(objectName) {
         if (fieldsByObject[objectName])
@@ -211,17 +235,52 @@ export function PermissionMatrixEditPage({ type, name }) {
             return { ...prev, fields };
         });
     }
+    /**
+     * Re-narrow a freshly-read full permission set to this package's slice for
+     * display. No-op at environment scope (no `packageId`).
+     */
+    function toDisplayDraft(set) {
+        if (!packageId)
+            return set;
+        const sliced = scopePermissionSet(set, objects.map((o) => o.name));
+        return { ...set, objects: sliced.objects, fields: sliced.fields };
+    }
     /* ── Save ────────────────────────────────────────────────── */
     async function doSave(force, pending) {
         const payload = pending ?? draft;
         setSaving(true);
         setError(null);
         try {
-            await client.save(type, payload.name, payload, {
+            // Package scope: merge only this package's slice back onto a fresh read
+            // of the record so rows contributed by other packages survive byte-for-
+            // byte (ADR-0086 P0). Environment scope keeps the whole-record save.
+            let toSave = payload;
+            if (packageId) {
+                const scope = objects.map((o) => o.name);
+                const fresh = await client
+                    .layered(type, payload.name)
+                    .catch(() => null);
+                const base = (fresh?.effective ?? payload);
+                toSave = mergePermissionSlice(base, payload, scope);
+            }
+            // ADR-0086 P2 (D6/D7). Package door → the set is metadata: write a DRAFT
+            // (stamped with `packageId`) that the package's atomic Publish promotes,
+            // exactly like the Data/Interfaces pillars — NOT a live record write.
+            // Environment door (no packageId) stays live (config).
+            await client.save(type, payload.name, toSave, {
                 force,
+                ...(packageId ? { mode: 'draft', packageId } : {}),
             });
-            const lay = await client.layered(type, payload.name);
-            setDraft((lay.effective ?? payload));
+            if (packageId) {
+                // The draft is now the pending truth for display; the published baseline
+                // hasn't moved. Show what we just staged and let the surface count it.
+                setDraft(toDisplayDraft(toSave));
+                onDraftSaved?.();
+            }
+            else {
+                const lay = await client.layered(type, payload.name);
+                setDraft(toDisplayDraft((lay.effective ?? toSave)));
+            }
             setDestructive(null);
         }
         catch (err) {

package/dist/views/metadata-admin/i18n.d.ts

@@ -1,24 +1,3 @@
-/**
- * Metadata admin i18n bundle (Phase 3f).
- *
- * Lightweight static label table for the 27 built-in metadata types,
- * plus a tiny `t()` helper for engine UI strings.
- *
- * Why not i18next? The engine already consumes `label` from the
- * server's `/meta/types` response (which is sourced from
- * `DEFAULT_METADATA_TYPE_REGISTRY`). This bundle exists as a fallback
- * for environments without translation bundles configured, and as the
- * single source of truth for Chinese labels until the platform's
- * `setup.translation.ts` ships zh-CN coverage.
- *
- * Usage:
- *   import { translateMetadataType, t } from './i18n';
- *   translateMetadataType('view', 'zh-CN')  // → '视图'
- *   t('engine.directory.title', 'zh-CN')    // → '元数据'
- *
- * The DirectoryPage / PageShell call these to localise headings when
- * the consumer hasn't wired the global i18n provider.
- */
 export type SupportedLocale = 'en-US' | 'zh-CN';
 export declare function translateMetadataType(type: string, locale?: SupportedLocale | string, fallback?: string): string;
 export declare function translateMetadataDomain(domain: string, locale?: SupportedLocale | string): string;
@@ -32,3 +11,15 @@ export declare function tFormat(key: string, locale: SupportedLocale | string |
 export declare function translateValidationMessage(message: string | undefined, locale?: SupportedLocale | string): string;
 /** Returns the locale string most browsers report (matches navigator.language). */
 export declare function detectLocale(): SupportedLocale;
+/**
+ * React hook — the Studio/metadata-admin locale derived from the app's ACTIVE
+ * i18n language, collapsed to one of the two locales this catalog ships.
+ *
+ * Prefer this over {@link detectLocale} in components: `detectLocale()` reads
+ * `navigator.language`, which never changes when the user switches languages
+ * in-app via the LocaleSwitcher (that only moves the i18next instance). This
+ * follows the live `useObjectTranslation().language`, so the Studio pillars
+ * re-render in lock-step with the console locale — the same source the rest of
+ * the app (Home, forms, list views) renders from.
+ */
+export declare function useMetadataLocale(): SupportedLocale;