@porulle/core 0.10.6 → 0.11.0

package/dist/modules/catalog/service.js

@@ -1,22 +1,358 @@
+import { resolveOrgId } from "../../auth/org.js";
+import { assertPermission } from "../../auth/permissions.js";
+import { Err, Ok } from "../../kernel/result.js";
+import { CommerceConflictError, CommerceNotFoundError, CommerceValidationError, toCommerceError } from "../../kernel/errors.js";
+import { createTxContext } from "../../kernel/database/tx-context.js";
+import { isValidFieldPath, validateFieldPath } from "./ownership.js";
+import { comparableSerialize } from "./revision.js";
 import { EntityService } from "./entity-service.js";
 import { CategoryService } from "./category-service.js";
 import { BrandService } from "./brand-service.js";
+function isUniqueViolation(error) {
+    if (error == null || typeof error !== "object")
+        return false;
+    const value = error;
+    if (value.code === "23505")
+        return true;
+    return isUniqueViolation(value.cause);
+}
 export class CatalogServiceImpl {
     repository;
+    database;
+    config;
     entities;
     categories;
     brands;
     constructor(deps) {
         this.repository = deps.repository;
-        this.entities = new EntityService(deps);
+        this.database = deps.database;
+        this.config = deps.config;
+        this.entities = new EntityService(deps, this.resolveEntityFieldDefinitions.bind(this));
         this.categories = new CategoryService(deps);
         this.brands = new BrandService(deps);
     }
+    codeFieldDefinition(entityType, name) {
+        return this.config.entities?.[entityType]?.fields.find((field) => field.name === name);
+    }
+    runtimeFieldDefinition(row) {
+        return {
+            name: row.name,
+            type: row.type,
+            ...(row.unit != null ? { unit: row.unit } : {}),
+            ...(row.options != null ? { options: row.options } : {}),
+            ...(row.target != null ? { target: row.target } : {}),
+            filterable: row.filterable,
+            localized: row.localized,
+            sortOrder: row.sortOrder,
+        };
+    }
+    async resolveEntityFieldDefinitions(entityType, actorOrOrg, ctx) {
+        const orgId = typeof actorOrOrg === "string"
+            ? actorOrOrg
+            : resolveOrgId(actorOrOrg ?? ctx?.actor ?? null);
+        const codeFields = this.config.entities?.[entityType]?.fields ?? [];
+        const merged = new Map(codeFields.map((field) => [field.name, { ...field }]));
+        const runtimeFields = await this.repository.findActiveEntityFieldDefinitions(orgId, entityType, ctx);
+        for (const row of runtimeFields) {
+            const codeField = merged.get(row.name);
+            if (!codeField) {
+                merged.set(row.name, this.runtimeFieldDefinition(row));
+                continue;
+            }
+            merged.set(row.name, {
+                ...codeField,
+                ...(row.options != null ? { options: row.options } : {}),
+                filterable: row.filterable,
+                localized: row.localized,
+                sortOrder: row.sortOrder,
+            });
+        }
+        return [...merged.values()].sort((first, second) => (first.sortOrder ?? 0) - (second.sortOrder ?? 0));
+    }
+    listEntityFieldDefinitions(actor, entityType, ctx) {
+        const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+        return this.withMutationResult(actor ?? ctx?.actor ?? null, ctx, async (txCtx) => Ok(await this.repository.findEntityFieldDefinitions(orgId, entityType, txCtx)));
+    }
+    createEntityFieldDefinition(input, actor, ctx) {
+        if (input.entityType.length === 0 || input.name.length === 0) {
+            return Promise.resolve(Err(new CommerceValidationError("Entity type and field name are required.")));
+        }
+        assertPermission(actor, "catalog:update");
+        const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+        return this.withMutationResult(actor, ctx, async (txCtx) => {
+            const codeField = this.codeFieldDefinition(input.entityType, input.name);
+            if (codeField && input.type !== codeField.type) {
+                return Err(new CommerceValidationError("Code-defined fields only allow options, filterable, localized, and sortOrder overrides."));
+            }
+            return Ok(await this.repository.createEntityFieldDefinition({
+                organizationId: orgId,
+                entityType: input.entityType,
+                name: input.name,
+                type: input.type,
+                // A shadow row over a code field inherits the code values for anything
+                // omitted, so creating one never silently flips a code default.
+                ...(codeField?.unit !== undefined || input.unit !== undefined
+                    ? { unit: codeField ? codeField.unit ?? null : input.unit }
+                    : {}),
+                ...(codeField?.target !== undefined || input.target !== undefined
+                    ? { target: codeField ? codeField.target ?? null : input.target }
+                    : {}),
+                ...(input.options !== undefined
+                    ? { options: input.options }
+                    : codeField?.options !== undefined ? { options: codeField.options } : {}),
+                ...(input.filterable !== undefined
+                    ? { filterable: input.filterable }
+                    : codeField?.filterable !== undefined ? { filterable: codeField.filterable } : {}),
+                ...(input.localized !== undefined ? { localized: input.localized } : {}),
+                ...(input.sortOrder !== undefined ? { sortOrder: input.sortOrder } : {}),
+            }, txCtx));
+        });
+    }
+    updateEntityFieldDefinition(id, input, actor, ctx) {
+        assertPermission(actor, "catalog:update");
+        const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+        return this.withMutationResult(actor, ctx, async (txCtx) => {
+            const existing = await this.repository.findEntityFieldDefinitionById(orgId, id, txCtx);
+            if (!existing)
+                return Err(new CommerceNotFoundError("Entity field definition not found."));
+            const codeField = this.codeFieldDefinition(existing.entityType, existing.name);
+            if (codeField && (input.entityType !== undefined || input.name !== undefined || input.type !== undefined || input.unit !== undefined || input.target !== undefined)) {
+                return Err(new CommerceValidationError("Code-defined fields only allow options, filterable, localized, and sortOrder updates."));
+            }
+            const data = {
+                ...(input.entityType !== undefined ? { entityType: input.entityType } : {}),
+                ...(input.name !== undefined ? { name: input.name } : {}),
+                ...(input.type !== undefined ? { type: input.type } : {}),
+                ...(input.unit !== undefined ? { unit: input.unit } : {}),
+                ...(input.options !== undefined ? { options: input.options } : {}),
+                ...(input.target !== undefined ? { target: input.target } : {}),
+                ...(input.filterable !== undefined ? { filterable: input.filterable } : {}),
+                ...(input.localized !== undefined ? { localized: input.localized } : {}),
+                ...(input.sortOrder !== undefined ? { sortOrder: input.sortOrder } : {}),
+            };
+            const updated = await this.repository.updateEntityFieldDefinition(orgId, id, data, txCtx);
+            if (!updated)
+                return Err(new CommerceNotFoundError("Entity field definition not found."));
+            return Ok(updated);
+        });
+    }
+    archiveEntityFieldDefinition(id, actor, ctx) {
+        assertPermission(actor, "catalog:update");
+        const orgId = resolveOrgId(actor ?? ctx?.actor ?? null);
+        return this.withMutationResult(actor, ctx, async (txCtx) => {
+            const existing = await this.repository.findEntityFieldDefinitionById(orgId, id, txCtx);
+            if (!existing)
+                return Err(new CommerceNotFoundError("Entity field definition not found."));
+            if (this.codeFieldDefinition(existing.entityType, existing.name)) {
+                return Err(new CommerceValidationError("Code-defined fields cannot be archived."));
+            }
+            if (existing.status === "archived")
+                return Ok(existing);
+            const updated = await this.repository.updateEntityFieldDefinition(orgId, id, { status: "archived" }, txCtx);
+            if (!updated)
+                return Err(new CommerceNotFoundError("Entity field definition not found."));
+            return Ok(updated);
+        });
+    }
+    async withMutation(actor, ctx, fn) {
+        if (ctx?.tx != null)
+            return fn(ctx);
+        for (let attempt = 0; attempt < 3; attempt += 1) {
+            try {
+                return await this.database.transaction(async (tx) => fn(createTxContext(tx, { actor })));
+            }
+            catch (error) {
+                if (!isUniqueViolation(error) || attempt === 2)
+                    throw error;
+            }
+        }
+        throw new Error("Catalog mutation retry limit reached.");
+    }
+    async withMutationResult(actor, ctx, fn) {
+        try {
+            return await this.withMutation(actor, ctx, fn);
+        }
+        catch (error) {
+            if (isUniqueViolation(error))
+                return Err(new CommerceConflictError("A resource with those values already exists."));
+            return Err(toCommerceError(error));
+        }
+    }
+    async captureRevision(entityId, actor, reason, ctx, force = false) {
+        const snapshot = await this.repository.snapshotEntity(entityId, ctx);
+        const latest = await this.repository.findLatestRevision(entityId, ctx);
+        if (!(force || reason === "push") && latest && comparableSerialize(latest.snapshot) === comparableSerialize(snapshot))
+            return latest;
+        const revisionActor = actor ?? ctx.actor;
+        const organizationId = typeof snapshot.entity.organizationId === "string"
+            ? snapshot.entity.organizationId
+            : resolveOrgId(revisionActor);
+        return this.repository.createRevision({
+            organizationId,
+            entityId,
+            snapshot,
+            reason,
+            actorId: revisionActor?.userId ?? null,
+            actorType: revisionActor?.type ?? null,
+            requestId: ctx.requestId,
+        }, ctx);
+    }
+    async recordEntityRevision(entityId, actor, reason = "update", ctx) {
+        try {
+            return await this.withMutation(actor, ctx, async (txCtx) => {
+                const revisionActor = actor ?? txCtx.actor;
+                assertPermission(revisionActor, "catalog:update");
+                const entity = await this.repository.findEntityById(entityId, txCtx);
+                if (!entity)
+                    return Err(new CommerceNotFoundError("Entity not found."));
+                if (entity.organizationId !== resolveOrgId(revisionActor)) {
+                    return Err(new CommerceNotFoundError("Entity not found."));
+                }
+                return Ok(await this.captureRevision(entityId, revisionActor, reason, txCtx));
+            });
+        }
+        catch (error) {
+            return Err(toCommerceError(error));
+        }
+    }
+    restoreDate(value) {
+        if (value == null)
+            return null;
+        return value instanceof Date ? value : new Date(String(value));
+    }
+    async applyRevisionSnapshot(entityId, snapshot, ctx) {
+        const entity = snapshot.entity;
+        const entityData = {
+            sourceStoreId: entity.sourceStoreId,
+            type: entity.type,
+            slug: entity.slug,
+            status: entity.status,
+            isVisible: entity.isVisible,
+            taxClass: entity.taxClass,
+            metadata: entity.metadata,
+            publishedAt: this.restoreDate(snapshot.entity.publishedAt),
+        };
+        await this.repository.updateEntity(entityId, entityData, ctx);
+        await this.repository.deleteAttributesByEntityId(entityId, ctx);
+        for (const row of snapshot.attributes) {
+            await this.repository.createAttribute({
+                id: row.id,
+                entityId,
+                locale: row.locale,
+                title: row.title,
+                subtitle: row.subtitle,
+                description: row.description,
+                richDescription: row.richDescription,
+                seoTitle: row.seoTitle,
+                seoDescription: row.seoDescription,
+            }, ctx);
+        }
+        await this.repository.deleteCustomFieldsByEntityId(entityId, ctx);
+        for (const row of snapshot.customFields) {
+            await this.repository.createCustomField({
+                id: row.id,
+                entityId,
+                fieldName: row.fieldName,
+                fieldType: row.fieldType,
+                source: row.source,
+                status: row.status,
+                confidence: row.confidence,
+                evidence: row.evidence,
+                locale: row.locale,
+                approvedAt: this.restoreDate(row.approvedAt),
+                approvedBy: row.approvedBy,
+                textValue: row.textValue,
+                numberValue: row.numberValue,
+                booleanValue: row.booleanValue,
+                dateValue: this.restoreDate(row.dateValue),
+                jsonValue: row.jsonValue,
+                createdAt: this.restoreDate(row.createdAt) ?? new Date(),
+                updatedAt: this.restoreDate(row.updatedAt) ?? new Date(),
+            }, ctx);
+        }
+        await this.repository.deleteEntityCategoriesByEntityId(entityId, ctx);
+        for (const row of snapshot.categories) {
+            await this.repository.addEntityToCategory(entityId, row.categoryId, row.sortOrder, ctx);
+        }
+        await this.repository.deleteEntityBrandsByEntityId(entityId, ctx);
+        for (const row of snapshot.brands) {
+            await this.repository.addEntityToBrand(entityId, row.brandId, row.sortOrder, ctx);
+        }
+        // Snapshots written before tags existed carry no key; restoring one must
+        // not delete tag links the snapshot never saw.
+        if (snapshot.tags) {
+            await this.repository.deleteEntityTagsByEntityId(entityId, ctx);
+            for (const row of snapshot.tags) {
+                await this.repository.addEntityTag(entityId, row.tagId, ctx);
+            }
+        }
+        await this.repository.deleteEntityMediaByEntityId(entityId, ctx);
+        for (const row of snapshot.media) {
+            await this.repository.createEntityMedia({
+                entityId,
+                mediaAssetId: row.mediaAssetId,
+                role: row.role,
+                sortOrder: row.sortOrder,
+                variantId: row.variantId,
+            }, ctx);
+        }
+    }
+    async restoreEntityRevision(entityId, revisionId, actor, ctx) {
+        try {
+            return await this.withMutation(actor, ctx, async (txCtx) => {
+                const revisionActor = actor ?? txCtx.actor;
+                assertPermission(revisionActor, "catalog:update");
+                const entity = await this.repository.findEntityById(entityId, txCtx);
+                if (!entity)
+                    return Err(new CommerceNotFoundError("Entity not found."));
+                if (entity.organizationId !== resolveOrgId(revisionActor)) {
+                    return Err(new CommerceNotFoundError("Entity not found."));
+                }
+                if (entity.sourceStoreId != null)
+                    assertPermission(revisionActor, "catalog:sync");
+                const revision = await this.repository.findRevisionById(entityId, revisionId, txCtx);
+                if (!revision)
+                    return Err(new CommerceNotFoundError("Revision not found."));
+                await this.applyRevisionSnapshot(entityId, revision.snapshot, txCtx);
+                const restored = await this.entities.getById(entityId, { includeAttributes: true, includeCategories: true, includeBrands: true, includeMedia: true }, revisionActor, txCtx);
+                if (!restored.ok)
+                    return restored;
+                await this.captureRevision(entityId, revisionActor, "restore", txCtx, true);
+                return restored;
+            });
+        }
+        catch (error) {
+            return Err(toCommerceError(error));
+        }
+    }
+    async trimEntityRevisions(actor, olderThanDays = 90, ctx) {
+        try {
+            return await this.withMutation(actor, ctx, async (txCtx) => {
+                const revisionActor = actor ?? txCtx.actor;
+                assertPermission(revisionActor, "catalog:update");
+                const cutoff = new Date(Date.now() - olderThanDays * 24 * 60 * 60 * 1000);
+                return Ok(await this.repository.deleteRevisionsOlderThan(resolveOrgId(revisionActor), cutoff, txCtx));
+            });
+        }
+        catch (error) {
+            return Err(toCommerceError(error));
+        }
+    }
     create(input, actor, ctx) {
-        return this.entities.create(input, actor, ctx);
+        return this.withMutationResult(actor, ctx, async (txCtx) => {
+            const result = await this.entities.create(input, actor, txCtx);
+            if (result.ok)
+                await this.captureRevision(result.value.id, actor, "create", txCtx);
+            return result;
+        });
     }
     update(id, input, actor, ctx) {
-        return this.entities.update(id, input, actor, ctx);
+        return this.withMutationResult(actor, ctx, async (txCtx) => {
+            const result = await this.entities.update(id, input, actor, txCtx);
+            if (result.ok)
+                await this.captureRevision(id, actor, "update", txCtx);
+            return result;
+        });
     }
     delete(id, actor, ctx) {
         return this.entities.delete(id, actor, ctx);
@@ -30,17 +366,162 @@ export class CatalogServiceImpl {
     list(params, actor, ctx) {
         return this.entities.list(params, actor, ctx);
     }
+    async resolveFieldOwner(entityId, fieldPath, storeId, ctx, variantId) {
+        if (!isValidFieldPath(fieldPath))
+            return undefined;
+        const rows = await this.repository.findFieldOwnershipForResolution(entityId, storeId, variantId ?? null, ctx);
+        let selected;
+        let selectedPriority = -1;
+        for (const row of rows) {
+            if (row.fieldPath !== fieldPath)
+                continue;
+            const priority = (row.variantId === variantId && variantId != null ? 2 : 0)
+                + (row.storeId === storeId ? 1 : 0);
+            if (priority > selectedPriority) {
+                selected = row;
+                selectedPriority = priority;
+            }
+        }
+        return selected?.owner;
+    }
+    async resolveFieldOwners(entityId, storeId, ctx) {
+        const rows = await this.repository.findFieldOwnershipForResolution(entityId, storeId, null, ctx);
+        const resolved = new Map();
+        for (const row of rows) {
+            const priority = row.storeId === storeId ? 1 : 0;
+            const current = resolved.get(row.fieldPath);
+            if (!current || priority > current.priority) {
+                resolved.set(row.fieldPath, { owner: row.owner, priority });
+            }
+        }
+        return new Map([...resolved].map(([fieldPath, value]) => [fieldPath, value.owner]));
+    }
+    setFieldOwner(entityId, fieldPath, storeId, owner, actor, ctx, variantId) {
+        return this.withMutationResult(actor, ctx, async (txCtx) => {
+            const setter = actor ?? txCtx.actor;
+            assertPermission(setter, "catalog:update");
+            validateFieldPath(fieldPath);
+            const entity = await this.repository.findEntityById(entityId, txCtx);
+            if (!entity)
+                return Err(new CommerceNotFoundError("Entity not found."));
+            if (entity.organizationId !== resolveOrgId(setter)) {
+                return Err(new CommerceNotFoundError("Entity not found."));
+            }
+            if (entity.sourceStoreId != null)
+                assertPermission(setter, "catalog:sync");
+            await this.repository.upsertFieldOwnership({
+                organizationId: entity.organizationId,
+                entityId,
+                ...(variantId != null ? { variantId } : {}),
+                ...(storeId != null ? { storeId } : {}),
+                fieldPath,
+                owner,
+            }, txCtx);
+            return Ok(undefined);
+        });
+    }
+    listFieldOwnership(entityId, actor, ctx, storeId) {
+        return this.withMutationResult(actor, ctx, async (txCtx) => {
+            const reader = actor ?? txCtx.actor;
+            assertPermission(reader, "catalog:read");
+            const entity = await this.repository.findEntityById(entityId, txCtx);
+            if (!entity)
+                return Err(new CommerceNotFoundError("Entity not found."));
+            if (entity.organizationId !== resolveOrgId(reader)) {
+                return Err(new CommerceNotFoundError("Entity not found."));
+            }
+            return Ok(await this.repository.findFieldOwnership(entityId, txCtx, storeId));
+        });
+    }
+    seedImportedFieldOwnership(entityId, storeId, fieldPaths, ctx) {
+        return this.withMutationResult(null, ctx, async (txCtx) => {
+            const entity = await this.repository.findEntityById(entityId, txCtx);
+            if (!entity)
+                return Err(new CommerceNotFoundError("Entity not found."));
+            const rows = fieldPaths.map((fieldPath) => ({
+                organizationId: entity.organizationId,
+                entityId,
+                storeId,
+                fieldPath: validateFieldPath(fieldPath),
+                owner: "store",
+            }));
+            await this.repository.seedFieldOwnership(rows, txCtx);
+            return Ok(undefined);
+        });
+    }
     publish(id, actor, ctx) {
-        return this.entities.publish(id, actor, ctx);
+        return this.withMutationResult(actor, ctx, async (txCtx) => {
+            const result = await this.entities.publish(id, actor, txCtx);
+            if (result.ok)
+                await this.captureRevision(id, actor, "update", txCtx);
+            return result;
+        });
     }
     archive(id, actor, ctx) {
-        return this.entities.archive(id, actor, ctx);
+        return this.withMutationResult(actor, ctx, async (txCtx) => {
+            const result = await this.entities.archive(id, actor, txCtx);
+            if (result.ok)
+                await this.captureRevision(id, actor, "update", txCtx);
+            return result;
+        });
     }
     discontinue(id, actor, ctx) {
-        return this.entities.discontinue(id, actor, ctx);
+        return this.withMutationResult(actor, ctx, async (txCtx) => {
+            const result = await this.entities.discontinue(id, actor, txCtx);
+            if (result.ok)
+                await this.captureRevision(id, actor, "update", txCtx);
+            return result;
+        });
     }
     setAttributes(entityId, locale, attrs, actor, ctx) {
-        return this.entities.setAttributes(entityId, locale, attrs, actor, ctx);
+        return this.withMutationResult(actor, ctx, async (txCtx) => {
+            const result = await this.entities.setAttributes(entityId, locale, attrs, actor, txCtx);
+            if (result.ok)
+                await this.captureRevision(entityId, actor, "update", txCtx);
+            return result;
+        });
+    }
+    reviewCustomField(status, entityId, fieldName, locale, actor, ctx) {
+        return this.withMutationResult(actor, ctx, async (txCtx) => {
+            const reviewer = actor ?? txCtx.actor;
+            assertPermission(reviewer, "catalog:update");
+            const entity = await this.repository.findEntityById(entityId, txCtx);
+            if (!entity)
+                return Err(new CommerceNotFoundError("Entity not found."));
+            if (entity.organizationId !== resolveOrgId(reviewer)) {
+                return Err(new CommerceNotFoundError("Entity not found."));
+            }
+            if (entity.sourceStoreId != null)
+                assertPermission(reviewer, "catalog:sync");
+            const proposal = await this.repository.findProposedCustomField(entityId, fieldName, locale, txCtx);
+            if (!proposal)
+                return Err(new CommerceNotFoundError("Custom field proposal not found."));
+            if (status === "approved") {
+                await this.repository.deleteCustomField(entityId, fieldName, locale, txCtx);
+            }
+            const updated = await this.repository.updateProposedCustomField(proposal.id, {
+                status,
+                ...(status === "approved"
+                    ? { approvedAt: new Date(), approvedBy: reviewer?.userId ?? null }
+                    : {}),
+            }, txCtx);
+            // Throw, never return Err, past this point: the approved-row delete above
+            // must roll back when the proposal was already resolved by a concurrent
+            // reviewer, or the live value is lost with no replacement.
+            if (!updated)
+                throw new CommerceNotFoundError("Custom field proposal not found.");
+            if (status === "approved") {
+                await this.repository.rejectOtherProposedCustomFields(entityId, fieldName, locale, updated.id, txCtx);
+            }
+            await this.captureRevision(entityId, reviewer, "update", txCtx);
+            return Ok(updated);
+        });
+    }
+    approveCustomField(entityId, fieldName, locale, actor, ctx) {
+        return this.reviewCustomField("approved", entityId, fieldName, locale, actor, ctx);
+    }
+    rejectCustomField(entityId, fieldName, locale, actor, ctx) {
+        return this.reviewCustomField("rejected", entityId, fieldName, locale, actor, ctx);
     }
     getAttributes(entityId, locale, ctx) {
         return this.entities.getAttributes(entityId, locale, ctx);
@@ -64,10 +545,20 @@ export class CatalogServiceImpl {
         return this.categories.deleteCategory(id, actor, ctx);
     }
     addToCategory(entityId, categoryId, actor, ctx) {
-        return this.categories.addToCategory(entityId, categoryId, actor, ctx);
+        return this.withMutationResult(actor, ctx, async (txCtx) => {
+            const result = await this.categories.addToCategory(entityId, categoryId, actor, txCtx);
+            if (result.ok)
+                await this.captureRevision(entityId, actor, "update", txCtx);
+            return result;
+        });
     }
     removeFromCategory(entityId, categoryId, actor, ctx) {
-        return this.categories.removeFromCategory(entityId, categoryId, actor, ctx);
+        return this.withMutationResult(actor, ctx, async (txCtx) => {
+            const result = await this.categories.removeFromCategory(entityId, categoryId, actor, txCtx);
+            if (result.ok)
+                await this.captureRevision(entityId, actor, "update", txCtx);
+            return result;
+        });
     }
     listBrands(ctx) {
         return this.brands.listBrands(ctx);
@@ -82,10 +573,20 @@ export class CatalogServiceImpl {
         return this.brands.deleteBrand(id, actor, ctx);
     }
     addToBrand(entityId, brandId, actor, ctx) {
-        return this.brands.addToBrand(entityId, brandId, actor, ctx);
+        return this.withMutationResult(actor, ctx, async (txCtx) => {
+            const result = await this.brands.addToBrand(entityId, brandId, actor, txCtx);
+            if (result.ok)
+                await this.captureRevision(entityId, actor, "update", txCtx);
+            return result;
+        });
     }
     removeFromBrand(entityId, brandId, actor, ctx) {
-        return this.brands.removeFromBrand(entityId, brandId, actor, ctx);
+        return this.withMutationResult(actor, ctx, async (txCtx) => {
+            const result = await this.brands.removeFromBrand(entityId, brandId, actor, txCtx);
+            if (result.ok)
+                await this.captureRevision(entityId, actor, "update", txCtx);
+            return result;
+        });
     }
     createOptionType(input, actor, ctx) {
         return this.entities.createOptionType(input, actor, ctx);