cloesce 0.0.3 → 0.0.4-unstable.0

package/dist/router/router.d.ts

@@ -0,0 +1,77 @@
+import { HttpResult, Either, ModelMethod, CloesceAst, Model, CloesceApp, InstanceRegistry } from "../common.js";
+import { OrmWasmExports } from "./wasm.js";
+import { CrudContext } from "./crud.js";
+/**
+ * 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 () => any>;
+/**
+ * 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;
+}
+/**
+ * Singleton instance containing the cidl, constructor registry, and wasm binary.
+ * These values are guaranteed to never change throughout a workers lifetime.
+ */
+export declare class RuntimeContainer {
+    readonly ast: CloesceAst;
+    readonly constructorRegistry: ModelConstructorRegistry;
+    readonly wasm: OrmWasmExports;
+    private static instance;
+    private constructor();
+    static init(ast: CloesceAst, constructorRegistry: ModelConstructorRegistry, wasm?: WebAssembly.Instance): Promise<void>;
+    static get(): RuntimeContainer;
+}
+/**
+ * Runtime entry point. Given a request, undergoes: routing, validating,
+ * hydrating, and method dispatch.
+ *
+ * @returns A Response with an `HttpResult` JSON body.
+ */
+export declare function cloesce(request: Request, env: any, ast: CloesceAst, app: CloesceApp, constructorRegistry: ModelConstructorRegistry, envMeta: MetaWranglerEnv, apiRoute: string): Promise<Response>;
+/**
+ * Matches a request to a method on a model.
+ * @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`
+ */
+declare function matchRoute(request: Request, ast: CloesceAst, apiRoute: string): Either<HttpResult, {
+    model: Model;
+    method: ModelMethod;
+    id: string | null;
+}>;
+/**
+ * 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, {
+    params: RequestParamMap;
+    dataSource: string | null;
+}>>;
+/**
+ * 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(crudCtx: CrudContext, instanceRegistry: InstanceRegistry, method: ModelMethod, params: Record<string, unknown>): Promise<HttpResult<unknown>>;
+/**
+ * For testing purposes
+ */
+export declare const _cloesceInternal: {
+    matchRoute: typeof matchRoute;
+    validateRequest: typeof validateRequest;
+    methodDispatch: typeof methodDispatch;
+    RuntimeContainer: typeof RuntimeContainer;
+};
+export {};
+//# sourceMappingURL=router.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../../src/router/router.ts"],"names":[],"mappings":"AACA,OAAO,EACL,UAAU,EACV,MAAM,EACN,WAAW,EAIX,UAAU,EAEV,KAAK,EAGL,UAAU,EACV,gBAAgB,EACjB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,cAAc,EAAwB,MAAM,WAAW,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAExC;;;;;GAKG;AACH,KAAK,wBAAwB,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,CAAC,CAAC;AAE9D;;;GAGG;AACH,KAAK,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE/C;;GAEG;AACH,UAAU,eAAe;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,qBAAa,gBAAgB;aAGT,GAAG,EAAE,UAAU;aACf,mBAAmB,EAAE,wBAAwB;aAC7C,IAAI,EAAE,cAAc;IAJtC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAA+B;IACtD,OAAO;WAMM,IAAI,CACf,GAAG,EAAE,UAAU,EACf,mBAAmB,EAAE,wBAAwB,EAC7C,IAAI,CAAC,EAAE,WAAW,CAAC,QAAQ;IAO7B,MAAM,CAAC,GAAG,IAAI,gBAAgB;CAG/B;AAED;;;;;GAKG;AACH,wBAAsB,OAAO,CAC3B,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,UAAU,EACf,GAAG,EAAE,UAAU,EACf,mBAAmB,EAAE,wBAAwB,EAC7C,OAAO,EAAE,eAAe,EACxB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,QAAQ,CAAC,CAqFnB;AAED;;;;GAIG;AACH,iBAAS,UAAU,CACjB,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,UAAU,EACf,QAAQ,EAAE,MAAM,GACf,MAAM,CACP,UAAU,EACV;IACE,KAAK,EAAE,KAAK,CAAC;IACb,MAAM,EAAE,WAAW,CAAC;IACpB,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;CACnB,CACF,CAyCA;AAED;;;;GAIG;AACH,iBAAe,eAAe,CAC5B,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,UAAU,EACf,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,WAAW,EACnB,EAAE,EAAE,MAAM,GAAG,IAAI,GAChB,OAAO,CACR,MAAM,CAAC,UAAU,EAAE;IAAE,MAAM,EAAE,eAAe,CAAC;IAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAC3E,CA4DA;AA2DD;;;GAGG;AACH,iBAAe,cAAc,CAC3B,OAAO,EAAE,WAAW,EACpB,gBAAgB,EAAE,gBAAgB,EAClC,MAAM,EAAE,WAAW,EACnB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAkD9B;AA+HD;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;CAK5B,CAAC"}

package/dist/router/router.js

