alepha 0.14.1 → 0.14.3

package/src/server/links/primitives/$remote.spec.ts

@@ -0,0 +1,228 @@
+import { Alepha, t } from "alepha";
+import { $action, ServerProvider } from "alepha/server";
+import { describe, it } from "vitest";
+import {
+  $client,
+  $remote,
+  AlephaServerLinks,
+  LinkProvider,
+  ServerLinksProvider,
+} from "../index.ts";
+
+describe("$remote", () => {
+  it("should enable remote action calls between services", async ({
+    expect,
+  }) => {
+    class App {
+      ping = $action({
+        schema: {
+          response: t.object({
+            pong: t.boolean(),
+          }),
+        },
+        handler: () => {
+          return { pong: true };
+        },
+      });
+    }
+
+    const alepha1 = Alepha.create().with(AlephaServerLinks).with(App);
+
+    // --
+
+    class Config {
+      alepha1 = $remote({
+        url: () => alepha1.inject(ServerProvider).hostname,
+      });
+    }
+
+    const alepha2 = Alepha.create({ env: {} })
+      .with(AlephaServerLinks)
+      .with(Config);
+
+    // --
+
+    await alepha1.start();
+    await alepha2.start();
+
+    const app = alepha2.inject(LinkProvider).client<App>();
+    const ping = () => alepha2.context.run(() => app.ping());
+    expect(await ping()).toStrictEqual({ pong: true });
+  });
+
+  it("should handle complex multi-service architecture with proxies", async ({
+    expect,
+  }) => {
+    const env = {
+      LOG_LEVEL: "warn" as const,
+    };
+
+    class ServiceC {
+      print = $action({
+        handler: () => "TADA!",
+      });
+    }
+
+    const c = Alepha.create({ env }).with(ServiceC).with(ServerLinksProvider);
+
+    class ServiceB {
+      compute = $action({
+        handler: () => {
+          return "42";
+        },
+      });
+    }
+
+    const b = Alepha.create({ env }).with(ServiceB).with(ServerLinksProvider);
+
+    class ServiceA {
+      br = $remote({
+        url: () => b.inject(ServerProvider).hostname,
+      });
+
+      cr = $remote({
+        url: () => c.inject(ServerProvider).hostname,
+        proxy: true,
+      });
+
+      sb = $client<ServiceB>();
+      sc = $client<ServiceC>();
+
+      getReport = $action({
+        handler: async () => {
+          const b = await this.sb.compute();
+          const c = await this.sc.print();
+          return `B: ${b}, C: ${c}`;
+        },
+      });
+    }
+
+    const a = Alepha.create({ env }).with(ServiceA).with(ServerLinksProvider);
+
+    class WebApp {
+      a = $remote({
+        url: () => a.inject(ServerProvider).hostname,
+        proxy: true,
+      });
+
+      ping = $action({
+        handler: async () => {
+          return "pong";
+        },
+      });
+    }
+
+    const front = Alepha.create({ env }).with(WebApp).with(ServerLinksProvider);
+
+    await c.start();
+    await b.start();
+    await a.start();
+    await front.start();
+
+    const linkProvider = front.inject(LinkProvider);
+
+    expect(await getLinks(c)).toEqual({
+      links: [
+        {
+          group: "ServiceC",
+          name: "print",
+          path: "/print",
+          rawSchema: {},
+        },
+      ],
+      prefix: "/api",
+    });
+
+    expect(await getLinks(b)).toEqual({
+      links: [
+        {
+          group: "ServiceB",
+          name: "compute",
+          path: "/compute",
+          rawSchema: {},
+        },
+      ],
+      prefix: "/api",
+    });
+
+    expect(await getLinks(a)).toEqual({
+      links: [
+        {
+          group: "ServiceA",
+          name: "getReport",
+          path: "/getReport",
+          rawSchema: {},
+        },
+        {
+          group: "ServiceC",
+          name: "print",
+          path: "/print",
+          service: "cr",
+          rawSchema: {},
+        },
+      ],
+      prefix: "/api",
+    });
+
+    expect(await getLinks(front)).toEqual({
+      links: [
+        {
+          group: "WebApp",
+          name: "ping",
+          path: "/ping",
+          rawSchema: {},
+        },
+        {
+          group: "ServiceA",
+          name: "getReport",
+          path: "/getReport",
+          rawSchema: {},
+          service: "a",
+        },
+        {
+          group: "ServiceC",
+          name: "print",
+          path: "/cr/print",
+          rawSchema: {},
+          service: "a",
+        },
+      ],
+      prefix: "/api",
+    });
+
+    expect(await linkProvider.client<WebApp>().ping.run({})).toEqual("pong");
+    expect(
+      await linkProvider
+        .client<WebApp>(front.inject(ServerProvider))
+        .ping.fetch({})
+        .then((it) => it.data),
+    ).toEqual("pong");
+
+    expect(await linkProvider.client<ServiceA>().getReport()).toEqual(
+      "B: 42, C: TADA!",
+    );
+    expect(
+      await linkProvider
+        .client<ServiceA>()
+        .getReport.fetch({})
+        .then((it) => it.data),
+    ).toEqual("B: 42, C: TADA!");
+
+    expect(await linkProvider.client<ServiceC>().print()).toEqual("TADA!");
+    expect(
+      await linkProvider
+        .client<ServiceC>()
+        .print.fetch({})
+        .then((it) => it.data),
+    ).toEqual("TADA!");
+
+    await expect(() =>
+      linkProvider.client<ServiceB>().compute(),
+    ).rejects.toThrow("Action compute not found");
+  });
+});
+
+const getLinks = (a: Alepha) =>
+  fetch(`${a.inject(ServerProvider).hostname}/api/_links`).then((res) =>
+    res.json(),
+  );

