@alepha/devtools 0.16.0 → 0.19.1

package/dist/index.js

@@ -1,46 +1,25 @@
-import { $context, $hook, $inject, $module, Alepha, pageQuerySchema, t } from "alepha";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { $batch } from "alepha/batch";
-import { $logger, JsonFormatterProvider } from "alepha/logger";
-import { $entity, PG_CREATED_AT, PG_DEFAULT, PG_DELETED_AT, PG_IDENTITY, PG_PRIMARY_KEY, PG_REF, PG_SERIAL, PG_UPDATED_AT, PG_VERSION, Repository, RepositoryProvider, SqliteProvider, parseQueryString, pg } from "alepha/orm";
-import { $action, $route, ServerProvider } from "alepha/server";
-import { $serve } from "alepha/server/static";
+import { $hook, $inject, $module, Alepha, t } from "alepha";
+import { $action, $route, AlephaServer, ServerProvider } from "alepha/server";
+import { $serve, AlephaServerStatic } from "alepha/server/static";
 import { $bucket } from "alepha/bucket";
 import { $cache } from "alepha/cache";
-import { $command } from "alepha/command";
+import { DateTimeProvider } from "alepha/datetime";
+import { $logger, MemoryDestinationProvider } from "alepha/logger";
+import { PG_CREATED_AT, PG_DEFAULT, PG_DELETED_AT, PG_IDENTITY, PG_PRIMARY_KEY, PG_REF, PG_SERIAL, PG_UPDATED_AT, PG_VERSION, RepositoryProvider } from "alepha/orm";
 import { $queue } from "alepha/queue";
+import { $page } from "alepha/react/router";
 import { $scheduler } from "alepha/scheduler";
 import { $issuer } from "alepha/security";
 import { $topic } from "alepha/topic";
