@tymber/common 0.0.1-alpha.0 → 0.0.1

package/dist/utils/sql.js

@@ -0,0 +1,433 @@
+export function sql() { }
+const options = {
+    placeholder: "$%d",
+    quoteChar: '"',
+};
+sql.setOption = function (o, value) {
+    options[o] = value;
+};
+function joinParts(parts) {
+    return parts.filter((s) => !!s).join(" ");
+}
+export class Statement {
+    build() {
+        const values = [];
+        return {
+            text: joinParts(this.computeParts({
+                values,
+            })),
+            values,
+        };
+    }
+}
+function joinExpression(type, table, on) {
+    return () => {
+        // we cannot use sql.and() since the right part of the expression must be escaped with handleColumn() instead of handleValue()
+        const condition = Object.entries(on)
+            .map(([column, value]) => {
+            return handleColumn(column) + " = " + handleColumn(value);
+        })
+            .join(" AND ");
+        return `${type} JOIN ${handleTable(table)} ON ${condition}`;
+    };
+}
+class SelectStatement extends Statement {
+    _table;
+    _distinct = false;
+    _columns = [];
+    _joins = [];
+    _where = [];
+    _orderBy = [];
+    _groupBy = [];
+    _having;
+    _limit;
+    _offset;
+    _forUpdate = false;
+    constructor(columns) {
+        super();
+        if (columns) {
+            this._columns.push(...columns);
+        }
+    }
+    distinct() {
+        this._distinct = true;
+        return this;
+    }
+    from(table) {
+        this._table = table;
+        return this;
+    }
+    innerJoin(table, on) {
+        this._joins.push(joinExpression("INNER", table, on));
+        return this;
+    }
+    leftJoin(table, on) {
+        this._joins.push(joinExpression("LEFT", table, on));
+        return this;
+    }
+    rightJoin(table, on) {
+        this._joins.push(joinExpression("RIGHT", table, on));
+        return this;
+    }
+    fullOuterJoin(table, on) {
+        this._joins.push(joinExpression("FULL OUTER", table, on));
+        return this;
+    }
+    where(arg) {
+        if (typeof arg === "function") {
+            this._where.push(arg);
+        }
+        else {
+            for (const [column, value] of Object.entries(arg)) {
+                this._where.push(sql.eq(column, value));
+            }
+        }
+        return this;
+    }
+    groupBy(columns) {
+        this._groupBy.push(...columns);
+        return this;
+    }
+    having(expr) {
+        this._having = expr;
+        return this;
+    }
+    orderBy(columns) {
+        this._orderBy.push(...columns);
+        return this;
+    }
+    limit(limit) {
+        this._limit = limit;
+        return this;
+    }
+    offset(offset) {
+        this._offset = offset;
+        return this;
+    }
+    forUpdate() {
+        this._forUpdate = true;
+        return this;
+    }
+    computeParts(ctx) {
+        return [
+            "SELECT",
+            this.distinctPart(),
+            this.columnsPart(ctx),
+            this.fromPart(),
+            this.joinsPart(ctx),
+            this.wherePart(ctx),
+            this.groupByPart(),
+            this.havingPart(ctx),
+            this.orderByPart(),
+            this.limitPart(ctx),
+            this.offsetPart(ctx),
+            this.forUpdatePart(),
+        ];
+    }
+    distinctPart() {
+        if (this._distinct) {
+            return "DISTINCT";
+        }
+    }
+    columnsPart(ctx) {
+        if (this._columns.length) {
+            return this._columns
+                .map((column) => {
+                return typeof column === "function"
+                    ? column(ctx)
+                    : handleColumn(column);
+            })
+                .join(", ");
+        }
+        else {
+            return "*";
+        }
+    }
+    fromPart() {
+        if (this._table) {
+            return `FROM ${handleTable(this._table)}`;
+        }
+    }
+    joinsPart(ctx) {
+        if (this._joins.length) {
+            return this._joins.map((join) => join(ctx)).join(" ");
+        }
+    }
+    wherePart(ctx) {
+        if (this._where.length) {
+            return "WHERE " + groupExpression(this._where, " AND ", false)(ctx);
+        }
+    }
+    groupByPart() {
+        if (this._groupBy.length) {
+            return "GROUP BY " + handleColumns(this._groupBy);
+        }
+    }
+    havingPart(ctx) {
+        if (this._having) {
+            return "HAVING " + this._having(ctx);
+        }
+    }
+    orderByPart() {
+        if (this._orderBy.length) {
+            return "ORDER BY " + handleColumns(this._orderBy);
+        }
+    }
+    limitPart(ctx) {
+        if (this._limit) {
+            // PostgreSQL/SQLite syntax
+            return "LIMIT " + handleValue(this._limit, ctx);
+        }
+    }
+    offsetPart(ctx) {
+        if (this._offset) {
+            // PostgreSQL/SQLite syntax
+            return "OFFSET " + handleValue(this._offset, ctx);
+        }
+    }
+    forUpdatePart() {
+        if (this._forUpdate) {
+            return "FOR UPDATE";
+        }
+    }
+}
+sql.select = (columns) => new SelectStatement(columns);
+class InsertStatement extends Statement {
+    _table;
+    _values = [];
+    _select;
+    _returning = [];
+    into(table) {
+        this._table = table;
+        return this;
+    }
+    values(values) {
+        this._values.push(...values);
+        return this;
+    }
+    select(statement) {
+        this._select = statement;
+        return this;
+    }
+    returning(columns = ["*"]) {
+        this._returning.push(...columns);
+        return this;
+    }
+    computeParts(ctx) {
+        return [
+            "INSERT",
+            this.intoPart(),
+            this.columnsPart(),
+            this.valuesPart(ctx),
+            this.returningPart(),
+        ];
+    }
+    intoPart() {
+        if (this._table) {
+            return "INTO " + handleTable(this._table);
+        }
+    }
+    columnsPart() {
+        if (this._values.length) {
+            const columns = Object.keys(this._values[0]);
+            return "(" + columns.map(handleColumn).join(", ") + ")";
+        }
+        if (this._select) {
+            // @ts-expect-error protected method
+            return "(" + this._select.columnsPart() + ")";
+        }
+    }
+    valuesPart(ctx) {
+        if (this._values.length) {
+            const columns = Object.keys(this._values[0]);
+            const values = this._values.map((values) => `(${columns.map((column) => handleValue(values[column], ctx)).join(", ")})`);
+            return "VALUES " + values.join(", ");
+        }
+        if (this._select) {
+            // @ts-expect-error protected method
+            return joinParts(this._select.computeParts(ctx));
+        }
+    }
+    returningPart() {
+        if (this._returning.length) {
+            return "RETURNING " + handleColumns(this._returning);
+        }
+    }
+}
+sql.insert = () => new InsertStatement();
+class UpdateStatement extends Statement {
+    table;
+    _values = {};
+    _where = [];
+    constructor(table) {
+        super();
+        this.table = table;
+    }
+    set(values) {
+        Object.assign(this._values, values);
+        return this;
+    }
+    where(arg) {
+        if (typeof arg === "function") {
+            this._where.push(arg);
+        }
+        else {
+            for (const [column, value] of Object.entries(arg)) {
+                this._where.push(sql.eq(column, value));
+            }
+        }
+        return this;
+    }
+    computeParts(ctx) {
+        return [
+            `UPDATE ${handleTable(this.table)}`,
+            this.setPart(ctx),
+            this.wherePart(ctx),
+        ];
+    }
+    setPart(ctx) {
+        const values = [];
+        for (const [column, value] of Object.entries(this._values)) {
+            values.push(`${handleColumn(column)} = ${handleValue(value, ctx)}`);
+        }
+        return "SET " + values.join(", ");
+    }
+    wherePart(ctx) {
+        if (this._where.length) {
+            return "WHERE " + groupExpression(this._where, " AND ", false)(ctx);
+        }
+    }
+}
+sql.update = (table) => new UpdateStatement(table);
+class DeleteStatement extends Statement {
+    _table;
+    _where = [];
+    constructor(table) {
+        super();
+        this._table = table;
+    }
+    where(arg) {
+        if (typeof arg === "function") {
+            this._where.push(arg);
+        }
+        else {
+            for (const [column, value] of Object.entries(arg)) {
+                this._where.push(sql.eq(column, value));
+            }
+        }
+        return this;
+    }
+    computeParts(ctx) {
+        return [`DELETE FROM ${handleTable(this._table)}`, this.wherePart(ctx)];
+    }
+    wherePart(ctx) {
+        if (this._where.length) {
+            return "WHERE " + groupExpression(this._where, " AND ", false)(ctx);
+        }
+    }
+}
+sql.deleteFrom = (table) => new DeleteStatement(table);
+function groupExpression(clauses, op, includeParens = true) {
+    return (ctx) => {
+        const output = clauses.map((expr) => expr(ctx)).join(op);
+        return includeParens ? `(${output})` : output;
+    };
+}
+sql.and = (clauses) => groupExpression(clauses, " AND ");
+sql.or = (clauses) => groupExpression(clauses, " OR ");
+sql.not = (expr) => (ctx) => "NOT " + expr(ctx);
+function unaryExpression(column, op) {
+    return () => `${handleColumn(column)} ${op}`;
+}
+sql.isNull = (column) => unaryExpression(column, "IS NULL");
+sql.isNotNull = (column) => unaryExpression(column, "IS NOT NULL");
+function binaryExpression(column, op, value) {
+    return (ctx) => `${handleColumn(column)} ${op} ${handleValue(value, ctx)}`;
+}
+sql.eq = (column, value) => {
+    return value === null
+        ? sql.isNull(column)
+        : binaryExpression(column, "=", value);
+};
+sql.notEq = (column, value) => {
+    return value === null
+        ? sql.isNotNull(column)
+        : binaryExpression(column, "<>", value);
+};
+sql.lt = (column, value) => binaryExpression(column, "<", value);
+sql.lte = (column, value) => binaryExpression(column, "<=", value);
+sql.gt = (column, value) => binaryExpression(column, ">", value);
+sql.gte = (column, value) => binaryExpression(column, ">=", value);
+sql.between = (column, low, high) => {
+    return (ctx) => `${handleColumn(column)} BETWEEN ${handleValue(low, ctx)} AND ${handleValue(high, ctx)}`;
+};
+function likeExpression(column, op, value, escapeChar) {
+    return (ctx) => {
+        const output = `${handleColumn(column)} ${op} ${handleValue(value, ctx)}`;
+        return escapeChar ? `${output} ESCAPE '${escapeChar}'` : output;
+    };
+}
+sql.like = (column, value, escapeChar) => likeExpression(column, "LIKE", value, escapeChar);
+sql.ilike = (column, value, escapeChar) => likeExpression(column, "ILIKE", value, escapeChar);
+sql.in = (column, values) => {
+    return (ctx) => `${handleColumn(column)} IN (${values.map((value) => handleValue(value, ctx)).join(", ")})`;
+};
+sql.raw = (text, values = []) => {
+    return (ctx) => {
+        let i = 0;
+        return text.replace(/\?/g, () => {
+            if (i >= values.length) {
+                throw new Error("not enough values");
+            }
+            return handleValue(values[i++], ctx);
+        });
+    };
+};
+function handleColumns(columns) {
+    return columns.map(handleColumn).join(", ");
+}
+const WITH_SCHEMA_OR_ALIAS_REGEX = /^((\w+)\.)?(\w+)(( AS)? \w+)?$/i;
+function handleTable(table) {
+    return handleColumn(table);
+}
+function handleColumn(name) {
+    const match = WITH_SCHEMA_OR_ALIAS_REGEX.exec(name);
+    if (match) {
+        const schema = match[2];
+        const table = match[3];
+        const alias = match[4];
+        let output = schema
+            ? `${quoteKey(schema)}.${quoteKey(table)}`
+            : quoteKey(table);
+        if (alias) {
+            output += alias;
+        }
+        return output;
+    }
+    return quoteKey(name);
+}
+const UPPERCASE_REGEX = /[A-Z]/;
+// SQL:2023 specification: https://en.wikipedia.org/wiki/List_of_SQL_reserved_words
+// prettier-ignore
+const RESERVED_KEYWORDS = new Set(["abs", "absent", "acos", "all", "allocate", "alter", "and", "any", "any_value", "are", "array", "array_agg", "array_max_cardinality", "as", "asensitive", "asin", "asymmetric", "at", "atan", "atomic", "authorization", "avg", "begin", "begin_frame", "begin_partition", "between", "bigint", "binary", "blob", "boolean", "both", "btrim", "by", "call", "called", "cardinality", "cascaded", "case", "cast", "ceil", "ceiling", "char", "char_length", "character", "character_length", "check", "classifier", "clob", "close", "coalesce", "collate", "collect", "column", "commit", "condition", "connect", "constraint", "contains", "convert", "copy", "corr", "corresponding", "cos", "cosh", "count", "covar_pop", "covar_samp", "create", "cross", "cube", "cume_dist", "current", "current_catalog", "current_date", "current_default_transform_group", "current_path", "current_role", "current_row", "current_schema", "current_time", "current_timestamp", "current_transform_group_for_type", "current_user", "cursor", "cycle", "date", "day", "deallocate", "dec", "decfloat", "decimal", "declare", "default", "define", "delete", "dense_rank", "deref", "describe", "deterministic", "disconnect", "distinct", "double", "drop", "dynamic", "each", "element", "else", "empty", "end", "end_frame", "end_partition", "end-exec", "equals", "escape", "every", "except", "exec", "execute", "exists", "exp", "external", "extract", "false", "fetch", "filter", "first_value", "float", "floor", "for", "foreign", "frame_row", "free", "from", "full", "function", "fusion", "get", "global", "grant", "greatest", "group", "grouping", "groups", "having", "hold", "hour", "identity", "in", "indicator", "initial", "inner", "inout", "insensitive", "insert", "int", "integer", "intersect", "intersection", "interval", "into", "is", "join", "json", "json_array", "json_arrayagg", "json_exists", "json_object", "json_objectagg", "json_query", "json_scalar", "json_serialize", "json_table", "json_table_primitive", "json_value", "lag", "language", "large", "last_value", "lateral", "lead", "leading", "least", "left", "like", "like_regex", "listagg", "ln", "local", "localtime", "localtimestamp", "log", "log10", "lower", "lpad", "ltrim", "match", "match_number", "match_recognize", "matches", "max", "member", "merge", "method", "min", "minute", "mod", "modifies", "module", "month", "multiset", "national", "natural", "nchar", "nclob", "new", "no", "none", "normalize", "not", "nth_value", "ntile", "null", "nullif", "numeric", "occurrences_regex", "octet_length", "of", "offset", "old", "omit", "on", "one", "only", "open", "or", "order", "out", "outer", "over", "overlaps", "overlay", "parameter", "partition", "pattern", "per", "percent", "percent_rank", "percentile_cont", "percentile_disc", "period", "portion", "position", "position_regex", "power", "precedes", "precision", "prepare", "primary", "procedure", "ptf", "range", "rank", "reads", "real", "recursive", "ref", "references", "referencing", "regr_avgx", "regr_avgy", "regr_count", "regr_intercept", "regr_r2", "regr_slope", "regr_sxx", "regr_sxy", "regr_syy", "release", "result", "return", "returns", "revoke", "right", "rollback", "rollup", "row", "row_number", "rows", "rpad", "running", "savepoint", "scope", "scroll", "search", "second", "seek", "select", "sensitive", "session_user", "set", "show", "similar", "sin", "sinh", "skip", "smallint", "some", "specific", "specifictype", "sql", "sqlexception", "sqlstate", "sqlwarning", "sqrt", "start", "static", "stddev_pop", "stddev_samp", "submultiset", "subset", "substring", "substring_regex", "succeeds", "sum", "symmetric", "system", "system_time", "system_user", "table", "tablesample", "tan", "tanh", "then", "time", "timestamp", "timezone_hour", "timezone_minute", "to", "trailing", "translate", "translate_regex", "translation", "treat", "trigger", "trim", "trim_array", "true", "truncate", "uescape", "union", "unique", "unknown", "unnest", "update", "upper", "user", "using", "value", "value_of", "values", "var_pop", "var_samp", "varbinary", "varchar", "varying", "versioning", "when", "whenever", "where", "width_bucket", "window", "with", "within", "without", "year"]);
+function quoteKey(name) {
+    if (UPPERCASE_REGEX.test(name) || RESERVED_KEYWORDS.has(name)) {
+        return options.quoteChar + name + options.quoteChar;
+    }
+    return name;
+}
+function handleValue(value, ctx) {
+    ctx.values.push(value);
+    return options.placeholder.replace("%d", String(ctx.values.length));
+}
+class RawStatement extends Statement {
+    text;
+    constructor(text) {
+        super();
+        this.text = text;
+    }
+    computeParts() {
+        return [this.text];
+    }
+}
+sql.rawStatement = (text) => new RawStatement(text);

