cloesce 0.0.3 → 0.0.4-unstable.0

package/dist/common.js

@@ -6,31 +6,61 @@ export function right(value) {
 }
 export var ExtractorErrorCode;
 (function (ExtractorErrorCode) {
-    ExtractorErrorCode[ExtractorErrorCode["UnknownType"] = 0] = "UnknownType";
-    ExtractorErrorCode[ExtractorErrorCode["MultipleGenericType"] = 1] = "MultipleGenericType";
-    ExtractorErrorCode[ExtractorErrorCode["InvalidIncludeTree"] = 2] = "InvalidIncludeTree";
-    ExtractorErrorCode[ExtractorErrorCode["UnknownNavigationPropertyReference"] = 3] = "UnknownNavigationPropertyReference";
-    ExtractorErrorCode[ExtractorErrorCode["InvalidNavigationPropertyReference"] = 4] = "InvalidNavigationPropertyReference";
-    ExtractorErrorCode[ExtractorErrorCode["MissingNavigationPropertyReference"] = 5] = "MissingNavigationPropertyReference";
-    ExtractorErrorCode[ExtractorErrorCode["MissingManyToManyUniqueId"] = 6] = "MissingManyToManyUniqueId";
-    ExtractorErrorCode[ExtractorErrorCode["MissingPrimaryKey"] = 7] = "MissingPrimaryKey";
-    ExtractorErrorCode[ExtractorErrorCode["MissingWranglerEnv"] = 8] = "MissingWranglerEnv";
-    ExtractorErrorCode[ExtractorErrorCode["TooManyWranglerEnvs"] = 9] = "TooManyWranglerEnvs";
-    ExtractorErrorCode[ExtractorErrorCode["MissingFile"] = 10] = "MissingFile";
+    ExtractorErrorCode[ExtractorErrorCode["MissingExport"] = 0] = "MissingExport";
+    ExtractorErrorCode[ExtractorErrorCode["AppMissingDefaultExport"] = 1] = "AppMissingDefaultExport";
+    ExtractorErrorCode[ExtractorErrorCode["UnknownType"] = 2] = "UnknownType";
+    ExtractorErrorCode[ExtractorErrorCode["MultipleGenericType"] = 3] = "MultipleGenericType";
+    ExtractorErrorCode[ExtractorErrorCode["DataSourceMissingStatic"] = 4] = "DataSourceMissingStatic";
+    ExtractorErrorCode[ExtractorErrorCode["InvalidPartialType"] = 5] = "InvalidPartialType";
+    ExtractorErrorCode[ExtractorErrorCode["InvalidIncludeTree"] = 6] = "InvalidIncludeTree";
+    ExtractorErrorCode[ExtractorErrorCode["InvalidAttributeModifier"] = 7] = "InvalidAttributeModifier";
+    ExtractorErrorCode[ExtractorErrorCode["InvalidApiMethodModifier"] = 8] = "InvalidApiMethodModifier";
+    ExtractorErrorCode[ExtractorErrorCode["UnknownNavigationPropertyReference"] = 9] = "UnknownNavigationPropertyReference";
+    ExtractorErrorCode[ExtractorErrorCode["InvalidNavigationPropertyReference"] = 10] = "InvalidNavigationPropertyReference";
+    ExtractorErrorCode[ExtractorErrorCode["MissingNavigationPropertyReference"] = 11] = "MissingNavigationPropertyReference";
+    ExtractorErrorCode[ExtractorErrorCode["MissingManyToManyUniqueId"] = 12] = "MissingManyToManyUniqueId";
+    ExtractorErrorCode[ExtractorErrorCode["MissingPrimaryKey"] = 13] = "MissingPrimaryKey";
+    ExtractorErrorCode[ExtractorErrorCode["MissingWranglerEnv"] = 14] = "MissingWranglerEnv";
+    ExtractorErrorCode[ExtractorErrorCode["TooManyWranglerEnvs"] = 15] = "TooManyWranglerEnvs";
+    ExtractorErrorCode[ExtractorErrorCode["MissingFile"] = 16] = "MissingFile";
 })(ExtractorErrorCode || (ExtractorErrorCode = {}));
 const errorInfoMap = {
+    [ExtractorErrorCode.MissingExport]: {
+        description: "All Cloesce types must be exported.",
+        suggestion: "Add `export` to the class definition.",
+    },
+    [ExtractorErrorCode.AppMissingDefaultExport]: {
+        description: "app.cloesce.ts does not export a CloesceApp by default",
+        suggestion: "Export an instantiated CloesceApp in app.cloesce.ts",
+    },
     [ExtractorErrorCode.UnknownType]: {
         description: "Encountered an unknown or unsupported type",
         suggestion: "Refer to the documentation on valid Cloesce TS types",
     },
+    [ExtractorErrorCode.InvalidPartialType]: {
+        description: "Partial types must only contain a model or plain old object",
+        suggestion: "Refer to the documentation on valid Cloesce TS types",
+    },
     [ExtractorErrorCode.MultipleGenericType]: {
         description: "Cloesce does not yet support types with multiple generics",
         suggestion: "Simplify your type to use only a single generic parameter, ie Foo<T>",
     },
+    [ExtractorErrorCode.DataSourceMissingStatic]: {
+        description: "Data Sources must be declared as static",
+        suggestion: "Declare your data source as `static readonly`",
+    },
     [ExtractorErrorCode.InvalidIncludeTree]: {
         description: "Invalid Include Tree",
         suggestion: "Include trees must only contain references to a model's navigation properties.",
     },
+    [ExtractorErrorCode.InvalidAttributeModifier]: {
+        description: "Attributes can only be public on a Model, Plain Old Object or Wrangler Environment",
+        suggestion: "Change the attribute modifier to just `public`",
+    },
+    [ExtractorErrorCode.InvalidApiMethodModifier]: {
+        description: "Model methods must be public if they are decorated as GET, POST, PUT, PATCH",
+        suggestion: "Change the method modifier to just `public`",
+    },
     [ExtractorErrorCode.UnknownNavigationPropertyReference]: {
         description: "Unknown Navigation Property Reference",
         suggestion: "Verify that the navigation property reference model exists, or create a model.",
@@ -78,6 +108,36 @@ export class ExtractorError {
         this.context = fn(this.context ?? "");
     }
 }
+/**
+ * A container for middleware. If an instance is exported from `app.cloesce.ts`, it will be used in the
+ * appropriate location, with global middleware happening before any routing occurs.
+ */
+export class CloesceApp {
+    global = [];
+    model = new Map();
+    method = new Map();
+    useGlobal(m) {
+        this.global.push(m);
+    }
+    useModel(ctor, m) {
+        if (this.model.has(ctor.name)) {
+            this.model.get(ctor.name).push(m);
+        }
+        else {
+            this.model.set(ctor.name, [m]);
+        }
+    }
+    useMethod(ctor, method, m) {
+        if (!this.method.has(ctor.name)) {
+            this.method.set(ctor.name, new Map());
+        }
+        const methods = this.method.get(ctor.name);
+        if (!methods.has(method)) {
+            methods.set(method, []);
+        }
+        methods.get(method).push(m);
+    }
+}
 export function isNullableType(ty) {
     return typeof ty === "object" && ty !== null && "Nullable" in ty;
 }
@@ -94,3 +154,4 @@ export function getNavigationPropertyCidlType(nav) {
         ? { Object: nav.model_name }
         : { Array: { Object: nav.model_name } };
 }
+export const NO_DATA_SOURCE = "none";

package/dist/{extract.d.ts → extractor/extract.d.ts}

@@ -1,14 +1,17 @@
 import { Project } from "ts-morph";
-import { CloesceAst, Either } from "./common.js";
+import { CloesceAst, Either, ExtractorError } from "../common.js";
 export declare class CidlExtractor {
     projectName: string;
     version: string;
     constructor(projectName: string, version: string);
-    extract(project: Project): Either<string, CloesceAst>;
+    extract(project: Project): Either<ExtractorError, CloesceAst>;
+    private static app;
     private static model;
+    private static poo;
     private static readonly primTypeMap;
     private static cidlType;
     private static includeTree;
     private static method;
+    private static crudMethod;
 }
 //# sourceMappingURL=extract.d.ts.map

package/dist/extractor/extract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract.d.ts","sourceRoot":"","sources":["../../src/extractor/extract.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,OAAO,EAUR,MAAM,UAAU,CAAC;AAElB,OAAO,EAEL,UAAU,EAGV,MAAM,EAUN,cAAc,EAKf,MAAM,cAAc,CAAC;AAuBtB,qBAAa,aAAa;IAEf,WAAW,EAAE,MAAM;IACnB,OAAO,EAAE,MAAM;gBADf,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM;IAGxB,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC,cAAc,EAAE,UAAU,CAAC;IA8F7D,OAAO,CAAC,MAAM,CAAC,GAAG;IA0BlB,OAAO,CAAC,MAAM,CAAC,KAAK;IAgQpB,OAAO,CAAC,MAAM,CAAC,GAAG;IAsClB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAOjC;IAEF,OAAO,CAAC,MAAM,CAAC,QAAQ;IAkJvB,OAAO,CAAC,MAAM,CAAC,WAAW;IAqF1B,OAAO,CAAC,MAAM,CAAC,MAAM;IAiFrB,OAAO,CAAC,MAAM,CAAC,UAAU;CAsD1B"}

package/dist/{extract.js → extractor/extract.js}

@@ -1,5 +1,5 @@
-import { SyntaxKind, } from "ts-morph";
-import { HttpVerb, left, right, ExtractorError, ExtractorErrorCode, } from "./common.js";
+import { Node as MorphNode, SyntaxKind, Scope, } from "ts-morph";
+import { HttpVerb, left, right, ExtractorError, ExtractorErrorCode, CloesceApp, } from "../common.js";
 import { TypeFormatFlags } from "typescript";
 var AttributeDecoratorKind;
 (function (AttributeDecoratorKind) {
@@ -15,6 +15,7 @@ var ClassDecoratorKind;
     ClassDecoratorKind["D1"] = "D1";
     ClassDecoratorKind["WranglerEnv"] = "WranglerEnv";
     ClassDecoratorKind["PlainOldObject"] = "PlainOldObject";
+    ClassDecoratorKind["CRUD"] = "CRUD";
 })(ClassDecoratorKind || (ClassDecoratorKind = {}));
 var ParameterDecoratorKind;
 (function (ParameterDecoratorKind) {
@@ -30,43 +31,64 @@ export class CidlExtractor {
     extract(project) {
         const models = {};
         const poos = {};
+        const wranglerEnvs = [];
+        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.ok) {
+                    return app;
+                }
+                app_source = app.value;
+            }
             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.ok) {
-                        result.value.addContext((old) => `${classDecl.getName()}.${old}`);
+                        result.value.addContext((prev) => `${classDecl.getName()}.${prev}`);
                         return result;
                     }
                     models[result.value.name] = result.value;
                     continue;
                 }
                 if (hasDecorator(classDecl, ClassDecoratorKind.PlainOldObject)) {
+                    if (!classDecl.isExported())
+                        return notExportedErr;
                     const result = CidlExtractor.poo(classDecl, sourceFile);
                     // Error: propogate from models
                     if (!result.ok) {
-                        result.value.addContext((old) => `${classDecl.getName()}.${old}`);
+                        result.value.addContext((prev) => `${classDecl.getName()}.${prev}`);
                         return result;
                     }
                     poos[result.value.name] = result.value;
                     continue;
                 }
+                if (hasDecorator(classDecl, ClassDecoratorKind.WranglerEnv)) {
+                    if (!classDecl.isExported())
+                        return notExportedErr;
+                    // Error: invalid attribute modifier
+                    for (const prop of classDecl.getProperties()) {
+                        const modifierRes = checkAttributeModifier(prop);
+                        if (modifierRes) {
+                            return modifierRes;
+                        }
+                    }
+                    wranglerEnvs.push({
+                        name: classDecl.getName(),
+                        source_path: sourceFile.getFilePath().toString(),
+                    });
+                }
             }
         }