-
-//#region src/api/entities/logs.ts
-const logs = $entity({
-	name: "logs",
-	schema: t.object({
-		id: pg.primaryKey(),
-		level: t.enum([
-			"TRACE",
-			"DEBUG",
-			"INFO",
-			"WARN",
-			"ERROR"
-		]),
-		message: t.text({ size: "rich" }),
-		service: t.text(),
-		module: t.text(),
-		context: t.optional(t.text()),
-		app: t.optional(t.text()),
-		data: t.optional(t.json()),
-		timestamp: t.integer()
-	})
-});
-
-//#endregion
-//#region src/api/providers/DevToolsMetadataProvider.ts
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/providers/DevToolsMetadataProvider.ts
 var DevToolsMetadataProvider = class {
 	alepha = $inject(Alepha);
+	dateTime = $inject(DateTimeProvider);
 	log = $logger();
+	serverProvider = $inject(ServerProvider);
+	startedAt = this.dateTime.nowMillis();
 	getActions() {
 		return this.alepha.primitives($action).map((action) => {
 			const schema = action.schema;
@@ -55,13 +34,14 @@ var DevToolsMetadataProvider = class {
 				description: action.options.description,
 				summary: options.summary,
 				disabled: action.options.disabled,
-				secure: options.secure,
+				secure: action.middlewares.some((m) => m?.name === "$secure") || void 0,
 				hide: options.hide,
 				body: schema?.body,
 				params: schema?.params,
 				query: schema?.query,
 				response: schema?.response,
-				bodyContentType: action.getBodyContentType()
+				bodyContentType: action.getBodyContentType(),
+				middlewares: action.middlewares.filter(Boolean).length ? action.middlewares.filter(Boolean) : void 0
 			};
 		});
 	}
@@ -83,12 +63,20 @@ var DevToolsMetadataProvider = class {
 		}));
 	}
 	getTopics() {
-		return this.alepha.primitives($topic).map((topic) => ({
-			name: topic.name,
-			description: topic.options.description,
-			schema: topic.options.schema,
-			provider: this.getProviderName(topic.options.provider)
-		}));
+		const topicPrimitives = this.alepha.primitives($topic);
+		const topicMap = /* @__PURE__ */ new Map();
+		for (const topic of topicPrimitives) {
+			const existing = topicMap.get(topic.name);
+			if (existing) existing.subscribers++;
+			else topicMap.set(topic.name, {
+				name: topic.name,
+				description: topic.options.description,
+				schema: topic.options.schema,
+				provider: this.getProviderName(topic.options.provider),
+				subscribers: 1
+			});
+		}
+		return Array.from(topicMap.values());
 	}
 	getBuckets() {
 		return this.alepha.primitives($bucket).map((bucket) => ({
@@ -123,7 +111,30 @@ var DevToolsMetadataProvider = class {
 		}));
 	}
 	getPages() {
-		return [];
+		return this.alepha.primitives($page).map((page) => {
+			const children = typeof page.options.children === "function" ? page.options.children() : page.options.children;
+			const childrenNames = Array.isArray(children) ? children.map((c) => c.name).filter(Boolean) : void 0;
+			return {
+				name: page.name,
+				label: page.options.label,
+				description: page.options.description,
+				path: page.options.path,
+				parentName: page.options.parent?.name,
+				params: page.options.schema?.params,
+				query: page.options.schema?.query,
+				hasComponent: !!page.options.component,
+				hasLazy: !!page.options.lazy,
+				hasResolve: !!page.options.resolve,
+				childrenNames: childrenNames?.length ? childrenNames : void 0,
+				hasChildren: !!page.options.children,
+				hasParent: !!page.options.parent,
+				hasErrorHandler: !!page.options.errorHandler,
+				static: typeof page.options.static === "boolean" ? page.options.static : !!page.options.static,
+				cache: page.options.cache,
+				client: page.options.client,
+				animation: page.options.animation
+			};
+		});
 	}
 	getProviders() {
 		const graph = this.alepha.graph();
@@ -203,7 +214,10 @@ var DevToolsMetadataProvider = class {
 					columns,
 					indexes,
 					foreignKeys,
-					constraints
+					constraints,
+					schema: entity.schema,
+					insertSchema: entity.insertSchema,
+					updateSchema: entity.updateSchema
 				};
 			});
 		} catch {
@@ -237,13 +251,6 @@ var DevToolsMetadataProvider = class {
 		if (t.schema.isUnion(field) && field.anyOf) return field.anyOf.some((type) => t.schema.isNull(type));
 		return false;
 	}
-	getCommands() {
-		return this.alepha.primitives($command).filter((cmd) => !cmd.options.hide).map((command) => ({
-			name: command.name,
-			description: command.options.description,
-			hidden: command.options.hide
-		}));
-	}
 	getRoutes() {
 		return [];
 	}
@@ -264,8 +271,22 @@ var DevToolsMetadataProvider = class {
 			currentValue: value
 		}));
 	}
