@tymber/common 0.0.1-alpha.0 → 0.0.1

package/dist/utils/computeBaseUrl.js

@@ -0,0 +1,37 @@
+function removeQuotes(str) {
+    if (str.startsWith('"') && str.endsWith('"')) {
+        return str.slice(1, -1);
+    }
+    else {
+        return str;
+    }
+}
+function parseForwardedHeader(header) {
+    const parts = header.split(";").map((part) => part.trim());
+    const parsed = {};
+    for (const part of parts) {
+        const [key, value] = part.split("=");
+        if (key && value) {
+            parsed[key.toLowerCase()] = removeQuotes(value);
+        }
+    }
+    return `${parsed.proto}://${parsed.host}`;
+}
+export function computeBaseUrl(headers) {
+    const forwardedHeader = headers.get("forwarded");
+    if (forwardedHeader) {
+        const baseUrl = parseForwardedHeader(forwardedHeader);
+        if (baseUrl) {
+            return baseUrl;
+        }
+    }
+    const forwardedProto = headers.get("x-forwarded-proto");
+    const forwardedHost = headers.get("x-forwarded-host");
+    if (forwardedProto && forwardedHost) {
+        const proto = forwardedProto.split(",");
+        const host = forwardedHost.split(",");
+        return `${proto[0]}://${host[0]}`;
+    }
+    const host = headers.get("host");
+    return `http://${host}`;
+}

package/dist/utils/computeContentType.d.ts

@@ -0,0 +1 @@
+export declare function computeContentType(path: string): string;

package/dist/utils/computeContentType.js

@@ -0,0 +1,17 @@
+const CONTENT_TYPES = new Map([
+    ["html", "text/html"],
+    ["css", "text/css"],
+    ["js", "application/javascript"],
+    ["json", "application/json"],
+    ["png", "image/png"],
+    ["jpg", "image/jpeg"],
+    ["gif", "image/gif"],
+    ["svg", "image/svg+xml"],
+]);
+export function computeContentType(path) {
+    const i = path.lastIndexOf(".");
+    if (i === -1)
+        return "application/octet-stream";
+    const extension = path.substring(i + 1);
+    return CONTENT_TYPES.get(extension) || "application/octet-stream";
+}

package/dist/utils/createDebug.d.ts

@@ -0,0 +1 @@
+export declare function createDebug(module: string): import("util").DebugLogger;

package/dist/utils/createDebug.js

@@ -0,0 +1,4 @@
+import { debuglog } from "node:util";
+export function createDebug(module) {
+    return debuglog(`tymber:${module}`);
+}

package/dist/utils/createTestApp.d.ts

@@ -0,0 +1,8 @@
+import { DB } from "../DB.js";
+import { type Module } from "../Module.js";
+export interface BaseTestContext {
+    baseUrl: string;
+    db: DB;
+    close: () => Promise<void>;
+}
+export declare function createTestApp(initDB: () => DB | Promise<DB>, modules: Module[]): Promise<BaseTestContext>;

package/dist/utils/createTestApp.js

@@ -0,0 +1,54 @@
+import { DB } from "../DB.js";
+import { createServer, Server } from "node:http";
+import {} from "node:net";
+import {} from "../Module.js";
+import { App } from "../App.js";
+import { toNodeHandler } from "./toNodeHandler.js";
+const CLOSE_DELAY_MS = 200;
+let sharedTestContext;
+let closeTimer;
+export async function createTestApp(initDB, modules) {
+    if (!sharedTestContext) {
+        const httpServer = createServer();
+        const [port, db] = await Promise.all([
+            startHttpServer(httpServer),
+            initDB(),
+        ]);
+        const baseUrl = `http://localhost:${port}`;
+        sharedTestContext = {
+            httpServer,
+            baseUrl,
+            db,
+        };
+    }
+    const { httpServer, baseUrl, db } = sharedTestContext;
+    const app = await App.create(db, modules);
+    httpServer.removeAllListeners("request");
+    httpServer.on("request", toNodeHandler(app.fetch.bind(app)));
+    return {
+        baseUrl,
+        db,
+        async close() {
+            clearTimeout(closeTimer);
+            closeTimer = setTimeout(async () => {
+                if (sharedTestContext) {
+                    const { httpServer } = sharedTestContext;
+                    sharedTestContext = undefined;
+                    await Promise.all([closeHttpServer(httpServer), app.close()]);
+                }
+            }, CLOSE_DELAY_MS);
+        },
+    };
+}
+function startHttpServer(httpServer) {
+    return new Promise((resolve) => {
+        httpServer.listen(0, () => {
+            resolve(httpServer.address().port);
+        });
+    });
+}
+function closeHttpServer(httpServer) {
+    return new Promise((resolve) => {
+        httpServer.close(() => resolve());
+    });
+}

