@tymber/common 0.0.1-alpha.0 → 0.1.0

package/dist/TemplateService.js

@@ -0,0 +1,66 @@
+import { compileTemplate } from "./contrib/template.js";
+import { ModuleDefinitions } from "./Module.js";
+import { createDebug } from "./utils/createDebug.js";
+import { Component, INJECT } from "./Component.js";
+import { FS } from "./utils/fs.js";
+import { isProduction } from "./utils/isProduction.js";
+const debug = createDebug("TemplateService");
+export class TemplateService extends Component {
+}
+export class FileBasedTemplateService extends TemplateService {
+    modules;
+    static [INJECT] = [ModuleDefinitions];
+    templates = new Map();
+    constructor(modules) {
+        super();
+        this.modules = modules;
+        this.modules = modules;
+    }
+    init() {
+        return this.loadTemplates();
+    }
+    async loadTemplates() {
+        for (const module of this.modules.modules) {
+            if (!module.assetsDir) {
+                return;
+            }
+            try {
+                for (const filename of await FS.readDirRecursively(FS.join(module.assetsDir, "templates"))) {
+                    const fileExtension = filename.slice(filename.lastIndexOf("."));
+                    if (fileExtension === this.fileExtension) {
+                        const viewName = filename.slice(0, filename.lastIndexOf("."));
+                        debug("adding template %s", viewName);
+                        if (this.templates.has(viewName)) {
+                            debug("overriding existing template %s", viewName);
+                        }
+                        this.templates.set(viewName, FS.join(module.assetsDir, "templates", filename));
+                    }
+                }
+            }
+            catch (e) { }
+        }
+    }
+    canRender(templateName) {
+        return this.templates.has(templateName);
+    }
+}
+export class BaseTemplateService extends FileBasedTemplateService {
+    fileExtension = ".html";
+    // TODO use a LRU cache
+    compiledTemplates = new Map();
+    render(templateName, data) {
+        return this.getTemplate(templateName).then((template) => template(data));
+    }
+    async getTemplate(templateName) {
+        if (isProduction && this.compiledTemplates.has(templateName)) {
+            return this.compiledTemplates.get(templateName);
+        }
+        const absolutePath = this.templates.get(templateName);
+        const content = await FS.readFile(absolutePath);
+        const compiledTemplate = compileTemplate(content);
+        if (isProduction) {
+            this.compiledTemplates.set(templateName, compiledTemplate);
+        }
+        return compiledTemplate;
+    }
+}

package/dist/View.d.ts

@@ -0,0 +1,17 @@
+import { type HttpContext } from "./HttpContext.js";
+import { Handler } from "./Handler.js";
+export declare abstract class BaseView extends Handler {
+    protected pathParamsSchema: unknown;
+    protected querySchema: unknown;
+    private validatePathParams?;
+    private validateQuery?;
+    doHandle(ctx: HttpContext): Response | Promise<Response>;
+}
+export declare abstract class View extends BaseView {
+    private _viewBrand;
+    doHandle(ctx: HttpContext): Response | Promise<Response>;
+}
+export declare abstract class AdminView extends BaseView {
+    private _adminViewBrand;
+    doHandle(ctx: HttpContext): Response | Promise<Response>;
+}

package/dist/View.js