+	getSystem() {
+		const isBun = typeof globalThis.Bun !== "undefined";
+		const port = Number(this.alepha.env.SERVER_PORT) || 3e3;
+		return {
+			alephaVersion: String(this.alepha.env.npm_package_version ?? "unknown"),
+			nodeVersion: isBun ? globalThis.Bun?.version ?? "unknown" : process.version,
+			runtime: isBun ? "bun" : "node",
+			mode: this.alepha.isProduction() ? "production" : "development",
+			port,
+			uptime: (this.dateTime.nowMillis() - this.startedAt) / 1e3,
+			memoryUsage: process.memoryUsage?.()?.rss ?? 0
+		};
+	}
 	getMetadata() {
 		return {
+			system: this.getSystem(),
 			actions: this.getActions(),
 			queues: this.getQueues(),
 			schedulers: this.getSchedulers(),
@@ -277,7 +298,6 @@ var DevToolsMetadataProvider = class {
 			providers: this.getProviders(),
 			modules: this.getModules(),
 			entities: this.getEntities(),
-			commands: this.getCommands(),
 			routes: this.getRoutes(),
 			envs: this.getEnvs(),
 			atoms: this.getAtoms()
@@ -289,37 +309,11 @@ var DevToolsMetadataProvider = class {
 		return provider.name || "custom";
 	}
 };
-
 //#endregion
-//#region src/api/providers/DevToolsDatabaseProvider.ts
-var DevToolsDatabaseProvider = class extends SqliteProvider {
-	get name() {
-		return "";
-	}
-	options = { path: ":memory:" };
-	async migrate() {
-		this.sqlite.exec(`
-        CREATE TABLE IF NOT EXISTS logs (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          level TEXT NOT NULL,
-          message TEXT,
-          service TEXT,
-          module TEXT,
-          context TEXT,
-          app TEXT,
-          data TEXT,
-          timestamp INTEGER NOT NULL
-        )
-      `);
-	}
-};
-
+//#region src/assets.ts
+const devtoolsAssets = { ui: join(fileURLToPath(import.meta.url), "../../assets/ui") };
 //#endregion
-//#region src/api/repositories/LogRepository.ts
-var LogRepository = class extends Repository.of(logs, DevToolsDatabaseProvider) {};
-
-//#endregion
-//#region src/api/schemas/DevActionMetadata.ts
+//#region src/schemas/DevActionMetadata.ts
 const devActionMetadataSchema = t.object({
 	name: t.text(),
 	group: t.text(),
@@ -336,11 +330,14 @@ const devActionMetadataSchema = t.object({
 	params: t.optional(t.any()),
 	query: t.optional(t.any()),
 	response: t.optional(t.any()),
-	bodyContentType: t.optional(t.text())
+	bodyContentType: t.optional(t.text()),
+	middlewares: t.optional(t.array(t.object({
+		name: t.text(),
+		options: t.optional(t.any())
+	})))
 });
-
 //#endregion
-//#region src/api/schemas/DevAtomMetadata.ts
+//#region src/schemas/DevAtomMetadata.ts
 const devAtomMetadataSchema = t.object({
 	name: t.text(),
 	description: t.optional(t.text()),
@@ -348,9 +345,8 @@ const devAtomMetadataSchema = t.object({
 	defaultValue: t.optional(t.any()),
 	currentValue: t.optional(t.any())
 });
-
 //#endregion
-//#region src/api/schemas/DevBucketMetadata.ts
+//#region src/schemas/DevBucketMetadata.ts
 const devBucketMetadataSchema = t.object({
 	name: t.text(),
 	description: t.optional(t.text()),
@@ -358,26 +354,16 @@ const devBucketMetadataSchema = t.object({
 	maxSize: t.optional(t.number()),
 	provider: t.text()
 });
-
 //#endregion
-//#region src/api/schemas/DevCacheMetadata.ts
+//#region src/schemas/DevCacheMetadata.ts
 const devCacheMetadataSchema = t.object({
 	name: t.text(),
 	ttl: t.optional(t.any()),
 	disabled: t.optional(t.boolean()),
 	provider: t.text()
 });
-
-//#endregion
-//#region src/api/schemas/DevCommandMetadata.ts
-const devCommandMetadataSchema = t.object({
-	name: t.text(),
-	description: t.optional(t.text()),
-	hidden: t.optional(t.boolean())
-});
-
 //#endregion
-//#region src/api/schemas/DevEntityMetadata.ts
+//#region src/schemas/DevEntityMetadata.ts
 const devEntityColumnSchema = t.object({
 	name: t.text(),
 	type: t.text(),
@@ -419,36 +405,39 @@ const devEntityMetadataSchema = t.object({
 	columns: t.array(devEntityColumnSchema),
 	indexes: t.array(devEntityIndexSchema),
 	foreignKeys: t.array(devEntityForeignKeySchema),
-	constraints: t.array(devEntityConstraintSchema)
+	constraints: t.array(devEntityConstraintSchema),
+	schema: t.optional(t.any()),
+	insertSchema: t.optional(t.any()),
+	updateSchema: t.optional(t.any())
 });
-
 //#endregion
-//#region src/api/schemas/DevEnvMetadata.ts
+//#region src/schemas/DevEnvMetadata.ts
 const devEnvMetadataSchema = t.object({
 	propertyKey: t.text(),
 	schema: t.any(),
 	values: t.record(t.text(), t.any()),
 	serviceName: t.optional(t.text())
 });
-
 //#endregion
-//#region src/api/schemas/DevModuleMetadata.ts
+//#region src/schemas/DevModuleMetadata.ts
 const devModuleMetadataSchema = t.object({
 	name: t.text(),
 	providers: t.array(t.text())
 });
-
 //#endregion
-//#region src/api/schemas/DevPageMetadata.ts
+//#region src/schemas/DevPageMetadata.ts
 const devPageMetadataSchema = t.object({
 	name: t.text(),
+	label: t.optional(t.text()),
 	description: t.optional(t.text()),
 	path: t.optional(t.text()),
+	parentName: t.optional(t.text()),
 	params: t.optional(t.any()),
 	query: t.optional(t.any()),
 	hasComponent: t.boolean(),
 	hasLazy: t.boolean(),
 	hasResolve: t.boolean(),
+	childrenNames: t.optional(t.array(t.text())),
 	hasChildren: t.boolean(),
 	hasParent: t.boolean(),
 	hasErrorHandler: t.boolean(),
@@ -457,27 +446,24 @@ const devPageMetadataSchema = t.object({
 	client: t.optional(t.any()),
 	animation: t.optional(t.any())
 });
-
 //#endregion
-//#region src/api/schemas/DevProviderMetadata.ts
+//#region src/schemas/DevProviderMetadata.ts
 const devProviderMetadataSchema = t.object({
 	name: t.text(),
 	module: t.optional(t.text()),
 	dependencies: t.array(t.text()),
 	aliases: t.optional(t.array(t.text()))
 });
-
 //#endregion
-//#region src/api/schemas/DevQueueMetadata.ts
+//#region src/schemas/DevQueueMetadata.ts
 const devQueueMetadataSchema = t.object({
 	name: t.text(),
 	description: t.optional(t.text()),
 	schema: t.optional(t.any()),
 	provider: t.text()
 });
-
 //#endregion
-//#region src/api/schemas/DevRealmMetadata.ts
+//#region src/schemas/DevRealmMetadata.ts
 const devRealmMetadataSchema = t.object({
 	name: t.text(),
 	description: t.optional(t.text()),
@@ -491,16 +477,14 @@ const devRealmMetadataSchema = t.object({
 		hasOnDeleteSession: t.boolean()
 	}))
 });
-
 //#endregion
-//#region src/api/schemas/DevRouteMetadata.ts
+//#region src/schemas/DevRouteMetadata.ts
 const devRouteMetadataSchema = t.object({
 	method: t.text(),
 	path: t.text()
 });
-
 //#endregion
-//#region src/api/schemas/DevSchedulerMetadata.ts
+//#region src/schemas/DevSchedulerMetadata.ts
 const devSchedulerMetadataSchema = t.object({
 	name: t.text(),
 	description: t.optional(t.text()),
@@ -508,19 +492,28 @@ const devSchedulerMetadataSchema = t.object({
 	interval: t.optional(t.any()),
 	lock: t.optional(t.boolean())
 });
-
 //#endregion
-//#region src/api/schemas/DevTopicMetadata.ts
+//#region src/schemas/DevTopicMetadata.ts
 const devTopicMetadataSchema = t.object({
 	name: t.text(),
 	description: t.optional(t.text()),
 	schema: t.optional(t.any()),
-	provider: t.text()
+	provider: t.text(),
+	subscribers: t.integer()
 });
-
 //#endregion
-//#region src/api/schemas/DevMetadata.ts
+//#region src/schemas/DevMetadata.ts
+const devSystemSchema = t.object({
+	alephaVersion: t.text(),
+	nodeVersion: t.text(),
+	runtime: t.enum(["node", "bun"]),
+	mode: t.enum(["development", "production"]),
+	port: t.integer(),
+	uptime: t.number(),
+	memoryUsage: t.number()
+});
 const devMetadataSchema = t.object({
+	system: devSystemSchema,
 	actions: t.array(devActionMetadataSchema),
 	queues: t.array(devQueueMetadataSchema),
 	schedulers: t.array(devSchedulerMetadataSchema),
@@ -532,84 +525,53 @@ const devMetadataSchema = t.object({
 	providers: t.array(devProviderMetadataSchema),
 	modules: t.array(devModuleMetadataSchema),
 	entities: t.array(devEntityMetadataSchema),
-	commands: t.array(devCommandMetadataSchema),
 	routes: t.array(devRouteMetadataSchema),
 	envs: t.array(devEnvMetadataSchema),
 	atoms: t.array(devAtomMetadataSchema)
 });
-
 //#endregion
-//#region src/api/DevToolsProvider.ts
+//#region src/providers/DevToolsProvider.ts
 var DevToolsProvider = class {
 	log = $logger();
 	alepha = $inject(Alepha);
 	serverProvider = $inject(ServerProvider);
-	jsonFormatter = $inject(JsonFormatterProvider);
-	logs = $inject(LogRepository);
 	devCollectorProvider = $inject(DevToolsMetadataProvider);
+	memoryDestination = $inject(MemoryDestinationProvider);
 	onStart = $hook({
 		on: "start",
 		handler: () => {
-			this.log.info("Devtools OK", { url: `${this.serverProvider.hostname}/devtools/` });
-		}
-	});
-	batchLogs = $batch({
-		maxSize: 50,
-		maxDuration: [10, "seconds"],
-		schema: logs.insertSchema,
-		handler: async (entries) => {
-			await this.logs.createMany(entries);
+			this.log.info("Devtools OK", { url: `${this.serverProvider.hostname}/__devtools/` });
 		}
 	});
+	/**
+	* Capture all logs into memory so the devtools UI can display them.
+	* In dev mode, LogDestinationProvider is bound to ConsoleDestinationProvider,
+	* so MemoryDestinationProvider would otherwise never receive writes.
+	*/
 	onLog = $hook({
 		on: "log",
-		handler: async (ev) => {
-			try {
-				if (!this.alepha.isStarted()) return;
-				ev.entry.message = ev.entry.message?.slice(0, 2e3);
-				if (ev.entry.module === "alepha.devtools") return;
-				if (ev.entry.level === "TRACE" && ev.entry.module === "alepha.batch") return;
-				if (this.alepha.isProduction() && ev.entry.level === "TRACE") return;
-				const entry = {
-					...ev.entry,
-					data: ev.entry.data instanceof Error ? this.jsonFormatter.formatJsonError(ev.entry.data) : typeof ev.entry.data === "object" && !Array.isArray(ev.entry.data) ? ev.entry.data : { data: ev.entry.data }
-				};
-				await this.batchLogs.push(entry);
-			} catch (error) {
-				console.error(error, ev);
-			}
+		handler: ({ entry }) => {
+			this.memoryDestination.write("", entry);
 		}
 	});
 	uiRoute = $serve({
-		path: "/devtools",
-		root: join(fileURLToPath(import.meta.url), "../../../assets/devtools"),
-		historyApiFallback: true
+		path: "/__devtools",
+		root: devtoolsAssets.ui,
+		historyApiFallback: true,
+		silent: true
 	});
 	metadataRoute = $route({
 		method: "GET",
-		path: "/devtools/api/metadata",
+		path: "/__devtools/api/metadata",
 		silent: true,
 		schema: { response: devMetadataSchema },
 		handler: () => {
 			return this.devCollectorProvider.getMetadata();
 		}
 	});
-	logsRoute = $route({
-		method: "GET",
-		path: "/devtools/api/logs",
-		silent: true,
-		schema: {
-			query: t.extend(pageQuerySchema, { search: t.optional(t.string()) }),
-			response: t.page(logs.schema)
-		},
-		handler: ({ query }) => {
-			query.sort ??= "-timestamp";
-			return this.logs.paginate(query, query.search ? { where: parseQueryString(query.search) } : {}, { count: true });
-		}
-	});
 	updateAtomRoute = $route({
 		method: "POST",
-		path: "/devtools/api/atoms",
+		path: "/__devtools/api/atoms",
 		silent: true,
 		schema: {
 			body: t.object({
@@ -627,15 +589,168 @@ var DevToolsProvider = class {
 			return { success: false };
 		}
 	});
+	logsRoute = $route({
+		method: "GET",
+		path: "/__devtools/api/logs",
+		silent: true,
+		schema: {
+			query: t.object({
+				level: t.optional(t.text()),
+				type: t.optional(t.text()),
+				module: t.optional(t.text()),
+				search: t.optional(t.text()),
+				since: t.optional(t.text()),
+				limit: t.optional(t.text()),
+				offset: t.optional(t.text())
+			}),
+			response: t.object({
+				logs: t.array(t.any()),
+				total: t.integer()
+			})
+		},
+		handler: ({ query }) => {
+			const levelOrder = [
+				"TRACE",
+				"DEBUG",
+				"INFO",
+				"WARN",
+				"ERROR"
+			];
+			let entries = this.memoryDestination.logs;
+			if (query.level) {
+				const minIndex = levelOrder.indexOf(query.level.toUpperCase());
+				if (minIndex >= 0) entries = entries.filter((e) => levelOrder.indexOf(e.level) >= minIndex);
+			}
+			if (query.type) {
+				const types = query.type.split(",").map((t) => t.trim());
+				entries = entries.filter((e) => {
+					if (!e.data || typeof e.data !== "object") return false;
+					const d = e.data;
+					for (const t of types) if (t === "http" || t === "http:request") {
+						if (d.status && d.method && d.path && d.duration) return true;
+					} else if (t === "db" || t === "db:query") {
+						if (d.type === "db:query") return true;
+					} else if (d.type === t) return true;
+					return false;
+				});
+			}
+			if (query.module) entries = entries.filter((e) => e.module === query.module);
+			if (query.search) {
+				const terms = query.search.toLowerCase().split(/\s+/);
+				entries = entries.filter((e) => {
+					const text = `${e.message} ${e.module} ${e.service}`.toLowerCase();
+					return terms.every((term) => text.includes(term));
+				});
+			}
+			if (query.since) {
+				const since = Number(query.since);
+				if (!Number.isNaN(since)) entries = entries.filter((e) => e.timestamp >= since);
+			}
+			const total = entries.length;
+			entries = entries.reverse();
+			const offset = query.offset ? Number(query.offset) : 0;
+			const limit = query.limit ? Number(query.limit) : 100;
+			entries = entries.slice(offset, offset + limit);
+			return {
+				logs: entries,
+				total
+			};
+		}
+	});
+	dbListRoute = $route({
+		method: "GET",
+		path: "/__devtools/api/db/:entity/records",
+		silent: true,
+		schema: {
+			params: t.object({ entity: t.text() }),
+			query: t.object({
+				page: t.optional(t.text()),
+				size: t.optional(t.text()),
+				sort: t.optional(t.text())
+			}),
+			response: t.record(t.text(), t.any())
+		},
+		handler: async ({ params, query }) => {
+			const repo = this.getRepository(params.entity);
+			if (!repo) return {
+				content: [],
+				page: { totalElements: 0 }
+			};
+			return repo.paginate({
+				page: query.page ? Number(query.page) : 0,
+				size: query.size ? Number(query.size) : 50,
+				sort: query.sort || void 0
+			}, {}, { count: true });
+		}
+	});
+	dbCreateRoute = $route({
+		method: "POST",
+		path: "/__devtools/api/db/:entity/records",
+		silent: true,
+		schema: {
+			params: t.object({ entity: t.text() }),
+			body: t.record(t.text(), t.any()),
+			response: t.record(t.text(), t.any())
+		},
+		handler: async ({ params, body }) => {
+			const repo = this.getRepository(params.entity);
+			if (!repo) return { error: "Entity not found" };
+			return repo.create(body);
+		}
+	});
+	dbUpdateRoute = $route({
+		method: "PUT",
+		path: "/__devtools/api/db/:entity/records/:id",
+		silent: true,
+		schema: {
+			params: t.object({
+				entity: t.text(),
+				id: t.text()
+			}),
+			body: t.record(t.text(), t.any()),
+			response: t.record(t.text(), t.any())
+		},
+		handler: async ({ params, body }) => {
+			const repo = this.getRepository(params.entity);
+			if (!repo) return { error: "Entity not found" };
+			const idValue = this.parseId(repo, params.id);
+			return repo.updateById(idValue, body);
+		}
+	});
+	dbDeleteRoute = $route({
+		method: "DELETE",
+		path: "/__devtools/api/db/:entity/records/:id",
+		silent: true,
+		schema: {
+			params: t.object({
+				entity: t.text(),
+				id: t.text()
+			}),
+			response: t.record(t.text(), t.any())
+		},
+		handler: async ({ params }) => {
+			const repo = this.getRepository(params.entity);
+			if (!repo) return { error: "Entity not found" };
+			const idValue = this.parseId(repo, params.id);
+			return repo.deleteById(idValue);
+		}
+	});
+	getRepository(entityName) {
+		try {
+			return this.alepha.inject(RepositoryProvider).getRepositories().find((r) => r.entity.name === entityName);
+		} catch {
+			return;
+		}
+	}
+	parseId(repo, rawId) {
+		const idType = repo.id.type;
+		if (idType?.type === "integer" || idType?.type === "number") return Number(rawId);
+		return rawId;
+	}
 };
-
 //#endregion
 //#region src/index.ts
 /**
-* | type | quality | stability |
-* |------|---------|-----------|
-* | tooling | rare | experimental |
-*
 * Runtime inspection and debugging UI.
 *
 * **Features:**
@@ -652,24 +767,16 @@ var DevToolsProvider = class {
 const AlephaDevtools = $module({
 	name: "alepha.devtools",
 	primitives: [],
-	services: [
-		DevToolsMetadataProvider,
-		DevToolsProvider,
-		DevToolsDatabaseProvider,
-		LogRepository
-	],
+	services: [DevToolsMetadataProvider, DevToolsProvider],
 	register: (alepha) => {
+		alepha.with(AlephaServer);
+		alepha.with(AlephaServerStatic);
 		alepha.with(DevToolsProvider);
-		alepha.with(DevToolsDatabaseProvider);
 		alepha.with(DevToolsMetadataProvider);
-		alepha.store.push("alepha.build.assets", "@alepha/devtools");
+		alepha.store.push("alepha.build.assets", "alepha");
 	}
 });
-const $devtools = () => {
-	$context().alepha.with(AlephaDevtools);
-	return {};
-};
-
 //#endregion
-export { $devtools, AlephaDevtools, DevToolsMetadataProvider, devActionMetadataSchema, devBucketMetadataSchema, devCacheMetadataSchema, devCommandMetadataSchema, devEntityColumnSchema, devEntityConstraintSchema, devEntityForeignKeySchema, devEntityIndexSchema, devEntityMetadataSchema, devMetadataSchema, devModuleMetadataSchema, devPageMetadataSchema, devProviderMetadataSchema, devQueueMetadataSchema, devRealmMetadataSchema, devRouteMetadataSchema, devSchedulerMetadataSchema, devTopicMetadataSchema };
+export { AlephaDevtools, DevToolsMetadataProvider, devActionMetadataSchema, devAtomMetadataSchema, devBucketMetadataSchema, devCacheMetadataSchema, devEntityColumnSchema, devEntityConstraintSchema, devEntityForeignKeySchema, devEntityIndexSchema, devEntityMetadataSchema, devEnvMetadataSchema, devMetadataSchema, devModuleMetadataSchema, devPageMetadataSchema, devProviderMetadataSchema, devQueueMetadataSchema, devRealmMetadataSchema, devRouteMetadataSchema, devSchedulerMetadataSchema, devSystemSchema, devTopicMetadataSchema };
+
 //# sourceMappingURL=index.js.map