cloesce 0.0.3-fix.1

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

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAGzC,eAAO,MAAM,EAAE,EAAE,cAAyB,CAAC;AAC3C,eAAO,MAAM,WAAW,EAAE,cAAyB,CAAC;AACpD,eAAO,MAAM,UAAU,EAAE,iBAA4B,CAAC;AACtD,eAAO,MAAM,GAAG,EAAE,eAA0B,CAAC;AAC7C,eAAO,MAAM,IAAI,EAAE,eAA0B,CAAC;AAC9C,eAAO,MAAM,GAAG,EAAE,eAA0B,CAAC;AAC7C,eAAO,MAAM,KAAK,EAAE,eAA0B,CAAC;AAC/C,eAAO,MAAM,MAAM,EAAE,eAA0B,CAAC;AAChD,eAAO,MAAM,UAAU,EAAE,iBAA4B,CAAC;AACtD,eAAO,MAAM,SAAS,MAChB,MAAM,KAAG,iBACL,CAAC;AACX,eAAO,MAAM,QAAQ,MACf,MAAM,KAAG,iBACL,CAAC;AACX,eAAO,MAAM,UAAU,MACjB,MAAM,KAAG,iBACL,CAAC;AACX,eAAO,MAAM,UAAU,GACpB,CAAC,KAAK,CAAC,KAAG,iBACH,CAAC;AACX,eAAO,MAAM,MAAM,EAAE,kBAA6B,CAAC;AAGnD,KAAK,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;AAChF,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,GAC5C,KAAK,GACL;KACG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,GACrC,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,GAC3B,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACnC,CAAC;AAGN,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,MAAM,EACpD,IAAI,EAAE,GAAG,EACT,IAAI,EAAE;IAAE,QAAQ,CAAC,CAAA;CAAE,GAClB,CAAC,EAAE,CAKL"}

package/dist/index.js

@@ -0,0 +1,24 @@
+export { cloesce, modelsFromSql } from "./cloesce.js";
+// Compiler hints
+export const D1 = () => { };
+export const PlainOldObject = () => { };
+export const WranglerEnv = () => { };
+export const PrimaryKey = () => { };
+export const GET = () => { };
+export const POST = () => { };
+export const PUT = () => { };
+export const PATCH = () => { };
+export const DELETE = () => { };
+export const DataSource = () => { };
+export const OneToMany = (_) => () => { };
+export const OneToOne = (_) => () => { };
+export const ManyToMany = (_) => () => { };
+export const ForeignKey = (_) => () => { };
+export const Inject = () => { };
+// Helpers
+export function instantiateObjectArray(data, ctor) {
+    if (Array.isArray(data)) {
+        return data.map((x) => instantiateObjectArray(x, ctor)).flat();
+    }
+    return [Object.assign(new ctor(), data)];
+}

package/dist/types.d.ts

@@ -0,0 +1,4 @@
+export interface D1Db {
+}
+export type Handler = (db: D1Db, req: Request, ...args: any[]) => Promise<Response>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,IAAI;CAAG;AAExB,MAAM,MAAM,OAAO,GAAG,CACpB,EAAE,EAAE,IAAI,EACR,GAAG,EAAE,OAAO,EACZ,GAAG,IAAI,EAAE,GAAG,EAAE,KACX,OAAO,CAAC,QAAQ,CAAC,CAAC"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "cloesce",
+  "version": "0.0.3-fix.1",
+  "description": "A tool to extract and compile TypeScript code into something wrangler can consume and deploy for D1 Databases and Cloudflare Workers",
+  "type": "module",
+  "license": "Apache-2.0",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./cli": "./dist/cli.js"
+  },
+  "bin": {
+    "cloesce": "./dist/cli.js"
+  },
+  "files": [
+    "dist/**",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18.17"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest --run",
+    "format": "prettier --check .",
+    "format:fix": "prettier --write .",
+    "prepublishOnly": "npm run typecheck && npm run build && npm run test"
+  },
+  "dependencies": {
+    "cmd-ts": "^0.14.1",
+    "ts-morph": "^22.0.0"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20250906.0",
+    "prettier": "^3.6.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.6.0",
+    "vitest": "^3.2.4",
+    "wrangler": "^4.34.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bens-schreiber/cloesce.git"
+  },
+  "homepage": "https://github.com/bens-schreiber/cloesce",
+  "keywords": [
+    "cloudflare",
+    "workers",
+    "d1",
+    "orm",
+    "cli"
+  ]
+}