package/dist/utils/toNodeHandler.d.ts

@@ -0,0 +1,2 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+export declare function toNodeHandler(nativeHandler: (req: Request) => Promise<Response>): (req: IncomingMessage, res: ServerResponse) => Promise<void>;

package/dist/utils/toNodeHandler.js

@@ -0,0 +1,91 @@
+import { Readable } from "node:stream";
+import { createBrotliCompress, createDeflate, createGzip, createZstdCompress, } from "node:zlib";
+function toHeaders(nodeHeaders) {
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(nodeHeaders)) {
+        if (Array.isArray(value)) {
+            for (const val of value) {
+                headers.append(key, val);
+            }
+        }
+        else if (value !== undefined) {
+            headers.set(key, value);
+        }
+    }
+    return headers;
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.setEncoding("utf8");
+        req.on("data", (chunk) => chunks.push(chunk));
+        req.on("end", () => resolve(chunks.join()));
+        req.on("error", (err) => reject(err));
+    });
+}
+function createNativeRequest(nodeReq) {
+    const req = Object.create(null);
+    req.url = nodeReq.url;
+    req.method = nodeReq.method;
+    req.headers = toHeaders(nodeReq.headers);
+    req.json = () => readBody(nodeReq).then(JSON.parse);
+    const controller = new AbortController();
+    req.signal = controller.signal;
+    nodeReq.on("close", () => controller.abort());
+    return req;
+}
+const AVAILABLE_COMPRESSION_ALGORITHMS = [
+    {
+        name: "zstd", // added in v22.15.0
+        createCompressor: createZstdCompress,
+    },
+    {
+        name: "brotli", // added in v10.16.0
+        createCompressor: createBrotliCompress,
+    },
+    {
+        name: "gzip",
+        createCompressor: createGzip,
+    },
+    {
+        name: "deflate",
+        createCompressor: createDeflate,
+    },
+];
+function writeResponse(nodeReq, nodeRes, res) {
+    const isSSE = res.headers.get("content-type") === "text/event-stream";
+    const acceptEncoding = nodeReq.headers["accept-encoding"];
+    let compressor;
+    if (res.body && acceptEncoding && !isSSE) {
+        // TODO handle quality
+        // ref: https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Accept-Encoding
+        for (const { name, createCompressor } of AVAILABLE_COMPRESSION_ALGORITHMS) {
+            if (acceptEncoding.includes(name)) {
+                res.headers.set("content-encoding", name);
+                compressor = createCompressor();
+                break;
+            }
+        }
+    }
+    nodeRes.setHeaders(res.headers);
+    nodeRes.writeHead(res.status);
+    if (!res.body) {
+        return nodeRes.end();
+    }
+    if (isSSE) {
+        nodeRes.flushHeaders();
+    }
+    if (compressor) {
+        Readable.fromWeb(res.body).pipe(compressor).pipe(nodeRes);
+    }
+    else {
+        Readable.fromWeb(res.body).pipe(nodeRes);
+    }
+}
+export function toNodeHandler(nativeHandler) {
+    return async function (nodeReq, nodeRes) {
+        const req = createNativeRequest(nodeReq);
+        const httpResponse = await nativeHandler(req);
+        writeResponse(nodeReq, nodeRes, httpResponse);
+    };
+}

