cloesce 0.0.5-unstable.3 → 0.0.5-unstable.5

package/dist/extractor/extract.js

@@ -1,882 +1,1044 @@
-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 || (AttributeDecoratorKind = {}));
+import { Either } from "../common.js";
+var PropertyDecoratorKind;
+(function (PropertyDecoratorKind) {
+    PropertyDecoratorKind["PrimaryKey"] = "PrimaryKey";
+    PropertyDecoratorKind["ForeignKey"] = "ForeignKey";
+    PropertyDecoratorKind["OneToOne"] = "OneToOne";
+    PropertyDecoratorKind["OneToMany"] = "OneToMany";
+    PropertyDecoratorKind["ManyToMany"] = "ManyToMany";
+    PropertyDecoratorKind["KeyParam"] = "KeyParam";
+    PropertyDecoratorKind["KV"] = "KV";
+    PropertyDecoratorKind["R2"] = "R2";
+})(PropertyDecoratorKind || (PropertyDecoratorKind = {}));
 var ClassDecoratorKind;
 (function (ClassDecoratorKind) {
-  ClassDecoratorKind["D1"] = "D1";
-  ClassDecoratorKind["WranglerEnv"] = "WranglerEnv";
-  ClassDecoratorKind["PlainOldObject"] = "PlainOldObject";
-  ClassDecoratorKind["Service"] = "Service";
-  ClassDecoratorKind["CRUD"] = "CRUD";
+    ClassDecoratorKind["Model"] = "Model";
+    ClassDecoratorKind["WranglerEnv"] = "WranglerEnv";
+    ClassDecoratorKind["Service"] = "Service";
 })(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;
+    modelDecls;
+    extractedPoos;
+    constructor(modelDecls, extractedPoos = new Map()) {
+        this.modelDecls = modelDecls;
+        this.extractedPoos = extractedPoos;
+    }
+    static extract(projectName, project) {
+        const modelDecls = new Map();
+        const serviceDecls = new Map();
+        const wranglerEnvs = [];
+        let main_source = null;
+        // TODO: Concurrently across several threads?
+        for (const sourceFile of project.getSourceFiles()) {
+            // Extract main source
+            const mainRes = CidlExtractor.main(sourceFile);
+            if (mainRes.isLeft()) {
+                return mainRes;
+            }
+            const main = mainRes.unwrap();
+            if (main) {
+                main_source = main;
+            }
+            for (const classDecl of sourceFile.getClasses()) {
+                const notExportedErr = err(ExtractorErrorCode.MissingExport, (e) => {
+                    e.context = classDecl.getName();
+                    e.snippet = classDecl.getText();
+                });
+                for (const decorator of classDecl.getDecorators()) {
+                    const decoratorName = decorator.getName();
+                    switch (decoratorName) {
+                        case ClassDecoratorKind.Model: {
+                            if (!classDecl.isExported())
+                                return notExportedErr;
+                            modelDecls.set(classDecl.getName(), [classDecl, decorator]);
+                            break;
+                        }
+                        case ClassDecoratorKind.Service: {
+                            if (!classDecl.isExported())
+                                return notExportedErr;
+                            serviceDecls.set(classDecl.getName(), classDecl);
+                            break;
+                        }
+                        case ClassDecoratorKind.WranglerEnv: {
+                            const res = CidlExtractor.env(classDecl, sourceFile);
+                            if (res.isLeft()) {
+                                res.value.addContext((prev) => `${classDecl.getName()}.${prev}`);
+                                return res;
+                            }
+                            const wranglerEnv = res.unwrap();
+                            wranglerEnvs.push(wranglerEnv);
+                            break;
+                        }
+                        default: {
+                            continue;
+                        }
+                    }
+                }
             }
-          }
-          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);
-    }
-    // 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,
-          },
+        const extractor = new CidlExtractor(modelDecls);
+        // Extract models
+        const models = {};
+        for (const [_, [classDecl, decorator]] of modelDecls) {
+            const res = extractor.model(classDecl, classDecl.getSourceFile(), decorator);
+            if (res.isLeft()) {
+                res.value.addContext((prev) => `${classDecl.getName()}.${prev}`);
+                return res;
+            }
+            const model = res.unwrap();
+            models[model.name] = model;
+        }
+        // Extract services
+        const services = {};
+        for (const [_, classDecl] of serviceDecls) {
+            const res = extractor.service(classDecl, classDecl.getSourceFile());
+            if (res.isLeft()) {
+                res.value.addContext((prev) => `${classDecl.getName()}.${prev}`);
+                return res;
+            }
+            const service = res.unwrap();
+            services[service.name] = service;
+        }
+        // Error: Only one wrangler environment can exist
+        if (wranglerEnvs.length > 1) {
+            return err(ExtractorErrorCode.TooManyWranglerEnvs, (e) => (e.context = wranglerEnvs.map((w) => w.name).toString()));
+        }
+        const poos = Object.fromEntries(extractor.extractedPoos);
+        return Either.right({
+            project_name: projectName,
+            wrangler_env: wranglerEnvs[0], // undefined if none
+            models,
+            poos,
+            services,
+            main_source,
         });