package/dist/utils/escapeValue.d.ts

@@ -0,0 +1 @@
+export declare function escapeValue(value: string): string;

package/dist/utils/escapeValue.js

@@ -0,0 +1,3 @@
+export function escapeValue(value) {
+    return value.replaceAll(/([~%_])/g, "~$1");
+}

package/dist/utils/fs.d.ts

@@ -0,0 +1,6 @@
+export declare const FS: {
+    join: (...paths: string[]) => string;
+    createReadStream: (path: string) => import("fs").ReadStream;
+    readFile: (path: string) => Promise<string>;
+    readDirRecursively: (path: string) => Promise<string[]>;
+};

package/dist/utils/fs.js

@@ -0,0 +1,13 @@
+import { join as nodeJoin } from "node:path";
+import { readdir, readFile as nodeReadFile } from "node:fs/promises";
+import { createReadStream as nodeCreateReadStream } from "node:fs";
+// group Node.js-specific methods
+export const FS = {
+    join: (...paths) => nodeJoin(...paths),
+    createReadStream: (path) => nodeCreateReadStream(path),
+    readFile: (path) => nodeReadFile(path, "utf8"),
+    readDirRecursively: (path) => readdir(path, {
+        encoding: "utf8",
+        recursive: true,
+    }),
+};

package/dist/utils/isAdmin.d.ts

@@ -0,0 +1,2 @@
+import { type HttpContext } from "../HttpContext.js";
+export declare function isAdmin(ctx: HttpContext): boolean;

package/dist/utils/isAdmin.js

@@ -0,0 +1,4 @@
+import {} from "../HttpContext.js";
+export function isAdmin(ctx) {
+    return ctx.admin !== undefined;
+}

package/dist/utils/isProduction.d.ts

@@ -0,0 +1 @@
+export declare const isProduction: boolean;

package/dist/utils/isProduction.js

@@ -0,0 +1 @@
+export const isProduction = process.env.NODE_ENV === "production" || process.env.ENV === "production";

package/dist/utils/loadModules.d.ts

@@ -0,0 +1,3 @@
+import { ComponentFactory } from "../Component.js";
+import type { Module, ModuleDefinition } from "../Module.js";
+export declare function loadModules(componentFactory: ComponentFactory, modules: Module[]): Promise<ModuleDefinition[]>;

package/dist/utils/loadModules.js

