shutro-erp 0.2.1 → 0.3.1

package/dist/product/taxes.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The tax engine (RFC 0016 §5.1), shared by Sales, Purchase and Accounting: the taxes of a line, in order. A tax is
+ * a percentage of its base or a fixed amount per unit; a tax that `affectsBase` adds its amount to the base of the
+ * taxes after it (supplementary duty before VAT); taxes `priceIncluded` are inside the unit price, which is then
+ * gross. A reverse-charge tax is computed like the others but not added to the total: the buyer pays it to the state,
+ * not to the supplier. Exact decimals throughout; rounding is the caller's (per document at posting).
+ */
+import { orm } from '../server/orm.js';
+type Decimal = ReturnType<typeof orm.toDecimal>;
+/** What the engine needs of a tax. */
+export interface TaxRule {
+    readonly id: number;
+    readonly sequence: number;
+    readonly amountType: 'percent' | 'fixed';
+    /** 0.15 for 15 % (percent taxes). */
+    readonly rate: Decimal;
+    /** Per unit, in the document currency (fixed taxes). */
+    readonly fixedAmount: Decimal;
+    readonly affectsBase: boolean;
+    readonly priceIncluded: boolean;
+    /** Paid by the buyer to the state (reverse charge): not in the line's total. */
+    readonly reverseCharge: boolean;
+}
+export interface TaxLine {
+    readonly tax: number;
+    readonly reverseCharge: boolean;
+    /** What the tax was computed on (the untaxed amount, plus the taxes before it that affect the base). */
+    readonly base: Decimal;
+    readonly amount: Decimal;
+}
+export interface TaxResult {
+    /** The amount without taxes. */
+    readonly untaxed: Decimal;
+    /** Each tax, in order (reverse-charge ones too). */
+    readonly taxes: readonly TaxLine[];
+    /** The taxes the supplier charges (reverse-charge ones are not). */
+    readonly taxTotal: Decimal;
+    readonly total: Decimal;
+}
+/** The rules in the order they apply: by sequence, then as given. */
+export declare function ordered(rules: readonly TaxRule[]): TaxRule[];
+/**
+ * The taxes of a line whose price amounts to `amount` (quantity × unit price, after discount) for `quantity` units.
+ * With taxes included in the price, `amount` is gross: the untaxed amount is what, taxed by the included taxes,
+ * gives it back.
+ */
+export declare function computeTaxes(amount: Decimal, quantity: Decimal, rules: readonly TaxRule[]): TaxResult;
+/** A tax record (as loaded) as the engine's rule. */
+export declare function taxRule(tax: {
+    readonly id: number;
+    readonly sequence?: number | null;
+    readonly amountType?: string | null;
+    readonly rate?: Decimal | null;
+    readonly fixedAmount?: Decimal | null;
+    readonly affectsBase?: boolean | null;
+    readonly priceIncluded?: boolean | null;
+    readonly reverseCharge?: boolean | null;
+}): TaxRule;
+export {};

package/dist/product/taxes.js

@@ -0,0 +1,61 @@
+/**
+ * The tax engine (RFC 0016 §5.1), shared by Sales, Purchase and Accounting: the taxes of a line, in order. A tax is
+ * a percentage of its base or a fixed amount per unit; a tax that `affectsBase` adds its amount to the base of the
+ * taxes after it (supplementary duty before VAT); taxes `priceIncluded` are inside the unit price, which is then
+ * gross. A reverse-charge tax is computed like the others but not added to the total: the buyer pays it to the state,
+ * not to the supplier. Exact decimals throughout; rounding is the caller's (per document at posting).
+ */
+import { orm } from '../server/orm.js';
+const ZERO = orm.toDecimal(0);
+/** The rules in the order they apply: by sequence, then as given. */
+export function ordered(rules) {
+    return rules
+        .map((rule, index) => ({ rule, index }))
+        .sort((a, b) => a.rule.sequence - b.rule.sequence || a.index - b.index)
+        .map(({ rule }) => rule);
+}
+/** The taxes applied in order on `untaxed`. */
+function apply(untaxed, quantity, rules) {
+    let base = untaxed;
+    const out = [];
+    for (const rule of rules) {
+        const amount = rule.amountType === 'fixed' ? quantity.times(rule.fixedAmount) : base.times(rule.rate);
+        out.push({ tax: rule.id, reverseCharge: rule.reverseCharge, base, amount });
+        if (rule.affectsBase)
+            base = base.plus(amount);
+    }
+    return out;
+}
+/**
+ * The taxes of a line whose price amounts to `amount` (quantity × unit price, after discount) for `quantity` units.
+ * With taxes included in the price, `amount` is gross: the untaxed amount is what, taxed by the included taxes,
+ * gives it back.
+ */
+export function computeTaxes(amount, quantity, rules) {
+    const all = ordered(rules);
+    const included = all.filter((r) => r.priceIncluded);
+    let untaxed = amount;
+    if (included.length > 0) {
+        // The included taxes are linear in their base: total(b) = c + k·b. Solve total(b) = amount.
+        const total = (b) => apply(b, quantity, included).reduce((s, t) => s.plus(t.amount), b);
+        const c = total(ZERO);
+        const k = total(orm.toDecimal(1)).minus(c);
+        untaxed = k.isZero() ? amount : amount.minus(c).div(k);
+    }
+    const taxes = apply(untaxed, quantity, all);
+    const taxTotal = taxes.reduce((s, t) => (t.reverseCharge ? s : s.plus(t.amount)), ZERO);
+    return { untaxed, taxes, taxTotal, total: untaxed.plus(taxTotal) };
+}
+/** A tax record (as loaded) as the engine's rule. */
+export function taxRule(tax) {
+    return {
+        id: tax.id,
+        sequence: tax.sequence ?? 10,
+        amountType: tax.amountType === 'fixed' ? 'fixed' : 'percent',
+        rate: tax.rate ?? ZERO,
+        fixedAmount: tax.fixedAmount ?? ZERO,
+        affectsBase: tax.affectsBase === true,
+        priceIncluded: tax.priceIncluded === true,
+        reverseCharge: tax.reverseCharge === true,
+    };
+}

