@sidekick-coder/zenith-kit 0.0.10 → 0.0.11

package/dist/shared/chunk-CfYAbeIz.mjs

@@ -0,0 +1,13 @@
+//#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
+export { __exportAll as t };

package/dist/shared/index.d.mts

@@ -25,7 +25,7 @@ declare class ConfigService {
 //#region src/shared/services/ContainerService.d.ts
 type Constructor$1<T = object> = new (...args: any[]) => T;
 type EntryKey = string | symbol | Constructor$1;
-declare class DIService {
+declare class ContainerService {
   private entries;
   loadFromRecord(record: Record<string, any>): void;
   toRecord(): Record<string, any>;
@@ -203,27 +203,48 @@ declare class UploadService {
   single(name: string): void;
   multiple(name: string): void;
 }
+declare namespace url_d_exports {
+  export { array, arrayNumber, boolean, date, datetime, number, object };
+}
+declare const number: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.NumberSchema<undefined>], undefined>, v.TransformAction<any, number>, v.IntegerAction<number, undefined>]>;
+declare const boolean: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.BooleanSchema<undefined>], undefined>, v.TransformAction<string | boolean, boolean>]>;
+declare const date: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.DateSchema<undefined>], undefined>, v.TransformAction<string | Date, Date>, v.TransformAction<Date, string | Date>]>;
+declare const datetime: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.DateSchema<undefined>], undefined>, v.TransformAction<string | Date, string | Date>]>;
+declare const array: <T extends v.BaseSchema<any, any, any>>(schema?: T) => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<T, undefined>]>;
+declare const arrayNumber: () => v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.ArraySchema<v.StringSchema<undefined>, undefined>], undefined>, v.TransformAction<string | string[], string[]>, v.ArraySchema<v.BaseSchema<any, any, any>, undefined>]>, v.TransformAction<any[], number[]>]>;
+declare const object: () => v.SchemaWithPipe<readonly [v.UnionSchema<[v.StringSchema<undefined>, v.RecordSchema<v.StringSchema<undefined>, v.AnySchema, undefined>], undefined>, v.TransformAction<string | {
+  [x: string]: any;
+}, {
+  [x: string]: any;
+}>, v.TransformAction<{
+  [x: string]: any;
+}, Record<string, any>>]>;
 //#endregion
 //#region src/shared/services/ValidatorService.d.ts
-type Valibot = typeof v;
+declare const extras: {
+  url: typeof url_d_exports;
+};
+type Valibot = typeof v & {
+  extras: typeof extras;
+};
 type ValibotSchema = v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>>;
 type ValibotSchemaAsync = v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>;
 interface ValidatorCallback<T extends ValibotSchema> {
-  (_v: typeof v): T;
+  (_v: Valibot): T;
 }
 type ValidatorCallbackAsync<T extends ValibotSchemaAsync> = {
-  (_v: typeof v): T;
+  (_v: Valibot): T;
 };
 type ValidatorResult<T extends v.ObjectEntries> = v.InferOutput<v.ObjectSchema<T, undefined>>;
 type ValidatePayload<T extends ValibotSchema = ValibotSchema> = ValidatorCallback<T> | T;
 type ValidateResult<T extends ValidatePayload> = T extends ValibotSchema ? v.InferOutput<T> : T extends ValidatorCallback<infer U> ? v.InferOutput<U> : unknown;
 declare class ValidatorService {
+  v: Valibot;
   create<T extends ValibotSchema>(cb: ValidatorCallback<T>): T;
   validate<T extends ValibotSchema>(payload: any, cb: ValidatePayload<T>): v.InferOutput<T>;
   validateAsync<T extends ValibotSchemaAsync>(payload: any, cb: ValidatorCallbackAsync<T> | T): Promise<v.InferOutput<T>>;
   isValid<T extends ValibotSchema>(payload: any, cb: ValidatePayload<T>): boolean;
 }
-declare const validator: ValidatorService;
 //#endregion
 //#region src/shared/utils/createId.d.ts
 declare function createId(prefix?: string): string;
@@ -252,4 +273,109 @@ declare namespace tryCatch {
   var sync: <T extends Tryer>(tryer: T) => TryCatchResult<T>;
 }
 //#endregion
