alepha 0.7.6 → 0.7.7

package/server/health.d.ts

@@ -0,0 +1,42 @@
+import * as _alepha_server5 from "@alepha/server";
+import { Alepha } from "@alepha/core";
+import { DateTimeProvider } from "@alepha/datetime";
+import * as _sinclair_typebox0 from "@sinclair/typebox";
+
+//#region src/providers/ServerHealthProvider.d.ts
+
+/**
+ * Register `/health` endpoint.
+ *
+ * - Provides basic health information about the server.
+ */
+declare class ServerHealthProvider {
+  protected readonly dateTimeProvider: DateTimeProvider;
+  protected readonly alepha: Alepha;
+  readonly health: _alepha_server5.RouteDescriptor<{
+    response: _sinclair_typebox0.TObject<{
+      message: _sinclair_typebox0.TString;
+      uptime: _sinclair_typebox0.TNumber;
+      date: _sinclair_typebox0.TString;
+      ready: _sinclair_typebox0.TBoolean;
+    }>;
+  }>;
+}
+//#endregion
+//#region src/index.d.ts
+/**
+ * Alepha Server Health Module
+ *
+ * @description
+ * Plugin for Alepha Server that provides health-check endpoints.
+ *
+ * @see {@link ServerHealthProvider}
+ * @module alepha.server.health
+ */
+declare class AlephaServerHealth {
+  readonly name = "alepha.server.health";
+  readonly $services: (alepha: any) => void;
+}
+//#endregion
+export { AlephaServerHealth, ServerHealthProvider };
+//# sourceMappingURL=index.d.ts.map

package/server/health.js

@@ -0,0 +1 @@
+export * from '@alepha/server-health'

package/server/links.cjs

@@ -0,0 +1,8 @@
+'use strict';
+var m = require('@alepha/server-links');
+Object.keys(m).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return m[k]; }
+	});
+});

package/server/links.d.ts

