raiton 1.1.1 → 3.0.0

package/build/chunk-K4KLOLSO.mjs

@@ -1,645 +0,0 @@
-import {
-  isControllerFile
-} from "./chunk-IOCHNQMF.mjs";
-import {
-  bodyParserPlugin
-} from "./chunk-RVH2YBNU.mjs";
-import {
-  Runtime
-} from "./chunk-GPJSLV3Q.mjs";
-import {
-  definePlugin
-} from "./chunk-UZFCGVHP.mjs";
-import {
-  Router
-} from "./chunk-XIGE72LC.mjs";
-import {
-  getControllerMetadata
-} from "./chunk-S3ONGVNZ.mjs";
-import {
-  MiddlewarePipeline
-} from "./chunk-52JR26TI.mjs";
-import {
-  Throwable
-} from "./chunk-VQINCGLQ.mjs";
-import {
-  RaitonDirectories
-} from "./chunk-T6L55AUG.mjs";
-import {
-  RaitonConfig
-} from "./chunk-QI7OFSXB.mjs";
-import {
-  Hmr
-} from "./chunk-TOJFTPAY.mjs";
-import {
-  HookStore
-} from "./chunk-NB62GSFI.mjs";
-import {
-  until
-} from "./chunk-5LNOA4SK.mjs";
-import {
-  Raiton
-} from "./chunk-YGIZFKLJ.mjs";
-
-// source/core/builder.ts
-import { context, build } from "esbuild";
-import path3 from "path";
-import { Logger as Logger5 } from "@protorians/logger";
-import fs3 from "fs";
-import { ProcessUtility as ProcessUtility2 } from "@protorians/core";
-
-// source/core/thread.ts
-import { ProcessUtility } from "@protorians/core";
-import { LBadge, Logger } from "@protorians/logger";
-var RaitonThread = class _RaitonThread {
-  constructor(builder, _options = {}) {
-    this.builder = builder;
-    this._options = _options;
-    this.appDir = process.cwd();
-    _RaitonThread.instance = this;
-  }
-  static instance = null;
-  static get current() {
-    if (!_RaitonThread.instance) throw new Throwable("Thread not initialized");
-    return _RaitonThread.instance;
-  }
-  application = null;
-  runtime = null;
-  server = null;
-  appDir;
-  restart() {
-    process.send?.(":restart" /* RESTART */);
-  }
-  stop() {
-    process.exit(0);
-  }
-  async sleep(milliseconds) {
-    return await ProcessUtility.sleep(milliseconds);
-  }
-  async wait(condition) {
-    return await until(condition);
-  }
-  setup({ application, runtime }) {
-    this.runtime = new Runtime(runtime || "node" /* Node */);
-    this.application = application;
-    this.application.use(bodyParserPlugin());
-    return this;
-  }
-  async run() {
-    if (!this.application)
-      throw new Throwable("Application not defined");
-    if (!this.runtime)
-      throw new Throwable("Runtime not defined");
-    const port = this.application.config.port || 5712;
-    this.server = this.runtime.createServer(this.application.handle.bind(this.application));
-    await this.server.listen(port);
-    if (this.builder.out)
-      await ControllerBuilder.scan(this.builder.out);
-    Logger.log(LBadge.info("Server Started"), `http://localhost:${port}`);
-    return this;
-  }
-};
-
-// source/sdk/decorators/routable.ts
-function createRoutableMethod(method) {
-  return (path5 = "") => (target, propertyKey) => {
-    const meta = getControllerMetadata(target);
-    meta.routes.push({
-      method,
-      path: path5,
-      propertyKey,
-      params: meta.params[propertyKey] || []
-    });
-  };
-}
-var Get = createRoutableMethod("GET" /* GET */);
-var Post = createRoutableMethod("POST" /* POST */);
-var Put = createRoutableMethod("PUT" /* PUT */);
-var Patch = createRoutableMethod("PATCH" /* PATCH */);
-var Options = createRoutableMethod("OPTIONS" /* OPTIONS */);
-var Trace = createRoutableMethod("TRACE" /* TRACE */);
-var Delete = createRoutableMethod("DELETE" /* DELETE */);
-var Head = createRoutableMethod("HEAD" /* HEAD */);
-
-// source/sdk/decorators/parametrable.ts
-function createParametrable(type, callable) {
-  return (key) => {
-    return (target, propertyKey, index) => {
-      const meta = getControllerMetadata(target);
-      if (!meta.params[propertyKey])
-        meta.params[propertyKey] = [];
-      meta.params[propertyKey].push({ index, type, key, callable });
-    };
-  };
-}
-var Query = createParametrable("query" /* QUERY */);
-var Param = createParametrable("param" /* PARAM */);
-var Body = createParametrable("body" /* BODY */);
-var UploadedFile = createParametrable("upload" /* UPLOAD_FILE */);
-var Headers = createParametrable("header" /* HEADER */);
-var Req = createParametrable("req" /* REQ */);
-var Reply = createParametrable("reply" /* REPLY */);
-
-// source/core/router/handler.ts
-import { Logger as Logger2 } from "@protorians/logger";
-function createHandler(instance, metadata) {
-  return async (ctx) => {
-    const args = [];
-    Logger2.debug("Metadata:", metadata);
-    for (const p of metadata.params) {
-      switch (p.type) {
-        case "query" /* QUERY */:
-          args[p.index] = ctx.req.query?.[p.key];
-          break;
-        case "param" /* PARAM */:
-          args[p.index] = ctx.req.params?.[p.key] ?? ctx.params?.[p.key];
-          break;
-        case "body" /* BODY */:
-          args[p.index] = ctx.req.body;
-          break;
-        case "header" /* HEADER */:
-          args[p.index] = ctx.req.headers[p.key.toLowerCase()];
-          break;
-        case "req" /* REQ */:
-          args[p.index] = ctx.req;
-          break;
-        case "reply" /* REPLY */:
-          args[p.index] = ctx.REPLY;
-          break;
-        case "upload" /* UPLOAD_FILE */:
-          args[p.index] = ctx.req.file;
-          break;
-        case "custom" /* CUSTOM */:
-          args[p.index] = p.callable?.(ctx) ?? null;
-          break;
-      }
-    }
-    return instance[metadata.propertyKey](...args);
-  };
-}
-
-// source/core/plugins/scope.ts
-var PluginScope = class _PluginScope {
-  hooks;
-  middleware;
-  router;
-  constructor(parent) {
-    this.hooks = parent ? parent.hooks.clone() : new HookStore();
-    this.middleware = parent ? parent.middleware.clone() : new MiddlewarePipeline();
-    this.router = parent ? parent.router : new Router();
-  }
-  addHook(name, fn) {
-    this.hooks.add(name, fn);
-    return this;
-  }
-  use(mw) {
-    if (typeof mw === "object" && mw !== null && "setup" in mw && typeof mw.setup === "function" && mw.setup.length === 1) {
-      mw.setup(this);
-      return this;
-    }
-    this.middleware.use(mw);
-    return this;
-  }
-  route(method, path5, handler, version) {
-    return this.router.add(method, path5, handler, version);
-  }
-  register(plugin) {
-    const child = new _PluginScope(this);
-    plugin.setup(child);
-    return child;
-  }
-};
-
-// source/sdk/plugins/security/headers.ts
-var secureHeaders = definePlugin((scope) => {
-  scope.use(async (ctx, next) => {
-    ctx.reply.header("X-Content-Type-Options", "nosniff");
-    ctx.reply.header("X-Frame-Options", "DENY");
-    ctx.reply.header("Referrer-Policy", "no-referrer");
-    ctx.reply.header("X-XSS-Protection", "1; mode=block");
-    await next();
-  });
-}, "security-headers");
-
-// source/sdk/plugins/security/cors.ts
-var secureCors = (opts = {}) => definePlugin((scope) => {
-  scope.use(async (ctx, next) => {
-    const origin = ctx.req.headers.get("origin");
-    if (opts.origin) {
-      const allowed = Array.isArray(opts.origin) ? opts.origin.includes(origin) : opts.origin === origin;
-      if (allowed) {
-        ctx.reply.header("Access-Control-Allow-Origin", origin);
-      }
-    } else {
-      ctx.reply.header("Access-Control-Allow-Origin", "*");
-    }
-    ctx.reply.header(
-      "Access-Control-Allow-Methods",
-      (opts.methods ?? ["GET", "POST", "PUT", "DELETE"]).join(",")
-    );
-    ctx.reply.header(
-      "Access-Control-Allow-Headers",
-      (opts.headers ?? ["Content-Type", "Authorization"]).join(",")
-    );
-    if (ctx.req.method === "OPTIONS") {
-      ctx.reply.status(204);
-      return ctx.send(null);
-    }
-    await next();
-  });
-}, "cors");
-
-// source/sdk/plugins/security/rate-limit.ts
-var secureRateLimit = (opts = {}) => definePlugin((scope) => {
-  const hits = /* @__PURE__ */ new Map();
-  const windowMs = opts.windowMs ?? 6e4;
-  const max = opts.max ?? 100;
-  scope.use(async (ctx, next) => {
-    const ip = ctx.req.remoteAddress ?? "unknown";
-    const now = Date.now();
-    const entry = hits.get(ip) ?? { count: 0, ts: now };
-    if (now - entry.ts > windowMs) {
-      entry.count = 0;
-      entry.ts = now;
-    }
-    entry.count++;
-    hits.set(ip, entry);
-    if (entry.count > max) {
-      ctx.reply.status(429);
-      return ctx.send({ error: "Too many requests" });
-    }
-    await next();
-  });
-}, "rate-limit");
-
-// source/sdk/plugins/security/body-limit.ts
-var secureBodyLimit = (maxBytes = 1e6) => definePlugin((scope) => {
-  scope.use(async (ctx, next) => {
-    const len = Number(
-      ctx.req.headers.get("content-length") ?? 0
-    );
-    if (len > maxBytes) {
-      ctx.reply.status(413);
-      return ctx.send({ error: "Payload too large" });
-    }
-    await next();
-  });
-}, "body-limit");
-
-// source/sdk/plugins/security/method-guard.ts
-var secureMethodGuard = (allowed) => definePlugin((scope) => {
-  scope.use(async (ctx, next) => {
-    if (!allowed.includes(ctx.req.method)) {
-      ctx.reply.status(405);
-      return ctx.send({ error: "Method not allowed" });
-    }
-    await next();
-  });
-}, "method-guard");
-
-// source/sdk/plugins/security/index.ts
-var SecureApp = class {
-  static headers = secureHeaders;
-  static cors = secureCors;
-  static rateLimit = secureRateLimit;
-  static bodyLimit = secureBodyLimit;
-  static methodGuard = secureMethodGuard;
-};
-
-// source/sdk/utilities/artifacts.util.ts
-import path2 from "path";
-import fs2 from "fs";
-import { LBadge as LBadge2, Logger as Logger4 } from "@protorians/logger";
-
-// source/sdk/artifacts.ts
-import path from "path";
-import fs from "fs";
-import { Logger as Logger3 } from "@protorians/logger";
-var ArtifactFactory = class {
-  static stack = /* @__PURE__ */ new Map();
-  static getSource(key) {
-    return path.join(
-      RaitonDirectories.artifacts(Raiton.thread.builder.workdir),
-      `${key}.json`
-    );
-  }
-  static add(key, file) {
-    if (!this.stack.has(key)) this.stack.set(key, /* @__PURE__ */ new Set());
-    this.stack.get(key)?.add(file);
-  }
-  static get(key) {
-    return this.stack.get(key);
-  }
-  static has(key) {
-    return this.stack.has(key);
-  }
-  static load(key) {
-    const outputFile = this.getSource(key);
-    if (!fs.existsSync(outputFile)) return this;
-    const content = fs.readFileSync(outputFile, "utf-8");
-    const files = JSON.parse(content);
-    files.forEach((file) => this.add(key, file));
-    return this;
-  }
-  static save(key) {
-    try {
-      const set = this.stack.get(key);
-      if (!set) return;
-      const content = JSON.stringify([...set.values()]);
-      const outputFile = this.getSource(key);
-      const dir = path.dirname(outputFile);
-      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-      fs.writeFileSync(outputFile, content, "utf-8");
-      return true;
-    } catch (e) {
-      Logger3.error(`Failed to save artifacts for key ${key}:`, e);
-      return false;
-    }
-  }
-};
-
-// source/sdk/utilities/artifacts.util.ts
-function generateArtifacts(artifact, interfaceName, decoratorSyntax, verbose = false) {
-  const artifacts = RaitonDirectories.artifacts(Raiton.thread.builder.workdir);
-  const dir = Raiton.thread.builder.source;
-  const outputFile = path2.join(artifacts, `${artifact}.d.ts`);
-  if (!dir) return;
-  const files = fs2.readdirSync(dir, { recursive: true }).filter((f) => [`.ts`, `.js`, `.mjs`, `.cjs`].some((ext) => f.toString().endsWith(ext))).map((f) => f.toString());
-  let mappings = "";
-  for (const file of files) {
-    const filename = path2.join(dir, file);
-    const content2 = fs2.readFileSync(filename, "utf-8");
-    const match = content2.match(decoratorSyntax);
-    if (!match) continue;
-    let name = match[3] || match[1] || "";
-    if (!name) {
-      const classMatch = content2.match(/export\s+default\s+class\s+([A-Za-z0-9_]+)/);
-      name = classMatch?.[1] || path2.parse(filename).name;
-    }
-    mappings += `    ${name}: InstanceType<typeof import("@/${file}").default>;
-`;
-    if (verbose) Logger4.info(LBadge2.debug(name), `artifact detected`);
-    ArtifactFactory.add(artifact, {
-      file,
-      dir,
-      relative: file,
-      absolute: filename
-    });
-  }
-  const content = `// AUTO-GENERATED FILE \u2014 DO NOT EDIT MANUALLY
-declare global {
-  interface ${interfaceName} {
-${mappings} }
-}
-export {};`;
-  fs2.writeFileSync(outputFile, content, "utf-8");
-  if (!ArtifactFactory.save(artifact)) Logger4.error(`Failed to save artifacts for ${artifact}`);
-}
-
-// source/core/builder.ts
-var sleep = ProcessUtility2.sleep;
-var RaitonBuilder = class {
-  // signal: ISignalStack<ServerSignalMap> = new Signal.Stack()
-  constructor(workdir, options = {}) {
-    this.workdir = workdir;
-    this.options = options;
-  }
-  _context = null;
-  _source = null;
-  _out = null;
-  _bootstrapper = null;
-  _bootstrapperIndex = null;
-  config = null;
-  _compiledVersionNumber = 1;
-  _importPattern = /from\s+["'](\.\.?\/[^."'][^"']*)["']/g;
-  hmr = new Hmr();
-  get context() {
-    return this._context;
-  }
-  get source() {
-    return this._source;
-  }
-  get out() {
-    return this._out;
-  }
-  get bootstrapper() {
-    return this._bootstrapper;
-  }
-  get bootstrapperIndex() {
-    return this._bootstrapperIndex;
-  }
-  get baseConfig() {
-    return {
-      absWorkingDir: this.workdir,
-      // write: false,
-      splitting: true,
-      bundle: false,
-      // preserveSymlinks: false,
-      platform: "node",
-      sourcemap: true,
-      minify: false,
-      format: "esm",
-      target: "node22",
-      metafile: true,
-      // bundle: false,
-      tsconfig: path3.join(this.workdir, "tsconfig.json"),
-      plugins: [
-        this.watcher()
-      ]
-    };
-  }
-  generateUniqueModuleUrl(filename) {
-    return `${filename}?t=${Date.now()}&v=${this._compiledVersionNumber}&r=${Math.random()}&hmr=1&${Math.random()}`;
-  }
-  async refreshFileCached(filename) {
-    try {
-      const url = this.generateUniqueModuleUrl(filename);
-      const mod = await import(url);
-      if (!mod) throw new Throwable("Module is invalid");
-      return mod;
-    } catch (er) {
-      Logger5.error("Failed to refresh file", filename, er);
-      return null;
-    }
-  }
-  async fixImports(pathname) {
-    if (!pathname.endsWith(".js")) return;
-    let code = await fs3.promises.readFile(pathname, "utf8");
-    const match = this._importPattern.test(code);
-    if (!match) return;
-    this._importPattern.lastIndex = 0;
-    const updated = code.replace(this._importPattern, (match2, detected) => {
-      return match2.replace(detected, detected + ".js");
-    });
-    return await fs3.promises.writeFile(pathname, updated);
-  }
-  watcher() {
-    const temporary = /* @__PURE__ */ new Map();
-    const this_ = this;
-    const importPattern = /from\s+["'](\.\.?\/[^."'][^"']*)["']/g;
-    const updateVersionNumber = () => this._compiledVersionNumber++;
-    const getVersionNumber = () => this._compiledVersionNumber;
-    let hmrMoment = false;
-    return {
-      name: `${Raiton.identifier}-build-plugin`,
-      setup(build2) {
-        build2.onEnd(async (result) => {
-          if (result.errors.length) Logger5.error("Errors:\n\u2014", result.errors.join("\n\u2014"));
-          if (result.warnings.length) Logger5.error("Warnings:\n\u2014", result.warnings.join("\n\u2014"));
-          if (result.metafile) {
-            const outputs = Object.keys(result.metafile.outputs);
-            for (const key of outputs) {
-              const filename = path3.resolve(key);
-              await this_.fixImports(filename);
-              if (isControllerFile(filename)) {
-                Raiton.signals.dispatch("hmr:controller", {
-                  filename,
-                  timestamp: Date.now(),
-                  version: getVersionNumber()
-                });
-              }
-            }
-          }
-          if (hmrMoment) {
-            updateVersionNumber();
-          }
-          hmrMoment = true;
-        });
-      }
-    };
-  }
-  async developmentBuild(callable) {
-    if (!this._context)
-      throw new Error("Builder not prepared");
-    this.context?.watch().then(async () => {
-      await sleep(60);
-      await until(() => this._bootstrapper ? fs3.existsSync(this._bootstrapper) : false);
-      callable?.(this);
-      Raiton.signals.listen(
-        "hmr:controller",
-        async ({ filename, version, timestamp }) => await ControllerBuilder.build({ filename, version, timestamp })
-      );
-    }).catch((err) => Logger5.error("Stack:\n", err));
-    return this;
-  }
-  async productionBuild(callable) {
-    if (!this.config)
-      throw new Error("Builder not prepared");
-    await build(this.config);
-    callable?.(this);
-    return this;
-  }
-  async prepare() {
-    this._source = path3.resolve(this.workdir, RaitonConfig.get("rootDir"));
-    this._out = path3.resolve(this.workdir, RaitonDirectories.server(this.workdir));
-    if (!fs3.existsSync(this._source))
-      throw new Error(`Source directory "${this._source}" does not exists`);
-    if (!fs3.existsSync(this._out))
-      fs3.mkdirSync(this._out, { recursive: true });
-    this._bootstrapper = path3.join(this._out, RaitonDirectories.bootstrapFile);
-    this._bootstrapperIndex = path3.join(RaitonDirectories.server("./"), RaitonDirectories.bootstrapFile);
-    this.config = {
-      ...this.baseConfig,
-      entryPoints: [`${RaitonConfig.get("rootDir")}/**/*.ts`],
-      outdir: RaitonDirectories.server("./")
-    };
-    if (this.options.development) {
-      this._context = await context(this.config);
-    }
-    if (!this.options.development) {
-    }
-    return this;
-  }
-  async boot() {
-    if (!this.bootstrapper) throw new Error("Bootstrapper not found");
-    if (!fs3.existsSync(this.bootstrapper))
-      throw new Error(`Bootstrapper file "${this.bootstrapper}" does not exists`);
-    const bootstrapper = await import(this.bootstrapper);
-    if (!("default" in bootstrapper))
-      throw new Error('Bootstrapper not supported! Please export to "default"');
-    Raiton.thread = new RaitonThread(this, {});
-    return bootstrapper.default(Raiton.thread);
-  }
-  async start(callable) {
-    return this.options.development ? await this.developmentBuild(callable) : await this.productionBuild(callable);
-  }
-};
-
-// source/core/controller/compiler.ts
-function compileController(ControllerClass, app) {
-  const instance = new ControllerClass();
-  const metadata = getControllerMetadata(ControllerClass.prototype);
-  for (const meta of metadata.routes) {
-    app.route(
-      meta.method,
-      `${metadata.prefix ?? ""}${meta.path}`,
-      createHandler(instance, meta)
-    );
-  }
-  return instance;
-}
-
-// source/core/controller/builder.ts
-import fs4 from "fs";
-import { LBadge as LBadge3, Logger as Logger6 } from "@protorians/logger";
-import path4 from "path";
-var ControllerBuilder = class {
-  static async scan(workdir) {
-    const files = fs4.readdirSync(workdir, { recursive: true }).map((file) => file.toString());
-    const output = [];
-    for (const file of files)
-      output.push(await this.build({ filename: path4.join(workdir, file), version: 1, timestamp: Date.now() }));
-    return output.filter((f) => typeof f !== "undefined");
-  }
-  static async build({ filename, version, timestamp }) {
-    if (!isControllerFile(filename))
-      return void 0;
-    const imported = await import(`${filename}?v=${version || 1}&t=${timestamp || Date.now()}`);
-    const controller = imported.default || imported || void 0;
-    if (!controller) return void 0;
-    if (!RaitonThread.current.application) return void 0;
-    Logger6.log(LBadge3.info("Controller"), controller.name);
-    return compileController(controller, RaitonThread.current.application);
-  }
-};
-
-// source/sdk/decorators/controllable.ts
-function Controllable(prefix = "") {
-  return (target) => {
-    const meta = getControllerMetadata(target.prototype || target);
-    meta.prefix = prefix;
-  };
-}
-
-export {
-  Controllable,
-  Get,
-  Post,
-  Put,
-  Patch,
-  Options,
-  Trace,
-  Delete,
-  Head,
-  Query,
-  Param,
-  Body,
-  UploadedFile,
-  Headers,
-  Req,
-  Reply,
-  PluginScope,
-  secureHeaders,
-  secureCors,
-  secureRateLimit,
-  secureBodyLimit,
-  secureMethodGuard,
-  SecureApp,
-  ArtifactFactory,
-  generateArtifacts,
-  createHandler,
-  compileController,
-  ControllerBuilder,
-  RaitonThread,
-  RaitonBuilder
-};

