shutro-erp 0.3.4 → 0.3.6

package/dist/documents/module.js

@@ -0,0 +1,214 @@
+/**
+ * The data layer of Documents (RFC 0024 §2.8): folders of a company — open to everyone with Documents, or kept to their
+ * members —, documents in them with tags and versions (each version a stored file, the latest the current one),
+ * share links with an expiry and an optional password (only hashes are kept), and requests: a person is asked for a
+ * file by email, with a link that uploads it into the right folder, and reminded once when it is late.
+ */
+import { contactsShutro } from '../contacts/index.js';
+import { messagingShutro } from '../messaging/index.js';
+import { orm } from '../server/orm.js';
+import { check, compute, defineModel, defineModule, f, records, } from './.kosh/bindings.js';
+import { announceRequests } from './documents.js';
+const ALL = ['read', 'write', 'create', 'unlink'];
+const me = { $env: 'uid' };
+export const DocumentsFolder = defineModel('documents.folder', {
+    label: 'Folder',
+    recName: 'fullName',
+    order: ['fullName asc'],
+    archivable: true,
+    companyScoped: { required: true },
+    hierarchy: { parent: 'parent', path: 'parentPath' },
+    tracking: ['restricted', 'members'],
+    access: { 'documents.user': ['read'], 'documents.manager': [...ALL, 'export'] },
+    rules: {
+        // A restricted folder is its members' (and its owner's); the others are everyone's with Documents.
+        see: {
+            groups: ['documents.user'],
+            perms: ['read'],
+            domain: { or: [{ restricted: false }, { owner: me }, { members: { any: { id: me } } }] },
+        },
+        all: { groups: ['documents.manager'], perms: [...ALL], domain: {} },
+    },
+    fields: {
+        name: f.char({ required: true, translate: true }),
+        parent: f.many2one('documents.folder', { ondelete: 'restrict', label: 'Inside' }),
+        parentPath: f.char({ readonly: true, index: true }),
+        children: f.one2many('documents.folder', 'parent'),
+        fullName: f.char({
+            store: true,
+            label: 'Folder',
+            ...compute('documents.folder', 'fullName', ['name', 'parent.name', 'parent.parent.name'], (folders) => {
+                for (const x of folders)
+                    x.fullName = [x.parent?.parent?.name, x.parent?.name, x.name]
+                        .filter((n) => n !== null && n !== undefined)
+                        .join(' / ');
+            }),
+        }),
+        owner: f.many2one('res.users', { default: (env) => env.userId, label: 'Owner' }),
+        /** Kept to its members (and its owner); otherwise everyone with Documents sees it. */
+        restricted: f.boolean({ default: false, label: 'Members only' }),
+        members: f.many2many('res.users', {
+            relation: 'documents_folder_member_rel',
+            label: 'Members',
+        }),
+        documents: f.one2many('documents.document', 'folder'),
+        description: f.text(),
+    },
+});
+export const DocumentsTag = defineModel('documents.tag', {
+    label: 'Document tag',
+    recName: 'name',
+    order: ['name asc'],
+    archivable: true,
+    access: { 'documents.user': ['read', 'create'], 'documents.manager': ALL },
+    fields: {
+        name: f.char({ required: true, translate: true }),
+        color: f.char({ label: 'Colour' }),
+    },
+    sqlConstraints: { oneName: { unique: ['name'], message: 'Another tag has this name.' } },
+});
+export const DocumentsDocument = defineModel('documents.document', {
+    label: 'Document',
+    recName: 'name',
+    order: ['updatedAt desc', 'id desc'],
+    archivable: true,
+    companyScoped: { required: true },
+    tracking: ['name', 'folder', 'attachment'],
+    access: {
+        'documents.user': ['read', 'write', 'create'],
+        'documents.manager': [...ALL, 'export', 'import'],
+    },
+    rules: {
+        // Read: in a folder they see, or their own; made and changed only in a folder they see.
+        see: {
+            groups: ['documents.user'],
+            perms: ['read'],
+            domain: {
+                or: [
+                    { 'folder.restricted': false },
+                    { 'folder.owner': me },
+                    { 'folder.members': { any: { id: me } } },
+                    { owner: me },
+                ],
+            },
+        },
+        edit: {
+            groups: ['documents.user'],
+            perms: ['write', 'create'],
+            domain: {
+                or: [
+                    { 'folder.restricted': false },
+                    { 'folder.owner': me },
+                    { 'folder.members': { any: { id: me } } },
+                ],
+            },
+        },
+        all: { groups: ['documents.manager'], perms: [...ALL], domain: {} },
+    },
+    fields: {
+        name: f.char({ required: true }),
+        folder: f.many2one('documents.folder', { required: true, ondelete: 'restrict' }),
+        tags: f.many2many('documents.tag', { relation: 'documents_document_tag_rel' }),
+        owner: f.many2one('res.users', { default: (env) => env.userId, label: 'Owner' }),
+        /** The current version: the latest file uploaded (`POST /api/v1/documents/:id/versions`). */
+        attachment: f.many2one('storage.attachment', { ondelete: 'set null', label: 'File' }),
+        mime: f.char({ label: 'Type' }),
+        size: f.integer({ label: 'Size (bytes)' }),
+        versions: f.integer({ required: true, default: 0, label: 'Versions' }),
+        /** The record it is about (an employee, an order), when there is one. */
+        resModel: f.char({ label: 'About (model)' }),
+        resId: f.integer({ label: 'About (record)' }),
+        description: f.text(),
+        /** The request it answered, when it came from one. */
+        request: f.many2one('documents.request', { ondelete: 'set null', label: 'Requested by' }),
+    },
+});
+export const DocumentsShare = defineModel('documents.share', {
+    label: 'Share link',
+    order: ['id desc'],
+    companyScoped: { required: true },
+    access: { 'documents.user': ['read', 'create', 'write'], 'documents.manager': ALL },
+    rules: {
+        mine: {
+            groups: ['documents.user'],
+            perms: ['read', 'create', 'write'],
+            domain: { createdBy: me },
+        },
+        all: { groups: ['documents.manager'], perms: [...ALL], domain: {} },
+    },
+    fields: {
+        document: f.many2one('documents.document', { ondelete: 'cascade' }),
+        folder: f.many2one('documents.folder', { ondelete: 'cascade' }),
+        /** The hash of the link's token (the token is shown once, when the link is made). */
+        tokenHash: f.char({ required: true, index: 'unique', label: 'Token (hash)' }),
+        passwordHash: f.char({ label: 'Password (hash)' }),
+        expiresAt: f.datetime({ required: true, label: 'Expires at' }),
+        downloads: f.integer({ required: true, default: 0 }),
+        revoked: f.boolean({ default: false }),
+    },
+    constraints: {
+        oneTarget: {
+            ...check('documents.share', ['document', 'folder'], async (shares) => (await shares.load({ document: true, folder: true }))
+                .filter((s) => (s.document === null) === (s.folder === null))
+                .map((s) => s.id)),
+            message: 'A link shares a document or a folder.',
+        },
+    },
+});
+export const DocumentsRequest = defineModel('documents.request', {
+    label: 'Document request',
+    recName: 'name',
+    order: ['id desc'],
+    companyScoped: { required: true },
+    tracking: ['state', 'dueDate'],
+    access: { 'documents.user': ['read', 'write', 'create'], 'documents.manager': ALL },
+    fields: {
+        /** What is asked for: "Your NID card", "The signed contract". */
+        name: f.char({ required: true, label: 'What is asked for' }),
+        folder: f.many2one('documents.folder', { required: true, ondelete: 'restrict', label: 'Into' }),
+        partner: f.many2one('res.partner', { ondelete: 'set null', label: 'From' }),
+        email: f.char({ required: true }),
+        message: f.text(),
+        dueDate: f.date({ label: 'Due' }),
+        /** The hash of the upload link's token (sent by email, never kept). */
+        tokenHash: f.char({ index: true, label: 'Token (hash)' }),
+        sentAt: f.datetime({ label: 'Sent at' }),
+        remindedAt: f.datetime({ label: 'Reminded at' }),
+        document: f.many2one('documents.document', { ondelete: 'set null', label: 'Received' }),
+        state: f.state({
+            states: { draft: 'Draft', sent: 'Sent', received: 'Received', cancel: 'Cancelled' },
+            initial: 'draft',
+            transitions: {
+                /** Emails the person a link that uploads the file into the folder. */
+                send: {
+                    from: ['draft'],
+                    to: 'sent',
+                    before: records('documents.request', async (requests) => {
+                        await announceRequests(requests.env, requests.ids);
+                    }),
+                },
+                receive: { from: ['sent'], to: 'received' },
+                cancel: { from: ['draft', 'sent'], to: 'cancel' },
+                redraft: { from: ['cancel'], to: 'draft' },
+            },
+        }),
+    },
+});
+export const documentsShutro = defineModule({
+    name: 'documents',
+    version: '0.1.0',
+    depends: [contactsShutro, messagingShutro],
+    groups: [
+        orm.defineGroup({
+            code: 'documents.user',
+            label: 'Documents user',
+            implies: ['contacts.user'],
+        }),
+        orm.defineGroup({
+            code: 'documents.manager',
+            label: 'Documents manager',
+            implies: ['documents.user'],
+        }),
+    ],
+    models: [DocumentsFolder, DocumentsTag, DocumentsDocument, DocumentsShare, DocumentsRequest],
+});

