micro-generate 1.3.10 → 1.3.12

package/dist/cli/templates/project/index.template.js

@@ -0,0 +1,104 @@
+export const getIndexTemplate = (options) => {
+    const { useMongo, useRedis, useMySQL, dbNames, mysqlDbNames } = options;
+    let indexImports = `import { MicroserviceServer } from 'micro-generate';
+import { typeDefs, resolvers } from './features/index.js';
+import * as dotenv from 'dotenv';\n`;
+    if (useMongo) {
+        indexImports += `import { setMongoDBConnector } from './database/mongo/client.js';\n`;
+    }
+    if (useRedis) {
+        indexImports += `import { createRedisConnector } from './database/redis.js';\n`;
+    }
+    if (useMySQL) {
+        indexImports += `import { MySQLConnector, setMySQLConnector } from './database/mysql/client.js';\n`;
+    }
+    const indexConfig = [];
+    indexConfig.push(`  port: parseInt(process.env.PORT || '4000')`);
+    if (useMongo) {
+        indexConfig.push(`  mongoUri: process.env.MONGO_URI || ''`);
+    }
+    let redisConnectorInit = '';
+    if (useRedis) {
+        redisConnectorInit = `
+const redisConnector = createRedisConnector({
+    host: process.env.REDIS_HOST || 'localhost',
+    port: parseInt(process.env.REDIS_PORT || '6379'),
+    password: process.env.REDIS_PASSWORD,
+    db: parseInt(process.env.REDIS_DB || '0')
+});
+`;
+        indexConfig.push(`  redisConnector: redisConnector`);
+    }
+    if (useMongo && dbNames.length > 0) {
+        const secondaryConfig = dbNames.map(name => {
+            const envVar = `MONGODB_URI_${name.toUpperCase().replace(/-/g, '_')}`;
+            return `${name}: process.env.${envVar} || ''`;
+        }).join(',\n    ');
+        indexConfig.push(`  secondaryConnections: {\n    ${secondaryConfig}\n  }`);
+    }
+    if (useMySQL) {
+        indexConfig.push(`  mysqlConnector: mysqlConnector`);
+    }
+    indexConfig.push(`  playground: process.env.GRAPHQL_PLAYGROUND === 'true'`);
+    indexConfig.push(`  introspection: process.env.GRAPHQL_INTROSPECTION === 'true'`);
+    indexConfig.push(`  graphqlPath: process.env.GRAPHQL_PATH || '/graphql'`);
+    let mysqlInit = '';
+    if (useMySQL) {
+        mysqlInit = `
+// MySQL Configuration
+const mysqlConfigs = [
+    {
+        name: 'default',
+        database: process.env.MYSQL_DB || '',
+        user: process.env.MYSQL_USER || '',
+        password: process.env.MYSQL_PASSWORD,
+        host: process.env.MYSQL_HOST || 'localhost',
+        port: parseInt(process.env.MYSQL_PORT || '3306'),
+    },
+    ${mysqlDbNames.map(name => {
+            const upper = name.toUpperCase().replace(/-/g, '_');
+            return `{
+        name: '${name}',
+        database: process.env.MYSQL_DB_${upper} || '',
+        user: process.env.MYSQL_USER_${upper} || '',
+        password: process.env.MYSQL_PASSWORD_${upper},
+        host: process.env.MYSQL_HOST_${upper} || 'localhost',
+        port: parseInt(process.env.MYSQL_PORT_${upper} || '3306'),
+    }`;
+        }).join(',\n    ')}
+];
+
+const mysqlConnector = new MySQLConnector(mysqlConfigs);
+setMySQLConnector(mysqlConnector);
+`;
+    }
+    return `${indexImports}
+dotenv.config();
+${redisConnectorInit}
+${mysqlInit}
+const server = new MicroserviceServer({
+${indexConfig.join(',\n')},
+  typeDefs,
+  resolvers,
+});
+
+server.start().then(async () => {
+    ${useMongo ? `if (server.getMongoDBConnector()) {
+        setMongoDBConnector(server.getMongoDBConnector()! as any);
+    }` : ''}
+    
+    console.log('Server initialized');
+});
+
+const gracefulShutdown = async () => {
+    console.log('Starting graceful shutdown...');
+    await server.stop();
+    console.log('Graceful shutdown complete.');
+    process.exit(0);
+};
+
+process.on('SIGINT', gracefulShutdown);
+process.on('SIGTERM', gracefulShutdown);
+`;
+};
+//# sourceMappingURL=index.template.js.map

