rads-db 3.0.58 → 3.0.62

package/dist/index.cjs

@@ -5,13 +5,11 @@ const _ = require('lodash');
 const uuid = require('uuid');
 const createMerge = require('@fastify/deepmerge');
 const _radsDb = require('_rads-db');
-const pluralize = require('pluralize');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
 const ___default = /*#__PURE__*/_interopDefaultCompat(_);
 const createMerge__default = /*#__PURE__*/_interopDefaultCompat(createMerge);
-const pluralize__default = /*#__PURE__*/_interopDefaultCompat(pluralize);
 
 function generateValidators(schema) {
   const zodSchemas = {};
@@ -58,7 +56,7 @@ function getZodSchema(zodSchemas, schema, key) {
   const objectSchema = {};
   for (const fieldName in type.fields) {
     const f = type.fields[fieldName];
-    if (f.decorators?.computed || f.decorators?.precomputed) {
+    if (f.decorators?.computed || f.decorators?.precomputed || f.isInverseRelation) {
       continue;
     }
     objectSchema[fieldName] = getFieldZodSchema(zodSchemas, schema, f);
@@ -82,7 +80,7 @@ function getFieldZodSchemaBase(zodSchemas, schema, field) {
     const zodSchema = getZodSchema(zodSchemas, schema, field.type);
     if (!zodSchema)
       throw new Error(`Cannot find zod schema for type: ${field.type}`);
-    return zodSchema.deepPartial().omit({ id: true });
+    return deepPartial(zodSchema.omit({ id: true }));
   }
   if (field.type === "string")
     return zod.z.string();
@@ -106,6 +104,25 @@ function getFieldZodSchemaBase(zodSchemas, schema, field) {
   }
   throw new Error(`Unknown type: ${field.type}`);
 }
+function deepPartial(zodSchema) {
+  const shape = zodSchema.shape;
+  const newShape = {};
+  for (const key in shape) {
+    let field = shape[key];
+    while (field instanceof zod.ZodNullable || field instanceof zod.ZodOptional) {
+      field = field.unwrap();
+    }
+    if (field instanceof zod.ZodLazy) {
+      field = field.schema;
+    }
+    if (field instanceof zod.ZodObject) {
+      newShape[key] = deepPartial(field).optional().nullable();
+    } else {
+      newShape[key] = field.optional().nullable();
+    }
+  }
+  return zod.z.object(newShape);
+}
 class ValidationError extends Error {
   constructor(error) {
     const firstError = error.errors[0];
@@ -491,6 +508,73 @@ async function handleEffectsAfterPut(context, docs, beforePutResults, ctx) {
   );
 }
 
+function cleanUndefinedAndNull(obj, isChange = false) {
+  for (const key in obj) {
+    if (obj[key] == null && !isChange)
+      delete obj[key];
+    if (___default.isPlainObject(obj[key]))
+      cleanUndefinedAndNull(obj[key], isChange || key === "change");
+  }
+}
+
+const mergeFn = createMerge__default({
+  mergeArray(options) {
+    const clone = options.clone;
+    return function(target, source) {
+      return clone(source);
+    };
+  }
+});
+function merge(target, source) {
+  cleanUndefined(source);
+  const result = mergeFn(target, source);
+  return result;
+}
+function cleanUndefined(obj) {
+  if (!obj || !___default.isPlainObject(obj))
+    return;
+  cleanUndefinedInner(obj);
+}
+function cleanUndefinedInner(obj) {
+  for (const key in obj) {
+    if (obj[key] === void 0)
+      delete obj[key];
+    if (___default.isPlainObject(obj[key]))
+      cleanUndefinedInner(obj[key]);
+  }
+}
+
+function diff(object, base, includeDenormFields = false) {
+  if (!base)
+    return object;
+  return ___default.transform(object, (result, value, key) => {
+    const oldValue = base[key];
+    if (!___default.isEqual(value, oldValue)) {
+      if (mustUseDeepDiff(value, oldValue)) {
+        const isRelationField = (value.id || oldValue.id) && key !== "change";
+        if (isRelationField && !includeDenormFields) {
+          if (value.id !== oldValue.id)
+            result[key] = value;
+        } else {
+          const subDiff = diff(value, oldValue, includeDenormFields);
+          if (!___default.isEmpty(subDiff))
+            result[key] = subDiff;
+        }
+      } else {
+        result[key] = value;
+      }
+    }
+  });
+}
+function mustUseDeepDiff(value, oldValue) {
+  return ___default.isObject(value) && ___default.isObject(oldValue) && !___default.isArray(value) && !___default.isArray(oldValue);
+}
+
+const radsDbRelations = {
+  verifyRelationsSetup,
+  fillDenormFieldsBeforePut,
+  handleInclude
+};
 function verifyRelationsSetup(schema, effects) {
   for (const entityName in schema) {
     const entity = schema[entityName];
@@ -570,67 +654,96 @@ async function fillDenormFieldsBeforePut(computedContext, docUpdates, ctx) {
   });
   await Promise.all(promises);
 }
-
-function cleanUndefinedAndNull(obj, isChange = false) {
-  for (const key in obj) {
-    if (obj[key] == null && !isChange)
-      delete obj[key];
-    if (___default.isPlainObject(obj[key]))
-      cleanUndefinedAndNull(obj[key], key === "change");
-  }
-}
-
-const mergeFn = createMerge__default({
-  mergeArray(options) {
-    const clone = options.clone;
-    return function(target, source) {
-      return clone(source);
-    };
-  }
-});
-function merge(target, source) {
-  cleanUndefined(source);
-  const result = mergeFn(target, source);
-  return result;
-}
-function cleanUndefined(obj) {
-  if (!obj || !___default.isPlainObject(obj))
+async function handleInclude(computedContext, include, result, ctx) {
+  if (!result || !result.length || !include)
     return;
-  cleanUndefinedInner(obj);
+  const { schema, typeName } = computedContext;
+  const fields = schema[typeName].fields || {};
+  const fieldsToInclude = ___default.keys(include).filter((key) => include[key]);
+  const relationsToInclude = fieldsToInclude.filter((key) => fields[key].isRelation);
+  const args = {
+    entityTypeName: typeName,
+    computedContext,
+    ctx,
+    result,
+    include
+  };
+  const inverseRelationsToInclude = fieldsToInclude.filter((key) => fields[key].isInverseRelation);
+  const downloadRelationsPromises = relationsToInclude.map(
+    (fieldName) => downloadRelatedDocuments({ ...args, fieldName })
+  );
+  const downloadInverseRelationsPromises = inverseRelationsToInclude.map(
+    (fieldName) => downloadInverseRelationDocuments({ ...args, fieldName })
+  );
+  await Promise.all([...downloadRelationsPromises, ...downloadInverseRelationsPromises]);
 }
-function cleanUndefinedInner(obj) {
-  for (const key in obj) {
-    if (obj[key] === void 0)
-      delete obj[key];
-    if (___default.isPlainObject(obj[key]))
-      cleanUndefinedInner(obj[key]);
+async function downloadInverseRelationDocuments(args) {
+  const { computedContext, ctx, entityTypeName, fieldName, result, include } = args;
+  const { schema, db } = computedContext;
+  const field = schema[entityTypeName].fields?.[fieldName];
+  if (!field?.inverseRelationField)
+    throw new Error(`Cannot find field ${fieldName}`);
+  const typeName = field.type;
+  const type = schema[typeName];
+  if (!type)
+    throw new Error(`Cannot find entity ${typeName}`);
+  for (const item of result) {
+    if (!item?.id)
+      continue;
+    const entityHandle = schema[typeName].handle;
+    const documentsRelatedToThisDoc = await db[entityHandle].getMany(
+      { where: { [field.inverseRelationField]: { id: item.id } }, include: include?.[fieldName], maxItemCount: 100 },
+      ctx
+    );
+    item[fieldName] = documentsRelatedToThisDoc.nodes;
   }
 }
-
-function diff(object, base, includeDenormFields = false) {
-  if (!base)
-    return object;
-  return ___default.transform(object, (result, value, key) => {
-    const oldValue = base[key];
-    if (!___default.isEqual(value, oldValue)) {
-      if (mustUseDeepDiff(value, oldValue)) {
-        const isRelationField = (value.id || oldValue.id) && key !== "change";
-        if (isRelationField && !includeDenormFields) {
-          if (value.id !== oldValue.id)
-            result[key] = value;
-        } else {
-          const subDiff = diff(value, oldValue, includeDenormFields);
-          if (!___default.isEmpty(subDiff))
-            result[key] = subDiff;
-        }
-      } else {
-        result[key] = value;
+async function downloadRelatedDocuments(args) {
+  const { computedContext, ctx, entityTypeName, fieldName, result, include } = args;
+  const { schema, db } = computedContext;
+  const typeName = schema[entityTypeName].fields?.[fieldName].type || "";
+  const type = schema[typeName];
+  if (!type)
+    throw new Error(`Cannot find entity ${typeName}`);
+  const idsToGet = /* @__PURE__ */ new Set();
+  for (const item of result) {
+    if (!item)
+      continue;
+    const fieldValue = item[fieldName];
+    if (!fieldValue)
+      continue;
+    const fieldValues = ___default.isArray(fieldValue) ? fieldValue : [fieldValue];
+    for (const fv of fieldValues) {
+      const id = fv?.id;
+      if (!id)
+        continue;
+      idsToGet.add(id);
+    }
+  }
+  const entityHandle = schema[typeName].handle;
+  const relatedEntities = await db[entityHandle].getAll(
+    { where: { id_in: [...idsToGet] }, include: include?.[fieldName] },
+    ctx
+  );
+  const relatedEntitiesById = ___default.keyBy(relatedEntities, "id");
+  for (const item of result) {
+    if (!item)
+      continue;
+    const fieldValue = item[fieldName];
+    if (!fieldValue)
+      continue;
+    const fieldValues = ___default.isArray(fieldValue) ? fieldValue : [fieldValue];
+    for (const fv of fieldValues) {
+      const id = fv?.id;
+      if (!id)
+        continue;
+      const relatedEntity = relatedEntitiesById[id];
+      if (!relatedEntity) {
+        console.warn(`Cannot find ${typeName} with id "${id}" (for ${typeName}.${fieldName} with id "${item.id}")`);
       }
+      Object.assign(fv, relatedEntity);
     }
-  });
-}
-function mustUseDeepDiff(value, oldValue) {
-  return ___default.isObject(value) && ___default.isObject(oldValue) && !___default.isArray(value) && !___default.isArray(oldValue);
+  }
 }
 
 function getRadsDbMethods(key, computedContext, driverInstance) {
@@ -643,7 +756,7 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
     if (!result2)
       result2 = await driverInstance.getMany(args, ctx);
     if (args.include)
-      await handleInclude(computedContext, args.include, result2.nodes, ctx);
+      await radsDbRelations.handleInclude(computedContext, args.include, result2.nodes, ctx);
     await handleComputed(computedContext, result2.nodes, ctx);
     await afterGet(result2.nodes, args, ctx, computedContext);
     return result2;
@@ -680,7 +793,7 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
       }
       d.doc = validatedDoc;
     }
-    await fillDenormFieldsBeforePut(computedContext, docArgsToSave, ctx);
+    await radsDbRelations.fillDenormFieldsBeforePut(computedContext, docArgsToSave, ctx);
     const docsToSave = docArgsToSave.map((x) => x.doc);
     await driverInstance.putMany(docsToSave, ctx);
     await handleEffectsAfterPut(computedContext, docArgsToSave, beforePutResults, ctx);
@@ -723,7 +836,7 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
       }
       d.doc = validatedDoc;
     }
-    await fillDenormFieldsBeforePut(computedContext, docArgsToSave, ctx);
+    await radsDbRelations.fillDenormFieldsBeforePut(computedContext, docArgsToSave, ctx);
     for (const { oldDoc, doc } of docArgsToSave) {
       const d = diff(doc, oldDoc);
       if (___default.isEmpty(d))
@@ -782,7 +895,7 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
         result2 = await driverInstance.get(args, ctx);
       const resultArray = result2 ? [result2] : [];
       if (result2 && args.include)
-        await handleInclude(computedContext, args.include, resultArray, ctx);
+        await radsDbRelations.handleInclude(computedContext, args.include, resultArray, ctx);
       if (result2)
         await handleComputed(computedContext, resultArray, ctx);
       await afterGet(resultArray, args, ctx, computedContext);
@@ -795,7 +908,7 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
       if (!result2)
         result2 = await driverInstance.getAll(args, ctx);
       if (args.include)
-        await handleInclude(computedContext, args.include, result2, ctx);
+        await radsDbRelations.handleInclude(computedContext, args.include, result2, ctx);
       await handleComputed(computedContext, result2, ctx);
       await afterGet(result2, args, ctx, computedContext);
       return result2;
@@ -838,7 +951,7 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
         }
       }
       doc = validatedDoc;
-      await fillDenormFieldsBeforePut(computedContext, docArgsToSave, ctx);
+      await radsDbRelations.fillDenormFieldsBeforePut(computedContext, docArgsToSave, ctx);
       await driverInstance.put(doc, ctx);
       await handleEffectsAfterPut(computedContext, docArgsToSave, beforePutResults, ctx);
       await afterPut(docArgsToSave, ctx, computedContext);
@@ -873,61 +986,6 @@ async function afterPut(items, ctx, computedContext) {
     await f.afterPut?.(items, ctx, computedContext);
   }
 }
-async function handleInclude(computedContext, include, result, ctx) {
-  if (!result || !result.length || !include)
-    return;
-  const { schema, typeName, drivers } = computedContext;
-  const fields = schema[typeName].fields || {};
-  const relationsToInclude = ___default.keys(include).filter((key) => include[key] && fields[key].isRelation);
-  const downloadRelationsPromises = relationsToInclude.map(async (fieldName) => {
-    const typeName2 = fields[fieldName].type;
-    const type = schema[typeName2];
-    if (!type)
-      throw new Error(`Cannot find entity ${typeName2}`);
-    const idsToGet = /* @__PURE__ */ new Set();
-    for (const item of result) {
-      if (!item)
-        continue;
-      const fieldValue = item[fieldName];
-      if (!fieldValue)
-        continue;
-      const fieldValues = ___default.isArray(fieldValue) ? fieldValue : [fieldValue];
-      for (const fv of fieldValues) {
-        const id = fv?.id;
-        if (!id)
-          continue;
-        idsToGet.add(id);
-      }
-    }
-    const driverInstance = getExistingDriverInstance(typeName2, drivers);
-    const relatedEntities = await driverInstance.getAll({ where: { id_in: [...idsToGet] } }, ctx);
-    const relatedEntitiesById = ___default.keyBy(relatedEntities, "id");
-    for (const item of result) {
-      if (!item)
-        continue;
-      const fieldValue = item[fieldName];
-      if (!fieldValue)
-        continue;
-      const fieldValues = ___default.isArray(fieldValue) ? fieldValue : [fieldValue];
-      for (const fv of fieldValues) {
-        const id = fv?.id;
-        if (!id)
-          continue;
-        const relatedEntity = relatedEntitiesById[id];
-        if (!relatedEntity)
-          console.warn(`Cannot find ${typeName2} with id "${id}" (for ${typeName2}.${fieldName} with id "${item.id}")`);
-        Object.assign(fv, relatedEntity);
-      }
-    }
-  });
-  await Promise.all(downloadRelationsPromises);
-}
-function getExistingDriverInstance(entityName, drivers) {
-  if (!drivers[entityName]) {
-    throw new Error(`Driver for entity ${entityName} was not found!`);
-  }
-  return drivers[entityName];
-}
 
 function generateMethods(schema, validators, options) {
   const drivers = {};
@@ -957,7 +1015,7 @@ function generateMethods(schema, validators, options) {
   if (!opts.noComputed) {
     verifyComputedPresense(schema, opts.computed, effects);
   }
-  verifyRelationsSetup(schema, effects);
+  radsDbRelations.verifyRelationsSetup(schema, effects);
   const computedContextGlobal = {
     schema,
     validators,
@@ -1125,12 +1183,14 @@ const restApi = (options) => (schema, entity) => {
     }
     return responseJson;
   }
-  const pluralEntityName = ___default.lowerFirst(pluralize__default(entity));
+  const { handlePlural } = schema[entity] || {};
+  if (!handlePlural)
+    throw new Error(`Entity ${entity} was not found in schema`);
   const instance = {
     driverName: "restApi",
     async getMany(args) {
       args = args || {};
-      const url = `${opts.baseUrl}/${pluralEntityName}`;
+      const url = `${opts.baseUrl}/${handlePlural}`;
       const fetchOptions = {
         method: "POST",
         body: JSON.stringify(args),
@@ -1140,7 +1200,7 @@ const restApi = (options) => (schema, entity) => {
       return await fetchInner(url, fetchOptions);
     },
     async putMany(item) {
-      const url = `${opts.baseUrl}/${pluralEntityName}`;
+      const url = `${opts.baseUrl}/${handlePlural}`;
       const fetchOptions = {
         method: "PUT",
         body: JSON.stringify({ data: item }),

package/dist/index.d.ts

@@ -89,9 +89,17 @@ type DeepPartialWithNullsItem<T> = T extends {
 type DeepPartial<T> = {
     [K in keyof T]?: NonNullable<T[K]> extends any[] ? DeepPartial<NonNullable<T[K]>[number]>[] : NonNullable<T[K]> extends Record<string, any> ? DeepPartial<T[K]> : T[K];
 };
+/** Indicates that this field is a relation to another entity in the database.
+ * Only id will be stored in the database.
+ * If you want to store additional fields, please, pass them as the second type argument */
 type Relation<T extends {
     id: any;
 }, K extends Exclude<keyof T, 'id'> = never> = Pick<T, K | 'id'>;
+/** Indicates that this is computed field - all documents that point to this document via Relation<>.
+ * Note: this field is not stored in the database at all. Returns up to 100 items and doesn't support pagination
+ * If you need more control, please, use separate request instead.
+ */
+type InverseRelation<EN extends keyof EntityMeta, _Field extends keyof EntityMeta[EN]['relations']> = EntityMeta[EN]['type'];
 type PutArgs<T> = {
     id: string;
 } & DeepPartialWithNulls<T>;
@@ -298,7 +306,9 @@ interface FieldDefinition {
     isRequired?: boolean;
     isArray?: boolean;
     isRelation?: boolean;
+    isInverseRelation?: boolean;
     isChange?: boolean;
+    inverseRelationField?: string;
     relationDenormFields?: string[];
     comment?: string;
     decorators?: Record<string, Record<string, any>>;
@@ -448,4 +458,4 @@ declare function createRadsDb(args?: CreateRadsDbArgs): RadsDb;
  */
 declare function createRadsDbClient(args?: CreateRadsDbClientArgs): RadsDb;
 
-export { Change, ComputedContext, ComputedContextGlobal, ComputedDecoratorArgs, CreateRadsArgsDrivers, CreateRadsDbArgs, CreateRadsDbArgsNormalized, CreateRadsDbClientArgs, DeepKeys, DeepPartial, DeepPartialWithNulls, DeepPartialWithNullsItem, Driver, DriverConstructor, EntityDecoratorArgs, EntityMethods, EnumDefinition, FieldDecoratorArgs, FieldDefinition, FileSystemNode, FileUploadArgs, FileUploadDriver, FileUploadResult, GenerateClientNormalizedOptions, GenerateClientOptions, Get, GetAggArgs, GetAggArgsAgg, GetAggArgsAny, GetAggResponse, GetArgs, GetArgsAny, GetArgsInclude, GetManyArgs, GetManyArgsAny, GetManyResponse, GetResponse, GetResponseInclude, GetResponseIncludeSelect, GetResponseNoInclude, GetRestRoutesArgs, GetRestRoutesOptions, GetRestRoutesResponse, MinimalDriver, Put, PutArgs, PutEffect, RadsFeature, RadsHookDoc, RadsRequestContext, RadsUiSlotDefinition, RadsUiSlotName, RadsVitePluginOptions, Relation, RequiredFields, RestDriverOptions, RestFileUploadDriverOptions, Schema, SchemaValidators, TypeDefinition, UiDecoratorArgs, UiFieldDecoratorArgs, ValidateEntityDecoratorArgs, ValidateFieldDecoratorArgs, ValidateStringDecoratorArgs, VerifyManyArgs, VerifyManyArgsAny, VerifyManyResponse, Where, WhereJsonContains, cleanUndefinedAndNull, computed, createRadsDb, createRadsDbClient, diff, entity, field, getDriverInstance, handlePrecomputed, keepHistory, merge, precomputed, ui, validate };
+export { Change, ComputedContext, ComputedContextGlobal, ComputedDecoratorArgs, CreateRadsArgsDrivers, CreateRadsDbArgs, CreateRadsDbArgsNormalized, CreateRadsDbClientArgs, DeepKeys, DeepPartial, DeepPartialWithNulls, DeepPartialWithNullsItem, Driver, DriverConstructor, EntityDecoratorArgs, EntityMethods, EnumDefinition, FieldDecoratorArgs, FieldDefinition, FileSystemNode, FileUploadArgs, FileUploadDriver, FileUploadResult, GenerateClientNormalizedOptions, GenerateClientOptions, Get, GetAggArgs, GetAggArgsAgg, GetAggArgsAny, GetAggResponse, GetArgs, GetArgsAny, GetArgsInclude, GetManyArgs, GetManyArgsAny, GetManyResponse, GetResponse, GetResponseInclude, GetResponseIncludeSelect, GetResponseNoInclude, GetRestRoutesArgs, GetRestRoutesOptions, GetRestRoutesResponse, InverseRelation, MinimalDriver, Put, PutArgs, PutEffect, RadsFeature, RadsHookDoc, RadsRequestContext, RadsUiSlotDefinition, RadsUiSlotName, RadsVitePluginOptions, Relation, RequiredFields, RestDriverOptions, RestFileUploadDriverOptions, Schema, SchemaValidators, TypeDefinition, UiDecoratorArgs, UiFieldDecoratorArgs, ValidateEntityDecoratorArgs, ValidateFieldDecoratorArgs, ValidateStringDecoratorArgs, VerifyManyArgs, VerifyManyArgsAny, VerifyManyResponse, Where, WhereJsonContains, cleanUndefinedAndNull, computed, createRadsDb, createRadsDbClient, diff, entity, field, getDriverInstance, handlePrecomputed, keepHistory, merge, precomputed, ui, validate };

package/dist/index.mjs

@@ -1,9 +1,8 @@
-import { z, ZodError } from 'zod';
+import { z, ZodNullable, ZodOptional, ZodLazy, ZodObject, ZodError } from 'zod';
 import _ from 'lodash';
 import { v4 } from 'uuid';
 import createMerge from '@fastify/deepmerge';
 import { schema } from '_rads-db';
-import pluralize from 'pluralize';
 
 function generateValidators(schema) {
   const zodSchemas = {};
@@ -50,7 +49,7 @@ function getZodSchema(zodSchemas, schema, key) {
   const objectSchema = {};
   for (const fieldName in type.fields) {
     const f = type.fields[fieldName];
-    if (f.decorators?.computed || f.decorators?.precomputed) {
+    if (f.decorators?.computed || f.decorators?.precomputed || f.isInverseRelation) {
       continue;
     }
     objectSchema[fieldName] = getFieldZodSchema(zodSchemas, schema, f);
@@ -74,7 +73,7 @@ function getFieldZodSchemaBase(zodSchemas, schema, field) {
     const zodSchema = getZodSchema(zodSchemas, schema, field.type);
     if (!zodSchema)
       throw new Error(`Cannot find zod schema for type: ${field.type}`);
-    return zodSchema.deepPartial().omit({ id: true });
+    return deepPartial(zodSchema.omit({ id: true }));
   }
   if (field.type === "string")
     return z.string();
@@ -98,6 +97,25 @@ function getFieldZodSchemaBase(zodSchemas, schema, field) {
   }
   throw new Error(`Unknown type: ${field.type}`);
 }
+function deepPartial(zodSchema) {
+  const shape = zodSchema.shape;
+  const newShape = {};
+  for (const key in shape) {
+    let field = shape[key];
+    while (field instanceof ZodNullable || field instanceof ZodOptional) {
+      field = field.unwrap();
+    }
+    if (field instanceof ZodLazy) {
+      field = field.schema;
+    }
+    if (field instanceof ZodObject) {
+      newShape[key] = deepPartial(field).optional().nullable();
+    } else {
+      newShape[key] = field.optional().nullable();
+    }
+  }
+  return z.object(newShape);
+}
 class ValidationError extends Error {
   constructor(error) {
     const firstError = error.errors[0];
@@ -483,6 +501,73 @@ async function handleEffectsAfterPut(context, docs, beforePutResults, ctx) {
   );
 }
 
+function cleanUndefinedAndNull(obj, isChange = false) {
+  for (const key in obj) {
+    if (obj[key] == null && !isChange)
+      delete obj[key];
+    if (_.isPlainObject(obj[key]))
+      cleanUndefinedAndNull(obj[key], isChange || key === "change");
+  }
+}
+
+const mergeFn = createMerge({
+  mergeArray(options) {
+    const clone = options.clone;
+    return function(target, source) {
+      return clone(source);
+    };
+  }
+});
+function merge(target, source) {
+  cleanUndefined(source);
+  const result = mergeFn(target, source);
+  return result;
+}
+function cleanUndefined(obj) {
+  if (!obj || !_.isPlainObject(obj))
+    return;
+  cleanUndefinedInner(obj);
+}
+function cleanUndefinedInner(obj) {
+  for (const key in obj) {
+    if (obj[key] === void 0)
+      delete obj[key];
+    if (_.isPlainObject(obj[key]))
+      cleanUndefinedInner(obj[key]);
+  }
+}
+
+function diff(object, base, includeDenormFields = false) {
+  if (!base)
+    return object;
+  return _.transform(object, (result, value, key) => {
+    const oldValue = base[key];
+    if (!_.isEqual(value, oldValue)) {
+      if (mustUseDeepDiff(value, oldValue)) {
+        const isRelationField = (value.id || oldValue.id) && key !== "change";
+        if (isRelationField && !includeDenormFields) {
+          if (value.id !== oldValue.id)
+            result[key] = value;
+        } else {
+          const subDiff = diff(value, oldValue, includeDenormFields);
+          if (!_.isEmpty(subDiff))
+            result[key] = subDiff;
+        }
+      } else {
+        result[key] = value;
+      }
+    }
+  });
+}
+function mustUseDeepDiff(value, oldValue) {
+  return _.isObject(value) && _.isObject(oldValue) && !_.isArray(value) && !_.isArray(oldValue);
+}
+
+const radsDbRelations = {
+  verifyRelationsSetup,
+  fillDenormFieldsBeforePut,
+  handleInclude
+};
 function verifyRelationsSetup(schema, effects) {
   for (const entityName in schema) {
     const entity = schema[entityName];
@@ -562,67 +647,96 @@ async function fillDenormFieldsBeforePut(computedContext, docUpdates, ctx) {
   });
   await Promise.all(promises);
 }
-
-function cleanUndefinedAndNull(obj, isChange = false) {
-  for (const key in obj) {
-    if (obj[key] == null && !isChange)
-      delete obj[key];
-    if (_.isPlainObject(obj[key]))
-      cleanUndefinedAndNull(obj[key], key === "change");
-  }
-}
-
-const mergeFn = createMerge({
-  mergeArray(options) {
-    const clone = options.clone;
-    return function(target, source) {
-      return clone(source);
-    };
-  }
-});
-function merge(target, source) {
-  cleanUndefined(source);
-  const result = mergeFn(target, source);
-  return result;
-}
-function cleanUndefined(obj) {
-  if (!obj || !_.isPlainObject(obj))
+async function handleInclude(computedContext, include, result, ctx) {
+  if (!result || !result.length || !include)
     return;
-  cleanUndefinedInner(obj);
+  const { schema, typeName } = computedContext;
+  const fields = schema[typeName].fields || {};
+  const fieldsToInclude = _.keys(include).filter((key) => include[key]);
+  const relationsToInclude = fieldsToInclude.filter((key) => fields[key].isRelation);
+  const args = {
+    entityTypeName: typeName,
+    computedContext,
+    ctx,
+    result,
+    include
+  };
+  const inverseRelationsToInclude = fieldsToInclude.filter((key) => fields[key].isInverseRelation);
+  const downloadRelationsPromises = relationsToInclude.map(
+    (fieldName) => downloadRelatedDocuments({ ...args, fieldName })
+  );
+  const downloadInverseRelationsPromises = inverseRelationsToInclude.map(
+    (fieldName) => downloadInverseRelationDocuments({ ...args, fieldName })
+  );
+  await Promise.all([...downloadRelationsPromises, ...downloadInverseRelationsPromises]);
 }
-function cleanUndefinedInner(obj) {
-  for (const key in obj) {
-    if (obj[key] === void 0)
-      delete obj[key];
-    if (_.isPlainObject(obj[key]))
-      cleanUndefinedInner(obj[key]);
+async function downloadInverseRelationDocuments(args) {
+  const { computedContext, ctx, entityTypeName, fieldName, result, include } = args;
+  const { schema, db } = computedContext;
+  const field = schema[entityTypeName].fields?.[fieldName];
+  if (!field?.inverseRelationField)
+    throw new Error(`Cannot find field ${fieldName}`);
+  const typeName = field.type;
+  const type = schema[typeName];
+  if (!type)
+    throw new Error(`Cannot find entity ${typeName}`);
+  for (const item of result) {
+    if (!item?.id)
+      continue;
+    const entityHandle = schema[typeName].handle;
+    const documentsRelatedToThisDoc = await db[entityHandle].getMany(
+      { where: { [field.inverseRelationField]: { id: item.id } }, include: include?.[fieldName], maxItemCount: 100 },
+      ctx
+    );
+    item[fieldName] = documentsRelatedToThisDoc.nodes;
   }
 }
-
-function diff(object, base, includeDenormFields = false) {
-  if (!base)
-    return object;
-  return _.transform(object, (result, value, key) => {
-    const oldValue = base[key];
-    if (!_.isEqual(value, oldValue)) {
-      if (mustUseDeepDiff(value, oldValue)) {
-        const isRelationField = (value.id || oldValue.id) && key !== "change";
-        if (isRelationField && !includeDenormFields) {
-          if (value.id !== oldValue.id)
-            result[key] = value;
-        } else {
-          const subDiff = diff(value, oldValue, includeDenormFields);
-          if (!_.isEmpty(subDiff))
-            result[key] = subDiff;
-        }
-      } else {
-        result[key] = value;
+async function downloadRelatedDocuments(args) {
+  const { computedContext, ctx, entityTypeName, fieldName, result, include } = args;
+  const { schema, db } = computedContext;
+  const typeName = schema[entityTypeName].fields?.[fieldName].type || "";
+  const type = schema[typeName];
+  if (!type)
+    throw new Error(`Cannot find entity ${typeName}`);
+  const idsToGet = /* @__PURE__ */ new Set();
+  for (const item of result) {
+    if (!item)
+      continue;
+    const fieldValue = item[fieldName];
+    if (!fieldValue)
+      continue;
+    const fieldValues = _.isArray(fieldValue) ? fieldValue : [fieldValue];
+    for (const fv of fieldValues) {
+      const id = fv?.id;
+      if (!id)
+        continue;
+      idsToGet.add(id);
+    }
+  }
+  const entityHandle = schema[typeName].handle;
+  const relatedEntities = await db[entityHandle].getAll(
+    { where: { id_in: [...idsToGet] }, include: include?.[fieldName] },
+    ctx
+  );
+  const relatedEntitiesById = _.keyBy(relatedEntities, "id");
+  for (const item of result) {
+    if (!item)
+      continue;
+    const fieldValue = item[fieldName];
+    if (!fieldValue)
+      continue;
+    const fieldValues = _.isArray(fieldValue) ? fieldValue : [fieldValue];
+    for (const fv of fieldValues) {
+      const id = fv?.id;
+      if (!id)
+        continue;
+      const relatedEntity = relatedEntitiesById[id];
+      if (!relatedEntity) {
+        console.warn(`Cannot find ${typeName} with id "${id}" (for ${typeName}.${fieldName} with id "${item.id}")`);
       }
+      Object.assign(fv, relatedEntity);
     }
-  });
-}
-function mustUseDeepDiff(value, oldValue) {
-  return _.isObject(value) && _.isObject(oldValue) && !_.isArray(value) && !_.isArray(oldValue);
+  }
 }
 
 function getRadsDbMethods(key, computedContext, driverInstance) {
@@ -635,7 +749,7 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
     if (!result2)
       result2 = await driverInstance.getMany(args, ctx);
     if (args.include)
-      await handleInclude(computedContext, args.include, result2.nodes, ctx);
+      await radsDbRelations.handleInclude(computedContext, args.include, result2.nodes, ctx);
     await handleComputed(computedContext, result2.nodes, ctx);
     await afterGet(result2.nodes, args, ctx, computedContext);
     return result2;
@@ -672,7 +786,7 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
       }
       d.doc = validatedDoc;
     }
-    await fillDenormFieldsBeforePut(computedContext, docArgsToSave, ctx);
+    await radsDbRelations.fillDenormFieldsBeforePut(computedContext, docArgsToSave, ctx);
     const docsToSave = docArgsToSave.map((x) => x.doc);
     await driverInstance.putMany(docsToSave, ctx);
     await handleEffectsAfterPut(computedContext, docArgsToSave, beforePutResults, ctx);
@@ -715,7 +829,7 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
       }
       d.doc = validatedDoc;
     }
-    await fillDenormFieldsBeforePut(computedContext, docArgsToSave, ctx);
+    await radsDbRelations.fillDenormFieldsBeforePut(computedContext, docArgsToSave, ctx);
     for (const { oldDoc, doc } of docArgsToSave) {
       const d = diff(doc, oldDoc);
       if (_.isEmpty(d))
@@ -774,7 +888,7 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
         result2 = await driverInstance.get(args, ctx);
       const resultArray = result2 ? [result2] : [];
       if (result2 && args.include)
-        await handleInclude(computedContext, args.include, resultArray, ctx);
+        await radsDbRelations.handleInclude(computedContext, args.include, resultArray, ctx);
       if (result2)
         await handleComputed(computedContext, resultArray, ctx);
       await afterGet(resultArray, args, ctx, computedContext);
@@ -787,7 +901,7 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
       if (!result2)
         result2 = await driverInstance.getAll(args, ctx);
       if (args.include)
-        await handleInclude(computedContext, args.include, result2, ctx);
+        await radsDbRelations.handleInclude(computedContext, args.include, result2, ctx);
       await handleComputed(computedContext, result2, ctx);
       await afterGet(result2, args, ctx, computedContext);
       return result2;
@@ -830,7 +944,7 @@ function getRadsDbMethods(key, computedContext, driverInstance) {
         }
       }
       doc = validatedDoc;
-      await fillDenormFieldsBeforePut(computedContext, docArgsToSave, ctx);
+      await radsDbRelations.fillDenormFieldsBeforePut(computedContext, docArgsToSave, ctx);
       await driverInstance.put(doc, ctx);
       await handleEffectsAfterPut(computedContext, docArgsToSave, beforePutResults, ctx);
       await afterPut(docArgsToSave, ctx, computedContext);
@@ -865,61 +979,6 @@ async function afterPut(items, ctx, computedContext) {
     await f.afterPut?.(items, ctx, computedContext);
   }
 }
-async function handleInclude(computedContext, include, result, ctx) {
-  if (!result || !result.length || !include)
-    return;
-  const { schema, typeName, drivers } = computedContext;
-  const fields = schema[typeName].fields || {};
-  const relationsToInclude = _.keys(include).filter((key) => include[key] && fields[key].isRelation);
-  const downloadRelationsPromises = relationsToInclude.map(async (fieldName) => {
-    const typeName2 = fields[fieldName].type;
-    const type = schema[typeName2];
-    if (!type)
-      throw new Error(`Cannot find entity ${typeName2}`);
-    const idsToGet = /* @__PURE__ */ new Set();
-    for (const item of result) {
-      if (!item)
-        continue;
-      const fieldValue = item[fieldName];
-      if (!fieldValue)
-        continue;
-      const fieldValues = _.isArray(fieldValue) ? fieldValue : [fieldValue];
-      for (const fv of fieldValues) {
-        const id = fv?.id;
-        if (!id)
-          continue;
-        idsToGet.add(id);
-      }
-    }
-    const driverInstance = getExistingDriverInstance(typeName2, drivers);
-    const relatedEntities = await driverInstance.getAll({ where: { id_in: [...idsToGet] } }, ctx);
-    const relatedEntitiesById = _.keyBy(relatedEntities, "id");
-    for (const item of result) {
-      if (!item)
-        continue;
-      const fieldValue = item[fieldName];
-      if (!fieldValue)
-        continue;
-      const fieldValues = _.isArray(fieldValue) ? fieldValue : [fieldValue];
-      for (const fv of fieldValues) {
-        const id = fv?.id;
-        if (!id)
-          continue;
-        const relatedEntity = relatedEntitiesById[id];
-        if (!relatedEntity)
-          console.warn(`Cannot find ${typeName2} with id "${id}" (for ${typeName2}.${fieldName} with id "${item.id}")`);
-        Object.assign(fv, relatedEntity);
-      }
-    }
-  });
-  await Promise.all(downloadRelationsPromises);
-}
-function getExistingDriverInstance(entityName, drivers) {
-  if (!drivers[entityName]) {
-    throw new Error(`Driver for entity ${entityName} was not found!`);
-  }
-  return drivers[entityName];
-}
 
 function generateMethods(schema, validators, options) {
   const drivers = {};
@@ -949,7 +1008,7 @@ function generateMethods(schema, validators, options) {
   if (!opts.noComputed) {
     verifyComputedPresense(schema, opts.computed, effects);
   }
-  verifyRelationsSetup(schema, effects);
+  radsDbRelations.verifyRelationsSetup(schema, effects);
   const computedContextGlobal = {
     schema,
     validators,
@@ -1117,12 +1176,14 @@ const restApi = (options) => (schema, entity) => {
     }
     return responseJson;
   }
-  const pluralEntityName = _.lowerFirst(pluralize(entity));
+  const { handlePlural } = schema[entity] || {};
+  if (!handlePlural)
+    throw new Error(`Entity ${entity} was not found in schema`);
   const instance = {
     driverName: "restApi",
     async getMany(args) {
       args = args || {};
-      const url = `${opts.baseUrl}/${pluralEntityName}`;
+      const url = `${opts.baseUrl}/${handlePlural}`;
       const fetchOptions = {
         method: "POST",
         body: JSON.stringify(args),
@@ -1132,7 +1193,7 @@ const restApi = (options) => (schema, entity) => {
       return await fetchInner(url, fetchOptions);
     },
     async putMany(item) {
-      const url = `${opts.baseUrl}/${pluralEntityName}`;
+      const url = `${opts.baseUrl}/${handlePlural}`;
       const fetchOptions = {
         method: "PUT",
         body: JSON.stringify({ data: item }),

package/drivers/restApi.cjs

@@ -4,9 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 module.exports = void 0;
-var _lodash = _interopRequireDefault(require("lodash"));
-var _pluralize = _interopRequireDefault(require("pluralize"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 var _default = options => (schema, entity) => {
   const opts = {
     baseUrl: "/api",
@@ -30,12 +27,15 @@ var _default = options => (schema, entity) => {
     }
     return responseJson;
   }
-  const pluralEntityName = _lodash.default.lowerFirst((0, _pluralize.default)(entity));
+  const {
+    handlePlural
+  } = schema[entity] || {};
+  if (!handlePlural) throw new Error(`Entity ${entity} was not found in schema`);
   const instance = {
     driverName: "restApi",
     async getMany(args) {
       args = args || {};
-      const url = `${opts.baseUrl}/${pluralEntityName}`;
+      const url = `${opts.baseUrl}/${handlePlural}`;
       const fetchOptions = {
         method: "POST",
         body: JSON.stringify(args),
@@ -50,7 +50,7 @@ var _default = options => (schema, entity) => {
       return await fetchInner(url, fetchOptions);
     },
     async putMany(item) {
-      const url = `${opts.baseUrl}/${pluralEntityName}`;
+      const url = `${opts.baseUrl}/${handlePlural}`;
       const fetchOptions = {
         method: "PUT",
         body: JSON.stringify({

package/drivers/restApi.mjs

@@ -1,5 +1,3 @@
-import _ from "lodash";
-import pluralize from "pluralize";
 export default (options) => (schema, entity) => {
   const opts = {
     baseUrl: "/api",
@@ -24,12 +22,14 @@ export default (options) => (schema, entity) => {
     }
     return responseJson;
   }
-  const pluralEntityName = _.lowerFirst(pluralize(entity));
+  const { handlePlural } = schema[entity] || {};
+  if (!handlePlural)
+    throw new Error(`Entity ${entity} was not found in schema`);
   const instance = {
     driverName: "restApi",
     async getMany(args) {
       args = args || {};
-      const url = `${opts.baseUrl}/${pluralEntityName}`;
+      const url = `${opts.baseUrl}/${handlePlural}`;
       const fetchOptions = {
         method: "POST",
         body: JSON.stringify(args),
@@ -39,7 +39,7 @@ export default (options) => (schema, entity) => {
       return await fetchInner(url, fetchOptions);
     },
     async putMany(item) {
-      const url = `${opts.baseUrl}/${pluralEntityName}`;
+      const url = `${opts.baseUrl}/${handlePlural}`;
       const fetchOptions = {
         method: "PUT",
         body: JSON.stringify({ data: item }),

package/features/cache.cjs

@@ -22,8 +22,7 @@ var _default = options => {
       async function preloadEntities(entitiesToPreload) {
         for (const typeName in entitiesToPreload) {
           const {
-            where,
-            revalidateInterval
+            where
           } = entitiesToPreload[typeName];
           const handle = schema[typeName]?.handle;
           if (!handle) throw new Error(`Entity ${typeName} was not found`);
@@ -54,7 +53,7 @@ var _default = options => {
           ...schema[typeName],
           name: cacheEntityName,
           handle: cacheEntityName,
-          handlePlural: `${cacheEntityName}s`
+          handlePlural: `${cacheEntityName}/list`
         };
         cacheDrivers[handle] = (0, _radsDb.getDriverInstance)(schema, cacheEntityName, normalizedOptions[typeName].driver, drivers);
         cacheStatus[handle] = {

package/features/cache.mjs

@@ -11,7 +11,7 @@ export default (options) => {
       const { schema, drivers } = context;
       async function preloadEntities(entitiesToPreload) {
         for (const typeName in entitiesToPreload) {
-          const { where, revalidateInterval } = entitiesToPreload[typeName];
+          const { where } = entitiesToPreload[typeName];
           const handle = schema[typeName]?.handle;
           if (!handle)
             throw new Error(`Entity ${typeName} was not found`);
@@ -36,7 +36,7 @@ export default (options) => {
           ...schema[typeName],
           name: cacheEntityName,
           handle: cacheEntityName,
-          handlePlural: `${cacheEntityName}s`
+          handlePlural: `${cacheEntityName}/list`
         };
         cacheDrivers[handle] = getDriverInstance(schema, cacheEntityName, normalizedOptions[typeName].driver, drivers);
         cacheStatus[handle] = { preloadStatus: normalizedOptions[typeName].preload ? "neverLoaded" : void 0 };

package/integrations/lib.cjs

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", {
 exports.parseSchema = parseSchema;
 var _typescript = require("typescript");
 var _lodash = _interopRequireDefault(require("lodash"));
-var _pluralize = _interopRequireDefault(require("pluralize"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const supportedPrimitiveTypes = ["string", "number", "boolean", "Record<string, string>", "Record<string, any>"];
 function parseSchema(typescriptFiles) {
@@ -186,7 +185,7 @@ function parseClassDeclaration(typeDeclaration, typeName, ctx) {
     fields[field.name] = field;
   }
   const handle = _lodash.default.lowerFirst(name);
-  const handlePlural = (0, _pluralize.default)(handle);
+  const handlePlural = `${handle}/list`;
   const result = {
     name,
     handle,
@@ -268,23 +267,13 @@ function parseClassMember(node, parentFields, parentName, ctx) {
     if (!parentField) throw new Error(`Cannot find field ${parentName}.${defaultValueCopyFrom}"`);
     defaultValueType = parentField.type;
   }
-  const {
-    isArray,
-    isRelation,
-    isChange,
-    relationDenormFields,
-    type
-  } = parseFieldType(ctx, parentName, name, node, defaultValueType);
+  const parsedType = parseFieldType(ctx, parentName, name, node, defaultValueType);
   const result = {
-    type,
+    ...parsedType,
     defaultValue,
     defaultValueCopyFrom,
     name,
     isRequired,
-    isArray,
-    isRelation,
-    isChange,
-    relationDenormFields,
     comment
   };
   if (!_lodash.default.isEmpty(decorators)) result.decorators = decorators;
@@ -311,6 +300,7 @@ function parseFieldType(ctx, parentName, fieldName, node, defaultValueType) {
   };
   parseFieldTypeArray(parsedType, parentName);
   parseFieldTypeRelation(parsedType, parentName, ctx);
+  parseFieldTypeInverseRelation(parsedType, parentName, ctx);
   parseFieldTypeInlineEnum(parsedType, parentName, fieldName, ctx);
   parseFieldTypeKeyofEnum(parsedType, parentName, fieldName, ctx);
   parseFieldTypeRecordEnum(parsedType, parentName, fieldName, ctx);
@@ -328,8 +318,10 @@ function parseFieldType(ctx, parentName, fieldName, node, defaultValueType) {
   return {
     isArray: parsedType.isArray || void 0,
     isRelation: parsedType.isRelation || void 0,
+    isInverseRelation: parsedType.isInverseRelation || void 0,
     isChange: parsedType.isChange || void 0,
     relationDenormFields: parsedType.relationDenormFields,
+    inverseRelationField: parsedType.inverseRelationField,
     type: parsedType.type
   };
 }
@@ -382,6 +374,28 @@ function parseFieldTypeRelation(parsedType, parentName, ctx) {
     }
   }
 }
+function parseFieldTypeInverseRelation(parsedType, parentName, ctx) {
+  if (parsedType.nodeType?.kind !== _typescript.SyntaxKind.TypeReference) return;
+  const nt = parsedType.nodeType;
+  if (nt.typeName.getText(ctx.sourceFile) === "InverseRelation") {
+    if (!nt.typeArguments?.length) throw new Error(`Missing type argument for Relation<>: '${parentName}'`);
+    parsedType.type = parseStringField(ctx, nt.typeArguments[0]);
+    parsedType.isInverseRelation = true;
+    if (nt.typeArguments[1]) {
+      const taNode = nt.typeArguments[1];
+      parsedType.inverseRelationField = parseStringField(ctx, taNode);
+    }
+  }
+}
+function parseStringField(ctx, node) {
+  if (node.kind === _typescript.SyntaxKind.LiteralType) {
+    const literal = node.literal;
+    if (literal.kind === _typescript.SyntaxKind.StringLiteral) {
+      return literal.text;
+    }
+  }
+  throw new Error(`Unexpected type - ${node.getText(ctx.sourceFile)}`);
+}
 function parseFieldTypeInlineEnum(parsedType, parentName, fieldName, ctx) {
   if (parsedType.nodeType?.kind !== _typescript.SyntaxKind.UnionType) return;
   const nt = parsedType.nodeType;
@@ -564,6 +578,14 @@ function verifyRelationFields(result) {
       if (field.isRelation && !result[field.type]?.decorators?.entity) {
         throw new Error(`${key}.${fieldName}: Relation must point to an entity. Got "${field.type}" instead.`);
       }
+      if (field.isInverseRelation) {
+        if (!result[field.type]?.decorators?.entity) throw new Error(`${key}.${fieldName}: InverseRelation must point to an entity. Got "${field.type}" instead.`);
+        if (field.isRequired) throw new Error(`${key}.${fieldName}: InverseRelation cannot be required. Please, add "?" to the field name.`);
+        if (!field.isArray) throw new Error(`${key}.${fieldName}: InverseRelation must be an array.`);
+        if (!field.inverseRelationField) throw new Error(`${key}.${fieldName}: InverseRelation must have a field name.`);
+        if (!result[field.type]?.fields?.[field.inverseRelationField]?.isRelation) throw new Error(`${key}.${fieldName}: InverseRelation field must point to relation field. Got "${field.inverseRelationField}" instead.`);
+        if (result[field.type]?.fields?.[field.inverseRelationField]?.type !== key) throw new Error(`${key}.${fieldName}: InverseRelation field must point to the current entity. Got "${field.inverseRelationField}" instead.`);
+      }
     }
   }
 }

package/integrations/lib.mjs

@@ -1,6 +1,5 @@
 import { ScriptTarget, SyntaxKind, createSourceFile } from "typescript";
 import _ from "lodash";
-import pluralize from "pluralize";
 const supportedPrimitiveTypes = ["string", "number", "boolean", "Record<string, string>", "Record<string, any>"];
 export function parseSchema(typescriptFiles) {
   const typeNodesMap = getTypeNodesMap(typescriptFiles);
@@ -163,7 +162,7 @@ function parseClassDeclaration(typeDeclaration, typeName, ctx) {
     fields[field.name] = field;
   }
   const handle = _.lowerFirst(name);
-  const handlePlural = pluralize(handle);
+  const handlePlural = `${handle}/list`;
   const result = {
     name,
     handle,
@@ -232,23 +231,13 @@ function parseClassMember(node, parentFields, parentName, ctx) {
       throw new Error(`Cannot find field ${parentName}.${defaultValueCopyFrom}"`);
     defaultValueType = parentField.type;
   }
-  const { isArray, isRelation, isChange, relationDenormFields, type } = parseFieldType(
-    ctx,
-    parentName,
-    name,
-    node,
-    defaultValueType
-  );
+  const parsedType = parseFieldType(ctx, parentName, name, node, defaultValueType);
   const result = {
-    type,
+    ...parsedType,
     defaultValue,
     defaultValueCopyFrom,
     name,
     isRequired,
-    isArray,
-    isRelation,
-    isChange,
-    relationDenormFields,
     comment
   };
   if (!_.isEmpty(decorators))
@@ -282,6 +271,7 @@ function parseFieldType(ctx, parentName, fieldName, node, defaultValueType) {
   };
   parseFieldTypeArray(parsedType, parentName);
   parseFieldTypeRelation(parsedType, parentName, ctx);
+  parseFieldTypeInverseRelation(parsedType, parentName, ctx);
   parseFieldTypeInlineEnum(parsedType, parentName, fieldName, ctx);
   parseFieldTypeKeyofEnum(parsedType, parentName, fieldName, ctx);
   parseFieldTypeRecordEnum(parsedType, parentName, fieldName, ctx);
@@ -301,8 +291,10 @@ function parseFieldType(ctx, parentName, fieldName, node, defaultValueType) {
   return {
     isArray: parsedType.isArray || void 0,
     isRelation: parsedType.isRelation || void 0,
+    isInverseRelation: parsedType.isInverseRelation || void 0,
     isChange: parsedType.isChange || void 0,
     relationDenormFields: parsedType.relationDenormFields,
+    inverseRelationField: parsedType.inverseRelationField,
     type: parsedType.type
   };
 }
@@ -360,6 +352,30 @@ function parseFieldTypeRelation(parsedType, parentName, ctx) {
     }
   }
 }
+function parseFieldTypeInverseRelation(parsedType, parentName, ctx) {
+  if (parsedType.nodeType?.kind !== SyntaxKind.TypeReference)
+    return;
+  const nt = parsedType.nodeType;
+  if (nt.typeName.getText(ctx.sourceFile) === "InverseRelation") {
+    if (!nt.typeArguments?.length)
+      throw new Error(`Missing type argument for Relation<>: '${parentName}'`);
+    parsedType.type = parseStringField(ctx, nt.typeArguments[0]);
+    parsedType.isInverseRelation = true;
+    if (nt.typeArguments[1]) {
+      const taNode = nt.typeArguments[1];
+      parsedType.inverseRelationField = parseStringField(ctx, taNode);
+    }
+  }
+}
+function parseStringField(ctx, node) {
+  if (node.kind === SyntaxKind.LiteralType) {
+    const literal = node.literal;
+    if (literal.kind === SyntaxKind.StringLiteral) {
+      return literal.text;
+    }
+  }
+  throw new Error(`Unexpected type - ${node.getText(ctx.sourceFile)}`);
+}
 function parseFieldTypeInlineEnum(parsedType, parentName, fieldName, ctx) {
   if (parsedType.nodeType?.kind !== SyntaxKind.UnionType)
     return;
@@ -537,6 +553,24 @@ function verifyRelationFields(result) {
       if (field.isRelation && !result[field.type]?.decorators?.entity) {
         throw new Error(`${key}.${fieldName}: Relation must point to an entity. Got "${field.type}" instead.`);
       }
+      if (field.isInverseRelation) {
+        if (!result[field.type]?.decorators?.entity)
+          throw new Error(`${key}.${fieldName}: InverseRelation must point to an entity. Got "${field.type}" instead.`);
+        if (field.isRequired)
+          throw new Error(`${key}.${fieldName}: InverseRelation cannot be required. Please, add "?" to the field name.`);
+        if (!field.isArray)
+          throw new Error(`${key}.${fieldName}: InverseRelation must be an array.`);
+        if (!field.inverseRelationField)
+          throw new Error(`${key}.${fieldName}: InverseRelation must have a field name.`);
+        if (!result[field.type]?.fields?.[field.inverseRelationField]?.isRelation)
+          throw new Error(
+            `${key}.${fieldName}: InverseRelation field must point to relation field. Got "${field.inverseRelationField}" instead.`
+          );
+        if (result[field.type]?.fields?.[field.inverseRelationField]?.type !== key)
+          throw new Error(
+            `${key}.${fieldName}: InverseRelation field must point to the current entity. Got "${field.inverseRelationField}" instead.`
+          );
+      }
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rads-db",
-  "version": "3.0.58",
+  "version": "3.0.62",
   "packageManager": "pnpm@8.6.1",
   "description": "Say goodbye to boilerplate code and hello to efficient and elegant syntax.",
   "author": "",
@@ -77,7 +77,6 @@
     "ignore": "^5.2.4",
     "klaw": "^4.1.0",
     "lodash": "^4.17.21",
-    "pluralize": "^8.0.0",
     "uuid": ">=8",
     "zod": "^3.21.4"
   },
@@ -87,7 +86,6 @@
     "@types/eslint": "^8.44.8",
     "@types/klaw": "^3.0.3",
     "@types/lodash": "4.14.191",
-    "@types/pluralize": "^0.0.29",
     "@types/uuid": "^9.0.2",
     "@vitest/ui": "^1.6.0",
     "cross-env": "^7.0.3",