-        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();
+    }
+    /**
+     * @returns An error if the main function is invalid, or the source code of the app function if valid.
+     * Undefined if no main function is defined.
+     */
+    static main(sourceFile) {
+        const symbol = sourceFile.getDefaultExportSymbol();
+        const decl = symbol?.getDeclarations()[0];
+        if (!decl || !MorphNode.isFunctionDeclaration(decl)) {
+            return Either.right(undefined);
+        }
+        // Must be named "main"
+        const name = decl.getName();
+        if (name !== "main") {
+            return Either.right(undefined);
+        }
+        // Must be async
+        if (!decl.isAsync()) {
+            return err(ExtractorErrorCode.InvalidMain, (e) => (e.context = "Missing async modifier"));
+        }
+        // Must have exactly 4 parameters
+        const params = decl.getParameters();
+        if (params.length !== 4) {
+            return err(ExtractorErrorCode.InvalidMain, (e) => {
+                e.context = `Expected 4 parameters, got ${params.length}`;
             });
-          // 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();
+        }
+        // Expected parameter types in order
+        // WranglerEnv does not have a required type annotation
+        const expectedTypes = ["Request", null, "CloesceApp", "ExecutionContext"];
+        for (let i = 0; i < params.length; i++) {
+            const param = params[i];
+            const expectedType = expectedTypes[i];
+            if (expectedType === null) {
+                continue;
+            }
+            const paramType = param.getType();
+            const symbol = paramType.getAliasSymbol() ??
+                paramType.getSymbol() ??
+                paramType.getTargetType()?.getSymbol();
+            if (symbol?.getName() !== expectedType) {
+                return err(ExtractorErrorCode.InvalidMain, (e) => {
+                    e.context = `Expected parameter ${i + 1} to be of type ${expectedType}, got ${paramType}`;
+                });
+            }
+        }
+        // Must return Response
+        const returnType = decl
+            .getReturnType()
+            .getText(undefined, TypeFormatFlags.UseAliasDefinedOutsideCurrentScope);
+        if (returnType !== "Promise<Response>") {
+            return err(ExtractorErrorCode.InvalidMain, (e) => {
+                e.context = `Expected return type to be Promise<Response>, got ${returnType}`;
             });
-          }
-          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();
-      });
+        }
+        return Either.right(sourceFile.getFilePath().toString());
     }
