@devmoods/express-extras 0.60.0 → 0.61.1

package/dist/manage.js

@@ -71,9 +71,9 @@ export function registerDefaultCommands(app) {
                     path: openApiFile,
                 },
                 output: {
-                    format: 'prettier',
+                    format: false,
                     path: options.output,
-                    lint: 'eslint',
+                    lint: false,
                     tsConfigPath: resolve('./tsconfig.json'),
                 },
                 plugins: [
@@ -91,4 +91,22 @@ export function registerDefaultCommands(app) {
             });
         }));
     });
+    registerManagementCommand((command, cli) => {
+        command('generate-db')
+            .option('--output <string>', 'Output file path', 'src/types/db.gen.ts')
+            .option('--connection <string>', 'Database connection string')
+            .action(cli.wrap(async (options) => {
+            const { generateDatabaseTypes } = await import('./postgres-ts-generator.js');
+            try {
+                await generateDatabaseTypes({
+                    outputPath: options.output,
+                    connectionString: options.connection || config.value.POSTGRES_URL,
+                });
+                cli.writeLine(`✅ Database types generated successfully at: ${options.output}\n`);
+            }
+            catch (error) {
+                cli.writeLine(`❌ Failed to generate database types: ${error}\n`);
+            }
+        }));
+    });
 }

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

@@ -0,0 +1,11 @@
+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>;

package/dist/postgres-ts-generator.js

@@ -0,0 +1,114 @@
+import { promises as fs } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import {} from 'pg-structure';
+import { pgStructure } from 'pg-structure/dist/main.js';
+/**
+ * Converts PostgreSQL data type to TypeScript type
+ */
+function pgTypeToTsType(pgType, isNullable) {
+    const nullableSuffix = isNullable ? ' | null' : '';
+    switch (pgType.name.toLowerCase()) {
+        case 'uuid':
+            return `string${nullableSuffix}`;
+        case 'text':
+        case 'varchar':
+        case 'char':
+        case 'character varying':
+            return `string${nullableSuffix}`;
+        case 'integer':
+        case 'int':
+        case 'int2':
+        case 'int4':
+        case 'int8':
+        case 'serial':
+        case 'smallint':
+            return `number${nullableSuffix}`;
+        case 'bigint':
+        case 'bigserial':
+        case 'decimal':
+        case 'numeric':
+            return `string${nullableSuffix}`;
+        case 'real':
+        case 'double precision':
+        case 'float':
+        case 'float4':
+        case 'float8':
+            return `number${nullableSuffix}`;
+        case 'boolean':
+        case 'bool':
+            return `boolean${nullableSuffix}`;
+        case 'timestamp':
+        case 'timestamp with time zone':
+        case 'timestamptz':
+            return `Date${nullableSuffix}`;
+        case 'date':
+            return `Date${nullableSuffix}`;
+        case 'time':
+        case 'time with time zone':
+            return `string${nullableSuffix}`;
+        case 'json':
+        case 'jsonb':
+            return `Record<string, any>${nullableSuffix}`;
+        case 'bytea':
+            return `Buffer${nullableSuffix}`;
+        case 'inet':
+        case 'cidr':
+            return `string${nullableSuffix}`;
+        case 'array':
+            return `any[]${nullableSuffix}`;
+        default:
+            return `any${nullableSuffix}`;
+    }
+}
+/**
+ * Generates TypeScript interface for a table
+ */
+function generateTableInterface(table, tableName) {
+    const interfaceName = tableName.charAt(0).toUpperCase() + tableName.slice(1);
+    let interfaceCode = `\n/**\n * ${interfaceName} table interface\n */\nexport interface ${interfaceName} {\n`;
+    for (const column of table.columns) {
+        const tsType = pgTypeToTsType(column.type, !column.notNull);
+        const comment = column.comment ? ` /** ${column.comment} */` : '';
+        interfaceCode += `  /** ${column.name} */\n  ${column.name}: ${tsType};${comment}\n`;
+    }
+    interfaceCode += '}\n';
+    return interfaceCode;
+}
+/**
+ * Generates complete TypeScript definitions from database schema
+ */
+export async function generateDatabaseTypes(options) {
+    const { outputPath, connectionString, schema = 'public', excludeTables = ['migrations', 'migration_lock'], includeTables, } = options;
+    // Connect to database and get schema
+    const db = await pgStructure(connectionString);
+    let output = `/**
+ * TypeScript definitions for database tables
+ * Auto-generated from database schema
+ */
+
+`;
+    const tables = db.schemas.get(schema)?.tables || [];
+    const filteredTables = tables.filter((table) => {
+        if (includeTables && includeTables.length > 0) {
+            return includeTables.includes(table.name);
+        }
+        return !excludeTables.includes(table.name);
+    });
+    // Generate table interfaces
+    for (const table of filteredTables) {
+        output += generateTableInterface(table, table.name);
+    }
+    // Generate DB interface
+    output +=
+        '\n/**\n * Database schema interface\n * Maps table names to their respective interfaces\n */\nexport interface DB {\n';
+    for (const table of filteredTables) {
+        const interfaceName = table.name.charAt(0).toUpperCase() + table.name.slice(1);
+        output += `  ${table.name}: ${interfaceName};\n`;
+    }
+    output += '}\n';
+    // Ensure output directory exists
+    const outputDir = dirname(resolve(outputPath));
+    await fs.mkdir(outputDir, { recursive: true });
+    // Write the generated types
+    await fs.writeFile(resolve(outputPath), output, 'utf-8');
+}

package/dist/routes.d.ts

@@ -21,6 +21,8 @@ export interface Key {
     optional: boolean;
     offset: number;
 }
+export declare function extractTagsFromPath(path: string): string[];
+export declare function convertPathToOperationId(method: string, path: string): string;
 export declare function toOpenAPISpec(app: Express, info?: {
     title: string;
     version: string;

package/dist/routes.js

@@ -143,9 +143,9 @@ const mapKeysToPath = (layerRegexPath, keys) => {
         .replace(/\\/gi, '')
         .replace(/\/{2,}/gi, '/');
 };
-function extractTagsFromPath(path) {
+export function extractTagsFromPath(path) {
     const segments = path
-        .replace(/^\/api\/v\d+\//, '') // Remove /api/v1, /api/v2, etc.
+        .replace(/^\/api(\/v\d+)?\//, '') // Remove /api, /api/v1, /api/v2, etc.
         .split('/')
         .filter(Boolean);
     if (segments.length === 0) {
@@ -155,12 +155,12 @@ function extractTagsFromPath(path) {
     const primaryTag = segments[0].charAt(0).toUpperCase() + segments[0].slice(1);
     return [primaryTag];
 }
-function convertPathToOperationId(method, path) {
+export function convertPathToOperationId(method, path) {
     // Clean the path and split into segments
     const segments = path
         .replace(/[{}]/g, '') // Remove OpenAPI parameter braces
         .replace(/[^a-zA-Z0-9/-]/g, '') // Keep hyphens, remove other non-alphanumeric chars
-        .replace(/^\/api\/v\d+\//, '') // Remove /api/v1, /api/v2, etc. prefixes
+        .replace(/^\/api(\/v\d+)?\//, '') // Remove /api, /api/v1, /api/v2, etc. prefixes
         .split('/') // Split by slashes
         .filter(Boolean) // Remove empty strings
         .map((segment) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devmoods/express-extras",
-  "version": "0.60.0",
+  "version": "0.61.1",
   "description": "Kubernetes-ready utilities for rapid Node.js application development",
   "type": "module",
   "main": "./dist/index.js",
@@ -92,6 +92,7 @@
     "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.6",