@alepha/devtools 0.13.6 → 0.13.7

package/src/{DevToolsProvider.ts → api/DevToolsProvider.ts}

@@ -49,6 +49,8 @@ export class DevToolsProvider {
           return;
         }
 
+        ev.entry.message = ev.entry.message?.slice(0, 2000); // limit message size
+
         if (ev.entry.module === "alepha.devtools") {
           // skip devtools logs to avoid infinite loop
           return;
@@ -85,7 +87,7 @@ export class DevToolsProvider {
 
   protected readonly uiRoute = $serve({
     path: "/devtools",
-    root: join(fileURLToPath(import.meta.url), "../../assets/devtools"),
+    root: join(fileURLToPath(import.meta.url), "../../../assets/devtools"),
     historyApiFallback: true,
   });
 
@@ -126,4 +128,30 @@ export class DevToolsProvider {
       );
     },
   });
+
+  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 };
+    },
+  });
 }

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

@@ -1,21 +1,45 @@
-import { $inject, Alepha } from "alepha";
+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 { $logger } 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 { $scheduler } from "alepha/scheduler";
 import { $realm } from "alepha/security";
 import { $action } 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,
+  DevEntityForeignKey,
+  DevEntityIndex,
+  DevEntityMetadata,
+} from "../schemas/DevEntityMetadata.ts";
+import type { DevEnvMetadata } from "../schemas/DevEnvMetadata.ts";
 import type { DevMetadata } 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";
 import type { DevQueueMetadata } from "../schemas/DevQueueMetadata.ts";
 import type { DevRealmMetadata } from "../schemas/DevRealmMetadata.ts";
+import type { DevRouteMetadata } from "../schemas/DevRouteMetadata.ts";
 import type { DevSchedulerMetadata } from "../schemas/DevSchedulerMetadata.ts";
 import type { DevTopicMetadata } from "../schemas/DevTopicMetadata.ts";
 
@@ -159,7 +183,7 @@ export class DevToolsMetadataProvider {
 
     return Object.entries(graph).map(([name, info]) => ({
       name,
-      module: info.module,
+      module: info.module ?? name,
       dependencies: info.from,
       aliases: info.as,
     }));
@@ -185,6 +209,185 @@ export class DevToolsMetadataProvider {
     }));
   }
 
