cloesce 0.0.5-unstable.4 → 0.0.5-unstable.5

package/dist/extractor/extract.js

@@ -2,165 +2,203 @@ 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["Model"] = "Model";
     ClassDecoratorKind["WranglerEnv"] = "WranglerEnv";
-    ClassDecoratorKind["PlainOldObject"] = "PlainOldObject";
     ClassDecoratorKind["Service"] = "Service";
-    ClassDecoratorKind["CRUD"] = "CRUD";
 })(ClassDecoratorKind || (ClassDecoratorKind = {}));
 var ParameterDecoratorKind;
 (function (ParameterDecoratorKind) {
     ParameterDecoratorKind["Inject"] = "Inject";
 })(ParameterDecoratorKind || (ParameterDecoratorKind = {}));
 export class CidlExtractor {
-    projectName;
-    version;
-    constructor(projectName, version) {
-        this.projectName = projectName;
-        this.version = version;
+    modelDecls;
+    extractedPoos;
+    constructor(modelDecls, extractedPoos = new Map()) {
+        this.modelDecls = modelDecls;
+        this.extractedPoos = extractedPoos;
     }
-    extract(project) {
-        const models = {};
-        const poos = {};
+    static extract(projectName, project) {
+        const modelDecls = new Map();
+        const serviceDecls = new Map();
         const wranglerEnvs = [];
-        const services = {};
-        let app_source = null;
+        let main_source = null;
+        // TODO: Concurrently across several threads?
         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();
+            // 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();
                 });
-                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;
+                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());
                 }
             }
         }
+        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({
-            version: this.version,
-            project_name: this.projectName,
-            language: "TypeScript",
-            wrangler_env: wranglerEnvs[0],
+            project_name: projectName,
+            wrangler_env: wranglerEnvs[0], // undefined if none
             models,
             poos,
             services,
-            app_source,
+            main_source,
         });
     }
