@kollors/deep-json-server 0.7.0 → 0.8.0

package/src/openapi/inference.js

@@ -1,187 +0,0 @@
-import { isObject } from '../utils.js';
-
-export const mergeSchemas = (schemas) => {
-  const uniqueSchemas = [...new Map(schemas.map((schema) => [JSON.stringify(schema), schema])).values()];
-  const nullable = uniqueSchemas.some((schema) => schema.type === 'null');
-  const nonNullSchemas = uniqueSchemas.filter((schema) => schema.type !== 'null');
-
-  if (nonNullSchemas.length === 0) {
-    return { nullable: true };
-  }
-
-  if (nonNullSchemas.length === 1) {
-    return nullable ? { ...nonNullSchemas[0], nullable: true } : nonNullSchemas[0];
-  }
-
-  return { oneOf: nonNullSchemas, ...(nullable && { nullable: true }) };
-};
-
-export const mergeSchemaOverrides = (schema, overrides) => {
-  if (!isObject(overrides)) {
-    return schema;
-  }
-
-  const result = { ...schema, ...overrides };
-
-  if (Object.hasOwn(overrides, 'type') && !Object.hasOwn(overrides, 'oneOf')) {
-    delete result.oneOf;
-  }
-
-  if (isObject(schema.properties) || isObject(overrides.properties)) {
-    const properties = isObject(schema.properties) ? { ...schema.properties } : {};
-
-    Object.entries(isObject(overrides.properties) ? overrides.properties : {}).forEach(([key, value]) => {
-      properties[key] = mergeSchemaOverrides(properties[key] ?? {}, value);
-    });
-
-    result.properties = properties;
-  }
-
-  if (isObject(schema.items) && isObject(overrides.items)) {
-    result.items = mergeSchemaOverrides(schema.items, overrides.items);
-  }
-
-  return result;
-};
-
-export const applyRequiredFields = (schema, path, requiredFields) => {
-  if (Array.isArray(schema.oneOf)) {
-    return { ...schema, oneOf: schema.oneOf.map((nestedSchema) => applyRequiredFields(nestedSchema, path, requiredFields)) };
-  }
-
-  if (schema.type === 'array') {
-    return { ...schema, items: applyRequiredFields(schema.items ?? {}, path, requiredFields) };
-  }
-
-  if (schema.type !== 'object' || !isObject(schema.properties)) {
-    return schema;
-  }
-
-  const properties = Object.fromEntries(
-    Object.entries(schema.properties).map(([key, value]) => {
-      const fieldPath = path === '' ? key : `${path}.${key}`;
-
-      return [key, applyRequiredFields(value, fieldPath, requiredFields)];
-    }),
-  );
-  const required = Object.keys(properties).filter((key) => {
-    const fieldPath = path === '' ? key : `${path}.${key}`;
-
-    return (path === '' && key === 'id') || requiredFields.has(fieldPath);
-  });
-  const result = { ...schema, properties };
-
-  delete result.required;
-
-  return required.length === 0 ? result : { ...result, required };
-};
-
-export const inferSchema = (values) => {
-  const schemas = [];
-  const arrays = values.filter(Array.isArray);
-  const objects = values.filter(isObject);
-
-  if (arrays.length > 0) {
-    const items = arrays.flat();
-
-    schemas.push({ items: items.length === 0 ? {} : inferSchema(items), type: 'array' });
-  }
-
-  if (objects.length > 0) {
-    schemas.push(inferObjectSchema(objects));
-  }
-
-  values
-    .filter((value) => !Array.isArray(value) && !isObject(value))
-    .forEach((value) => {
-      if (value === null) {
-        schemas.push({ type: 'null' });
-      } else if (typeof value === 'number') {
-        schemas.push({ type: Number.isInteger(value) ? 'integer' : 'number' });
-      } else {
-        schemas.push({ type: typeof value });
-      }
-    });
-
-  return mergeSchemas(schemas);
-};
-
-export function inferObjectSchema(values) {
-  const keys = [...new Set(values.flatMap((value) => Object.keys(value)))].sort((left, right) => (left === 'id' ? -1 : right === 'id' ? 1 : left.localeCompare(right)));
-  const properties = Object.fromEntries(
-    keys.map((key) => {
-      const fieldValues = values.filter((value) => Object.hasOwn(value, key)).map((value) => value[key]);
-
-      return [key, inferSchema(fieldValues)];
-    }),
-  );
-
-  return { properties, type: 'object' };
-}
-
-export const ensureGeneratedIdSchema = (schema) => {
-  const idSchema = schema.properties?.id ?? {};
-  const idSchemas = Array.isArray(idSchema.oneOf) ? idSchema.oneOf : [idSchema];
-  const properties = {
-    ...schema.properties,
-    id: idSchemas.some(({ type }) => type === 'string') ? idSchema : { oneOf: [...idSchemas, { type: 'string' }] },
-  };
-
-  return { ...schema, properties };
-};
-
-export const getSchemasAtPath = (schema, keys) => {
-  if (Array.isArray(schema.oneOf)) {
-    return schema.oneOf.flatMap((nestedSchema) => getSchemasAtPath(nestedSchema, keys));
-  }
-
-  if (schema.type === 'array') {
-    return getSchemasAtPath(schema.items ?? {}, keys);
-  }
-
-  if (keys.length === 0) {
-    return [schema];
-  }
-
-  if (schema.type !== 'object' || !isObject(schema.properties) || !Object.hasOwn(schema.properties, keys[0])) {
-    return [];
-  }
-
-  return getSchemasAtPath(schema.properties[keys[0]], keys.slice(1));
-};
-
-export const updateSchemasAtPath = (schema, keys, update) => {
-  if (Array.isArray(schema.oneOf)) {
-    return { ...schema, oneOf: schema.oneOf.map((nestedSchema) => updateSchemasAtPath(nestedSchema, keys, update)) };
-  }
-
-  if (schema.type === 'array') {
-    return { ...schema, items: updateSchemasAtPath(schema.items ?? {}, keys, update) };
-  }
-
-  if (keys.length === 0) {
-    return update(schema);
-  }
-
-  if (schema.type !== 'object' || !isObject(schema.properties) || !Object.hasOwn(schema.properties, keys[0])) {
-    return schema;
-  }
-
-  return {
-    ...schema,
-    properties: {
-      ...schema.properties,
-      [keys[0]]: updateSchemasAtPath(schema.properties[keys[0]], keys.slice(1), update),
-    },
-  };
-};
-
-export const omitId = (schema, keepRequired) => {
-  const properties = Object.fromEntries(Object.entries(schema.properties ?? {}).filter(([key]) => key !== 'id'));
-  const required = keepRequired ? schema.required?.filter((key) => key !== 'id') : undefined;
-  const result = { ...schema, properties };
-
-  delete result.required;
-
-  return required?.length > 0 ? { ...result, required } : result;
-};