@@ -0,0 +1,188 @@
+import * as _alepha_core23 from "@alepha/core";
+import * as _alepha_core24 from "@alepha/core";
+import * as _alepha_core0 from "@alepha/core";
+import { Alepha, KIND, Module, OPTIONS } from "@alepha/core";
+import * as _alepha_server16 from "@alepha/server";
+import { ActionDescriptor, ActionDescriptorHelper, ApiLink, ApiLinksResponse, ClientRequestOptions, FetchResponse, HttpClient, RequestConfigSchema, ServerActionDescriptorProvider, ServerHandler, ServerRemote, ServerRequestConfigEntry } from "@alepha/server";
+import * as _alepha_retry27 from "@alepha/retry";
+import { ProxyDescriptorOptions, ProxyDescriptorProvider } from "@alepha/server-proxy";
+import { ServiceAccountDescriptor, UserAccountToken } from "@alepha/security";
+import * as _sinclair_typebox1 from "@sinclair/typebox";
+
+//#region src/providers/LinkProvider.d.ts
+declare class LinkProvider {
+  readonly URL_LINKS = "/api/_links";
+  protected readonly log: _alepha_core23.Logger;
+  protected readonly alepha: Alepha;
+  protected readonly httpClient: HttpClient;
+  links?: Array<HttpClientLink>;
+  pushLink(link: HttpClientLink): void;
+  getLinks(force?: boolean): Promise<HttpClientLink[]>;
+  client<T extends object>(scope?: ClientScope): HttpVirtualClient<T>;
+  /**
+   * Resolve a link by its name and call it.
+   * - If link is local, it will call the local handler.
+   * - If link is remote, it will make a fetch request to the remote server.
+   */
+  follow(name: string, config?: Partial<ServerRequestConfigEntry>, options?: ClientRequestOptions & ClientScope): Promise<any>;
+  protected followRemote(link: HttpClientLink, config?: Partial<ServerRequestConfigEntry>, options?: ClientRequestOptions): Promise<FetchResponse>;
+  can(name: string): boolean;
+  protected getLinkByName(name: string, options?: ClientScope): Promise<HttpClientLink>;
+}
+interface HttpClientLink extends ApiLink {
+  secured?: boolean;
+  prefix?: string;
+  host?: string;
+  service?: string;
+  schema?: RequestConfigSchema;
+  handler?: ServerHandler;
+}
+interface ClientScope {
+  group?: string;
+  service?: string;
+}
+type HttpVirtualClient<T> = { [K in keyof T as T[K] extends ActionDescriptor ? K : never]: T[K] extends ActionDescriptor<infer Schema> ? T[K] & {
+  can: () => boolean;
+  schema: Schema;
+} : never };
+//#endregion
+//#region src/descriptors/$client.d.ts
+declare const $client: <T extends object>(scope?: ClientScope) => HttpVirtualClient<T>;
+//#endregion
+//#region src/descriptors/$remote.d.ts
+declare const KEY = "REMOTE";
+interface RemoteDescriptorOptions {
+  /**
+   * The URL of the remote service.
+   * You can use a function to generate the URL dynamically.
+   * You probably should use $inject(env) to get the URL from the environment.
+   *
+   * @example
+   * ```ts
+   * import { $remote } from "@alepha/server";
+   * import { $inject, t } from "@alepha/core";
+   *
+   * class App {
+   *   env = $inject(t.object({
+   *     REMOTE_URL: t.string({default: "http://localhost:3000"}),
+   *   }));
+   *   remote = $remote({
+   *     url: this.env.REMOTE_URL,
+   *   });
+   * }
+   * ```
+   */
+  url: string | (() => string);
+  /**
+   * The name of the remote service.
+   *
+   * @default Member of the class containing the remote service.
+   */
+  name?: string;
+  /**
+   * If true, all methods of the remote service will be exposed as actions in this context.
+   * > Note: Proxy will never use the service account, it just... proxies the request.
+   */
+  proxy?: boolean | Partial<ProxyDescriptorOptions & {
+    /**
+     * If true, the remote service won't be available internally, only through the proxy.
+     */
+    noInternal: boolean;
+  }>;
+  /**
+   * For communication between the server and the remote service with a security layer.
+   * This will be used for internal communication and will not be exposed to the client.
+   */
+  serviceAccount?: ServiceAccountDescriptor;
+}
+interface RemoteDescriptor {
+  [KIND]: typeof KEY;
+  [OPTIONS]: RemoteDescriptorOptions;
+}
+/**
+ * $remote is a descriptor that allows you to define a remote service access.
+ *
+ * Use it only when you have 2 or more services that need to communicate with each other.
+ *
+ * All remote services can be exposed as actions, ... or not.
+ *
+ * You can add a service account if you want to use a security layer.
+ */
+declare const $remote: {
+  (options: RemoteDescriptorOptions): RemoteDescriptor;
+  [KIND]: string;
+};
+//#endregion
+//#region src/providers/RemoteDescriptorProvider.d.ts
+declare class RemoteDescriptorProvider {
+  static path: {
+    apiLinks: string;
+  };
+  protected readonly alepha: Alepha;
+  protected readonly client: LinkProvider;
+  protected readonly proxyProvider: ProxyDescriptorProvider;
+  protected readonly remotes: Array<ServerRemote>;
+  protected readonly log: _alepha_core24.Logger;
+  getRemotes(): ServerRemote[];
+  readonly configure: _alepha_core24.HookDescriptor<"configure">;
+  readonly start: _alepha_core24.HookDescriptor<"start">;
+  registerRemote(value: RemoteDescriptor, key: string): Promise<void>;
+  protected readonly fetchLinks: _alepha_retry27.RetryDescriptor<(opts: {
+    service: string;
+    url: string;
+    authorization?: string;
+  }) => Promise<{
+    prefix?: string | undefined;
+    links: {
+      method?: string | undefined;
+      group?: string | undefined;
+      requestBodyType?: string | undefined;
+      service?: string | undefined;
+      name: string;
+      path: string;
+    }[];
+  }>>;
+}
+//#endregion
+//#region src/providers/ServerLinksProvider.d.ts
+declare class ServerLinksProvider {
+  protected readonly alepha: Alepha;
+  protected readonly client: LinkProvider;
+  protected readonly helper: ActionDescriptorHelper;
+  protected readonly remoteProvider: RemoteDescriptorProvider;
+  protected readonly serverActionDescriptorProvider: ServerActionDescriptorProvider;
+  readonly onRoute: _alepha_core0.HookDescriptor<"server:onRoute">;
+  readonly links: _alepha_server16.RouteDescriptor<{
+    response: _sinclair_typebox1.TObject<{
+      prefix: _sinclair_typebox1.TOptional<_sinclair_typebox1.TString>;
+      links: _sinclair_typebox1.TArray<_sinclair_typebox1.TObject<{
+        name: _sinclair_typebox1.TString;
+        path: _sinclair_typebox1.TString;
+        method: _sinclair_typebox1.TOptional<_sinclair_typebox1.TString>;
+        group: _sinclair_typebox1.TOptional<_sinclair_typebox1.TString>;
+        requestBodyType: _sinclair_typebox1.TOptional<_sinclair_typebox1.TString>;
+        service: _sinclair_typebox1.TOptional<_sinclair_typebox1.TString>;
+      }>>;
+    }>;
+  }>;
+  readonly schema: _alepha_server16.RouteDescriptor<{
+    params: _sinclair_typebox1.TObject<{
+      name: _sinclair_typebox1.TString;
+    }>;
+    response: _sinclair_typebox1.TRecord<_sinclair_typebox1.TString, _sinclair_typebox1.TAny>;
+  }>;
+  getLinks(options: GetLinksOptions): Promise<ApiLinksResponse>;
+}
+interface GetLinksOptions {
+  user?: UserAccountToken;
+  authorization?: string;
+}
+//#endregion
+//#region src/index.d.ts
+declare class AlephaServerLinks implements Module {
+  readonly name = "alepha.server.links";
+  readonly $services: (alepha: Alepha) => void;
+}
+//#endregion
+export { $client, $remote, AlephaServerLinks, ClientScope, GetLinksOptions, HttpClientLink, HttpVirtualClient, LinkProvider, RemoteDescriptor, RemoteDescriptorOptions, RemoteDescriptorProvider, ServerLinksProvider };
+//# sourceMappingURL=index.d.ts.map