+  public getEntities(): DevEntityMetadata[] {
+    try {
+      const repositoryProvider = this.alepha.inject(RepositoryProvider);
+      const repositories = repositoryProvider.getRepositories();
+
+      return repositories.map((repo) => {
+        const entity = repo.entity;
+        const schema = entity.schema as TObject;
+        const options = entity.options;
+
+        // Extract columns from schema
+        const columns: DevEntityColumn[] = Object.entries(
+          schema.properties,
+        ).map(([name, field]) => {
+          const fieldSchema = field as TSchema & Record<symbol, any>;
+          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,
+                }
+              : undefined,
+          };
+        });
+
+        // Extract indexes
+        const indexes: DevEntityIndex[] = (options.indexes ?? []).map(
+          (idx: any) => {
+            if (typeof idx === "string") {
+              return { columns: [idx], unique: false };
+            }
+            return {
+              name: idx.name,
+              columns: idx.column ? [idx.column] : (idx.columns ?? []),
+              unique: idx.unique ?? false,
+            };
+          },
+        );
+
+        // Extract foreign keys
+        const foreignKeys: DevEntityForeignKey[] = (
+          options.foreignKeys ?? []
+        ).map((fk: any) => ({
+          name: fk.name,
+          columns: fk.columns.map(String),
+          foreignEntity: fk.foreignColumns?.[0]?.()?.entity?.name ?? "unknown",
+          foreignColumns: fk.foreignColumns?.map(
+            (fc: any) => fc?.()?.name ?? "unknown",
+          ),
+        }));
+
+        // Extract constraints
+        const constraints: DevEntityConstraint[] = (
+          options.constraints ?? []
+        ).map((c: any) => ({
+          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,
+        };
+      });
+    } catch {
+      // RepositoryProvider not available (ORM not used)
+      return [];
+    }
+  }
+
+  protected getColumnType(field: TSchema): string {
+    // Handle optional/nullable wrappers (unions with null)
+    if (t.schema.isUnion(field) && (field as any).anyOf) {
+      const types = (field as any).anyOf as TSchema[];
+      const nonNull = types.find((type) => !t.schema.isNull(type));
+      if (nonNull) {
+        return this.getColumnType(nonNull);
+      }
+    }
+
+    const f = field as any;
+
+    // Check for enum (t.enum wraps in Unsafe with type=string and enum array)
+    if (
+      t.schema.isUnsafe(field) &&
+      f.type === "string" &&
+      Array.isArray(f.enum)
+    ) {
+      return "enum";
+    }
+
+    // Use TypeBox's type guards
+    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";
+  }
+
+  protected isNullable(field: TSchema): boolean {
+    if (t.schema.isUnion(field) && (field as any).anyOf) {
+      const types = (field as any).anyOf as TSchema[];
+      return types.some((type) => t.schema.isNull(type));
+    }
+    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
+    return [];
+  }
+
+  public getEnvs(): DevEnvMetadata[] {
+    const envSchemas = this.alepha.getEnvSchemas();
+
+    return envSchemas.map((item, index) => ({
+      propertyKey: `env_${index}`,
+      schema: item.schema,
+      values: item.values,
+      serviceName: undefined,
+    }));
+  }
+
+  public getAtoms(): DevAtomMetadata[] {
+    const atomsWithValues = this.alepha.store.getAtoms(false);
+
+    return atomsWithValues.map(({ atom, value }) => ({
+      name: atom.key,
+      description: atom.options.description,
+      schema: atom.schema,
+      defaultValue: atom.options.default,
+      currentValue: value,
+    }));
+  }
+
   public getMetadata(): DevMetadata {
     return {
       actions: this.getActions(),
@@ -197,6 +400,11 @@ export class DevToolsMetadataProvider {
       pages: this.getPages(),
       providers: this.getProviders(),
       modules: this.getModules(),
+      entities: this.getEntities(),
+      commands: this.getCommands(),
+      routes: this.getRoutes(),
+      envs: this.getEnvs(),
+      atoms: this.getAtoms(),
     };
   }
 

package/src/api/schemas/DevAtomMetadata.ts

@@ -0,0 +1,26 @@
+import { type Static, t } from "alepha";
+
+export const devAtomMetadataSchema = t.object({
+  /**
+   * The unique name/key of the atom
+   */
+  name: t.text(),
+  /**
+   * Optional description of the atom
+   */
+  description: t.optional(t.text()),
+  /**
+   * The schema for the atom value (TypeBox/JSON Schema)
+   */
+  schema: t.any(),
+  /**
+   * The default value defined for the atom
+   */
+  defaultValue: t.optional(t.any()),
+  /**
+   * The current value of the atom
+   */
+  currentValue: t.optional(t.any()),
+});
+
+export type DevAtomMetadata = Static<typeof devAtomMetadataSchema>;

package/src/api/schemas/DevCommandMetadata.ts

@@ -0,0 +1,9 @@
+import { type Static, t } from "alepha";
+
+export const devCommandMetadataSchema = t.object({
+  name: t.text(),
+  description: t.optional(t.text()),
+  hidden: t.optional(t.boolean()),
+});
+
+export type DevCommandMetadata = Static<typeof devCommandMetadataSchema>;

package/src/api/schemas/DevEntityMetadata.ts

@@ -0,0 +1,57 @@
+import { type Static, t } from "alepha";
+
+export 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()),
+    }),
+  ),
+});
+
+export const devEntityIndexSchema = t.object({
+  name: t.optional(t.text()),
+  columns: t.array(t.text()),
+  unique: t.boolean(),
+});
+
+export const devEntityForeignKeySchema = t.object({
+  name: t.optional(t.text()),
+  columns: t.array(t.text()),
+  foreignEntity: t.text(),
+  foreignColumns: t.array(t.text()),
+});
+
+export const devEntityConstraintSchema = t.object({
+  name: t.optional(t.text()),
+  columns: t.array(t.text()),
+  unique: t.boolean(),
+  hasCheck: t.boolean(),
+});
+
+export 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),
+});
+
+export type DevEntityColumn = Static<typeof devEntityColumnSchema>;
+export type DevEntityIndex = Static<typeof devEntityIndexSchema>;
+export type DevEntityForeignKey = Static<typeof devEntityForeignKeySchema>;
+export type DevEntityConstraint = Static<typeof devEntityConstraintSchema>;
+export type DevEntityMetadata = Static<typeof devEntityMetadataSchema>;

