@object-ui/core 17.5.0 → 17.7.0

package/dist/actions/recordDelete.js

@@ -0,0 +1,112 @@
+/**
+ * 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.
+ */
+const PERMISSION_SET_OBJECT = 'sys_permission_set';
+/** ADR-0094: is this permission-set row owned by an installed package? */
+function isPackageOwned(row) {
+    return row?.managed_by === 'package';
+}
+/**
+ * The record-delete core: `confirmText` is the question to ask before deleting
+ * one record, `run` performs the delete (one record, or several settled
+ * together) and reports it. See the module docblock for objectui#10383 and
+ * ADR-0094.
+ */
+export const recordDelete = Object.freeze({
+    /**
+     * The question to ask before deleting ONE record: the reset question for a
+     * package-owned permission set (ADR-0094), the plain delete question
+     * otherwise. Reads only the row it is handed — no lookup.
+     */
+    confirmText(deps, record) {
+        const { objectName, t } = deps;
+        return objectName === PERMISSION_SET_OBJECT && isPackageOwned(record)
+            ? t('objectActions.resetPackageSetConfirm', {
+                defaultValue: 'This permission set ships with an installed package and cannot be removed. ' +
+                    'Deleting resets it to the shipped baseline and discards your environment customization. Continue?',
+            })
+            : t('objectActions.deleteConfirm');
+    },
+    /**
+     * Delete, refresh and report. Several records (`params.records`, more than
+     * one with an `id`) are deleted one call each and settled together, then the
+     * list refreshes and ONE summary toast reports the batch. Otherwise one
+     * record is deleted; on success the list refreshes and a success toast shows
+     * (the reset copy for a package-owned permission set), on failure an error
+     * toast carries the error message and the list is left as it is.
+     */
+    async run(deps, request) {
+        const { objectName, t, label, dataSource, toast, onRefresh } = deps;
+        const params = request.params;
+        const records = Array.isArray(params?.records)
+            ? params.records.filter((r) => r?.id != null)
+            : null;
+        // Bulk path — delete every record in parallel and report a summary.
+        if (records && records.length > 1) {
+            const results = await Promise.allSettled(records.map((r) => dataSource.delete(objectName, r.id)));
+            const failed = results.filter((r) => r.status === 'rejected').length;
+            const succeeded = results.length - failed;
+            onRefresh?.();
+            if (failed === 0) {
+                toast.success(t('objectActions.bulkDeleteSuccess', {
+                    count: succeeded,
+                    label,
+                    defaultValue: `Deleted ${succeeded} ${label} records`,
+                }));
+                // `silent`: the summary above is the feedback — without it the runner's
+                // post-execution hook adds a second, generic success toast.
+                return { success: true, reload: true, silent: true };
+            }
+            toast.error(t('objectActions.bulkDeletePartial', {
+                succeeded,
+                failed,
+                defaultValue: `${succeeded} deleted, ${failed} failed`,
+            }));
+            // The summary above is authoritative; returning WITHOUT `error` keeps the
+            // runner from toasting the failure a second time.
+            return { success: false };
+        }
+        const recordId = params?.recordId ?? params?.record?.id ?? records?.[0]?.id ?? request.recordId;
+        if (!recordId)
+            return { success: false, error: t('objectActions.noRecordId') };
+        // [ADR-0094] Detect the reset BEFORE the delete (the row still exists), so
+        // the success toast tells the truth. A caller that passed the row spares
+        // the lookup.
+        let packagedSetReset = false;
+        if (objectName === PERMISSION_SET_OBJECT) {
+            try {
+                const row = params?.record?.managed_by !== undefined
+                    ? params.record
+                    : await dataSource.findOne(objectName, recordId);
+                packagedSetReset = isPackageOwned(row);
+            }
+            catch { /* best-effort — fall back to the generic delete copy */ }
+        }
+        try {
+            await dataSource.delete(objectName, recordId);
+            onRefresh?.();
+            toast.success(packagedSetReset
+                // No `label` argument, unlike `deleteSuccess` below: this sentence
+                // names the permission set by kind rather than by label, so none of
+                // the ten packs has a `{{label}}` hole and i18next would drop the
+                // argument in silence (objectui#3845).
+                ? t('objectActions.resetPackageSetSuccess', {
+                    defaultValue: 'Permission set reset to its shipped baseline',
+                })
+                : t('objectActions.deleteSuccess', { label }));
+            return { success: true, reload: true, silent: true };
+        }
+        catch (err) {
+            toast.error(t('objectActions.deleteFailed', { label }), {
+                description: err.message,
+            });
+            // The toast above (label + error message) is the feedback; returning
+            // WITHOUT `error` keeps the runner from toasting the raw message again.
+            return { success: false };
+        }
+    },
+});

package/dist/actions/recordIdParam.d.ts