-    static app(sourceFile) {
+    /**
+     * @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) {
-            return err(ExtractorErrorCode.AppMissingDefaultExport);
+        if (!decl || !MorphNode.isFunctionDeclaration(decl)) {
+            return Either.right(undefined);
+        }
+        // Must be named "main"
+        const name = decl.getName();
+        if (name !== "main") {
+            return Either.right(undefined);
         }
-        const getTypeText = () => {
-            let type = undefined;
-            if (MorphNode.isExportAssignment(decl)) {
-                type = decl.getExpression()?.getType();
+        // 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}`;
+            });
+        }
+        // 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;
             }
-            if (MorphNode.isVariableDeclaration(decl)) {
-                type = decl.getInitializer()?.getType();
+            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}`;
+                });
             }
-            return type?.getText(undefined, TypeFormatFlags.UseAliasDefinedOutsideCurrentScope);
-        };
-        const typeText = getTypeText();
-        if (typeText === "CloesceApp") {
-            return Either.right(sourceFile.getFilePath().toString());
         }
-        return err(ExtractorErrorCode.AppMissingDefaultExport);
+        // 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}`;
+            });
+        }
+        return Either.right(sourceFile.getFilePath().toString());
     }
-    static model(classDecl, sourceFile) {
+    model(classDecl, sourceFile, decorator) {
         const name = classDecl.getName();
-        const attributes = [];
+        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 = undefined;
+        let primary_key = null;
         // Extract crud methods
-        const crudDecorator = classDecl
-            .getDecorators()
-            .find((d) => getDecoratorName(d) === ClassDecoratorKind.CRUD);
-        if (crudDecorator) {
-            setCrudKinds(crudDecorator, cruds);
+        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 attribtutes
+        // Iterate properties
         for (const prop of classDecl.getProperties()) {
-            const decorators = prop.getDecorators();
             const typeRes = CidlExtractor.cidlType(prop.getType());
             // Error: invalid property type
             if (typeRes.isLeft()) {
@@ -168,15 +206,45 @@ export class CidlExtractor {
                 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();
+            // 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();
+                    });
                 }
-                const cidl_type = typeRes.unwrap();
-                attributes.push({
+                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(),
@@ -185,26 +253,19 @@ export class CidlExtractor {
                 });
                 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: {
+                case PropertyDecoratorKind.PrimaryKey: {
                     primary_key = {
                         name: prop.getName(),
                         cidl_type,
                     };
                     break;
                 }
-                case AttributeDecoratorKind.ForeignKey: {
-                    attributes.push({
+                case PropertyDecoratorKind.ForeignKey: {
+                    columns.push({
                         foreign_key_reference: getDecoratorArgument(decorator, 0) ?? null,
                         value: {
                             name: prop.getName(),
@@ -213,35 +274,33 @@ export class CidlExtractor {
                     });
                     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) => {
+                case PropertyDecoratorKind.OneToOne: {
+                    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);
+                    const model_name = getObjectName(cidl_type);
                     // Error: navigation properties require a model reference
                     if (!model_name) {
-                        return err(ExtractorErrorCode.MissingNavigationPropertyReference, (e) => {
+                        return err(ExtractorErrorCode.InvalidSelectorSyntax, (e) => {
                             e.snippet = prop.getText();
                             e.context = prop.getName();
                         });
                     }
                     navigation_properties.push({
                         var_name: prop.getName(),
-                        model_name,
-                        kind: { OneToOne: { reference } },
+                        model_reference: model_name,
+                        kind: { OneToOne: { column_reference: selector.unwrap() } },
                     });
                     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) => {
+                case PropertyDecoratorKind.OneToMany: {
+                    const selector = getSelectorPropertyName(decorator);
+                    if (selector.isLeft()) {
+                        return err(ExtractorErrorCode.InvalidSelectorSyntax, (e) => {
                             e.snippet = prop.getText();
                             e.context = prop.getName();
                         });
@@ -249,82 +308,111 @@ export class CidlExtractor {
                     let model_name = getObjectName(cidl_type);
                     // Error: navigation properties require a model reference
                     if (!model_name) {
-                        return err(ExtractorErrorCode.MissingNavigationPropertyReference, (e) => {
+                        return err(ExtractorErrorCode.InvalidNavigationProperty, (e) => {
                             e.snippet = prop.getText();
                             e.context = prop.getName();
                         });
                     }
                     navigation_properties.push({
                         var_name: prop.getName(),
-                        model_name,
-                        kind: { OneToMany: { reference } },
+                        model_reference: model_name,
+                        kind: { OneToMany: { column_reference: selector.unwrap() } },
                     });
                     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();
-                        });
+                case PropertyDecoratorKind.ManyToMany: {
                     // Error: navigation properties require a model reference
                     let model_name = getObjectName(cidl_type);
                     if (!model_name) {
-                        return err(ExtractorErrorCode.MissingNavigationPropertyReference, (e) => {
+                        return err(ExtractorErrorCode.InvalidNavigationProperty, (e) => {
                             e.snippet = prop.getText();
                             e.context = prop.getName();
                         });
                     }
                     navigation_properties.push({
                         var_name: prop.getName(),
-                        model_name,
-                        kind: { ManyToMany: { unique_id } },
+                        model_reference: model_name,
+                        kind: "ManyToMany",
                     });
                     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) => {
+                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();
                         });
                     }
-                    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;
+                    // 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();
+                        });
                     }
-                    data_sources[prop.getName()] = {
-                        name: prop.getName(),
-                        tree: treeRes.unwrap(),
-                    };
+                    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;
                 }
             }
         }
-        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))
+                .map(getDecoratorName)
                 .find((name) => Object.values(HttpVerb).includes(name));
             if (!httpVerb) {
                 continue;
             }
-            const result = CidlExtractor.modelMethod(name, m, httpVerb);
+            const result = this.method(m, httpVerb);
             if (result.isLeft()) {
                 result.value.addContext((prev) => `${m.getName()} ${prev}`);
                 return result;
@@ -333,84 +421,22 @@ export class CidlExtractor {
         }
         return Either.right({
             name,
-            attributes,
+            columns,
             primary_key,
             navigation_properties,
+            key_params,
+            kv_objects,
+            r2_objects,
             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);
-                // 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 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) {
+    service(classDecl, sourceFile) {
         const attributes = [];
         const methods = {};
-        // Attributes
+        // Properties
         for (const prop of classDecl.getProperties()) {
             const typeRes = CidlExtractor.cidlType(prop.getType(), true);
             // Error: invalid property type
@@ -420,30 +446,31 @@ export class CidlExtractor {
                 return typeRes;
             }
             if (typeof typeRes.value === "string" || !("Inject" in typeRes.value)) {
-                return err(ExtractorErrorCode.InvalidServiceAttribute, (e) => {
+                return err(ExtractorErrorCode.InvalidServiceProperty, (e) => {
                     e.context = prop.getName();
                     e.snippet = prop.getText();
                 });
             }
-            const checkModifierRes = checkAttributeModifier(prop);
+            // Error: invalid property modifier
+            const checkModifierRes = checkPropertyModifier(prop);
             if (checkModifierRes.isLeft()) {
                 return checkModifierRes;
             }
             attributes.push({
                 var_name: prop.getName(),
-                injected: typeRes.value.Inject,
+                inject_reference: typeRes.value.Inject,
             });
         }
         // Methods
         for (const m of classDecl.getMethods()) {
             const httpVerb = m
                 .getDecorators()
-                .map((d) => getDecoratorName(d))
+                .map(getDecoratorName)
                 .find((name) => Object.values(HttpVerb).includes(name));
             if (!httpVerb) {
                 continue;
             }
-            const res = CidlExtractor.serviceMethod(m, httpVerb);
+            const res = this.method(m, httpVerb);
             if (res.isLeft()) {
                 return res;
             }
@@ -457,7 +484,7 @@ export class CidlExtractor {
             source_path: sourceFile.getFilePath().toString(),
         });
     }
-    static serviceMethod(method, verb) {
+    method(method, verb) {
         // Error: invalid method scope, must be public
         if (method.getScope() != Scope.Public) {
             return err(ExtractorErrorCode.InvalidApiMethodModifier, (e) => {
@@ -490,6 +517,17 @@ export class CidlExtractor {
                 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(),
@@ -501,6 +539,17 @@ export class CidlExtractor {
             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;
+            }
+        }
         return Either.right({
             name: method.getName(),
             http_verb: verb,
@@ -511,10 +560,22 @@ export class CidlExtractor {
             parameters,
         });
     }
-    static poo(classDecl, sourceFile) {
+    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()) {
@@ -522,32 +583,59 @@ export class CidlExtractor {
                 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();
+            // 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;
         }
-        return Either.right({
+        // Mark as extracted
+        const poo = {
             name,
             attributes,
             source_path: sourceFile.getFilePath().toString(),
-        });
+        };
+        this.extractedPoos.set(name, poo);
+        return Either.right(null);
     }
+    // public for tests
     static env(classDecl, sourceFile) {
         const vars = {};
-        let binding;
+        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") {
-                binding = prop.getName();
+                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());
@@ -558,13 +646,12 @@ export class CidlExtractor {
             }
             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,
+            d1_binding,
+            kv_bindings,
+            r2_bindings,
             vars,
         });
     }
@@ -578,13 +665,17 @@ export class CidlExtractor {
         Boolean: "Boolean",
         Date: "DateIso",
         Uint8Array: "Blob",
-        Stream: "Stream",
     };
+    // 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" });
@@ -641,8 +732,12 @@ export class CidlExtractor {
                     .trim(),
             }, nullable));
         }
-        if (symbolName === "Promise" || aliasName === "IncludeTree") {
-            // Unwrap promises
+        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()) {
@@ -665,81 +760,201 @@ export class CidlExtractor {
         }
         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 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];
             }
-            return [nonNulls[0] ?? ty, hasNullable];
+            const stripUndefined = nonNulls.filter((t) => !t.isUndefined());
+            return [stripUndefined[0] ?? ty, hasNullable];
         }
     }
-    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();
-                });
+    /**
+     * 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;
             }
-            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;
+            // 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;
+                }
             }
-            // 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();
+            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;
                 });
-            }
-            // 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;
+                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;
                     }
-                    nestedTree = treeRes.unwrap();
+                    // Add a foreign key decorator
+                    prop.addDecorator({
+                        name: PropertyDecoratorKind.ForeignKey,
+                        arguments: [objectName],
+                    });
+                    return;
                 }
             }
-            result[navProp.getName()] = nestedTree;
         }
-        return Either.right(result);
+        // 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;
+            }
+        }
     }
 }
 function err(code, fn) {
@@ -785,36 +1000,45 @@ function getObjectName(t) {
     }
     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()));
+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
+            }
         }
-    }
-}
-function findPropertyByName(cls, name) {
-    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 result;
 }
-function checkAttributeModifier(prop) {
-    // Error: attributes must be just 'public'
+function checkPropertyModifier(prop) {
+    // Error: properties must be just 'public'
     if (prop.getScope() != Scope.Public || prop.isReadonly() || prop.isStatic()) {
-        return err(ExtractorErrorCode.InvalidAttributeModifier, (e) => {
+        return err(ExtractorErrorCode.InvalidPropertyModifier, (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());
+}