shutro-erp 0.3.4 → 0.3.6

package/dist/stock_account/module.js

@@ -0,0 +1,339 @@
+/**
+ * The data layer of the Stockroom ↔ Accounting bridge (RFC 0021 step 3, perpetual valuation): every validated
+ * transfer that brings goods into stock or takes them out is valued — at the product's average cost, or FIFO from
+ * the receipts still in stock — in a valuation layer, and posted at once in the Stock journal: a receipt to
+ * Inventory against Goods received not billed, a delivery to Cost of goods sold, a count's gain or loss to Stock
+ * adjustments. Internal moves keep their value. The stock's value at a date is the sum of its layers.
+ */
+import { accountingShutro } from '../accounting/index.js';
+import { productShutro } from '../product/index.js';
+import { orm } from '../server/orm.js';
+import { stockShutro } from '../stock/index.js';
+import { defineModel, defineModule, extendModel, f, method, } from './.kosh/bindings.js';
+const zero = orm.toDecimal(0);
+const money = (d) => d.toDecimalPlaces(2);
+/** The accounts this bridge adds to a chart (by code), when the chart has none with that code. */
+export const STOCK_ACCOUNTS = [
+    { code: '1250', name: 'Work in progress', type: 'asset_current' },
+    { code: '2150', name: 'Goods received not billed', type: 'liability_current' },
+    { code: '5100', name: 'Stock adjustments', type: 'expense_direct_cost' },
+    { code: '5110', name: 'Price differences', type: 'expense_direct_cost' },
+];
+const COMPANY_DEFAULTS = {
+    stockValuationAccount: '1200',
+    stockInterimAccount: '2150',
+    stockCogsAccount: '5000',
+    stockAdjustmentAccount: '5100',
+    stockPriceDiffAccount: '5110',
+    stockProductionAccount: '1250',
+};
+export const CategoryValuation = extendModel('product.category', {
+    fields: {
+        costMethod: f.selection({ average: 'Average cost', fifo: 'First in, first out (FIFO)' }, { label: 'Cost method' }),
+        stockValuationAccount: f.many2one('account.account', { label: 'Inventory account' }),
+        stockCogsAccount: f.many2one('account.account', { label: 'Cost of goods sold account' }),
+    },
+});
+export const ProductValuation = extendModel('product.product', {
+    fields: {
+        /** Empty: the category's, else average cost. */
+        costMethod: f.selection({ average: 'Average cost', fifo: 'First in, first out (FIFO)' }, { label: 'Cost method' }),
+        valuationLayers: f.one2many('stock.valuation.layer', 'product'),
+    },
+});
+export const CompanyStockAccounts = extendModel('res.company', {
+    fields: {
+        stockJournal: f.many2one('account.journal', { label: 'Stock journal' }),
+        stockValuationAccount: f.many2one('account.account', { label: 'Inventory account' }),
+        stockInterimAccount: f.many2one('account.account', {
+            label: 'Goods received not billed account',
+        }),
+        stockCogsAccount: f.many2one('account.account', { label: 'Cost of goods sold account' }),
+        stockAdjustmentAccount: f.many2one('account.account', { label: 'Stock adjustments account' }),
+        stockPriceDiffAccount: f.many2one('account.account', { label: 'Price differences account' }),
+        stockProductionAccount: f.many2one('account.account', { label: 'Work in progress account' }),
+    },
+});
+/**
+ * What a validated transfer did to a product's value: in (positive) or out (negative), at what unit cost, with its
+ * entry; an incoming layer keeps what of it is still in stock (FIFO). Written only by validations.
+ */
+export const StockValuationLayer = defineModel('stock.valuation.layer', {
+    label: 'Stock valuation',
+    order: ['id asc'],
+    companyScoped: { required: true },
+    access: {
+        'stock_account.user': ['read', 'export'],
+        'stock.manager': ['read', 'export'],
+        'account.user': ['read', 'export'],
+        'account.manager': ['read', 'export'],
+    },
+    fields: {
+        product: f.many2one('product.product', { required: true, ondelete: 'restrict' }),
+        picking: f.many2one('stock.picking', { ondelete: 'set null', label: 'Transfer' }),
+        move: f.many2one('stock.move', { ondelete: 'set null', label: 'Transfer line' }),
+        date: f.date({ required: true, default: (env) => env.today() }),
+        /** In the product's unit: positive in, negative out. */
+        quantity: f.decimal({ scale: 4, required: true }),
+        unitCost: f.decimal({ scale: 4, required: true, default: '0', label: 'Unit cost' }),
+        value: f.decimal({ scale: 2, required: true, default: '0' }),
+        remainingQty: f.decimal({ scale: 4, required: true, default: '0', label: 'Still in stock' }),
+        remainingValue: f.decimal({
+            scale: 2,
+            required: true,
+            default: '0',
+            label: 'Value still in stock',
+        }),
+        accountMove: f.many2one('account.move', { ondelete: 'set null', label: 'Entry' }),
+    },
+});
+export const PickingLayers = extendModel('stock.picking', {
+    fields: {
+        valuationLayers: f.one2many('stock.valuation.layer', 'picking'),
+    },
+});
+/**
+ * The accounts and the Stock journal of a company, made when missing: the bridge's accounts are added to the
+ * company's chart, the company's defaults point to them. Null when the company has no chart yet.
+ */
+export async function stockAccountsOf(env, company) {
+    const [c] = await env.model('res.company').browse([company]).load({});
+    if (c === undefined)
+        return null;
+    const chart = await env.model('account.account').search({ where: { company }, limit: 1 });
+    if (chart.length === 0)
+        return null;
+    const byCode = async (code) => (await env.model('account.account').search({ where: { company, code }, limit: 1 })).ids[0];
+    for (const a of STOCK_ACCOUNTS)
+        if ((await byCode(a.code)) === undefined)
+            await env.model('account.account').create([{ ...a, company }]);
+    const changes = {};
+    for (const [field, code] of Object.entries(COMPANY_DEFAULTS))
+        if (c[field] === null)
+            changes[field] = (await byCode(code)) ?? null;
+    if (c.stockJournal === null) {
+        const existing = await env
+            .model('account.journal')
+            .search({ where: { company, code: 'STJ' }, limit: 1 });
+        changes['stockJournal'] =
+            existing.ids[0] ??
+                (await env
+                    .model('account.journal')
+                    .create([{ name: 'Stock', code: 'STJ', type: 'general', company }])).ids[0];
+    }
+    if (Object.keys(changes).length > 0)
+        await env
+            .model('res.company')
+            .browse([company])
+            .write(changes);
+    const [after] = await env.model('res.company').browse([company]).load({});
+    if (after?.stockJournal == null ||
+        after.stockValuationAccount == null ||
+        after.stockInterimAccount == null ||
+        after.stockCogsAccount == null ||
+        after.stockAdjustmentAccount == null ||
+        after.stockPriceDiffAccount == null ||
+        after.stockProductionAccount == null)
+        return null;
+    return {
+        journal: after.stockJournal.id,
+        valuation: after.stockValuationAccount.id,
+        interim: after.stockInterimAccount.id,
+        cogs: after.stockCogsAccount.id,
+        adjustment: after.stockAdjustmentAccount.id,
+        priceDiff: after.stockPriceDiffAccount.id,
+        production: after.stockProductionAccount.id,
+    };
+}
+/**
+ * Values the validated transfers' goods and posts them (see the module's documentation). Incoming stock is valued
+ * at `incomingUnitCost` (the product's cost; a bridge may know better, a purchase order's price); outgoing stock at
+ * the average cost or, FIFO, from the oldest incoming layers still in stock.
+ */
+async function valueTransfers(pickings) {
+    const env = pickings.env;
+    const loaded = await pickings.load({
+        source: true,
+        destination: true,
+        company: true,
+        partner: true,
+        moves: { product: { category: true } },
+    });
+    for (const p of loaded) {
+        const incoming = p.source.usage !== 'internal' && p.destination.usage === 'internal';
+        const outgoing = p.source.usage === 'internal' && p.destination.usage !== 'internal';
+        if (!incoming && !outgoing)
+            continue;
+        const accounts = await stockAccountsOf(env, p.company.id);
+        if (accounts === null)
+            continue; // no chart yet: nothing to post to
+        const costs = incoming
+            ? await env
+                .model('stock.move')
+                .browse([...p.moves].map((m) => m.id))
+                .incomingUnitCost()
+            : new Map();
+        const lines = [];
+        const layers = [];
+        for (const m of p.moves) {
+            const quantity = m.doneQty ?? zero;
+            if (quantity.lte(0))
+                continue;
+            const product = m.product;
+            const fifo = (product.costMethod ?? product.category?.costMethod ?? 'average') === 'fifo';
+            let value = zero;
+            if (incoming) {
+                const given = costs.get(m.id);
+                const unit = given === undefined ? product.standardPrice : orm.toDecimal(given);
+                value = money(quantity.times(unit));
+                if (!fifo) {
+                    // The average weighs what was on hand before this receipt (the quants already hold it).
+                    const [now] = await env.model('product.product').browse([product.id]).load(['qtyOnHand']);
+                    const before = (now?.qtyOnHand ?? quantity).minus(quantity);
+                    const total = before.gt(0) ? before.plus(quantity) : quantity;
+                    const cost = before.gt(0)
+                        ? before.times(product.standardPrice).plus(value).div(total)
+                        : unit;
+                    await env
+                        .model('product.product')
+                        .browse([product.id])
+                        .write({ standardPrice: money(cost) });
+                }
+                layers.push({
+                    company: p.company.id,
+                    product: product.id,
+                    picking: p.id,
+                    move: m.id,
+                    quantity,
+                    unitCost: unit,
+                    value,
+                    remainingQty: quantity,
+                    remainingValue: value,
+                });
+            }
+            else {
+                let left = quantity;
+                if (fifo) {
+                    const open = await (await env.model('stock.valuation.layer').search({
+                        where: { company: p.company.id, product: product.id, remainingQty: { gt: '0' } },
+                        order: ['id asc'],
+                    })).load(['remainingQty', 'remainingValue']);
+                    for (const layer of open) {
+                        if (left.lte(0))
+                            break;
+                        const take = left.lt(layer.remainingQty) ? left : layer.remainingQty;
+                        const part = take.eq(layer.remainingQty)
+                            ? layer.remainingValue
+                            : money(layer.remainingValue.times(take).div(layer.remainingQty));
+                        value = value.plus(part);
+                        left = left.minus(take);
+                        await layer.write({
+                            remainingQty: layer.remainingQty.minus(take),
+                            remainingValue: layer.remainingValue.minus(part),
+                        });
+                    }
+                }
+                // Average cost, or FIFO beyond the layers (stock from before valuation): the product's cost.
+                if (left.gt(0))
+                    value = value.plus(money(left.times(product.standardPrice)));
+                layers.push({
+                    company: p.company.id,
+                    product: product.id,
+                    picking: p.id,
+                    move: m.id,
+                    quantity: quantity.negated(),
+                    unitCost: quantity.gt(0) ? money(value.div(quantity)) : zero,
+                    value: value.negated(),
+                    remainingQty: zero,
+                    remainingValue: zero,
+                });
+            }
+            if (value.lte(0))
+                continue;
+            // Production consumes into and produces out of Work in progress.
+            const against = p.kind === 'production'
+                ? accounts.production
+                : p.kind === 'adjustment'
+                    ? accounts.adjustment
+                    : incoming
+                        ? accounts.interim
+                        : (product.category?.stockCogsAccount?.id ?? accounts.cogs);
+            const stock = product.category?.stockValuationAccount?.id ?? accounts.valuation;
+            const label = `${p.name} ${product.name}`;
+            if (incoming) {
+                lines.push({ account: stock, debit: value, credit: zero, name: label });
+                lines.push({ account: against, debit: zero, credit: value, name: label });
+            }
+            else {
+                lines.push({ account: against, debit: value, credit: zero, name: label });
+                lines.push({ account: stock, debit: zero, credit: value, name: label });
+            }
+        }
+        let entry = null;
+        if (lines.length > 0) {
+            const [company] = await env.model('res.company').browse([p.company.id]).load({});
+            const made = await env.model('account.move').create([
+                {
+                    kind: 'entry',
+                    journal: accounts.journal,
+                    company: p.company.id,
+                    currency: company?.currency.id,
+                    date: env.today(),
+                    ref: p.origin ? `${p.name} (${p.origin})` : p.name,
+                    partner: p.partner?.id ?? null,
+                    lines: { create: lines },
+                },
+            ]);
+            await env.withGrants({ grants: ['account.post'], reason: `stock valuation ${p.name}` }, (e) => e.model('account.move').browse(made.ids).post());
+            entry = made.ids[0] ?? null;
+        }
+        if (layers.length > 0)
+            await env
+                .model('stock.valuation.layer')
+                .create(layers.map((l) => ({ ...l, accountMove: entry })));
+    }
+}
+export const MoveCost = extendModel('stock.move', {
+    methods: {
+        /**
+         * What each of these lines' stock costs when it comes in, by line, in the product's unit, as a decimal string:
+         * the product's cost. A bridge that knows better overrides it (a purchase order's price).
+         */
+        incomingUnitCost: method('stock.move', async function () {
+            const out = new Map();
+            for (const m of await this.load({ product: true }))
+                out.set(m.id, m.product.standardPrice.toString());
+            return out;
+        }),
+    },
+});
+export const PickingValued = extendModel('stock.picking', {
+    overrides: {
+        // A validated transfer's stock is valued and posted.
+        validated: async function (next) {
+            await next();
+            await valueTransfers(this);
+        },
+    },
+});
+export const stockAccountShutro = defineModule({
+    name: 'stock_account',
+    version: '0.1.0',
+    depends: [stockShutro, accountingShutro, productShutro],
+    groups: [
+        orm.defineGroup({
+            code: 'stock_account.user',
+            label: 'Stock valuation',
+            implies: ['stock.user'],
+        }),
+    ],
+    models: [StockValuationLayer],
+    extensions: [
+        CategoryValuation,
+        ProductValuation,
+        CompanyStockAccounts,
+        PickingLayers,
+        MoveCost,
+        PickingValued,
+    ],
+});

