@sidekick-coder/zenith-kit 0.0.8 → 0.0.11

package/dist/shared/index.mjs

@@ -1,8 +1,206 @@
-import "lodash-es";
+import { t as __exportAll } from "./chunk-CfYAbeIz.mjs";
+import { debounce, get, has, set, unset } from "lodash-es";
 import * as v from "valibot";
+import { format } from "date-fns";
+import qs from "qs";
 import fg from "fast-glob";
 import fs from "fs";
 import path from "path";
+//#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/services/CookieService.ts
+var CookieService = class {
+	cookies;
+	prefix;
+	constructor(data = {}) {
+		this.cookies = data.cookies || /* @__PURE__ */ new Map();
+		this.prefix = data.prefix || "";
+	}
+	load(cookies) {
+		if (cookies instanceof Map) {
+			for (const [key, value] of cookies.entries()) this.set(key, value);
+			return;
+		}
+		for (const key of Object.keys(cookies)) this.set(key, cookies[key]);
+	}
+	get(name, defaultValue = null) {
+		const fullName = this.prefix + name;
+		return this.cookies.get(fullName) || defaultValue;
+	}
+	set(name, value, options) {
+		const fullName = this.prefix + name;
+		this.cookies.set(fullName, value);
+	}
+	toRecord() {
+		const result = {};
+		for (const [key, value] of this.cookies.entries()) if (key.startsWith(this.prefix)) {
+			const unprefixedKey = key.slice(this.prefix.length);
+			result[unprefixedKey] = value;
+		}
+		return result;
+	}
+};
+//#endregion
 //#region src/shared/utils/compose.ts
 /**
 * Composes multiple mixins into a single class that can be extended.
@@ -128,6 +326,334 @@ function createId(prefix = "") {
 	return prefix + uuid();
 }
 //#endregion
+//#region src/shared/services/LoggerService.ts
+var LoggerService = class LoggerService {
+	info(message, meta) {}
+	debug(message, meta) {}
+	warn(message, meta) {}
+	error(message, meta) {}
+	child(options) {
+		return new LoggerService();
+	}
+};
+//#endregion
+//#region src/shared/services/EmmitterService.ts
+var EmmitterService = class {
+	handlers = [];
+	debug;
+	logger;
+	load(options) {
+		this.debug = options?.debug || false;
+		this.logger = options?.logger || new LoggerService();
+		if (this.debug) this.logger.debug("emmitter loaded with debug mode enabled");
+	}
+	on(event, listener, options) {
+		const id = options?.id || createId();
+		if (options?.unique) {
+			if (this.handlers.some((h) => h.event === event && h.listener === listener || h.id === id)) return;
+		}
+		const handler = {
+			id,
+			event,
+			listener
+		};
+		this.handlers.push(handler);
+		if (this.debug) this.logger.debug("handler added", handler);
+		return handler;
+	}
+	once(event, listener, options) {
+		const wrapper = (args) => {
+			listener(args);
+			this.off(event, wrapper);
+		};
+		return this.on(event, wrapper, options);
+	}
+	onDebounce(event, listener, options) {
+		const debounced = debounce(listener, options?.debounce || 300);
+		const handler = this.on(event, debounced, options);
+		if (handler) handler.originalListener = listener;
+		return handler;
+	}
+	onAnyOf(events, listener, options) {
+		const handlers = [];
+		for (const event of events) {
+			const handler = this.on(event, listener, options);
+			if (handler) handlers.push(handler);
+		}
+		return handlers;
+	}
+	off(event, listener) {
+		this.handlers = this.handlers.filter((h) => {
+			if (h.event === event && (h.listener === listener || h.originalListener === listener)) return false;
+			return true;
+		});
+		if (this.debug) this.logger.debug("handler removed", { event });
+	}
+	emit(event, args) {
+		if (this.debug) this.logger.debug("emitting event", {
+			event,
+			args
+		});
+		const handlers = this.handlers.filter((h) => h.event === event);
+		for (const handler of handlers) tryCatch.sync(() => handler.listener(args));
+	}
+	async emitAndWait(event, args) {
+		const handlers = this.handlers.filter((h) => h.event === event);
+		if (this.debug) this.logger.debug("emitting event", {
+			handlers: handlers.length,
+			event,
+			args
+		});
+		for await (const handler of handlers) await handler.listener(args);
+	}
+	list() {
+		return this.handlers;
+	}
+	listByEvent(event) {
+		return this.handlers.filter((h) => h.event === event);
+	}
+	remove(payload) {
+		const ids = Array.isArray(payload) ? payload : [payload];
+		this.handlers = this.handlers.filter((h) => !ids.includes(h.id));
+		if (this.debug) this.logger.debug("handlers removed", { ids });
+	}
+	clear() {
+		this.handlers = [];
+		if (this.debug) this.logger.debug("all handlers cleared");
+	}
+	hasHandlers() {
+		return this.handlers.length > 0;
+	}
+};
+//#endregion
+//#region src/shared/services/LifecycleService.ts
+var LifecycleService = class {
+	hooks;
+	logger;
+	debug = false;
+	constructor(data = {}) {
+		this.debug = data.debug ?? this.debug;
+		this.hooks = data.hooks ?? /* @__PURE__ */ new Map();
+		this.logger = data.logger ?? new LoggerService();
+	}
+	async executeHookMethod(hook, method) {
+		await hook[method]();
+		if (this.debug) this.logger.debug(`${method} ${hook.hook_id}`);
+		const subhooks = hook.subhooks || [];
+		for (const subhook of subhooks) {
+			await this.executeHookMethod(subhook, method);
+			if (this.debug) this.logger.debug(`${method} subhook ${subhook.hook_id} of ${hook.hook_id}`);
+		}
+	}
+	list(options) {
+		let hooks = Array.from(this.hooks.values());
+		if (options?.exclude) {
+			const ids = options.exclude.filter((item) => typeof item === "string");
+			const constructors = options.exclude.filter((item) => typeof item === "function");
+			const instances = options.exclude.filter((item) => typeof item === "object");
+			hooks = hooks.filter((hook) => {
+				if (ids.includes(hook.hook_id)) return false;
+				if (constructors.find((ctor) => hook instanceof ctor)) return false;
+				if (instances.find((inst) => hook === inst)) return false;
+				return true;
+			});
+		}
+		hooks.sort((a, b) => {
+			return (a.order ?? 0) - (b.order ?? 0);
+		});
+		return hooks;
+	}
+	add(...payload) {
+		const instances = [];
+		for (const item of payload) {
+			if (typeof item === "function") {
+				instances.push(new item());
+				continue;
+			}
+			instances.push(item);
+		}
+		for (const hook of instances) {
+			this.hooks.set(hook.hook_id, hook);
+			if (this.debug) this.logger.debug("add " + hook.hook_id);
+			if (hook.subhooks) hook.subhooks.forEach((subhook) => this.add(subhook));
+		}
+	}
+	async register(options) {
+		for (const hook of this.list(options)) {
+			const [error] = await tryCatch(() => this.executeHookMethod(hook, "onRegister"));
+			if (error) {
+				Object.assign(error, { hookId: hook.hook_id });
+				this.logger.error("error in hook register: ", error);
+				continue;
+			}
+			if (this.debug) this.logger.debug("register " + hook.hook_id);
+		}
+	}
+	async load(options) {
+		for (const hook of this.list(options)) {
+			const [error] = await tryCatch(() => this.executeHookMethod(hook, "onLoad"));
+			if (error) {
+				Object.assign(error, { hookId: hook.hook_id });
+				this.logger.error("error in hook load:", error);
+				continue;
+			}
+			if (this.debug) this.logger.debug("load " + hook.hook_id);
+		}
+	}
+	async boot(options) {
+		const hooks = this.list(options);
+		for (const hook of hooks) {
+			const [error] = await tryCatch(() => this.executeHookMethod(hook, "onBoot"));
+			if (error) {
+				Object.assign(error, { hookId: hook.hook_id });
+				this.logger.error("error in hook boot:", error);
+				continue;
+			}
+			if (this.debug) this.logger.debug("boot " + hook.hook_id);
+		}
+	}
+	async shutdown(options) {
+		for (const hook of this.list(options)) {
+			const [error] = await tryCatch(() => this.executeHookMethod(hook, "onShutdown"));
+			if (error) {
+				Object.assign(error, { hookId: hook.hook_id });
+				this.logger.error("error in hook shutdown:", error);
+				continue;
+			}
+			if (this.debug) this.logger.debug("shutdown " + hook.hook_id);
+		}
+	}
+	clear() {
+		this.hooks.clear();
+	}
+};
+//#endregion
+//#region src/shared/services/TranslatorService.ts
+var TranslatorService = class {
+	entries;
+	locale;
+	localeLoaders;
+	debug = false;
+	logger;
+	cache;
+	constructor(data = {}) {
+		this.entries = data.entries || /* @__PURE__ */ new Map();
+		this.locale = data.locale || "en";
+		this.debug = data.debug || false;
+		this.cache = data.cache || /* @__PURE__ */ new Map();
+		this.logger = data.logger || new LoggerService();
+		this.localeLoaders = /* @__PURE__ */ new Map();
+		if (this.debug) this.logger.debug("initialized in debug mode", { locale: this.locale });
+	}
+	get locales() {
+		return Array.from(this.localeLoaders.keys());
+	}
+	list() {
+		const items = [];
+		this.entries.forEach((value, key) => {
+			items.push({
+				key,
+				value
+			});
+		});
+		return items;
+	}
+	async getEntries(locale) {
+		const cache = this.cache.get(locale);
+		if (cache && this.debug) this.logger.debug(`load locale "${locale}" from cache`, {
+			locale,
+			length: Object.keys(cache).length
+		});
+		if (cache) return cache;
+		const loader = this.localeLoaders.get(locale);
+		if (!loader) {
+			this.logger.warn(`no loader found for locale "${locale}"`);
+			return {};
+		}
+		const entries = await loader();
+		this.cache.set(locale, entries);
+		if (this.debug) this.logger.debug(`load locale ${locale}`, {
+			locale,
+			keys: Object.keys(entries).length
+		});
+		return entries;
+	}
+	async load(locale) {
+		const entries = await this.getEntries(locale);
+		this.entries = new Map(Object.entries(entries));
+		this.locale = locale;
+	}
+	t(key, args = {}) {
+		if (!this.entries.has(key) && this.debug) this.logger.debug(`missing translation for key "${key}"`, {
+			key,
+			locale: this.locale
+		});
+		let translation = this.entries.get(key) || key;
+		if (!Object.keys(args).length) return translation;
+		Object.entries(args).forEach(([aKey, aValue]) => {
+			translation = translation.replace(`:${aKey}`, aValue);
+		});
+		return translation;
+	}
+	date(data) {
+		return new Date(data).toLocaleDateString(this.locale, {
+			year: "numeric",
+			month: "2-digit",
+			day: "2-digit"
+		});
+	}
+	datetime(data) {
+		return new Date(data).toLocaleString(this.locale, {
+			year: "numeric",
+			month: "2-digit",
+			day: "2-digit",
+			hour: "2-digit",
+			minute: "2-digit"
+		});
+	}
+};
+//#endregion
+//#region src/shared/services/UploadService.ts
+var UploadService = class {
+	single(name) {
+		const error = /* @__PURE__ */ new Error("Method not implemented.");
+		Object.assign(error, { name });
+		throw error;
+	}
+	multiple(name) {
+		const error = /* @__PURE__ */ new Error("Method not implemented.");
+		Object.assign(error, { name });
+		throw error;
+	}
+};
+//#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/exceptions/BaseException.ts
 var BaseException = class BaseException extends Error {
 	statusCode = 500;
@@ -142,12 +668,17 @@ var BaseException = class BaseException extends Error {
 };
 //#endregion
 //#region src/shared/services/ValidatorService.ts
+const extras = { url: url_exports };
 var ValidatorService = class {
+	v = {
+		...v,
+		extras
+	};
 	create(cb) {
-		return cb(v);
+		return cb(this.v);
 	}
 	validate(payload, cb) {
-		const schema = typeof cb === "function" ? cb(v) : 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);
@@ -165,7 +696,7 @@ var ValidatorService = class {
 		return output;
 	}
 	async validateAsync(payload, cb) {
-		const schema = typeof cb === "function" ? cb(v) : 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");
@@ -180,27 +711,146 @@ var ValidatorService = class {
 		return output;
 	}
 	isValid(payload, cb) {
-		const schema = typeof cb === "function" ? cb(v) : cb;
+		const schema = typeof cb === "function" ? cb(this.v) : cb;
 		const { success } = v.safeParse(schema, payload);
 		return success;
 	}
 };
-new ValidatorService();
 //#endregion
 //#region src/shared/utils/generateIndexFile.ts
 function generateIndexFile(options) {
 	const folders = options.folders;
 	const filename = options.filename;
+	const defaultIgnore = [
+		"**/index.ts",
+		"**/*.spec.ts",
+		"**/*.test.ts"
+	];
+	const ignore = options.ignore || [];
 	let content = "";
 	for (const folder of folders) {
-		const files = fg.sync(`${folder}/**/*.ts`, { ignore: ["**/index.ts"] });
+		const files = fg.sync(`${folder}/**/*.ts`, { ignore: [...defaultIgnore, ...ignore] });
 		for (const file of files) {
 			const filePath = path.relative(path.dirname(filename), file);
+			const hasDefaultExport = fs.readFileSync(file, "utf-8").includes("export default") && !filePath.includes("generateIndexFile.ts");
 			content += `export * from './${filePath}'\n`;
+			if (hasDefaultExport) content += `export { default as ${path.basename(file, ".ts")} } from './${filePath}'\n`;
 		}
 	}
 	content = content.trim();
 	fs.writeFileSync(filename, content);
 }
 //#endregion
-export { ValidatorService, compose, composeWith, createId, flatten, formatBytes, generateIndexFile, mixin, tryCatch, unflatten };
+//#region src/shared/schemas/permissionAssignmentSchema.ts
+const permissionAssignmentSchema = 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()
+});
+//#endregion
+//#region src/shared/schemas/permissionSchema.ts
+const permissionSchema = 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()
+});
+//#endregion
+//#region src/shared/schemas/tokenSchema.ts
+const tokenSchema = 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;
+	}
+};
+//#endregion
+//#region src/shared/facades/validator.ts
+const validator = 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 = 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}`;
+	}
+};
+//#endregion
+//#region src/shared/entities/ModuleManifestEntity.ts
+var ModuleManifest = class extends compose(BaseEntity) {
+	id;
+	name;
+	version;
+	description;
+	enabled;
+	author;
+	dependencies;
+	build;
+};
+//#endregion
+export { BaseException, ConfigService, ContainerService, CookieService, EmmitterService, LifecycleHook, LifecycleService, LoggerService, Module as ModuleEntity, ModuleManifest as ModuleManifestEntity, ShellException, TranslatorService, UploadService, ValidatorService, compose, composeWith, createId, flatten, formatBytes, generateIndexFile, mixin, permissionAssignmentSchema, permissionSchema, tokenSchema, tryCatch, unflatten, validator };