-    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;
+    model(classDecl, sourceFile, decorator) {
+        const name = classDecl.getName();
+        const columns = [];
+        const key_params = [];
+        const kv_objects = [];
+        const r2_objects = [];
+        const navigation_properties = [];
+        const data_sources = {};
+        const methods = {};
+        const cruds = new Set();
+        let primary_key = null;
+        // Extract crud methods
+        const arg = decorator.getArguments()[0];
+        if (arg && MorphNode.isArrayLiteralExpression(arg)) {
+            for (const a of arg.getElements()) {
+                cruds.add((MorphNode.isStringLiteral(a)
+                    ? a.getLiteralValue()
+                    : a.getText()));
+            }
+        }
+        // Iterate properties
+        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;
+            }
+            const cidl_type = typeRes.unwrap();
+            // Include Trees
+            const isIncludeTree = prop
+                .getType()
+                .getText(undefined, TypeFormatFlags.UseAliasDefinedOutsideCurrentScope) === `IncludeTree<${name}>`;
+            if (isIncludeTree) {
+                // Error: data sources must be static include trees
+                if (!prop.isStatic()) {
+                    return err(ExtractorErrorCode.InvalidDataSourceDefinition, (e) => {
+                        e.snippet = prop.getText();
+                        e.context = prop.getName();
+                    });
+                }
+                const initializer = prop.getInitializer();
+                if (!initializer?.isKind(SyntaxKind.ObjectLiteralExpression)) {
+                    return err(ExtractorErrorCode.InvalidDataSourceDefinition, (e) => {
+                        e.snippet = prop.getText();
+                        e.context = prop.getName();
+                    });
+                }
+                data_sources[prop.getName()] = {
+                    name: prop.getName(),
+                    tree: parseIncludeTree(initializer),
+                };
+                continue;
+            }
+            const checkModifierRes = checkPropertyModifier(prop);
+            // Error: invalid property modifier
+            if (checkModifierRes.isLeft()) {
+                return checkModifierRes;
+            }
+            // Infer decorator
+            if (prop.getDecorators().length === 0) {
+                this.inferModelDecorator(prop, classDecl, cidl_type);
+            }
+            const decorators = prop.getDecorators();
+            // Scalar column
+            if (decorators.length === 0) {
+                columns.push({
+                    foreign_key_reference: null,
+                    value: {
+                        name: prop.getName(),
+                        cidl_type,
+                    },
+                });
+                continue;
+            }
+            const decorator = decorators[0];
+            const decoratorName = getDecoratorName(decorator);
+            // Process decorator
+            switch (decoratorName) {
+                case PropertyDecoratorKind.PrimaryKey: {
+                    primary_key = {
+                        name: prop.getName(),
+                        cidl_type,
+                    };
+                    break;
+                }
+                case PropertyDecoratorKind.ForeignKey: {
+                    columns.push({
+                        foreign_key_reference: getDecoratorArgument(decorator, 0) ?? null,
+                        value: {
+                            name: prop.getName(),
+                            cidl_type,
+                        },
+                    });
+                    break;
+                }
+                case PropertyDecoratorKind.OneToOne: {
+                    const selector = getSelectorPropertyName(decorator);
+                    if (selector.isLeft()) {
+                        return err(ExtractorErrorCode.InvalidSelectorSyntax, (e) => {
+                            e.snippet = prop.getText();
+                            e.context = prop.getName();
+                        });
+                    }
+                    const model_name = getObjectName(cidl_type);
+                    // Error: navigation properties require a model reference
+                    if (!model_name) {
+                        return err(ExtractorErrorCode.InvalidSelectorSyntax, (e) => {
+                            e.snippet = prop.getText();
+                            e.context = prop.getName();
+                        });
+                    }
+                    navigation_properties.push({
+                        var_name: prop.getName(),
+                        model_reference: model_name,
+                        kind: { OneToOne: { column_reference: selector.unwrap() } },
+                    });
+                    break;
+                }
+                case PropertyDecoratorKind.OneToMany: {
+                    const selector = getSelectorPropertyName(decorator);
+                    if (selector.isLeft()) {
+                        return err(ExtractorErrorCode.InvalidSelectorSyntax, (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.InvalidNavigationProperty, (e) => {
+                            e.snippet = prop.getText();
+                            e.context = prop.getName();
+                        });
+                    }
+                    navigation_properties.push({
+                        var_name: prop.getName(),
+                        model_reference: model_name,
+                        kind: { OneToMany: { column_reference: selector.unwrap() } },
+                    });
+                    break;
+                }
+                case PropertyDecoratorKind.ManyToMany: {
+                    // Error: navigation properties require a model reference
+                    let model_name = getObjectName(cidl_type);
+                    if (!model_name) {
+                        return err(ExtractorErrorCode.InvalidNavigationProperty, (e) => {
+                            e.snippet = prop.getText();
+                            e.context = prop.getName();
+                        });
+                    }
+                    navigation_properties.push({
+                        var_name: prop.getName(),
+                        model_reference: model_name,
+                        kind: "ManyToMany",
+                    });
+                    break;
+                }
+                case PropertyDecoratorKind.KeyParam: {
+                    key_params.push(prop.getName());
+                    break;
+                }
+                case PropertyDecoratorKind.KV: {
+                    // Format and namespace binding are required
+                    const format = getDecoratorArgument(decorator, 0);
+                    const namespace_binding = getDecoratorArgument(decorator, 1);
+                    if (!format || !namespace_binding) {
+                        return err(ExtractorErrorCode.InvalidTypescriptSyntax, (e) => {
+                            e.snippet = prop.getText();
+                            e.context = prop.getName();
+                        });
+                    }
+                    // Ensure that the prop type is KValue<T>
+                    const ty = prop.getType();
+                    const isArray = ty.isArray();
+                    const elementType = isArray ? ty.getArrayElementTypeOrThrow() : ty;
+                    const symbolName = elementType.getSymbol()?.getName();
+                    if (symbolName !== "KValue") {
+                        return err(ExtractorErrorCode.MissingKValue, (e) => {
+                            e.snippet = prop.getText();
+                            e.context = prop.getName();
+                        });
+                    }
+                    kv_objects.push({
+                        format,
+                        namespace_binding,
+                        value: {
+                            name: prop.getName(),
+                            cidl_type: isArray ? cidl_type.Array : cidl_type,
+                        },
+                        list_prefix: isArray,
+                    });
+                    break;
+                }
+                case PropertyDecoratorKind.R2: {
+                    // Format and bucket binding are required
+                    const format = getDecoratorArgument(decorator, 0);
+                    const bucket_binding = getDecoratorArgument(decorator, 1);
+                    if (!format || !bucket_binding) {
+                        return err(ExtractorErrorCode.InvalidTypescriptSyntax, (e) => {
+                            e.snippet = prop.getText();
+                            e.context = prop.getName();
+                        });
+                    }
+                    // Type must be R2ObjectBody
+                    const ty = prop.getType();
+                    const isArray = ty.isArray();
+                    const elementType = isArray ? ty.getArrayElementTypeOrThrow() : ty;
+                    const symbolName = elementType.getSymbol()?.getName();
+                    if (symbolName !== "R2ObjectBody") {
+                        return err(ExtractorErrorCode.MissingR2ObjectBody, (e) => {
+                            e.snippet = prop.getText();
+                            e.context = prop.getName();
+                        });
+                    }
+                    r2_objects.push({
+                        format,
+                        bucket_binding,
+                        var_name: prop.getName(),
+                        list_prefix: isArray,
+                    });
+                    break;
+                }
+            }
         }
