cloesce 0.0.3-fix.1 → 0.0.3-fix.2

package/dist/{cloesce.js → runtime/runtime.js}

@@ -1,50 +1,74 @@
-import { left, right, isNullableType, getNavigationPropertyCidlType, } from "./common.js";
+import { left, right, isNullableType, getNavigationPropertyCidlType, } from "../common.js";
+// Requires the rust runtime binary to have been built
+import mod from "../../dist/runtime.wasm";
 /**
- * Singleton instances of the MetaCidl and Constructor Registry.
- * These values are guaranteed to never change throughout a workers lifetime.
+ * RAII for wasm memory
  */
-class MetaContainer {
+class WasmResource {
+    wasm;
+    ptr;
+    len;
+    constructor(wasm, ptr, len) {
+        this.wasm = wasm;
+        this.ptr = ptr;
+        this.len = len;
+    }
+    free() {
+        this.wasm.dealloc(this.ptr, this.len);
+    }
+    /**
+     * Copies a value from TS memory to WASM memory. A subsequent `free` is necessary.
+     */
+    static fromString(str, wasm) {
+        const encoder = new TextEncoder();
+        const bytes = encoder.encode(str);
+        const ptr = wasm.alloc(bytes.length);
+        const mem = new Uint8Array(wasm.memory.buffer, ptr, bytes.length);
+        mem.set(bytes);
+        return new this(wasm, ptr, bytes.length);
+    }
+}
+/**
+ * Singleton instances of the cidl, constructor registry, and wasm binary.
+ * These values are guaranteed to never change throughout a program lifetime.
+ */
+class RuntimeContainer {
     ast;
     constructorRegistry;
+    wasm;
     static instance;
-    constructor(ast, constructorRegistry) {
+    constructor(ast, constructorRegistry, wasm) {
         this.ast = ast;
         this.constructorRegistry = constructorRegistry;
+        this.wasm = wasm;
     }
-    static init(ast, constructorRegistry) {
-        if (!this.instance) {
-            this.instance = new MetaContainer(ast, constructorRegistry);
+    static async init(ast, constructorRegistry, wasm) {
+        if (this.instance) {
+            return;
+        }
+        // Load WASM
+        const wasmInstance = (wasm ??
+            (await WebAssembly.instantiate(mod)));
+        const modelMeta = WasmResource.fromString(JSON.stringify(ast.models), wasmInstance.exports);
+        if (wasmInstance.exports.set_meta_ptr(modelMeta.ptr, modelMeta.len) != 0) {
+            modelMeta.free();
+            throw Error("The WASM Module failed to load due to an invalid CIDL");
         }
+        // Intentionally leak `modelMeta`, it should exist for the programs lifetime.
+        this.instance = new RuntimeContainer(ast, constructorRegistry, wasmInstance.exports);
     }
     static get() {
         return this.instance;
     }
 }
 /**
- * Creates model instances given a properly formatted SQL record
- * (either a foreign-key-less model or derived from a Cloesce generated view)
- * @param ctor The type of the model
- * @param records SQL records
- * @param includeTree The include tree to use when parsing the records
- * @returns
- */
-export function modelsFromSql(ctor, records, includeTree) {
-    const { ast, constructorRegistry } = MetaContainer.get();
-    return _modelsFromSql(ctor.name, ast, constructorRegistry, records, includeTree);
-}
-/**
- * Cloesce entry point. Given a request, undergoes routing, validating,
+ * Runtime entry point. Given a request, undergoes: routing, validating,
  * hydrating, and method dispatch.
- * @param ast The CIDL AST
- * @param constructorRegistry A mapping of user defined class names to their respective constructor
- * @param instanceRegistry A mapping of a dependency class name to its instantiated object.
- * @param request An incoming request to the workers server
- * @param api_route The url's path to the api, e.g. api/v1/fooapi/
- * @param envMeta Meta information on the wrangler env and D1 databases
+ *
  * @returns A Response with an `HttpResult` JSON body.
  */
 export async function cloesce(request, ast, constructorRegistry, instanceRegistry, envMeta, api_route) {
-    MetaContainer.init(ast, constructorRegistry);
+    await RuntimeContainer.init(ast, constructorRegistry);
     const d1 = instanceRegistry.get(envMeta.envName)[envMeta.dbName];
     // Match the route to a model method
     const route = matchRoute(request, ast, api_route);
@@ -53,25 +77,25 @@ export async function cloesce(request, ast, constructorRegistry, instanceRegistr
     }
     const { method, model, id } = route.value;
     // Validate request body to the model method
-    const isValidRequest = await validateRequest(request, ast, model, method, id);
-    if (!isValidRequest.ok) {
-        return toResponse(isValidRequest.value);
+    const validation = await validateRequest(request, ast, model, method, id);
+    if (!validation.ok) {
+        return toResponse(validation.value);
     }
-    const [requestParamMap, dataSource] = isValidRequest.value;
+    const { params, dataSource } = validation.value;
     // Instantatiate the model
     let instance;
     if (method.is_static) {
         instance = constructorRegistry[model.name];
     }
     else {
-        const successfulModel = await hydrateModel(ast, constructorRegistry, d1, model, id, dataSource);
-        if (!successfulModel.ok) {
-            return toResponse(successfulModel.value);
+        const hydratedModel = await hydrateModel(constructorRegistry, d1, model, id, dataSource);
+        if (!hydratedModel.ok) {
+            return toResponse(hydratedModel.value);
         }
-        instance = successfulModel.value;
+        instance = hydratedModel.value;
     }
     // Dispatch a method on the model and return the result
-    return toResponse(await methodDispatch(instance, instanceRegistry, envMeta, method, requestParamMap));
+    return toResponse(await methodDispatch(instance, instanceRegistry, envMeta, method, params));
 }
 /**
  * Matches a request to a method on a model.
@@ -80,6 +104,8 @@ export async function cloesce(request, ast, constructorRegistry, instanceRegistr
  */
 function matchRoute(request, ast, api_route) {
     const url = new URL(request.url);
+    // Error state: We expect an exact request format, and expect that the model
+    // and are apart of the CIDL
     const notFound = (e) => left(errorState(404, `Path not found: ${e} ${url.pathname}`));
     const routeParts = url.pathname
         .slice(api_route.length)
@@ -129,13 +155,13 @@ async function validateRequest(request, ast, model, method, id) {
     const url = new URL(request.url);
     let dataSource = url.searchParams.get("dataSource");
     // Extract url or body parameters
-    let requestBodyMap;
+    let params;
     if (method.http_verb === "GET") {
-        requestBodyMap = Object.fromEntries(url.searchParams.entries());
+        params = Object.fromEntries(url.searchParams.entries());
     }
     else {
         try {
-            requestBodyMap = await request.json();
+            params = await request.json();
         }
         catch {
             return invalidRequest("Could not retrieve JSON body.");
@@ -146,17 +172,17 @@ async function validateRequest(request, ast, model, method, id) {
         return invalidRequest(`Unknown data source ${dataSource}`);
     }
     // Ensure all required params exist
-    if (!requiredParams.every((p) => p.name in requestBodyMap)) {
+    if (!requiredParams.every((p) => p.name in params)) {
         return invalidRequest(`Missing parameters.`);
     }
     // Validate all parameters type
     for (const p of requiredParams) {
-        const value = requestBodyMap[p.name];
+        const value = params[p.name];
         if (!validateCidlType(ast, value, p.cidl_type)) {
             return invalidRequest("Invalid parameters.");
         }
     }
-    return right([requestBodyMap, dataSource]);
+    return right({ params, dataSource });
 }
 /**
  * Queries D1 for a particular model's ID, then transforms the SQL column output into
@@ -165,7 +191,7 @@ async function validateRequest(request, ast, model, method, id) {
  * @returns 500 if the D1 database is not synced with Cloesce and yields an error
  * @returns The instantiated model on success
  */
-async function hydrateModel(ast, constructorRegistry, d1, model, id, dataSource) {
+async function hydrateModel(constructorRegistry, d1, model, id, dataSource) {
     // Error state: If the D1 database has been tweaked outside of Cloesce
     // resulting in a malformed query, exit with a 500.
     const malformedQuery = (e) => left(errorState(500, `Error in hydration query, is the database out of sync with the backend?: ${e instanceof Error ? e.message : String(e)}`));
@@ -192,8 +218,7 @@ async function hydrateModel(ast, constructorRegistry, d1, model, id, dataSource)
     // Get include tree
     const includeTree = dataSource !== null ? model.data_sources[dataSource].tree : {};
     // Hydrate
-    const models = _modelsFromSql(model.name, ast, constructorRegistry, records.results, includeTree);
-    console.log(JSON.stringify(models));
+    const models = modelsFromSql(constructorRegistry[model.name], records.results, includeTree);
     return right(models[0]);
 }
 /**
@@ -294,142 +319,65 @@ function validateCidlType(ast, value, cidlType) {
     return false;
 }
 /**
- * Actual implementation of sql to model mapping.
+ * Creates model instances given a properly formatted SQL record, being either:
  *
- * TODO: If we don't want to write this in every language, would it be possible to create a
- * single WASM binary for this method?
+ *  1. Flat, relationship-less (ex: id, name, location, ...)
+ *  2. `DataSource` formatted (ex: Horse.id, Horse.name, Horse.rider, ...)
  *
- * @throws generic errors if the metadata is missing some value
+ * @param ctor The type of the model
+ * @param records SQL records
+ * @param includeTree The include tree to use when parsing the records
+ * @returns An instantiated array of `T`, containing one or more objects.
  */
-// Main function that creates instances from SQL records
-function _modelsFromSql(modelName, ast, constructorRegistry, records, includeTree) {
-    const model = ast.models[modelName];
-    if (!model)
-        return [];
-    const Constructor = constructorRegistry[modelName];
-    if (!Constructor)
-        return [];
-    const pkName = model.primary_key.name;
-    const resultMap = new Map();
-    for (const record of records) {
-        const pkValue = record[`${modelName}.${pkName}`] ?? record[pkName];
-        if (pkValue == null)
-            continue;
-        let instance = resultMap.get(pkValue);
-        if (!instance) {
-            instance = new Constructor();
-            instance[pkName] = pkValue;
-            // Set scalar attributes
-            for (const attr of model.attributes) {
-                const attrName = attr.value.name;
-                const prefixedKey = `${modelName}.${attrName}`;
-                const nonPrefixedKey = attrName;
-                if (prefixedKey in record) {
-                    instance[attrName] = record[prefixedKey];
-                }
-                else if (nonPrefixedKey in record) {
-                    instance[attrName] = record[nonPrefixedKey];
-                }
-            }
-            // Initialize ALL navigation properties at root level
-            // If not in include tree, initialize OneToMany and ManyToMany as empty arrays
-            for (const navProp of model.navigation_properties) {
-                if ("OneToMany" in navProp.kind || "ManyToMany" in navProp.kind) {
-                    // Always initialize OneToMany and ManyToMany as empty arrays
-                    instance[navProp.var_name] = [];
-                }
-                // OneToOne properties left as undefined unless populated
-            }
-            resultMap.set(pkValue, instance);
-        }
-        // Process navigation properties that are in the include tree
-        if (includeTree) {
-            processNavigationProperties(instance, model, modelName, includeTree, record, ast, constructorRegistry);
-        }
-    }
-    return Array.from(resultMap.values());
-}
-function processNavigationProperties(instance, model, prefix, includeTree, record, ast, constructorRegistry) {
-    for (const navProp of model.navigation_properties) {
-        if (!(navProp.var_name in includeTree)) {
-            continue;
+export function modelsFromSql(ctor, records, includeTree) {
+    const { ast, constructorRegistry, wasm } = RuntimeContainer.get();
+    const modelName = WasmResource.fromString(ctor.name, wasm);
+    const rows = WasmResource.fromString(JSON.stringify(records), wasm);
+    const includeTreeJson = WasmResource.fromString(JSON.stringify(includeTree), wasm);
+    // Invoke the ORM
+    const jsonResults = (() => {
+        let resPtr;
+        let resLen;
+        try {
+            resPtr = wasm.object_relational_mapping(modelName.ptr, modelName.len, rows.ptr, rows.len, includeTreeJson.ptr, includeTreeJson.len);
+            resLen = wasm.get_return_len();
+            // Parse the results as JSON
+            return JSON.parse(new TextDecoder().decode(new Uint8Array(wasm.memory.buffer, resPtr, resLen)));
         }
-        const nestedModel = ast.models[navProp.model_name];
-        if (!nestedModel) {
-            continue;
+        finally {
+            modelName.free();
+            rows.free();
+            includeTreeJson.free();
+            // Could resPtr some how be set but not resLen? Kind of a flaw
+            // in how WASM works.
+            if (resPtr && resLen)
+                wasm.dealloc(resPtr, resLen);
         }
-        // Extract nested model's primary key - check both prefixed and non-prefixed
-        const nestedPkName = nestedModel.primary_key.name;
-        const prefixedNestedPkKey = `${prefix}.${navProp.var_name}.${nestedPkName}`;
-        const nonPrefixedNestedPkKey = `${navProp.var_name}.${nestedPkName}`;
-        const nestedPkValue = record[prefixedNestedPkKey] ?? record[nonPrefixedNestedPkKey];
-        if (nestedPkValue == null) {
-            continue; // No nested object in this row
+    })();
+    return jsonResults.map((obj) => instantiateDfs(obj, ast.models[ctor.name], includeTree));
+    // The result that comes back is just raw JSON, run a DFS on each navigation property
+    // in the include tree provided, instantiating each object via constructor registry.
+    function instantiateDfs(m, meta, includeTree) {
+        m = Object.assign(new constructorRegistry[meta.name](), m);
+        if (!includeTree) {
+            return m;
         }
-        // Determine if this is OneToMany/ManyToMany or OneToOne
-        const isOneToMany = "OneToMany" in navProp.kind || "ManyToMany" in navProp.kind;
-        // Check if we already added this nested object (for OneToMany)
-        if (isOneToMany) {
-            const navArray = instance[navProp.var_name];
-            const alreadyExists = navArray.some((item) => item[nestedPkName] === nestedPkValue);
-            if (alreadyExists) {
+        for (const navProp of meta.navigation_properties) {
+            const nestedIncludeTree = includeTree[navProp.var_name];
+            if (!nestedIncludeTree)
                 continue;
+            const nestedMeta = ast.models[navProp.model_name];
+            const value = m[navProp.var_name];
+            // One to Many, Many to Many
+            if (Array.isArray(value)) {
+                m[navProp.var_name] = value.map((child) => instantiateDfs(child, nestedMeta, nestedIncludeTree));
             }
-        }
-        else {
-            // For OneToOne, check if already set
-            if (instance[navProp.var_name] != null) {
-                continue;
+            // One to one
+            else if (value) {
+                m[navProp.var_name] = instantiateDfs(value, nestedMeta, nestedIncludeTree);
             }
         }
-        const NestedConstructor = constructorRegistry[navProp.model_name];
-        if (!NestedConstructor) {
-            continue;
-        }
-        const nestedInstance = new NestedConstructor();
-        nestedInstance[nestedPkName] = nestedPkValue;
-        // Assign nested scalar attributes - check both prefixed and non-prefixed
-        for (const nestedAttr of nestedModel.attributes) {
-            const nestedAttrName = nestedAttr.value.name;
-            const prefixedKey = `${prefix}.${navProp.var_name}.${nestedAttrName}`;
-            const nonPrefixedKey = `${navProp.var_name}.${nestedAttrName}`;
-            // Check prefixed key first, then non-prefixed
-            if (prefixedKey in record) {
-                nestedInstance[nestedAttrName] = record[prefixedKey];
-            }
-            else if (nonPrefixedKey in record) {
-                nestedInstance[nestedAttrName] = record[nonPrefixedKey];
-            }
-        }
-        // Initialize ALL navigation properties on the nested instance
-        // If not in include tree, initialize OneToMany and ManyToMany as empty arrays
-        const nestedIncludeTree = includeTree[navProp.var_name];
-        for (const nestedNavProp of nestedModel.navigation_properties) {
-            const isInIncludeTree = nestedIncludeTree &&
-                typeof nestedIncludeTree === "object" &&
-                nestedNavProp.var_name in nestedIncludeTree;
-            if ("OneToMany" in nestedNavProp.kind ||
-                "ManyToMany" in nestedNavProp.kind) {
-                // Always initialize OneToMany and ManyToMany as arrays (empty if not in include tree)
-                nestedInstance[nestedNavProp.var_name] = [];
-            }
-            else if (!isInIncludeTree) {
-                // OneToOne not in include tree - leave as undefined or null
-                // Will be set during recursive processing if in include tree
-            }
-        }
-        // Recursively process nested navigation properties that are in the include tree
-        if (nestedIncludeTree && typeof nestedIncludeTree === "object") {
-            processNavigationProperties(nestedInstance, nestedModel, `${prefix}.${navProp.var_name}`, nestedIncludeTree, record, ast, constructorRegistry);
-        }
-        // Assign the nested instance based on relationship type
-        if (isOneToMany) {
-            instance[navProp.var_name].push(nestedInstance);
-        }
-        else {
-            // OneToOne - assign directly
-            instance[navProp.var_name] = nestedInstance;
-        }
+        return m;
     }
 }
 function errorState(status, message) {
@@ -442,12 +390,11 @@ function toResponse(r) {
     });
 }
 /**
- * Each individual state of the `cloesce` function for testing purposes.
+ * For testing purposes
  */
 export const _cloesceInternal = {
     matchRoute,
     validateRequest,
-    hydrateModel,
     methodDispatch,
-    _modelsFromSql,
+    RuntimeContainer,
 };

package/package.json

@@ -1,60 +1,61 @@
-{
-  "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"
-  ]
-}
+{
+  "name": "cloesce",
+  "version": "0.0.3-fix.2",
+  "description": "A tool to extract and compile TypeScript code into something wrangler can consume and deploy for D1 Databases and Cloudflare Workers",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "license": "Apache-2.0",
+  "scripts": {
+    "test": "vitest",
+    "format:fix": "prettier --write .",
+    "format": "prettier --check .",
+    "typecheck": "tsc --noEmit",
+    "build": "tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "cmd-ts": "^0.14.1",
+    "prettier": "^3.6.2",
+    "ts-morph": "^22.0.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.6.0",
+    "wrangler": "^4.34.0"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20250906.0",
+    "prettier": "^3.6.2",
+    "vitest": "^3.2.4",
+    "vite-plugin-wasm": "^3.5.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./cli": "./dist/cli.js"
+  },
+  "bin": {
+    "cloesce": "./dist/extractor/cli.js"
+  },
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18.17"
+  },
+  "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"
+  ]
+}

package/dist/cli.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":""}

package/dist/cloesce.d.ts

@@ -1,108 +0,0 @@
-import { D1Database } from "@cloudflare/workers-types/experimental/index.js";
-import { HttpResult, Either, ModelMethod, CloesceAst, Model } from "./common.js";
-import { IncludeTree } from "./index.js";
-/**
- * A map of model names to their respective constructor.
- *
- * The value accepted into the `cloesce` function is generated by the Cloesce compiler, and
- * is guaranteed to contain all model definitions.
- */
-type ModelConstructorRegistry = Record<string, new () => UserDefinedModel>;
-/**
- * A dependency injection container, mapping an object type name to an instance of that object.
- *
- * The value accepted into the `cloesce` function is generated by the Cloesce compiler, and is
- * guaranteed to contain all injected model method parameters.
- */
-type InstanceRegistry = Map<string, any>;
-/**
- * Users will create Cloesce models, which have metadata for them in the ast.
- * For TypeScript's purposes, these models can be anything. We can assume any
- * `UserDefinedModel` has been verified by the compiler.
- */
-type UserDefinedModel = any;
-type InstantiatedUserDefinedModel = object;
-/**
- * Given a request, this represents a map of each body / url  param name to
- * its actual value. Unknown, as the a request can be anything.
- */
-type RequestParamMap = Record<string, unknown>;
-/**
- * Meta information on the wrangler env and db bindings
- */
-interface MetaWranglerEnv {
-    envName: string;
-    dbName: string;
-}
-/**
- * Creates model instances given a properly formatted SQL record
- * (either a foreign-key-less model or derived from a Cloesce generated view)
- * @param ctor The type of the model
- * @param records SQL records
- * @param includeTree The include tree to use when parsing the records
- * @returns
- */
-export declare function modelsFromSql<T>(ctor: new () => T, records: Record<string, any>[], includeTree: IncludeTree<T> | null): T[];
-/**
- * Cloesce entry point. Given a request, undergoes routing, validating,
- * hydrating, and method dispatch.
- * @param ast The CIDL AST
- * @param constructorRegistry A mapping of user defined class names to their respective constructor
- * @param instanceRegistry A mapping of a dependency class name to its instantiated object.
- * @param request An incoming request to the workers server
- * @param api_route The url's path to the api, e.g. api/v1/fooapi/
- * @param envMeta Meta information on the wrangler env and D1 databases
- * @returns A Response with an `HttpResult` JSON body.
- */
-export declare function cloesce(request: Request, ast: CloesceAst, constructorRegistry: ModelConstructorRegistry, instanceRegistry: InstanceRegistry, envMeta: MetaWranglerEnv, api_route: string): Promise<Response>;
-/**
- * Matches a request to a method on a model.
- * @param api_route The route from the domain to the actual API, ie https://foo.com/route/to/api => route/to/api/
- * @returns 404 or a `MatchedRoute`
- */
-declare function matchRoute(request: Request, ast: CloesceAst, api_route: string): Either<HttpResult, MatchedRoute>;
-/**
- * Validates the request's body/search params against a ModelMethod
- * @returns 400 or a `RequestParamMap` consisting of each parameters name mapped to its value, and
- * a data source
- */
-declare function validateRequest(request: Request, ast: CloesceAst, model: Model, method: ModelMethod, id: string | null): Promise<Either<HttpResult, [RequestParamMap, string | null]>>;
-/**
- * Queries D1 for a particular model's ID, then transforms the SQL column output into
- * an instance of a model using the provided include tree and metadata as a guide.
- * @returns 404 if no record was found for the provided ID
- * @returns 500 if the D1 database is not synced with Cloesce and yields an error
- * @returns The instantiated model on success
- */
-declare function hydrateModel(ast: CloesceAst, constructorRegistry: ModelConstructorRegistry, d1: D1Database, model: Model, id: string, dataSource: string | null): Promise<Either<HttpResult, object>>;
-/**
- * Calls a method on a model given a list of parameters.
- * @returns 500 on an uncaught client error, 200 with a result body on success
- */
-declare function methodDispatch(instance: InstantiatedUserDefinedModel, instanceRegistry: InstanceRegistry, envMeta: MetaWranglerEnv, method: ModelMethod, params: Record<string, unknown>): Promise<HttpResult<unknown>>;
-/**
- * Actual implementation of sql to model mapping.
- *
- * TODO: If we don't want to write this in every language, would it be possible to create a
- * single WASM binary for this method?
- *
- * @throws generic errors if the metadata is missing some value
- */
-declare function _modelsFromSql(modelName: string, ast: CloesceAst, constructorRegistry: ModelConstructorRegistry, records: Record<string, any>[], includeTree: Record<string, UserDefinedModel> | null): InstantiatedUserDefinedModel[];
-interface MatchedRoute {
-    model: Model;
-    method: ModelMethod;
-    id: string | null;
-}
-/**
- * Each individual state of the `cloesce` function for testing purposes.
- */
-export declare const _cloesceInternal: {
-    matchRoute: typeof matchRoute;
-    validateRequest: typeof validateRequest;
-    hydrateModel: typeof hydrateModel;
-    methodDispatch: typeof methodDispatch;
-    _modelsFromSql: typeof _modelsFromSql;
-};
-export {};
-//# sourceMappingURL=cloesce.d.ts.map

package/dist/cloesce.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cloesce.d.ts","sourceRoot":"","sources":["../src/cloesce.ts"],"names":[],"mappings":"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"}