@@ -0,0 +1,83 @@
+import { Component, ComponentFactory } from "../Component.js";
+import {} from "../Router.js";
+import { AdminEndpoint, Endpoint } from "../Endpoint.js";
+import { AdminView, View } from "../View.js";
+import { Middleware } from "../Middleware.js";
+import { createDebug } from "./createDebug.js";
+const debug = createDebug("loadModules");
+export async function loadModules(componentFactory, modules) {
+    const moduleDefinitions = [];
+    for (const module of modules) {
+        const moduleDefinition = {
+            name: module.name,
+            version: module.version,
+            assetsDir: module.assetsDir,
+            adminSidebarItems: module.adminSidebarItems,
+            endpoints: [],
+            views: [],
+            adminEndpoints: [],
+            adminViews: [],
+            middlewares: [],
+        };
+        const appInit = {
+            component(ctor) {
+                debug("adding component %s", ctor.name);
+                componentFactory.register(ctor);
+            },
+            endpoint: (method, path, ctor) => {
+                debug("adding endpoint %s %s", method, path);
+                componentFactory.register(ctor, (handler) => {
+                    moduleDefinition.endpoints.push({
+                        method,
+                        path,
+                        handlerName: ctor.name,
+                        handler,
+                    });
+                });
+            },
+            view: (path, ctor) => {
+                debug("adding view %s", path);
+                componentFactory.register(ctor, (handler) => {
+                    moduleDefinition.views.push({
+                        method: "GET",
+                        path,
+                        handlerName: ctor.name,
+                        handler,
+                    });
+                });
+            },
+            adminEndpoint: (method, path, ctor) => {
+                debug("adding admin endpoint %s %s", method, path);
+                componentFactory.register(ctor, (handler) => {
+                    moduleDefinition.adminEndpoints.push({
+                        method,
+                        path,
+                        handlerName: ctor.name,
+                        handler,
+                    });
+                });
+            },
+            adminView: (path, ctor) => {
+                debug("adding admin view %s", path);
+                componentFactory.register(ctor, (handler) => {
+                    moduleDefinition.adminViews.push({
+                        method: "GET",
+                        path,
+                        handlerName: ctor.name,
+                        handler,
+                    });
+                });
+            },
+            middleware: (ctor) => {
+                debug("adding middleware %s", ctor.name);
+                componentFactory.register(ctor, (instance) => {
+                    moduleDefinition.middlewares.push(instance);
+                });
+            },
+        };
+        debug("loading module %s", module.name);
+        module.init(appInit);
+        moduleDefinitions.push(moduleDefinition);
+    }
+    return moduleDefinitions;
+}

package/dist/utils/randomId.d.ts

@@ -0,0 +1 @@
+export declare function randomId(): string;

package/dist/utils/randomId.js

@@ -0,0 +1,4 @@
+import { randomBytes } from "node:crypto";
+export function randomId() {
+    return randomBytes(8).toString("hex");
+}

package/dist/utils/randomUUID.d.ts

@@ -0,0 +1 @@
+export declare function randomUUID(): `${string}-${string}-${string}-${string}-${string}`;

package/dist/utils/randomUUID.js

@@ -0,0 +1,4 @@
+import { randomUUID as nodeRandomUUID } from "node:crypto";
+export function randomUUID() {
+    return nodeRandomUUID();
+}

package/dist/utils/runMigrations.d.ts

@@ -0,0 +1,3 @@
+import type { ModuleDefinition } from "../Module.js";
+import type { DB } from "../DB.js";
+export declare function runMigrations(db: DB, modules: ModuleDefinition[]): Promise<void>;

package/dist/utils/runMigrations.js

