shutro-erp 0.3.1 → 0.3.3

package/dist/permissions/roles.js

@@ -0,0 +1,236 @@
+import { HttpProblem } from '../server/index.js';
+import { requireAdministrator } from './admin.js';
+const PERMS = ['read', 'write', 'create', 'unlink', 'export', 'import'];
+const find = async (env, model, where, keys) => {
+    const set = (await env.model(model).search({ where, order: ['id asc'] }));
+    return set.length === 0 ? [] : (await set.load(keys)).read(['id', ...keys]);
+};
+const bad = (detail) => new HttpProblem(400, 'invalid-body', 'Invalid request', detail);
+export function registerRoleRoutes(context) {
+    const { app, registry } = context;
+    const reg = registry.registry;
+    const loaded = registry.loaded;
+    const modules = loaded.modules;
+    const hidden = new Set(modules.flatMap((m) => m.privateModels ?? []));
+    const appOf = new Map(modules.map((m) => [m.name, m.app?.label ?? null]));
+    /** Every group a set of roles amounts to: declared groups' closure, runtime roles followed through. */
+    const closureOf = (codes, runtime) => {
+        const roles = new Map(runtime.roles.map((r) => [r.code, r]));
+        const seen = new Set();
+        const queue = [...codes];
+        while (queue.length > 0) {
+            const code = queue.pop();
+            if (seen.has(code))
+                continue;
+            seen.add(code);
+            for (const next of roles.get(code)?.implies ?? [])
+                queue.push(next);
+        }
+        return new Set([
+            ...seen,
+            ...reg.security.closure([...seen].filter((c) => reg.security.groups.has(c))),
+        ]);
+    };
+    /** What a set of groups grants: per model the permissions, and the feature permissions. */
+    const grants = (groups, runtime, except) => {
+        const models = new Map();
+        for (const [name, model] of reg.models) {
+            const access = (model.model.access ?? {});
+            const perms = new Set();
+            for (const g of groups)
+                for (const p of access[g] ?? [])
+                    perms.add(p);
+            if (perms.size > 0)
+                models.set(name, perms);
+        }
+        for (const a of runtime.access)
+            if (groups.has(a.role) && a.role !== except)
+                for (const p of a.perms) {
+                    const set = models.get(a.model) ?? new Set();
+                    set.add(p);
+                    models.set(a.model, set);
+                }
+        const permissions = new Set();
+        for (const p of reg.security.permissions.values())
+            if (p.groups.some((g) => groups.has(g)))
+                permissions.add(p.code);
+        for (const g of runtime.permissions)
+            if (groups.has(g.role) && g.role !== except)
+                permissions.add(g.permission);
+        const levels = new Set([...loaded.accessLevels.entries()]
+            .filter(([, level]) => level.groups.length > 0 && level.groups.every((g) => groups.has(g)))
+            .map(([code]) => code));
+        return { models, permissions, levels };
+    };
+    const levelLabel = (code) => {
+        const level = loaded.accessLevels.get(code);
+        return level === undefined
+            ? code
+            : `${appOf.get(level.module) ?? level.module} · ${level.label}`;
+    };
+    const permissionLabel = (code) => reg.security.permissions.get(code)?.label ?? code;
+    /** The role, whether declared in code or made at runtime. */
+    const roleOf = (code, runtime) => {
+        const declared = reg.security.groups.get(code);
+        if (declared !== undefined)
+            return {
+                code,
+                label: declared.label ?? code,
+                implies: [...(declared.implies ?? [])],
+                builtIn: true,
+            };
+        const made = runtime.roles.find((r) => r.code === code);
+        if (made === undefined)
+            throw new HttpProblem(404, 'missing-record', 'Not found', `There is no role '${code}'.`);
+        return { code, label: made.label, implies: [...made.implies], builtIn: false };
+    };
+    const holdersOf = async (env, code) => env.asSuperuser({ reason: 'role holders' }, async (su) => {
+        const assigned = await find(su, 'auth.user_group', { group: code }, ['user']);
+        const ids = [...new Set(assigned.map((a) => a['user']))];
+        if (ids.length === 0)
+            return [];
+        return (await find(su, 'res.users', { id: { in: ids } }, ['name', 'login'])).map((u) => ({
+            id: u['id'],
+            name: String(u['name']),
+            login: String(u['login']),
+        }));
+    });
+    const codeParam = (request) => String(request.params['code'] ?? '');
+    app.get('/api/v1/admin/roles/:code', async (request) => {
+        const code = codeParam(request);
+        return request.env(async (env) => {
+            requireAdministrator(env);
+            const runtime = await env.securityAdmin.describe();
+            const role = roleOf(code, runtime);
+            const closure = closureOf([code], runtime);
+            // Locked: what code and the included roles give; own: this role's runtime grants.
+            const locked = grants(closure, runtime, code);
+            const own = new Map(runtime.access.filter((a) => a.role === code).map((a) => [a.model, [...a.perms]]));
+            const ownPermissions = runtime.permissions
+                .filter((p) => p.role === code)
+                .map((p) => p.permission);
+            return {
+                ...role,
+                administrator: env.access.administratorGroups().has(code),
+                accessLevels: [...grants(closureOf(role.implies, runtime), runtime).levels],
+                holders: await holdersOf(env, code),
+                models: [...reg.models]
+                    .filter(([name]) => !hidden.has(name) && !name.startsWith('shutro.'))
+                    .map(([name, model]) => ({
+                    name,
+                    label: model.model.label ?? name,
+                    app: appOf.get(model.module) ?? null,
+                    locked: [...(locked.models.get(name) ?? [])],
+                    own: own.get(name) ?? [],
+                }))
+                    // Apps first (by name), technical models last.
+                    .sort((a, b) => Number(a.app === null) - Number(b.app === null) ||
+                    (a.app ?? '').localeCompare(b.app ?? '') ||
+                    a.label.localeCompare(b.label)),
+                permissions: [...reg.security.permissions.values()].map((p) => ({
+                    code: p.code,
+                    label: p.label ?? p.code,
+                    locked: locked.permissions.has(p.code),
+                    own: ownPermissions.includes(p.code),
+                })),
+                rules: runtime.rules.filter((r) => r.role === code),
+                fields: runtime.fields.filter((f) => f.read.includes(code) || f.write.includes(code)),
+            };
+        }, { write: true });
+    });
+    app.post('/api/v1/admin/roles/:code/preview', async (request) => {
+        const code = codeParam(request);
+        const body = (request.body ?? {});
+        const list = (v, what) => {
+            if (v === undefined)
+                return undefined;
+            if (!Array.isArray(v) || v.some((x) => typeof x !== 'string'))
+                throw bad(`${what} is a list of codes.`);
+            return v;
+        };
+        const levels = list(body['accessLevels'], 'accessLevels');
+        const implies = list(body['implies'], 'implies');
+        const permissions = list(body['permissions'], 'permissions');
+        const access = body['access'];
+        if (access !== undefined &&
+            (typeof access !== 'object' || access === null || Array.isArray(access)))
+            throw bad('access is { model: [permissions] }.');
+        return request.env(async (env) => {
+            requireAdministrator(env);
+            const runtime = await env.securityAdmin.describe();
+            const role = roleOf(code, runtime);
+            // The role's proposed state, as a runtime overlay of itself.
+            const levelGroups = (levels ?? []).flatMap((l) => {
+                const level = loaded.accessLevels.get(l);
+                if (level === undefined)
+                    throw bad(`'${l}' is not an access level.`);
+                return [...level.groups];
+            });
+            const proposedImplies = levels === undefined && implies === undefined
+                ? role.implies
+                : [...new Set([...levelGroups, ...(implies ?? [])])];
+            const ownAccess = (access ??
+                Object.fromEntries(runtime.access.filter((a) => a.role === code).map((a) => [a.model, a.perms])));
+            const proposed = {
+                ...runtime,
+                roles: role.builtIn
+                    ? runtime.roles
+                    : runtime.roles.map((r) => (r.code === code ? { ...r, implies: proposedImplies } : r)),
+                access: [
+                    ...runtime.access.filter((a) => a.role !== code),
+                    ...Object.entries(ownAccess).map(([model, perms]) => ({
+                        role: code,
+                        model,
+                        perms: perms,
+                    })),
+                ],
+                permissions: permissions === undefined
+                    ? runtime.permissions
+                    : [
+                        ...runtime.permissions.filter((p) => p.role !== code),
+                        ...permissions.map((permission) => ({ role: code, permission })),
+                    ],
+            };
+            const before = grants(closureOf([code], runtime), runtime);
+            const after = grants(closureOf([code], proposed), proposed);
+            const holders = await holdersOf(env, code);
+            const others = await env.asSuperuser({ reason: 'role preview' }, (su) => find(su, 'auth.user_group', { user: { in: holders.map((h) => h.id) } }, [
+                'user',
+                'group',
+            ]));
+            const people = holders
+                .map((h) => {
+                const elsewhere = grants(closureOf(others
+                    .filter((o) => o['user'] === h.id && o['group'] !== code)
+                    .map((o) => String(o['group'])), runtime), runtime);
+                const diff = (from, to, kept) => [...to].filter((x) => !from.has(x) && !kept.has(x));
+                return {
+                    id: h.id,
+                    name: h.name,
+                    gains: [
+                        ...diff(before.levels, after.levels, elsewhere.levels).map(levelLabel),
+                        ...diff(before.permissions, after.permissions, elsewhere.permissions).map(permissionLabel),
+                    ],
+                    losses: [
+                        ...diff(after.levels, before.levels, elsewhere.levels).map(levelLabel),
+                        ...diff(after.permissions, before.permissions, elsewhere.permissions).map(permissionLabel),
+                    ],
+                };
+            })
+                .filter((p) => p.gains.length > 0 || p.losses.length > 0);
+            const models = [...new Set([...before.models.keys(), ...after.models.keys()])]
+                .map((name) => {
+                const was = before.models.get(name) ?? new Set();
+                const will = after.models.get(name) ?? new Set();
+                return {
+                    model: name,
+                    label: reg.models.get(name)?.model?.label ?? name,
+                    added: PERMS.filter((p) => will.has(p) && !was.has(p)),
+                    removed: PERMS.filter((p) => was.has(p) && !will.has(p)),
+                };
+            })
+                .filter((m) => m.added.length > 0 || m.removed.length > 0);
+            return { holders: holders.length, people, models };
+        }, { write: true });
+    });
+}

