@stonyx/orm 0.2.1-beta.82 → 0.2.1-beta.84

package/src/postgres/connection.ts

@@ -0,0 +1,46 @@
+import type { Pool as PgPool } from 'pg';
+
+interface PgConfig {
+  host: string;
+  port: number;
+  user: string;
+  password: string;
+  database: string;
+  connectionLimit: number;
+}
+
+let pool: PgPool | null = null;
+
+/**
+ * Create or return the singleton pg Pool.
+ */
+export async function getPool(pgConfig: PgConfig, extensions: string[] = ['vector']): Promise<PgPool> {
+  if (pool) return pool;
+
+  const { default: pg } = await import('pg');
+
+  pool = new pg.Pool({
+    host: pgConfig.host,
+    port: pgConfig.port,
+    user: pgConfig.user,
+    password: pgConfig.password,
+    database: pgConfig.database,
+    max: pgConfig.connectionLimit,
+    idleTimeoutMillis: 30000,
+    connectionTimeoutMillis: 10000,
+  });
+
+  // Enable requested PostgreSQL extensions
+  for (const ext of extensions) {
+    await pool.query(`CREATE EXTENSION IF NOT EXISTS ${ext}`);
+  }
+
+  return pool;
+}
+
+export async function closePool(): Promise<void> {
+  if (!pool) return;
+
+  await pool.end();
+  pool = null;
+}

package/src/postgres/{migration-generator.js → migration-generator.ts}

@@ -3,9 +3,53 @@ import { readFile, createFile, createDirectory, fileExists } from '@stonyx/utils
 import path from 'path';
 import config from 'stonyx/config';
 import log from 'stonyx/log';
+import type { ForeignKeyDef, SnapshotEntry } from '../types/orm-types.js';
 