package/dist/storage/attachments.d.ts

@@ -27,7 +27,12 @@ export declare function saveAttachment(env: Env, storage: Storage, models: Reado
     readonly name: string;
     readonly mime?: string | undefined;
     readonly data: Uint8Array;
+    /** A variant (a thumbnail) of an attachment of the same record, `width` pixels wide. */
+    readonly variantOf?: number | undefined;
+    readonly width?: number | undefined;
 }): Promise<AttachmentInfo>;
+/** The variant of attachment `id` that is `width` pixels wide, if one was uploaded; else `id` itself. */
+export declare function variantOf(env: Env, id: number, width: number): Promise<number>;
 /** The attachments of a record `env` may read, newest first. */
 export declare function attachmentsOf(env: Env, models: ReadonlySet<string>, model: string, id: number): Promise<AttachmentInfo[]>;
 /** Attachments by id, each checked through its record. @throws 404 for any `env` may not see */

package/dist/storage/attachments.js

@@ -74,16 +74,27 @@ export async function saveAttachment(env, storage, models, input) {
             key,
             resModel: input.model,
             resId: input.id,
+            ...(input.variantOf === undefined
+                ? {}
+                : { variantOf: input.variantOf, width: input.width ?? null }),
         },
     ]);
     const [row] = (await created.load(KEYS)).read(['id', ...KEYS]);
     return info(row);
 }
