cloesce 0.0.5-unstable.1 → 0.0.5-unstable.2

package/dist/extractor/extract.js

@@ -1,882 +1,820 @@
-import { Node as MorphNode, SyntaxKind, Scope } from "ts-morph";
-import { HttpVerb, defaultMediaType } from "../ast.js";
+import { Node as MorphNode, SyntaxKind, Scope, } from "ts-morph";
+import { HttpVerb, defaultMediaType, } from "../ast.js";
 import { TypeFormatFlags } from "typescript";
 import { ExtractorError, ExtractorErrorCode } from "./err.js";
 import { Either } from "../ui/common.js";
 var AttributeDecoratorKind;
 (function (AttributeDecoratorKind) {
-  AttributeDecoratorKind["PrimaryKey"] = "PrimaryKey";
-  AttributeDecoratorKind["ForeignKey"] = "ForeignKey";
-  AttributeDecoratorKind["OneToOne"] = "OneToOne";
-  AttributeDecoratorKind["OneToMany"] = "OneToMany";
-  AttributeDecoratorKind["ManyToMany"] = "ManyToMany";
-  AttributeDecoratorKind["DataSource"] = "DataSource";
+    AttributeDecoratorKind["PrimaryKey"] = "PrimaryKey";
+    AttributeDecoratorKind["ForeignKey"] = "ForeignKey";
+    AttributeDecoratorKind["OneToOne"] = "OneToOne";
+    AttributeDecoratorKind["OneToMany"] = "OneToMany";
+    AttributeDecoratorKind["ManyToMany"] = "ManyToMany";
+    AttributeDecoratorKind["DataSource"] = "DataSource";
 })(AttributeDecoratorKind || (AttributeDecoratorKind = {}));
 var ClassDecoratorKind;
 (function (ClassDecoratorKind) {
-  ClassDecoratorKind["D1"] = "D1";
-  ClassDecoratorKind["WranglerEnv"] = "WranglerEnv";
-  ClassDecoratorKind["PlainOldObject"] = "PlainOldObject";
-  ClassDecoratorKind["Service"] = "Service";
-  ClassDecoratorKind["CRUD"] = "CRUD";
+    ClassDecoratorKind["D1"] = "D1";
+    ClassDecoratorKind["WranglerEnv"] = "WranglerEnv";
+    ClassDecoratorKind["PlainOldObject"] = "PlainOldObject";
+    ClassDecoratorKind["Service"] = "Service";
+    ClassDecoratorKind["CRUD"] = "CRUD";
 })(ClassDecoratorKind || (ClassDecoratorKind = {}));
 var ParameterDecoratorKind;
 (function (ParameterDecoratorKind) {
-  ParameterDecoratorKind["Inject"] = "Inject";
+    ParameterDecoratorKind["Inject"] = "Inject";
 })(ParameterDecoratorKind || (ParameterDecoratorKind = {}));
 export class CidlExtractor {
-  projectName;
-  version;
-  constructor(projectName, version) {
-    this.projectName = projectName;
-    this.version = version;
-  }
-  extract(project) {
-    const models = {};
-    const poos = {};
-    const wranglerEnvs = [];
-    const services = {};
-    let app_source = null;
-    for (const sourceFile of project.getSourceFiles()) {
-      if (
-        sourceFile.getBaseName() === "app.cloesce.ts" ||
-        sourceFile.getBaseName() === "seed__app.cloesce.ts" // hardcoding for tests
-      ) {
-        const app = CidlExtractor.app(sourceFile);
-        if (app.isLeft()) {
-          return app;
-        }
-        app_source = app.unwrap();
-      }
-      for (const classDecl of sourceFile.getClasses()) {
-        const notExportedErr = err(ExtractorErrorCode.MissingExport, (e) => {
-          e.context = classDecl.getName();
-          e.snippet = classDecl.getText();
-        });
-        if (hasDecorator(classDecl, ClassDecoratorKind.D1)) {
-          if (!classDecl.isExported()) return notExportedErr;
-          const result = CidlExtractor.model(classDecl, sourceFile);
-          // Error: propogate from models
-          if (result.isLeft()) {
-            result.value.addContext((prev) => `${classDecl.getName()}.${prev}`);
-            return result;
-          }
-          const model = result.unwrap();
-          models[model.name] = model;
-          continue;
-        }
-        if (hasDecorator(classDecl, ClassDecoratorKind.Service)) {
-          if (!classDecl.isExported()) return notExportedErr;
-          const result = CidlExtractor.service(classDecl, sourceFile);
-          // Error: propogate from service
-          if (result.isLeft()) {
-            result.value.addContext((prev) => `${classDecl.getName()}.${prev}`);
-            return result;
-          }
-          const service = result.unwrap();
-          services[service.name] = service;
-          continue;
-        }
-        if (hasDecorator(classDecl, ClassDecoratorKind.PlainOldObject)) {
-          if (!classDecl.isExported()) return notExportedErr;
-          const result = CidlExtractor.poo(classDecl, sourceFile);
-          // Error: propogate from models
-          if (result.isLeft()) {
-            result.value.addContext((prev) => `${classDecl.getName()}.${prev}`);
-            return result;
-          }
-          poos[result.unwrap().name] = result.unwrap();
-          continue;
-        }
-        if (hasDecorator(classDecl, ClassDecoratorKind.WranglerEnv)) {
-          // Error: invalid attribute modifier
-          for (const prop of classDecl.getProperties()) {
-            const modifierRes = checkAttributeModifier(prop);
-            if (modifierRes.isLeft()) {
-              return modifierRes;
+    projectName;
+    version;
+    constructor(projectName, version) {
+        this.projectName = projectName;
+        this.version = version;
+    }
+    extract(project) {
+        const models = {};
+        const poos = {};
+        const wranglerEnvs = [];
+        const services = {};
+        let app_source = null;
+        for (const sourceFile of project.getSourceFiles()) {
+            if (sourceFile.getBaseName() === "app.cloesce.ts" ||
+                sourceFile.getBaseName() === "seed__app.cloesce.ts" // hardcoding for tests
+            ) {
+                const app = CidlExtractor.app(sourceFile);
+                if (app.isLeft()) {
+                    return app;
+                }
+                app_source = app.unwrap();
+            }
+            for (const classDecl of sourceFile.getClasses()) {
+                const notExportedErr = err(ExtractorErrorCode.MissingExport, (e) => {
+                    e.context = classDecl.getName();
+                    e.snippet = classDecl.getText();
+                });
+                if (hasDecorator(classDecl, ClassDecoratorKind.D1)) {
+                    if (!classDecl.isExported())
+                        return notExportedErr;
+                    const result = CidlExtractor.model(classDecl, sourceFile);
+                    // Error: propogate from models
+                    if (result.isLeft()) {
+                        result.value.addContext((prev) => `${classDecl.getName()}.${prev}`);
+                        return result;
+                    }
+                    const model = result.unwrap();
+                    models[model.name] = model;
+                    continue;
+                }
+                if (hasDecorator(classDecl, ClassDecoratorKind.Service)) {
+                    if (!classDecl.isExported())
+                        return notExportedErr;
+                    const result = CidlExtractor.service(classDecl, sourceFile);
+                    // Error: propogate from service
+                    if (result.isLeft()) {
+                        result.value.addContext((prev) => `${classDecl.getName()}.${prev}`);
+                        return result;
+                    }
+                    const service = result.unwrap();
+                    services[service.name] = service;
+                    continue;
+                }
+                if (hasDecorator(classDecl, ClassDecoratorKind.PlainOldObject)) {
+                    if (!classDecl.isExported())
+                        return notExportedErr;
+                    const result = CidlExtractor.poo(classDecl, sourceFile);
+                    // Error: propogate from models
+                    if (result.isLeft()) {
+                        result.value.addContext((prev) => `${classDecl.getName()}.${prev}`);
+                        return result;
+                    }
+                    poos[result.unwrap().name] = result.unwrap();
+                    continue;
+                }
+                if (hasDecorator(classDecl, ClassDecoratorKind.WranglerEnv)) {
+                    // Error: invalid attribute modifier
+                    for (const prop of classDecl.getProperties()) {
+                        const modifierRes = checkAttributeModifier(prop);
+                        if (modifierRes.isLeft()) {
+                            return modifierRes;
+                        }
+                    }
+                    const result = CidlExtractor.env(classDecl, sourceFile);
+                    if (result.isLeft()) {
+                        return result;
+                    }
+                    wranglerEnvs.push(result.unwrap());
+                }
             }
-          }
-          const result = CidlExtractor.env(classDecl, sourceFile);
-          if (result.isLeft()) {
-            return result;
-          }
-          wranglerEnvs.push(result.unwrap());
         }
-      }
-    }
-    // Error: Only one wrangler environment can exist
-    if (wranglerEnvs.length > 1) {
-      return err(
-        ExtractorErrorCode.TooManyWranglerEnvs,
-        (e) => (e.context = wranglerEnvs.map((w) => w.name).toString()),
-      );
-    }
-    return Either.right({
-      version: this.version,
-      project_name: this.projectName,
-      language: "TypeScript",
-      wrangler_env: wranglerEnvs[0],
-      models,
-      poos,
-      services,
-      app_source,
-    });
-  }
-  static app(sourceFile) {
-    const symbol = sourceFile.getDefaultExportSymbol();
-    const decl = symbol?.getDeclarations()[0];
-    if (!decl) {
-      return err(ExtractorErrorCode.AppMissingDefaultExport);
-    }
-    const getTypeText = () => {
-      let type = undefined;
-      if (MorphNode.isExportAssignment(decl)) {
-        type = decl.getExpression()?.getType();
-      }
-      if (MorphNode.isVariableDeclaration(decl)) {
-        type = decl.getInitializer()?.getType();
-      }
-      return type?.getText(
-        undefined,
-        TypeFormatFlags.UseAliasDefinedOutsideCurrentScope,
-      );
-    };
-    const typeText = getTypeText();
-    if (typeText === "CloesceApp") {
-      return Either.right(sourceFile.getFilePath().toString());
-    }
-    return err(ExtractorErrorCode.AppMissingDefaultExport);
-  }
-  static model(classDecl, sourceFile) {
-    const name = classDecl.getName();
-    const attributes = [];
-    const navigation_properties = [];
-    const data_sources = {};
-    const methods = {};
-    const cruds = new Set();
-    let primary_key = undefined;
-    // Extract crud methods
-    const crudDecorator = classDecl
-      .getDecorators()
-      .find((d) => getDecoratorName(d) === ClassDecoratorKind.CRUD);
-    if (crudDecorator) {
-      setCrudKinds(crudDecorator, cruds);
+        // Error: Only one wrangler environment can exist
+        if (wranglerEnvs.length > 1) {
+            return err(ExtractorErrorCode.TooManyWranglerEnvs, (e) => (e.context = wranglerEnvs.map((w) => w.name).toString()));
+        }
+        return Either.right({
+            version: this.version,
+            project_name: this.projectName,
+            language: "TypeScript",
+            wrangler_env: wranglerEnvs[0],
+            models,
+            poos,
+            services,
+            app_source,
+        });
     }
-    // Iterate attribtutes
-    for (const prop of classDecl.getProperties()) {
-      const decorators = prop.getDecorators();
-      const typeRes = CidlExtractor.cidlType(prop.getType());
-      // Error: invalid property type
-      if (typeRes.isLeft()) {
-        typeRes.value.context = prop.getName();
-        typeRes.value.snippet = prop.getText();
-        return typeRes;
-      }
-      const checkModifierRes = checkAttributeModifier(prop);
-      // No decorators means this is a standard attribute
-      if (decorators.length === 0) {
-        // Error: invalid attribute modifier
-        if (checkModifierRes.isLeft()) {
-          return checkModifierRes;
-        }
-        const cidl_type = typeRes.unwrap();
-        attributes.push({
-          foreign_key_reference: null,
-          value: {
-            name: prop.getName(),
-            cidl_type,
-          },
+    static app(sourceFile) {
+        const symbol = sourceFile.getDefaultExportSymbol();
+        const decl = symbol?.getDeclarations()[0];
+        if (!decl) {
+            return err(ExtractorErrorCode.AppMissingDefaultExport);
+        }
+        const getTypeText = () => {
+            let type = undefined;
+            if (MorphNode.isExportAssignment(decl)) {
+                type = decl.getExpression()?.getType();
+            }
+            if (MorphNode.isVariableDeclaration(decl)) {
+                type = decl.getInitializer()?.getType();
+            }
+            return type?.getText(undefined, TypeFormatFlags.UseAliasDefinedOutsideCurrentScope);
+        };
+        const typeText = getTypeText();
+        if (typeText === "CloesceApp") {
+            return Either.right(sourceFile.getFilePath().toString());
+        }
+        return err(ExtractorErrorCode.AppMissingDefaultExport);
+    }
+    static model(classDecl, sourceFile) {
+        const name = classDecl.getName();
+        const attributes = [];
+        const navigation_properties = [];
+        const data_sources = {};
+        const methods = {};
+        const cruds = new Set();
+        let primary_key = undefined;
+        // Extract crud methods
+        const crudDecorator = classDecl
+            .getDecorators()
+            .find((d) => getDecoratorName(d) === ClassDecoratorKind.CRUD);
+        if (crudDecorator) {
+            setCrudKinds(crudDecorator, cruds);
+        }
+        // Iterate attribtutes
+        for (const prop of classDecl.getProperties()) {
+            const decorators = prop.getDecorators();
+            const typeRes = CidlExtractor.cidlType(prop.getType());
+            // Error: invalid property type
+            if (typeRes.isLeft()) {
+                typeRes.value.context = prop.getName();
+                typeRes.value.snippet = prop.getText();
+                return typeRes;
+            }
+            const checkModifierRes = checkAttributeModifier(prop);
+            // No decorators means this is a standard attribute
+            if (decorators.length === 0) {
+                // Error: invalid attribute modifier
+                if (checkModifierRes.isLeft()) {
+                    return checkModifierRes;
+                }
+                const cidl_type = typeRes.unwrap();
+                attributes.push({
+                    foreign_key_reference: null,
+                    value: {
+                        name: prop.getName(),
+                        cidl_type,
+                    },
+                });
+                continue;
+            }
+            // TODO: Limiting to one decorator. Can't get too fancy on us.
+            const decorator = decorators[0];
+            const decoratorName = getDecoratorName(decorator);
+            // Error: invalid attribute modifier
+            if (checkModifierRes.isLeft() &&
+                decoratorName !== AttributeDecoratorKind.DataSource) {
+                return checkModifierRes;
+            }
+            // Process decorator
+            const cidl_type = typeRes.unwrap();
+            switch (decoratorName) {
+                case AttributeDecoratorKind.PrimaryKey: {
+                    primary_key = {
+                        name: prop.getName(),
+                        cidl_type,
+                    };
+                    break;
+                }
+                case AttributeDecoratorKind.ForeignKey: {
+                    attributes.push({
+                        foreign_key_reference: getDecoratorArgument(decorator, 0) ?? null,
+                        value: {
+                            name: prop.getName(),
+                            cidl_type,
+                        },
+                    });
+                    break;
+                }
+                case AttributeDecoratorKind.OneToOne: {
+                    const reference = getDecoratorArgument(decorator, 0);
+                    // Error: One to one navigation properties requre a reference
+                    if (!reference) {
+                        return err(ExtractorErrorCode.MissingNavigationPropertyReference, (e) => {
+                            e.snippet = prop.getText();
+                            e.context = prop.getName();
+                        });
+                    }
+                    let model_name = getObjectName(cidl_type);
+                    // Error: navigation properties require a model reference
+                    if (!model_name) {
+                        return err(ExtractorErrorCode.MissingNavigationPropertyReference, (e) => {
+                            e.snippet = prop.getText();
+                            e.context = prop.getName();
+                        });
+                    }
+                    navigation_properties.push({
+                        var_name: prop.getName(),
+                        model_name,
+                        kind: { OneToOne: { reference } },
+                    });
+                    break;
+                }
+                case AttributeDecoratorKind.OneToMany: {
+                    const reference = getDecoratorArgument(decorator, 0);
+                    // Error: One to one navigation properties requre a reference
+                    if (!reference) {
+                        return err(ExtractorErrorCode.MissingNavigationPropertyReference, (e) => {
+                            e.snippet = prop.getText();
+                            e.context = prop.getName();
+                        });
+                    }
+                    let model_name = getObjectName(cidl_type);
+                    // Error: navigation properties require a model reference
+                    if (!model_name) {
+                        return err(ExtractorErrorCode.MissingNavigationPropertyReference, (e) => {
+                            e.snippet = prop.getText();
+                            e.context = prop.getName();
+                        });
+                    }
+                    navigation_properties.push({
+                        var_name: prop.getName(),
+                        model_name,
+                        kind: { OneToMany: { reference } },
+                    });
+                    break;
+                }
+                case AttributeDecoratorKind.ManyToMany: {
+                    const unique_id = getDecoratorArgument(decorator, 0);
+                    // Error: many to many attribtues require a unique id
+                    if (!unique_id)
+                        return err(ExtractorErrorCode.MissingManyToManyUniqueId, (e) => {
+                            e.snippet = prop.getText();
+                            e.context = prop.getName();
+                        });
+                    // Error: navigation properties require a model reference
+                    let model_name = getObjectName(cidl_type);
+                    if (!model_name) {
+                        return err(ExtractorErrorCode.MissingNavigationPropertyReference, (e) => {
+                            e.snippet = prop.getText();
+                            e.context = prop.getName();
+                        });
+                    }
+                    navigation_properties.push({
+                        var_name: prop.getName(),
+                        model_name,
+                        kind: { ManyToMany: { unique_id } },
+                    });
+                    break;
+                }
+                case AttributeDecoratorKind.DataSource: {
+                    const isIncludeTree = prop
+                        .getType()
+                        .getText(undefined, TypeFormatFlags.UseAliasDefinedOutsideCurrentScope) === `IncludeTree<${name}>`;
+                    // Error: data sources must be static include trees
+                    if (!prop.isStatic() || !isIncludeTree) {
+                        return err(ExtractorErrorCode.InvalidDataSourceDefinition, (e) => {
+                            e.snippet = prop.getText();
+                            e.context = prop.getName();
+                        });
+                    }
+                    const initializer = prop.getInitializer();
+                    const treeRes = CidlExtractor.includeTree(initializer, classDecl, sourceFile);
+                    if (treeRes.isLeft()) {
+                        treeRes.value.addContext((prev) => `${prop.getName()} ${prev}`);
+                        treeRes.value.snippet = prop.getText();
+                        return treeRes;
+                    }
+                    data_sources[prop.getName()] = {
+                        name: prop.getName(),
+                        tree: treeRes.unwrap(),
+                    };
+                    break;
+                }
+            }
+        }
+        if (primary_key == undefined) {
+            return err(ExtractorErrorCode.MissingPrimaryKey, (e) => {
+                e.snippet = classDecl.getText();
+            });
+        }
+        // Process methods
+        for (const m of classDecl.getMethods()) {
+            const httpVerb = m
+                .getDecorators()
+                .map((d) => getDecoratorName(d))
+                .find((name) => Object.values(HttpVerb).includes(name));
+            if (!httpVerb) {
+                continue;
+            }
+            const result = CidlExtractor.modelMethod(name, m, httpVerb);
+            if (result.isLeft()) {
+                result.value.addContext((prev) => `${m.getName()} ${prev}`);
+                return result;
+            }
+            methods[result.unwrap().name] = result.unwrap();
+        }
+        return Either.right({
+            name,
+            attributes,
+            primary_key,
+            navigation_properties,
+            methods,
+            data_sources,
+            cruds: Array.from(cruds).sort(),
+            source_path: sourceFile.getFilePath().toString(),
         });
-        continue;
-      }
-      // TODO: Limiting to one decorator. Can't get too fancy on us.
-      const decorator = decorators[0];
-      const decoratorName = getDecoratorName(decorator);
-      // Error: invalid attribute modifier
-      if (
-        checkModifierRes.isLeft() &&
-        decoratorName !== AttributeDecoratorKind.DataSource
-      ) {
-        return checkModifierRes;
-      }
-      // Process decorator
-      const cidl_type = typeRes.unwrap();
-      switch (decoratorName) {
-        case AttributeDecoratorKind.PrimaryKey: {
-          primary_key = {
-            name: prop.getName(),
-            cidl_type,
-          };
-          break;
-        }
-        case AttributeDecoratorKind.ForeignKey: {
-          attributes.push({
-            foreign_key_reference: getDecoratorArgument(decorator, 0) ?? null,
-            value: {
-              name: prop.getName(),
-              cidl_type,
-            },
-          });
-          break;
-        }
-        case AttributeDecoratorKind.OneToOne: {
-          const reference = getDecoratorArgument(decorator, 0);
-          // Error: One to one navigation properties requre a reference
-          if (!reference) {
-            return err(
-              ExtractorErrorCode.MissingNavigationPropertyReference,
-              (e) => {
-                e.snippet = prop.getText();
-                e.context = prop.getName();
-              },
-            );
-          }
-          let model_name = getObjectName(cidl_type);
-          // Error: navigation properties require a model reference
-          if (!model_name) {
-            return err(
-              ExtractorErrorCode.MissingNavigationPropertyReference,
-              (e) => {
-                e.snippet = prop.getText();
-                e.context = prop.getName();
-              },
-            );
-          }
-          navigation_properties.push({
-            var_name: prop.getName(),
-            model_name,
-            kind: { OneToOne: { reference } },
-          });
-          break;
-        }
-        case AttributeDecoratorKind.OneToMany: {
-          const reference = getDecoratorArgument(decorator, 0);
-          // Error: One to one navigation properties requre a reference
-          if (!reference) {
-            return err(
-              ExtractorErrorCode.MissingNavigationPropertyReference,
-              (e) => {
-                e.snippet = prop.getText();
-                e.context = prop.getName();
-              },
-            );
-          }
-          let model_name = getObjectName(cidl_type);
-          // Error: navigation properties require a model reference
-          if (!model_name) {
-            return err(
-              ExtractorErrorCode.MissingNavigationPropertyReference,
-              (e) => {
-                e.snippet = prop.getText();
-                e.context = prop.getName();
-              },
-            );
-          }
-          navigation_properties.push({
-            var_name: prop.getName(),
-            model_name,
-            kind: { OneToMany: { reference } },
-          });
-          break;
-        }
-        case AttributeDecoratorKind.ManyToMany: {
-          const unique_id = getDecoratorArgument(decorator, 0);
-          // Error: many to many attribtues require a unique id
-          if (!unique_id)
-            return err(ExtractorErrorCode.MissingManyToManyUniqueId, (e) => {
-              e.snippet = prop.getText();
-              e.context = prop.getName();
+    }
+    static modelMethod(modelName, method, verb) {
+        // Error: invalid method scope, must be public
+        if (method.getScope() != Scope.Public) {
+            return err(ExtractorErrorCode.InvalidApiMethodModifier, (e) => {
+                e.context = method.getName();
+                e.snippet = method.getText();
             });
-          // Error: navigation properties require a model reference
-          let model_name = getObjectName(cidl_type);
-          if (!model_name) {
-            return err(
-              ExtractorErrorCode.MissingNavigationPropertyReference,
-              (e) => {
-                e.snippet = prop.getText();
-                e.context = prop.getName();
-              },
-            );
-          }
-          navigation_properties.push({
-            var_name: prop.getName(),
-            model_name,
-            kind: { ManyToMany: { unique_id } },
-          });
-          break;
-        }
-        case AttributeDecoratorKind.DataSource: {
-          const isIncludeTree =
-            prop
-              .getType()
-              .getText(
-                undefined,
-                TypeFormatFlags.UseAliasDefinedOutsideCurrentScope,
-              ) === `IncludeTree<${name}>`;
-          // Error: data sources must be static include trees
-          if (!prop.isStatic() || !isIncludeTree) {
-            return err(ExtractorErrorCode.InvalidDataSourceDefinition, (e) => {
-              e.snippet = prop.getText();
-              e.context = prop.getName();
+        }
+        let needsDataSource = !method.isStatic();
+        const parameters = [];
+        for (const param of method.getParameters()) {
+            // Handle injected param
+            if (param.getDecorator(ParameterDecoratorKind.Inject)) {
+                const typeRes = CidlExtractor.cidlType(param.getType(), true);
+                // Error: invalid type
+                if (typeRes.isLeft()) {
+                    typeRes.value.snippet = method.getText();
+                    typeRes.value.context = param.getName();
+                    return typeRes;
+                }
+                parameters.push({
+                    name: param.getName(),
+                    cidl_type: typeRes.unwrap(),
+                });
+                continue;
+            }
+            // Handle all other params
+            const typeRes = CidlExtractor.cidlType(param.getType());
+            // Error: invalid type
+            if (typeRes.isLeft()) {
+                typeRes.value.snippet = method.getText();
+                typeRes.value.context = param.getName();
+                return typeRes;
+            }
+            if (typeof typeRes.value !== "string" && "DataSource" in typeRes.value) {
+                needsDataSource = false;
+            }
+            parameters.push({
+                name: param.getName(),
+                cidl_type: typeRes.unwrap(),
             });
-          }
-          const initializer = prop.getInitializer();
-          const treeRes = CidlExtractor.includeTree(
-            initializer,
-            classDecl,
-            sourceFile,
-          );
-          if (treeRes.isLeft()) {
-            treeRes.value.addContext((prev) => `${prop.getName()} ${prev}`);
-            treeRes.value.snippet = prop.getText();
-            return treeRes;
-          }
-          data_sources[prop.getName()] = {
-            name: prop.getName(),
-            tree: treeRes.unwrap(),
-          };
-          break;
-        }
-      }
-    }
-    if (primary_key == undefined) {
-      return err(ExtractorErrorCode.MissingPrimaryKey, (e) => {
-        e.snippet = classDecl.getText();
-      });
-    }
-    // Process methods
-    for (const m of classDecl.getMethods()) {
-      const httpVerb = m
-        .getDecorators()
-        .map((d) => getDecoratorName(d))
-        .find((name) => Object.values(HttpVerb).includes(name));
-      if (!httpVerb) {
-        continue;
-      }
-      const result = CidlExtractor.modelMethod(name, m, httpVerb);
-      if (result.isLeft()) {
-        result.value.addContext((prev) => `${m.getName()} ${prev}`);
-        return result;
-      }
-      methods[result.unwrap().name] = result.unwrap();
-    }
-    return Either.right({
-      name,
-      attributes,
-      primary_key,
-      navigation_properties,
-      methods,
-      data_sources,
-      cruds: Array.from(cruds).sort(),
-      source_path: sourceFile.getFilePath().toString(),
-    });
-  }
-  static modelMethod(modelName, method, verb) {
-    // Error: invalid method scope, must be public
-    if (method.getScope() != Scope.Public) {
-      return err(ExtractorErrorCode.InvalidApiMethodModifier, (e) => {
-        e.context = method.getName();
-        e.snippet = method.getText();
-      });
-    }
-    let needsDataSource = !method.isStatic();
-    const parameters = [];
-    for (const param of method.getParameters()) {
-      // Handle injected param
-      if (param.getDecorator(ParameterDecoratorKind.Inject)) {
-        const typeRes = CidlExtractor.cidlType(param.getType(), true);
+        }
+        const typeRes = CidlExtractor.cidlType(method.getReturnType());
         // Error: invalid type
         if (typeRes.isLeft()) {
-          typeRes.value.snippet = method.getText();
-          typeRes.value.context = param.getName();
-          return typeRes;
+            typeRes.value.snippet = method.getText();
+            return typeRes;
+        }
+        // Sugaring: add data source
+        if (needsDataSource) {
+            parameters.push({
+                name: "__dataSource",
+                cidl_type: { DataSource: modelName },
+            });
         }
-        parameters.push({
-          name: param.getName(),
-          cidl_type: typeRes.unwrap(),
+        return Either.right({
+            name: method.getName(),
+            is_static: method.isStatic(),
+            http_verb: verb,
+            return_media: defaultMediaType(),
+            return_type: typeRes.unwrap(),
+            parameters_media: defaultMediaType(),
+            parameters,
         });
-        continue;
-      }
-      // Handle all other params
-      const typeRes = CidlExtractor.cidlType(param.getType());
-      // Error: invalid type
-      if (typeRes.isLeft()) {
-        typeRes.value.snippet = method.getText();
-        typeRes.value.context = param.getName();
-        return typeRes;
-      }
-      if (typeof typeRes.value !== "string" && "DataSource" in typeRes.value) {
-        needsDataSource = false;
-      }
-      parameters.push({
-        name: param.getName(),
-        cidl_type: typeRes.unwrap(),
-      });
     }
-    const typeRes = CidlExtractor.cidlType(method.getReturnType());
-    // Error: invalid type
-    if (typeRes.isLeft()) {
-      typeRes.value.snippet = method.getText();
-      return typeRes;
-    }
-    // Sugaring: add data source
-    if (needsDataSource) {
-      parameters.push({
-        name: "__dataSource",
-        cidl_type: { DataSource: modelName },
-      });
-    }
-    return Either.right({
-      name: method.getName(),
-      is_static: method.isStatic(),
-      http_verb: verb,
-      return_media: defaultMediaType(),
-      return_type: typeRes.unwrap(),
-      parameters_media: defaultMediaType(),
-      parameters,
-    });
-  }
-  static service(classDecl, sourceFile) {
-    const attributes = [];
-    const methods = {};
-    // Attributes
-    for (const prop of classDecl.getProperties()) {
-      const typeRes = CidlExtractor.cidlType(prop.getType(), true);
-      // Error: invalid property type
-      if (typeRes.isLeft()) {
-        typeRes.value.context = prop.getName();
-        typeRes.value.snippet = prop.getText();
-        return typeRes;
-      }
-      if (typeof typeRes.value === "string" || !("Inject" in typeRes.value)) {
-        return err(ExtractorErrorCode.InvalidServiceAttribute, (e) => {
-          e.context = prop.getName();
-          e.snippet = prop.getText();
+    static service(classDecl, sourceFile) {
+        const attributes = [];
+        const methods = {};
+        // Attributes
+        for (const prop of classDecl.getProperties()) {
+            const typeRes = CidlExtractor.cidlType(prop.getType(), true);
+            // Error: invalid property type
+            if (typeRes.isLeft()) {
+                typeRes.value.context = prop.getName();
+                typeRes.value.snippet = prop.getText();
+                return typeRes;
+            }
+            if (typeof typeRes.value === "string" || !("Inject" in typeRes.value)) {
+                return err(ExtractorErrorCode.InvalidServiceAttribute, (e) => {
+                    e.context = prop.getName();
+                    e.snippet = prop.getText();
+                });
+            }
+            const checkModifierRes = checkAttributeModifier(prop);
+            if (checkModifierRes.isLeft()) {
+                return checkModifierRes;
+            }
+            attributes.push({
+                var_name: prop.getName(),
+                injected: typeRes.value.Inject,
+            });
+        }
+        // Methods
+        for (const m of classDecl.getMethods()) {
+            const httpVerb = m
+                .getDecorators()
+                .map((d) => getDecoratorName(d))
+                .find((name) => Object.values(HttpVerb).includes(name));
+            if (!httpVerb) {
+                continue;
+            }
+            const res = CidlExtractor.serviceMethod(m, httpVerb);
+            if (res.isLeft()) {
+                return res;
+            }
+            const serviceMethod = res.unwrap();
+            methods[serviceMethod.name] = serviceMethod;
+        }
+        return Either.right({
+            name: classDecl.getName(),
+            attributes,
+            methods,
+            source_path: sourceFile.getFilePath().toString(),
         });
-      }
-      const checkModifierRes = checkAttributeModifier(prop);
-      if (checkModifierRes.isLeft()) {
-        return checkModifierRes;
-      }
-      attributes.push({
-        var_name: prop.getName(),
-        injected: typeRes.value.Inject,
-      });
-    }
-    // Methods
-    for (const m of classDecl.getMethods()) {
-      const httpVerb = m
-        .getDecorators()
-        .map((d) => getDecoratorName(d))
-        .find((name) => Object.values(HttpVerb).includes(name));
-      if (!httpVerb) {
-        continue;
-      }
-      const res = CidlExtractor.serviceMethod(m, httpVerb);
-      if (res.isLeft()) {
-        return res;
-      }
-      const serviceMethod = res.unwrap();
-      methods[serviceMethod.name] = serviceMethod;
     }
-    return Either.right({
-      name: classDecl.getName(),
-      attributes,
-      methods,
-      source_path: sourceFile.getFilePath().toString(),
-    });
-  }
-  static serviceMethod(method, verb) {
-    // Error: invalid method scope, must be public
-    if (method.getScope() != Scope.Public) {
-      return err(ExtractorErrorCode.InvalidApiMethodModifier, (e) => {
-        e.context = method.getName();
-        e.snippet = method.getText();
-      });
-    }
-    const parameters = [];
-    for (const param of method.getParameters()) {
-      // Handle injected param
-      if (param.getDecorator(ParameterDecoratorKind.Inject)) {
-        const typeRes = CidlExtractor.cidlType(param.getType(), true);
+    static serviceMethod(method, verb) {
+        // Error: invalid method scope, must be public
+        if (method.getScope() != Scope.Public) {
+            return err(ExtractorErrorCode.InvalidApiMethodModifier, (e) => {
+                e.context = method.getName();
+                e.snippet = method.getText();
+            });
+        }
+        const parameters = [];
+        for (const param of method.getParameters()) {
+            // Handle injected param
+            if (param.getDecorator(ParameterDecoratorKind.Inject)) {
+                const typeRes = CidlExtractor.cidlType(param.getType(), true);
+                // Error: invalid type
+                if (typeRes.isLeft()) {
+                    typeRes.value.snippet = method.getText();
+                    typeRes.value.context = param.getName();
+                    return typeRes;
+                }
+                parameters.push({
+                    name: param.getName(),
+                    cidl_type: typeRes.unwrap(),
+                });
+                continue;
+            }
+            // Handle all other params
+            const typeRes = CidlExtractor.cidlType(param.getType());
+            // Error: invalid type
+            if (typeRes.isLeft()) {
+                typeRes.value.snippet = method.getText();
+                typeRes.value.context = param.getName();
+                return typeRes;
+            }
+            parameters.push({
+                name: param.getName(),
+                cidl_type: typeRes.unwrap(),
+            });
+        }
+        const typeRes = CidlExtractor.cidlType(method.getReturnType());
         // Error: invalid type
         if (typeRes.isLeft()) {
-          typeRes.value.snippet = method.getText();
-          typeRes.value.context = param.getName();
-          return typeRes;
+            typeRes.value.snippet = method.getText();
+            return typeRes;
         }
-        parameters.push({
-          name: param.getName(),
-          cidl_type: typeRes.unwrap(),
+        return Either.right({
+            name: method.getName(),
+            http_verb: verb,
+            is_static: method.isStatic(),
+            return_media: defaultMediaType(),
+            return_type: typeRes.unwrap(),
+            parameters_media: defaultMediaType(),
+            parameters,
         });
-        continue;
-      }
-      // Handle all other params
-      const typeRes = CidlExtractor.cidlType(param.getType());
-      // Error: invalid type
-      if (typeRes.isLeft()) {
-        typeRes.value.snippet = method.getText();
-        typeRes.value.context = param.getName();
-        return typeRes;
-      }
-      parameters.push({
-        name: param.getName(),
-        cidl_type: typeRes.unwrap(),
-      });
-    }
-    const typeRes = CidlExtractor.cidlType(method.getReturnType());
-    // Error: invalid type
-    if (typeRes.isLeft()) {
-      typeRes.value.snippet = method.getText();
-      return typeRes;
-    }
-    return Either.right({
-      name: method.getName(),
-      http_verb: verb,
-      is_static: method.isStatic(),
-      return_media: defaultMediaType(),
-      return_type: typeRes.unwrap(),
-      parameters_media: defaultMediaType(),
-      parameters,
-    });
-  }
-  static poo(classDecl, sourceFile) {
-    const name = classDecl.getName();
-    const attributes = [];
-    for (const prop of classDecl.getProperties()) {
-      const typeRes = CidlExtractor.cidlType(prop.getType());
-      // Error: invalid property type
-      if (typeRes.isLeft()) {
-        typeRes.value.context = prop.getName();
-        typeRes.value.snippet = prop.getText();
-        return typeRes;
-      }
-      // Error: invalid attribute modifier
-      const modifierRes = checkAttributeModifier(prop);
-      if (modifierRes.isLeft()) {
-        return modifierRes;
-      }
-      const cidl_type = typeRes.unwrap();
-      attributes.push({
-        name: prop.getName(),
-        cidl_type,
-      });
-      continue;
-    }
-    return Either.right({
-      name,
-      attributes,
-      source_path: sourceFile.getFilePath().toString(),
-    });
-  }
-  static env(classDecl, sourceFile) {
-    const vars = {};
-    let binding;
-    for (const prop of classDecl.getProperties()) {
-      if (
-        prop
-          .getType()
-          .getText(
-            undefined,
-            TypeFormatFlags.UseAliasDefinedOutsideCurrentScope,
-          ) === "D1Database"
-      ) {
-        binding = prop.getName();
-        continue;
-      }
-      const ty = CidlExtractor.cidlType(prop.getType());
-      if (ty.isLeft()) {
-        ty.value.context = prop.getName();
-        ty.value.snippet = prop.getText();
-        return ty;
-      }
-      vars[prop.getName()] = ty.unwrap();
-    }
-    if (!binding) {
-      return err(ExtractorErrorCode.MissingDatabaseBinding);
-    }
-    return Either.right({
-      name: classDecl.getName(),
-      source_path: sourceFile.getFilePath().toString(),
-      db_binding: binding,
-      vars,
-    });
-  }
-  static primTypeMap = {
-    number: "Real",
-    Number: "Real",
-    Integer: "Integer",
-    string: "Text",
-    String: "Text",
-    boolean: "Boolean",
-    Boolean: "Boolean",
-    Date: "DateIso",
-    Uint8Array: "Blob",
-    Stream: "Stream",
-  };
-  static cidlType(type, inject = false) {
-    // Void
-    if (type.isVoid()) {
-      return Either.right("Void");
-    }
-    // Null
-    if (type.isNull()) {
-      return Either.right({ Nullable: "Void" });
-    }
-    // Nullable via union
-    const [unwrappedType, nullable] = unwrapNullable(type);
-    const tyText = unwrappedType
-      .getText(undefined, TypeFormatFlags.UseAliasDefinedOutsideCurrentScope)
-      .split("|")[0]
-      .trim();
-    // Primitives
-    const prim = this.primTypeMap[tyText];
-    if (prim) {
-      return Either.right(wrapNullable(prim, nullable));
-    }
-    const generics = [
-      ...unwrappedType.getAliasTypeArguments(),
-      ...unwrappedType.getTypeArguments(),
-    ];
-    // Error: can't handle multiple generics
-    if (generics.length > 1) {
-      return err(ExtractorErrorCode.MultipleGenericType);
-    }
-    // No generics -> inject or object
-    if (generics.length === 0) {
-      const base = inject ? { Inject: tyText } : { Object: tyText };
-      return Either.right(wrapNullable(base, nullable));
     }
-    // Single generic
-    const genericTy = generics[0];
-    const symbolName = unwrappedType.getSymbol()?.getName();
-    const aliasName = unwrappedType.getAliasSymbol()?.getName();
-    if (aliasName === "DataSourceOf") {
-      return Either.right(
-        wrapNullable(
-          {
-            DataSource: genericTy.getText(
-              undefined,
-              TypeFormatFlags.UseAliasDefinedOutsideCurrentScope,
-            ),
-          },
-          nullable,
-        ),
-      );
-    }
-    if (aliasName === "DeepPartial") {
-      const [_, genericTyNullable] = unwrapNullable(genericTy);
-      const genericTyGenerics = [
-        ...genericTy.getAliasTypeArguments(),
-        ...genericTy.getTypeArguments(),
-      ];
-      // Expect partials to be of the exact form DeepPartial<Model>
-      if (
-        genericTyNullable ||
-        genericTy.isUnion() ||
-        genericTyGenerics.length > 0
-      ) {
-        return err(ExtractorErrorCode.InvalidPartialType);
-      }
-      return Either.right(
-        wrapNullable(
-          {
-            Partial: genericTy
-              .getText(
-                undefined,
-                TypeFormatFlags.UseAliasDefinedOutsideCurrentScope,
-              )
-              .split("|")[0]
-              .trim(),
-          },
-          nullable,
-        ),
-      );
-    }
-    if (symbolName === "Promise" || aliasName === "IncludeTree") {
-      // Unwrap promises
-      return wrapGeneric(genericTy, nullable, (inner) => inner);
-    }
-    if (unwrappedType.isArray()) {
-      return wrapGeneric(genericTy, nullable, (inner) => ({ Array: inner }));
-    }
-    if (symbolName === "HttpResult") {
-      return wrapGeneric(genericTy, nullable, (inner) => ({
-        HttpResult: inner,
-      }));
-    }
-    // Error: unknown type
-    return err(ExtractorErrorCode.UnknownType);
-    function wrapNullable(inner, isNullable) {
-      if (isNullable) {
-        return { Nullable: inner };
-      } else {
-        return inner;
-      }
-    }
-    function wrapGeneric(t, isNullable, wrapper) {
-      const res = CidlExtractor.cidlType(t, inject);
-      // Error: propogated from `cidlType`
-      return res.map((inner) => wrapNullable(wrapper(inner), isNullable));
+    static poo(classDecl, sourceFile) {
+        const name = classDecl.getName();
+        const attributes = [];
+        for (const prop of classDecl.getProperties()) {
+            const typeRes = CidlExtractor.cidlType(prop.getType());
+            // Error: invalid property type
+            if (typeRes.isLeft()) {
+                typeRes.value.context = prop.getName();
+                typeRes.value.snippet = prop.getText();
+                return typeRes;
+            }
+            // Error: invalid attribute modifier
+            const modifierRes = checkAttributeModifier(prop);
+            if (modifierRes.isLeft()) {
+                return modifierRes;
+            }
+            const cidl_type = typeRes.unwrap();
+            attributes.push({
+                name: prop.getName(),
+                cidl_type,
+            });
+            continue;
+        }
+        return Either.right({
+            name,
+            attributes,
+            source_path: sourceFile.getFilePath().toString(),
+        });
     }
-    function unwrapNullable(ty) {
-      if (!ty.isUnion()) return [ty, false];
-      const unions = ty.getUnionTypes();
-      const nonNulls = unions.filter((t) => !t.isNull() && !t.isUndefined());
-      const hasNullable = nonNulls.length < unions.length;
-      // Booleans seperate into [null, true, false] from the `getUnionTypes` call
-      if (
-        nonNulls.length === 2 &&
-        nonNulls.every((t) => t.isBooleanLiteral())
-      ) {
-        return [nonNulls[0].getApparentType(), hasNullable];
-      }
-      return [nonNulls[0] ?? ty, hasNullable];
+    static env(classDecl, sourceFile) {
+        const vars = {};
+        let binding;
+        for (const prop of classDecl.getProperties()) {
+            if (prop
+                .getType()
+                .getText(undefined, TypeFormatFlags.UseAliasDefinedOutsideCurrentScope) === "D1Database") {
+                binding = prop.getName();
+                continue;
+            }
+            const ty = CidlExtractor.cidlType(prop.getType());
+            if (ty.isLeft()) {
+                ty.value.context = prop.getName();
+                ty.value.snippet = prop.getText();
+                return ty;
+            }
+            vars[prop.getName()] = ty.unwrap();
+        }
+        if (!binding) {
+            return err(ExtractorErrorCode.MissingDatabaseBinding);
+        }
+        return Either.right({
+            name: classDecl.getName(),
+            source_path: sourceFile.getFilePath().toString(),
+            db_binding: binding,
+            vars,
+        });
     }
-  }
-  static includeTree(expr, currentClass, sf) {
-    // Include trees must be of the expected form
-    if (
-      !expr ||
-      !expr.isKind ||
-      !expr.isKind(SyntaxKind.ObjectLiteralExpression)
-    ) {
-      return err(ExtractorErrorCode.InvalidIncludeTree);
+    static primTypeMap = {
+        number: "Real",
+        Number: "Real",
+        Integer: "Integer",
+        string: "Text",
+        String: "Text",
+        boolean: "Boolean",
+        Boolean: "Boolean",
+        Date: "DateIso",
+        Uint8Array: "Blob",
+        Stream: "Stream",
+    };
+    static cidlType(type, inject = false) {
+        // Void
+        if (type.isVoid()) {
+            return Either.right("Void");
+        }
+        // Null
+        if (type.isNull()) {
+            return Either.right({ Nullable: "Void" });
+        }
+        // Nullable via union
+        const [unwrappedType, nullable] = unwrapNullable(type);
+        const tyText = unwrappedType
+            .getText(undefined, TypeFormatFlags.UseAliasDefinedOutsideCurrentScope)
+            .split("|")[0]
+            .trim();
+        // Primitives
+        const prim = this.primTypeMap[tyText];
+        if (prim) {
+            return Either.right(wrapNullable(prim, nullable));
+        }
+        const generics = [
+            ...unwrappedType.getAliasTypeArguments(),
+            ...unwrappedType.getTypeArguments(),
+        ];
+        // Error: can't handle multiple generics
+        if (generics.length > 1) {
+            return err(ExtractorErrorCode.MultipleGenericType);
+        }
+        // No generics -> inject or object
+        if (generics.length === 0) {
+            const base = inject ? { Inject: tyText } : { Object: tyText };
+            return Either.right(wrapNullable(base, nullable));
+        }
+        // Single generic
+        const genericTy = generics[0];
+        const symbolName = unwrappedType.getSymbol()?.getName();
+        const aliasName = unwrappedType.getAliasSymbol()?.getName();
+        if (aliasName === "DataSourceOf") {
+            return Either.right(wrapNullable({
+                DataSource: genericTy.getText(undefined, TypeFormatFlags.UseAliasDefinedOutsideCurrentScope),
+            }, nullable));
+        }
+        if (aliasName === "DeepPartial") {
+            const [_, genericTyNullable] = unwrapNullable(genericTy);
+            const genericTyGenerics = [
+                ...genericTy.getAliasTypeArguments(),
+                ...genericTy.getTypeArguments(),
+            ];
+            // Expect partials to be of the exact form DeepPartial<Model>
+            if (genericTyNullable ||
+                genericTy.isUnion() ||
+                genericTyGenerics.length > 0) {
+                return err(ExtractorErrorCode.InvalidPartialType);
+            }
+            return Either.right(wrapNullable({
+                Partial: genericTy
+                    .getText(undefined, TypeFormatFlags.UseAliasDefinedOutsideCurrentScope)
+                    .split("|")[0]
+                    .trim(),
+            }, nullable));
+        }
+        if (symbolName === "Promise" || aliasName === "IncludeTree") {
+            // Unwrap promises
+            return wrapGeneric(genericTy, nullable, (inner) => inner);
+        }
+        if (unwrappedType.isArray()) {
+            return wrapGeneric(genericTy, nullable, (inner) => ({ Array: inner }));
+        }
+        if (symbolName === "HttpResult") {
+            return wrapGeneric(genericTy, nullable, (inner) => ({
+                HttpResult: inner,
+            }));
+        }
+        // Error: unknown type
+        return err(ExtractorErrorCode.UnknownType);
+        function wrapNullable(inner, isNullable) {
+            if (isNullable) {
+                return { Nullable: inner };
+            }
+            else {
+                return inner;
+            }
+        }
+        function wrapGeneric(t, isNullable, wrapper) {
+            const res = CidlExtractor.cidlType(t, inject);
+            // Error: propogated from `cidlType`
+            return res.map((inner) => wrapNullable(wrapper(inner), isNullable));
+        }
+        function unwrapNullable(ty) {
+            if (!ty.isUnion())
+                return [ty, false];
+            const unions = ty.getUnionTypes();
+            const nonNulls = unions.filter((t) => !t.isNull() && !t.isUndefined());
+            const hasNullable = nonNulls.length < unions.length;
+            // Booleans seperate into [null, true, false] from the `getUnionTypes` call
+            if (nonNulls.length === 2 &&
+                nonNulls.every((t) => t.isBooleanLiteral())) {
+                return [nonNulls[0].getApparentType(), hasNullable];
+            }
+            return [nonNulls[0] ?? ty, hasNullable];
+        }
     }
-    const result = {};
-    for (const prop of expr.getProperties()) {
-      if (!prop.isKind(SyntaxKind.PropertyAssignment)) continue;
-      // Error: navigation property not found
-      const navProp = findPropertyByName(currentClass, prop.getName());
-      if (!navProp) {
-        return err(
-          ExtractorErrorCode.UnknownNavigationPropertyReference,
-          (e) => {
-            e.snippet = expr.getText();
-            e.context = prop.getName();
-          },
-        );
-      }
-      const typeRes = CidlExtractor.cidlType(navProp.getType());
-      // Error: invalid referenced nav prop type
-      if (typeRes.isLeft()) {
-        typeRes.value.snippet = navProp.getText();
-        typeRes.value.context = prop.getName();
-        return typeRes;
-      }
-      // Error: invalid referenced nav prop type
-      const cidl_type = typeRes.unwrap();
-      if (typeof cidl_type === "string") {
-        return err(
-          ExtractorErrorCode.InvalidNavigationPropertyReference,
-          (e) => {
-            e.snippet = navProp.getText();
-            e.context = prop.getName();
-          },
-        );
-      }
-      // Recurse for nested includes
-      const initializer = prop.getInitializer?.();
-      let nestedTree = {};
-      if (initializer?.isKind?.(SyntaxKind.ObjectLiteralExpression)) {
-        const targetModel = getObjectName(cidl_type);
-        const targetClass = currentClass
-          .getSourceFile()
-          .getProject()
-          .getSourceFiles()
-          .flatMap((f) => f.getClasses())
-          .find((c) => c.getName() === targetModel);
-        if (targetClass) {
-          const treeRes = CidlExtractor.includeTree(
-            initializer,
-            targetClass,
-            sf,
-          );
-          // Error: Propogated from `includeTree`
-          if (treeRes.isLeft()) {
-            treeRes.value.snippet = expr.getText();
-            return treeRes;
-          }
-          nestedTree = treeRes.unwrap();
-        }
-      }
-      result[navProp.getName()] = nestedTree;
+    static includeTree(expr, currentClass, sf) {
+        // Include trees must be of the expected form
+        if (!expr ||
+            !expr.isKind ||
+            !expr.isKind(SyntaxKind.ObjectLiteralExpression)) {
+            return err(ExtractorErrorCode.InvalidIncludeTree);
+        }
+        const result = {};
+        for (const prop of expr.getProperties()) {
+            if (!prop.isKind(SyntaxKind.PropertyAssignment))
+                continue;
+            // Error: navigation property not found
+            const navProp = findPropertyByName(currentClass, prop.getName());
+            if (!navProp) {
+                return err(ExtractorErrorCode.UnknownNavigationPropertyReference, (e) => {
+                    e.snippet = expr.getText();
+                    e.context = prop.getName();
+                });
+            }
+            const typeRes = CidlExtractor.cidlType(navProp.getType());
+            // Error: invalid referenced nav prop type
+            if (typeRes.isLeft()) {
+                typeRes.value.snippet = navProp.getText();
+                typeRes.value.context = prop.getName();
+                return typeRes;
+            }
+            // Error: invalid referenced nav prop type
+            const cidl_type = typeRes.unwrap();
+            if (typeof cidl_type === "string") {
+                return err(ExtractorErrorCode.InvalidNavigationPropertyReference, (e) => {
+                    e.snippet = navProp.getText();
+                    e.context = prop.getName();
+                });
+            }
+            // Recurse for nested includes
+            const initializer = prop.getInitializer?.();
+            let nestedTree = {};
+            if (initializer?.isKind?.(SyntaxKind.ObjectLiteralExpression)) {
+                const targetModel = getObjectName(cidl_type);
+                const targetClass = currentClass
+                    .getSourceFile()
+                    .getProject()
+                    .getSourceFiles()
+                    .flatMap((f) => f.getClasses())
+                    .find((c) => c.getName() === targetModel);
+                if (targetClass) {
+                    const treeRes = CidlExtractor.includeTree(initializer, targetClass, sf);
+                    // Error: Propogated from `includeTree`
+                    if (treeRes.isLeft()) {
+                        treeRes.value.snippet = expr.getText();
+                        return treeRes;
+                    }
+                    nestedTree = treeRes.unwrap();
+                }
+            }
+            result[navProp.getName()] = nestedTree;
+        }
+        return Either.right(result);
     }
-    return Either.right(result);
-  }
 }
 function err(code, fn) {
-  let e = new ExtractorError(code);
-  if (fn) {
-    fn(e);
-  }
-  return Either.left(e);
+    let e = new ExtractorError(code);
+    if (fn) {
+        fn(e);
+    }
+    return Either.left(e);
 }
 function getDecoratorName(decorator) {
-  const name = decorator.getName() ?? decorator.getExpression().getText();
-  return String(name).replace(/\(.*\)$/, "");
+    const name = decorator.getName() ?? decorator.getExpression().getText();
+    return String(name).replace(/\(.*\)$/, "");
 }
 function getDecoratorArgument(decorator, index) {
-  const args = decorator.getArguments();
-  if (!args[index]) return undefined;
-  const arg = args[index];
-  if (arg.getKind?.() === SyntaxKind.Identifier) {
-    return arg.getText();
-  }
-  return arg.getLiteralValue();
+    const args = decorator.getArguments();
+    if (!args[index])
+        return undefined;
+    const arg = args[index];
+    if (arg.getKind?.() === SyntaxKind.Identifier) {
+        return arg.getText();
+    }
+    return arg.getLiteralValue();
 }
 function getRootType(t) {
-  if (typeof t === "string") {
+    if (typeof t === "string") {
+        return t;
+    }
+    if ("Nullable" in t) {
+        return getRootType(t.Nullable);
+    }
+    if ("Array" in t) {
+        return getRootType(t.Array);
+    }
+    if ("HttpResult" in t) {
+        return getRootType(t.HttpResult);
+    }
     return t;
-  }
-  if ("Nullable" in t) {
-    return getRootType(t.Nullable);
-  }
-  if ("Array" in t) {
-    return getRootType(t.Array);
-  }
-  if ("HttpResult" in t) {
-    return getRootType(t.HttpResult);
-  }
-  return t;
 }
 function getObjectName(t) {
-  const root = getRootType(t);
-  if (typeof root !== "string" && "Object" in root) {
-    return root["Object"];
-  }
-  return undefined;
+    const root = getRootType(t);
+    if (typeof root !== "string" && "Object" in root) {
+        return root["Object"];
+    }
+    return undefined;
 }
 function setCrudKinds(d, cruds) {
-  const arg = d.getArguments()[0];
-  if (!arg) {
-    return;
-  }
-  if (MorphNode.isArrayLiteralExpression(arg)) {
-    for (const a of arg.getElements()) {
-      cruds.add(
-        MorphNode.isStringLiteral(a) ? a.getLiteralValue() : a.getText(),
-      );
+    const arg = d.getArguments()[0];
+    if (!arg) {
+        return;
+    }
+    if (MorphNode.isArrayLiteralExpression(arg)) {
+        for (const a of arg.getElements()) {
+            cruds.add((MorphNode.isStringLiteral(a)
+                ? a.getLiteralValue()
+                : a.getText()));
+        }
     }
-  }
 }
 function findPropertyByName(cls, name) {
-  const exactMatch = cls.getProperties().find((p) => p.getName() === name);
-  return exactMatch;
+    const exactMatch = cls.getProperties().find((p) => p.getName() === name);
+    return exactMatch;
 }
 function hasDecorator(node, name) {
-  return node.getDecorators().some((d) => {
-    const decoratorName = getDecoratorName(d);
-    return decoratorName === name || decoratorName.endsWith("." + name);
-  });
+    return node.getDecorators().some((d) => {
+        const decoratorName = getDecoratorName(d);
+        return decoratorName === name || decoratorName.endsWith("." + name);
+    });
 }
 function checkAttributeModifier(prop) {
-  // Error: attributes must be just 'public'
-  if (prop.getScope() != Scope.Public || prop.isReadonly() || prop.isStatic()) {
-    return err(ExtractorErrorCode.InvalidAttributeModifier, (e) => {
-      e.context = prop.getName();
-      e.snippet = prop.getText();
-    });
-  }
-  return Either.right(null);
+    // Error: attributes must be just 'public'
+    if (prop.getScope() != Scope.Public || prop.isReadonly() || prop.isStatic()) {
+        return err(ExtractorErrorCode.InvalidAttributeModifier, (e) => {
+            e.context = prop.getName();
+            e.snippet = prop.getText();
+        });
+    }
+    return Either.right(null);
 }