@tymber/common 0.0.1-alpha.0 → 0.1.0

package/dist/Endpoint.js

@@ -0,0 +1,87 @@
+import {} from "./HttpContext.js";
+import {} from "ajv";
+import { Handler } from "./Handler.js";
+import { AJV_INSTANCE } from "./utils/ajv.js";
+function formatErrors(errors) {
+    return errors.map((error) => ({
+        keyword: error.keyword,
+        message: error.message,
+    }));
+}
+class BaseEndpoint extends Handler {
+    pathParamsSchema; // JSONSchemaType<Params>;
+    querySchema; // JSONSchemaType<Query>;
+    payloadSchema; // JSONSchemaType<Payload>;
+    validatePathParams;
+    validateQuery;
+    validatePayload;
+    doHandle(ctx) {
+        const { pathParams, query, payload } = ctx;
+        if (this.pathParamsSchema && !this.validatePathParams) {
+            this.validatePathParams = AJV_INSTANCE.compile(this.pathParamsSchema);
+        }
+        if (this.validatePathParams && !this.validatePathParams(pathParams)) {
+            return this.badRequest("invalid path params", {
+                errors: formatErrors(this.validatePathParams.errors),
+            });
+        }
+        if (this.querySchema && !this.validateQuery) {
+            this.validateQuery = AJV_INSTANCE.compile(this.querySchema);
+        }
+        if (this.validateQuery && !this.validateQuery(query)) {
+            return this.badRequest("invalid query params", {
+                errors: formatErrors(this.validateQuery.errors),
+            });
+        }
+        if (this.payloadSchema && !this.validatePayload) {
+            this.validatePayload = AJV_INSTANCE.compile(this.payloadSchema);
+        }
+        if (this.validatePayload && !this.validatePayload(payload)) {
+            return this.badRequest("invalid payload", {
+                errors: formatErrors(this.validatePayload.errors),
+            });
+        }
+        if (!this.hasPermission(ctx)) {
+            return Response.json({
+                message: "forbidden",
+            }, {
+                status: 403,
+            });
+        }
+        return this.handle(ctx);
+    }
+    badRequest(message, details) {
+        return Response.json({
+            message,
+            ...details,
+        }, {
+            status: 400,
+        });
+    }
+}
+export class Endpoint extends BaseEndpoint {
+    _endpointBrand; // nominal typing
+    doHandle(ctx) {
+        if (!this.allowAnonymous && !ctx.user) {
+            return Response.json({
+                message: "unauthorized",
+            }, {
+                status: 401,
+            });
+        }
+        return super.doHandle(ctx);
+    }
+}
+export class AdminEndpoint extends BaseEndpoint {
+    _adminEndpointBrand; // nominal typing
+    doHandle(ctx) {
+        if (!this.allowAnonymous && !ctx.admin) {
+            return Response.json({
+                message: "unauthorized",
+            }, {
+                status: 401,
+            });
+        }
+        return super.doHandle(ctx);
+    }
+}

package/dist/EventEmitter.d.ts

@@ -0,0 +1,9 @@
+type EventMap = Record<string, any>;
+type EventKey<T extends EventMap> = string & keyof T;
+type EventCallback<T> = (payload: T) => void;
+export declare class EventEmitter<Events extends EventMap> {
+    private listeners;
+    on<K extends EventKey<Events>>(event: K, callback: EventCallback<Events[K]>): void;
+    emit<K extends EventKey<Events>>(event: K, payload: Events[K]): void;
+}
+export {};

package/dist/EventEmitter.js

@@ -0,0 +1,21 @@
+import { createDebug } from "./utils/createDebug.js";
+const debug = createDebug("EventEmitter");
+export class EventEmitter {
+    listeners = new Map();
+    on(event, callback) {
+        debug("subscribing to event %s", event);
+        if (!this.listeners.has(event)) {
+            this.listeners.set(event, []);
+        }
+        this.listeners
+            .get(event)
+            .push(callback);
+    }
+    emit(event, payload) {
+        debug("emitting event %s", event);
+        const callbacks = this.listeners.get(event);
+        if (callbacks) {
+            callbacks.forEach((callback) => callback(payload));
+        }
+    }
+}