package/dist/documents/web/Versions.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The versions of a document on its form (RFC 0024 §2.8): each upload a new version, the latest the current one;
+ * every version can be downloaded. The server stores the file and keeps the count; this only shows and sends it.
+ */
+import { type NodeComponentProps } from '../../ui/index.js';
+import { type ReactElement } from 'react';
+export declare function Versions({ record, api }: NodeComponentProps): ReactElement | null;

package/dist/documents/web/Versions.js

@@ -0,0 +1,45 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * The versions of a document on its form (RFC 0024 §2.8): each upload a new version, the latest the current one;
+ * every version can be downloaded. The server stores the file and keeps the count; this only shows and sends it.
+ */
+import { Alert, Button, useKosh } from '../../ui/index.js';
+import { useMutation, useQuery } from '@tanstack/react-query';
+import { useId, useRef } from 'react';
+import { useTranslation } from 'react-i18next';
+export function Versions({ record, api }) {
+    const { t } = useTranslation('documents');
+    const { format } = useKosh();
+    const id = useId();
+    const input = useRef(null);
+    const doc = typeof record?.['id'] === 'number' ? record['id'] : null;
+    const versions = useQuery({
+        queryKey: ['documents', 'versions', doc],
+        queryFn: () => api.call('GET', `/api/v1/documents/${String(doc)}/versions`),
+        enabled: doc !== null,
+    });
+    const upload = useMutation({
+        mutationFn: (file) => api.upload(`/api/v1/documents/${String(doc)}/versions`, file, file.name),
+        onSuccess: async () => {
+            if (input.current !== null)
+                input.current.value = '';
+            await versions.refetch();
+        },
+    });
+    if (doc === null)
+        return _jsx("p", { className: "text-sm text-muted-foreground", children: t('saveFirst') });
+    const rows = versions.data?.versions ?? [];
+    return (_jsxs("section", { "aria-labelledby": `${id}-title`, className: "col-span-full grid gap-2", children: [_jsx("h3", { id: `${id}-title`, className: "text-sm font-semibold", children: t('versions') }), _jsxs("div", { className: "flex items-center gap-2", children: [_jsx("input", { ref: input, id: `${id}-file`, type: "file", "aria-label": t('newVersion'), className: "text-sm", onChange: (e) => {
+                            const file = e.target.files?.[0];
+                            if (file !== undefined)
+                                upload.mutate(file);
+                        } }), upload.isPending ? _jsx("span", { className: "text-sm", children: t('uploading') }) : null] }), upload.error === null ? null : _jsx(Alert, { tone: "danger", children: upload.error.message }), rows.length === 0 ? (_jsx("p", { className: "text-sm text-muted-foreground", children: t('noVersion') })) : (_jsx("ul", { className: "grid gap-1 text-sm", children: rows.map((v, i) => (_jsxs("li", { className: "flex flex-wrap items-center gap-2", children: [_jsx("span", { className: "font-medium", children: t('version', { n: rows.length - i }) }), _jsx("span", { children: v.name }), _jsxs("span", { className: "text-muted-foreground", children: [format.decimal(String(Math.ceil(v.size / 1024))), " KB \u00B7 ", format.date(v.at)] }), _jsx(Button, { variant: "secondary", onClick: async () => {
+                                const { blob, filename } = await api.download(`/api/v1/attachments/${v.id}/download`, undefined, 'GET');
+                                const url = URL.createObjectURL(blob);
+                                const a = document.createElement('a');
+                                a.href = url;
+                                a.download = filename;
+                                a.click();
+                                URL.revokeObjectURL(url);
+                            }, children: t('download') })] }, v.id))) }))] }));
+}