@@ -0,0 +1,48 @@
+import {} from "ajv";
+import {} from "./HttpContext.js";
+import { Handler } from "./Handler.js";
+import { AJV_INSTANCE } from "./utils/ajv.js";
+export class BaseView extends Handler {
+    pathParamsSchema; // JSONSchemaType<Params>;
+    querySchema; // JSONSchemaType<Query>;
+    validatePathParams;
+    validateQuery;
+    doHandle(ctx) {
+        const { pathParams, query } = ctx;
+        if (this.pathParamsSchema && !this.validatePathParams) {
+            this.validatePathParams = AJV_INSTANCE.compile(this.pathParamsSchema);
+        }
+        if (this.validatePathParams) {
+            this.validatePathParams(pathParams);
+        }
+        if (this.querySchema && !this.validateQuery) {
+            this.validateQuery = AJV_INSTANCE.compile(this.querySchema);
+        }
+        if (this.validateQuery) {
+            this.validateQuery(query);
+        }
+        return this.handle(ctx);
+    }
+}
+export class View extends BaseView {
+    _viewBrand; // nominal typing
+    doHandle(ctx) {
+        if (!this.allowAnonymous && !ctx.user) {
+            return ctx.redirect("/login");
+        }
+        if (!this.hasPermission(ctx)) {
+            return ctx.redirect("/forbidden");
+        }
+        return super.doHandle(ctx);
+    }
+}
+export class AdminView extends BaseView {
+    _adminViewBrand; // nominal typing
+    doHandle(ctx) {
+        if (!this.allowAnonymous && !ctx.admin) {
+            return ctx.redirect("/admin/login");
+        }
+        // note: no hasPermission() check for admins
+        return super.doHandle(ctx);
+    }
+}

package/dist/ViewRenderer.d.ts

@@ -0,0 +1,16 @@
+import { Component, INJECT } from "./Component.js";
+import { BaseTemplateService, TemplateService } from "./TemplateService.js";
+import { I18nService } from "./I18nService.js";
+import { ModuleDefinitions } from "./Module.js";
+import type { HttpContext } from "./HttpContext.js";
+export declare class ViewRenderer extends Component {
+    private readonly i18nService;
+    private readonly templateService;
+    private readonly customTemplateService;
+    private readonly modules;
+    static [INJECT]: (typeof ModuleDefinitions | typeof TemplateService | typeof BaseTemplateService | typeof I18nService)[];
+    constructor(i18nService: I18nService, templateService: BaseTemplateService, customTemplateService: TemplateService, modules: ModuleDefinitions);
+    computeLocale(req: Request): import("./contrib/accept-language-parser.js").Locale;
+    render(ctx: HttpContext, view: string | string[], data?: Record<string, any>): Promise<import("undici-types").Response>;
+    private renderTemplate;
+}

package/dist/ViewRenderer.js

@@ -0,0 +1,59 @@
+import { Component, INJECT } from "./Component.js";
+import { BaseTemplateService, TemplateService } from "./TemplateService.js";
+import { I18nService } from "./I18nService.js";
+import { pick } from "./contrib/accept-language-parser.js";
+import { ModuleDefinitions } from "./Module.js";
+import { isProduction } from "./utils/isProduction.js";
+export class ViewRenderer extends Component {
+    i18nService;
+    templateService;
+    customTemplateService;
+    modules;
+    static [INJECT] = [
+        I18nService,
+        BaseTemplateService,
+        TemplateService,
+        ModuleDefinitions,
+    ];
+    constructor(i18nService, templateService, customTemplateService, modules) {
+        super();
+        this.i18nService = i18nService;
+        this.templateService = templateService;
+        this.customTemplateService = customTemplateService;
+        this.modules = modules;
+    }
+    computeLocale(req) {
+        return pick(this.i18nService.availableLocales(), req.headers.get("accept-language") || "");
+    }
+    async render(ctx, view, data = {}) {
+        const templates = Array.isArray(view) ? view.reverse() : [view];
+        data.TITLE = "Tymber";
+        data.CTX = ctx;
+        data.CTX.app = data.CTX.app || {};
+        data.CTX.app.isProduction = isProduction;
+        data.CTX.app.modules = this.modules.modules;
+        data.$t = (key, ...args) => {
+            return this.i18nService.translate(ctx, ctx.locale, key, ...args);
+        };
+        for (const template of templates) {
+            data.VIEW = await this.renderTemplate(template, data);
+        }
+        return new Response(data.VIEW, {
+            headers: {
+                "content-type": "text/html",
+                "cache-control": "no-cache",
+            },
+        });
+    }
+    renderTemplate(templateName, data) {
+        if (this.customTemplateService.canRender(templateName)) {
+            return this.customTemplateService.render(templateName, data);
+        }
+        else if (this.templateService.canRender(templateName)) {
+            return this.templateService.render(templateName, data);
+        }
+        else {
+            throw new Error(`template ${templateName} not found`);
+        }
+    }
+}

