@yunsoft/yuncms-api 0.1.2 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yunsoft/yuncms-api",
-  "version": "0.1.2",
+  "version": "0.1.5",
   "description": "Express API runtime and bundled Studio server for YunCMS.",
   "license": "MIT",
   "type": "module",
@@ -32,7 +32,7 @@
     "test": "node --test"
   },
   "dependencies": {
-    "@yunsoft/yuncms-core": "0.1.2",
+    "@yunsoft/yuncms-core": "0.1.5",
     "express": "5.2.1"
   }
 }

package/src/app.js

@@ -7,6 +7,8 @@ import {
 
 import { createAuthenticationMiddleware } from './authentication.js';
 import { apiErrorHandler } from './error-response.js';
+import { createPressureLimit } from './pressure-limit.js';
+import { createFixedWindowRateLimit } from './rate-limit.js';
 import { createAuditRouter } from './routes/audit.js';
 import { createAuthRouter } from './routes/auth.js';
 import { createFilesRouter } from './routes/files.js';
@@ -15,10 +17,26 @@ import { createPermissionsRouter } from './routes/permissions.js';
 import { createRolesRouter } from './routes/roles.js';
 import { createSchemaRouter } from './routes/schema.js';
 import { createStudioSettingsRouter } from './routes/studio-settings.js';
+import { createSystemSchemaRouter } from './routes/system-schema.js';
 import { createUsersRouter } from './routes/users.js';
 import { createStudioMiddleware } from './studio.js';
 
 const REQUEST_ID_PATTERN = /^[A-Za-z0-9._:-]{1,64}$/;
+const CONTENT_SECURITY_POLICY = [
+  "default-src 'self'",
+  "base-uri 'self'",
+  "object-src 'none'",
+  "frame-ancestors 'none'",
+  "script-src 'self'",
+  "style-src 'self' 'unsafe-inline'",
+  "img-src 'self' data: blob: https://yunsoft.com",
+  "font-src 'self' data:",
+  "connect-src 'self'",
+  "media-src 'self' blob:",
+  "frame-src 'self' blob:",
+  "worker-src 'self' blob:",
+  "form-action 'self'",
+].join('; ');
 
 function securityHeaders(req, res, next) {
   res.set('x-content-type-options', 'nosniff');
@@ -26,6 +44,12 @@ function securityHeaders(req, res, next) {
   res.set('referrer-policy', 'no-referrer');
   res.set('permissions-policy', 'camera=(), microphone=(), geolocation=(), payment=(), usb=()');
   res.set('cross-origin-resource-policy', 'same-origin');
+  res.set('cross-origin-opener-policy', 'same-origin');
+  res.set('x-dns-prefetch-control', 'off');
+  res.set('content-security-policy', CONTENT_SECURITY_POLICY);
+  if (req.secure === true) {
+    res.set('strict-transport-security', 'max-age=15552000; includeSubDomains');
+  }
   next();
 }
 
@@ -53,12 +77,23 @@ function requestIdentity(req, res, next) {
   next();
 }
 
+function createApiRateLimit(config) {
+  const limits = config?.server?.rateLimit;
+  if (!limits?.enabled) return null;
+  return createFixedWindowRateLimit({
+    windowMs: limits.windowMs,
+    max: limits.max,
+    maxBuckets: limits.maxBuckets,
+  });
+}
+
 export function createApp({
   pool,
   config,
   logger = console,
   serviceRegistry = createCoreServiceRegistry(),
   schemaCache = null,
+  permissionCache = null,
   emitter = null,
   storage = null,
   mailer = null,
@@ -99,18 +134,26 @@ export function createApp({
 
   app.use(createStudioMiddleware({ root: studioRoot }));
 
+  const pressureLimit = createPressureLimit(config.server?.pressure);
+  if (pressureLimit) app.use(pressureLimit);
+
+  const apiRateLimit = createApiRateLimit(config);
+  if (apiRateLimit) app.use(apiRateLimit);
+
   app.use(createAuthenticationMiddleware({
     pool,
     config,
     logger,
     services,
     schemaCache,
+    permissionCache,
     emitter,
     storage,
   }));
   app.use('/studio-settings', createStudioSettingsRouter());
   app.use('/auth', createAuthRouter({ mailer, config, logger }));
   app.use('/items', createItemsRouter());
+  app.use('/schema', createSystemSchemaRouter({ schemaCache }));
   app.use('/schema', createSchemaRouter({ schemaCache }));
   app.use('/users', createUsersRouter());
   app.use('/roles', createRolesRouter());
@@ -135,4 +178,10 @@ export function createApp({
   return app;
 }
 
-export { requestIdentity, securityHeaders, studioCors };
+export {
+  CONTENT_SECURITY_POLICY,
+  createApiRateLimit,
+  requestIdentity,
+  securityHeaders,
+  studioCors,
+};

package/src/audit-events.js

@@ -0,0 +1,18 @@
+export const INTERNAL_AUDIT_EVENTS = Object.freeze([
+  'items.create',
+  'items.update',
+  'items.delete',
+  'files.create',
+  'files.update',
+  'files.delete',
+  'users.create',
+  'users.update',
+  'users.delete',
+  'users.password.update',
+  'roles.create',
+  'roles.update',
+  'roles.delete',
+  'permissions.create',
+  'permissions.update',
+  'permissions.delete',
+]);

package/src/authentication.js

@@ -25,6 +25,7 @@ export function createAuthenticationMiddleware({
   logger,
   services,
   schemaCache = null,
+  permissionCache = null,
   emitter = null,
   storage = null,
 }) {
@@ -79,6 +80,7 @@ export function createAuthenticationMiddleware({
         env: config,
         emitter,
         storage,
+        permissionCache,
         requestId: req.id,
       });
       next();

package/src/pressure-limit.js

@@ -0,0 +1,51 @@
+function assertPositiveInteger(value, name) {
+  if (!Number.isInteger(value) || value < 1) throw new Error(`${name} must be a positive integer`);
+}
+
+export function createPressureLimit({
+  enabled = true,
+  maxConcurrent = 250,
+  maxHeapPercent = 95,
+  retryAfterSeconds = 1,
+  memoryUsage = () => process.memoryUsage(),
+} = {}) {
+  if (!enabled) return null;
+  assertPositiveInteger(maxConcurrent, 'Pressure maxConcurrent');
+  assertPositiveInteger(maxHeapPercent, 'Pressure maxHeapPercent');
+  if (maxHeapPercent > 100) throw new Error('Pressure maxHeapPercent cannot exceed 100');
+  assertPositiveInteger(retryAfterSeconds, 'Pressure retryAfterSeconds');
+  if (typeof memoryUsage !== 'function') throw new Error('Pressure memoryUsage must be a function');
+
+  let inFlight = 0;
+
+  return (req, res, next) => {
+    const memory = memoryUsage();
+    const heapPercent = memory.heapTotal > 0
+      ? (memory.heapUsed / memory.heapTotal) * 100
+      : 0;
+    const overloaded = inFlight >= maxConcurrent || heapPercent >= maxHeapPercent;
+
+    if (overloaded) {
+      res.set('retry-after', String(retryAfterSeconds));
+      res.status(503).json({
+        errors: [{
+          code: 'SERVER_PRESSURE',
+          message: 'Server is temporarily under pressure',
+          request_id: req.id ?? null,
+        }],
+      });
+      return;
+    }
+
+    inFlight += 1;
+    let released = false;
+    const release = () => {
+      if (released) return;
+      released = true;
+      inFlight = Math.max(0, inFlight - 1);
+    };
+    res.once('finish', release);
+    res.once('close', release);
+    next();
+  };
+}

package/src/routes/studio-settings.js

@@ -7,9 +7,25 @@ function settingsService(req) {
   return new Service(serviceOptionsFromRequest(req));
 }
 
+function sendImageAsset(res, asset) {
+  const { file, contents } = asset;
+  res.set('cache-control', 'no-cache, must-revalidate');
+  res.set('content-security-policy', 'sandbox');
+  res.set('content-disposition', 'inline');
+  return res.type(file.mimetype || 'application/octet-stream').send(contents);
+}
+
 export function createStudioSettingsRouter() {
   const router = express.Router();
 
+  router.get('/logo', async (req, res) => {
+    sendImageAsset(res, await settingsService(req).readLogoContent());
+  });
+
+  router.get('/favicon', async (req, res) => {
+    sendImageAsset(res, await settingsService(req).readFaviconContent());
+  });
+
   router.get('/', async (req, res) => {
     res.json({ data: await settingsService(req).readPublic() });
   });

package/src/routes/system-schema.js

@@ -0,0 +1,41 @@
+import express from 'express';
+
+import { serviceOptionsFromRequest } from '../service-options.js';
+
+function service(req, name) {
+  const Service = req.context.services[name];
+  if (!Service) throw new Error(`Service is not registered: ${name}`);
+  return new Service(serviceOptionsFromRequest(req));
+}
+
+export function createSystemSchemaRouter({ schemaCache = null } = {}) {
+  const router = express.Router();
+
+  router.post('/system-collections/:collection/fields', async (req, res) => {
+    const data = await service(req, 'SystemCollectionFieldsService').createOne(
+      req.params.collection,
+      req.body ?? {},
+    );
+    schemaCache?.clear();
+    try {
+      await service(req, 'AuditService').record({
+        action: 'schema.system-field.create',
+        collection: req.params.collection,
+        itemKey: data.field,
+        requestId: req.id,
+        payload: { after: data },
+      });
+    } catch (error) {
+      req.context.logger?.error?.('YunCMS system field audit write failed after committed mutation', {
+        requestId: req.id,
+        collection: req.params.collection,
+        field: data.field,
+        code: error?.code,
+        message: error?.message,
+      });
+    }
+    res.status(201).json({ data });
+  });
+
+  return router;
+}

package/src/server.js

@@ -1,5 +1,6 @@
 import {
   assertDatabaseCompatible,
+  assertMaintenanceStartupAllowed,
   closeDatabasePool,
   createCoreServiceRegistry,
   createDatabasePool,
@@ -10,14 +11,20 @@ import {
   loadConfig,
   loadEnvFileIfPresent,
   LocalStorageDriver,
+  MemoryCacheStore,
   S3StorageDriver,
   SchemaCache,
   SmtpMailer,
 } from '@yunsoft/yuncms-core';
 import { createApp } from './app.js';
+import { INTERNAL_AUDIT_EVENTS } from './audit-events.js';
 import { loadExtensionRuntime } from './extensions/runtime.js';
 
 loadEnvFileIfPresent();
+await assertMaintenanceStartupAllowed({
+  cwd: process.cwd(),
+  env: process.env,
+});
 const config = loadConfig();
 const logger = createJsonLogger({ level: config.logging.level });
 const pool = createDatabasePool(config.database);
@@ -35,6 +42,12 @@ if (config.storage.s3.bucket) {
   });
 }
 const storage = createStorageRegistry(storageDrivers);
+const permissionCache = config.cache.enabled
+  ? new MemoryCacheStore({
+    ttlMs: config.cache.ttlMs,
+    maxEntries: config.cache.maxEntries,
+  })
+  : null;
 
 const hasAnyMailConfig = Boolean(
   config.mail.host || config.mail.from || config.mail.user || config.mail.password,
@@ -59,16 +72,8 @@ let shuttingDown = false;
 function registerInternalAudit({ emitter, services }) {
   const AuditService = services.AuditService;
   const systemAccountability = createSystemAccountability();
-  const events = [
-    'items.create',
-    'items.update',
-    'items.delete',
-    'files.create',
-    'files.update',
-    'files.delete',
-  ];
 
-  for (const event of events) {
+  for (const event of INTERNAL_AUDIT_EVENTS) {
     emitter.registerAction(event, async (payload, context) => {
       try {
         const audit = new AuditService({
@@ -122,6 +127,7 @@ async function start() {
     logger,
     serviceRegistry,
     schemaCache,
+    permissionCache,
     emitter,
     storage,
     mailer,