@alepha/devtools 0.10.6 → 0.11.0

package/src/DevCollectorProvider.ts

@@ -23,249 +23,253 @@ import type { DevSchedulerMetadata } from "./schemas/DevSchedulerMetadata.ts";
 import type { DevTopicMetadata } from "./schemas/DevTopicMetadata.ts";
 
 export class DevCollectorProvider {
-	protected readonly alepha = $inject(Alepha);
-	protected readonly logs: DevLogEntry[] = [];
-	protected readonly maxLogs = 10000;
-
-	protected readonly onLog = $hook({
-		on: "log",
-		handler: (ev: { message: string; entry: LogEntry }) => {
-			this.logs.push({
-				formatted: ev.message,
-				entry: ev.entry,
-			});
-
-			// Keep only the last 10000 logs
-			if (this.logs.length > this.maxLogs) {
-				this.logs.shift();
-			}
-		},
-	});
-
-	protected readonly uiRoute = $route({
-		method: "GET",
-		path: "/devtools",
-		schema: {
-			response: t.text(),
-		},
-		handler: () => {
-			return ui;
-		},
-	});
-
-	protected readonly metadataRoute = $route({
-		method: "GET",
-		path: "/devtools/metadata",
-		schema: {
-			response: devMetadataSchema,
-		},
-		handler: () => {
-			return this.getMetadata();
-		},
-	});
-
-	protected readonly logsRoute = $route({
-		method: "GET",
-		path: "/devtools/logs",
-		schema: {
-			response: t.array(
-				t.object({
-					formatted: t.text(),
-					entry: t.any(),
-				}),
-			),
-		},
-		handler: () => {
-			return this.getLogs();
-		},
-	});
-
-	public getLogs(): DevLogEntry[] {
-		return this.logs;
-	}
-
-	public getActions(): DevActionMetadata[] {
-		const actionDescriptors = this.alepha.descriptors($action);
-
-		return actionDescriptors.map((action) => {
-			const schema = action.schema;
-			const options = action.options as any; // Allow accessing augmented properties
-
-			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: options.secure,
-				hide: options.hide,
-				body: schema?.body,
-				params: schema?.params,
-				query: schema?.query,
-				response: schema?.response,
-				bodyContentType: action.getBodyContentType(),
-			};
-		});
-	}
-
-	public getQueues(): DevQueueMetadata[] {
-		const queueDescriptors = this.alepha.descriptors($queue);
-
-		return queueDescriptors.map((queue) => ({
-			name: queue.name,
-			description: queue.options.description,
-			schema: queue.options.schema,
-			provider: this.getProviderName(queue.options.provider),
-		}));
-	}
-
-	public getSchedulers(): DevSchedulerMetadata[] {
-		const schedulerDescriptors = this.alepha.descriptors($scheduler);
-
-		return schedulerDescriptors.map((scheduler) => ({
-			name: scheduler.name,
-			description: scheduler.options.description,
-			cron: scheduler.options.cron,
-			interval: scheduler.options.interval,
-			lock: scheduler.options.lock,
-		}));
-	}
-
-	public getTopics(): DevTopicMetadata[] {
-		const topicDescriptors = this.alepha.descriptors($topic);
-
-		return topicDescriptors.map((topic) => ({
-			name: topic.name,
-			description: topic.options.description,
-			schema: topic.options.schema,
-			provider: this.getProviderName(topic.options.provider),
-		}));
-	}
-
-	public getBuckets(): DevBucketMetadata[] {
-		const bucketDescriptors = this.alepha.descriptors($bucket);
-
-		return bucketDescriptors.map((bucket) => ({
-			name: bucket.name,
-			description: bucket.options.description,
-			mimeTypes: bucket.options.mimeTypes,
-			maxSize: bucket.options.maxSize,
-			provider: this.getProviderName(bucket.options.provider),
-		}));
-	}
-
-	public getRealms(): DevRealmMetadata[] {
-		const realmDescriptors = this.alepha.descriptors($realm);
-
-		return realmDescriptors.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,
-			},
-		}));
-	}
-
-	public getCaches(): DevCacheMetadata[] {
-		const cacheDescriptors = this.alepha.descriptors($cache);
-
-		return cacheDescriptors.map((cache) => ({
-			name: cache.container,
-			ttl: cache.options.ttl,
-			disabled: cache.options.disabled,
-			provider: this.getProviderName(cache.options.provider),
-		}));
-	}
-
-	public getPages(): DevPageMetadata[] {
-		const pageDescriptors = this.alepha.descriptors($page);
-
-		return pageDescriptors.map((page) => ({
-			name: page.name,
-			description: page.options.description,
-			path: page.options.path,
-			params: page.options.schema?.params,
-			query: page.options.schema?.query,
-			hasComponent: !!page.options.component,
-			hasLazy: !!page.options.lazy,
-			hasResolve: !!page.options.resolve,
-			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,
-		}));
-	}
-
-	public getProviders(): DevProviderMetadata[] {
-		const graph = this.alepha.graph();
-
-		return Object.entries(graph).map(([name, info]) => ({
-			name,
-			module: info.module,
-			dependencies: info.from,
-			aliases: info.as,
-		}));
-	}
-
-	public getModules(): DevModuleMetadata[] {
-		const graph = this.alepha.graph();
-		const moduleMap = new Map<string, Set<string>>();
-
-		// Group providers by module
-		for (const [providerName, info] of Object.entries(graph)) {
-			if (info.module) {
-				if (!moduleMap.has(info.module)) {
-					moduleMap.set(info.module, new Set());
-				}
-				moduleMap.get(info.module)!.add(providerName);
-			}
-		}
-
-		return Array.from(moduleMap.entries()).map(([name, providers]) => ({
-			name,
-			providers: Array.from(providers),
-		}));
-	}
-
-	public getMetadata(): DevMetadata {
-		return {
-			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(),
-		};
-	}
-
-	protected getProviderName(provider?: "memory" | any): string {
-		if (!provider) {
-			return "default";
-		}
-		if (provider === "memory") {
-			return "memory";
-		}
-		return provider.name || "custom";
-	}
+  protected readonly alepha = $inject(Alepha);
+  protected readonly logs: DevLogEntry[] = [];
+  protected readonly maxLogs = 10000;
+
+  protected readonly onLog = $hook({
+    on: "log",
+    handler: (ev: { message: string; entry: LogEntry }) => {
+      this.logs.push({
+        formatted: ev.message,
+        entry: ev.entry,
+      });
+
+      // Keep only the last 10000 logs
+      if (this.logs.length > this.maxLogs) {
+        this.logs.shift();
+      }
+    },
+  });
+
+  protected readonly uiRoute = $route({
+    method: "GET",
+    path: "/devtools",
+    schema: {
+      response: t.text(),
+    },
+    handler: () => {
+      return ui;
+    },
+  });
+
+  protected readonly metadataRoute = $route({
+    method: "GET",
+    path: "/devtools/metadata",
+    schema: {
+      response: devMetadataSchema,
+    },
+    handler: () => {
+      return this.getMetadata();
+    },
+  });
+
+  protected readonly logsRoute = $route({
+    method: "GET",
+    path: "/devtools/logs",
+    schema: {
+      response: t.array(
+        t.object({
+          formatted: t.text(),
+          entry: t.any(),
+        }),
+      ),
+    },
+    handler: () => {
+      return this.getLogs();
+    },
+  });
+
+  public getLogs(): DevLogEntry[] {
+    return this.logs;
+  }
+
+  // -------------------------------------------------------------------------------------------------------------------
+
+  public getActions(): DevActionMetadata[] {
+    const actionDescriptors = this.alepha.descriptors($action);
+
+    return actionDescriptors.map((action) => {
+      const schema = action.schema;
+      const options = action.options as any; // Allow accessing augmented properties
+
+      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: options.secure,
+        hide: options.hide,
+        body: schema?.body,
+        params: schema?.params,
+        query: schema?.query,
+        response: schema?.response,
+        bodyContentType: action.getBodyContentType(),
+      };
+    });
+  }
+
+  public getQueues(): DevQueueMetadata[] {
+    const queueDescriptors = this.alepha.descriptors($queue);
+
+    return queueDescriptors.map((queue) => ({
+      name: queue.name,
+      description: queue.options.description,
+      schema: queue.options.schema,
+      provider: this.getProviderName(queue.options.provider),
+    }));
+  }
+
+  public getSchedulers(): DevSchedulerMetadata[] {
+    const schedulerDescriptors = this.alepha.descriptors($scheduler);
+
+    return schedulerDescriptors.map((scheduler) => ({
+      name: scheduler.name,
+      description: scheduler.options.description,
+      cron: scheduler.options.cron,
+      interval: scheduler.options.interval,
+      lock: scheduler.options.lock,
+    }));
+  }
+
+  public getTopics(): DevTopicMetadata[] {
+    const topicDescriptors = this.alepha.descriptors($topic);
+
+    return topicDescriptors.map((topic) => ({
+      name: topic.name,
+      description: topic.options.description,
+      schema: topic.options.schema,
+      provider: this.getProviderName(topic.options.provider),
+    }));
+  }
+
+  public getBuckets(): DevBucketMetadata[] {
+    const bucketDescriptors = this.alepha.descriptors($bucket);
+
+    return bucketDescriptors.map((bucket) => ({
+      name: bucket.name,
+      description: bucket.options.description,
+      mimeTypes: bucket.options.mimeTypes,
+      maxSize: bucket.options.maxSize,
+      provider: this.getProviderName(bucket.options.provider),
+    }));
+  }
+
+  public getRealms(): DevRealmMetadata[] {
+    const realmDescriptors = this.alepha.descriptors($realm);
+
+    return realmDescriptors.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,
+      },
+    }));
+  }
+
+  public getCaches(): DevCacheMetadata[] {
+    const cacheDescriptors = this.alepha.descriptors($cache);
+
+    return cacheDescriptors.map((cache) => ({
+      name: cache.container,
+      ttl: cache.options.ttl,
+      disabled: cache.options.disabled,
+      provider: this.getProviderName(cache.options.provider),
+    }));
+  }
+
+  public getPages(): DevPageMetadata[] {
+    const pageDescriptors = this.alepha.descriptors($page);
+
+    return pageDescriptors.map((page) => ({
+      name: page.name,
+      description: page.options.description,
+      path: page.options.path,
+      params: page.options.schema?.params,
+      query: page.options.schema?.query,
+      hasComponent: !!page.options.component,
+      hasLazy: !!page.options.lazy,
+      hasResolve: !!page.options.resolve,
+      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,
+    }));
+  }
+
+  public getProviders(): DevProviderMetadata[] {
+    const graph = this.alepha.graph();
+
+    return Object.entries(graph).map(([name, info]) => ({
+      name,
+      module: info.module,
+      dependencies: info.from,
+      aliases: info.as,
+    }));
+  }
+
+  public getModules(): DevModuleMetadata[] {
+    const graph = this.alepha.graph();
+    const moduleMap = new Map<string, Set<string>>();
+
+    // Group providers by module
+    for (const [providerName, info] of Object.entries(graph)) {
+      if (info.module) {
+        if (!moduleMap.has(info.module)) {
+          moduleMap.set(info.module, new Set());
+        }
+        moduleMap.get(info.module)!.add(providerName);
+      }
+    }
+
+    return Array.from(moduleMap.entries()).map(([name, providers]) => ({
+      name,
+      providers: Array.from(providers),
+    }));
+  }
+
+  public getMetadata(): DevMetadata {
+    return {
+      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(),
+    };
+  }
+
+  // -------------------------------------------------------------------------------------------------------------------
+
+  protected getProviderName(provider?: "memory" | any): string {
+    if (!provider) {
+      return "default";
+    }
+    if (provider === "memory") {
+      return "memory";
+    }
+    return provider.name || "custom";
+  }
 }

