noormme 1.0.0

package/dist/esm/schema/builders/unique-constraint-builder.js

@@ -0,0 +1,42 @@
+/// <reference types="./unique-constraint-builder.d.ts" />
+import { UniqueConstraintNode } from '../../operation-node/unique-constraint-node.js';
+export class UniqueConstraintNodeBuilder {
+    #node;
+    constructor(node) {
+        this.#node = node;
+    }
+    /**
+     * Adds `nulls not distinct` to the unique constraint definition
+     *
+     * Supported by PostgreSQL dialect only
+     */
+    nullsNotDistinct() {
+        return new UniqueConstraintNodeBuilder(UniqueConstraintNode.cloneWith(this.#node, { nullsNotDistinct: true }));
+    }
+    deferrable() {
+        return new UniqueConstraintNodeBuilder(UniqueConstraintNode.cloneWith(this.#node, { deferrable: true }));
+    }
+    notDeferrable() {
+        return new UniqueConstraintNodeBuilder(UniqueConstraintNode.cloneWith(this.#node, { deferrable: false }));
+    }
+    initiallyDeferred() {
+        return new UniqueConstraintNodeBuilder(UniqueConstraintNode.cloneWith(this.#node, {
+            initiallyDeferred: true,
+        }));
+    }
+    initiallyImmediate() {
+        return new UniqueConstraintNodeBuilder(UniqueConstraintNode.cloneWith(this.#node, {
+            initiallyDeferred: false,
+        }));
+    }
+    /**
+     * Simply calls the provided function passing `this` as the only argument. `$call` returns
+     * what the provided function returns.
+     */
+    $call(func) {
+        return func(this);
+    }
+    toOperationNode() {
+        return this.#node;
+    }
+}

package/dist/esm/schema/core/coordinators/schema-discovery.coordinator.d.ts

@@ -0,0 +1,35 @@
+import type { Kysely } from '../../../kysely.js';
+import { SchemaInfo, IntrospectionConfig } from '../../../types/index.js';
+import type { Dialect } from '../../../dialect/dialect.js';
+import { DiscoveryFactory } from '../factories/discovery-factory.js';
+/**
+ * Central coordinator for schema discovery operations
+ * Uses factory pattern to create database-specific discovery services
+ */
+export declare class SchemaDiscoveryCoordinator {
+    private static instance;
+    private factory;
+    private currentDialect;
+    private constructor();
+    static getInstance(): SchemaDiscoveryCoordinator;
+    /**
+     * Discover the complete database schema using dialect-specific coordinator
+     */
+    discoverSchema(db: Kysely<any>, config?: IntrospectionConfig, dialect?: Dialect): Promise<SchemaInfo>;
+    /**
+     * Get the discovery factory instance
+     */
+    getFactory(): DiscoveryFactory;
+    /**
+     * Get current dialect
+     */
+    getCurrentDialect(): string;
+    /**
+     * Get dialect capabilities
+     */
+    getDialectCapabilities(): ReturnType<DiscoveryFactory['getDialectCapabilities']>;
+    /**
+     * Check if a dialect is supported
+     */
+    isDialectSupported(dialect: string): boolean;
+}

package/dist/esm/schema/core/coordinators/schema-discovery.coordinator.js

@@ -0,0 +1,60 @@
+/// <reference types="./schema-discovery.coordinator.d.ts" />
+import { DiscoveryFactory } from '../factories/discovery-factory.js';
+/**
+ * Central coordinator for schema discovery operations
+ * Uses factory pattern to create database-specific discovery services
+ */
+export class SchemaDiscoveryCoordinator {
+    static instance;
+    factory;
+    currentDialect = '';
+    constructor() {
+        this.factory = DiscoveryFactory.getInstance();
+    }
+    static getInstance() {
+        if (!SchemaDiscoveryCoordinator.instance) {
+            SchemaDiscoveryCoordinator.instance = new SchemaDiscoveryCoordinator();
+        }
+        return SchemaDiscoveryCoordinator.instance;
+    }
+    /**
+     * Discover the complete database schema using dialect-specific coordinator
+     */
+    async discoverSchema(db, config = {}, dialect) {
+        // Determine the dialect
+        const dialectName = dialect?.name || 'sqlite';
+        this.currentDialect = dialectName;
+        // Check if dialect is supported
+        if (!this.factory.isDialectSupported(dialectName)) {
+            throw new Error(`Unsupported database dialect: ${dialectName}`);
+        }
+        // Create dialect-specific discovery coordinator
+        const coordinator = this.factory.createDiscoveryCoordinator(dialectName);
+        // Delegate to dialect-specific coordinator
+        return await coordinator.discoverSchema(db, config);
+    }
+    /**
+     * Get the discovery factory instance
+     */
+    getFactory() {
+        return this.factory;
+    }
+    /**
+     * Get current dialect
+     */
+    getCurrentDialect() {
+        return this.currentDialect;
+    }
+    /**
+     * Get dialect capabilities
+     */
+    getDialectCapabilities() {
+        return this.factory.getDialectCapabilities(this.currentDialect);
+    }
+    /**
+     * Check if a dialect is supported
+     */
+    isDialectSupported(dialect) {
+        return this.factory.isDialectSupported(dialect);
+    }
+}

package/dist/esm/schema/core/discovery/relationship-discovery.d.ts

@@ -0,0 +1,36 @@
+import { TableInfo, RelationshipInfo } from '../../../types/index.js';
+/**
+ * Specialized service for discovering relationships between tables
+ */
+export declare class RelationshipDiscovery {
+    private static instance;
+    static getInstance(): RelationshipDiscovery;
+    /**
+     * Discover relationships between tables
+     */
+    discoverRelationships(tables: TableInfo[]): Promise<RelationshipInfo[]>;
+    /**
+     * Analyze relationship patterns
+     */
+    analyzeRelationshipPatterns(tables: TableInfo[]): {
+        oneToMany: number;
+        manyToMany: number;
+        selfReferencing: number;
+        circularReferences: string[];
+    };
+    /**
+     * Check if a table is a junction table (many-to-many)
+     */
+    private isJunctionTable;
+    /**
+     * Detect circular references in the relationship graph
+     */
+    private detectCircularReferences;
+    /**
+     * Validate relationships
+     */
+    validateRelationships(tables: TableInfo[]): {
+        isValid: boolean;
+        issues: string[];
+    };
+}

package/dist/esm/schema/core/discovery/relationship-discovery.js

@@ -0,0 +1,159 @@
+/// <reference types="./relationship-discovery.d.ts" />
+import { NameGenerator } from '../utils/name-generator.js';
+/**
+ * Specialized service for discovering relationships between tables
+ */
+export class RelationshipDiscovery {
+    static instance;
+    static getInstance() {
+        if (!RelationshipDiscovery.instance) {
+            RelationshipDiscovery.instance = new RelationshipDiscovery();
+        }
+        return RelationshipDiscovery.instance;
+    }
+    /**
+     * Discover relationships between tables
+     */
+    async discoverRelationships(tables) {
+        const relationships = [];
+        for (const table of tables) {
+            for (const fk of table.foreignKeys) {
+                // Find the referenced table
+                const referencedTable = tables.find(t => t.name === fk.referencedTable);
+                if (!referencedTable)
+                    continue;
+                // Create relationship name based on column name
+                const relationshipName = NameGenerator.generateRelationshipName(fk.column, fk.referencedTable);
+                // Determine relationship type
+                const isUnique = referencedTable.primaryKey?.includes(fk.referencedColumn) || false;
+                const relationshipType = isUnique ? 'many-to-one' : 'one-to-many';
+                relationships.push({
+                    name: relationshipName,
+                    type: relationshipType,
+                    fromTable: table.name,
+                    fromColumn: fk.column,
+                    toTable: fk.referencedTable,
+                    toColumn: fk.referencedColumn
+                });
+                // Add reverse relationship
+                const reverseName = NameGenerator.generateReverseRelationshipName(table.name, fk.column);
+                relationships.push({
+                    name: reverseName,
+                    type: relationshipType === 'many-to-one' ? 'one-to-many' : 'many-to-one',
+                    fromTable: fk.referencedTable,
+                    fromColumn: fk.referencedColumn,
+                    toTable: table.name,
+                    toColumn: fk.column
+                });
+            }
+        }
+        return relationships;
+    }
+    /**
+     * Analyze relationship patterns
+     */
+    analyzeRelationshipPatterns(tables) {
+        const patterns = {
+            oneToMany: 0,
+            manyToMany: 0,
+            selfReferencing: 0,
+            circularReferences: []
+        };
+        for (const table of tables) {
+            for (const fk of table.foreignKeys) {
+                // Check for self-referencing relationships
+                if (fk.referencedTable === table.name) {
+                    patterns.selfReferencing++;
+                }
+                // Check for many-to-many (junction tables)
+                const referencedTable = tables.find(t => t.name === fk.referencedTable);
+                if (referencedTable && this.isJunctionTable(table)) {
+                    patterns.manyToMany++;
+                }
+                else {
+                    patterns.oneToMany++;
+                }
+            }
+        }
+        // Detect circular references
+        patterns.circularReferences = this.detectCircularReferences(tables);
+        return patterns;
+    }
+    /**
+     * Check if a table is a junction table (many-to-many)
+     */
+    isJunctionTable(table) {
+        // Junction tables typically have:
+        // 1. Only foreign key columns (plus possibly a primary key)
+        // 2. Composite primary key
+        // 3. No other data columns
+        const hasOnlyFkColumns = table.columns.every(col => (col.isPrimaryKey ?? false) || (table.foreignKeys.some(fk => fk.column === col.name) ?? false));
+        const hasCompositePk = (table.primaryKey && table.primaryKey.length > 1) ?? false;
+        return hasOnlyFkColumns && hasCompositePk;
+    }
+    /**
+     * Detect circular references in the relationship graph
+     */
+    detectCircularReferences(tables) {
+        const circularRefs = [];
+        const visited = new Set();
+        const recursionStack = new Set();
+        const dfs = (tableName, path) => {
+            if (recursionStack.has(tableName)) {
+                const cycleStart = path.indexOf(tableName);
+                const cycle = path.slice(cycleStart).join(' -> ') + ` -> ${tableName}`;
+                circularRefs.push(cycle);
+                return;
+            }
+            if (visited.has(tableName))
+                return;
+            visited.add(tableName);
+            recursionStack.add(tableName);
+            const table = tables.find(t => t.name === tableName);
+            if (table) {
+                for (const fk of table.foreignKeys) {
+                    dfs(fk.referencedTable, [...path, tableName]);
+                }
+            }
+            recursionStack.delete(tableName);
+        };
+        for (const table of tables) {
+            if (!visited.has(table.name)) {
+                dfs(table.name, []);
+            }
+        }
+        return circularRefs;
+    }
+    /**
+     * Validate relationships
+     */
+    validateRelationships(tables) {
+        const issues = [];
+        const tableNames = new Set(tables.map(t => t.name));
+        for (const table of tables) {
+            for (const fk of table.foreignKeys) {
+                // Check if referenced table exists
+                if (!tableNames.has(fk.referencedTable)) {
+                    issues.push(`Foreign key '${fk.name}' in table '${table.name}' references non-existent table '${fk.referencedTable}'`);
+                }
+                // Check if referenced column exists in referenced table
+                const referencedTable = tables.find(t => t.name === fk.referencedTable);
+                if (referencedTable) {
+                    const referencedColumnExists = referencedTable.columns.some(col => col.name === fk.referencedColumn);
+                    if (!referencedColumnExists) {
+                        issues.push(`Foreign key '${fk.name}' in table '${table.name}' references non-existent column '${fk.referencedColumn}' in table '${fk.referencedTable}'`);
+                    }
+                }
+                // Check if foreign key column exists
+                const fkColumnExists = table.columns.some(col => col.name === fk.column);
+                if (!fkColumnExists) {
+                    issues.push(`Foreign key '${fk.name}' in table '${table.name}' references non-existent column '${fk.column}'`);
+                }
+            }
+        }
+        return {
+            isValid: issues.length === 0,
+            issues
+        };
+    }
+}

package/dist/esm/schema/core/discovery/table-metadata-discovery.d.ts

@@ -0,0 +1,29 @@
+import { DatabaseIntrospector } from '../../../dialect/database-introspector.js';
+import { TableInfo } from '../../../types/index.js';
+import { SchemaDiscoveryConfig } from '../types/schema-discovery-types.js';
+/**
+ * Specialized service for discovering table metadata
+ */
+export declare class TableMetadataDiscovery {
+    private static instance;
+    static getInstance(): TableMetadataDiscovery;
+    /**
+     * Discover all tables in the database
+     */
+    discoverTables(introspector: DatabaseIntrospector, config?: SchemaDiscoveryConfig): Promise<TableInfo[]>;
+    /**
+     * Process a single table to get its metadata
+     */
+    private processTable;
+    /**
+     * Get table statistics
+     */
+    getTableStatistics(introspector: DatabaseIntrospector, tableName: string): Promise<any>;
+    /**
+     * Validate table structure
+     */
+    validateTableStructure(table: TableInfo): {
+        isValid: boolean;
+        issues: string[];
+    };
+}

package/dist/esm/schema/core/discovery/table-metadata-discovery.js

@@ -0,0 +1,123 @@
+/// <reference types="./table-metadata-discovery.d.ts" />
+import { TypeMapper } from '../utils/type-mapper.js';
+/**
+ * Specialized service for discovering table metadata
+ */
+export class TableMetadataDiscovery {
+    static instance;
+    static getInstance() {
+        if (!TableMetadataDiscovery.instance) {
+            TableMetadataDiscovery.instance = new TableMetadataDiscovery();
+        }
+        return TableMetadataDiscovery.instance;
+    }
+    /**
+     * Discover all tables in the database
+     */
+    async discoverTables(introspector, config = {}) {
+        const tables = await introspector.getTables();
+        // Process tables in parallel to reduce total time
+        const tablePromises = tables.map(async (table) => {
+            return await this.processTable(table, introspector, config);
+        });
+        // Wait for all table processing to complete
+        const results = await Promise.all(tablePromises);
+        // Filter out null results and return valid table infos
+        return results.filter((table) => table !== null);
+    }
+    /**
+     * Process a single table to get its metadata
+     */
+    async processTable(table, introspector, config) {
+        // Skip excluded tables
+        if (config.excludeTables?.includes(table.name)) {
+            return null;
+        }
+        try {
+            // Get columns, indexes, and foreign keys for this table
+            const [columns, indexes, foreignKeys] = await Promise.all([
+                introspector.getColumns(table.name).catch(() => []),
+                introspector.getIndexes(table.name).catch(() => []),
+                introspector.getForeignKeys(table.name).catch(() => [])
+            ]);
+            // Find primary key columns
+            const primaryKeyColumns = columns
+                .filter((col) => col.isPrimaryKey)
+                .map((col) => col.name);
+            return {
+                name: table.name,
+                schema: table.schema,
+                columns: columns.map((col) => TypeMapper.mapColumnInfo(col, config.customTypeMappings)),
+                primaryKey: primaryKeyColumns.length > 0 ? primaryKeyColumns : undefined,
+                indexes: indexes.map((idx) => ({
+                    name: idx.name,
+                    columns: idx.columns,
+                    unique: idx.unique
+                })),
+                foreignKeys: foreignKeys.map((fk) => ({
+                    name: fk.name,
+                    column: fk.column,
+                    referencedTable: fk.referencedTable,
+                    referencedColumn: fk.referencedColumn,
+                    onDelete: fk.onDelete,
+                    onUpdate: fk.onUpdate
+                }))
+            };
+        }
+        catch (error) {
+            console.warn(`Failed to get metadata for table ${table.name}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Get table statistics
+     */
+    async getTableStatistics(introspector, tableName) {
+        try {
+            // This would be implemented based on the specific database dialect
+            // For now, return basic structure
+            return {
+                rowCount: 0,
+                size: 0,
+                lastModified: new Date(),
+                indexes: [],
+                constraints: []
+            };
+        }
+        catch (error) {
+            console.warn(`Failed to get statistics for table ${tableName}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Validate table structure
+     */
+    validateTableStructure(table) {
+        const issues = [];
+        // Check for required fields
+        if (!table.name) {
+            issues.push('Table name is required');
+        }
+        if (!table.columns || table.columns.length === 0) {
+            issues.push('Table must have at least one column');
+        }
+        // Check for duplicate column names
+        const columnNames = table.columns.map(col => col.name);
+        const duplicates = columnNames.filter((name, index) => columnNames.indexOf(name) !== index);
+        if (duplicates.length > 0) {
+            issues.push(`Duplicate column names found: ${duplicates.join(', ')}`);
+        }
+        // Check for valid primary key
+        if (table.primaryKey && table.primaryKey.length > 0) {
+            const primaryKeyColumns = table.primaryKey;
+            const invalidPkColumns = primaryKeyColumns.filter(pkCol => !table.columns.some(col => col.name === pkCol));
+            if (invalidPkColumns.length > 0) {
+                issues.push(`Primary key references non-existent columns: ${invalidPkColumns.join(', ')}`);
+            }
+        }
+        return {
+            isValid: issues.length === 0,
+            issues
+        };
+    }
+}

package/dist/esm/schema/core/discovery/view-discovery.d.ts

@@ -0,0 +1,36 @@
+import { DatabaseIntrospector } from '../../../dialect/database-introspector.js';
+import { ViewMetadata } from '../types/schema-discovery-types.js';
+/**
+ * Specialized service for discovering database views
+ */
+export declare class ViewDiscovery {
+    private static instance;
+    static getInstance(): ViewDiscovery;
+    /**
+     * Discover views in the database
+     */
+    discoverViews(introspector: DatabaseIntrospector): Promise<ViewMetadata[]>;
+    /**
+     * Get view definition for a specific view
+     */
+    getViewDefinition(introspector: DatabaseIntrospector, viewName: string): Promise<string | null>;
+    /**
+     * Check if a table metadata represents a view
+     */
+    private isView;
+    /**
+     * Validate view metadata
+     */
+    validateView(view: ViewMetadata): {
+        isValid: boolean;
+        issues: string[];
+    };
+    /**
+     * Analyze view dependencies
+     */
+    analyzeViewDependencies(views: ViewMetadata[]): Map<string, string[]>;
+    /**
+     * Extract table references from SQL definition
+     */
+    private extractTableReferences;
+}

package/dist/esm/schema/core/discovery/view-discovery.js

@@ -0,0 +1,134 @@
+/// <reference types="./view-discovery.d.ts" />
+/**
+ * Specialized service for discovering database views
+ */
+export class ViewDiscovery {
+    static instance;
+    static getInstance() {
+        if (!ViewDiscovery.instance) {
+            ViewDiscovery.instance = new ViewDiscovery();
+        }
+        return ViewDiscovery.instance;
+    }
+    /**
+     * Discover views in the database
+     */
+    async discoverViews(introspector) {
+        try {
+            // Get views using the introspector's getTables method with view filter
+            const tables = await introspector.getTables();
+            const views = [];
+            // Filter for views (this depends on the specific introspector implementation)
+            for (const table of tables) {
+                // Check if this is a view (different databases handle this differently)
+                if (this.isView(table)) {
+                    views.push({
+                        name: table.name,
+                        schema: table.schema,
+                        definition: (await this.getViewDefinition(introspector, table.name)) ?? undefined,
+                        columns: [] // Views don't have explicit columns in this context
+                    });
+                }
+            }
+            return views;
+        }
+        catch (error) {
+            console.warn('Failed to discover views:', error);
+            return [];
+        }
+    }
+    /**
+     * Get view definition for a specific view
+     */
+    async getViewDefinition(introspector, viewName) {
+        try {
+            // This would need to be implemented based on the specific database dialect
+            // For PostgreSQL, we could query pg_views
+            // For MySQL, we could query information_schema.views
+            // For SQLite, we could query sqlite_master
+            // For now, return a placeholder that indicates the view exists
+            return `-- View definition for ${viewName} would be retrieved here`;
+        }
+        catch (error) {
+            console.warn(`Failed to get definition for view ${viewName}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Check if a table metadata represents a view
+     */
+    isView(table) {
+        // Different databases indicate views differently
+        // PostgreSQL: table.isView or table.table_type === 'v'
+        // MySQL: table.table_type === 'VIEW'
+        // SQLite: table.type === 'view'
+        return (table.isView === true ||
+            table.table_type === 'v' ||
+            table.table_type === 'VIEW' ||
+            table.type === 'view');
+    }
+    /**
+     * Validate view metadata
+     */
+    validateView(view) {
+        const issues = [];
+        if (!view.name) {
+            issues.push('View name is required');
+        }
+        if (!view.definition || view.definition.trim() === '') {
+            issues.push('View definition is required');
+        }
+        // Check for SQL injection patterns in view definition
+        const dangerousPatterns = [
+            /DROP\s+TABLE/i,
+            /DELETE\s+FROM/i,
+            /UPDATE\s+SET/i,
+            /INSERT\s+INTO/i,
+            /TRUNCATE/i,
+            /ALTER\s+TABLE/i
+        ];
+        if (view.definition) {
+            for (const pattern of dangerousPatterns) {
+                if (pattern.test(view.definition)) {
+                    issues.push(`View definition contains potentially dangerous SQL: ${pattern.source}`);
+                }
+            }
+        }
+        return {
+            isValid: issues.length === 0,
+            issues
+        };
+    }
+    /**
+     * Analyze view dependencies
+     */
+    analyzeViewDependencies(views) {
+        const dependencies = new Map();
+        for (const view of views) {
+            if (view.definition) {
+                const deps = this.extractTableReferences(view.definition);
+                dependencies.set(view.name, deps);
+            }
+        }
+        return dependencies;
+    }
+    /**
+     * Extract table references from SQL definition
+     */
+    extractTableReferences(sql) {
+        // Simple regex to extract table references from SQL
+        // This is a basic implementation and could be enhanced with a proper SQL parser
+        const tableRegex = /FROM\s+([a-zA-Z_][a-zA-Z0-9_]*)/gi;
+        const joinRegex = /JOIN\s+([a-zA-Z_][a-zA-Z0-9_]*)/gi;
+        const references = [];
+        let match;
+        while ((match = tableRegex.exec(sql)) !== null) {
+            references.push(match[1]);
+        }
+        while ((match = joinRegex.exec(sql)) !== null) {
+            references.push(match[1]);
+        }
+        // Remove duplicates
+        return [...new Set(references)];
+    }
+}