+/** The variant of attachment `id` that is `width` pixels wide, if one was uploaded; else `id` itself. */
+export async function variantOf(env, id, width) {
+    const found = await ref(env, 'storage.attachment').search({
+        where: { variantOf: id, width },
+        limit: 1,
+    });
+    return found.ids[0] ?? id;
+}
 /** The attachments of a record `env` may read, newest first. */
 export async function attachmentsOf(env, models, model, id) {
     await checkRecord(env, models, model, id);
     const found = await ref(env, 'storage.attachment').search({
-        where: { resModel: model, resId: id },
+        where: { resModel: model, resId: id, variantOf: null },
         order: ['id desc'],
     });
     return found.length === 0 ? [] : (await found.load(KEYS)).read(['id', ...KEYS]).map(info);

package/dist/storage/models.js

@@ -23,6 +23,9 @@ const Attachment = defineModel('storage.attachment', {
         key: f.char({ required: true, index: 'unique' }),
         resModel: f.char({ required: true, label: 'Model' }),
         resId: f.integer({ required: true, label: 'Record' }),
+        /** A smaller rendering of another attachment (RFC 0022 §3.3: an image's thumbnail), `width` pixels wide. */
+        variantOf: f.many2one('storage.attachment', { ondelete: 'cascade', label: 'Variant of' }),
+        width: f.integer({ label: 'Width (px)' }),
     },
 });
 export const storageShutro = defineModule({

package/dist/storage/routes.js

@@ -7,7 +7,7 @@
  * - `DELETE /api/v1/attachments/:id`          by the uploader
  */
 import { HttpProblem, publicApiModels } from '../server/index.js';
-import { attachmentsOf, cleanName, disposition, INLINE_TYPES, openAttachment, removeAttachments, saveAttachment, } from './attachments.js';
+import { attachmentsOf, cleanName, disposition, INLINE_TYPES, openAttachment, removeAttachments, saveAttachment, variantOf, } from './attachments.js';
 import { StorageError, storageFromEnv } from './backends.js';
 /** Upload limit (`KOSH_ATTACHMENT_MAX_BYTES`, default 25 MB). */
 export function maxAttachmentBytes(env = process.env) {
@@ -86,6 +86,7 @@ export function registerAttachmentRoutes(context) {
                 name,
                 mime: request.headers['content-type'],
                 data: body,
+                ...variantHeaders(request.headers),
             }), { write: true })
                 .catch((e) => storageProblem(e, request));
             return reply.code(201).send(created);
@@ -102,8 +103,10 @@ export function registerAttachmentRoutes(context) {
         const id = positive(request.params.id, 'id');
         const inline = request.query.inline === 'true';
         const storage = storageOf(app);
+        // `?w=256`: the variant of that width when one was uploaded (an image's thumbnail), else the file itself.
+        const width = Number(request.query.w);
         const opened = await request
-            .env((env) => openAttachment(env, storage, models, id))
+            .env(async (env) => openAttachment(env, storage, models, Number.isInteger(width) && width > 0 ? await variantOf(env, id, width) : id))
             .catch((e) => storageProblem(e, request));
         const shown = inline && INLINE_TYPES.has(opened.info.mime);
         return reply
@@ -132,3 +135,11 @@ export async function deleteObjects(app, keys, request) {
             request.log.warn({ err, key }, 'attachment object left behind');
         });
 }