package/dist/Handler.d.ts

@@ -0,0 +1,8 @@
+import { Component } from "./Component.js";
+import { type HttpContext } from "./HttpContext.js";
+export declare abstract class Handler extends Component {
+    protected allowAnonymous: boolean;
+    protected hasPermission(ctx: HttpContext): boolean;
+    abstract doHandle(ctx: HttpContext): Response | Promise<Response>;
+    protected abstract handle(ctx: HttpContext): Response | Promise<Response>;
+}

package/dist/Handler.js

@@ -0,0 +1,8 @@
+import { Component } from "./Component.js";
+import {} from "./HttpContext.js";
+export class Handler extends Component {
+    allowAnonymous = false;
+    hasPermission(ctx) {
+        return true;
+    }
+}

package/dist/HttpContext.d.ts

@@ -0,0 +1,26 @@
+import { type Context } from "./Context.js";
+import { type HttpMethod } from "./Router.js";
+import { type Locale } from "./contrib/accept-language-parser.js";
+export interface HttpContext<Payload = any, PathParams = any, QueryParams = any> extends Context {
+    method: HttpMethod;
+    payload: Payload;
+    path: string;
+    pathParams: PathParams;
+    query: QueryParams;
+    headers: Headers;
+    cookies: Record<string, string>;
+    abortSignal: AbortSignal;
+    locale: Locale;
+    responseHeaders: Headers;
+    sessionId?: string;
+    adminSessionId?: string;
+    render: (view: string | string[], data?: Record<string, any>) => Promise<Response>;
+    redirect(path: string, type?: HttpRedirectCode): Response;
+}
+export declare enum HttpRedirectCode {
+    HTTP_301_MOVED_PERMANENTLY = 301,
+    HTTP_302_FOUND = 302,
+    HTTP_303_SEE_OTHER = 303,
+    HTTP_307_TEMPORARY_REDIRECT = 307,
+    HTTP_308_PERMANENT_REDIRECT = 308
+}

package/dist/HttpContext.js

@@ -0,0 +1,11 @@
+import {} from "./Context.js";
+import {} from "./Router.js";
+import {} from "./contrib/accept-language-parser.js";
+export var HttpRedirectCode;
+(function (HttpRedirectCode) {
+    HttpRedirectCode[HttpRedirectCode["HTTP_301_MOVED_PERMANENTLY"] = 301] = "HTTP_301_MOVED_PERMANENTLY";
+    HttpRedirectCode[HttpRedirectCode["HTTP_302_FOUND"] = 302] = "HTTP_302_FOUND";
+    HttpRedirectCode[HttpRedirectCode["HTTP_303_SEE_OTHER"] = 303] = "HTTP_303_SEE_OTHER";
+    HttpRedirectCode[HttpRedirectCode["HTTP_307_TEMPORARY_REDIRECT"] = 307] = "HTTP_307_TEMPORARY_REDIRECT";
+    HttpRedirectCode[HttpRedirectCode["HTTP_308_PERMANENT_REDIRECT"] = 308] = "HTTP_308_PERMANENT_REDIRECT";
+})(HttpRedirectCode || (HttpRedirectCode = {}));

package/dist/I18nService.d.ts

@@ -0,0 +1,18 @@
+import { type Locale } from "./contrib/accept-language-parser.js";
+import { ModuleDefinitions } from "./Module.js";
+import { Component, INJECT } from "./Component.js";
+import type { Context } from "./Context.js";
+export declare abstract class I18nService extends Component {
+    abstract availableLocales(): Locale[];
+    abstract translate(ctx: Context, locale: Locale, key: string, ...args: any[]): string;
+}
+export declare class BaseI18nService extends I18nService {
+    private readonly modules;
+    static [INJECT]: (typeof ModuleDefinitions)[];
+    private readonly translations;
+    constructor(modules: ModuleDefinitions);
+    init(): Promise<void>;
+    private loadTranslations;
+    availableLocales(): Locale[];
+    translate(_ctx: Context, locale: Locale, key: string, ...args: any[]): string;
+}

