cloesce 0.0.3-fix.6 → 0.0.4-unstable.0

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

@@ -1,38 +1,11 @@
-import { left, right, isNullableType, getNavigationPropertyCidlType, } from "../common.js";
-// Requires the rust runtime binary to have been built
-import mod from "../runtime.wasm";
+import { left, right, isNullableType, getNavigationPropertyCidlType, NO_DATA_SOURCE, } from "../common.js";
+import { fromSql, loadOrmWasm } from "./wasm.js";
+import { CrudContext } from "./crud.js";
 /**
- * RAII for wasm memory
+ * Singleton instance containing the cidl, constructor registry, and wasm binary.
+ * These values are guaranteed to never change throughout a workers lifetime.
  */
-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 {
+export class RuntimeContainer {
     ast;
     constructorRegistry;
     wasm;
@@ -43,19 +16,10 @@ class RuntimeContainer {
         this.wasm = wasm;
     }
     static async init(ast, constructorRegistry, wasm) {
-        if (this.instance) {
+        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);
+        const wasmAbi = await loadOrmWasm(ast, wasm);
+        this.instance = new RuntimeContainer(ast, constructorRegistry, wasmAbi);
     }
     static get() {
         return this.instance;
@@ -67,48 +31,82 @@ class RuntimeContainer {
  *
  * @returns A Response with an `HttpResult` JSON body.
  */
-export async function cloesce(request, ast, constructorRegistry, instanceRegistry, envMeta, api_route) {
+export async function cloesce(request, env, ast, app, constructorRegistry, envMeta, apiRoute) {
+    //#region Initialization
+    const ir = new Map();
+    ir.set(envMeta.envName, env);
+    ir.set("Request", request);
     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);
+    const d1 = env[envMeta.dbName]; // TODO: multiple dbs
+    //#endregion
+    //#region Global Middleware
+    for (const m of app.global) {
+        const res = await m(request, env, ir);
+        if (res) {
+            return toResponse(res);
+        }
+    }
+    //#endregion
+    //#region Match the route to a model method
+    const route = matchRoute(request, ast, apiRoute);
     if (!route.ok) {
         return toResponse(route.value);
     }
     const { method, model, id } = route.value;
-    // Validate request body to the model method
+    //#endregion
+    //#region Model Middleware
+    for (const m of app.model.get(model.name) ?? []) {
+        const res = await m(request, env, ir);
+        if (res) {
+            return toResponse(res);
+        }
+    }
+    //#endregion
+    //#region Validate request body to the model method
     const validation = await validateRequest(request, ast, model, method, id);
     if (!validation.ok) {
         return toResponse(validation.value);
     }
     const { params, dataSource } = validation.value;
-    // Instantatiate the model
-    let instance;
-    if (method.is_static) {
-        instance = constructorRegistry[model.name];
+    //#endregion
+    //#region Method Middleware
+    for (const m of app.method.get(model.name)?.get(method.name) ?? []) {
+        const res = await m(request, env, ir);
+        if (res) {
+            return toResponse(res);
+        }
     }
-    else {
-        const hydratedModel = await hydrateModel(constructorRegistry, d1, model, id, dataSource);
+    //#endregion
+    //#region Instantatiate the model
+    const crudCtx = await (async () => {
+        if (method.is_static) {
+            return right(CrudContext.fromCtor(d1, constructorRegistry[model.name]));
+        }
+        const hydratedModel = await hydrateModel(constructorRegistry, d1, model, id, // id must exist after matchRoute
+        dataSource);
         if (!hydratedModel.ok) {
-            return toResponse(hydratedModel.value);
+            return hydratedModel;
         }
-        instance = hydratedModel.value;
+        return right(CrudContext.fromInstance(d1, hydratedModel.value, constructorRegistry[model.name]));
+    })();
+    if (!crudCtx.ok) {
+        return toResponse(crudCtx.value);
     }
-    // Dispatch a method on the model and return the result
-    return toResponse(await methodDispatch(instance, instanceRegistry, envMeta, method, params));
+    //#endregion
+    return toResponse(await methodDispatch(crudCtx.value, ir, method, params));
 }
 /**
  * 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/
+ * @param apiRoute The route from the domain to the actual API, ie https://foo.com/route/to/api => route/to/api/
  * @returns 404 or a `MatchedRoute`
  */
-function matchRoute(request, ast, api_route) {
+function matchRoute(request, ast, apiRoute) {
     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)
+        .slice(apiRoute.length)
         .split("/")
         .filter(Boolean);
     if (routeParts.length < 2) {
@@ -148,14 +146,10 @@ async function validateRequest(request, ast, model, method, id) {
     }
     // Filter out any injected parameters that will not be passed
     // by the query.
-    const requiredParams = method.parameters.filter((p) => !(typeof p.cidl_type === "object" &&
-        p.cidl_type !== null &&
-        "Inject" in p.cidl_type));
-    // Extract data source
-    const url = new URL(request.url);
-    let dataSource = url.searchParams.get("dataSource");
+    const requiredParams = method.parameters.filter((p) => !(typeof p.cidl_type === "object" && "Inject" in p.cidl_type));
     // Extract url or body parameters
-    let params;
+    const url = new URL(request.url);
+    let params = {};
     if (method.http_verb === "GET") {
         params = Object.fromEntries(url.searchParams.entries());
     }
@@ -167,10 +161,6 @@ async function validateRequest(request, ast, model, method, id) {
             return invalidRequest("Could not retrieve JSON body.");
         }
     }
-    // Validate data source if exists
-    if (dataSource && !(dataSource in model.data_sources)) {
-        return invalidRequest(`Unknown data source ${dataSource}`);
-    }
     // Ensure all required params exist
     if (!requiredParams.every((p) => p.name in params)) {
         return invalidRequest(`Missing parameters.`);
@@ -178,10 +168,21 @@ async function validateRequest(request, ast, model, method, id) {
     // Validate all parameters type
     for (const p of requiredParams) {
         const value = params[p.name];
-        if (!validateCidlType(ast, value, p.cidl_type)) {
+        const isPartial = typeof p.cidl_type !== "string" && "Partial" in p.cidl_type;
+        if (!validateCidlType(ast, value, p.cidl_type, isPartial)) {
             return invalidRequest("Invalid parameters.");
         }
     }
+    // Validate data source if exists
+    const dataSourceParam = requiredParams.find((p) => typeof p.cidl_type === "object" && "DataSource" in p.cidl_type);
+    const dataSource = dataSourceParam
+        ? params[dataSourceParam.name]
+        : null;
+    if (dataSource &&
+        dataSource !== NO_DATA_SOURCE &&
+        !(dataSource in model.data_sources)) {
+        return invalidRequest(`Unknown data source ${dataSource}`);
+    }
     return right({ params, dataSource });
 }
 /**
@@ -198,14 +199,14 @@ async function hydrateModel(constructorRegistry, d1, model, id, dataSource) {
     // Error state: If no record is found for the id, return a 404
     const missingRecord = left(errorState(404, "Record not found"));
     const pk = model.primary_key.name;
-    const query = dataSource !== null
+    const query = dataSource !== NO_DATA_SOURCE
         ? `SELECT * FROM "${model.name}.${dataSource}" WHERE "${model.name}.${pk}" = ?`
         : `SELECT * FROM "${model.name}" WHERE "${pk}" = ?`;
     // Query DB
     let records;
     try {
         records = await d1.prepare(query).bind(id).run();
-        if (!records) {
+        if (!records?.results) {
             return missingRecord;
         }
         if (records.error) {
@@ -215,24 +216,32 @@ async function hydrateModel(constructorRegistry, d1, model, id, dataSource) {
     catch (e) {
         return malformedQuery(e);
     }
-    // Get include tree
-    const includeTree = dataSource !== null ? model.data_sources[dataSource].tree : {};
     // Hydrate
-    const models = modelsFromSql(constructorRegistry[model.name], records.results, includeTree);
+    const models = fromSql(constructorRegistry[model.name], records.results, model.data_sources[dataSource]?.tree ?? {}).value;
     return right(models[0]);
 }
 /**
  * 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
  */
-async function methodDispatch(instance, instanceRegistry, envMeta, method, params) {
+async function methodDispatch(crudCtx, instanceRegistry, method, params) {
     // Error state: Client code ran into an uncaught exception.
     const uncaughtException = (e) => errorState(500, `Uncaught exception in method dispatch: ${e instanceof Error ? e.message : String(e)}`);
-    // For now, the only injected dependency is the wrangler env,
-    // so we will assume that is what this is
-    const paramArray = method.parameters.map((p) => params[p.name] == undefined
-        ? instanceRegistry.get(envMeta.envName)
-        : params[p.name]);
+    const paramArray = [];
+    for (const param of method.parameters) {
+        if (params[param.name]) {
+            paramArray.push(params[param.name]);
+            continue;
+        }
+        // Injected type
+        const injected = instanceRegistry.get(param.cidl_type["Inject"]);
+        if (!injected) {
+            // Error state: Injected parameters cannot be found at compile time, only at runtime.
+            // If a injected reference does not exist, throw a 500.
+            return errorState(500, `An injected parameter was missing from the instance registry: ${JSON.stringify(param.cidl_type)}`);
+        }
+        paramArray.push(injected);
+    }
     // Ensure the result is always some HttpResult
     const resultWrapper = (res) => {
         const rt = method.return_type;
@@ -245,17 +254,18 @@ async function methodDispatch(instance, instanceRegistry, envMeta, method, param
         return { ok: true, status: 200, data: res };
     };
     try {
-        return resultWrapper(await instance[method.name](...paramArray));
+        const res = await crudCtx.interceptCrud(method.name)(...paramArray);
+        return resultWrapper(res);
     }
     catch (e) {
         return uncaughtException(e);
     }
 }
-function validateCidlType(ast, value, cidlType) {
+function validateCidlType(ast, value, cidlType, isPartial) {
     if (value === undefined)
-        return false;
+        return isPartial;
     // TODO: consequences of null checking like this? 'null' is passed in
-    // as a string for GET requests...
+    // as a string for GET requests
     const nullable = isNullableType(cidlType);
     if (value == null || value === "null")
         return nullable;
@@ -277,109 +287,57 @@ function validateCidlType(ast, value, cidlType) {
                 return false;
         }
     }
+    // Handle Data Sources
+    if ("DataSource" in cidlType) {
+        return typeof value === "string";
+    }
     // Handle Models
-    if ("Object" in cidlType && ast.models[cidlType.Object]) {
-        const model = ast.models[cidlType.Object];
+    let cidlTypeAccessor = "Partial" in cidlType
+        ? cidlType.Partial
+        : "Object" in cidlType
+            ? cidlType.Object
+            : undefined;
+    if (cidlTypeAccessor && ast.models[cidlTypeAccessor]) {
+        const model = ast.models[cidlTypeAccessor];
         if (!model || typeof value !== "object")
             return false;
         const valueObj = value;
         // Validate attributes
-        if (!model.attributes.every((attr) => validateCidlType(ast, valueObj[attr.value.name], attr.value.cidl_type))) {
+        if (!model.attributes.every((attr) => validateCidlType(ast, valueObj[attr.value.name], attr.value.cidl_type, isPartial))) {
             return false;
         }
         // Validate navigation properties
         return model.navigation_properties.every((nav) => {
             const navValue = valueObj[nav.var_name];
             return (navValue == null ||
-                validateCidlType(ast, navValue, getNavigationPropertyCidlType(nav)));
+                validateCidlType(ast, navValue, getNavigationPropertyCidlType(nav), isPartial));
         });
     }
     // Handle Plain Old Objects
-    if ("Object" in cidlType && ast.poos[cidlType.Object]) {
-        const poo = ast.poos[cidlType.Object];
+    if (cidlTypeAccessor && ast.poos[cidlTypeAccessor]) {
+        const poo = ast.poos[cidlTypeAccessor];
         if (!poo || typeof value !== "object")
             return false;
         const valueObj = value;
         // Validate attributes
-        if (!poo.attributes.every((attr) => validateCidlType(ast, valueObj[attr.name], attr.cidl_type))) {
+        if (!poo.attributes.every((attr) => validateCidlType(ast, valueObj[attr.name], attr.cidl_type, isPartial))) {
             return false;
         }
     }
     if ("Array" in cidlType) {
         const arr = cidlType.Array;
-        return (Array.isArray(value) && value.every((v) => validateCidlType(ast, v, arr)));
+        return (Array.isArray(value) &&
+            value.every((v) => validateCidlType(ast, v, arr, isPartial)));
     }
     if ("HttpResult" in cidlType) {
         if (value === null)
             return cidlType.HttpResult === null;
         if (cidlType.HttpResult === null)
             return false;
-        return validateCidlType(ast, value, cidlType.HttpResult);
+        return validateCidlType(ast, value, cidlType.HttpResult, isPartial);
     }
     return false;
 }
-/**
- * Creates model instances given a properly formatted SQL record, being either:
- *
- *  1. Flat, relationship-less (ex: id, name, location, ...)
- *  2. `DataSource` formatted (ex: Horse.id, Horse.name, Horse.rider, ...)
- *
- * @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.
- */
-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)));
-        }
-        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);
-        }
-    })();
-    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;
-        }
-        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));
-            }
-            // One to one
-            else if (value) {
-                m[navProp.var_name] = instantiateDfs(value, nestedMeta, nestedIncludeTree);
-            }
-        }
-        return m;
-    }
-}
 function errorState(status, message) {
     return { ok: false, status, message };
 }

