cloesce 0.0.3-fix.1 → 0.0.3-fix.3

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 "../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,23 +1,45 @@
 {
   "name": "cloesce",
-  "version": "0.0.3-fix.1",
+  "version": "0.0.3-fix.3",
   "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",
+  "license": "Apache-2.0",
+  "scripts": {
+    "test": "vitest",
+    "format:fix": "prettier --write .",
+    "format": "prettier --check .",
+    "typecheck": "tsc --noEmit",
+    "build": "tsc -p tsconfig.json && npm run copy-rs-runtime-wasm && npm run copy-generator-wasm",
+    "copy-rs-runtime-wasm": "cp ../../runtime/target/wasm32-unknown-unknown/release/runtime.wasm ./dist/runtime.wasm",
+    "copy-generator-wasm": "cp ../../generator/target/wasm32-wasip1/release/cli.wasm ./dist/generator.wasm"
+  },
+  "dependencies": {
+    "cmd-ts": "^0.14.1",
+    "ts-morph": "^22.0.0",
+    "wrangler": "^4.34.0"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20250906.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.6.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"
+    "./cli": "./dist/extractor/cli.js"
   },
   "bin": {
-    "cloesce": "./dist/cli.js"
+    "cloesce": "dist/extractor/cli.js"
   },
   "files": [
-    "dist/**",
+    "dist/**/*",
     "README.md",
     "LICENSE"
   ],
@@ -25,26 +47,6 @@
   "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"