package/dist/cli/templates/project/index.template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.template.js","sourceRoot":"","sources":["../../../../src/cli/templates/project/index.template.ts"],"names":[],"mappings":"AAQA,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,OAA6B,EAAU,EAAE;IACtE,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC;IAExE,IAAI,YAAY,GAAG;;oCAEa,CAAC;IAEjC,IAAI,QAAQ,EAAE,CAAC;QACX,YAAY,IAAI,qEAAqE,CAAC;IAC1F,CAAC;IAED,IAAI,QAAQ,EAAE,CAAC;QACX,YAAY,IAAI,+DAA+D,CAAC;IACpF,CAAC;IAED,IAAI,QAAQ,EAAE,CAAC;QACX,YAAY,IAAI,mFAAmF,CAAC;IACxG,CAAC;IAED,MAAM,WAAW,GAAG,EAAE,CAAC;IACvB,WAAW,CAAC,IAAI,CAAC,8CAA8C,CAAC,CAAC;IAEjE,IAAI,QAAQ,EAAE,CAAC;QACX,WAAW,CAAC,IAAI,CAAC,yCAAyC,CAAC,CAAC;IAChE,CAAC;IAED,IAAI,kBAAkB,GAAG,EAAE,CAAC;IAC5B,IAAI,QAAQ,EAAE,CAAC;QACX,kBAAkB,GAAG;;;;;;;CAO5B,CAAC;QACM,WAAW,CAAC,IAAI,CAAC,kCAAkC,CAAC,CAAC;IACzD,CAAC;IAED,IAAI,QAAQ,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACjC,MAAM,eAAe,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;YACvC,MAAM,MAAM,GAAG,eAAe,IAAI,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,CAAC;YACtE,OAAO,GAAG,IAAI,iBAAiB,MAAM,QAAQ,CAAC;QAClD,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACnB,WAAW,CAAC,IAAI,CAAC,kCAAkC,eAAe,OAAO,CAAC,CAAC;IAC/E,CAAC;IAED,IAAI,QAAQ,EAAE,CAAC;QACX,WAAW,CAAC,IAAI,CAAC,kCAAkC,CAAC,CAAC;IACzD,CAAC;IAED,WAAW,CAAC,IAAI,CAAC,yDAAyD,CAAC,CAAC;IAC5E,WAAW,CAAC,IAAI,CAAC,+DAA+D,CAAC,CAAC;IAClF,WAAW,CAAC,IAAI,CAAC,uDAAuD,CAAC,CAAC;IAE1E,IAAI,SAAS,GAAG,EAAE,CAAC;IACnB,IAAI,QAAQ,EAAE,CAAC;QACX,SAAS,GAAG;;;;;;;;;;;MAWd,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;YACtB,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;YACpD,OAAO;iBACE,IAAI;yCACoB,KAAK;uCACP,KAAK;+CACG,KAAK;uCACb,KAAK;gDACI,KAAK;MAC/C,CAAC;QACH,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC;;;;;CAKrB,CAAC;IACE,CAAC;IAED,OAAO,GAAG,YAAY;;EAExB,kBAAkB;EAClB,SAAS;;EAET,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC;;;;;;MAMnB,QAAQ,CAAC,CAAC,CAAC;;MAEX,CAAC,CAAC,CAAC,EAAE;;;;;;;;;;;;;;CAcV,CAAC;AACF,CAAC,CAAC"}

package/dist/cli/templates/project/mongo.template.d.ts

@@ -0,0 +1 @@
+export declare const mongoTemplate = "import mongoose from 'mongoose';\n\nexport interface MongoDBOptions {\n    uri: string;\n    options?: mongoose.ConnectOptions;\n    secondaryConnections?: Record<string, string>;\n}\n\nexport class MongoDBConnector {\n    private uri: string;\n    private options: mongoose.ConnectOptions;\n    private secondaryConnectionsConfig: Record<string, string> = {};\n    private isConnected = false;\n    private secondaryConnections: Map<string, mongoose.Connection> = new Map();\n\n    constructor(config: MongoDBOptions) {\n        this.uri = config.uri;\n        this.options = config.options || {};\n        this.secondaryConnectionsConfig = config.secondaryConnections || {};\n    }\n\n    async connect(): Promise<void> {\n        if (this.isConnected) return;\n        try {\n            await mongoose.connect(this.uri, this.options);\n            this.isConnected = true;\n            console.log('\u2705 Primary MongoDB connected');\n\n            const secondaryPromises = Object.entries(this.secondaryConnectionsConfig).map(async ([name, uri]) => {\n                const conn = mongoose.createConnection(uri, this.options);\n                await conn.asPromise();\n                this.secondaryConnections.set(name, conn);\n                console.log(`\u2705 Secondary MongoDB '${name}' connected`);\n            });\n            await Promise.all(secondaryPromises);\n        } catch (error) {\n            console.error('MongoDB connection error:', error);\n            throw error;\n        }\n    }\n\n    getSecondaryConnection(name: string): mongoose.Connection | undefined {\n        return this.secondaryConnections.get(name);\n    }\n}\n\nexport function createMongoDBConnector(uri: string, secondaryConnections?: Record<string, string>): MongoDBConnector {\n    return new MongoDBConnector({ uri, secondaryConnections });\n}\n";

package/dist/cli/templates/project/mongo.template.js

