cloesce 0.0.4-unstable.1 → 0.0.4-unstable.10

package/dist/extractor/extract.js

@@ -1,5 +1,5 @@
 import { Node as MorphNode, SyntaxKind, Scope, } from "ts-morph";
-import { HttpVerb, left, right, ExtractorError, ExtractorErrorCode, CloesceApp, } from "../common.js";
+import { Either, HttpVerb, ExtractorError, ExtractorErrorCode, } from "../common.js";
 import { TypeFormatFlags } from "typescript";
 var AttributeDecoratorKind;
 (function (AttributeDecoratorKind) {
@@ -38,10 +38,10 @@ export class CidlExtractor {
                 sourceFile.getBaseName() === "seed__app.cloesce.ts" // hardcoding for tests
             ) {
                 const app = CidlExtractor.app(sourceFile);
-                if (!app.ok) {
+                if (app.isLeft()) {
                     return app;
                 }
-                app_source = app.value;
+                app_source = app.unwrap();
             }
             for (const classDecl of sourceFile.getClasses()) {
                 const notExportedErr = err(ExtractorErrorCode.MissingExport, (e) => {
@@ -53,11 +53,11 @@ export class CidlExtractor {
                         return notExportedErr;
                     const result = CidlExtractor.model(classDecl, sourceFile);
                     // Error: propogate from models
-                    if (!result.ok) {
+                    if (result.isLeft()) {
                         result.value.addContext((prev) => `${classDecl.getName()}.${prev}`);
                         return result;
                     }
-                    models[result.value.name] = result.value;
+                    models[result.unwrap().name] = result.unwrap();
                     continue;
                 }
                 if (hasDecorator(classDecl, ClassDecoratorKind.PlainOldObject)) {
@@ -65,16 +65,14 @@ export class CidlExtractor {
                         return notExportedErr;
                     const result = CidlExtractor.poo(classDecl, sourceFile);
                     // Error: propogate from models
-                    if (!result.ok) {
+                    if (result.isLeft()) {
                         result.value.addContext((prev) => `${classDecl.getName()}.${prev}`);
                         return result;
                     }
-                    poos[result.value.name] = result.value;
+                    poos[result.unwrap().name] = result.unwrap();
                     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);
@@ -82,10 +80,11 @@ export class CidlExtractor {
                             return modifierRes;
                         }
                     }
-                    wranglerEnvs.push({
-                        name: classDecl.getName(),
-                        source_path: sourceFile.getFilePath().toString(),
-                    });
+                    const result = CidlExtractor.env(classDecl, sourceFile);
+                    if (result.isLeft()) {
+                        return result;
+                    }
+                    wranglerEnvs.push(result.unwrap());
                 }
             }
         }
@@ -97,7 +96,7 @@ export class CidlExtractor {
         if (wranglerEnvs.length > 1) {
             return err(ExtractorErrorCode.TooManyWranglerEnvs, (e) => (e.context = wranglerEnvs.map((w) => w.name).toString()));
         }
-        return right({
+        return Either.right({
             version: this.version,
             project_name: this.projectName,
             language: "TypeScript",
@@ -114,41 +113,42 @@ export class CidlExtractor {
             return err(ExtractorErrorCode.AppMissingDefaultExport);
         }
         const getTypeText = () => {
+            let type = undefined;
             if (MorphNode.isExportAssignment(decl)) {
-                return decl.getExpression()?.getType().getText();
+                type = decl.getExpression()?.getType();
             }
             if (MorphNode.isVariableDeclaration(decl)) {
-                return decl.getInitializer()?.getType().getText();
+                type = decl.getInitializer()?.getType();
             }
-            return undefined;
+            return type?.getText(undefined, TypeFormatFlags.UseAliasDefinedOutsideCurrentScope);
         };
         const typeText = getTypeText();
-        if (typeText === CloesceApp.name) {
-            return right(sourceFile.getFilePath().toString());
+        if (typeText === "CloesceApp") {
+            return Either.right(sourceFile.getFilePath().toString());
         }
         return err(ExtractorErrorCode.AppMissingDefaultExport);
     }
     static model(classDecl, sourceFile) {
         const name = classDecl.getName();
         const attributes = [];
-        const navigationProperties = [];
-        const dataSources = {};
+        const navigation_properties = [];
+        const data_sources = {};
         const methods = {};
-        let cruds = [];
+        const cruds = new Set();
         let primary_key = undefined;
         // Extract crud methods
         const crudDecorator = classDecl
             .getDecorators()
             .find((d) => getDecoratorName(d) === ClassDecoratorKind.CRUD);
         if (crudDecorator) {
-            cruds = getCrudKinds(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.ok) {
+            if (typeRes.isLeft()) {
                 typeRes.value.context = prop.getName();
                 typeRes.value.snippet = prop.getText();
                 return typeRes;
@@ -160,7 +160,7 @@ export class CidlExtractor {
                 if (checkModifierRes !== undefined) {
                     return checkModifierRes;
                 }
-                const cidl_type = typeRes.value;
+                const cidl_type = typeRes.unwrap();
                 attributes.push({
                     foreign_key_reference: null,
                     value: {
@@ -172,15 +172,15 @@ export class CidlExtractor {
             }
             // TODO: Limiting to one decorator. Can't get too fancy on us.
             const decorator = decorators[0];
-            const name = getDecoratorName(decorator);
+            const decoratorName = getDecoratorName(decorator);
             // Error: invalid attribute modifier
             if (checkModifierRes !== undefined &&
-                name !== AttributeDecoratorKind.DataSource) {
+                decoratorName !== AttributeDecoratorKind.DataSource) {
                 return checkModifierRes;
             }
-            // Process decorators
-            const cidl_type = typeRes.value;
-            switch (name) {
+            // Process decorator
+            const cidl_type = typeRes.unwrap();
+            switch (decoratorName) {
                 case AttributeDecoratorKind.PrimaryKey: {
                     primary_key = {
                         name: prop.getName(),
@@ -215,7 +215,7 @@ export class CidlExtractor {
                             e.context = prop.getName();
                         });
                     }
-                    navigationProperties.push({
+                    navigation_properties.push({
                         var_name: prop.getName(),
                         model_name,
                         kind: { OneToOne: { reference } },
@@ -239,7 +239,7 @@ export class CidlExtractor {
                             e.context = prop.getName();
                         });
                     }
-                    navigationProperties.push({
+                    navigation_properties.push({
                         var_name: prop.getName(),
                         model_name,
                         kind: { OneToMany: { reference } },
@@ -262,7 +262,7 @@ export class CidlExtractor {
                             e.context = prop.getName();
                         });
                     }
-                    navigationProperties.push({
+                    navigation_properties.push({
                         var_name: prop.getName(),
                         model_name,
                         kind: { ManyToMany: { unique_id } },
@@ -270,23 +270,26 @@ export class CidlExtractor {
                     break;
                 }
                 case AttributeDecoratorKind.DataSource: {
-                    // Error: data sources must be static
-                    if (!prop.isStatic()) {
-                        return err(ExtractorErrorCode.DataSourceMissingStatic, (e) => {
+                    const isIncludeTree = prop
+                        .getType()
+                        .getText(undefined, TypeFormatFlags.UseAliasDefinedOutsideCurrentScope) === `IncludeTree<${name}>`;
+                    // Error: data sources must be static include trees
+                    if (!prop.isStatic() || !isIncludeTree) {
+                        return err(ExtractorErrorCode.InvalidDataSourceDefinition, (e) => {
                             e.snippet = prop.getText();
                             e.context = prop.getName();
                         });
                     }
                     const initializer = prop.getInitializer();
                     const treeRes = CidlExtractor.includeTree(initializer, classDecl, sourceFile);
-                    if (!treeRes.ok) {
+                    if (treeRes.isLeft()) {
                         treeRes.value.addContext((prev) => `${prop.getName()} ${prev}`);
                         treeRes.value.snippet = prop.getText();
                         return treeRes;
                     }
-                    dataSources[prop.getName()] = {
+                    data_sources[prop.getName()] = {
                         name: prop.getName(),
-                        tree: treeRes.value,
+                        tree: treeRes.unwrap(),
                     };
                     break;
                 }
@@ -307,25 +310,20 @@ export class CidlExtractor {
                 continue;
             }
             const result = CidlExtractor.method(name, m, httpVerb);
-            if (!result.ok) {
+            if (result.isLeft()) {
                 result.value.addContext((prev) => `${m.getName()} ${prev}`);
-                return left(result.value);
+                return result;
             }
-            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;
+            methods[result.unwrap().name] = result.unwrap();
         }
-        return right({
+        return Either.right({
             name,
             attributes,
             primary_key,
-            navigation_properties: navigationProperties,
+            navigation_properties,
             methods,
-            data_sources: dataSources,
+            data_sources,
+            cruds: Array.from(cruds).sort(),
             source_path: sourceFile.getFilePath().toString(),
         });
     }
@@ -335,7 +333,7 @@ export class CidlExtractor {
         for (const prop of classDecl.getProperties()) {
             const typeRes = CidlExtractor.cidlType(prop.getType());
             // Error: invalid property type
-            if (!typeRes.ok) {
+            if (typeRes.isLeft()) {
                 typeRes.value.context = prop.getName();
                 typeRes.value.snippet = prop.getText();
                 return typeRes;
@@ -345,35 +343,65 @@ export class CidlExtractor {
             if (modifierRes) {
                 return modifierRes;
             }
-            const cidl_type = typeRes.value;
+            const cidl_type = typeRes.unwrap();
             attributes.push({
                 name: prop.getName(),
                 cidl_type,
             });
             continue;
         }
-        return right({
+        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: "Integer",
-        Number: "Integer",
+        number: "Real",
+        Number: "Real",
+        Integer: "Integer",
         string: "Text",
         String: "Text",
-        boolean: "Integer",
-        Boolean: "Integer",
+        boolean: "Boolean",
+        Boolean: "Boolean",
+        Date: "DateIso",
     };
     static cidlType(type, inject = false) {
         // Void
         if (type.isVoid()) {
-            return right("Void");
+            return Either.right("Void");
         }
         // Null
         if (type.isNull()) {
-            return right({ Nullable: "Void" });
+            return Either.right({ Nullable: "Void" });
         }
         // Nullable via union
         const [unwrappedType, nullable] = unwrapNullable(type);
@@ -384,7 +412,7 @@ export class CidlExtractor {
         // Primitives
         const prim = this.primTypeMap[tyText];
         if (prim) {
-            return right(wrapNullable(prim, nullable));
+            return Either.right(wrapNullable(prim, nullable));
         }
         const generics = [
             ...unwrappedType.getAliasTypeArguments(),
@@ -397,14 +425,14 @@ export class CidlExtractor {
         // No generics -> inject or object
         if (generics.length === 0) {
             const base = inject ? { Inject: tyText } : { Object: tyText };
-            return right(wrapNullable(base, nullable));
+            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 right(wrapNullable({
+            return Either.right(wrapNullable({
                 DataSource: genericTy.getText(undefined, TypeFormatFlags.UseAliasDefinedOutsideCurrentScope),
             }, nullable));
         }
@@ -420,20 +448,21 @@ export class CidlExtractor {
                 genericTyGenerics.length > 0) {
                 return err(ExtractorErrorCode.InvalidPartialType);
             }
-            return right(wrapNullable({
+            return Either.right(wrapNullable({
                 Partial: genericTy
                     .getText(undefined, TypeFormatFlags.UseAliasDefinedOutsideCurrentScope)
                     .split("|")[0]
                     .trim(),
             }, nullable));
         }
+        // Ignore
         if (symbolName === "Promise" || aliasName === "IncludeTree") {
             return wrapGeneric(genericTy, nullable, (inner) => inner);
         }
         if (unwrappedType.isArray()) {
             return wrapGeneric(genericTy, nullable, (inner) => ({ Array: inner }));
         }
-        if (aliasName === "HttpResult") {
+        if (symbolName === "HttpResult") {
             return wrapGeneric(genericTy, nullable, (inner) => ({
                 HttpResult: inner,
             }));
@@ -451,19 +480,20 @@ export class CidlExtractor {
         function wrapGeneric(t, isNullable, wrapper) {
             const res = CidlExtractor.cidlType(t, inject);
             // Error: propogated from `cidlType`
-            if (!res.ok) {
-                return res;
-            }
-            return right(wrapNullable(wrapper(res.value), isNullable));
+            return res.map((inner) => wrapNullable(wrapper(inner), isNullable));
         }
         function unwrapNullable(ty) {
-            if (ty.isUnion()) {
-                const nonNull = ty.getUnionTypes().filter((t) => !t.isNull());
-                if (nonNull.length === 1) {
-                    return [nonNull[0], true];
-                }
+            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 [ty, false];
+            return [nonNulls[0] ?? ty, hasNullable];
         }
     }
     static includeTree(expr, currentClass, sf) {
@@ -487,13 +517,13 @@ export class CidlExtractor {
             }
             const typeRes = CidlExtractor.cidlType(navProp.getType());
             // Error: invalid referenced nav prop type
-            if (!typeRes.ok) {
+            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.value;
+            const cidl_type = typeRes.unwrap();
             if (typeof cidl_type === "string") {
                 return err(ExtractorErrorCode.InvalidNavigationPropertyReference, (e) => {
                     ((e.snippet = navProp.getText()), (e.context = prop.getName()));
@@ -513,16 +543,16 @@ export class CidlExtractor {
                 if (targetClass) {
                     const treeRes = CidlExtractor.includeTree(initializer, targetClass, sf);
                     // Error: Propogated from `includeTree`
-                    if (!treeRes.ok) {
+                    if (treeRes.isLeft()) {
                         treeRes.value.snippet = expr.getText();
                         return treeRes;
                     }
-                    nestedTree = treeRes.value;
+                    nestedTree = treeRes.unwrap();
                 }
             }
             result[navProp.getName()] = nestedTree;
         }
-        return right(result);
+        return Either.right(result);
     }
     static method(modelName, method, httpVerb) {
         // Error: invalid method scope, must be public
@@ -539,37 +569,36 @@ export class CidlExtractor {
             if (param.getDecorator(ParameterDecoratorKind.Inject)) {
                 const typeRes = CidlExtractor.cidlType(param.getType(), true);
                 // Error: invalid type
-                if (!typeRes.ok) {
+                if (typeRes.isLeft()) {
                     typeRes.value.snippet = method.getText();
                     typeRes.value.context = param.getName();
                     return typeRes;
                 }
                 parameters.push({
                     name: param.getName(),
-                    cidl_type: typeRes.value,
+                    cidl_type: typeRes.unwrap(),
                 });
                 continue;
             }
             // Handle all other params
             const typeRes = CidlExtractor.cidlType(param.getType());
             // Error: invalid type
-            if (!typeRes.ok) {
+            if (typeRes.isLeft()) {
                 typeRes.value.snippet = method.getText();
                 typeRes.value.context = param.getName();
                 return typeRes;
             }
-            const rootType = getRootType(typeRes.value);
-            if (typeof rootType !== "string" && "DataSource" in rootType) {
+            if (typeof typeRes.value !== "string" && "DataSource" in typeRes.value) {
                 needsDataSource = false;
             }
             parameters.push({
                 name: param.getName(),
-                cidl_type: typeRes.value,
+                cidl_type: typeRes.unwrap(),
             });
         }
         const typeRes = CidlExtractor.cidlType(method.getReturnType());
         // Error: invalid type
-        if (!typeRes.ok) {
+        if (typeRes.isLeft()) {
             typeRes.value.snippet = method.getText();
             return typeRes;
         }
@@ -580,71 +609,21 @@ export class CidlExtractor {
                 cidl_type: { DataSource: modelName },
             });
         }
-        return right({
+        return Either.right({
             name: method.getName(),
             is_static: method.isStatic(),
             http_verb: httpVerb,
-            return_type: typeRes.value,
+            return_type: typeRes.unwrap(),
             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);
     if (fn) {
         fn(e);
     }
-    return left(e);
+    return Either.left(e);
 }
 function getDecoratorName(decorator) {
     const name = decorator.getName() ?? decorator.getExpression().getText();
@@ -682,18 +661,18 @@ function getObjectName(t) {
     }
     return undefined;
 }
-function getCrudKinds(d) {
+function setCrudKinds(d, cruds) {
     const arg = d.getArguments()[0];
-    if (!arg)
-        return [];
+    if (!arg) {
+        return;
+    }
     if (MorphNode.isArrayLiteralExpression(arg)) {
-        return arg
-            .getElements()
-            .map((e) => (MorphNode.isStringLiteral(e)
-            ? e.getLiteralValue()
-            : e.getText()));
+        for (const a of arg.getElements()) {
+            cruds.add((MorphNode.isStringLiteral(a)
+                ? a.getLiteralValue()
+                : a.getText()));
+        }
     }
-    return [];
 }
 function findPropertyByName(cls, name) {
     const exactMatch = cls.getProperties().find((p) => p.getName() === name);

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

@@ -1 +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"}
+{"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;IAiBrE,GAAG,CAAC,EAAE,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IAU9D,IAAI,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;CAY7D"}