@vandenberghinc/volt 1.1.26 → 1.1.28

package/backend/dist/{esm → cjs/backend/src}/endpoint.d.ts

@@ -1,6 +1,10 @@
+/**
+ * @author Daan van den Bergh
+ * @copyright © 2022 - 2025 Daan van den Bergh. All rights reserved
+ */
 import { View } from './view.js';
 import * as vlib from "@vandenberghinc/vlib";
-import { RateLimits, RateLimitGroup } from "./rate_limit.js";
+import { RateLimitGroup, RateLimitData } from "./rate_limit.js";
 import { Stream, AuthStream } from "./stream.js";
 import type { Server } from "./server.js";
 import { Route } from './route.js';
@@ -93,8 +97,7 @@ import { Route } from './route.js';
  *   and only have to be assigned once. The assigned attributes will be overridden when
  *   these attributes are reassigned for the same group.
  */
-export declare class Endpoint<const S extends vlib.scheme.Infer.Scheme.S = {}> {
-    static rate_limits: Map<string, any>;
+export declare class Endpoint<const M extends Endpoint.Method = "GET", const E extends string | RegExp = string, const S extends vlib.Schema.Entries.Opts = {}> {
     static compressed_content_types: string[];
     /** Route attributes */
     id: string;
@@ -102,17 +105,19 @@ export declare class Endpoint<const S extends vlib.scheme.Infer.Scheme.S = {}> {
     /** Requires authentication */
     authenticated: boolean;
     /** Parameter scheme validator */
-    params_val?: vlib.scheme.Validator<object, object, "object">;
+    params_schema?: vlib.Schema.Validator<object>;
     /** The default response headers */
     headers: [string, string][];
     /** Option 1) User callback - defined as method so a derived endpoint can do that as well. */
-    callback?(stream: Stream, params: vlib.scheme.Infer.Scheme<S>): any;
-    callback?(stream: AuthStream, params: vlib.scheme.Infer.Scheme<S>): any;
+    callback?(stream: Stream, params: vlib.Schema.Entries.Infer<S>): any;
+    callback?(stream: AuthStream, params: vlib.Schema.Entries.Infer<S>): any;
     /** Option 2) View based endpoint */
     view?: View;
     /** Option 3) Data endpoint, raw */
-    data: Buffer | string | any[] | Record<any, any>;
+    data?: Buffer | string | any[] | Record<any, any>;
     raw_data?: Buffer | string | any[] | Record<any, any>;
+    /** Option 4 Data endpoint by file path. */
+    file_path?: vlib.Path;
     /** Content length & type */
     content_length?: number;
     content_type?: string;
@@ -122,60 +127,78 @@ export declare class Endpoint<const S extends vlib.scheme.Infer.Scheme.S = {}> {
     allow_sitemap: boolean;
     allow_robots: boolean;
     /** Rate limit groups for internal use. */
-    rate_limit_groups: ReturnType<typeof RateLimits.add>[];
+    rate_limit_groups: RateLimitData[];
     /** Private attributes */
     private _compress;
     private _cache;
-    _static_path?: string;
-    private _templates;
     private ip_whitelist?;
     private _is_compressed?;
     private _initialized;
-    private _server?;
-    constructor({ method, endpoint, authenticated, rate_limit, params, callback, view, data, content_type, // = "text/plain",
-    compress, cache, ip_whitelist, sitemap, robots, allow_unknown_params, _templates, // only used in loading static files.
-    _static_path, _is_static, }: {
-        method?: string;
-        endpoint: string | RegExp;
-        authenticated?: boolean;
-        rate_limit?: string | RateLimitGroup | RateLimitGroup[];
+    /** A reference to the server. */
+    server?: Server;
+    constructor({ method, endpoint, authenticated, rate_limit, params, compress, cache, ip_whitelist, sitemap, robots, allow_unknown_params, _is_static, callback, view, data, file_path, content_type, }: Endpoint.Opts<M, E, S>);
+    /** Initialize with server. */
+    _initialize(server: Server): this;
+    _dynamic_initialize(): Promise<void>;
+    _set_headers(stream: Stream): void;
+    _serve_options(stream: Stream): Promise<void>;
+    _serve(stream: Stream, status_code?: number): Promise<void>;
+    private _load_data_by_path;
+}
+export declare namespace Endpoint {
+    /** The endpoint method. */
+    type Method = "GET" | "POST" | "DELETE" | "PUT" | "PATCH" | "OPTIONS";
+    /** Options for constructing an endpoint. */
+    type Opts<M extends Method = Method, E extends string | RegExp = string, S extends vlib.Schema.Entries.Opts = {}> = {
+        /**
+         * The endpoint method.
+         * @default "GET"
+         */
+        method?: M extends undefined ? "GET" : M;
+        endpoint: E;
+        rate_limit?: string | RateLimitGroup | (string | RateLimitGroup)[];
         params?: S;
-        callback?: ((stream: Stream, params: vlib.scheme.Infer.Scheme<S>) => any) | ((stream: AuthStream, params: vlib.scheme.Infer.Scheme<S>) => any);
-        data?: any;
         compress?: "auto" | boolean;
         cache?: boolean | number;
         ip_whitelist?: string[];
         sitemap?: boolean;
         robots?: boolean;
-        _templates?: Record<string, any>;
-        _static_path?: string;
         _is_static?: boolean;
         allow_unknown_params?: boolean;
     } & ({
-        view: View | View.Opts;
-        content_type?: string;
+        data?: Buffer | string | any[] | Record<any, any>;
+        file_path?: never;
+        view?: never;
+        authenticated?: boolean;
+        callback?: never;
+        content_type: string;
+    } | {
+        data?: never;
+        file_path: string | vlib.Path;
+        authenticated?: boolean;
+        callback?: never;
+        view?: never;
+        content_type: string;
     } | {
-        view?: null | undefined;
+        data?: never;
+        file_path?: never;
+        authenticated?: false;
+        callback: ((stream: Stream, params: vlib.Schema.Entries.Infer<S>) => any);
+        view?: never;
         content_type: string;
-    }));
-    /** Initialize with server. */
-    _initialize(server: Server): this;
-    /**
-     * Convert a RegExp into a readable path:
-     * - strips ^…$ anchors
-     * - unescapes `\/` → `/`
-     * - `(?<name>…)` → `:name`
-     * - anonymous captures `(…)` → `:param1`, `:param2`, …
-     */
-    _stringify_endpoint_regex(re: RegExp): string;
-    _load_data_by_path(server: any): this;
-    _set_headers(stream: any): void;
-    _refresh(server: any): Promise<void>;
-    _dynamic_initialize(): Promise<void>;
-    _serve_options(stream: Stream): Promise<void>;
-    _serve(stream: Stream, status_code?: number): Promise<void>;
-}
-export declare namespace Endpoint {
-    /** Constructor options without the `_server` attribute. */
-    type Opts<S extends vlib.scheme.Infer.Scheme.S = {}> = ConstructorParameters<typeof Endpoint<S>>[0];
+    } | {
+        data?: never;
+        file_path?: never;
+        authenticated: true;
+        callback: ((stream: AuthStream, params: vlib.Schema.Entries.Infer<S>) => any);
+        view?: never;
+        content_type: string;
+    } | {
+        data?: never;
+        file_path?: never;
+        authenticated?: boolean;
+        callback?: never;
+        view: View | View.Opts;
+        content_type?: string;
+    });
 }

package/backend/dist/cjs/{endpoint.js → backend/src/endpoint.js}

@@ -34,17 +34,14 @@ var import_clean_css = __toESM(require("clean-css"));
 var import_zlib = __toESM(require("zlib"));
 var import_view = require("./view.js");
 var vlib = __toESM(require("@vandenberghinc/vlib"));
-var import_utils = require("./utils.js");
+var import_internal_external = require("./errors/internal_external.js");
 var import_status = require("./status.js");
-var import_logger = require("./logger.js");
 var import_rate_limit = require("./rate_limit.js");
 var import_route = require("./route.js");
 var import_meta = __toESM(require("./meta.js"));
-const { log, error, warn } = import_logger.logger;
 const { debug } = vlib;
 class Endpoint {
   // Static attributes.
-  static rate_limits = /* @__PURE__ */ new Map();
   static compressed_content_types = [
     // Image formats (often already compressed)
     "image/jpeg",
@@ -106,7 +103,7 @@ class Endpoint {
   /** Requires authentication */
   authenticated;
   /** Parameter scheme validator */
-  params_val;
+  params_schema;
   /** The default response headers */
   headers;
   /** Option 2) View based endpoint */
@@ -114,6 +111,8 @@ class Endpoint {
   /** Option 3) Data endpoint, raw */
   data;
   raw_data;
+  /** Option 4 Data endpoint by file path. */
+  file_path;
   /** Content length & type */
   content_length;
   content_type;
@@ -127,35 +126,33 @@ class Endpoint {
   /** Private attributes */
   _compress;
   _cache;
-  _static_path;
-  _templates;
   ip_whitelist;
   _is_compressed;
   _initialized = false;
-  _server;
+  /** A reference to the server. */
+  server;
   constructor({
-    method = "GET",
-    endpoint = "/",
+    method,
+    endpoint,
     authenticated = false,
     rate_limit = void 0,
     params = void 0,
-    callback = void 0,
-    view = void 0,
-    data = void 0,
-    content_type,
-    // = "text/plain",
     compress = "auto",
     cache = true,
     ip_whitelist = void 0,
     sitemap = void 0,
     robots = void 0,
     allow_unknown_params = false,
-    _templates = {},
-    // only used in loading static files.
-    _static_path = void 0,
-    _is_static = false
+    _is_static = false,
+    // mode options.
+    callback = void 0,
+    view = void 0,
+    data = void 0,
+    file_path = void 0,
+    content_type
+    // = "text/plain",
   }) {
-    this.route = new import_route.Route(method, endpoint);
+    this.route = new import_route.Route(method ?? "GET", endpoint);
     this.id = this.route.id;
     this.authenticated = authenticated;
     if (this.callback === void 0) {
@@ -166,8 +163,7 @@ class Endpoint {
     this._cache = cache;
     this.allow_sitemap = sitemap ?? true;
     this.allow_robots = robots ?? true;
-    this._templates = _templates;
-    this._static_path = _static_path == null ? void 0 : new vlib.Path(_static_path).abs().str();
+    this.file_path = file_path == null ? file_path : new vlib.Path(file_path).abs();
     this.ip_whitelist = Array.isArray(ip_whitelist) ? ip_whitelist : void 0;
     this.is_static = _is_static;
     this.headers = [];
@@ -209,10 +205,20 @@ class Endpoint {
     this.rate_limit_groups = [];
     if (Array.isArray(rate_limit)) {
       rate_limit.forEach((item) => {
-        this.rate_limit_groups.push(import_rate_limit.RateLimits.add(item));
+        if (typeof item === "string") {
+          const group = import_rate_limit.RateLimits.groups.get(item);
+          if (!group)
+            throw new Error(`Rate limit group "${item}" does not exist.`);
+          this.rate_limit_groups.push(group);
+        } else {
+          this.rate_limit_groups.push(import_rate_limit.RateLimits.add(item));
+        }
       });
     } else if (typeof rate_limit === "string") {
-      this.rate_limit_groups.push(import_rate_limit.RateLimits.add({ group: rate_limit }));
+      const group = import_rate_limit.RateLimits.groups.get(rate_limit);
+      if (!group)
+        throw new Error(`Rate limit group "${rate_limit}" does not exist.`);
+      this.rate_limit_groups.push(group);
     } else if (typeof rate_limit === "object" && rate_limit != null) {
       this.rate_limit_groups.push(import_rate_limit.RateLimits.add(rate_limit));
     }
@@ -230,9 +236,9 @@ class Endpoint {
       });
     }
     if (params_scheme != null) {
-      this.params_val = new vlib.scheme.Validator("object", {
-        scheme: params,
-        strict: !allow_unknown_params,
+      this.params_schema = new vlib.Schema.Validator({
+        schema: params_scheme,
+        unknown: !allow_unknown_params,
         parent: this.route.id + ":",
         throw: false
       });
@@ -240,7 +246,7 @@ class Endpoint {
   }
   /** Initialize with server. */
   _initialize(server) {
-    this._server = server;
+    this.server = server;
     if (this.view != null) {
       this.view._initialize(server, this);
     }
@@ -253,78 +259,30 @@ class Endpoint {
     }
     return this;
   }
-  /**
-   * Convert a RegExp into a readable path:
-   * - strips ^…$ anchors
-   * - unescapes `\/` → `/`
-   * - `(?<name>…)` → `:name`
-   * - anonymous captures `(…)` → `:param1`, `:param2`, …
-   */
-  _stringify_endpoint_regex(re) {
-    let src = re.source;
-    src = src.replace(/^\^/, "").replace(/\$$/, "");
-    src = src.replace(/\\\//g, "/");
-    src = src.replace(/\(\?<([^>]+)>[^)]+\)/g, (_match, name) => `:${name}`);
-    let idx = 1;
-    src = src.replace(/\((?!\?)[^)]+\)/g, () => `:param${idx++}`);
-    return src;
-  }
-  // Load data by path.
-  _load_data_by_path(server) {
-    const path = new vlib.Path(this._static_path);
-    let data;
-    if (path.extension() === ".js") {
-      data = path.load_sync();
-    } else if (path.extension() === ".css") {
-      const minifier = new import_clean_css.default();
-      data = minifier.minify(path.load_sync()).styles;
-    } else {
-      data = path.load_sync({ type: "buffer" });
-    }
-    if (this._templates && typeof data === "string") {
-      data = import_utils.Utils.fill_templates(data, this._templates);
-    }
-    this.data = data;
-    return this;
-  }
-  // Set default headers.
-  _set_headers(stream) {
-    this.headers.forEach((item) => {
-      stream.set_header(item[0], item[1]);
-    });
-  }
-  // Refresh for file watcher.
-  async _refresh(server) {
-    if (server.production) {
-      throw new Error("This function is not designed for production mode.");
-    }
-    if (this.view != null) {
-      await this.view._build_html();
-    }
-  }
   // Initialize.
   async _dynamic_initialize() {
-    if (!this._server) {
+    if (!this.server) {
       throw new Error(`Endpoint "${this.id}" is not initialized by the server yet.`);
     }
-    if (this.view != null) {
-      await this.view._build_html();
+    if (this.file_path != null) {
+      this._load_data_by_path(this.server);
     }
-    if (this._server.production && this.callback == null && this._compress) {
+    if (this.server.production && this.callback == null && this._compress) {
       this._is_compressed = true;
       if (this.data != null && (this.data instanceof Buffer || typeof this.data === "string")) {
         this.raw_data = this.data;
         this.data = import_zlib.default.gzipSync(this.data, { level: import_zlib.default.constants.Z_BEST_COMPRESSION });
         this.content_length = this.data.length;
-      } else if (this.view != null) {
-        this.view.raw_html = this.view.html;
-        this.view.html = import_zlib.default.gzipSync(this.view.html, { level: import_zlib.default.constants.Z_BEST_COMPRESSION });
-        this.content_length = this.view.html.length;
       }
       debug(2, this.route.id, ": ", "Compressed - content_length:", this.content_length);
     }
-    this._cache = false;
-    if ((this.callback == null || this.is_image_endpoint) && (typeof this._cache === "number" || this._cache === true)) {
+    if (!this.server.production) {
+      this._cache = false;
+    }
+    if (
+      // (this.callback == null || this.is_image_endpoint) &&
+      typeof this._cache === "number" || this._cache === true
+    ) {
       if (this._cache === 1 || this._cache === true) {
         this.headers.push(["Cache-Control", "max-age=86400"]);
       } else {
@@ -346,6 +304,12 @@ class Endpoint {
     }
     this._initialized = true;
   }
+  // Set default headers.
+  _set_headers(stream) {
+    this.headers.forEach((item) => {
+      stream.set_header(item[0], item[1]);
+    });
+  }
   // Serve a client.
   async _serve_options(stream) {
     if (!this._initialized) {
@@ -353,13 +317,17 @@ class Endpoint {
     }
     try {
       if (this.ip_whitelist && !this.ip_whitelist.includes(stream.ip)) {
-        stream.send({
+        stream.error({
           status: import_status.Status.unauthorized,
-          body: "Unauthorized."
+          type: "Unauthorized",
+          message: "Unauthorized."
         });
         return;
       }
       this._set_headers(stream);
+      if (this.content_length == null && this.view != null) {
+        stream.set_header("Content-Length", (await this.view.content_length()).toString());
+      }
       stream.send({ status: import_status.Status.no_content });
     } catch (err) {
       throw err;
@@ -371,7 +339,7 @@ class Endpoint {
     }
     try {
       if (this.ip_whitelist && !this.ip_whitelist.includes(stream.ip)) {
-        log(2, this.route.id, ": ", "Blocking ip ", stream.ip, " per ip whitelist.");
+        this.server?.log(2, this.route.id, ": ", "Blocking ip ", stream.ip, " per ip whitelist.");
         stream.send({
           status: import_status.Status.unauthorized,
           data: "Unauthorized."
@@ -380,15 +348,15 @@ class Endpoint {
       }
       this._set_headers(stream);
       if (this.callback != null) {
-        log(3, this.route.id, ": ", "Serving endpoint in callback mode.");
-        if (this.params_val != null) {
-          const { error: error2, invalid_fields } = this.params_val.validate(stream.param);
-          if (error2) {
+        this.server?.log(3, this.route.id, ": ", "Serving endpoint in callback mode.");
+        if (this.params_schema != null) {
+          const { error, invalid_fields } = this.params_schema.validate(stream.params ?? {});
+          if (error) {
             stream.send({
               status: import_status.Status.bad_request,
               headers: { "Content-Type": "application/json" },
               data: {
-                error: error2,
+                error,
                 invalid_fields
               }
             });
@@ -397,7 +365,7 @@ class Endpoint {
         }
         try {
           let promise;
-          if (this.params_val != null) {
+          if (this.params_schema != null) {
             promise = this.callback(stream, stream.params ?? {});
           } else {
             promise = this.callback(stream, {});
@@ -406,7 +374,7 @@ class Endpoint {
             await promise;
           }
         } catch (err) {
-          if (err instanceof import_utils.ExternalError || err instanceof import_utils.InternalError) {
+          if (err instanceof import_internal_external.ExternalError || err instanceof import_internal_external.InternalError) {
             err.serve(stream);
           } else {
             stream.error({
@@ -416,15 +384,15 @@ class Endpoint {
               type: "InternalServerError"
             });
           }
-          error(`${this.id}: `, err);
+          this.server?.log.error(`${this.id}: `, err);
         }
         return;
       } else if (this.view != null) {
-        log(3, this.route.id, ": ", "Serving endpoint in view mode.");
-        this.view._serve(stream, status_code);
+        this.server?.log(3, this.route.id, ": ", "Serving endpoint in view mode.");
+        await this.view._serve(stream, status_code, { compress: this._compress });
         return;
       } else if (this.data != null) {
-        log(3, this.route.id, ": ", "Serving endpoint in data mode.");
+        this.server?.log(3, this.route.id, ": ", "Serving endpoint in data mode.");
         stream.send({
           status: status_code,
           data: this.data
@@ -437,6 +405,24 @@ class Endpoint {
       throw err;
     }
   }
+  // Load data by path.
+  _load_data_by_path(server) {
+    if (!this.file_path) {
+      throw new Error(`Endpoint "${this.id}" has no file path assigned.`);
+    }
+    const path = new vlib.Path(this.file_path);
+    let data;
+    if (path.extension() === ".js") {
+      data = path.load_sync();
+    } else if (path.extension() === ".css") {
+      const minifier = new import_clean_css.default();
+      data = minifier.minify(path.load_sync()).styles;
+    } else {
+      data = path.load_sync({ type: "buffer" });
+    }
+    this.data = data;
+    return this;
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/backend/dist/cjs/backend/src/errors/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @author Daan van den Bergh
+ * @copyright © 2022 - 2025 Daan van den Bergh.
+ */
+export * from './invalid_usage_error.js';
+export * from './system_error.js';
+export * from './internal_external.js';

package/backend/dist/cjs/backend/src/errors/index.js

@@ -0,0 +1,25 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+module.exports = __toCommonJS(stdin_exports);
+__reExport(stdin_exports, require("./invalid_usage_error.js"), module.exports);
+__reExport(stdin_exports, require("./system_error.js"), module.exports);
+__reExport(stdin_exports, require("./internal_external.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./invalid_usage_error.js"),
+  ...require("./system_error.js"),
+  ...require("./internal_external.js")
+});

package/backend/dist/{esm/utils.d.ts → cjs/backend/src/errors/internal_external.d.ts}

@@ -1,4 +1,8 @@
-import type { Stream } from "./stream.js";
+/**
+ * @author Daan van den Bergh
+ * @copyright © 2022 - 2025 Daan van den Bergh.
+ */
+import type { Stream } from "../stream.js";
 /**
  * The base class for internal and external errors.
  */
@@ -7,40 +11,28 @@ declare class BaseError extends Error {
     status: number;
     data?: any[] | Record<string, any>;
     invalid_fields: Record<string, string>;
-    constructor({ type, message, status, data, invalid_fields }: {
-        type?: string;
+    constructor({ type, message, status, data, invalid_fields, cause }: {
         message: string;
+        type?: string;
         status?: number;
-        data?: any;
+        data?: any[] | Record<string, any>;
         invalid_fields?: Record<string, string>;
+        cause?: unknown;
     });
     serve(stream: Stream): this;
 }
 /**
- * Thrown external errors are presented to the user.
+ * Thrown internal errors are not presented to the user, isntead an internal server error message is shown.
  */
-export declare class ExternalError extends BaseError {
+export declare class InternalError extends BaseError {
     constructor(args: ConstructorParameters<typeof BaseError>[0]);
     serve(stream: Stream): this;
 }
 /**
- * Thrown internal errors are not presented to the user, isntead an internal server error message is shown.
+ * Thrown external errors are presented to the user.
  */
-export declare class InternalError extends BaseError {
+export declare class ExternalError extends BaseError {
     constructor(args: ConstructorParameters<typeof BaseError>[0]);
     serve(stream: Stream): this;
 }
-interface UtilsInt {
-    "APIError": typeof ExternalError;
-    fill_templates(data: string, templates: Record<string, any>, curly_style?: boolean): string;
-    get_currency_symbol(currency: string): string | null;
-    get_compiled_cache(domain: string, method: string, endpoint: string): {
-        cache_path: any;
-        cache_hash: any;
-        cache_data: any;
-    };
-    set_compiled_cache(path: any, data: string, hash: string): void;
-}
-export declare const Utils: UtilsInt;
-export { Utils as utils };
-export default Utils;
+export {};