record projection codegen fixes

java/codegen/src/main/scala/ws/epigraph/java/service/projections/req/ReqEntityProjectionGen.scala

@@ -43,8 +43,14 @@ trait ReqEntityProjectionGen extends ReqTypeProjectionGen {
 
   protected def genShortClassName(prefix: String, suffix: String): String = genShortClassName(prefix, suffix, cType)
 
-  override def children: Iterable[JavaGen] =
-    tagGenerators.values ++ /*tailGenerators.values ++*/
+  override def children: Iterable[JavaGen]
+  = {
+      if (invalidParentClassGenerator)
+        Iterable()
+      else
+        tagGenerators.values
+    } ++
+    /*tailGenerators.values ++*/
     normalizedTailGenerators/*.filterKeys(p => p.referenceName() == null)*/ .values // filter out named generators
 
   override protected val cType: CEntityTypeDef = toCType(op.`type`()).asInstanceOf[CEntityTypeDef]
@@ -61,11 +67,11 @@ trait ReqEntityProjectionGen extends ReqTypeProjectionGen {
     t: CEntityTypeDef): Map[String, (Option[ReqEntityProjectionGen], OpTagProjectionEntryType)] = {
     val op = g.op
 
-    val parentOverridingTagProjections = g.parentClassGenOpt.map(
-      pg => tagProjections(
-        pg.asInstanceOf[ReqEntityProjectionGen], t
-      )
-    ).getOrElse(Map())
+//    val parentOverridingTagProjections = g.parentClassGenOpt.map(
+//      pg => tagProjections(
+//        pg.asInstanceOf[ReqEntityProjectionGen], t
+//      )
+//    ).getOrElse(Map())
 
     val gOverridingTagProjections = op.tagProjections().toSeq.toListMap
         .filter { case (tn, tp) =>
@@ -83,7 +89,8 @@ trait ReqEntityProjectionGen extends ReqTypeProjectionGen {
           )
         }
 
-    parentOverridingTagProjections ++ gOverridingTagProjections
+//    parentOverridingTagProjections ++ gOverridingTagProjections
+    gOverridingTagProjections
   }
 
   /** tag projections: should only include new or overridden tags, should not include inherited */

java/codegen/src/main/scala/ws/epigraph/java/service/projections/req/ReqRecordModelProjectionGen.scala

@@ -44,16 +44,16 @@ trait ReqRecordModelProjectionGen extends ReqModelProjectionGen {
 
   protected val cRecordType: CRecordTypeDef = cType.asInstanceOf[CRecordTypeDef]
 
-  /** get field projections from `g.op` if they override fields from `t` */
+  /** get field projections from `g.op` if they are overridden in type `t` */
   def overridingFieldProjections(
     g: ReqRecordModelProjectionGen,
     t: CRecordTypeDef): Map[String, (Option[ReqRecordModelProjectionGen], OpFieldProjectionType)] = {
 
     val p = g.op
 
-    val parentOverridingFieldProjections = g.parentClassGenOpt.map(
-      pg => overridingFieldProjections(pg.asInstanceOf[ReqRecordModelProjectionGen], t)
-    ).getOrElse(Map())
+//    val parentOverridingFieldProjections = g.parentClassGenOpt.map(
+//      pg => overridingFieldProjections(pg.asInstanceOf[ReqRecordModelProjectionGen], t)
+//    ).getOrElse(Map())
 
     val gOverridingFieldProjections = p.fieldProjections().toSeq.toListMap
         .filter { case (fieldName, fieldProjection) =>
@@ -75,7 +75,8 @@ trait ReqRecordModelProjectionGen extends ReqModelProjectionGen {
           )
         }
 
-    parentOverridingFieldProjections ++ gOverridingFieldProjections
+//    parentOverridingFieldProjections ++ gOverridingFieldProjections
+    gOverridingFieldProjections
   }
 
   /**
@@ -104,8 +105,9 @@ trait ReqRecordModelProjectionGen extends ReqModelProjectionGen {
   }
 
   override def children: Iterable[JavaGen] = super.children ++ {
-    // exclude (overriden) fields taken from parent generator
-    if (ReqFieldProjectionGen.generateFieldProjections)
+    if (invalidParentClassGenerator)
+      Iterable()
+    else if (ReqFieldProjectionGen.generateFieldProjections)
       fieldGenerators.values
     else
       fieldGenerators.values.flatMap(_.children)

java/codegen/src/main/scala/ws/epigraph/java/service/projections/req/ReqTypeProjectionGen.scala

@@ -80,7 +80,10 @@ trait ReqTypeProjectionGen extends ReqProjectionGen {
   }
 
   protected def invalidParentClassGenerator: Boolean =
-    parentClassGenOpt.isEmpty && normalizedFromGenOpt.isDefined
+    parentClassGenOpt match {
+      case Some(parentGen) => parentGen.invalidParentClassGenerator
+      case None => normalizedFromGenOpt.isDefined
+    }
 
   protected def generate0: String
 }

tests/schema-java/build.gradle

@@ -39,7 +39,8 @@ epigraph {
         "ws.epigraph.tests.users",
         "ws.epigraph.tests.codegenstress.namedDoubleTail",
         "ws.epigraph.tests.codegenstress.childWithUnusedParent",
-        "ws.epigraph.tests.codegenstress.childUsedByParent"
+        "ws.epigraph.tests.codegenstress.childUsedByParent",
+//        "com.sumologic.som.folders"
     ]
   }
 }

tests/schema/src/main/epigraph/ws/epigraph/tests/codegenstress/childProjectionWithUnusedParent.epigraph

@@ -3,16 +3,24 @@ namespace ws.epigraph.tests.codegenstress
 // resource output projection uses normalized $child projection
 // while $parent projection is never used
 
-entity SomeParentEntity {
+record SomeParent {
   id: Long
+  me: SomeParent
 }
-entity SomeChildEntity extends SomeParentEntity {
+record SomeChild extends SomeParent {
   name: String
+  override me: SomeChild
 }
 
-outputProjection parent: SomeParentEntity = :( id ) :~ SomeChildEntity $child = :( name )
+record SomeChild2 extends SomeChild {
+  child2: String
+}
+
+outputProjection parent: SomeParent = ( id, me )
+                                        ~ SomeChild $child = ( name )
+                                          ~ SomeChild2 ( child2 )
 
-resource childWithUnusedParent : SomeChildEntity {
+resource childWithUnusedParent : SomeChild {
   read {
     outputProjection $child
   }