import { Entity, Column, Index, ManyToOne, JoinColumn } from 'typeorm';
import { BaseEntity } from '../../abstract/base.entity';
import { Business } from '../business/business.entity';

@Entity('my_entities')
@Index(['businessId', 'code'], { unique: true })
export class MyEntity extends BaseEntity {
    @Column({ type: 'varchar', length: 100 })
    code: string;

    @Column({ type: 'varchar', length: 255 })
    name: string;

    @Column({ type: 'text', nullable: true })
    description?: string;

    // Relationship
    @Column({ type: 'uuid' })
    businessId: string;

    @ManyToOne(() => 'Business', { lazy: true })
    @JoinColumn({ name: 'business_id' })
    business: Promise<Business>;
}

import { DataSource, Repository } from 'typeorm';
import { MyEntity } from './my-entity.entity';

export class MyEntityRepository extends Repository<MyEntity> {
    constructor(dataSource: DataSource) {
        super(MyEntity, dataSource.createEntityManager());
    }

    /**
     * Find by code
     */
    async findByCode(code: string): Promise<MyEntity | null> {
        return this.findOne({ where: { code } });
    }

    /**
     * Find all by business
     */
    async findByBusiness(businessId: string): Promise<MyEntity[]> {
        return this.find({
            where: { businessId },
            order: { createdAt: 'DESC' },
        });
    }

    /**
     * Find active entities
     */
    async findActive(): Promise<MyEntity[]> {
        return this.createQueryBuilder('entity')
            .where('entity.deletedAt IS NULL')
            .orderBy('entity.name', 'ASC')
            .getMany();
    }
}

export * from './my-entity.entity';
export * from './my-entity.repository';

// My Entity module
export * from './modules/my-entity';

import { DataSource } from 'typeorm';
import { MyEntityRepository } from '../modules/my-entity';

export async function seedMyEntity(dataSource: DataSource): Promise<void> {
    const repo = new MyEntityRepository(dataSource);

    const entities = [
        {
            code: 'ENTITY_1',
            name: 'Entity One',
            description: 'First entity',
            businessId: null, // or specific business ID
        },
        {
            code: 'ENTITY_2',
            name: 'Entity Two',
            description: 'Second entity',
            businessId: null,
        },
    ];

    for (const data of entities) {
        const existing = await repo.findByCode(data.code);
        if (!existing) {
            const entity = repo.create(data);
            await repo.save(entity);
            console.log(`✅ Entity created: ${data.name}`);
        } else {
            console.log(`⏭️  Entity already exists: ${data.name}`);
        }
    }
}

import { MigrationInterface, QueryRunner } from "typeorm";

export class AddMyEntityTable1234567890 implements MigrationInterface {
    name = 'AddMyEntityTable1234567890'

    public async up(queryRunner: QueryRunner): Promise<void> {
        await queryRunner.query(`
            CREATE TABLE "my_entities" (
                "id" uuid NOT NULL DEFAULT uuid_generate_v4(),
                "created_at" TIMESTAMP NOT NULL DEFAULT now(),
                "updated_at" TIMESTAMP NOT NULL DEFAULT now(),
                "deleted_at" TIMESTAMP,
                "code" character varying(100) NOT NULL,
                "name" character varying(255) NOT NULL,
                "description" text,
                "business_id" uuid,
                CONSTRAINT "PK_my_entities" PRIMARY KEY ("id")
            )
        `);

        await queryRunner.query(`
            CREATE UNIQUE INDEX "IDX_my_entities_code" 
            ON "my_entities" ("business_id", "code")
        `);
    }

    public async down(queryRunner: QueryRunner): Promise<void> {
        await queryRunner.query(`DROP INDEX "IDX_my_entities_code"`);
        await queryRunner.query(`DROP TABLE "my_entities"`);
    }
}

import { DataSource } from 'typeorm';
import { MyEntityRepository } from '../modules/my-entity';

export async function seedMyFeature(dataSource: DataSource): Promise<void> {
    const repo = new MyEntityRepository(dataSource);

    // Your seeding logic here
    const data = [
        { code: 'ITEM_1', name: 'Item One' },
        { code: 'ITEM_2', name: 'Item Two' },
    ];

    for (const item of data) {
        const existing = await repo.findByCode(item.code);
        if (!existing) {
            const entity = repo.create(item);
            await repo.save(entity);
            console.log(`✅ Created: ${item.name}`);
        } else {
            console.log(`⏭️  Already exists: ${item.name}`);
        }
    }
}

import { registerSeeder, runAllSeeders } from '@rempays/data-core';

// Register custom seeder
registerSeeder({
    name: 'lambda-custom-tools',
    priority: 100,
    fn: async (dataSource) => {
        // Your seeding logic
    }
});

// Run all seeders (core + custom)
await runAllSeeders(dataSource);