package/src/api/schemas/DevEnvMetadata.ts

@@ -0,0 +1,22 @@
+import { type Static, t } from "alepha";
+
+export const devEnvMetadataSchema = t.object({
+  /**
+   * The property name in the service where $env is defined
+   */
+  propertyKey: t.text(),
+  /**
+   * The schema for the environment variables (TypeBox/JSON Schema)
+   */
+  schema: t.any(),
+  /**
+   * The parsed values from the environment
+   */
+  values: t.record(t.text(), t.any()),
+  /**
+   * The service class name where this $env is defined
+   */
+  serviceName: t.optional(t.text()),
+});
+
+export type DevEnvMetadata = Static<typeof devEnvMetadataSchema>;

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

@@ -1,12 +1,17 @@
 import { type Static, t } from "alepha";
 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";
 import { devPageMetadataSchema } from "./DevPageMetadata.ts";
 import { devProviderMetadataSchema } from "./DevProviderMetadata.ts";
 import { devQueueMetadataSchema } from "./DevQueueMetadata.ts";
 import { devRealmMetadataSchema } from "./DevRealmMetadata.ts";
+import { devRouteMetadataSchema } from "./DevRouteMetadata.ts";
 import { devSchedulerMetadataSchema } from "./DevSchedulerMetadata.ts";
 import { devTopicMetadataSchema } from "./DevTopicMetadata.ts";
 
@@ -21,7 +26,11 @@ export const devMetadataSchema = t.object({
   pages: t.array(devPageMetadataSchema),
   providers: t.array(devProviderMetadataSchema),
   modules: t.array(devModuleMetadataSchema),
-  // More metadata will be added here later
+  entities: t.array(devEntityMetadataSchema),
+  commands: t.array(devCommandMetadataSchema),
+  routes: t.array(devRouteMetadataSchema),
+  envs: t.array(devEnvMetadataSchema),
+  atoms: t.array(devAtomMetadataSchema),
 });
 
 export type DevMetadata = Static<typeof devMetadataSchema>;

package/src/api/schemas/DevRouteMetadata.ts

@@ -0,0 +1,8 @@
+import { type Static, t } from "alepha";
+
+export const devRouteMetadataSchema = t.object({
+  method: t.text(),
+  path: t.text(),
+});
+
+export type DevRouteMetadata = Static<typeof devRouteMetadataSchema>;

package/src/index.ts

@@ -1,23 +1,26 @@
 import { $module } from "alepha";