package/dist/portal/.kosh/bindings.js

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

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

@@ -1,4 +1,4 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: bae647ca883975a1
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: f41721dc1c51ba8a
 // Schema view of module `portal` (RFC 0002 §7.7): the models it owns or depends on, with the extensions it can see.
 import type { F } from '../../server/orm.js';
 
@@ -7,6 +7,7 @@ export interface SchemaView {
   readonly 'audit.event': AuditEvent;
   readonly 'auth.api_key': AuthApiKey;
   readonly 'auth.credential': AuthCredential;
+  readonly 'auth.policy': AuthPolicy;
   readonly 'auth.session': AuthSession;
   readonly 'auth.user_grant': AuthUserGrant;
   readonly 'auth.user_group': AuthUserGroup;
@@ -97,6 +98,26 @@ export interface AuthCredential {
 export interface AuthCredentialMethods extends F.Methods<typeof import('../../server/index.js').baseShutro, 'auth.credential'> {
 }
 
+/** `auth.policy` (owner: base). */
+export interface AuthPolicy {
+  readonly name: 'auth.policy';
+  readonly fields: {
+    readonly id: F.Id<'auth.policy'>;
+    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 twoFactor: F.Selection<'administrators' | 'everyone', { readonly required: true; readonly default: true }>;
+    readonly sessionDays: F.Integer;
+  };
+  readonly methods: AuthPolicyMethods;
+}
+
+/** Methods of `auth.policy`: declared ones and transitions. */
+export interface AuthPolicyMethods extends F.Methods<typeof import('../../server/index.js').baseShutro, 'auth.policy'> {
+}
+
 /** `auth.session` (owner: base). */
 export interface AuthSession {
   readonly name: 'auth.session';
@@ -278,6 +299,13 @@ export interface ResCompany {
     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 accentColor: F.Char;
+    readonly street: F.Char;
+    readonly city: F.Char;
+    readonly zip: F.Char;
+    readonly email: F.Char;
+    readonly phone: F.Char;
+    readonly website: F.Char;
   };
   readonly methods: ResCompanyMethods;
 }

package/dist/portal/routes-documents.js

@@ -207,6 +207,11 @@ export function registerPortalDocumentRoutes(context) {
                     ? {}
                     : { lineFields: meta(d.lineModel, d.spec.lines.fields), lines }),
                 actions: await available(su, d, id),
+                payable: d.spec.payment !== undefined &&
+                    (await ref(su, d.model.name).search({
+                        where: { and: [{ id }, d.spec.payment.when] },
+                        limit: 1,
+                    })).length > 0,
                 pdf: d.spec.pdf !== undefined,
                 thread: d.spec.thread === true,
             };

package/dist/product/.kosh/bindings.js

@@ -1,4 +1,4 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 86d7229d7b275957
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 2544d3673d343d73
 // Bindings of module `product`: 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/product/.kosh/schema.d.ts

@@ -1,4 +1,4 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 86d7229d7b275957
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 2544d3673d343d73
 // Schema view of module `product` (RFC 0002 §7.7): the models it owns or depends on, with the extensions it can see.
 import type { F } from '../../server/orm.js';
 
@@ -8,6 +8,7 @@ export interface SchemaView {
   readonly 'audit.event': AuditEvent;
   readonly 'auth.api_key': AuthApiKey;
   readonly 'auth.credential': AuthCredential;
+  readonly 'auth.policy': AuthPolicy;
   readonly 'auth.session': AuthSession;
   readonly 'auth.user_grant': AuthUserGrant;
   readonly 'auth.user_group': AuthUserGroup;
@@ -125,6 +126,26 @@ export interface AuthCredential {
 export interface AuthCredentialMethods extends F.Methods<typeof import('../../server/index.js').baseShutro, 'auth.credential'> {
 }
 
+/** `auth.policy` (owner: base). */
+export interface AuthPolicy {
+  readonly name: 'auth.policy';
+  readonly fields: {
+    readonly id: F.Id<'auth.policy'>;
+    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 twoFactor: F.Selection<'administrators' | 'everyone', { readonly required: true; readonly default: true }>;
+    readonly sessionDays: F.Integer;
+  };
+  readonly methods: AuthPolicyMethods;
+}
+
+/** Methods of `auth.policy`: declared ones and transitions. */
+export interface AuthPolicyMethods extends F.Methods<typeof import('../../server/index.js').baseShutro, 'auth.policy'> {
+}
+
 /** `auth.session` (owner: base). */
 export interface AuthSession {
   readonly name: 'auth.session';
@@ -288,6 +309,13 @@ export interface ResCompany {
     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 accentColor: F.Char;
+    readonly street: F.Char;
+    readonly city: F.Char;
+    readonly zip: F.Char;
+    readonly email: F.Char;
+    readonly phone: F.Char;
+    readonly website: F.Char;
   };
   readonly methods: ResCompanyMethods;
 }

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

@@ -1,4 +1,4 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 8538c294f98318cd
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 25d6271e4bd2aa40
 // 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,4 +1,4 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 8538c294f98318cd
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 25d6271e4bd2aa40
 // 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';
 
@@ -7,6 +7,7 @@ export interface SchemaView {
   readonly 'audit.event': AuditEvent;
   readonly 'auth.api_key': AuthApiKey;
   readonly 'auth.credential': AuthCredential;
+  readonly 'auth.policy': AuthPolicy;
   readonly 'auth.session': AuthSession;
   readonly 'auth.user_grant': AuthUserGrant;
   readonly 'auth.user_group': AuthUserGroup;
@@ -106,6 +107,26 @@ export interface AuthCredential {
 export interface AuthCredentialMethods extends F.Methods<typeof import('../../server/index.js').baseShutro, 'auth.credential'> {
 }
 
+/** `auth.policy` (owner: base). */
+export interface AuthPolicy {
+  readonly name: 'auth.policy';
+  readonly fields: {
+    readonly id: F.Id<'auth.policy'>;
+    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 twoFactor: F.Selection<'administrators' | 'everyone', { readonly required: true; readonly default: true }>;
+    readonly sessionDays: F.Integer;
+  };
+  readonly methods: AuthPolicyMethods;
+}
+
+/** Methods of `auth.policy`: declared ones and transitions. */
+export interface AuthPolicyMethods extends F.Methods<typeof import('../../server/index.js').baseShutro, 'auth.policy'> {
+}
+
 /** `auth.session` (owner: base). */
 export interface AuthSession {
   readonly name: 'auth.session';
@@ -503,6 +524,13 @@ export interface ResCompany {
     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 accentColor: F.Char;
+    readonly street: F.Char;
+    readonly city: F.Char;
+    readonly zip: F.Char;
+    readonly email: F.Char;
+    readonly phone: F.Char;
+    readonly website: F.Char;
   };
   readonly methods: ResCompanyMethods;
 }

package/dist/project_portal/.kosh/bindings.js

@@ -1,4 +1,4 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 0440c5ae846a11ac
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 99c699d27d0e98db
 // 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';

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

@@ -1,4 +1,4 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 0440c5ae846a11ac
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 99c699d27d0e98db
 // Schema view of module `project_portal` (RFC 0002 §7.7): the models it owns or depends on, with the extensions it can see.
 import type { F } from '../../server/orm.js';
 
@@ -7,6 +7,7 @@ export interface SchemaView {
   readonly 'audit.event': AuditEvent;
   readonly 'auth.api_key': AuthApiKey;
   readonly 'auth.credential': AuthCredential;
+  readonly 'auth.policy': AuthPolicy;
   readonly 'auth.session': AuthSession;
   readonly 'auth.user_grant': AuthUserGrant;
   readonly 'auth.user_group': AuthUserGroup;
@@ -109,6 +110,26 @@ export interface AuthCredential {
 export interface AuthCredentialMethods extends F.Methods<typeof import('../../server/index.js').baseShutro, 'auth.credential'> {
 }
 
+/** `auth.policy` (owner: base). */
+export interface AuthPolicy {
+  readonly name: 'auth.policy';
+  readonly fields: {
+    readonly id: F.Id<'auth.policy'>;
+    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 twoFactor: F.Selection<'administrators' | 'everyone', { readonly required: true; readonly default: true }>;
+    readonly sessionDays: F.Integer;
+  };
+  readonly methods: AuthPolicyMethods;
+}
+
+/** Methods of `auth.policy`: declared ones and transitions. */
+export interface AuthPolicyMethods extends F.Methods<typeof import('../../server/index.js').baseShutro, 'auth.policy'> {
+}
+
 /** `auth.session` (owner: base). */
 export interface AuthSession {
   readonly name: 'auth.session';
@@ -578,6 +599,13 @@ export interface ResCompany {
     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 accentColor: F.Char;
+    readonly street: F.Char;
+    readonly city: F.Char;
+    readonly zip: F.Char;
+    readonly email: F.Char;
+    readonly phone: F.Char;
+    readonly website: F.Char;
   };
   readonly methods: ResCompanyMethods;
 }

package/dist/purchase/.kosh/bindings.js

@@ -1,4 +1,4 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: c5ae4567ecbd3b97
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 96928facddb91996
 // Bindings of module `purchase`: 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/purchase/.kosh/schema.d.ts

@@ -1,4 +1,4 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: c5ae4567ecbd3b97
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 96928facddb91996
 // Schema view of module `purchase` (RFC 0002 §7.7): the models it owns or depends on, with the extensions it can see.
 import type { F } from '../../server/orm.js';
 
@@ -11,6 +11,7 @@ export interface SchemaView {
   readonly 'audit.event': AuditEvent;
   readonly 'auth.api_key': AuthApiKey;
   readonly 'auth.credential': AuthCredential;
+  readonly 'auth.policy': AuthPolicy;
   readonly 'auth.session': AuthSession;
   readonly 'auth.user_grant': AuthUserGrant;
   readonly 'auth.user_group': AuthUserGroup;
@@ -219,6 +220,26 @@ export interface AuthCredential {
 export interface AuthCredentialMethods extends F.Methods<typeof import('../../server/index.js').baseShutro, 'auth.credential'> {
 }
 
+/** `auth.policy` (owner: base). */
+export interface AuthPolicy {
+  readonly name: 'auth.policy';
+  readonly fields: {
+    readonly id: F.Id<'auth.policy'>;
+    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 twoFactor: F.Selection<'administrators' | 'everyone', { readonly required: true; readonly default: true }>;
+    readonly sessionDays: F.Integer;
+  };
+  readonly methods: AuthPolicyMethods;
+}
+
+/** Methods of `auth.policy`: declared ones and transitions. */
+export interface AuthPolicyMethods extends F.Methods<typeof import('../../server/index.js').baseShutro, 'auth.policy'> {
+}
+
 /** `auth.session` (owner: base). */
 export interface AuthSession {
   readonly name: 'auth.session';
@@ -631,6 +652,13 @@ export interface ResCompany {
     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 accentColor: F.Char;
+    readonly street: F.Char;
+    readonly city: F.Char;
+    readonly zip: F.Char;
+    readonly email: F.Char;
+    readonly phone: F.Char;
+    readonly website: F.Char;
   };
   readonly methods: ResCompanyMethods;
 }

package/dist/purchase_account/.kosh/bindings.js

@@ -1,4 +1,4 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 81a33d0265524052
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 637dfa1606a303a1
 // Bindings of module `purchase_account`: 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/purchase_account/.kosh/schema.d.ts

@@ -1,4 +1,4 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 81a33d0265524052
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 637dfa1606a303a1
 // Schema view of module `purchase_account` (RFC 0002 §7.7): the models it owns or depends on, with the extensions it can see.
 import type { F } from '../../server/orm.js';
 
@@ -24,6 +24,7 @@ export interface SchemaView {
   readonly 'audit.event': AuditEvent;
   readonly 'auth.api_key': AuthApiKey;
   readonly 'auth.credential': AuthCredential;
+  readonly 'auth.policy': AuthPolicy;
   readonly 'auth.session': AuthSession;
   readonly 'auth.user_grant': AuthUserGrant;
   readonly 'auth.user_group': AuthUserGroup;
@@ -634,6 +635,26 @@ export interface AuthCredential {
 export interface AuthCredentialMethods extends F.Methods<typeof import('../../server/index.js').baseShutro, 'auth.credential'> {
 }
 
+/** `auth.policy` (owner: base). */
+export interface AuthPolicy {
+  readonly name: 'auth.policy';
+  readonly fields: {
+    readonly id: F.Id<'auth.policy'>;
+    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 twoFactor: F.Selection<'administrators' | 'everyone', { readonly required: true; readonly default: true }>;
+    readonly sessionDays: F.Integer;
+  };
+  readonly methods: AuthPolicyMethods;
+}
+
+/** Methods of `auth.policy`: declared ones and transitions. */
+export interface AuthPolicyMethods extends F.Methods<typeof import('../../server/index.js').baseShutro, 'auth.policy'> {
+}
+
 /** `auth.session` (owner: base). */
 export interface AuthSession {
   readonly name: 'auth.session';
@@ -1202,6 +1223,13 @@ export interface ResCompany {
     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 accentColor: F.Char;
+    readonly street: F.Char;
+    readonly city: F.Char;
+    readonly zip: F.Char;
+    readonly email: F.Char;
+    readonly phone: F.Char;
+    readonly website: F.Char;
     readonly fiscalYearStart: F.Integer<{ readonly required: true; readonly default: true }>; // accounting
     readonly chartTemplate: F.Char; // accounting
     readonly country: F.Char; // accounting

package/dist/purchase_portal/.kosh/bindings.js

@@ -1,4 +1,4 @@
-// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 64da9b36804c7c1a
+// GENERATED by `pnpm generate:models` (Shutro’s generator). Do not edit. definitions-hash: 2bbbe12acf870fd9
 // Bindings of module `purchase_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';