@devmoods/express-extras 0.53.0 → 0.54.1

package/dist/index.d.ts

@@ -14,10 +14,12 @@ export * from './logger.js';
 export * from './manage.js';
 export * from './middleware.js';
 export * from './postgres.js';
+export * from './rate-limit.js';
 export * from './redis.js';
 export * from './routes.js';
 export * from './sentry.js';
 export * from './slack.js';
+export * from './sql.js';
 export * from './utils.js';
 export * from './validate.js';
 export * from './webapi.js';

package/dist/index.js

@@ -15,10 +15,12 @@ export * from './logger.js';
 export * from './manage.js';
 export * from './middleware.js';
 export * from './postgres.js';
+export * from './rate-limit.js';
 export * from './redis.js';
 export * from './routes.js';
 export * from './sentry.js';
 export * from './slack.js';
+export * from './sql.js';
 export * from './utils.js';
 export * from './validate.js';
 export * from './webapi.js';

package/dist/middleware.js

@@ -68,8 +68,17 @@ export function before({ cookies = false, helmet: useHelmet = true, json: useJso
     ].filter(Boolean));
 }
 function logRequestDuration() {
+    const FILTERED_PATHS = [
+        '/src',
+        '/node_modules',
+        '/@fs',
+        '/@vite',
+        '/@react-refresh',
+        '/@id',
+        '/analytics.js',
+    ];
     return (req, res, next) => {
-        if (req.path.startsWith('/src')) {
+        if (FILTERED_PATHS.some((p) => req.path.startsWith(p))) {
             return next();
         }
         const timer = startTimer();

package/dist/migrate.d.ts

@@ -1,6 +1,6 @@
 import { type Command } from 'commander';
 import { type CLI } from './cli.js';
-import { type Connection, createPostgres } from './postgres.js';
+import { createPostgres } from './postgres.js';
 interface Migration {
     name: string;
     filename: string;
@@ -33,8 +33,8 @@ export declare class Migrator {
     log(...args: any[]): void;
     executeMigration(migrations: Migration[], currentVersion: number, direction: 'up' | 'down'): Promise<number>;
     readMigrationFile(filename: string): Promise<MigrationFileAPI>;
-    migrate(connection: Connection, migrator: MigrationFileAPI, direction: 'up' | 'down'): Promise<void>;
-    updateCurrentVersion(connection: Connection, version: number): Promise<import("pg").QueryResult<import("pg").QueryResultRow>>;
+    migrate(migrator: MigrationFileAPI, direction: 'up' | 'down'): Promise<void>;
+    updateCurrentVersion(version: number): Promise<import("pg").QueryResult<import("pg").QueryResultRow>>;
     getCurrentVersion(): Promise<number>;
     getMigrations(): Promise<{
         filename: string;

package/dist/migrate.js

@@ -3,7 +3,8 @@ import * as path from 'node:path';
 import chalk from 'chalk';
 import {} from 'commander';
 import {} from './cli.js';
-import { createPostgres, formatSql, sql } from './postgres.js';
+import { createPostgres } from './postgres.js';
+import { formatSql, sql } from './sql.js';
 export const asCli = (command, cli) => {
     command.command('up').action(cli.wrap(async () => {
         const migrator = new Migrator();
@@ -138,15 +139,15 @@ export class Migrator {
                 this.log('Running migration', migration.filename);
                 const migrator = await this.readMigrationFile(migration.filename);
                 if (migrator.useTransaction !== false) {
-                    await this.postgres.transaction(async (tx) => {
-                        await this.migrate(tx, migrator, direction);
-                        await this.updateCurrentVersion(tx, migration.version);
+                    await this.postgres.transaction(async () => {
+                        await this.migrate(migrator, direction);
+                        await this.updateCurrentVersion(migration.version);
                     });
                 }
                 else {
-                    await this.postgres.withConnection(async (tx) => {
-                        await this.migrate(tx, migrator, direction);
-                        await this.updateCurrentVersion(tx, migration.version);
+                    await this.postgres.withConnection(async () => {
+                        await this.migrate(migrator, direction);
+                        await this.updateCurrentVersion(migration.version);
                     });
                 }
             }
@@ -165,15 +166,15 @@ export class Migrator {
             this.log('Rolling back migration', migrationToRollback.filename);
             const migrator = await this.readMigrationFile(migrationToRollback.filename);
             if (migrator.useTransaction !== false) {
-                await this.postgres.transaction(async (tx) => {
-                    await this.migrate(tx, migrator, 'down');
-                    await this.updateCurrentVersion(tx, updatedVersion);
+                await this.postgres.transaction(async () => {
+                    await this.migrate(migrator, 'down');
+                    await this.updateCurrentVersion(updatedVersion);
                 });
             }
             else {
-                await this.postgres.withConnection(async (tx) => {
-                    await this.migrate(tx, migrator, 'down');
-                    await this.updateCurrentVersion(tx, updatedVersion);
+                await this.postgres.withConnection(async () => {
+                    await this.migrate(migrator, 'down');
+                    await this.updateCurrentVersion(updatedVersion);
                 });
             }
             return await this.getCurrentVersion();
@@ -197,13 +198,13 @@ export class Migrator {
             },
         };
     }
-    async migrate(connection, migrator, direction) {
+    async migrate(migrator, direction) {
         try {
             const queryWithLog = (statement) => {
                 this.log(chalk.yellow(formatSql(statement)));
-                return connection.query(statement);
+                return this.postgres.query(statement);
             };
-            const returnValue = await migrator[direction](queryWithLog.bind(connection));
+            const returnValue = await migrator[direction](queryWithLog.bind(this.postgres));
             if (typeof returnValue === 'string') {
                 if (returnValue !== '') {
                     await queryWithLog(returnValue);
@@ -218,8 +219,8 @@ export class Migrator {
             throw new Error(`Migration failed: ${error.message}`);
         }
     }
-    updateCurrentVersion(connection, version) {
-        return connection.query(`INSERT INTO ${this.migrationTableName} (version, run_at) VALUES ($1, $2)`, [version, new Date()]);
+    updateCurrentVersion(version) {
+        return this.postgres.query(`INSERT INTO ${this.migrationTableName} (version, run_at) VALUES ($1, $2)`, [version, new Date()]);
     }
     async getCurrentVersion() {
         const result = await this.postgres.first(`SELECT version FROM ${this.migrationTableName} ORDER BY run_at DESC LIMIT 1`);

package/dist/postgres.d.ts

@@ -1,10 +1,9 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { type RequestHandler } from 'express';
 import pg, { type PoolClient, type PoolConfig, type QueryResult, type QueryResultRow } from 'pg';
+import { type SqlStatement } from './sql.js';
 export declare const escapePostgresIdentifier: typeof pg.escapeIdentifier;
 export declare const escapePostgresLiteral: typeof pg.escapeLiteral;
-/**
- * Returns a pretty-printed SQL statement.
- */
-export declare const formatSql: (statement: SqlStatement | string) => string;
 export interface PostgresOptions extends PoolConfig, ConnectionOptions {
     onError?: (error: Error, client: any) => void;
     url?: PoolConfig['connectionString'];
@@ -22,11 +21,18 @@ type Value = null | string | number | Date;
 export interface ConnectionOptions {
     onLogStatement?: (statement: SqlStatement | string, values: unknown[] | undefined, duration: number) => void;
 }
+export interface TransactionContext {
+    connection: Connection;
+    savepoints: string[];
+    isCommitted: boolean;
+    isRolledBack: boolean;
+}
+export declare const transactionStorage: AsyncLocalStorage<TransactionContext>;
 export declare class Connection {
     private options;
     client: PoolClient;
     constructor(client: PoolClient, options: ConnectionOptions);
-    private onLogStatement;
+    private logStatement;
     query<T extends QueryResultRow>(text: string | SqlStatement, values?: Value[]): Promise<QueryResult<T>>;
     all<T extends QueryResultRow>(text: string | SqlStatement, values?: Value[]): Promise<T[]>;
     insert<T extends QueryResultRow>(text: string | SqlStatement, values?: Value[]): Promise<QueryResult<T>>;
@@ -34,6 +40,12 @@ export declare class Connection {
     get<T extends QueryResultRow>(text: string | SqlStatement, values?: Value[]): Promise<T>;
 }
 export declare class Transaction extends Connection {
+    savepoints: string[];
+    isCommitted: boolean;
+    isRolledBack: boolean;
+    createSavepoint(): Promise<string>;
+    rollbackToSavepoint(savepointName: string): Promise<void>;
+    releaseSavepoint(savepointName: string): Promise<void>;
 }
 /**
  * Create a new Postgres connection pool with
@@ -49,37 +61,11 @@ export declare function createPostgres({ onError, url, ...postgresOptions }?: Po
     all: <T extends QueryResultRow>(text: string | SqlStatement, values?: Value[]) => Promise<T[]>;
     get: <T extends QueryResultRow>(text: string | SqlStatement, values?: Value[]) => Promise<T>;
     withConnection: <T>(callback: (connection: Connection) => Promise<T>) => Promise<T>;
-    transaction: <T>(callback: (connection: Transaction) => Promise<T> | T) => Promise<T>;
+    transaction: <T>(callback: () => Promise<T> | T) => Promise<T>;
+    getCurrentTransaction: () => Transaction | null;
     instance: pg.Pool;
     clear: (force?: boolean) => Promise<void>;
     end(): Promise<void>;
 };
-export declare class SqlStatement {
-    stringsAndValues: [string, unknown | undefined][];
-    constructor(strings: string[], values: unknown[]);
-    _extract(strings: string[], values: unknown[]): void;
-    append(statement: SqlStatement | string): this;
-    get values(): ({} | null)[];
-    get text(): string;
-}
-export declare const sql: {
-    (strings: TemplateStringsArray, ...values: unknown[]): SqlStatement;
-    identifier(name: string): {
-        name: string;
-        raw: boolean;
-    };
-    raw(name: string): {
-        name: string;
-        raw: boolean;
-    };
-    literal(name: string | null): {
-        name: string;
-        raw: boolean;
-    };
-    spreadUpdate: typeof spreadUpdate;
-    spreadInsert: typeof spreadInsert;
-};
-declare function spreadUpdate(data: Record<string, any>): SqlStatement;
-declare function spreadInsert<TData extends Record<string, any>>(data: TData | TData[]): SqlStatement;
-export declare function joinStatements(statements: SqlStatement[], separator: string): SqlStatement;
+export declare function withTransaction(postgres: ReturnType<typeof createPostgres>): RequestHandler;
 export {};

package/dist/postgres.js

@@ -1,21 +1,11 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import {} from 'express';
 import pg, {} from 'pg';
-import { format } from 'sql-formatter';
 import { config } from './config.js';
+import { formatSql } from './sql.js';
 import { startTimer } from './utils.js';
 export const escapePostgresIdentifier = pg.escapeIdentifier;
 export const escapePostgresLiteral = pg.escapeLiteral;
-/**
- * Returns a pretty-printed SQL statement.
- */
-export const formatSql = (statement) => {
-    const value = statement instanceof SqlStatement ? statement.text : statement;
-    return format(value, {
-        language: 'postgresql',
-        keywordCase: 'upper',
-        tabWidth: 2,
-        useTabs: false,
-    });
-};
 export class DoesNotExistError extends Error {
     constructor(message) {
         super(message);
@@ -34,12 +24,13 @@ export class IntegrityError extends Error {
         this.name = 'IntegrityError';
     }
 }
+export const transactionStorage = new AsyncLocalStorage();
 export class Connection {
     constructor(client, options) {
         this.options = options;
         this.client = client;
     }
-    onLogStatement(text, values, duration) {
+    logStatement(text, values, duration) {
         if (this.options.onLogStatement) {
             return this.options.onLogStatement(text, values, duration);
         }
@@ -59,7 +50,7 @@ export class Connection {
             throw error;
         }
         finally {
-            this.onLogStatement?.(text, values, timer.getDuration());
+            this.logStatement?.(text, values, timer.getDuration());
         }
     }
     async all(text, values) {
@@ -89,6 +80,28 @@ export class Connection {
     }
 }
 export class Transaction extends Connection {
+    constructor() {
+        super(...arguments);
+        this.savepoints = [];
+        this.isCommitted = false;
+        this.isRolledBack = false;
+    }
+    async createSavepoint() {
+        const savepointName = `sp_${this.savepoints.length + 1}`;
+        await this.query(`SAVEPOINT ${savepointName}`);
+        this.savepoints.push(savepointName);
+        return savepointName;
+    }
+    async rollbackToSavepoint(savepointName) {
+        await this.query(`ROLLBACK TO SAVEPOINT ${savepointName}`);
+    }
+    async releaseSavepoint(savepointName) {
+        await this.query(`RELEASE SAVEPOINT ${savepointName}`);
+        const index = this.savepoints.indexOf(savepointName);
+        if (index !== -1) {
+            this.savepoints.splice(index, 1);
+        }
+    }
 }
 /**
  * Create a new Postgres connection pool with
@@ -103,6 +116,11 @@ export function createPostgres({ onError, url = config.value.POSTGRES_URL, ...po
         onError?.(e, client);
     });
     async function withConnection(callback) {
+        // Check if we're already in a transaction context
+        const txContext = transactionStorage.getStore();
+        if (txContext) {
+            return callback(txContext.connection);
+        }
         const client = await pool.connect();
         try {
             const result = await callback(new Connection(client, {
@@ -128,21 +146,50 @@ export function createPostgres({ onError, url = config.value.POSTGRES_URL, ...po
     }
     /**
      * Run queries inside a BEGIN, COMMIT / ROLLBACK transaction.
+     * Supports nested transactions using SAVEPOINT.
      */
     async function transaction(callback) {
+        // Check if we're already in a transaction context
+        const existingTxContext = transactionStorage.getStore();
+        if (existingTxContext) {
+            // We're already in a transaction, create a savepoint for nested transaction
+            const txConnection = existingTxContext.connection;
+            const savepointName = await txConnection.createSavepoint();
+            try {
+                const result = await callback();
+                await txConnection.releaseSavepoint(savepointName);
+                return result;
+            }
+            catch (error) {
+                await txConnection.rollbackToSavepoint(savepointName);
+                throw error;
+            }
+        }
+        // Start a new top-level transaction
         const client = await pool.connect();
+        const txConnection = new Transaction(client, {
+            onLogStatement: postgresOptions.onLogStatement,
+        });
         try {
-            await client.query('BEGIN');
-            const result = await callback(new Transaction(client, {
-                onLogStatement: postgresOptions.onLogStatement,
-            }));
-            await client.query('COMMIT');
+            await txConnection.query('BEGIN');
+            // Create transaction context
+            const txContext = {
+                connection: txConnection,
+                savepoints: [],
+                isCommitted: false,
+                isRolledBack: false,
+            };
+            // Run the callback within the transaction context
+            const result = await transactionStorage.run(txContext, async () => {
+                return await callback();
+            });
+            await txConnection.query('COMMIT');
+            txContext.isCommitted = true;
             return result;
         }
         catch (error) {
-            await client.query('ROLLBACK');
+            await txConnection.query('ROLLBACK');
             throw error;
-            /* c8 ignore next 3 */
         }
         finally {
             client.release();
@@ -173,6 +220,14 @@ export function createPostgres({ onError, url = config.value.POSTGRES_URL, ...po
             return connection.get(...args);
         });
     };
+    /**
+     * Get the current transaction from the AsyncLocalStorage context.
+     * Returns null if not in a transaction.
+     */
+    function getCurrentTransaction() {
+        const txContext = transactionStorage.getStore();
+        return txContext ? txContext.connection : null;
+    }
     return {
         insert,
         query,
@@ -181,6 +236,7 @@ export function createPostgres({ onError, url = config.value.POSTGRES_URL, ...po
         get,
         withConnection,
         transaction,
+        getCurrentTransaction,
         instance: pool,
         clear,
         end() {
@@ -188,123 +244,19 @@ export function createPostgres({ onError, url = config.value.POSTGRES_URL, ...po
         },
     };
 }
-const isRaw = (value) => {
-    return (typeof value === 'object' && value !== null && 'raw' in value && !!value.raw);
-};
-export class SqlStatement {
-    constructor(strings, values) {
-        this.stringsAndValues = [];
-        this._extract(strings, values);
-    }
-    _extract(strings, values) {
-        for (let i = 0; i < strings.length; i++) {
-            const string = strings[i];
-            const value = values[i];
-            if (isRaw(value)) {
-                this.stringsAndValues.push([string + value.name, undefined]);
-            }
-            else if (value instanceof SqlStatement) {
-                this.stringsAndValues.push([string, undefined]);
-                this.stringsAndValues.push(...value.stringsAndValues);
-            }
-            else {
-                this.stringsAndValues.push([string, value]);
-            }
-        }
-    }
-    append(statement) {
-        if (statement instanceof SqlStatement) {
-            this.stringsAndValues.push(...statement.stringsAndValues);
-        }
-        else {
-            this.stringsAndValues.push([statement, undefined]);
-        }
-        return this;
-    }
-    get values() {
-        return this.stringsAndValues
-            .map(([, value]) => value)
-            .filter((x) => x !== undefined);
-    }
-    get text() {
-        let i = 1;
-        let result = '';
-        for (const [string, value] of this.stringsAndValues) {
-            if (value == null) {
-                result += string;
-            }
-            else {
-                result += `${string}$${i}`;
-                i += 1;
-            }
-        }
-        return result;
-    }
-}
-export const sql = (strings, ...values) => {
-    return new SqlStatement(Array.from(strings), values);
-};
-function spreadUpdate(data) {
-    const entries = Object.entries(data);
-    if (entries.length === 0) {
-        return sql ``;
-    }
-    return joinStatements(entries
-        .filter(([, value]) => typeof value !== 'undefined')
-        .map(([key, value]) => sql `${sql.identifier(key)} = ${value == null ? sql.raw('NULL') : value}`), ', ');
-}
-function spreadInsert(data) {
-    const rows = Array.isArray(data) ? data : [data];
-    if (rows.length === 0) {
-        return sql ``;
-    }
-    const statement = sql `(`;
-    statement.append(Object.keys(rows[0])
-        .map((k) => escapePostgresIdentifier(k))
-        .join(', '));
-    statement.append(sql `) VALUES `);
-    const toInsert = [];
-    for (const row of rows) {
-        const values = Object.values(row);
-        if (values.length === 0) {
-            continue;
+export function withTransaction(postgres) {
+    return async (req, res, next) => {
+        try {
+            await postgres.transaction(async () => {
+                await new Promise((resolve, reject) => {
+                    res.on('finish', resolve);
+                    res.on('error', reject);
+                    next();
+                });
+            });
         }
-        toInsert.push(sql `(${joinStatements(values.map((value) => sql `${value ?? sql.raw('NULL')}`), ', ')})`);
-    }
-    statement.append(joinStatements(toInsert, ', '));
-    return statement;
-}
-/**
- * Inject an identifier into the template string
- */
-sql.identifier = (name) => {
-    return { name: escapePostgresIdentifier(name), raw: true };
-};
-/**
- * Inject a raw value into the template string
- */
-sql.raw = (name) => {
-    return { name, raw: true };
-};
-/**
- * Inject a literal value into the template string
- */
-sql.literal = (name) => {
-    if (name === null) {
-        return { name: 'NULL', raw: true };
-    }
-    return { name: escapePostgresLiteral(name), raw: true };
-};
-sql.spreadUpdate = spreadUpdate;
-sql.spreadInsert = spreadInsert;
-export function joinStatements(statements, separator) {
-    let i = 0;
-    const statement = sql ``;
-    for (const o of statements) {
-        if (i++ !== 0) {
-            statement.append(separator);
+        catch (error) {
+            next(error);
         }
-        statement.append(o);
-    }
-    return statement;
+    };
 }

package/dist/rate-limit.d.ts

@@ -0,0 +1,22 @@
+import { type RequestHandler, type Request } from 'express';
+import { type RedisClient } from './redis.js';
+export interface RateLimitOptions {
+    /**
+     * Maximum number of requests allowed within the window
+     * @default 100
+     */
+    max?: number;
+    /**
+     * Time window in seconds
+     * @default 60
+     */
+    windowSizeInSeconds?: number;
+    /**
+     * Function to generate a key for rate limiting
+     * @default IP-based rate limiting
+     */
+    getKey?: (req: Request) => string;
+}
+export declare function rateLimit(redis: RedisClient, { max, windowSizeInSeconds, getKey, }?: RateLimitOptions): RequestHandler<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>> & {
+    clear: (key: string) => Promise<void>;
+};

package/dist/rate-limit.js

@@ -0,0 +1,35 @@
+import {} from 'express';
+import { config } from './config.js';
+import { makeError } from './errors.js';
+import {} from './redis.js';
+export function rateLimit(redis, { max = 100, windowSizeInSeconds = 60, getKey = (req) => req.ip || 'unknown', } = {}) {
+    const handler = async (req, res, next) => {
+        try {
+            const key = `${config.value.REDIS_KEY_PREFIX}rate-limit:${getKey(req)}`;
+            // Use Redis to track requests
+            const currentCount = await redis.get(key);
+            const count = currentCount ? parseInt(currentCount, 10) : 0;
+            // Set headers for rate limiting info
+            res.setHeader('X-RateLimit-Limit', max.toString());
+            res.setHeader('X-RateLimit-Remaining', Math.max(0, max - count - 1).toString());
+            if (count >= max) {
+                throw makeError(429, 'Rate limit exceeded');
+            }
+            if (count === 0) {
+                await redis.set(key, '1', { EX: windowSizeInSeconds });
+            }
+            else {
+                await redis.incr(key);
+            }
+            next();
+        }
+        catch (error) {
+            next(error);
+        }
+    };
+    const clear = async (key) => {
+        await redis.del(`rate-limit:${key}`);
+    };
+    handler.clear = clear;
+    return handler;
+}

package/dist/sql.d.ts

@@ -0,0 +1,33 @@
+export declare class SqlStatement {
+    stringsAndValues: [string, unknown | undefined][];
+    constructor(strings: string[], values: unknown[]);
+    _extract(strings: string[], values: unknown[]): void;
+    append(statement: SqlStatement | string): this;
+    get values(): ({} | null)[];
+    get text(): string;
+}
+export declare const sql: {
+    (strings: TemplateStringsArray, ...values: unknown[]): SqlStatement;
+    identifier(name: string): {
+        name: string;
+        raw: boolean;
+    };
+    raw(name: string): {
+        name: string;
+        raw: boolean;
+    };
+    literal(name: string | null): {
+        name: string;
+        raw: boolean;
+    };
+    spreadUpdate: typeof spreadUpdate;
+    spreadInsert: typeof spreadInsert;
+};
+declare function spreadUpdate(data: Record<string, any>): SqlStatement;
+declare function spreadInsert<TData extends Record<string, any>>(data: TData | TData[]): SqlStatement;
+export declare function joinStatements(statements: SqlStatement[], separator: string): SqlStatement;
+/**
+ * Returns a pretty-printed SQL statement.
+ */
+export declare const formatSql: (statement: SqlStatement | string) => string;
+export {};

package/dist/sql.js

@@ -0,0 +1,134 @@
+import { format } from 'sql-formatter';
+import { escapePostgresIdentifier, escapePostgresLiteral } from './postgres.js';
+const isRaw = (value) => {
+    return (typeof value === 'object' && value !== null && 'raw' in value && !!value.raw);
+};
+export class SqlStatement {
+    constructor(strings, values) {
+        this.stringsAndValues = [];
+        this._extract(strings, values);
+    }
+    _extract(strings, values) {
+        for (let i = 0; i < strings.length; i++) {
+            const string = strings[i];
+            const value = values[i];
+            if (isRaw(value)) {
+                this.stringsAndValues.push([string + value.name, undefined]);
+            }
+            else if (value instanceof SqlStatement) {
+                this.stringsAndValues.push([string, undefined]);
+                this.stringsAndValues.push(...value.stringsAndValues);
+            }
+            else {
+                this.stringsAndValues.push([string, value]);
+            }
+        }
+    }
+    append(statement) {
+        if (statement instanceof SqlStatement) {
+            this.stringsAndValues.push(...statement.stringsAndValues);
+        }
+        else {
+            this.stringsAndValues.push([statement, undefined]);
+        }
+        return this;
+    }
+    get values() {
+        return this.stringsAndValues
+            .map(([, value]) => value)
+            .filter((x) => x !== undefined);
+    }
+    get text() {
+        let i = 1;
+        let result = '';
+        for (const [string, value] of this.stringsAndValues) {
+            if (value == null) {
+                result += string;
+            }
+            else {
+                result += `${string}$${i}`;
+                i += 1;
+            }
+        }
+        return result;
+    }
+}
+export const sql = (strings, ...values) => {
+    return new SqlStatement(Array.from(strings), values);
+};
+function spreadUpdate(data) {
+    const entries = Object.entries(data);
+    if (entries.length === 0) {
+        return sql ``;
+    }
+    return joinStatements(entries
+        .filter(([, value]) => typeof value !== 'undefined')
+        .map(([key, value]) => sql `${sql.identifier(key)} = ${value == null ? sql.raw('NULL') : value}`), ', ');
+}
+function spreadInsert(data) {
+    const rows = Array.isArray(data) ? data : [data];
+    if (rows.length === 0) {
+        return sql ``;
+    }
+    const statement = sql `(`;
+    statement.append(Object.keys(rows[0])
+        .map((k) => escapePostgresIdentifier(k))
+        .join(', '));
+    statement.append(sql `) VALUES `);
+    const toInsert = [];
+    for (const row of rows) {
+        const values = Object.values(row);
+        if (values.length === 0) {
+            continue;
+        }
+        toInsert.push(sql `(${joinStatements(values.map((value) => sql `${value ?? sql.raw('NULL')}`), ', ')})`);
+    }
+    statement.append(joinStatements(toInsert, ', '));
+    return statement;
+}
+/**
+ * Inject an identifier into the template string
+ */
+sql.identifier = (name) => {
+    return { name: escapePostgresIdentifier(name), raw: true };
+};
+/**
+ * Inject a raw value into the template string
+ */
+sql.raw = (name) => {
+    return { name, raw: true };
+};
+/**
+ * Inject a literal value into the template string
+ */
+sql.literal = (name) => {
+    if (name === null) {
+        return { name: 'NULL', raw: true };
+    }
+    return { name: escapePostgresLiteral(name), raw: true };
+};
+sql.spreadUpdate = spreadUpdate;
+sql.spreadInsert = spreadInsert;
+export function joinStatements(statements, separator) {
+    let i = 0;
+    const statement = sql ``;
+    for (const o of statements) {
+        if (i++ !== 0) {
+            statement.append(separator);
+        }
+        statement.append(o);
+    }
+    return statement;
+}
+/**
+ * Returns a pretty-printed SQL statement.
+ */
+export const formatSql = (statement) => {
+    const value = statement instanceof SqlStatement ? statement.text : statement;
+    return format(value, {
+        language: 'postgresql',
+        keywordCase: 'upper',
+        tabWidth: 2,
+        useTabs: false,
+    });
+};

package/dist/validate.js

@@ -56,6 +56,7 @@ function createAjv(options) {
     });
     ajv.addKeyword('$enumNames');
     ajv.addKeyword('$bitiforms');
+    ajv.addKeyword('$forms');
     return ajv;
 }
 export function compileValidateSchema(schema, options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devmoods/express-extras",
-  "version": "0.53.0",
+  "version": "0.54.1",
   "description": "Kubernetes-ready utilities for rapid Node.js application development",
   "type": "module",
   "main": "./dist/index.js",