noormme 1.0.0

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

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViewDiscovery = void 0;
+/**
+ * Specialized service for discovering database views
+ */
+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)];
+    }
+}
+exports.ViewDiscovery = ViewDiscovery;

package/dist/cjs/schema/core/factories/discovery-factory.d.ts

@@ -0,0 +1,66 @@
+import { TableMetadataDiscovery } from '../discovery/table-metadata-discovery.js';
+import { RelationshipDiscovery } from '../discovery/relationship-discovery.js';
+import { ViewDiscovery } from '../discovery/view-discovery.js';
+import { SQLiteDiscoveryCoordinator } from '../../dialects/sqlite/sqlite-discovery.coordinator.js';
+import { SQLiteIndexDiscovery } from '../../dialects/sqlite/discovery/sqlite-index-discovery.js';
+import { SQLiteConstraintDiscovery } from '../../dialects/sqlite/discovery/sqlite-constraint-discovery.js';
+/**
+ * Factory for creating database-specific discovery services
+ */
+export declare class DiscoveryFactory {
+    private static instance;
+    static getInstance(): DiscoveryFactory;
+    /**
+     * Create table discovery service
+     */
+    createTableDiscovery(): TableMetadataDiscovery;
+    /**
+     * Create relationship discovery service
+     */
+    createRelationshipDiscovery(): RelationshipDiscovery;
+    /**
+     * Create view discovery service
+     */
+    createViewDiscovery(): ViewDiscovery;
+    /**
+     * Create index discovery service based on dialect
+     */
+    createIndexDiscovery(dialect: string): SQLiteIndexDiscovery;
+    /**
+     * Create constraint discovery service based on dialect
+     */
+    createConstraintDiscovery(dialect: string): SQLiteConstraintDiscovery;
+    /**
+     * Create dialect-specific discovery coordinator
+     */
+    createDiscoveryCoordinator(dialect: string): SQLiteDiscoveryCoordinator;
+    /**
+     * Create all discovery services for a specific dialect
+     */
+    createDiscoveryServices(dialect: string): {
+        tableDiscovery: TableMetadataDiscovery;
+        relationshipDiscovery: RelationshipDiscovery;
+        viewDiscovery: ViewDiscovery;
+        indexDiscovery: SQLiteIndexDiscovery;
+        constraintDiscovery: SQLiteConstraintDiscovery;
+    };
+    /**
+     * Get supported dialects
+     */
+    getSupportedDialects(): string[];
+    /**
+     * Check if a dialect is supported
+     */
+    isDialectSupported(dialect: string): boolean;
+    /**
+     * Get dialect-specific capabilities
+     */
+    getDialectCapabilities(dialect: string): {
+        supportsViews: boolean;
+        supportsIndexes: boolean;
+        supportsConstraints: boolean;
+        supportsForeignKeys: boolean;
+        supportsCheckConstraints: boolean;
+        supportsDeferredConstraints: boolean;
+    };
+}

