@yunsoft/yuncms-core 0.1.5 → 0.1.6

package/src/mail/smtp-mailer.js

@@ -13,6 +13,25 @@ function assertAddress(value, label) {
   return value.trim();
 }
 
+function normalizeMessage({ to, subject, text, html = undefined } = {}) {
+  const recipient = assertAddress(to, 'Recipient');
+  if (typeof subject !== 'string' || !subject.trim() || /[\r\n]/.test(subject)) {
+    throw mailError('INVALID_MAIL_MESSAGE', 'Mail subject is invalid');
+  }
+  if (typeof text !== 'string' || !text) {
+    throw mailError('INVALID_MAIL_MESSAGE', 'Mail text body is required');
+  }
+  if (html !== undefined && typeof html !== 'string') {
+    throw mailError('INVALID_MAIL_MESSAGE', 'Mail HTML body must be a string');
+  }
+  return {
+    to: recipient,
+    subject: subject.trim(),
+    text,
+    ...(html ? { html } : {}),
+  };
+}
+
 export class SmtpMailer {
   constructor({
     host,
@@ -22,9 +41,11 @@ export class SmtpMailer {
     password = null,
     from,
     transport = null,
+    emitter = null,
   } = {}) {
     if (!transport && (!host || typeof host !== 'string')) throw new Error('SMTP host is required');
     this.from = assertAddress(from, 'SMTP from address');
+    this.emitter = emitter;
     this.transport = transport ?? nodemailer.createTransport({
       host,
       port,
@@ -40,26 +61,49 @@ export class SmtpMailer {
     });
   }
 
+  setEmitter(emitter) {
+    this.emitter = emitter;
+    return this;
+  }
+
   async verify() {
     if (typeof this.transport.verify !== 'function') return true;
     return this.transport.verify();
   }
 
-  async send({ to, subject, text, html = undefined } = {}) {
-    const recipient = assertAddress(to, 'Recipient');
-    if (typeof subject !== 'string' || !subject.trim() || /[\r\n]/.test(subject)) {
-      throw mailError('INVALID_MAIL_MESSAGE', 'Mail subject is invalid');
-    }
-    if (typeof text !== 'string' || !text) {
-      throw mailError('INVALID_MAIL_MESSAGE', 'Mail text body is required');
+  async send(message = {}, context = {}) {
+    let normalized = normalizeMessage(message);
+    if (this.emitter) {
+      normalized = normalizeMessage(await this.emitter.filter('mail.send', normalized, {
+        accountability: context.accountability ?? null,
+        requestId: context.requestId ?? null,
+      }));
     }
 
-    return this.transport.sendMail({
-      from: this.from,
-      to: recipient,
-      subject: subject.trim(),
-      text,
-      ...(html ? { html } : {}),
-    });
+    try {
+      const result = await this.transport.sendMail({
+        from: this.from,
+        ...normalized,
+      });
+      await this.emitter?.action('mail.sent', {
+        to: normalized.to,
+        subject: normalized.subject,
+        messageId: result?.messageId ?? null,
+      }, {
+        accountability: context.accountability ?? null,
+        requestId: context.requestId ?? null,
+      });
+      return result;
+    } catch (error) {
+      await this.emitter?.action('mail.failed', {
+        to: normalized.to,
+        subject: normalized.subject,
+        code: error?.code ?? 'MAIL_DELIVERY_FAILED',
+      }, {
+        accountability: context.accountability ?? null,
+        requestId: context.requestId ?? null,
+      });
+      throw error;
+    }
   }
 }

package/src/migrations/0013-external-auth-foundation.js

@@ -0,0 +1,35 @@
+export const externalAuthFoundationMigration = {
+  id: '0013-external-auth-foundation',
+  statements: [
+    `CREATE TABLE IF NOT EXISTS yuncms_auth_identities (
+      id CHAR(36) NOT NULL PRIMARY KEY,
+      provider VARCHAR(64) NOT NULL,
+      subject VARCHAR(255) NOT NULL,
+      user CHAR(36) NOT NULL,
+      email VARCHAR(191) NULL,
+      profile JSON NULL,
+      last_login_at DATETIME(3) NULL,
+      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),
+      UNIQUE KEY uq_yuncms_auth_identity_provider_subject (provider, subject),
+      KEY idx_yuncms_auth_identity_user (user),
+      CONSTRAINT fk_yuncms_auth_identity_user FOREIGN KEY (user)
+        REFERENCES yuncms_users (id) ON DELETE CASCADE
+    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci`,
+
+    `CREATE TABLE IF NOT EXISTS yuncms_auth_transactions (
+      id CHAR(36) NOT NULL PRIMARY KEY,
+      provider VARCHAR(64) NOT NULL,
+      state_hash CHAR(64) NOT NULL,
+      secret_ciphertext TEXT NULL,
+      redirect_target VARCHAR(512) NULL,
+      metadata JSON NULL,
+      expires_at DATETIME(3) NOT NULL,
+      used_at DATETIME(3) NULL,
+      created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3),
+      UNIQUE KEY uq_yuncms_auth_transaction_state (state_hash),
+      KEY idx_yuncms_auth_transaction_provider_expiry (provider, expires_at),
+      KEY idx_yuncms_auth_transaction_expiry (expires_at)
+    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci`,
+  ],
+};

package/src/query.js

@@ -1,27 +1,34 @@
 import { quoteIdentifier } from './identifier.js';
 
-const QUERY_KEYS = new Set(['fields', 'filter', 'sort', 'limit', 'offset']);
+const QUERY_KEYS = new Set(['fields', 'filter', 'sort', 'limit', 'offset', 'search', 'aggregate', 'groupBy']);
 const FILTER_OPERATORS = new Set([
   '_eq', '_neq', '_lt', '_lte', '_gt', '_gte',
   '_in', '_nin', '_null', '_nnull',
   '_contains', '_starts_with', '_ends_with',
 ]);
+const AGGREGATE_FUNCTIONS = new Set(['count', 'countDistinct', 'sum', 'avg', 'min', 'max']);
+const SEARCHABLE_TYPES = new Set(['string', 'text']);
 
 export const QUERY_LIMITS = Object.freeze({
   defaultLimit: 100,
   maxLimit: 500,
   maxFields: 100,
   maxRelationExpansions: 20,
+  maxRelationDepth: 4,
   maxSortFields: 20,
   maxOffset: 1_000_000,
   maxFilterDepth: 8,
   maxFilterNodes: 100,
   maxInValues: 100,
+  maxSearchLength: 200,
+  maxAggregateFields: 20,
+  maxGroupByFields: 10,
+  maxCost: 2_000,
 });
 
-function queryError(message, path = null) {
+function queryError(message, path = null, code = 'INVALID_QUERY') {
   const error = new Error(message);
-  error.code = 'INVALID_QUERY';
+  error.code = code;
   if (path) error.path = path;
   return error;
 }
@@ -51,45 +58,92 @@ function normalizeFilter(value) {
   if (typeof value === 'string') {
     try {
       const parsed = JSON.parse(value);
-      if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        throw new Error('not an object');
-      }
+      if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) throw new Error('not an object');
       return parsed;
     } catch {
       throw queryError('filter must be a valid JSON object', 'filter');
     }
   }
-  if (typeof value !== 'object' || Array.isArray(value)) {
-    throw queryError('filter must be an object', 'filter');
-  }
+  if (typeof value !== 'object' || Array.isArray(value)) throw queryError('filter must be an object', 'filter');
   return value;
 }
 
+function normalizeSearch(value, limits) {
+  if (value == null || value === '') return null;
+  if (Array.isArray(value) || typeof value === 'object') throw queryError('search must be a string', 'search');
+  const search = String(value).trim();
+  if (!search) return null;
+  if (search.length > limits.maxSearchLength) {
+    throw queryError(`search cannot exceed ${limits.maxSearchLength} characters`, 'search');
+  }
+  return search;
+}
+
+function normalizeAggregate(value, limits) {
+  if (value == null || value === '') return null;
+  let aggregate = value;
+  if (typeof aggregate === 'string') {
+    try { aggregate = JSON.parse(aggregate); } catch { throw queryError('aggregate must be a JSON object', 'aggregate'); }
+  }
+  if (!aggregate || typeof aggregate !== 'object' || Array.isArray(aggregate)) {
+    throw queryError('aggregate must be an object', 'aggregate');
+  }
+
+  const normalized = {};
+  let count = 0;
+  for (const [fn, rawFields] of Object.entries(aggregate)) {
+    if (!AGGREGATE_FUNCTIONS.has(fn)) throw queryError(`Unknown aggregate function: ${fn}`, `aggregate.${fn}`);
+    const fields = normalizeDelimited(rawFields, `aggregate.${fn}`, { maxItems: limits.maxAggregateFields });
+    if (!fields) throw queryError(`aggregate.${fn} cannot be empty`, `aggregate.${fn}`);
+    count += fields.length;
+    if (count > limits.maxAggregateFields) {
+      throw queryError(`aggregate cannot contain more than ${limits.maxAggregateFields} fields`, 'aggregate');
+    }
+    normalized[fn] = fields;
+  }
+  if (Object.keys(normalized).length === 0) throw queryError('aggregate cannot be empty', 'aggregate');
+  return normalized;
+}
+
 export function parseItemsQuery(raw = {}, options = {}) {
   const limits = { ...QUERY_LIMITS, ...options };
-  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
-    throw queryError('Query must be an object');
-  }
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw queryError('Query must be an object');
 
   for (const key of Object.keys(raw)) {
     if (!QUERY_KEYS.has(key)) throw queryError(`Unknown query parameter: ${key}`, key);
   }
 
-  return {
+  const query = {
     fields: normalizeDelimited(raw.fields, 'fields', { maxItems: limits.maxFields }),
     filter: normalizeFilter(raw.filter),
     sort: normalizeDelimited(raw.sort, 'sort', { maxItems: limits.maxSortFields }),
-    limit: normalizeInteger(raw.limit, limits.defaultLimit, {
-      label: 'limit',
-      min: 1,
-      max: limits.maxLimit,
-    }),
-    offset: normalizeInteger(raw.offset, 0, {
-      label: 'offset',
-      min: 0,
-      max: limits.maxOffset,
-    }),
+    limit: normalizeInteger(raw.limit, limits.defaultLimit, { label: 'limit', min: 1, max: limits.maxLimit }),
+    offset: normalizeInteger(raw.offset, 0, { label: 'offset', min: 0, max: limits.maxOffset }),
+    search: normalizeSearch(raw.search, limits),
+    aggregate: normalizeAggregate(raw.aggregate, limits),
+    groupBy: normalizeDelimited(raw.groupBy, 'groupBy', { maxItems: limits.maxGroupByFields }),
   };
+
+  if (query.groupBy && !query.aggregate) throw queryError('groupBy requires aggregate', 'groupBy');
+  return Object.freeze(query);
+}
+
+export function queryCost(query, { relationDepth = 0, relationCount = 0 } = {}) {
+  let cost = 1 + Number(query?.limit ?? QUERY_LIMITS.defaultLimit);
+  cost += (query?.fields?.length ?? 0) * 2;
+  cost += (query?.sort?.length ?? 0) * 5;
+  cost += relationCount * 50;
+  cost += relationDepth * 100;
+  if (query?.search) cost += 100;
+  if (query?.aggregate) cost += 250 + Object.values(query.aggregate).flat().length * 25;
+  return cost;
+}
+
+export function assertQueryCost(query, options = {}) {
+  const maxCost = options.maxCost ?? QUERY_LIMITS.maxCost;
+  const cost = queryCost(query, options);
+  if (cost > maxCost) throw queryError(`Query cost ${cost} exceeds limit ${maxCost}`, null, 'QUERY_COST_LIMIT');
+  return cost;
 }
 
 function resolveField(schema, field, path = field) {
@@ -100,7 +154,6 @@ function resolveField(schema, field, path = field) {
 export function compileSelectFields(fields, schema) {
   const selected = !fields || fields.includes('*') ? Object.keys(schema.fields) : fields;
   if (selected.length === 0) throw queryError('At least one field must be selected', 'fields');
-
   const unique = [...new Set(selected)];
   return {
     fields: unique,
@@ -113,7 +166,6 @@ export function compileSelectFields(fields, schema) {
 
 export function compileSort(sort, schema) {
   if (!sort) return '';
-
   const parts = sort.map((entry, index) => {
     const descending = entry.startsWith('-');
     const field = descending ? entry.slice(1) : entry;
@@ -121,7 +173,6 @@ export function compileSort(sort, schema) {
     resolveField(schema, field, `sort.${index}`);
     return `${quoteIdentifier(field, 'field name')} ${descending ? 'DESC' : 'ASC'}`;
   });
-
   return parts.length ? ` ORDER BY ${parts.join(', ')}` : '';
 }
 
@@ -129,9 +180,49 @@ function escapeLike(value) {
   return String(value).replace(/[\\%_]/g, '\\$&');
 }
 
+export function compileSearch(search, schema) {
+  if (!search) return { sql: '', params: [] };
+  const fields = Object.entries(schema?.fields ?? {})
+    .filter(([, field]) => SEARCHABLE_TYPES.has(field.type))
+    .map(([name]) => name);
+  if (fields.length === 0) return { sql: ' WHERE 0 = 1', params: [] };
+  const needle = `%${escapeLike(search)}%`;
+  return {
+    sql: ` WHERE (${fields.map((field) => `${quoteIdentifier(field, 'field name')} LIKE ? ESCAPE '\\\\'`).join(' OR ')})`,
+    params: fields.map(() => needle),
+  };
+}
+
+export function compileAggregate(aggregate, groupBy, schema) {
+  if (!aggregate) return null;
+  const groups = groupBy ?? [];
+  for (const field of groups) resolveField(schema, field, `groupBy.${field}`);
+  const selections = groups.map((field) => quoteIdentifier(field, 'field name'));
+  const aliases = new Set(groups);
+
+  for (const [fn, fields] of Object.entries(aggregate)) {
+    for (const field of fields) {
+      if (field === '*' && fn !== 'count') throw queryError(`${fn} does not support *`, `aggregate.${fn}`);
+      if (field !== '*') resolveField(schema, field, `aggregate.${fn}.${field}`);
+      const column = field === '*' ? '*' : quoteIdentifier(field, 'field name');
+      const sqlFn = fn === 'countDistinct' ? 'COUNT' : fn.toUpperCase();
+      const expression = fn === 'countDistinct' ? `${sqlFn}(DISTINCT ${column})` : `${sqlFn}(${column})`;
+      const rawAlias = field === '*' ? fn : `${fn}_${field}`;
+      let alias = rawAlias;
+      let suffix = 2;
+      while (aliases.has(alias)) alias = `${rawAlias}_${suffix++}`;
+      aliases.add(alias);
+      selections.push(`${expression} AS ${quoteIdentifier(alias, 'aggregate alias')}`);
+    }
+  }
+  return {
+    sql: selections.join(', '),
+    groupSql: groups.length ? ` GROUP BY ${groups.map((field) => quoteIdentifier(field, 'field name')).join(', ')}` : '',
+  };
+}
+
 function compileOperator(fieldSql, operator, value, path, limits) {
   if (!FILTER_OPERATORS.has(operator)) throw queryError(`Unknown filter operator: ${operator}`, path);
-
   switch (operator) {
     case '_eq':
       if (value === null) throw queryError('Use _null for NULL comparisons', path);
@@ -146,15 +237,10 @@ function compileOperator(fieldSql, operator, value, path, limits) {
     case '_in':
     case '_nin': {
       if (!Array.isArray(value)) throw queryError(`${operator} requires an array`, path);
-      if (value.length > limits.maxInValues) {
-        throw queryError(`${operator} accepts at most ${limits.maxInValues} values`, path);
-      }
+      if (value.length > limits.maxInValues) throw queryError(`${operator} accepts at most ${limits.maxInValues} values`, path);
       if (value.length === 0) return { sql: operator === '_in' ? '0 = 1' : '1 = 1', params: [] };
       const placeholders = value.map(() => '?').join(', ');
-      return {
-        sql: `${fieldSql} ${operator === '_in' ? 'IN' : 'NOT IN'} (${placeholders})`,
-        params: value,
-      };
+      return { sql: `${fieldSql} ${operator === '_in' ? 'IN' : 'NOT IN'} (${placeholders})`, params: value };
     }
     case '_null':
     case '_nnull': {
@@ -162,67 +248,41 @@ function compileOperator(fieldSql, operator, value, path, limits) {
       const wantsNull = operator === '_null' ? value : !value;
       return { sql: `${fieldSql} IS ${wantsNull ? '' : 'NOT '}NULL`, params: [] };
     }
-    case '_contains':
-      return { sql: `${fieldSql} LIKE ? ESCAPE '\\\\'`, params: [`%${escapeLike(value)}%`] };
-    case '_starts_with':
-      return { sql: `${fieldSql} LIKE ? ESCAPE '\\\\'`, params: [`${escapeLike(value)}%`] };
-    case '_ends_with':
-      return { sql: `${fieldSql} LIKE ? ESCAPE '\\\\'`, params: [`%${escapeLike(value)}`] };
-    default:
-      throw queryError(`Unknown filter operator: ${operator}`, path);
+    case '_contains': return { sql: `${fieldSql} LIKE ? ESCAPE '\\\\'`, params: [`%${escapeLike(value)}%`] };
+    case '_starts_with': return { sql: `${fieldSql} LIKE ? ESCAPE '\\\\'`, params: [`${escapeLike(value)}%`] };
+    case '_ends_with': return { sql: `${fieldSql} LIKE ? ESCAPE '\\\\'`, params: [`%${escapeLike(value)}`] };
+    default: throw queryError(`Unknown filter operator: ${operator}`, path);
   }
 }
 
 function compileFilterObject(filter, schema, path, limits, state, depth) {
-  if (!filter || typeof filter !== 'object' || Array.isArray(filter)) {
-    throw queryError('Filter node must be an object', path);
-  }
-  if (depth > limits.maxFilterDepth) {
-    throw queryError(`Filter depth cannot exceed ${limits.maxFilterDepth}`, path);
-  }
-
+  if (!filter || typeof filter !== 'object' || Array.isArray(filter)) throw queryError('Filter node must be an object', path);
+  if (depth > limits.maxFilterDepth) throw queryError(`Filter depth cannot exceed ${limits.maxFilterDepth}`, path);
   state.nodes += 1;
-  if (state.nodes > limits.maxFilterNodes) {
-    throw queryError(`Filter cannot contain more than ${limits.maxFilterNodes} nodes`, path);
-  }
+  if (state.nodes > limits.maxFilterNodes) throw queryError(`Filter cannot contain more than ${limits.maxFilterNodes} nodes`, path);
 
   const fragments = [];
   const params = [];
-
   for (const [key, value] of Object.entries(filter)) {
     if (key === '_and' || key === '_or') {
-      if (!Array.isArray(value) || value.length === 0) {
-        throw queryError(`${key} requires a non-empty array`, `${path}.${key}`);
-      }
-      const children = value.map((child, index) =>
-        compileFilterObject(child, schema, `${path}.${key}.${index}`, limits, state, depth + 1));
+      if (!Array.isArray(value) || value.length === 0) throw queryError(`${key} requires a non-empty array`, `${path}.${key}`);
+      const children = value.map((child, index) => compileFilterObject(child, schema, `${path}.${key}.${index}`, limits, state, depth + 1));
       fragments.push(`(${children.map((child) => child.sql).join(key === '_and' ? ' AND ' : ' OR ')})`);
       for (const child of children) params.push(...child.params);
       continue;
     }
-
     resolveField(schema, key, `${path}.${key}`);
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-      throw queryError('Field filters must be operator objects', `${path}.${key}`);
-    }
-
+    if (!value || typeof value !== 'object' || Array.isArray(value)) throw queryError('Field filters must be operator objects', `${path}.${key}`);
     const fieldSql = quoteIdentifier(key, 'field name');
     const fieldFragments = [];
     for (const [operator, operatorValue] of Object.entries(value)) {
-      const compiled = compileOperator(
-        fieldSql,
-        operator,
-        operatorValue,
-        `${path}.${key}.${operator}`,
-        limits,
-      );
+      const compiled = compileOperator(fieldSql, operator, operatorValue, `${path}.${key}.${operator}`, limits);
       fieldFragments.push(compiled.sql);
       params.push(...compiled.params);
     }
     if (fieldFragments.length === 0) throw queryError('Field filter cannot be empty', `${path}.${key}`);
     fragments.push(`(${fieldFragments.join(' AND ')})`);
   }
-
   if (fragments.length === 0) throw queryError('Filter cannot be empty', path);
   return { sql: fragments.join(' AND '), params };
 }