@@ -0,0 +1,85 @@
+import { sortBy } from "./sortBy.js";
+import { createDebug } from "./createDebug.js";
+import { emptyContext } from "../Context.js";
+import { FS } from "./fs.js";
+import { sql } from "./sql.js";
+const debug = createDebug("runMigrations");
+// example: 0001-create-users-table.sql
+const MIGRATION_REGEX = /^(\d+)-(.*)\.sql$/;
+export async function runMigrations(db, modules) {
+    const ctx = emptyContext();
+    debug("creating migrations table");
+    await db.createMigrationsTable(ctx);
+    for (const module of modules) {
+        if (!module.assetsDir) {
+            continue;
+        }
+        const migrationFiles = [];
+        for (const { filename, absolutePath } of await readMigrationFiles(db, module)) {
+            let match = MIGRATION_REGEX.exec(filename);
+            if (match) {
+                migrationFiles.push({
+                    module: module.name,
+                    id: parseInt(match[1], 10),
+                    name: match[2],
+                    sql: await FS.readFile(absolutePath),
+                });
+            }
+        }
+        sortBy(migrationFiles, "id");
+        for (const migration of migrationFiles) {
+            await db.startTransaction(ctx, async () => {
+                const result = await db.query(ctx, sql.select().from("t_migrations").where({
+                    id: migration.id,
+                    module: migration.module,
+                }));
+                if (result.length === 1) {
+                    debug("migration #%d of module %s already applied", migration.id, migration.module);
+                    return;
+                }
+                debug("applying migration #%d of module %s", migration.id, migration.module);
+                await db.exec(ctx, sql.rawStatement(migration.sql));
+                await db.run(ctx, sql
+                    .insert()
+                    .into("t_migrations")
+                    .values([
+                    {
+                        module: migration.module,
+                        id: migration.id,
+                        name: migration.name,
+                        run_at: new Date(),
+                    },
+                ]));
+            });
+        }
+    }
+}
+async function readMigrationFiles(db, module) {
+    const assetsDir = module.assetsDir;
+    if (!assetsDir) {
+        return [];
+    }
+    try {
+        const dbSpecificPath = FS.join(assetsDir, "migrations", db.name);
+        debug("reading files from %s", dbSpecificPath);
+        const filenames = await FS.readDirRecursively(dbSpecificPath);
+        return filenames.map((filename) => ({
+            filename,
+            absolutePath: FS.join(assetsDir, "migrations", db.name, filename),
+        }));
+    }
+    catch (e) {
+        try {
+            const commonPath = FS.join(assetsDir, "migrations");
+            debug("reading files from %s", commonPath);
+            const filenames = await FS.readDirRecursively(commonPath);
+            return filenames.map((filename) => ({
+                filename,
+                absolutePath: FS.join(assetsDir, "migrations", filename),
+            }));
+        }
+        catch (e) {
+            return [];
+        }
+    }
+}

package/dist/utils/snakeToCamelCase.d.ts

@@ -0,0 +1 @@
+export declare function snakeToCamelCase(str: string): string;

package/dist/utils/snakeToCamelCase.js

@@ -0,0 +1,3 @@
+export function snakeToCamelCase(str) {
+    return str.replace(/_([a-z])/g, (letter) => letter[1].toUpperCase());
+}

package/dist/utils/sortBy.d.ts

@@ -0,0 +1 @@
+export declare function sortBy<T>(array: T[], field: keyof T, field2?: keyof T): T[];

package/dist/utils/sortBy.js

@@ -0,0 +1,8 @@
+export function sortBy(array, field, field2) {
+    return array.sort((a, b) => {
+        if (a[field] === b[field] && field2) {
+            return a[field2] < b[field2] ? -1 : 1;
+        }
+        return a[field] < b[field] ? -1 : 1;
+    });
+}

package/dist/utils/sql.d.ts