-        parameters.push({
-          name: param.getName(),
-          cidl_type: typeRes.unwrap(),
+        // Process methods
+        for (const m of classDecl.getMethods()) {
+            const httpVerb = m
+                .getDecorators()
+                .map(getDecoratorName)
+                .find((name) => Object.values(HttpVerb).includes(name));
+            if (!httpVerb) {
+                continue;
+            }
+            const result = this.method(m, httpVerb);
+            if (result.isLeft()) {
+                result.value.addContext((prev) => `${m.getName()} ${prev}`);
+                return result;
+            }
+            methods[result.unwrap().name] = result.unwrap();
+        }
+        return Either.right({
+            name,
+            columns,
+            primary_key,
+            navigation_properties,
+            key_params,
+            kv_objects,
+            r2_objects,
+            methods,
+            data_sources,
+            cruds: Array.from(cruds).sort(),
+            source_path: sourceFile.getFilePath().toString(),
         });
-        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();
+    service(classDecl, sourceFile) {
+        const attributes = [];
+        const methods = {};
+        // Properties
+        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.InvalidServiceProperty, (e) => {
+                    e.context = prop.getName();
+                    e.snippet = prop.getText();
+                });
+            }
+            // Error: invalid property modifier
+            const checkModifierRes = checkPropertyModifier(prop);
+            if (checkModifierRes.isLeft()) {
+                return checkModifierRes;
+            }
+            attributes.push({
+                var_name: prop.getName(),
+                inject_reference: typeRes.value.Inject,
+            });
+        }
+        // Methods
+        for (const m of classDecl.getMethods()) {
+            const httpVerb = m
+                .getDecorators()
+                .map(getDecoratorName)
+                .find((name) => Object.values(HttpVerb).includes(name));
+            if (!httpVerb) {
+                continue;
+            }
+            const res = this.method(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);
+    method(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;
+            }
+            // Extract any POOs used as parameter types
+            const objectName = getObjectName(typeRes.unwrap());
+            if (objectName &&
+                !this.extractedPoos.has(objectName) &&
+                !this.modelDecls.has(objectName)) {
+                const res = this.poo(method.getSourceFile().getClassOrThrow(objectName), method.getSourceFile());
+                if (res.isLeft()) {
+                    res.value.addContext((prev) => `${param.getName()}.${prev}`);
+                    return res;
+                }
+            }
+            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;
+        }
+        // Extract any POOs used as return types
+        const objectName = getObjectName(typeRes.unwrap());
+        if (objectName &&
+            !this.extractedPoos.has(objectName) &&
+            !this.modelDecls.has(objectName)) {
+            const res = this.poo(method.getSourceFile().getClassOrThrow(objectName), method.getSourceFile());
+            if (res.isLeft()) {
+                res.value.addContext((prev) => `returns ${prev}`);
+                return res;
+            }
         }
