@derivesome/server 1.0.1

package/src/common/index.ts~

@@ -0,0 +1 @@
+export * from './types';

package/src/common/is.ts

@@ -0,0 +1,6 @@
+export const isPlainObject = (x: any): x is Record<PropertyKey, unknown> => {
+  if (x === null || typeof x === "undefined") return false;
+  if (Array.isArray(x)) return false;
+  if (x instanceof Date) return false;
+  return Object.getPrototypeOf(x) === Object.prototype;
+};

package/src/common/types.ts

@@ -0,0 +1,9 @@
+export type TupleOf<T> = [...T[], T] | [T, ...T[]] | [T];
+
+export type Arrayish<T> = TupleOf<T> | Array<T>;
+
+export type UnknownRecord = Record<string, unknown>;
+export type LooseRecord = Record<string, any>;
+
+export type UnknownArray = Array<unknown>;
+export type LooseArray = Array<any>;

package/src/common/types.ts~

@@ -0,0 +1,13 @@
+export type TupleOf<T> =
+  | [...T[], T]
+  | [T, ...T[]]
+  | [T]
+
+
+export type Arrayish<T> =
+  | TupleOf<T>
+  | Array<T>
+
+
+export type UnknownRecord = Record<string, unknown>;
+export type LooseRecord = Record<string, any>;

package/src/index.ts

@@ -0,0 +1,8 @@
+export * from "./common";
+export * from "./request-method";
+export * from "./response";
+export * from "./request-response";
+export * from "./route-handler";
+export * from "./route";
+export * from "./meta-provider";
+export * from "./app";

package/src/index.ts~

@@ -0,0 +1,8 @@
+export * from "./common";
+export * from "./request-method";
+export * from "./response";
+export * from "./request-response";
+export * from "./route-handler";
+export * from "./route";
+export * from './meta-provider';
+export * from './app';

package/src/meta-provider.ts

@@ -0,0 +1,10 @@
+import { UnknownRecord } from "./common";
+import { Request, Response } from "./request-response";
+import { RouteHandlerContext } from "./route-handler";
+
+export type MetaProvider<
+  NextMeta extends UnknownRecord = UnknownRecord,
+  PrevMeta extends UnknownRecord = UnknownRecord,
+> = (
+  ctx: RouteHandlerContext<Request, Response, PrevMeta>,
+) => NextMeta | Promise<NextMeta>;

package/src/meta-provider.ts~

@@ -0,0 +1,5 @@
+import { UnknownRecord } from "./common";
+import { Request, Response } from "./request-response";
+import { RouteHandlerContext } from "./route-handler";
+
+export type MetaProvider<NextMeta extends UnknownRecord = UnknownRecord, PrevMeta extends UnknownRecord = UnknownRecord> = (ctx: RouteHandlerContext<Request, Response, PrevMeta>) => ((PrevMeta & NextMeta) | Promise<PrevMeta &  NextMeta>)

package/src/request-method.ts

@@ -0,0 +1 @@
+export type RequestMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";

package/src/request-method.ts~

@@ -0,0 +1 @@
+export type RequestMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';

package/src/request-response.ts

@@ -0,0 +1,63 @@
+import { IncomingHttpHeaders, IncomingMessage, ServerResponse } from "http";
+
+export class Request {
+  raw: IncomingMessage;
+  body: any = {};
+
+  constructor(raw: IncomingMessage) {
+    this.raw = raw;
+  }
+
+  get method(): string {
+    return (this.raw.method || "GET").toUpperCase();
+  }
+
+  get headers(): IncomingHttpHeaders {
+    return this.raw.headers;
+  }
+
+  private readBody(limit: number = 1_048_576 * 2): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const chunks: Buffer[] = [];
+      let size = 0;
+
+      this.raw.addListener("data", (chunk) => {
+        size += chunk.length;
+        if (size > limit) {
+          this.raw.destroy();
+          reject(new Error("Body too large"));
+        } else {
+          chunks.push(chunk);
+        }
+      });
+
+      this.raw.addListener("end", () =>
+        resolve(Buffer.concat(chunks).toString()),
+      );
+      this.raw.addListener("error", reject);
+    });
+  }
+
+  async run() {
+    switch (this.method) {
+      case "POST":
+      case "PUT":
+      case "PATCH":
+        {
+          const data = await this.readBody();
+          try {
+            this.body = JSON.parse(data);
+          } catch (e) {
+            console.error(e);
+          }
+        }
+        break;
+      default:
+        {
+        }
+        break;
+    }
+  }
+}
+
+export interface Response extends ServerResponse {}

