raiton 1.1.1

package/build/chunk-O7R3NJQN.mjs

@@ -0,0 +1,19 @@
+// source/sdk/enums/encrypted.enum.ts
+var HashAlgoEnum = /* @__PURE__ */ ((HashAlgoEnum2) => {
+  HashAlgoEnum2["ARGON2ID"] = "ARGON2ID";
+  HashAlgoEnum2["BCRYPT"] = "BCRYPT";
+  HashAlgoEnum2["PBKDF2"] = "PBKDF2";
+  HashAlgoEnum2["SCRYPT"] = "SCRYPT";
+  HashAlgoEnum2["SHA256"] = "SHA256";
+  HashAlgoEnum2["SHA512"] = "SHA512";
+  HashAlgoEnum2["MD5"] = "MD5";
+  HashAlgoEnum2["RIPEMD160"] = "RIPEMD160";
+  HashAlgoEnum2["BLAKE2B"] = "BLAKE2B";
+  HashAlgoEnum2["SHA3_256"] = "SHA3_256";
+  HashAlgoEnum2["SHA3_512"] = "SHA3_512";
+  return HashAlgoEnum2;
+})(HashAlgoEnum || {});
+
+export {
+  HashAlgoEnum
+};

package/build/chunk-P2YCCBFR.mjs

@@ -0,0 +1,14 @@
+// source/bin/cli.ts
+import { Command } from "commander";
+
+// package.json
+var version = "0.1.0";
+
+// source/bin/cli.ts
+var CLI = new Command();
+CLI.name("raiton").description("Protorians Raiton development kit for backend microservice").version(version);
+var cli_default = CLI;
+
+export {
+  cli_default
+};

package/build/chunk-P3IRIFPT.mjs

@@ -0,0 +1,53 @@
+// source/core/router/route.ts
+var Route = class {
+  method;
+  path;
+  version;
+  handler;
+  parameters = {};
+  constructor(def) {
+    this.method = def.method;
+    this.path = def.path;
+    this.version = def.version;
+    this.handler = def.handler;
+  }
+  get params() {
+    const fullPath = this.version ? `/${this.version}${this.path}` : this.path;
+    const matches = fullPath.match(/:[a-zA-Z0-9_]+/g);
+    return matches ? matches.map((m) => m.substring(1)) : [];
+  }
+  get name() {
+    return this.handler.name;
+  }
+  extractParams(url) {
+    const fullPath = (this.version ? `/${this.version}${this.path}` : this.path).replace(/\/+$/, "");
+    const paramNames = this.params;
+    if (paramNames.length === 0) return this;
+    const regexPath = fullPath.replace(/:[a-zA-Z0-9_]+/g, "([^/]+)");
+    const regex = new RegExp(`^${regexPath || "/"}/?$`);
+    const matches = url.match(regex);
+    if (matches) {
+      const params = {};
+      paramNames.forEach((name, index) => {
+        params[name] = matches[index + 1];
+      });
+      this.parameters = params;
+    }
+    return this;
+  }
+  match(method, url) {
+    if (method !== this.method) return false;
+    const fullPath = (this.version ? `/${this.version}${this.path}` : this.path).replace(/\/+$/, "");
+    const cleanUrl = url.replace(/\/+$/, "");
+    if (!fullPath.includes(":")) {
+      return (fullPath || "/") === (cleanUrl || "/");
+    }
+    const regexPath = fullPath.replace(/:[a-zA-Z0-9_]+/g, "([^/]+)");
+    const regex = new RegExp(`^${regexPath || "/"}/?$`);
+    return regex.test(url);
+  }
+};
+
+export {
+  Route
+};

package/build/chunk-QFSXFOEN.mjs