-export { AnyClass, ConfigService, Constructor, DIService as ContainerService, CookieService, EmmitterService, EmmitterServiceOptions, LifecycleService, LoggerService, Mixin, PartialBy, PublicData, TranslatorService, UnionToIntersection, UploadService, Valibot, ValibotSchema, ValibotSchemaAsync, ValidatePayload, ValidateResult, ValidatorCallback, ValidatorCallbackAsync, ValidatorResult, validator as ValidatorService, compose, composeWith, createId, flatten, formatBytes, generateIndexFile, mixin, tryCatch, unflatten };
+//#region src/shared/schemas/permissionAssignmentSchema.d.ts
+type PermissionAssignment = v.InferOutput<typeof permissionAssignmentSchema>;
+declare const permissionAssignmentSchema: v.ObjectSchema<{
+  readonly id: v.NumberSchema<undefined>;
+  readonly permission_id: v.NumberSchema<undefined>;
+  readonly assignable_type: v.StringSchema<undefined>;
+  readonly assignable_id: v.StringSchema<undefined>;
+  readonly created_at: v.StringSchema<undefined>;
+  readonly updated_at: v.StringSchema<undefined>;
+}, undefined>;
+//#endregion
+//#region src/shared/schemas/permissionSchema.d.ts
+type Permission = v.InferOutput<typeof permissionSchema>;
+declare const permissionSchema: v.ObjectSchema<{
+  readonly id: v.NumberSchema<undefined>;
+  readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+  readonly description: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+  readonly action: v.StringSchema<undefined>;
+  readonly subject: v.StringSchema<undefined>;
+  readonly conditions: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+  readonly created_at: v.StringSchema<undefined>;
+  readonly updated_at: v.StringSchema<undefined>;
+  readonly expires_at: v.StringSchema<undefined>;
+}, undefined>;
+//#endregion
+//#region src/shared/schemas/tokenSchema.d.ts
+type Token = v.InferOutput<typeof tokenSchema>;
+declare const tokenSchema: v.ObjectSchema<{
+  readonly id: v.NumberSchema<undefined>;
+  readonly name: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+  readonly type: v.StringSchema<undefined>;
+  readonly user_id: v.NumberSchema<undefined>;
+  readonly token: v.StringSchema<undefined>;
+  readonly created_at: v.StringSchema<undefined>;
+  readonly updated_at: v.StringSchema<undefined>;
+  readonly expires_at: v.StringSchema<undefined>;
+}, undefined>;
+//#endregion
+//#region src/shared/exceptions/BaseException.d.ts
+declare class BaseException extends Error {
+  statusCode: number;
+  constructor(message: string, statusCode?: number);
+  static fromError(error: Error): BaseException;
+}
+//#endregion
+//#region src/shared/exceptions/ShellException.d.ts
+declare class ShellException extends BaseException {
+  output: string;
+  bin: string;
+  args: string[];
+  constructor(message: string, output: string, bin: string, args: string[]);
+}
+//#endregion
+//#region src/shared/facades/validator.d.ts
+declare const validator: ValidatorService;
+//#endregion
+//#region src/shared/entities/ModuleManifestEntity.d.ts
+interface ModuleManifestBuildImport {
+  from: string;
+  to?: string;
+  type: 'global_import';
+}
+interface ModuleManifestBuild {
+  imports?: ModuleManifestBuildImport[];
+}
+declare const ModuleManifest_base: {
+  new (...args: any[]): {
+    merge(data: Partial< /*elided*/any>): /*elided*/any;
+  };
+  from<T>(this: new () => T, data: Partial<T>): T;
+} & Constructor;
+declare class ModuleManifest extends ModuleManifest_base {
+  id: string;
+  name: string;
+  version: string;
+  description?: string;
+  enabled: boolean;
+  author?: string;
+  dependencies?: Record<string, string>;
+  build?: ModuleManifestBuild;
+  [key: string]: any;
+}
+//#endregion
+//#region src/shared/entities/ModuleEntity.d.ts
+interface ModuleUpgradeInfo {
+  source: 'git' | 'zip';
+  [key: string]: any;
+}
+declare const Module_base: {
+  new (...args: any[]): {
+    merge(data: Partial< /*elided*/any>): /*elided*/any;
+  };
+  from<T>(this: new () => T, data: Partial<T>): T;
+} & Constructor & Constructor<{}> & typeof LifecycleHook;
+declare class Module extends Module_base {
+  id: string;
+  name: string;
+  enabled: boolean;
+  dependencies: Record<string, any>;
+  build: ModuleManifest['build'];
+  directory: string;
+  upgrade_info?: ModuleUpgradeInfo;
+  setData(data: Partial<Module | ModuleManifest>): void;
+}
+//#endregion
+export { AnyClass, BaseException, ConfigService, Constructor, ContainerService, CookieService, EmmitterService, EmmitterServiceOptions, LifecycleHook, LifecycleService, LoggerService, Mixin, Module as ModuleEntity, ModuleManifestBuild, ModuleManifestBuildImport, ModuleManifest as ModuleManifestEntity, PartialBy, Permission, PermissionAssignment, PublicData, ShellException, Token, TranslatorService, UnionToIntersection, UploadService, Valibot, ValibotSchema, ValibotSchemaAsync, ValidatePayload, ValidateResult, ValidatorCallback, ValidatorCallbackAsync, ValidatorResult, ValidatorService, compose, composeWith, createId, flatten, formatBytes, generateIndexFile, mixin, permissionAssignmentSchema, permissionSchema, tokenSchema, tryCatch, unflatten, validator };