package/dist/I18nService.js

@@ -0,0 +1,72 @@
+import {} from "./contrib/accept-language-parser.js";
+import { ModuleDefinitions } from "./Module.js";
+import { compileTemplate } from "./contrib/template.js";
+import { Component, INJECT } from "./Component.js";
+import { FS } from "./utils/fs.js";
+function flatten(obj) {
+    const output = {};
+    function flattenRecursively(curr, parentKey) {
+        if (typeof curr === "object" && curr !== null && !Array.isArray(curr)) {
+            for (const key in curr) {
+                flattenRecursively(curr[key], parentKey ? `${parentKey}.${key}` : key);
+            }
+        }
+        else {
+            output[parentKey] = curr;
+        }
+    }
+    flattenRecursively(obj, "");
+    return output;
+}
+export class I18nService extends Component {
+}
+export class BaseI18nService extends I18nService {
+    modules;
+    static [INJECT] = [ModuleDefinitions];
+    translations = new Map();
+    constructor(modules) {
+        super();
+        this.modules = modules;
+    }
+    init() {
+        return this.loadTranslations();
+    }
+    async loadTranslations() {
+        try {
+            for (const module of this.modules.modules) {
+                if (!module.assetsDir) {
+                    continue;
+                }
+                for (const filename of await FS.readDirRecursively(FS.join(module.assetsDir, "i18n"))) {
+                    if (!filename.endsWith(".json")) {
+                        continue;
+                    }
+                    const content = await FS.readFile(FS.join(module.assetsDir, "i18n", filename));
+                    const locale = filename.slice(0, -5);
+                    const values = JSON.parse(content);
+                    let localizedTranslations = this.translations.get(locale);
+                    if (!localizedTranslations) {
+                        this.translations.set(locale, (localizedTranslations = new Map()));
+                    }
+                    const flatTranslations = flatten(values);
+                    for (const [key, value] of Object.entries(flatTranslations)) {
+                        localizedTranslations.set(key, value);
+                    }
+                }
+            }
+        }
+        catch (e) { }
+    }
+    availableLocales() {
+        return Array.from(this.translations.keys());
+    }
+    translate(_ctx, locale, key, ...args) {
+        const value = this.translations.get(locale)?.get(key);
+        if (value && value.includes("<%")) {
+            return compileTemplate(value)(args);
+        }
+        else {
+            return value || "";
+        }
+    }
+}

package/dist/Middleware.d.ts

@@ -0,0 +1,6 @@
+import type { HttpContext } from "./HttpContext.js";
+import { Component } from "./Component.js";
+export declare abstract class Middleware extends Component {
+    private _middlewareBrand;
+    abstract handle(ctx: HttpContext): void | Response | Promise<void | Response>;
+}

package/dist/Middleware.js

@@ -0,0 +1,4 @@
+import { Component } from "./Component.js";
+export class Middleware extends Component {
+    _middlewareBrand; // nominal typing
+}

package/dist/Module.d.ts

@@ -0,0 +1,47 @@
+import { Component, type Ctor } from "./Component.js";
+import type { HttpMethod } from "./Router.js";
+import { AdminEndpoint, Endpoint } from "./Endpoint.js";
+import { AdminView, View } from "./View.js";
+import { Middleware } from "./Middleware.js";
+import { type Handler } from "./Handler.js";
+export interface AdminSidebarItem {
+    label: string;
+    icon: string;
+    path: string;
+}
+export interface Module {
+    name: string;
+    version: string;
+    assetsDir?: string;
+    adminSidebarItems?: AdminSidebarItem[];
+    init(app: AppInit): void;
+}
+export interface AppInit {
+    component<T extends Component>(ctor: Ctor<T>): void;
+    endpoint(method: HttpMethod, path: string, ctor: Ctor<Endpoint>): void;
+    view(path: string, ctor: Ctor<View>): void;
+    adminEndpoint(method: HttpMethod, path: string, ctor: Ctor<AdminEndpoint>): void;
+    adminView(path: string, ctor: Ctor<AdminView>): void;
+    middleware(ctor: Ctor<Middleware>): void;
+}
+export interface Route {
+    method: HttpMethod;
+    path: string;
+    handlerName: string;
+    handler: Handler;
+}
+export interface ModuleDefinition {
+    name: string;
+    version: string;
+    assetsDir?: string;
+    adminSidebarItems?: AdminSidebarItem[];
+    endpoints: Route[];
+    views: Route[];
+    adminEndpoints: Route[];
+    adminViews: Route[];
+    middlewares: Middleware[];
+}
+export declare class ModuleDefinitions extends Component {
+    readonly modules: ModuleDefinition[];
+    constructor(modules: ModuleDefinition[]);
+}