@@ -0,0 +1,56 @@
+// source/sdk/runtime/node/server.ts
+import http from "http";
+var nodeRuntime = {
+  createServer(handler) {
+    const server = http.createServer(async (req, res) => {
+      const runtimeReq = {
+        method: req.method || "GET",
+        url: req.url || "/",
+        headers: new Headers(req.headers),
+        body: req,
+        remoteAddress: req.socket.remoteAddress
+      };
+      const runtimeReply = {
+        status(code) {
+          res.statusCode = code;
+        },
+        header(name, value) {
+          res.setHeader(name, value);
+        },
+        send(body) {
+          if (body === void 0) {
+            res.end();
+          } else if (typeof body === "string" || Buffer.isBuffer(body)) {
+            res.end(body);
+          } else {
+            res.setHeader("content-type", "application/json");
+            res.end(JSON.stringify(body));
+          }
+        },
+        text(text) {
+          res.end(text);
+        },
+        json(json) {
+          res.end(JSON.stringify(json));
+        }
+      };
+      await handler(runtimeReq, runtimeReply);
+    });
+    return {
+      listen(port) {
+        return new Promise(
+          (resolve) => server.listen(port, resolve)
+        );
+      },
+      close() {
+        return new Promise(
+          (resolve, reject) => server.close((err) => err ? reject(err) : resolve())
+        );
+      }
+    };
+  }
+};
+
+export {
+  nodeRuntime
+};

package/build/chunk-QHCQ4AUA.mjs

@@ -0,0 +1,14 @@
+// source/sdk/constants/decorators.constant.ts
+var SYSTEM_DECORATORS_KEYS = {
+  CONTROLLERS: /* @__PURE__ */ Symbol("controllers"),
+  ROUTES: /* @__PURE__ */ Symbol("routes"),
+  ROUTES_PARAMETERS: /* @__PURE__ */ Symbol("routes:parameters"),
+  ROUTES_METHODS: /* @__PURE__ */ Symbol("routes:methods"),
+  ROUTES_SCHEMES: /* @__PURE__ */ Symbol("routes:scheme:schemas"),
+  GRAFT: /* @__PURE__ */ Symbol("graft"),
+  ACCESS_GUARD: /* @__PURE__ */ Symbol("acces:guard")
+};
+
+export {
+  SYSTEM_DECORATORS_KEYS
+};

package/build/chunk-QI7OFSXB.mjs

@@ -0,0 +1,37 @@
+import {
+  Raiton
+} from "./chunk-YGIZFKLJ.mjs";
+
+// source/core/config.ts
+import path from "path";
+import fs from "fs";
+import { Logger } from "@protorians/logger";
+var RaitonConfig = class {
+  static current = /* @__PURE__ */ new Map();
+  static get(key) {
+    return this.current.get(key);
+  }
+  static defaultConfig = {
+    rootDir: ".",
+    version: "0.0.1"
+  };
+  static load(workdir) {
+    try {
+      if (!this.current.size) {
+        const file = path.join(workdir, `${Raiton.identifier}.config.json`);
+        if (!fs.existsSync(file)) return this.current;
+        const configContent = fs.readFileSync(file, "utf-8");
+        for (const [key, value] of Object.entries({ ...this.defaultConfig, ...JSON.parse(configContent) || {} }))
+          this.current.set(key, value);
+      }
+      return this.current;
+    } catch (e) {
+      Logger.error(`Failed to load ${Raiton.identifier} config:`, e.message ?? e);
+      return this.current;
+    }
+  }
+};
+
+export {
+  RaitonConfig
+};

package/build/chunk-RVH2YBNU.mjs