package/src/index.ts

@@ -29,7 +29,7 @@ export * from "./schemas/DevTopicMetadata.ts";
  * @module alepha.devtools
  */
 export const AlephaDevtools = $module({
-	name: "alepha.devtools",
-	descriptors: [],
-	services: [DevCollectorProvider],
+  name: "alepha.devtools",
+  descriptors: [],
+  services: [DevCollectorProvider],
 });

package/src/schemas/DevActionMetadata.ts

@@ -1,22 +1,22 @@
 import { type Static, t } from "@alepha/core";
 
 export 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()),
+  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()),
 });
 
 export type DevActionMetadata = Static<typeof devActionMetadataSchema>;

package/src/schemas/DevBucketMetadata.ts

@@ -1,11 +1,11 @@
 import { type Static, t } from "@alepha/core";
 
 export 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(),
+  name: t.text(),
+  description: t.optional(t.text()),
+  mimeTypes: t.optional(t.array(t.text())),
+  maxSize: t.optional(t.number()),
+  provider: t.text(),
 });
 
 export type DevBucketMetadata = Static<typeof devBucketMetadataSchema>;

package/src/schemas/DevCacheMetadata.ts

@@ -1,10 +1,10 @@
 import { type Static, t } from "@alepha/core";
 
 export const devCacheMetadataSchema = t.object({
-	name: t.text(),
-	ttl: t.optional(t.any()),
-	disabled: t.optional(t.boolean()),
-	provider: t.text(),
+  name: t.text(),
+  ttl: t.optional(t.any()),
+  disabled: t.optional(t.boolean()),
+  provider: t.text(),
 });
 
 export type DevCacheMetadata = Static<typeof devCacheMetadataSchema>;

