@orpc/standard-server 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 oRPC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.js

@@ -0,0 +1,225 @@
+// src/event-source/errors.ts
+var EventEncoderError = class extends TypeError {
+};
+var EventDecoderError = class extends TypeError {
+};
+var ErrorEvent = class extends Error {
+  data;
+  constructor(options) {
+    super(options?.message ?? "An error event was received", options);
+    this.data = options?.data;
+  }
+};
+var UnknownEvent = class extends ErrorEvent {
+};
+
+// src/event-source/decoder.ts
+function decodeEventMessage(encoded) {
+  const lines = encoded.replace(/\n+$/, "").split(/\n/);
+  const message = {
+    data: "",
+    event: void 0,
+    id: void 0,
+    retry: void 0
+  };
+  for (const line of lines) {
+    const index = line.indexOf(": ");
+    if (index === -1) {
+      throw new EventDecoderError(`Invalid EventSource message line: ${line}`);
+    }
+    const key = line.slice(0, index);
+    const value = line.slice(index + 2);
+    if (key !== "data" && key in message && message[key] !== void 0) {
+      throw new EventDecoderError(`Duplicate EventSource message key: ${key}`);
+    }
+    if (key === "data") {
+      message.data += `${value}
+`;
+    } else if (key === "event") {
+      message.event = value;
+    } else if (key === "id") {
+      message.id = value;
+    } else if (key === "retry") {
+      const maybeInteger = Number.parseInt(value);
+      if (!Number.isInteger(maybeInteger) || maybeInteger < 0 || maybeInteger.toString() !== value) {
+        throw new EventDecoderError(`Invalid EventSource message retry value: ${value}`);
+      }
+      message.retry = maybeInteger;
+    } else {
+      throw new EventDecoderError(`Unknown EventSource message key: ${key}`);
+    }
+  }
+  message.data = message.data.replace(/\n$/, "");
+  return message;
+}
+var EventDecoder = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  incomplete = "";
+  feed(chunk) {
+    this.incomplete += chunk;
+    const lastCompleteIndex = this.incomplete.lastIndexOf("\n\n");
+    if (lastCompleteIndex === -1) {
+      return;
+    }
+    const completes = this.incomplete.slice(0, lastCompleteIndex + 2).split(/\n{2,}/);
+    this.incomplete = this.incomplete.slice(lastCompleteIndex + 2);
+    for (const encoded of completes) {
+      if (!encoded) {
+        continue;
+      }
+      const message = decodeEventMessage(`${encoded}
+
+`);
+      if (this.options.onEvent) {
+        this.options.onEvent(message);
+      }
+    }
+    this.incomplete = "";
+  }
+  end() {
+    this.feed("\n\n");
+  }
+};
+var EventDecoderStream = class extends TransformStream {
+  constructor() {
+    let decoder;
+    super({
+      start(controller) {
+        decoder = new EventDecoder({
+          onEvent: (event) => {
+            controller.enqueue(event);
+          }
+        });
+      },
+      transform(chunk) {
+        decoder.feed(chunk);
+      },
+      flush() {
+        decoder.end();
+      }
+    });
+  }
+};
+
+// src/event-source/encoder.ts
+function assertEventId(id) {
+  if (id.includes("\n")) {
+    throw new EventEncoderError("Event-source id must not contain a newline character");
+  }
+}
+function assertEventName(event) {
+  if (event.includes("\n")) {
+    throw new EventEncoderError("Event-source event must not contain a newline character");
+  }
+}
+function assertEventRetry(retry) {
+  if (!Number.isInteger(retry) || retry < 0) {
+    throw new EventEncoderError("Event-source retry must be a integer and >= 0");
+  }
+}
+function encodeEventData(data) {
+  const lines = data ? data.split(/\n/) : [""];
+  let output = "";
+  for (const line of lines) {
+    output += `data: ${line}
+`;
+  }
+  return output;
+}
+function encodeEventMessage(message) {
+  let output = "";
+  if (message.event !== void 0) {
+    assertEventName(message.event);
+    output += `event: ${message.event}
+`;
+  }
+  if (message.retry !== void 0) {
+    assertEventRetry(message.retry);
+    output += `retry: ${message.retry}
+`;
+  }
+  if (message.id !== void 0) {
+    assertEventId(message.id);
+    output += `id: ${message.id}
+`;
+  }
+  output += encodeEventData(message.data);
+  output += "\n";
+  return output;
+}
+
+// src/event-source/meta.ts
+var EVENT_SOURCE_META_SYMBOL = Symbol("ORPC_EVENT_SOURCE_META");
+function isEventMetaContainer(value) {
+  return !!value && (typeof value === "object" || typeof value === "function");
+}
+function withEventMeta(container, meta) {
+  if (meta.id !== void 0) {
+    assertEventId(meta.id);
+  }
+  if (meta.retry !== void 0) {
+    assertEventRetry(meta.retry);
+  }
+  return new Proxy(container, {
+    get(target, prop, receiver) {
+      if (prop === EVENT_SOURCE_META_SYMBOL) {
+        return meta;
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+function getEventMeta(container) {
+  return isEventMetaContainer(container) ? Reflect.get(container, EVENT_SOURCE_META_SYMBOL) : void 0;
+}
+
+// src/utils.ts
+import { contentDisposition, parse } from "@tinyhttp/content-disposition";
+function once(fn) {
+  let cached;
+  return () => {
+    if (cached) {
+      return cached.result;
+    }
+    const result = fn();
+    cached = { result };
+    return result;
+  };
+}
+function parseEmptyableJSON(text) {
+  if (!text) {
+    return void 0;
+  }
+  return JSON.parse(text);
+}
+function isAsyncIteratorObject(maybe) {
+  if (!maybe || typeof maybe !== "object") {
+    return false;
+  }
+  return Symbol.asyncIterator in maybe && typeof maybe[Symbol.asyncIterator] === "function";
+}
+export {
+  ErrorEvent,
+  EventDecoder,
+  EventDecoderError,
+  EventDecoderStream,
+  EventEncoderError,
+  UnknownEvent,
+  assertEventId,
+  assertEventName,
+  assertEventRetry,
+  contentDisposition,
+  decodeEventMessage,
+  encodeEventData,
+  encodeEventMessage,
+  getEventMeta,
+  isAsyncIteratorObject,
+  isEventMetaContainer,
+  once,
+  parse as parseContentDisposition,
+  parseEmptyableJSON,
+  withEventMeta
+};
+//# sourceMappingURL=index.js.map

package/dist/src/event-source/decoder.d.ts

@@ -0,0 +1,16 @@
+import type { EventMessage } from './types';
+export declare function decodeEventMessage(encoded: string): EventMessage;
+export interface EventDecoderOptions {
+    onEvent?: (event: EventMessage) => void;
+}
+export declare class EventDecoder {
+    private options;
+    private incomplete;
+    constructor(options?: EventDecoderOptions);
+    feed(chunk: string): void;
+    end(): void;
+}
+export declare class EventDecoderStream extends TransformStream<string, EventMessage> {
+    constructor();
+}
+//# sourceMappingURL=decoder.d.ts.map

package/dist/src/event-source/encoder.d.ts

@@ -0,0 +1,7 @@
+import type { EventMessage } from './types';
+export declare function assertEventId(id: string): void;
+export declare function assertEventName(event: string): void;
+export declare function assertEventRetry(retry: number): void;
+export declare function encodeEventData(data: string | undefined): string;
+export declare function encodeEventMessage(message: Partial<EventMessage>): string;
+//# sourceMappingURL=encoder.d.ts.map

package/dist/src/event-source/errors.d.ts

@@ -0,0 +1,16 @@
+import type { JsonValue } from 'type-fest';
+export declare class EventEncoderError extends TypeError {
+}
+export declare class EventDecoderError extends TypeError {
+}
+export interface ErrorEventOptions extends ErrorOptions {
+    message?: string;
+    data?: undefined | JsonValue;
+}
+export declare class ErrorEvent extends Error {
+    data: undefined | JsonValue;
+    constructor(options?: ErrorEventOptions);
+}
+export declare class UnknownEvent extends ErrorEvent {
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/src/event-source/index.d.ts

@@ -0,0 +1,6 @@
+export * from './decoder';
+export * from './encoder';
+export * from './errors';
+export * from './meta';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/event-source/meta.d.ts

@@ -0,0 +1,6 @@
+import type { EventMessage } from './types';
+export type EventMeta = Partial<Pick<EventMessage, 'retry' | 'id'>>;
+export declare function isEventMetaContainer(value: unknown): value is Record<PropertyKey, unknown>;
+export declare function withEventMeta<T extends object>(container: T, meta: EventMeta): T;
+export declare function getEventMeta(container: unknown): EventMeta | undefined;
+//# sourceMappingURL=meta.d.ts.map

package/dist/src/event-source/types.d.ts

@@ -0,0 +1,10 @@
+export interface EventMessage {
+    event: string | undefined;
+    id: string | undefined;
+    data: string;
+    /**
+     * The number of milliseconds to wait before retrying the event source if error occurs.
+     */
+    retry: number | undefined;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+export * from './event-source';
+export * from './types';
+export * from './utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/types.d.ts

@@ -0,0 +1,27 @@
+import type { JsonValue } from 'type-fest';
+export type { JsonValue };
+export interface StandardHeaders {
+    [key: string]: string | string[] | undefined;
+}
+export type StandardBody = undefined | JsonValue | Blob | URLSearchParams | FormData | AsyncIterator<JsonValue | void, JsonValue | void, undefined>;
+export interface StandardRequest {
+    /**
+     * Can be { request: Request } or { request: IncomingMessage, response: ServerResponse } based on the adapter.
+     */
+    raw: Record<string, unknown>;
+    method: string;
+    url: URL;
+    headers: StandardHeaders;
+    /**
+     * The body has been parsed base on the content-type header.
+     * This method can safely call multiple times (cached).
+     */
+    body: () => Promise<StandardBody>;
+    signal: AbortSignal | undefined;
+}
+export interface StandardResponse {
+    status: number;
+    headers: StandardHeaders;
+    body: StandardBody;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/utils.d.ts

@@ -0,0 +1,6 @@
+import type { JsonValue } from 'type-fest';
+export declare function once<T extends () => any>(fn: T): () => ReturnType<T>;
+export declare function parseEmptyableJSON(text: string): JsonValue | undefined;
+export declare function isAsyncIteratorObject(maybe: unknown): maybe is AsyncIteratorObject<any, any, any>;
+export { contentDisposition, parse as parseContentDisposition } from '@tinyhttp/content-disposition';
+//# sourceMappingURL=utils.d.ts.map

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@orpc/standard-server",
+  "type": "module",
+  "version": "0.0.0",
+  "license": "MIT",
+  "homepage": "https://unnoq.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unnoq/orpc.git",
+    "directory": "packages/standard-server"
+  },
+  "keywords": [
+    "orpc"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./🔒/*": {
+      "types": "./dist/src/*.d.ts"
+    }
+  },
+  "files": [
+    "!**/*.map",
+    "!**/*.tsbuildinfo",
+    "dist"
+  ],
+  "dependencies": {
+    "@tinyhttp/content-disposition": "^2.2.2",
+    "type-fest": "^4.34.1"
+  },
+  "scripts": {
+    "build": "tsup --clean --sourcemap --entry.index=src/index.ts --format=esm --onSuccess='tsc -b --noCheck'",
+    "build:watch": "pnpm run build --watch",
+    "type:check": "tsc -b"
+  }
+}