@@ -0,0 +1,111 @@
+import {
+  tryParseJson
+} from "./chunk-MLFGBJDV.mjs";
+
+// source/sdk/plugins/body-parser.plugin.ts
+import { Logger } from "@protorians/logger";
+function bodyParserPlugin() {
+  return {
+    name: "body-parser-plugin",
+    setup: (scope) => {
+      scope.use(async (ctx, next) => {
+        const contentType = ctx.req.headers.get("content-type") || "";
+        if (ctx.req.body && !ctx.state.bodyParsed) {
+          try {
+            const rawBody = await readRawBody(ctx.req.body);
+            const bodyString = decode(rawBody);
+            readQueryBody(ctx);
+            readJsonBody(ctx, contentType, bodyString);
+            readUrlEncodedBody(ctx, contentType, bodyString);
+            readTextBody(ctx, contentType, bodyString);
+            if (!ctx.state.bodyParsed) {
+              ctx.req.body = rawBody;
+              ctx.state.bodyParsed = true;
+            }
+          } catch (e) {
+            Logger.error("Error parsing body:", e);
+          }
+        }
+        await next();
+      });
+    }
+  };
+}
+function readJsonBody(ctx, contentType, body) {
+  if (contentType.includes("application/json")) {
+    ctx.req.body = tryParseJson(body) || {};
+    ctx.state.bodyParsed = true;
+  }
+}
+function readUrlEncodedBody(ctx, contentType, body) {
+  if (contentType.includes("application/x-www-form-urlencoded")) {
+    const params = new URLSearchParams(body);
+    const record = {};
+    params.forEach((value, key) => {
+      record[key] = value;
+    });
+    ctx.req.body = record;
+    ctx.state.bodyParsed = true;
+  }
+}
+function readTextBody(ctx, contentType, body) {
+  if (contentType.includes("text/")) {
+    ctx.req.body = body;
+    ctx.state.bodyParsed = true;
+  }
+}
+function readQueryBody(ctx) {
+  const searchParams = new URLSearchParams(ctx.req.url.split("?")[1] || "");
+  const record = {};
+  searchParams.forEach((value, key) => record[key] = value);
+  ctx.req.query = record;
+}
+async function readRawBody(body) {
+  if (body instanceof ReadableStream) {
+    const reader = body.getReader();
+    const chunks = [];
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+    }
+    const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return result;
+  }
+  if (typeof body === "object" && body !== null && "on" in body && typeof body.on === "function") {
+    return new Promise((resolve, reject) => {
+      const chunks = [];
+      body.on("data", (chunk) => chunks.push(chunk));
+      body.on("end", () => {
+        if (chunks.length > 0 && typeof chunks[0] === "string") {
+          resolve(chunks.join(""));
+        } else {
+          const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+          const result = new Uint8Array(totalLength);
+          let offset = 0;
+          for (const chunk of chunks) {
+            result.set(new Uint8Array(chunk), offset);
+            offset += chunk.length;
+          }
+          resolve(result);
+        }
+      });
+      body.on("error", reject);
+    });
+  }
+  return body;
+}
+function decode(data) {
+  if (typeof data === "string") return data;
+  return new TextDecoder().decode(data);
+}
+
+export {
+  bodyParserPlugin
+};

package/build/chunk-RXG7754R.mjs

@@ -0,0 +1,25 @@
+// source/sdk/utilities/callable.util.ts
+import { LBadge, Logger } from "@protorians/logger";
+async function retryCallable(label, callback, onFail, trying = 0, limit = 7) {
+  try {
+    Logger.info(
+      LBadge.debug(label || "Running"),
+      LBadge.info(trying),
+      LBadge.log(limit)
+    );
+    await callback();
+  } catch (e) {
+    Logger.info(
+      LBadge.debug("Trying"),
+      LBadge.info(trying),
+      LBadge.log(limit)
+    );
+    if (trying < limit)
+      setTimeout(() => retryCallable(label, callback, onFail, trying + 1, limit), 1e3);
+    else onFail?.(e);
+  }
+}
+
+export {
+  retryCallable
+};

package/build/chunk-S3ONGVNZ.mjs

@@ -0,0 +1,11 @@
+// source/core/controller/metadata.ts
+var META = /* @__PURE__ */ Symbol("controller:meta");
+function getControllerMetadata(target) {
+  if (!target[META])
+    target[META] = { routes: [], params: {} };
+  return target[META];
+}
+
+export {
+  getControllerMetadata
+};

package/build/chunk-SRR4467I.mjs

@@ -0,0 +1,29 @@
+// source/core/context.ts
+var RequestContext = class {
+  constructor(req, reply) {
+    this.req = req;
+    this.reply = reply;
+  }
+  state = {};
+  decorations = /* @__PURE__ */ new Map();
+  decorate(key, value) {
+    if (this.decorations.has(key)) {
+      throw new Error(`Decoration "${key}" already exists`);
+    }
+    this.decorations.set(key, value);
+  }
+  get(key) {
+    if (key in this.state) return this.state[key];
+    if (this.decorations.has(key)) {
+      return this.decorations.get(key);
+    }
+    throw new Error(`Context value "${key}" not found`);
+  }
+  send(body) {
+    this.reply.send(body);
+  }
+};
+
+export {
+  RequestContext
+};

package/build/chunk-T6L55AUG.mjs