package/dist/utils/types.d.ts

@@ -0,0 +1,3 @@
+export type Brand<K, T> = K & {
+    __brand: T;
+};

package/dist/utils/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/waitFor.d.ts

@@ -0,0 +1 @@
+export declare function waitFor(target: EventTarget, type: string): Promise<unknown>;

package/dist/utils/waitFor.js

@@ -0,0 +1,5 @@
+export function waitFor(target, type) {
+    return new Promise((resolve) => {
+        target.addEventListener(type, resolve, { once: true });
+    });
+}

package/package.json

@@ -1,7 +1,33 @@
 {
   "name": "@tymber/common",
-  "version": "0.0.1-alpha.0",
+  "version": "0.0.1",
   "description": "The base of the Tymber framework",
   "license": "MIT",
-  "author": "Damien ARRACHEQUESNE"
+  "author": "Damien ARRACHEQUESNE",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tymber-framework/tymber.git"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "compile": "rm -rf dist/ && tsc",
+    "format:check": "prettier -c src/ test/ bun-tests/",
+    "format:fix": "prettier -w src/ test/ bun-tests/",
+    "test": "tsx --test 'test/**/*.test.ts'"
+  },
+  "files": [
+    "src/",
+    "dist/"
+  ],
+  "exports": {
+    "node": "./dist/index.js",
+    "bun": "./src/index.ts",
+    "deno": "./src/index.ts"
+  },
+  "dependencies": {
+    "ajv": "~8.17.1",
+    "ajv-formats": "~3.0.1"
+  }
 }