package/src/request-response.ts~

@@ -0,0 +1,63 @@
+import { IncomingHttpHeaders, IncomingMessage, ServerResponse } from "http";
+
+export class Request {
+  raw: IncomingMessage;
+  body: any = {};
+
+  constructor(raw: IncomingMessage) {
+    this.raw = raw;
+  }
+
+  get method(): string {
+    return (this.raw.method || "GET").toUpperCase();
+  }
+
+  get headers(): IncomingHttpHeaders {
+    return this.raw.headers;
+  }
+
+  private readBody(limit: number = 1_048_576 * 2): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const chunks: Buffer[] = [];
+      let size = 0;
+
+      this.raw.addListener("data", (chunk) => {
+        size += chunk.length;
+        if (size > limit) {
+          this.raw.destroy();
+          reject(new Error("Body too large"));
+        } else {
+          chunks.push(chunk);
+        }
+      });
+
+      this.raw.addListener("end", () =>
+        resolve(Buffer.concat(chunks).toString()),
+      );
+      this.raw.addListener("error", reject);
+    });
+  }
+
+  async run() {
+    switch (this.method) {
+      case "POST":
+      case "PUT":
+      case "PATCH":
+        {
+          const data = await this.readBody();
+          try {
+            this.body = JSON.parse(data);
+          } catch (e) {
+            console.error(e);
+          }
+        }
+        break;
+      default:
+        {
+        }
+        break;
+    }
+  }
+}
+
+export interface Response extends ServerResponse {}

package/src/response.ts

@@ -0,0 +1,100 @@
+import { LooseArray, LooseRecord } from "./common";
+import { Readable } from "node:stream";
+
+export interface ResponseBase<Type extends string> {
+  statusCode: number;
+  type: Type;
+}
+
+export interface ResponseJSON extends ResponseBase<"json"> {
+  contentType: "application/json";
+  payload: LooseRecord | LooseArray;
+}
+
+export interface ResponseText extends ResponseBase<"text"> {
+  contentType: "text/html";
+  payload: string;
+}
+
+export interface ResponseFile extends ResponseBase<"file"> {
+  filePath: string;
+  contentType: string | null;
+}
+
+export interface ResponseBinary extends ResponseBase<"binary"> {
+  contentType: string;
+  payload: Buffer | Uint8Array;
+}
+
+export interface ResponseStream extends ResponseBase<"stream"> {
+  contentType: string;
+  stream: Readable;
+}
+
+export type AnyResponse =
+  | ResponseJSON
+  | ResponseText
+  | ResponseFile
+  | ResponseBinary
+  | ResponseStream;
+
+export class ResponseBuilder<Resp extends AnyResponse = AnyResponse> {
+  resp: Resp;
+
+  constructor(resp: Resp) {
+    this.resp = resp;
+  }
+  status(code: number): this {
+    this.resp.statusCode = code;
+    return this;
+  }
+}
+
+export class ResponseMaker {
+  json(payload: LooseRecord | LooseArray): ResponseBuilder {
+    return new ResponseBuilder({
+      type: "json",
+      contentType: "application/json",
+      payload: payload,
+      statusCode: 200,
+    });
+  }
+  text(payload: string): ResponseBuilder {
+    return new ResponseBuilder({
+      type: "text",
+      contentType: "text/html",
+      payload: payload,
+      statusCode: 200,
+    });
+  }
+  stream(
+    stream: Readable,
+    contentType: string,
+  ): ResponseBuilder<ResponseStream> {
+    return new ResponseBuilder<ResponseStream>({
+      type: "stream",
+      contentType,
+      stream,
+      statusCode: 200,
+    });
+  }
+  binary(
+    payload: Buffer | Uint8Array,
+    contentType: string,
+  ): ResponseBuilder<ResponseBinary> {
+    return new ResponseBuilder<ResponseBinary>({
+      type: "binary",
+      contentType,
+      payload,
+      statusCode: 200,
+    });
+  }
+  file(filePath: string, contentType?: string): ResponseBuilder<ResponseFile> {
+    return new ResponseBuilder<ResponseFile>({
+      type: "file",
+      filePath,
+      contentType: contentType ?? null,
+      statusCode: 200,
+    });
+  }
+}

package/src/response.ts~