@@ -0,0 +1,51 @@
+export const mongoTemplate = `import mongoose from 'mongoose';
+
+export interface MongoDBOptions {
+    uri: string;
+    options?: mongoose.ConnectOptions;
+    secondaryConnections?: Record<string, string>;
+}
+
+export class MongoDBConnector {
+    private uri: string;
+    private options: mongoose.ConnectOptions;
+    private secondaryConnectionsConfig: Record<string, string> = {};
+    private isConnected = false;
+    private secondaryConnections: Map<string, mongoose.Connection> = new Map();
+
+    constructor(config: MongoDBOptions) {
+        this.uri = config.uri;
+        this.options = config.options || {};
+        this.secondaryConnectionsConfig = config.secondaryConnections || {};
+    }
+
+    async connect(): Promise<void> {
+        if (this.isConnected) return;
+        try {
+            await mongoose.connect(this.uri, this.options);
+            this.isConnected = true;
+            console.log('✅ Primary MongoDB connected');
+
+            const secondaryPromises = Object.entries(this.secondaryConnectionsConfig).map(async ([name, uri]) => {
+                const conn = mongoose.createConnection(uri, this.options);
+                await conn.asPromise();
+                this.secondaryConnections.set(name, conn);
+                console.log(\`✅ Secondary MongoDB '\${name}' connected\`);
+            });
+            await Promise.all(secondaryPromises);
+        } catch (error) {
+            console.error('MongoDB connection error:', error);
+            throw error;
+        }
+    }
+
+    getSecondaryConnection(name: string): mongoose.Connection | undefined {
+        return this.secondaryConnections.get(name);
+    }
+}
+
+export function createMongoDBConnector(uri: string, secondaryConnections?: Record<string, string>): MongoDBConnector {
+    return new MongoDBConnector({ uri, secondaryConnections });
+}
+`;
+//# sourceMappingURL=mongo.template.js.map

package/dist/cli/templates/project/mongo.template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongo.template.js","sourceRoot":"","sources":["../../../../src/cli/templates/project/mongo.template.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiD5B,CAAC"}

package/dist/cli/templates/project/mongoClient.template.d.ts

@@ -0,0 +1 @@
+export declare const mongoClientTemplate = "import { MongoDBConnector } from '../mongo.js';\nimport mongoose from 'mongoose';\n\nlet mongoConnector: MongoDBConnector | null = null;\n\nexport function setMongoDBConnector(connector: MongoDBConnector): void {\n    mongoConnector = connector;\n}\n\nexport function getMongoDBConnector(): MongoDBConnector {\n    if (!mongoConnector) {\n        throw new Error('MongoDB connector not initialized. Make sure to connect in main.ts');\n    }\n    return mongoConnector;\n}\n\nexport function getSecondaryConnection(name: string): mongoose.Connection | undefined {\n    return getMongoDBConnector().getSecondaryConnection(name);\n}\n";

package/dist/cli/templates/project/mongoClient.template.js

@@ -0,0 +1,21 @@
+export const mongoClientTemplate = `import { MongoDBConnector } from '../mongo.js';
+import mongoose from 'mongoose';
+
+let mongoConnector: MongoDBConnector | null = null;
+
+export function setMongoDBConnector(connector: MongoDBConnector): void {
+    mongoConnector = connector;
+}
+
+export function getMongoDBConnector(): MongoDBConnector {
+    if (!mongoConnector) {
+        throw new Error('MongoDB connector not initialized. Make sure to connect in main.ts');
+    }
+    return mongoConnector;
+}
+
+export function getSecondaryConnection(name: string): mongoose.Connection | undefined {
+    return getMongoDBConnector().getSecondaryConnection(name);
+}
+`;
+//# sourceMappingURL=mongoClient.template.js.map

package/dist/cli/templates/project/mongoClient.template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongoClient.template.js","sourceRoot":"","sources":["../../../../src/cli/templates/project/mongoClient.template.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,mBAAmB,GAAG;;;;;;;;;;;;;;;;;;;CAmBlC,CAAC"}

package/dist/cli/templates/project/mysqlClient.template.d.ts

@@ -0,0 +1 @@
+export declare const mysqlClientTemplate = "import { Sequelize } from 'sequelize';\nimport { MySQLConnector, setMySQLConnector as coreSetMySQLConnector, getMySQLConnector as coreGetMySQLConnector, getSecondaryMySQLConnection as coreGetSecondaryMySQLConnection } from 'micro-generate';\n\nexport { MySQLConnector };\n\nexport const setMySQLConnector = coreSetMySQLConnector;\nexport const getMySQLConnector = coreGetMySQLConnector;\nexport const getSecondaryMySQLConnection = coreGetSecondaryMySQLConnection;\n\nexport default () => {\n    try {\n        return getMySQLConnector().getConnection('default');\n    } catch (e) {\n        return null;\n    }\n};\n";

package/dist/cli/templates/project/mysqlClient.template.js

@@ -0,0 +1,18 @@
+export const mysqlClientTemplate = `import { Sequelize } from 'sequelize';
+import { MySQLConnector, setMySQLConnector as coreSetMySQLConnector, getMySQLConnector as coreGetMySQLConnector, getSecondaryMySQLConnection as coreGetSecondaryMySQLConnection } from 'micro-generate';
+
+export { MySQLConnector };
+
+export const setMySQLConnector = coreSetMySQLConnector;
+export const getMySQLConnector = coreGetMySQLConnector;
+export const getSecondaryMySQLConnection = coreGetSecondaryMySQLConnection;
+
+export default () => {
+    try {
+        return getMySQLConnector().getConnection('default');
+    } catch (e) {
+        return null;
+    }
+};
+`;
+//# sourceMappingURL=mysqlClient.template.js.map

package/dist/cli/templates/project/mysqlClient.template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mysqlClient.template.js","sourceRoot":"","sources":["../../../../src/cli/templates/project/mysqlClient.template.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,mBAAmB,GAAG;;;;;;;;;;;;;;;;CAgBlC,CAAC"}

package/dist/cli/templates/project/redis.template.d.ts