@@ -0,0 +1,32 @@
+import {
+  RaitonConfig
+} from "./chunk-QI7OFSXB.mjs";
+import {
+  Raiton
+} from "./chunk-YGIZFKLJ.mjs";
+
+// source/core/directories.ts
+import path from "path";
+var RaitonDirectories = class {
+  static index = `.${Raiton.identifier}`;
+  static bootstrapFile = "main.js";
+  static caches(workdir) {
+    return path.join(workdir, this.index, "caches");
+  }
+  static artifacts(workdir) {
+    return path.join(workdir, this.index, "artifacts");
+  }
+  static server(workdir) {
+    return path.join(workdir, this.index, "server");
+  }
+  static root(workdir) {
+    return path.join(workdir, this.index);
+  }
+  static app() {
+    return path.join(Raiton.thread.builder.workdir, RaitonConfig.get("rootDir"));
+  }
+};
+
+export {
+  RaitonDirectories
+};

package/build/chunk-TOJFTPAY.mjs

@@ -0,0 +1,83 @@
+// source/core/hmr.ts
+import { Logger } from "@protorians/logger";
+var Hmr = class {
+  files = /* @__PURE__ */ new Map();
+  set(file, filename, size = 0) {
+    if (!filename.endsWith(".js")) return this;
+    this.files.set(file, {
+      filename,
+      size,
+      version: 1,
+      timestamp: Date.now()
+    });
+    return this;
+  }
+  clear() {
+    this.files.clear();
+    return this;
+  }
+  entries() {
+    return Object.fromEntries(this.files.entries());
+  }
+  has(key) {
+    return this.files.has(key);
+  }
+  async refresh() {
+    await this.each(async (file, key) => await this.upsert(key, file.filename));
+    return this;
+  }
+  async load(key) {
+    const file = this.files.get(key);
+    Logger.log("HMR", file);
+    const mod = file ? await import(`${file.filename}?t=${file.timestamp}&v=${file.version}`) : void 0;
+    return mod;
+  }
+  async reload(key) {
+    const file = this.files.get(key);
+    if (!file) return void 0;
+    file.version++;
+    file.timestamp = Date.now();
+    this.files.set(key, file);
+    return await import(`${file.filename}?t=${file.timestamp}&v=${file.version}`);
+  }
+  unset(key) {
+    this.files.delete(key);
+    return this;
+  }
+  size() {
+    return this.files.size;
+  }
+  async each(callable) {
+    await Promise.all([...this.files.entries()].map(async ([key, value]) => await callable(value, key, this.files)));
+    return this;
+  }
+  get(key) {
+    return this.files.get(key);
+  }
+  getEntries() {
+    return [...this.files.entries()];
+  }
+  getKeys() {
+    return [...this.files.keys()];
+  }
+  getValues() {
+    return [...this.files.values()];
+  }
+  async upsert(key, filename, size = 0) {
+    let file = this.files.get(key);
+    if (!file) {
+      this.set(key, filename);
+      file = this.files.get(key);
+    }
+    if (!file) return void 0;
+    if (file.size === size) return void 0;
+    file.version++;
+    file.timestamp = Date.now();
+    file.size = size;
+    return await this.set(key, filename, size).load(key);
+  }
+};
+
+export {
+  Hmr
+};

package/build/chunk-UAPCBU3J.mjs

@@ -0,0 +1,12 @@
+// source/sdk/enums/runtime.enum.ts
+var RuntimeType = /* @__PURE__ */ ((RuntimeType2) => {
+  RuntimeType2["Node"] = "node";
+  RuntimeType2["Deno"] = "deno";
+  RuntimeType2["Bun"] = "bun";
+  RuntimeType2["Web"] = "web";
+  return RuntimeType2;
+})(RuntimeType || {});
+
+export {
+  RuntimeType
+};

package/build/chunk-UCHBN3DV.mjs

