shutro-erp 0.3.3 → 0.3.5

package/dist/server/images.js

@@ -0,0 +1,139 @@
+/**
+ * Profile photos and company logos: small images (resized to 256 px in the browser) kept in the database, so they
+ * work with or without file storage. PNG, JPEG or WebP only — checked by their bytes, never trusted from the name or
+ * the type given; at most 300 KB. Served to signed-in users with a version in the URL, so browsers cache them.
+ *
+ * - `GET    /api/v1/images/:kind/:id`        `kind`: `user` or `company`; the image, or 404
+ * - `PUT    /api/v1/auth/profile/avatar`     `{ image: 'data:image/…;base64,…' }`: your photo; `DELETE` removes it
+ * - `PUT    /api/v1/images/company/:id`      a company's logo (Administrator or Settings / Company, one of your
+ *                                            companies); `DELETE` removes it
+ */
+import { createHash } from 'node:crypto';
+import { audit } from './audit.js';
+import { HttpProblem } from './errors.js';
+const MAX_BYTES = 300 * 1024;
+const KINDS = { user: 'res.users', company: 'res.company' };
+const images = (env) => env.model('kosh.image');
+/** The image's type from its first bytes: PNG, JPEG or WebP; anything else (SVG included) is refused. */
+function sniff(bytes) {
+    if (bytes.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])))
+        return 'image/png';
+    if (bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff)
+        return 'image/jpeg';
+    if (bytes.subarray(0, 4).toString('latin1') === 'RIFF' &&
+        bytes.subarray(8, 12).toString('latin1') === 'WEBP')
+        return 'image/webp';
+    return null;
+}
+/** The bytes of a `data:` URL, checked. @throws {HttpProblem} 422 */
+function decode(input) {
+    const bad = (detail) => new HttpProblem(422, 'invalid-image', 'Invalid image', detail);
+    const match = typeof input === 'string'
+        ? /^data:image\/[a-z+.-]+;base64,([A-Za-z0-9+/=]+)$/.exec(input)
+        : null;
+    if (match === null)
+        throw bad('Send the image as a data URL (PNG, JPEG or WebP).');
+    const bytes = Buffer.from(match[1], 'base64');
+    if (bytes.length === 0 || bytes.length > MAX_BYTES)
+        throw bad('The image must be under 300 KB.');
+    const mime = sniff(bytes);
+    if (mime === null)
+        throw bad('Only PNG, JPEG or WebP images.');
+    return { bytes, mime };
+}
+/** The image versions of `ids` of a kind (a short digest), for URLs that change when the image does. */
+export async function imageVersions(env, kind, ids) {
+    if (ids.length === 0)
+        return {};
+    const found = await images(env).search({
+        where: { ownerModel: KINDS[kind], ownerId: { in: [...ids] } },
+    });
+    const rows = found.length === 0 ? [] : (await found.load(['ownerId', 'hash'])).read(['ownerId', 'hash']);
+    return Object.fromEntries(rows.map((r) => [String(r['ownerId']), String(r['hash'])]));
+}
+async function store(env, kind, id, input) {
+    const existing = await images(env).search({ where: { ownerModel: KINDS[kind], ownerId: id } });
+    if (input === null) {
+        if (existing.length > 0)
+            await existing.unlink();
+        return null;
+    }
+    const { bytes, mime } = decode(input);
+    const hash = createHash('sha256').update(bytes).digest('hex').slice(0, 16);
+    const values = { mime, data: bytes.toString('base64'), hash };
+    if (existing.length > 0)
+        await existing.write(values);
+    else
+        await images(env).create([{ ownerModel: KINDS[kind], ownerId: id, ...values }]);
+    return hash;
+}
+export function registerImageRoutes(app, auth) {
+    app.get('/api/v1/images/:kind/:id', async (request, reply) => {
+        const { kind, id } = request.params;
+        const owner = Number(id);
+        if (!(kind === 'user' || kind === 'company') || !Number.isSafeInteger(owner) || owner <= 0)
+            throw new HttpProblem(404, 'not-found', 'Not found', 'No such image.');
+        const row = await request.env((env) => env.asSuperuser({ reason: 'image' }, async (su) => {
+            const found = await images(su).search({
+                where: { ownerModel: KINDS[kind], ownerId: owner },
+            });
+            return found.length === 0
+                ? undefined
+                : (await found.load(['mime', 'data', 'hash'])).read(['mime', 'data', 'hash'])[0];
+        }), { write: true });
+        if (row === undefined)
+            throw new HttpProblem(404, 'not-found', 'Not found', 'No image.');
+        const etag = `"${String(row['hash'])}"`;
+        reply
+            .header('content-type', String(row['mime']))
+            .header('etag', etag)
+            .header('x-content-type-options', 'nosniff')
+            // Versioned URLs (`?v=<hash>`) never change; plain ones are checked again after a minute.
+            .header('cache-control', request.query.v === undefined
+            ? 'private, max-age=60'
+            : 'private, max-age=31536000, immutable');
+        if (request.headers['if-none-match'] === etag)
+            return reply.status(304).send();
+        return reply.send(Buffer.from(String(row['data']), 'base64'));
+    });
+    const own = async (request, image) => {
+        const session = await auth.requireSession(request);
+        const hash = await request.env((env) => env.asSuperuser({ reason: 'profile photo' }, async (su) => {
+            const out = await store(su, 'user', session.user, image);
+            await audit(env, {
+                kind: 'auth.avatar',
+                summary: image === null ? 'Profile photo removed.' : 'Profile photo changed.',
+                targetModel: 'res.users',
+                targetId: session.user,
+            });
+            await su.flush();
+            return out;
+        }), { write: true });
+        auth.forget(session.user);
+        return { avatar: hash };
+    };
+    app.put('/api/v1/auth/profile/avatar', async (request) => own(request, request.body?.['image'] ?? ''));
+    app.delete('/api/v1/auth/profile/avatar', async (request) => own(request, null));
+    const logo = async (request, image) => {
+        const company = Number(request.params.id);
+        return request.env(async (env) => {
+            if (!env.administrator && !env.groups.has('settings.company'))
+                throw new HttpProblem(403, 'access', 'Company settings', 'Changing the logo needs the Administrator role or the Settings / Company access.');
+            if (!env.administrator && !env.companyIds.includes(company))
+                throw new HttpProblem(403, 'access', 'Company settings', 'Not one of your companies.');
+            return env.asSuperuser({ reason: 'company logo' }, async (su) => {
+                const hash = await store(su, 'company', company, image);
+                await audit(env, {
+                    kind: 'settings.logo',
+                    summary: image === null ? 'Company logo removed.' : 'Company logo changed.',
+                    targetModel: 'res.company',
+                    targetId: company,
+                });
+                await su.flush();
+                return { logo: hash };
+            });
+        }, { write: true });
+    };
+    app.put('/api/v1/images/company/:id', async (request) => logo(request, request.body?.['image'] ?? ''));
+    app.delete('/api/v1/images/company/:id', async (request) => logo(request, null));
+}