@@ -0,0 +1,49 @@
+import { LooseArray, LooseRecord } from "./common";
+
+export interface ResponseBase<Type extends string> {
+  statusCode: number;
+  type: Type;
+}
+
+export interface ResponseJSON extends ResponseBase<"json"> {
+  contentType: "application/json";
+  payload: LooseRecord | LooseArray;
+}
+
+export interface ResponseText extends ResponseBase<"text"> {
+  contentType: "text/html";
+  payload: string;
+}
+
+export type AnyResponse = ResponseJSON | ResponseText;
+
+export class ResponseBuilder<Resp extends AnyResponse = AnyResponse> {
+  resp: Resp;
+
+  constructor(resp: Resp) {
+    this.resp = resp;
+  }
+  status(code: number): this {
+    this.resp.statusCode = code;
+    return this;
+  }
+}
+
+export class ResponseMaker {
+  json(payload: LooseRecord | LooseArray): ResponseBuilder {
+    return new ResponseBuilder({
+      type: "json",
+      contentType: "application/json",
+      payload: payload,
+      statusCode: 200,
+    });
+  }
+  text(payload: string): ResponseBuilder {
+    return new ResponseBuilder({
+      type: "text",
+      contentType: "text/html",
+      payload: payload,
+      statusCode: 200,
+    });
+  }
+}

package/src/route-handler.ts

@@ -0,0 +1,45 @@
+import { OutputOfShape, ShapeMapping } from "shapedef";
+import { LooseArray, LooseRecord, UnknownRecord } from "./common";
+import { Request, Response } from "./request-response";
+import { ResponseBuilder, ResponseMaker } from "./response";
+
+export type ExtractParams<Path extends string> =
+  Path extends `${string}:${infer Param}/${infer Rest}` ?
+    { [K in Param]: string } & ExtractParams<Rest>
+  : Path extends `${string}:${infer Param}` ? { [K in Param]: string }
+  : {};
+
+export type RouteHandlerContext<
+  Req extends Request = Request,
+  Res extends Response = Response,
+  Meta extends UnknownRecord = UnknownRecord,
+  Args extends ShapeMapping<any> | null = ShapeMapping<any> | null,
+  Params extends Record<string, string> = Record<string, string>,
+> = {
+  req: Req;
+  res: Res;
+  meta: Meta;
+  args: OutputOfShape<Args>;
+  params: Params;
+  R: ResponseMaker;
+};
+
+export type RouteHandlerReturn =
+  | void
+  | Promise<void>
+  | LooseRecord
+  | Promise<LooseRecord>
+  | LooseArray
+  | Promise<LooseArray>
+  | ResponseBuilder
+  | Promise<ResponseBuilder>;
+
+export type RouteHandler<
+  Meta extends UnknownRecord = UnknownRecord,
+  Args extends ShapeMapping<any> | null = ShapeMapping<any> | null,
+  Params extends Record<string, string> = Record<string, string>,
+  Req extends Request = Request,
+  Res extends Response = Response,
+  Ctx extends RouteHandlerContext<Req, Res, Meta, Args, Params> =
+    RouteHandlerContext<Req, Res, Meta, Args, Params>,
+> = (ctx: Ctx) => RouteHandlerReturn;

package/src/route-handler.ts~

@@ -0,0 +1,37 @@
+import { OutputOfShape, ShapeMapping } from "shapedef";
+import { LooseArray, LooseRecord, UnknownRecord } from "./common";
+import { Request, Response } from "./request-response";
+import { ResponseBuilder, ResponseMaker } from "./response";
+
+export type ExtractParams<Path extends string> =
+  Path extends `${string}:${infer Param}/${infer Rest}`
+    ? { [K in Param]: string } & ExtractParams<Rest>
+    : Path extends `${string}:${infer Param}`
+      ? { [K in Param]: string }
+      : {};
+
+export type RouteHandlerContext<
+  Req extends Request = Request,
+  Res extends Response = Response,
+  Meta extends UnknownRecord = UnknownRecord,
+  Args extends ShapeMapping<any> | null = ShapeMapping<any> | null,
+  Params extends Record<string, string> = Record<string, string>
+> = {
+  req: Req;
+  res: Res;
+  meta: Meta;
+  args: OutputOfShape<Args>;
+  params: Params;
+  R: ResponseMaker; 
+};
+
+export type RouteHandlerReturn = void | Promise<void> | LooseRecord | Promise<LooseRecord> | LooseArray | Promise<LooseArray> | ResponseBuilder | Promise<ResponseBuilder>;
+
+export type RouteHandler<
+  Meta extends UnknownRecord = UnknownRecord,
+  Args extends ShapeMapping<any> | null = ShapeMapping<any> | null,
+  Params extends Record<string, string> = Record<string, string>,
+  Req extends Request = Request,
+  Res extends Response = Response,
+  Ctx extends RouteHandlerContext<Req, Res, Meta, Args, Params> = RouteHandlerContext<Req, Res, Meta, Args, Params>,
+> = (ctx: Ctx) => RouteHandlerReturn;

