@ketvietlab/ketsuite 0.1.2 → 0.1.3

package/dist/modules/product/functions.js

@@ -1,7 +1,59 @@
-import { asc, bucketEq, compileListFilter, defineFn, deleteFrom, desc, eq, from, isNull, like, } from '@ketvietlab/ketjs';
+import { asc, bucketEq, compileListFilter, defineFn, deleteFrom, desc, eq, from, ilike, inArray, isNull, } from '@ketvietlab/ketjs';
 import { PRODUCT_TYPES } from './types.js';
 import { emptyProductListState, productListSearch } from './search.js';
-const listStateOf = (value) => value && typeof value === 'object' ? value : null;
+/**
+ * The same escape the framework applies to `state.q`, so a term containing `%`
+ * or `_` is matched literally rather than as a wildcard. Paired with the escape
+ * flag on `ilike`, which is what puts `ESCAPE '\'` on the statement.
+ */
+const wildcard = (value) => String(value ?? '').replace(/[\\%_]/g, '\\$&');
+/**
+ * The `search` and `limit` a relation picker sends, applied in memory.
+ *
+ * These lists are small and already fully loaded by their handler, so narrowing
+ * here costs nothing and keeps the picker's contract — a `search` term and a
+ * `limit` on every call — satisfiable without a second query path.
+ */
+const narrow = (rows, args, fields) => {
+    const needle = String(args.search ?? '')
+        .trim()
+        .toLocaleLowerCase();
+    const matched = needle
+        ? rows.filter((row) => fields.some((field) => String(row[field] ?? '')
+            .toLocaleLowerCase()
+            .includes(needle)))
+        : rows;
+    const rawOffset = Number(args.offset);
+    const offset = Number.isInteger(rawOffset) && rawOffset > 0 ? rawOffset : 0;
+    const limit = Number(args.limit);
+    return Number.isInteger(limit) && limit > 0 ? matched.slice(offset, offset + limit) : matched.slice(offset);
+};
+/**
+ * A caller's list state is JSON, so it may be partial or the wrong shape entirely.
+ * Filling every field from the empty state keeps `compileListFilter` and the group
+ * walk working on the arrays they are typed to expect: `{ state: {} }` is a
+ * reasonable thing for an agent to send, and it should narrow nothing rather than
+ * throw a TypeError from inside the framework.
+ */
+const listStateOf = (value) => {
+    if (!value || typeof value !== 'object')
+        return null;
+    const raw = value;
+    const empty = emptyProductListState();
+    const page = Number(raw.page);
+    return {
+        ...empty,
+        ...raw,
+        presets: Array.isArray(raw.presets) ? raw.presets : empty.presets,
+        filters: Array.isArray(raw.filters) ? raw.filters : empty.filters,
+        groupBy: Array.isArray(raw.groupBy) ? raw.groupBy : empty.groupBy,
+        sort: Array.isArray(raw.sort) && raw.sort.length ? raw.sort : empty.sort,
+        openGroups: Array.isArray(raw.openGroups) ? raw.openGroups : empty.openGroups,
+        groupPages: raw.groupPages && typeof raw.groupPages === 'object' ? raw.groupPages : empty.groupPages,
+        page: Number.isInteger(page) && page > 0 ? page : empty.page,
+        includeArchived: raw.includeArchived === true,
+    };
+};
 const templateQuery = (ctx, args) => {
     const T = ctx.table('product.Template');
     const state = listStateOf(args.state);
@@ -12,7 +64,7 @@ const templateQuery = (ctx, args) => {
     if (args.type != null)
         query = query.where(eq(T.type, args.type));
     if (args.search)
-        query = query.where(like(T.name, `%${args.search}%`));
+        query = query.where(ilike(T.name, `%${wildcard(args.search)}%`, true));
     const compiled = compileListFilter(productListSearch(T), normalized, { timezone: args.timezone ?? 'UTC' });
     if (compiled)
         query = query.where(compiled);
@@ -40,36 +92,324 @@ const templateQuery = (ctx, args) => {
     return query;
 };
 const productExists = async (ctx, id) => Boolean((await ctx.db.select('product.Product', { id }))[0]);
+/**
+ * The id of a company-scoped row, carrying the company it belongs to.
+ *
+ * `id` is a tenant-wide primary key, so a derived id built only from the shared
+ * ids either collides across companies or reads as another company's row. Reads
+ * span the whole readable company set while writes are pinned to the active
+ * company, so a lookup that ignores the company finds a row it can never write.
+ */
+const companyKey = (company, ...parts) => [company, ...parts.map((part) => String(part))].join(':');
 const uomRoot = (row) => String(row.parentPath).split('/').filter(Boolean)[0] ?? '';
+/**
+ * What a variant is called, spelled out from the values that define it.
+ *
+ * `product.Product` has no name of its own — a variant *is* its combination, and
+ * storing a copy of that would be a second source of truth to keep in step. So
+ * the name is derived: "Đỏ · L" for a variant of colour and size. Callers that
+ * only need one variant still pay one pass, which is why the whole set is
+ * resolved at once rather than per row.
+ */
+const describeVariants = async (ctx, products) => {
+    if (!products.length)
+        return products;
+    const wanted = new Set(products.map((product) => String(product.id)));
+    const links = (await ctx.db.select('product.ProductValue')).filter((link) => wanted.has(String(link.productId)));
+    if (!links.length)
+        return products.map((product) => ({ ...product, values: [], name: null }));
+    const templateValues = new Map((await ctx.db.select('product.TemplateAttributeValue')).map((row) => [String(row.id), row]));
+    const attributeValues = new Map((await ctx.db.select('product.AttributeValue')).map((row) => [String(row.id), row]));
+    const lines = new Map((await ctx.db.select('product.TemplateAttributeLine')).map((row) => [String(row.id), row]));
+    const attributes = new Map((await ctx.db.select('product.Attribute')).map((row) => [String(row.id), row]));
+    const byProduct = new Map();
+    for (const link of links) {
+        const templateValue = templateValues.get(String(link.templateAttributeValueId));
+        const value = templateValue ? attributeValues.get(String(templateValue.valueId)) : undefined;
+        if (!value)
+            continue;
+        const line = templateValue ? lines.get(String(templateValue.lineId)) : undefined;
+        const attribute = line ? attributes.get(String(line.attributeId)) : undefined;
+        const held = byProduct.get(String(link.productId)) ?? [];
+        held.push({
+            valueId: String(value.id),
+            value: String(value.name),
+            attributeId: attribute ? String(attribute.id) : null,
+            attribute: attribute ? String(attribute.name) : null,
+            sequence: Number(attribute?.sequence ?? 10),
+            valueSequence: Number(value.sequence ?? 10),
+        });
+        byProduct.set(String(link.productId), held);
+    }
+    return products.map((product) => {
+        const values = (byProduct.get(String(product.id)) ?? []).sort((a, b) => Number(a.sequence) - Number(b.sequence) ||
+            Number(a.valueSequence) - Number(b.valueSequence) ||
+            String(a.value).localeCompare(String(b.value)));
+        return {
+            ...product,
+            values,
+            name: values.length ? values.map((entry) => String(entry.value)).join(' · ') : null,
+        };
+    });
+};
+const templateSummary = (template) => ({
+    id: String(template.id),
+    name: String(template.name),
+    type: String(template.type),
+    categoryId: template.categoryId == null ? null : String(template.categoryId),
+    brandId: template.brandId == null ? null : String(template.brandId),
+    uomId: template.uomId == null ? null : String(template.uomId),
+    listPrice: String(template.listPrice),
+    origin: template.origin == null ? null : String(template.origin),
+    saleOk: template.saleOk === true,
+    purchaseOk: template.purchaseOk === true,
+    active: template.active !== false,
+});
+/**
+ * What both unit writers have to agree on before touching `product.ProductUom`.
+ *
+ * The existing row is matched on (productId, uomId) within the active company
+ * rather than on a derived id: a read spans every readable company, so an id-only
+ * lookup can return a sibling company's row — which the write then filters out,
+ * changing nothing. Matching this way also still finds rows written under the
+ * older tenant-global id scheme.
+ */
+const productUomTarget = async (ctx, args) => {
+    if (!(await productExists(ctx, args.productId)))
+        return { ok: false, errors: [{ field: 'productId', message: 'biến thể không tồn tại' }] };
+    const company = ctx.scope.company;
+    if (!company)
+        return { ok: false, errors: [{ field: 'company', message: 'cần chọn company để ghi đơn vị' }] };
+    const unit = (await ctx.db.select('uom.Unit', { id: args.uomId }))[0];
+    if (!unit)
+        return { ok: false, errors: [{ field: 'uomId', message: 'đơn vị không tồn tại' }] };
+    const product = (await ctx.db.select('product.Product', { id: args.productId }))[0];
+    const template = (await ctx.db.select('product.Template', { id: product.templateId }))[0];
+    const primary = template.uomId ? (await ctx.db.select('uom.Unit', { id: template.uomId }))[0] : null;
+    if (!primary || uomRoot(primary) !== uomRoot(unit))
+        return { ok: false, errors: [{ field: 'uomId', message: 'đơn vị phải cùng cây với UoM mặc định' }] };
+    const existing = (await ctx.db.select('product.ProductUom', { productId: args.productId, uomId: args.uomId })).find((row) => String(row.companyId) === company);
+    return {
+        ok: true,
+        company,
+        id: existing ? String(existing.id) : companyKey(company, args.productId, args.uomId),
+        existing,
+    };
+};
+/**
+ * Whether a barcode is held by a row that will still exist after this write.
+ *
+ * The index is `(companyId, barcode)`, so the check is scoped to the company —
+ * and `ignoreIds` names the rows the caller is about to overwrite or delete.
+ * Without it, replacing a variant's unit while keeping its barcode collides with
+ * the very row the replacement removes.
+ */
+const productUomBarcodeTaken = async (ctx, company, barcode, ignoreIds) => (await ctx.db.select('product.ProductUom', { barcode })).some((row) => String(row.companyId) === company && !ignoreIds.has(String(row.id)));
+/** The ids this company holds for a variant — every row a replace will drop. */
+const productUomIds = async (ctx, company, productId) => new Set((await ctx.db.select('product.ProductUom', { productId }))
+    .filter((row) => String(row.companyId) === company)
+    .map((row) => String(row.id)));
+const writeProductUom = async (ctx, target, args) => {
+    if (target.existing)
+        await ctx.db.update('product.ProductUom', { id: target.id }, { barcode: args.barcode ?? null });
+    else
+        await ctx.db.insert('product.ProductUom', {
+            id: target.id,
+            productId: args.productId,
+            uomId: args.uomId,
+            barcode: args.barcode ?? null,
+        });
+    await ctx.db.update('uom.Unit', { id: args.uomId }, { locked: true });
+};
+/** Drop every unit this company holds for the variant, except the one being kept. */
+const dropProductUoms = async (ctx, company, productId, keep) => {
+    const U = ctx.table('product.ProductUom');
+    for (const row of await ctx.db.select('product.ProductUom', { productId }))
+        if (String(row.companyId) === company && String(row.id) !== keep)
+            await ctx.db.del(deleteFrom(U).where(eq(U.id, row.id)));
+};
 export const functions = {
+    /**
+     * The variants of one template, or of the whole catalogue.
+     *
+     * `templateId` became optional so a relation picker on a sale or purchase line
+     * can search every variant at once — that field holds a variant, not a template,
+     * and the forms were flat-mapping the entire catalogue into a `<select>`.
+     * `search` matches the derived name, the internal reference and the barcode,
+     * which are the three things a person has in front of them.
+     */
     listVariants: defineFn({
-        input: { templateId: 'id' },
-        effects: ['read:product.Product'],
+        input: {
+            templateId: 'id?',
+            ids: 'json?',
+            search: 'text?',
+            limit: 'int?',
+            offset: 'int?',
+            includeArchived: 'bool?',
+            active: 'bool?',
+            type: 'text?',
+            saleOk: 'bool?',
+            purchaseOk: 'bool?',
+            requireUom: 'bool?',
+        },
+        effects: [
+            'read:product.Product',
+            'read:product.Template',
+            'read:product.ProductValue',
+            'read:product.TemplateAttributeValue',
+            'read:product.TemplateAttributeLine',
+            'read:product.AttributeValue',
+            'read:product.Attribute',
+        ],
         agent: true,
-        handler: (ctx, args) => ctx.db.select('product.Product', { templateId: args.templateId }),
+        handler: async (ctx, args) => {
+            const wanted = Array.isArray(args.ids) ? [...new Set(args.ids.map(String))].slice(0, 2_000) : null;
+            if (wanted && !wanted.length)
+                return [];
+            const P = ctx.table('product.Product');
+            const rows = wanted
+                ? await ctx.db.all(from(P).where(inArray(P.id, wanted)))
+                : await ctx.db.select('product.Product', args.templateId == null ? {} : { templateId: args.templateId });
+            const templates = new Map((await ctx.db.select('product.Template')).map((row) => [String(row.id), row]));
+            const eligible = rows.filter((row) => {
+                const template = templates.get(String(row.templateId));
+                if (!template)
+                    return false;
+                const active = row.active !== false && template.active !== false;
+                if (args.includeArchived !== true && !active)
+                    return false;
+                if (args.active === true && !active)
+                    return false;
+                if (args.active === false && active)
+                    return false;
+                if (args.type && template.type !== args.type)
+                    return false;
+                if (args.saleOk === true && template.saleOk !== true)
+                    return false;
+                if (args.purchaseOk === true && template.purchaseOk !== true)
+                    return false;
+                if (args.requireUom === true && template.uomId == null)
+                    return false;
+                return true;
+            });
+            const described = await describeVariants(ctx, eligible);
+            // The template's name is what makes a variant recognisable in a list that
+            // spans the catalogue: "Xanh nghiệp vụ" alone says nothing about which
+            // product it belongs to.
+            const labelled = described.map((variant) => ({
+                ...variant,
+                templateName: templates.get(String(variant.templateId))?.name == null
+                    ? null
+                    : String(templates.get(String(variant.templateId)).name),
+                template: templateSummary(templates.get(String(variant.templateId))),
+            }));
+            return narrow(labelled.sort((left, right) => String(left.id).localeCompare(String(right.id))), args, ['name', 'templateName', 'defaultCode', 'barcode']);
+        },
+    }),
+    /** Safe catalogue detail without company cost or barcode-unit records. */
+    getVariantSummary: defineFn({
+        input: { id: 'id' },
+        effects: [
+            'read:product.Product',
+            'read:product.Template',
+            'read:product.ProductValue',
+            'read:product.TemplateAttributeValue',
+            'read:product.TemplateAttributeLine',
+            'read:product.AttributeValue',
+            'read:product.Attribute',
+        ],
+        agent: true,
+        handler: async (ctx, args) => {
+            const found = (await ctx.db.select('product.Product', { id: args.id }))[0];
+            if (!found)
+                return null;
+            const template = (await ctx.db.select('product.Template', { id: found.templateId }))[0];
+            if (!template)
+                return null;
+            const product = (await describeVariants(ctx, [found]))[0];
+            return { ...product, template: templateSummary(template) };
+        },
     }),
     getVariant: defineFn({
         input: { id: 'id' },
-        effects: ['read:product.Product', 'read:product.Cost', 'read:product.ProductUom'],
+        effects: [
+            'read:product.Product',
+            'read:product.Cost',
+            'read:product.ProductUom',
+            'read:product.ProductValue',
+            'read:product.TemplateAttributeValue',
+            'read:product.TemplateAttributeLine',
+            'read:product.AttributeValue',
+            'read:product.Attribute',
+        ],
         agent: true,
         handler: async (ctx, args) => {
-            const product = (await ctx.db.select('product.Product', { id: args.id }))[0];
-            if (!product)
+            const found = (await ctx.db.select('product.Product', { id: args.id }))[0];
+            if (!found)
                 return null;
+            const product = (await describeVariants(ctx, [found]))[0];
+            // Cost and ProductUom are company-scoped, and a read spans every readable
+            // company — so both are narrowed to the active one. Otherwise the variant
+            // screen shows a sibling company's cost and unit, and saving the form
+            // writes those values into this company.
+            const company = ctx.scope.company;
+            const costs = await ctx.db.select('product.Cost', { productId: args.id });
+            const uoms = await ctx.db.select('product.ProductUom', { productId: args.id });
+            const mine = (rows) => company ? rows.filter((row) => String(row.companyId) === company) : [];
             return {
                 ...product,
-                cost: (await ctx.db.select('product.Cost', { productId: args.id }))[0] ?? null,
-                uoms: await ctx.db.select('product.ProductUom', { productId: args.id }),
+                cost: mine(costs)[0] ?? null,
+                // Ordered, because the variant form renders `uoms[0]` and `select` has no
+                // ORDER BY of its own.
+                uoms: mine(uoms).sort((a, b) => String(a.id).localeCompare(String(b.id))),
             };
         },
     }),
+    /** Company-scoped batch cost evidence for bounded operational catalogues. */
+    listVariantCosts: defineFn({
+        input: { productIds: 'json' },
+        output: { productId: 'id', standardPrice: 'decimal' },
+        effects: ['read:product.Cost'],
+        agent: true,
+        handler: async (ctx, args) => {
+            const productIds = [
+                ...new Set(Array.isArray(args.productIds) ? args.productIds.map(String).slice(0, 2_000) : []),
+            ];
+            if (!productIds.length || !ctx.scope.company)
+                return [];
+            const C = ctx.table('product.Cost');
+            return ctx.db.all(from(C).where(eq(C.companyId, ctx.scope.company), inArray(C.productId, productIds)));
+        },
+    }),
     listAttributes: defineFn({
-        input: {},
+        input: { search: 'text?', limit: 'int?', variantsOnly: 'bool?' },
         effects: ['read:product.Attribute', 'read:product.AttributeValue'],
         agent: true,
-        handler: (ctx) => {
+        handler: async (ctx, args) => {
             const A = ctx.table('product.Attribute');
-            return ctx.db.all(from(A).orderBy(asc(A.sequence), asc(A.name)).preload('values'));
+            const rows = await ctx.db.all(from(A).orderBy(asc(A.sequence), asc(A.name)).preload('values'));
+            return narrow(args.variantsOnly === true
+                ? rows.filter((attribute) => attribute.createVariant !== 'no_variant')
+                : rows, args, ['name']);
+        },
+    }),
+    /**
+     * Attribute values on their own, rather than nested inside their attribute.
+     *
+     * A picker asks for the values of one attribute and narrows them as the user
+     * types; reaching them through `listAttributes` would mean shipping every
+     * attribute's values to filter one attribute's worth in the browser.
+     */
+    listAttributeValues: defineFn({
+        input: { attributeId: 'id?', search: 'text?', limit: 'int?' },
+        output: { id: 'id', attributeId: 'id', name: 'text', sequence: 'int' },
+        effects: ['read:product.AttributeValue'],
+        agent: true,
+        handler: async (ctx, args) => {
+            const V = ctx.table('product.AttributeValue');
+            const base = from(V).orderBy(asc(V.sequence), asc(V.name));
+            const rows = await ctx.db.all(args.attributeId == null ? base : base.where(eq(V.attributeId, args.attributeId)));
+            return narrow(rows, args, ['name']);
         },
     }),
     listTemplates: defineFn({
@@ -150,7 +490,9 @@ export const functions = {
             name: 'text',
             type: 'text',
             categoryId: 'id?',
+            brandId: 'id?',
             uomId: 'id?',
+            origin: 'text?',
             description: 'text?',
             listPrice: 'decimal',
             saleOk: 'bool',
@@ -160,18 +502,20 @@ export const functions = {
             category: 'json?',
             uoms: 'json?',
             attributeLines: 'json?',
+            brand: 'json?',
         },
         effects: [
             'read:product.Template',
             'read:product.Product',
             'read:product.Category',
+            'read:product.Brand',
             'read:product.TemplateUom',
             'read:product.TemplateAttributeLine',
         ],
         agent: true,
         handler: async (ctx, args) => {
             const T = ctx.table('product.Template');
-            const row = await ctx.db.one(from(T).where(eq(T.id, args.id)).preload('variants', 'category', 'uoms', 'attributeLines'));
+            const row = await ctx.db.one(from(T).where(eq(T.id, args.id)).preload('variants', 'category', 'brand', 'uoms', 'attributeLines'));
             return row;
         },
     }),
@@ -181,14 +525,26 @@ export const functions = {
             name: 'text',
             type: 'text',
             categoryId: 'id?',
+            brandId: 'id?',
             uomId: 'id?',
+            origin: 'text?',
             description: 'text?',
             listPrice: 'decimal?',
             saleOk: 'bool?',
             purchaseOk: 'bool?',
+            defaultCode: 'text?',
+            barcode: 'text?',
         },
         output: { ok: 'bool', id: 'id?', errors: 'json?' },
-        effects: ['read:product.Template', 'write:product.Template', 'read:uom.Unit', 'write:uom.Unit'],
+        effects: [
+            'read:product.Template',
+            'write:product.Template',
+            'read:product.Product',
+            'write:product.Product',
+            'read:product.Brand',
+            'read:uom.Unit',
+            'write:uom.Unit',
+        ],
         idempotent: true,
         agent: true,
         handler: async (ctx, args) => {
@@ -199,7 +555,16 @@ export const functions = {
                 };
             if (args.uomId && !(await ctx.db.select('uom.Unit', { id: args.uomId }))[0])
                 return { ok: false, errors: [{ field: 'uomId', message: 'không có đơn vị nào mang id này' }] };
+            if (args.brandId && !(await ctx.db.select('product.Brand', { id: args.brandId }))[0])
+                return { ok: false, errors: [{ field: 'brandId', message: 'thương hiệu không tồn tại' }] };
             const existing = (await ctx.db.select('product.Template', { id: args.id }))[0];
+            const products = await ctx.db.select('product.Product', { templateId: args.id });
+            const defaultVariant = products.find((product) => String(product.combinationKey) === '');
+            if (args.barcode) {
+                const collision = (await ctx.db.select('product.Product', { barcode: args.barcode }))[0];
+                if (collision && collision.id !== defaultVariant?.id)
+                    return { ok: false, errors: [{ field: 'barcode', message: 'barcode đã được dùng' }] };
+            }
             let changes = ctx
                 .change('product.Template', args, existing ?? null)
                 .cast([
@@ -207,7 +572,9 @@ export const functions = {
                 'name',
                 'type',
                 'categoryId',
+                'brandId',
                 'uomId',
+                'origin',
                 'description',
                 'listPrice',
                 'saleOk',
@@ -225,12 +592,60 @@ export const functions = {
                 return { ok: false, errors: changes.errors };
             await ctx.tx(async (tx) => {
                 await tx.db.commit(changes, existing ? { id: args.id } : undefined);
+                const generated = products.some((product) => String(product.combinationKey) !== '' && product.active !== false);
+                const identity = {
+                    ...(Object.hasOwn(args, 'defaultCode') ? { defaultCode: args.defaultCode ?? null } : {}),
+                    ...(Object.hasOwn(args, 'barcode') ? { barcode: args.barcode ?? null } : {}),
+                    active: !generated,
+                };
+                if (defaultVariant)
+                    await tx.db.update('product.Product', { id: defaultVariant.id }, identity);
+                else
+                    await tx.db.insert('product.Product', {
+                        id: `${String(args.id)}:default`,
+                        templateId: args.id,
+                        defaultCode: args.defaultCode ?? null,
+                        barcode: args.barcode ?? null,
+                        weight: '0',
+                        volume: '0',
+                        combinationKey: '',
+                        active: !generated,
+                    });
                 if (args.uomId)
                     await tx.db.update('uom.Unit', { id: args.uomId }, { locked: true });
             });
             return { ok: true, id: args.id };
         },
     }),
+    listBrands: defineFn({
+        input: { search: 'text?', limit: 'int?', includeArchived: 'bool?' },
+        output: { id: 'id', name: 'text', active: 'bool' },
+        effects: ['read:product.Brand'],
+        agent: true,
+        handler: async (ctx, args) => {
+            const B = ctx.table('product.Brand');
+            const rows = await ctx.db.all(from(B).orderBy(asc(B.name)));
+            return narrow(args.includeArchived === true ? rows : rows.filter((brand) => brand.active !== false), args, ['name']);
+        },
+    }),
+    saveBrand: defineFn({
+        input: { id: 'id', name: 'text', active: 'bool?' },
+        output: { ok: 'bool', id: 'id?', errors: 'json?' },
+        effects: ['read:product.Brand', 'write:product.Brand'],
+        idempotent: true,
+        agent: true,
+        handler: async (ctx, args) => {
+            const existing = (await ctx.db.select('product.Brand', { id: args.id }))[0];
+            const changes = ctx
+                .change('product.Brand', { ...args, active: args.active ?? true }, existing ?? null)
+                .cast(['id', 'name', 'active'])
+                .required(['name']);
+            if (!changes.valid)
+                return { ok: false, errors: changes.errors };
+            await ctx.db.commit(changes, existing ? { id: args.id } : undefined);
+            return { ok: true, id: args.id };
+        },
+    }),
     saveVariant: defineFn({
         input: {
             id: 'id',
@@ -250,9 +665,12 @@ export const functions = {
             if (!(await ctx.db.select('product.Template', { id: args.templateId }))[0])
                 return { ok: false, errors: [{ field: 'templateId', message: 'không có template nào mang id này' }] };
             const existing = (await ctx.db.select('product.Product', { id: args.id }))[0];
+            const implicitDefault = !existing && args.combinationKey === ''
+                ? (await ctx.db.select('product.Product', { templateId: args.templateId })).find((product) => String(product.combinationKey) === '')
+                : null;
             if (args.barcode) {
                 const collision = (await ctx.db.select('product.Product', { barcode: args.barcode }))[0];
-                if (collision && collision.id !== args.id)
+                if (collision && collision.id !== args.id && collision.id !== implicitDefault?.id)
                     return { ok: false, errors: [{ field: 'barcode', message: 'barcode đã được dùng' }] };
             }
             const values = {
@@ -278,7 +696,17 @@ export const functions = {
                     .put('active', true);
             if (!changes.valid)
                 return { ok: false, errors: changes.errors };
-            await ctx.db.commit(changes, existing ? { id: args.id } : undefined);
+            await ctx.tx(async (tx) => {
+                // Older integrations create the no-combination variant under their own
+                // business id immediately after saving a template. Replace the fresh,
+                // deterministic implicit row before anything can reference it, keeping
+                // that public workflow compatible with the new default-variant model.
+                if (implicitDefault) {
+                    const Product = tx.table('product.Product');
+                    await tx.db.del(deleteFrom(Product).where(eq(Product.id, implicitDefault.id)));
+                }
+                await tx.db.commit(changes, existing ? { id: args.id } : undefined);
+            });
             return { ok: true, id: args.id };
         },
     }),
@@ -346,6 +774,86 @@ export const functions = {
             return { ok: true, id: args.id };
         },
     }),
+    /**
+     * The attribute lines of a template, each with the values it allows.
+     *
+     * `getTemplate` preloads the lines but not what is on them, and a line without
+     * its values says nothing a reader can act on — "Màu sắc" is not an answer to
+     * "which colours does this product come in".
+     */
+    listAttributeLines: defineFn({
+        input: { templateId: 'id' },
+        output: { id: 'id', templateId: 'id', attributeId: 'id', attribute: 'text?', values: 'json?' },
+        effects: [
+            'read:product.TemplateAttributeLine',
+            'read:product.TemplateAttributeValue',
+            'read:product.AttributeValue',
+            'read:product.Attribute',
+        ],
+        agent: true,
+        handler: async (ctx, args) => {
+            const lines = await ctx.db.select('product.TemplateAttributeLine', { templateId: args.templateId });
+            if (!lines.length)
+                return [];
+            const attributes = new Map((await ctx.db.select('product.Attribute')).map((row) => [String(row.id), row]));
+            const values = new Map((await ctx.db.select('product.AttributeValue')).map((row) => [String(row.id), row]));
+            const templateValues = await ctx.db.select('product.TemplateAttributeValue');
+            const byLine = new Map();
+            for (const templateValue of templateValues) {
+                const value = values.get(String(templateValue.valueId));
+                if (!value)
+                    continue;
+                const held = byLine.get(String(templateValue.lineId)) ?? [];
+                held.push({ id: String(value.id), name: String(value.name), sequence: Number(value.sequence ?? 10) });
+                byLine.set(String(templateValue.lineId), held);
+            }
+            return lines
+                .map((line) => {
+                const attribute = attributes.get(String(line.attributeId));
+                return {
+                    id: String(line.id),
+                    templateId: String(line.templateId),
+                    attributeId: String(line.attributeId),
+                    attribute: attribute ? String(attribute.name) : null,
+                    sequence: Number(attribute?.sequence ?? 10),
+                    values: (byLine.get(String(line.id)) ?? []).sort((a, b) => Number(a.sequence) - Number(b.sequence) || String(a.name).localeCompare(String(b.name))),
+                };
+            })
+                .sort((a, b) => a.sequence - b.sequence || String(a.attribute ?? '').localeCompare(String(b.attribute ?? '')));
+        },
+    }),
+    /**
+     * Take an attribute off a template, with the values it carried.
+     *
+     * Variants already generated from it are left alone: they are real records
+     * that may be on documents. Regenerating is what prunes them, and that is a
+     * decision the reader makes rather than a side effect of this one.
+     */
+    removeAttributeLine: defineFn({
+        input: { id: 'id' },
+        output: { ok: 'bool', id: 'id?' },
+        effects: [
+            'read:product.TemplateAttributeLine',
+            'read:product.TemplateAttributeValue',
+            'write:product.TemplateAttributeLine',
+            'write:product.TemplateAttributeValue',
+        ],
+        idempotent: true,
+        agent: true,
+        handler: async (ctx, args) => {
+            const line = (await ctx.db.select('product.TemplateAttributeLine', { id: args.id }))[0];
+            if (!line)
+                return { ok: true };
+            await ctx.tx(async (tx) => {
+                const TAV = tx.table('product.TemplateAttributeValue');
+                for (const value of await tx.db.select('product.TemplateAttributeValue', { lineId: args.id }))
+                    await tx.db.del(deleteFrom(TAV).where(eq(TAV.id, value.id)));
+                const TAL = tx.table('product.TemplateAttributeLine');
+                await tx.db.del(deleteFrom(TAL).where(eq(TAL.id, args.id)));
+            });
+            return { ok: true, id: String(args.id) };
+        },
+    }),
     saveAttributeLine: defineFn({
         input: { id: 'id', templateId: 'id', attributeId: 'id', valueIds: 'json' },
         output: { ok: 'bool', id: 'id?', errors: 'json?' },
@@ -490,8 +998,13 @@ export const functions = {
             const standardPrice = args.standardPrice ?? args.amount;
             if (standardPrice == null)
                 return { ok: false, errors: [{ field: 'standardPrice', message: 'bắt buộc' }] };
-            const existing = (await ctx.db.select('product.Cost', { productId: args.productId }))[0];
-            const id = existing?.id ?? `${ctx.scope.company}:${String(args.productId)}`;
+            // Look the row up by the id that already names the active company, not by
+            // productId: a read spans every readable company, so searching on productId
+            // alone can return a sibling company's cost. Updating that row then filters
+            // on the active company and changes nothing, while the insert branch is
+            // skipped — a write that reports success and stores no price.
+            const id = companyKey(ctx.scope.company, args.productId);
+            const existing = (await ctx.db.select('product.Cost', { id }))[0];
             if (existing)
                 await ctx.db.update('product.Cost', { id }, { standardPrice });
             else
@@ -536,35 +1049,66 @@ export const functions = {
         ],
         idempotent: true,
         agent: true,
+        handler: async (ctx, args) => {
+            const target = await productUomTarget(ctx, args);
+            if (!target.ok)
+                return target;
+            // Only this row is overwritten; another unit of the same variant keeping
+            // the barcode is a genuine collision.
+            if (args.barcode &&
+                (await productUomBarcodeTaken(ctx, target.company, args.barcode, new Set([target.id]))))
+                return { ok: false, errors: [{ field: 'barcode', message: 'barcode đã được dùng trong company' }] };
+            await writeProductUom(ctx, target, args);
+            return { ok: true, id: target.id };
+        },
+    }),
+    /**
+     * The variant's unit, as one value rather than a growing list.
+     *
+     * `addProductUom` is an add and stays one, but the variant form offers a single
+     * select: submitting it has to *replace* what is there, or changing the unit
+     * silently leaves the old row behind and the form — which renders the first row
+     * it is given — keeps showing the unit the user just changed away from. A null
+     * `uomId` clears the unit, which is what the form's empty option means.
+     */
+    setProductUom: defineFn({
+        input: { productId: 'id', uomId: 'id?', barcode: 'text?' },
+        output: { ok: 'bool', id: 'id?', errors: 'json?' },
+        effects: [
+            'read:product.Product',
+            'read:product.Template',
+            'read:product.ProductUom',
+            'read:uom.Unit',
+            'write:uom.Unit',
+            'write:product.ProductUom',
+        ],
+        idempotent: true,
+        agent: true,
         handler: async (ctx, args) => {
             if (!(await productExists(ctx, args.productId)))
                 return { ok: false, errors: [{ field: 'productId', message: 'biến thể không tồn tại' }] };
-            const unit = (await ctx.db.select('uom.Unit', { id: args.uomId }))[0];
-            if (!unit)
-                return { ok: false, errors: [{ field: 'uomId', message: 'đơn vị không tồn tại' }] };
-            const product = (await ctx.db.select('product.Product', { id: args.productId }))[0];
-            const template = (await ctx.db.select('product.Template', { id: product.templateId }))[0];
-            const primary = template.uomId ? (await ctx.db.select('uom.Unit', { id: template.uomId }))[0] : null;
-            if (!primary || uomRoot(primary) !== uomRoot(unit))
-                return { ok: false, errors: [{ field: 'uomId', message: 'đơn vị phải cùng cây với UoM mặc định' }] };
-            const id = `${String(args.productId)}:${String(args.uomId)}`;
-            if (args.barcode) {
-                const collision = (await ctx.db.select('product.ProductUom', { barcode: args.barcode }))[0];
-                if (collision && collision.id !== id)
-                    return { ok: false, errors: [{ field: 'barcode', message: 'barcode đã được dùng trong company' }] };
+            const company = ctx.scope.company;
+            if (!company)
+                return { ok: false, errors: [{ field: 'company', message: 'cần chọn company để ghi đơn vị' }] };
+            if (args.uomId == null) {
+                await ctx.tx((tx) => dropProductUoms(tx, company, args.productId, null));
+                return { ok: true };
             }
-            const existing = (await ctx.db.select('product.ProductUom', { id }))[0];
-            if (existing)
-                await ctx.db.update('product.ProductUom', { id }, { barcode: args.barcode ?? null });
-            else
-                await ctx.db.insert('product.ProductUom', {
-                    id,
-                    productId: args.productId,
-                    uomId: args.uomId,
-                    barcode: args.barcode ?? null,
-                });
-            await ctx.db.update('uom.Unit', { id: args.uomId }, { locked: true });
-            return { ok: true, id };
+            const target = await productUomTarget(ctx, args);
+            if (!target.ok)
+                return target;
+            // Every unit this variant currently holds is about to be dropped, so none
+            // of them can collide — including the one whose barcode is being carried
+            // over to the unit replacing it.
+            const replaced = await productUomIds(ctx, company, args.productId);
+            replaced.add(target.id);
+            if (args.barcode && (await productUomBarcodeTaken(ctx, company, args.barcode, replaced)))
+                return { ok: false, errors: [{ field: 'barcode', message: 'barcode đã được dùng trong company' }] };
+            await ctx.tx(async (tx) => {
+                await dropProductUoms(tx, company, args.productId, target.id);
+                await writeProductUom(tx, target, args);
+            });
+            return { ok: true, id: target.id };
         },
     }),
     archiveTemplate: defineFn({
@@ -578,14 +1122,99 @@ export const functions = {
             return { id: args.id, active: args.active };
         },
     }),
+    deleteTemplates: defineFn({
+        input: { ids: 'json' },
+        output: { deleted: 'int' },
+        effects: [
+            'read:product.Template',
+            'read:product.Product',
+            'read:product.Cost',
+            'read:product.TemplateUom',
+            'read:product.ProductUom',
+            'read:product.TemplateAttributeLine',
+            'read:product.TemplateAttributeValue',
+            'read:product.ProductValue',
+            'write:product.Template',
+            'write:product.Product',
+            'write:product.Cost',
+            'write:product.TemplateUom',
+            'write:product.ProductUom',
+            'write:product.TemplateAttributeLine',
+            'write:product.TemplateAttributeValue',
+            'write:product.ProductValue',
+        ],
+        agent: true,
+        handler: async (ctx, args) => {
+            const ids = [...new Set(Array.isArray(args.ids) ? args.ids.map(String).filter(Boolean) : [])];
+            if (!ids.length)
+                return { deleted: 0 };
+            return ctx.tx(async (tx) => {
+                const Template = tx.table('product.Template');
+                const Product = tx.table('product.Product');
+                const Cost = tx.table('product.Cost');
+                const TemplateUom = tx.table('product.TemplateUom');
+                const ProductUom = tx.table('product.ProductUom');
+                const Line = tx.table('product.TemplateAttributeLine');
+                const Value = tx.table('product.TemplateAttributeValue');
+                const ProductValue = tx.table('product.ProductValue');
+                const products = await tx.db.all(from(Product).where(inArray(Product.templateId, ids)));
+                const productIds = products.map((row) => String(row.id));
+                const lines = await tx.db.all(from(Line).where(inArray(Line.templateId, ids)));
+                const lineIds = lines.map((row) => String(row.id));
+                if (productIds.length) {
+                    await tx.db.del(deleteFrom(ProductValue).where(inArray(ProductValue.productId, productIds)));
+                    await tx.db.del(deleteFrom(ProductUom).where(inArray(ProductUom.productId, productIds)));
+                    await tx.db.del(deleteFrom(Cost).where(inArray(Cost.productId, productIds)));
+                }
+                if (lineIds.length)
+                    await tx.db.del(deleteFrom(Value).where(inArray(Value.lineId, lineIds)));
+                await tx.db.del(deleteFrom(Line).where(inArray(Line.templateId, ids)));
+                await tx.db.del(deleteFrom(TemplateUom).where(inArray(TemplateUom.templateId, ids)));
+                if (productIds.length)
+                    await tx.db.del(deleteFrom(Product).where(inArray(Product.id, productIds)));
+                const result = await tx.db.del(deleteFrom(Template).where(inArray(Template.id, ids)));
+                return { deleted: result.changes };
+            });
+        },
+    }),
     listCategories: defineFn({
-        input: {},
-        output: { id: 'id', name: 'text', parentId: 'id?', children: 'json?' },
+        // `ids` narrows the answer to the categories a caller already named — a page
+        // of products wants the labels behind its categoryIds, not the tenant's whole
+        // tree. The rows are still all read, because `path` is an ancestry walk that
+        // the selected rows cannot answer alone, but children are left unloaded and
+        // only the named categories come back.
+        input: { search: 'text?', ids: 'json?', limit: 'int?' },
+        output: { id: 'id', name: 'text', parentId: 'id?', path: 'text?', children: 'json?' },
         effects: ['read:product.Category'],
         agent: true,
-        handler: (ctx) => ctx.db.all(from(ctx.table('product.Category'))
-            .orderBy(asc(ctx.table('product.Category').name))
-            .preload('children')),
+        handler: async (ctx, args) => {
+            const C = ctx.table('product.Category');
+            const wanted = Array.isArray(args.ids) ? new Set(args.ids.map(String)) : null;
+            if (wanted && !wanted.size)
+                return [];
+            // Children answer the tree picker. An id lookup walks parents instead, so
+            // preloading them there is work nobody reads.
+            const base = from(C).orderBy(asc(C.name));
+            const rows = await ctx.db.all(wanted ? base : base.preload('children'));
+            // A category is a node in a tree, and two branches may well hold a "Shirts".
+            // `path` spells the ancestry out so a flat picker list stays unambiguous;
+            // it is derived here rather than stored, and searching matches on it too.
+            const byId = new Map(rows.map((row) => [String(row.id), row]));
+            const pathOf = (row) => {
+                const parts = [];
+                const seen = new Set();
+                let cursor = row;
+                while (cursor && !seen.has(String(cursor.id))) {
+                    seen.add(String(cursor.id));
+                    parts.unshift(String(cursor.name));
+                    cursor = cursor.parentId == null ? undefined : byId.get(String(cursor.parentId));
+                }
+                return parts.join(' / ');
+            };
+            return narrow(rows
+                .filter((row) => (wanted ? wanted.has(String(row.id)) : true))
+                .map((row) => ({ ...row, path: pathOf(row) })), args, ['name', 'path']);
+        },
     }),
     saveCategory: defineFn({
         input: { id: 'id', name: 'text', parentId: 'id?' },