@yunsoft/yuncms-core 0.1.8 → 0.1.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yunsoft/yuncms-core",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Core services, schema, authentication, permissions and storage primitives for YunCMS.",
   "license": "MIT",
   "type": "module",

package/src/bootstrap.js

@@ -13,6 +13,9 @@ import { studioFaviconFileMigration } from './migrations/0010-studio-favicon-fil
 import { rolePermissionActionsMigration } from './migrations/0011-role-permission-actions.js';
 import { filesReadFiltersMigration } from './migrations/0012-files-read-filters.js';
 import { externalAuthFoundationMigration } from './migrations/0013-external-auth-foundation.js';
+import { aiSettingsMigration } from './migrations/0014-ai-settings.js';
+import { navigationGroupsMigration } from './migrations/0015-navigation-groups.js';
+import { navigationGroupCollapseMigration } from './migrations/0016-navigation-group-collapse.js';
 import { readSchemaVersion } from './schema-version.js';
 import { ensurePublicRole } from './setup.js';
 
@@ -30,6 +33,9 @@ export const CORE_MIGRATIONS = Object.freeze([
   rolePermissionActionsMigration,
   filesReadFiltersMigration,
   externalAuthFoundationMigration,
+  aiSettingsMigration,
+  navigationGroupsMigration,
+  navigationGroupCollapseMigration,
 ]);
 
 export const REQUIRED_CORE_MIGRATION_IDS = Object.freeze(

package/src/index.js

@@ -57,8 +57,10 @@ export { AuthTokensService } from './services/auth-tokens-service.js';
 export { ExternalAuthService, AUTH_TRANSACTION_TTL_MS } from './services/external-auth-service.js';
 export { ApiTokensService } from './services/api-tokens-service.js';
 export { AuditService, redactAuditValue } from './services/audit-service.js';
-export { ItemsService } from './services/items-service.js';
-export { CollectionsService } from './services/collections-service.js';
+export {
+  SingletonItemsService as ItemsService,
+  SingletonCollectionsService as CollectionsService,
+} from './services/singleton-services.js';
 export { FieldsService } from './services/fields-service.js';
 export { SystemCollectionFieldsService } from './services/system-collection-fields-service.js';
 export { RelationsService } from './services/relations-service.js';
@@ -68,6 +70,7 @@ export { PermissionsService } from './services/permissions-service.js';
 export { FilesService } from './services/files-service.js';
 export { FileReconciliationService } from './services/file-reconciliation-service.js';
 export { StudioSettingsService, STUDIO_SETTING_DEFAULTS } from './services/studio-settings-service.js';
+export { NavigationGroupsService } from './services/navigation-groups-service.js';
 export { SchemaMetadataRepository } from './schema-metadata-repository.js';
 export { loadSchemaSnapshot, SchemaCache } from './schema.js';
 export { assertFieldType, compileFieldColumn } from './field-types.js';

package/src/migrations/0014-ai-settings.js

@@ -0,0 +1,23 @@
+export const aiSettingsMigration = Object.freeze({
+  id: '0014-ai-settings',
+  statements: [
+    `CREATE TABLE yuncms_ai_settings (
+      id TINYINT UNSIGNED NOT NULL PRIMARY KEY,
+      enabled TINYINT(1) NOT NULL DEFAULT 0,
+      base_url VARCHAR(2048) NOT NULL DEFAULT 'https://api.openai.com/v1',
+      model VARCHAR(200) NULL,
+      api_key_ciphertext TEXT NULL,
+      writes_enabled TINYINT(1) NOT NULL DEFAULT 0,
+      max_tool_rounds INT UNSIGNED NOT NULL DEFAULT 6,
+      max_tool_calls_per_round INT UNSIGNED NOT NULL DEFAULT 8,
+      max_history INT UNSIGNED NOT NULL DEFAULT 20,
+      max_message_chars INT UNSIGNED NOT NULL DEFAULT 12000,
+      max_tool_result_bytes INT UNSIGNED NOT NULL DEFAULT 250000,
+      max_output_tokens INT UNSIGNED NOT NULL DEFAULT 1500,
+      timeout_ms INT UNSIGNED NOT NULL DEFAULT 60000,
+      updated_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3),
+      CONSTRAINT chk_yuncms_ai_settings_singleton CHECK (id = 1)
+    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci`,
+    `INSERT INTO yuncms_ai_settings (id) VALUES (1)`,
+  ],
+});

package/src/migrations/0015-navigation-groups.js

@@ -0,0 +1,13 @@
+export const navigationGroupsMigration = Object.freeze({
+  id: '0015-navigation-groups',
+  statements: [
+    `CREATE TABLE yuncms_navigation_groups (
+      id CHAR(36) NOT NULL PRIMARY KEY,
+      name VARCHAR(100) NOT NULL,
+      sort INT NOT NULL DEFAULT 0,
+      created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3),
+      updated_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3),
+      INDEX idx_yuncms_navigation_groups_sort (sort, name)
+    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci`,
+  ],
+});

package/src/migrations/0016-navigation-group-collapse.js

@@ -0,0 +1,7 @@
+export const navigationGroupCollapseMigration = Object.freeze({
+  id: '0016-navigation-group-collapse',
+  statements: [
+    `ALTER TABLE yuncms_navigation_groups
+       ADD COLUMN collapse VARCHAR(16) NOT NULL DEFAULT 'open' AFTER sort`,
+  ],
+});

package/src/services/core-services.js

@@ -2,15 +2,15 @@ import { ApiTokensService } from './api-tokens-service.js';
 import { AuditService } from './audit-service.js';
 import { AuthService } from './auth-service.js';
 import { AuthTokensService } from './auth-tokens-service.js';
-import { CollectionsService } from './collections-service.js';
 import { ExternalAuthService } from './external-auth-service.js';
 import { FieldsService } from './fields-service.js';
 import { FileReconciliationService } from './file-reconciliation-service.js';
 import { FilesService } from './files-service.js';
-import { ItemsService } from './items-service.js';
+import { NavigationGroupsService } from './navigation-groups-service.js';
 import { PermissionsService } from './permissions-service.js';
 import { RelationsService } from './relations-service.js';
 import { RolesService } from './roles-service.js';
+import { SingletonCollectionsService, SingletonItemsService } from './singleton-services.js';
 import { StudioSettingsService } from './studio-settings-service.js';
 import { SystemCollectionFieldsService } from './system-collection-fields-service.js';
 import { UsersService } from './users-service.js';
@@ -23,8 +23,8 @@ export function createCoreServiceRegistry() {
     ExternalAuthService,
     ApiTokensService,
     AuditService,
-    ItemsService,
-    CollectionsService,
+    ItemsService: SingletonItemsService,
+    CollectionsService: SingletonCollectionsService,
     FieldsService,
     SystemCollectionFieldsService,
     RelationsService,
@@ -34,5 +34,6 @@ export function createCoreServiceRegistry() {
     FilesService,
     FileReconciliationService,
     StudioSettingsService,
+    NavigationGroupsService,
   });
 }