package/dist/Module.js

@@ -0,0 +1,12 @@
+import { Component } from "./Component.js";
+import { AdminEndpoint, Endpoint } from "./Endpoint.js";
+import { AdminView, View } from "./View.js";
+import { Middleware } from "./Middleware.js";
+import {} from "./Handler.js";
+export class ModuleDefinitions extends Component {
+    modules;
+    constructor(modules) {
+        super();
+        this.modules = modules;
+    }
+}

package/dist/PubSubService.d.ts

@@ -0,0 +1,20 @@
+import { Component } from "./Component.js";
+import type { Context } from "./Context.js";
+interface Message {
+    from: string;
+    type: string;
+    payload?: any;
+}
+export declare class PubSubService extends Component {
+    protected readonly id: string;
+    private eventEmitter;
+    publish(_ctx: Context, _type: string, _payload?: any): void;
+    subscribe<T>(type: string, handler: (payload: T) => void): void;
+    protected onMessage(message: Message): void;
+}
+export declare class NodeClusterPubSubService extends PubSubService {
+    constructor();
+    publish(_ctx: Context, type: string, payload?: any): void;
+}
+export declare function initPrimary(): void;
+export {};

package/dist/PubSubService.js

@@ -0,0 +1,60 @@
+import { Component } from "./Component.js";
+import { createDebug } from "./utils/createDebug.js";
+import { EventEmitter } from "./EventEmitter.js";
+import cluster from "node:cluster";
+import { randomId } from "./utils/randomId.js";
+const debug = createDebug("PubSubService");
+export class PubSubService extends Component {
+    id = randomId();
+    eventEmitter = new EventEmitter();
+    publish(_ctx, _type, _payload) {
+        // noop
+    }
+    subscribe(type, handler) {
+        this.eventEmitter.on(type, handler);
+    }
+    onMessage(message) {
+        if (message.from === this.id) {
+            debug("ignore message from self");
+            return;
+        }
+        debug("received message %s", message.type);
+        this.eventEmitter.emit(message.type, message.payload);
+    }
+}
+function ignoreError() { }
+export class NodeClusterPubSubService extends PubSubService {
+    constructor() {
+        super();
+        if (!cluster.isWorker) {
+            throw "not worker";
+        }
+        process.on("message", (message) => this.onMessage(message));
+    }
+    publish(_ctx, type, payload) {
+        if (typeof process.send !== "function") {
+            return;
+        }
+        debug("sending message %s", type);
+        const message = {
+            from: this.id,
+            type,
+            payload,
+        };
+        process.send(message, undefined, {}, ignoreError);
+    }
+}
+export function initPrimary() {
+    if (!cluster.isPrimary) {
+        throw "not primary";
+    }
+    cluster.on("message", (worker, message) => {
+        const emitterId = String(worker.id);
+        debug("forwarding message %s to other workers", message.type);
+        for (const workerId in cluster.workers) {
+            if (workerId !== emitterId) {
+                cluster.workers[workerId]?.send(message, ignoreError);
+            }
+        }
+    });
+}

package/dist/Repository.d.ts

