@startsimpli/ui 0.4.149 → 0.4.151

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startsimpli/ui",
-  "version": "0.4.149",
+  "version": "0.4.151",
   "description": "Shared UI components package for StartSimpli applications",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -56,7 +56,7 @@
     "@codemirror/state": "^6.0.0",
     "@codemirror/view": "^6.0.0",
     "@startsimpli/api": "^0.5.66",
-    "@startsimpli/auth": "^0.4.39",
+    "@startsimpli/auth": "^0.4.40",
     "@startsimpli/i18n": "^0.1.3"
   },
   "peerDependenciesMeta": {
@@ -152,8 +152,8 @@
     "tailwindcss": "^3.4.19",
     "tsup": "^8.5.1",
     "typescript": "^6.0.3",
-    "@startsimpli/i18n": "0.1.3",
-    "@startsimpli/realtime": "0.0.2"
+    "@startsimpli/realtime": "0.0.2",
+    "@startsimpli/i18n": "0.1.3"
   },
   "keywords": [
     "ui",

package/src/foundry/LinkPanel.tsx

@@ -33,6 +33,7 @@ import { Button } from '../components/ui/button';
 import { Input } from '../components/ui/input';
 import { notify } from '../components/toast/use-notify';
 import { useNow } from '../hooks/use-now';
+import { can } from './permissions';
 import {
   edgeEndpoints,
   edgesForSide,
@@ -191,6 +192,9 @@ export function LinkPanel({
   dateAttributeFor,
 }: LinkPanelProps) {
   const qc = useQueryClient();
+  // Adding or removing a link is editing the record (bd startsim-768w.71). A
+  // tenant that sends no permissions keeps the controls, as before.
+  const mayLink = can(record, 'canLink', true);
   const [picking, setPicking] = useState(false);
   const [search, setSearch] = useState('');
   const [busy, setBusy] = useState(false);
@@ -276,7 +280,7 @@ export function LinkPanel({
           </h3>
           {description ? <p className="mt-0.5 text-xs text-neutral-500">{description}</p> : null}
         </div>
-        <Button
+        {mayLink ? <Button
           size="sm"
           variant={picking ? 'outline' : 'default'}
           onClick={() => {
@@ -291,7 +295,7 @@ export function LinkPanel({
               <Plus className="mr-1 h-3.5 w-3.5" aria-hidden /> Add
             </>
           )}
-        </Button>
+        </Button> : null}
       </header>
 
       {picking ? (
@@ -373,7 +377,7 @@ export function LinkPanel({
                       </span>
                     )}
                   </span>
-                  <button
+                  {mayLink ? <button
                     type="button"
                     disabled={busy}
                     onClick={() => unlink(edge.id, label)}
@@ -382,7 +386,7 @@ export function LinkPanel({
                     className="shrink-0 rounded p-1 text-neutral-400 hover:bg-red-50 hover:text-red-600 disabled:opacity-50"
                   >
                     <X className="h-4 w-4" aria-hidden />
-                  </button>
+                  </button> : null}
                 </li>
               );
             })}

package/src/foundry/__tests__/permissions.test.tsx

@@ -0,0 +1,74 @@
+/**
+ * Controls follow the record's `permissions` object (bd startsim-768w.71), and a
+ * tenant that sends none keeps the old behaviour.
+ */
+import { render, screen } from '@testing-library/react'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { LinkPanel, type LinkPanelApi } from '../LinkPanel'
+import { linkSidesFor, type LinkSide } from '../links'
+import { can, permissionsOf, SHARE_LEVELS, type RecordPermissions } from '../permissions'
+import type { EntityRecordShape, EntityTypeShape, RelationshipEdgeShape } from '../types'
+
+const PRODUCT: EntityTypeShape = { id: 't1', key: 'product', label: 'Products', attributes: [] }
+const PATENT: EntityTypeShape = { id: 't2', key: 'patent', label: 'Patents', attributes: [] }
+const side = linkSidesFor(PRODUCT, [{ key: 'marked_with', sourceType: 't1', targetType: 't2' }], [
+  PRODUCT,
+  PATENT,
+])[0] as LinkSide
+
+const VIEW: RecordPermissions = {
+  level: 'view', canComment: true, canSuggest: true, canEdit: false, canAccept: false,
+  canRestore: false, canTag: false, canLink: false, canShare: false, canDelete: false,
+  canTransfer: false,
+}
+const EDIT: RecordPermissions = { ...VIEW, level: 'edit', canEdit: true, canAccept: true,
+  canRestore: true, canTag: true, canLink: true, canShare: true }
+
+const api: LinkPanelApi = {
+  listTypes: async () => ({ results: [PRODUCT, PATENT] }),
+  listEdgesFor: async () => [{ id: 'E1', relType: 'marked_with', source: 'P1', target: 'X1' }] as RelationshipEdgeShape[],
+  listRelated: async () => ({ results: [{ id: 'X1', name: 'A patent', data: {} }], next: null }),
+  searchRecords: async () => ({ results: [] as EntityRecordShape[] }),
+  createEdge: async () => undefined,
+  deleteEdge: async () => undefined,
+}
+
+function renderPanel(record: EntityRecordShape) {
+  const qc = new QueryClient({ defaultOptions: { queries: { retry: false } } })
+  return render(
+    <QueryClientProvider client={qc}>
+      <LinkPanel record={record} side={side} api={api} />
+    </QueryClientProvider>,
+  )
+}
+
+describe('permissions', () => {
+  it('reads the object, and falls back when a tenant sends none', () => {
+    expect(permissionsOf({ permissions: EDIT })).toEqual(EDIT)
+    expect(permissionsOf({})).toBeNull()
+    expect(can({ permissions: VIEW }, 'canEdit', true)).toBe(false)
+    expect(can({}, 'canEdit', true)).toBe(true)
+    expect(can({}, 'canEdit')).toBe(false)
+  })
+
+  it('offers exactly the two enforced share levels', () => {
+    expect(SHARE_LEVELS.map((l) => [l.value, l.label])).toEqual([
+      ['viewer', 'Can view'],
+      ['editor', 'Can edit'],
+    ])
+  })
+
+  it('hides Add and Unlink from someone who can only view the record', async () => {
+    renderPanel({ id: 'P1', name: 'A product', data: {}, permissions: VIEW })
+    expect(await screen.findByText('A patent')).toBeInTheDocument()
+    expect(screen.queryByRole('button', { name: /add/i })).toBeNull()
+    expect(screen.queryByRole('button', { name: /unlink/i })).toBeNull()
+  })
+
+  it('shows them to someone who can edit it', async () => {
+    renderPanel({ id: 'P1', name: 'A product', data: {}, permissions: EDIT })
+    expect(await screen.findByText('A patent')).toBeInTheDocument()
+    expect(screen.getByRole('button', { name: /add/i })).toBeInTheDocument()
+    expect(screen.getByRole('button', { name: /unlink/i })).toBeInTheDocument()
+  })
+})

package/src/foundry/index.ts

@@ -17,5 +17,6 @@ export * from './list-query';
 export * from './publication';
 export * from './record-validation';
 export * from './system-attrs';
+export * from './permissions';
 export { LinkPanel, linkQueryKey } from './LinkPanel';
 export type { LinkPanelApi, LinkPanelProps, LinkPanelPage } from './LinkPanel';

package/src/foundry/permissions.ts

@@ -0,0 +1,65 @@
+/**
+ * WHAT THE CALLER MAY DO TO A RECORD, as the tenant says it (bd startsim-768w.71).
+ *
+ * Every record a foundry tenant serves carries a `permissions` object, computed
+ * by the same code that refuses the writes (tenant-starter
+ * `apps/schema_registry/rights.py`; the model in plain words is
+ * `tenant-starter/PERMISSIONS.md`). A screen shows or hides each control from
+ * this ONE answer, and never re-derives it from the workspace role: a Viewer
+ * with a "Can edit" share edits that record, and a Member with "Can view" on a
+ * space does not edit what is in it.
+ *
+ * An older tenant that does not send the object yields `null`, and `can()`
+ * falls back to whatever the caller says the old behaviour was, so a tenant
+ * that has not rolled yet keeps its controls.
+ */
+import type { EntityRecordShape } from './types';
+
+export type AccessLevel = 'view' | 'edit' | 'full';
+
+export interface RecordPermissions {
+  level: AccessLevel;
+  canComment: boolean;
+  canSuggest: boolean;
+  canEdit: boolean;
+  canAccept: boolean;
+  canRestore: boolean;
+  canTag: boolean;
+  canLink: boolean;
+  canShare: boolean;
+  canDelete: boolean;
+  canTransfer: boolean;
+}
+
+export type Permission = Exclude<keyof RecordPermissions, 'level'>;
+
+/** The record's permissions object, or `null` when the tenant sent none. */
+export function permissionsOf(
+  record: Pick<EntityRecordShape, 'permissions'> | null | undefined,
+): RecordPermissions | null {
+  const p = record?.permissions;
+  return p && typeof p === 'object' ? (p as RecordPermissions) : null;
+}
+
+/** May the caller do `what` to `record`? `fallback` answers for a tenant that
+ *  sends no permissions object yet. */
+export function can(
+  record: Pick<EntityRecordShape, 'permissions'> | null | undefined,
+  what: Permission,
+  fallback = false,
+): boolean {
+  const p = permissionsOf(record);
+  if (!p) return fallback;
+  return p[what] === true;
+}
+
+/**
+ * The share levels, exactly the ones the tenant enforces (Quinn 2026-10-08:
+ * "Can view" and "Can edit", nothing else). `value` is what a grant stores.
+ */
+export const SHARE_LEVELS = [
+  { value: 'viewer', label: 'Can view', description: 'Read, suggest and comment' },
+  { value: 'editor', label: 'Can edit', description: 'Change, accept suggestions and share' },
+] as const;
+
+export type ShareLevel = (typeof SHARE_LEVELS)[number]['value'];

package/src/foundry/types.ts

@@ -61,6 +61,9 @@ export interface EntityRecordShape {
   name?: string | null;
   externalId?: string | null;
   data?: Record<string, unknown>;
+  /** What the caller may do to this record (bd startsim-768w.71). Absent on a
+   *  tenant that has not rolled the permission model; see ./permissions. */
+  permissions?: import('./permissions').RecordPermissions | null;
 }
 
 /** A declared relationship: a fixed source type -> target type edge. */