@@ -0,0 +1,358 @@
+import { left, right, isNullableType, getNavigationPropertyCidlType, NO_DATA_SOURCE, } from "../common.js";
+import { fromSql, loadOrmWasm } from "./wasm.js";
+import { CrudContext } from "./crud.js";
+/**
+ * Singleton instance containing the cidl, constructor registry, and wasm binary.
+ * These values are guaranteed to never change throughout a workers lifetime.
+ */
+export class RuntimeContainer {
+    ast;
+    constructorRegistry;
+    wasm;
+    static instance;
+    constructor(ast, constructorRegistry, wasm) {
+        this.ast = ast;
+        this.constructorRegistry = constructorRegistry;
+        this.wasm = wasm;
+    }
+    static async init(ast, constructorRegistry, wasm) {
+        if (this.instance)
+            return;
+        const wasmAbi = await loadOrmWasm(ast, wasm);
+        this.instance = new RuntimeContainer(ast, constructorRegistry, wasmAbi);
+    }
+    static get() {
+        return this.instance;
+    }
+}
+/**
+ * Runtime entry point. Given a request, undergoes: routing, validating,
+ * hydrating, and method dispatch.
+ *
+ * @returns A Response with an `HttpResult` JSON body.
+ */
+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 = 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;
+    //#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;
+    //#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);
+        }
+    }
+    //#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 hydratedModel;
+        }
+        return right(CrudContext.fromInstance(d1, hydratedModel.value, constructorRegistry[model.name]));
+    })();
+    if (!crudCtx.ok) {
+        return toResponse(crudCtx.value);
+    }
+    //#endregion
+    return toResponse(await methodDispatch(crudCtx.value, ir, method, params));
+}
+/**
+ * Matches a request to a method on a model.
+ * @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, 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(apiRoute.length)
+        .split("/")
+        .filter(Boolean);
+    if (routeParts.length < 2) {
+        return notFound("Expected /model/method or /model/:id/method");
+    }
+    // Attempt to extract from routeParts
+    const modelName = routeParts[0];
+    const methodName = routeParts[routeParts.length - 1];
+    const id = routeParts.length === 3 ? routeParts[1] : null;
+    const model = ast.models[modelName];
+    if (!model) {
+        return notFound(`Unknown model ${modelName}`);
+    }
+    const method = model.methods[methodName];
+    if (!method) {
+        return notFound(`Unknown method ${modelName}.${methodName}`);
+    }
+    if (request.method !== method.http_verb) {
+        return notFound("Unmatched HTTP method");
+    }
+    return right({
+        model,
+        method,
+        id,
+    });
+}
+/**
+ * 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
+ */
+async function validateRequest(request, ast, model, method, id) {
+    // Error state: any missing parameter, body, or malformed input will exit with 400.
+    const invalidRequest = (e) => left(errorState(400, `Invalid Request Body: ${e}`));
+    if (!method.is_static && id == null) {
+        return invalidRequest("Id's are required for instantiated methods.");
+    }
+    // Filter out any injected parameters that will not be passed
+    // by the query.
+    const requiredParams = method.parameters.filter((p) => !(typeof p.cidl_type === "object" && "Inject" in p.cidl_type));
+    // Extract url or body parameters
+    const url = new URL(request.url);
+    let params = {};
+    if (method.http_verb === "GET") {
+        params = Object.fromEntries(url.searchParams.entries());
+    }
+    else {
+        try {
+            params = await request.json();
+        }
+        catch {
+            return invalidRequest("Could not retrieve JSON body.");
+        }
+    }
+    // Ensure all required params exist
+    if (!requiredParams.every((p) => p.name in params)) {
+        return invalidRequest(`Missing parameters.`);
+    }
+    // Validate all parameters type
+    for (const p of requiredParams) {
+        const value = params[p.name];
+        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 });
+}
+/**
+ * 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
+ */
+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)}`));
+    // 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 !== 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?.results) {
+            return missingRecord;
+        }
+        if (records.error) {
+            return malformedQuery(records.error);
+        }
+    }
+    catch (e) {
+        return malformedQuery(e);
+    }
+    // Hydrate
+    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(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)}`);
+    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;
+        if (rt === null) {
+            return { ok: true, status: 200 };
+        }
+        if (typeof rt === "object" && rt !== null && "HttpResult" in rt) {
+            return res;
+        }
+        return { ok: true, status: 200, data: res };
+    };
+    try {
+        const res = await crudCtx.interceptCrud(method.name)(...paramArray);
+        return resultWrapper(res);
+    }
+    catch (e) {
+        return uncaughtException(e);
+    }
+}
+function validateCidlType(ast, value, cidlType, isPartial) {
+    if (value === undefined)
+        return isPartial;
+    // TODO: consequences of null checking like this? 'null' is passed in
+    // as a string for GET requests
+    const nullable = isNullableType(cidlType);
+    if (value == null || value === "null")
+        return nullable;
+    if (nullable) {
+        cidlType = cidlType.Nullable; // Unwrap the nullable type
+    }
+    // Handle primitive string types with switch
+    if (typeof cidlType === "string") {
+        switch (cidlType) {
+            case "Integer":
+                return Number.isInteger(Number(value));
+            case "Real":
+                return !Number.isNaN(Number(value));
+            case "Text":
+                return typeof value === "string";
+            case "Blob":
+                return value instanceof Blob || value instanceof ArrayBuffer;
+            default:
+                return false;
+        }
+    }
+    // Handle Data Sources
+    if ("DataSource" in cidlType) {
+        return typeof value === "string";
+    }
+    // Handle Models
+    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, 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), isPartial));
+        });
+    }
+    // Handle Plain Old Objects
+    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, isPartial))) {
+            return false;
+        }
+    }
+    if ("Array" in cidlType) {
+        const arr = cidlType.Array;
+        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, isPartial);
+    }
+    return false;
+}
+function errorState(status, message) {
+    return { ok: false, status, message };
+}
+function toResponse(r) {
+    return new Response(JSON.stringify(r), {
+        status: r.status,
+        headers: { "Content-Type": "application/json" },
+    });
+}
+/**
+ * For testing purposes
+ */
+export const _cloesceInternal = {
+    matchRoute,
+    validateRequest,
+    methodDispatch,
+    RuntimeContainer,
+};

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;
+    }
+}