+/** `X-Variant-Of` and `X-Width` on an upload: the file is a thumbnail of that attachment, that wide. */
+function variantHeaders(headers) {
+    const of = Number(headers['x-variant-of']);
+    const width = Number(headers['x-width']);
+    if (!Number.isInteger(of) || of <= 0)
+        return {};
+    return { variantOf: of, ...(Number.isInteger(width) && width > 0 ? { width } : {}) };
+}

package/dist/todo/.kosh/bindings.d.ts

@@ -0,0 +1,22 @@
+export { defineModel, defineModule, extendModel, f, replace } from '../../server/orm.js';
+import { type DefinitionHelpers } from '../../server/orm.js';
+import type { DefaultLoaded, Env as CoreEnv, RecordSet as CoreRecordSet, Shutro as CoreShutro } from '../../server/orm.js';
+import type { SchemaView } from './schema.js';
+export type { SchemaView };
+/** Every model visible in this view. */
+export type ModelName = keyof SchemaView & string;
+/** `Env` typed to this view. */
+export type Env = CoreEnv<SchemaView>;
+/** `Shutro` typed to this view. */
+export type Shutro = CoreShutro<SchemaView>;
+/** A recordset of `M`, with the default loaded shape unless `L` is given. */
+export type Records<M extends ModelName, L = DefaultLoaded<SchemaView, M>> = CoreRecordSet<SchemaView, M, L>;
+export declare const compute: DefinitionHelpers<SchemaView>['compute'];
+export declare const check: DefinitionHelpers<SchemaView>['check'];
+export declare const onchange: DefinitionHelpers<SchemaView>['onchange'];
+export declare const records: DefinitionHelpers<SchemaView>['records'];
+export declare const method: DefinitionHelpers<SchemaView>['method'];
+/** Module data (RFC 0017): records, overrides of dependencies' records, and references, typed like creates. */
+export declare const record: DefinitionHelpers<SchemaView>['record'];
+export declare const override: DefinitionHelpers<SchemaView>['override'];
+export declare const ref: DefinitionHelpers<SchemaView>['ref'];

package/dist/todo/.kosh/bindings.js

@@ -0,0 +1,15 @@
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 552b3bb4df0f7a15
+// Bindings of module `todo`: import the definition API from here to get types scoped to what it can see.
+export { defineModel, defineModule, extendModel, f, replace } from '../../server/orm.js';
+import { definitions } from '../../server/orm.js';
+/** Definition callbacks typed against this module's view: no casts in computes, checks, onchange, methods. */
+const helpers = definitions();
+export const compute = helpers.compute;
+export const check = helpers.check;
+export const onchange = helpers.onchange;
+export const records = helpers.records;
+export const method = helpers.method;
+/** Module data (RFC 0017): records, overrides of dependencies' records, and references, typed like creates. */
+export const record = helpers.record;
+export const override = helpers.override;
+export const ref = helpers.ref;