alepha 0.7.2 → 0.7.4

package/scheduler.d.ts

@@ -2,9 +2,17 @@ import * as _alepha_core from '@alepha/core';
 import { Async, KIND, OPTIONS, Static, Alepha } from '@alepha/core';
 import { DurationLike, DateTimeProvider, Interval } from '@alepha/datetime';
 import * as _alepha_lock from '@alepha/lock';
-import { CronJob } from 'cron';
+import { ScheduledTask } from 'node-cron';
 
 declare const KEY = "SCHEDULER";
+/**
+ * Scheduler descriptor.
+ */
+declare const $scheduler: {
+    (options: SchedulerDescriptorOptions): SchedulerDescriptor;
+    [KIND]: string;
+};
+declare const isScheduler: (value: any) => value is SchedulerDescriptor;
 type SchedulerDescriptorOptions = {
     /**
      * Function to run on schedule.
@@ -37,17 +45,6 @@ interface SchedulerDescriptor {
     [OPTIONS]: SchedulerDescriptorOptions;
     (): Promise<void>;
 }
-/**
- * Scheduler descriptor.
- *
- * @param options - The scheduler options.
- * @returns The descriptor value.
- */
-declare const $scheduler: {
-    (options: SchedulerDescriptorOptions): SchedulerDescriptor;
-    [KIND]: string;
-};
-declare const isScheduler: (value: any) => value is SchedulerDescriptor;
 
 /** Symbol key applied to readonly types */
 declare const ReadonlyKind: unique symbol;
@@ -157,9 +154,6 @@ declare class SchedulerDescriptorProvider {
     protected run(options: SchedulerDescriptorOptions): Promise<void>;
     /**
      * Prefix the scheduler key.
-     *
-     * @param key
-     * @protected
      */
     protected prefix(key: string): string;
     /**
@@ -173,13 +167,21 @@ interface Scheduler {
     name: string;
     options: SchedulerDescriptorOptions;
     trigger: () => Promise<void>;
-    cronJob?: CronJob;
+    cron?: ScheduledTask;
     interval?: Interval;
 }
 
-declare class SchedulerModule {
-    protected readonly alepha: Alepha;
-    constructor();
+/**
+ * Alepha Scheduler Module
+ *
+ * Generic interface for scheduling tasks.
+ *
+ * @see {@link $scheduler}
+ * @module alepha.scheduler
+ */
+declare class AlephaScheduler {
+    readonly name = "alepha.scheduler";
+    readonly $services: (alepha: Alepha) => Alepha;
 }
 
-export { $scheduler, type Scheduler, type SchedulerDescriptor, type SchedulerDescriptorOptions, SchedulerDescriptorProvider, SchedulerModule, isScheduler };
+export { $scheduler, AlephaScheduler, type Scheduler, type SchedulerDescriptor, type SchedulerDescriptorOptions, SchedulerDescriptorProvider, isScheduler };

package/security.d.ts

@@ -697,9 +697,9 @@ declare module "alepha/core" {
         };
     }
 }