@@ -0,0 +1 @@
+export declare const redisTemplate = "import { Redis, RedisOptions } from 'ioredis';\nimport { logger } from 'micro-generate';\n\nexport class RedisConnector {\n    private defaultClient: Redis | null = null;\n    private clients: Map<number, Redis> = new Map();\n    private options: RedisOptions = {};\n    private defaultDb: number = 0;\n    private host?: string;\n\n    constructor(optionsOrUrl: RedisOptions | string) {\n        if (typeof optionsOrUrl === 'string') {\n            this.options = {\n                retryStrategy: (times: number) => Math.min(times * 50, 2000)\n            };\n            this.host = undefined; \n            (this as any).url = optionsOrUrl; \n        } else {\n            this.options = {\n                retryStrategy: (times: number) => Math.min(times * 50, 2000),\n                ...optionsOrUrl\n            };\n            this.defaultDb = optionsOrUrl.db || 0;\n            this.host = optionsOrUrl.host;\n        }\n    }\n\n    async connect(): Promise<void> {\n        if (this.defaultClient) {\n            logger.info('Redis default client already connected');\n            return;\n        }\n        try {\n            this.defaultClient = this.createClient(this.defaultDb);\n            this.clients.set(this.defaultDb, this.defaultClient);\n            await this.defaultClient.connect();\n        } catch (error) {\n            logger.error(`Failed to connect to Redis: ${error}`);\n            throw error;\n        }\n    }\n\n    private createClient(db: number): Redis {\n        let client: Redis;\n        const url = (this as any).url;\n\n        if (url) {\n             client = new Redis(url, { ...this.options, db, lazyConnect: true });\n        } else {\n            client = new Redis({ ...this.options, db, lazyConnect: true });\n        }\n\n        client.on('connect', () => logger.info(`\uD83D\uDD34 Redis connected to db ${db}`));\n        client.on('error', (err) => logger.error(`Redis error on db ${db}: ${err}`));\n        return client;\n    }\n\n    async disconnect(): Promise<void> {\n        const disconnectPromises: Promise<void>[] = [];\n        for (const [db, client] of this.clients.entries()) {\n            disconnectPromises.push(client.quit().then(() => {}).catch(() => client.disconnect()));\n        }\n        await Promise.all(disconnectPromises);\n        this.clients.clear();\n        this.defaultClient = null;\n    }\n\n    getClient(): Redis {\n        if (!this.defaultClient) throw new Error('Redis not connected');\n        return this.defaultClient;\n    }\n\n    async getConnection(db: number): Promise<Redis> {\n        if (db === this.defaultDb) {\n            if (!this.defaultClient) await this.connect();\n            return this.defaultClient!;\n        }\n        if (this.clients.has(db)) {\n            const client = this.clients.get(db)!;\n            if (client.status === 'wait') await client.connect();\n            return client;\n        }\n        const newClient = this.createClient(db);\n        this.clients.set(db, newClient);\n        await newClient.connect();\n        return newClient;\n    }\n}\n\nexport let redisConnectorInstance: RedisConnector | null = null;\n\nexport const setRedisConnectorInstance = (connector: RedisConnector) => {\n    redisConnectorInstance = connector;\n};\n\nexport const getRedisConnector = (): RedisConnector => {\n    if (!redisConnectorInstance) {\n        throw new Error('Redis connector not initialized.');\n    }\n    return redisConnectorInstance;\n};\n\nexport const createRedisRepository = (getDb: () => (Redis | Promise<Redis>), keyPrefix: string) => {\n    const promiseFunct = (err: any, response: any, resolve: (value: any) => void, reject: (reason?: any) => void) => {\n        if (err) reject(err);\n        else resolve(response);\n    };\n\n    const resolveDb = async (): Promise<Redis> => {\n        const dbOrPromise = getDb();\n        return dbOrPromise instanceof Promise ? await dbOrPromise : dbOrPromise;\n    };\n\n    return {\n        find: async (_id: string) => {\n            const db = await resolveDb();\n            return new Promise((resolve, reject) => {\n                db.get(_id, (err, response) => promiseFunct(err, response, resolve, reject));\n            });\n        },\n        saveTTL: async (_id: string, _data: any, ttl: number) => {\n            const db = await resolveDb();\n            return new Promise((resolve, reject) => {\n                db.set(_id, _data, (err, response) => {\n                    if (err) reject(err);\n                    else {\n                        db.expire(_id, ttl);\n                        resolve(response);\n                    }\n                });\n            });\n        },\n        findKeys: async (_id: string) => {\n            const db = await resolveDb();\n            return new Promise((resolve, reject) => {\n                db.keys(_id, (err, response) => {\n                    if (response && response.length > 0) {\n                        promiseFunct(err, response, resolve, reject);\n                    } else {\n                        promiseFunct(null, ['No genero datos'], resolve, reject);\n                    }\n                });\n            });\n        },\n\n        findAll: async () => {\n            const db = await resolveDb();\n            return new Promise((resolve, reject) => {\n                db.keys(keyPrefix + '*', (err, response) => {\n                    if (response && response.length > 0) {\n                        db.mget(response, (err, response2) => {\n                            promiseFunct(err, response2, resolve, reject);\n                        });\n                    } else {\n                        promiseFunct(null, ['No genero datos'], resolve, reject);\n                    }\n                });\n            });\n        },\n\n        save: async (_id: string, _data: any) => {\n            const db = await resolveDb();\n            return new Promise((resolve, reject) => {\n                db.set(_id, _data, (err, response) => {\n                    promiseFunct(err, response, resolve, reject);\n                });\n            });\n        },\n\n        addTTL: async (_id: string, ttl: number) => {\n            const db = await resolveDb();\n            return db.expire(_id, ttl);\n        },\n\n        getTTL: async (_id: string) => {\n            const db = await resolveDb();\n            return new Promise((resolve, reject) => {\n                db.ttl(_id, (err, response) => {\n                    promiseFunct(err, response, resolve, reject);\n                });\n            });\n        },\n\n        incr: async (_id: string) => {\n            const db = await resolveDb();\n            return new Promise((resolve, reject) => {\n                db.incr(_id, (err, response) => {\n                    promiseFunct(err, response, resolve, reject);\n                });\n            });\n        },\n\n        sadd: async (_id: string, _data: any) => {\n            const db = await resolveDb();\n            return new Promise((resolve, reject) => {\n                db.sadd(_id, _data, (err, response) => {\n                    promiseFunct(err, response, resolve, reject);\n                });\n            });\n        },\n\n        sismember: async (_id: string, _data: any) => {\n            const db = await resolveDb();\n            return new Promise((resolve, reject) => {\n                db.sismember(_id, _data, (err, response) => {\n                    promiseFunct(err, response, resolve, reject);\n                });\n            });\n        },\n\n        sisremove: async (_id: string, _data: any) => {\n            const db = await resolveDb();\n            return new Promise((resolve, reject) => {\n                db.srem(_id, _data, (err, response) => {\n                    promiseFunct(err, response, resolve, reject);\n                });\n            });\n        },\n\n        smembers: async (_id: string) => {\n            const db = await resolveDb();\n            return new Promise((resolve, reject) => {\n                db.smembers(_id, (err, response) => {\n                    promiseFunct(err, response, resolve, reject);\n                });\n            });\n        },\n\n        sdiff: async (keys: string[]) => {\n            const db = await resolveDb();\n            return new Promise((resolve, reject) => {\n                db.sdiff(keys, (err, response) => {\n                    promiseFunct(err, response, resolve, reject);\n                });\n            });\n        },\n\n        clear: async (key: string) => {\n            const db = await resolveDb();\n            return new Promise((resolve, reject) => {\n                db.del(key, (err, response) => {\n                    promiseFunct(err, response, resolve, reject);\n                });\n            });\n        }\n    };\n};\n\nexport function createRedisConnector(urlOrOptions: string | RedisOptions): RedisConnector {\n    const connector = new RedisConnector(urlOrOptions);\n    setRedisConnectorInstance(connector);\n    return connector;\n}\n";

