@alepha/devtools 0.16.0 → 0.19.1

package/src/{api/providers → providers}/DevToolsMetadataProvider.ts

@@ -1,7 +1,7 @@
 import { $inject, Alepha, type TObject, type TSchema, t } from "alepha";
 import { $bucket } from "alepha/bucket";
 import { $cache } from "alepha/cache";
-import { $command } from "alepha/command";
+import { DateTimeProvider } from "alepha/datetime";
 import { $logger } from "alepha/logger";
 import {
   PG_CREATED_AT,
@@ -16,15 +16,15 @@ import {
   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 { $action } from "alepha/server";
+import { $action, ServerProvider } from "alepha/server";
 import { $topic } from "alepha/topic";
 import type { DevActionMetadata } from "../schemas/DevActionMetadata.ts";
 import type { DevAtomMetadata } from "../schemas/DevAtomMetadata.ts";
 import type { DevBucketMetadata } from "../schemas/DevBucketMetadata.ts";
 import type { DevCacheMetadata } from "../schemas/DevCacheMetadata.ts";
-import type { DevCommandMetadata } from "../schemas/DevCommandMetadata.ts";
 import type {
   DevEntityColumn,
   DevEntityConstraint,
@@ -33,7 +33,7 @@ import type {
   DevEntityMetadata,
 } from "../schemas/DevEntityMetadata.ts";
 import type { DevEnvMetadata } from "../schemas/DevEnvMetadata.ts";
-import type { DevMetadata } from "../schemas/DevMetadata.ts";
+import type { DevMetadata, DevSystem } from "../schemas/DevMetadata.ts";
 import type { DevModuleMetadata } from "../schemas/DevModuleMetadata.ts";
 import type { DevPageMetadata } from "../schemas/DevPageMetadata.ts";
 import type { DevProviderMetadata } from "../schemas/DevProviderMetadata.ts";
@@ -45,7 +45,10 @@ import type { DevTopicMetadata } from "../schemas/DevTopicMetadata.ts";
 
 export class DevToolsMetadataProvider {
   protected readonly alepha = $inject(Alepha);
+  protected readonly dateTime = $inject(DateTimeProvider);
   protected readonly log = $logger();
+  protected readonly serverProvider = $inject(ServerProvider);
+  protected readonly startedAt = this.dateTime.nowMillis();
 
   public getActions(): DevActionMetadata[] {
     const actionPrimitives = this.alepha.primitives($action);
@@ -64,13 +67,17 @@ export class DevToolsMetadataProvider {
         description: action.options.description,
         summary: options.summary,
         disabled: action.options.disabled,
-        secure: options.secure,
+        secure:
+          action.middlewares.some((m) => m?.name === "$secure") || undefined,
         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)
+          : undefined,
       };
     });
   }
@@ -101,12 +108,23 @@ export class DevToolsMetadataProvider {
   public getTopics(): DevTopicMetadata[] {
     const topicPrimitives = this.alepha.primitives($topic);
 
-    return topicPrimitives.map((topic) => ({
-      name: topic.name,
-      description: topic.options.description,
-      schema: topic.options.schema,
-      provider: this.getProviderName(topic.options.provider),
-    }));
+    // Deduplicate by name, count subscribers
+    const topicMap = new Map<string, DevTopicMetadata>();
+    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());
   }
 
   public getBuckets(): DevBucketMetadata[] {
@@ -152,30 +170,42 @@ export class DevToolsMetadataProvider {
   }
 
   public getPages(): DevPageMetadata[] {
-    // const pagePrimitives = this.alepha.primitives($page);
-    //
-    // return pagePrimitives.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,
-    // }));
+    const pagePrimitives = this.alepha.primitives($page);
+
+    return pagePrimitives.map((page: any) => {
+      // Resolve children (can be an array or a function returning an array)
+      const children =
+        typeof page.options.children === "function"
+          ? page.options.children()
+          : page.options.children;
+      const childrenNames = Array.isArray(children)
+        ? children.map((c: any) => c.name).filter(Boolean)
+        : undefined;
 
-    return [];
+      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 : undefined,
+        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[] {
@@ -291,6 +321,9 @@ export class DevToolsMetadataProvider {
           indexes,
           foreignKeys,
           constraints,
+          schema: entity.schema,
+          insertSchema: entity.insertSchema,
+          updateSchema: entity.updateSchema,
         };
       });
     } catch {
@@ -347,18 +380,6 @@ export class DevToolsMetadataProvider {
     return false;
   }
 
-  public getCommands(): DevCommandMetadata[] {
-    const commandPrimitives = this.alepha.primitives($command);
-
-    return commandPrimitives
-      .filter((cmd) => !cmd.options.hide)
-      .map((command) => ({
-        name: command.name,
-        description: command.options.description,
-        hidden: command.options.hide,
-      }));
-  }
-
   public getRoutes(): DevRouteMetadata[] {
     // Routes are the base primitive - actions and pages are routes
     // Showing them separately would be redundant with actions
@@ -388,8 +409,25 @@ export class DevToolsMetadataProvider {
     }));
   }
 
+  public getSystem(): DevSystem {
+    const isBun = typeof globalThis.Bun !== "undefined";
+    const port = Number(this.alepha.env.SERVER_PORT) || 3000;
+    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) / 1000,
+      memoryUsage: process.memoryUsage?.()?.rss ?? 0,
+    };
+  }
+
   public getMetadata(): DevMetadata {
     return {
+      system: this.getSystem(),
       actions: this.getActions(),
       queues: this.getQueues(),
       schedulers: this.getSchedulers(),
@@ -401,7 +439,6 @@ export class DevToolsMetadataProvider {
       providers: this.getProviders(),
       modules: this.getModules(),
       entities: this.getEntities(),
-      commands: this.getCommands(),
       routes: this.getRoutes(),
       envs: this.getEnvs(),
       atoms: this.getAtoms(),

package/src/providers/DevToolsProvider.ts

@@ -0,0 +1,280 @@
+import { $hook, $inject, Alepha, t } from "alepha";
+import { $logger, MemoryDestinationProvider } from "alepha/logger";
+import { RepositoryProvider } from "alepha/orm";
+import { $route, ServerProvider } from "alepha/server";
+import { $serve } from "alepha/server/static";
+import { devtoolsAssets } from "../assets.ts";
+import { devMetadataSchema } from "../schemas/DevMetadata.ts";
+import { DevToolsMetadataProvider } from "./DevToolsMetadataProvider.ts";
+
+export class DevToolsProvider {
+  protected readonly log = $logger();
+  protected readonly alepha = $inject(Alepha);
+  protected readonly serverProvider = $inject(ServerProvider);
+  protected readonly devCollectorProvider = $inject(DevToolsMetadataProvider);
+  protected readonly memoryDestination = $inject(MemoryDestinationProvider);
+
+  protected readonly 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.
+   */
+  protected readonly onLog = $hook({
+    on: "log",
+    handler: ({ entry }) => {
+      this.memoryDestination.write("", entry);
+    },
+  });
+
+  protected readonly uiRoute = $serve({
+    path: "/__devtools",
+    root: devtoolsAssets.ui,
+    historyApiFallback: true,
+    silent: true,
+  });
+
+  protected readonly metadataRoute = $route({
+    method: "GET",
+    path: "/__devtools/api/metadata",
+    silent: true,
+    schema: {
+      response: devMetadataSchema,
+    },
+    handler: () => {
+      return this.devCollectorProvider.getMetadata();
+    },
+  });
+
+  protected readonly 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 atoms = this.alepha.store.getAtoms(false);
+      const atomEntry = atoms.find((a) => a.atom.key === body.name);
+
+      if (atomEntry) {
+        this.alepha.store.set(atomEntry.atom, body.value);
+        return { success: true };
+      }
+
+      return { success: false };
+    },
+  });
+
+  // -------------------------------------------------------------------------------------------------------------------
+  // Logs endpoint
+  // -------------------------------------------------------------------------------------------------------------------
+
+  protected readonly 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 as Record<string, unknown>;
+          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;
+
+      // Reverse so newest first
+      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 };
+    },
+  });
+
+  // -------------------------------------------------------------------------------------------------------------------
+  // DB CRUD endpoints
+  // -------------------------------------------------------------------------------------------------------------------
+
+  protected readonly 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 || undefined,
+        },
+        {},
+        { count: true },
+      ) as any;
+    },
+  });
+
+  protected readonly 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) as any;
+    },
+  });
+
+  protected readonly 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) as any;
+    },
+  });
+
+  protected readonly 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) as any;
+    },
+  });
+
+  // -------------------------------------------------------------------------------------------------------------------
+
+  protected getRepository(entityName: string) {
+    try {
+      const repositoryProvider = this.alepha.inject(RepositoryProvider);
+      const repos = repositoryProvider.getRepositories();
+      return repos.find((r) => r.entity.name === entityName);
+    } catch {
+      return undefined;
+    }
+  }
+
+  protected parseId(repo: any, rawId: string): string | number {
+    const idType = repo.id.type;
+    if (idType?.type === "integer" || idType?.type === "number") {
+      return Number(rawId);
+    }
+    return rawId;
+  }
+}