package/dist/server/index.d.ts

@@ -11,6 +11,7 @@ export { type FoundRecord, type MenuNode, moduleVisible, Navigation } from './ap
 export { fieldSchema, openApiDocument, openApiOf } from './api/openapi.js';
 export { readApiRecord, registerRestApi } from './api/rest.js';
 export { type ServedView, type ViewField, ViewRegistry } from './api/views.js';
+export { installationSetting } from './app-settings.js';
 export { APPS_CHANNEL, APPS_LOG_TABLE, APPS_TABLE, type AppLoadContext, type ApplyAppsOptions, type AppsResult, applyApps, appsDigest, appTableStatements, FRAMEWORK_TABLES, installDefaults, installedApps, installedModules, type PrepareAppsOptions, type PreparedApps, prepareApps, readInstalledApps, recordInstalledApps, restoreAppMigrations, } from './apps.js';
 export { type AuditInput, audit } from './audit.js';
 export { administrators, isAdministratorUser, keepingAdministrator, LAST_ADMINISTRATOR, } from './auth/admins.js';
@@ -24,6 +25,7 @@ export { applyEnvironmentNames } from './env-names.js';
 export { HttpProblem, type Problem, problemOf, ServerConfigError } from './errors.js';
 export { type AppHost, type AppHostOptions, createAppHost, startAppHost } from './host.js';
 export { type Authenticator, denyAll, isSuperuser, languageOf, type RequestIdentity, type RequestRunOptions, runOptionsOf, } from './identity.js';
+export { imageVersions, registerImageRoutes } from './images.js';
 export { migrate, orm, pg } from './orm.js';
 export { buildKoshRegistry, KOSH_VERSION, type KoshRegistry } from './registry.js';
 export { type AppsContext, createServer, type KoshServer, type ModuleContext, type ServerOptions, startServer, } from './server.js';

package/dist/server/index.js

