@temporary-name/server 0.0.1-alpha.0cb08cf84b740850e7d8dcd1d8b87f78af26071b

package/dist/shared/server.JwVIEHL6.mjs

@@ -0,0 +1,386 @@
+import { runWithSpan, isAsyncIteratorObject, overlayProxy, asyncIteratorWithSpan, fallbackContractConfig, tryDecodeURIComponent, parseHTTPEndpoint, KRUSTY_NAME, setSpanError } from '@temporary-name/shared';
+import { N as NotFoundError, V as ValidationError, B as BadRequestError, I as InternalServerError, e as encodeError, s as standardizeHTTPPath, i as isLazyResource, v as validateLazyLoadedResource, A as ApiError, t as toApiError$1 } from './server.D7jtfDRy.mjs';
+import { mapEventIterator, ErrorEvent } from '@temporary-name/standard-server';
+import * as z from '@temporary-name/zod';
+import { safeDecodeAsync, safeEncodeAsync } from '@temporary-name/zod';
+import { toApiError } from '@temporary-name/server';
+import { parse } from 'neoqs';
+import { createRouter, addRoute, findRoute } from 'rou3';
+
+function mergeContext(context, other) {
+  return { ...context, ...other };
+}
+
+function getEndpointId(config) {
+  return `${config.method}:${config.path}`;
+}
+
+async function callMethod(method, ...[input, options]) {
+  const context = options?.context ?? {};
+  const output = await runWithSpan({ name: "call_method", signal: options?.signal }, (span) => {
+    span?.setAttribute("method.path", getEndpointId(method["~def"].methodConfig));
+    return executeMethodInternal(
+      method,
+      {
+        query: input?.query ?? {},
+        headers: new Headers(input?.headers),
+        body: input?.body ?? {},
+        path: input?.path ?? {}
+      },
+      {
+        context,
+        method,
+        request: options?.request,
+        signal: options?.signal,
+        lastEventId: options?.lastEventId
+      }
+    );
+  });
+  if (isAsyncIteratorObject(output)) {
+    return overlayProxy(
+      output,
+      mapEventIterator(
+        asyncIteratorWithSpan({ name: "consume_event_iterator_output", signal: options?.signal }, output),
+        {
+          value: (v) => v,
+          error: async (e) => e
+        }
+      )
+    );
+  }
+  return output;
+}
+function validateInput(schemas, input, config) {
+  return runWithSpan({ name: "validate_input" }, async () => {
+    const { strictParams, method } = config;
+    if (method) {
+      const { middlewareOnlyKeys } = method["~def"];
+      for (const key of middlewareOnlyKeys.query) {
+        delete input.query[key];
+      }
+      if (input.body) {
+        for (const key of middlewareOnlyKeys.body) {
+          delete input.body[key];
+        }
+      }
+    }
+    const resultBody = await safeDecodeAsync(schemas.bodySchema, input.body, {
+      coerce: false,
+      defaultStrictObjects: strictParams
+    });
+    const resultPath = await safeDecodeAsync(schemas.pathSchema, input.path, {
+      coerce: true,
+      defaultStrictObjects: strictParams
+    });
+    const resultQuery = await safeDecodeAsync(schemas.querySchema, input.query, {
+      coerce: true,
+      defaultStrictObjects: strictParams
+    });
+    const resultHeaders = await safeDecodeAsync(
+      schemas.headersSchema,
+      normalizeHeadersForSchema(input.headers, schemas.headersSchema),
+      {
+        coerce: true,
+        // Headers are always non-strict
+        defaultStrictObjects: false
+      }
+    );
+    const issues = [];
+    if (!resultPath.success) {
+      issues.push(...resultPath.error.issues.map((i) => ({ ...i, path: ["path", ...i.path] })));
+      throw new NotFoundError({
+        cause: new ValidationError({
+          issues,
+          data: input
+        })
+      });
+    }
+    if (!resultBody.success) {
+      issues.push(...resultBody.error.issues.map((i) => ({ ...i, path: ["body", ...i.path] })));
+    }
+    if (!resultQuery.success) {
+      issues.push(...resultQuery.error.issues.map((i) => ({ ...i, path: ["query", ...i.path] })));
+    }
+    if (!resultHeaders.success) {
+      issues.push(...resultHeaders.error.issues.map((i) => ({ ...i, path: ["headers", ...i.path] })));
+    }
+    if (issues.length > 0) {
+      throw new BadRequestError({
+        code: "input_validation_failed",
+        message: "Input validation failed",
+        cause: new ValidationError({
+          issues,
+          data: input
+        })
+      });
+    }
+    const results = {
+      body: resultBody.data,
+      path: resultPath.data,
+      query: resultQuery.data,
+      headers: resultHeaders.data
+    };
+    return results;
+  });
+}
+async function validateOutput(method, output) {
+  const schema = method["~def"].schemas.responseSchema;
+  if (!schema) {
+    return output;
+  }
+  return runWithSpan({ name: "validate_output" }, async () => {
+    const result = await safeEncodeAsync(schema, output);
+    if (!result.success) {
+      throw new InternalServerError({
+        message: "Output validation failed",
+        cause: new ValidationError({
+          issues: result.error.issues,
+          data: output
+        })
+      });
+    }
+    return result.data;
+  });
+}
+const respond = (response) => ({ response });
+async function executeMethodInternal(method, input, options) {
+  const middlewares = method["~def"].middlewares;
+  const next = async (index, context) => {
+    const mid = middlewares[index];
+    return mid ? await runWithSpan({ name: `middleware.${index}`, signal: options.signal }, async (span) => {
+      const validatedInput = await validateInput(mid["~def"].schemas, input, { strictParams: false });
+      span?.setAttribute("middleware.index", index);
+      const result = await mid.handler({
+        ...options,
+        ...validatedInput,
+        context,
+        respond,
+        next: async (nextOptions) => {
+          const nextContext = nextOptions?.context ?? {};
+          return {
+            response: await next(index + 1, mergeContext(context, nextContext))
+          };
+        }
+      });
+      return result.response;
+    }) : await runWithSpan({ name: "handler", signal: options.signal }, async () => {
+      const validatedInput = await validateInput(method["~def"].schemas, input, {
+        strictParams: true,
+        method
+      });
+      const response = await method.handler(validatedInput, { ...options, context });
+      return validateOutput(method, response);
+    });
+  };
+  return next(0, options.context);
+}
+function normalizeHeadersForSchema(headers, schema) {
+  if (!(schema instanceof z.core.$ZodObject)) {
+    return Object.fromEntries(headers.entries());
+  }
+  const { def } = schema._zod;
+  const normalized = {};
+  for (const key in def.shape) {
+    const value = headers.get(key);
+    if (value != null) {
+      normalized[key] = value;
+    }
+  }
+  if (def.catchall) {
+    const lowerShapeKeys = new Set(Object.keys(def.shape).map((k) => k.toLowerCase()));
+    for (const [key, value] of headers.entries()) {
+      if (!lowerShapeKeys.has(key)) {
+        normalized[key] = value;
+      }
+    }
+  }
+  return normalized;
+}
+
+async function decode(request, pathParams) {
+  return {
+    path: pathParams ?? {},
+    query: parse(request.url.search, { ignoreQueryPrefix: true }),
+    headers: request.headers,
+    body: await request.body() ?? {}
+  };
+}
+function asyncSafeSerialize(data) {
+  if (isAsyncIteratorObject(data)) {
+    return mapEventIterator(data, {
+      value: async (value) => value,
+      error: async (e) => {
+        return new ErrorEvent({
+          data: encodeError(toApiError(e))["body"],
+          cause: e
+        });
+      }
+    });
+  }
+  return data;
+}
+function encode(output, method) {
+  const successStatus = fallbackContractConfig(
+    "defaultSuccessStatus",
+    method["~def"].methodConfig.successStatus
+  );
+  return {
+    status: successStatus,
+    headers: new Headers(),
+    body: asyncSafeSerialize(output)
+  };
+}
+
+function resolveFriendlyStandardHandleOptions(options) {
+  return {
+    ...options,
+    context: options.context ?? {}
+    // Context only optional if all fields are optional
+  };
+}
+function toRou3Pattern(path) {
+  return standardizeHTTPPath(path).replace(/\/\{\+([^}]+)\}/g, "/**:$1").replace(/\/\{([^}]+)\}/g, "/:$1");
+}
+function decodeParams(params) {
+  return Object.fromEntries(
+    Object.entries(params).map(([key, value]) => [key, tryDecodeURIComponent(value)])
+  );
+}
+
+class StandardOpenAPIMatcher {
+  tree = createRouter();
+  constructor(resources) {
+    for (const resource of resources) {
+      if (isLazyResource(resource)) {
+        const { endpoints } = resource;
+        for (const methodName in endpoints) {
+          const endpoint = endpoints[methodName];
+          const [method, path] = parseHTTPEndpoint(endpoint);
+          const httpPath = toRou3Pattern(path);
+          addRoute(this.tree, method, httpPath, { lazyResource: resource, methodName });
+        }
+      } else {
+        for (const route of Object.values(resource.methods)) {
+          const { methodConfig } = route["~def"];
+          const method = methodConfig.method;
+          const httpPath = toRou3Pattern(methodConfig.path ?? "/");
+          addRoute(this.tree, method, httpPath, { method: route });
+        }
+      }
+    }
+  }
+  async match(method, pathname) {
+    const match = findRoute(this.tree, method, pathname);
+    if (!match) {
+      return void 0;
+    }
+    const params = match.params ? decodeParams(match.params) : void 0;
+    if ("lazyResource" in match.data) {
+      const { lazyResource, methodName } = match.data;
+      if (lazyResource.loaderCache === void 0) {
+        lazyResource.loaderCache = await lazyResource.loader();
+        validateLazyLoadedResource(lazyResource, lazyResource.loaderCache);
+      }
+      return { method: lazyResource.loaderCache.methods[methodName], params };
+    }
+    return { method: match.data.method, params };
+  }
+}
+
+function throwOrLog(error) {
+  if (process.env.NODE_ENV !== "production") {
+    throw error;
+  } else {
+    console.error(error);
+  }
+}
+class StandardHandler {
+  matcher;
+  constructor(resources) {
+    this.matcher = new StandardOpenAPIMatcher(resources);
+  }
+  async handle(request, options) {
+    const prefix = options.prefix?.replace(/\/$/, "") || void 0;
+    if (prefix && !request.url.pathname.startsWith(`${prefix}/`) && request.url.pathname !== prefix) {
+      return { matched: false, response: void 0 };
+    }
+    return runWithSpan({ name: `${request.method} ${request.url.pathname}` }, async (span) => {
+      let step;
+      let errorMap;
+      try {
+        const context = options.context;
+        const method = request.method;
+        const url = request.url;
+        const pathname = prefix ? url.pathname.replace(prefix, "") : url.pathname;
+        const match = await runWithSpan(
+          { name: "find_method" },
+          () => this.matcher.match(method, `/${pathname.replace(/^\/|\/$/g, "")}`)
+        );
+        if (!match) {
+          return { matched: false, response: void 0 };
+        }
+        errorMap = match.method["~def"].errorMap;
+        const endpointId = getEndpointId(match.method["~def"].methodConfig);
+        span?.updateName(`${KRUSTY_NAME}.${endpointId}`);
+        span?.setAttribute("rpc.system", KRUSTY_NAME);
+        span?.setAttribute("rpc.method", endpointId);
+        step = "decode_input";
+        const input = await runWithSpan({ name: "decode_input" }, () => decode(request, match.params));
+        step = void 0;
+        if (isAsyncIteratorObject(input.body)) {
+          input.body = asyncIteratorWithSpan(
+            { name: "consume_event_iterator_input", signal: request.signal },
+            input.body
+          );
+        }
+        step = "call_method";
+        const output = await callMethod(match.method, input, {
+          request,
+          context,
+          signal: request.signal,
+          lastEventId: request.headers.get("last-event-id") ?? void 0
+        });
+        step = void 0;
+        const response = encode(output, match.method);
+        return {
+          matched: true,
+          response
+        };
+      } catch (e) {
+        if (step !== "call_method") {
+          setSpanError(span, e);
+        }
+        const isApiError = e instanceof ApiError;
+        if (isApiError) {
+          if (!errorMap) {
+            throwOrLog(
+              new Error(`Got ApiError but errorMap is undefined. ApiError="{${e.message}"`, { cause: e })
+            );
+          } else if (!errorMap[e.constructor.name]) {
+            throwOrLog(
+              new Error(
+                `ApiError "${e.constructor.name}" (type "${e.constructor.type}") is not registered. Add it to your API with: baseApi.useErrors({ ${e.constructor.name} })`,
+                { cause: e }
+              )
+            );
+          }
+        }
+        const error = step === "decode_input" && !(e instanceof ApiError) ? new BadRequestError({
+          code: "malformed_request",
+          message: `Malformed request. Ensure the request body is properly formatted and the 'Content-Type' header is set correctly.`,
+          cause: e
+        }) : toApiError$1(e);
+        if (error instanceof InternalServerError) {
+          console.error(error.cause ?? error);
+        }
+        const response = encodeError(error);
+        return {
+          matched: true,
+          response
+        };
+      }
+    });
+  }
+}
+
+export { StandardHandler as S, StandardOpenAPIMatcher as a, decodeParams as b, callMethod as c, decode as d, encode as e, getEndpointId as g, mergeContext as m, resolveFriendlyStandardHandleOptions as r, toRou3Pattern as t };