package/dist/shared/index.mjs

@@ -1,5 +1,8 @@
+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";
@@ -104,7 +107,7 @@ var ConfigService = class {
 };
 //#endregion
 //#region src/shared/services/ContainerService.ts
-var DIService = class {
+var ContainerService = class {
 	entries = /* @__PURE__ */ new Map();
 	loadFromRecord(record) {
 		Object.entries(record).forEach(([key, value]) => {
@@ -435,7 +438,12 @@ var LifecycleService = class {
 	}
 	async executeHookMethod(hook, method) {
 		await hook[method]();
-		if (hook.subhooks) for (const subhook of hook.subhooks) await this.executeHookMethod(subhook, 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());
@@ -467,6 +475,7 @@ var LifecycleService = class {
 		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) {
@@ -618,6 +627,33 @@ var UploadService = class {
 	}
 };
 //#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;
@@ -632,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);
@@ -655,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");
@@ -670,20 +711,25 @@ 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;
 	}
 };
-const validator = 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");
@@ -695,4 +741,116 @@ function generateIndexFile(options) {
 	fs.writeFileSync(filename, content);
 }
 //#endregion
-export { ConfigService, DIService as ContainerService, CookieService, EmmitterService, LifecycleService, LoggerService, TranslatorService, UploadService, validator as 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 };

package/eslint.config.mts

@@ -17,6 +17,7 @@ export default defineConfig([
     {
         rules: {
             '@typescript-eslint/no-explicit-any': 'off',
+            '@typescript-eslint/no-empty-object-type': 'off',
         }
     }
 ]);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@sidekick-coder/zenith-kit",
-    "version": "0.0.10",
+    "version": "0.0.11",
     "license": "MIT",
     "description": "A collection of utilities and tools for building language servers and related applications.",
     "keywords": [],
@@ -13,6 +13,11 @@
     "publishConfig": {
         "access": "public"
     },
+    "imports": {
+        "#client/*": "./src/client/*",
+        "#server/*": "./src/server/*",
+        "#shared/*": "./src/shared/*"
+    },
     "exports": {
         "./shared": {
             "import": "./dist/shared/index.mjs",
@@ -36,6 +41,7 @@
         "@eslint/json": "^0.14.0",
         "@types/lodash-es": "^4.17.12",
         "@types/node": "^25.6.0",
+        "@types/qs": "^6.15.0",
         "@vue/tsconfig": "^0.9.1",
         "commander": "^14.0.3",
         "eslint": "^9.39.4",
@@ -45,11 +51,18 @@
         "jiti": "^2.6.1",
         "tsdown": "^0.21.9",
         "typescript": "^6.0.3",
-        "typescript-eslint": "^8.58.2"
+        "typescript-eslint": "^8.58.2",
+        "vitest": "^3.2.4"
     },
     "dependencies": {
+        "better-sqlite3": "^12.9.0",
+        "date-fns": "^4.1.0",
         "fast-glob": "^3.3.3",
+        "kysely": "^0.28.16",
         "lodash-es": "^4.18.1",
+        "mysql2": "^3.22.3",
+        "pg": "^8.20.0",
+        "qs": "^6.15.1",
         "valibot": "^1.3.1"
     }
 }

package/tsconfig.server.json

@@ -20,7 +20,7 @@
     "noUnusedParameters": true,
     "noFallthroughCasesInSwitch": true,
     "noUncheckedSideEffectImports": true,
-    "strictPropertyInitialization": false
+    "strictPropertyInitialization": false,
   },
   "include": [
     "src/server/**/*.ts",

package/tsdown.config.ts

@@ -9,7 +9,14 @@ export default defineConfig([
         hooks(hooks) {
             hooks.hook('build:before', async () => {
                 generateIndexFile({
-                    folders: ['src/shared/services', 'src/shared/utils'],
+                    folders: [
+                        'src/shared/services', 
+                        'src/shared/utils',
+                        'src/shared/schemas',
+                        'src/shared/exceptions',
+                        'src/shared/facades',
+                        'src/shared/entities',
+                    ],
                     filename: 'src/shared/index.ts'
                 })
 
@@ -26,7 +33,14 @@ export default defineConfig([
                 generateIndexFile({
                     folders: [
                         'src/server/services',
+                        'src/server/repositories',
                         'src/server/gateways',
+                        'src/server/mixins',
+                        'src/server/facades',
+                        'src/server/contracts',
+                        'src/server/loaders',
+                        'src/server/entities',
+                        'src/server/utils',
                     ],
                     filename: 'src/server/index.ts'
                 })