alepha 0.7.3 → 0.7.5

package/README.md

@@ -1,21 +1,44 @@
 <div align="center">
 
-<img src="./assets/logo.png" alt="Logo" style="width: 256px"/>
-
-<h1>Alepha</h1>
-
+<h1 >
+<img
+	src="https://raw.githubusercontent.com/feunard/alepha/main/assets/logo.png"
+	width="128"
+	height="128"
+	alt="Logo"
+  valign="middle"
+/>
+Alepha
+</h1>
 <p style="max-width: 512px">
 🚧
 </p>
-
+<a href="https://www.npmjs.com/package/alepha"><img src="https://img.shields.io/npm/v/alepha.svg" alt="npm"/></a>
+<a href="https://www.npmjs.com/package/alepha"><img src="https://img.shields.io/npm/l/alepha.svg" alt="npm"/></a>
+<a href="https://codecov.io/gh/feunard/alepha"><img src="https://codecov.io/gh/feunard/alepha/graph/badge.svg?token=ZDLWI514CP" alt="npm"/></a>
+<a href="https://www.npmjs.com/package/alepha"><img src="https://img.shields.io/npm/dt/alepha.svg" alt="npm"/></a>
+<a href="https://github.com/feunard/alepha"><img src="https://img.shields.io/github/stars/feunard/alepha.svg?style=social" alt="GitHub stars"/></a>
 </div>
 