@@ -0,0 +1,29 @@
+import { Component, INJECT } from "./Component.js";
+import { DB } from "./DB.js";
+import type { Context } from "./Context.js";
+import { Statement } from "./utils/sql.js";
+export declare class EntityNotFoundError extends Error {
+}
+export declare abstract class Repository<ID, T extends Record<string, any>> extends Component {
+    protected readonly db: DB;
+    static [INJECT]: (typeof DB)[];
+    protected abstract tableName: string;
+    protected idField: string | string[];
+    protected dateFields: string[];
+    constructor(db: DB);
+    findById(ctx: Context, id: ID): Promise<T | undefined>;
+    deleteById(ctx: Context, id: ID): Promise<void>;
+    private idClause;
+    save(ctx: Context, entity: Partial<T>): Promise<T>;
+    startTransaction(ctx: Context, fn: () => Promise<void>): void | Promise<void>;
+    protected one(ctx: Context, query: Statement): Promise<T | undefined>;
+    protected all(ctx: Context, query: Statement): Promise<T[]>;
+    protected count(ctx: Context, countQuery: Statement): Promise<number>;
+    protected toRow(entity: Partial<T>): Record<string, any>;
+    protected toEntity(row: Record<string, any>): T;
+    protected onBeforeInsert(ctx: Context, entity: Partial<T>): void;
+    protected onBeforeUpdate(ctx: Context, entity: Partial<T>): void;
+}
+export interface Page<T> {
+    items: T[];
+}

package/dist/Repository.js

@@ -0,0 +1,110 @@
+import { camelToSnakeCase } from "./utils/camelToSnakeCase.js";
+import { snakeToCamelCase } from "./utils/snakeToCamelCase.js";
+import { Component, INJECT } from "./Component.js";
+import { DB } from "./DB.js";
+import { sql, Statement } from "./utils/sql.js";
+export class EntityNotFoundError extends Error {
+}
+export class Repository extends Component {
+    db;
+    static [INJECT] = [DB];
+    idField = "id";
+    dateFields = [];
+    constructor(db) {
+        super();
+        this.db = db;
+    }
+    findById(ctx, id) {
+        const query = sql.select().from(this.tableName).where(this.idClause(id));
+        return this.one(ctx, query);
+    }
+    async deleteById(ctx, id) {
+        const query = sql.deleteFrom(this.tableName).where(this.idClause(id));
+        const res = await this.db.run(ctx, query);
+        if (res.affectedRows !== 1) {
+            throw new EntityNotFoundError();
+        }
+    }
+    idClause(id) {
+        if (Array.isArray(this.idField)) {
+            return this.idField.reduce((acc, k) => {
+                // @ts-expect-error
+                acc[camelToSnakeCase(k)] = id[k];
+                return acc;
+            }, {});
+        }
+        else {
+            return {
+                [camelToSnakeCase(this.idField)]: id,
+            };
+        }
+    }
+    async save(ctx, entity) {
+        const idFields = Array.isArray(this.idField)
+            ? this.idField
+            : [this.idField];
+        const isIDSpecified = idFields.every((idField) => entity[idField] !== undefined);
+        if (isIDSpecified) {
+            const idClause = {};
+            idFields.forEach((idField) => {
+                idClause[camelToSnakeCase(idField)] = entity[idField];
+            });
+            this.onBeforeUpdate(ctx, entity);
+            const { affectedRows } = await this.db.run(ctx, sql.update(this.tableName).set(this.toRow(entity)).where(idClause));
+            if (affectedRows > 1) {
+                throw "unexpected number of updated rows";
+            }
+            else if (affectedRows === 1) {
+                return entity;
+            }
+        }
+        this.onBeforeInsert(ctx, entity);
+        const rows = await this.db.query(ctx, sql
+            .insert()
+            .into(this.tableName)
+            .values([this.toRow(entity)])
+            .returning(idFields.map((idField) => camelToSnakeCase(idField))));
+        if (rows.length !== 1) {
+            throw "unexpected number of inserted rows";
+        }
+        Object.assign(entity, this.toEntity(rows[0]));
+        return entity;
+    }
+    startTransaction(ctx, fn) {
+        return this.db.startTransaction(ctx, fn);
+    }
+    async one(ctx, query) {
+        const rows = await this.db.query(ctx, query);
+        return rows.length === 1 ? this.toEntity(rows[0]) : undefined;
+    }
+    async all(ctx, query) {
+        const rows = await this.db.query(ctx, query);
+        return rows.map((row) => this.toEntity(row));
+    }
+    async count(ctx, countQuery) {
+        const rows = await this.db.query(ctx, countQuery);
+        return parseInt(rows[0].count, 10);
+    }
+    toRow(entity) {
+        const row = {};
+        Object.keys(entity).forEach((key) => {
+            row[camelToSnakeCase(key)] = entity[key];
+        });
+        return row;
+    }
+    toEntity(row) {
+        const entity = {};
+        Object.keys(row).forEach((key) => {
+            const fieldName = snakeToCamelCase(key);
+            let fieldValue = row[key];
+            if (this.dateFields.includes(fieldName) &&
+                typeof fieldValue === "number") {
+                fieldValue = new Date(fieldValue);
+            }
+            entity[fieldName] = fieldValue;
+        });
+        return entity;
+    }
+    onBeforeInsert(ctx, entity) { }
+    onBeforeUpdate(ctx, entity) { }
+}

