@devbro/pashmak 0.1.7 → 0.1.9

package/dist/bin/router.cjs

@@ -0,0 +1,547 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/router.mts
+var router_exports = {};
+__export(router_exports, {
+  BaseController: () => BaseController,
+  CompiledRoute: () => CompiledRoute,
+  Controller: () => Controller,
+  Delete: () => Delete,
+  Get: () => Get,
+  Middleware: () => Middleware,
+  MiddlewareFactory: () => MiddlewareFactory,
+  Model: () => Model,
+  Options: () => Options,
+  Param: () => Param,
+  Patch: () => Patch,
+  Post: () => Post,
+  Put: () => Put,
+  Route: () => Route,
+  Router: () => Router,
+  ValidatedRequest: () => ValidatedRequest,
+  createParamDecorator: () => createParamDecorator,
+  runNext: () => runNext
+});
+module.exports = __toCommonJS(router_exports);
+var import_neko_context = require("@devbro/neko-context");
+var import_errors = require("@devbro/neko-http/errors");
+
+// ../neko-router/dist/Middleware.mjs
+var Middleware = class {
+  static {
+    __name(this, "Middleware");
+  }
+  constructor(params = {}) {
+  }
+  static getInstance(params) {
+    throw new Error("Method not implemented. Please implement a static getInstance method.");
+  }
+};
+
+// ../neko-router/dist/MiddlewareFactory.mjs
+var MiddlewareFactory = class {
+  static {
+    __name(this, "MiddlewareFactory");
+  }
+  static create(func) {
+    const cls = class extends Middleware {
+      static {
+        __name(this, "cls");
+      }
+      call(req, res, next) {
+        return func(req, res, next);
+      }
+      constructor(params = {}) {
+        super(params);
+      }
+    };
+    return new cls();
+  }
+};
+
+// ../neko-router/dist/CompiledRoute.mjs
+var CompiledRoute = class {
+  static {
+    __name(this, "CompiledRoute");
+  }
+  constructor(route, request, response, globalMiddlewares = []) {
+    this.route = route;
+    this.request = request;
+    this.response = response;
+    this.globalMiddlewares = globalMiddlewares;
+    this.prepareMiddlewares();
+  }
+  middlewares = [];
+  getMiddlewares() {
+    return this.middlewares;
+  }
+  prepareMiddlewares() {
+    this.middlewares = [];
+    for (const middleware of [...this.globalMiddlewares, ...this.route.getMiddlewares()]) {
+      if (middleware instanceof Middleware) {
+        this.middlewares.push(middleware);
+      } else if (this.isClass(middleware)) {
+        this.middlewares.push(middleware.getInstance({}));
+      } else if (typeof middleware === "function") {
+        this.middlewares.push(MiddlewareFactory.create(middleware));
+      } else {
+        throw new Error("Invalid middleware type");
+      }
+    }
+  }
+  isClass(func) {
+    return typeof func === "function" && /^class\s/.test(Function.prototype.toString.call(func));
+  }
+  async run() {
+    return await this.runMiddlewares(this.middlewares, this.request, this.response);
+  }
+  prepareOutputJsonFormat(obj) {
+    function traverse(value) {
+      if (!value || typeof value !== "object") {
+        return value;
+      }
+      if (typeof value.toJson === "function") {
+        return traverse(value.toJson());
+      }
+      if (Array.isArray(value)) {
+        return value.map(traverse);
+      }
+      const result = {};
+      for (const key in value) {
+        if (Object.prototype.hasOwnProperty.call(value, key)) {
+          result[key] = traverse(value[key]);
+        }
+      }
+      return result;
+    }
+    __name(traverse, "traverse");
+    return traverse(obj);
+  }
+  convertToString(obj) {
+    if (typeof obj === "string") {
+      return obj;
+    } else if (obj instanceof Buffer) {
+      return obj.toString();
+    } else if (typeof obj === "object") {
+      return JSON.stringify(this.prepareOutputJsonFormat(obj));
+    }
+    return String(obj);
+  }
+  processResponseBody(res, controller_rc) {
+    if (controller_rc && res.writableEnded) {
+      throw new Error("cannot write to response, response has already ended");
+    }
+    if (res.writableEnded) {
+      return;
+    }
+    if (controller_rc) {
+      const header_content_type = res.getHeader("Content-Type");
+      if (!header_content_type && typeof controller_rc === "object") {
+        res.setHeader("Content-Type", "application/json");
+      } else if (!header_content_type) {
+        res.setHeader("Content-Type", "text/plain");
+      }
+      res.end(this.convertToString(controller_rc));
+      return;
+    } else {
+      res.statusCode = [200].includes(res.statusCode) ? 204 : res.statusCode;
+      res.end();
+    }
+  }
+  async runMiddlewares(middlewares, req, res) {
+    let index = 0;
+    const me = this;
+    async function next() {
+      if (index >= middlewares.length) {
+        const controller_rc = await me.route.callHanlder(req, res);
+        await me.processResponseBody(res, controller_rc);
+        return;
+      }
+      const middleware = middlewares[index++];
+      if (middleware instanceof Middleware) {
+        await middleware.call(req, res, next);
+      } else if (typeof middleware === "function") {
+        await middleware(req, res, next);
+      } else {
+        throw new Error("does not know how to run middleware");
+      }
+    }
+    __name(next, "next");
+    await next();
+  }
+};
+
+// ../neko-router/dist/Controller.mjs
+var BaseController = class {
+  static {
+    __name(this, "BaseController");
+  }
+  static basePath = "";
+  static baseMiddlewares;
+  static getInstance() {
+    return new this();
+  }
+};
+function Controller(path2, options = {}) {
+  return function(target) {
+    target.routes = target.routes || [];
+    target.basePath = path2;
+    target.baseMiddlewares = options.middlewares || [];
+  };
+}
+__name(Controller, "Controller");
+function createHttpDecorator(data) {
+  return function(target, propertyKey, descriptor) {
+    const ctor = target.constructor;
+    if (!ctor.routes) ctor.routes = [];
+    ctor.routes.push({
+      methods: data.methods,
+      path: data.path,
+      handler: propertyKey,
+      middlewares: data.middlewares || []
+    });
+    const originalMethod = descriptor.value;
+    const paramKeys = Reflect.ownKeys(target.constructor);
+    const methodName = propertyKey.toString();
+    descriptor.value = async function(...args) {
+      const paramCustomKeys = paramKeys.filter(
+        (key) => typeof key === "string" && key.startsWith(`${methodName}:`) && key.endsWith(":custom")
+      );
+      for (const paramKey of paramCustomKeys) {
+        const paramIndex = parseInt(paramKey.split(":")[1]);
+        let method = Reflect.get(target.constructor, paramKey.toString());
+        if (typeof paramIndex === "number" && typeof method === "function") {
+          args[paramIndex] = await method();
+        }
+      }
+      return originalMethod.apply(this, args);
+    };
+  };
+}
+__name(createHttpDecorator, "createHttpDecorator");
+function Get(data = {}) {
+  return createHttpDecorator({
+    methods: ["GET", "HEAD"],
+    path: data.path || "/",
+    middlewares: data.middlewares || []
+  });
+}
+__name(Get, "Get");
+function Post(data = {}) {
+  return createHttpDecorator({
+    methods: ["POST"],
+    path: data.path || "/",
+    middlewares: data.middlewares || []
+  });
+}
+__name(Post, "Post");
+function Put(data = {}) {
+  return createHttpDecorator({
+    methods: ["PUT"],
+    path: data.path || "/",
+    middlewares: data.middlewares || []
+  });
+}
+__name(Put, "Put");
+function Patch(data = {}) {
+  return createHttpDecorator({
+    methods: ["PATCH"],
+    path: data.path || "/",
+    middlewares: data.middlewares || []
+  });
+}
+__name(Patch, "Patch");
+function Delete(data = {}) {
+  return createHttpDecorator({
+    methods: ["DELETE"],
+    path: data.path || "/",
+    middlewares: data.middlewares || []
+  });
+}
+__name(Delete, "Delete");
+function Options(data = {}) {
+  return createHttpDecorator({
+    methods: ["OPTIONS"],
+    path: data.path || "/",
+    middlewares: data.middlewares || []
+  });
+}
+__name(Options, "Options");
+function createParamDecorator(func) {
+  return /* @__PURE__ */ __name(function MyParamDecorator(target, propertyKey, parameterIndex) {
+    Reflect.set(target.constructor, `${propertyKey?.toString()}:${parameterIndex}:custom`, func);
+  }, "MyParamDecorator");
+}
+__name(createParamDecorator, "createParamDecorator");
+
+// ../neko-router/dist/Route.mjs
+var Route = class {
+  static {
+    __name(this, "Route");
+  }
+  constructor(methods, path2, handler) {
+    this.methods = methods;
+    this.path = path2;
+    this.handler = handler;
+    this.urlRegex = this.pathToRegex(path2);
+  }
+  middlewares = [];
+  urlRegex;
+  pathToRegex(path2) {
+    const lex = this.lexUrlPath(path2);
+    return this.tokensToRegex(lex);
+  }
+  lexUrlPath(path2) {
+    const tokens = [];
+    let i = 0;
+    while (i < path2.length) {
+      const char = path2[i];
+      if (char === "/") {
+        tokens.push({ type: "SLASH", value: "/" });
+        i++;
+      } else if (char === ":") {
+        let start = i + 1;
+        while (start < path2.length && /[a-zA-Z0-9_]/.test(path2[start])) {
+          start++;
+        }
+        tokens.push({ type: "PARAM", value: path2.slice(i + 1, start) });
+        i = start;
+      } else if (char === "*") {
+        let start = i + 1;
+        while (start < path2.length && /[a-zA-Z0-9_]/.test(path2[start])) {
+          start++;
+        }
+        tokens.push({ type: "WILDCARD", value: path2.slice(i + 1, start) });
+        i = start;
+      } else {
+        let start = i;
+        while (start < path2.length && !["/", ":", "*"].includes(path2[start])) {
+          start++;
+        }
+        tokens.push({ type: "TEXT", value: path2.slice(i, start) });
+        i = start;
+      }
+    }
+    return tokens;
+  }
+  tokensToRegex(tokens) {
+    const regexParts = [];
+    for (const token of tokens) {
+      if (token.type === "SLASH") {
+        regexParts.push("\\/");
+      } else if (token.type === "PARAM") {
+        regexParts.push(`(?<${token.value}>[^\\/]+)`);
+      } else if (token.type === "WILDCARD") {
+        regexParts.push("(.+)");
+      } else if (token.type === "TEXT") {
+        regexParts.push(token.value.replace(/[-\/\\^$.*+?()[\]{}|]/g, "\\$&"));
+      }
+    }
+    if (regexParts.length > 0 && regexParts[regexParts.length - 1] === "\\/") {
+      regexParts[regexParts.length - 1] = "\\/?";
+    } else {
+      regexParts.push("\\/?");
+    }
+    return new RegExp(`^${regexParts.join("")}$`);
+  }
+  /**
+   * to evaludate if request is a match for this route
+   * @param request http request
+   * @returns return true if route is a match for this request
+   */
+  test(request) {
+    if (this.methods.indexOf(request.method) === -1) {
+      return false;
+    }
+    const url = new URL(request.url || "/", "http://localhost");
+    return this.testPath(url.pathname);
+  }
+  testPath(pathname) {
+    return this.urlRegex.test(pathname);
+  }
+  /**
+   * returns details of the match, otherwise it returns false
+   * @param request the request to match
+   * @returns object cotaining details of match including matched params
+   */
+  match(request) {
+    if (this.methods.indexOf(request.method) === -1) {
+      return false;
+    }
+    const url = new URL(request.url || "/", "http://localhost");
+    const r = this.urlRegex.exec(url.pathname);
+    if (!r) {
+      return false;
+    }
+    return {
+      url,
+      params: r.groups || {}
+    };
+  }
+  addMiddleware(middlewares) {
+    this.middlewares = this.middlewares.concat(middlewares);
+    return this;
+  }
+  getMiddlewares() {
+    return this.middlewares;
+  }
+  callHanlder(request, response) {
+    return this.handler(request, response);
+  }
+};
+
+// ../neko-router/dist/Router.mjs
+var import_path = __toESM(require("path"), 1);
+var Router = class {
+  static {
+    __name(this, "Router");
+  }
+  middlewares = [];
+  routes = [];
+  addRoute(methods, path2, handler) {
+    const route = new Route(methods, path2, handler);
+    this.routes.push(route);
+    return route;
+  }
+  getMiddlewares() {
+    return [...this.middlewares];
+  }
+  addController(controller) {
+    const basePath = controller.basePath || "";
+    for (const route of controller.routes) {
+      const urlPath = import_path.default.join(basePath, route.path);
+      this.addRoute(route.methods, urlPath, async (req, res) => {
+        const controllerInstance = controller.getInstance();
+        return await controllerInstance[route.handler]();
+      }).addMiddleware([...controller.baseMiddlewares, ...route.middlewares]);
+    }
+  }
+  addGlobalMiddleware(middlewares) {
+    this.middlewares = this.middlewares.concat(middlewares);
+  }
+  resolve(request) {
+    for (const route of this.routes) {
+      if (route.test(request)) {
+        return route;
+      }
+    }
+    return void 0;
+  }
+  resolveMultiple(request) {
+    const rc = [];
+    const url = new URL(request.url || "/", "http://localhost");
+    for (const route of this.routes) {
+      if (route.testPath(url.pathname)) {
+        rc.push(route);
+      }
+    }
+    return rc;
+  }
+  getCompiledRoute(request, response) {
+    const route = this.resolve(request);
+    if (!route) {
+      return void 0;
+    }
+    const match = route.match(request);
+    if (!match) {
+      return void 0;
+    }
+    request.params = match.params;
+    return new CompiledRoute(route, request, response, this.middlewares);
+  }
+};
+
+// ../neko-router/dist/helpers.mjs
+async function runNext(middlewares, req, res, final) {
+  let index = 0;
+  async function next() {
+    if (index >= middlewares.length) {
+      return await final(req, res);
+    }
+    const middleware = middlewares[index++];
+    if (middleware instanceof Middleware) {
+      await middleware.call(req, res, next);
+    } else if (typeof middleware === "function") {
+      await middleware(req, res, next);
+    } else {
+      throw new Error("does not know how to run middleware");
+    }
+  }
+  __name(next, "next");
+  await next();
+}
+__name(runNext, "runNext");
+
+// src/router.mts
+function Model(model, paramName) {
+  return createParamDecorator(async () => {
+    let rc = await model.find((0, import_neko_context.ctx)().get("request").params[paramName]);
+    if (!rc) {
+      throw new import_errors.HttpNotFoundError("Object not found");
+    }
+    return rc;
+  });
+}
+__name(Model, "Model");
+function Param(paramName) {
+  return createParamDecorator(() => {
+    return (0, import_neko_context.ctx)().get("request").params[paramName];
+  });
+}
+__name(Param, "Param");
+function ValidatedRequest(validationRules) {
+  return createParamDecorator(async () => {
+    const rc = await (typeof validationRules === "function" ? validationRules() : validationRules).noUnknown().validate((0, import_neko_context.ctx)().get("request").body, { abortEarly: false });
+    return rc;
+  });
+}
+__name(ValidatedRequest, "ValidatedRequest");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseController,
+  CompiledRoute,
+  Controller,
+  Delete,
+  Get,
+  Middleware,
+  MiddlewareFactory,
+  Model,
+  Options,
+  Param,
+  Patch,
+  Post,
+  Put,
+  Route,
+  Router,
+  ValidatedRequest,
+  createParamDecorator,
+  runNext
+});

package/dist/bin/sql.cjs

@@ -0,0 +1,24 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/sql.mts
+var sql_exports = {};
+module.exports = __toCommonJS(sql_exports);
+__reExport(sql_exports, require("@devbro/neko-sql"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("@devbro/neko-sql")
+});

package/dist/{config.js → config.mjs}

@@ -1,2 +1,2 @@
 export * from "@devbro/neko-config";
-//# sourceMappingURL=config.js.map
+//# sourceMappingURL=config.mjs.map

package/dist/config.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/config.mts"],"sourcesContent":["export * from \"@devbro/neko-config\";\n"],"mappings":"AAAA,cAAc;","names":[]}

package/dist/{context.js → context.mjs}

@@ -1,2 +1,2 @@
 export * from "@devbro/neko-context";
-//# sourceMappingURL=context.js.map
+//# sourceMappingURL=context.mjs.map

package/dist/context.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/context.mts"],"sourcesContent":["export * from \"@devbro/neko-context\";\n"],"mappings":"AAAA,cAAc;","names":[]}