@yunsoft/yuncms-core 0.1.2 → 0.1.5

package/src/services/studio-settings-service.js

@@ -3,6 +3,11 @@ import { BaseService } from './base-service.js';
 const THEMES = new Set(['system', 'light', 'dark']);
 const LOCALES = new Set(['en', 'tr']);
 const ACCENT_PATTERN = /^#[0-9a-f]{6}$/i;
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const YUNSOFT_LOGOS = new Set([
+  'https://yunsoft.com/light-logo.png',
+  'https://yunsoft.com/dark-logo.png',
+]);
 
 function invalid(message) {
   const error = new Error(message);
@@ -10,6 +15,12 @@ function invalid(message) {
   return error;
 }
 
+function notFound(message) {
+  const error = new Error(message);
+  error.code = 'NOT_FOUND';
+  return error;
+}
+
 function assertManager(accountability) {
   if (accountability.admin === true || accountability.system === true) return;
   const error = new Error('Studio settings require administrator accountability');
@@ -25,16 +36,17 @@ function normalizeBrandName(value) {
 }
 
 function normalizeLogoUrl(value) {
-  if (typeof value !== 'string' || !value.trim()) throw invalid('Logo URL is required');
-  const normalized = value.trim();
-  if (normalized.length > 512) throw invalid('Logo URL cannot exceed 512 characters');
-  let url;
-  try {
-    url = new URL(normalized);
-  } catch {
-    throw invalid('Logo URL must be a valid URL');
+  const normalized = String(value ?? '').trim();
+  if (!YUNSOFT_LOGOS.has(normalized)) {
+    throw invalid('External logo URLs are not supported; choose an image from Files');
   }
-  if (!['http:', 'https:'].includes(url.protocol)) throw invalid('Logo URL must use HTTP or HTTPS');
+  return normalized;
+}
+
+function normalizeImageFile(value, label) {
+  if (value == null || value === '') return null;
+  const normalized = String(value).trim();
+  if (!UUID_PATTERN.test(normalized)) throw invalid(`${label} file id must be a UUID`);
   return normalized;
 }
 
@@ -60,6 +72,8 @@ function publicSettings(row) {
   return {
     brand_name: row.brand_name,
     logo_url: row.logo_url,
+    logo_file: row.logo_file ?? null,
+    favicon_file: row.favicon_file ?? null,
     accent_color: row.accent_color,
     theme: row.theme,
     default_locale: row.default_locale,
@@ -70,7 +84,7 @@ function publicSettings(row) {
 export class StudioSettingsService extends BaseService {
   async readPublic() {
     const [rows] = await this.database.query(
-      `SELECT brand_name, logo_url, accent_color, theme, default_locale, updated_at
+      `SELECT brand_name, logo_url, logo_file, favicon_file, accent_color, theme, default_locale, updated_at
        FROM yuncms_studio_settings
        WHERE id = 1
        LIMIT 1`,
@@ -89,12 +103,56 @@ export class StudioSettingsService extends BaseService {
     return this.readPublic();
   }
 
+  async readImageAssetContent(settingKey, label) {
+    const settings = await this.readPublic();
+    const fileId = settings[settingKey];
+    if (!fileId) throw notFound(`No file-backed Studio ${label.toLowerCase()} is configured`);
+    if (!this.storage) throw new Error(`StudioSettingsService requires storage to read a file-backed ${label.toLowerCase()}`);
+
+    const [rows] = await this.database.query(
+      `SELECT id, storage, filename_disk, mimetype, filesize
+       FROM yuncms_files
+       WHERE id = ?
+       LIMIT 1`,
+      [fileId],
+    );
+    const file = rows[0];
+    if (!file) throw notFound(`Configured Studio ${label.toLowerCase()} file does not exist`);
+    if (!String(file.mimetype || '').toLowerCase().startsWith('image/')) {
+      throw invalid(`Configured Studio ${label.toLowerCase()} must be an image`);
+    }
+
+    const driver = this.storage.get(file.storage);
+    const contents = await driver.get(file.filename_disk);
+    return { file, contents };
+  }
+
+  async readLogoContent() {
+    return this.readImageAssetContent('logo_file', 'Logo');
+  }
+
+  async readFaviconContent() {
+    return this.readImageAssetContent('favicon_file', 'Favicon');
+  }
+
+  async validateSelectedImage(fileId, label) {
+    if (!fileId) return;
+    const [files] = await this.database.query(
+      'SELECT id, mimetype FROM yuncms_files WHERE id = ? LIMIT 1',
+      [fileId],
+    );
+    if (!files[0]) throw invalid(`Selected ${label.toLowerCase()} file does not exist`);
+    if (!String(files[0].mimetype || '').toLowerCase().startsWith('image/')) {
+      throw invalid(`Selected ${label.toLowerCase()} file must be an image`);
+    }
+  }
+
   async updateOne(patch = {}) {
     assertManager(this.accountability);
     if (!patch || typeof patch !== 'object' || Array.isArray(patch)) throw invalid('Studio settings patch must be an object');
 
     const keys = Object.keys(patch);
-    const allowed = new Set(['brand_name', 'logo_url', 'accent_color', 'theme', 'default_locale']);
+    const allowed = new Set(['brand_name', 'logo_url', 'logo_file', 'favicon_file', 'accent_color', 'theme', 'default_locale']);
     if (keys.length === 0 || keys.some((key) => !allowed.has(key))) {
       throw invalid('Studio settings patch contains unsupported properties');
     }
@@ -109,6 +167,18 @@ export class StudioSettingsService extends BaseService {
       assignments.push('logo_url = ?');
       params.push(normalizeLogoUrl(patch.logo_url));
     }
+    if (Object.hasOwn(patch, 'logo_file')) {
+      const fileId = normalizeImageFile(patch.logo_file, 'Logo');
+      await this.validateSelectedImage(fileId, 'Logo');
+      assignments.push('logo_file = ?');
+      params.push(fileId);
+    }
+    if (Object.hasOwn(patch, 'favicon_file')) {
+      const fileId = normalizeImageFile(patch.favicon_file, 'Favicon');
+      await this.validateSelectedImage(fileId, 'Favicon');
+      assignments.push('favicon_file = ?');
+      params.push(fileId);
+    }
     if (Object.hasOwn(patch, 'accent_color')) {
       assignments.push('accent_color = ?');
       params.push(normalizeAccent(patch.accent_color));
@@ -134,6 +204,8 @@ export class StudioSettingsService extends BaseService {
 export const STUDIO_SETTING_DEFAULTS = Object.freeze({
   brand_name: 'YunCMS',
   logo_url: 'https://yunsoft.com/light-logo.png',
+  logo_file: null,
+  favicon_file: null,
   accent_color: '#2563eb',
   theme: 'system',
   default_locale: 'en',

package/src/services/system-collection-fields-service.js

@@ -0,0 +1,122 @@
+import { withAdvisoryLock } from '../advisory-lock.js';
+import { compileFieldColumn } from '../field-types.js';
+import { assertIdentifier, quoteIdentifier } from '../identifier.js';
+import { SchemaMetadataRepository } from '../schema-metadata-repository.js';
+import { resolveSchemaName } from '../schema-key.js';
+import { incrementSchemaVersion } from '../schema-version.js';
+import { isPermissionManagedSystemResource } from '../system-permissions.js';
+import { withConnectionTransaction } from '../transaction.js';
+import { BaseService } from './base-service.js';
+import { assertSchemaManager } from './schema-access.js';
+
+function fieldName(value) {
+  assertIdentifier(value, 'field name');
+  if (value.length > 64) {
+    const error = new Error('Field name cannot exceed 64 characters');
+    error.code = 'INVALID_SCHEMA_PAYLOAD';
+    throw error;
+  }
+  if (value === 'id') {
+    const error = new Error('The id field cannot be replaced');
+    error.code = 'FIELD_EXISTS';
+    throw error;
+  }
+  return value;
+}
+
+function assertExtensibleSystemCollection(collection) {
+  if (!collection?.system || !isPermissionManagedSystemResource(collection)) {
+    const error = new Error(`System collection is not extensible: ${collection?.collection || 'unknown'}`);
+    error.code = 'SYSTEM_SCHEMA_READ_ONLY';
+    throw error;
+  }
+}
+
+function assertSystemExtensionInput(input = {}) {
+  if (input.required === true) {
+    const error = new Error('Custom system collection fields must be optional in V1');
+    error.code = 'SYSTEM_EXTENSION_REQUIRED_UNSUPPORTED';
+    throw error;
+  }
+}
+
+export class SystemCollectionFieldsService extends BaseService {
+  async createOne(collectionName, input = {}) {
+    assertSchemaManager(this.accountability);
+    assertIdentifier(collectionName, 'collection name');
+    assertSystemExtensionInput(input);
+    const resolvedName = resolveSchemaName({
+      displayName: input.name ?? input.field,
+      key: input.field,
+      prefix: 'field',
+    });
+    const field = fieldName(resolvedName.key);
+    const name = resolvedName.name;
+    const compiled = compileFieldColumn({ ...input, required: false });
+
+    return withAdvisoryLock(this.database, 'yuncms:schema', async (connection) => {
+      const metadata = new SchemaMetadataRepository(connection);
+      const collection = await metadata.readCollection(collectionName);
+      if (!collection) {
+        const error = new Error(`Unknown collection: ${collectionName}`);
+        error.code = 'COLLECTION_NOT_FOUND';
+        throw error;
+      }
+      assertExtensibleSystemCollection(collection);
+
+      const existing = await metadata.readField(collectionName, field);
+      if (existing) {
+        const error = new Error(`Field already exists: ${collectionName}.${field}`);
+        error.code = 'FIELD_EXISTS';
+        throw error;
+      }
+
+      const table = quoteIdentifier(collectionName, 'collection name');
+      const column = quoteIdentifier(field, 'field name');
+      let physicalCreated = false;
+
+      try {
+        await connection.query(`ALTER TABLE ${table} ADD COLUMN ${column} ${compiled.sql}`, compiled.params);
+        physicalCreated = true;
+
+        return await withConnectionTransaction(connection, async () => {
+          const created = await metadata.createField({
+            collection: collectionName,
+            field,
+            name,
+            type: input.type,
+            required: false,
+            readonly: input.readonly === true,
+            hidden: input.hidden === true,
+            sort: input.sort ?? null,
+            interface: input.interface ?? null,
+            options: input.options ?? null,
+            schemaMetadata: {
+              ...compiled.schemaMetadata,
+              systemExtension: true,
+            },
+          });
+          const schemaVersion = await incrementSchemaVersion(connection);
+          return { ...created, schemaVersion };
+        });
+      } catch (error) {
+        try {
+          await metadata.deleteField(collectionName, field);
+        } catch (cleanupError) {
+          error.cleanupMetadataError = cleanupError;
+        }
+        if (physicalCreated) {
+          try {
+            await connection.query(`ALTER TABLE ${table} DROP COLUMN ${column}`);
+          } catch (cleanupError) {
+            error.cleanupPhysicalError = cleanupError;
+            error.code ||= 'SCHEMA_PARTIAL_FAILURE';
+          }
+        }
+        throw error;
+      }
+    });
+  }
+}
+
+export { assertExtensibleSystemCollection, assertSystemExtensionInput };

package/src/services/users-service.js

@@ -63,6 +63,13 @@ async function assertRoleAssignable(database, role, accountability) {
   if (targetRole.admin && accountability.admin !== true && accountability.system !== true) {
     throw forbidden('Only an administrator can assign the administrator role');
   }
+  if (
+    accountability.admin !== true
+    && accountability.system !== true
+    && role !== accountability.role
+  ) {
+    throw forbidden('Delegated user managers may assign only their own role');
+  }
 }
 
 async function assertTargetManageable(database, id, accountability) {
@@ -84,6 +91,15 @@ async function assertTargetManageable(database, id, accountability) {
 }
 
 export class UsersService extends BaseService {
+  async action(event, payload) {
+    if (!this.emitter) return;
+    await this.emitter.action(event, payload, {
+      accountability: this.accountability,
+      requestId: this.requestId,
+      collection: 'yuncms_users',
+    });
+  }
+
   async #readOneUnsafe(id) {
     const [rows] = await this.database.query(
       `SELECT id, email, role, status, email_verified_at, last_access, created_at, updated_at
@@ -133,7 +149,9 @@ export class UsersService extends BaseService {
       ],
     );
 
-    return this.#readOneUnsafe(id);
+    const user = await this.#readOneUnsafe(id);
+    await this.action('users.create', { key: id, item: user });
+    return user;
   }
 
   async updateOne(id, patch = {}) {
@@ -163,7 +181,7 @@ export class UsersService extends BaseService {
       await assertRoleAssignable(this.database, patch.role, this.accountability);
     }
 
-    return withTransaction(this.database, async (connection) => {
+    const user = await withTransaction(this.database, async (connection) => {
       const assignments = [];
       const params = [];
 
@@ -202,6 +220,8 @@ export class UsersService extends BaseService {
       );
       return rows[0] ?? null;
     });
+    await this.action('users.update', { key: id, item: user, changes: patch });
+    return user;
   }
 
   async deleteOne(id) {
@@ -212,12 +232,14 @@ export class UsersService extends BaseService {
       error.code = 'SELF_ADMIN_MUTATION_FORBIDDEN';
       throw error;
     }
+    const before = this.emitter ? await this.#readOneUnsafe(id) : null;
     const [result] = await this.database.query('DELETE FROM yuncms_users WHERE id = ?', [id]);
     if (result.affectedRows !== 1) {
       const error = new Error(`Unknown user: ${id}`);
       error.code = 'USER_NOT_FOUND';
       throw error;
     }
+    await this.action('users.delete', { key: id, before });
     return true;
   }
 
@@ -241,7 +263,6 @@ export class UsersService extends BaseService {
       }
       await connection.query('DELETE FROM yuncms_sessions WHERE user = ?', [id]);
       await connection.commit();
-      return true;
     } catch (error) {
       try {
         await connection.rollback();
@@ -252,6 +273,9 @@ export class UsersService extends BaseService {
     } finally {
       connection.release();
     }
+
+    await this.action('users.password.update', { key: id });
+    return true;
   }
 }
 

package/src/system-permissions.js

@@ -1,4 +1,5 @@
 const ALL_ACTIONS = Object.freeze(['read', 'create', 'update', 'delete']);
+const PERMISSION_MODES = new Set(['action-only', 'filter-read']);
 
 function parseMetadata(value) {
   if (value == null) return {};
@@ -14,16 +15,28 @@ function isEnabledFlag(value) {
   return value === true || value === 1;
 }
 
+function advancedUnsupported(collectionSchema, message) {
+  const error = new Error(message ?? `System resource ${collectionSchema.collection} does not support this advanced permission rule`);
+  error.code = 'SYSTEM_PERMISSION_ADVANCED_UNSUPPORTED';
+  throw error;
+}
+
 export function systemPermissionConfig(collectionSchema) {
   if (!collectionSchema?.system) return null;
   const metadata = parseMetadata(collectionSchema.metadata);
   if (!isEnabledFlag(metadata.permissionManaged)) return null;
+  const mode = metadata.permissionMode ?? 'action-only';
+  if (!PERMISSION_MODES.has(mode)) {
+    const error = new Error(`Unsupported system permission mode for ${collectionSchema.collection}: ${mode}`);
+    error.code = 'SYSTEM_PERMISSION_MODE_UNSUPPORTED';
+    throw error;
+  }
   const allowedActions = Array.isArray(metadata.allowedActions)
     ? metadata.allowedActions.filter((action) => ALL_ACTIONS.includes(action))
     : [];
   return Object.freeze({
     resource: metadata.resource ?? collectionSchema.collection,
-    mode: metadata.permissionMode ?? 'action-only',
+    mode,
     allowedActions: Object.freeze([...new Set(allowedActions)]),
   });
 }
@@ -43,12 +56,42 @@ export function assertSystemResourceAction(collectionSchema, action) {
   return config;
 }
 
-export function assertActionOnlyPermissionPayload(collectionSchema, { fields, filter, validation } = {}) {
+export function assertSystemPermissionPayload(
+  collectionSchema,
+  action,
+  { fields, filter, validation } = {},
+) {
   const config = systemPermissionConfig(collectionSchema);
-  if (!config || config.mode !== 'action-only') return;
-  if (fields != null || filter != null || validation != null) {
-    const error = new Error(`System resource ${collectionSchema.collection} supports action-level permissions only`);
-    error.code = 'SYSTEM_PERMISSION_ADVANCED_UNSUPPORTED';
-    throw error;
+  if (!config) return;
+
+  if (config.mode === 'action-only') {
+    if (fields != null || filter != null || validation != null) {
+      advancedUnsupported(
+        collectionSchema,
+        `System resource ${collectionSchema.collection} supports action-level permissions only`,
+      );
+    }
+    return;
   }
+
+  if (config.mode === 'filter-read') {
+    if (fields != null || validation != null) {
+      advancedUnsupported(
+        collectionSchema,
+        `System resource ${collectionSchema.collection} supports only a row filter on read permissions`,
+      );
+    }
+    if (filter != null && action !== 'read') {
+      advancedUnsupported(
+        collectionSchema,
+        `System resource ${collectionSchema.collection} permits row filters only for read`,
+      );
+    }
+  }
+}
+
+export function assertActionOnlyPermissionPayload(collectionSchema, payload = {}) {
+  const config = systemPermissionConfig(collectionSchema);
+  if (!config || config.mode !== 'action-only') return;
+  return assertSystemPermissionPayload(collectionSchema, 'read', payload);
 }