alepha 0.19.0 → 0.19.2

package/src/devtools/providers/DevToolsProvider.ts

@@ -1,280 +0,0 @@
-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/devtools/schemas/DevActionMetadata.ts

@@ -1,30 +0,0 @@
-import { type Static, t } from "alepha";
-
-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()),
-  middlewares: t.optional(
-    t.array(
-      t.object({
-        name: t.text(),
-        options: t.optional(t.any()),
-      }),
-    ),
-  ),
-});
-
-export type DevActionMetadata = Static<typeof devActionMetadataSchema>;

package/src/devtools/schemas/DevAtomMetadata.ts

@@ -1,26 +0,0 @@
-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/devtools/schemas/DevBucketMetadata.ts

@@ -1,11 +0,0 @@
-import { type Static, t } from "alepha";
-
-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(),
-});
-
-export type DevBucketMetadata = Static<typeof devBucketMetadataSchema>;

package/src/devtools/schemas/DevCacheMetadata.ts

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

package/src/devtools/schemas/DevEntityMetadata.ts

@@ -1,60 +0,0 @@
-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),
-  schema: t.optional(t.any()),
-  insertSchema: t.optional(t.any()),
-  updateSchema: t.optional(t.any()),
-});
-
-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/devtools/schemas/DevEnvMetadata.ts

@@ -1,22 +0,0 @@
-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/devtools/schemas/DevMetadata.ts

@@ -1,47 +0,0 @@
-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 { 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";
-
-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),
-  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),
-});
-
-export type DevMetadata = Static<typeof devMetadataSchema>;

package/src/devtools/schemas/DevModuleMetadata.ts

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

package/src/devtools/schemas/DevPageMetadata.ts

@@ -1,24 +0,0 @@
-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(),
-  static: t.optional(t.boolean()),
-  cache: t.optional(t.any()),
-  client: t.optional(t.any()),
-  animation: t.optional(t.any()),
-});
-
-export type DevPageMetadata = Static<typeof devPageMetadataSchema>;

package/src/devtools/schemas/DevProviderMetadata.ts

@@ -1,10 +0,0 @@
-import { type Static, t } from "alepha";
-
-export const devProviderMetadataSchema = t.object({
-  name: t.text(),
-  module: t.optional(t.text()),
-  dependencies: t.array(t.text()),
-  aliases: t.optional(t.array(t.text())),
-});
-
-export type DevProviderMetadata = Static<typeof devProviderMetadataSchema>;

package/src/devtools/schemas/DevQueueMetadata.ts

@@ -1,10 +0,0 @@
-import { type Static, t } from "alepha";
-
-export const devQueueMetadataSchema = t.object({
-  name: t.text(),
-  description: t.optional(t.text()),
-  schema: t.optional(t.any()),
-  provider: t.text(),
-});
-
-export type DevQueueMetadata = Static<typeof devQueueMetadataSchema>;

package/src/devtools/schemas/DevRealmMetadata.ts

@@ -1,19 +0,0 @@
-import { type Static, t } from "alepha";
-
-export 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(),
-    }),
-  ),
-});
-
-export type DevRealmMetadata = Static<typeof devRealmMetadataSchema>;

package/src/devtools/schemas/DevRouteMetadata.ts

@@ -1,8 +0,0 @@
-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/devtools/schemas/DevSchedulerMetadata.ts

@@ -1,11 +0,0 @@
-import { type Static, t } from "alepha";
-
-export 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()),
-});
-
-export type DevSchedulerMetadata = Static<typeof devSchedulerMetadataSchema>;

package/src/devtools/schemas/DevTopicMetadata.ts

@@ -1,11 +0,0 @@
-import { type Static, t } from "alepha";
-
-export const devTopicMetadataSchema = t.object({
-  name: t.text(),
-  description: t.optional(t.text()),
-  schema: t.optional(t.any()),
-  provider: t.text(),
-  subscribers: t.integer(),
-});
-
-export type DevTopicMetadata = Static<typeof devTopicMetadataSchema>;

package/src/mqtt/index.ts

@@ -1,32 +0,0 @@
-import { $module, type Alepha } from "alepha";
-import { MqttClientProvider } from "./providers/MqttClientProvider.ts";
-import { MqttJsClientProvider } from "./providers/MqttJsClientProvider.ts";
-
-// ---------------------------------------------------------------------------------------------------------------------
-
-export * from "./providers/MqttClientProvider.ts";
-export * from "./providers/MqttJsClientProvider.ts";
-
-// ---------------------------------------------------------------------------------------------------------------------
-
-/**
- * MQTT client module for Alepha.
- *
- * Provides a lifecycle-managed MQTT client backed by `mqtt.js`.
- * Registers `MqttJsClientProvider` as the default implementation of `MqttClientProvider`.
- *
- * @see {@link MqttClientProvider}
- * @see {@link MqttJsClientProvider}
- * @module alepha.mqtt
- */
-export const AlephaMqtt = $module({
-  name: "alepha.mqtt",
-  services: [MqttClientProvider, MqttJsClientProvider],
-  register: (alepha: Alepha): void => {
-    alepha.with({
-      optional: true,
-      provide: MqttClientProvider,
-      use: MqttJsClientProvider,
-    });
-  },
-});