alepha 0.7.1 → 0.7.3

package/react.d.ts

@@ -1,6 +1,6 @@
 import * as _alepha_core from '@alepha/core';
 import { TSchema as TSchema$1, KIND, OPTIONS, Static as Static$1, Async, Alepha, Service, TObject as TObject$1 } from '@alepha/core';
-import { ServerRoute, ApiLinksResponse, HttpClient, ClientScope, HttpVirtualClient, ServerRouterProvider, ServerTimingProvider, ServerHandler, ServerRequest } from '@alepha/server';
+import { ServerRoute, ServerRequest, ApiLinksResponse, HttpClient, ClientScope, HttpVirtualClient, ServerRouterProvider, ServerTimingProvider, ServerHandler } from '@alepha/server';
 import * as React from 'react';
 import React__default, { PropsWithChildren, ReactNode, FC, ErrorInfo, AnchorHTMLAttributes } from 'react';
 import { Root } from 'react-dom/client';
@@ -227,6 +227,7 @@ interface PageDescriptorOptions<TConfig extends PageConfigSchema = PageConfigSch
      * If true, the page will be rendered on the client-side.
      */
     client?: boolean | ClientOnlyProps;
+    afterHandler?: (request: ServerRequest) => any;
 }
 interface PageDescriptor<TConfig extends PageConfigSchema = PageConfigSchema, TProps extends object = TPropsDefault, TPropsParent extends object = TPropsParentDefault> {
     [KIND]: typeof KEY;
@@ -296,11 +297,11 @@ interface PageRequestConfig<TConfig extends PageConfigSchema = PageConfigSchema>
 }
 type PageResolve<TConfig extends PageConfigSchema = PageConfigSchema, TPropsParent extends object = TPropsParentDefault> = PageRequestConfig<TConfig> & TPropsParent & PageReactContext;
 