package/dist/cli/templates/project/redis.template.js

@@ -0,0 +1,255 @@
+export const redisTemplate = `import { Redis, RedisOptions } from 'ioredis';
+import { logger } from 'micro-generate';
+
+export class RedisConnector {
+    private defaultClient: Redis | null = null;
+    private clients: Map<number, Redis> = new Map();
+    private options: RedisOptions = {};
+    private defaultDb: number = 0;
+    private host?: string;
+
+    constructor(optionsOrUrl: RedisOptions | string) {
+        if (typeof optionsOrUrl === 'string') {
+            this.options = {
+                retryStrategy: (times: number) => Math.min(times * 50, 2000)
+            };
+            this.host = undefined; 
+            (this as any).url = optionsOrUrl; 
+        } else {
+            this.options = {
+                retryStrategy: (times: number) => Math.min(times * 50, 2000),
+                ...optionsOrUrl
+            };
+            this.defaultDb = optionsOrUrl.db || 0;
+            this.host = optionsOrUrl.host;
+        }
+    }
+
+    async connect(): Promise<void> {
+        if (this.defaultClient) {
+            logger.info('Redis default client already connected');
+            return;
+        }
+        try {
+            this.defaultClient = this.createClient(this.defaultDb);
+            this.clients.set(this.defaultDb, this.defaultClient);
+            await this.defaultClient.connect();
+        } catch (error) {
+            logger.error(\`Failed to connect to Redis: \${error}\`);
+            throw error;
+        }
+    }
+
+    private createClient(db: number): Redis {
+        let client: Redis;
+        const url = (this as any).url;
+
+        if (url) {
+             client = new Redis(url, { ...this.options, db, lazyConnect: true });
+        } else {
+            client = new Redis({ ...this.options, db, lazyConnect: true });
+        }
+
+        client.on('connect', () => logger.info(\`🔴 Redis connected to db \${db}\`));
+        client.on('error', (err) => logger.error(\`Redis error on db \${db}: \${err}\`));
+        return client;
+    }
+
+    async disconnect(): Promise<void> {
+        const disconnectPromises: Promise<void>[] = [];
+        for (const [db, client] of this.clients.entries()) {
+            disconnectPromises.push(client.quit().then(() => {}).catch(() => client.disconnect()));
+        }
+        await Promise.all(disconnectPromises);
+        this.clients.clear();
+        this.defaultClient = null;
+    }
+
+    getClient(): Redis {
+        if (!this.defaultClient) throw new Error('Redis not connected');
+        return this.defaultClient;
+    }
+
+    async getConnection(db: number): Promise<Redis> {
+        if (db === this.defaultDb) {
+            if (!this.defaultClient) await this.connect();
+            return this.defaultClient!;
+        }
+        if (this.clients.has(db)) {
+            const client = this.clients.get(db)!;
+            if (client.status === 'wait') await client.connect();
+            return client;
+        }
+        const newClient = this.createClient(db);
+        this.clients.set(db, newClient);
+        await newClient.connect();
+        return newClient;
+    }
+}
+
+export let redisConnectorInstance: RedisConnector | null = null;
+
+export const setRedisConnectorInstance = (connector: RedisConnector) => {
+    redisConnectorInstance = connector;
+};
+
+export const getRedisConnector = (): RedisConnector => {
+    if (!redisConnectorInstance) {
+        throw new Error('Redis connector not initialized.');
+    }
+    return redisConnectorInstance;
+};
+
+export const createRedisRepository = (getDb: () => (Redis | Promise<Redis>), keyPrefix: string) => {
+    const promiseFunct = (err: any, response: any, resolve: (value: any) => void, reject: (reason?: any) => void) => {
+        if (err) reject(err);
+        else resolve(response);
+    };
+
+    const resolveDb = async (): Promise<Redis> => {
+        const dbOrPromise = getDb();
+        return dbOrPromise instanceof Promise ? await dbOrPromise : dbOrPromise;
+    };
+
+    return {
+        find: async (_id: string) => {
+            const db = await resolveDb();
+            return new Promise((resolve, reject) => {
+                db.get(_id, (err, response) => promiseFunct(err, response, resolve, reject));
+            });
+        },
+        saveTTL: async (_id: string, _data: any, ttl: number) => {
+            const db = await resolveDb();
+            return new Promise((resolve, reject) => {
+                db.set(_id, _data, (err, response) => {
+                    if (err) reject(err);
+                    else {
+                        db.expire(_id, ttl);
+                        resolve(response);
+                    }
+                });
+            });
+        },
+        findKeys: async (_id: string) => {
+            const db = await resolveDb();
+            return new Promise((resolve, reject) => {
+                db.keys(_id, (err, response) => {
+                    if (response && response.length > 0) {
+                        promiseFunct(err, response, resolve, reject);
+                    } else {
+                        promiseFunct(null, ['No genero datos'], resolve, reject);
+                    }
+                });
+            });
+        },
+
+        findAll: async () => {
+            const db = await resolveDb();
+            return new Promise((resolve, reject) => {
+                db.keys(keyPrefix + '*', (err, response) => {
+                    if (response && response.length > 0) {
+                        db.mget(response, (err, response2) => {
+                            promiseFunct(err, response2, resolve, reject);
+                        });
+                    } else {
+                        promiseFunct(null, ['No genero datos'], resolve, reject);
+                    }
+                });
+            });
+        },
+
+        save: async (_id: string, _data: any) => {
+            const db = await resolveDb();
+            return new Promise((resolve, reject) => {
+                db.set(_id, _data, (err, response) => {
+                    promiseFunct(err, response, resolve, reject);
+                });
+            });
+        },
+
+        addTTL: async (_id: string, ttl: number) => {
+            const db = await resolveDb();
+            return db.expire(_id, ttl);
+        },
+
+        getTTL: async (_id: string) => {
+            const db = await resolveDb();
+            return new Promise((resolve, reject) => {
+                db.ttl(_id, (err, response) => {
+                    promiseFunct(err, response, resolve, reject);
+                });
+            });
+        },
+
+        incr: async (_id: string) => {
+            const db = await resolveDb();
+            return new Promise((resolve, reject) => {
+                db.incr(_id, (err, response) => {
+                    promiseFunct(err, response, resolve, reject);
+                });
+            });
+        },
+
+        sadd: async (_id: string, _data: any) => {
+            const db = await resolveDb();
+            return new Promise((resolve, reject) => {
+                db.sadd(_id, _data, (err, response) => {
+                    promiseFunct(err, response, resolve, reject);
+                });
+            });
+        },
+
+        sismember: async (_id: string, _data: any) => {
+            const db = await resolveDb();
+            return new Promise((resolve, reject) => {
+                db.sismember(_id, _data, (err, response) => {
+                    promiseFunct(err, response, resolve, reject);
+                });
+            });
+        },
+
+        sisremove: async (_id: string, _data: any) => {
+            const db = await resolveDb();
+            return new Promise((resolve, reject) => {
+                db.srem(_id, _data, (err, response) => {
+                    promiseFunct(err, response, resolve, reject);
+                });
+            });
+        },
+
+        smembers: async (_id: string) => {
+            const db = await resolveDb();
+            return new Promise((resolve, reject) => {
+                db.smembers(_id, (err, response) => {
+                    promiseFunct(err, response, resolve, reject);
+                });
+            });
+        },
+
+        sdiff: async (keys: string[]) => {
+            const db = await resolveDb();
+            return new Promise((resolve, reject) => {
+                db.sdiff(keys, (err, response) => {
+                    promiseFunct(err, response, resolve, reject);
+                });
+            });
+        },
+
+        clear: async (key: string) => {
+            const db = await resolveDb();
+            return new Promise((resolve, reject) => {
+                db.del(key, (err, response) => {
+                    promiseFunct(err, response, resolve, reject);
+                });
+            });
+        }
+    };
+};
+
+export function createRedisConnector(urlOrOptions: string | RedisOptions): RedisConnector {
+    const connector = new RedisConnector(urlOrOptions);
+    setRedisConnectorInstance(connector);
+    return connector;
+}
+`;
+//# sourceMappingURL=redis.template.js.map

