alepha 0.7.5 → 0.7.7

package/security.js

@@ -1 +1 @@
-export * from '@alepha/security';
+export * from '@alepha/security'

package/server/cache.cjs

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

package/server/cache.d.ts

@@ -1,48 +1,50 @@
-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';
+import { Cache, CacheDescriptorOptions, CacheDescriptorProvider } from "@alepha/cache";
+import { ServerHandler, ServerRequestConfig } from "@alepha/server";
+import * as _alepha_core1 from "@alepha/core";
+import { Alepha, Module, OPTIONS } from "@alepha/core";
+import { DateTimeProvider, DurationLike } from "@alepha/datetime";
 
+//#region src/providers/ServerCacheProvider.d.ts
 declare module "alepha/server" {
-    interface ServerRoute {
-        cache?: ServerRouteCache;
-    }
-    interface ActionDescriptor {
-        invalidate: () => Promise<void>;
-    }
+  interface ServerRoute {
+    cache?: ServerRouteCache;
+  }
+  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;
+  protected readonly log: _alepha_core1.Logger;
+  protected readonly alepha: Alepha;
+  protected readonly cacheProvider: CacheDescriptorProvider;
+  protected readonly time: DateTimeProvider;
+  protected readonly caches: Map<ServerHandler, RouteCache>;
+  readonly onConfigure: _alepha_core1.HookDescriptor<"configure">;
+  readonly onRoute: _alepha_core1.HookDescriptor<"server:onRoute">;
+  readonly onRequest: _alepha_core1.HookDescriptor<"server:onRequest">;
+  readonly onSend: _alepha_core1.HookDescriptor<"server:onResponse">;
+  generateETag(content: string): string;
+  invalidate(route: RouteLike): Promise<void>;
+  protected getCacheByRoute(route: RouteLike): RouteCache | undefined;
+  protected createCacheKey(args: ServerRequestConfig): string;
 }
 type ServerRouteCache = boolean | DurationLike | Omit<CacheDescriptorOptions<any>, "handler" | "key">;
 type RouteCache = Cache<{
-    contentType?: string;
-    body: string;
-    status?: number;
-    lastModified: string;
-    hash: string;
+  contentType?: string;
+  body: string;
+  status?: number;
+  lastModified: string;
+  hash: string;
 }>;
 type RouteLike = {
-    [OPTIONS]: {
-        handler?: ServerHandler;
-    };
-} | {
+  [OPTIONS]: {
     handler?: ServerHandler;
+  };
+} | {
+  handler?: ServerHandler;
 };
-
+//#endregion
+//#region src/index.d.ts
 /**
  * # Alepha Server Cache Module
  *
@@ -53,8 +55,8 @@ type RouteLike = {
  *
  * @example
  * ```ts
- * import { Alepha } from "@alepha/core";
- * import { $action } from "@alepha/server";
+ * import { Alepha } from "alepha";
+ * import { $action } from "alepha/server";
  * import { AlephaServerCache } from "alepha/server/cache";
  *
  * class ApiServer {
@@ -75,8 +77,9 @@ type RouteLike = {
  * @module alepha.server.cache
  */
 declare class AlephaServerCache implements Module {
-    readonly name = "alepha.server.cache";
-    readonly $services: (alepha: Alepha) => Alepha;
+  readonly name = "alepha.server.cache";
+  readonly $services: (alepha: Alepha) => Alepha;
 }
-
-export { AlephaServerCache, ServerCacheProvider, type ServerRouteCache };
+//#endregion
+export { AlephaServerCache, ServerCacheProvider, ServerRouteCache };
+//# sourceMappingURL=index.d.ts.map

package/server/cache.js

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

package/server/cookies.cjs

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

package/server/cookies.d.ts

@@ -1,56 +1,64 @@
-import * as _alepha_core from '@alepha/core';
-import { TSchema, KIND, OPTIONS, Static } from '@alepha/core';
-import { DurationLike } from '@alepha/datetime';
+import * as _alepha_core1 from "@alepha/core";
+import { KIND, OPTIONS, Static, TSchema } from "@alepha/core";
+import { DurationLike } from "@alepha/datetime";
 