package/src/services/navigation-groups-service.js

@@ -0,0 +1,136 @@
+import { randomUUID } from 'node:crypto';
+
+import { incrementSchemaVersion } from '../schema-version.js';
+import { withTransaction } from '../transaction.js';
+import { BaseService } from './base-service.js';
+import { assertSchemaManager } from './schema-access.js';
+
+function invalid(message) {
+  const error = new Error(message);
+  error.code = 'INVALID_PAYLOAD';
+  return error;
+}
+
+function notFound(id) {
+  const error = new Error(`Unknown navigation group: ${id}`);
+  error.code = 'NAVIGATION_GROUP_NOT_FOUND';
+  return error;
+}
+
+function normalizeName(value) {
+  if (typeof value !== 'string' || !value.trim()) throw invalid('Navigation group name is required');
+  const name = value.trim();
+  if (name.length > 100) throw invalid('Navigation group name cannot exceed 100 characters');
+  return name;
+}
+
+function normalizeSort(value, fallback = 0) {
+  if (value == null || value === '') return fallback;
+  const sort = Number(value);
+  if (!Number.isInteger(sort) || sort < -1_000_000 || sort > 1_000_000) {
+    throw invalid('Navigation group sort must be an integer between -1000000 and 1000000');
+  }
+  return sort;
+}
+
+function normalizeCollapse(value, fallback = 'open') {
+  if (value == null || value === '') return fallback;
+  const collapse = String(value).trim().toLowerCase();
+  if (!['open', 'closed', 'locked'].includes(collapse)) {
+    throw invalid('Navigation group collapse must be open, closed or locked');
+  }
+  return collapse;
+}
+
+export class NavigationGroupsService extends BaseService {
+  async readMany() {
+    const [rows] = await this.database.query(
+      `SELECT id, name, sort, collapse, created_at, updated_at
+       FROM yuncms_navigation_groups
+       ORDER BY sort ASC, name ASC, id ASC`,
+    );
+    return rows;
+  }
+
+  async readOne(id) {
+    const [rows] = await this.database.query(
+      `SELECT id, name, sort, collapse, created_at, updated_at
+       FROM yuncms_navigation_groups
+       WHERE id = ?
+       LIMIT 1`,
+      [String(id ?? '')],
+    );
+    return rows[0] ?? null;
+  }
+
+  async createOne(input = {}) {
+    assertSchemaManager(this.accountability);
+    const id = randomUUID();
+    const name = normalizeName(input.name);
+    const sort = normalizeSort(input.sort, 0);
+    const collapse = normalizeCollapse(input.collapse);
+    await this.database.query(
+      'INSERT INTO yuncms_navigation_groups (id, name, sort, collapse) VALUES (?, ?, ?, ?)',
+      [id, name, sort, collapse],
+    );
+    return this.readOne(id);
+  }
+
+  async updateOne(id, patch = {}) {
+    assertSchemaManager(this.accountability);
+    if (!patch || typeof patch !== 'object' || Array.isArray(patch)) throw invalid('Navigation group patch must be an object');
+    const keys = Object.keys(patch);
+    if (keys.length === 0 || keys.some((key) => !['name', 'sort', 'collapse'].includes(key))) {
+      throw invalid('Navigation group patch contains unsupported properties');
+    }
+    const assignments = [];
+    const params = [];
+    if (Object.hasOwn(patch, 'name')) {
+      assignments.push('name = ?');
+      params.push(normalizeName(patch.name));
+    }
+    if (Object.hasOwn(patch, 'sort')) {
+      assignments.push('sort = ?');
+      params.push(normalizeSort(patch.sort));
+    }
+    if (Object.hasOwn(patch, 'collapse')) {
+      assignments.push('collapse = ?');
+      params.push(normalizeCollapse(patch.collapse));
+    }
+    params.push(String(id ?? ''));
+    const [result] = await this.database.query(
+      `UPDATE yuncms_navigation_groups SET ${assignments.join(', ')} WHERE id = ?`,
+      params,
+    );
+    if (!result.affectedRows && !await this.readOne(id)) throw notFound(id);
+    return this.readOne(id);
+  }
+
+  async deleteOne(id) {
+    assertSchemaManager(this.accountability);
+    const groupId = String(id ?? '');
+    return withTransaction(this.database, async (connection) => {
+      const [existing] = await connection.query(
+        'SELECT id FROM yuncms_navigation_groups WHERE id = ? LIMIT 1',
+        [groupId],
+      );
+      if (!existing[0]) throw notFound(groupId);
+      const [cleanup] = await connection.query(
+        `UPDATE yuncms_collections
+         SET metadata = JSON_REMOVE(metadata, '$.group')
+         WHERE metadata IS NOT NULL
+           AND JSON_UNQUOTE(JSON_EXTRACT(metadata, '$.group')) = ?`,
+        [groupId],
+      );
+      await connection.query('DELETE FROM yuncms_navigation_groups WHERE id = ?', [groupId]);
+      if (Number(cleanup.affectedRows ?? 0) > 0) await incrementSchemaVersion(connection);
+      return { deleted: true, id: groupId };
+    });
+  }
+}
+
+export {
+  normalizeCollapse as normalizeNavigationGroupCollapse,
+  normalizeName as normalizeNavigationGroupName,
+  normalizeSort as normalizeNavigationGroupSort,
+};