-        const wranglerEnvs = project
-            .getSourceFiles()
-            .flatMap((sourceFile) => {
-            return sourceFile
-                .getClasses()
-                .filter((classDecl) => hasDecorator(classDecl, ClassDecoratorKind.WranglerEnv))
-                .map((classDecl) => {
-                return {
-                    name: classDecl.getName(),
-                    source_path: sourceFile.getFilePath().toString(),
-                };
-            });
-        });
         // Error: A wrangler environment is required
         if (wranglerEnvs.length < 1) {
             return err(ExtractorErrorCode.MissingWranglerEnv);
@@ -82,15 +104,46 @@ export class CidlExtractor {
             wrangler_env: wranglerEnvs[0],
             models,
             poos,
+            app_source,
         });
     }
+    static app(sourceFile) {
+        const symbol = sourceFile.getDefaultExportSymbol();
+        const decl = symbol?.getDeclarations()[0];
+        if (!decl) {
+            return err(ExtractorErrorCode.AppMissingDefaultExport);
+        }
+        const getTypeText = () => {
+            if (MorphNode.isExportAssignment(decl)) {
+                return decl.getExpression()?.getType().getText();
+            }
+            if (MorphNode.isVariableDeclaration(decl)) {
+                return decl.getInitializer()?.getType().getText();
+            }
+            return undefined;
+        };
+        const typeText = getTypeText();
+        if (typeText === CloesceApp.name) {
+            return right(sourceFile.getFilePath().toString());
+        }
+        return err(ExtractorErrorCode.AppMissingDefaultExport);
+    }
     static model(classDecl, sourceFile) {
         const name = classDecl.getName();
         const attributes = [];
         const navigationProperties = [];
         const dataSources = {};
         const methods = {};
+        let cruds = [];
         let primary_key = undefined;
+        // Extract crud methods
+        const crudDecorator = classDecl
+            .getDecorators()
+            .find((d) => getDecoratorName(d) === ClassDecoratorKind.CRUD);
+        if (crudDecorator) {
+            cruds = getCrudKinds(crudDecorator);
+        }
+        // Iterate attribtutes
         for (const prop of classDecl.getProperties()) {
             const decorators = prop.getDecorators();
             const typeRes = CidlExtractor.cidlType(prop.getType());
@@ -100,8 +153,13 @@ 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 !== undefined) {
+                    return checkModifierRes;
+                }
                 const cidl_type = typeRes.value;
                 attributes.push({
                     foreign_key_reference: null,
@@ -115,6 +173,11 @@ export class CidlExtractor {
             // TODO: Limiting to one decorator. Can't get too fancy on us.
             const decorator = decorators[0];
             const name = getDecoratorName(decorator);
+            // Error: invalid attribute modifier
+            if (checkModifierRes !== undefined &&
+                name !== AttributeDecoratorKind.DataSource) {
+                return checkModifierRes;
+            }
             // Process decorators
             const cidl_type = typeRes.value;
             switch (name) {
@@ -207,10 +270,17 @@ export class CidlExtractor {
                     break;
                 }
                 case AttributeDecoratorKind.DataSource: {
+                    // Error: data sources must be static
+                    if (!prop.isStatic()) {
+                        return err(ExtractorErrorCode.DataSourceMissingStatic, (e) => {
+                            e.snippet = prop.getText();
+                            e.context = prop.getName();
+                        });
+                    }
                     const initializer = prop.getInitializer();
                     const treeRes = CidlExtractor.includeTree(initializer, classDecl, sourceFile);
                     if (!treeRes.ok) {
-                        treeRes.value.addContext((old) => `${prop.getName()} ${old}`);
+                        treeRes.value.addContext((prev) => `${prop.getName()} ${prev}`);
                         treeRes.value.snippet = prop.getText();
                         return treeRes;
                     }
@@ -229,13 +299,26 @@ export class CidlExtractor {
         }
         // Process methods
         for (const m of classDecl.getMethods()) {
-            const result = CidlExtractor.method(m);
+            const httpVerb = m
+                .getDecorators()
+                .map((d) => getDecoratorName(d))
+                .find((name) => Object.values(HttpVerb).includes(name));
+            if (!httpVerb) {
+                continue;
+            }
+            const result = CidlExtractor.method(name, m, httpVerb);
             if (!result.ok) {
-                result.value.addContext((old) => `${m.getName()} ${old}`);
+                result.value.addContext((prev) => `${m.getName()} ${prev}`);
                 return left(result.value);
             }
             methods[result.value.name] = result.value;
         }
+        // Add CRUD methods
+        for (const crud of cruds) {
+            // TODO: This overwrites any exisiting impl-- is that what we want?
+            const crudMethod = CidlExtractor.crudMethod(crud, primary_key, name);
+            methods[crudMethod.name] = crudMethod;
+        }
         return right({
             name,
             attributes,
@@ -257,6 +340,11 @@ export class CidlExtractor {
                 typeRes.value.snippet = prop.getText();
                 return typeRes;
             }
+            // Error: invalid attribute modifier
+            const modifierRes = checkAttributeModifier(prop);
+            if (modifierRes) {
+                return modifierRes;
+            }
             const cidl_type = typeRes.value;
             attributes.push({
                 name: prop.getName(),
@@ -277,7 +365,6 @@ export class CidlExtractor {
         String: "Text",
         boolean: "Integer",
         Boolean: "Integer",
-        Date: "Text",
     };
     static cidlType(type, inject = false) {
         // Void
@@ -316,6 +403,30 @@ export class CidlExtractor {
         const genericTy = generics[0];
         const symbolName = unwrappedType.getSymbol()?.getName();
         const aliasName = unwrappedType.getAliasSymbol()?.getName();
+        if (aliasName === "DataSourceOf") {
+            return 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 right(wrapNullable({
+                Partial: genericTy
+                    .getText(undefined, TypeFormatFlags.UseAliasDefinedOutsideCurrentScope)
+                    .split("|")[0]
+                    .trim(),
+            }, nullable));
+        }
         if (symbolName === "Promise" || aliasName === "IncludeTree") {
             return wrapGeneric(genericTy, nullable, (inner) => inner);
         }
@@ -413,10 +524,15 @@ export class CidlExtractor {
         }
         return right(result);
     }
-    static method(method) {
-        const decorators = method.getDecorators();
-        const decoratorNames = decorators.map((d) => getDecoratorName(d));
-        const httpVerb = decoratorNames.find((name) => Object.values(HttpVerb).includes(name));
+    static method(modelName, method, httpVerb) {
+        // 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
@@ -442,6 +558,10 @@ export class CidlExtractor {
                 typeRes.value.context = param.getName();
                 return typeRes;
             }
+            const rootType = getRootType(typeRes.value);
+            if (typeof rootType !== "string" && "DataSource" in rootType) {
+                needsDataSource = false;
+            }
             parameters.push({
                 name: param.getName(),
                 cidl_type: typeRes.value,
@@ -453,6 +573,13 @@ export class CidlExtractor {
             typeRes.value.snippet = method.getText();
             return typeRes;
         }
+        // Sugaring: add data source
+        if (needsDataSource) {
+            parameters.push({
+                name: "__dataSource",
+                cidl_type: { DataSource: modelName },
+            });
+        }
         return right({
             name: method.getName(),
             is_static: method.isStatic(),
@@ -461,6 +588,56 @@ export class CidlExtractor {
             parameters,
         });
     }
+    static crudMethod(crud, primaryKey, modelName) {
+        // TODO: Should this impementation be in some JSON project file s.t. other
+        // langs can use it?
+        return {
+            POST: {
+                name: "post",
+                is_static: true,
+                http_verb: HttpVerb.POST,
+                return_type: { HttpResult: { Object: modelName } },
+                parameters: [
+                    {
+                        name: "obj",
+                        cidl_type: { Partial: modelName },
+                    },
+                    {
+                        name: "dataSource",
+                        cidl_type: { DataSource: modelName },
+                    },
+                ],
+            },
+            GET: {
+                name: "get",
+                is_static: true,
+                http_verb: HttpVerb.GET,
+                return_type: { HttpResult: { Object: modelName } },
+                parameters: [
+                    {
+                        name: "id",
+                        cidl_type: primaryKey.cidl_type,
+                    },
+                    {
+                        name: "dataSource",
+                        cidl_type: { DataSource: modelName },
+                    },
+                ],
+            },
+            LIST: {
+                name: "list",
+                is_static: true,
+                http_verb: HttpVerb.GET,
+                return_type: { HttpResult: { Array: { Object: modelName } } },
+                parameters: [
+                    {
+                        name: "dataSource",
+                        cidl_type: { DataSource: modelName },
+                    },
+                ],
+            },
+        }[crud];
+    }
 }
 function err(code, fn) {
     let e = new ExtractorError(code);
@@ -478,33 +655,46 @@ function getDecoratorArgument(decorator, index) {
     if (!args[index])
         return undefined;
     const arg = args[index];
-    // Identifier
     if (arg.getKind?.() === SyntaxKind.Identifier) {
         return arg.getText();
     }
-    // String literal
-    const text = arg.getText?.();
-    if (!text)
-        return undefined;
-    const match = text.match(/^['"](.*)['"]$/);
-    return match ? match[1] : text;
+    return arg.getLiteralValue();
 }
-function getObjectName(t) {
-    if (typeof t === "string")
-        return undefined;
-    if ("Object" in t) {
-        return t.Object;
+function getRootType(t) {
+    if (typeof t === "string") {
+        return t;
     }
-    else if ("Array" in t) {
-        return getObjectName(t.Array);
+    if ("Nullable" in t) {
+        return getRootType(t.Nullable);
     }
-    else if ("HttpResult" in t) {
-        if (t == null)
-            return undefined;
-        return getObjectName(t.HttpResult);
+    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 getCrudKinds(d) {
+    const arg = d.getArguments()[0];
+    if (!arg)
+        return [];
+    if (MorphNode.isArrayLiteralExpression(arg)) {
+        return arg
+            .getElements()
+            .map((e) => (MorphNode.isStringLiteral(e)
+            ? e.getLiteralValue()
+            : e.getText()));
+    }
+    return [];
+}
 function findPropertyByName(cls, name) {
     const exactMatch = cls.getProperties().find((p) => p.getName() === name);
     return exactMatch;
@@ -515,3 +705,12 @@ function hasDecorator(node, name) {
         return decoratorName === name || decoratorName.endsWith("." + name);
     });
 }
+function checkAttributeModifier(prop) {
+    // Error: attributes must be just 'public'
+    if (prop.getScope() != Scope.Public || prop.isReadonly() || prop.isStatic()) {
+        return err(ExtractorErrorCode.InvalidAttributeModifier, (e) => {
+            e.context = prop.getName();
+            e.snippet = prop.getText();
+        });
+    }
+}

package/dist/router/crud.d.ts

@@ -0,0 +1,22 @@
+import { D1Database } from "@cloudflare/workers-types/experimental";
+import { HttpResult } from "../common.js";
+/**
+ * A wrapper for Model Instances, containing definitions for built-in CRUD methods.
+ */
+export declare class CrudContext {
+    private d1;
+    private instance;
+    private ctor;
+    private constructor();
+    static fromInstance(d1: D1Database, instance: any, ctor: new () => object): CrudContext;
+    static fromCtor(d1: D1Database, ctor: new () => object): CrudContext;
+    /**
+     * Invokes a method on the instance, intercepting built-in CRUD methods and injecting
+     * a default definition.
+     */
+    interceptCrud(methodName: string): Function;
+    upsert(obj: object, dataSource: string): Promise<HttpResult<unknown>>;
+    get(id: any, dataSource: string): Promise<HttpResult<unknown>>;
+    list(dataSource: string): Promise<HttpResult<unknown>>;
+}
+//# sourceMappingURL=crud.d.ts.map

package/dist/router/crud.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crud.d.ts","sourceRoot":"","sources":["../../src/router/crud.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,wCAAwC,CAAC;AACpE,OAAO,EAAE,UAAU,EAAkB,MAAM,cAAc,CAAC;AAG1D;;GAEG;AACH,qBAAa,WAAW;IAEpB,OAAO,CAAC,EAAE;IACV,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,IAAI;IAHd,OAAO;IAMP,MAAM,CAAC,YAAY,CACjB,EAAE,EAAE,UAAU,EACd,QAAQ,EAAE,GAAG,EACb,IAAI,EAAE,UAAU,MAAM,GACrB,WAAW;IAId,MAAM,CAAC,QAAQ,CAAC,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,MAAM,GAAG,WAAW;IAIpE;;;OAGG;IACH,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,QAAQ;IAWrC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IAkBrE,GAAG,CAAC,EAAE,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IAS9D,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;CAQ7D"}

package/dist/router/crud.js

@@ -0,0 +1,65 @@
+import { NO_DATA_SOURCE } from "../common.js";
+import { Orm } from "../ui/backend.js";
+/**
+ * A wrapper for Model Instances, containing definitions for built-in CRUD methods.
+ */
+export class CrudContext {
+    d1;
+    instance;
+    ctor;
+    constructor(d1, instance, ctor) {
+        this.d1 = d1;
+        this.instance = instance;
+        this.ctor = ctor;
+    }
+    static fromInstance(d1, instance, ctor) {
+        return new this(d1, instance, ctor);
+    }
+    static fromCtor(d1, ctor) {
+        return new this(d1, ctor, ctor);
+    }
+    /**
+     * Invokes a method on the instance, intercepting built-in CRUD methods and injecting
+     * a default definition.
+     */
+    interceptCrud(methodName) {
+        const map = {
+            post: this.upsert.bind(this),
+            get: this.get.bind(this),
+            list: this.list.bind(this),
+        };
+        const fn = this.instance && this.instance[methodName];
+        return fn ? fn.bind(this.instance) : map[methodName];
+    }
+    async upsert(obj, dataSource) {
+        const normalizedDs = dataSource === NO_DATA_SOURCE ? null : dataSource;
+        const includeTree = normalizedDs ? this.ctor[normalizedDs] : null;
+        // Upsert
+        const orm = Orm.fromD1(this.d1);
+        const upsert = await orm.upsert(this.ctor, obj, includeTree);
+        if (!upsert.ok) {
+            return { ok: false, status: 500, data: upsert.value }; // TODO: better status code?
+        }
+        // Get
+        const get = await orm.get(this.ctor, upsert.value, normalizedDs);
+        return get.ok
+            ? { ok: true, status: 200, data: get.value }
+            : { ok: false, status: 500, data: get.value };
+    }
+    async get(id, dataSource) {
+        const normalizedDs = dataSource === NO_DATA_SOURCE ? null : dataSource;
+        const orm = Orm.fromD1(this.d1);
+        const res = await orm.get(this.ctor, id, normalizedDs);
+        return res.ok
+            ? { ok: true, status: 200, data: res.value }
+            : { ok: false, status: 500, data: res.value };
+    }
+    async list(dataSource) {
+        const normalizedDs = dataSource === NO_DATA_SOURCE ? null : dataSource;
+        const orm = Orm.fromD1(this.d1);
+        const res = await orm.list(this.ctor, normalizedDs);
+        return res.ok
+            ? { ok: true, status: 200, data: res.value }
+            : { ok: false, status: 500, data: res.value };
+    }
+}