package/dist/cli/templates/project/redis.template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.template.js","sourceRoot":"","sources":["../../../../src/cli/templates/project/redis.template.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,aAAa,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6P5B,CAAC"}

package/dist/cli/templates/project/sanitize.template.d.ts

@@ -0,0 +1 @@
+export declare const sanitizeTemplate = "import DOMPurify from 'dompurify';\nimport { JSDOM } from 'jsdom';\n\nconst window = new JSDOM('').window;\nconst purify = DOMPurify(window as any);\n\nexport function sanitize(dirty: string): string {\n    return purify.sanitize(dirty, { ALLOWED_TAGS: [], ALLOWED_ATTR: [] });\n}\n";

package/dist/cli/templates/project/sanitize.template.js

@@ -0,0 +1,11 @@
+export const sanitizeTemplate = `import DOMPurify from 'dompurify';
+import { JSDOM } from 'jsdom';
+
+const window = new JSDOM('').window;
+const purify = DOMPurify(window as any);
+
+export function sanitize(dirty: string): string {
+    return purify.sanitize(dirty, { ALLOWED_TAGS: [], ALLOWED_ATTR: [] });
+}
+`;
+//# sourceMappingURL=sanitize.template.js.map

package/dist/cli/templates/project/sanitize.template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize.template.js","sourceRoot":"","sources":["../../../../src/cli/templates/project/sanitize.template.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,gBAAgB,GAAG;;;;;;;;;CAS/B,CAAC"}