@@ -0,0 +1,77 @@
+/**
+ * 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.
+ */
+/**
+ * Seeding an action's `recordIdParam` from the row — and refusing to dispatch
+ * when the row cannot supply it (objectstack#8018).
+ *
+ * An `api` action declaring `recordIdParam` names the request key that carries
+ * the record it acts on; `recordIdField` names the row field whose value seeds
+ * it (default `id`). Every call site used to spell the read the same permissive
+ * way:
+ *
+ * ```ts
+ * const rowValue = rowRecord[action.recordIdField || 'id'];
+ * if (rowValue != null) body[action.recordIdParam] = rowValue;   // else: nothing
+ * ```
+ *
+ * The `else` branch is the defect. It cannot distinguish "this row has no such
+ * key" from "this row's value is null", and in both cases it drops the parameter
+ * and lets the request go out anyway. What reaches the server is a mutation with
+ * no record named — and a backend that treats a missing selector as "match
+ * nothing" answers `{ status: true }` for having deleted nothing. The user is
+ * told the action succeeded. The measured instance was a session-revocation
+ * control that revoked nothing, which is the worst shape this can take: a
+ * security affordance that reports success while no-op'ing.
+ *
+ * The absent-key half is reachable from ordinary authoring, not just from bad
+ * data: the grid projects `$select` from the listView columns, so until
+ * `recordIdField` was harvested into it (see `listViewPredicates`) any action
+ * keyed on a non-column field got a row without that key. The harvest closes the
+ * common route; this guard closes the class, because a row can still lack the key
+ * for reasons projection cannot fix — a server-side read mask that strips the
+ * field regardless of projection (`internal: true`), a partial payload handed
+ * down from a host, a field the principal cannot read.
+ *
+ * Contract-first (AGENTS.md #0.1): the answer to an under-specified request is to
+ * refuse it at the producer, loudly, not to send it and hope the server objects.
+ * The two failures are named separately because they point at different repairs —
+ * an absent key is a projection/visibility problem, a null value is a data one.
+ */
+/** The minimal action shape this resolution reads. */
+export interface RecordIdParamAction {
+    /** Request key that carries the record id. Absent ⇒ no injection is declared. */
+    recordIdParam?: string;
+    /** Row field whose value seeds it. Defaults to `id`. */
+    recordIdField?: string;
+    /** Used only to make the refusal message name the action. */
+    name?: string;
+    label?: string;
+}
+/**
+ * Either the value to inject, or the reason the action must not be dispatched.
+ * `{}` (neither key) means no injection is declared — carry on unchanged.
+ */
+export type RecordIdParamSeed = {
+    value: unknown;
+    error?: undefined;
+} | {
+    value?: undefined;
+    error: string;
+} | {
+    value?: undefined;
+    error?: undefined;
+};
+/**
+ * Resolve the value an action's `recordIdParam` should carry, or the refusal.
+ *
+ * Pure — reads the action and the row, mutates nothing. Returns `{}` when the
+ * action declares no `recordIdParam` (nothing to inject) or when there is no row
+ * record at all (the caller is on a path where no row context exists; that is not
+ * this guard's business).
+ */
+export declare function resolveRecordIdParamSeed(action: RecordIdParamAction | null | undefined, rowRecord: Record<string, unknown> | null | undefined): RecordIdParamSeed;

package/dist/actions/recordIdParam.js

@@ -0,0 +1,37 @@
+/**
+ * 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.
+ */
+/**
+ * Resolve the value an action's `recordIdParam` should carry, or the refusal.
+ *
+ * Pure — reads the action and the row, mutates nothing. Returns `{}` when the
+ * action declares no `recordIdParam` (nothing to inject) or when there is no row
+ * record at all (the caller is on a path where no row context exists; that is not
+ * this guard's business).
+ */
+export function resolveRecordIdParamSeed(action, rowRecord) {
+    const param = action?.recordIdParam;
+    if (!param || !rowRecord || typeof rowRecord !== 'object')
+        return {};
+    const field = action?.recordIdField || 'id';
+    const label = action?.label || action?.name || param;
+    if (!(field in rowRecord)) {
+        return {
+            error: `Action "${label}" identifies its record by "${field}", but that field is not ` +
+                `present on the row. Add it to the view's columns, or check that it is readable ` +
+                `— running without it would send a request that names no record.`,
+        };
+    }
+    const value = rowRecord[field];
+    if (value == null) {
+        return {
+            error: `Action "${label}" identifies its record by "${field}", but this record has no ` +
+                `value for it — running without it would send a request that names no record.`,
+        };
+    }
+    return { value };
+}

package/dist/actions/serverActionHandler.d.ts

@@ -52,7 +52,7 @@
  * // <ActionProvider handlers={{ script }} … />  (or runner.registerHandler('script', script))
  * ```
  */
-import type { ActionContext, ActionDef, ActionResult } from './ActionRunner';
+import type { ActionContext, ActionDef, ActionResult } from './ActionRunner.js';
 /** The response surface the dispatcher needs — satisfied by a WHATWG `Response`. */
 export interface ServerActionFetchResponse {
     ok: boolean;

package/dist/actions/serverActionHandler.js

@@ -5,7 +5,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import { interpretActionResponse } from './actionResponse';
+import { interpretActionResponse } from './actionResponse.js';
 /**
  * An action that also mounts on list rows (`list_item`) or record pages is
  * designed to run against a single record. When such an action is launched

package/dist/adapters/ValueDataSource.d.ts

@@ -63,6 +63,11 @@ export declare class ValueDataSource<T = any> implements DataSource<T> {
     onMutation(callback: (event: DataSourceMutationEvent<T>) => void): () => void;
     /** Get the current number of items */
     get count(): number;
-    /** Get a snapshot of all items (cloned) */
+    /**
+     * Get a snapshot of all items (cloned).
+     *
+     * Same clone as the constructor and for the same reason — see the note
+     * there: `structuredClone`, never a JSON round-trip (objectui#9175).
+     */
     getAll(): T[];
 }