package/src/server/links/providers/LinkProvider.spec.ts

@@ -0,0 +1,54 @@
+import { Alepha, t } from "alepha";
+import { $action, ServerProvider } from "alepha/server";
+import { describe, it } from "vitest";
+import { LinkProvider, ServerLinksProvider } from "../index.ts";
+
+class App {
+  ping = $action({
+    schema: {
+      response: t.object({
+        pong: t.boolean(),
+      }),
+    },
+    handler: () => {
+      return { pong: true };
+    },
+  });
+}
+
+describe("LinkProvider", () => {
+  it("should execute action through local handler", async ({ expect }) => {
+    const alepha = Alepha.create().with(App).with(ServerLinksProvider);
+    await alepha.start();
+
+    const app = alepha.inject(LinkProvider).client<App>();
+
+    expect(await app.ping()).toStrictEqual({ pong: true });
+  });
+
+  it("should expose links endpoint with available actions", async ({
+    expect,
+  }) => {
+    const alepha = Alepha.create().with(App).with(ServerLinksProvider);
+    await alepha.start();
+
+    const res = await fetch(
+      `${alepha.inject(ServerProvider).hostname}/api/_links`,
+    );
+
+    expect(await res.json()).toStrictEqual({
+      prefix: "/api",
+      links: [
+        {
+          group: "App",
+          name: "ping",
+          path: "/ping",
+          rawSchema: {
+            response:
+              '{"type":"object","required":["pong"],"properties":{"pong":{"type":"boolean"}},"additionalProperties":false}',
+          },
+        },
+      ],
+    });
+  });
+});

package/src/server/links/providers/LinkProvider.ts