package/dist/cjs/schema/core/factories/discovery-factory.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiscoveryFactory = void 0;
+const table_metadata_discovery_js_1 = require("../discovery/table-metadata-discovery.js");
+const relationship_discovery_js_1 = require("../discovery/relationship-discovery.js");
+const view_discovery_js_1 = require("../discovery/view-discovery.js");
+const sqlite_discovery_coordinator_js_1 = require("../../dialects/sqlite/sqlite-discovery.coordinator.js");
+const sqlite_index_discovery_js_1 = require("../../dialects/sqlite/discovery/sqlite-index-discovery.js");
+const sqlite_constraint_discovery_js_1 = require("../../dialects/sqlite/discovery/sqlite-constraint-discovery.js");
+/**
+ * Factory for creating database-specific discovery services
+ */
+class DiscoveryFactory {
+    static instance;
+    static getInstance() {
+        if (!DiscoveryFactory.instance) {
+            DiscoveryFactory.instance = new DiscoveryFactory();
+        }
+        return DiscoveryFactory.instance;
+    }
+    /**
+     * Create table discovery service
+     */
+    createTableDiscovery() {
+        return table_metadata_discovery_js_1.TableMetadataDiscovery.getInstance();
+    }
+    /**
+     * Create relationship discovery service
+     */
+    createRelationshipDiscovery() {
+        return relationship_discovery_js_1.RelationshipDiscovery.getInstance();
+    }
+    /**
+     * Create view discovery service
+     */
+    createViewDiscovery() {
+        return view_discovery_js_1.ViewDiscovery.getInstance();
+    }
+    /**
+     * Create index discovery service based on dialect
+     */
+    createIndexDiscovery(dialect) {
+        switch (dialect.toLowerCase()) {
+            case 'sqlite':
+                return sqlite_index_discovery_js_1.SQLiteIndexDiscovery.getInstance();
+            default:
+                throw new Error(`Unsupported dialect for index discovery: ${dialect}`);
+        }
+    }
+    /**
+     * Create constraint discovery service based on dialect
+     */
+    createConstraintDiscovery(dialect) {
+        switch (dialect.toLowerCase()) {
+            case 'sqlite':
+                return sqlite_constraint_discovery_js_1.SQLiteConstraintDiscovery.getInstance();
+            default:
+                throw new Error(`Unsupported dialect for constraint discovery: ${dialect}`);
+        }
+    }
+    /**
+     * Create dialect-specific discovery coordinator
+     */
+    createDiscoveryCoordinator(dialect) {
+        switch (dialect.toLowerCase()) {
+            case 'sqlite':
+                return sqlite_discovery_coordinator_js_1.SQLiteDiscoveryCoordinator.getInstance();
+            default:
+                throw new Error(`Unsupported dialect for discovery coordinator: ${dialect}`);
+        }
+    }
+    /**
+     * Create all discovery services for a specific dialect
+     */
+    createDiscoveryServices(dialect) {
+        return {
+            tableDiscovery: this.createTableDiscovery(),
+            relationshipDiscovery: this.createRelationshipDiscovery(),
+            viewDiscovery: this.createViewDiscovery(),
+            indexDiscovery: this.createIndexDiscovery(dialect),
+            constraintDiscovery: this.createConstraintDiscovery(dialect)
+        };
+    }
+    /**
+     * Get supported dialects
+     */
+    getSupportedDialects() {
+        return ['sqlite'];
+    }
+    /**
+     * Check if a dialect is supported
+     */
+    isDialectSupported(dialect) {
+        return this.getSupportedDialects().includes(dialect.toLowerCase());
+    }
+    /**
+     * Get dialect-specific capabilities
+     */
+    getDialectCapabilities(dialect) {
+        switch (dialect.toLowerCase()) {
+            case 'sqlite':
+                return {
+                    supportsViews: true,
+                    supportsIndexes: true,
+                    supportsConstraints: true,
+                    supportsForeignKeys: true,
+                    supportsCheckConstraints: true,
+                    supportsDeferredConstraints: false
+                };
+            default:
+                return {
+                    supportsViews: false,
+                    supportsIndexes: false,
+                    supportsConstraints: false,
+                    supportsForeignKeys: false,
+                    supportsCheckConstraints: false,
+                    supportsDeferredConstraints: false
+                };
+        }
+    }
+}
+exports.DiscoveryFactory = DiscoveryFactory;

package/dist/cjs/schema/core/types/schema-discovery-types.d.ts

@@ -0,0 +1,43 @@
+export interface SchemaDiscoveryConfig {
+    excludeTables?: string[];
+    includeViews?: boolean;
+    customTypeMappings?: Record<string, string>;
+}
+export interface ColumnInfo {
+    name: string;
+    type: string;
+    nullable: boolean;
+    defaultValue?: any;
+    isPrimaryKey: boolean;
+    isAutoIncrement: boolean;
+    maxLength?: number;
+    precision?: number;
+    scale?: number;
+}
+export interface TableMetadata {
+    name: string;
+    schema?: string;
+    columns: ColumnInfo[];
+    primaryKey?: string[];
+    indexes: IndexMetadata[];
+    foreignKeys: ForeignKeyMetadata[];
+}
+export interface IndexMetadata {
+    name: string;
+    columns: string[];
+    unique: boolean;
+}
+export interface ForeignKeyMetadata {
+    name: string;
+    column: string;
+    referencedTable: string;
+    referencedColumn: string;
+    onDelete?: string;
+    onUpdate?: string;
+}
+export interface ViewMetadata {
+    name: string;
+    schema?: string;
+    definition?: string;
+    columns?: any[];
+}