package/src/schemas/DevLogEntry.ts

@@ -2,10 +2,10 @@ import { type Static, t } from "@alepha/core";
 import type { LogEntry } from "@alepha/logger";
 
 export const devLogEntrySchema = t.object({
-	formatted: t.text(),
-	entry: t.any(), // Use any since LogEntry has Date instead of string for timestamp
+  formatted: t.text(),
+  entry: t.any(), // Use any since LogEntry has Date instead of string for timestamp
 });
 
 export type DevLogEntry = Static<typeof devLogEntrySchema> & {
-	entry: LogEntry;
+  entry: LogEntry;
 };

package/src/schemas/DevMetadata.ts

@@ -11,17 +11,17 @@ import { devSchedulerMetadataSchema } from "./DevSchedulerMetadata.ts";
 import { devTopicMetadataSchema } from "./DevTopicMetadata.ts";
 
 export const devMetadataSchema = t.object({
-	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),
-	// More metadata will be added here later
+  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),
+  // More metadata will be added here later
 });
 
 export type DevMetadata = Static<typeof devMetadataSchema>;

package/src/schemas/DevModuleMetadata.ts

@@ -1,8 +1,8 @@
 import { type Static, t } from "@alepha/core";
 
 export const devModuleMetadataSchema = t.object({
-	name: t.text(),
-	providers: t.array(t.text()),
+  name: t.text(),
+  providers: t.array(t.text()),
 });
 
 export type DevModuleMetadata = Static<typeof devModuleMetadataSchema>;