u

src/automats/attributeAutomat.js

@@ -0,0 +1,190 @@
+import { Automat } from 'react-automat';
+import { attributename as attributenameApi, attributevalue as attributevalueApi } from '../api';
+import authAutomat from './authAutomat';
+
+/**
+ * @typedef {Object} AttributeValue
+ * @property {number} id
+ * @property {number} attributeId
+ * @property {string} value
+ * @property {number} sort
+ */
+
+/**
+ * @typedef {Object} AttributeName
+ * @property {number} id
+ * @property {string} name
+ * @property {number} sort
+ * @property {boolean} exclusive
+ * @property {AttributeValue[]} values
+ */
+
+/**
+ * @typedef {Object} AttributeState
+ * @property {AttributeName[]} attributes
+ * @property {'idle'|'loading'|'succeeded'|'failed'} status
+ * @property {string|null} error
+ */
+
+/** @type {AttributeState} */
+const initialState = {
+  attributes: [],
+  status: 'idle',
+  error: null,
+};
+
+function sortValues(values) {
+  if (!Array.isArray(values)) return [];
+  return [...values].sort((a, b) => {
+    const sDiff = (a.sort ?? 0) - (b.sort ?? 0);
+    if (sDiff !== 0) return sDiff;
+    return (a.id ?? 0) - (b.id ?? 0);
+  });
+}
+
+function normalizeAttributes(attributes) {
+  if (!Array.isArray(attributes)) return [];
+  return [...attributes]
+    .map((attr) => ({
+      ...attr,
+      exclusive: Boolean(attr.exclusive),
+      values: sortValues(attr.values),
+    }))
+    .sort((a, b) => {
+      const sDiff = (a.sort ?? 0) - (b.sort ?? 0);
+      if (sDiff !== 0) return sDiff;
+      return (a.id ?? 0) - (b.id ?? 0);
+    });
+}
+
+let attributeAutomat;
+
+const actions = {
+  /** Load all attribute names and their values for the selected company. */
+  async load() {
+    attributeAutomat.setState({ status: 'loading', error: null });
+    try {
+      const res = await attributenameApi.list();
+      const attributes = normalizeAttributes(res.attributenames);
+      attributeAutomat.setState({ attributes, status: 'succeeded' });
+      return attributes;
+    } catch (err) {
+      attributeAutomat.setState({ status: 'failed', error: err?.message ?? String(err) });
+      throw err;
+    }
+  },
+
+  /**
+   * Create an attribute name.
+   * @param {{ name: string, sort?: number, exclusive?: boolean }} body
+   */
+  async createAttribute(body) {
+    const res = await attributenameApi.create(body);
+    await actions.load();
+    return res.attributename;
+  },
+
+  /**
+   * Update an attribute name.
+   * @param {number} id
+   * @param {{ name?: string, sort?: number, exclusive?: boolean }} body
+   */
+  async updateAttribute(id, body) {
+    const res = await attributenameApi.update(id, body);
+    await actions.load();
+    return res.attributename;
+  },
+
+  /**
+   * Delete an attribute name.
+   * @param {number} id
+   */
+  async deleteAttribute(id) {
+    await attributenameApi.delete(id);
+    await actions.load();
+  },
+
+  /**
+   * Reorder attribute names.
+   * @param {number[]} attributenameIds
+   */
+  async reorderAttributes(attributenameIds) {
+    await attributenameApi.order(attributenameIds);
+    await actions.load();
+  },
+
+  /**
+   * Create a value for an attribute.
+   * @param {number} attributeId
+   * @param {{ value: string, sort?: number }} body
+   */
+  async createValue(attributeId, body) {
+    const res = await attributevalueApi.create(attributeId, body);
+    await actions.load();
+    return res.attributevalue;
+  },
+
+  /**
+   * Update an attribute value.
+   * @param {number} id
+   * @param {{ value?: string, sort?: number }} body
+   */
+  async updateValue(id, body) {
+    const res = await attributevalueApi.update(id, body);
+    await actions.load();
+    return res.attributevalue;
+  },
+
+  /**
+   * Delete an attribute value.
+   * @param {number} id
+   */
+  async deleteValue(id) {
+    await attributevalueApi.delete(id);
+    await actions.load();
+  },
+
+  /**
+   * Reorder values of an attribute.
+   * @param {number} attributeId
+   * @param {number[]} attributevalueIds
+   */
+  async reorderValues(attributeId, attributevalueIds) {
+    await attributevalueApi.order(attributeId, attributevalueIds);
+    await actions.load();
+  },
+
+  /** Reset to idle state (called on logout / company switch). */
+  reset() {
+    attributeAutomat.setState(initialState);
+  },
+};
+
+/**
+ * Global attribute state container.
+ * Loads automatically when authAutomat reaches 'authed' with a selectedCompanyId.
+ *
+ * @type {Automat<AttributeState>}
+ */
+attributeAutomat = new Automat(initialState, actions, { name: 'attribute' });
+
+// Selectors
+export function selectAttributes() {
+  return attributeAutomat.state.attributes;
+}
+
+export function selectAttributeStatus() {
+  return attributeAutomat.state.status;
+}
+
+// Subscribe to auth changes
+authAutomat.subscribe((auth) => {
+  const companyId = auth.user?.selectedCompanyId;
+  if (auth.status === 'authed' && companyId) {
+    void attributeAutomat.actions.load();
+  } else if (auth.status === 'anon') {
+    attributeAutomat.actions.reset();
+  }
+});
+
+export default attributeAutomat;