package/build/chunk-M2RZZJQR.mjs

@@ -1,27 +0,0 @@
-// source/sdk/utilities/utilities.util.ts
-function getType(value) {
-  if (typeof value === "string") return "string";
-  if (typeof value === "boolean") return "boolean";
-  if (typeof value === "bigint") return "bigInt";
-  if (typeof value === "number") {
-    if (Number.isInteger(value)) return "int";
-    return "float";
-  }
-  return typeof value;
-}
-function stabilizeJson(json) {
-  if (!json) return {};
-  switch (typeof json) {
-    case "string":
-      return JSON.parse(json);
-    case "object":
-      return json;
-    default:
-      throw new Error("Invalid JSON format");
-  }
-}
-
-export {
-  getType,
-  stabilizeJson
-};

package/build/chunk-MLFGBJDV.mjs

@@ -1,12 +0,0 @@
-// source/sdk/utilities/json.util.ts
-function tryParseJson(obj) {
-  try {
-    return JSON.parse(obj);
-  } catch (e) {
-    return null;
-  }
-}
-
-export {
-  tryParseJson
-};

package/build/chunk-NB62GSFI.mjs

@@ -1,27 +0,0 @@
-// source/core/hooks.ts
-var HookStore = class _HookStore {
-  hooks = /* @__PURE__ */ new Map();
-  add(name, handler) {
-    const list = this.hooks.get(name) ?? [];
-    list.push(handler);
-    this.hooks.set(name, list);
-  }
-  async run(name, ctx) {
-    const list = this.hooks.get(name);
-    if (!list) return;
-    for (const hook of list) {
-      await hook(ctx);
-    }
-  }
-  clone() {
-    const store = new _HookStore();
-    for (const [key, value] of this.hooks) {
-      store.hooks.set(key, [...value]);
-    }
-    return store;
-  }
-};
-
-export {
-  HookStore
-};