@devmoods/express-extras 0.64.0 → 0.65.1

package/dist/vitest/testClient.d.ts

@@ -0,0 +1,30 @@
+import { type Server } from 'node:http';
+import { type FetchClientOptions } from '@devmoods/fetch';
+import { type Application } from 'express';
+import * as tough from 'tough-cookie';
+export declare function createTestClient(server: Server | Application, options?: FetchClientOptions): Promise<{
+    duplicate(): Promise</*elided*/ any>;
+    cookieJar: tough.CookieJar;
+    fetch: {
+        <TResponseData, TRequestData = any, TTransformedResponseData = TResponseData, TTransformedRequestData = TRequestData, TSchema extends import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1<TTransformedResponseData, any> = import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1<TTransformedResponseData, TTransformedResponseData>>(url: string, options?: import("@devmoods/fetch").RequestOptions<TRequestData, TTransformedRequestData, TResponseData, TTransformedResponseData, TSchema>): Promise<import("@devmoods/fetch").HttpResponse<import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1.InferOutput<TSchema>>>;
+        intercept(interceptor: import("@devmoods/fetch").FetchInterceptor): () => void;
+    };
+    post: {
+        <TResponseData, TRequestData = any, TTransformedResponseData = TResponseData, TTransformedRequestData = TRequestData, TSchema extends import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1<TTransformedResponseData, any> = import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1<TTransformedResponseData, TTransformedResponseData>>(url: string, options?: import("@devmoods/fetch").RequestOptions<TRequestData, TTransformedRequestData, TResponseData, TTransformedResponseData, TSchema>): Promise<import("@devmoods/fetch").HttpResponse<import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1.InferOutput<TSchema>>>;
+        intercept(interceptor: import("@devmoods/fetch").FetchInterceptor): () => void;
+    };
+    get: {
+        <TResponseData, TRequestData = any, TTransformedResponseData = TResponseData, TTransformedRequestData = TRequestData, TSchema extends import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1<TTransformedResponseData, any> = import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1<TTransformedResponseData, TTransformedResponseData>>(url: string, options?: import("@devmoods/fetch").RequestOptions<TRequestData, TTransformedRequestData, TResponseData, TTransformedResponseData, TSchema>): Promise<import("@devmoods/fetch").HttpResponse<import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1.InferOutput<TSchema>>>;
+        intercept(interceptor: import("@devmoods/fetch").FetchInterceptor): () => void;
+    };
+    put: {
+        <TResponseData, TRequestData = any, TTransformedResponseData = TResponseData, TTransformedRequestData = TRequestData, TSchema extends import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1<TTransformedResponseData, any> = import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1<TTransformedResponseData, TTransformedResponseData>>(url: string, options?: import("@devmoods/fetch").RequestOptions<TRequestData, TTransformedRequestData, TResponseData, TTransformedResponseData, TSchema>): Promise<import("@devmoods/fetch").HttpResponse<import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1.InferOutput<TSchema>>>;
+        intercept(interceptor: import("@devmoods/fetch").FetchInterceptor): () => void;
+    };
+    delete: {
+        <TResponseData, TRequestData = any, TTransformedResponseData = TResponseData, TTransformedRequestData = TRequestData, TSchema extends import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1<TTransformedResponseData, any> = import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1<TTransformedResponseData, TTransformedResponseData>>(url: string, options?: import("@devmoods/fetch").RequestOptions<TRequestData, TTransformedRequestData, TResponseData, TTransformedResponseData, TSchema>): Promise<import("@devmoods/fetch").HttpResponse<import("@standard-schema/spec", { with: { "resolution-mode": "require" } }).StandardSchemaV1.InferOutput<TSchema>>>;
+        intercept(interceptor: import("@devmoods/fetch").FetchInterceptor): () => void;
+    };
+    close: () => Promise<void>;
+    [Symbol.asyncDispose]: () => Promise<void>;
+}>;

package/dist/vitest/testClient.js

