@kollors/deep-json-server 0.3.1 → 0.4.0

package/src/{query.js → query/filter.js}

@@ -1,4 +1,4 @@
-import { createHttpError, isEqual, isObject, isSafeKey, toArray } from './utils.js';
+import { createHttpError, isEqual, isObject, isSafeKey, toArray } from '../utils.js';
 
 const FIELD_OPERATORS = new Set(['contains', 'endsWith', 'eq', 'every', 'gt', 'gte', 'in', 'lt', 'lte', 'ne', 'none', 'not', 'some', 'startsWith']);
 const RESERVED_QUERY_KEYS = new Set(['_embed', '_page', '_perPage', '_sort', '_where']);
@@ -16,36 +16,10 @@ const isFilterEqual = (left, right) => {
   return typeof right === 'number' && typeof left === 'string' && NUMBER_PATTERN.test(left) && right === Number(left);
 };
 
-const compareValues = (left, right) => {
-  if (Object.is(left, right)) {
-    return 0;
-  }
-
-  if (left == null) {
-    return 1;
-  }
-
-  if (right == null) {
-    return -1;
-  }
-
-  if (typeof left === 'number' && typeof right === 'number') {
-    return left - right;
-  }
-
-  return String(left).localeCompare(String(right), undefined, { numeric: true, sensitivity: 'base' });
-};
-
-const getValueByPath = (value, path) => path.split('.').reduce((currentValue, key) => {
-  return isSafeKey(key) && currentValue != null ? currentValue[key] : undefined;
-}, value);
-
 const matchesOperator = (field, operator, expectedValue) => {
   switch (operator) {
     case 'contains':
-      return typeof field === 'string'
-        ? field.toLowerCase().includes(String(expectedValue).toLowerCase())
-        : Array.isArray(field) && field.some((value) => isFilterEqual(value, expectedValue));
+      return typeof field === 'string' ? field.toLowerCase().includes(String(expectedValue).toLowerCase()) : Array.isArray(field) && field.some((value) => isFilterEqual(value, expectedValue));
     case 'endsWith':
       return typeof field === 'string' && field.toLowerCase().endsWith(String(expectedValue).toLowerCase());
     case 'eq':
@@ -95,10 +69,10 @@ function matchesValue(field, condition) {
     return false;
   }
 
-  return nestedEntries.length === 0 || isObject(field) && matchesWhere(field, Object.fromEntries(nestedEntries));
+  return nestedEntries.length === 0 || (isObject(field) && matchesWhere(field, Object.fromEntries(nestedEntries)));
 }
 
-function matchesWhere(value, where) {
+export function matchesWhere(value, where) {
   if (!isObject(value) || !isObject(where)) {
     return false;
   }
@@ -156,11 +130,7 @@ const parseFilterKey = (key) => {
 
   const legacyOperator = key.match(/^(.*)_([a-zA-Z]+)$/);
 
-  if (legacyOperator?.[1] != null && legacyOperator[2] != null && FIELD_OPERATORS.has(legacyOperator[2])) {
-    return { operator: legacyOperator[2], path: legacyOperator[1] };
-  }
-
-  return { operator: 'eq', path: key };
+  return legacyOperator?.[1] != null && legacyOperator[2] != null && FIELD_OPERATORS.has(legacyOperator[2]) ? { operator: legacyOperator[2], path: legacyOperator[1] } : { operator: 'eq', path: key };
 };
 
 const setWhereOperator = (where, path, operator, value) => {
@@ -202,14 +172,12 @@ export const parseWhere = (query) => {
   const where = {};
 
   Object.entries(query).forEach(([key, rawValue]) => {
-    if (RESERVED_QUERY_KEYS.has(key)) {
-      return;
-    }
+    if (!RESERVED_QUERY_KEYS.has(key)) {
+      const filterKey = parseFilterKey(key);
 
-    const filterKey = parseFilterKey(key);
-
-    if (filterKey != null) {
-      toArray(rawValue).forEach((value) => setWhereOperator(where, filterKey.path, filterKey.operator, value));
+      toArray(rawValue).forEach((value) => {
+        setWhereOperator(where, filterKey.path, filterKey.operator, value);
+      });
     }
   });
 
@@ -223,11 +191,13 @@ const validateCondition = (condition, samples, path) => {
 
   Object.entries(condition).forEach(([key, value]) => {
     if (key === 'and' || key === 'or') {
-      if (!Array.isArray(value) || key === 'or' && value.length === 0 || value.some((nestedWhere) => !isObject(nestedWhere))) {
+      if (!Array.isArray(value) || (key === 'or' && value.length === 0) || value.some((nestedWhere) => !isObject(nestedWhere))) {
         throw createHttpError(400, `Оператор «${key}» должен содержать ${key === 'or' ? 'непустой ' : ''}массив JSON-объектов`);
       }
 
-      value.forEach((nestedWhere) => validateWhere(nestedWhere, samples, path));
+      value.forEach((nestedWhere) => {
+        validateWhere(nestedWhere, samples, path);
+      });
       return;
     }
 
@@ -237,9 +207,11 @@ const validateCondition = (condition, samples, path) => {
           throw createHttpError(400, `Оператор «${key}» в фильтре «${path}» можно применить только к массиву`);
         }
 
-        const nestedSamples = samples.flatMap((sample) => Array.isArray(sample) ? sample : []);
-
-        validateCondition(value, nestedSamples, `${path}.${key}`);
+        validateCondition(
+          value,
+          samples.flatMap((sample) => (Array.isArray(sample) ? sample : [])),
+          `${path}.${key}`,
+        );
       } else if (key === 'not') {
         validateCondition(value, samples, `${path}.not`);
       } else if (['endsWith', 'startsWith'].includes(key) && samples.length > 0 && !samples.some((sample) => typeof sample === 'string')) {
@@ -274,11 +246,13 @@ const validateCondition = (condition, samples, path) => {
 export const validateWhere = (where, items, path = '') => {
   Object.entries(where).forEach(([key, condition]) => {
     if (key === 'and' || key === 'or') {
-      if (!Array.isArray(condition) || key === 'or' && condition.length === 0 || condition.some((nestedWhere) => !isObject(nestedWhere))) {
+      if (!Array.isArray(condition) || (key === 'or' && condition.length === 0) || condition.some((nestedWhere) => !isObject(nestedWhere))) {
         throw createHttpError(400, `Оператор «${key}» должен содержать ${key === 'or' ? 'непустой ' : ''}массив JSON-объектов`);
       }
 
-      condition.forEach((nestedWhere) => validateWhere(nestedWhere, items, path));
+      condition.forEach((nestedWhere) => {
+        validateWhere(nestedWhere, items, path);
+      });
       return;
     }
 
@@ -306,67 +280,3 @@ export const validateWhere = (where, items, path = '') => {
     validateCondition(condition, samples, fieldPath);
   });
 };
-
-const parsePositiveInteger = (value, name, defaultValue) => {
-  if (value == null) {
-    return defaultValue;
-  }
-
-  if (Array.isArray(value) || !/^[1-9]\d*$/.test(String(value))) {
-    throw createHttpError(400, `Параметр ${name} должен быть положительным целым числом`);
-  }
-
-  const number = Number(value);
-
-  if (!Number.isSafeInteger(number)) {
-    throw createHttpError(400, `Параметр ${name} должен быть положительным целым числом`);
-  }
-
-  return number;
-};
-
-export const parsePagination = (query) => ({
-  page: parsePositiveInteger(query._page, '_page', 1),
-  pageSize: parsePositiveInteger(query._perPage, '_perPage', 10),
-});
-
-export const paginateItems = (items, page, pageSize) => {
-  const safePageSize = Number.isFinite(pageSize) && pageSize > 0 ? Math.floor(pageSize) : 10;
-  const pages = Math.max(1, Math.ceil(items.length / safePageSize));
-  const safePage = Math.max(1, Math.min(Number.isFinite(page) ? Math.floor(page) : 1, pages));
-  const offset = (safePage - 1) * safePageSize;
-
-  return {
-    data: items.slice(offset, offset + safePageSize),
-    first: 1,
-    items: items.length,
-    last: pages,
-    next: safePage < pages ? safePage + 1 : null,
-    pages,
-    prev: safePage > 1 ? safePage - 1 : null,
-  };
-};
-
-export const sortItems = (items, sort) => {
-  const sortRules = typeof sort === 'string' ? sort.split(',').filter(Boolean) : [];
-
-  if (sortRules.length === 0) {
-    return [...items];
-  }
-
-  return [...items].sort((left, right) => {
-    for (const sortRule of sortRules) {
-      const isDescending = sortRule.startsWith('-');
-      const path = isDescending ? sortRule.slice(1) : sortRule;
-      const comparison = compareValues(getValueByPath(left, path), getValueByPath(right, path));
-
-      if (comparison !== 0) {
-        return isDescending ? -comparison : comparison;
-      }
-    }
-
-    return 0;
-  });
-};
-
-export { matchesWhere };

package/src/query/index.js

@@ -0,0 +1,3 @@
+export { matchesWhere, parseWhere, validateWhere } from './filter.js';
+export { paginateItems, parsePagination } from './pagination.js';
+export { sortItems } from './sort.js';

package/src/query/pagination.js

@@ -0,0 +1,50 @@
+import { DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE } from '../constants.js';
+import { createHttpError } from '../utils.js';
+
+const parsePositiveInteger = (value, name, defaultValue) => {
+  if (value == null) {
+    return defaultValue;
+  }
+
+  if (Array.isArray(value) || !/^[1-9]\d*$/.test(String(value))) {
+    throw createHttpError(400, `Параметр ${name} должен быть положительным целым числом`);
+  }
+
+  const number = Number(value);
+
+  if (!Number.isSafeInteger(number)) {
+    throw createHttpError(400, `Параметр ${name} должен быть положительным целым числом`);
+  }
+
+  return number;
+};
+
+export const parsePagination = (query, maxPageSize = MAX_PAGE_SIZE) => {
+  const page = parsePositiveInteger(query._page, '_page', 1);
+  const pageSize = parsePositiveInteger(query._perPage, '_perPage', DEFAULT_PAGE_SIZE);
+
+  if (!Number.isInteger(maxPageSize) || maxPageSize < 1) {
+    throw new Error('Максимальный размер страницы должен быть положительным целым числом');
+  }
+
+  if (pageSize > maxPageSize) {
+    throw createHttpError(400, `Параметр _perPage не должен превышать ${maxPageSize}`);
+  }
+
+  return { page, pageSize };
+};
+
+export const paginateItems = (items, page, pageSize) => {
+  const pages = Math.max(1, Math.ceil(items.length / pageSize));
+  const offset = (page - 1) * pageSize;
+
+  return {
+    data: items.slice(offset, offset + pageSize),
+    first: 1,
+    items: items.length,
+    last: pages,
+    next: page < pages ? page + 1 : null,
+    pages,
+    prev: page > 1 ? Math.min(page - 1, pages) : null,
+  };
+};

package/src/query/sort.js

@@ -0,0 +1,63 @@
+import { createHttpError, isObject, isSafeKey } from '../utils.js';
+
+const compareValues = (left, right) => {
+  if (Object.is(left, right)) {
+    return 0;
+  }
+
+  if (left == null) {
+    return 1;
+  }
+
+  if (right == null) {
+    return -1;
+  }
+
+  return typeof left === 'number' && typeof right === 'number' ? left - right : String(left).localeCompare(String(right), undefined, { numeric: true, sensitivity: 'base' });
+};
+
+const getValueByPath = (value, path) => path.split('.').reduce((currentValue, key) => (isObject(currentValue) && isSafeKey(key) ? currentValue[key] : undefined), value);
+
+const parseSortRules = (sort, items) => {
+  if (sort == null || sort === '') {
+    return [];
+  }
+
+  if (typeof sort !== 'string') {
+    throw createHttpError(400, 'Параметр _sort должен содержать строку');
+  }
+
+  return sort.split(',').map((sortRule) => {
+    const isDescending = sortRule.startsWith('-');
+    const path = isDescending ? sortRule.slice(1) : sortRule;
+    const keys = path.split('.');
+
+    if (keys.some((key) => key === '' || !isSafeKey(key))) {
+      throw createHttpError(400, `Недопустимое поле сортировки «${path}»`);
+    }
+
+    if (items.length > 0 && !items.some((item) => getValueByPath(item, path) !== undefined)) {
+      throw createHttpError(400, `Неизвестное поле сортировки «${path}»`);
+    }
+
+    return { isDescending, path };
+  });
+};
+
+export const sortItems = (items, sort, validationItems = items) => {
+  const sortRules = parseSortRules(sort, validationItems);
+
+  return sortRules.length === 0
+    ? [...items]
+    : [...items].sort((left, right) => {
+        for (const { isDescending, path } of sortRules) {
+          const comparison = compareValues(getValueByPath(left, path), getValueByPath(right, path));
+
+          if (comparison !== 0) {
+            return isDescending ? -comparison : comparison;
+          }
+        }
+
+        return 0;
+      });
+};

package/src/relation-metadata.js

@@ -0,0 +1,40 @@
+import { singularize } from './utils.js';
+
+const SELF_RELATIONS = new Set(['child', 'children', 'parent', 'parents']);
+
+export const getRelationKeys = (...names) => [...new Set(names.flatMap((name) => [`${name}Id`, `${name}Ids`]))];
+
+export const resolveRelationResource = (resourceNames, relation, sourceResource) => {
+  const resource = resourceNames.find((resourceName) => resourceName === relation) ?? resourceNames.find((resourceName) => singularize(resourceName) === relation);
+
+  if (resource != null) {
+    return resource;
+  }
+
+  return SELF_RELATIONS.has(relation) && resourceNames.includes(sourceResource) ? sourceResource : undefined;
+};
+
+export const getRelationMetadata = (key, resourceNames, sourceResource) => {
+  const match = key.match(/^(.+)(Id|Ids)$/);
+
+  if (match == null) {
+    return undefined;
+  }
+
+  const [, relation, suffix] = match;
+  const isMany = suffix === 'Ids';
+  const relationName = isMany ? (resourceNames.find((resource) => singularize(resource) === relation) ?? `${relation}s`) : relation;
+  const targetResource = resolveRelationResource(resourceNames, relationName, sourceResource);
+
+  if (targetResource == null) {
+    return undefined;
+  }
+
+  return {
+    isMany,
+    relationName,
+    reverseRelationName: ['parent', 'parents'].includes(relationName) ? 'children' : sourceResource,
+    sourceResource,
+    targetResource,
+  };
+};

package/src/relations.js

@@ -1,17 +1,5 @@
-import { getResourceNames, isEqual, isObject, isSafeKey, singularize, toArray } from './utils.js';
-
-const resolveResource = (database, relation, sourceResource) => {
-  const resourceNames = getResourceNames(database.data);
-  const resource = resourceNames.find((resourceName) => resourceName === relation) ?? resourceNames.find((resourceName) => singularize(resourceName) === relation);
-
-  if (resource != null) {
-    return resource;
-  }
-
-  return ['child', 'children', 'parent', 'parents'].includes(relation) && resourceNames.includes(sourceResource) ? sourceResource : undefined;
-};
-
-const getRelationKeys = (...names) => [...new Set(names.flatMap((name) => [`${name}Id`, `${name}Ids`]))];
+import { getRelationKeys, resolveRelationResource } from './relation-metadata.js';
+import { createHttpError, getResourceNames, isIdEqual, isObject, isSafeKey, singularize, toArray } from './utils.js';
 
 const findLocalRelation = (item, relation, targetResource) => {
   const relationKey = getRelationKeys(relation, singularize(relation), targetResource, singularize(targetResource)).find((key) => Object.hasOwn(item, key));
@@ -38,7 +26,7 @@ const hasReference = (value, relationKeys, id) => {
     }
 
     if (relationKeys.includes(key)) {
-      return toArray(nestedValue).some((nestedId) => isEqual(nestedId, id));
+      return toArray(nestedValue).some((nestedId) => isIdEqual(nestedId, id));
     }
 
     return hasReference(nestedValue, relationKeys, id);
@@ -51,7 +39,7 @@ const getResourceIndex = (database, resource, indexes) => {
 
     database.data[resource].forEach((item) => {
       if (isObject(item) && item.id != null && !index.has(item.id)) {
-        index.set(item.id, item);
+        index.set(String(item.id), item);
       }
     });
 
@@ -71,9 +59,9 @@ const findRelatedValue = (database, item, sourceResource, relation, targetResour
 
   if (localRelation != null) {
     const targetIndex = getResourceIndex(database, targetResource, indexes);
-    const relatedItems = localRelation.ids.map((id) => targetIndex.get(id)).filter((targetItem) => targetItem != null);
+    const relatedItems = localRelation.ids.map((id) => targetIndex.get(String(id))).filter((targetItem) => targetItem != null);
 
-    return localRelation.isMany ? relatedItems : relatedItems[0] ?? null;
+    return localRelation.isMany ? relatedItems : (relatedItems[0] ?? null);
   }
 
   if (item.id == null) {
@@ -95,13 +83,15 @@ const embedPath = (database, item, sourceResource, [relation, ...nestedRelations
   }
 
   const currentValue = item[relation];
-  const targetResource = resolveResource(database, relation, sourceResource);
+  const targetResource = resolveRelationResource(getResourceNames(database.data), relation, sourceResource);
   const nestedSourceResource = targetResource ?? relation;
   const localRelation = targetResource == null ? undefined : findLocalRelation(item, relation, targetResource);
 
   if (localRelation == null) {
     if (Array.isArray(currentValue)) {
-      return nestedRelations.length === 0 ? item : { ...item, [relation]: currentValue.map((value) => (isObject(value) ? embedPath(database, value, nestedSourceResource, nestedRelations, indexes) : value)) };
+      return nestedRelations.length === 0
+        ? item
+        : { ...item, [relation]: currentValue.map((value) => (isObject(value) ? embedPath(database, value, nestedSourceResource, nestedRelations, indexes) : value)) };
     }
 
     if (isObject(currentValue)) {
@@ -127,9 +117,57 @@ const embedPath = (database, item, sourceResource, [relation, ...nestedRelations
   };
 };
 
-export const parseEmbedPaths = (embed) => toArray(embed)
-  .flatMap((value) => (typeof value === 'string' ? value.split(',') : []))
-  .map((path) => path.split('.').filter(Boolean))
-  .filter((path) => path.length > 0 && path.every(isSafeKey));
+export const parseEmbedPaths = (embed) => {
+  if (embed == null) {
+    return [];
+  }
+
+  const values = toArray(embed);
+
+  if (values.some((value) => typeof value !== 'string')) {
+    throw createHttpError(400, 'Параметр _embed должен содержать строковые пути связей');
+  }
+
+  return values
+    .flatMap((value) => value.split(','))
+    .map((path) => {
+      const keys = path.split('.');
+
+      if (keys.some((key) => key === '' || !isSafeKey(key))) {
+        throw createHttpError(400, `Недопустимый путь связи «${path}»`);
+      }
+
+      return keys;
+    });
+};
+
+const getNestedSamples = (samples, relation) =>
+  samples.flatMap((sample) => {
+    if (!isObject(sample) || !Object.hasOwn(sample, relation)) {
+      return [];
+    }
+
+    return toArray(sample[relation]).filter(isObject);
+  });
+
+const validateEmbedPath = (database, sourceResource, samples, [relation, ...nestedRelations], path = '') => {
+  const relationPath = path === '' ? relation : `${path}.${relation}`;
+  const targetResource = resolveRelationResource(getResourceNames(database.data), relation, sourceResource);
+  const nestedSamples = targetResource == null ? getNestedSamples(samples, relation) : database.data[targetResource];
+
+  if (targetResource == null && nestedSamples.length === 0) {
+    throw createHttpError(400, `Неизвестный путь связи «${relationPath}»`);
+  }
+
+  if (nestedRelations.length > 0) {
+    validateEmbedPath(database, targetResource ?? relation, nestedSamples, nestedRelations, relationPath);
+  }
+};
+
+export const validateEmbedPaths = (database, resource, items, embedPaths) => {
+  embedPaths.forEach((path) => {
+    validateEmbedPath(database, resource, items, path);
+  });
+};
 
 export const embedItem = (database, item, resource, embedPaths, indexes = new Map()) => embedPaths.reduce((embeddedItem, path) => embedPath(database, embeddedItem, resource, path, indexes), item);