cloesce 0.0.4-unstable.8 → 0.0.5-unstable.0

package/dist/router/router.js

@@ -1,187 +1,395 @@
-import { Either, isNullableType, getNavigationPropertyCidlType, NO_DATA_SOURCE, } from "../common.js";
 import { mapSql, loadOrmWasm } from "./wasm.js";
-import { CrudContext } from "./crud.js";
-import { Orm } from "../ui/backend.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 { RuntimeValidator } from "./validator.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;
-    }
+  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;
+  }
 }
 /**
- * Runtime entry point. Given a request, undergoes: routing, validating,
- * hydrating, and method dispatch.
- *
- * @returns A Response with an `HttpResult` JSON body.
+ * Expected states in which the router may exit.
  */
-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);
-        }
+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 = {}));
+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]);
     }
-    //#endregion
-    //#region Match the route to a model method
-    const route = matchRoute(request, ast, apiRoute);
-    if (route.isLeft()) {
-        return toResponse(route.value);
+  }
+  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 { method, model, id } = route.unwrap();
-    //#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);
-        }
+    const methods = this.methodMiddleware.get(ctor.name);
+    if (!methods.has(method)) {
+      methods.set(method, []);
     }
-    //#endregion
-    //#region Validate request body to the model method
-    const validation = await validateRequest(request, ast, model, method, id);
+    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;
+      }
+    }
+    // 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 toResponse(validation.value);
+      return validation.value;
     }
     const { params, dataSource } = validation.unwrap();
-    //#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);
-        }
+    // Method middleware
+    for (const m of this.methodMiddleware
+      .get(route.namespace)
+      ?.get(route.method.name) ?? []) {
+      const res = await m(di);
+      if (res) {
+        return res;
+      }
     }
-    //#endregion
-    //#region Instantatiate the model
-    const crudCtx = await (async () => {
-        if (method.is_static) {
-            return Either.right(CrudContext.fromCtor(d1, constructorRegistry[model.name]));
+    // 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),
+          );
         }
-        const hydratedModel = await hydrateModel(constructorRegistry, d1, model, id, // id must exist after matchRoute
-        dataSource);
-        return hydratedModel.map((_) => CrudContext.fromInstance(d1, hydratedModel.value, constructorRegistry[model.name]));
+        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 (crudCtx.isLeft()) {
-        return toResponse(crudCtx.value);
+    if (hydrated.isLeft()) {
+      return hydrated.value;
+    }
+    // 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);
+    }
+    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();
+        }
+        service[attr.var_name] = injected;
+      }
+      // Inject services
+      di.set(name, Object.assign(new ctorReg[name](), service));
     }
-    //#endregion
-    return toResponse(await methodDispatch(crudCtx.unwrap(), ir, method, 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();
+        }
+      }
+      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 a method on a model.
+ * Matches a request to an ApiInvocation
  * @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`
+ * @returns 404 or a matched 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) => Either.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}`);
-    }
+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(`Unknown method ${modelName}.${methodName}`);
+    if (!method) return notFound(RouterError.UnknownRoute);
+    if (request.method !== method.http_verb) {
+      return notFound(RouterError.UnmatchedHttpVerb);
     }
+    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("Unmatched HTTP method");
+      return notFound(RouterError.UnmatchedHttpVerb);
     }
     return Either.right({
-        model,
-        method,
-        id,
+      kind: "service",
+      namespace,
+      method,
+      service,
+      id: null,
     });
+  }
+  return notFound(RouterError.UnknownRoute);
 }
 /**
  * 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) => Either.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();
+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;
         }
-        catch {
-            return invalidRequest("Could not retrieve JSON body.");
+        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;
         }
-    }
-    // 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.");
+        default: {
+          throw new Error("not implemented");
         }
+      }
+    } catch {
+      return invalidRequest(RouterError.RequestMissingBody);
     }
-    // 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}`);
+  }
+  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();
     }
-    return Either.right({ params, dataSource });
+  }
+  // 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 });
 }
 /**
  * Queries D1 for a particular model's ID, then transforms the SQL column output into
@@ -190,173 +398,102 @@ 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(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) => Either.left(errorState(500, `Error in hydration query, is the database out of sync with the backend?: ${e instanceof Error ? e.message : String(e)}`));
+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
+        ? 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
-    const missingRecord = Either.left(errorState(404, "Record not found"));
-    // Query DB
-    let records;
-    try {
-        let includeTree = dataSource === NO_DATA_SOURCE
-            ? null
-            : constructorRegistry[model.name][dataSource];
-        records = await d1
-            .prepare(Orm.getQuery(constructorRegistry[model.name], includeTree).unwrap())
-            .bind(id)
-            .run();
-        if (!records?.results) {
-            return missingRecord;
-        }
-        if (records.error) {
-            return malformedQuery(records.error);
-        }
+    if (!records?.results) {
+      return exit(404, RouterError.ModelNotFound, "Record not found");
     }
-    catch (e) {
-        return malformedQuery(e);
+    if (records.error) {
+      return malformedQuery(records.error);
     }
-    // Hydrate
-    const models = mapSql(constructorRegistry[model.name], records.results, model.data_sources[dataSource]?.tree ?? {}).value;
-    return Either.right(models[0]);
+  } 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(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);
+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;
     }
-    catch (e) {
-        return uncaughtException(e);
+    // 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);
+  } 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 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 "Boolean":
-                return typeof value === "boolean";
-            case "DateIso":
-                const date = new Date(value);
-                return !isNaN(date.getTime());
-            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;
-        }
-        return true;
-    }
-    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" },
-    });
+function exit(status, state, message, 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,
 };