+//#region src/descriptors/$cookie.d.ts
 interface CookieDescriptorOptions<T extends TSchema> {
-    schema: T;
-    name: string;
-    path?: string;
-    ttl?: DurationLike;
-    secure?: boolean;
-    httpOnly?: boolean;
-    sameSite?: "strict" | "lax" | "none";
-    domain?: string;
-    compress?: boolean;
-    encrypt?: boolean;
-    sign?: boolean;
+  schema: T;
+  name: string;
+  path?: string;
+  ttl?: DurationLike;
+  secure?: boolean;
+  httpOnly?: boolean;
+  sameSite?: "strict" | "lax" | "none";
+  domain?: string;
+  compress?: boolean;
+  encrypt?: boolean;
+  sign?: boolean;
 }
 interface CookieDescriptor<T extends TSchema> {
-    [KIND]: "COOKIE";
-    [OPTIONS]: CookieDescriptorOptions<T>;
-    set: (cookies: Cookies, value: Static<T>) => void;
-    get: (cookies: Cookies) => Static<T> | undefined;
-    del: (cookies: Cookies) => void;
+  [KIND]: "COOKIE";
+  [OPTIONS]: CookieDescriptorOptions<T>;
+  set: (cookies: Cookies, value: Static<T>) => void;
+  get: (cookies: Cookies) => Static<T> | undefined;
+  del: (cookies: Cookies) => void;
 }
 declare const $cookie: {
-    <T extends TSchema>(options: CookieDescriptorOptions<T>): CookieDescriptor<T>;
-    [KIND]: string;
+  <T extends TSchema>(options: CookieDescriptorOptions<T>): CookieDescriptor<T>;
+  [KIND]: string;
 };
 interface Cookies {
-    req: Record<string, string>;
-    res: Record<string, Cookie | null>;
+  req: Record<string, string>;
+  res: Record<string, Cookie | null>;
 }
 interface Cookie {
-    value: string;
-    path?: string;
-    maxAge?: number;
-    secure?: boolean;
-    httpOnly?: boolean;
-    sameSite?: "strict" | "lax" | "none";
-    domain?: string;
+  value: string;
+  path?: string;
+  maxAge?: number;
+  secure?: boolean;
+  httpOnly?: boolean;
+  sameSite?: "strict" | "lax" | "none";
+  domain?: string;
 }
-
+//#endregion
+//#region src/providers/ServerCookiesProvider.d.ts
 declare class ServerCookiesProvider {
-    readonly onRequest: _alepha_core.HookDescriptor<"server:onRequest">;
-    readonly onSend: _alepha_core.HookDescriptor<"server:onSend">;
-    fromHeader(header: string): Record<string, string>;
-    toHeader(cookies: Record<string, Cookie | null>, isHttps?: boolean): string[];
+  readonly onRequest: _alepha_core1.HookDescriptor<"server:onRequest">;
+  readonly onSend: _alepha_core1.HookDescriptor<"server:onSend">;
+  fromHeader(header: string): Record<string, string>;
+  toHeader(cookies: Record<string, Cookie | null>, isHttps?: boolean): string[];
 }
-
+//#endregion
+//#region src/index.d.ts
 declare module "alepha/server" {
-    interface ServerRequest {
-        cookies: Cookies;
-    }
+  interface ServerRequest {
+    cookies: Cookies;
+  }
 }
-
-export { $cookie, type Cookie, type CookieDescriptor, type CookieDescriptorOptions, type Cookies, ServerCookiesProvider };
+declare class AlephaServerCookies {
+  readonly name = "alepha.server.cookies";
+  readonly $services: (alepha: any) => void;
+}
+//#endregion
+export { $cookie, AlephaServerCookies, Cookie, CookieDescriptor, CookieDescriptorOptions, Cookies, ServerCookiesProvider };
+//# sourceMappingURL=index.d.ts.map

package/server/cookies.js

@@ -1 +1 @@
-export * from '@alepha/server-cookies';
+export * from '@alepha/server-cookies'

package/server/cors.cjs

@@ -0,0 +1,8 @@
+'use strict';
+var m = require('@alepha/server-cors');
+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/cors.d.ts

@@ -0,0 +1,25 @@
+import * as _alepha_core0 from "@alepha/core";
+import { Alepha, Module } from "@alepha/core";
+
+//#region src/providers/ServerCorsProvider.d.ts
+declare class ServerCorsProvider {
+  options: CorsOptions;
+  protected readonly onRequest: _alepha_core0.HookDescriptor<"server:onRequest">;
+  isOriginAllowed(origin: string | undefined, allowed: CorsOptions["origin"]): boolean;
+}
+interface CorsOptions {
+  origin?: string | string[] | ((origin: string | undefined) => boolean);
+  methods: string[];
+  headers: string[];
+  credentials?: boolean;
+  maxAge?: number;
+}
+//#endregion
+//#region src/index.d.ts
+declare class AlephaServerCors implements Module {
+  readonly name = "alepha.server.cors";
+  readonly $services: (alepha: Alepha) => void;
+}
+//#endregion
+export { AlephaServerCors, CorsOptions, ServerCorsProvider };
+//# sourceMappingURL=index.d.ts.map

package/server/cors.js

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

package/server/health.cjs

@@ -0,0 +1,8 @@
+'use strict';
+var m = require('@alepha/server-health');
+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/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'

package/server/static.cjs

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