package/src/services/singleton-services.js

@@ -0,0 +1,80 @@
+import { createHash } from 'node:crypto';
+
+import { withAdvisoryLock } from '../advisory-lock.js';
+import { quoteIdentifier } from '../identifier.js';
+import { CollectionsService } from './collections-service.js';
+import { ItemsService } from './items-service.js';
+
+function singletonError(code, message) {
+  const error = new Error(message);
+  error.code = code;
+  return error;
+}
+
+function singletonLockName(collection) {
+  const digest = createHash('sha256').update(String(collection)).digest('hex').slice(0, 40);
+  return `yuncms:singleton:${digest}`;
+}
+
+async function assertSingletonVacant(database, collection, schema) {
+  if (!schema?.singleton) return;
+  const table = quoteIdentifier(collection, 'collection name');
+  const [rows] = await database.query(`SELECT 1 AS present FROM ${table} LIMIT 1`);
+  if (rows[0]) {
+    throw singletonError('SINGLETON_ITEM_EXISTS', `Singleton collection already contains an item: ${collection}`);
+  }
+}
+
+export class SingletonItemsService extends ItemsService {
+  async createOne(payload = {}) {
+    const schema = await this.getCollectionSchema();
+    if (!schema.singleton) return super.createOne(payload);
+    return withAdvisoryLock(
+      this.database,
+      singletonLockName(this.collection),
+      async (connection) => {
+        await assertSingletonVacant(connection, this.collection, schema);
+        return super.createOne(payload);
+      },
+      { timeoutSeconds: 10 },
+    );
+  }
+
+  async createMany(payloads = []) {
+    const schema = await this.getCollectionSchema();
+    if (!schema.singleton) return super.createMany(payloads);
+    if (!Array.isArray(payloads) || payloads.length !== 1) {
+      throw singletonError('SINGLETON_BULK_CREATE_FORBIDDEN', 'Singleton collections accept exactly one create payload');
+    }
+    return withAdvisoryLock(
+      this.database,
+      singletonLockName(this.collection),
+      async (connection) => {
+        await assertSingletonVacant(connection, this.collection, schema);
+        return super.createMany(payloads);
+      },
+      { timeoutSeconds: 10 },
+    );
+  }
+}
+
+export class SingletonCollectionsService extends CollectionsService {
+  async updateOne(collection, patch) {
+    if (patch?.singleton === true) {
+      const existing = await this.readOne(collection);
+      if (existing && !existing.singleton && !existing.system) {
+        const table = quoteIdentifier(collection, 'collection name');
+        const [rows] = await this.database.query(`SELECT COUNT(*) AS count FROM ${table}`);
+        if (Number(rows?.[0]?.count ?? 0) > 1) {
+          throw singletonError(
+            'SINGLETON_MULTIPLE_ITEMS',
+            'A collection with more than one item cannot be converted to singleton',
+          );
+        }
+      }
+    }
+    return super.updateOne(collection, patch);
+  }
+}
+
+export { assertSingletonVacant, singletonLockName };