rads-db 3.0.73 → 3.0.75

package/dist/index.cjs

@@ -662,6 +662,9 @@ async function handleInclude(computedContext, include, result, ctx) {
   const { schema, typeName } = computedContext;
   const fields = schema[typeName].fields || {};
   const fieldsToInclude = ___default.keys(include).filter((key) => include[key]);
+  const nestedFieldsToInclude = fieldsToInclude.filter(
+    (key) => !fields[key].isRelation && !fields[key].isInverseRelation && schema[fields[key].type]?.fields
+  );
   const relationsToInclude = fieldsToInclude.filter((key) => fields[key].isRelation);
   const args = {
     entityTypeName: typeName,
@@ -670,6 +673,15 @@ async function handleInclude(computedContext, include, result, ctx) {
     result,
     include
   };
+  for (const nf of nestedFieldsToInclude) {
+    const resultsWithNestedField = result.filter((item) => item[nf]);
+    await handleInclude(
+      { ...computedContext, typeName: fields[nf].type },
+      include[nf],
+      resultsWithNestedField.map((x) => x[nf]),
+      ctx
+    );
+  }
   const inverseRelationsToInclude = fieldsToInclude.filter((key) => fields[key].isInverseRelation);
   const downloadRelationsPromises = relationsToInclude.map(
     (fieldName) => downloadRelatedDocuments({ ...args, fieldName })

package/dist/index.d.ts

@@ -42,12 +42,13 @@ type GetManyArgsAny = GetManyArgs<any>;
 type GetArgsAny = GetArgs<any>;
 type GetAggArgsAny = GetAggArgs<any>;
 type VerifyManyArgsAny = VerifyManyArgs<any>;
-type GetArgsInclude<EN extends keyof EntityMeta, R extends keyof EntityMeta[EN]['relations'] = keyof EntityMeta[EN]['relations']> = [R] extends [never] ? {
+type RelationsAndNestedObjects<EN extends keyof EntityMeta> = EntityMeta[EN]['relations'] & EntityMeta[EN]['nestedObjects'];
+type GetArgsInclude<EN extends keyof EntityMeta, R extends keyof RelationsAndNestedObjects<EN> = keyof RelationsAndNestedObjects<EN>> = [R] extends [never] ? {
     _pick?: EntityMeta[EN]['primitives'][];
 } : {
     _pick?: EntityMeta[EN]['primitives'][];
 } & {
-    [K in R]?: GetArgsInclude<EntityMeta[EN]['relations'][K]['entityName']>;
+    [K in R]?: GetArgsInclude<RelationsAndNestedObjects<EN>[K]['entityName']>;
 };
 type GetAggResponse<EN extends keyof EntityMeta, A extends GetAggArgs<EN>> = {
     [K in A['agg'][0]]: K extends '_count' ? number : number | undefined;
@@ -250,6 +251,7 @@ interface TypeDefinition {
     handlePlural?: string;
     isExtending?: string;
     keepHistoryFields?: string[];
+    sourceFile?: string;
 }
 interface FileUploadResult {
     url: string;

package/dist/index.mjs

@@ -655,6 +655,9 @@ async function handleInclude(computedContext, include, result, ctx) {
   const { schema, typeName } = computedContext;
   const fields = schema[typeName].fields || {};
   const fieldsToInclude = _.keys(include).filter((key) => include[key]);
+  const nestedFieldsToInclude = fieldsToInclude.filter(
+    (key) => !fields[key].isRelation && !fields[key].isInverseRelation && schema[fields[key].type]?.fields
+  );
   const relationsToInclude = fieldsToInclude.filter((key) => fields[key].isRelation);
   const args = {
     entityTypeName: typeName,
@@ -663,6 +666,15 @@ async function handleInclude(computedContext, include, result, ctx) {
     result,
     include
   };
+  for (const nf of nestedFieldsToInclude) {
+    const resultsWithNestedField = result.filter((item) => item[nf]);
+    await handleInclude(
+      { ...computedContext, typeName: fields[nf].type },
+      include[nf],
+      resultsWithNestedField.map((x) => x[nf]),
+      ctx
+    );
+  }
   const inverseRelationsToInclude = fieldsToInclude.filter((key) => fields[key].isInverseRelation);
   const downloadRelationsPromises = relationsToInclude.map(
     (fieldName) => downloadRelatedDocuments({ ...args, fieldName })

package/integrations/lib.cjs

@@ -165,7 +165,7 @@ function parseClassDeclaration(typeDeclaration, typeName, ctx) {
   const nameNode = typeDeclaration.name;
   if (!nameNode || nameNode.kind !== _typescript.SyntaxKind.Identifier) throw new Error("Cannot detect class name");
   const name = nameNode.text;
-  const comment = typeDeclaration.jsDoc?.[0]?.comment;
+  const comment = getCommentFromJsdocNode(typeDeclaration.jsDoc);
   const decorators = parseDecorators(modifiers, ctx);
   const classDeclaration = typeDeclaration;
   const {
@@ -193,7 +193,8 @@ function parseClassDeclaration(typeDeclaration, typeName, ctx) {
     decorators,
     fields,
     isExtending,
-    comment
+    comment,
+    sourceFile: ctx.sourceFile.fileName
   };
   return result;
 }
@@ -202,7 +203,7 @@ function parseTypeAliasDeclaration(typeDeclaration, typeName, ctx) {
   const nameNode = typeDeclaration.name;
   if (!nameNode || nameNode.kind !== _typescript.SyntaxKind.Identifier) throw new Error("Cannot detect class name");
   const name = nameNode.text;
-  const comment = typeDeclaration.jsDoc?.[0]?.comment;
+  const comment = getCommentFromJsdocNode(typeDeclaration.jsDoc);
   const typeAliasDeclaration = typeDeclaration;
   const typeAliasType = typeAliasDeclaration.type;
   if (typeAliasType.kind === _typescript.SyntaxKind.UnionType) {
@@ -212,7 +213,8 @@ function parseTypeAliasDeclaration(typeDeclaration, typeName, ctx) {
       name,
       enumValues,
       comment,
-      decorators: {}
+      decorators: {},
+      sourceFile: ctx.sourceFile.fileName
     };
   }
   if (typeAliasType.kind === _typescript.SyntaxKind.TypeOperator && typeAliasType.operator === _typescript.SyntaxKind.KeyOfKeyword) {
@@ -221,7 +223,8 @@ function parseTypeAliasDeclaration(typeDeclaration, typeName, ctx) {
       name,
       enumValues,
       comment,
-      decorators: {}
+      decorators: {},
+      sourceFile: ctx.sourceFile.fileName
     };
   }
   throw new Error(`Unexpected type definition - ${typeDeclaration.getText(ctx.sourceFile)}. Did you mean 'class'?`);
@@ -259,7 +262,7 @@ function parseClassMember(node, parentFields, parentName, ctx) {
     defaultValueClass
   } = parseDefaultValueExpression(node.initializer, ctx);
   const isRequired = !node.questionToken;
-  const comment = node.jsDoc?.[0]?.comment;
+  const comment = getCommentFromJsdocNode(node.jsDoc);
   const decorators = parseDecorators(node.modifiers, ctx);
   let defaultValueType = defaultValueClass || getPrimitiveTypeFromDefaultValue(defaultValue);
   if (defaultValueCopyFrom) {
@@ -280,6 +283,12 @@ function parseClassMember(node, parentFields, parentName, ctx) {
   if (defaultValueClass) result.defaultValueClass = defaultValueClass;
   return result;
 }
+function getCommentFromJsdocNode(jsDoc) {
+  const comment = jsDoc?.[0]?.comment;
+  const tags = jsDoc?.[0]?.tags;
+  const tagsStr = tags?.map(tag => [`@${tag.tagName.text}`, tag.comment || ""].filter(x => x).join(" "))?.join("\n") || "";
+  return [comment, tagsStr].filter(x => x).join("\n") || void 0;
+}
 function getPrimitiveTypeFromDefaultValue(value) {
   if (_lodash.default.isString(value)) return "string";
   if (_lodash.default.isNumber(value)) return "number";
@@ -346,7 +355,8 @@ function parseFieldTypeRecordEnum(parsedType, parentName, fieldName, ctx) {
   ctx.result[newTypeName] = {
     name: newTypeName,
     decorators: {},
-    fields: _lodash.default.keyBy(fieldsArray, "name")
+    fields: _lodash.default.keyBy(fieldsArray, "name"),
+    sourceFile: ctx.sourceFile.fileName
   };
   parsedType.type = newTypeName;
 }
@@ -404,7 +414,8 @@ function parseFieldTypeInlineEnum(parsedType, parentName, fieldName, ctx) {
   ctx.result[newTypeName] = {
     name: newTypeName,
     decorators: {},
-    enumValues
+    enumValues,
+    sourceFile: ctx.sourceFile.fileName
   };
   parsedType.type = newTypeName;
 }
@@ -417,7 +428,8 @@ function parseFieldTypeKeyofEnum(parsedType, parentName, fieldName, ctx) {
   ctx.result[newTypeName] = {
     name: newTypeName,
     decorators: {},
-    enumValues
+    enumValues,
+    sourceFile: ctx.sourceFile.fileName
   };
   parsedType.type = newTypeName;
 }

package/integrations/lib.mjs

@@ -145,7 +145,7 @@ function parseClassDeclaration(typeDeclaration, typeName, ctx) {
   if (!nameNode || nameNode.kind !== SyntaxKind.Identifier)
     throw new Error("Cannot detect class name");
   const name = nameNode.text;
-  const comment = typeDeclaration.jsDoc?.[0]?.comment;
+  const comment = getCommentFromJsdocNode(typeDeclaration.jsDoc);
   const decorators = parseDecorators(modifiers, ctx);
   const classDeclaration = typeDeclaration;
   const { members, heritageClauses } = classDeclaration;
@@ -170,7 +170,8 @@ function parseClassDeclaration(typeDeclaration, typeName, ctx) {
     decorators,
     fields,
     isExtending,
-    comment
+    comment,
+    sourceFile: ctx.sourceFile.fileName
   };
   return result;
 }
@@ -181,17 +182,17 @@ function parseTypeAliasDeclaration(typeDeclaration, typeName, ctx) {
   if (!nameNode || nameNode.kind !== SyntaxKind.Identifier)
     throw new Error("Cannot detect class name");
   const name = nameNode.text;
-  const comment = typeDeclaration.jsDoc?.[0]?.comment;
+  const comment = getCommentFromJsdocNode(typeDeclaration.jsDoc);
   const typeAliasDeclaration = typeDeclaration;
   const typeAliasType = typeAliasDeclaration.type;
   if (typeAliasType.kind === SyntaxKind.UnionType) {
     const typeAliasValue = typeAliasDeclaration.type;
     const enumValues = getEnumValues(typeAliasValue, typeDeclaration, ctx);
-    return { name, enumValues, comment, decorators: {} };
+    return { name, enumValues, comment, decorators: {}, sourceFile: ctx.sourceFile.fileName };
   }
   if (typeAliasType.kind === SyntaxKind.TypeOperator && typeAliasType.operator === SyntaxKind.KeyOfKeyword) {
     const enumValues = getEnumValuesFromKeyOf(typeAliasType, ctx);
-    return { name, enumValues, comment, decorators: {} };
+    return { name, enumValues, comment, decorators: {}, sourceFile: ctx.sourceFile.fileName };
   }
   throw new Error(`Unexpected type definition - ${typeDeclaration.getText(ctx.sourceFile)}. Did you mean 'class'?`);
 }
@@ -222,7 +223,7 @@ function parseClassMember(node, parentFields, parentName, ctx) {
   const name = node.name.getText(ctx.sourceFile);
   const { defaultValue, defaultValueCopyFrom, defaultValueClass } = parseDefaultValueExpression(node.initializer, ctx);
   const isRequired = !node.questionToken;
-  const comment = node.jsDoc?.[0]?.comment;
+  const comment = getCommentFromJsdocNode(node.jsDoc);
   const decorators = parseDecorators(node.modifiers, ctx);
   let defaultValueType = defaultValueClass || getPrimitiveTypeFromDefaultValue(defaultValue);
   if (defaultValueCopyFrom) {
@@ -246,6 +247,12 @@ function parseClassMember(node, parentFields, parentName, ctx) {
     result.defaultValueClass = defaultValueClass;
   return result;
 }
+function getCommentFromJsdocNode(jsDoc) {
+  const comment = jsDoc?.[0]?.comment;
+  const tags = jsDoc?.[0]?.tags;
+  const tagsStr = tags?.map((tag) => [`@${tag.tagName.text}`, tag.comment || ""].filter((x) => x).join(" "))?.join("\n") || "";
+  return [comment, tagsStr].filter((x) => x).join("\n") || void 0;
+}
 function getPrimitiveTypeFromDefaultValue(value) {
   if (_.isString(value))
     return "string";
@@ -321,7 +328,8 @@ function parseFieldTypeRecordEnum(parsedType, parentName, fieldName, ctx) {
   ctx.result[newTypeName] = {
     name: newTypeName,
     decorators: {},
-    fields: _.keyBy(fieldsArray, "name")
+    fields: _.keyBy(fieldsArray, "name"),
+    sourceFile: ctx.sourceFile.fileName
   };
   parsedType.type = newTypeName;
 }
@@ -382,7 +390,7 @@ function parseFieldTypeInlineEnum(parsedType, parentName, fieldName, ctx) {
   const nt = parsedType.nodeType;
   const enumValues = getEnumValues(nt, parsedType.node, ctx);
   const newTypeName = `${parentName}_${_.upperFirst(fieldName)}`;
-  ctx.result[newTypeName] = { name: newTypeName, decorators: {}, enumValues };
+  ctx.result[newTypeName] = { name: newTypeName, decorators: {}, enumValues, sourceFile: ctx.sourceFile.fileName };
   parsedType.type = newTypeName;
 }
 function parseFieldTypeKeyofEnum(parsedType, parentName, fieldName, ctx) {
@@ -393,7 +401,7 @@ function parseFieldTypeKeyofEnum(parsedType, parentName, fieldName, ctx) {
     return;
   const enumValues = getEnumValuesFromKeyOf(nt, ctx);
   const newTypeName = `${parentName}_${_.upperFirst(fieldName)}`;
-  ctx.result[newTypeName] = { name: newTypeName, decorators: {}, enumValues };
+  ctx.result[newTypeName] = { name: newTypeName, decorators: {}, enumValues, sourceFile: ctx.sourceFile.fileName };
   parsedType.type = newTypeName;
 }
 function getEnumValuesFromKeyOf(nodeType, ctx) {

package/integrations/node.cjs

@@ -104,11 +104,13 @@ function getIndexDts(schema, options) {
   const schemaTypesStr = options.entitiesDir ? "" : getEntityTypesStrFromSchema(schema);
   for (const key in schema) {
     const type = schema[key];
-    if (!type.decorators.entity) continue;
-    if (options.entitiesDir) {
-      imports.push(`import type { ${type.name} } from '../../${options.entitiesDir}/${key}'`);
+    if (!type.fields) continue;
+    if (options.entitiesDir && type.sourceFile) {
+      imports.push(`import type { ${type.name} } from '../../${options.entitiesDir}/${type.sourceFile}'`);
+    }
+    if (type.decorators?.entity) {
+      rootFields.push(`${type.handle}: EntityMethods<${type.name}, '${type.name}'>`);
     }
-    rootFields.push(`${type.handle}: EntityMethods<${type.name}, '${type.name}'>`);
     const fieldsArray = Object.values(type.fields);
     const relations = _lodash.default.fromPairs(fieldsArray.filter(f => f.isRelation).map(f => [f.name, {
       entity: f.type,
@@ -118,6 +120,7 @@ function getIndexDts(schema, options) {
       type: type.name,
       whereType: `${type.name}_Where`,
       relationsStr: _lodash.default.keys(relations).map(k => `${k}: { entityName: '${relations[k].entity}', entity: ${relations[k].entity}, denormFields: ${relations[k].denormFields} }`),
+      nestedObjectsStr: fieldsArray.filter(f => schema[f.type]?.fields && !f.isRelation && !f.isChange && !f.isInverseRelation).map(f => `${f.name}: { entityName: '${f.type}' }`),
       aggregates: fieldsArray.filter(f => f.type === "number" && !f.isArray).map(x => `'${x.name}'`).join(" | "),
       primitives: fieldsArray.filter(f => !schema[f.type]?.decorators?.entity).map(x => `'${x.name}'`).join(" | ")
     });
@@ -137,6 +140,7 @@ ${whereFields.join("\n")}
     whereType: ${x.whereType}
     primitives: ${x.primitives || "never"}
     aggregates: ${x.aggregates || "never"}
+    nestedObjects: {${x.nestedObjectsStr}}
     relations: {${x.relationsStr}}
   }
       `.trim()).join("\n");

package/integrations/node.mjs

@@ -94,12 +94,14 @@ export function getIndexDts(schema, options) {
   const schemaTypesStr = options.entitiesDir ? "" : getEntityTypesStrFromSchema(schema);
   for (const key in schema) {
     const type = schema[key];
-    if (!type.decorators.entity)
+    if (!type.fields)
       continue;
-    if (options.entitiesDir) {
-      imports.push(`import type { ${type.name} } from '../../${options.entitiesDir}/${key}'`);
+    if (options.entitiesDir && type.sourceFile) {
+      imports.push(`import type { ${type.name} } from '../../${options.entitiesDir}/${type.sourceFile}'`);
+    }
+    if (type.decorators?.entity) {
+      rootFields.push(`${type.handle}: EntityMethods<${type.name}, '${type.name}'>`);
     }
-    rootFields.push(`${type.handle}: EntityMethods<${type.name}, '${type.name}'>`);
     const fieldsArray = Object.values(type.fields);
     const relations = _.fromPairs(
       fieldsArray.filter((f) => f.isRelation).map((f) => [
@@ -113,6 +115,7 @@ export function getIndexDts(schema, options) {
       relationsStr: _.keys(relations).map(
         (k) => `${k}: { entityName: '${relations[k].entity}', entity: ${relations[k].entity}, denormFields: ${relations[k].denormFields} }`
       ),
+      nestedObjectsStr: fieldsArray.filter((f) => schema[f.type]?.fields && !f.isRelation && !f.isChange && !f.isInverseRelation).map((f) => `${f.name}: { entityName: '${f.type}' }`),
       aggregates: fieldsArray.filter((f) => f.type === "number" && !f.isArray).map((x) => `'${x.name}'`).join(" | "),
       primitives: fieldsArray.filter((f) => !schema[f.type]?.decorators?.entity).map((x) => `'${x.name}'`).join(" | ")
     });
@@ -136,6 +139,7 @@ ${whereFields.join("\n")}
     whereType: ${x.whereType}
     primitives: ${x.primitives || "never"}
     aggregates: ${x.aggregates || "never"}
+    nestedObjects: {${x.nestedObjectsStr}}
     relations: {${x.relationsStr}}
   }
       `.trim()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rads-db",
-  "version": "3.0.73",
+  "version": "3.0.75",
   "packageManager": "pnpm@8.6.1",
   "description": "Say goodbye to boilerplate code and hello to efficient and elegant syntax.",
   "author": "",