-declare const envSchema$2: _alepha_core.TObject<{
+declare const envSchema$1: _alepha_core.TObject<{
     REACT_STRICT_MODE: TBoolean;
 }>;
 declare module "alepha" {
-    interface Env extends Partial<Static$1<typeof envSchema$2>> {
+    interface Env extends Partial<Static$1<typeof envSchema$1>> {
     }
 }
 declare class PageDescriptorProvider {
@@ -445,22 +446,12 @@ declare class BrowserRouterProvider extends RouterProvider<BrowserRoute> {
     root(state: RouterState, context: PageReactContext): ReactNode;
 }
 
-declare const envSchema$1: _alepha_core.TObject<{
-    REACT_ROOT_ID: TString;
-}>;
-declare module "alepha/core" {
-    interface Env extends Partial<Static$1<typeof envSchema$1>> {
-    }
-}
 declare class ReactBrowserProvider {
     protected readonly log: _alepha_core.Logger;
     protected readonly client: HttpClient;
     protected readonly alepha: Alepha;
     protected readonly router: BrowserRouterProvider;
     protected readonly headProvider: BrowserHeadProvider;
-    protected readonly env: {
-        REACT_ROOT_ID: string;
-    };
     protected root: Root;
     transitioning?: {
         to: string;
@@ -470,11 +461,6 @@ declare class ReactBrowserProvider {
     get history(): History;
     get url(): string;
     invalidate(props?: Record<string, any>): Promise<void>;
-    /**
-     *
-     * @param url
-     * @param options
-     */
     go(url: string, options?: RouterGoOptions): Promise<void>;
     protected render(options?: {
         url?: string;
@@ -482,19 +468,8 @@ declare class ReactBrowserProvider {
     }): Promise<RouterRenderResult>;
     /**
      * Get embedded layers from the server.
-     *
-     * @protected
      */
     protected getHydrationState(): ReactHydrationState | undefined;
-    /**
-     *
-     * @protected
-     */
-    protected getRootElement(): HTMLElement;
-    /**
-     *
-     * @protected
-     */
     readonly ready: _alepha_core.HookDescriptor<"ready">;
     readonly onTransitionEnd: _alepha_core.HookDescriptor<"react:transition:end">;
 }
@@ -542,30 +517,11 @@ declare class RouterHookApi {
     constructor(pages: PageRoute[], state: RouterState, layer: {
         path: string;
     }, browser?: ReactBrowserProvider | undefined);
-    /**
-     *
-     */
     get current(): RouterState;
-    /**
-     *
-     */
     get pathname(): string;
-    /**
-     *
-     */
     get query(): Record<string, string>;
-    /**
-     *
-     */
     back(): Promise<void>;
-    /**
-     *
-     */
     forward(): Promise<void>;
-    /**
-     *
-     * @param props
-     */
     invalidate(props?: Record<string, any>): Promise<void>;
     /**
      * Create a valid href for the given pathname.
@@ -716,7 +672,7 @@ declare const envSchema: TObject<{
     REACT_SSR_ENABLED: TOptional<TBoolean>;
     REACT_ROOT_ID: TString;
 }>;
-declare module "@alepha/core" {
+declare module "alepha/core" {
     interface Env extends Partial<Static$1<typeof envSchema>> {
     }
     interface State {
@@ -734,9 +690,9 @@ declare class ReactServerProvider {
     protected readonly serverTimingProvider: ServerTimingProvider;
     protected readonly env: {
         REACT_SSR_ENABLED?: boolean | undefined;
-        REACT_ROOT_ID: string;
         REACT_SERVER_DIST: string;
         REACT_SERVER_PREFIX: string;
+        REACT_ROOT_ID: string;
     };
     protected readonly ROOT_DIV_REGEX: RegExp;
     readonly onConfigure: _alepha_core.HookDescriptor<"configure">;

package/redis.d.ts

@@ -1,7 +1,7 @@
+import * as _redis_client from '@redis/client';
+import { createClient, SetOptions } from '@redis/client';
 import * as _alepha_core from '@alepha/core';
 import { Static, Alepha } from '@alepha/core';
-import * as Redis from 'ioredis';
-import Redis__default, { RedisOptions } from 'ioredis';
 
 /** Symbol key applied to readonly types */
 declare const ReadonlyKind: unique symbol;
@@ -89,7 +89,9 @@ declare module "alepha" {
     interface Env extends Partial<Static<typeof envSchema>> {
     }
 }
-type RedisClient = Redis__default;
+type RedisClient = ReturnType<typeof createClient>;
+type RedisClientOptions = Parameters<typeof createClient>[0];
+type RedisSetOptions = SetOptions;
 declare class RedisProvider {
     protected readonly log: _alepha_core.Logger;
     protected readonly alepha: Alepha;
@@ -98,7 +100,7 @@ declare class RedisProvider {
         REDIS_PORT: number;
         REDIS_HOST: string;
     };
-    protected readonly client: Redis__default;
+    protected readonly client: _redis_client.RedisClientType<_redis_client.RedisModules, _redis_client.RedisFunctions, _redis_client.RedisScripts, _redis_client.RespVersions, _redis_client.TypeMapping>;
     get publisher(): RedisClient;
     protected readonly start: _alepha_core.HookDescriptor<"start">;
     protected readonly stop: _alepha_core.HookDescriptor<"stop">;
@@ -110,7 +112,7 @@ declare class RedisProvider {
      * Close the connection to the Redis server.
      */
     close(): Promise<void>;
-    duplicate(options?: Partial<RedisOptions>): RedisClient;
+    duplicate(options?: Partial<RedisClientOptions>): RedisClient;
     /**
      * Redis subscriber client factory method.
      */
@@ -121,16 +123,16 @@ declare class RedisSubscriberProvider {
     protected readonly log: _alepha_core.Logger;
     protected readonly alepha: Alepha;
     protected readonly redisProvider: RedisProvider;
-    protected readonly client: Redis.default;
+    protected readonly client: _redis_client.RedisClientType<_redis_client.RedisModules, _redis_client.RedisFunctions, _redis_client.RedisScripts, _redis_client.RespVersions, _redis_client.TypeMapping>;
     get subscriber(): RedisClient;
     protected readonly start: _alepha_core.HookDescriptor<"start">;
     protected readonly stop: _alepha_core.HookDescriptor<"stop">;
     connect(): Promise<void>;
-    close(): void;
+    close(): Promise<void>;
     /**
      * Redis subscriber client factory method.
      */
     protected createClient(): RedisClient;
 }
 
-export { type RedisClient, RedisProvider, RedisSubscriberProvider };
+export { type RedisClient, type RedisClientOptions, RedisProvider, type RedisSetOptions, RedisSubscriberProvider };

package/scheduler.d.ts

@@ -2,7 +2,7 @@ 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";
 type SchedulerDescriptorOptions = {
@@ -173,7 +173,7 @@ interface Scheduler {
     name: string;
     options: SchedulerDescriptorOptions;
     trigger: () => Promise<void>;
-    cronJob?: CronJob;
+    cron?: ScheduledTask;
     interval?: Interval;
 }
 

package/server/{proxy.cjs → cache.cjs}

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

package/server/cache.d.ts

@@ -0,0 +1,51 @@
+import * as _alepha_core from '@alepha/core';
+import { Alepha, OPTIONS } 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 ServerCacheModule {
+    protected readonly alepha: Alepha;
+    constructor();
+}
+
+export { ServerCacheModule, ServerCacheProvider, type ServiceRouteCache };

package/server/cache.js

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

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';
 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;

package/src/server/cache.ts

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

package/topic.d.ts

@@ -184,38 +184,21 @@ declare class RedisTopicProvider implements TopicProvider {
     };
     protected readonly redisProvider: RedisProvider;
     protected readonly redisSubscriberProvider: RedisSubscriberProvider;
-    protected readonly subscriptions: Record<string, SubscribeCallback[]>;
     protected readonly log: _alepha_core.Logger;
-    protected readonly start: _alepha_core.HookDescriptor<"start">;
     protected readonly stop: _alepha_core.HookDescriptor<"stop">;
     prefix(queue: string): string;
     /**
      * Publish a message to a topic.
-     *
-     * @param topic
-     * @param message
      */
     publish(topic: string, message: string): Promise<void>;
     /**
      * Subscribe to a topic.
-     *
-     * @param name
-     * @param callback
      */
     subscribe(name: string, callback: SubscribeCallback): Promise<UnSubscribeFn>;
     /**
      * Unsubscribe from a topic.
-     *
-     * @param name
-     * @param callback
      */
     unsubscribe(name: string, callback?: SubscribeCallback): Promise<void>;
-    /**
-     * Listen for messages.
-     *
-     * @protected
-     */
-    protected listen(): void;
 }
 
 declare class TopicDescriptorProvider {

package/vite.d.ts

@@ -1,14 +1,18 @@
 import { Alepha } from '@alepha/core';
-import viteReactPlugin from '@vitejs/plugin-react';
-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.
+     */
+    serverEntry?: string;
+    /**
+     * Set false to skip the client build.
+     * This is useful if you only want to build the server-side application.
      */
-    entry?: string;
+    client?: false;
     /**
      * If true, the build will be optimized for Vercel deployment.
      *
@@ -17,24 +21,15 @@ interface ViteAlephaBuildOptions {
      * @default false
      */
     vercel?: boolean;
-    /**
-     * Vite server options to override the default server configuration.
-     */
-    server?: false | UserConfig;
-    /**
-     * 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
      *
@@ -43,7 +38,7 @@ interface ViteAlephaDevOptions {
     debug?: boolean;
 }
 /**
- *
+ * Plug Alepha into Vite development server.
  */
 declare function viteAlephaDev(options?: ViteAlephaDevOptions): Promise<Plugin>;
 
@@ -70,10 +65,39 @@ declare function viteAlephaBuildVercel(opts?: ViteAlephaBuildVercelOptions): {
     writeBundle(): void;
 };
 
-declare const viteReact: typeof viteReactPlugin;
+interface ViteCompressOptions {
+    /**
+     * If true, the plugin will not compress the files.
+     *
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * If true, the plugin will compress the files using brotli.
+     * Can also be an object with brotli options.
+     *
+     * @default true
+     */
+    brotli?: boolean | BrotliOptions;
+    /**
+     * If true, the plugin will compress the files using gzip.
+     * Can also be an object with gzip options.
+     *
+     * @default true
+     */
+    gzip?: boolean | ZlibOptions;
+    /**
+     * A filter to determine which files to compress.
+     * Can be a RegExp or a function that returns true for files to compress.
+     *
+     * @default /\.(js|mjs|cjs|css|wasm|svg)$/
+     */
+    filter?: RegExp | ((fileName: string) => boolean);
+}
+declare function viteCompress(options?: ViteCompressOptions): Plugin;
 
 declare global {
     var __alepha: Alepha;
 }
 
-export { type ViteAlephaBuildOptions, type ViteAlephaBuildVercelOptions, type ViteAlephaDevOptions, type ViteAlephaOptions, viteAlepha, viteAlephaBuild, viteAlephaBuildVercel, viteAlephaDev, viteReact };
+export { type ViteAlephaBuildOptions, type ViteAlephaBuildVercelOptions, type ViteAlephaDevOptions, type ViteAlephaOptions, type ViteCompressOptions, viteAlepha, viteAlephaBuild, viteAlephaBuildVercel, viteAlephaDev, viteCompress };

package/server/metrics.cjs

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

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/server/proxy.d.ts

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

package/server/proxy.js

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

package/src/server/metrics.ts

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

package/src/server/proxy.ts

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