-declare class SecurityModule {
-    protected readonly alepha: Alepha;
-    constructor();
+declare class AlephaSecurity {
+    readonly name = "alepha.security";
+    readonly $services: (alepha: Alepha) => Alepha;
 }
 
-export { $permission, $realm, $role, $serviceAccount, type AccessTokenResponse, type ExtendedJWTPayload, InvalidPermissionError, type JwtParseResult, JwtProvider, type JwtServiceAccountDescriptorOptions, type JwtSignOptions, type KeyLoader, type KeyLoaderHolder, type Oauth2ServiceAccountDescriptorOptions, type Permission, type PermissionDescriptor, type PermissionDescriptorOptions, type Realm, type RealmConfig, type RealmDescriptor, type RealmDescriptorOptions, type Role, type RoleDescriptor, type RoleDescriptorOptions, type SecurityCheckResult, SecurityError, SecurityModule, SecurityProvider, type SecurityUserAccountProvider, type ServiceAccountDescriptor, type ServiceAccountDescriptorOptions, type ServiceAccountStore, type UserAccountInfo, type UserAccountToken, permissionSchema, roleSchema };
+export { $permission, $realm, $role, $serviceAccount, type AccessTokenResponse, AlephaSecurity, type ExtendedJWTPayload, InvalidPermissionError, type JwtParseResult, JwtProvider, type JwtServiceAccountDescriptorOptions, type JwtSignOptions, type KeyLoader, type KeyLoaderHolder, type Oauth2ServiceAccountDescriptorOptions, type Permission, type PermissionDescriptor, type PermissionDescriptorOptions, type Realm, type RealmConfig, type RealmDescriptor, type RealmDescriptorOptions, type Role, type RoleDescriptor, type RoleDescriptorOptions, type SecurityCheckResult, SecurityError, SecurityProvider, type SecurityUserAccountProvider, type ServiceAccountDescriptor, type ServiceAccountDescriptorOptions, type ServiceAccountStore, type UserAccountInfo, type UserAccountToken, permissionSchema, roleSchema };

package/server/cache.cjs

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

package/server/cache.d.ts

@@ -0,0 +1,51 @@
+import * as _alepha_core from '@alepha/core';
+import { Alepha, OPTIONS, Module } from '@alepha/core';
+import { CacheDescriptorOptions, CacheDescriptorProvider, Cache } from '@alepha/cache';
+import { DurationLike, DateTimeProvider } from '@alepha/datetime';
+import { ServerHandler, ServerRequestConfig } from '@alepha/server';
+
+declare module "alepha/server" {
+    interface ServerRoute {
+        cache?: ServiceRouteCache;
+    }
+    interface ActionDescriptor {
+        invalidate: () => Promise<void>;
+    }
+}
+declare class ServerCacheProvider {
+    protected readonly log: _alepha_core.Logger;
+    protected readonly alepha: Alepha;
+    protected readonly cacheProvider: CacheDescriptorProvider;
+    protected readonly time: DateTimeProvider;
+    protected readonly caches: Map<ServerHandler, RouteCache>;
+    readonly onConfigure: _alepha_core.HookDescriptor<"configure">;
+    readonly onRoute: _alepha_core.HookDescriptor<"server:onRoute">;
+    readonly onRequest: _alepha_core.HookDescriptor<"server:onRequest">;
+    readonly onSend: _alepha_core.HookDescriptor<"server:onResponse">;
+    generateETag(content: string): string;
+    invalidate(route: RouteLike): Promise<void>;
+    protected getCacheByRoute(route: RouteLike): RouteCache | undefined;
+    protected createCacheKey(args: ServerRequestConfig): string;
+}
+type ServiceRouteCache = boolean | DurationLike | Omit<CacheDescriptorOptions<any>, "handler" | "key">;
+type RouteCache = Cache<{
+    contentType?: string;
+    body: string;
+    status?: number;
+    lastModified: string;
+    hash: string;
+}>;
+type RouteLike = {
+    [OPTIONS]: {
+        handler?: ServerHandler;
+    };
+} | {
+    handler?: ServerHandler;
+};
+
+declare class AlephaServerCache implements Module {
+    readonly name = "alepha.server.cache";
+    readonly $services: (alepha: Alepha) => Alepha;
+}
+
+export { AlephaServerCache, ServerCacheProvider, type ServiceRouteCache };

package/server/cache.js

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

package/server/swagger.d.ts

@@ -1,5 +1,5 @@
 import * as _alepha_core from '@alepha/core';
-import { KIND, OPTIONS, Alepha, TObject } from '@alepha/core';
+import { KIND, OPTIONS, Alepha, TObject, Module } from '@alepha/core';
 import { OpenAPIV3 } from 'openapi-types';
 import { ServerActionDescriptorProvider, ServerRouterProvider, ServerRouteAction } from '@alepha/server';
 import { ServerStaticProvider } from '@alepha/server-static';
@@ -100,4 +100,9 @@ declare class ServerSwaggerProvider {
     protected configureSwaggerUi(prefix: string, options: SwaggerDescriptorOptions): Promise<void>;
 }
 
-export { $swagger, ServerSwaggerProvider, type SwaggerDescriptor, type SwaggerDescriptorOptions, type SwaggerUiOptions };
+declare class AlephaServerSwagger implements Module {
+    readonly name = "alepha.server.swagger";
+    readonly $services: (alepha: Alepha) => Alepha;
+}
+
+export { $swagger, AlephaServerSwagger, ServerSwaggerProvider, type SwaggerDescriptor, type SwaggerDescriptorOptions, type SwaggerUiOptions };

package/server.d.ts

@@ -1,14 +1,13 @@
 import * as _alepha_core from '@alepha/core';
-import { Static as Static$1, TObject as TObject$1, TSchema as TSchema$2, Async, StreamLike, Alepha, FileLike, OPTIONS, KIND, Service } from '@alepha/core';
+import { Static as Static$1, TObject as TObject$1, TSchema as TSchema$2, Async, StreamLike, Alepha, FileLike, OPTIONS, KIND, Module } from '@alepha/core';
 export { KIND } from '@alepha/core';
-import * as _alepha_cache from '@alepha/cache';
-import { CacheDescriptorOptions } from '@alepha/cache';
-import { DurationLike, DateTimeProvider } from '@alepha/datetime';
 import { UserAccountToken, Permission, ServiceAccountDescriptor as ServiceAccountDescriptor$1, SecurityProvider, JwtProvider } from '@alepha/security';
 import { IncomingMessage, ServerResponse as ServerResponse$1 } from 'node:http';
 import { Readable } from 'node:stream';
 import { ReadableStream } from 'node:stream/web';
 import { Route, RouterProvider } from '@alepha/router';
+import * as _alepha_cache from '@alepha/cache';
+import { DurationLike, DateTimeProvider } from '@alepha/datetime';
 import * as _alepha_retry from '@alepha/retry';
 import { BusboyConfig } from '@fastify/busboy';
 import * as http from 'http';
@@ -210,8 +209,6 @@ interface TSchema$1 extends TKind$1, SchemaOptions$1 {
 declare const routeMethods: readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "CONNECT", "TRACE"];
 type RouteMethod = (typeof routeMethods)[number];
 
-type ServiceRouteCache = boolean | DurationLike | Omit<CacheDescriptorOptions<any>, "handler" | "key">;
-
 declare const envSchema$4: TObject$1<{
     SERVER_ALS_ENABLED: TBoolean;
 }>;
@@ -289,10 +286,6 @@ interface ServerRoute<TConfig extends RequestConfigSchema = RequestConfigSchema>
      * @see ServerSecurityProvider
      */
     secure?: ServerRouteSecure;
-    /**
-     * @see ServerCacheProvider
-     */
-    cache?: ServiceRouteCache;
 }
 type ServerResponseBody<TConfig extends RequestConfigSchema = RequestConfigSchema> = TConfig["response"] extends TSchema$2 ? Static$1<TConfig["response"]> : ResponseBodyType;
 type ResponseType = "json" | "text" | "void" | "file" | "any";
