shutro-erp 0.3.3 → 0.3.5

package/dist/purchase_stock_account/module.js

@@ -0,0 +1,162 @@
+/**
+ * The data layer of the Purchase ↔ Stockroom ↔ Accounting bridge (RFC 0021 step 3, part 2): what is received on a
+ * purchase order is valued at the order's price (converted to the product's unit and to the company's currency), a
+ * vendor bill's goods are posted to Goods received not billed — where they meet the receipt — and what the bill
+ * says differently from the receipt's value goes to Price differences, so the interim account is cleared.
+ */
+import { accountingShutro } from '../accounting/index.js';
+import { purchaseShutro } from '../purchase/index.js';
+import { purchaseAccountShutro } from '../purchase_account/index.js';
+import { purchaseStockShutro } from '../purchase_stock/index.js';
+import { orm } from '../server/orm.js';
+import { stockShutro } from '../stock/index.js';
+import { stockAccountShutro, stockAccountsOf } from '../stock_account/index.js';
+import { defineModule, extendModel } from './.kosh/bindings.js';
+const zero = orm.toDecimal(0);
+const money = (d) => d.toDecimalPlaces(2);
+export const MoveOrderCost = extendModel('stock.move', {
+    overrides: {
+        // A line received on a purchase order costs the order's price, per product unit, in the company's currency.
+        incomingUnitCost: async function (next) {
+            const out = await next();
+            const moves = this;
+            const loaded = await moves.load({
+                purchaseLine: { order: { currency: true, company: { currency: true } } },
+            });
+            for (const m of loaded) {
+                const line = m.purchaseLine;
+                if (line === null || m.productQty === null || m.productQty.lte(0))
+                    continue;
+                // The order's price is per the line's unit; the move counts the same units.
+                let unit = line.priceUnit.times(m.quantity).div(m.productQty);
+                const order = line.order;
+                if (order.currency.id !== order.company.currency.id) {
+                    try {
+                        const rates = await moves.env.fx.prepare({
+                            date: moves.env.today(),
+                            currencies: [order.currency.id],
+                            company: order.company.id,
+                        });
+                        unit = unit.div(rates.rate(order.currency.id).rate);
+                    }
+                    catch {
+                        continue; // no rate for the day: the product's cost (left as it is)
+                    }
+                }
+                out.set(m.id, unit.toDecimalPlaces(4).toString());
+            }
+            return out;
+        },
+    },
+});
+const BILLS = new Set(['in_invoice', 'in_refund', 'in_debit']);
+export const BillGoods = extendModel('account.move', {
+    overrides: {
+        // A vendor bill's goods meet their receipts in Goods received not billed.
+        productLineAccounts: async function (next) {
+            const out = await next();
+            const bills = this;
+            for (const m of await bills.load({ lines: { product: true } })) {
+                if (!BILLS.has(m.kind))
+                    continue;
+                const accounts = await stockAccountsOf(bills.env, m.company.id);
+                if (accounts === null)
+                    continue;
+                for (const l of m.lines)
+                    if (l.lineKind === 'product' && l.product?.kind === 'goods' && !out.has(l.id))
+                        out.set(l.id, accounts.interim);
+            }
+            return out;
+        },
+        // What a bill says differently from the value of the goods received on its order: to Price differences.
+        posted: async function (next) {
+            await next();
+            await postPriceDifferences(this);
+        },
+    },
+});
+/**
+ * For each goods line of posted vendor bills from a purchase order: the value received for that product on the
+ * order (its receipts' valuation layers), per unit received, times the quantity billed, against what the bill
+ * posted. The difference is posted in the Stock journal between Price differences and Goods received not billed.
+ */
+async function postPriceDifferences(bills) {
+    const env = bills.env;
+    for (const m of await bills.load({ lines: { product: true }, company: true })) {
+        if (m.kind !== 'in_invoice' || m.purchaseOrder === null)
+            continue;
+        const accounts = await stockAccountsOf(env, m.company.id);
+        if (accounts === null)
+            continue;
+        const lines = [];
+        for (const l of m.lines) {
+            if (l.lineKind !== 'product' || l.product === null || l.product.kind !== 'goods')
+                continue;
+            // The receipts of the order for this product: what was received (in the order's units) and its value.
+            const receipts = await env
+                .model('stock.picking')
+                .search({ where: { purchaseOrder: m.purchaseOrder.id, state: 'done' } });
+            if (receipts.length === 0)
+                continue;
+            const moves = await (await env
+                .model('stock.move')
+                .search({ where: { picking: { in: [...receipts.ids] }, product: l.product.id } })).load(['quantityDone', 'quantity']);
+            const received = [...moves].reduce((s, mv) => s.plus(mv.quantityDone ?? mv.quantity), zero);
+            if (received.lte(0))
+                continue;
+            const layers = await (await env.model('stock.valuation.layer').search({
+                where: { picking: { in: [...receipts.ids] }, product: l.product.id },
+            })).load(['value']);
+            const value = [...layers].reduce((s, x) => s.plus(x.value), zero);
+            const quantity = l.quantity ?? zero;
+            const expected = money(value.times(quantity).div(received));
+            const billed = money((l.debit?.amount ?? zero).minus(l.credit?.amount ?? zero));
+            const difference = billed.minus(expected);
+            if (difference.isZero())
+                continue;
+            const name = `${m.name} ${l.product.name}: price difference`;
+            const amount = difference.abs();
+            const [over, under] = difference.gt(0)
+                ? [accounts.priceDiff, accounts.interim]
+                : [accounts.interim, accounts.priceDiff];
+            lines.push({ account: over, debit: amount, credit: zero, name });
+            lines.push({ account: under, debit: zero, credit: amount, name });
+        }
+        if (lines.length === 0)
+            continue;
+        const made = await env.model('account.move').create([
+            {
+                kind: 'entry',
+                journal: accounts.journal,
+                company: m.company.id,
+                currency: m.company.currency.id,
+                date: m.date,
+                ref: `${m.name} price differences`,
+                partner: m.partner?.id ?? null,
+                lines: { create: lines },
+            },
+        ]);
+        await env.withGrants({ grants: ['account.post'], reason: `price differences of ${m.name}` }, (e) => e.model('account.move').browse(made.ids).post());
+    }
+}
+export const purchaseStockAccountShutro = defineModule({
+    name: 'purchase_stock_account',
+    version: '0.1.0',
+    depends: [
+        purchaseShutro,
+        stockShutro,
+        accountingShutro,
+        purchaseStockShutro,
+        stockAccountShutro,
+        purchaseAccountShutro,
+    ],
+    groups: [
+        orm.defineGroup({
+            code: 'purchase_stock_account.user',
+            label: 'Purchases valued in stock',
+            implies: ['purchase.user'],
+        }),
+    ],
+    models: [],
+    extensions: [MoveOrderCost, BillGoods],
+});

package/dist/recruitment/.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/recruitment/.kosh/bindings.js

@@ -0,0 +1,15 @@
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 3b224d5b3282989d
+// Bindings of module `recruitment`: 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;