@yunsoft/yuncms-core 0.1.2 → 0.1.5

package/src/query.js

@@ -7,6 +7,18 @@ const FILTER_OPERATORS = new Set([
   '_contains', '_starts_with', '_ends_with',
 ]);
 
+export const QUERY_LIMITS = Object.freeze({
+  defaultLimit: 100,
+  maxLimit: 500,
+  maxFields: 100,
+  maxRelationExpansions: 20,
+  maxSortFields: 20,
+  maxOffset: 1_000_000,
+  maxFilterDepth: 8,
+  maxFilterNodes: 100,
+  maxInValues: 100,
+});
+
 function queryError(message, path = null) {
   const error = new Error(message);
   error.code = 'INVALID_QUERY';
@@ -14,11 +26,14 @@ function queryError(message, path = null) {
   return error;
 }
 
-function normalizeDelimited(value, label) {
+function normalizeDelimited(value, label, { maxItems }) {
   if (value == null || value === '') return null;
   const values = Array.isArray(value) ? value : String(value).split(',');
   const normalized = values.map((item) => String(item).trim()).filter(Boolean);
   if (normalized.length === 0) throw queryError(`${label} cannot be empty`, label);
+  if (normalized.length > maxItems) {
+    throw queryError(`${label} cannot contain more than ${maxItems} entries`, label);
+  }
   return normalized;
 }
 
@@ -50,7 +65,8 @@ function normalizeFilter(value) {
   return value;
 }
 
-export function parseItemsQuery(raw = {}, { defaultLimit = 100, maxLimit = 500 } = {}) {
+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');
   }
@@ -60,11 +76,19 @@ export function parseItemsQuery(raw = {}, { defaultLimit = 100, maxLimit = 500 }
   }
 
   return {
-    fields: normalizeDelimited(raw.fields, 'fields'),
+    fields: normalizeDelimited(raw.fields, 'fields', { maxItems: limits.maxFields }),
     filter: normalizeFilter(raw.filter),
-    sort: normalizeDelimited(raw.sort, 'sort'),
-    limit: normalizeInteger(raw.limit, defaultLimit, { label: 'limit', min: 1, max: maxLimit }),
-    offset: normalizeInteger(raw.offset, 0, { label: 'offset', min: 0, max: Number.MAX_SAFE_INTEGER }),
+    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,
+    }),
   };
 }
 
@@ -105,7 +129,7 @@ function escapeLike(value) {
   return String(value).replace(/[\\%_]/g, '\\$&');
 }
 