package/dist/Router.d.ts

@@ -0,0 +1,10 @@
+import { Handler } from "./Handler.js";
+export type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "HEAD";
+export declare class Router {
+    private routes;
+    registerRoute(method: HttpMethod, path: string, handler: Handler): void;
+    findRoute(method: HttpMethod, path: string): {
+        handler: Handler;
+        pathParams: Record<string, string>;
+    } | undefined;
+}

package/dist/Router.js

@@ -0,0 +1,53 @@
+import { Handler } from "./Handler.js";
+function createMatcher(path) {
+    if (!path.includes(":")) {
+        return (p) => {
+            return p === path ? {} : undefined;
+        };
+    }
+    const pathParams = [];
+    const regex = new RegExp("^" +
+        path.replace(/:(\w+)/g, (pathParam) => {
+            pathParams.push(pathParam.substring(1));
+            return "([\\w-_]+)";
+        }) +
+        "$");
+    return (path) => {
+        const match = regex.exec(path);
+        if (!match) {
+            return;
+        }
+        const params = {};
+        for (let i = 0; i < pathParams.length; i++) {
+            params[pathParams[i]] = match[i + 1];
+        }
+        return params;
+    };
+}
+export class Router {
+    routes = [];
+    registerRoute(method, path, handler) {
+        for (const route of this.routes) {
+            if (route.path === path) {
+                route.handlers.set(method, handler);
+                return;
+            }
+        }
+        this.routes.push({
+            path,
+            matcher: createMatcher(path),
+            handlers: new Map([[method, handler]]),
+        });
+    }
+    findRoute(method, path) {
+        for (const route of this.routes) {
+            const pathParams = route.matcher(path);
+            if (pathParams !== undefined && route.handlers.has(method)) {
+                return {
+                    handler: route.handlers.get(method),
+                    pathParams,
+                };
+            }
+        }
+    }
+}

package/dist/TemplateService.d.ts

@@ -0,0 +1,22 @@
+import { ModuleDefinitions } from "./Module.js";
+import { Component, INJECT } from "./Component.js";
+export declare abstract class TemplateService extends Component {
+    abstract canRender(templateName: string): boolean;
+    abstract render(templateName: string, data: Record<string, any>): Promise<string>;
+}
+export declare abstract class FileBasedTemplateService extends TemplateService {
+    private readonly modules;
+    static [INJECT]: (typeof ModuleDefinitions)[];
+    abstract readonly fileExtension: string;
+    protected templates: Map<string, string>;
+    constructor(modules: ModuleDefinitions);
+    init(): Promise<void>;
+    private loadTemplates;
+    canRender(templateName: string): boolean;
+}
+export declare class BaseTemplateService extends FileBasedTemplateService {
+    fileExtension: string;
+    private compiledTemplates;
+    render(templateName: string, data: Record<string, any>): Promise<string>;
+    private getTemplate;
+}