@alepha/devtools 0.19.1 → 0.19.3

package/dist/index.js

@@ -1,782 +0,0 @@
-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 { 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";
-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;
-			const options = action.options;
-			return {
-				name: action.name,
-				group: action.group,
-				method: action.method,
-				path: action.path,
-				prefix: action.prefix,
-				fullPath: action.route.path,
-				description: action.options.description,
-				summary: options.summary,
-				disabled: action.options.disabled,
-				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(),
-				middlewares: action.middlewares.filter(Boolean).length ? action.middlewares.filter(Boolean) : void 0
-			};
-		});
-	}
-	getQueues() {
-		return this.alepha.primitives($queue).map((queue) => ({
-			name: queue.name,
-			description: queue.options.description,
-			schema: queue.options.schema,
-			provider: this.getProviderName(queue.options.provider)
-		}));
-	}
-	getSchedulers() {
-		return this.alepha.primitives($scheduler).map((scheduler) => ({
-			name: scheduler.name,
-			description: scheduler.options.description,
-			cron: scheduler.options.cron,
-			interval: scheduler.options.interval,
-			lock: scheduler.options.lock
-		}));
-	}
-	getTopics() {
-		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) => ({
-			name: bucket.name,
-			description: bucket.options.description,
-			mimeTypes: bucket.options.mimeTypes,
-			maxSize: bucket.options.maxSize,
-			provider: this.getProviderName(bucket.options.provider)
-		}));
-	}
-	getRealms() {
-		return this.alepha.primitives($issuer).map((realm) => ({
-			name: realm.name,
-			description: realm.options.description,
-			roles: realm.options.roles,
-			type: "secret" in realm.options ? "internal" : "external",
-			settings: {
-				accessTokenExpiration: realm.options.settings?.accessToken?.expiration,
-				refreshTokenExpiration: realm.options.settings?.refreshToken?.expiration,
-				hasOnCreateSession: !!realm.options.settings?.onCreateSession,
-				hasOnRefreshSession: !!realm.options.settings?.onRefreshSession,
-				hasOnDeleteSession: !!realm.options.settings?.onDeleteSession
-			}
-		}));
-	}
-	getCaches() {
-		return this.alepha.primitives($cache).map((cache) => ({
-			name: cache.container,
-			ttl: cache.options.ttl,
-			disabled: cache.options.disabled,
-			provider: this.getProviderName(cache.options.provider)
-		}));
-	}
-	getPages() {
-		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();
-		return Object.entries(graph).map(([name, info]) => ({
-			name,
-			module: info.module ?? name,
-			dependencies: info.from,
-			aliases: info.as
-		}));
-	}
-	getModules() {
-		const graph = this.alepha.graph();
-		const moduleMap = /* @__PURE__ */ new Map();
-		for (const [providerName, info] of Object.entries(graph)) if (info.module) {
-			if (!moduleMap.has(info.module)) moduleMap.set(info.module, /* @__PURE__ */ new Set());
-			moduleMap.get(info.module).add(providerName);
-		}
-		return Array.from(moduleMap.entries()).map(([name, providers]) => ({
-			name,
-			providers: Array.from(providers)
-		}));
-	}
-	getEntities() {
-		try {
-			return this.alepha.inject(RepositoryProvider).getRepositories().map((repo) => {
-				const entity = repo.entity;
-				const schema = entity.schema;
-				const options = entity.options;
-				const columns = Object.entries(schema.properties).map(([name, field]) => {
-					const fieldSchema = field;
-					const refData = fieldSchema[PG_REF];
-					return {
-						name,
-						type: this.getColumnType(fieldSchema),
-						nullable: this.isNullable(fieldSchema),
-						primaryKey: PG_PRIMARY_KEY in fieldSchema,
-						identity: PG_IDENTITY in fieldSchema || PG_SERIAL in fieldSchema,
-						createdAt: PG_CREATED_AT in fieldSchema,
-						updatedAt: PG_UPDATED_AT in fieldSchema,
-						deletedAt: PG_DELETED_AT in fieldSchema,
-						version: PG_VERSION in fieldSchema,
-						hasDefault: PG_DEFAULT in fieldSchema,
-						ref: refData ? {
-							entity: refData.ref?.()?.entity?.name ?? "unknown",
-							column: refData.ref?.()?.name ?? "unknown",
-							onUpdate: refData.actions?.onUpdate,
-							onDelete: refData.actions?.onDelete
-						} : void 0
-					};
-				});
-				const indexes = (options.indexes ?? []).map((idx) => {
-					if (typeof idx === "string") return {
-						columns: [idx],
-						unique: false
-					};
-					return {
-						name: idx.name,
-						columns: idx.column ? [idx.column] : idx.columns ?? [],
-						unique: idx.unique ?? false
-					};
-				});
-				const foreignKeys = (options.foreignKeys ?? []).map((fk) => ({
-					name: fk.name,
-					columns: fk.columns.map(String),
-					foreignEntity: fk.foreignColumns?.[0]?.()?.entity?.name ?? "unknown",
-					foreignColumns: fk.foreignColumns?.map((fc) => fc?.()?.name ?? "unknown")
-				}));
-				const constraints = (options.constraints ?? []).map((c) => ({
-					name: c.name,
-					columns: c.columns.map(String),
-					unique: !!c.unique,
-					hasCheck: !!c.check
-				}));
-				return {
-					name: entity.name,
-					provider: repo.provider.constructor.name,
-					columns,
-					indexes,
-					foreignKeys,
-					constraints,
-					schema: entity.schema,
-					insertSchema: entity.insertSchema,
-					updateSchema: entity.updateSchema
-				};
-			});
-		} catch {
-			return [];
-		}
-	}
-	getColumnType(field) {
-		if (t.schema.isUnion(field) && field.anyOf) {
-			const nonNull = field.anyOf.find((type) => !t.schema.isNull(type));
-			if (nonNull) return this.getColumnType(nonNull);
-		}
-		const f = field;
-		if (t.schema.isUnsafe(field) && f.type === "string" && Array.isArray(f.enum)) return "enum";
-		if (t.schema.isString(field)) {
-			if (f.enum) return "enum";
-			if (f.format === "uuid") return "uuid";
-			if (f.format === "date-time") return "datetime";
-			if (f.format === "date") return "date";
-			if (f.format === "bigint") return "bigint";
-			return "text";
-		}
-		if (t.schema.isInteger(field)) return "integer";
-		if (t.schema.isNumber(field)) return "number";
-		if (t.schema.isBoolean(field)) return "boolean";
-		if (t.schema.isArray(field)) return "array";
-		if (t.schema.isObject(field)) return "json";
-		if (t.schema.isLiteral(field)) return "literal";
-		return "unknown";
-	}
-	isNullable(field) {
-		if (t.schema.isUnion(field) && field.anyOf) return field.anyOf.some((type) => t.schema.isNull(type));
-		return false;
-	}
-	getRoutes() {
-		return [];
-	}
-	getEnvs() {
-		return this.alepha.getEnvSchemas().map((item, index) => ({
-			propertyKey: `env_${index}`,
-			schema: item.schema,
-			values: item.values,
-			serviceName: void 0
-		}));
-	}
-	getAtoms() {
-		return this.alepha.store.getAtoms(false).map(({ atom, value }) => ({
-			name: atom.key,
-			description: atom.options.description,
-			schema: atom.schema,
-			defaultValue: atom.options.default,
-			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(),
-			topics: this.getTopics(),
-			buckets: this.getBuckets(),
-			realms: this.getRealms(),
-			caches: this.getCaches(),
-			pages: this.getPages(),
-			providers: this.getProviders(),
-			modules: this.getModules(),
-			entities: this.getEntities(),
-			routes: this.getRoutes(),
-			envs: this.getEnvs(),
-			atoms: this.getAtoms()
-		};
-	}
-	getProviderName(provider) {
-		if (!provider) return "default";
-		if (provider === "memory") return "memory";
-		return provider.name || "custom";
-	}
-};
-//#endregion
-//#region src/assets.ts
-const devtoolsAssets = { ui: join(fileURLToPath(import.meta.url), "../../assets/ui") };
-//#endregion
-//#region src/schemas/DevActionMetadata.ts
-const devActionMetadataSchema = t.object({
-	name: t.text(),
-	group: t.text(),
-	method: t.text(),
-	path: t.text(),
-	prefix: t.text(),
-	fullPath: t.text(),
-	description: t.optional(t.text()),
-	summary: t.optional(t.text()),
-	disabled: t.optional(t.boolean()),
-	secure: t.optional(t.boolean()),
-	hide: t.optional(t.boolean()),
-	body: t.optional(t.any()),
-	params: t.optional(t.any()),
-	query: t.optional(t.any()),
-	response: t.optional(t.any()),
-	bodyContentType: t.optional(t.text()),
-	middlewares: t.optional(t.array(t.object({
-		name: t.text(),
-		options: t.optional(t.any())
-	})))
-});
-//#endregion
-//#region src/schemas/DevAtomMetadata.ts
-const devAtomMetadataSchema = t.object({
-	name: t.text(),
-	description: t.optional(t.text()),
-	schema: t.any(),
-	defaultValue: t.optional(t.any()),
-	currentValue: t.optional(t.any())
-});
-//#endregion
-//#region src/schemas/DevBucketMetadata.ts
-const devBucketMetadataSchema = t.object({
-	name: t.text(),
-	description: t.optional(t.text()),
-	mimeTypes: t.optional(t.array(t.text())),
-	maxSize: t.optional(t.number()),
-	provider: t.text()
-});
-//#endregion
-//#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/schemas/DevEntityMetadata.ts
-const devEntityColumnSchema = t.object({
-	name: t.text(),
-	type: t.text(),
-	nullable: t.boolean(),
-	primaryKey: t.boolean(),
-	identity: t.boolean(),
-	createdAt: t.boolean(),
-	updatedAt: t.boolean(),
-	deletedAt: t.boolean(),
-	version: t.boolean(),
-	hasDefault: t.boolean(),
-	ref: t.optional(t.object({
-		entity: t.text(),
-		column: t.text(),
-		onUpdate: t.optional(t.text()),
-		onDelete: t.optional(t.text())
-	}))
-});
-const devEntityIndexSchema = t.object({
-	name: t.optional(t.text()),
-	columns: t.array(t.text()),
-	unique: t.boolean()
-});
-const devEntityForeignKeySchema = t.object({
-	name: t.optional(t.text()),
-	columns: t.array(t.text()),
-	foreignEntity: t.text(),
-	foreignColumns: t.array(t.text())
-});
-const devEntityConstraintSchema = t.object({
-	name: t.optional(t.text()),
-	columns: t.array(t.text()),
-	unique: t.boolean(),
-	hasCheck: t.boolean()
-});
-const devEntityMetadataSchema = t.object({
-	name: t.text(),
-	provider: t.text(),
-	columns: t.array(devEntityColumnSchema),
-	indexes: t.array(devEntityIndexSchema),
-	foreignKeys: t.array(devEntityForeignKeySchema),
-	constraints: t.array(devEntityConstraintSchema),
-	schema: t.optional(t.any()),
-	insertSchema: t.optional(t.any()),
-	updateSchema: t.optional(t.any())
-});
-//#endregion
-//#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/schemas/DevModuleMetadata.ts
-const devModuleMetadataSchema = t.object({
-	name: t.text(),
-	providers: t.array(t.text())
-});
-//#endregion
-//#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(),
-	static: t.optional(t.boolean()),
-	cache: t.optional(t.any()),
-	client: t.optional(t.any()),
-	animation: t.optional(t.any())
-});
-//#endregion
-//#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/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/schemas/DevRealmMetadata.ts
-const devRealmMetadataSchema = t.object({
-	name: t.text(),
-	description: t.optional(t.text()),
-	roles: t.optional(t.array(t.any())),
-	type: t.enum(["internal", "external"]),
-	settings: t.optional(t.object({
-		accessTokenExpiration: t.optional(t.any()),
-		refreshTokenExpiration: t.optional(t.any()),
-		hasOnCreateSession: t.boolean(),
-		hasOnRefreshSession: t.boolean(),
-		hasOnDeleteSession: t.boolean()
-	}))
-});
-//#endregion
-//#region src/schemas/DevRouteMetadata.ts
-const devRouteMetadataSchema = t.object({
-	method: t.text(),
-	path: t.text()
-});
-//#endregion
-//#region src/schemas/DevSchedulerMetadata.ts
-const devSchedulerMetadataSchema = t.object({
-	name: t.text(),
-	description: t.optional(t.text()),
-	cron: t.optional(t.text()),
-	interval: t.optional(t.any()),
-	lock: t.optional(t.boolean())
-});
-//#endregion
-//#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(),
-	subscribers: t.integer()
-});
-//#endregion
-//#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),
-	topics: t.array(devTopicMetadataSchema),
-	buckets: t.array(devBucketMetadataSchema),
-	realms: t.array(devRealmMetadataSchema),
-	caches: t.array(devCacheMetadataSchema),
-	pages: t.array(devPageMetadataSchema),
-	providers: t.array(devProviderMetadataSchema),
-	modules: t.array(devModuleMetadataSchema),
-	entities: t.array(devEntityMetadataSchema),
-	routes: t.array(devRouteMetadataSchema),
-	envs: t.array(devEnvMetadataSchema),
-	atoms: t.array(devAtomMetadataSchema)
-});
-//#endregion
-//#region src/providers/DevToolsProvider.ts
-var DevToolsProvider = class {
-	log = $logger();
-	alepha = $inject(Alepha);
-	serverProvider = $inject(ServerProvider);
-	devCollectorProvider = $inject(DevToolsMetadataProvider);
-	memoryDestination = $inject(MemoryDestinationProvider);
-	onStart = $hook({
-		on: "start",
-		handler: () => {
-			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: ({ entry }) => {
-			this.memoryDestination.write("", entry);
-		}
-	});
-	uiRoute = $serve({
-		path: "/__devtools",
-		root: devtoolsAssets.ui,
-		historyApiFallback: true,
-		silent: true
-	});
-	metadataRoute = $route({
-		method: "GET",
-		path: "/__devtools/api/metadata",
-		silent: true,
-		schema: { response: devMetadataSchema },
-		handler: () => {
-			return this.devCollectorProvider.getMetadata();
-		}
-	});
-	updateAtomRoute = $route({
-		method: "POST",
-		path: "/__devtools/api/atoms",
-		silent: true,
-		schema: {
-			body: t.object({
-				name: t.text(),
-				value: t.any()
-			}),
-			response: t.object({ success: t.boolean() })
-		},
-		handler: ({ body }) => {
-			const atomEntry = this.alepha.store.getAtoms(false).find((a) => a.atom.key === body.name);
-			if (atomEntry) {
-				this.alepha.store.set(atomEntry.atom, body.value);
-				return { success: true };
-			}
-			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
-/**
-* Runtime inspection and debugging UI.
-*
-* **Features:**
-* - DevTools UI at `GET /devtools`
-* - Application metadata at `GET /devtools/metadata`
-* - Last 10,000 logs at `GET /devtools/logs`
-* - Runtime inspection of actions, queues, schedulers, topics, buckets
-* - Log viewer with filtering
-* - React Flow visualization
-* - Provider and module browsing
-*
-* @module alepha.devtools
-*/
-const AlephaDevtools = $module({
-	name: "alepha.devtools",
-	primitives: [],
-	services: [DevToolsMetadataProvider, DevToolsProvider],
-	register: (alepha) => {
-		alepha.with(AlephaServer);
-		alepha.with(AlephaServerStatic);
-		alepha.with(DevToolsProvider);
-		alepha.with(DevToolsMetadataProvider);
-		alepha.store.push("alepha.build.assets", "alepha");
-	}
-});
-//#endregion
-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