package/dist/contrib/accept-language-parser.d.ts

@@ -0,0 +1,9 @@
+import { type Brand } from "../utils/types.js";
+export type Locale = Brand<string, "Locale">;
+export declare function parse(al: string): ({
+    code: string;
+    script: string | null;
+    region: string;
+    quality: number;
+} | undefined)[];
+export declare function pick(supportedLanguages: string[], acceptLanguage: any, options?: any): Locale;

package/dist/contrib/accept-language-parser.js

@@ -0,0 +1,73 @@
+// from https://github.com/opentable/accept-language-parser
+import {} from "../utils/types.js";
+var regex = /((([a-zA-Z]+(-[a-zA-Z0-9]+){0,2})|\*)(;q=[0-1](\.[0-9]+)?)?)*/g;
+var isString = function (s) {
+    return typeof s === "string";
+};
+export function parse(al) {
+    var strings = (al || "").match(regex);
+    return strings
+        .map(function (m) {
+        if (!m) {
+            return;
+        }
+        var bits = m.split(";");
+        var ietf = bits[0].split("-");
+        var hasScript = ietf.length === 3;
+        return {
+            code: ietf[0],
+            script: hasScript ? ietf[1] : null,
+            region: hasScript ? ietf[2] : ietf[1],
+            quality: bits[1] ? parseFloat(bits[1].split("=")[1]) : 1.0,
+        };
+    })
+        .filter(function (r) {
+        return r;
+    })
+        .sort(function (a, b) {
+        return b.quality - a.quality;
+    });
+}
+export function pick(supportedLanguages, acceptLanguage, options) {
+    options = options || {};
+    // if (!supportedLanguages || !supportedLanguages.length || !acceptLanguage) {
+    //   return null;
+    // }
+    if (!acceptLanguage) {
+        return supportedLanguages[0]; // pick first as default
+    }
+    if (isString(acceptLanguage)) {
+        acceptLanguage = parse(acceptLanguage);
+    }
+    var supported = supportedLanguages.map(function (support) {
+        var bits = support.split("-");
+        var hasScript = bits.length === 3;
+        return {
+            code: bits[0],
+            script: hasScript ? bits[1] : null,
+            region: hasScript ? bits[2] : bits[1],
+        };
+    });
+    for (var i = 0; i < acceptLanguage.length; i++) {
+        var lang = acceptLanguage[i];
+        var langCode = lang.code.toLowerCase();
+        var langRegion = lang.region ? lang.region.toLowerCase() : lang.region;
+        var langScript = lang.script ? lang.script.toLowerCase() : lang.script;
+        for (var j = 0; j < supported.length; j++) {
+            var supportedCode = supported[j].code.toLowerCase();
+            var supportedScript = supported[j].script
+                ? supported[j].script.toLowerCase()
+                : supported[j].script;
+            var supportedRegion = supported[j].region
+                ? supported[j].region.toLowerCase()
+                : supported[j].region;
+            if (langCode === supportedCode &&
+                (options.loose || !langScript || langScript === supportedScript) &&
+                (options.loose || !langRegion || langRegion === supportedRegion)) {
+                return supportedLanguages[j];
+            }
+        }
+    }
+    // return null;
+    return supportedLanguages[0]; // pick first as default
+}

package/dist/contrib/cookie.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Module variables.
+ * @private
+ */
+/**
+ * Parse a cookie header.
+ *
+ * Parse the given cookie header string into an object
+ * The object has the various cookies as keys(names) => values
+ *
+ * @param {string} str
+ * @param {object} [options]
+ * @return {object}
+ * @public
+ */
+declare function parse(str: string, options?: any): Record<string, string>;
+/**
+ * Serialize data into a cookie header.
+ *
+ * Serialize the a name value pair into a cookie string suitable for
+ * http headers. An optional options object specified cookie parameters.
+ *
+ * serialize('foo', 'bar', { httpOnly: true })
+ *   => "foo=bar; httpOnly"
+ *
+ * @param {string} name
+ * @param {string} val
+ * @param {object} [options]
+ * @return {string}
+ * @public
+ */
+declare function serialize(name: string, val: string, options: any): string;
+export { parse as parseCookieHeader, serialize as createCookie };