package/src/query/filter.js

@@ -1,283 +0,0 @@
-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']);
-const NUMBER_PATTERN = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
-
-const isFilterEqual = (left, right) => {
-  if (isEqual(left, right)) {
-    return true;
-  }
-
-  if (typeof left === 'number' && typeof right === 'string' && NUMBER_PATTERN.test(right)) {
-    // Query parameters are strings, so numeric strings must match stored numbers.
-    return left === Number(right);
-  }
-
-  return typeof right === 'number' && typeof left === 'string' && NUMBER_PATTERN.test(left) && right === Number(left);
-};
-
-const validateLogicalConditions = (operator, value) => {
-  if (!Array.isArray(value) || (operator === 'or' && value.length === 0) || value.some((condition) => !isObject(condition))) {
-    throw createHttpError(400, `Оператор «${operator}» должен содержать ${operator === 'or' ? 'непустой ' : ''}массив JSON-объектов`);
-  }
-
-  return 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));
-    case 'endsWith':
-      return typeof field === 'string' && field.toLowerCase().endsWith(String(expectedValue).toLowerCase());
-    case 'eq':
-      return isFilterEqual(field, expectedValue);
-    case 'every':
-      return Array.isArray(field) && field.every((value) => matchesValue(value, expectedValue));
-    case 'gt':
-      return field != null && field > expectedValue;
-    case 'gte':
-      return field != null && field >= expectedValue;
-    case 'in': {
-      const expectedValues = toArray(expectedValue);
-
-      return Array.isArray(field)
-        ? field.some((value) => expectedValues.some((expectedItem) => isFilterEqual(value, expectedItem)))
-        : expectedValues.some((expectedItem) => isFilterEqual(field, expectedItem));
-    }
-    case 'lt':
-      return field != null && field < expectedValue;
-    case 'lte':
-      return field != null && field <= expectedValue;
-    case 'ne':
-      return !isFilterEqual(field, expectedValue);
-    case 'none':
-      return Array.isArray(field) && !field.some((value) => matchesValue(value, expectedValue));
-    case 'not':
-      return !matchesValue(field, expectedValue);
-    case 'some':
-      return Array.isArray(field) && field.some((value) => matchesValue(value, expectedValue));
-    case 'startsWith':
-      return typeof field === 'string' && field.toLowerCase().startsWith(String(expectedValue).toLowerCase());
-    default:
-      return false;
-  }
-};
-
-function matchesValue(field, condition) {
-  if (!isObject(condition)) {
-    return isFilterEqual(field, condition);
-  }
-
-  const conditionEntries = Object.entries(condition);
-  const operatorEntries = conditionEntries.filter(([operator]) => FIELD_OPERATORS.has(operator));
-  const nestedEntries = conditionEntries.filter(([key]) => !FIELD_OPERATORS.has(key));
-
-  if (!operatorEntries.every(([operator, expectedValue]) => matchesOperator(field, operator, expectedValue))) {
-    return false;
-  }
-
-  return nestedEntries.length === 0 || (isObject(field) && matchesWhere(field, Object.fromEntries(nestedEntries)));
-}
-
-export function matchesWhere(value, where) {
-  if (!isObject(value) || !isObject(where)) {
-    return false;
-  }
-
-  return Object.entries(where).every(([key, condition]) => {
-    if (key === 'and') {
-      return Array.isArray(condition) && condition.every((nestedWhere) => matchesWhere(value, nestedWhere));
-    }
-
-    if (key === 'or') {
-      return Array.isArray(condition) && condition.length > 0 && condition.some((nestedWhere) => matchesWhere(value, nestedWhere));
-    }
-
-    if (key === 'not') {
-      return isObject(condition) && !matchesWhere(value, condition);
-    }
-
-    return isSafeKey(key) && matchesValue(value[key], condition);
-  });
-}
-
-const parsePrimitive = (value) => {
-  if (typeof value !== 'string') {
-    return value;
-  }
-
-  if (value === 'true') {
-    return true;
-  }
-
-  if (value === 'false') {
-    return false;
-  }
-
-  if (value === 'null') {
-    return null;
-  }
-
-  return NUMBER_PATTERN.test(value) && Number.isFinite(Number(value)) ? Number(value) : value;
-};
-
-const parseFilterKey = (key) => {
-  const colonIndex = key.lastIndexOf(':');
-
-  if (colonIndex !== -1) {
-    const path = key.slice(0, colonIndex);
-    const operator = key.slice(colonIndex + 1);
-
-    if (!FIELD_OPERATORS.has(operator)) {
-      throw createHttpError(400, `Неизвестный оператор «${operator}» в фильтре «${key}»`);
-    }
-
-    return { operator, path };
-  }
-
-  const legacyOperator = key.match(/^(.*)_([a-zA-Z]+)$/);
-
-  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) => {
-  const keys = path.split('.');
-
-  if (keys.some((key) => key === '' || !isSafeKey(key))) {
-    throw createHttpError(400, `Недопустимый путь фильтра «${path}»`);
-  }
-
-  const fieldKey = keys.pop();
-  let currentValue = where;
-
-  keys.forEach((key) => {
-    currentValue[key] = isObject(currentValue[key]) ? currentValue[key] : {};
-    currentValue = currentValue[key];
-  });
-
-  currentValue[fieldKey] = isObject(currentValue[fieldKey]) ? currentValue[fieldKey] : {};
-  currentValue[fieldKey][operator] = operator === 'in' && typeof value === 'string' ? value.split(',').map((item) => parsePrimitive(item.trim())) : parsePrimitive(value);
-};
-
-export const parseWhere = (query) => {
-  const rawWhere = toArray(query._where).at(-1);
-
-  if (rawWhere != null) {
-    try {
-      const where = JSON.parse(rawWhere);
-
-      if (!isObject(where)) {
-        throw new Error();
-      }
-
-      return where;
-    } catch {
-      throw createHttpError(400, 'Параметр _where должен содержать JSON-объект');
-    }
-  }
-
-  const where = {};
-
-  Object.entries(query).forEach(([key, rawValue]) => {
-    if (!RESERVED_QUERY_KEYS.has(key)) {
-      const filterKey = parseFilterKey(key);
-
-      toArray(rawValue).forEach((value) => {
-        setWhereOperator(where, filterKey.path, filterKey.operator, value);
-      });
-    }
-  });
-
-  return where;
-};
-
-const validateCondition = (condition, samples, path) => {
-  if (!isObject(condition)) {
-    return;
-  }
-
-  Object.entries(condition).forEach(([key, value]) => {
-    if (key === 'and' || key === 'or') {
-      validateLogicalConditions(key, value).forEach((nestedWhere) => {
-        validateWhere(nestedWhere, samples, path);
-      });
-      return;
-    }
-
-    if (FIELD_OPERATORS.has(key)) {
-      if (['every', 'none', 'some'].includes(key)) {
-        if (samples.length > 0 && !samples.some(Array.isArray)) {
-          throw createHttpError(400, `Оператор «${key}» в фильтре «${path}» можно применить только к массиву`);
-        }
-
-        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')) {
-        throw createHttpError(400, `Оператор «${key}» в фильтре «${path}» можно применить только к строке`);
-      } else if (key === 'contains' && samples.length > 0 && !samples.some((sample) => typeof sample === 'string' || Array.isArray(sample))) {
-        throw createHttpError(400, `Оператор «contains» в фильтре «${path}» можно применить только к строке или массиву`);
-      }
-
-      return;
-    }
-
-    if (!isSafeKey(key)) {
-      throw createHttpError(400, `Недопустимый путь фильтра «${path}.${key}»`);
-    }
-
-    const objectSamples = samples.filter(isObject);
-
-    if (samples.length > 0 && objectSamples.length === 0) {
-      throw createHttpError(400, `Неизвестный оператор или вложенное поле «${path}.${key}»`);
-    }
-
-    const nestedSamples = objectSamples.filter((sample) => Object.hasOwn(sample, key)).map((sample) => sample[key]);
-
-    if (objectSamples.length > 0 && nestedSamples.length === 0) {
-      throw createHttpError(400, `Неизвестное поле фильтра «${path}.${key}»`);
-    }
-
-    validateCondition(value, nestedSamples, `${path}.${key}`);
-  });
-};
-
-export const validateWhere = (where, items, path = '') => {
-  Object.entries(where).forEach(([key, condition]) => {
-    if (key === 'and' || key === 'or') {
-      validateLogicalConditions(key, condition).forEach((nestedWhere) => {
-        validateWhere(nestedWhere, items, path);
-      });
-      return;
-    }
-
-    if (key === 'not') {
-      if (!isObject(condition)) {
-        throw createHttpError(400, 'Оператор «not» должен содержать JSON-объект');
-      }
-
-      validateWhere(condition, items, path);
-      return;
-    }
-
-    if (!isSafeKey(key)) {
-      throw createHttpError(400, `Недопустимый путь фильтра «${path === '' ? key : `${path}.${key}`}»`);
-    }
-
-    const fieldPath = path === '' ? key : `${path}.${key}`;
-    const objectItems = items.filter(isObject);
-    const samples = objectItems.filter((item) => Object.hasOwn(item, key)).map((item) => item[key]);
-
-    if (objectItems.length > 0 && samples.length === 0) {
-      throw createHttpError(400, `Неизвестное поле фильтра «${fieldPath}»`);
-    }
-
-    validateCondition(condition, samples, fieldPath);
-  });
-};

package/src/query/pagination.js

@@ -1,44 +0,0 @@
-import { DEFAULT_MAX_PAGE_SIZE, DEFAULT_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 = DEFAULT_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 offset = (page - 1) * pageSize;
-
-  return {
-    data: items.slice(offset, offset + pageSize),
-    total: items.length,
-  };
-};

package/src/query/sort.js

@@ -1,63 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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) => {
-  // Relation fields follow the <resource>Id and <resource>Ids conventions.
-  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,
-  };
-};