-        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));
+    poo(classDecl, sourceFile) {
+        const name = classDecl.getName();
+        const attributes = [];
+        // Error: POOs must be exported
+        if (!classDecl.isExported()) {
+            return err(ExtractorErrorCode.MissingExport, (e) => {
+                e.context = name;
+                e.snippet = classDecl.getText();
+            });
+        }
+        for (const prop of classDecl.getProperties()) {
+            // Error: invalid property modifier
+            const modifierRes = checkPropertyModifier(prop);
+            if (modifierRes.isLeft()) {
+                return modifierRes;
+            }
+            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 cidl_type = typeRes.unwrap();
+            // Check that the type is an already extracted POO, or a model decl.
+            // If not, find the source and extract it as a POO.
+            const objectName = getObjectName(cidl_type);
+            if (objectName &&
+                !this.extractedPoos.has(objectName) &&
+                !this.modelDecls.has(objectName)) {
+                const res = this.poo(classDecl.getSourceFile().getClassOrThrow(objectName), classDecl.getSourceFile());
+                if (res.isLeft()) {
+                    res.value.addContext((prev) => `${prop.getName()}.${prev}`);
+                    return res;
+                }
+            }
+            attributes.push({
+                name: prop.getName(),
+                cidl_type,
+            });
+            continue;
+        }
+        // Mark as extracted
+        const poo = {
+            name,
+            attributes,
+            source_path: sourceFile.getFilePath().toString(),
+        };
+        this.extractedPoos.set(name, poo);
+        return Either.right(null);
     }
