@kaito-http/core 1.3.2 → 2.0.0

package/README.md

@@ -1,12 +1,12 @@
-# `kaito-http`
-
-[![Vercel](https://github.com/kaito-http/kaito/raw/main/static/powered-by-vercel.svg)](https://vercel.com?utm_source=kaito-http&utm_campaign=oss)
-
-#### An HTTP Framework for TypeScript
-
-View the [documentation here](https://kaito.cloud)
-
-#### Credits
-
-- [Vercel](https://vercel.com?utm_source=kaito-http&utm_campaign=oss), for sponsoring the project and hosting the documentation
-- [Alistair Smith](https://twitter.com/aabbccsmith)
+# `kaito-http`
+
+[![Vercel](https://github.com/kaito-http/kaito/raw/main/static/powered-by-vercel.svg)](https://vercel.com?utm_source=kaito-http&utm_campaign=oss)
+
+#### An HTTP Framework for TypeScript
+
+View the [documentation here](https://kaito.cloud)
+
+#### Credits
+
+- [Vercel](https://vercel.com?utm_source=kaito-http&utm_campaign=oss), for sponsoring the project and hosting the documentation
+- [Alistair Smith](https://twitter.com/aabbccsmith)

package/dist/declarations/src/index.d.ts

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

package/dist/declarations/src/server.d.ts

@@ -0,0 +1,99 @@
+/// <reference types="node" />
+import { FastifyReply, FastifyRequest } from 'fastify';
+import { z, ZodTypeAny } from 'zod';
+export declare enum Method {
+    GET = "GET",
+    POST = "POST",
+    PATCH = "PATCH",
+    DELETE = "DELETE"
+}
+export declare type GetContext<T> = (req: FastifyRequest, res: FastifyReply) => Promise<T>;
+declare type Never = [never];
+export declare function createGetContext<T>(getContext: GetContext<T>): GetContext<T>;
+export declare type InferContext<T> = T extends GetContext<infer Value> ? Value : never;
+export declare type ContextWithInput<Ctx, Input> = {
+    ctx: Ctx;
+    input: Input;
+};
+declare type Values<T> = T[keyof T];
+declare type Proc<Ctx, Result, Input extends z.ZodTypeAny | Never = Never> = Readonly<{
+    input?: Input;
+    run(arg: ContextWithInput<Ctx, Input extends ZodTypeAny ? z.infer<Input> : undefined>): Promise<Result>;
+}>;
+declare type ProcsInit<Ctx> = {
+    [Key in string]: Proc<Ctx, unknown, z.ZodTypeAny> & {
+        method: Method;
+        name: Key;
+    };
+};
+declare type AnyRouter<Ctx> = Router<Ctx, ProcsInit<Ctx>>;
+export declare class Router<Ctx, Procs extends ProcsInit<Ctx>> {
+    private readonly procs;
+    constructor(procs: Procs);
+    getProcs(): Procs;
+    private readonly create;
+    readonly merge: <NewCtx>(router: AnyRouter<NewCtx>) => Router<NewCtx & Ctx, Procs & ProcsInit<NewCtx>>;
+    readonly get: <Name extends string, Result, Input extends z.ZodTypeAny>(name: Name, proc: Readonly<{
+        input?: Input | undefined;
+        run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
+    }>) => Router<Ctx, Procs & Record<Name, Readonly<{
+        input?: Input | undefined;
+        run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
+    }> & {
+        method: Method.GET;
+        name: Name;
+    }>>;
+    readonly post: <Name extends string, Result, Input extends z.ZodTypeAny>(name: Name, proc: Readonly<{
+        input?: Input | undefined;
+        run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
+    }>) => Router<Ctx, Procs & Record<Name, Readonly<{
+        input?: Input | undefined;
+        run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
+    }> & {
+        method: Method.POST;
+        name: Name;
+    }>>;
+    readonly patch: <Name extends string, Result, Input extends z.ZodTypeAny>(name: Name, proc: Readonly<{
+        input?: Input | undefined;
+        run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
+    }>) => Router<Ctx, Procs & Record<Name, Readonly<{
+        input?: Input | undefined;
+        run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
+    }> & {
+        method: Method.PATCH;
+        name: Name;
+    }>>;
+    readonly delete: <Name extends string, Result, Input extends z.ZodTypeAny>(name: Name, proc: Readonly<{
+        input?: Input | undefined;
+        run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
+    }>) => Router<Ctx, Procs & Record<Name, Readonly<{
+        input?: Input | undefined;
+        run(arg: ContextWithInput<Ctx, Input extends z.ZodTypeAny ? z.TypeOf<Input> : undefined>): Promise<Result>;
+    }> & {
+        method: Method.DELETE;
+        name: Name;
+    }>>;
+}
+export declare class KaitoError extends Error {
+    readonly code: number;
+    readonly cause?: Error | undefined;
+    constructor(code: number, message: string, cause?: Error | undefined);
+}
+export declare function createRouter<Ctx>(): Router<Ctx, {}>;
+export declare type InferApiResponseType<R extends AnyRouter<unknown>, M extends Method, Path extends Extract<Values<ReturnType<R['getProcs']>>, {
+    method: M;
+}>['name']> = ReturnType<ReturnType<R['getProcs']>[Path]['run']> extends Promise<infer V> ? V : never;
+export declare function createServer<Ctx, R extends Router<Ctx, ProcsInit<Ctx>>>(config: {
+    getContext: GetContext<Ctx>;
+    router: R;
+    onError(error: {
+        error: Error;
+        req: FastifyRequest;
+        res: FastifyReply;
+    }): Promise<{
+        code: number;
+        message: string;
+    }>;
+    log?: (message: string) => unknown | false;
+}): import("fastify").FastifyInstance<import("http").Server, import("http").IncomingMessage, import("http").ServerResponse, import("fastify").FastifyLoggerInstance> & PromiseLike<import("fastify").FastifyInstance<import("http").Server, import("http").IncomingMessage, import("http").ServerResponse, import("fastify").FastifyLoggerInstance>>;
+export {};

package/dist/kaito-http-core.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./declarations/src/index";

package/dist/kaito-http-core.cjs.dev.js

@@ -0,0 +1,232 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var fastify = require('fastify');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var fastify__default = /*#__PURE__*/_interopDefault(fastify);
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg);
+    var value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+
+  if (info.done) {
+    resolve(value);
+  } else {
+    Promise.resolve(value).then(_next, _throw);
+  }
+}
+
+function _asyncToGenerator(fn) {
+  return function () {
+    var self = this,
+        args = arguments;
+    return new Promise(function (resolve, reject) {
+      var gen = fn.apply(self, args);
+
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+
+      _next(undefined);
+    });
+  };
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+
+    if (enumerableOnly) {
+      symbols = symbols.filter(function (sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      });
+    }
+
+    keys.push.apply(keys, symbols);
+  }
+
+  return keys;
+}
+
+function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+
+    if (i % 2) {
+      ownKeys(Object(source), true).forEach(function (key) {
+        _defineProperty(target, key, source[key]);
+      });
+    } else if (Object.getOwnPropertyDescriptors) {
+      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+      ownKeys(Object(source)).forEach(function (key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+  }
+
+  return target;
+}
+
+exports.Method = void 0;
+
+(function (Method) {
+  Method["GET"] = "GET";
+  Method["POST"] = "POST";
+  Method["PATCH"] = "PATCH";
+  Method["DELETE"] = "DELETE";
+})(exports.Method || (exports.Method = {}));
+
+function createGetContext(getContext) {
+  return getContext;
+}
+class Router {
+  constructor(procs) {
+    _defineProperty(this, "create", method => (name, proc) => {
+      return new Router(_objectSpread2(_objectSpread2({}, this.procs), {}, {
+        [name]: _objectSpread2(_objectSpread2({}, proc), {}, {
+          method,
+          name
+        })
+      }));
+    });
+
+    _defineProperty(this, "merge", router => new Router(_objectSpread2(_objectSpread2({}, this.procs), router.getProcs())));
+
+    _defineProperty(this, "get", this.create(exports.Method.GET));
+
+    _defineProperty(this, "post", this.create(exports.Method.POST));
+
+    _defineProperty(this, "patch", this.create(exports.Method.PATCH));
+
+    _defineProperty(this, "delete", this.create(exports.Method.DELETE));
+
+    this.procs = procs;
+  }
+
+  getProcs() {
+    return this.procs;
+  }
+
+}
+class KaitoError extends Error {
+  constructor(code, message, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+  }
+
+}
+function createRouter() {
+  return new Router({});
+}
+function createServer(config) {
+  var tree = config.router.getProcs();
+  var app = fastify__default["default"]();
+  app.setErrorHandler( /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator(function* (error, req, res) {
+      if (error instanceof KaitoError) {
+        yield res.status(error.code).send({
+          success: false,
+          data: null,
+          message: error.message
+        });
+        return;
+      }
+
+      var {
+        code,
+        message
+      } = yield config.onError({
+        error,
+        req,
+        res
+      }).catch(() => ({
+        code: 500,
+        message: 'Something went wrong'
+      }));
+      yield res.status(code).send({
+        success: false,
+        data: null,
+        message
+      });
+    });
+
+    return function (_x, _x2, _x3) {
+      return _ref.apply(this, arguments);
+    };
+  }());
+  app.all('*', /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator(function* (req, res) {
+      var _handler$input$parse, _handler$input;
+
+      var logMessage = "".concat(req.hostname, " ").concat(req.method, " ").concat(req.routerPath);
+
+      if (config.log === undefined) {
+        console.log(logMessage);
+      } else if (config.log) {
+        config.log(logMessage);
+      }
+
+      var url = new URL("".concat(req.protocol, "://").concat(req.hostname).concat(req.url));
+      var handler = tree[url.pathname];
+
+      if (!handler) {
+        throw new KaitoError(404, "Cannot ".concat(req.method, " this route."));
+      }
+
+      var context = yield config.getContext(req, res); // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+
+      var input = (_handler$input$parse = (_handler$input = handler.input) === null || _handler$input === void 0 ? void 0 : _handler$input.parse(req.method === 'GET' ? req.query : req.body)) !== null && _handler$input$parse !== void 0 ? _handler$input$parse : null;
+      yield res.send({
+        success: true,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        data: yield handler.run({
+          ctx: context,
+          input
+        }),
+        message: 'OK'
+      });
+    });
+
+    return function (_x4, _x5) {
+      return _ref2.apply(this, arguments);
+    };
+  }());
+  return app;
+}
+
+exports.KaitoError = KaitoError;
+exports.Router = Router;
+exports.createGetContext = createGetContext;
+exports.createRouter = createRouter;
+exports.createServer = createServer;

package/dist/kaito-http-core.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./kaito-http-core.cjs.prod.js");
+} else {
+  module.exports = require("./kaito-http-core.cjs.dev.js");
+}

package/dist/kaito-http-core.cjs.prod.js

@@ -0,0 +1,232 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var fastify = require('fastify');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var fastify__default = /*#__PURE__*/_interopDefault(fastify);
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg);
+    var value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+
+  if (info.done) {
+    resolve(value);
+  } else {
+    Promise.resolve(value).then(_next, _throw);
+  }
+}
+
+function _asyncToGenerator(fn) {
+  return function () {
+    var self = this,
+        args = arguments;
+    return new Promise(function (resolve, reject) {
+      var gen = fn.apply(self, args);
+
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+
+      _next(undefined);
+    });
+  };
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+
+    if (enumerableOnly) {
+      symbols = symbols.filter(function (sym) {
+        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+      });
+    }
+
+    keys.push.apply(keys, symbols);
+  }
+
+  return keys;
+}
+
+function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+
+    if (i % 2) {
+      ownKeys(Object(source), true).forEach(function (key) {
+        _defineProperty(target, key, source[key]);
+      });
+    } else if (Object.getOwnPropertyDescriptors) {
+      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+      ownKeys(Object(source)).forEach(function (key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+  }
+
+  return target;
+}
+
+exports.Method = void 0;
+
+(function (Method) {
+  Method["GET"] = "GET";
+  Method["POST"] = "POST";
+  Method["PATCH"] = "PATCH";
+  Method["DELETE"] = "DELETE";
+})(exports.Method || (exports.Method = {}));
+
+function createGetContext(getContext) {
+  return getContext;
+}
+class Router {
+  constructor(procs) {
+    _defineProperty(this, "create", method => (name, proc) => {
+      return new Router(_objectSpread2(_objectSpread2({}, this.procs), {}, {
+        [name]: _objectSpread2(_objectSpread2({}, proc), {}, {
+          method,
+          name
+        })
+      }));
+    });
+
+    _defineProperty(this, "merge", router => new Router(_objectSpread2(_objectSpread2({}, this.procs), router.getProcs())));
+
+    _defineProperty(this, "get", this.create(exports.Method.GET));
+
+    _defineProperty(this, "post", this.create(exports.Method.POST));
+
+    _defineProperty(this, "patch", this.create(exports.Method.PATCH));
+
+    _defineProperty(this, "delete", this.create(exports.Method.DELETE));
+
+    this.procs = procs;
+  }
+
+  getProcs() {
+    return this.procs;
+  }
+
+}
+class KaitoError extends Error {
+  constructor(code, message, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+  }
+
+}
+function createRouter() {
+  return new Router({});
+}
+function createServer(config) {
+  var tree = config.router.getProcs();
+  var app = fastify__default["default"]();
+  app.setErrorHandler( /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator(function* (error, req, res) {
+      if (error instanceof KaitoError) {
+        yield res.status(error.code).send({
+          success: false,
+          data: null,
+          message: error.message
+        });
+        return;
+      }
+
+      var {
+        code,
+        message
+      } = yield config.onError({
+        error,
+        req,
+        res
+      }).catch(() => ({
+        code: 500,
+        message: 'Something went wrong'
+      }));
+      yield res.status(code).send({
+        success: false,
+        data: null,
+        message
+      });
+    });
+
+    return function (_x, _x2, _x3) {
+      return _ref.apply(this, arguments);
+    };
+  }());
+  app.all('*', /*#__PURE__*/function () {
+    var _ref2 = _asyncToGenerator(function* (req, res) {
+      var _handler$input$parse, _handler$input;
+
+      var logMessage = "".concat(req.hostname, " ").concat(req.method, " ").concat(req.routerPath);
+
+      if (config.log === undefined) {
+        console.log(logMessage);
+      } else if (config.log) {
+        config.log(logMessage);
+      }
+
+      var url = new URL("".concat(req.protocol, "://").concat(req.hostname).concat(req.url));
+      var handler = tree[url.pathname];
+
+      if (!handler) {
+        throw new KaitoError(404, "Cannot ".concat(req.method, " this route."));
+      }
+
+      var context = yield config.getContext(req, res); // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+
+      var input = (_handler$input$parse = (_handler$input = handler.input) === null || _handler$input === void 0 ? void 0 : _handler$input.parse(req.method === 'GET' ? req.query : req.body)) !== null && _handler$input$parse !== void 0 ? _handler$input$parse : null;
+      yield res.send({
+        success: true,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        data: yield handler.run({
+          ctx: context,
+          input
+        }),
+        message: 'OK'
+      });
+    });
+
+    return function (_x4, _x5) {
+      return _ref2.apply(this, arguments);
+    };
+  }());
+  return app;
+}
+
+exports.KaitoError = KaitoError;
+exports.Router = Router;
+exports.createGetContext = createGetContext;
+exports.createRouter = createRouter;
+exports.createServer = createServer;