-[![npm](https://img.shields.io/npm/v/alepha.svg)](https://www.npmjs.com/package/alepha)
-[![license](https://img.shields.io/npm/l/alepha.svg)](https://www.npmjs.com/package/alepha)
-[![downloads](https://img.shields.io/npm/dt/alepha.svg)](https://www.npmjs.com/package/alepha)
-
 ## Installation
 
 ```bash
 npm install alepha
 ```
+
+## Usage
+
+Minimalist http server with a single endpoint.
+
+```ts
+import { run } from "alepha";
+import { $action } from "alepha/server";
+
+class App {
+  hello = $action({
+    handler: () => "Hello world!",
+  })
+}
+
+run(App);
+```

package/cache/redis.cjs

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

package/cache/redis.d.ts

@@ -0,0 +1,105 @@
+import * as _alepha_core from '@alepha/core';
+import { Static, Alepha, Module } from '@alepha/core';
+import { CacheProvider } from '@alepha/cache';
+import { RedisProvider } 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;
+
+type StringFormatOption = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex' | ({} & string);
+type StringContentEncodingOption = '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64' | ({} & string);
+interface StringOptions extends SchemaOptions {
+    /** The maximum string length */
+    maxLength?: number;
+    /** The minimum string length */
+    minLength?: number;
+    /** A regular expression pattern this string should match */
+    pattern?: string;
+    /** A format this string should match */
+    format?: StringFormatOption;
+    /** The content encoding for this string */
+    contentEncoding?: StringContentEncodingOption;
+    /** The content media type for this string */
+    contentMediaType?: string;
+}
+interface TString extends TSchema, StringOptions {
+    [Kind]: 'String';
+    static: string;
+    type: 'string';
+}
+
+type TOptional<T extends TSchema> = T & {
+    [OptionalKind]: 'Optional';
+};
+
+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 const envSchema: _alepha_core.TObject<{
+    REDIS_CACHE_PREFIX: TOptional<TString>;
+}>;
+declare module "alepha" {
+    interface Env extends Partial<Static<typeof envSchema>> {
+    }
+}
+declare class RedisCacheProvider implements CacheProvider {
+    protected readonly log: _alepha_core.Logger;
+    protected readonly redisProvider: RedisProvider;
+    protected readonly env: {
+        REDIS_CACHE_PREFIX?: string | undefined;
+    };
+    protected readonly alepha: Alepha;
+    get(name: string, key: string): Promise<Uint8Array | undefined>;
+    set(name: string, key: string, value: Uint8Array | string, ttl?: number): Promise<Uint8Array>;
+    del(name: string, ...keys: string[]): Promise<void>;
+    has(name: string, key: string): Promise<boolean>;
+    keys(name: string): Promise<string[]>;
+    protected prefix(...path: string[]): string;
+}
+
+/**
+ * Alepha Cache Redis Module
+ *
+ * Plugin for Alepha Cache that provides Redis caching capabilities.
+ *
+ * @see {@link RedisCacheProvider}
+ * @module alepha.cache.redis
+ */
+declare class AlephaCacheRedis implements Module {
+    readonly name = "alepha.cache.redis";
+    readonly $services: (alepha: Alepha) => Alepha;
+}
+
+export { AlephaCacheRedis, RedisCacheProvider };

package/cache/redis.js

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

package/cache.d.ts

@@ -1,7 +1,119 @@
 import * as _alepha_core from '@alepha/core';
-import { KIND, OPTIONS, Static, Alepha } from '@alepha/core';
+import { KIND, OPTIONS, Static, Alepha, Module } from '@alepha/core';
 import { DurationLike, DateTimeProvider, Timeout } from '@alepha/datetime';
-import { RedisProvider, RedisClient } from '@alepha/redis';
+
+/**
+ * Cache provider interface.
+ *
+ * All methods are asynchronous and return promises.
+ * Values are stored as Uint8Array.
+ */
+declare abstract class CacheProvider {
+    /**
+     * Get the value of a key.
+     *
+     * @param name Cache name, used to group keys. Should be Redis-like "some:group:name" format.
+     * @param key The key of the value to get.
+     *
+     * @return The value of the key, or undefined if the key does not exist.
+     */
+    abstract get(name: string, key: string): Promise<Uint8Array | undefined>;
+    /**
+     * Set the string value of a key.
+     *
+     * @param name Cache name, used to group keys. Should be Redis-like "some:group:name" format.
+     * @param key The key of the value to set.
+     * @param value The value to set.
+     * @param ttl The time-to-live of the key, in milliseconds.
+     *
+     * @return The value of the key.
+     */
+    abstract set(name: string, key: string, value: Uint8Array, ttl?: number): Promise<Uint8Array>;
+    /**
+     * Remove the specified keys.
+     *
+     * @param name Cache name, used to group keys. Should be Redis-like "some:group:name" format.
+     * @param keys The keys to delete.
+     */
+    abstract del(name: string, ...keys: string[]): Promise<void>;
+    abstract has(name: string, key: string): Promise<boolean>;
+    abstract keys(name: string): Promise<string[]>;
+}
+
+declare const KEY = "CACHE";
+/**
+ * Cache Descriptor
+ */
+declare const $cache: {
+    <TReturn = string, TParameter extends any[] = any[]>(options?: CacheDescriptorOptions<TReturn, TParameter>): CacheDescriptor<TReturn, TParameter>;
+    [KIND]: string;
+};
+interface CacheDescriptorOptions<TReturn, TParameter extends any[] = any[]> {
+    /**
+     * The cache name. This is useful for invalidating multiple caches at once.
+     *
+     * Store key as `cache:$name:$key`.
+     *
+     * @default ClassName:methodName
+     */
+    name?: string;
+    /**
+     * Function which returns cached data.
+     * @param args Arguments for handler.
+     */
+    handler?: (...args: TParameter) => TReturn;
+    /**
+     * The key generator for the cache.
+     * If not provided, the arguments will be json.stringify().
+     */
+    key?: (...args: TParameter) => string;
+    /**
+     * The store provider for the cache.
+     * If not provided, the default store provider will be used.
+     */
+    provider?: CacheProvider | (() => CacheProvider) | "memory";
+    /**
+     * The time-to-live for the cache in seconds.
+     * Set 0 to skip expiration.
+     *
+     * @default 300 (5 minutes).
+     */
+    ttl?: DurationLike;
+    /**
+     * If the cache is disabled.
+     */
+    disabled?: boolean;
+}
+interface CacheDescriptor<TReturn = any, TParameter extends any[] = any[]> {
+    [KIND]: typeof KEY;
+    [OPTIONS]: CacheDescriptorOptions<TReturn, TParameter>;
+    /**
+     * Cache handler.
+     */
+    (...args: TParameter): Promise<TReturn>;
+    /**
+     * Cache key generator.
+     */
+    key: (...args: TParameter) => string;
+    /**
+     * Invalidate cache by keys.
+     */
+    invalidate: (...keys: string[]) => Promise<void>;
+    /**
+     * Set cache with key, value and ttl.
+     *
+     * @param key
+     * @param value
+     * @param ttl
+     */
+    set: (key: string, value: TReturn, ttl?: DurationLike) => Promise<void>;
+    /**
+     * Get cache by key.
+     *
+     * @param key
+     */
+    get: (key: string) => Promise<TReturn | undefined>;
+}
 
 /** Symbol key applied to readonly types */
 declare const ReadonlyKind: unique symbol;
@@ -12,11 +124,6 @@ declare const Hint: unique symbol;
 /** Symbol key applied to types */
 declare const Kind: unique symbol;
 
-interface TUnsafe<T> extends TSchema {
-    [Kind]: string;
-    static: T;
-}
-
 type StringFormatOption = 'date-time' | 'time' | 'date' | 'email' | 'idn-email' | 'hostname' | 'idn-hostname' | 'ipv4' | 'ipv6' | 'uri' | 'uri-reference' | 'iri' | 'uuid' | 'iri-reference' | 'uri-template' | 'json-pointer' | 'relative-json-pointer' | 'regex' | ({} & string);
 type StringContentEncodingOption = '7bit' | '8bit' | 'binary' | 'quoted-printable' | 'base64' | ({} & string);
 interface StringOptions extends SchemaOptions {
@@ -91,169 +198,35 @@ interface TSchema extends TKind, SchemaOptions {
     static: unknown;
 }
 
-interface CacheProvider {
-    /**
-     * Get the value of a key.
-     *
-     * @param group The group of the value to get.
-     * @param key The key of the value to get.
-     */
-    get(group: string, key: string): Promise<string | undefined>;
-    /**
-     * Set the string value of a key.
-     *
-     * @param group The group of the value to get.
-     * @param key The key of the value to set.
-     * @param value The value to set.
-     * @param ttl The time-to-live of the key, in milliseconds.
-     */
-    set(group: string, key: string, value: string, ttl?: number): Promise<string>;
-    /**
-     * Remove the specified keys.
-     *
-     * @param group The group of the value to get.
-     * @param keys The keys to delete.
-     */
-    del(group: string, ...keys: string[]): Promise<void>;
-}
-
-declare class DefaultCacheProvider implements CacheProvider {
-    constructor();
-    get(): Promise<string | undefined>;
-    set(): Promise<string>;
-    del(): Promise<void>;
-}
-
-declare const KEY = "CACHE";
-interface CacheDescriptorOptions<TReturn, TParameter extends any[] = any[]> {
-    /**
-     * Function which returns cached data.
-     * @param args Arguments for handler.
-     */
-    handler?: (...args: TParameter) => TReturn;
-    /**
-     * The key generator for the cache.
-     * If not provided, the arguments will be json.stringify().
-     */
-    key?: (...args: TParameter) => string;
-    /**
-     * The store provider for the cache.
-     * If not provided, the default store provider will be used.
-     */
-    provider?: (() => DefaultCacheProvider) | "memory";
-    /**
-     * The cache group. This is useful for invalidating multiple caches at once.
-     * Key is used as the group if not provided.
-     *
-     * Store key as `cache:$group:$key`.
-     *
-     * @default ClassName:methodName
-     */
-    group?: string;
-    /**
-     * The time-to-live for the cache in seconds.
-     * Set 0 to skip expiration.
-     *
-     * @default 300 (5 minutes).
-     */
-    ttl?: DurationLike;
-    /**
-     * If the cache is disabled.
-     */
-    disabled?: boolean;
-}
-interface CacheDescriptor<TReturn = any, TParameter extends any[] = any[]> {
-    [KIND]: typeof KEY;
-    [OPTIONS]: CacheDescriptorOptions<TReturn, TParameter>;
-    /**
-     * Cache handler.
-     */
-    (...args: TParameter): Promise<TReturn>;
-    /**
-     * Cache key generator.
-     */
-    key: (...args: TParameter) => string;
-    /**
-     * Invalidate cache by keys.
-     */
-    invalidate: (...keys: string[]) => Promise<void>;
-    /**
-     * Set cache with key, value and ttl.
-     *
-     * @param key
-     * @param value
-     * @param ttl
-     */
-    set: (key: string, value: TReturn, ttl?: DurationLike) => Promise<void>;
-    /**
-     * Get cache by key.
-     *
-     * @param key
-     */
-    get: (key: string) => Promise<TReturn | undefined>;
-}
-/**
- * Cache Descriptor
- *
- * @param options
- */
-declare const $cache: {
-    <TReturn = string, TParameter extends any[] = any[]>(options?: CacheDescriptorOptions<TReturn, TParameter>): CacheDescriptor<TReturn, TParameter>;
-    [KIND]: string;
+type CacheName = string;
+type CacheKey = string;
+type CacheValue = {
+    data?: Uint8Array;
+    timeout?: Timeout;
 };
-
-/**
- * A simple in-memory store provider.
- */
 declare class MemoryCacheProvider implements CacheProvider {
     protected readonly dateTimeProvider: DateTimeProvider;
     protected readonly log: _alepha_core.Logger;
-    /**
-     * The in-memory store.
-     */
-    protected store: Record<string, Record<string, string>>;
-    /**
-     * Timeouts used to expire keys.
-     */
-    protected storeTimeout: Record<string, Record<string, Timeout>>;
-    /**
-     * Get the value of a key.
-     *
-     * @param group The group of the value to get.
-     * @param key The key of the value to get.
-     */
-    get(group: string, key: string): Promise<string | undefined>;
-    /**
-     * Set the string value of a key.
-     *
-     * @param group The group of the value to get.
-     * @param key The key of the value to set.
-     * @param value The value to set.
-     * @param ttl The time-to-live of the key, in milliseconds.
-     */
-    set(group: string, key: string, value: string, ttl?: number): Promise<string>;
-    /**
-     * Remove the specified keys.
-     *
-     * @param group The group of the value to get.
-     * @param keys The keys to delete.
-     */
-    del(group: string, ...keys: string[]): Promise<void>;
-    private ttl;
+    protected store: Record<CacheName, Record<CacheKey, CacheValue>>;
+    get(name: string, key: string): Promise<Uint8Array | undefined>;
+    set(name: string, key: string, value: Uint8Array, ttl?: number): Promise<Uint8Array>;
+    del(name: string, ...keys: string[]): Promise<void>;
+    has(name: string, key: string): Promise<boolean>;
+    keys(name: string): Promise<string[]>;
 }
 
-declare const envSchema$2: _alepha_core.TObject<{
+declare const envSchema: _alepha_core.TObject<{
     CACHE_DEFAULT_TTL: TNumber;
     CACHE_PREFIX: TOptional<TString>;
     CACHE_ENABLED: TBoolean;
 }>;
 declare module "alepha" {
-    interface Env extends Partial<Static<typeof envSchema$2>> {
+    interface Env extends Partial<Static<typeof envSchema>> {
     }
 }
 declare class CacheDescriptorProvider {
     protected readonly alepha: Alepha;
-    protected readonly cacheProvider: DefaultCacheProvider;
+    protected readonly cacheProvider: CacheProvider;
     protected readonly memoryCacheProvider: MemoryCacheProvider;
     protected readonly dateTimeProvider: DateTimeProvider;
     protected readonly env: {
@@ -300,72 +273,33 @@ declare class CacheDescriptorProvider {
      * @param ttl Override cache.ttl option.
      */
     set<TReturn>(cache: Cache<TReturn>, key: string, value: TReturn, ttl?: DurationLike): Promise<void>;
-    protected serialize<TReturn>(value: TReturn): string;
-    protected deserialize<TReturn>(value: string): TReturn;
+    protected encoder: TextEncoder;
+    protected decoder: TextDecoder;
+    protected codes: {
+        BINARY: number;
+        JSON: number;
+        STRING: number;
+    };
+    protected serialize<TReturn>(value: TReturn): Uint8Array;
+    protected deserialize<TReturn>(uint8Array: Uint8Array): Promise<TReturn>;
 }
 interface Cache<TReturn = any, TParameter extends any[] = any[]> {
-    group: string;
+    name: string;
     options: CacheDescriptorOptions<TReturn, TParameter>;
 }
 
-declare const envSchema$1: _alepha_core.TObject<{
-    REDIS_CACHE_PREFIX: TOptional<TString>;
-}>;
-declare module "alepha/core" {
-    interface Env extends Partial<Static<typeof envSchema$1>> {
-    }
-}
-declare class RedisCacheProvider implements CacheProvider {
-    protected readonly log: _alepha_core.Logger;
-    protected readonly redisProvider: RedisProvider;
-    protected readonly env: {
-        REDIS_CACHE_PREFIX?: string | undefined;
-    };
-    get publisher(): RedisClient;
-    /**
-     * Get the value of a key.
-     *
-     * @param group - The group of the value to get.
-     * @param key - The key of the value to get.
-     */
-    get(group: string, key: string): Promise<string | undefined>;
-    /**
-     * Set the string value of a key.
-     *
-     * @param group - The group of the value to get.
-     * @param key - The key of the value to set.
-     * @param value - The value to set.
-     * @param ttl - The time-to-live of the key, in milliseconds.
-     */
-    set(group: string, key: string, value: string, ttl?: number): Promise<string>;
-    /**
-     * Remove the specified keys.
-     *
-     * @param group - The group of the value to get.
-     * @param keys - The keys to delete.
-     */
-    del(group: string, ...keys: string[]): Promise<void>;
-    /**
-     * Prefix the cache key.
-     *
-     * @param path - The path to prefix.
-     */
-    protected prefix(...path: string[]): string;
-}
-
-declare const envSchema: _alepha_core.TObject<{
-    CACHE_PROVIDER: TUnsafe<"memory" | "redis">;
-}>;
-declare module "@alepha/core" {
-    interface Env extends Partial<Static<typeof envSchema>> {
-    }
-}
-declare class CacheModule {
-    protected readonly alepha: Alepha;
-    protected readonly env: {
-        CACHE_PROVIDER: "memory" | "redis";
-    };
-    constructor();
+/**
+ * Alepha Cache Module
+ *
+ * This module provides a caching mechanism for Alepha applications.
+ *
+ * @see {@link $cache}
+ * @see {@link CacheProvider}
+ * @module alepha.cache
+ */
+declare class AlephaCache implements Module {
+    readonly name = "alepha.cache";
+    readonly $services: (alepha: Alepha) => Alepha;
 }
 
-export { $cache, type Cache, type CacheDescriptor, type CacheDescriptorOptions, CacheDescriptorProvider, CacheModule, type CacheProvider, DefaultCacheProvider, MemoryCacheProvider, RedisCacheProvider };
+export { $cache, AlephaCache, type Cache, type CacheDescriptor, type CacheDescriptorOptions, CacheDescriptorProvider, CacheProvider, MemoryCacheProvider };