package/src/route.ts

@@ -0,0 +1,37 @@
+import { ShapeMapping } from "shapedef";
+import { UnknownRecord } from "./common";
+import { RequestMethod } from "./request-method";
+import { ExtractParams, RouteHandler } from "./route-handler";
+
+export type Route<
+  Meta extends UnknownRecord = UnknownRecord,
+  Args extends ShapeMapping<any> = ShapeMapping<any>,
+  Method extends RequestMethod = RequestMethod,
+  Path extends string = string,
+  Handler extends RouteHandler<Meta, Args, ExtractParams<Path>> = RouteHandler<
+    Meta,
+    Args,
+    ExtractParams<Path>
+  >,
+> = {
+  method: Method;
+  path: Path;
+  handler: Handler;
+  args: Args | null;
+  mergeParams?: boolean | undefined | null;
+};
+
+export type RouteWithoutArgs<
+  Meta extends UnknownRecord = UnknownRecord,
+  Method extends RequestMethod = RequestMethod,
+  Path extends string = string,
+  Handler extends RouteHandler<Meta, null, ExtractParams<Path>> = RouteHandler<
+    Meta,
+    null,
+    ExtractParams<Path>
+  >,
+> = {
+  method: Method;
+  path: Path;
+  handler: Handler;
+};

package/src/route.ts~

@@ -0,0 +1,37 @@
+import { ShapeMapping } from "shapedef";
+import { UnknownRecord } from "./common";
+import { RequestMethod } from "./request-method";
+import { ExtractParams, RouteHandler } from "./route-handler";
+
+export type Route<
+  Meta extends UnknownRecord = UnknownRecord,
+  Args extends ShapeMapping<any> = ShapeMapping<any>,
+  Method extends RequestMethod = RequestMethod,
+  Path extends string = string,
+  Handler extends RouteHandler<Meta, Args, ExtractParams<Path>> = RouteHandler<
+    Meta,
+    Args,
+    ExtractParams<Path>
+  >,
+> = {
+  method: Method;
+  path: Path;
+  handler: Handler;
+  args: Args | null;
+  mergeParams?: boolean | undefined | null;
+};
+
+export type RouteWithoutArgs<
+  Meta extends UnknownRecord = UnknownRecord,
+  Method extends RequestMethod = RequestMethod,
+  Path extends string = string,
+  Handler extends RouteHandler<Meta, null, ExtractParams<Path>> = RouteHandler<
+    Meta,
+    null,
+    ExtractParams<Path>
+  >,
+> = {
+  method: Method;
+  path: Path;
+  handler: Handler;
+};

package/tsconfig.cjs.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist/cjs",
+    "module": "commonjs",
+    "moduleResolution": "node10"
+  },
+  "include": ["./src/**/*.ts"],
+  "exclude": ["./src/**/*.test.ts", "./src/**/*.sample.ts"]
+}

package/tsconfig.esm.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist/esm",
+    "module": "nodenext",
+    "target": "esnext"
+  },
+  "include": ["./src/**/*.ts"],
+  "exclude": ["./src/**/*.test.ts", "./src/**/*.sample.ts"]
+}

package/tsconfig.esm.json~

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist/esm",
+    "module": "nodenext",
+    "target": "esnext"
+  },
+  "include": ["./src/**/*.ts"],
+  "exclude": ["./src/**/*.test.ts", "./src/**/*.sample.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "module": "nodenext",
+    "target": "esnext",
+    "lib": ["esnext", "dom", "dom.iterable"],
+    "types": ["node"],
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "strict": true,
+    "isolatedModules": true,
+    "esModuleInterop": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true
+  },
+  "include": ["./src/**/*.ts"]
+}

package/tsconfig.json~

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "module": "nodenext",
+    "target": "esnext",
+    "lib": ["esnext", "dom", "dom.iterable"],
+    "types": ["node"],
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "strict": true,
+    "isolatedModules": true,
+    "esModuleInterop": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true
+  },
+  "include": ["./src/**/*.ts"]
+}