package/dist/router/wasm.d.ts

@@ -0,0 +1,37 @@
+import { CidlIncludeTree, CloesceAst, Either } from "../common.js";
+import { IncludeTree } from "../ui/backend.js";
+/**
+ * WASM ABI
+ */
+export interface OrmWasmExports {
+    memory: WebAssembly.Memory;
+    get_return_len(): number;
+    get_return_ptr(): number;
+    set_meta_ptr(ptr: number, len: number): number;
+    alloc(len: number): number;
+    dealloc(ptr: number, len: number): void;
+    object_relational_mapping(model_name_ptr: number, model_name_len: number, sql_rows_ptr: number, sql_rows_len: number, include_tree_ptr: number, include_tree_len: number): boolean;
+    upsert_model(model_name_ptr: number, model_name_len: number, new_model_ptr: number, new_model_len: number, include_tree_ptr: number, include_tree_len: number): boolean;
+}
+/**
+ * RAII for wasm memory
+ */
+export declare class WasmResource {
+    private wasm;
+    ptr: number;
+    len: number;
+    constructor(wasm: OrmWasmExports, ptr: number, len: number);
+    free(): void;
+    /**
+     * Copies a value from TS memory to WASM memory. A subsequent `free` is necessary.
+     */
+    static fromString(str: string, wasm: OrmWasmExports): WasmResource;
+}
+export declare function loadOrmWasm(ast: CloesceAst, wasm?: WebAssembly.Instance): Promise<OrmWasmExports>;
+export declare function invokeOrmWasm<T>(fn: (...args: number[]) => boolean, args: WasmResource[], wasm: OrmWasmExports): Either<string, T>;
+/**
+ * Calls `object_relational_mapping` to turn a row of SQL records into
+ * an instantiated object.
+ */
+export declare function fromSql<T extends object>(ctor: new () => T, records: Record<string, any>[], includeTree: IncludeTree<T> | CidlIncludeTree | null): Either<string, T[]>;
+//# sourceMappingURL=wasm.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wasm.d.ts","sourceRoot":"","sources":["../../src/router/wasm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,UAAU,EACV,MAAM,EAIP,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAM/C;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC;IAC3B,cAAc,IAAI,MAAM,CAAC;IACzB,cAAc,IAAI,MAAM,CAAC;IACzB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;IAC/C,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAExC,yBAAyB,CACvB,cAAc,EAAE,MAAM,EACtB,cAAc,EAAE,MAAM,EACtB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,MAAM,EACxB,gBAAgB,EAAE,MAAM,GACvB,OAAO,CAAC;IAEX,YAAY,CACV,cAAc,EAAE,MAAM,EACtB,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,MAAM,EACrB,gBAAgB,EAAE,MAAM,EACxB,gBAAgB,EAAE,MAAM,GACvB,OAAO,CAAC;CACZ;AAED;;GAEG;AACH,qBAAa,YAAY;IAErB,OAAO,CAAC,IAAI;IACL,GAAG,EAAE,MAAM;IACX,GAAG,EAAE,MAAM;gBAFV,IAAI,EAAE,cAAc,EACrB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM;IAEpB,IAAI;IAIJ;;OAEG;IACH,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,GAAG,YAAY;CAQnE;AAED,wBAAsB,WAAW,CAC/B,GAAG,EAAE,UAAU,EACf,IAAI,CAAC,EAAE,WAAW,CAAC,QAAQ,GAC1B,OAAO,CAAC,cAAc,CAAC,CAmBzB;AAED,wBAAgB,aAAa,CAAC,CAAC,EAC7B,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,MAAM,EAAE,KAAK,OAAO,EAClC,IAAI,EAAE,YAAY,EAAE,EACpB,IAAI,EAAE,cAAc,GACnB,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAkBnB;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,EACtC,IAAI,EAAE,UAAU,CAAC,EACjB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,EAC9B,WAAW,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,eAAe,GAAG,IAAI,GACnD,MAAM,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,CA0DrB"}

