cloesce 0.0.3

package/dist/decorators.js

@@ -0,0 +1,13 @@
+/** Use as @GET (no parentheses) */
+export function GET(_value, _ctx) { }
+/** Use as @POST (no parentheses) */
+export function POST(_value, _ctx) { }
+export function PUT(_value, _ctx) { }
+export function PATCH(_value, _ctx) { }
+export function DELETE(_value, _ctx) { }
+/** Class decorator (no-op) */
+export function D1(value, _ctx) {
+    return value;
+}
+/** Field decorator (no-op) */
+export function PrimaryKey(_v, _ctx) { }

package/dist/dog.cloesce.js

@@ -0,0 +1,111 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { WranglerEnv } from './cloesce.js'; // adjust import path
+let MyEnvironment = (() => {
+    let _classDecorators = [WranglerEnv({
+            name: "my-worker",
+            compatibility_date: "2024-01-01"
+        })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var MyEnvironment = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            MyEnvironment = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return MyEnvironment = _classThis;
+})();
+let Dog = (() => {
+    let _classDecorators = [D1];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _staticExtraInitializers = [];
+    let _instanceExtraInitializers = [];
+    let _static_woof_decorators;
+    let _id_decorators;
+    let _id_initializers = [];
+    let _id_extraInitializers = [];
+    let _get_name_decorators;
+    let _get_breed_decorators;
+    var Dog = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _id_decorators = [PrimaryKey];
+            _get_name_decorators = [GET];
+            _get_breed_decorators = [GET];
+            _static_woof_decorators = [POST];
+            __esDecorate(this, null, _static_woof_decorators, { kind: "method", name: "woof", static: true, private: false, access: { has: obj => "woof" in obj, get: obj => obj.woof }, metadata: _metadata }, null, _staticExtraInitializers);
+            __esDecorate(this, null, _get_name_decorators, { kind: "method", name: "get_name", static: false, private: false, access: { has: obj => "get_name" in obj, get: obj => obj.get_name }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _get_breed_decorators, { kind: "method", name: "get_breed", static: false, private: false, access: { has: obj => "get_breed" in obj, get: obj => obj.get_breed }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            Dog = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _staticExtraInitializers);
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        id = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _id_initializers, void 0));
+        name = __runInitializers(this, _id_extraInitializers);
+        breed;
+        preferred_treat;
+        async get_name(db, req) {
+            const who = new URL(req.url).searchParams.get("name");
+            return new Response(JSON.stringify({ hello: who }), {
+                headers: { "content-type": "application/json" },
+            });
+        }
+        async get_breed(db, req) {
+            const breed = new URL(req.url).searchParams.get("breed");
+            return new Response(JSON.stringify({ hello: breed }), {
+                headers: { "content-type": "application/json" },
+            });
+        }
+        static async woof(db, req, phrase) {
+            return new Response(JSON.stringify({ phrase }), {
+                status: 201,
+                headers: { "content-type": "application/json" },
+            });
+        }
+    };
+    return Dog = _classThis;
+})();

package/dist/extract.d.ts

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

package/dist/extract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract.d.ts","sourceRoot":"","sources":["../src/extract.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EASR,MAAM,UAAU,CAAC;AAElB,OAAO,EAEL,UAAU,EAGV,MAAM,EAUP,MAAM,aAAa,CAAC;AAqBrB,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,MAAM,EAAE,UAAU,CAAC;IA8CrD,OAAO,CAAC,MAAM,CAAC,KAAK;IA+KpB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAQjC;IAEF,OAAO,CAAC,MAAM,CAAC,QAAQ;IAgGvB,OAAO,CAAC,MAAM,CAAC,WAAW;IA8D1B,OAAO,CAAC,MAAM,CAAC,MAAM;CAqDtB"}

package/dist/extract.js