package/dist/contrib/cookie.js

@@ -0,0 +1,207 @@
+// from https://www.npmjs.com/package/cookie
+/**
+ * Module variables.
+ * @private
+ */
+var __toString = Object.prototype.toString;
+/**
+ * RegExp to match field-content in RFC 7230 sec 3.2
+ *
+ * field-content = field-vchar [ 1*( SP / HTAB ) field-vchar ]
+ * field-vchar   = VCHAR / obs-text
+ * obs-text      = %x80-FF
+ */
+var fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
+/**
+ * Parse a cookie header.
+ *
+ * Parse the given cookie header string into an object
+ * The object has the various cookies as keys(names) => values
+ *
+ * @param {string} str
+ * @param {object} [options]
+ * @return {object}
+ * @public
+ */
+function parse(str, options) {
+    if (typeof str !== "string") {
+        throw new TypeError("argument str must be a string");
+    }
+    var obj = {};
+    var opt = options || {};
+    var dec = opt.decode || decode;
+    var index = 0;
+    while (index < str.length) {
+        var eqIdx = str.indexOf("=", index);
+        // no more cookie pairs
+        if (eqIdx === -1) {
+            break;
+        }
+        var endIdx = str.indexOf(";", index);
+        if (endIdx === -1) {
+            endIdx = str.length;
+        }
+        else if (endIdx < eqIdx) {
+            // backtrack on prior semicolon
+            index = str.lastIndexOf(";", eqIdx - 1) + 1;
+            continue;
+        }
+        var key = str.slice(index, eqIdx).trim();
+        // only assign once
+        if (undefined === obj[key]) {
+            var val = str.slice(eqIdx + 1, endIdx).trim();
+            // quoted values
+            if (val.charCodeAt(0) === 0x22) {
+                val = val.slice(1, -1);
+            }
+            obj[key] = tryDecode(val, dec);
+        }
+        index = endIdx + 1;
+    }
+    return obj;
+}
+/**
+ * Serialize data into a cookie header.
+ *
+ * Serialize the a name value pair into a cookie string suitable for
+ * http headers. An optional options object specified cookie parameters.
+ *
+ * serialize('foo', 'bar', { httpOnly: true })
+ *   => "foo=bar; httpOnly"
+ *
+ * @param {string} name
+ * @param {string} val
+ * @param {object} [options]
+ * @return {string}
+ * @public
+ */
+function serialize(name, val, options) {
+    var opt = options || {};
+    var enc = opt.encode || encode;
+    if (typeof enc !== "function") {
+        throw new TypeError("option encode is invalid");
+    }
+    if (!fieldContentRegExp.test(name)) {
+        throw new TypeError("argument name is invalid");
+    }
+    var value = enc(val);
+    if (value && !fieldContentRegExp.test(value)) {
+        throw new TypeError("argument val is invalid");
+    }
+    var str = name + "=" + value;
+    if (null != opt.maxAge) {
+        var maxAge = opt.maxAge - 0;
+        if (isNaN(maxAge) || !isFinite(maxAge)) {
+            throw new TypeError("option maxAge is invalid");
+        }
+        str += "; Max-Age=" + Math.floor(maxAge);
+    }
+    if (opt.domain) {
+        if (!fieldContentRegExp.test(opt.domain)) {
+            throw new TypeError("option domain is invalid");
+        }
+        str += "; Domain=" + opt.domain;
+    }
+    if (opt.path) {
+        if (!fieldContentRegExp.test(opt.path)) {
+            throw new TypeError("option path is invalid");
+        }
+        str += "; Path=" + opt.path;
+    }
+    if (opt.expires) {
+        var expires = opt.expires;
+        if (!isDate(expires) || isNaN(expires.valueOf())) {
+            throw new TypeError("option expires is invalid");
+        }
+        str += "; Expires=" + expires.toUTCString();
+    }
+    if (opt.httpOnly) {
+        str += "; HttpOnly";
+    }
+    if (opt.secure) {
+        str += "; Secure";
+    }
+    if (opt.priority) {
+        var priority = typeof opt.priority === "string"
+            ? opt.priority.toLowerCase()
+            : opt.priority;
+        switch (priority) {
+            case "low":
+                str += "; Priority=Low";
+                break;
+            case "medium":
+                str += "; Priority=Medium";
+                break;
+            case "high":
+                str += "; Priority=High";
+                break;
+            default:
+                throw new TypeError("option priority is invalid");
+        }
+    }
+    if (opt.sameSite) {
+        var sameSite = typeof opt.sameSite === "string"
+            ? opt.sameSite.toLowerCase()
+            : opt.sameSite;
+        switch (sameSite) {
+            case true:
+                str += "; SameSite=Strict";
+                break;
+            case "lax":
+                str += "; SameSite=Lax";
+                break;
+            case "strict":
+                str += "; SameSite=Strict";
+                break;
+            case "none":
+                str += "; SameSite=None";
+                break;
+            default:
+                throw new TypeError("option sameSite is invalid");
+        }
+    }
+    return str;
+}
+/**
+ * URL-decode string value. Optimized to skip native call when no %.
+ *
+ * @param {string} str
+ * @returns {string}
+ */
+function decode(str) {
+    return str.indexOf("%") !== -1 ? decodeURIComponent(str) : str;
+}
+/**
+ * URL-encode value.
+ *
+ * @param {string} str
+ * @returns {string}
+ */
+function encode(val) {
+    return encodeURIComponent(val);
+}
+/**
+ * Determine if value is a Date.
+ *
+ * @param {*} val
+ * @private
+ */
+function isDate(val) {
+    return __toString.call(val) === "[object Date]" || val instanceof Date;
+}
+/**
+ * Try decoding a string using a decoding function.
+ *
+ * @param {string} str
+ * @param {function} decode
+ * @private
+ */
+function tryDecode(str, decode) {
+    try {
+        return decode(str);
+    }
+    catch (e) {
+        return str;
+    }
+}
+export { parse as parseCookieHeader, serialize as createCookie };

