cloesce 0.0.5-unstable.0 → 0.0.5-unstable.10

package/dist/router/router.js

@@ -1,263 +1,223 @@
-import { mapSql, loadOrmWasm } from "./wasm.js";
+import { loadOrmWasm } from "./wasm.js";
 import { proxyCrud } from "./crud.js";
-import { HttpResult, Orm } from "../ui/backend.js";
-import { Either } from "../ui/common.js";
-import { NO_DATA_SOURCE, MediaType } from "../ast.js";
+import { NO_DATA_SOURCE, MediaType, } from "../ast.js";
 import { RuntimeValidator } from "./validator.js";
+import { Either, InternalError } from "../common.js";
+import { Orm, HttpResult } from "../ui/backend.js";
 /**
- * Singleton instance containing the cidl, constructor registry, and wasm binary.
+ * 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;
-  }
-  /**
-   * Disposes the singleton instance. For testing purposes only.
-   */
-  static dispose() {
-    this.instance = undefined;
-  }
+    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;
+    }
+    /**
+     * Disposes the singleton instance. For testing purposes only.
+     */
+    static dispose() {
+        this.instance = undefined;
+    }
 }
 /**
  * Expected states in which the router may exit.
  */
 export var RouterError;
 (function (RouterError) {
-  RouterError[(RouterError["UnknownPrefix"] = 0)] = "UnknownPrefix";
-  RouterError[(RouterError["UnknownRoute"] = 1)] = "UnknownRoute";
-  RouterError[(RouterError["UnmatchedHttpVerb"] = 2)] = "UnmatchedHttpVerb";
-  RouterError[(RouterError["InstantiatedMethodMissingId"] = 3)] =
-    "InstantiatedMethodMissingId";
-  RouterError[(RouterError["RequestMissingBody"] = 4)] = "RequestMissingBody";
-  RouterError[(RouterError["RequestBodyMissingParameters"] = 5)] =
-    "RequestBodyMissingParameters";
-  RouterError[(RouterError["RequestBodyInvalidParameter"] = 6)] =
-    "RequestBodyInvalidParameter";
-  RouterError[(RouterError["InstantiatedMethodMissingDataSource"] = 7)] =
-    "InstantiatedMethodMissingDataSource";
-  RouterError[(RouterError["MissingDependency"] = 8)] = "MissingDependency";
-  RouterError[(RouterError["InvalidDatabaseQuery"] = 9)] =
-    "InvalidDatabaseQuery";
-  RouterError[(RouterError["ModelNotFound"] = 10)] = "ModelNotFound";
-  RouterError[(RouterError["UncaughtException"] = 11)] = "UncaughtException";
+    RouterError[RouterError["UnknownPrefix"] = 0] = "UnknownPrefix";
+    RouterError[RouterError["UnknownRoute"] = 1] = "UnknownRoute";
+    RouterError[RouterError["UnmatchedHttpVerb"] = 2] = "UnmatchedHttpVerb";
+    RouterError[RouterError["InstantiatedMethodMissingPrimaryKey"] = 3] = "InstantiatedMethodMissingPrimaryKey";
+    RouterError[RouterError["InstantiatedMethodMissingKeyParam"] = 4] = "InstantiatedMethodMissingKeyParam";
+    RouterError[RouterError["RequestMissingBody"] = 5] = "RequestMissingBody";
+    RouterError[RouterError["RequestBodyMissingParameters"] = 6] = "RequestBodyMissingParameters";
+    RouterError[RouterError["RequestBodyInvalidParameter"] = 7] = "RequestBodyInvalidParameter";
+    RouterError[RouterError["InstantiatedMethodMissingDataSource"] = 8] = "InstantiatedMethodMissingDataSource";
+    RouterError[RouterError["MissingDependency"] = 9] = "MissingDependency";
+    RouterError[RouterError["InvalidDatabaseQuery"] = 10] = "InvalidDatabaseQuery";
+    RouterError[RouterError["ModelNotFound"] = 11] = "ModelNotFound";
+    RouterError[RouterError["UncaughtException"] = 12] = "UncaughtException";
 })(RouterError || (RouterError = {}));
 export class CloesceApp {
-  routePrefix = "api";
-  globalMiddleware = [];
-  /**
-   * Registers global middleware which runs before any route matching.
-   *
-   * TODO: Middleware may violate the API contract and return unexpected types
-   *
-   * @param m - The middleware function to register.
-   */
-  onRequest(m) {
-    this.globalMiddleware.push(m);
-  }
-  resultMiddleware = [];
-  /**
-   * Registers middleware which runs after the response is generated, but before
-   * it is returned to the client.
-   *
-   * Optionally, return a new HttpResult to short-circuit the response.
-   *
-   * Errors thrown in response middleware are caught and returned as a 500 response.
-   *
-   * TODO: Middleware may violate the API contract and return unexpected types
-   *
-   * @param m - The middleware function to register.
-   */
-  onResult(m) {
-    this.resultMiddleware.push(m);
-  }
-  namespaceMiddleware = new Map();
-  /**
-   * Registers middleware for a specific namespace (being, a model or service)
-   *
-   * Runs before request validation and method middleware.
-   *
-   * TODO: Middleware may violate the API contract and return unexpected types
-   *
-   * @typeParam T - The namespace type
-   * @param ctor - The namespace's constructor (used to derive its name).
-   * @param m - The middleware function to register.
-   */
-  onNamespace(ctor, m) {
-    if (this.namespaceMiddleware.has(ctor.name)) {
-      this.namespaceMiddleware.get(ctor.name).push(m);
-    } else {
-      this.namespaceMiddleware.set(ctor.name, [m]);
-    }
-  }
-  methodMiddleware = new Map();
-  /**
-   * Registers middleware for a specific method on a namespace
-   *
-   * Runs after namespace middleware and request validation.
-   *
-   * TODO: Middleware may violate the API contract and return unexpected types
-   *
-   * @typeParam T - The namespace type
-   * @param ctor - The namespace constructor
-   * @param method - The method name on the namespace.
-   * @param m - The middleware function to register.
-   */
-  onMethod(ctor, method, m) {
-    if (!this.methodMiddleware.has(ctor.name)) {
-      this.methodMiddleware.set(ctor.name, new Map());
-    }
-    const methods = this.methodMiddleware.get(ctor.name);
-    if (!methods.has(method)) {
-      methods.set(method, []);
+    routePrefix = "api";
+    static async init(ast, ctorReg) {
+        await RuntimeContainer.init(ast, ctorReg);
+        return new CloesceApp();
     }
-    methods.get(method).push(m);
-  }
-  async router(request, env, ast, ctorReg, di) {
-    // Global middleware
-    for (const m of this.globalMiddleware) {
-      const res = await m(di);
-      if (res) {
-        return res;
-      }
+    globalMiddleware = [];
+    /**
+     * Registers global middleware that runs before all requests.
+     *
+     * Runs before namespace middleware, request validation, and method middleware.
+     *
+     * TODO: Middleware may violate the API contract and return unexpected types
+     *
+     * @param m - The middleware function to register.
+     */
+    onRun(m) {
+        this.globalMiddleware.push(m);
     }
-    // Route match
-    const routeRes = matchRoute(request, ast, this.routePrefix);
-    if (routeRes.isLeft()) {
-      return routeRes.value;
-    }
-    const route = routeRes.unwrap();
-    // Model middleware
-    for (const m of this.namespaceMiddleware.get(route.namespace) ?? []) {
-      const res = await m(di);
-      if (res) {
-        return res;
-      }
-    }
-    // Request validation
-    const validation = await validateRequest(request, ast, ctorReg, route);
-    if (validation.isLeft()) {
-      return validation.value;
-    }
-    const { params, dataSource } = validation.unwrap();
-    // Method middleware
-    for (const m of this.methodMiddleware
-      .get(route.namespace)
-      ?.get(route.method.name) ?? []) {
-      const res = await m(di);
-      if (res) {
-        return res;
-      }
-    }
-    // Hydration
-    const hydrated = await (async () => {
-      if (route.kind == "model") {
-        // TODO: Support multiple D1 bindings
-        // It's been verified by the compiler that wrangler_env exists if a D1 model is present
-        const d1 = env[ast.wrangler_env.db_binding];
-        // Proxy CRUD
-        if (route.method.is_static) {
-          return Either.right(
-            proxyCrud(ctorReg[route.namespace], ctorReg[route.namespace], d1),
-          );
+    namespaceMiddleware = new Map();
+    /**
+     * Registers middleware for a specific namespace (model or service)
+     *
+     * Runs before request validation and method middleware.
+     *
+     * TODO: Middleware may violate the API contract and return unexpected types
+     *
+     * @typeParam T - The namespace type
+     * @param ctor - The namespace's constructor (used to derive its name).
+     * @param m - The middleware function to register.
+     */
+    onNamespace(ctor, m) {
+        const existing = this.namespaceMiddleware.get(ctor.name);
+        if (existing) {
+            existing.push(m);
+            return;
         }
-        return await hydrateModelD1(
-          ctorReg,
-          d1,
-          route.model,
-          route.id,
-          dataSource,
-        );
-      }
-      // Services
-      if (route.method.is_static) {
-        return Either.right(ctorReg[route.namespace]);
-      }
-      return Either.right(di.get(route.namespace));
-    })();
-    if (hydrated.isLeft()) {
-      return hydrated.value;
+        this.namespaceMiddleware.set(ctor.name, [m]);
     }
-    // Method dispatch
-    return await methodDispatch(hydrated.unwrap(), di, route, params);
-  }
-  /**
-   * Runs the Cloesce app. Intended to be called from the generated workers code.
-   */
-  async run(request, env, ast, ctorReg) {
-    await RuntimeContainer.init(ast, ctorReg);
-    const di = new Map();
-    if (ast.wrangler_env) {
-      di.set(ast.wrangler_env.name, env);
+    methodMiddleware = new Map();
+    /**
+     * Registers middleware for a specific method on a namespace
+     *
+     * Runs after namespace middleware and request validation.
+     *
+     * TODO: Middleware may violate the API contract and return unexpected types
+     *
+     * @typeParam T - The namespace type
+     * @param ctor - The namespace constructor
+     * @param method - The method name on the namespace.
+     * @param m - The middleware function to register.
+     */
+    onMethod(ctor, method, m) {
+        let classMap = this.methodMiddleware.get(ctor.name);
+        if (!classMap) {
+            classMap = new Map();
+            this.methodMiddleware.set(ctor.name, classMap);
+        }
+        let methodArray = classMap.get(method);
+        if (!methodArray) {
+            methodArray = [];
+            classMap.set(method, methodArray);
+        }
+        methodArray.push(m);
     }
-    di.set("Request", request);
-    // Note: Services are in topological order
-    for (const name in ast.services) {
-      const service = ast.services[name];
-      for (const attr of service.attributes) {
-        const injected = di.get(attr.injected);
-        if (!injected) {
-          return exit(
-            500,
-            RouterError.MissingDependency,
-            `An injected parameter was missing from the instance registry: ${JSON.stringify(attr.injected)}`,
-          )
-            .unwrapLeft()
-            .toResponse();
+    async router(request, env, ast, ctorReg, di) {
+        // Global middleware
+        for (const m of this.globalMiddleware) {
+            const res = await m(di);
+            if (res) {
+                return res;
+            }
+        }
+        // Route match
+        const routeRes = matchRoute(request, ast, this.routePrefix);
+        if (routeRes.isLeft()) {
+            return routeRes.value;
+        }
+        const route = routeRes.unwrap();
+        // Namespace middleware
+        for (const m of this.namespaceMiddleware.get(route.namespace) ?? []) {
+            const res = await m(di);
+            if (res) {
+                return res;
+            }
+        }
+        // Request validation
+        const validation = await validateRequest(request, ast, ctorReg, route);
+        if (validation.isLeft()) {
+            return validation.value;
+        }
+        const { params, dataSource } = validation.unwrap();
+        // Method middleware
+        for (const m of this.methodMiddleware
+            .get(route.namespace)
+            ?.get(route.method.name) ?? []) {
+            const res = await m(di);
+            if (res) {
+                return res;
+            }
         }
-        service[attr.var_name] = injected;
-      }
-      // Inject services
-      di.set(name, Object.assign(new ctorReg[name](), service));
+        // Hydration
+        const hydrated = await hydrate(di, ctorReg, route, dataSource, env);
+        if (hydrated.isLeft()) {
+            return hydrated.value;
+        }
+        // Method dispatch
+        return await methodDispatch(hydrated.unwrap(), di, route, params);
     }
-    try {
-      let httpResult = await this.router(request, env, ast, ctorReg, di);
-      // Response middleware
-      for (const m of this.resultMiddleware) {
-        const res = await m(di, httpResult);
-        if (res) {
-          return res.toResponse();
+    /**
+     * Runs the Cloesce app. Intended to be called from the generated workers code.
+     */
+    async run(request, env) {
+        const { ast, constructorRegistry: ctorReg } = RuntimeContainer.get();
+        const di = new Map();
+        if (ast.wrangler_env) {
+            di.set(ast.wrangler_env.name, env);
+        }
+        di.set("Request", request);
+        // Note: Services are in topological order
+        for (const name in ast.services) {
+            const serviceMeta = ast.services[name];
+            const service = {};
+            for (const attr of serviceMeta.attributes) {
+                const injected = di.get(attr.inject_reference);
+                if (!injected) {
+                    return exit(500, RouterError.MissingDependency, `An injected parameter was missing from the instance registry: ${JSON.stringify(attr.inject_reference)}`)
+                        .unwrapLeft()
+                        .toResponse();
+                }
+                service[attr.var_name] = injected;
+            }
+            // Inject services
+            di.set(name, Object.assign(new ctorReg[name](), service));
+        }
+        try {
+            const httpResult = await this.router(request, env, ast, ctorReg, di);
+            // Log any 500 errors
+            if (httpResult.status === 500) {
+                console.error("A caught error occurred in the Cloesce Router: ", httpResult.message);
+            }
+            return httpResult.toResponse();
+        }
+        catch (e) {
+            let debug;
+            if (e instanceof Error) {
+                debug = {
+                    name: e.name,
+                    message: e.message,
+                    stack: e.stack,
+                    cause: e.cause,
+                };
+            }
+            else {
+                debug = {
+                    name: "NonErrorThrown",
+                    message: typeof e === "string" ? e : JSON.stringify(e),
+                    stack: undefined,
+                };
+            }
+            const res = HttpResult.fail(500, JSON.stringify(debug));
+            console.error("An uncaught error occurred in the Cloesce Router: ", debug);
+            return res.toResponse();
         }
-      }
-      return httpResult.toResponse();
-    } catch (e) {
-      let debug;
-      if (e instanceof Error) {
-        debug = {
-          name: e.name,
-          message: e.message,
-          stack: e.stack,
-          cause: e.cause,
-        };
-      } else {
-        debug = {
-          name: "NonErrorThrown",
-          message: typeof e === "string" ? e : JSON.stringify(e),
-          stack: undefined,
-        };
-      }
-      const res = HttpResult.fail(500, JSON.stringify(debug));
-      console.error(
-        "An uncaught error occurred in the Cloesce Router: ",
-        debug,
-      );
-      return res.toResponse();
     }
-  }
 }
 /**
  * Matches a request to an ApiInvocation
@@ -265,54 +225,66 @@ export class CloesceApp {
  * @returns 404 or a matched route.
  */
 function matchRoute(request, ast, routePrefix) {
-  const url = new URL(request.url);
-  const parts = url.pathname.split("/").filter(Boolean);
-  const prefix = routePrefix.split("/").filter(Boolean);
-  // Error state: We expect an exact request format, and expect that the model
-  // and are apart of the CIDL
-  const notFound = (c) => exit(404, c, "Unknown route");
-  for (const p of prefix) {
-    if (parts.shift() !== p) return notFound(RouterError.UnknownPrefix);
-  }
-  if (parts.length < 2) {
-    return notFound(RouterError.UnknownPrefix);
-  }
-  // Extract pattern
-  const namespace = parts[0];
-  const methodName = parts[parts.length - 1];
-  const id = parts.length === 3 ? parts[1] : null;
-  const model = ast.models[namespace];
-  if (model) {
-    const method = model.methods[methodName];
-    if (!method) return notFound(RouterError.UnknownRoute);
-    if (request.method !== method.http_verb) {
-      return notFound(RouterError.UnmatchedHttpVerb);
+    const url = new URL(request.url);
+    const parts = url.pathname.split("/").filter(Boolean);
+    const prefix = routePrefix.split("/").filter(Boolean);
+    // Error state: We expect an exact request format, and expect that the model
+    // and are apart of the CIDL
+    const notFound = (c) => exit(404, c, "Unknown route");
+    for (const p of prefix) {
+        if (parts.shift() !== p)
+            return notFound(RouterError.UnknownPrefix);
     }
-    return Either.right({
-      kind: "model",
-      namespace,
-      method,
-      model,
-      id,
-    });
-  }
-  const service = ast.services[namespace];
-  if (service) {
-    const method = service.methods[methodName];
-    // Services do not have IDs.
-    if (!method || id) return notFound(RouterError.UnknownRoute);
-    if (request.method !== method.http_verb) {
-      return notFound(RouterError.UnmatchedHttpVerb);
+    if (parts.length < 2) {
+        return notFound(RouterError.UnknownPrefix);
     }
-    return Either.right({
-      kind: "service",
-      namespace,
-      method,
-      service,
-      id: null,
-    });
-  }
-  return notFound(RouterError.UnknownRoute);
+    // Route format: /{namespace}/...{id}/{method}
+    const namespace = parts[0];
+    const methodName = parts[parts.length - 1];
+    const id = parts.length > 2
+        ? parts.slice(1, parts.length - 1).map(decodeURIComponent)
+        : [];
+    const model = ast.models[namespace];
+    if (model) {
+        const method = model.methods[methodName];
+        if (!method)
+            return notFound(RouterError.UnknownRoute);
+        if (request.method !== method.http_verb) {
+            return notFound(RouterError.UnmatchedHttpVerb);
+        }
+        const hasPrimaryKey = model.primary_key !== null;
+        const offset = hasPrimaryKey ? 1 : 0;
+        const primaryKey = hasPrimaryKey ? (id.at(0) ?? null) : null;
+        const keyParams = Object.fromEntries(id
+            .slice(offset)
+            .map((v, i) => [model.key_params[i], decodeURIComponent(v)]));
+        return Either.right({
+            kind: "model",
+            namespace,
+            method,
+            model,
+            primaryKey,
+            keyParams,
+        });
+    }
+    const service = ast.services[namespace];
+    if (service) {
+        const method = service.methods[methodName];
+        if (!method || id.length > 0)
+            return notFound(RouterError.UnknownRoute);
+        if (request.method !== method.http_verb) {
+            return notFound(RouterError.UnmatchedHttpVerb);
+        }
+        return Either.right({
+            kind: "service",
+            namespace,
+            method,
+            service,
+            primaryKey: null,
+            keyParams: {},
+        });
+    }
+    return notFound(RouterError.UnknownRoute);
 }
 /**
  * Validates the request's body/search params against a ModelMethod
@@ -320,180 +292,165 @@ function matchRoute(request, ast, routePrefix) {
  * a data source
  */
 async function validateRequest(request, ast, ctorReg, route) {
-  // Error state: any missing parameter, body, or malformed input will exit with 400.
-  const invalidRequest = (c) => exit(400, c, "Invalid Request Body");
-  // Models must have an ID on instantiated methods.
-  if (route.kind === "model" && !route.method.is_static && route.id == null) {
-    return invalidRequest(RouterError.InstantiatedMethodMissingId);
-  }
-  // Filter out injected parameters
-  const requiredParams = route.method.parameters.filter(
-    (p) => !(typeof p.cidl_type === "object" && "Inject" in p.cidl_type),
-  );
-  const url = new URL(request.url);
-  let params = Object.fromEntries(url.searchParams.entries());
-  // Extract all method parameters from the body
-  if (route.method.http_verb !== "GET") {
-    try {
-      switch (route.method.parameters_media) {
-        case MediaType.Json: {
-          const body = await request.json();
-          params = { ...params, ...body };
-          break;
+    // Error state: any missing parameter, body, or malformed input will exit with 400.
+    const invalidRequest = (c) => exit(400, c, "Invalid Request Body");
+    // Validate instantiated model ids
+    if (route.kind === "model" && !route.method.is_static) {
+        const model = route.model;
+        if (model.primary_key !== null && route.primaryKey === null) {
+            return invalidRequest(RouterError.InstantiatedMethodMissingPrimaryKey);
         }
-        case MediaType.Octet: {
-          // Octet streams are verified by the Cloesce compiler to have
-          // one Stream type
-          const streamParam = requiredParams.find(
-            (p) => typeof p.cidl_type === "string" && p.cidl_type === "Stream",
-          );
-          params[streamParam.name] = request.body;
-          break;
+        if (model.key_params.length !== Object.keys(route.keyParams).length) {
+            return invalidRequest(RouterError.InstantiatedMethodMissingKeyParam);
         }
-        default: {
-          throw new Error("not implemented");
+        for (const keyParam of model.key_params) {
+            if (!(keyParam in route.keyParams)) {
+                return invalidRequest(RouterError.InstantiatedMethodMissingKeyParam);
+            }
         }
-      }
-    } catch {
-      return invalidRequest(RouterError.RequestMissingBody);
     }
-  }
-  if (!requiredParams.every((p) => p.name in params)) {
-    return invalidRequest(RouterError.RequestBodyMissingParameters);
-  }
-  // Validate all parameters type
-  // Octet streams can be passed as is
-  if (route.method.parameters_media !== MediaType.Octet) {
-    for (const p of requiredParams) {
-      const res = RuntimeValidator.validate(
-        params[p.name],
-        p.cidl_type,
-        ast,
-        ctorReg,
-      );
-      if (res.isLeft()) {
-        return invalidRequest(RouterError.RequestBodyInvalidParameter);
-      }
-      params[p.name] = res.unwrap();
+    // Filter out injected parameters
+    const requiredParams = route.method.parameters.filter((p) => !(typeof p.cidl_type === "object" && "Inject" in p.cidl_type));
+    const url = new URL(request.url);
+    let params = Object.fromEntries(url.searchParams.entries());
+    // Extract all method parameters from the body
+    if (route.method.http_verb !== "GET") {
+        try {
+            switch (route.method.parameters_media) {
+                case MediaType.Json: {
+                    const body = await request.json();
+                    params = { ...params, ...body };
+                    break;
+                }
+                case MediaType.Octet: {
+                    // Octet streams are verified by the Cloesce compiler to have
+                    // one Stream type
+                    const streamParam = requiredParams.find((p) => typeof p.cidl_type === "string" && p.cidl_type === "Stream");
+                    params[streamParam.name] = request.body;
+                    break;
+                }
+                default: {
+                    throw new InternalError("not implemented");
+                }
+            }
+        }
+        catch {
+            return invalidRequest(RouterError.RequestMissingBody);
+        }
+    }
+    if (!requiredParams.every((p) => p.name in params)) {
+        return invalidRequest(RouterError.RequestBodyMissingParameters);
     }
-  }
-  // A data source is required for instantiated model methods
-  const dataSource = requiredParams
-    .filter(
-      (p) =>
-        typeof p.cidl_type === "object" &&
+    // Validate all parameters type. Octet streams need no validation.
+    if (route.method.parameters_media !== MediaType.Octet) {
+        for (const p of requiredParams) {
+            const res = RuntimeValidator.validate(params[p.name], p.cidl_type, ast, ctorReg);
+            if (res.isLeft()) {
+                return invalidRequest(RouterError.RequestBodyInvalidParameter);
+            }
+            params[p.name] = res.unwrap();
+        }
+    }
+    // A data source is required for instantiated model methods
+    const dataSource = requiredParams
+        .filter((p) => typeof p.cidl_type === "object" &&
         "DataSource" in p.cidl_type &&
-        p.cidl_type.DataSource === route.namespace,
-    )
-    .map((p) => params[p.name])[0];
-  if (route.kind === "model" && !route.method.is_static && !dataSource) {
-    return invalidRequest(RouterError.InstantiatedMethodMissingDataSource);
-  }
-  return Either.right({ params, dataSource: dataSource ?? null });
+        p.cidl_type.DataSource === route.namespace)
+        .map((p) => params[p.name])
+        .at(0);
+    if (route.kind === "model" &&
+        !route.method.is_static &&
+        dataSource === undefined) {
+        return invalidRequest(RouterError.InstantiatedMethodMissingDataSource);
+    }
+    return Either.right({ params, dataSource: dataSource ?? 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
+ * Hydrates a model or service instance for method dispatch.
+ * @returns 500 or the hydrated instance
  */
-async function hydrateModelD1(constructorRegistry, d1, model, id, dataSource) {
-  // Error state: If some outside force tweaked the database schema, the query may fail.
-  // Otherwise, this indicates a bug in the compiler or runtime.
-  const malformedQuery = (e) =>
-    exit(
-      500,
-      RouterError.InvalidDatabaseQuery,
-      `Error in hydration query, is the database out of sync with the backend?: ${e instanceof Error ? e.message : String(e)}`,
-    );
-  // Query DB
-  let records;
-  try {
-    let includeTree =
-      dataSource === NO_DATA_SOURCE
+async function hydrate(di, ctorReg, route, dataSource, env) {
+    if (route.kind === "service") {
+        if (route.method.is_static) {
+            return Either.right(ctorReg[route.namespace]);
+        }
+        return Either.right(di.get(route.namespace));
+    }
+    const model = route.model;
+    const modelCtor = ctorReg[model.name];
+    // Static methods operate on the class itself, no hydration needed
+    if (route.method.is_static) {
+        return Either.right(proxyCrud(modelCtor, modelCtor, env));
+    }
+    const includeTree = dataSource === NO_DATA_SOURCE
         ? null
-        : constructorRegistry[model.name][dataSource];
-    records = await d1
-      .prepare(Orm.getQuery(constructorRegistry[model.name], includeTree))
-      .bind(id)
-      .run();
-    // Error state: If no record is found for the id, return a 404
-    if (!records?.results) {
-      return exit(404, RouterError.ModelNotFound, "Record not found");
+        : ctorReg[model.name][dataSource];
+    const orm = Orm.fromEnv(env);
+    // Error state: If some outside force tweaked the database schema, the query may fail.
+    // Otherwise, this indicates a bug in the compiler or runtime.
+    const malformedQuery = (e) => exit(500, RouterError.InvalidDatabaseQuery, `Error in hydration query, is the database out of sync with the backend?: ${e instanceof Error ? e.message : String(e)}`);
+    try {
+        const result = await orm.get(modelCtor, {
+            id: route.primaryKey,
+            includeTree,
+            keyParams: route.keyParams,
+        });
+        // Result will only be null if the instance does not exist
+        // for a D1 query.
+        if (result === null) {
+            return exit(404, RouterError.ModelNotFound, `Model instance of type ${model.name} with primary key ${route.primaryKey} not found`);
+        }
+        return Either.right(result);
     }
-    if (records.error) {
-      return malformedQuery(records.error);
+    catch (e) {
+        return malformedQuery(JSON.stringify(e));
     }
-  } catch (e) {
-    return malformedQuery(e);
-  }
-  // Hydrate
-  const models = mapSql(
-    constructorRegistry[model.name],
-    records.results,
-    model.data_sources[dataSource]?.tree ?? {},
-  );
-  if (models.isLeft()) {
-    return malformedQuery(models.value);
-  }
-  return Either.right(models.unwrap()[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(obj, di, route, params) {
-  const paramArray = [];
-  for (const param of route.method.parameters) {
-    if (param.name in params) {
-      paramArray.push(params[param.name]);
-      continue;
+    const paramArray = [];
+    for (const param of route.method.parameters) {
+        if (param.name in params) {
+            paramArray.push(params[param.name]);
+            continue;
+        }
+        // Injected type
+        const injected = di.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 exit(500, RouterError.MissingDependency, `An injected parameter was missing from the instance registry: ${JSON.stringify(param.cidl_type)}`).unwrapLeft();
+        }
+        paramArray.push(injected);
+    }
+    const wrapResult = (res) => {
+        const rt = route.method.return_type;
+        const httpResult = typeof rt === "object" && rt !== null && "HttpResult" in rt
+            ? res
+            : HttpResult.ok(200, res);
+        return httpResult.setMediaType(route.method.return_media);
+    };
+    try {
+        const res = await obj[route.method.name](...paramArray);
+        return wrapResult(res);
     }
-    // Injected type
-    const injected = di.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 exit(
-        500,
-        RouterError.MissingDependency,
-        `An injected parameter was missing from the instance registry: ${JSON.stringify(param.cidl_type)}`,
-      ).unwrapLeft();
+    catch (e) {
+        // Error state: Client code threw an uncaught exception.
+        return exit(500, RouterError.UncaughtException, `Uncaught exception in method dispatch: ${e instanceof Error ? e.message : String(e)}`).unwrapLeft();
     }
-    paramArray.push(injected);
-  }
-  const wrapResult = (res) => {
-    const rt = route.method.return_type;
-    const httpResult =
-      typeof rt === "object" && rt !== null && "HttpResult" in rt
-        ? res
-        : HttpResult.ok(200, res);
-    return httpResult.setMediaType(route.method.return_media);
-  };
-  try {
-    const res = await obj[route.method.name](...paramArray);
-    return wrapResult(res);
-  } catch (e) {
-    // Error state: Client code threw an uncaught exception.
-    return exit(
-      500,
-      RouterError.UncaughtException,
-      `Uncaught exception in method dispatch: ${e instanceof Error ? e.message : String(e)}`,
-    ).unwrapLeft();
-  }
 }
 function exit(status, state, message, debugMessage = "") {
-  return Either.left(
-    HttpResult.fail(status, `${message} (ErrorCode: ${state}${debugMessage})`),
-  );
+    return Either.left(HttpResult.fail(status, `${message} (ErrorCode: ${state}${debugMessage})`));
 }
 /**
  * For testing purposes
  */
 export const _cloesceInternal = {
-  matchRoute,
-  validateRequest,
-  methodDispatch,
-  RuntimeContainer,
+    matchRoute,
+    validateRequest,
+    methodDispatch,
+    RuntimeContainer,
 };