@@ -0,0 +1,120 @@
+export declare function sql(): void;
+export declare namespace sql {
+    export var setOption: <T extends keyof Options>(o: T, value: Options[T]) => void;
+    export var select: (columns?: Array<string | Expression>) => SelectStatement;
+    export var insert: () => InsertStatement;
+    export var update: (table: string) => UpdateStatement;
+    export var deleteFrom: (table: string) => DeleteStatement;
+    export var and: (clauses: Expression[]) => (ctx: BuildContext) => string;
+    export var or: (clauses: Expression[]) => (ctx: BuildContext) => string;
+    export var not: (expr: Expression) => (ctx: BuildContext) => string;
+    export var isNull: (column: string) => () => string;
+    export var isNotNull: (column: string) => () => string;
+    export var eq: (column: string, value: any) => (ctx: BuildContext) => string;
+    export var notEq: (column: string, value: any) => (ctx: BuildContext) => string;
+    export var lt: (column: string, value: any) => (ctx: BuildContext) => string;
+    export var lte: (column: string, value: any) => (ctx: BuildContext) => string;
+    export var gt: (column: string, value: any) => (ctx: BuildContext) => string;
+    export var gte: (column: string, value: any) => (ctx: BuildContext) => string;
+    export var between: (column: string, low: any, high: any) => (ctx: BuildContext) => string;
+    export var like: (column: string, value: any, escapeChar?: string) => (ctx: BuildContext) => string;
+    export var ilike: (column: string, value: any, escapeChar?: string) => (ctx: BuildContext) => string;
+    var _a: (column: string, values: any[]) => (ctx: BuildContext) => string;
+    export var raw: (text: string, values?: any[]) => (ctx: BuildContext) => string;
+    export var rawStatement: (text: string) => RawStatement;
+    export { _a as in };
+}
+interface Options {
+    placeholder: string;
+    quoteChar: string;
+}
+interface BuildContext {
+    values: any[];
+}
+export declare abstract class Statement {
+    build(): {
+        text: string;
+        values: any[];
+    };
+    protected abstract computeParts(ctx: BuildContext): Array<string | undefined>;
+}
+export type Expression = (ctx: BuildContext) => string;
+declare class SelectStatement extends Statement {
+    private _table?;
+    private _distinct;
+    private _columns;
+    private _joins;
+    private _where;
+    private _orderBy;
+    private _groupBy;
+    private _having?;
+    private _limit?;
+    private _offset?;
+    private _forUpdate;
+    constructor(columns?: Array<string | Expression>);
+    distinct(): this;
+    from(table: string): this;
+    innerJoin(table: string, on: Record<string, any>): this;
+    leftJoin(table: string, on: Record<string, any>): this;
+    rightJoin(table: string, on: Record<string, any>): this;
+    fullOuterJoin(table: string, on: Record<string, any>): this;
+    where(arg: Record<string, any> | Expression): this;
+    groupBy(columns: string[]): this;
+    having(expr: Expression): this;
+    orderBy(columns: string[]): this;
+    limit(limit: number): this;
+    offset(offset: number): this;
+    forUpdate(): this;
+    protected computeParts(ctx: BuildContext): (string | undefined)[];
+    protected distinctPart(): "DISTINCT" | undefined;
+    protected columnsPart(ctx: BuildContext): string;
+    protected fromPart(): string | undefined;
+    protected joinsPart(ctx: BuildContext): string | undefined;
+    protected wherePart(ctx: BuildContext): string | undefined;
+    protected groupByPart(): string | undefined;
+    protected havingPart(ctx: BuildContext): string | undefined;
+    protected orderByPart(): string | undefined;
+    protected limitPart(ctx: BuildContext): string | undefined;
+    protected offsetPart(ctx: BuildContext): string | undefined;
+    protected forUpdatePart(): "FOR UPDATE" | undefined;
+}
+declare class InsertStatement extends Statement {
+    private _table?;
+    private _values;
+    private _select?;
+    private _returning;
+    into(table: string): this;
+    values(values: Array<Record<string, any>>): this;
+    select(statement: SelectStatement): this;
+    returning(columns?: string[]): this;
+    protected computeParts(ctx: BuildContext): (string | undefined)[];
+    protected intoPart(): string | undefined;
+    protected columnsPart(): string | undefined;
+    protected valuesPart(ctx: BuildContext): string | undefined;
+    protected returningPart(): string | undefined;
+}
+declare class UpdateStatement extends Statement {
+    private readonly table;
+    private _values;
+    private _where;
+    constructor(table: string);
+    set(values: Record<string, any>): this;
+    where(arg: Record<string, any> | Expression): this;
+    protected computeParts(ctx: BuildContext): (string | undefined)[];
+    protected setPart(ctx: BuildContext): string;
+    protected wherePart(ctx: BuildContext): string | undefined;
+}
+declare class DeleteStatement extends Statement {
+    private readonly _table;
+    private _where;
+    constructor(table: string);
+    where(arg: Record<string, any> | Expression): this;
+    protected computeParts(ctx: BuildContext): (string | undefined)[];
+    protected wherePart(ctx: BuildContext): string | undefined;
+}
+declare class RawStatement extends Statement {
+    private readonly text;
+    constructor(text: string);
+    computeParts(): Array<string | undefined>;
+}
+export {};