package/src/{api/schemas → schemas}/DevActionMetadata.ts

@@ -17,6 +17,14 @@ export const devActionMetadataSchema = t.object({
   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()),
+      }),
+    ),
+  ),
 });
 
 export type DevActionMetadata = Static<typeof devActionMetadataSchema>;

package/src/{api/schemas → schemas}/DevEntityMetadata.ts

@@ -48,6 +48,9 @@ export const devEntityMetadataSchema = t.object({
   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()),
 });
 
 export type DevEntityColumn = Static<typeof devEntityColumnSchema>;

package/src/{api/schemas → schemas}/DevMetadata.ts

@@ -3,7 +3,6 @@ import { devActionMetadataSchema } from "./DevActionMetadata.ts";
 import { devAtomMetadataSchema } from "./DevAtomMetadata.ts";
 import { devBucketMetadataSchema } from "./DevBucketMetadata.ts";
 import { devCacheMetadataSchema } from "./DevCacheMetadata.ts";
-import { devCommandMetadataSchema } from "./DevCommandMetadata.ts";
 import { devEntityMetadataSchema } from "./DevEntityMetadata.ts";
 import { devEnvMetadataSchema } from "./DevEnvMetadata.ts";
 import { devModuleMetadataSchema } from "./DevModuleMetadata.ts";
@@ -15,7 +14,20 @@ import { devRouteMetadataSchema } from "./DevRouteMetadata.ts";
 import { devSchedulerMetadataSchema } from "./DevSchedulerMetadata.ts";
 import { devTopicMetadataSchema } from "./DevTopicMetadata.ts";
 
+export 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(),
+});
+
+export type DevSystem = Static<typeof devSystemSchema>;
+
 export const devMetadataSchema = t.object({
+  system: devSystemSchema,
   actions: t.array(devActionMetadataSchema),
   queues: t.array(devQueueMetadataSchema),
   schedulers: t.array(devSchedulerMetadataSchema),
@@ -27,7 +39,6 @@ export 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),

package/src/{api/schemas → schemas}/DevPageMetadata.ts

@@ -2,13 +2,16 @@ import { type Static, t } from "alepha";
 
 export 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(),

package/src/{api/schemas → schemas}/DevTopicMetadata.ts

@@ -5,6 +5,7 @@ export const devTopicMetadataSchema = t.object({
   description: t.optional(t.text()),
   schema: t.optional(t.any()),
   provider: t.text(),
+  subscribers: t.integer(),
 });
 
 export type DevTopicMetadata = Static<typeof devTopicMetadataSchema>;