@temporary-name/server 1.9.3-alpha.a252b3ff8cb6bf7deaa6d41dc9ac8a8d50edd80e → 1.9.3-alpha.a253b67a3639148c12f13a47295e1922182adecd

package/dist/plugins/index.mjs

@@ -1,119 +1,5 @@
-import { runWithSpan, value, setSpanError, isAsyncIteratorObject, AsyncIteratorClass, clone, ORPCError } from '@temporary-name/shared';
-import { flattenHeader } from '@temporary-name/standard-server';
-import { parseBatchRequest, toBatchResponse } from '@temporary-name/standard-server/batch';
-import { toFetchHeaders } from '@temporary-name/standard-server-fetch';
-
-class BatchHandlerPlugin {
-  maxSize;
-  mapRequestItem;
-  successStatus;
-  headers;
-  order = 5e6;
-  constructor(options = {}) {
-    this.maxSize = options.maxSize ?? 10;
-    this.mapRequestItem = options.mapRequestItem ?? ((request, { request: batchRequest }) => ({
-      ...request,
-      headers: {
-        ...batchRequest.headers,
-        ...request.headers
-      }
-    }));
-    this.successStatus = options.successStatus ?? 207;
-    this.headers = options.headers ?? {};
-  }
-  init(options) {
-    options.rootInterceptors ??= [];
-    options.rootInterceptors.unshift(async (options2) => {
-      const xHeader = flattenHeader(options2.request.headers["x-orpc-batch"]);
-      if (xHeader === void 0) {
-        return options2.next();
-      }
-      let isParsing = false;
-      try {
-        return await runWithSpan({ name: "handle_batch_request" }, async (span) => {
-          const mode = xHeader === "buffered" ? "buffered" : "streaming";
-          isParsing = true;
-          const parsed = parseBatchRequest({ ...options2.request, body: await options2.request.body() });
-          isParsing = false;
-          span?.setAttribute("batch.mode", mode);
-          span?.setAttribute("batch.size", parsed.length);
-          const maxSize = await value(this.maxSize, options2);
-          if (parsed.length > maxSize) {
-            const message = "Batch request size exceeds the maximum allowed size";
-            setSpanError(span, message);
-            return {
-              matched: true,
-              response: {
-                status: 413,
-                headers: {},
-                body: message
-              }
-            };
-          }
-          const responses = parsed.map((request, index) => {
-            const mapped = this.mapRequestItem(request, options2);
-            return options2.next({ ...options2, request: { ...mapped, body: () => Promise.resolve(mapped.body) } }).then(({ response: response2, matched }) => {
-              span?.addEvent(`response.${index}.${matched ? "success" : "not_matched"}`);
-              if (matched) {
-                if (response2.body instanceof Blob || response2.body instanceof FormData || isAsyncIteratorObject(response2.body)) {
-                  return {
-                    index,
-                    status: 500,
-                    headers: {},
-                    body: "Batch responses do not support file/blob, or event-iterator. Please call this procedure separately outside of the batch request."
-                  };
-                }
-                return { ...response2, index };
-              }
-              return { index, status: 404, headers: {}, body: "No procedure matched" };
-            }).catch((err) => {
-              Promise.reject(err);
-              return { index, status: 500, headers: {}, body: "Internal server error" };
-            });
-          });
-          await Promise.race(responses);
-          const status = await value(this.successStatus, responses, options2);
-          const headers = await value(this.headers, responses, options2);
-          const promises = [...responses];
-          const response = await toBatchResponse({
-            status,
-            headers,
-            mode,
-            body: new AsyncIteratorClass(
-              async () => {
-                const handling = promises.filter((p) => p !== void 0);
-                if (handling.length <= 0) {
-                  return { done: true, value: void 0 };
-                }
-                const value2 = await Promise.race(handling);
-                promises[value2.index] = void 0;
-                return { done: false, value: value2 };
-              },
-              async () => {
-              }
-            )
-          });
-          return {
-            matched: true,
-            response
-          };
-        });
-      } catch (cause) {
-        if (isParsing) {
-          return {
-            matched: true,
-            response: {
-              status: 400,
-              headers: {},
-              body: "Invalid batch request, this could be caused by a malformed request body or a missing header"
-            }
-          };
-        }
-        throw cause;
-      }
-    });
-  }
-}
+import { value, ORPCError } from '@temporary-name/shared';
+import { maybeSetHeader } from '@temporary-name/standard-server';
 
 class CORSPlugin {
   options;
@@ -132,17 +18,13 @@ class CORSPlugin {
     options.rootInterceptors ??= [];
     options.rootInterceptors.unshift(async (interceptorOptions) => {
       if (interceptorOptions.request.method === "OPTIONS") {
-        const resHeaders = {};
+        const resHeaders = new Headers();
         if (this.options.maxAge !== void 0) {
-          resHeaders["access-control-max-age"] = this.options.maxAge.toString();
-        }
-        if (this.options.allowMethods?.length) {
-          resHeaders["access-control-allow-methods"] = flattenHeader(this.options.allowMethods);
-        }
-        const allowHeaders = this.options.allowHeaders ?? interceptorOptions.request.headers["access-control-request-headers"];
-        if (typeof allowHeaders === "string" || allowHeaders?.length) {
-          resHeaders["access-control-allow-headers"] = flattenHeader(allowHeaders);
+          resHeaders.set("access-control-max-age", this.options.maxAge.toString());
         }
+        maybeSetHeader(resHeaders, "access-control-allow-methods", this.options.allowMethods);
+        const allowHeaders = this.options.allowHeaders ?? interceptorOptions.request.headers.get("access-control-request-headers");
+        maybeSetHeader(resHeaders, "access-control-allow-headers", allowHeaders);
         return {
           matched: true,
           response: {
@@ -159,87 +41,33 @@ class CORSPlugin {
       if (!result.matched) {
         return result;
       }
-      const origin = flattenHeader(interceptorOptions.request.headers.origin) ?? "";
+      const origin = interceptorOptions.request.headers.get("origin") ?? "";
       const allowedOrigin = await value(this.options.origin, origin, interceptorOptions);
       const allowedOriginArr = Array.isArray(allowedOrigin) ? allowedOrigin : [allowedOrigin];
       if (allowedOriginArr.includes("*")) {
-        result.response.headers["access-control-allow-origin"] = "*";
+        result.response.headers.set("access-control-allow-origin", "*");
       } else {
         if (allowedOriginArr.includes(origin)) {
-          result.response.headers["access-control-allow-origin"] = origin;
+          result.response.headers.set("access-control-allow-origin", origin);
         }
-        result.response.headers.vary = interceptorOptions.request.headers.vary ?? "origin";
+        result.response.headers.set("vary", interceptorOptions.request.headers.get("vary") ?? "origin");
       }
       const allowedTimingOrigin = await value(this.options.timingOrigin, origin, interceptorOptions);
       const allowedTimingOriginArr = Array.isArray(allowedTimingOrigin) ? allowedTimingOrigin : [allowedTimingOrigin];
       if (allowedTimingOriginArr.includes("*")) {
-        result.response.headers["timing-allow-origin"] = "*";
+        result.response.headers.set("timing-allow-origin", "*");
       } else if (allowedTimingOriginArr.includes(origin)) {
-        result.response.headers["timing-allow-origin"] = origin;
+        result.response.headers.set("timing-allow-origin", origin);
       }
       if (this.options.credentials) {
-        result.response.headers["access-control-allow-credentials"] = "true";
-      }
-      if (this.options.exposeHeaders?.length) {
-        result.response.headers["access-control-expose-headers"] = flattenHeader(this.options.exposeHeaders);
+        result.response.headers.set("access-control-allow-credentials", "true");
       }
+      maybeSetHeader(result.response.headers, "access-control-expose-headers", this.options.exposeHeaders);
       return result;
     });
   }
 }
 
-class RequestHeadersPlugin {
-  init(options) {
-    options.rootInterceptors ??= [];
-    options.rootInterceptors.push((interceptorOptions) => {
-      const reqHeaders = interceptorOptions.context.reqHeaders ?? toFetchHeaders(interceptorOptions.request.headers);
-      return interceptorOptions.next({
-        ...interceptorOptions,
-        context: {
-          ...interceptorOptions.context,
-          reqHeaders
-        }
-      });
-    });
-  }
-}
-
-class ResponseHeadersPlugin {
-  init(options) {
-    options.rootInterceptors ??= [];
-    options.rootInterceptors.push(async (interceptorOptions) => {
-      const resHeaders = interceptorOptions.context.resHeaders ?? new Headers();
-      const result = await interceptorOptions.next({
-        ...interceptorOptions,
-        context: {
-          ...interceptorOptions.context,
-          resHeaders
-        }
-      });
-      if (!result.matched) {
-        return result;
-      }
-      const responseHeaders = clone(result.response.headers);
-      for (const [key, value] of resHeaders) {
-        if (Array.isArray(responseHeaders[key])) {
-          responseHeaders[key].push(value);
-        } else if (responseHeaders[key] !== void 0) {
-          responseHeaders[key] = [responseHeaders[key], value];
-        } else {
-          responseHeaders[key] = value;
-        }
-      }
-      return {
-        ...result,
-        response: {
-          ...result.response,
-          headers: responseHeaders
-        }
-      };
-    });
-  }
-}
-
 const SIMPLE_CSRF_PROTECTION_CONTEXT_SYMBOL = Symbol("SIMPLE_CSRF_PROTECTION_CONTEXT");
 class SimpleCsrfProtectionHandlerPlugin {
   headerName;
@@ -266,7 +94,7 @@ class SimpleCsrfProtectionHandlerPlugin {
         ...options2,
         context: {
           ...options2.context,
-          [SIMPLE_CSRF_PROTECTION_CONTEXT_SYMBOL]: options2.request.headers[headerName] === headerValue
+          [SIMPLE_CSRF_PROTECTION_CONTEXT_SYMBOL]: options2.request.headers.get(headerName) === headerValue
         }
       });
     });
@@ -285,4 +113,4 @@ class SimpleCsrfProtectionHandlerPlugin {
   }
 }
 
-export { BatchHandlerPlugin, CORSPlugin, RequestHeadersPlugin, ResponseHeadersPlugin, SimpleCsrfProtectionHandlerPlugin };
+export { CORSPlugin, SimpleCsrfProtectionHandlerPlugin };

package/dist/shared/{server.SLLuK6_v.d.ts → server.BR0GBxlv.d.ts}

@@ -1,6 +1,6 @@
 import { HTTPPath } from '@temporary-name/shared';
-import { C as Context } from './server.BKSOrA6h.js';
-import { c as StandardHandleOptions } from './server.CQyYNJ1H.js';
+import { C as Context } from './server.oy0285uM.js';
+import { c as StandardHandleOptions } from './server.CPThlZ_E.js';
 
 type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
     context?: T;

package/dist/shared/server.C1RJffw4.mjs

@@ -0,0 +1,30 @@
+import { parse, serialize } from 'cookie';
+
+function setCookie(headers, name, value, options = {}) {
+  if (headers === void 0) {
+    return;
+  }
+  const cookieString = serialize(name, value, {
+    path: "/",
+    ...options
+  });
+  headers.append("Set-Cookie", cookieString);
+}
+function getCookie(headers, name, options = {}) {
+  if (headers === void 0) {
+    return void 0;
+  }
+  const cookieHeader = headers.get("cookie");
+  if (cookieHeader === null) {
+    return void 0;
+  }
+  return parse(cookieHeader, options)[name];
+}
+function deleteCookie(headers, name, options = {}) {
+  return setCookie(headers, name, "", {
+    ...options,
+    maxAge: 0
+  });
+}
+
+export { deleteCookie as d, getCookie as g, setCookie as s };

package/dist/shared/{server.BeuTpcmO.d.mts → server.C7HccVwN.d.mts}

@@ -1,6 +1,6 @@
 import { HTTPPath } from '@temporary-name/shared';
-import { C as Context } from './server.BKSOrA6h.mjs';
-import { c as StandardHandleOptions } from './server.C1fnTLq0.mjs';
+import { C as Context } from './server.oy0285uM.mjs';
+import { c as StandardHandleOptions } from './server.y97Td78c.mjs';
 
 type FriendlyStandardHandleOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
     context?: T;

package/dist/shared/{server.CQyYNJ1H.d.ts → server.CPThlZ_E.d.ts}

@@ -1,16 +1,15 @@
 import { Meta } from '@temporary-name/contract';
-import { HTTPPath, Interceptor } from '@temporary-name/shared';
-import { StandardLazyRequest, StandardResponse } from '@temporary-name/standard-server';
-import { C as Context, R as Router, E as ProcedureClientInterceptorOptions } from './server.BKSOrA6h.js';
+import { HTTPPath, StandardLazyRequest, Interceptor, StandardResponse } from '@temporary-name/shared';
+import { C as Context, R as Router, N as ProcedureClientInterceptorOptions } from './server.oy0285uM.js';
 
 interface StandardHandlerPlugin<T extends Context> {
     order?: number;
-    init?(options: StandardHandlerOptions<T>, router: Router<any, T>): void;
+    init?(options: StandardHandlerOptions<T>, router: Router<T>): void;
 }
 declare class CompositeStandardHandlerPlugin<T extends Context, TPlugin extends StandardHandlerPlugin<T>> implements StandardHandlerPlugin<T> {
     protected readonly plugins: TPlugin[];
     constructor(plugins?: readonly TPlugin[]);
-    init(options: StandardHandlerOptions<T>, router: Router<any, T>): void;
+    init(options: StandardHandlerOptions<T>, router: Router<T>): void;
 }
 
 interface StandardHandleOptions<T extends Context> {
@@ -41,15 +40,14 @@ interface StandardHandlerOptions<TContext extends Context> {
      *
      * Interceptors for procedure client.
      */
-    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, Record<never, never>, Meta>, Promise<unknown>>[];
+    clientInterceptors?: Interceptor<ProcedureClientInterceptorOptions<TContext, Meta>, Promise<unknown>>[];
 }
 declare class StandardHandler<T extends Context> {
     private readonly interceptors;
     private readonly clientInterceptors;
     private readonly rootInterceptors;
     private readonly matcher;
-    private readonly codec;
-    constructor(router: Router<any, T>, options: NoInfer<StandardHandlerOptions<T>>);
+    constructor(router: Router<T>, options: NoInfer<StandardHandlerOptions<T>>);
     handle(request: StandardLazyRequest, options: StandardHandleOptions<T>): Promise<StandardHandleResult>;
 }