package/dist/cjs/schema/core/types/schema-discovery-types.js

@@ -0,0 +1,3 @@
+"use strict";
+// Removed import of missing types to fix error
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/schema/core/utils/name-generator.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Utility class for generating relationship names and handling naming conventions
+ */
+export declare class NameGenerator {
+    /**
+     * Generate relationship name from foreign key column
+     */
+    static generateRelationshipName(columnName: string, referencedTable: string): string;
+    /**
+     * Generate reverse relationship name
+     */
+    static generateReverseRelationshipName(tableName: string, columnName: string): string;
+    /**
+     * Convert string to camelCase
+     */
+    static toCamelCase(str: string): string;
+    /**
+     * Simple pluralization (basic implementation)
+     */
+    static pluralize(str: string): string;
+}

package/dist/cjs/schema/core/utils/name-generator.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NameGenerator = void 0;
+/**
+ * Utility class for generating relationship names and handling naming conventions
+ */
+class NameGenerator {
+    /**
+     * Generate relationship name from foreign key column
+     */
+    static generateRelationshipName(columnName, referencedTable) {
+        // Remove common foreign key suffixes
+        let name = columnName;
+        if (name.endsWith('_id')) {
+            name = name.slice(0, -3);
+        }
+        if (name.endsWith('Id')) {
+            name = name.slice(0, -2);
+        }
+        // Convert to camelCase
+        return this.toCamelCase(name);
+    }
+    /**
+     * Generate reverse relationship name
+     */
+    static generateReverseRelationshipName(tableName, columnName) {
+        // Convert table name to plural for one-to-many relationships
+        const pluralTableName = this.pluralize(this.toCamelCase(tableName));
+        return pluralTableName;
+    }
+    /**
+     * Convert string to camelCase
+     */
+    static toCamelCase(str) {
+        return str
+            .replace(/(?:^\w|[A-Z]|\b\w)/g, (word, index) => {
+            return index === 0 ? word.toLowerCase() : word.toUpperCase();
+        })
+            .replace(/\s+/g, '')
+            .replace(/[_-]/g, '');
+    }
+    /**
+     * Simple pluralization (basic implementation)
+     */
+    static pluralize(str) {
+        if (str.endsWith('y')) {
+            return str.slice(0, -1) + 'ies';
+        }
+        if (str.endsWith('s') || str.endsWith('sh') || str.endsWith('ch') || str.endsWith('x') || str.endsWith('z')) {
+            return str + 'es';
+        }
+        return str + 's';
+    }
+}
+exports.NameGenerator = NameGenerator;

package/dist/cjs/schema/core/utils/type-mapper.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Maps database column types to TypeScript types
+ */
+export declare class TypeMapper {
+    private static typeMapping;
+    /**
+     /**
+      * Map database column info to our ColumnInfo interface
+      */
+    static mapColumnInfo(dbColumn: any, customTypeMappings?: Record<string, string>): {
+        name: string;
+        type: string;
+        nullable: boolean;
+        defaultValue?: any;
+        isPrimaryKey: boolean;
+        isAutoIncrement: boolean;
+        maxLength?: number;
+        precision?: number;
+        scale?: number;
+    };
+    /**
+     * Map database column types to TypeScript types
+     */
+    static mapColumnType(dbType: string, customTypeMappings?: Record<string, string>): string;
+}

package/dist/cjs/schema/core/utils/type-mapper.js

