@jmnuf/ao
Version:
A simple typescript based full-stack api endpoint creator that is meant to somewhat follow web standards in its implementation.
117 lines (114 loc) • 29.4 kB
JavaScript
//#region src/utils.ts
const HttpMethods = [
"GET",
"POST",
"PUT",
"DELETE"
];
const GeneratorHTTPHeaderName = "X-AncientOnes-Streaming";
//#endregion
//#region src/apostles.ts
const DEBUG_PATHING_PROPERTY = "__DEBUG_PATHING__";
async function* streamToGenerator(reader) {
const decode = (data) => new TextDecoder().decode(data);
do {
const step = await reader.read();
if (step.done) return;
const json = decode(step.value);
const data = JSON.parse(json);
yield data.data;
} while (true);
}
const PROTOCOL_CHECK_REGEX = /^https?:\/\//;
function createApostle(origin) {
origin = origin.trim();
if (!origin.match(PROTOCOL_CHECK_REGEX)) throw new Error("Origin must start with the protocol (http:// or https://)");
while (origin.endsWith("/")) origin = origin.substring(0, origin.length - 1);
const pushParams = (path, params = {}) => {
for (const param of Object.keys(params)) path += "/" + params[param];
return path;
};
const doFetch = async (method, path, config = {}) => {
try {
if (config.params) for (const key of Object.keys(config.params ?? {})) path += "/" + config.params[key];
const url = new URL(path);
if (config.query) for (const key of Object.keys(config.query ?? {})) {
const val = config.query[key];
if (!Array.isArray(val)) {
url.searchParams.append(key, val);
continue;
}
for (const v of val) url.searchParams.append(key, v);
}
const response = await fetch(url, {
method,
body: config.body
});
if (!response.ok) {
const message = await response.text();
return {
ok: false,
status: response.status,
response,
error: new Error(message)
};
}
const status = response.status;
const generatorHeader = response.headers.get(GeneratorHTTPHeaderName);
if (generatorHeader === "Generator" || generatorHeader === "AsyncGenerator") {
if (!response.body) return {
ok: false,
status,
response,
error: new Error("Received generator header but there's no body to read stream from")
};
const reader = response.body.getReader();
const generator = streamToGenerator(reader);
return {
ok: true,
status,
response,
data: generator
};
}
const res = await response.json();
return {
ok: true,
status,
response,
data: res.data
};
} catch (err) {
const error = new Error("Fetch request failed", { cause: err });
return {
ok: false,
error
};
}
};
const methods = HttpMethods.map((x) => x.toLowerCase());
const p = new Proxy({ pathing: origin }, { get(target, property) {
if (typeof property === "symbol") return target[property];
if (property === DEBUG_PATHING_PROPERTY) return target.pathing;
if (methods.includes(property)) return doFetch.bind(null, property.toUpperCase(), target.pathing);
return pathing(origin + "/" + property);
} });
const pathing = (path) => {
const data = { pathing: path };
const fn = (params) => {
data.pathing = pushParams(data.pathing, params);
return proxy;
};
const proxy = new Proxy(fn, { get(target, property) {
if (typeof property === "symbol") return target[property];
if (property === DEBUG_PATHING_PROPERTY) return data.pathing;
if (methods.includes(property)) return doFetch.bind(null, property.toUpperCase(), data.pathing);
return pathing(`${data.pathing}/${property}`);
} });
return proxy;
};
return p;
}
//#endregion
export { DEBUG_PATHING_PROPERTY, createApostle };
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"apostles.js","names":["reader: ReadableStreamDefaultReader<Uint8Array<ArrayBufferLike>>","data: any","origin: string","path: string","params: Record<string, string>","method: HTTPMethod","config: FetchConfig","property: symbol | (typeof methods)[number] | (string & {})"],"sources":["src/utils.ts","src/apostles.ts"],"sourcesContent":["export const StatusMap = {\r\n  100: \"Continue\",\r\n  101: \"Switching Protocols\",\r\n  102: \"Processing\",\r\n  103: \"Early Hints\",\r\n  200: \"OK\",\r\n  201: \"Created\",\r\n  202: \"Accepted\",\r\n  203: \"Non-Authoritative Information\",\r\n  204: \"No Content\",\r\n  205: \"Reset Content\",\r\n  206: \"Partial Content\",\r\n  207: \"Multi-Status\",\r\n  208: \"Already Reported\",\r\n  300: \"Multiple Choices\",\r\n  301: \"Moved Permanently\",\r\n  302: \"Found\",\r\n  303: \"See Other\",\r\n  304: \"Not Modified\",\r\n  307: \"Temporary Redirect\",\r\n  308: \"Permanent Redirect\",\r\n  400: \"Bad Request\",\r\n  401: \"Unauthorized\",\r\n  402: \"Payment Required\",\r\n  403: \"Forbidden\",\r\n  404: \"Not Found\",\r\n  405: \"Method Not Allowed\",\r\n  406: \"Not Acceptable\",\r\n  407: \"Proxy Authentication Required\",\r\n  408: \"Request Timeout\",\r\n  409: \"Conflict\",\r\n  410: \"Gone\",\r\n  411: \"Length Required\",\r\n  412: \"Precondition Failed\",\r\n  413: \"Payload Too Large\",\r\n  414: \"URI Too Long\",\r\n  415: \"Unsupported Media Type\",\r\n  416: \"Range Not Satisfiable\",\r\n  417: \"Expectation Failed\",\r\n  418: \"I'm a teapot\",\r\n  421: \"Misdirected Request\",\r\n  422: \"Unprocessable Content\",\r\n  423: \"Locked\",\r\n  424: \"Failed Dependency\",\r\n  425: \"Too Early\",\r\n  426: \"Upgrade Required\",\r\n  428: \"Precondition Required\",\r\n  429: \"Too Many Requests\",\r\n  431: \"Request Header Fields Too Large\",\r\n  451: \"Unavailable For Legal Reasons\",\r\n  500: \"Internal Server Error\",\r\n  501: \"Not Implemented\",\r\n  502: \"Bad Gateway\",\r\n  503: \"Service Unavailable\",\r\n  504: \"Gateway Timeout\",\r\n  505: \"HTTP Version Not Supported\",\r\n  506: \"Variant Also Negotiates\",\r\n  507: \"Insufficient Storage\",\r\n  508: \"Loop Detected\",\r\n  510: \"Not Extended\",\r\n  511: \"Network Authentication Required\",\r\n} as const;\r\n\r\nexport type Prettify<T> = {\r\n  [K in keyof T]: T[K];\r\n} & unknown;\r\n// type IsType<Value, Type> = Value extends Type ? true : false;\r\n// type IsStr<Value> = IsType<Value, string>;\r\nexport type And<A extends boolean, B extends boolean> = A extends true ? B extends true ? true : false : false;\r\n// type When<Cond extends boolean, OnTrue> = Cond extends true ? OnTrue : never;\r\nexport type If<Cond extends boolean, OnTrue, OnFalse> = Cond extends true ? OnTrue : OnFalse;\r\n\r\nexport type SplitString<Str extends string, Delimiter extends string, IgnoreEmpty extends boolean = false> =\r\n  string extends Str\r\n  ? string[]\r\n  : Str extends \"\"\r\n  ? []\r\n  : Str extends `${infer T}${Delimiter}${infer U}`\r\n  ? If<IgnoreEmpty, If<And<IgnoreEmpty, T extends \"\" ? true : false>, [...SplitString<U, Delimiter, IgnoreEmpty>], [T, ...SplitString<U, Delimiter, IgnoreEmpty>]>, [T, ...SplitString<U, Delimiter, IgnoreEmpty>]>\r\n  : [Str];\r\n\r\nexport type JoinString<Pieces extends any[], Joiner extends string = \"\", Joined extends string = \"\"> =\r\n  Pieces extends []\r\n  ? Joined\r\n  : Pieces extends [infer Head, ...infer Tail]\r\n  ? Head extends string\r\n  ? JoinString<Tail, Joiner, Joined extends \"\" ? `${Head}` : `${Joined}${Joiner}${Head}`>\r\n  : JoinString<Tail, Joiner, Joined>\r\n  : never;\r\n\r\nexport type UnionToIntersection<U> =\r\n  (U extends any ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never;\r\n\r\nexport type UnionToParm<U> = U extends any ? (k: U) => void : never;\r\nexport type UnionToSect<U> = UnionToParm<U> extends ((k: infer I) => void) ? I : never;\r\nexport type ExtractParm<F> = F extends { (a: infer A): void } ? A : never;\r\n\r\nexport type UnionSpliceOne<Union> = Exclude<Union, UnionExtractOne<Union>>;\r\nexport type UnionExtractOne<Union> = ExtractParm<UnionToSect<UnionToParm<Union>>>;\r\n\r\nexport type UnionToTuple<Union> = UnionToTupleRec<Union, []>;\r\nexport type UnionToTupleRec<Union, Rslt extends any[]> =\r\n  UnionSpliceOne<Union> extends never ? [UnionExtractOne<Union>, ...Rslt]\r\n  : UnionToTupleRec<UnionSpliceOne<Union>, [UnionExtractOne<Union>, ...Rslt]>;\r\n\r\nexport type JoinTuple<Tuple extends string[], Delim extends string> = Tuple extends []\r\n  ? \"\"\r\n  : Tuple extends [infer Head extends string, ...infer Tail extends string[]]\r\n  ? JoinTupleRec<Head, Delim, Tail>\r\n  : never;\r\nexport type JoinTupleRec<Acc extends string, Delim extends string, Tuple extends string[]> =\r\n  Tuple extends []\r\n  ? Acc\r\n  : Tuple extends [infer Head extends string, ...infer Tail extends string[]]\r\n  ? JoinTupleRec<`${Acc}${Delim}${Head}`, Delim, Tail>\r\n  : Acc;\r\n\r\nexport type TuplePush<Tuple extends any[], Value> = [...Tuple, Value];\r\nexport type TupleRemove<Tuple extends any[], Value> = UnionToTuple<Exclude<Tuple[number], Value>>;\r\n\r\nexport type SimplifyBooleanLiteral<Bool extends boolean> = Bool extends true ? boolean : Bool extends false ? boolean : boolean;\r\n\r\nexport type TupleToArraysUnion<Tuple extends any[], SimplifyBoolean extends boolean = false> = Tuple extends []\r\n  ? never\r\n  : Tuple extends [infer Head, ...infer Tail extends any[]]\r\n  ? TupleToArraysUnionRec<Array<SimplifyBoolean extends true ? Head extends boolean ? SimplifyBooleanLiteral<Head> : Head : Head>, Tail, SimplifyBoolean>\r\n  : never;\r\nexport type TupleToArraysUnionRec<Acc, Tuple extends any[], SimplifyBoolean extends boolean> = Tuple extends []\r\n  ? Acc\r\n  : Tuple extends [infer Head, ...infer Tail]\r\n  ? TupleToArraysUnionRec<Acc | Array<SimplifyBoolean extends true ? Head extends boolean ? SimplifyBooleanLiteral<Head> : Head : Head>, Tail, SimplifyBoolean>\r\n  : Acc;\r\n\r\nexport type ObjectValues<T extends Record<any, any>> = UnionToIntersection<T[keyof T]>;\r\n\r\nexport type FindPathParams<Path extends string> = FindPathParamsRec<SplitString<Path, \"/\", true>, {}>;\r\ntype FindPathParamsRec<Parts extends string[], FoundParams extends { [param: string | never]: string | string[] }> =\r\n  Parts extends []\r\n  ? FoundParams\r\n  : Parts extends [infer Head extends string, ...infer Tail extends string[]]\r\n  ? Head extends `:${infer Param extends string}`\r\n  ? Param extends keyof FoundParams\r\n  ? (FoundParams[Param] extends string\r\n    ? Omit<FoundParams, Param> & { [P in Param]: [string, string] }\r\n    : FoundParams[Param] extends string[]\r\n    ? Omit<FoundParams, Param> & { [P in Param]: TuplePush<FoundParams[Param], string>; }\r\n    : FoundParams & { [P in Param]: string; }\r\n  )\r\n  : FoundParams & { [P in Param]: string; }\r\n  : FindPathParamsRec<Tail, FoundParams>\r\n  : never;\r\n\r\nexport type PrimitiveResponse = string | number | boolean;\r\nexport type ArrayResponse = Prettify<Array<PrimitiveResponse> | TupleToArraysUnion<UnionToTuple<PrimitiveResponse>, true>>;\r\nexport type ObjectResponse = { [K in string | number]: PrimitiveResponse | ArrayResponse | ObjectResponse; };\r\nexport type SimpleResponse = PrimitiveResponse | ArrayResponse | ObjectResponse;\r\nexport type GeneratorResponse = Generator<SimpleResponse> | AsyncGenerator<SimpleResponse>;\r\nexport type ResponseValueType = PrimitiveResponse | ArrayResponse | ObjectResponse | GeneratorResponse;\r\nexport type ResponseData<T extends ResponseValueType> = {\r\n  ok: true;\r\n  status: number;\r\n  data: T extends Generator<infer U> ? AsyncGenerator<U> : T;\r\n  response: Response;\r\n} | {\r\n  ok: false;\r\n  status?: number;\r\n  response?: Response;\r\n  error: Error;\r\n};\r\n\r\n\r\nexport const HttpMethods = [\"GET\", \"POST\", \"PUT\", \"DELETE\"] as const;\r\nexport type HTTPMethod = (typeof HttpMethods)[number];\r\nexport type Cookie = {\r\n  value: string | undefined;\r\n  secure: boolean;\r\n  expireDate: Date | undefined;\r\n  maxAge: number | undefined;\r\n  sameSite: \"Strict\" | \"Lax\" | \"None\" | undefined;\r\n  remove(): void;\r\n}\r\n\r\nexport function isGeneratorObject(obj: any): obj is Generator<any> {\r\n  if (obj == null) return false;\r\n  if (typeof obj !== \"object\") return false;\r\n  // If someone changes this value, they should be striken down by the entire pantheon of eldritch horrors and Gods of all religions/mythologies\r\n  if (obj[Symbol.toStringTag] !== \"Generator\") return false;\r\n  return true;\r\n}\r\nexport function isAsyncGeneratorObject(obj: any): obj is AsyncGenerator<any> {\r\n  if (obj == null) return false;\r\n  if (typeof obj !== \"object\") return false;\r\n  // If someone changes this value, they should be striken down by the entire pantheon of eldritch horrors and Gods of all religions/mythologies\r\n  if (obj[Symbol.toStringTag] !== \"AsyncGenerator\") return false;\r\n  return true;\r\n}\r\n\r\nexport const GeneratorHTTPHeaderName = \"X-AncientOnes-Streaming\";\r\n\r\n","import type {\r\n  AncientOne,\r\n  RouteHandler,\r\n} from \"./ancients\";\r\nimport type {\r\n  HTTPMethod,\r\n  ObjectValues,\r\n  Prettify,\r\n  ResponseData,\r\n  ResponseValueType,\r\n  SplitString,\r\n  TuplePush,\r\n  TupleRemove,\r\n  UnionToTuple\r\n} from \"./utils\";\r\nimport {\r\n  HttpMethods,\r\n  GeneratorHTTPHeaderName,\r\n} from \"./utils\";\r\n\r\ntype FindPathParamNames<Path extends string> = FindPathParamNamesRec<SplitString<Path, \"/\", true>, []>;\r\ntype FindPathParamNamesRec<PathParts extends string[], Names extends string[]> =\r\n  PathParts extends []\r\n  ? Names\r\n  : PathParts extends [infer Head extends string, ...infer Tail extends string[]]\r\n  ? Head extends `:${infer PathParam extends string}`\r\n  ? FindPathParamNamesRec<Tail, TuplePush<Names, PathParam>>\r\n  : FindPathParamNamesRec<Tail, Names>\r\n  : never\r\n  ;\r\n\r\n\r\nexport type Apostle<Ancient extends AncientOne<any, Record<string, { [M in Lowercase<HTTPMethod>]: RouteHandler<any, any> }>>> =\r\n  Ancient extends AncientOne<infer Prefix extends string, any>\r\n  ? ObjectValues<{ [Path in keyof Ancient[\"__TYPE_LEVEL_T\"]as Path extends string ? Path : never]: Path extends string ? CreateRoutine<SplitString<`${Prefix}${Path}`, \"/\", true>, Path, Ancient[\"__TYPE_LEVEL_T\"], FindPathParamNames<Path>> : never; }>\r\n  : never;\r\n\r\ntype CreateRoutine<PathParts extends string[], FullPath extends string, Handlers extends Record<string, { [M in Lowercase<HTTPMethod>]: RouteHandler<any, any> }>, PathParamNames extends string[]> =\r\n  PathParts extends []\r\n  ? {\r\n    [M in keyof Handlers[FullPath]as M extends \"\" ? never : Handlers[FullPath][M] extends never ? never : Handlers[FullPath][M] extends RouteHandler<any, any> ? M : never]: Handlers[FullPath][M] extends RouteHandler<infer Return, infer PathParams>\r\n    ? PathParamNames extends []\r\n    ? (cfg?: { query?: Record<string, string | string[]>; }) => Promise<ResponseData<Return>>\r\n    : Prettify<Omit<PathParams, PathParamNames[number]>> extends Record<string, never>\r\n    ? (cfg?: { query?: Record<string, string | string[]>; }) => Promise<ResponseData<Return>>\r\n    : (cfg: { params: Prettify<Omit<PathParams, PathParamNames[number]>>, query?: Record<string, string | string[]>; }) => Promise<ResponseData<Return>>\r\n    : never;\r\n  }\r\n  : PathParts extends [infer Head extends string, ...infer Tail extends string[]]\r\n  ? Head extends `:${infer PathParam}`\r\n  ? Tail extends []\r\n  // @ts-expect-error TupleRemove doesn't explicitly return string[] but it is a string[] because the passed tuple is a string[]\r\n  ? { (params: { [param in PathParam]: string }): CreateRoutine<[], FullPath, Handlers, PathParamNames>; } & CreateRoutine<[], FullPath, Handlers, TupleRemove<PathParamNames, PathParam>>\r\n  : (params: { [param in PathParam]: string }) => CreateRoutine<Tail, FullPath, Handlers, Exclude<PathParamNames, PathParam>>\r\n  : { [path in Head]: CreateRoutine<Tail, FullPath, Handlers, PathParamNames>; }\r\n  : CreateRoutine<[], FullPath, Handlers, PathParamNames>;\r\n\r\nexport const DEBUG_PATHING_PROPERTY = \"__DEBUG_PATHING__\";\r\n\r\nasync function* streamToGenerator(reader: ReadableStreamDefaultReader<Uint8Array<ArrayBufferLike>>) {\r\n  const decode = (data: any) => new TextDecoder().decode(data);\r\n  do {\r\n    const step = await reader.read();\r\n    if (step.done) {\r\n      return;\r\n    }\r\n    const json = decode(step.value);\r\n    const data = JSON.parse(json);\r\n    yield data.data;\r\n  } while (true);\r\n}\r\nconst PROTOCOL_CHECK_REGEX = /^https?:\\/\\//;\r\nexport function createApostle<\r\n  Ancient extends AncientOne<any, Record<string, { [M in Lowercase<HTTPMethod>]: RouteHandler<any, any> }>>\r\n>(origin: string): Apostle<Ancient> {\r\n  origin = origin.trim();\r\n  if (!origin.match(PROTOCOL_CHECK_REGEX)) {\r\n    throw new Error(\"Origin must start with the protocol (http:// or https://)\");\r\n  }\r\n  while (origin.endsWith(\"/\")) {\r\n    origin = origin.substring(0, origin.length - 1);\r\n  }\r\n  const pushParams = (path: string, params: Record<string, string> = {}) => {\r\n    for (const param of Object.keys(params)) {\r\n      path += \"/\" + params[param];\r\n    }\r\n    return path;\r\n  };\r\n  type FetchConfig = {\r\n    params?: Record<string, string>;\r\n    query?: Record<string, string | string[]>;\r\n    body?: BodyInit;\r\n  };\r\n  const doFetch = async (method: HTTPMethod, path: string, config: FetchConfig = {}): Promise<ResponseData<ResponseValueType>> => {\r\n    try {\r\n      if (config.params) {\r\n        for (const key of Object.keys(config.params ?? {})) {\r\n          path += \"/\" + config.params[key];\r\n        }\r\n      }\r\n      const url = new URL(path);\r\n      if (config.query) {\r\n        for (const key of Object.keys(config.query ?? {})) {\r\n          const val = config.query[key]!;\r\n          if (!Array.isArray(val)) {\r\n            url.searchParams.append(key, val);\r\n            continue;\r\n          }\r\n          for (const v of val) {\r\n            url.searchParams.append(key, v);\r\n          }\r\n        }\r\n      }\r\n      const response = await fetch(url, {\r\n        method,\r\n        body: config.body,\r\n      });\r\n      if (!response.ok) {\r\n        const message = await response.text();\r\n        return { ok: false, status: response.status, response, error: new Error(message) };\r\n      }\r\n      const status = response.status;\r\n      const generatorHeader = response.headers.get(GeneratorHTTPHeaderName);\r\n      if (generatorHeader === \"Generator\" || generatorHeader === \"AsyncGenerator\") {\r\n        if (!response.body) {\r\n          return { ok: false, status, response, error: new Error(\"Received generator header but there's no body to read stream from\") };\r\n        }\r\n        const reader = response.body.getReader();\r\n        const generator = streamToGenerator(reader);\r\n        return { ok: true, status, response, data: generator };\r\n      }\r\n\r\n      const res = await response.json() as { data: any };\r\n      // Maybe handle other stuff here\r\n      return { ok: true, status, response, data: res.data };\r\n    } catch (err) {\r\n      // @ts-ignore Cause is not supported in my version of tsc, TODO: fix it\r\n      const error = new Error(\"Fetch request failed\", { cause: err });\r\n      return { ok: false, error };\r\n    }\r\n  };\r\n  const methods = HttpMethods.map((x) => x.toLowerCase()) as UnionToTuple<Lowercase<HTTPMethod>>;\r\n\r\n  const p = new Proxy({ pathing: origin }, {\r\n    get(target, property: symbol | (typeof methods)[number] | (string & {})) {\r\n      if (typeof property === \"symbol\") {\r\n        return (target as any)[property];\r\n      }\r\n\r\n      if (property === DEBUG_PATHING_PROPERTY) return target.pathing;\r\n\r\n      if (methods.includes(property as any)) {\r\n        return doFetch.bind(null, property.toUpperCase() as any, target.pathing);\r\n      }\r\n\r\n      return pathing(origin + \"/\" + property);\r\n    }\r\n  });\r\n  const pathing = (path: string) => {\r\n    const data = { pathing: path };\r\n    const fn = (params: Record<string, string>) => {\r\n      data.pathing = pushParams(data.pathing, params);\r\n      return proxy;\r\n    };\r\n    const proxy = new Proxy(fn, {\r\n      get(target, property) {\r\n        if (typeof property === \"symbol\") {\r\n          // @ts-ignore\r\n          return target[property];\r\n        }\r\n\r\n        if (property === DEBUG_PATHING_PROPERTY) return data.pathing;\r\n        if (methods.includes(property as any)) {\r\n          return doFetch.bind(null, property.toUpperCase() as any, data.pathing);\r\n        }\r\n\r\n        return pathing(`${data.pathing}/${property}`);\r\n      }\r\n    });\r\n    return proxy;\r\n  };\r\n  return p as any;\r\n}\r\n"],"mappings":"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"}