@sidekick-coder/zenith-kit 0.0.10 → 0.0.11

package/dist/server/index.mjs

@@ -1,10 +1,85 @@
-import { debounce } from "lodash-es";
+import { debounce, get, has, set, unset } from "lodash-es";
+import fg from "fast-glob";
+import path, { join } from "path";
+import * as v from "valibot";
+import { format } from "date-fns";
+import qs from "qs";
+import fs from "fs";
+import { spawn } from "child_process";
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
 import { unlink, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { join as join$1 } from "node:path";
 import { randomUUID } from "node:crypto";
+import { pathToFileURL } from "url";
+import { pathToFileURL as pathToFileURL$1 } from "node:url";
+import fs$1 from "node:fs";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/shared/utils/compose.ts
+/**
+* Composes multiple mixins into a single class that can be extended.
+* Allows for multiple inheritance-like behavior by applying mixins sequentially.
+* 
+* @param mixins - Array of mixin functions to compose
+* @returns A class constructor that includes all mixin functionality
+* 
+* @example
+* ```typescript
+* class User extends compose(Timestamp, SoftDelete) {
+*   constructor(public name: string) {
+*     super()
+*   }
+* }
+* ```
+*/
+function compose(...mixins) {
+	return mixins.reduce((base, mixin) => mixin(base), class {});
+}
+/**
+* Alternative compose function that starts with a base class
+* 
+* @param baseClass - The base class to start with
+* @param mixins - Array of mixin functions to apply
+* @returns A class constructor that extends the base class with all mixin functionality
+* 
+* @example
+* ```typescript
+* class User extends composeWith(BaseEntity, Timestamp, SoftDelete) {
+*   constructor(public name: string) {
+*     super()
+*   }
+* }
+* ```
+*/
+function composeWith(baseClass, ...mixins) {
+	return mixins.reduce((base, mixin) => mixin(base), baseClass);
+}
+function mixin(Source) {
+	return function(Target) {
+		class Mixed extends Target {
+			constructor(...args) {
+				super(...args);
+				const source = new Source(...args);
+				Object.assign(this, source);
+			}
+		}
+		for (const key of Reflect.ownKeys(Source.prototype)) if (key !== "constructor") Object.defineProperty(Mixed.prototype, key, Object.getOwnPropertyDescriptor(Source.prototype, key));
+		return Mixed;
+	};
+}
+//#endregion
 //#region src/shared/utils/tryCatch.ts
 async function tryCatch(tryer) {
 	try {
@@ -397,6 +472,1011 @@ var PluginRouter = class {
 	}
 };
 //#endregion
+//#region src/shared/exceptions/BaseException.ts
+var BaseException = class BaseException extends Error {
+	statusCode = 500;
+	constructor(message, statusCode = 500) {
+		super(message);
+		this.name = this.constructor.name;
+		this.statusCode = statusCode;
+	}
+	static fromError(error) {
+		return new BaseException(error.message, 500);
+	}
+};
+//#endregion
+//#region src/server/services/RouterFileBaseRoutingService.ts
+var RouterFileBaseRoutingService = class RouterFileBaseRoutingService {
+	directory;
+	prefix;
+	module;
+	router;
+	logger = new LoggerService();
+	routes = [];
+	debug = false;
+	setDirectory(directory) {
+		this.directory = directory;
+		return this;
+	}
+	setPrefix(prefix) {
+		this.prefix = prefix;
+		return this;
+	}
+	setRouter(router) {
+		this.router = router;
+		return this;
+	}
+	setModule(module) {
+		this.module = module;
+		return this;
+	}
+	setLogger(logger) {
+		this.logger = logger;
+		return this;
+	}
+	setDebug(debug) {
+		this.debug = debug;
+		return this;
+	}
+	static create(directory) {
+		return new RouterFileBaseRoutingService().setDirectory(directory);
+	}
+	async loadFiles() {
+		const files = fg.sync("**/*.(ts|js)", { cwd: this.directory });
+		if (this.debug) this.logger.debug(`Found ${files.length} route files in ${this.directory}`, { files });
+		const routes = [];
+		for (const file of files) {
+			let routePath = file.replace(/\.(ts|js)$/, "");
+			let method = "get";
+			for (const suffix of [
+				".post",
+				".patch",
+				".delete",
+				".put"
+			]) if (routePath.endsWith(suffix)) {
+				method = suffix.substring(1);
+				routePath = routePath.replace(suffix, "");
+				break;
+			}
+			routePath = routePath.replace(/\/index$/, "");
+			routePath = routePath.replace(/^index$/, "");
+			routePath = routePath.replace(/\[\.\.\.([^\]]+)]/g, "*$1");
+			routePath = routePath.replace(/\[([^\]]+)]/g, ":$1");
+			if (!routePath.startsWith("/")) routePath = "/" + routePath;
+			if (routePath === "/") routePath = "/";
+			if (this.prefix) routePath = (this.prefix.startsWith("/") ? this.prefix : "/" + this.prefix) + routePath;
+			let sortKey = 0;
+			if (routePath.includes("*")) sortKey += 1e6;
+			const paramCount = (routePath.match(/:/g) || []).length;
+			sortKey += paramCount * 1e4;
+			const segmentCount = routePath.split("/").filter((s) => s).length;
+			sortKey -= segmentCount * 100;
+			routes.push({
+				file,
+				routePath,
+				method,
+				sortKey,
+				module: this.module
+			});
+		}
+		routes.sort((a, b) => a.sortKey - b.sortKey);
+		this.routes = routes;
+	}
+	async registerRoutes() {
+		if (!this.router) throw new BaseException("Router instance not set");
+		const moduleName = this.module || "unknown";
+		const hook = function(route) {
+			route.metadata = {
+				...route.metadata,
+				module: moduleName
+			};
+		};
+		this.router.on("added", hook);
+		for (const route of this.routes) {
+			const handler = (await import(`${this.directory}/${route.file}`)).default;
+			if (typeof handler !== "function") {
+				this.logger.warn(`Route file ${route.file} does not export a default function`);
+				continue;
+			}
+			this.router[route.method](route.routePath, handler);
+		}
+		this.router.off("added", hook);
+	}
+	async load() {
+		await this.loadFiles();
+		await this.registerRoutes();
+	}
+};
+//#endregion
+//#region src/shared/services/ConfigService.ts
+var ConfigService = class {
+	entries;
+	constructor() {
+		this.entries = /* @__PURE__ */ new Map();
+	}
+	list() {
+		return Array.from(this.entries.values());
+	}
+	parseValue(value) {
+		if (typeof value === "string" && value.endsWith(":boolean")) return value.replace(":boolean", "").trim() === "true";
+		return value;
+	}
+	loadFromRecord(record, source = "unknow") {
+		for (const [key, value] of Object.entries(record)) this.entries.set(key, {
+			key,
+			value: this.parseValue(value),
+			source
+		});
+	}
+	loadFromEntries(entries, source = "unknow") {
+		for (const [key, value] of entries) this.entries.set(key, {
+			key,
+			value: this.parseValue(value),
+			source
+		});
+	}
+	toRecord() {
+		const record = {};
+		for (const [key, entry] of this.entries.entries()) record[key] = entry.value;
+		return record;
+	}
+	has(key) {
+		if (this.entries.get(key)) return true;
+		if (!key.includes(".")) return false;
+		const primary = key.split(".")[0];
+		const primaryEntry = this.entries.get(primary);
+		if (!primaryEntry) return this.entries.get(key) ? true : false;
+		const value = primaryEntry.value;
+		if (typeof value !== "object" || Array.isArray(value)) return false;
+		return has(value, key.substring(primary.length + 1));
+	}
+	get(key, defaultValue) {
+		const entry = this.entries.get(key);
+		if (entry) return entry.value;
+		if (!key.includes(".")) return defaultValue;
+		const primary = key.split(".")[0];
+		const primaryEntry = this.entries.get(primary);
+		if (!primaryEntry) {
+			const entry = this.entries.get(key);
+			return entry ? entry.value : defaultValue;
+		}
+		const value = primaryEntry.value;
+		if (typeof value !== "object" || Array.isArray(value)) return defaultValue;
+		return get(value, key.substring(primary.length + 1), defaultValue);
+	}
+	getOne(keys, defaultValue) {
+		for (const key of keys) if (this.has(key)) return this.get(key);
+		return defaultValue;
+	}
+	set(key, value, source = "runtime") {
+		if (!key.includes(".")) {
+			this.entries.set(key, {
+				key,
+				source,
+				value
+			});
+			return;
+		}
+		const primary = key.split(".")[0];
+		let primaryValue = this.get(primary, {});
+		if (typeof primaryValue !== "object" || Array.isArray(primaryValue)) primaryValue = {};
+		set(primaryValue, key.substring(primary.length + 1), value);
+		this.entries.set(primary, {
+			key: primary,
+			source,
+			value: primaryValue
+		});
+	}
+	unset(key) {
+		if (!key.includes(".")) {
+			this.entries.delete(key);
+			return;
+		}
+		const primary = key.split(".")[0];
+		const primaryValue = this.get(primary, {});
+		if (!primaryValue) return;
+		if (typeof primaryValue !== "object" || Array.isArray(primaryValue)) return;
+		unset(primaryValue, key.substring(primary.length + 1));
+		this.entries.set(primary, {
+			key: primary,
+			source: "runtime",
+			value: primaryValue
+		});
+	}
+	clear() {
+		this.entries.clear();
+	}
+};
+//#endregion
+//#region src/shared/services/ContainerService.ts
+var ContainerService = class {
+	entries = /* @__PURE__ */ new Map();
+	loadFromRecord(record) {
+		Object.entries(record).forEach(([key, value]) => {
+			this.set(key, value);
+		});
+	}
+	toRecord() {
+		const record = {};
+		for (const [key, value] of this.entries.entries()) record[String(key)] = value;
+		return record;
+	}
+	set(payload, value) {
+		let key = payload;
+		if (typeof payload === "function" || typeof payload === "object") key = payload.name;
+		this.entries.set(key, value);
+	}
+	has(payload) {
+		let key = payload;
+		if (typeof payload === "function" || typeof payload === "object") key = payload.name;
+		return this.entries.has(key);
+	}
+	get(payload) {
+		let key = payload;
+		if (typeof payload === "function" || typeof payload === "object") key = payload.name;
+		if (!this.has(key)) throw new Error(`entry not found: ${String(key)}`);
+		return this.entries.get(key);
+	}
+	singleton(classConstructor) {
+		const key = classConstructor.name;
+		const existingInstance = this.entries.get(key);
+		if (existingInstance) return existingInstance;
+		const newInstance = new classConstructor();
+		this.entries.set(key, newInstance);
+		return newInstance;
+	}
+	load(entries) {
+		Object.entries(entries).forEach(([key, value]) => {
+			this.set(key, value);
+		});
+	}
+	proxy(key) {
+		return new Proxy({}, {
+			get: (_target, prop) => {
+				const entry = this.get(key);
+				const value = entry[prop];
+				if (typeof value === "function") return value.bind(entry);
+				return entry[prop];
+			},
+			set: (_target, prop, value) => {
+				const entry = this.get(key);
+				entry[prop] = value;
+				return true;
+			}
+		});
+	}
+	keys() {
+		return Array.from(this.entries.keys());
+	}
+};
+//#endregion
+//#region src/shared/validators/url.ts
+var url_exports = /* @__PURE__ */ __exportAll({
+	array: () => array,
+	arrayNumber: () => arrayNumber,
+	boolean: () => boolean,
+	date: () => date,
+	datetime: () => datetime,
+	number: () => number,
+	object: () => object
+});
+const number = () => v.pipe(v.union([v.string(), v.number()]), v.transform(Number), v.integer());
+const boolean = () => v.pipe(v.union([v.string(), v.boolean()]), v.transform((v) => v === true || v === "true"));
+const date = () => v.pipe(v.union([v.string(), v.date()]), v.transform((v) => v instanceof Date ? v : new Date(v)), v.transform((v) => v ? format(v, "yyyy-MM-dd") : v));
+const datetime = () => v.pipe(v.union([v.string(), v.date()]), v.transform((v) => {
+	if (!v) return v;
+	if (v === "null") return null;
+	if (typeof v === "string") v = new Date(v);
+	return format(v, "yyyy-MM-dd HH:mm");
+}));
+const array = (schema = v.any()) => v.pipe(v.union([v.string(), v.array(v.string())]), v.transform((value) => Array.isArray(value) ? value : value.split(",")), v.array(schema));
+const arrayNumber = () => v.pipe(array(), v.transform((value) => value.map(Number)));
+const object = () => v.pipe(v.union([v.string(), v.record(v.string(), v.any())]), v.transform((value) => typeof value === "string" ? qs.parse(value) : value), v.transform((value) => {
+	const result = {};
+	for (const key in value) set(result, key, get(value, key));
+	return result;
+}));
+//#endregion
+//#region src/shared/services/ValidatorService.ts
+const extras = { url: url_exports };
+var ValidatorService = class {
+	v = {
+		...v,
+		extras
+	};
+	create(cb) {
+		return cb(this.v);
+	}
+	validate(payload, cb) {
+		const schema = typeof cb === "function" ? cb(this.v) : cb;
+		const { output, issues, success } = v.safeParse(schema, payload);
+		if (!success) {
+			const flatten = v.flatten(issues);
+			const messages = [];
+			if (flatten.root) messages.push(...flatten.root);
+			if (flatten.nested) Object.entries(flatten.nested).forEach((entry) => {
+				const [key, value] = entry;
+				messages.push(...value.map((v) => `${key}: ${v}`));
+			});
+			const error = new BaseException(messages.length ? messages.join(", ") : "Validation failed", 422);
+			error.name = "ValidationError";
+			Object.assign(error, { messages });
+			throw error;
+		}
+		return output;
+	}
+	async validateAsync(payload, cb) {
+		const schema = typeof cb === "function" ? cb(this.v) : cb;
+		const { output, issues, success } = await v.safeParseAsync(schema, payload);
+		if (!success) {
+			const error = /* @__PURE__ */ new Error("Validation failed");
+			const flatten = v.flatten(issues);
+			const details = {
+				...flatten.root,
+				...flatten.nested
+			};
+			Object.assign(error, { details });
+			throw error;
+		}
+		return output;
+	}
+	isValid(payload, cb) {
+		const schema = typeof cb === "function" ? cb(this.v) : cb;
+		const { success } = v.safeParse(schema, payload);
+		return success;
+	}
+};
+v.object({
+	id: v.number(),
+	permission_id: v.number(),
+	assignable_type: v.string(),
+	assignable_id: v.string(),
+	created_at: v.string(),
+	updated_at: v.string()
+});
+v.object({
+	id: v.number(),
+	name: v.nullable(v.string()),
+	description: v.nullable(v.string()),
+	action: v.string(),
+	subject: v.string(),
+	conditions: v.nullable(v.string()),
+	created_at: v.string(),
+	updated_at: v.string(),
+	expires_at: v.string()
+});
+v.object({
+	id: v.number(),
+	name: v.nullable(v.string()),
+	type: v.string(),
+	user_id: v.number(),
+	token: v.string(),
+	created_at: v.string(),
+	updated_at: v.string(),
+	expires_at: v.string()
+});
+//#endregion
+//#region src/shared/exceptions/ShellException.ts
+var ShellException = class extends BaseException {
+	output;
+	bin;
+	args;
+	constructor(message, output, bin, args) {
+		super(message, 501);
+		this.output = output;
+		this.bin = bin;
+		this.args = args;
+	}
+};
+new ValidatorService();
+//#endregion
+//#region src/shared/entities/LifecycleHook.ts
+var LifecycleHook = class {
+	hook_id;
+	order;
+	subhooks;
+	constructor() {
+		if (!this.hook_id) this.hook_id = this.constructor.name;
+	}
+	async onRegister() {}
+	async onLoad() {}
+	async onBoot() {}
+	async onShutdown() {}
+};
+//#endregion
+//#region src/shared/mixins/BaseEntityMixin.ts
+function BaseEntity(Base) {
+	return class extends Base {
+		static from(data) {
+			const contructor = typeof this === "function" ? this : Base;
+			const instance = new contructor();
+			let payload = { ...data };
+			if (typeof contructor?.parse === "function") payload = contructor.parse(data);
+			if (typeof this?.parse === "function") payload = this.parse(data);
+			Object.assign(instance, payload);
+			return instance;
+		}
+		merge(data) {
+			Object.assign(this, data);
+			return this;
+		}
+	};
+}
+//#endregion
+//#region src/shared/entities/ModuleEntity.ts
+var Module$1 = class extends compose(BaseEntity, mixin(LifecycleHook)) {
+	id;
+	name;
+	enabled = false;
+	dependencies = {};
+	build = {};
+	directory;
+	upgrade_info;
+	setData(data) {
+		const filtered = Object.fromEntries(Object.entries(data).filter(([, v]) => v !== void 0));
+		Object.assign(this, filtered);
+		this.hook_id = `module:${this.id}`;
+	}
+};
+compose(BaseEntity);
+//#endregion
+//#region src/server/facades/container.ts
+const container = globalThis.container || new ContainerService();
+//#endregion
+//#region src/server/facades/logger.ts
+const logger = container.proxy(LoggerService);
+//#endregion
+//#region src/server/entities/RouteEntity.ts
+var Route = class {
+	path = "";
+	method = "get";
+	handler = null;
+	middlewares = [];
+	metadata = {};
+	constructor(data = {}) {
+		this.path = data.path || "";
+		this.method = data.method || "get";
+		this.handler = data.handler || null;
+		this.middlewares = data.middlewares || [];
+		this.metadata = data.metadata || {};
+	}
+	static params(routePath, requestPath) {
+		const params = {};
+		const routeSegments = routePath.split("/").filter(Boolean);
+		const requestSegments = requestPath.split("/").filter(Boolean);
+		for (let i = 0; i < routeSegments.length; i++) {
+			const routeSegment = routeSegments[i];
+			const requestSegment = requestSegments[i];
+			if (routeSegment.startsWith(":")) {
+				const paramName = routeSegment.slice(1);
+				params[paramName] = requestSegment;
+			}
+			if (routeSegment === "*") {
+				params["*"] = requestSegments.slice(i).join("/");
+				break;
+			}
+		}
+		return params;
+	}
+	static query(requestPath) {
+		const query = {};
+		const queryString = requestPath.split("?")[1];
+		if (!queryString) return query;
+		return qs.parse(queryString);
+	}
+	toJSON() {
+		return {
+			path: this.path,
+			method: this.method,
+			middlewares: this.middlewares.map((mw) => mw.constructor.name),
+			metadata: this.metadata
+		};
+	}
+};
+//#endregion
+//#region src/shared/mixins/HooksMixin.ts
+async function emitHook(constructor, event, ...args) {
+	const listeners = constructor.listeners || [];
+	for await (const l of listeners.filter((l) => l.event === event)) await l.listener(...args);
+}
+function onHook(constructor, event, listener) {
+	const listeners = constructor.listeners || [];
+	if (listeners.find((l) => l.event === event && l.listener === listener)) return;
+	listeners.push({
+		event,
+		listener
+	});
+	constructor.listeners = listeners;
+}
+function HooksStatic(Base) {
+	return class extends Base {
+		constructor(...args) {
+			super(...args);
+			if (typeof this.constructor.boot === "function") this.constructor.boot.apply(this.constructor);
+		}
+		static listeners = [];
+		static on(event, listener) {
+			return onHook(this, event, listener);
+		}
+		static async emit(event, ...args) {
+			return emitHook(this, event, ...args);
+		}
+	};
+}
+function Hooks(Base) {
+	return class extends Base {
+		listeners;
+		constructor(...args) {
+			super(...args);
+			this.listeners = [];
+		}
+		on(event, listener) {
+			this.listeners.push({
+				event,
+				listener
+			});
+		}
+		off(event, listener) {
+			const index = this.listeners.findIndex((l) => l.event === event && l.listener === listener);
+			if (index === -1) return;
+			this.listeners.splice(index, 1);
+		}
+		emit(event, ...args) {
+			const listeners = this.listeners.filter((l) => l.event === event);
+			for (const l of listeners) l.listener(...args);
+		}
+		async emitAsync(event, ...args) {
+			const listeners = this.listeners.filter((l) => l.event === event);
+			for await (const l of listeners) await l.listener(...args);
+		}
+	};
+}
+HooksStatic.emit = emitHook;
+HooksStatic.on = onHook;
+//#endregion
+//#region src/server/services/RouterService.ts
+var Router = class Router extends compose(Hooks) {
+	routes = [];
+	middlewares = [];
+	prefixes = [];
+	groups = [];
+	groupPrefixes = [];
+	debug = false;
+	logger = logger.child({ label: "router" });
+	metadata = {};
+	constructor(data = {}) {
+		super();
+		this.routes = data.routes || [];
+		this.middlewares = data.middlewares || [];
+		this.prefixes = data.prefixes || [];
+		this.groups = data.groups || [];
+		this.groupPrefixes = data.groupPrefixes || [];
+		this.debug = data.debug || false;
+		this.metadata = data.metadata || {};
+		this.listeners = data.listeners || [];
+	}
+	use(middleware, context = "route") {
+		this.middlewares.push({
+			middleware,
+			context
+		});
+		return this;
+	}
+	prefix(prefix) {
+		this.prefixes.push(prefix);
+		return this;
+	}
+	makePath(args) {
+		return join(...this.groupPrefixes, ...this.prefixes, args);
+	}
+	add(payload) {
+		const route = new Route({
+			method: payload.method,
+			path: this.makePath(payload.path),
+			handler: payload.handler,
+			middlewares: this.middlewares.map((m) => m.middleware)
+		});
+		this.middlewares = this.middlewares.filter((m) => m.context !== "route");
+		this.prefixes = [];
+		this.routes.push(route);
+		if (this.debug) this.logger.debug("added route", route);
+		this.emit("added", route);
+	}
+	get(path, handler) {
+		this.add({
+			path,
+			method: "GET",
+			handler
+		});
+	}
+	post(path, handler) {
+		this.add({
+			path,
+			method: "POST",
+			handler
+		});
+	}
+	put(path, handler) {
+		this.add({
+			path,
+			method: "PUT",
+			handler
+		});
+	}
+	patch(path, handler) {
+		this.add({
+			path,
+			method: "PATCH",
+			handler
+		});
+	}
+	many(methods, path, handler) {
+		methods.forEach((method) => {
+			this.add({
+				path,
+				method,
+				handler
+			});
+		});
+	}
+	delete(path, handler) {
+		this.add({
+			path,
+			method: "DELETE",
+			handler
+		});
+	}
+	group() {
+		const group = new Router({
+			listeners: this.listeners,
+			debug: this.debug
+		});
+		group.groupPrefixes = this.prefixes;
+		group.middlewares = this.middlewares.map((r) => ({
+			middleware: r.middleware,
+			context: "group"
+		}));
+		this.groups.push(group);
+		this.middlewares = this.middlewares.filter((m) => m.context !== "route");
+		this.prefixes = [];
+		return group;
+	}
+	resolve(method, path) {
+		const route = this.list().find((r) => {
+			if (r.method.toUpperCase() !== method.toUpperCase()) return false;
+			return this.matchPath(r.path, path);
+		});
+		if (!route) return null;
+		return route;
+	}
+	async execute(route, initialCtx) {
+		if (!route.handler) throw new Error(`Route handler not found for ${route.method} ${route.path}`);
+		const ctx = { ...initialCtx };
+		for await (const middleware of route.middlewares) {
+			const result = await middleware.handle(ctx);
+			if (result && "redirect" in result) return result;
+			Object.assign(ctx, result);
+		}
+		return route.handler(ctx);
+	}
+	matchPath(routePath, requestPath) {
+		const routeSegments = routePath.split("/").filter(Boolean);
+		const requestSegments = requestPath.split("/").filter(Boolean);
+		for (let i = 0; i < routeSegments.length; i++) {
+			const routeSegment = routeSegments[i];
+			const requestSegment = requestSegments[i];
+			if (routeSegment === "*") return true;
+			if (i >= requestSegments.length) return false;
+			if (routeSegment.startsWith(":")) continue;
+			if (routeSegment !== requestSegment) return false;
+		}
+		if (requestSegments.length > routeSegments.length) return false;
+		return true;
+	}
+	clear() {
+		if (this.debug) this.logger.debug("clear", { count: this.routes.length });
+		this.routes = [];
+		this.groups = [];
+	}
+	list() {
+		return this.routes.concat(...this.groups.map((g) => g.routes));
+	}
+	async load(options = {}) {
+		this.debug = options.debug ?? this.debug;
+		if (this.debug) this.logger.debug("service loaded in debug mode");
+	}
+	loadSync(options = {}) {
+		this.debug = options.debug ?? this.debug;
+		if (this.debug) this.logger.debug("service loaded in debug mode");
+	}
+};
+//#endregion
+//#region src/server/services/ShellService.ts
+var ShellService = class {
+	debug;
+	logger;
+	init(data = {}) {
+		this.debug = data.debug || false;
+		this.logger = data.logger || logger.child({ label: "shell" });
+		if (this.debug) this.logger.debug("initialized in debug mode");
+	}
+	/**
+	* Execute a shell command and return a promise
+	*/
+	async command(bin, args, options = {}) {
+		return new Promise((resolve, reject) => {
+			const child = spawn(bin, args, {
+				cwd: options.cwd || process.cwd(),
+				stdio: "pipe",
+				shell: options.shell ?? true,
+				env: options.env || process.env
+			});
+			let data = "";
+			child.stdout?.on("data", (d) => {
+				data += d.toString();
+			});
+			child.stderr?.on("data", (d) => {
+				data += d.toString();
+			});
+			child.on("close", (code) => {
+				if (this.debug) this.logger.debug("command executed", {
+					bin,
+					args,
+					output: data
+				});
+				if (code === 0) return resolve();
+				const errorMessage = `Command failed with exit code ${code}`;
+				this.logger.error(errorMessage, {
+					bin,
+					args,
+					code,
+					output: data
+				});
+				reject(new ShellException(errorMessage, data, bin, args));
+			});
+			child.on("error", (error) => {
+				this.logger.error("Command execution error", {
+					bin,
+					args,
+					error: error.message
+				});
+				reject(error);
+			});
+		});
+	}
+	/**
+	* Execute a shell command and return the output as a string
+	*/
+	async executeCommandWithOutput(bin, args, options = {}) {
+		if (this.debug) this.logger.debug("executing command", {
+			bin,
+			args
+		});
+		return new Promise((resolve, reject) => {
+			const child = spawn(bin, args, {
+				cwd: options.cwd || process.cwd(),
+				stdio: "pipe",
+				shell: true,
+				env: options.env || process.env
+			});
+			let output = "";
+			let errorOutput = "";
+			child.stdout?.on("data", (data) => {
+				output += data.toString();
+			});
+			child.stderr?.on("data", (data) => {
+				errorOutput += data.toString();
+			});
+			child.on("close", (code) => {
+				if (code === 0) resolve(output.trim());
+				else {
+					const errorMessage = `Command failed with exit code ${code}: ${errorOutput}`;
+					this.logger.error(errorMessage, {
+						bin,
+						args,
+						code,
+						errorOutput
+					});
+					reject(new ShellException(errorMessage, output, bin, args));
+				}
+			});
+			child.on("error", (error) => {
+				this.logger.error("Command execution error", {
+					bin,
+					args,
+					error: error.message
+				});
+				reject(error);
+			});
+		});
+	}
+};
+//#endregion
+//#region src/server/repositories/DatabaseRepository.ts
+var DatabaseRepository = class {
+	db = null;
+	table = "";
+	primaryKey = "id";
+	constructor(db, table, primaryKey) {
+		if (db) this.db = db;
+		if (table) this.table = table;
+		if (primaryKey) this.primaryKey = primaryKey;
+	}
+	setDatabase(db) {
+		this.db = db;
+		return this;
+	}
+	setTable(table) {
+		this.table = table;
+		return this;
+	}
+	setPrimaryKey(primaryKey) {
+		this.primaryKey = primaryKey;
+		return this;
+	}
+	query(options) {
+		return options?.qb || this.db.selectFrom(this.table);
+	}
+	async count(options) {
+		let qb = this.query(options);
+		qb = qb.select((eb) => eb.fn.countAll().as("count"));
+		const result = await qb.executeTakeFirstOrThrow();
+		return Number(result.count);
+	}
+	async findMany(options) {
+		let qb = this.query(options);
+		qb = qb.selectAll();
+		if (options?.limit) qb = qb.limit(options.limit);
+		if (options?.offset) qb = qb.offset(options.offset);
+		if (options?.orderBy) {
+			const orderBy = Array.isArray(options.orderBy) ? options.orderBy : [options.orderBy];
+			const orderDirection = Array.isArray(options.orderDirection) ? options.orderDirection : [options.orderDirection ?? "asc"];
+			orderBy.forEach((ob, index) => {
+				qb = qb.orderBy(ob, orderDirection[index] || "asc");
+			});
+		}
+		return await qb.execute();
+	}
+	async findById(id, options) {
+		let qb = this.query(options);
+		qb = qb.selectAll();
+		qb = qb.where(this.primaryKey, "=", id);
+		return await qb.executeTakeFirst();
+	}
+	async findByIdOrFail(id, options) {
+		const item = await this.findById(id, options);
+		if (!item) throw new BaseException("Item not found", 404);
+		return item;
+	}
+	async paginate(options) {
+		const page = options?.page ?? 1;
+		const offset = (page - 1) * (options?.limit ?? 10);
+		const limit = options?.limit ?? 10;
+		const findAllOptions = {
+			...options,
+			limit,
+			offset
+		};
+		const countOptions = { ...options };
+		const [items, totalItems] = await Promise.all([this.findMany(findAllOptions), this.count(countOptions)]);
+		return {
+			items,
+			page,
+			per_page: limit,
+			total: totalItems,
+			total_pages: Math.ceil(totalItems / limit)
+		};
+	}
+	async create(data) {
+		let qb = this.db.insertInto(this.table);
+		qb = qb.values(data).returningAll();
+		return await qb.executeTakeFirst();
+	}
+	async createMany(data) {
+		let qb = this.db.insertInto(this.table);
+		qb = qb.values(data).returningAll();
+		return await qb.execute();
+	}
+	async updateById(id, data) {
+		const row = await this.findByIdOrFail(id);
+		let qb = this.db.updateTable(this.table);
+		qb = qb.set(data).where(this.primaryKey, "=", row[this.primaryKey]).returningAll();
+		await qb.executeTakeFirst();
+	}
+	async deleteById(id) {
+		const row = await this.findByIdOrFail(id);
+		let qb = this.db.deleteFrom(this.table);
+		qb = qb.where(this.primaryKey, "=", row[this.primaryKey]);
+		await qb.executeTakeFirst();
+	}
+	async deleteMany(options) {
+		const deleteOptions = {
+			...options,
+			qb: this.db.deleteFrom(this.table)
+		};
+		let qb = this.query(deleteOptions);
+		if (options?.limit) qb = qb.limit(options.limit);
+		await qb.execute();
+	}
+};
+//#endregion
+//#region src/server/mixins/DatabaseRepositoryInferMixin.ts
+function DatabaseRepositoryInferMixin() {
+	return function(Base) {
+		class OptionsMixin extends Base {}
+		return OptionsMixin;
+	};
+}
+//#endregion
+//#region src/server/repositories/PermissionAssignmentRepository.ts
+var PermissionAssignmentRepository = class extends compose(mixin(DatabaseRepository), DatabaseRepositoryInferMixin()) {
+	constructor(db) {
+		super(db, "permissions_assignments", "id");
+	}
+	query(options) {
+		let qb = super.query(options);
+		if (options?.id) {
+			const ids = Array.isArray(options.id) ? options.id : [options.id];
+			qb = qb.where("id", "in", ids);
+		}
+		if (options?.permissionId) {
+			const permissionIds = Array.isArray(options.permissionId) ? options.permissionId : [options.permissionId];
+			qb = qb.where("permission_id", "in", permissionIds);
+		}
+		if (options?.assignableId) {
+			const assignableIds = Array.isArray(options.assignableId) ? options.assignableId : [options.assignableId];
+			qb = qb.where("assignable_id", "in", assignableIds);
+		}
+		if (options?.assignableType) {
+			const assignableTypes = Array.isArray(options.assignableType) ? options.assignableType : [options.assignableType];
+			qb = qb.where("assignable_type", "in", assignableTypes);
+		}
+		return qb;
+	}
+};
+//#endregion
+//#region src/server/repositories/PermissionRepository.ts
+var PermissionRepository = class extends compose(mixin(DatabaseRepository), DatabaseRepositoryInferMixin()) {
+	constructor(db) {
+		super(db, "permissions", "id");
+	}
+	query(options) {
+		let qb = super.query(options);
+		if (options?.id) {
+			const ids = Array.isArray(options.id) ? options.id : [options.id];
+			qb = qb.where("id", "in", ids);
+		}
+		if (options?.search) qb = qb.where("name", "like", `%${options.search}%`);
+		return qb;
+	}
+};
+//#endregion
+//#region src/server/repositories/TokenRepository.ts
+var TokenRepository = class extends compose(mixin(DatabaseRepository), DatabaseRepositoryInferMixin()) {
+	constructor(db) {
+		super(db, "tokens", "id");
+	}
+	query(options) {
+		let qb = super.query(options);
+		if (options?.id) {
+			const ids = Array.isArray(options.id) ? options.id : [options.id];
+			qb = qb.where("id", "in", ids);
+		}
+		if (options?.search) qb = qb.where("name", "like", `%${options.search}%`);
+		if (options?.type) {
+			const types = Array.isArray(options.type) ? options.type : [options.type];
+			qb = qb.where("type", "in", types);
+		}
+		return qb;
+	}
+	async findByToken(token) {
+		let qb = this.query();
+		qb = qb.selectAll();
+		qb = qb.where("token", "=", token);
+		return await qb.executeTakeFirst() || null;
+	}
+};
+//#endregion
 //#region src/server/gateways/GitGateway.ts
 const execAsync = promisify(exec);
 function escapeShellArgument(value) {
@@ -423,7 +1503,7 @@ var GitGateway = class {
 			result.sshKeyFile = this.sshKeyFile;
 		}
 		if (this.sshKey) {
-			const tempFile = this.sshKeyTmpFileName ?? join(tmpdir(), `git-ssh-key-${randomUUID()}`);
+			const tempFile = this.sshKeyTmpFileName ?? join$1(tmpdir(), `git-ssh-key-${randomUUID()}`);
 			await writeFile(tempFile, this.sshKey, { mode: 384 });
 			result.env.GIT_SSH_COMMAND = `ssh -i ${escapeShellArgument(tempFile)} -o StrictHostKeyChecking=no`;
 			result.sshKeyFile = tempFile;
@@ -486,4 +1566,178 @@ var GitGateway = class {
 	}
 };
 //#endregion
-export { EmmitterService, GitBranchRepository, GitCommitRepository, GitGateway, PluginIpcClient, PluginIpcHost, PluginRouter };
+//#region src/server/facades/config.ts
+const config = container.proxy(ConfigService);
+//#endregion
+//#region src/server/facades/database.ts
+const key = "database";
+const database = container.proxy(key);
+//#endregion
+//#region src/server/facades/router.ts
+const router = container.proxy(Router);
+//#endregion
+//#region src/server/facades/shell.ts
+const shell = new ShellService();
+//#endregion
+//#region src/server/utils/defineLoader.ts
+function defineLoader(loader) {
+	return loader;
+}
+//#endregion
+//#region src/server/loaders/createHasManyThroughLoader.ts
+async function loadHasManyThrough(payload, options) {
+	const entities = Array.isArray(payload) ? payload : [payload];
+	const target = options.target;
+	const pivot = options.pivot;
+	function findKey(entity, keyOrFn) {
+		if (typeof keyOrFn === "function") return keyOrFn(entity);
+		return get(entity, keyOrFn);
+	}
+	const pivoIds = entities.map((e) => findKey(e, pivot.sourceKey)).filter(Boolean);
+	const pivotEntities = await pivot.findEntities(pivoIds);
+	const targetIds = pivotEntities.map((p) => findKey(p, pivot.targetKey)).filter(Boolean);
+	const targetEntities = await target.findEntities(targetIds);
+	for (const entity of entities) {
+		const pivots = pivotEntities.filter((p) => findKey(p, pivot.sourceKey) === findKey(entity, pivot.sourceKey));
+		if (!pivots.length) {
+			set(entity, options.key, []);
+			continue;
+		}
+		const targets = targetEntities.filter((t) => pivots.some((p) => findKey(p, target.sourceKey) === findKey(t, target.targetKey)));
+		set(entity, options.key, targets);
+	}
+}
+function createHasManyThroughLoader(options) {
+	return defineLoader({ load: async (entities) => loadHasManyThrough(entities, options) });
+}
+//#endregion
+//#region src/server/utils/basePath.ts
+const BASE_PATH = process.env.ZENITH_BASE_PATH;
+function basePath(...args) {
+	if (!BASE_PATH) throw new Error("ZENITH_BASE_PATH environment variable is not set");
+	return path.resolve(BASE_PATH, ...args);
+}
+function tmpPath(...args) {
+	return basePath("tmp", ...args);
+}
+//#endregion
+//#region src/server/entities/ModuleEntity.ts
+var Module = class extends composeWith(Module$1) {
+	get git() {
+		return new GitGateway({
+			cwd: this.directory,
+			sshKey: config.get(`modules.${this.id}.ssh_key`),
+			sshKeyTmpFileName: tmpPath(`ssh_key_${this.id}.pem`),
+			logger: logger.child({ label: "git" }),
+			debug: config.get("git.debug", false)
+		});
+	}
+	makePath(...parts) {
+		return join(this.directory, this.id, ...parts);
+	}
+	staticPath(...parts) {
+		return join("/static", "modules", this.id, ...parts);
+	}
+	command = (bin, args, options) => {
+		return shell.command(bin, args, {
+			cwd: this.directory,
+			...options
+		});
+	};
+	load() {
+		const manifestPath = this.makePath("module.json");
+		if (!fs.existsSync(manifestPath)) return;
+		const content = fs.readFileSync(manifestPath, "utf-8");
+		const json = JSON.parse(content);
+		this.dependencies = json.dependencies || {};
+		this.build = json.build || {};
+	}
+};
+//#endregion
+//#region src/server/utils/createLoaderFactory.ts
+function createLoaderFactory(loaders) {
+	async function load(entities, names) {
+		const items = Array.isArray(entities) ? entities : [entities];
+		const relationNames = Array.isArray(names) ? names : [names];
+		for (const name of relationNames) {
+			const loader = loaders?.[name];
+			if (!loader) throw new BaseException(`Loader ${String(name)} not declared`);
+			await loader.load(items);
+		}
+	}
+	return {
+		keys: Object.keys(loaders),
+		loaders,
+		load
+	};
+}
+//#endregion
+//#region src/server/utils/importAll.ts
+async function importFiles(files, options = {}) {
+	const modules = {};
+	let onError = (ctx) => {
+		Object.assign(ctx.error, { filename: ctx.filename });
+		logger.error(`Failed to import ${ctx.filename}`, ctx.error);
+	};
+	if (options.onError) onError = options.onError;
+	for (const filename of files) {
+		if (options.exclude && options.exclude.some((pattern) => filename.includes(pattern))) continue;
+		const ctx = { filename };
+		if (options.onBeforeImport) await options.onBeforeImport(ctx);
+		const cleanFilename = ctx.filename.split("?")[0];
+		if (/\.(mts|ts|js)$/.test(cleanFilename)) {
+			const fileUrl = pathToFileURL(path.resolve(ctx.filename));
+			if (options.cache === false) fileUrl.searchParams.set("t", Date.now().toString());
+			const [error, mod] = await tryCatch(() => import(fileUrl.toString()));
+			if (error) {
+				Object.assign(error, {
+					filename: ctx.filename,
+					url: fileUrl
+				});
+				onError({
+					filename: ctx.filename,
+					error
+				});
+				continue;
+			}
+			modules[filename] = mod;
+		}
+		if (/\.json$/.test(cleanFilename)) {
+			const [error, json] = await tryCatch(async () => {
+				const text = await fs.promises.readFile(ctx.filename, "utf8");
+				return JSON.parse(text);
+			});
+			if (error) {
+				onError({
+					filename: ctx.filename,
+					error
+				});
+				continue;
+			}
+			modules[filename] = json;
+		}
+		if (options.onAfterImport) await options.onAfterImport({
+			...ctx,
+			module: modules[filename]
+		});
+	}
+	return modules;
+}
+async function importGlob(pattern, options = {}) {
+	return importFiles(await fg(pattern), options);
+}
+async function importAll(directory, options = {}) {
+	return importFiles((await fs.promises.readdir(directory, { withFileTypes: true })).filter((dirent) => dirent.isFile()).map((dirent) => path.join(directory, dirent.name)), options);
+}
+//#endregion
+//#region src/server/utils/importOne.ts
+async function importOne(filenames) {
+	for (const filename of filenames) {
+		const fileUrl = pathToFileURL$1(filename);
+		if (!fs$1.existsSync(filename)) continue;
+		return await import(fileUrl.toString());
+	}
+	return null;
+}
+//#endregion
+export { DatabaseRepository, DatabaseRepositoryInferMixin, EmmitterService, GitBranchRepository, GitCommitRepository, GitGateway, Module as ModuleEntity, PermissionAssignmentRepository, PermissionRepository, PluginIpcClient, PluginIpcHost, PluginRouter, Route as RouteEntity, RouterFileBaseRoutingService, Router as RouterService, ShellService, TokenRepository, basePath, config, container, createHasManyThroughLoader, createLoaderFactory, database, defineLoader, importAll, importFiles, importGlob, importOne, key, loadHasManyThrough, logger, router, shell, tmpPath };