@@ -0,0 +1,52 @@
+// source/sdk/runtime/deno/server.ts
+var denoRuntime = {
+  createServer(handler) {
+    let controller;
+    return {
+      async listen(port) {
+        if (typeof Deno === "undefined") throw new Error(
+          "Deno is not installed, please run `deno install -A -f --unstable https://deno.land/x/raiton/cli.ts`"
+        );
+        controller = new AbortController();
+        Deno.serve({ port, signal: controller.signal }, async (req) => {
+          let body;
+          let status = 200;
+          const headers = new Headers();
+          await handler(
+            {
+              method: req.method,
+              url: req.url,
+              headers: req.headers,
+              body: req.body
+            },
+            {
+              status(code) {
+                status = code;
+              },
+              header(name, value) {
+                headers.set(name, value);
+              },
+              send(value) {
+                body = value;
+              },
+              text(text) {
+                body = text;
+              },
+              json(json) {
+                body = JSON.stringify(json);
+              }
+            }
+          );
+          return new Response(body, { status, headers });
+        });
+      },
+      async close() {
+        controller.abort();
+      }
+    };
+  }
+};
+
+export {
+  denoRuntime
+};

package/build/chunk-UWM46HLZ.mjs

@@ -0,0 +1,18 @@
+// source/core/bytes.util.ts
+function parseBytes(bytes, decimals = 2) {
+  if (bytes === 0) return { size: 0, unit: "o" };
+  const k = 1024;
+  const units = ["o", "Ko", "Mo", "Go", "To"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  const size = parseFloat((bytes / Math.pow(k, i)).toFixed(decimals));
+  return { size, unit: units[i] };
+}
+function formatBytes(bytes, decimals = 2) {
+  const { size, unit } = parseBytes(bytes, decimals);
+  return `${size.toString().trim()}${unit.trim()}`;
+}
+
+export {
+  parseBytes,
+  formatBytes
+};

package/build/chunk-UZFCGVHP.mjs

@@ -0,0 +1,8 @@
+// source/core/plugins/plugin.ts
+function definePlugin(setup, name) {
+  return { setup, name };
+}
+
+export {
+  definePlugin
+};

package/build/chunk-VQINCGLQ.mjs

@@ -0,0 +1,59 @@
+// source/sdk/throwable.ts
+import { LBadge, Logger } from "@protorians/logger";
+import { EventBus, EventBusEnum } from "@protorians/events-bus";
+var Throwable = class _Throwable extends Error {
+  constructor(message, statusCode = 500, label) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "Throwable";
+    if (label) Logger.debug(LBadge.debug(label), message);
+    EventBus.dispatch(EventBusEnum.SERVER_THROW, { error: this });
+  }
+  /**
+   * Dispatches a system server error event and optionally throws an error.
+   *
+   * @param {string} message - The error message to be dispatched and potentially thrown.
+   * @param {boolean} [soft=true] - Determines whether the error should be thrown. If true, the error is only dispatched. If false, the error is dispatched and then thrown.
+   * @param statusCode
+   * @return {void} This method does not return a value.
+   */
+  static error(message, soft = true, statusCode = 500) {
+    EventBus.dispatch(EventBusEnum.SERVER_ERROR, { message, soft });
+    if (!soft) throw new _Throwable(message, statusCode, "ERR");
+  }
+  /**
+   * Emits a system server warning event and optionally throws an error based on the severity of the warning.
+   *
+   * @param {string} message - The warning message to be dispatched and possibly thrown as an error.
+   * @param {boolean} [soft=true] - Determines whether the warning should be treated as non-critical (soft). If false, an error is thrown.
+   * @param statusCode
+   * @return {void} This method does not return a value.
+   */
+  static warning(message, soft = true, statusCode = 500) {
+    EventBus.dispatch(EventBusEnum.SERVER_WARNING, { message, soft });
+    if (!soft) throw new _Throwable(message, statusCode, "WRN");
+  }
+  /**
+   * Triggers a critical system event, dispatching an alert message and terminating the process.
+   *
+   * @param {string} message - The critical error message to be dispatched with the event.
+   * @return {void} This method does not return a value as it terminates the process.
+   */
+  static critical(message) {
+    Logger.debug(LBadge.debug("CRITICAL"), message);
+    EventBus.dispatch(EventBusEnum.SERVER_CRITICAL, { message });
+    process.exit(1);
+  }
+};
+var throwError = (message, soft = true, statusCode = 500) => Throwable.error(message, soft, statusCode);
+var throwException = (message, statusCode = 500) => throwError(message, false, statusCode);
+var throwWarning = (message, soft = true, statusCode = 500) => Throwable.warning(message, soft, statusCode);
+var throwCritical = (message) => Throwable.critical(message);
+
+export {
+  Throwable,
+  throwError,
+  throwException,
+  throwWarning,
+  throwCritical
+};