-function compileOperator(fieldSql, operator, value, path) {
+function compileOperator(fieldSql, operator, value, path, limits) {
   if (!FILTER_OPERATORS.has(operator)) throw queryError(`Unknown filter operator: ${operator}`, path);
 
   switch (operator) {
@@ -122,6 +146,9 @@ function compileOperator(fieldSql, operator, value, path) {
     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 === 0) return { sql: operator === '_in' ? '0 = 1' : '1 = 1', params: [] };
       const placeholders = value.map(() => '?').join(', ');
       return {
@@ -146,10 +173,18 @@ function compileOperator(fieldSql, operator, value, path) {
   }
 }
 
-function compileFilterObject(filter, schema, path = 'filter') {
+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);
+  }
+
+  state.nodes += 1;
+  if (state.nodes > limits.maxFilterNodes) {
+    throw queryError(`Filter cannot contain more than ${limits.maxFilterNodes} nodes`, path);
+  }
 
   const fragments = [];
   const params = [];
@@ -160,7 +195,7 @@ function compileFilterObject(filter, schema, path = 'filter') {
         throw queryError(`${key} requires a non-empty array`, `${path}.${key}`);
       }
       const children = value.map((child, index) =>
-        compileFilterObject(child, schema, `${path}.${key}.${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;
@@ -174,7 +209,13 @@ function compileFilterObject(filter, schema, path = 'filter') {
     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}`);
+      const compiled = compileOperator(
+        fieldSql,
+        operator,
+        operatorValue,
+        `${path}.${key}.${operator}`,
+        limits,
+      );
       fieldFragments.push(compiled.sql);
       params.push(...compiled.params);
     }
@@ -186,8 +227,9 @@ function compileFilterObject(filter, schema, path = 'filter') {
   return { sql: fragments.join(' AND '), params };
 }
 
-export function compileFilter(filter, schema) {
+export function compileFilter(filter, schema, options = {}) {
   if (!filter) return { sql: '', params: [] };
-  const compiled = compileFilterObject(filter, schema);
+  const limits = { ...QUERY_LIMITS, ...options };
+  const compiled = compileFilterObject(filter, schema, 'filter', limits, { nodes: 0 }, 1);
   return { sql: ` WHERE ${compiled.sql}`, params: compiled.params };
 }

package/src/relation-expansion.js

@@ -1,8 +1,9 @@
 import { assertIdentifier } from './identifier.js';
+import { QUERY_LIMITS } from './query.js';
 import { SchemaCache } from './schema.js';
 import { ItemsService } from './services/items-service.js';
 
-const MAX_EXPAND_FIELDS = 8;
+export const MAX_EXPAND_FIELDS = QUERY_LIMITS.maxRelationExpansions;
 const defaultSchemaCache = new SchemaCache();
 
 function expansionError(code, message, path = null) {
@@ -18,16 +19,24 @@ function normalizeDelimited(value) {
   return values.map((entry) => String(entry).trim()).filter(Boolean);
 }
 
+function assertFieldToken(field, path) {
+  try {
+    assertIdentifier(field, 'field');
+  } catch {
+    throw expansionError('INVALID_QUERY', `Invalid field: ${field}`, path);
+  }
+  return field;
+}
+
 export function parseExpandInput(value) {
   const fields = [...new Set(normalizeDelimited(value))];
   if (fields.length > MAX_EXPAND_FIELDS) {
     throw expansionError(
       'INVALID_QUERY',
-      `expand supports at most ${MAX_EXPAND_FIELDS} direct relation fields`,
+      `expand cannot contain more than ${MAX_EXPAND_FIELDS} entries`,
       'expand',
     );
   }
-
   for (const field of fields) {
     try {
       assertIdentifier(field, 'expand field');
@@ -47,73 +56,199 @@ function parseRelationMetadata(value) {
   }
 }
 
-function withExpansionFields(rawFields, expandFields) {
-  if (rawFields == null || rawFields === '') return rawFields;
-  const selected = normalizeDelimited(rawFields);
-  if (selected.includes('*')) return selected;
-  return [...new Set([...selected, ...expandFields])];
-}
-
-function withoutExpand(query = {}, expandFields = []) {
-  const base = { ...query };
-  delete base.expand;
-  if (expandFields.length > 0 && Object.hasOwn(base, 'fields')) {
-    base.fields = withExpansionFields(base.fields, expandFields);
-  }
-  return base;
-}
-
 async function schemaSnapshot(options) {
   if (options.schema) return options.schema;
   const cache = options.schemaCache ?? defaultSchemaCache;
   return cache.get(options.database);
 }
 
-function directRelation(snapshot, collection, field) {
-  const relation = snapshot.relationByManyField?.get(`${collection}.${field}`);
+function relationFromSnapshot(snapshot, collection, field) {
+  return snapshot.relationByManyField?.get(`${collection}.${field}`) ?? null;
+}
+
+function isDirectRelation(relation) {
+  if (!relation) return false;
+  const metadata = parseRelationMetadata(relation.metadata);
+  return !relation.junction_collection && metadata.kind !== 'm2m';
+}
+
+function directRelation(snapshot, collection, field, path = `fields.${field}`) {
+  const relation = relationFromSnapshot(snapshot, collection, field);
   if (!relation) {
     throw expansionError(
       'INVALID_QUERY',
       `Field is not a direct relation and cannot be expanded: ${collection}.${field}`,
-      `expand.${field}`,
+      path,
     );
   }
 
-  const metadata = parseRelationMetadata(relation.metadata);
-  if (relation.junction_collection || metadata.kind === 'm2m') {
+  if (!isDirectRelation(relation)) {
     throw expansionError(
       'UNSUPPORTED_RELATION_EXPANSION',
-      `Only direct M2O fields can be expanded in V1: ${collection}.${field}`,
-      `expand.${field}`,
+      `Only direct M2O/O2O fields can be expanded: ${collection}.${field}`,
+      path,
     );
   }
   return relation;
 }
 
-async function validateSourceExpansions({ collection, expandFields, options, service }) {
+function readableSourceField(sourceSchema, permission, field) {
+  return Boolean(sourceSchema.fields?.[field]
+    && (!permission.fields || permission.fields.includes(field)));
+}
+
+function directReadableRelationFields(snapshot, collection, sourceSchema, permission) {
+  const prefix = `${collection}.`;
+  const fields = [];
+  for (const [key, relation] of snapshot.relationByManyField?.entries?.() ?? []) {
+    if (!key.startsWith(prefix) || !isDirectRelation(relation)) continue;
+    const field = key.slice(prefix.length);
+    if (readableSourceField(sourceSchema, permission, field)) fields.push(field);
+  }
+  return [...new Set(fields)];
+}
+
+function mergeExpansionSelection(expansions, relationField, targetField) {
+  const current = expansions.get(relationField) ?? [];
+  if (current.includes('*')) return;
+  if (targetField === '*') {
+    expansions.set(relationField, ['*']);
+    return;
+  }
+  expansions.set(relationField, [...new Set([...current, targetField])]);
+}
+
+function assertExpansionLimit(expansions, path = 'fields') {
+  if (expansions.size > MAX_EXPAND_FIELDS) {
+    throw expansionError(
+      'INVALID_QUERY',
+      `Relation expansion cannot contain more than ${MAX_EXPAND_FIELDS} fields`,
+      path,
+    );
+  }
+}
+
+function parseFieldsPlan({ value, snapshot, collection, sourceSchema, permission }) {
+  const tokens = normalizeDelimited(value);
+  if (tokens.length === 0) {
+    return { sourceFields: null, expansions: new Map() };
+  }
+
+  let sourceAll = false;
+  const sourceFields = [];
+  const expansions = new Map();
+
+  for (const token of tokens) {
+    if (token === '*') {
+      sourceAll = true;
+      continue;
+    }
+
+    if (token === '*.*') {
+      sourceAll = true;
+      for (const relationField of directReadableRelationFields(
+        snapshot,
+        collection,
+        sourceSchema,
+        permission,
+      )) {
+        mergeExpansionSelection(expansions, relationField, '*');
+      }
+      assertExpansionLimit(expansions);
+      continue;
+    }
+
+    if (!token.includes('.')) {
+      sourceFields.push(assertFieldToken(token, `fields.${token}`));
+      continue;
+    }
+
+    const parts = token.split('.');
+    if (parts.length !== 2 || !parts[0] || !parts[1]) {
+      throw expansionError(
+        'UNSUPPORTED_RELATION_EXPANSION',
+        `Only one relation depth is supported in fields: ${token}`,
+        `fields.${token}`,
+      );
+    }
+
+    const relationField = assertFieldToken(parts[0], `fields.${token}`);
+    const targetField = parts[1] === '*'
+      ? '*'
+      : assertFieldToken(parts[1], `fields.${token}`);
+
+    if (!readableSourceField(sourceSchema, permission, relationField)) {
+      throw expansionError('INVALID_QUERY', `Unknown field: ${relationField}`, `fields.${token}`);
+    }
+    directRelation(snapshot, collection, relationField, `fields.${token}`);
+    sourceFields.push(relationField);
+    mergeExpansionSelection(expansions, relationField, targetField);
+    assertExpansionLimit(expansions);
+  }
+
+  return {
+    sourceFields: sourceAll ? ['*'] : [...new Set(sourceFields)],
+    expansions,
+  };
+}
+
+function addLegacyExpansions({ query, plan, snapshot, collection, sourceSchema, permission }) {
+  for (const field of parseExpandInput(query.expand)) {
+    if (!readableSourceField(sourceSchema, permission, field)) {
+      throw expansionError('INVALID_QUERY', `Unknown field: ${field}`, `expand.${field}`);
+    }
+    directRelation(snapshot, collection, field, `expand.${field}`);
+    mergeExpansionSelection(plan.expansions, field, '*');
+    assertExpansionLimit(plan.expansions, 'expand');
+    if (plan.sourceFields && !plan.sourceFields.includes('*') && !plan.sourceFields.includes(field)) {
+      plan.sourceFields.push(field);
+    }
+  }
+  return plan;
+}
+
+async function buildSelectionPlan({ collection, query, options, service }) {
   const snapshot = await schemaSnapshot(options);
   const sourceSchema = snapshot.collections?.[collection];
   if (!sourceSchema) {
     throw expansionError('COLLECTION_NOT_FOUND', `Unknown collection: ${collection}`);
   }
-  if (expandFields.length === 0) return snapshot;
 
   const permission = await service.resolvePermission('read');
-  for (const field of expandFields) {
-    if (!sourceSchema.fields?.[field] || (permission.fields && !permission.fields.includes(field))) {
-      throw expansionError('INVALID_QUERY', `Unknown field: ${field}`, `expand.${field}`);
-    }
-    directRelation(snapshot, collection, field);
-  }
-  return snapshot;
+  const plan = parseFieldsPlan({
+    value: query.fields,
+    snapshot,
+    collection,
+    sourceSchema,
+    permission,
+  });
+  addLegacyExpansions({ query, plan, snapshot, collection, sourceSchema, permission });
+  return { ...plan, snapshot };
 }
 
-async function expandRows({ collection, rows, expandFields, options, ItemsServiceClass, snapshot }) {
-  if (expandFields.length === 0 || rows.length === 0) return rows;
+function baseQuery(query, sourceFields) {
+  const base = { ...query };
+  delete base.expand;
+  if (sourceFields == null) delete base.fields;
+  else base.fields = sourceFields;
+  return base;
+}
+
+function projectTarget(target, selection, visibleFields) {
+  const projectedFields = selection.includes('*') ? visibleFields : selection;
+  return Object.fromEntries(
+    projectedFields
+      .filter((field) => Object.hasOwn(target, field))
+      .map((field) => [field, target[field]]),
+  );
+}
+
+async function expandRows({ collection, rows, expansions, options, ItemsServiceClass, snapshot }) {
+  if (expansions.size === 0 || rows.length === 0) return rows;
   const effectiveSnapshot = snapshot ?? await schemaSnapshot(options);
   let expandedRows = rows.map((row) => ({ ...row }));
 
-  for (const field of expandFields) {
+  for (const [field, selection] of expansions) {
     const relation = directRelation(effectiveSnapshot, collection, field);
     const targetCollection = relation.one_collection;
     const targetKey = relation.one_field
@@ -132,21 +267,25 @@ async function expandRows({ collection, rows, expandFields, options, ItemsServic
     }
 
     const targetService = new ItemsServiceClass(targetCollection, options);
-    const targetRows = await targetService.readMany({
-      filter: { [targetKey]: { _in: values } },
-      limit: Math.min(values.length, 500),
+    const targetResult = await targetService.readManyForRelation({
+      fields: selection,
+      lookupField: targetKey,
+      values,
     });
 
     const byKey = new Map();
-    for (const target of targetRows) {
+    for (const target of targetResult.data) {
       if (!Object.hasOwn(target, targetKey)) {
         throw expansionError(
           'FORBIDDEN_FIELD',
           `Expanded relation key is not readable: ${targetCollection}.${targetKey}`,
-          `expand.${field}`,
+          `fields.${field}`,
         );
       }
-      byKey.set(String(target[targetKey]), target);
+      byKey.set(
+        String(target[targetKey]),
+        projectTarget(target, selection, targetResult.visibleFields),
+      );
     }
 
     expandedRows = expandedRows.map((row) => ({
@@ -167,17 +306,16 @@ export async function readManyWithRelations({
   ItemsServiceClass = ItemsService,
 } = {}) {
   assertIdentifier(collection, 'collection name');
-  const expandFields = parseExpandInput(query.expand);
   const service = new ItemsServiceClass(collection, options);
-  const snapshot = await validateSourceExpansions({ collection, expandFields, options, service });
-  const result = await service.readManyWithMeta(withoutExpand(query, expandFields));
+  const plan = await buildSelectionPlan({ collection, query, options, service });
+  const result = await service.readManyWithMeta(baseQuery(query, plan.sourceFields));
   const data = await expandRows({
     collection,
     rows: result.data,
-    expandFields,
+    expansions: plan.expansions,
     options,
     ItemsServiceClass,
-    snapshot,
+    snapshot: plan.snapshot,
   });
   return { ...result, data };
 }
@@ -196,21 +334,17 @@ export async function readOneWithRelations({
     }
   }
 
-  const expandFields = parseExpandInput(query.expand);
   const service = new ItemsServiceClass(collection, options);
-  const snapshot = await validateSourceExpansions({ collection, expandFields, options, service });
-  const fields = withExpansionFields(query.fields ?? null, expandFields);
-  const record = await service.readOne(id, { fields });
+  const plan = await buildSelectionPlan({ collection, query, options, service });
+  const record = await service.readOne(id, { fields: plan.sourceFields });
   if (!record) return null;
   const [expanded] = await expandRows({
     collection,
     rows: [record],
-    expandFields,
+    expansions: plan.expansions,
     options,
     ItemsServiceClass,
-    snapshot,
+    snapshot: plan.snapshot,
   });
   return expanded;
 }
-
-export { MAX_EXPAND_FIELDS };

package/src/schema-key.js

@@ -0,0 +1,54 @@
+const TURKISH_ASCII = Object.freeze({
+  ç: 'c',
+  Ç: 'c',
+  ğ: 'g',
+  Ğ: 'g',
+  ı: 'i',
+  İ: 'i',
+  ö: 'o',
+  Ö: 'o',
+  ş: 's',
+  Ş: 's',
+  ü: 'u',
+  Ü: 'u',
+});
+
+function schemaNameError(message) {
+  const error = new Error(message);
+  error.code = 'INVALID_SCHEMA_NAME';
+  return error;
+}
+
+export function normalizeDisplayName(value, { fallback = null, maxLength = 255 } = {}) {
+  const candidate = typeof value === 'string' ? value.trim().replace(/\s+/g, ' ') : '';
+  const normalized = candidate || (typeof fallback === 'string' ? fallback.trim().replace(/\s+/g, ' ') : '');
+  if (!normalized) throw schemaNameError('A display name is required');
+  if (normalized.length > maxLength) throw schemaNameError(`Display name cannot exceed ${maxLength} characters`);
+  return normalized;
+}
+
+export function normalizeSchemaKey(value, { prefix = 'field', maxLength = 64 } = {}) {
+  const source = normalizeDisplayName(value, { maxLength: 512 });
+  const transliterated = [...source].map((character) => TURKISH_ASCII[character] ?? character).join('');
+  let key = transliterated
+    .normalize('NFKD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '_')
+    .replace(/^_+|_+$/g, '')
+    .replace(/_+/g, '_');
+
+  if (!key) throw schemaNameError('Name must contain at least one letter or number');
+  if (/^[0-9]/.test(key)) key = `${prefix}_${key}`;
+  if (key.length > maxLength) key = key.slice(0, maxLength).replace(/_+$/g, '');
+  if (!key) throw schemaNameError('Name cannot be normalized to a schema key');
+  return key;
+}
+
+export function resolveSchemaName({ displayName, key, prefix = 'field' } = {}) {
+  const name = normalizeDisplayName(displayName ?? key);
+  return {
+    name,
+    key: normalizeSchemaKey(key ?? name, { prefix }),
+  };
+}

package/src/schema-metadata-repository.js

@@ -12,7 +12,7 @@ export class SchemaMetadataRepository {
 
   async listCollections() {
     const [rows] = await this.database.query(
-      `SELECT collection, primary_key, note, singleton, hidden, \`system\`, metadata, created_at, updated_at
+      `SELECT collection, name, primary_key, note, singleton, hidden, \`system\`, metadata, created_at, updated_at
        FROM yuncms_collections
        ORDER BY collection ASC`,
     );
@@ -21,7 +21,7 @@ export class SchemaMetadataRepository {
 
   async readCollection(collection) {
     const [rows] = await this.database.query(
-      `SELECT collection, primary_key, note, singleton, hidden, \`system\`, metadata, created_at, updated_at
+      `SELECT collection, name, primary_key, note, singleton, hidden, \`system\`, metadata, created_at, updated_at
        FROM yuncms_collections
        WHERE collection = ?
        LIMIT 1`,
@@ -32,6 +32,7 @@ export class SchemaMetadataRepository {
 
   async createCollection({
     collection,
+    name = collection,
     primaryKey = 'id',
     note = null,
     singleton = false,
@@ -41,10 +42,11 @@ export class SchemaMetadataRepository {
   }) {
     await this.database.query(
       `INSERT INTO yuncms_collections
-       (collection, primary_key, note, singleton, hidden, \`system\`, metadata)
-       VALUES (?, ?, ?, ?, ?, ?, ?)`,
+       (collection, name, primary_key, note, singleton, hidden, \`system\`, metadata)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
       [
         collection,
+        name,
         primaryKey,
         note,
         singleton ? 1 : 0,
@@ -60,6 +62,10 @@ export class SchemaMetadataRepository {
     const assignments = [];
     const params = [];
 
+    if (Object.hasOwn(patch, 'name')) {
+      assignments.push('name = ?');
+      params.push(patch.name);
+    }
     if (Object.hasOwn(patch, 'note')) {
       assignments.push('note = ?');
       params.push(patch.note ?? null);
@@ -96,7 +102,7 @@ export class SchemaMetadataRepository {
 
   async listFields(collection) {
     const [rows] = await this.database.query(
-      `SELECT id, collection, field, type, required, readonly, hidden, sort, interface, options, schema_metadata,
+      `SELECT id, collection, field, name, type, required, readonly, hidden, sort, interface, options, schema_metadata,
               created_at, updated_at
        FROM yuncms_fields
        WHERE collection = ?
@@ -108,7 +114,7 @@ export class SchemaMetadataRepository {
 
   async readField(collection, field) {
     const [rows] = await this.database.query(
-      `SELECT id, collection, field, type, required, readonly, hidden, sort, interface, options, schema_metadata,
+      `SELECT id, collection, field, name, type, required, readonly, hidden, sort, interface, options, schema_metadata,
               created_at, updated_at
        FROM yuncms_fields
        WHERE collection = ? AND field = ?
@@ -121,6 +127,7 @@ export class SchemaMetadataRepository {
   async createField({
     collection,
     field,
+    name = field,
     type,
     required = false,
     readonly = false,
@@ -137,11 +144,12 @@ export class SchemaMetadataRepository {
     }
     await this.database.query(
       `INSERT INTO yuncms_fields
-       (collection, field, type, required, readonly, hidden, sort, interface, options, schema_metadata)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+       (collection, field, name, type, required, readonly, hidden, sort, interface, options, schema_metadata)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       [
         collection,
         field,
+        name,
         type,
         required ? 1 : 0,
         readonly ? 1 : 0,
@@ -169,6 +177,10 @@ export class SchemaMetadataRepository {
       }
     }
 
+    if (Object.hasOwn(patch, 'name')) {
+      assignments.push('name = ?');
+      params.push(patch.name);
+    }
     if (Object.hasOwn(patch, 'readonly')) {
       assignments.push('readonly = ?');
       params.push(patch.readonly ? 1 : 0);