-export async function generateMigration(description = 'migration') {
-  const { migrationsDir } = config.orm.postgres;
+interface ColumnChange {
+  model: string;
+  column: string;
+  type: string;
+}
+
+interface ColumnTypeChange {
+  model: string;
+  column: string;
+  from: string;
+  to: string;
+}
+
+interface ForeignKeyChange {
+  model: string;
+  column: string;
+  references: ForeignKeyDef;
+}
+
+interface DiffResult {
+  hasChanges: boolean;
+  addedModels: string[];
+  removedModels: string[];
+  addedColumns: ColumnChange[];
+  removedColumns: ColumnChange[];
+  changedColumns: ColumnTypeChange[];
+  addedForeignKeys: ForeignKeyChange[];
+  removedForeignKeys: ForeignKeyChange[];
+}
+
+interface ViewDiffResult {
+  hasChanges: boolean;
+  addedViews: string[];
+  removedViews: string[];
+  changedViews: string[];
+}
+
+interface MigrationResult {
+  filename: string;
+  content: string;
+  snapshot: Record<string, unknown>;
+}
+
+export async function generateMigration(description: string = 'migration', configKey: string = 'postgres'): Promise<MigrationResult | null> {
+  const { migrationsDir } = config.orm[configKey] as { migrationsDir: string };
   const rootPath = config.rootPath;
   const migrationsPath = path.resolve(rootPath, migrationsDir);
 
@@ -13,10 +57,10 @@ export async function generateMigration(description = 'migration') {
 
   const schemas = introspectModels();
   const currentSnapshot = schemasToSnapshot(schemas);
-  const previousSnapshot = await loadLatestSnapshot(migrationsPath);
+  const previousSnapshot = await loadLatestSnapshot(migrationsPath) as Record<string, SnapshotEntry>;
   const diff = diffSnapshots(previousSnapshot, currentSnapshot);
 
-  // Don't return early — check view changes too before deciding
+  // Don't return early -- check view changes too before deciding
   if (!diff.hasChanges) {
     const viewSchemasPrelim = introspectViews();
     const currentViewSnapshotPrelim = viewSchemasToSnapshot(viewSchemasPrelim);
@@ -24,20 +68,20 @@ export async function generateMigration(description = 'migration') {
     const viewDiffPrelim = diffViewSnapshots(previousViewSnapshotPrelim, currentViewSnapshotPrelim);
 
     if (!viewDiffPrelim.hasChanges) {
-      log.db('No schema changes detected.');
+      log.db!('No schema changes detected.');
       return null;
     }
   }
 
-  const upStatements = [];
-  const downStatements = [];
+  const upStatements: string[] = [];
+  const downStatements: string[] = [];
 
   // pgvector extension (include in initial migration)
   if (Object.keys(previousSnapshot).length === 0) {
     upStatements.push('CREATE EXTENSION IF NOT EXISTS vector;');
   }
 
-  // New tables — in topological order (parents before children)
+  // New tables -- in topological order (parents before children)
   const allOrder = getTopologicalOrder(schemas);
   const addedOrdered = allOrder.filter(name => diff.addedModels.includes(name));
 
@@ -74,7 +118,7 @@ export async function generateMigration(description = 'migration') {
 
   // Removed columns
   for (const { model, column, type } of diff.removedColumns) {
-    const table = previousSnapshot[model].table;
+    const table = previousSnapshot[model].table!;
     upStatements.push(`ALTER TABLE "${table}" DROP COLUMN "${column}";`);
     downStatements.push(`ALTER TABLE "${table}" ADD COLUMN "${column}" ${type};`);
   }
@@ -100,7 +144,7 @@ export async function generateMigration(description = 'migration') {
 
   // Removed foreign keys
   for (const { model, column, references } of diff.removedForeignKeys) {
-    const table = previousSnapshot[model].table;
+    const table = previousSnapshot[model].table!;
     const refModel = Object.entries(previousSnapshot).find(([, s]) => s.table === references.references);
     const fkType = refModel && refModel[1].idType === 'string' ? 'VARCHAR(255)' : 'INTEGER';
     const constraintName = `fk_${table}_${column}`;
@@ -110,7 +154,7 @@ export async function generateMigration(description = 'migration') {
     downStatements.push(`ALTER TABLE "${table}" ADD CONSTRAINT "${constraintName}" FOREIGN KEY ("${column}") REFERENCES "${references.references}"("${references.column}") ON DELETE SET NULL;`);
   }
 
-  // View migrations — views are created AFTER tables (dependency order)
+  // View migrations -- views are created AFTER tables (dependency order)
   const viewSchemas = introspectViews();
   const currentViewSnapshot = viewSchemasToSnapshot(viewSchemas);
   const previousViewSnapshot = extractViewsFromSnapshot(previousSnapshot);
@@ -129,7 +173,7 @@ export async function generateMigration(description = 'migration') {
         upStatements.push(ddl + ';');
         downStatements.unshift(`DROP VIEW IF EXISTS "${viewSchemas[name].viewName}";`);
       } catch (error) {
-        upStatements.push(`-- WARNING: Could not generate DDL for view '${name}': ${error.message}`);
+        upStatements.push(`-- WARNING: Could not generate DDL for view '${name}': ${error instanceof Error ? error.message : String(error)}`);
       }
     }
 
@@ -146,7 +190,7 @@ export async function generateMigration(description = 'migration') {
         const ddl = buildViewDDL(name, viewSchemas[name], schemas);
         upStatements.push(ddl + ';');
       } catch (error) {
-        upStatements.push(`-- WARNING: Could not generate DDL for changed view '${name}': ${error.message}`);
+        upStatements.push(`-- WARNING: Could not generate DDL for changed view '${name}': ${error instanceof Error ? error.message : String(error)}`);
       }
     }
   }
@@ -154,12 +198,12 @@ export async function generateMigration(description = 'migration') {
   const combinedHasChanges = diff.hasChanges || viewDiff.hasChanges;
 
   if (!combinedHasChanges) {
-    log.db('No schema changes detected.');
+    log.db!('No schema changes detected.');
     return null;
   }
 
   // Merge view snapshot into the main snapshot
-  const combinedSnapshot = { ...currentSnapshot };
+  const combinedSnapshot: Record<string, unknown> = { ...currentSnapshot };
   for (const [name, viewSnap] of Object.entries(currentViewSnapshot)) {
     combinedSnapshot[name] = viewSnap;
   }
@@ -172,28 +216,28 @@ export async function generateMigration(description = 'migration') {
   await createFile(path.join(migrationsPath, filename), content);
   await createFile(path.join(migrationsPath, '.snapshot.json'), JSON.stringify(combinedSnapshot, null, 2));
 
-  log.db(`Migration generated: ${filename}`);
+  log.db!(`Migration generated: ${filename}`);
 
   return { filename, content, snapshot: combinedSnapshot };
 }
 
-export async function loadLatestSnapshot(migrationsPath) {
+export async function loadLatestSnapshot(migrationsPath: string): Promise<Record<string, unknown>> {
   const snapshotPath = path.join(migrationsPath, '.snapshot.json');
   const exists = await fileExists(snapshotPath);
 
   if (!exists) return {};
 
-  return readFile(snapshotPath, { json: true });
+  return readFile(snapshotPath, { json: true }) as Promise<Record<string, unknown>>;
 }
 
-export function diffSnapshots(previous, current) {
-  const addedModels = [];
-  const removedModels = [];
-  const addedColumns = [];
-  const removedColumns = [];
-  const changedColumns = [];
-  const addedForeignKeys = [];
-  const removedForeignKeys = [];
+export function diffSnapshots(previous: Record<string, SnapshotEntry>, current: Record<string, SnapshotEntry>): DiffResult {
+  const addedModels: string[] = [];
+  const removedModels: string[] = [];
+  const addedColumns: ColumnChange[] = [];
+  const removedColumns: ColumnChange[] = [];
+  const changedColumns: ColumnTypeChange[] = [];
+  const addedForeignKeys: ForeignKeyChange[] = [];
+  const removedForeignKeys: ForeignKeyChange[] = [];
 
   // Find added models
   for (const name of Object.keys(current)) {
@@ -209,8 +253,8 @@ export function diffSnapshots(previous, current) {
   for (const name of Object.keys(current)) {
     if (!previous[name]) continue;
 
-    const { columns: prevCols = {} } = previous[name];
-    const { columns: currCols = {} } = current[name];
+    const prevCols: Record<string, string> = previous[name].columns || {};
+    const currCols: Record<string, string> = current[name].columns || {};
 
     // Added columns
     for (const [col, type] of Object.entries(currCols)) {
@@ -229,8 +273,8 @@ export function diffSnapshots(previous, current) {
     }
 
     // Foreign key changes
-    const prevFKs = previous[name].foreignKeys || {};
-    const currFKs = current[name].foreignKeys || {};
+    const prevFKs: Record<string, ForeignKeyDef> = previous[name].foreignKeys || {};
+    const currFKs: Record<string, ForeignKeyDef> = current[name].foreignKeys || {};
 
     for (const [col, refs] of Object.entries(currFKs)) {
       if (!prevFKs[col]) {
@@ -261,23 +305,23 @@ export function diffSnapshots(previous, current) {
   };
 }
 
-export function detectSchemaDrift(schemas, snapshot) {
-  const current = schemasToSnapshot(schemas);
+export function detectSchemaDrift(schemas: Record<string, unknown>, snapshot: Record<string, SnapshotEntry>): DiffResult {
+  const current = schemasToSnapshot(schemas as Parameters<typeof schemasToSnapshot>[0]);
   return diffSnapshots(snapshot, current);
 }
 
-export function extractViewsFromSnapshot(snapshot) {
-  const views = {};
+export function extractViewsFromSnapshot(snapshot: Record<string, SnapshotEntry>): Record<string, SnapshotEntry> {
+  const views: Record<string, SnapshotEntry> = {};
   for (const [name, entry] of Object.entries(snapshot)) {
     if (entry.isView) views[name] = entry;
   }
   return views;
 }
 
-export function diffViewSnapshots(previous, current) {
-  const addedViews = [];
-  const removedViews = [];
-  const changedViews = [];
+export function diffViewSnapshots(previous: Record<string, SnapshotEntry>, current: Record<string, SnapshotEntry>): ViewDiffResult {
+  const addedViews: string[] = [];
+  const removedViews: string[] = [];
+  const changedViews: string[] = [];
 
   for (const name of Object.keys(current)) {
     if (!previous[name]) {

package/src/postgres/{migration-runner.js → migration-runner.ts}

@@ -1,8 +1,9 @@
 import { readFile, fileExists } from '@stonyx/utils/file';
 import path from 'path';
 import fs from 'fs/promises';
+import type { Pool, PoolClient } from 'pg';
 
-export async function ensureMigrationsTable(pool, tableName = '__migrations') {
+export async function ensureMigrationsTable(pool: Pool, tableName: string = '__migrations'): Promise<void> {
   await pool.query(`
     CREATE TABLE IF NOT EXISTS "${tableName}" (
       id INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
@@ -12,15 +13,15 @@ export async function ensureMigrationsTable(pool, tableName = '__migrations') {
   `);
 }
 
-export async function getAppliedMigrations(pool, tableName = '__migrations') {
+export async function getAppliedMigrations(pool: Pool, tableName: string = '__migrations'): Promise<string[]> {
   const result = await pool.query(
     `SELECT filename FROM "${tableName}" ORDER BY id ASC`
   );
 
-  return result.rows.map(row => row.filename);
+  return result.rows.map(row => row.filename as string);
 }
 
-export async function getMigrationFiles(migrationsDir) {
+export async function getMigrationFiles(migrationsDir: string): Promise<string[]> {
   const exists = await fileExists(migrationsDir);
   if (!exists) return [];
 
@@ -31,7 +32,7 @@ export async function getMigrationFiles(migrationsDir) {
     .sort();
 }
 
-export function parseMigrationFile(content) {
+export function parseMigrationFile(content: string): { up: string; down: string } {
   const upMarker = '-- UP';
   const downMarker = '-- DOWN';
   const upIndex = content.indexOf(upMarker);
@@ -49,8 +50,8 @@ export function parseMigrationFile(content) {
   return { up, down };
 }
 
-export async function applyMigration(pool, filename, upSql, tableName = '__migrations') {
-  const client = await pool.connect();
+export async function applyMigration(pool: Pool, filename: string, upSql: string, tableName: string = '__migrations'): Promise<void> {
+  const client: PoolClient = await pool.connect();
 
   try {
     await client.query('BEGIN');
@@ -75,8 +76,8 @@ export async function applyMigration(pool, filename, upSql, tableName = '__migra
   }
 }
 
-export async function rollbackMigration(pool, filename, downSql, tableName = '__migrations') {
-  const client = await pool.connect();
+export async function rollbackMigration(pool: Pool, filename: string, downSql: string, tableName: string = '__migrations'): Promise<void> {
+  const client: PoolClient = await pool.connect();
 
   try {
     await client.query('BEGIN');
@@ -101,7 +102,7 @@ export async function rollbackMigration(pool, filename, downSql, tableName = '__
   }
 }
 
-function splitStatements(sql) {
+function splitStatements(sql: string): string[] {
   return sql
     .split(';')
     .map(s => s.trim())