@@ -11,6 +11,7 @@ export { moduleVisible, Navigation } from './api/navigation.js';
 export { fieldSchema, openApiDocument, openApiOf } from './api/openapi.js';
 export { readApiRecord, registerRestApi } from './api/rest.js';
 export { ViewRegistry } from './api/views.js';
+export { installationSetting } from './app-settings.js';
 export { APPS_CHANNEL, APPS_LOG_TABLE, APPS_TABLE, applyApps, appsDigest, appTableStatements, FRAMEWORK_TABLES, installDefaults, installedApps, installedModules, prepareApps, readInstalledApps, recordInstalledApps, restoreAppMigrations, } from './apps.js';
 export { audit } from './audit.js';
 export { administrators, isAdministratorUser, keepingAdministrator, LAST_ADMINISTRATOR, } from './auth/admins.js';
@@ -24,6 +25,7 @@ export { applyEnvironmentNames } from './env-names.js';
 export { HttpProblem, problemOf, ServerConfigError } from './errors.js';
 export { createAppHost, startAppHost } from './host.js';
 export { denyAll, isSuperuser, languageOf, runOptionsOf, } from './identity.js';
+export { imageVersions, registerImageRoutes } from './images.js';
 export { migrate, orm, pg } from './orm.js';
 export { buildKoshRegistry, KOSH_VERSION } from './registry.js';
 export { createServer, startServer, } from './server.js';

package/dist/server/server.d.ts

@@ -47,6 +47,10 @@ export interface ServerOptions {
         /** Sign-in attempts per 15 minutes per IP and login (default 10; 0 turns the limit off). */
         readonly loginLimit?: number;
     };
+    /** OAuth 2.0 provider (RFC 0017 §5.2): the back-office's address, where the consent page is (`KOSH_BASE_URL`). */
+    readonly oauth?: {
+        readonly baseUrl?: string;
+    };
     /**
      * Shutro's identity loader checks every request's user (active, companies, groups) against `base`'s data. Default:
      * on with the built-in authentication; custom authenticators opt in.

package/dist/server/server.js

@@ -13,12 +13,14 @@ import { openApiDocument } from './api/openapi.js';
 import { registerRestApi } from './api/rest.js';
 import { ViewRegistry } from './api/views.js';
 import { registerApiKeyRoutes } from './auth/api-keys.js';
+import { registerOAuthRoutes } from './auth/oauth.js';
 import { registerAuthRoutes } from './auth/routes.js';
 import { enforceScopes } from './auth/scopes.js';
 import { AuthService } from './auth/service.js';
 import { applyEnvironmentNames } from './env-names.js';
 import { HttpProblem, problemOf, ServerConfigError } from './errors.js';
 import { denyAll, runOptionsOf } from './identity.js';
+import { registerImageRoutes } from './images.js';
 import { orm, pg } from './orm.js';
 import { buildKoshRegistry, KOSH_VERSION } from './registry.js';
 import { endSpan, tracer } from './telemetry.js';
@@ -169,7 +171,9 @@ export async function createServer(options) {
                 ? `ip:${request.ip}`
                 : request.identity.apiKey !== undefined
                     ? `key:${request.identity.apiKey}`
-                    : `user:${request.identity.user}`,
+                    : request.identity.oauthToken !== undefined
+                        ? `oauth:${request.identity.oauthToken}`
+                        : `user:${request.identity.user}`,
             allowList: (request) => request.routeOptions.config.public === true,
             errorResponseBuilder: (_request, context) => new HttpProblem(429, 'rate-limited', 'Too many requests', `Limit of ${context.max} requests per ${context.after} reached.`, `Retry after ${context.after}.`),
         });
@@ -209,6 +213,10 @@ export async function createServer(options) {
     if (auth !== undefined) {
         registerAuthRoutes(app, auth, { loginLimit: options.auth?.loginLimit ?? 10 });
         registerApiKeyRoutes(app, auth, registry);
+        registerImageRoutes(app, auth);
+        registerOAuthRoutes(app, auth, () => shutro, registry, {
+            baseUrl: options.oauth?.baseUrl ?? process.env['KOSH_BASE_URL'] ?? 'http://localhost:5173',
+        });
     }
     // The generated REST API and its OpenAPI document (RFC 0002 §6.3–6.4).
     for (const statement of idempotencyTableStatements())

package/dist/settings/app-settings.d.ts

@@ -0,0 +1,2 @@
+import { type ModuleContext } from '../server/index.js';
+export declare function registerAppSettingsRoutes(context: ModuleContext): void;