-    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];
+    // public for tests
+    static env(classDecl, sourceFile) {
+        const vars = {};
+        let d1_binding = undefined;
+        const kv_bindings = [];
+        const r2_bindings = [];
+        for (const prop of classDecl.getProperties()) {
+            // Error: invalid property modifier
+            const checkModifierRes = checkPropertyModifier(prop);
+            if (checkModifierRes.isLeft()) {
+                return checkModifierRes;
+            }
+            // TODO: Support multiple D1 bindings
+            if (prop
+                .getType()
+                .getText(undefined, TypeFormatFlags.UseAliasDefinedOutsideCurrentScope) === "D1Database") {
+                d1_binding = prop.getName();
+                continue;
+            }
+            if (prop.getType().getSymbol()?.getName() === "KVNamespace") {
+                kv_bindings.push(prop.getName());
+                continue;
+            }
+            if (prop.getType().getSymbol()?.getName() === "R2Bucket") {
+                r2_bindings.push(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();
+        }
+        return Either.right({
+            name: classDecl.getName(),
+            source_path: sourceFile.getFilePath().toString(),
+            d1_binding,
+            kv_bindings,
+            r2_bindings,
+            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",
+    };
+    // public for tests
+    static cidlType(type, inject = false) {
+        // Void
+        if (type.isVoid()) {
+            return Either.right("Void");
+        }
+        // Unknown
+        if (type.isUnknown()) {
+            return Either.right("JsonValue");
+        }
+        // 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 === ReadableStream.name) {
+            return Either.right(wrapNullable("Stream", nullable));
+        }
+        if (symbolName === Promise.name ||
+            aliasName === "IncludeTree" ||
+            symbolName === "KValue") {
+            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);
+            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());
+            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];
+            }
+            const stripUndefined = nonNulls.filter((t) => !t.isUndefined());
+            return [stripUndefined[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;
+    /**
+     * Mutates the property declaration to add inferred decorators based on naming conventions.
+     */
+    inferModelDecorator(prop, classDecl, cidlType) {
+        const className = classDecl.getName();
+        const objectName = getObjectName(cidlType);
+        const normalizedPropName = normalizeName(prop.getName());
+        // Primary Key
+        if (normalizedPropName === "id" ||
+            normalizedPropName === `${className.toLowerCase()}id`) {
+            // Add a primary key decorator
+            prop.addDecorator({
+                name: PropertyDecoratorKind.PrimaryKey,
+                arguments: [],
+            });
+            return;
+        }
+        // Foreign Key
+        if (normalizedPropName.endsWith("id")) {
+            const referencedNavName = prop
+                .getName()
+                .slice(0, prop.getName().length - (normalizedPropName.endsWith("_id") ? 3 : 2));
+            const oneToOneProperties = classDecl
+                .getProperties()
+                .filter((p) => p.getName() === referencedNavName);
+            if (oneToOneProperties.length > 1) {
+                console.warn(`
+          Cannot infer ForeignKey relationship due to ambiguity, model ${className}, property ${prop.getName()}
+          could match ${oneToOneProperties.map((p) => p.getName()).join(", ")}
+          `);
+                return;
+            }
+            // If a one to one property exists with the expected name, use that
+            if (oneToOneProperties[0] !== undefined) {
+                const oneToOneProperty = oneToOneProperties[0];
+                const navModelTypeRes = CidlExtractor.cidlType(oneToOneProperty?.getType());
+                if (navModelTypeRes.isLeft()) {
+                    navModelTypeRes.value.context = prop.getName();
+                    navModelTypeRes.value.snippet = prop.getText();
+                    return navModelTypeRes;
+                }
+                const navModelType = navModelTypeRes.unwrap();
+                const objectName = getObjectName(navModelType);
+                if (objectName) {
+                    // Add a foreign key decorator
+                    prop.addDecorator({
+                        name: PropertyDecoratorKind.ForeignKey,
+                        arguments: [objectName],
+                    });
+                    return;
+                }
+            }
+            if (objectName !== undefined) {
+                const oneToManyClassDecl = this.modelDecls.get(objectName)?.[0];
+                const containsOneToManyProp = oneToManyClassDecl
+                    ?.getProperties()
+                    .filter((p) => {
+                    const tyRes = CidlExtractor.cidlType(p.getType());
+                    if (tyRes.isLeft()) {
+                        return false;
+                    }
+                    const ty = tyRes.unwrap();
+                    const navObjectName = getObjectName(ty);
+                    if (navObjectName !== className) {
+                        return false;
+                    }
+                    if (typeof ty === "string" || !("Array" in ty)) {
+                        return false;
+                    }
+                    return true;
+                });
+                if (containsOneToManyProp) {
+                    if (containsOneToManyProp.length > 1) {
+                        console.warn(`
+              Cannot infer ForeignKey relationship due to ambiguity, model ${className}, property ${prop.getName()}
+              could match ${containsOneToManyProp.map((p) => p.getName()).join(", ")}
+              `);
+                        return;
+                    }
+                    // Add a foreign key decorator
+                    prop.addDecorator({
+                        name: PropertyDecoratorKind.ForeignKey,
+                        arguments: [objectName],
+                    });
+                    return;
+                }
+            }
+        }
+        // One to Many + Many to Many
+        if (objectName !== undefined &&
+            typeof cidlType !== "string" &&
+            "Array" in cidlType) {
+            const referencedModelDecl = this.modelDecls.get(objectName)?.[0];
+            const normalizedModelIdName = `${normalizeName(className)}id`;
+            const foreignKeyProps = [];
+            const manyToManyProps = [];
+            for (const prop of referencedModelDecl?.getProperties() ?? []) {
+                const tyRes = CidlExtractor.cidlType(prop.getType());
+                if (tyRes.isLeft()) {
+                    continue;
+                }
+                const ty = tyRes.unwrap();
+                const navObjectName = getObjectName(ty);
+                const normalizedPropName = normalizeName(prop.getName());
+                if (typeof ty !== "string" &&
+                    "Array" in ty &&
+                    navObjectName === className) {
+                    // Many to Many
+                    manyToManyProps.push(prop);
+                }
+                else if (normalizedPropName === normalizedModelIdName) {
+                    // One to Many
+                    foreignKeyProps.push(prop);
+                }
+            }
+            if (foreignKeyProps.length > 1) {
+                console.warn(`
+          Cannot infer OneToMany relationship due to ambiguity, model ${className}, property ${prop.getName()}
+          could match ${foreignKeyProps.map((p) => p.getName()).join(", ")}
+          `);
+                return;
+            }
+            if (manyToManyProps.length > 1) {
+                console.warn(`
+          Cannot infer ManyToMany relationship due to ambiguity, model ${className}, property ${prop.getName()}
+          could match ${manyToManyProps.map((p) => p.getName()).join(", ")}
+          `);
+                return;
+            }
+            const hasForeignKeyProp = foreignKeyProps.at(0);
+            const hasManyToManyProp = manyToManyProps.at(0);
+            if (hasForeignKeyProp && hasManyToManyProp) {
+                console.warn(`
+          Cannot infer relationship due to ambiguity, model ${className}, property ${prop.getName()}
+          could be OneToMany or ManyToMany
+          `);
+                return;
+            }
+            if (hasForeignKeyProp) {
+                // Add a one to many decorator
+                prop.addDecorator({
+                    name: PropertyDecoratorKind.OneToMany,
+                    arguments: [`(m: any) => m.${hasForeignKeyProp.getName()}`],
+                });
+                return;
+            }
+            if (hasManyToManyProp) {
+                // Add a many to many decorator
+                prop.addDecorator({
+                    name: PropertyDecoratorKind.ManyToMany,
+                    arguments: [],
+                });
+                return;
+            }
+        }
+        // One to One
+        if (objectName !== undefined) {
+            const normalizedPropIdName = `${normalizedPropName}id`;
+            const foreignKeyProps = classDecl.getProperties().filter((p) => {
+                const norm = normalizeName(p.getName());
+                return norm === normalizedPropIdName;
+            });
+            if (foreignKeyProps.length > 1) {
+                console.warn(`
+          Cannot infer OneToOne relationship due to ambiguity, model ${className}, property ${prop.getName()}
+          could match ${foreignKeyProps.map((p) => p.getName()).join(", ")}
+          `);
+            }
+            if (foreignKeyProps.at(0) !== undefined) {
+                const foreignKey = foreignKeyProps[0];
+                // Add a one to one decorator
+                prop.addDecorator({
+                    name: PropertyDecoratorKind.OneToOne,
+                    arguments: [`(_m: any) => m.${foreignKey.getName()}`],
+                });
+                return;
+            }
+        }
     }
-    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;
-}
-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 root = getRootType(t);
+    if (typeof root !== "string" && "Object" in root) {
+        return root["Object"];
     }
-  }
+    return undefined;
 }