-import { DevToolsProvider } from "./DevToolsProvider.ts";
-import { DevToolsDatabaseProvider } from "./providers/DevToolsDatabaseProvider.ts";
-import { DevToolsMetadataProvider } from "./providers/DevToolsMetadataProvider.ts";
-import { LogRepository } from "./repositories/LogRepository.ts";
+import { DevToolsProvider } from "./api/DevToolsProvider.ts";
+import { DevToolsDatabaseProvider } from "./api/providers/DevToolsDatabaseProvider.ts";
+import { DevToolsMetadataProvider } from "./api/providers/DevToolsMetadataProvider.ts";
+import { LogRepository } from "./api/repositories/LogRepository.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export * from "./providers/DevToolsMetadataProvider.ts";
-export * from "./schemas/DevActionMetadata.ts";
-export * from "./schemas/DevBucketMetadata.ts";
-export * from "./schemas/DevCacheMetadata.ts";
-export * from "./schemas/DevMetadata.ts";
-export * from "./schemas/DevModuleMetadata.ts";
-export * from "./schemas/DevPageMetadata.ts";
-export * from "./schemas/DevProviderMetadata.ts";
-export * from "./schemas/DevQueueMetadata.ts";
-export * from "./schemas/DevRealmMetadata.ts";
-export * from "./schemas/DevSchedulerMetadata.ts";
-export * from "./schemas/DevTopicMetadata.ts";
+export * from "./api/providers/DevToolsMetadataProvider.ts";
+export * from "./api/schemas/DevActionMetadata.ts";
+export * from "./api/schemas/DevBucketMetadata.ts";
+export * from "./api/schemas/DevCacheMetadata.ts";
+export * from "./api/schemas/DevCommandMetadata.ts";
+export * from "./api/schemas/DevEntityMetadata.ts";
+export * from "./api/schemas/DevMetadata.ts";
+export * from "./api/schemas/DevModuleMetadata.ts";
+export * from "./api/schemas/DevPageMetadata.ts";
+export * from "./api/schemas/DevProviderMetadata.ts";
+export * from "./api/schemas/DevQueueMetadata.ts";
+export * from "./api/schemas/DevRealmMetadata.ts";
+export * from "./api/schemas/DevRouteMetadata.ts";
+export * from "./api/schemas/DevSchedulerMetadata.ts";
+export * from "./api/schemas/DevTopicMetadata.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
@@ -40,6 +43,10 @@ export const AlephaDevtools = $module({
     LogRepository,
   ],
   register: (alepha) => {
+    if (!alepha.isViteDev()) {
+      return;
+    }
+
     alepha.with(DevToolsProvider);
     alepha.with(DevToolsDatabaseProvider);
     alepha.with(DevToolsMetadataProvider);

package/src/ui/AppRouter.tsx

@@ -1,6 +1,17 @@
 import { $page } from "@alepha/react";
 import { RootRouter } from "@alepha/ui";
-import { IconDashboard, IconLogs } from "@tabler/icons-react";
+import {
+  IconApi,
+  IconArchive,
+  IconAtom,
+  IconDashboard,
+  IconDatabase,
+  IconLogs,
+  IconMessageCircle,
+  IconStack2,
+  IconTopologyRing,
+  IconVariable,
+} from "@tabler/icons-react";
 
 export class AppRouter extends RootRouter {
   layout = $page({
@@ -14,7 +25,79 @@ export class AppRouter extends RootRouter {
     icon: <IconDashboard />,
     static: true,
     parent: this.layout,
-    component: () => <div>Dashboard</div>,
+    lazy: () => import("./components/DevDashboard.tsx"),
+  });
+
+  actions = $page({
+    path: "/actions",
+    label: "Actions",
+    icon: <IconApi />,
+    static: true,
+    parent: this.layout,
+    lazy: () => import("./components/actions/DevActionsExplorer.tsx"),
+  });
+
+  queues = $page({
+    path: "/queues",
+    label: "Queues",
+    icon: <IconStack2 />,
+    static: true,
+    parent: this.layout,
+    lazy: () => import("./components/DevQueueMonitor.tsx"),
+  });
+
+  topics = $page({
+    path: "/topics",
+    label: "Topics",
+    icon: <IconMessageCircle />,
+    static: true,
+    parent: this.layout,
+    lazy: () => import("./components/DevTopicsViewer.tsx"),
+  });
+
+  caches = $page({
+    path: "/caches",
+    label: "Caches",
+    icon: <IconArchive />,
+    static: true,
+    parent: this.layout,
+    lazy: () => import("./components/DevCacheInspector.tsx"),
+  });
+
+  env = $page({
+    path: "/env",
+    label: "Environment",
+    icon: <IconVariable />,
+    static: true,
+    parent: this.layout,
+    lazy: () => import("./components/DevEnvExplorer.tsx"),
+  });
+
+  atoms = $page({
+    path: "/atoms",
+    label: "Atoms",
+    icon: <IconAtom />,
+    static: true,
+    parent: this.layout,
+    lazy: () => import("./components/DevAtomsViewer.tsx"),
+  });
+
+  db = $page({
+    path: "/db",
+    label: "DB Studio",
+    icon: <IconDatabase />,
+    static: true,
+    parent: this.layout,
+    lazy: () => import("./components/db/DevDbStudio.tsx"),
+  });
+
+  graph = $page({
+    path: "/graph",
+    label: "Graph",
+    icon: <IconTopologyRing />,
+    static: true,
+    parent: this.layout,
+    lazy: () => import("./components/graph/DevDependencyGraph.tsx"),
   });
 
   logs = $page({