package/dist/documents/web/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @packageDocumentation
+ * The web contribution of `shutro-erp/documents`: the versions panel of a document's form.
+ */
+import { type Registry } from '../../ui/index.js';
+import type { i18n } from 'i18next';
+import { messages } from './messages.js';
+export { Versions } from './Versions.js';
+/** Registers the component (and the messages in `i18n`, when given). */
+export declare function registerDocumentsWeb(registry: Registry, i18n?: i18n): Registry;
+export { messages as documentsMessages };

package/dist/documents/web/index.js

@@ -0,0 +1,16 @@
+/**
+ * @packageDocumentation
+ * The web contribution of `shutro-erp/documents`: the versions panel of a document's form.
+ */
+import { addMessages } from '../../ui/index.js';
+import { messages } from './messages.js';
+import { Versions } from './Versions.js';
+export { Versions } from './Versions.js';
+/** Registers the component (and the messages in `i18n`, when given). */
+export function registerDocumentsWeb(registry, i18n) {
+    registry.registerComponent('documents.Versions', Versions);
+    if (i18n !== undefined)
+        addMessages(i18n, 'documents', messages);
+    return registry;
+}
+export { messages as documentsMessages };

package/dist/documents/web/messages.d.ts

@@ -0,0 +1,2 @@
+/** Messages of the Documents screens (namespace `documents`), in English and Bangla. */
+export declare const messages: Readonly<Record<string, object>>;

package/dist/documents/web/messages.js

@@ -0,0 +1,21 @@
+/** Messages of the Documents screens (namespace `documents`), in English and Bangla. */
+export const messages = {
+    en: {
+        versions: 'Versions',
+        newVersion: 'Upload a new version',
+        uploading: 'Uploading…',
+        noVersion: 'No file yet: upload the first version.',
+        version: 'Version {{n}}',
+        download: 'Download',
+        saveFirst: 'Save the document, then upload its file.',
+    },
+    bn: {
+        versions: 'সংস্করণ',
+        newVersion: 'নতুন সংস্করণ আপলোড করুন',
+        uploading: 'আপলোড হচ্ছে…',
+        noVersion: 'এখনো কোনো ফাইল নেই: প্রথম সংস্করণ আপলোড করুন।',
+        version: 'সংস্করণ {{n}}',
+        download: 'ডাউনলোড',
+        saveFirst: 'আগে নথিটি সংরক্ষণ করুন, তারপর ফাইল আপলোড করুন।',
+    },
+};

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

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