package/dist/router/wasm.js

@@ -0,0 +1,98 @@
+import { left, right, } from "../common.js";
+import { RuntimeContainer } from "./router.js";
+// Requires the ORM binary to have been built
+import mod from "../orm.wasm";
+/**
+ * RAII for wasm memory
+ */
+export 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);
+    }
+}
+export async function loadOrmWasm(ast, wasm) {
+    // 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.
+    return wasmInstance.exports;
+}
+export function invokeOrmWasm(fn, args, wasm) {
+    let resPtr;
+    let resLen;
+    try {
+        const failed = fn(...args.flatMap((a) => [a.ptr, a.len]));
+        resPtr = wasm.get_return_ptr();
+        resLen = wasm.get_return_len();
+        const result = new TextDecoder().decode(new Uint8Array(wasm.memory.buffer, resPtr, resLen));
+        return failed ? left(result) : right(result);
+    }
+    finally {
+        args.forEach((a) => a.free());
+        if (resPtr && resLen)
+            wasm.dealloc(resPtr, resLen);
+    }
+}
+/**
+ * Calls `object_relational_mapping` to turn a row of SQL records into
+ * an instantiated object.
+ */
+export function fromSql(ctor, records, includeTree) {
+    const { ast, constructorRegistry, wasm } = RuntimeContainer.get();
+    const args = [
+        WasmResource.fromString(ctor.name, wasm),
+        WasmResource.fromString(JSON.stringify(records), wasm),
+        WasmResource.fromString(JSON.stringify(includeTree), wasm),
+    ];
+    const jsonResults = invokeOrmWasm(wasm.object_relational_mapping, args, wasm);
+    if (!jsonResults.ok)
+        return jsonResults;
+    const parsed = JSON.parse(jsonResults.value);
+    return right(parsed.map((obj) => instantiateDepthFirst(obj, ast.models[ctor.name], includeTree)));
+    function instantiateDepthFirst(m, meta, includeTree) {
+        m = Object.assign(new constructorRegistry[meta.name](), m);
+        if (!includeTree) {
+            return m;
+        }
+        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) => instantiateDepthFirst(child, nestedMeta, nestedIncludeTree));
+            }
+            // One to one
+            else if (value) {
+                m[navProp.var_name] = instantiateDepthFirst(value, nestedMeta, nestedIncludeTree);
+            }
+        }
+        return m;
+    }
+}