noormme 1.0.0

package/dist/cjs/testing/test-utils.js

@@ -0,0 +1,328 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestEnvironment = exports.TestUtils = exports.TestDataFactory = void 0;
+exports.createTestDatabase = createTestDatabase;
+exports.setupTestSchema = setupTestSchema;
+exports.cleanupTestDatabase = cleanupTestDatabase;
+const noormme_js_1 = require("../noormme.js");
+/**
+ * Create an in-memory SQLite database for testing
+ */
+async function createTestDatabase(config = {}) {
+    const { dialect = 'sqlite', database = ':memory:', cleanup = true, seed = false } = config;
+    let dbConfig;
+    switch (dialect) {
+        case 'sqlite':
+            dbConfig = {
+                dialect: 'sqlite',
+                connection: {
+                    database,
+                    host: '',
+                    port: 0,
+                    username: '',
+                    password: ''
+                },
+                logging: {
+                    enabled: false // Disable logging in tests by default
+                }
+            };
+            break;
+        default:
+            throw new Error(`Unsupported test database dialect: ${dialect}`);
+    }
+    const db = new noormme_js_1.NOORMME(dbConfig);
+    if (seed) {
+        await setupTestSchema(db);
+    }
+    return db;
+}
+/**
+ * Create test schema with sample tables
+ */
+async function setupTestSchema(db) {
+    const kysely = db.getKysely();
+    // Create users table
+    await kysely.schema
+        .createTable('users')
+        .ifNotExists()
+        .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
+        .addColumn('name', 'varchar(255)', col => col.notNull())
+        .addColumn('email', 'varchar(255)', col => col.notNull().unique())
+        .addColumn('age', 'integer')
+        .addColumn('active', 'boolean', col => col.defaultTo(true))
+        .addColumn('created_at', 'timestamp', col => col.defaultTo('now()').notNull())
+        .addColumn('updated_at', 'timestamp', col => col.defaultTo('now()').notNull())
+        .execute();
+    // Create posts table
+    await kysely.schema
+        .createTable('posts')
+        .ifNotExists()
+        .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
+        .addColumn('title', 'varchar(255)', col => col.notNull())
+        .addColumn('content', 'text')
+        .addColumn('user_id', 'integer', col => col.references('users.id').onDelete('cascade'))
+        .addColumn('published', 'boolean', col => col.defaultTo(false))
+        .addColumn('created_at', 'timestamp', col => col.defaultTo('now()').notNull())
+        .addColumn('updated_at', 'timestamp', col => col.defaultTo('now()').notNull())
+        .execute();
+    // Create comments table
+    await kysely.schema
+        .createTable('comments')
+        .ifNotExists()
+        .addColumn('id', 'integer', col => col.primaryKey().autoIncrement())
+        .addColumn('content', 'text', col => col.notNull())
+        .addColumn('post_id', 'integer', col => col.references('posts.id').onDelete('cascade'))
+        .addColumn('user_id', 'integer', col => col.references('users.id').onDelete('cascade'))
+        .addColumn('created_at', 'timestamp', col => col.defaultTo('now()').notNull())
+        .execute();
+    // Create indexes for better performance
+    await kysely.schema
+        .createIndex('idx_posts_user_id')
+        .ifNotExists()
+        .on('posts')
+        .column('user_id')
+        .execute();
+    await kysely.schema
+        .createIndex('idx_comments_post_id')
+        .ifNotExists()
+        .on('comments')
+        .column('post_id')
+        .execute();
+    await kysely.schema
+        .createIndex('idx_comments_user_id')
+        .ifNotExists()
+        .on('comments')
+        .column('user_id')
+        .execute();
+    // Initialize NOORMME to discover the schema
+    await db.initialize();
+}
+/**
+ * Clean up test database
+ */
+async function cleanupTestDatabase(db) {
+    const kysely = db.getKysely();
+    try {
+        // Drop tables in reverse order to handle foreign keys
+        await kysely.schema.dropTable('comments').ifExists().execute();
+        await kysely.schema.dropTable('posts').ifExists().execute();
+        await kysely.schema.dropTable('users').ifExists().execute();
+    }
+    catch (error) {
+        // Ignore errors during cleanup
+    }
+    await db.close();
+}
+/**
+ * Test data factory
+ */
+class TestDataFactory {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    /**
+     * Create a test user
+     */
+    async createUser(overrides = {}) {
+        const userRepo = this.db.getRepository('users');
+        const userData = {
+            name: 'Test User',
+            email: `test${Date.now()}@example.com`,
+            age: 25,
+            active: true,
+            ...overrides
+        };
+        return await userRepo.create(userData);
+    }
+    /**
+     * Create multiple test users
+     */
+    async createUsers(count, overrides = {}) {
+        const users = [];
+        for (let i = 0; i < count; i++) {
+            const user = await this.createUser({
+                name: `Test User ${i + 1}`,
+                email: `test${Date.now()}_${i}@example.com`,
+                ...overrides
+            });
+            users.push(user);
+        }
+        return users;
+    }
+    /**
+     * Create a test post
+     */
+    async createPost(userId, overrides = {}) {
+        const postRepo = this.db.getRepository('posts');
+        const postData = {
+            title: 'Test Post',
+            content: 'This is a test post content',
+            user_id: userId,
+            published: false,
+            ...overrides
+        };
+        return await postRepo.create(postData);
+    }
+    /**
+     * Create multiple test posts
+     */
+    async createPosts(userId, count, overrides = {}) {
+        const posts = [];
+        for (let i = 0; i < count; i++) {
+            const post = await this.createPost(userId, {
+                title: `Test Post ${i + 1}`,
+                ...overrides
+            });
+            posts.push(post);
+        }
+        return posts;
+    }
+    /**
+     * Create a test comment
+     */
+    async createComment(postId, userId, overrides = {}) {
+        const commentRepo = this.db.getRepository('comments');
+        const commentData = {
+            content: 'This is a test comment',
+            post_id: postId,
+            user_id: userId,
+            ...overrides
+        };
+        return await commentRepo.create(commentData);
+    }
+    /**
+     * Create multiple test comments
+     */
+    async createComments(postId, userId, count, overrides = {}) {
+        const comments = [];
+        for (let i = 0; i < count; i++) {
+            const comment = await this.createComment(postId, userId, {
+                content: `Test comment ${i + 1}`,
+                ...overrides
+            });
+            comments.push(comment);
+        }
+        return comments;
+    }
+    /**
+     * Create a complete test dataset
+     */
+    async createTestDataset() {
+        // Create users
+        const users = await this.createUsers(3);
+        // Create posts for each user
+        const posts = [];
+        for (const user of users) {
+            const userPosts = await this.createPosts(user.id, 2);
+            posts.push(...userPosts);
+        }
+        // Create comments for each post
+        const comments = [];
+        for (const post of posts) {
+            // Each post gets comments from different users
+            for (const user of users) {
+                const postComments = await this.createComments(post.id, user.id, 1);
+                comments.push(...postComments);
+            }
+        }
+        return { users, posts, comments };
+    }
+    /**
+     * Clear all test data
+     */
+    async clearAllData() {
+        const kysely = this.db.getKysely();
+        // Delete in reverse order to handle foreign keys
+        await kysely.deleteFrom('comments').execute();
+        await kysely.deleteFrom('posts').execute();
+        await kysely.deleteFrom('users').execute();
+    }
+}
+exports.TestDataFactory = TestDataFactory;
+/**
+ * Test utilities for mocking and assertions
+ */
+class TestUtils {
+    /**
+     * Wait for a promise to reject with a specific error
+     */
+    static async expectError(promise, expectedErrorMessage) {
+        try {
+            await promise;
+            throw new Error('Expected promise to reject, but it resolved');
+        }
+        catch (error) {
+            if (expectedErrorMessage && !String(error).includes(expectedErrorMessage)) {
+                throw new Error(`Expected error message to contain "${expectedErrorMessage}", but got: ${error}`);
+            }
+            return error;
+        }
+    }
+    /**
+     * Measure execution time of a function
+     */
+    static async measureTime(fn) {
+        const start = Date.now();
+        const result = await fn();
+        const time = Date.now() - start;
+        return { result, time };
+    }
+    /**
+     * Create a spy function for testing callbacks
+     */
+    static createSpy() {
+        const calls = [];
+        const spy = ((...args) => {
+            calls.push(args);
+        });
+        Object.defineProperty(spy, 'calls', {
+            get: () => calls
+        });
+        Object.defineProperty(spy, 'callCount', {
+            get: () => calls.length
+        });
+        return spy;
+    }
+    /**
+     * Delay execution for testing timing-sensitive operations
+     */
+    static delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+exports.TestUtils = TestUtils;
+/**
+ * Test environment setup and teardown
+ */
+class TestEnvironment {
+    static databases = [];
+    /**
+     * Setup test environment
+     */
+    static async setup() {
+        // Any global test setup
+    }
+    /**
+     * Teardown test environment
+     */
+    static async teardown() {
+        // Close all test databases
+        for (const db of this.databases) {
+            try {
+                await db.close();
+            }
+            catch (error) {
+                // Ignore errors during cleanup
+            }
+        }
+        this.databases = [];
+    }
+    /**
+     * Register a database for automatic cleanup
+     */
+    static registerDatabase(db) {
+        this.databases.push(db);
+    }
+}
+exports.TestEnvironment = TestEnvironment;

package/dist/cjs/types/index.d.ts

@@ -0,0 +1,155 @@
+/**
+ * Core type definitions for NOORMME
+ */
+export interface NOORMConfig {
+    dialect: 'sqlite';
+    connection: ConnectionConfig;
+    introspection?: IntrospectionConfig;
+    cache?: CacheConfig;
+    logging?: LoggingConfig;
+    performance?: PerformanceConfig;
+}
+export interface ConnectionConfig {
+    host: string;
+    port: number;
+    database: string;
+    username: string;
+    password: string;
+    ssl?: boolean | object;
+    pool?: PoolConfig;
+}
+export interface PoolConfig {
+    min?: number;
+    max?: number;
+    idleTimeoutMillis?: number;
+}
+export interface IntrospectionConfig {
+    includeViews?: boolean;
+    excludeTables?: string[];
+    customTypeMappings?: Record<string, string>;
+}
+export interface CacheConfig {
+    ttl?: number;
+    maxSize?: number;
+    strategy?: 'lru' | 'fifo';
+}
+export interface LoggingConfig {
+    level?: 'debug' | 'info' | 'warn' | 'error';
+    enabled?: boolean;
+    file?: string;
+}
+export interface PerformanceConfig {
+    enableQueryOptimization?: boolean;
+    enableBatchLoading?: boolean;
+    maxBatchSize?: number;
+}
+export interface SchemaInfo {
+    tables: TableInfo[];
+    relationships: RelationshipInfo[];
+    views?: ViewInfo[];
+}
+export interface TableInfo {
+    name: string;
+    schema?: string;
+    columns: ColumnInfo[];
+    primaryKey?: string[];
+    indexes: IndexInfo[];
+    foreignKeys: ForeignKeyInfo[];
+}
+export interface ColumnInfo {
+    name: string;
+    type: string;
+    nullable: boolean;
+    defaultValue?: any;
+    isPrimaryKey: boolean;
+    isAutoIncrement: boolean;
+    maxLength?: number;
+    precision?: number;
+    scale?: number;
+}
+export interface IndexInfo {
+    name: string;
+    columns: string[];
+    unique: boolean;
+}
+export interface ForeignKeyInfo {
+    name: string;
+    column: string;
+    referencedTable: string;
+    referencedColumn: string;
+    onDelete?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
+    onUpdate?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
+}
+export interface RelationshipInfo {
+    name: string;
+    type: 'one-to-many' | 'many-to-one' | 'many-to-many';
+    fromTable: string;
+    fromColumn: string;
+    toTable: string;
+    toColumn: string;
+    throughTable?: string;
+    throughFromColumn?: string;
+    throughToColumn?: string;
+}
+export interface ViewInfo {
+    name: string;
+    schema?: string;
+    definition: string;
+    columns: ColumnInfo[];
+}
+export interface GeneratedTypes {
+    entities: EntityType[];
+    interfaces: string;
+    types: string;
+}
+export interface EntityType {
+    name: string;
+    tableName: string;
+    interface: string;
+    insertType: string;
+    updateType: string;
+    selectType: string;
+}
+export interface Repository<T> {
+    findById(id: any): Promise<T | null>;
+    findAll(): Promise<T[]>;
+    create(data: Partial<T>): Promise<T>;
+    update(entity: T): Promise<T>;
+    delete(id: any): Promise<boolean>;
+    findWithRelations(id: any, relations: string[]): Promise<T | null>;
+    loadRelationships(entities: T[], relations: string[]): Promise<void>;
+    count(): Promise<number>;
+    exists(id: any): Promise<boolean>;
+    paginate(options: {
+        page: number;
+        limit: number;
+        where?: Partial<T>;
+        orderBy?: {
+            column: keyof T;
+            direction: 'asc' | 'desc';
+        };
+    }): Promise<{
+        data: T[];
+        pagination: {
+            page: number;
+            limit: number;
+            total: number;
+            totalPages: number;
+            hasNext: boolean;
+            hasPrev: boolean;
+        };
+    }>;
+    withCount(id: any, relationships: string[]): Promise<T & Record<string, number>>;
+    [key: string]: any;
+}
+export interface SchemaChange {
+    type: 'table_added' | 'table_removed' | 'column_added' | 'column_removed' | 'column_modified';
+    table: string;
+    column?: string;
+    details?: any;
+}
+export interface RefreshResult {
+    schemaInfo: SchemaInfo;
+    changes: SchemaChange[];
+    typesRegenerated: boolean;
+}

package/dist/cjs/types/index.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Core type definitions for NOORMME
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/types/type-generator.d.ts

@@ -0,0 +1,52 @@
+import { SchemaInfo, GeneratedTypes, IntrospectionConfig } from '../types';
+/**
+ * Type generation system that creates TypeScript types from database schema
+ */
+export declare class TypeGenerator {
+    private config;
+    constructor(config?: IntrospectionConfig);
+    /**
+     * Generate TypeScript types from schema information
+     */
+    generateTypes(schemaInfo: SchemaInfo): GeneratedTypes;
+    /**
+     * Generate entity type for a table
+     */
+    private generateEntityType;
+    /**
+     * Generate main entity interface
+     */
+    private generateEntityInterface;
+    /**
+     * Generate insert type
+     */
+    private generateInsertType;
+    /**
+     * Generate update type
+     */
+    private generateUpdateType;
+    /**
+     * Generate select type
+     */
+    private generateSelectType;
+    /**
+     * Generate relationship types
+     */
+    private generateRelationshipTypes;
+    /**
+     * Map database column to TypeScript type
+     */
+    private mapColumnToTypeScript;
+    /**
+     * Get relationships for a specific table
+     */
+    private getRelationshipsForTable;
+    /**
+     * Get relationship type name
+     */
+    private getRelationshipType;
+    /**
+     * Convert string to PascalCase
+     */
+    private toPascalCase;
+}