@@ -0,0 +1,98 @@
+import { createServer } from 'node:http';
+import {} from 'node:net';
+import { createFetch, HttpError, } from '@devmoods/fetch';
+import {} from 'express';
+import * as tough from 'tough-cookie';
+export async function createTestClient(server, options) {
+    // Express app
+    if ('route' in server) {
+        server = createServer(server);
+    }
+    let address = server.address();
+    /* c8 ignore next 5 */
+    if (typeof address === 'string') {
+        throw new Error(`Can't use a server listening on a UNIX domain socket: ${address}`);
+    }
+    let started = false;
+    if (address == null) {
+        await new Promise((resolve) => {
+            server.once('listening', resolve);
+            server.listen(0);
+        });
+        started = true;
+        address = server.address();
+    }
+    const cookieJar = new tough.CookieJar();
+    const fetch = createFetch({
+        getRootUrl: () => `http://localhost:${address.port}`,
+        redirect: 'manual',
+        ...options,
+    });
+    fetch.intercept({
+        request: async (req) => {
+            req.headers.set('cookie', await cookieJar.getCookieString(req.url));
+        },
+        response: async (response) => {
+            const cookies = response.headers.getSetCookie();
+            await Promise.all(cookies.map(async (cookie) => await cookieJar.setCookie(cookie, response.url, {
+                ignoreError: false,
+            })));
+        },
+    });
+    const post = async (url, opt) => {
+        return fetch(url, { method: 'POST', ...opt }).catch((e) => {
+            if (e instanceof HttpError) {
+                return e.response;
+            }
+            throw e;
+        });
+    };
+    post.intercept = fetch.intercept;
+    const get = async (url, opt) => {
+        return fetch(url, { method: 'GET', ...opt }).catch((e) => {
+            if (e instanceof HttpError) {
+                return e.response;
+            }
+            throw e;
+        });
+    };
+    get.intercept = fetch.intercept;
+    const put = async (url, opt) => {
+        return fetch(url, { method: 'PUT', ...opt }).catch((e) => {
+            if (e instanceof HttpError) {
+                return e.response;
+            }
+            throw e;
+        });
+    };
+    put.intercept = fetch.intercept;
+    const delete_ = async (url, opt) => {
+        return fetch(url, { method: 'DELETE', ...opt }).catch((e) => {
+            if (e instanceof HttpError) {
+                return e.response;
+            }
+            throw e;
+        });
+    };
+    delete_.intercept = fetch.intercept;
+    const close = async () => {
+        if (started) {
+            server.close();
+        }
+    };
+    return {
+        duplicate() {
+            return createTestClient(server, options);
+        },
+        cookieJar,
+        fetch,
+        post,
+        get,
+        put,
+        delete: delete_,
+        close,
+        [Symbol.asyncDispose]: async () => {
+            await close();
+        },
+    };
+}

package/dist/webapi.js

