@adcops/autocore-react 3.3.112 → 3.3.115

package/src/hooks/useAmsSchemaConfig.ts

@@ -0,0 +1,142 @@
+/**
+ * useAmsSchemaConfig — load and edit the AMS custom `asset_types` catalog.
+ *
+ * Thin wrapper around the `ams.show_schema_config` / `ams.put_asset_type` /
+ * `ams.remove_asset_type` / `ams.save_schema_config` /
+ * `ams.discard_schema_changes` IPC surface. Mirrors the server's
+ * staged-then-saved model (and the TIS `useTisConfig` hook exactly): edits
+ * land in the AMS module's in-memory buffer (dirty = true) until `save()`
+ * persists them to the `asset_management.json` sidecar next to project.json.
+ *
+ * Only the project's CUSTOM asset types are editable here. The three
+ * built-in types (load_cell/linear_encoder/spring) are code-defined and
+ * surfaced read-only via `ams.list_schemas` (see `useAmsAssetTypes`).
+ *
+ * Pass an `invoker` override to mock the IPC layer (playground / tests).
+ * When omitted, the hook reads `EventEmitterContext`.
+ */
+
+import { useCallback, useContext, useEffect, useRef, useState } from 'react';
+import { EventEmitterContext } from '../core/EventEmitterContext';
+import { MessageType } from '../hub/CommandMessage';
+import type { TisIpcInvoker } from './useTisConfig';
+import type { AssetTypeDef } from '../components/ams-editor/types';
+
+export interface AmsSchemaConfig {
+    assetTypes: Record<string, AssetTypeDef>;
+    dirty: boolean;
+}
+
+export interface UseAmsSchemaConfigResult {
+    config: AmsSchemaConfig | null;
+    loading: boolean;
+    /** Last server-reported error from a mutation. Cleared on next success. */
+    error: string | null;
+    refresh: () => Promise<void>;
+    putType: (typeId: string, def: AssetTypeDef) => Promise<void>;
+    removeType: (typeId: string) => Promise<void>;
+    save: () => Promise<void>;
+    revert: () => Promise<void>;
+}
+
+export interface UseAmsSchemaConfigOptions {
+    invoker?: TisIpcInvoker;
+}
+
+export function useAmsSchemaConfig(
+    options?: UseAmsSchemaConfigOptions,
+): UseAmsSchemaConfigResult {
+    const ctx = useContext(EventEmitterContext);
+
+    const invoker: TisIpcInvoker = options?.invoker
+        ?? (async (topic, payload) => {
+            return await ctx.invoke(topic as any, MessageType.Request, payload as any);
+        });
+
+    // Hold the invoker in a ref so the memoized callbacks keep a STABLE
+    // identity even when the caller passes a freshly-built invoker each
+    // render — same refetch-loop hazard the TIS hook documents (an unstable
+    // `refresh` re-ran the mount effect, wiping in-progress edits).
+    const invokerRef = useRef(invoker);
+    invokerRef.current = invoker;
+
+    const [config, setConfig] = useState<AmsSchemaConfig | null>(null);
+    const [loading, setLoading] = useState<boolean>(true);
+    const [error, setError] = useState<string | null>(null);
+
+    const refresh = useCallback(async () => {
+        setLoading(true);
+        try {
+            const resp = await invokerRef.current('ams.show_schema_config', {});
+            if (!resp.success) {
+                setError(resp.error_message ?? 'ams.show_schema_config failed');
+                setConfig(null);
+                return;
+            }
+            const d = resp.data ?? {};
+            setConfig({
+                assetTypes: (d.asset_types ?? {}) as Record<string, AssetTypeDef>,
+                dirty: !!d.dirty,
+            });
+            setError(null);
+        } catch (e: any) {
+            setError(String(e?.message ?? e));
+            setConfig(null);
+        } finally {
+            setLoading(false);
+        }
+    }, []);
+
+    useEffect(() => {
+        void refresh();
+    }, [refresh]);
+
+    const putType = useCallback(async (typeId: string, def: AssetTypeDef) => {
+        const resp = await invokerRef.current('ams.put_asset_type', {
+            type_id: typeId,
+            definition: def,
+        });
+        if (!resp.success) {
+            const m = resp.error_message ?? 'ams.put_asset_type failed';
+            setError(m);
+            throw new Error(m);
+        }
+        setError(null);
+        await refresh();
+    }, [refresh]);
+
+    const removeType = useCallback(async (typeId: string) => {
+        const resp = await invokerRef.current('ams.remove_asset_type', { type_id: typeId });
+        if (!resp.success) {
+            const m = resp.error_message ?? 'ams.remove_asset_type failed';
+            setError(m);
+            throw new Error(m);
+        }
+        setError(null);
+        await refresh();
+    }, [refresh]);
+
+    const save = useCallback(async () => {
+        const resp = await invokerRef.current('ams.save_schema_config', {});
+        if (!resp.success) {
+            const m = resp.error_message ?? 'ams.save_schema_config failed';
+            setError(m);
+            throw new Error(m);
+        }
+        setError(null);
+        await refresh();
+    }, [refresh]);
+
+    const revert = useCallback(async () => {
+        const resp = await invokerRef.current('ams.discard_schema_changes', {});
+        if (!resp.success) {
+            const m = resp.error_message ?? 'ams.discard_schema_changes failed';
+            setError(m);
+            throw new Error(m);
+        }
+        setError(null);
+        await refresh();
+    }, [refresh]);
+
+    return { config, loading, error, refresh, putType, removeType, save, revert };
+}

package/src/hooks/useTisConfig.ts

@@ -5,7 +5,7 @@
  * `tis.remove_method` / `tis.save_config` / `tis.discard_config_changes`
  * IPC surface. Mirrors the server's staged-then-saved model: edits land in
  * the server's in-memory copy (dirty = true) until `save()` persists them
- * to project.json.
+ * to the `test_methods.json` sidecar next to project.json.
  *
  * Today the server hosts exactly one project (the one configured at
  * startup), so `projectId` is informational; the hook still threads it