@@ -0,0 +1,517 @@
+import { SyntaxKind, } from "ts-morph";
+import { HttpVerb, left, right, ExtractorError, ExtractorErrorCode, } from "./common.js";
+import { TypeFormatFlags } from "typescript";
+var AttributeDecoratorKind;
+(function (AttributeDecoratorKind) {
+    AttributeDecoratorKind["PrimaryKey"] = "PrimaryKey";
+    AttributeDecoratorKind["ForeignKey"] = "ForeignKey";
+    AttributeDecoratorKind["OneToOne"] = "OneToOne";
+    AttributeDecoratorKind["OneToMany"] = "OneToMany";
+    AttributeDecoratorKind["ManyToMany"] = "ManyToMany";
+    AttributeDecoratorKind["DataSource"] = "DataSource";
+})(AttributeDecoratorKind || (AttributeDecoratorKind = {}));
+var ClassDecoratorKind;
+(function (ClassDecoratorKind) {
+    ClassDecoratorKind["D1"] = "D1";
+    ClassDecoratorKind["WranglerEnv"] = "WranglerEnv";
+    ClassDecoratorKind["PlainOldObject"] = "PlainOldObject";
+})(ClassDecoratorKind || (ClassDecoratorKind = {}));
+var ParameterDecoratorKind;
+(function (ParameterDecoratorKind) {
+    ParameterDecoratorKind["Inject"] = "Inject";
+})(ParameterDecoratorKind || (ParameterDecoratorKind = {}));
+export class CidlExtractor {
+    projectName;
+    version;
+    constructor(projectName, version) {
+        this.projectName = projectName;
+        this.version = version;
+    }
+    extract(project) {
+        const models = {};
+        const poos = {};
+        for (const sourceFile of project.getSourceFiles()) {
+            for (const classDecl of sourceFile.getClasses()) {
+                if (hasDecorator(classDecl, ClassDecoratorKind.D1)) {
+                    const result = CidlExtractor.model(classDecl, sourceFile);
+                    // Error: propogate from models
+                    if (!result.ok) {
+                        result.value.addContext((old) => `${classDecl.getName()}.${old}`);
+                        return result;
+                    }
+                    models[result.value.name] = result.value;
+                    continue;
+                }
+                if (hasDecorator(classDecl, ClassDecoratorKind.PlainOldObject)) {
+                    const result = CidlExtractor.poo(classDecl, sourceFile);
+                    // Error: propogate from models
+                    if (!result.ok) {
+                        result.value.addContext((old) => `${classDecl.getName()}.${old}`);
+                        return result;
+                    }
+                    poos[result.value.name] = result.value;
+                    continue;
+                }
+            }
+        }
+        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);
+        }
+        // Error: Only one wrangler environment can exist
+        if (wranglerEnvs.length > 1) {
+            return err(ExtractorErrorCode.TooManyWranglerEnvs, (e) => (e.context = wranglerEnvs.map((w) => w.name).toString()));
+        }
+        return right({
+            version: this.version,
+            project_name: this.projectName,
+            language: "TypeScript",
+            wrangler_env: wranglerEnvs[0],
+            models,
+            poos,
+        });
+    }
+    static model(classDecl, sourceFile) {
+        const name = classDecl.getName();
+        const attributes = [];
+        const navigationProperties = [];
+        const dataSources = {};
+        const methods = {};
+        let primary_key = undefined;
+        for (const prop of classDecl.getProperties()) {
+            const decorators = prop.getDecorators();
+            const typeRes = CidlExtractor.cidlType(prop.getType());
+            // Error: invalid property type
+            if (!typeRes.ok) {
+                typeRes.value.context = prop.getName();
+                typeRes.value.snippet = prop.getText();
+                return typeRes;
+            }
+            // No decorators means this is a standard attribute
+            if (decorators.length === 0) {
+                const cidl_type = typeRes.value;
+                attributes.push({
+                    foreign_key_reference: null,
+                    value: {
+                        name: prop.getName(),
+                        cidl_type,
+                    },
+                });
+                continue;
+            }
+            // TODO: Limiting to one decorator. Can't get too fancy on us.
+            const decorator = decorators[0];
+            const name = getDecoratorName(decorator);
+            // Process decorators
+            const cidl_type = typeRes.value;
+            switch (name) {
+                case AttributeDecoratorKind.PrimaryKey: {
+                    primary_key = {
+                        name: prop.getName(),
+                        cidl_type,
+                    };
+                    break;
+                }
+                case AttributeDecoratorKind.ForeignKey: {
+                    attributes.push({
+                        foreign_key_reference: getDecoratorArgument(decorator, 0) ?? null,
+                        value: {
+                            name: prop.getName(),
+                            cidl_type,
+                        },
+                    });
+                    break;
+                }
+                case AttributeDecoratorKind.OneToOne: {
+                    const reference = getDecoratorArgument(decorator, 0);
+                    // Error: One to one navigation properties requre a reference
+                    if (!reference) {
+                        return err(ExtractorErrorCode.MissingNavigationPropertyReference, (e) => {
+                            e.snippet = prop.getText();
+                            e.context = prop.getName();
+                        });
+                    }
+                    let model_name = getObjectName(cidl_type);
+                    // Error: navigation properties require a model reference
+                    if (!model_name) {
+                        return err(ExtractorErrorCode.MissingNavigationPropertyReference, (e) => {
+                            e.snippet = prop.getText();
+                            e.context = prop.getName();
+                        });
+                    }
+                    navigationProperties.push({
+                        var_name: prop.getName(),
+                        model_name,
+                        kind: { OneToOne: { reference } },
+                    });
+                    break;
+                }
+                case AttributeDecoratorKind.OneToMany: {
+                    const reference = getDecoratorArgument(decorator, 0);
+                    // Error: One to one navigation properties requre a reference
+                    if (!reference) {
+                        return err(ExtractorErrorCode.MissingNavigationPropertyReference, (e) => {
+                            e.snippet = prop.getText();
+                            e.context = prop.getName();
+                        });
+                    }
+                    let model_name = getObjectName(cidl_type);
+                    // Error: navigation properties require a model reference
+                    if (!model_name) {
+                        return err(ExtractorErrorCode.MissingNavigationPropertyReference, (e) => {
+                            e.snippet = prop.getText();
+                            e.context = prop.getName();
+                        });
+                    }
+                    navigationProperties.push({
+                        var_name: prop.getName(),
+                        model_name,
+                        kind: { OneToMany: { reference } },
+                    });
+                    break;
+                }
+                case AttributeDecoratorKind.ManyToMany: {
+                    const unique_id = getDecoratorArgument(decorator, 0);
+                    // Error: many to many attribtues require a unique id
+                    if (!unique_id)
+                        return err(ExtractorErrorCode.MissingManyToManyUniqueId, (e) => {
+                            e.snippet = prop.getText();
+                            e.context = prop.getName();
+                        });
+                    // Error: navigation properties require a model reference
+                    let model_name = getObjectName(cidl_type);
+                    if (!model_name) {
+                        return err(ExtractorErrorCode.MissingNavigationPropertyReference, (e) => {
+                            e.snippet = prop.getText();
+                            e.context = prop.getName();
+                        });
+                    }
+                    navigationProperties.push({
+                        var_name: prop.getName(),
+                        model_name,
+                        kind: { ManyToMany: { unique_id } },
+                    });
+                    break;
+                }
+                case AttributeDecoratorKind.DataSource: {
+                    const initializer = prop.getInitializer();
+                    const treeRes = CidlExtractor.includeTree(initializer, classDecl, sourceFile);
+                    if (!treeRes.ok) {
+                        treeRes.value.addContext((old) => `${prop.getName()} ${old}`);
+                        treeRes.value.snippet = prop.getText();
+                        return treeRes;
+                    }
+                    dataSources[prop.getName()] = {
+                        name: prop.getName(),
+                        tree: treeRes.value,
+                    };
+                    break;
+                }
+            }
+        }
+        if (primary_key == undefined) {
+            return err(ExtractorErrorCode.MissingPrimaryKey, (e) => {
+                e.snippet = classDecl.getText();
+            });
+        }
+        // Process methods
+        for (const m of classDecl.getMethods()) {
+            const result = CidlExtractor.method(m);
+            if (!result.ok) {
+                result.value.addContext((old) => `${m.getName()} ${old}`);
+                return left(result.value);
+            }
+            methods[result.value.name] = result.value;
+        }
+        return right({
+            name,
+            attributes,
+            primary_key,
+            navigation_properties: navigationProperties,
+            methods,
+            data_sources: dataSources,
+            source_path: sourceFile.getFilePath().toString(),
+        });
+    }
+    static poo(classDecl, sourceFile) {
+        const name = classDecl.getName();
+        const attributes = [];
+        for (const prop of classDecl.getProperties()) {
+            const typeRes = CidlExtractor.cidlType(prop.getType());
+            // Error: invalid property type
+            if (!typeRes.ok) {
+                typeRes.value.context = prop.getName();
+                typeRes.value.snippet = prop.getText();
+                return typeRes;
+            }
+            const cidl_type = typeRes.value;
+            attributes.push({
+                name: prop.getName(),
+                cidl_type,
+            });
+            continue;
+        }
+        return right({
+            name,
+            attributes,
+            source_path: sourceFile.getFilePath().toString(),
+        });
+    }
+    static primTypeMap = {
+        number: "Integer",
+        Number: "Integer",
+        string: "Text",
+        String: "Text",
+        boolean: "Integer",
+        Boolean: "Integer",
+        Date: "Text",
+    };
+    static cidlType(type, inject = false) {
+        // Void
+        if (type.isVoid()) {
+            return right("Void");
+        }
+        // Null
+        if (type.isNull()) {
+            return right({ Nullable: "Void" });
+        }
+        // Nullable via union
+        const [unwrappedType, nullable] = unwrapNullable(type);
+        const tyText = unwrappedType
+            .getText(undefined, TypeFormatFlags.UseAliasDefinedOutsideCurrentScope)
+            .split("|")[0]
+            .trim();
+        // Primitives
+        const prim = this.primTypeMap[tyText];
+        if (prim) {
+            return right(wrapNullable(prim, nullable));
+        }
+        const generics = [
+            ...unwrappedType.getAliasTypeArguments(),
+            ...unwrappedType.getTypeArguments(),
+        ];
+        // Error: can't handle multiple generics
+        if (generics.length > 1) {
+            return err(ExtractorErrorCode.MultipleGenericType);
+        }
+        // No generics -> inject or object
+        if (generics.length === 0) {
+            const base = inject ? { Inject: tyText } : { Object: tyText };
+            return right(wrapNullable(base, nullable));
+        }
+        // Single generic
+        const genericTy = generics[0];
+        const symbolName = unwrappedType.getSymbol()?.getName();
+        const aliasName = unwrappedType.getAliasSymbol()?.getName();
+        if (symbolName === "Promise" || aliasName === "IncludeTree") {
+            return wrapGeneric(genericTy, nullable, (inner) => inner);
+        }
+        if (unwrappedType.isArray()) {
+            return wrapGeneric(genericTy, nullable, (inner) => ({ Array: inner }));
+        }
+        if (aliasName === "HttpResult") {
+            return wrapGeneric(genericTy, nullable, (inner) => ({
+                HttpResult: inner,
+            }));
+        }
+        // Error: unknown type
+        return err(ExtractorErrorCode.UnknownType);
+        function wrapNullable(inner, isNullable) {
+            if (isNullable) {
+                return { Nullable: inner };
+            }
+            else {
+                return inner;
+            }
+        }
+        function wrapGeneric(t, isNullable, wrapper) {
+            const res = CidlExtractor.cidlType(t, inject);
+            // Error: propogated from `cidlType`
+            if (!res.ok) {
+                return res;
+            }
+            return right(wrapNullable(wrapper(res.value), isNullable));
+        }
+        function unwrapNullable(ty) {
+            if (ty.isUnion()) {
+                const nonNull = ty.getUnionTypes().filter((t) => !t.isNull());
+                if (nonNull.length === 1) {
+                    return [nonNull[0], true];
+                }
+            }
+            return [ty, false];
+        }
+    }
+    static includeTree(expr, currentClass, sf) {
+        // Include trees must be of the expected form
+        if (!expr ||
+            !expr.isKind ||
+            !expr.isKind(SyntaxKind.ObjectLiteralExpression)) {
+            return err(ExtractorErrorCode.InvalidIncludeTree);
+        }
+        const result = {};
+        for (const prop of expr.getProperties()) {
+            if (!prop.isKind(SyntaxKind.PropertyAssignment))
+                continue;
+            // Error: navigation property not found
+            const navProp = findPropertyByName(currentClass, prop.getName());
+            if (!navProp) {
+                return err(ExtractorErrorCode.UnknownNavigationPropertyReference, (e) => {
+                    e.snippet = expr.getText();
+                    e.context = prop.getName();
+                });
+            }
+            const typeRes = CidlExtractor.cidlType(navProp.getType());
+            // Error: invalid referenced nav prop type
+            if (!typeRes.ok) {
+                typeRes.value.snippet = navProp.getText();
+                typeRes.value.context = prop.getName();
+                return typeRes;
+            }
+            // Error: invalid referenced nav prop type
+            const cidl_type = typeRes.value;
+            if (typeof cidl_type === "string") {
+                return err(ExtractorErrorCode.InvalidNavigationPropertyReference, (e) => {
+                    ((e.snippet = navProp.getText()), (e.context = prop.getName()));
+                });
+            }
+            // Recurse for nested includes
+            const initializer = prop.getInitializer?.();
+            let nestedTree = {};
+            if (initializer?.isKind?.(SyntaxKind.ObjectLiteralExpression)) {
+                const targetModel = getObjectName(cidl_type);
+                const targetClass = currentClass
+                    .getSourceFile()
+                    .getProject()
+                    .getSourceFiles()
+                    .flatMap((f) => f.getClasses())
+                    .find((c) => c.getName() === targetModel);
+                if (targetClass) {
+                    const treeRes = CidlExtractor.includeTree(initializer, targetClass, sf);
+                    // Error: Propogated from `includeTree`
+                    if (!treeRes.ok) {
+                        treeRes.value.snippet = expr.getText();
+                        return treeRes;
+                    }
+                    nestedTree = treeRes.value;
+                }
+            }
+            result[navProp.getName()] = nestedTree;
+        }
+        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));
+        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.ok) {
+                    typeRes.value.snippet = method.getText();
+                    typeRes.value.context = param.getName();
+                    return typeRes;
+                }
+                parameters.push({
+                    name: param.getName(),
+                    cidl_type: typeRes.value,
+                });
+                continue;
+            }
+            // Handle all other params
+            const typeRes = CidlExtractor.cidlType(param.getType());
+            // Error: invalid type
+            if (!typeRes.ok) {
+                typeRes.value.snippet = method.getText();
+                typeRes.value.context = param.getName();
+                return typeRes;
+            }
+            parameters.push({
+                name: param.getName(),
+                cidl_type: typeRes.value,
+            });
+        }
+        const typeRes = CidlExtractor.cidlType(method.getReturnType());
+        // Error: invalid type
+        if (!typeRes.ok) {
+            typeRes.value.snippet = method.getText();
+            return typeRes;
+        }
+        return right({
+            name: method.getName(),
+            is_static: method.isStatic(),
+            http_verb: httpVerb,
+            return_type: typeRes.value,
+            parameters,
+        });
+    }
+}
+function err(code, fn) {
+    let e = new ExtractorError(code);
+    if (fn) {
+        fn(e);
+    }
+    return left(e);
+}
+function getDecoratorName(decorator) {
+    const name = decorator.getName() ?? decorator.getExpression().getText();
+    return String(name).replace(/\(.*\)$/, "");
+}
+function getDecoratorArgument(decorator, index) {
+    const args = decorator.getArguments();
+    if (!args[index])
+        return undefined;
+    const arg = args[index];
+    // 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;
+}
+function getObjectName(t) {
+    if (typeof t === "string")
+        return undefined;
+    if ("Object" in t) {
+        return t.Object;
+    }
+    else if ("Array" in t) {
+        return getObjectName(t.Array);
+    }
+    else if ("HttpResult" in t) {
+        if (t == null)
+            return undefined;
+        return getObjectName(t.HttpResult);
+    }
+    return undefined;
+}
+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);
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+export { cloesce, modelsFromSql } from "./cloesce.js";
+export { HttpResult } from "./common.js";
+export declare const D1: ClassDecorator;
+export declare const WranglerEnv: ClassDecorator;
+export declare const PrimaryKey: PropertyDecorator;
+export declare const GET: MethodDecorator;
+export declare const POST: MethodDecorator;
+export declare const PUT: MethodDecorator;
+export declare const PATCH: MethodDecorator;
+export declare const DELETE: MethodDecorator;
+export declare const DataSource: PropertyDecorator;
+export declare const OneToMany: (_: string) => PropertyDecorator;
+export declare const OneToOne: (_: string) => PropertyDecorator;
+export declare const ManyToMany: (_: string) => PropertyDecorator;
+export declare const ForeignKey: <T>(_: T) => PropertyDecorator;
+export declare const Inject: ParameterDecorator;
+type Primitive = string | number | boolean | bigint | symbol | null | undefined;
+export type IncludeTree<T> = T extends Primitive ? never : {
+    [K in keyof T]?: T[K] extends (infer U)[] ? IncludeTree<NonNullable<U>> : IncludeTree<NonNullable<T[K]>>;
+};
+export declare function instantiateModelArray<T extends object>(data: any, ctor: {
+    new (): T;
+}): T[];
+//# sourceMappingURL=index.d.ts.map