package/dist/contrib/template.d.ts

@@ -0,0 +1 @@
+export declare function compileTemplate(text: string): (data: any) => string;

package/dist/contrib/template.js

@@ -0,0 +1,107 @@
+// from https://github.com/jashkenas/underscore/blob/master/modules/template.js
+const escapeMap = {
+    "&": "&",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+};
+const ESCAPE_REGEX = /[&<>"]/g;
+const _ = {
+    escape(s) {
+        return s.replace(ESCAPE_REGEX, (match) => escapeMap[match]);
+    },
+};
+// When customizing `_.templateSettings`, if you don't want to define an
+// interpolation, evaluation or escaping regex, we need one that is
+// guaranteed not to match.
+var noMatch = /(.)^/;
+// Certain characters need to be escaped so that they can be put into a
+// string literal.
+var escapes = {
+    "'": "'",
+    "\\": "\\",
+    "\r": "r",
+    "\n": "n",
+    "\u2028": "u2028",
+    "\u2029": "u2029",
+};
+var escapeRegExp = /\\|'|\r|\n|\u2028|\u2029/g;
+function escapeChar(match) {
+    return "\\" + escapes[match];
+}
+// In order to prevent third-party code injection through
+// `_.templateSettings.variable`, we test it against the following regular
+// expression. It is intentionally a bit more liberal than just matching valid
+// identifiers, but still prevents possible loopholes through defaults or
+// destructuring assignment.
+var bareIdentifier = /^\s*(\w|\$)+\s*$/;
+// JavaScript micro-templating, similar to John Resig's implementation.
+// Underscore templating handles arbitrary delimiters, preserves whitespace,
+// and correctly escapes quotes within interpolated code.
+// NB: `oldSettings` only exists for backwards compatibility.
+export function compileTemplate(text) {
+    const settings = {
+        evaluate: /<%([\s\S]+?)%>/g,
+        interpolate: /<%=([\s\S]+?)%>/g,
+        escape: /<%-([\s\S]+?)%>/g,
+    };
+    // Combine delimiters into one regular expression via alternation.
+    var matcher = RegExp([
+        (settings.escape || noMatch).source,
+        (settings.interpolate || noMatch).source,
+        (settings.evaluate || noMatch).source,
+    ].join("|") + "|$", "g");
+    // Compile the template source, escaping string literals appropriately.
+    var index = 0;
+    var source = "__p+='";
+    text.replace(matcher, function (match, escape, interpolate, evaluate, offset) {
+        source += text.slice(index, offset).replace(escapeRegExp, escapeChar);
+        index = offset + match.length;
+        if (escape) {
+            source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
+        }
+        else if (interpolate) {
+            source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
+        }
+        else if (evaluate) {
+            source += "';\n" + evaluate + "\n__p+='";
+        }
+        // Adobe VMs need the match returned to produce the correct offset.
+        return match;
+    });
+    source += "';\n";
+    // @ts-expect-error unknown property
+    var argument = settings.variable;
+    if (argument) {
+        // Insure against third-party code injection. (CVE-2021-23358)
+        if (!bareIdentifier.test(argument))
+            throw new Error("variable is not a bare identifier: " + argument);
+    }
+    else {
+        // If a variable is not specified, place data values in local scope.
+        source = "with(obj||{}){\n" + source + "}\n";
+        argument = "obj";
+    }
+    source =
+        "var __t,__p='',__j=Array.prototype.join," +
+            "print=function(){__p+=__j.call(arguments,'');};\n" +
+            source +
+            "return __p;\n";
+    var render;
+    try {
+        render = new Function(argument, "_", source);
+    }
+    catch (e) {
+        // @ts-expect-error unknown property
+        e.source = source;
+        throw e;
+    }
+    var template = function (data) {
+        // @ts-expect-error unknown this
+        return render.call(this, data, _);
+    };
+    // Provide the compiled source as a convenience for precompilation.
+    // @ts-expect-error unknown property
+    template.source = "function(" + argument + "){\n" + source + "}";
+    return template;
+}

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+export { Component, type Ctor, ComponentFactory, INJECT } from "./Component.js";
+export { type InternalUserId, type UserId, type InternalGroupId, type GroupId, type Role, type ConnectedUser, type AdminUserId, type Admin, type Context, emptyContext, } from "./Context.js";
+export { ConfigService } from "./ConfigService.js";
+export { DB, DuplicateKeyError } from "./DB.js";
+export { EventEmitter } from "./EventEmitter.js";
+export { PubSubService, NodeClusterPubSubService, initPrimary, } from "./PubSubService.js";
+export { I18nService } from "./I18nService.js";
+export { Endpoint, AdminEndpoint } from "./Endpoint.js";
+export { type HttpContext } from "./HttpContext.js";
+export { App } from "./App.js";
+export { type Module, type AppInit, ModuleDefinitions, type Route, } from "./Module.js";
+export { View, AdminView } from "./View.js";
+export { Middleware } from "./Middleware.js";
+export { Repository, type Page, EntityNotFoundError } from "./Repository.js";
+export { TemplateService } from "./TemplateService.js";
+export { createCookie, parseCookieHeader } from "./contrib/cookie.js";
+export { AJV_INSTANCE } from "./utils/ajv.js";
+export { camelToSnakeCase } from "./utils/camelToSnakeCase.js";
+export { createDebug } from "./utils/createDebug.js";
+export { createTestApp, type BaseTestContext } from "./utils/createTestApp.js";
+export { escapeValue } from "./utils/escapeValue.js";
+export { FS } from "./utils/fs.js";
+export { isAdmin } from "./utils/isAdmin.js";
+export { isProduction } from "./utils/isProduction.js";
+export { randomId } from "./utils/randomId.js";
+export { randomUUID } from "./utils/randomUUID.js";
+export { snakeToCamelCase } from "./utils/snakeToCamelCase.js";
+export { sortBy } from "./utils/sortBy.js";
+export { sql, Statement } from "./utils/sql.js";
+export { toNodeHandler } from "./utils/toNodeHandler.js";
+export { type Brand } from "./utils/types.js";
+export { waitFor } from "./utils/waitFor.js";