@@ -4,6 +4,7 @@ export function createFetchHeaders(requestHeaders) {
     const headers = new Headers();
     for (const [key, values] of Object.entries(requestHeaders)) {
         if (values) {
+            /* c8 ignore next 4 */
             if (Array.isArray(values)) {
                 for (const value of values) {
                     headers.append(key, value);
@@ -20,8 +21,10 @@ export function createFetchRequest(req) {
     try {
         const origin = `${req.protocol}://${req.get('host')}`;
         // Note: This had to take originalUrl into account for presumably vite's proxying
+        /* c8 ignore next 1 */
         const url = new URL(req.originalUrl || req.url, origin);
         const controller = new AbortController();
+        /* c8 ignore next 3 */
         req.on('close', () => {
             controller.abort();
         });
@@ -34,6 +37,7 @@ export function createFetchRequest(req) {
             init.body = req.body;
         }
         return new Request(url.href, init);
+        /* c8 ignore next 7 */
     }
     catch (error) {
         if (error instanceof TypeError) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devmoods/express-extras",
-  "version": "0.64.0",
+  "version": "0.65.1",
   "description": "Kubernetes-ready utilities for rapid Node.js application development",
   "type": "module",
   "main": "./dist/index.js",
@@ -12,10 +12,16 @@
         "default": "./dist/index.js"
       }
     },
+    "./config": {
+      "import": {
+        "types": "./dist/config.d.ts",
+        "default": "./dist/config.js"
+      }
+    },
     "./vite": {
       "import": {
         "types": "./dist/vite/vite.d.ts",
-        "default": "./dist/vite.js"
+        "default": "./dist/vite/index.js"
       }
     },
     "./vite/ssr": {
@@ -37,9 +43,13 @@
       }
     }
   },
-  "author": {
-    "name": "hanse",
-    "email": "hanse@koren.im"
+  "scripts": {
+    "clean": "rm -rf dist",
+    "lint": "eslint",
+    "test": "NODE_ENV=test DOTENV_CONFIG_PATH=.env.test vitest",
+    "test:coverage": "pnpm run test --coverage",
+    "build": "pnpm run clean && tsc",
+    "prepublishOnly": "pnpm run clean && pnpm run build"
   },
   "repository": {
     "type": "git",
@@ -50,40 +60,31 @@
   ],
   "license": "ISC",
   "devDependencies": {
-    "@devmoods/eslint-config": "^2.12.0",
     "@types/koa-compose": "^3.2.8",
-    "@types/node": "24.3.1",
-    "@types/supertest": "^6.0.3",
-    "@vitejs/plugin-react": "^5.0.2",
-    "@vitest/coverage-v8": "^3.2.4",
+    "@vitejs/plugin-react": "^5.0.3",
     "arktype": "^2.1.22",
-    "cookiejar": "^2.1.4",
-    "eslint": "^9.35.0",
     "faktory-worker": "^4.7.1",
-    "prettier": "3.6.2",
-    "supertest": "7.1.4",
-    "ts-node": "10.9.2",
-    "tsx": "^4.20.5",
-    "typescript": "5.9.2",
-    "vite": "^7.1.5",
-    "vitest": "^3.2.4",
-    "vitest-fail-on-console": "^0.10.1"
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1",
+    "vite": "^7.1.7"
   },
   "dependencies": {
+    "@devmoods/config": "0.1.1",
     "@devmoods/fetch": "^4.2.0",
-    "@hey-api/openapi-ts": "^0.83.1",
-    "@sentry/node": "^10.11.0",
-    "@sentry/profiling-node": "^10.11.0",
+    "@devmoods/observability": "0.1.1",
+    "@devmoods/postgres": "0.1.1",
+    "@hey-api/openapi-ts": "^0.84.3",
+    "@sentry/node": "^10.15.0",
+    "@sentry/node-native": "^10.15.0",
+    "@sentry/profiling-node": "^10.15.0",
     "@standard-schema/spec": "^1.0.0",
     "@types/bcrypt": "^6.0.0",
     "@types/cookie-parser": "^1.4.9",
     "@types/express": "^5.0.3",
     "@types/jsonwebtoken": "^9.0.10",
     "@types/nodemailer": "^7.0.1",
-    "@types/pg": "^8.15.5",
     "@types/qs": "^6.14.0",
     "@types/superagent": "^8.1.9",
-    "@types/uuid": "^10.0.0",
     "ajv": "^8.17.1",
     "argon2": "^0.44.0",
     "bcrypt": "^6.0.0",
@@ -97,15 +98,11 @@
     "helmet": "^8.1.0",
     "jsonwebtoken": "^9.0.2",
     "nodemailer": "^7.0.6",
-    "pg": "^8.16.3",
-    "pg-structure": "^7.15.3",
     "redis": "^5.8.2",
     "sonda": "^0.9.0",
-    "sql-formatter": "^15.6.9",
-    "uuid": "^13.0.0"
-  },
-  "prettier": {
-    "singleQuote": true
+    "tough-cookie": "^6.0.0",
+    "uuid": "^13.0.0",
+    "vitest-fail-on-console": "^0.10.1"
   },
   "peerDependencies": {
     "@vitejs/plugin-react": ">=4.3.4",
@@ -117,13 +114,5 @@
   "engines": {
     "node": ">=20 <25"
   },
-  "scripts": {
-    "start": "pushd example; pnpm run start --watch; popd example;",
-    "start:worker": "pushd example; pnpm run start:worker; popd example;",
-    "clean": "rm -rf dist",
-    "lint": "eslint",
-    "test": "./test.sh",
-    "build": "pnpm run clean && tsc --project tsconfig.build.json",
-    "format": "prettier --write '**/*.{js,css,md,ts,tsx}'"
-  }
-}
+  "gitHead": "916426bf70f924d62e9dfaccbb22145d41eece28"
+}

package/dist/__tests__/__migrations__/1_a.d.ts

@@ -1,3 +0,0 @@
-import { type Connection } from '../../postgres.js';
-export declare function up(query: Connection['query']): Promise<void>;
-export declare function down(query: Connection['query']): Promise<void>;

package/dist/__tests__/__migrations__/1_a.js

@@ -1,9 +0,0 @@
-import {} from '../../postgres.js';
-export async function up(query) {
-    await query('CREATE TABLE baz (id serial primary key)');
-    await query('CREATE TABLE foo (id serial primary key)');
-}
-export async function down(query) {
-    await query('DROP TABLE foo');
-    await query('DROP TABLE baz');
-}

package/dist/migrate.d.ts

@@ -1,47 +0,0 @@
-import { type Command } from 'commander';
-import { type CLI } from './cli.js';
-import { createPostgres } from './postgres.js';
-interface Migration {
-    name: string;
-    filename: string;
-    version: number;
-}
-interface MigrationFileAPI {
-    useTransaction?: boolean;
-    up(fn: any): Promise<void> | Promise<void> | string | undefined;
-    down(fn: any): Promise<string> | Promise<void> | string | undefined;
-}
-export declare const asCli: (command: Command, cli: CLI) => void;
-export interface MigratorOptions {
-    postgres?: ReturnType<typeof createPostgres>;
-    migrationTableName?: string;
-    verbose?: boolean;
-    pathToMigrations?: string;
-}
-export declare class Migrator {
-    private postgres;
-    private migrationTableName;
-    private pathToMigrations;
-    private filenameRegExp;
-    private verbose;
-    constructor({ postgres, pathToMigrations, migrationTableName, verbose, }?: MigratorOptions);
-    end(): Promise<void>;
-    init(): Promise<boolean>;
-    isInstalled(): Promise<boolean>;
-    create(name: string | null | undefined, format?: 'ts' | 'sql'): Promise<string>;
-    runMigrations(direction: 'up' | 'down'): Promise<number>;
-    log(...args: any[]): void;
-    executeMigration(migrations: Migration[], currentVersion: number, direction: 'up' | 'down'): Promise<number>;
-    readMigrationFile(filename: string): Promise<MigrationFileAPI>;
-    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;
-        version: number;
-        name: string;
-    }[]>;
-    getPreviousMigrations(migrations: Migration[], currentVersion: number): Migration[];
-    getPendingMigrations(migrations: Migration[], currentVersion: number): Migration[];
-}
-export {};

package/dist/migrate.js

@@ -1,255 +0,0 @@
-import { promises as fs } from 'node:fs';
-import * as path from 'node:path';
-import chalk from 'chalk';
-import {} from 'commander';
-import {} from './cli.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();
-        try {
-            await migrator.runMigrations('up');
-        }
-        finally {
-            await migrator.end();
-        }
-    }));
-    command.command('down').action(cli.wrap(async () => {
-        const migrator = new Migrator();
-        try {
-            await migrator.runMigrations('down');
-        }
-        finally {
-            await migrator.end();
-        }
-    }));
-    command.command('init').action(cli.wrap(async () => {
-        const migrator = new Migrator();
-        try {
-            const created = await migrator.init();
-            if (created) {
-                cli.greenLine('Migrations table was successfully setup.');
-            }
-            else {
-                cli.greenLine('Migrations table already existing.');
-            }
-        }
-        finally {
-            await migrator.end();
-        }
-    }));
-    command
-        .command('create')
-        .argument('<string>', 'name of migration')
-        .option('--typescript', 'use typescript')
-        .action(cli.wrap(async (name, flags) => {
-        const migrator = new Migrator();
-        try {
-            const createdMigration = await migrator.create(name, flags.typescript ? 'ts' : 'sql');
-            migrator.log(chalk.green('Created migration', createdMigration));
-        }
-        finally {
-            await migrator.end();
-        }
-    }));
-};
-export class Migrator {
-    postgres;
-    migrationTableName;
-    pathToMigrations;
-    filenameRegExp = /(\d+)_(.*)\.(js|ts|mjs|mts|sql)/;
-    verbose;
-    constructor({ postgres = createPostgres({ onLogStatement: () => { } }), pathToMigrations = path.resolve(process.cwd(), 'db', 'migrations'), migrationTableName = 'migrations', verbose = true, } = {}) {
-        this.postgres = postgres;
-        this.pathToMigrations = pathToMigrations;
-        this.migrationTableName = migrationTableName;
-        this.verbose = verbose;
-    }
-    end() {
-        return this.postgres.end();
-    }
-    async init() {
-        if (await this.isInstalled()) {
-            return false;
-        }
-        await fs.mkdir(this.pathToMigrations, { recursive: true });
-        await this.postgres.query(sql `
-      CREATE TABLE IF NOT EXISTS ${sql.identifier(this.migrationTableName)} (
-        id bigserial PRIMARY KEY,
-        version int NOT NULL,
-        run_at timestamp with time zone NOT NULL
-      );
-    `);
-        return true;
-    }
-    async isInstalled() {
-        try {
-            await this.postgres.query(sql `SELECT * FROM ${sql.identifier(this.migrationTableName)}`);
-            await fs.stat(this.pathToMigrations);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async create(name, format = 'sql') {
-        if (!name) {
-            throw new Error('Missing positional argument <name>');
-        }
-        if (!(await this.isInstalled())) {
-            await this.init();
-        }
-        const existingMigrations = await this.getMigrations();
-        const lastVersion = existingMigrations.length
-            ? existingMigrations[existingMigrations.length - 1].version
-            : 0;
-        const filename = path.join(this.pathToMigrations, `${lastVersion + 1}_${name}.${format}`);
-        const getTemplate = () => {
-            switch (format) {
-                case 'sql':
-                    return `-- Migration ${name} created ${new Date()}\n\nSELECT 1;\n\n-- ROLLBACK --\n\nSELECT 1;\n`;
-                case 'ts':
-                    return `// Migration ${name} created ${new Date()}\n\nexport function up(query: any) {}\n\nexport function down(query: any) {}\n`;
-            }
-        };
-        await fs.writeFile(filename, getTemplate());
-        return filename;
-    }
-    async runMigrations(direction) {
-        if (direction !== 'up' && direction !== 'down') {
-            throw new Error('Only up and down are supported.');
-        }
-        if (!(await this.isInstalled())) {
-            await this.init();
-        }
-        const migrations = await this.getMigrations();
-        const currentVersion = await this.getCurrentVersion();
-        return this.executeMigration(migrations, currentVersion, direction);
-    }
-    log(...args) {
-        if (this.verbose) {
-            console.log(...args);
-        }
-    }
-    async executeMigration(migrations, currentVersion, direction) {
-        if (direction === 'up') {
-            const pendingMigrations = this.getPendingMigrations(migrations, currentVersion);
-            if (!pendingMigrations.length) {
-                this.log(chalk.green('No pending migrations'));
-                return currentVersion;
-            }
-            for (const migration of pendingMigrations) {
-                this.log('Running migration', migration.filename);
-                const migrator = await this.readMigrationFile(migration.filename);
-                if (migrator.useTransaction !== false) {
-                    await this.postgres.transaction(async () => {
-                        await this.migrate(migrator, direction);
-                        await this.updateCurrentVersion(migration.version);
-                    });
-                }
-                else {
-                    await this.postgres.withConnection(async () => {
-                        await this.migrate(migrator, direction);
-                        await this.updateCurrentVersion(migration.version);
-                    });
-                }
-            }
-            this.log(chalk.green('Done!'));
-            return await this.getCurrentVersion();
-        }
-        else if (direction === 'down') {
-            const previousMigrations = this.getPreviousMigrations(migrations, currentVersion);
-            const previousMigration = previousMigrations[0];
-            const updatedVersion = previousMigration ? previousMigration.version : 0;
-            const migrationToRollback = migrations.find((migration) => migration.version === currentVersion);
-            if (!migrationToRollback) {
-                this.log(chalk.green('No migrations have been run, so nothing to rollback to.'));
-                return currentVersion;
-            }
-            this.log('Rolling back migration', migrationToRollback.filename);
-            const migrator = await this.readMigrationFile(migrationToRollback.filename);
-            if (migrator.useTransaction !== false) {
-                await this.postgres.transaction(async () => {
-                    await this.migrate(migrator, 'down');
-                    await this.updateCurrentVersion(updatedVersion);
-                });
-            }
-            else {
-                await this.postgres.withConnection(async () => {
-                    await this.migrate(migrator, 'down');
-                    await this.updateCurrentVersion(updatedVersion);
-                });
-            }
-            return await this.getCurrentVersion();
-            /* c8 ignore next 2 */
-        }
-        throw new Error(`Invalid direction ${direction}`);
-    }
-    async readMigrationFile(filename) {
-        if (!filename.endsWith('.sql')) {
-            return import(filename);
-        }
-        const content = await fs.readFile(filename, 'utf-8');
-        const [up, down] = content.split(/[-\s]+ROLLBACK[-\s]+/i);
-        return {
-            useTransaction: !/[-\s]+NO[\s]*TRANSACTION[-\s]+/i.test(content),
-            up() {
-                return up.trim();
-            },
-            down() {
-                return (down || '').trim();
-            },
-        };
-    }
-    async migrate(migrator, direction) {
-        try {
-            const queryWithLog = (statement) => {
-                this.log(chalk.yellow(formatSql(statement)));
-                return this.postgres.query(statement);
-            };
-            const returnValue = await migrator[direction](queryWithLog.bind(this.postgres));
-            if (typeof returnValue === 'string') {
-                if (returnValue !== '') {
-                    await queryWithLog(returnValue);
-                }
-            }
-            else {
-                await returnValue;
-            }
-            /* c8 ignore next 3 */
-        }
-        catch (error) {
-            throw new Error(`Migration failed: ${error.message}`);
-        }
-    }
-    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`);
-        return result ? result.version : 0;
-    }
-    async getMigrations() {
-        const files = await fs.readdir(this.pathToMigrations);
-        return files
-            .map((filename) => filename.match(this.filenameRegExp))
-            .filter(notNullOrUndefined)
-            .map(([filename, version, name]) => ({
-            filename: path.join(this.pathToMigrations, filename),
-            version: parseInt(version, 10),
-            name,
-        }))
-            .sort((a, b) => a.version - b.version);
-    }
-    getPreviousMigrations(migrations, currentVersion) {
-        const reversedMigrations = migrations.reverse();
-        return reversedMigrations.filter((migration) => migration.version < currentVersion);
-    }
-    getPendingMigrations(migrations, currentVersion) {
-        return migrations.filter((migration) => migration.version > currentVersion);
-    }
-}
-function notNullOrUndefined(x) {
-    return x != null;
-}

package/dist/postgres-ts-generator.d.ts

@@ -1,11 +0,0 @@
-export interface GenerateDatabaseTypesOptions {
-    outputPath: string;
-    connectionString: string;
-    schema?: string;
-    excludeTables?: string[];
-    includeTables?: string[];
-}
-/**
- * Generates complete TypeScript definitions from database schema
- */
-export declare function generateDatabaseTypes(options: GenerateDatabaseTypesOptions): Promise<void>;