@@ -537,11 +530,6 @@ interface ActionDescriptorOptions<TConfig extends RequestConfigSchema = RequestC
      * Main route handler. This is where the route logic is implemented.
      */
     handler?: ServerHandler<TConfig>;
-    /**
-     * If true, the route will be cached.
-     * - Number as seconds or boolean to enable cache.
-     */
-    cache?: boolean | DurationLike | Omit<CacheDescriptorOptions<any>, "handler" | "key">;
 }
 interface ActionDescriptor<TConfig extends RequestConfigSchema = RequestConfigSchema> {
     [KIND]: typeof KEY$2;
@@ -558,11 +546,6 @@ interface ActionDescriptor<TConfig extends RequestConfigSchema = RequestConfigSc
      * Name of the permission required to access this route.
      */
     permission: () => string;
-    /**
-     * Invalidate the cache for this action.
-     * This is only available if the action has cache enabled.
-     */
-    invalidate: () => Promise<void>;
 }
 declare const $action: {
     <TConfig extends RequestConfigSchema>(options: ActionDescriptorOptions<TConfig>): ActionDescriptor<TConfig>;
@@ -982,8 +965,8 @@ declare class RemoteDescriptorProvider {
     }) => Promise<{
         prefix?: string | undefined;
         links: {
-            group?: string | undefined;
             method?: string | undefined;
+            group?: string | undefined;
             requestBodyType?: string | undefined;
             service?: string | undefined;
             path: string;
@@ -1137,8 +1120,6 @@ type Ok = Static$1<typeof okSchema>;
 declare const envSchema: _alepha_core.TObject<{
     SERVER_LINKS_ENABLED: TBoolean;
     SERVER_HEALTH_ENABLED: TBoolean;
-    SERVER_NOT_READY_ENABLED: TBoolean;
-    SERVER_TIMING_ENABLED: TOptional<TBoolean>;
 }>;
 declare module "@alepha/core" {
     interface Hooks {
@@ -1185,16 +1166,13 @@ declare module "@alepha/core" {
     interface Env extends Partial<Static$1<typeof envSchema>> {
     }
 }
-declare class ServerModule {
-    static plugins: Array<Service>;
+declare class AlephaServer implements Module {
     protected readonly env: {
-        SERVER_TIMING_ENABLED?: boolean | undefined;
         SERVER_LINKS_ENABLED: boolean;
         SERVER_HEALTH_ENABLED: boolean;
-        SERVER_NOT_READY_ENABLED: boolean;
     };
-    protected readonly alepha: Alepha;
-    constructor();
+    readonly name = "alepha.server";
+    readonly $services: (alepha: Alepha) => void;
 }
 
-export { $action, $client, $proxy, $remote, $route, type ActionDescriptor, type ActionDescriptorOptions, type ApiLink, type ApiLinksResponse, BadRequestError, type ClientRequestEntry, type ClientRequestEntryContainer, type ClientRequestOptions, type ClientRequestResponse, type ClientScope, ConflictError, type FetchFactoryAdditionalOptions, type FetchLinkArgs, type FetchResponse, type FetchRunOptions, ForbiddenError, HttpClient, type HttpClientLink, type HttpClientPendingRequests, HttpError, type HttpErrorLike, type HttpVirtualClient, NodeHttpServerProvider, NotFoundError, type Ok, type ProxyDescriptor, type ProxyDescriptorOptions, ProxyDescriptorProvider, type RemoteDescriptor, type RemoteDescriptorOptions, RemoteDescriptorProvider, type RequestConfigSchema, type ResponseBodyType, type ResponseType, type RouteDescriptor, type RouteDescriptorOptions, type RouteMethod, ServerActionDescriptorProvider, type ServerHandler, ServerHealthProvider, ServerLinksProvider, ServerLoggerProvider, type ServerMiddlewareHandler, ServerModule, ServerMultipartProvider, ServerNotReadyProvider, ServerProvider, type ServerRawRequest, type ServerRemote, type ServerReply, type ServerRequest, type ServerRequestConfig, type ServerRequestConfigEntry, type ServerResponse, type ServerResponseBody, type ServerRoute, type ServerRouteAction, type ServerRouteSecure, type ServerRouteWithHandler, ServerRouterProvider, ServerSecurityProvider, ServerTimingProvider, UnauthorizedError, ValidationError, apiLinkSchema, apiLinksResponseSchema, errorNameByStatus, errorSchema, isHttpError, isServerAction, okSchema, routeMethods };
+export { $action, $client, $proxy, $remote, $route, type ActionDescriptor, type ActionDescriptorOptions, AlephaServer, type ApiLink, type ApiLinksResponse, BadRequestError, type ClientRequestEntry, type ClientRequestEntryContainer, type ClientRequestOptions, type ClientRequestResponse, type ClientScope, ConflictError, type FetchFactoryAdditionalOptions, type FetchLinkArgs, type FetchResponse, type FetchRunOptions, ForbiddenError, HttpClient, type HttpClientLink, type HttpClientPendingRequests, HttpError, type HttpErrorLike, type HttpVirtualClient, NodeHttpServerProvider, NotFoundError, type Ok, type ProxyDescriptor, type ProxyDescriptorOptions, ProxyDescriptorProvider, type RemoteDescriptor, type RemoteDescriptorOptions, RemoteDescriptorProvider, type RequestConfigSchema, type ResponseBodyType, type ResponseType, type RouteDescriptor, type RouteDescriptorOptions, type RouteMethod, ServerActionDescriptorProvider, type ServerHandler, ServerHealthProvider, ServerLinksProvider, ServerLoggerProvider, type ServerMiddlewareHandler, ServerMultipartProvider, ServerNotReadyProvider, ServerProvider, type ServerRawRequest, type ServerRemote, type ServerReply, type ServerRequest, type ServerRequestConfig, type ServerRequestConfigEntry, type ServerResponse, type ServerResponseBody, type ServerRoute, type ServerRouteAction, type ServerRouteSecure, type ServerRouteWithHandler, ServerRouterProvider, ServerSecurityProvider, ServerTimingProvider, UnauthorizedError, ValidationError, apiLinkSchema, apiLinksResponseSchema, errorNameByStatus, errorSchema, isHttpError, isServerAction, okSchema, routeMethods };

package/src/cache/redis.ts

@@ -0,0 +1 @@
+export * from "@alepha/cache-redis";

package/src/lock/redis.ts

@@ -0,0 +1 @@
+export * from "@alepha/lock-redis";

package/src/queue/redis.ts

@@ -0,0 +1 @@
+export * from "@alepha/queue-redis";

package/src/server/cache.ts

@@ -0,0 +1 @@
+export * from "@alepha/server-cache";

package/src/topic/redis.ts

@@ -0,0 +1 @@
+export * from "@alepha/topic-redis";

package/topic.d.ts

@@ -1,50 +1,6 @@
 import * as _alepha_core from '@alepha/core';
-import { TSchema as TSchema$1, KIND, OPTIONS, Static, Alepha } from '@alepha/core';
+import { TSchema, KIND, OPTIONS, Static, Alepha, Module } from '@alepha/core';
 import { DurationLike, DateTimeProvider } from '@alepha/datetime';
-import { RedisProvider, RedisSubscriberProvider } from '@alepha/redis';
-
-/** Symbol key applied to readonly types */
-declare const ReadonlyKind: unique symbol;
-/** Symbol key applied to optional types */
-declare const OptionalKind: unique symbol;
-/** Symbol key applied to types */
-declare const Hint: unique symbol;
-/** Symbol key applied to types */
-declare const Kind: unique symbol;
-
-interface TUnsafe<T> extends TSchema {
-    [Kind]: string;
-    static: T;
-}
-
-interface SchemaOptions {
-    $schema?: string;
-    /** Id for this schema */
-    $id?: string;
-    /** Title of this schema */
-    title?: string;
-    /** Description of this schema */
-    description?: string;
-    /** Default value for this schema */
-    default?: any;
-    /** Example values matching this schema */
-    examples?: any;
-    /** Optional annotation for readOnly */
-    readOnly?: boolean;
-    /** Optional annotation for writeOnly */
-    writeOnly?: boolean;
-    [prop: string]: any;
-}
-interface TKind {
-    [Kind]: string;
-}
-interface TSchema extends TKind, SchemaOptions {
-    [ReadonlyKind]?: string;
-    [OptionalKind]?: string;
-    [Hint]?: string;
-    params: unknown[];
-    static: unknown;
-}
 
 declare class TopicProvider {
     constructor();
@@ -74,8 +30,8 @@ type UnSubscribeFn = () => Promise<void>;
 
 declare const KEY$1 = "TOPIC";
 interface TopicMessageSchema {
-    headers?: TSchema$1;
-    payload: TSchema$1;
+    headers?: TSchema;
+    payload: TSchema;
 }
 interface TopicDescriptorOptions<T extends TopicMessageSchema = TopicMessageSchema> {
     name?: string;
@@ -178,29 +134,6 @@ declare class MemoryTopicProvider implements TopicProvider {
     unsubscribe(topic: string): Promise<void>;
 }
 
-declare class RedisTopicProvider implements TopicProvider {
-    protected readonly env: {
-        REDIS_TOPIC_PREFIX: string;
-    };
-    protected readonly redisProvider: RedisProvider;
-    protected readonly redisSubscriberProvider: RedisSubscriberProvider;
-    protected readonly log: _alepha_core.Logger;
-    protected readonly stop: _alepha_core.HookDescriptor<"stop">;
-    prefix(queue: string): string;
-    /**
-     * Publish a message to a topic.
-     */
-    publish(topic: string, message: string): Promise<void>;
-    /**
-     * Subscribe to a topic.
-     */
-    subscribe(name: string, callback: SubscribeCallback): Promise<UnSubscribeFn>;
-    /**
-     * Unsubscribe from a topic.
-     */
-    unsubscribe(name: string, callback?: SubscribeCallback): Promise<void>;
-}
-
 declare class TopicDescriptorProvider {
     protected readonly log: _alepha_core.Logger;
     protected readonly alepha: Alepha;
@@ -267,19 +200,20 @@ declare class TopicDescriptorProvider {
     };
 }
 
-declare const envSchema: _alepha_core.TObject<{
-    TOPIC_PROVIDER: TUnsafe<"memory" | "redis">;
-}>;
-declare module "alepha" {
-    interface Env extends Partial<Static<typeof envSchema>> {
-    }
-}
-declare class TopicModule {
-    protected readonly alepha: Alepha;
-    protected readonly env: {
-        TOPIC_PROVIDER: "memory" | "redis";
-    };
-    constructor();
+/**
+ * Alepha Topic Module
+ *
+ * Generic interface for pub/sub messaging.
+ * Gives you the ability to create topics and subscribers.
+ * This module provides only a memory implementation of the topic provider.
+ *
+ * @see {@link $topic}
+ * @see {@link $subscriber}
+ * @module alepha.topic
+ */
+declare class AlephaTopic implements Module {
+    readonly name = "alepha.topic";
+    readonly $services: (alepha: Alepha) => Alepha;
 }
 
-export { $subscriber, $topic, MemoryTopicProvider, RedisTopicProvider, type SubscribeCallback, type SubscriberDescriptor, type SubscriberDescriptorOptions, type TopicDescriptor, type TopicDescriptorOptions, TopicDescriptorProvider, type TopicMessage, type TopicMessageSchema, TopicModule, TopicProvider, TopicTimeoutError, type TopicWaitOptions, type UnSubscribeFn };
+export { $subscriber, $topic, AlephaTopic, MemoryTopicProvider, type SubscribeCallback, type SubscriberDescriptor, type SubscriberDescriptorOptions, type TopicDescriptor, type TopicDescriptorOptions, TopicDescriptorProvider, type TopicMessage, type TopicMessageSchema, TopicProvider, TopicTimeoutError, type TopicWaitOptions, type UnSubscribeFn };

package/vite.d.ts

@@ -1,14 +1,18 @@
 import { Alepha } from '@alepha/core';
-import { UserConfig, Plugin } from 'vite';
+import { Plugin } from 'vite';
 import { BrotliOptions, ZlibOptions } from 'node:zlib';
 
 interface ViteAlephaBuildOptions {
     /**
-     * The entry point for the application. This is the file that will be executed when the application is run.
-     *
-     * @default 'src/index.server.ts'
+     * Path to the entry file for the server build.
+     * If empty, SSR build will be skipped.
      */
-    entry?: string;
+    serverEntry?: string;
+    /**
+     * Set false to skip the client build.
+     * This is useful if you only want to build the server-side application.
+     */
+    client?: false;
     /**
      * If true, the build will be optimized for Vercel deployment.
      *
@@ -17,25 +21,15 @@ interface ViteAlephaBuildOptions {
      * @default false
      */
     vercel?: boolean;
-    /**
-     * Vite server options to override the default server configuration.
-     */
-    server?: false | UserConfig;
-    client?: false;
-    /**
-     * If true, all compatible pages will be pre-rendered.
-     */
-    prerender?: boolean;
 }
 declare function viteAlephaBuild(options?: ViteAlephaBuildOptions): Promise<Plugin>;
 
 interface ViteAlephaDevOptions {
     /**
-     * The entry point for the application. This is the file that will be executed when the application is run.
-     *
-     * @default 'src/index.server.ts'
+     * Path to the entry file for the server build.
+     * If empty, plugin will be disabled.
      */
-    entry?: string;
+    serverEntry?: string;
     /**
      * Enable or disable debug mode
      *
@@ -44,7 +38,7 @@ interface ViteAlephaDevOptions {
     debug?: boolean;
 }
 /**
- *
+ * Plug Alepha into Vite development server.
  */
 declare function viteAlephaDev(options?: ViteAlephaDevOptions): Promise<Plugin>;
 

package/server/metrics.d.ts

@@ -1,14 +0,0 @@
-import * as _alepha_server from '@alepha/server';
-
-declare class ServerMetricsProvider {
-    private readonly register;
-    private cpuUsage;
-    private memoryUsage;
-    private gcDuration;
-    private heapUsage;
-    readonly metrics: _alepha_server.ActionDescriptor<_alepha_server.RequestConfigSchema>;
-    constructor();
-    private collectMetrics;
-}
-
-export { ServerMetricsProvider };

package/server/metrics.js

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

package/src/server/metrics.ts

@@ -1 +0,0 @@
-export * from "@alepha/server-metrics";