-function findPropertyByName(cls, name) {
-  const exactMatch = cls.getProperties().find((p) => p.getName() === name);
-  return exactMatch;
+function parseIncludeTree(objLiteral) {
+    const result = {};
+    objLiteral.getProperties().forEach((prop) => {
+        if (prop.isKind(SyntaxKind.PropertyAssignment)) {
+            const name = prop.getName();
+            const init = prop.getInitializer();
+            // Check if it's a nested object literal
+            if (init?.isKind(SyntaxKind.ObjectLiteralExpression)) {
+                result[name] = parseIncludeTree(init); // Recurse
+            }
+            else {
+                result[name] = {}; // Empty object by default
+            }
+        }
+    });
+    return result;
 }
-function hasDecorator(node, name) {
-  return node.getDecorators().some((d) => {
-    const decoratorName = getDecoratorName(d);
-    return decoratorName === name || decoratorName.endsWith("." + name);
-  });
+function checkPropertyModifier(prop) {
+    // Error: properties must be just 'public'
+    if (prop.getScope() != Scope.Public || prop.isReadonly() || prop.isStatic()) {
+        return err(ExtractorErrorCode.InvalidPropertyModifier, (e) => {
+            e.context = prop.getName();
+            e.snippet = prop.getText();
+        });
+    }
+    return Either.right(null);
 }
-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);
+function normalizeName(name) {
+    return name.toLowerCase().replace(/_/g, "");
+}
+export function getSelectorPropertyName(decorator) {
+    const call = decorator.getCallExpression();
+    const selector = call?.getArguments()[0];
+    if (!selector?.isKind(SyntaxKind.ArrowFunction)) {
+        return err(ExtractorErrorCode.InvalidSelectorSyntax);
+    }
+    const body = selector.getBody();
+    if (!body.isKind(SyntaxKind.PropertyAccessExpression)) {
+        return err(ExtractorErrorCode.InvalidSelectorSyntax);
+    }
+    return Either.right(body.getName());
 }