import { 
    ConnectionManager, 
    UserRepository, 
    BusinessRepository 
} from '@rempays/data-core';

export const handler = async (event) => {
    // Get database connection
    const connectionManager = ConnectionManager.getInstance();
    const dataSource = await connectionManager.getDataSource();
    
    // Use repositories
    const userRepo = new UserRepository(dataSource);
    const user = await userRepo.findByEmail(event.email);
    
    if (!user) {
        return { statusCode: 404, body: 'User not found' };
    }
    
    return { 
        statusCode: 200, 
        body: JSON.stringify(user) 
    };
};

import { 
    registerSeeder, 
    runAllSeeders,
    ConnectionManager,
    DynamicToolRepository 
} from '@rempays/data-core';

// Register a custom seeder for your lambda
registerSeeder({
    name: 'lambda-custom-tools',
    priority: 100, // Higher priority = runs after core seeders (0-99)
    fn: async (dataSource) => {
        const toolRepo = new DynamicToolRepository(dataSource);
        
        // Check if tool already exists
        const existing = await toolRepo.findByFunctionName('get_menu');
        if (existing) {
            console.log('✅ Tool already exists: get_menu');
            return;
        }
        
        // Create your custom tool
        const tool = toolRepo.create({
            functionName: 'get_menu',
            businessId: null, // null = global tool
            schemaJson: {
                name: 'get_menu',
                description: 'Get restaurant menu items',
                parameters: {
                    type: 'object',
                    properties: {
                        category: { type: 'string' }
                    }
                }
            },
            actionType: 'TYPEORM_SAVE',
            actionConfig: {
                entity: 'CatalogItem',
                operation: 'find'
            },
            isActive: true
        });
        
        await toolRepo.save(tool);
        console.log('✅ Tool created: get_menu');
    }
});

// Run all seeders (core + custom)
export const seedHandler = async () => {
    const connectionManager = ConnectionManager.getInstance();
    const dataSource = await connectionManager.getDataSource();
    
    await runAllSeeders(dataSource);
    
    return { statusCode: 200, body: 'Seeders completed' };
};

// Example: Multiple seeders with different priorities
registerSeeder({
    name: 'lambda-base-tools',
    priority: 100, // Runs first among lambda seeders
    fn: async (dataSource) => {
        // Seed base tools
    }
});

registerSeeder({
    name: 'lambda-business-specific',
    priority: 150, // Runs after base tools
    fn: async (dataSource) => {
        // Seed business-specific data
    }
});

import { runAllSeeders, listSeeders } from '@rempays/data-core';

// Run only external (lambda) seeders
await runAllSeeders(dataSource, { onlyExternal: true });

// Run only internal (core) seeders
await runAllSeeders(dataSource, { onlyInternal: true });

// Silent mode (no console output)
await runAllSeeders(dataSource, { silent: true });

// List all registered seeders
const seeders = await listSeeders();
console.log(seeders);
// [
//   { name: '001-categories.seeder', priority: 1, type: 'internal' },
//   { name: 'lambda-custom-tools', priority: 100, type: 'external' }
// ]

import { ConnectionManager } from '@rempays/data-core';

// Singleton pattern - reuses connection
const connectionManager = ConnectionManager.getInstance();
const dataSource = await connectionManager.getDataSource();

// Connection is automatically managed
// No need to close in Lambda (reused across invocations)

const connectionManager = ConnectionManager.getInstance();
const dataSource = await connectionManager.getDataSource();

const userRepo = new UserRepository(dataSource);

// Find by email
const user = await userRepo.findByEmail('user@example.com');

// Find by Cognito sub
const user = await userRepo.findByCognitoSub('cognito-sub-id');

// Find by phone
const user = await userRepo.findByPhoneNumber('+1234567890');

// Find by business
const users = await userRepo.findByBusiness('business-uuid');

const businessRepo = new BusinessRepository(dataSource);

// Find by NIT
const business = await businessRepo.findByNit('900123456-7');

// Find by owner
const businesses = await businessRepo.findByOwner('user-uuid');

// Find active businesses
const active = await businessRepo.findActive();

// Find by category
const restaurants = await businessRepo.findByCategory('category-uuid');

const categoryRepo = new CategoryRepository(dataSource);

// Find by code
const category = await categoryRepo.findByCode('restaurant');

// Find all active
const categories = await categoryRepo.findAllActive();

import { 
    registerSeeder, 
    runAllSeeders, 
    runSeeder,
    listSeeders,
    clearExternalSeeders 
} from '@rempays/data-core';

// Register seeder
registerSeeder({
    name: 'my-seeder',
    priority: 100,
    fn: async (dataSource) => { /* ... */ }
});

// Run all seeders
await runAllSeeders(dataSource);

// Run specific seeder
await runSeeder(dataSource, 'categories');

// List seeders
const seeders = await listSeeders();

// Clear external seeders (testing)
clearExternalSeeders();