package/server/links.js

@@ -0,0 +1 @@
+export * from '@alepha/server-links'

package/server/proxy.cjs

@@ -0,0 +1,8 @@
+'use strict';
+var m = require('@alepha/server-proxy');
+Object.keys(m).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return m[k]; }
+	});
+});

package/server/proxy.d.ts

@@ -0,0 +1,41 @@
+import * as _alepha_core0 from "@alepha/core";
+import { Alepha, Async, KIND, Module, OPTIONS } from "@alepha/core";
+import { ServerHandler, ServerRequest, ServerRouterProvider } from "@alepha/server";
+
+//#region src/descriptors/$proxy.d.ts
+type ProxyDescriptorOptions = {
+  path: string;
+  target: string;
+  disabled?: boolean;
+  beforeRequest?: (request: ServerRequest, proxyRequest: RequestInit) => Async<void>;
+  afterResponse?: (request: ServerRequest, proxyResponse: Response) => Async<void>;
+  rewrite?: (url: URL) => void;
+};
+interface ProxyDescriptor {
+  [KIND]: "PROXY";
+  [OPTIONS]: ProxyDescriptorOptions;
+}
+declare const $proxy: {
+  (options: ProxyDescriptorOptions): ProxyDescriptor;
+  [KIND]: string;
+};
+//#endregion
+//#region src/providers/ProxyDescriptorProvider.d.ts
+declare class ProxyDescriptorProvider {
+  protected readonly log: _alepha_core0.Logger;
+  protected readonly routerProvider: ServerRouterProvider;
+  protected readonly alepha: Alepha;
+  readonly configure: _alepha_core0.HookDescriptor<"configure">;
+  createProxyHandler(options: Omit<ProxyDescriptorOptions, "path">): ServerHandler;
+  proxy(options: ProxyDescriptorOptions): Promise<void>;
+  private getRawRequestBody;
+}
+//#endregion
+//#region src/index.d.ts
+declare class AlephaServerProxy implements Module {
+  readonly name = "alepha.server.proxy";
+  readonly $services: (alepha: Alepha) => void;
+}
+//#endregion
+export { $proxy, AlephaServerProxy, ProxyDescriptor, ProxyDescriptorOptions, ProxyDescriptorProvider };
+//# sourceMappingURL=index.d.ts.map

package/server/proxy.js

@@ -0,0 +1 @@
+export * from '@alepha/server-proxy'