@@ -0,0 +1,61 @@
+"use strict";
+// TODO: Remove this import if ColumnInfo is not used, or fix the import path if necessary.
+// import { ColumnInfo } from '../../types/index.js'
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeMapper = void 0;
+/**
+ * Maps database column types to TypeScript types
+ */
+class TypeMapper {
+    static typeMapping = {
+        // SQLite types
+        'text': 'string',
+        'varchar': 'string',
+        'char': 'string',
+        'integer': 'number',
+        'real': 'number',
+        'numeric': 'number',
+        'boolean': 'boolean',
+        'date': 'Date',
+        'datetime': 'Date',
+        'blob': 'Buffer',
+    };
+    /**
+     /**
+      * Map database column info to our ColumnInfo interface
+      */
+    static mapColumnInfo(dbColumn, customTypeMappings) {
+        return {
+            name: dbColumn.name,
+            type: this.mapColumnType(dbColumn.type, customTypeMappings),
+            nullable: dbColumn.nullable,
+            defaultValue: dbColumn.defaultValue,
+            isPrimaryKey: dbColumn.isPrimaryKey ?? false,
+            isAutoIncrement: dbColumn.isAutoIncrement ?? false,
+            maxLength: dbColumn.maxLength,
+            precision: dbColumn.precision,
+            scale: dbColumn.scale
+        };
+    }
+    /**
+     * Map database column types to TypeScript types
+     */
+    static mapColumnType(dbType, customTypeMappings) {
+        // Handle custom type mappings first
+        if (customTypeMappings?.[dbType]) {
+            return customTypeMappings[dbType];
+        }
+        // Try exact match first
+        if (this.typeMapping[dbType.toLowerCase()]) {
+            return this.typeMapping[dbType.toLowerCase()];
+        }
+        // Handle parameterized types (e.g., varchar(255), decimal(10,2))
+        const baseType = dbType.toLowerCase().split('(')[0];
+        if (this.typeMapping[baseType]) {
+            return this.typeMapping[baseType];
+        }
+        // Default to any for unknown types
+        return 'any';
+    }
+}
+exports.TypeMapper = TypeMapper;

package/dist/cjs/schema/dialects/sqlite/discovery/sqlite-constraint-discovery.d.ts

@@ -0,0 +1,97 @@
+import type { Kysely } from '../../../../kysely.js';
+/**
+ * SQLite-specific constraint discovery
+ */
+export declare class SQLiteConstraintDiscovery {
+    private static instance;
+    static getInstance(): SQLiteConstraintDiscovery;
+    /**
+     * Discover constraints from SQLite table definition
+     */
+    discoverTableConstraints(db: Kysely<any>, tableName: string): Promise<any[]>;
+    /**
+     * Parse constraints from SQLite CREATE TABLE statement
+     */
+    private parseConstraintsFromSQL;
+    /**
+     * Get foreign key information using PRAGMA
+     */
+    getForeignKeyInfo(db: Kysely<any>, tableName: string): Promise<any[]>;
+    /**
+     * Check if foreign keys are enabled
+     */
+    isForeignKeySupportEnabled(db: Kysely<any>): Promise<boolean>;
+    /**
+     * Validate SQLite constraints
+     */
+    validateConstraints(constraints: any[]): {
+        isValid: boolean;
+        issues: string[];
+    };
+    /**
+     * Analyze constraint compatibility
+     */
+    analyzeConstraintCompatibility(constraints: any[]): {
+        recommendations: string[];
+        compatibilityIssues: string[];
+    };
+    /**
+     * Validate foreign key constraints and provide recommendations
+     */
+    validateForeignKeyConstraints(db: Kysely<any>): Promise<{
+        isValid: boolean;
+        issues: string[];
+        recommendations: string[];
+        orphanedRecords: {
+            table: string;
+            count: number;
+        }[];
+        performanceImpact: 'low' | 'medium' | 'high';
+    }>;
+    /**
+     * Get tables that have foreign key constraints
+     */
+    private getTablesWithForeignKeys;
+    /**
+     * Check for orphaned records in foreign key relationships
+     */
+    private checkOrphanedRecords;
+    /**
+     * Check if foreign key column has an index
+     */
+    private checkForeignKeyIndex;
+    /**
+     * Check if table exists
+     */
+    private checkTableExists;
+    /**
+     * Check if column exists in table
+     */
+    private checkColumnExists;
+    /**
+     * Assess performance impact of foreign key issues
+     */
+    private assessPerformanceImpact;
+    /**
+     * Generate foreign key optimization recommendations
+     */
+    generateForeignKeyOptimizations(db: Kysely<any>): Promise<{
+        indexRecommendations: string[];
+        constraintRecommendations: string[];
+        cleanupRecommendations: string[];
+        performanceRecommendations: string[];
+    }>;
+    /**
+     * Auto-fix common foreign key issues
+     */
+    autoFixForeignKeyIssues(db: Kysely<any>, options?: {
+        createMissingIndexes?: boolean;
+        enableForeignKeys?: boolean;
+        cleanupOrphanedRecords?: boolean;
+        dryRun?: boolean;
+    }): Promise<{
+        applied: string[];
+        failed: string[];
+        skipped: string[];
+    }>;
+}