@@ -1,4 +1,11 @@
-import { $inject, Alepha, AlephaError, type Async, t } from "alepha";
+import {
+  $inject,
+  Alepha,
+  AlephaError,
+  type Async,
+  jsonSchemaToTypeBox,
+  t,
+} from "alepha";
 import { $logger } from "alepha/logger";
 import {
   type ActionPrimitive,
@@ -12,6 +19,7 @@ import {
   type ServerRequest,
   type ServerRequestConfigEntry,
   type ServerResponseBody,
+  type TRequestBody,
   UnauthorizedError,
 } from "alepha/server";
 import type { ServerRouteSecure } from "alepha/server/security";
@@ -26,7 +34,6 @@ import {
 export class LinkProvider {
   static path = {
     apiLinks: "/api/_links",
-    apiSchema: "/api/_links/:name/schema",
   };
 
   protected readonly log = $logger();
@@ -74,6 +81,14 @@ export class LinkProvider {
       this.serverLinks = this.serverLinks.filter((l) => l.name !== link.name);
     }
 
+    if (!link.rawSchema) {
+      link.rawSchema = {};
+      if (link.schema?.body)
+        link.rawSchema.body = JSON.stringify(link.schema.body);
+      if (link.schema?.response)
+        link.rawSchema.response = JSON.stringify(link.schema.response);
+    }
+
     this.serverLinks.push(link);
   }
 
@@ -82,6 +97,7 @@ export class LinkProvider {
     const apiLinks = this.alepha.store.get(
       "alepha.server.request.apiLinks",
     )?.links;
+
     if (apiLinks) {
       if (this.alepha.isBrowser()) {
         return apiLinks;
@@ -223,6 +239,32 @@ export class LinkProvider {
       return this.can(name);
     };
 
+    $.schema = () => {
+      const link = this.links.find((l) => l.name === name);
+      if (!link) {
+        throw new AlephaError(`Link ${name} not found.`);
+      }
+
+      if (link.rawSchema && !link.schema) {
+        link.schema = {};
+        link.schema.body = link.rawSchema?.body
+          ? (jsonSchemaToTypeBox(
+              JSON.parse(link.rawSchema.body),
+            ) as TRequestBody)
+          : undefined;
+        link.schema.response = link.rawSchema?.response
+          ? (jsonSchemaToTypeBox(
+              JSON.parse(link.rawSchema.response),
+            ) as TRequestBody)
+          : undefined;
+      }
+
+      return link.schema as {
+        body: any;
+        response: any;
+      };
+    };
+
     return $;
   }
 
@@ -247,7 +289,7 @@ export class LinkProvider {
     const action = {
       ...link,
       // schema is not used in the client,
-      // we assume that typescript will check
+      // we assume that TypeScript will check
       schema: {
         body: t.any(),
         response: t.any(),
@@ -348,4 +390,8 @@ export interface VirtualAction<T extends RequestConfigSchema>
     opts?: ClientRequestOptions,
   ): Promise<ClientRequestResponse<T>>;
   can: () => boolean;
+  schema: () => {
+    body: T["body"];
+    response: T["response"];
+  };
 }

package/src/server/links/providers/ServerLinksProvider.ts

@@ -80,59 +80,6 @@ export class ServerLinksProvider {
     },
   });
 
-  /**
-   * Second API - Get schema for a specific API link.
-   *
-   * Note: Body/Response schema are not included in `links` API because it's TOO BIG.
-   * I mean for 150+ links, you got 50ms of serialization time.
-   */
-  public readonly schema = $route({
-    path: LinkProvider.path.apiSchema,
-    schema: {
-      params: t.object({
-        name: t.text(),
-      }),
-      response: t.json(),
-    },
-    handler: ({ params, user, headers }) => {
-      return this.getSchemaByName(params.name, {
-        user,
-        authorization: headers.authorization,
-      });
-    },
-  });
-
-  public async getSchemaByName(
-    name: string,
-    options: GetApiLinksOptions = {},
-  ): Promise<RequestConfigSchema> {
-    const authorization = options.authorization;
-    const api = await this.getUserApiLinks({
-      user: options.user,
-      authorization,
-    });
-
-    for (const link of api.links) {
-      if (link.name === name) {
-        if (link.service) {
-          // remote
-          return this.remoteProvider
-            .getRemotes()
-            .find((it) => it.name === link.service)
-            ?.schema({ name: name, authorization });
-        }
-
-        // local
-        return (
-          this.linkProvider.getServerLinks().find((it) => it.name === name)
-            ?.schema ?? {}
-        );
-      }
-    }
-
-    return {};
-  }
-
   /**
    * Retrieves API links for the user based on their permissions.
    * Will check on local links and remote links.
@@ -200,6 +147,7 @@ export class ServerLinksProvider {
         requestBodyType: link.requestBodyType,
         method: link.method,
         path: link.path,
+        rawSchema: link.rawSchema,
       });
     }
 

package/src/server/links/schemas/apiLinksResponseSchema.ts

@@ -37,6 +37,13 @@ export const apiLinkSchema = t.object({
         "Service name associated with the API link, used for service discovery.",
     }),
   ),
+
+  rawSchema: t.optional(
+    t.object({
+      body: t.optional(t.string()),
+      response: t.optional(t.string()),
+    }),
+  ),
 });
 
 export const apiLinksResponseSchema = t.object({

package/src/server/metrics/providers/ServerMetricsProvider.spec.ts

@@ -0,0 +1,25 @@
+import { Alepha } from "alepha";
+import { ServerProvider } from "alepha/server";
+import { describe, it } from "vitest";
+import { AlephaServerMetrics } from "../index.ts";
+
+describe("ServerMetricsProvider", () => {
+  it("should expose metrics endpoint with process metrics", async ({
+    expect,
+  }) => {
+    const alepha = Alepha.create().with(AlephaServerMetrics);
+    await alepha.start();
+
+    const resp = await fetch(
+      `${alepha.inject(ServerProvider).hostname}/metrics`,
+    );
+
+    expect(resp.status).toBe(200);
+    const text = await resp.text();
+
+    expect(text).toContain("process_cpu_system_seconds_total");
+    expect(text).toContain("process_cpu_seconds_total");
+    expect(text).toContain("process_start_time_seconds");
+    // etc...
+  });
+});