package/dist/cli/templates/project/skill.template.d.ts

@@ -0,0 +1 @@
+export declare const skillTemplate = "---\nname: micro-generate-helper\ndescription: Use the micro-generate CLI non-interactively to generate features, queries, mutations, standalone models, and add database/cache configurations to existing projects.\n---\n\n# Micro-Generate Skill\n\nThis skill allows you to programmatically invoke the \\`micro-generate\\` CLI tools to create features, GraphQL operations, standalone models, and database/cache connectors without user interaction.\n\n## Usage\n\nYou should use your terminal or command-execution tool to execute the \\`npx micro-generate\\` command directly. The CLI supports headless execution via flags for all commands.\n\n---\n\n## \uD83D\uDD04 Recommended Workflow (Order of Operations)\n\nWhen implementing a new feature or database configuration, follow this exact sequence:\n\n1. **Initialize Technologies (If missing)**: If the project does not have the database/cache you need, run the \\`add\\` command first.\n2. **Scaffold the Feature**: Execute the \\`feature\\` command to generate the vertical slice folder structure.\n3. **Scaffold Standalone Models (Optional)**: If you need separate standalone models not coupled to a single feature, run the \\`model\\` command.\n4. **Scaffold Operations**: Use the \\`query\\` and \\`mutation\\` commands to add GraphQL endpoints.\n5. **Implement Business Logic**: Open and implement the business logic in the generated files (see **Landing Paths** below).\n6. **Verify and Self-Correct**: Run verification commands to ensure the project builds and runs without TypeScript or runtime errors.\n\n---\n\n## \uD83D\uDCC2 File Landing Paths & Architectural Conventions\n\nAfter running the CLI generators, you **must** locate and write the actual implementation in the following paths:\n\n*   **GraphQL Schema**: \\`src/features/<feature-name>/typeDefs.ts\\`\n    *   *Convention*: Declare your types, queries, and mutations here. The CLI inserts new operations, but you must define arguments and return types.\n*   **GraphQL Resolvers**: \\`src/features/<feature-name>/resolvers.ts\\`\n    *   *Convention*: Map the schema queries/mutations to call the corresponding service methods. Keep resolvers thin.\n*   **Business Logic / Services**: \\`src/features/<feature-name>/service.ts\\`\n    *   *Convention*: Implement your database queries, data mutations, APIs, and caching operations here. \n*   **Feature-coupled Models**: \\`src/features/<feature-name>/model.ts\\` (or under \\`src/database/<mongo|mysql>/models/\\` if standalone).\n    *   *Convention*: Define your mongoose schemas or sequelize schemas.\n*   **Feature Entrypoint**: \\`src/features/<feature-name>/index.ts\\`\n    *   *Convention*: Aggregates typeDefs, resolvers, and services. It is automatically registered in \\`src/features/index.ts\\`.\n\n---\n\n## \uD83D\uDEE0\uFE0F CLI Command Reference & Preconditions\n\nExecute these commands using your terminal or command-execution tool.\n\n### 1. \\`add <technology>\\`\nAdds database/cache configurations to the project.\n*   **Preconditions**: None.\n*   **Usage**: \\`npx micro-generate add <redis | mongo | mysql>\\`\n*   **Options**:\n    *   \\`-n, --name <string>\\`: (Optional) Default database name (for MongoDB/MySQL).\n    *   \\`-s, --secondary <string>\\`: (Optional) Comma-separated list of secondary databases to add (for MongoDB/MySQL).\n    *   *Note*: For Redis, it sets up the main connection parameters in \\`.env\\`. Redis does not require secondary connection parameters as multiple databases are accessed by index.\n*   **Example**:\n    \\`\\`\\`bash\n    npx micro-generate add mongo --name \"my_core\" --secondary \"logs,analytics\"\n    \\`\\`\\`\n\n### 2. \\`feature\\`\nCreates a new vertical slice module.\n*   **Preconditions**: If database/cache flags (\\`--mongo\\`, \\`--mysql\\`, \\`--redis\\`) are passed, those technologies must be configured in the project (either initialized at project creation or added using the \\`add\\` command).\n*   **Usage**: \\`npx micro-generate feature --name <name> [options]\\`\n*   **Options**:\n    *   \\`--mongo\\` / \\`--no-mongo\\`: Enable/disable MongoDB support.\n    *   \\`--mysql\\` / \\`--no-mysql\\`: Enable/disable MySQL support.\n    *   \\`--redis\\` / \\`--no-redis\\`: Enable/disable Redis support.\n    *   \\`--db-connection <string>\\`: (Optional) Connect to a specific MongoDB database name (Multi-DB).\n    *   \\`--mysql-connection <string>\\`: (Optional) Connect to a specific MySQL database name (Multi-DB).\n    *   \\`--redis-db <number>\\`: (Optional) Connect to a specific Redis database number (0-15).\n*   **Example**:\n    \\`\\`\\`bash\n    npx micro-generate feature --name \"billing\" --mysql --redis --mysql-connection \"payments\" --redis-db 2\n    \\`\\`\\`\n\n### 3. \\`model\\`\nGenerates a standalone database model.\n*   **Preconditions**: The selected database type must be configured in the project.\n*   **Usage**: \\`npx micro-generate model --name <name> --type <mongo | mysql> [options]\\`\n*   **Options**:\n    *   \\`-n, --name <string>\\`: (Required) Model name (e.g., \"Invoice\").\n    *   \\`-t, --type <string>\\`: (Required) Database type (\\`mongo\\` or \\`mysql\\`).\n    *   \\`-c, --connection <string>\\`: (Optional) Connection name (defaults to default).\n*   **Example**:\n    \\`\\`\\`bash\n    npx micro-generate model --name \"Invoice\" --type \"mysql\" --connection \"billing\"\n    \\`\\`\\`\n\n### 4. \\`query\\` and \\`mutation\\`\nAdds a new GraphQL operation to an existing feature.\n*   **Preconditions**: The target feature must already exist under \\`src/features/<feature-name>\\`.\n*   **Usage**: \\`npx micro-generate <query | mutation> --feature <feature-name> --name <name> [options]\\`\n*   **Options**:\n    *   \\`-f, --feature <string>\\`: (Required) Target feature.\n    *   \\`-n, --name <string>\\`: (Required) Operation name (e.g., \"getInvoice\").\n    *   \\`-r, --return-type <string>\\`: (Optional) Return type (e.g., \"InvoiceResponse\").\n*   **Example**:\n    \\`\\`\\`bash\n    npx micro-generate query --feature \"billing\" --name \"getInvoice\" --return-type \"Invoice\"\n    \\`\\`\\`\n\n---\n\n## \uD83D\uDCDD End-to-End Example: Implementing a Feature\n\nHere is how you would implement a new feature called \"notifications\" that uses MySQL and Redis:\n\n1.  **Generate the feature**:\n    \\`\\`\\`bash\n    npx micro-generate feature --name \"notifications\" --mysql --redis --redis-db 1\n    \\`\\`\\`\n2.  **Add a query**:\n    \\`\\`\\`bash\n    npx micro-generate query --feature \"notifications\" --name \"getUserNotifications\" --return-type \"[Notification!]\"\n    \\`\\`\\`\n3.  **Implement database schema**:\n    Open the generated model file in \\`src/features/notifications/model.ts\\` (or standalone model) and define the fields (e.g., \\`title\\`, \\`message\\`, \\`userId\\`, \\`read\\`).\n4.  **Write the business logic**:\n    Open \\`src/features/notifications/service.ts\\`. Add code to fetch notifications from the MySQL database and cache them in Redis.\n5.  **Hook up the resolver**:\n    Open \\`src/features/notifications/resolvers.ts\\` and map the query to your service method.\n6.  **Verify**:\n    Run \\`npm run build\\` to ensure it compiles without TypeScript errors.\n\n---\n\n## \uD83D\uDD0D Verification & Self-Correction Loop\n\nAlways verify your changes after generating or modifying files:\n\n1.  **Check Registration**: Ensure that your feature is listed in \\`src/features/index.ts\\`. The CLI registers new features automatically, but verify that it was not corrupted:\n    \\`\\`\\`typescript\n    import * as notifications from './notifications/index.js';\n    \\`\\`\\`\n2.  **Compile Project**: Run the TypeScript compiler to ensure there are no syntax or type mismatches:\n    \\`\\`\\`bash\n    npm run build\n    \\`\\`\\`\n3.  **Read and Correct Errors**: If \\`tsc\\` fails:\n    *   Read the line number and error description.\n    *   Check for missing imports or incorrect relative paths (e.g., missing \\`.js\\` in TypeScript ESM imports).\n    *   Fix the types and compile again until it builds with **0 errors**.\n";