package/dist/project/.kosh/bindings.js

@@ -1,4 +1,4 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 88400d6014f58a65
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 8538c294f98318cd
 // Bindings of module `project`: 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';

package/dist/project/.kosh/schema.d.ts

@@ -1,10 +1,11 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 88400d6014f58a65
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 8538c294f98318cd
 // Schema view of module `project` (RFC 0002 §7.7): the models it owns or depends on, with the extensions it can see.
 import type { F } from '../../server/orm.js';
 
 /** Model name → model type (RFC 0002 §7.7). */
 export interface SchemaView {
   readonly 'audit.event': AuditEvent;
+  readonly 'auth.api_key': AuthApiKey;
   readonly 'auth.credential': AuthCredential;
   readonly 'auth.session': AuthSession;
   readonly 'auth.user_grant': AuthUserGrant;
@@ -54,6 +55,34 @@ export interface AuditEvent {
 export interface AuditEventMethods extends F.Methods<typeof import('../../server/index.js').baseShutro, 'audit.event'> {
 }
 
+/** `auth.api_key` (owner: base). */
+export interface AuthApiKey {
+  readonly name: 'auth.api_key';
+  readonly fields: {
+    readonly id: F.Id<'auth.api_key'>;
+    readonly createdAt: F.Datetime<{ readonly required: true; readonly readonly: true }>;
+    readonly updatedAt: F.Datetime<{ readonly required: true; readonly readonly: true }>;
+    readonly createdBy: F.Many2one<'res.users', { readonly readonly: true }>;
+    readonly updatedBy: F.Many2one<'res.users', { readonly readonly: true }>;
+    readonly displayName: F.Char<{ readonly required: true; readonly readonly: true; readonly compute: true }>;
+    readonly name: F.Char<{ readonly required: true }>;
+    readonly user: F.Many2one<'res.users', { readonly required: true }>;
+    readonly tokenHash: F.Char<{ readonly required: true }>;
+    readonly prefix: F.Char<{ readonly required: true }>;
+    readonly scopes: F.Text<{ readonly required: true }>;
+    readonly expiresAt: F.Datetime<{ readonly required: true }>;
+    readonly lastUsedAt: F.Datetime;
+    readonly lastUsedIp: F.Char;
+    readonly revoked: F.Bool<{ readonly required: true; readonly default: true }>;
+    readonly issuedBy: F.Many2one<'res.users'>;
+  };
+  readonly methods: AuthApiKeyMethods;
+}
+
+/** Methods of `auth.api_key`: declared ones and transitions. */
+export interface AuthApiKeyMethods extends F.Methods<typeof import('../../server/index.js').baseShutro, 'auth.api_key'> {
+}
+
 /** `auth.credential` (owner: base). */
 export interface AuthCredential {
   readonly name: 'auth.credential';
@@ -473,6 +502,7 @@ export interface ResCompany {
     readonly displayName: F.Char<{ readonly required: true; readonly readonly: true; readonly compute: true }>;
     readonly name: F.Char<{ readonly required: true }>;
     readonly currency: F.Many2one<'res.currency', { readonly required: true }>;
+    readonly numberGrouping: F.Selection<'international' | 'lakh', { readonly required: true; readonly default: true }>;
   };
   readonly methods: ResCompanyMethods;
 }
@@ -526,6 +556,7 @@ export interface ResPartner {
     readonly city: F.Char;
     readonly zip: F.Char;
     readonly country: F.Char;
+    readonly state: F.Char;
     readonly taxId: F.Char;
     readonly isCustomer: F.Bool<{ readonly required: true; readonly default: true }>;
     readonly isVendor: F.Bool<{ readonly required: true; readonly default: true }>;
@@ -558,6 +589,7 @@ export interface ResUsers {
     readonly companies: F.Many2many<'res.company', { readonly required: true }>;
     readonly lang: F.Char<{ readonly default: true }>;
     readonly tz: F.Char<{ readonly default: true }>;
+    readonly isService: F.Bool<{ readonly required: true; readonly default: true }>;
   };
   readonly methods: ResUsersMethods;
 }

package/dist/project/module.d.ts

@@ -1845,6 +1845,16 @@ export declare const projectShutro: import("../server/orm.js").Module<readonly [
         readonly hasDefault: false;
         readonly readonly: false;
     }, string>;
+    readonly state: import("../server/orm.js").CharField<{
+        readonly required: false;
+        readonly computed: false;
+        readonly inverse: false;
+        readonly sequence: false;
+        readonly computeName: undefined;
+        readonly store: true;
+        readonly hasDefault: false;
+        readonly readonly: false;
+    }, string>;
     readonly taxId: import("../server/orm.js").CharField<{
         readonly required: false;
         readonly computed: false;
@@ -2016,6 +2026,16 @@ export declare const projectShutro: import("../server/orm.js").Module<readonly [
         readonly hasDefault: false;
         readonly readonly: false;
     }, string>;
+    readonly state: import("../server/orm.js").CharField<{
+        readonly required: false;
+        readonly computed: false;
+        readonly inverse: false;
+        readonly sequence: false;
+        readonly computeName: undefined;
+        readonly store: true;
+        readonly hasDefault: false;
+        readonly readonly: false;
+    }, string>;
     readonly taxId: import("../server/orm.js").CharField<{
         readonly required: false;
         readonly computed: false;

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

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